static bool
txn_abort (mongoc_client_session_t *session, bson_t *reply, bson_error_t *error)
{
bson_t cmd = BSON_INITIALIZER;
bson_t opts = BSON_INITIALIZER;
bson_error_t err_local;
bson_error_t *err_ptr = error ? error : &err_local;
bson_t reply_local = BSON_INITIALIZER;
mongoc_write_err_type_t error_type;
bool r = false;
_mongoc_bson_init_if_set (reply);
if (!mongoc_client_session_append (session, &opts, err_ptr)) {
GOTO (done);
}
if (session->txn.opts.write_concern) {
if (!mongoc_write_concern_append (session->txn.opts.write_concern,
&opts)) {
bson_set_error (err_ptr,
MONGOC_ERROR_TRANSACTION,
MONGOC_ERROR_TRANSACTION_INVALID_STATE,
"Invalid transaction write concern");
GOTO (done);
}
}
BSON_APPEND_INT32 (&cmd, "abortTransaction", 1);
/* will be reinitialized by mongoc_client_write_command_with_opts */
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
/* Transactions Spec: "Drivers MUST retry the commitTransaction command once
* after it fails with a retryable error", same for abort */
error_type = _mongoc_write_error_get_type (r, err_ptr, &reply_local);
if (error_type == MONGOC_WRITE_ERR_RETRY) {
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
}
if (!r) {
/* we won't return an error from abortTransaction, so warn */
MONGOC_WARNING ("Error in abortTransaction: %s", err_ptr->message);
}
done:
bson_destroy (&reply_local);
bson_destroy (&cmd);
bson_destroy (&opts);
return r;
}
static bool
txn_finish (mongoc_client_session_t *session,
mongoc_txn_intent_t intent,
bson_t *reply,
bson_error_t *error)
{
const char *cmd_name;
bson_t cmd = BSON_INITIALIZER;
bson_t opts = BSON_INITIALIZER;
bson_error_t err_local;
bson_error_t *err_ptr = error ? error : &err_local;
bson_t reply_local = BSON_INITIALIZER;
mongoc_write_err_type_t error_type;
bool r = false;
_mongoc_bson_init_if_set (reply);
cmd_name = (intent == TXN_COMMIT ? "commitTransaction" : "abortTransaction");
if (!mongoc_client_session_append (session, &opts, err_ptr)) {
GOTO (done);
}
if (session->txn.opts.write_concern) {
if (!mongoc_write_concern_append (session->txn.opts.write_concern,
&opts)) {
bson_set_error (err_ptr,
MONGOC_ERROR_TRANSACTION,
MONGOC_ERROR_TRANSACTION_INVALID_STATE,
"Invalid transaction write concern");
GOTO (done);
}
}
BSON_APPEND_INT32 (&cmd, cmd_name, 1);
/* will be reinitialized by mongoc_client_write_command_with_opts */
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
/* Transactions Spec: "Drivers MUST retry the commitTransaction command once
* after it fails with a retryable error", same for abort */
error_type = _mongoc_write_error_get_type (r, err_ptr, &reply_local);
if (error_type == MONGOC_WRITE_ERR_RETRY) {
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
error_type = _mongoc_write_error_get_type (r, err_ptr, &reply_local);
}
/* Transactions Spec: "add the UnknownTransactionCommitResult error label
* when commitTransaction fails with a network error, server selection
* error, or write concern failed / timeout." */
if (intent == TXN_COMMIT && reply) {
if ((!r && err_ptr->domain == MONGOC_ERROR_SERVER_SELECTION) ||
error_type == MONGOC_WRITE_ERR_RETRY ||
error_type == MONGOC_WRITE_ERR_WRITE_CONCERN) {
bson_copy_to_excluding_noinit (
&reply_local, reply, "errorLabels", NULL);
copy_labels_plus_unknown_commit_result (&reply_local, reply);
} else {
/* maintain invariants: reply & reply_local are valid until the end */
bson_destroy (reply);
bson_steal (reply, &reply_local);
bson_init (&reply_local);
}
} else if (intent == TXN_ABORT && !r) {
/* we won't return an error from abortTransaction, so warn */
MONGOC_WARNING ("Error in %s: %s", cmd_name, err_ptr->message);
}
done:
bson_destroy (&reply_local);
bson_destroy (&cmd);
bson_destroy (&opts);
return r;
}
static bool
txn_commit (mongoc_client_session_t *session,
bool explicitly_retrying,
bson_t *reply,
bson_error_t *error)
{
bson_t cmd = BSON_INITIALIZER;
bson_t opts = BSON_INITIALIZER;
bson_error_t err_local;
bson_error_t *err_ptr = error ? error : &err_local;
bson_t reply_local = BSON_INITIALIZER;
mongoc_write_err_type_t error_type;
bool r = false;
bool retrying_after_error = false;
mongoc_write_concern_t *retry_wc = NULL;
_mongoc_bson_init_if_set (reply);
BSON_APPEND_INT32 (&cmd, "commitTransaction", 1);
retry:
if (!mongoc_client_session_append (session, &opts, err_ptr)) {
GOTO (done);
}
/* Transactions Spec: "When commitTransaction is retried, either by the
* driver's internal retry-once logic or explicitly by the user calling
* commitTransaction again, drivers MUST apply w:majority to the write
* concern of the commitTransaction command." */
if (!retry_wc && (retrying_after_error || explicitly_retrying)) {
retry_wc = create_commit_retry_wc (session->txn.opts.write_concern
? session->txn.opts.write_concern
: session->client->write_concern);
}
if (retry_wc || session->txn.opts.write_concern) {
if (!mongoc_write_concern_append (
retry_wc ? retry_wc : session->txn.opts.write_concern, &opts)) {
bson_set_error (err_ptr,
MONGOC_ERROR_TRANSACTION,
MONGOC_ERROR_TRANSACTION_INVALID_STATE,
"Invalid transaction write concern");
GOTO (done);
}
}
/* will be reinitialized by mongoc_client_write_command_with_opts */
bson_destroy (&reply_local);
r = mongoc_client_write_command_with_opts (
session->client, "admin", &cmd, &opts, &reply_local, err_ptr);
/* Transactions Spec: "Drivers MUST retry the commitTransaction command once
* after it fails with a retryable error", same for abort */
error_type = _mongoc_write_error_get_type (r, err_ptr, &reply_local);
if (!retrying_after_error && error_type == MONGOC_WRITE_ERR_RETRY) {
retrying_after_error = true; /* retry after error only once */
bson_reinit (&opts);
GOTO (retry);
}
/* Transactions Spec: "add the UnknownTransactionCommitResult error label
* when commitTransaction fails with a network error, server selection
* error, or write concern failed / timeout." */
if (reply) {
if ((!r && err_ptr->domain == MONGOC_ERROR_SERVER_SELECTION) ||
error_type == MONGOC_WRITE_ERR_RETRY ||
error_type == MONGOC_WRITE_ERR_WRITE_CONCERN) {
bson_copy_to_excluding_noinit (
&reply_local, reply, "errorLabels", NULL);
copy_labels_plus_unknown_commit_result (&reply_local, reply);
} else {
/* maintain invariants: reply & reply_local are valid until the end */
bson_destroy (reply);
bson_steal (reply, &reply_local);
bson_init (&reply_local);
}
}
done:
bson_destroy (&reply_local);
bson_destroy (&cmd);
bson_destroy (&opts);
if (retry_wc) {
mongoc_write_concern_destroy (retry_wc);
}
return r;
}
int
main (int argc, char *argv[])
{
int exit_code = EXIT_FAILURE;
mongoc_client_t *client;
mongoc_client_session_t *client_session = NULL;
mongoc_collection_t *collection = NULL;
const char *uristr = "mongodb://127.0.0.1/?appname=session-example";
bson_error_t error;
bson_t *selector = NULL;
bson_t *update = NULL;
bson_t *update_opts = NULL;
bson_t *find_opts = NULL;
mongoc_read_prefs_t *secondary = NULL;
mongoc_cursor_t *cursor = NULL;
const bson_t *doc;
char *str;
bool r;
mongoc_init ();
if (argc > 1) {
uristr = argv[1];
}
client = mongoc_client_new (uristr);
if (!client) {
fprintf (stderr, "Failed to parse URI.\n");
goto done;
}
mongoc_client_set_error_api (client, 2);
/* pass NULL for options - by default the session is causally consistent */
client_session = mongoc_client_start_session (client, NULL, &error);
if (!client_session) {
fprintf (stderr, "Failed to start session: %s\n", error.message);
goto done;
}
collection = mongoc_client_get_collection (client, "test", "collection");
selector = BCON_NEW ("_id", BCON_INT32 (1));
update = BCON_NEW ("$inc", "{", "x", BCON_INT32 (1), "}");
update_opts = bson_new ();
if (!mongoc_client_session_append (client_session, update_opts, &error)) {
fprintf (stderr, "Could not add session to opts: %s\n", error.message);
goto done;
}
r = mongoc_collection_update_one (
collection, selector, update, update_opts, NULL /* reply */, &error);
if (!r) {
fprintf (stderr, "Update failed: %s\n", error.message);
goto done;
}
bson_destroy (selector);
selector = BCON_NEW ("_id", BCON_INT32 (1));
secondary = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);
find_opts = BCON_NEW ("maxTimeMS", BCON_INT32 (2000));
if (!mongoc_client_session_append (client_session, find_opts, &error)) {
fprintf (stderr, "Could not add session to opts: %s\n", error.message);
goto done;
};
/* read from secondary. since we're in a causally consistent session, the
* data is guaranteed to reflect the update we did on the primary. the query
* blocks waiting for the secondary to catch up, if necessary, or times out
* and fails after 2000 ms.
*/
cursor = mongoc_collection_find_with_opts (
collection, selector, find_opts, secondary);
bson_destroy (selector);
mongoc_read_prefs_destroy (secondary);
bson_destroy (find_opts);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_json (doc, NULL);
fprintf (stdout, "%s\n", str);
bson_free (str);
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
goto done;
}
exit_code = EXIT_SUCCESS;
done:
if (find_opts) {
bson_destroy (find_opts);
}
if (update) {
bson_destroy (update);
}
if (selector) {
bson_destroy (selector);
}
if (update_opts) {
bson_destroy (update_opts);
}
if (secondary) {
mongoc_read_prefs_destroy (secondary);
}
/* destroy cursor, collection, session before the client they came from */
if (cursor) {
mongoc_cursor_destroy (cursor);
}
if (collection) {
mongoc_collection_destroy (collection);
}
if (client_session) {
mongoc_client_session_destroy (client_session);
}
if (client) {
mongoc_client_destroy (client);
}
mongoc_cleanup ();
return exit_code;
}
/*---------------------------------------------------------------------------
*
* _make_cursor --
*
* Construct and send the aggregate command and create the resulting
* cursor. On error, stream->cursor remains NULL, otherwise it is
* created and must be destroyed.
*
* Return:
* False on error and sets stream->err.
*
*--------------------------------------------------------------------------
*/
static bool
_make_cursor (mongoc_change_stream_t *stream)
{
mongoc_client_session_t *cs = NULL;
bson_t command_opts;
bson_t command; /* { aggregate: "coll", pipeline: [], ... } */
bson_t reply;
bson_t getmore_opts = BSON_INITIALIZER;
bson_iter_t iter;
mongoc_server_description_t *sd;
uint32_t server_id;
int32_t max_wire_version = -1;
BSON_ASSERT (stream);
BSON_ASSERT (!stream->cursor);
_make_command (stream, &command);
bson_copy_to (&(stream->opts.extra), &command_opts);
sd = mongoc_client_select_server (
stream->client, false /* for_writes */, stream->read_prefs, &stream->err);
if (!sd) {
goto cleanup;
}
server_id = mongoc_server_description_id (sd);
bson_append_int32 (&command_opts, "serverId", 8, server_id);
bson_append_int32 (&getmore_opts, "serverId", 8, server_id);
max_wire_version = sd->max_wire_version;
mongoc_server_description_destroy (sd);
if (bson_iter_init_find (&iter, &command_opts, "sessionId")) {
if (!_mongoc_client_session_from_iter (
stream->client, &iter, &cs, &stream->err)) {
goto cleanup;
}
} else if (stream->implicit_session) {
/* If an implicit session was created before, and this cursor is now
* being recreated after resuming, then use the same session as before. */
cs = stream->implicit_session;
if (!mongoc_client_session_append (cs, &command_opts, &stream->err)) {
goto cleanup;
}
} else {
/* Create an implicit session. This session lsid must be the same for the
* agg command and the subsequent getMores. Thus, this implicit session is
* passed as if it were an explicit session to
* collection_read_command_with_opts and cursor_new_from_reply, but it is
* still implicit and its lifetime is owned by this change_stream_t. */
mongoc_session_opt_t *session_opts;
session_opts = mongoc_session_opts_new ();
mongoc_session_opts_set_causal_consistency (session_opts, false);
/* returns NULL if sessions aren't supported. ignore errors. */
cs = mongoc_client_start_session (stream->client, session_opts, NULL);
stream->implicit_session = cs;
mongoc_session_opts_destroy (session_opts);
if (cs &&
!mongoc_client_session_append (cs, &command_opts, &stream->err)) {
goto cleanup;
}
}
if (cs && !mongoc_client_session_append (cs, &getmore_opts, &stream->err)) {
goto cleanup;
}
if (stream->read_concern && !bson_has_field (&command_opts, "readConcern")) {
mongoc_read_concern_append (stream->read_concern, &command_opts);
}
/* even though serverId has already been set, still pass the read prefs.
* they are necessary for OP_MSG if sending to a secondary. */
if (!mongoc_client_read_command_with_opts (stream->client,
stream->db,
&command,
stream->read_prefs,
&command_opts,
&reply,
&stream->err)) {
bson_destroy (&stream->err_doc);
bson_copy_to (&reply, &stream->err_doc);
bson_destroy (&reply);
goto cleanup;
}
bson_append_bool (
&getmore_opts, MONGOC_CURSOR_TAILABLE, MONGOC_CURSOR_TAILABLE_LEN, true);
bson_append_bool (&getmore_opts,
MONGOC_CURSOR_AWAIT_DATA,
MONGOC_CURSOR_AWAIT_DATA_LEN,
true);
/* maxTimeMS is only appended to getMores if these are set in cursor opts. */
if (stream->max_await_time_ms > 0) {
bson_append_int64 (&getmore_opts,
MONGOC_CURSOR_MAX_AWAIT_TIME_MS,
MONGOC_CURSOR_MAX_AWAIT_TIME_MS_LEN,
stream->max_await_time_ms);
}
if (stream->batch_size > 0) {
bson_append_int32 (&getmore_opts,
MONGOC_CURSOR_BATCH_SIZE,
MONGOC_CURSOR_BATCH_SIZE_LEN,
stream->batch_size);
}
/* Change streams spec: "If neither startAtOperationTime nor resumeAfter are
* specified, and the max wire version is >= 7, and the initial aggregate
* command does not return a resumeToken (indicating no results), the
* ChangeStream MUST save the operationTime from the initial aggregate
* command when it returns." */
if (bson_empty (&stream->resume_token) &&
_mongoc_timestamp_empty (&stream->operation_time) &&
max_wire_version >= 7 &&
bson_iter_init_find (&iter, &reply, "operationTime")) {
_mongoc_timestamp_set_from_bson (&stream->operation_time, &iter);
}
/* steals reply. */
stream->cursor = mongoc_cursor_new_from_command_reply_with_opts (
stream->client, &reply, &getmore_opts);
cleanup:
bson_destroy (&command);
bson_destroy (&command_opts);
bson_destroy (&getmore_opts);
return stream->err.code == 0;
}
/* Construct and send the aggregate command and create the resulting cursor.
* Returns false on error, and sets stream->err. On error, stream->cursor
* remains NULL, otherwise it is created and must be destroyed. */
static bool
_make_cursor (mongoc_change_stream_t *stream)
{
mongoc_client_session_t *cs = NULL;
bson_t command_opts;
bson_t command; /* { aggregate: "coll", pipeline: [], ... } */
bson_t reply;
bson_iter_t iter;
mongoc_server_description_t *sd;
uint32_t server_id;
BSON_ASSERT (stream);
BSON_ASSERT (!stream->cursor);
_make_command (stream, &command);
bson_copy_to (&stream->opts, &command_opts);
sd = mongoc_client_select_server (stream->coll->client,
false /* for_writes */,
stream->coll->read_prefs,
&stream->err);
if (!sd) {
goto cleanup;
}
server_id = mongoc_server_description_id (sd);
bson_append_int32 (&command_opts, "serverId", 8, server_id);
mongoc_server_description_destroy (sd);
if (bson_iter_init_find (&iter, &command_opts, "sessionId")) {
if (!_mongoc_client_session_from_iter (
stream->coll->client, &iter, &cs, &stream->err)) {
goto cleanup;
}
} else if (stream->implicit_session) {
/* If an implicit session was created before, and this cursor is now
* being recreated after resuming, then use the same session as before. */
cs = stream->implicit_session;
if (!mongoc_client_session_append (cs, &command_opts, &stream->err)) {
goto cleanup;
}
} else {
/* Create an implicit session. This session lsid must be the same for the
* agg command and the subsequent getMores. Thus, this implicit session is
* passed as if it were an explicit session to
* collection_read_command_with_opts and cursor_new_from_reply, but it is
* still implicit and its lifetime is owned by this change_stream_t. */
mongoc_session_opt_t *session_opts;
session_opts = mongoc_session_opts_new ();
mongoc_session_opts_set_causal_consistency (session_opts, false);
/* returns NULL if sessions aren't supported. ignore errors. */
cs =
mongoc_client_start_session (stream->coll->client, session_opts, NULL);
stream->implicit_session = cs;
mongoc_session_opts_destroy (session_opts);
if (cs &&
!mongoc_client_session_append (cs, &command_opts, &stream->err)) {
goto cleanup;
}
}
/* use inherited read preference and read concern of the collection */
if (!mongoc_collection_read_command_with_opts (
stream->coll, &command, NULL, &command_opts, &reply, &stream->err)) {
bson_destroy (&stream->err_doc);
bson_copy_to (&reply, &stream->err_doc);
bson_destroy (&reply);
goto cleanup;
}
stream->cursor = mongoc_cursor_new_from_command_reply (
stream->coll->client, &reply, server_id); /* steals reply */
if (cs) {
stream->cursor->client_session = cs;
stream->cursor->explicit_session = true;
}
/* maxTimeMS is only appended to getMores if these are set in cursor opts */
bson_append_bool (&stream->cursor->opts,
MONGOC_CURSOR_TAILABLE,
MONGOC_CURSOR_TAILABLE_LEN,
true);
bson_append_bool (&stream->cursor->opts,
MONGOC_CURSOR_AWAIT_DATA,
MONGOC_CURSOR_AWAIT_DATA_LEN,
true);
if (stream->max_await_time_ms > 0) {
BSON_ASSERT (
_mongoc_cursor_set_opt_int64 (stream->cursor,
MONGOC_CURSOR_MAX_AWAIT_TIME_MS,
stream->max_await_time_ms));
}
if (stream->batch_size > 0) {
mongoc_cursor_set_batch_size (stream->cursor,
(uint32_t) stream->batch_size);
}
cleanup:
bson_destroy (&command);
bson_destroy (&command_opts);
return stream->err.code == 0;
}