Distributed Transactions from the C++ SDK

// Initialize the Couchbase cluster
couchbase::cluster cluster("couchbase://localhost", "transactor", "mypass");
auto bucket = cluster.bucket("transact");
auto collection = bucket->default_collection();

// Create the single Transactions object
couchbase::transactions::transactions transactions(cluster, {});

couchbase::transactions::transaction_config configuration;
configuration.durability_level(couchbase::transactions::durability_level::PERSIST_TO_MAJORITY);
couchbase::transactions::transactions transactions(cluster, configuration);

try {
    transactions.run([&](couchbase::transactions::attempt_context& ctx) {
        // 'ctx' permits getting, inserting, removing and replacing documents,
        // along with committing and rolling back the transaction

        // ... Your transaction logic here ...

        // This call is optional -- if you leave it off,
        // the transaction will be committed anyway.
        ctx.commit();
    });
} catch (couchbase::transactions::transaction_failed& e) {
    std::cerr << "Transaction did not reach commit point: " << e.what() << "\n";
}

try {
    transactions.run([&](couchbase::transactions::attempt_context& ctx) {
        // Inserting a doc:
        ctx.insert(collection, "doc-a", nlohmann::json({}));

        // Getting documents:
        // Use ctx.get_optional() if the document may or may not exist
        auto doc_opt = ctx.get_optional(collection, "doc-a");
        if (doc_opt) {
            couchbase::transactions::transaction_get_result& doc = doc_opt.value();
        }

        // Use ctx.get if the document should exist, and the transaction
        // will fail if it does not
        couchbase::transactions::transaction_get_result doc_a = ctx.get(collection, "doc-a");

        // Replacing a doc:
        couchbase::transactions::transaction_get_result doc_b = ctx.get(collection, "doc-b");
        nlohmann::json content = doc_b.content<nlohmann::json>();
        content["transactions"] = "are awesome";
        ctx.replace(collection, doc_b, content);

        // Removing a doc:
        couchbase::transactions::transaction_get_result doc_c = ctx.get(collection, "doc-c");
        ctx.remove(collection, doc_c);

        ctx.commit();
    });
} catch (couchbase::transactions::transaction_failed& e) {
    std::cerr << "Transaction did not reach commit point: " << e.what() << "\n";
}

transactions.run([&](couchbase::transactions::attempt_context& ctx) {
    std::string id = "doc-a";
    auto doc_opt = ctx.get_optional(collection, id);
    if (doc_opt) {
        couchbase::transactions::transaction_get_result& doc = doc_opt.value();
    }
});

transactions.run([&](couchbase::transactions::attempt_context& ctx) {
    std::string id = "doc_id";
    nlohmann::json value{
        { "foo", "bar" },
    };
    ctx.insert(collection, id, value);
    // document must be accessible
    couchbase::transactions::transaction_get_result doc = ctx.get(collection, id);
});

couchbase::cluster c("couchbase://localhost", "transactor", "mypass", cluster_options().max_bucket_instances(10));
auto coll = c.bucket("transact")->default_collection();

std::list<std::thread> threads;
std::atomic<int> counter {0};
for (int i=0; i<10; i++) {
  threads.emplace_back([&]() {
    transactions.run([&](couchbase::transactions::attempt_context& ctx) {
      std::string id = "doc_a";
      auto doc = ctx.get(coll, id);
      auto doc_content = doc.value();
      doc_content["counter"] = ++counter;
      ctx.replace(coll, doc, doc_content);
    });
  });
}
for (auto& t: threads) {
  if (t.joinable()) {
    t.join();
  }
}

try {
    transactions.run([&](couchbase::transactions::attempt_context& ctx) {
        auto monster = ctx.get(collection, monster_id);
        const Monster& monster_body = monster.content<Monster>();

        int monster_hitpoints = monster_body.hitpoints;
        int monster_new_hitpoints = monster_hitpoints - damage;

        auto player = ctx.get(collection, player_id);

        if (monster_new_hitpoints <= 0) {
            // Monster is killed. The remove is just for demoing, and a more realistic examples would set a "dead" flag or similar.
            ctx.remove(collection, monster);

            const Player& player_body = player.content<Player>();

            // the player earns experience for killing the monster
            int experience_for_killing_monster = monster_body.experience_when_killed;
            int player_experience = player_body.experience;
            int player_new_experience = player_experience + experience_for_killing_monster;
            int player_new_level = calculate_level_for_experience(player_new_experience);

            Player player_new_body = player_body;
            player_new_body.experience = player_new_experience;
            player_new_body.level = player_new_level;
            ctx.replace(collection, player, player_new_body);
        } else {
            Monster monster_new_body = monster_body;
            monster_new_body.hitpoints = monster_new_hitpoints;
            ctx.replace(collection, monster, monster_new_body);
        }
    });
} catch (couchbase::transactions::transaction_failed& e) {
    // The operation failed. Both the monster and the player will be untouched

    // Situations that can cause this would include either the monster
    // or player not existing (as get is used), or a persistent
    // failure to be able to commit the transaction, for example on
    // prolonged node failure.
}

transactions.run([&](couchbase::transactions::attempt_context& ctx) {
    couchbase::transactions::transaction_get_result customer = ctx.get(collection, "customer-name");

    auto content = customer.content<nlohmann::json>();
    int balance = content["balance"].get<int>();
    if (balance < cost_of_item) {
        ctx.rollback();
    }
    // else continue transaction
});

couchbase::transactions::transaction_config configuration;
configuration.expiration_time(std::chrono::seconds(120));
couchbase::transactions::transactions transactions(cluster, configuration);

// Set logging level to Trace
couchbase::transactions::set_transactions_logging_level(log_level::TRACE);