private async Task CreateBucketAsync() { _logger.LogInformation("Attempting to create bucket..."); var bucketManager = _cluster.Buckets; var bucketSettings = new BucketSettings { BucketType = BucketType.Couchbase, Name = _config.TargetBucket, RamQuotaMB = _config.TargetBucketRamQuotaMB }; _logger.LogInformation($"Creating bucket `{_config.TargetBucket}`..."); try { await bucketManager.CreateBucketAsync(bucketSettings); _logger.LogInformation("Bucket creation complete."); } catch (BucketExistsException) { _logger.LogInformation("already exists."); } _bucket = await _cluster.BucketAsync(_config.TargetBucket); var opts = new WaitUntilReadyOptions(); opts.DesiredState(ClusterState.Online); opts.ServiceTypes(ServiceType.KeyValue, ServiceType.Query); await _bucket.WaitUntilReadyAsync(TimeSpan.FromSeconds(30), opts); _collManager = _bucket.Collections; }
private async Task <PerBucketCleaner> CleanerForBucket(string bucketName, bool startDisabled) { var bucket = await _cluster.BucketAsync(bucketName).CAF(); var collection = bucket.DefaultCollection(); return(CleanerForCollection(collection, startDisabled)); }
public async Task <ICouchbaseCollection> GetCollection(ICluster cluster) { var bucket = await cluster.BucketAsync(BucketName).CAF(); var scope = bucket.Scope(ScopeName); return(scope.Collection(CollectionName)); }
public async Task InitializeAsync() { var opts = GetClusterOptions(); Cluster = await Couchbase.Cluster.ConnectAsync( _settings.ConnectionString, opts) .ConfigureAwait(false); var bucketSettings = new BucketSettings() { BucketType = BucketType.Couchbase, Name = BucketName, RamQuotaMB = 100, NumReplicas = 0 }; try { await Cluster.Buckets.CreateBucketAsync(bucketSettings).ConfigureAwait(false); } catch (BucketExistsException) { } catch (System.Net.Http.HttpRequestException) { // why did it fail? } try { var bucket = await Cluster.BucketAsync(BucketName); try { await bucket.Collections.CreateScopeAsync(CustomScopeName); await Task.Delay(5_000); } catch (ScopeExistsException) {} try { var collectionSpec = new CollectionSpec(scopeName: CustomScopeName, CustomCollectionName); await bucket.Collections.CreateCollectionAsync(collectionSpec); await Task.Delay(5_000); } catch (CollectionExistsException) {} } catch { throw; } }
private async Task ConnectToCouchbaseAsync() { _trace.TraceInformation("Connecting..."); _cluster = await Cluster.ConnectAsync(_config.ConnectionString, _config.Username, _config.Password); _bucket = await _cluster.BucketAsync(_config.Bucket); _collection = _bucket.DefaultCollection(); _trace.TraceInformation("Connected to Couchbase collection - ", _collection.Name); }
public async Task Setup() { Cluster = await Couchbase.Cluster.ConnectAsync( "couchbase://localhost", "Administrator", "password"); Bucket = await Cluster.BucketAsync("matt"); Collection = Bucket.DefaultCollection(); }
protected async Task ConnectAsync() { var options = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .Build() .GetSection("couchbase") .Get <ClusterOptions>(); Cluster = await Couchbase.Cluster.ConnectAsync(options).ConfigureAwait(false); Bucket = await Cluster.BucketAsync("default").ConfigureAwait(false); }
public async Task <Employees> PutEmployeById(ICluster cluster, int id, Employees value) { var bucket = await cluster.BucketAsync("Employees"); var collection = bucket.DefaultCollection(); var collectiondata = await collection.UpsertAsync(id.ToString(), value); if (collectiondata == null) { logger.LogError("Error in update"); } return(null); }
//create public async Task <Employees> PostEmploye(ICluster cluster, Employees value) { var bucket = await cluster.BucketAsync("Employees"); var collection = bucket.DefaultCollection(); int idvalue = value.id; var collectiondataa = await collection.InsertAsync(idvalue.ToString(), value); if (collectiondataa == null) { logger.LogError("Error in creating"); } return(null); }
async Task <ICouchbaseCollectionManager> getCollectionManager(String username, String password) { Console.WriteLine("create-collection-manager"); // tag::create-collection-manager[] ICluster cluster = await Cluster.ConnectAsync("couchbase://localhost", username, password); IBucket bucket = await cluster.BucketAsync("travel-sample"); ICouchbaseCollectionManager collectionMgr = bucket.Collections; // end::create-collection-manager[] return(collectionMgr); }
public async Task GlobalSetup() { var options = new ClusterOptions() .WithConnectionString("couchbase://localhost") .WithCredentials("Administrator", "password"); _cluster = await Cluster.ConnectAsync(options); var bucket = await _cluster.BucketAsync("default"); _collection = bucket.DefaultCollection(); _key = Guid.NewGuid().ToString(); await _collection.InsertAsync(_key, new { name = "mike" }).ConfigureAwait(false); }
public async Task Setup() { var connectionString = Environment.GetEnvironmentVariable("COUCHBASE_CONNECTION_STRING") ?? "couchbase://localhost"; var username = Environment.GetEnvironmentVariable("COUCHBASE_USERNAME") ?? "Administrator"; var password = Environment.GetEnvironmentVariable("COUCHBASE_PASSWORD") ?? "password"; var bucketName = Environment.GetEnvironmentVariable("COUCHBASE_BUCKET_NAME") ?? "tests"; _cluster = await Cluster.ConnectAsync(connectionString, username, password); var bucket = await _cluster.BucketAsync(bucketName); _collection = bucket.DefaultCollection(); _dal = new DataAccess(_collection); _documentsToDelete = new List <string>(); }
public async Task <Employees> DeleteEmployeById(ICluster cluster, int id) { try { // var queryResult = await cluster.QueryAsync<Employees>("SELECT username,name,email,age,location,srccs,phoneNumber,salary,skill,managerName,address,id FROM Employees where id= " + id.ToString() , new Couchbase.Query.QueryOptions()); var bucket = await cluster.BucketAsync("Employees"); var collection = bucket.DefaultCollection(); await collection.RemoveAsync(id.ToString()); return(null); } catch (BucketNotFoundException) { logger.LogError("Bucket not found"); throw; } }
private async Task Initialize() { /* Logging here used the following dependencies in the associated .csproj file * <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="3.1.3" /> * <PackageReference Include="Serilog.Extensions.Logging.File" Version="2.0.0-dev-00039" /> */ IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddLogging(builder => builder .AddFilter(level => level >= LogLevel.Information) // change to Debug if trying to diagnose ); loggerFactory = serviceCollection.BuildServiceProvider().GetService <ILoggerFactory>(); loggerFactory.AddFile("Logs/myapp-{Date}.txt"); // change to Debug if trying to diagnose /* Note: in the configuration below, EnableTls is required as Couchbase Capella is * always TLS. Also, the IgnoreRemoteCertificateNameMismatch will trust the asserted * CA Cert by Couchbase Capella. There is a known issue that prevents programmatically * adding the cert, so either this or adding it to the platform is required. */ var config = new ClusterOptions { UserName = "******", Password = "******", IgnoreRemoteCertificateNameMismatch = true, // workaround for CA Cert EnableTls = true }.WithLogging(loggerFactory); cluster = await Cluster.ConnectAsync( "couchbases://6b115491-a379-4bc3-bedb-780c5fbdf8a8.dp.cloud.couchbase.com", config); Thread.Sleep(500); bucket = await cluster.BucketAsync("travel-sample"); collection = bucket.DefaultCollection(); }
public virtual async Task Setup() { var connectionString = Environment.GetEnvironmentVariable("COUCHBASE_CONNECTION_STRING") ?? "couchbase://localhost"; var username = Environment.GetEnvironmentVariable("COUCHBASE_USERNAME") ?? "Administrator"; var password = Environment.GetEnvironmentVariable("COUCHBASE_PASSWORD") ?? "password"; var bucketName = Environment.GetEnvironmentVariable("COUCHBASE_BUCKET_NAME") ?? "tests"; TestCluster = await Cluster.ConnectAsync(connectionString, username, password); // from this point on, any test using this base class assumes: // - that a bucket with name in bucketName exists // - that a primary index in that bucket exists // Locally, you'll need to make sure this is setup manually // Also see the .github folder for how this is setup for Github Actions CI/CD Bucket = await TestCluster.BucketAsync(bucketName); Collection = Bucket.DefaultCollection(); DocumentsToRemove = new List <string>(); BucketProvider = new IntegrationTestBucketProvider(Bucket); TestKeyGen = new TestKeyGenerator(DocumentsToRemove); TestConfiguration = new FakeConfiguration(); }
public async Task Setup() { var connectionString = Environment.GetEnvironmentVariable("COUCHBASE_CONNECTION_STRING") ?? "couchbase://localhost"; var username = Environment.GetEnvironmentVariable("COUCHBASE_USERNAME") ?? "Administrator"; var password = Environment.GetEnvironmentVariable("COUCHBASE_PASSWORD") ?? "password"; var bucketName = Environment.GetEnvironmentVariable("COUCHBASE_BUCKET_NAME") ?? "tests"; _cluster = await Cluster.ConnectAsync(connectionString, username, password); // try // { await _cluster.Buckets.CreateBucketAsync(new BucketSettings { Name = bucketName, BucketType = BucketType.Couchbase, FlushEnabled = true, RamQuotaMB = 100, NumReplicas = 0 }); await _cluster.QueryIndexes.CreatePrimaryIndexAsync(bucketName); // } // catch // { // // assume the bucket already exists // } var bucket = await _cluster.BucketAsync(bucketName); _collection = bucket.DefaultCollection(); _dal = new DataAccess(_collection); _documentsToDelete = new List <string>(); }
protected async Task ConnectAsync() { IServiceCollection serviceCollection = new ServiceCollection(); serviceCollection.AddLogging(builder => builder .AddFilter(level => level >= LogLevel.Debug) ); var loggerFactory = serviceCollection.BuildServiceProvider().GetService <ILoggerFactory>(); loggerFactory.AddFile("Logs/myapp-{Date}.txt", LogLevel.Debug); Logger = loggerFactory.CreateLogger("examples"); var options = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .Build() .GetSection("couchbase") .Get <ClusterOptions>() .WithLogging(loggerFactory); Cluster = await Couchbase.Cluster.ConnectAsync(options).ConfigureAwait(false); Bucket = await Cluster.BucketAsync("default").ConfigureAwait(false); }
public async Task CreateJobs(int nbr, Database databases, bool useStronglyTyped = false) { jsonObjects.Clear(); for (int i = 1; i <= nbr; i++) { JObject temp = JObject.FromObject(_baseJsonObject); temp["JobId"] = i; temp["CustomerName"] = $"{firstnames[rand.Next(0, firstnames.Count - 1)]} {lastnames[rand.Next(0, lastnames.Count - 1)]}"; jsonObjects.Add(temp); pocoObjects.Add(JsonConvert.DeserializeObject <Root>(temp.ToString())); // added option to use strongly typed stuff } Console.WriteLine($"Done initializing dummy objects"); Stopwatch sw = new Stopwatch(); if (databases.HasFlag(Database.Couchbase)) { // TODO You need to setup Couchbase with the buckets etc as listed here IBucket bucket = await cluster.BucketAsync("myBucket"); IScope scope = bucket.Scope("myScope"); var collection = scope.Collection("myCollection"); // avoid measuring lazy loading: JObject t = JObject.FromObject(_baseJsonObject); t["JobId"] = 0; t["CustomerName"] = $"{firstnames[rand.Next(0, firstnames.Count - 1)]} {lastnames[rand.Next(0, lastnames.Count - 1)]}"; await collection.InsertAsync("0", t); await collection.RemoveAsync("0"); // List<Task> inserTasks = new List<Task>(); sw.Start(); if (useStronglyTyped) { foreach (Root root in pocoObjects) { await collection.InsertAsync(root.JobId.ToString(), root); } } else { foreach (JObject temp in jsonObjects) { await collection.InsertAsync(temp.GetValue("JobId").ToString(), temp); } } // await Task.WhenAll(inserTasks); sw.Stop(); Console.WriteLine($"Adding {nbr} to Couchbase took {sw.ElapsedMilliseconds} ms"); sw.Reset(); } if (databases.HasFlag(Database.Redis)) { sw.Restart(); using (var client = redisManager.GetClient()) { // no concepts of strongly typed in redis... foreach (JObject temp in jsonObjects) { client.Set($"jobId:{temp.GetValue("JobId")}", temp.ToString()); } } sw.Stop(); Console.WriteLine($"Adding {nbr} to Redis took {sw.ElapsedMilliseconds} ms"); sw.Reset(); } if (databases.HasFlag(Database.MySql)) // file 'mysql-table-sql' has table def { MySqlConnection mySqlConnection = new MySqlConnection("Server=localhost;Database=test;port=3306;User Id=root;password=root;"); // TODO replace user / pass mySqlConnection.Open(); sw.Restart(); foreach (JObject temp in jsonObjects) { MySqlCommand cmd = new MySqlCommand($"INSERT INTO test (id, data) VALUES ('{temp.GetValue("JobId")}', @data)", mySqlConnection); cmd.Parameters.AddWithValue("@data", temp.ToString()); cmd.ExecuteNonQuery(); } sw.Stop(); Console.WriteLine($"Adding {nbr} to MySql took {sw.ElapsedMilliseconds} ms"); sw.Reset(); } if (databases.HasFlag(Database.Aerospike)) { /* namespace = database * sets = tables * records = rows * bins = columns */ sw.Restart(); // no concept of strongly typed foreach (JObject temp in jsonObjects) { aeroClient.Put(null, new Key("test", "cache", temp.GetValue("JobId").ToString()), new Bin[] { new Bin("Id", temp.GetValue("JobId").ToString()), new Bin("Data", temp.ToString()) }); } sw.Stop(); Console.WriteLine($"Adding {nbr} to Aerospike took {sw.ElapsedMilliseconds} ms"); sw.Reset(); } if (databases.HasFlag(Database.RediSql)) { var dbName = "db"; using (var client = redisManager.GetClient()) { client.Custom($"DEL", dbName); client.Custom($"REDISQL.CREATE_DB", dbName); client.Custom($"REDISQL.EXEC", dbName, $"CREATE TABLE alfacom_jobcache (Id INT, Data TEXT)"); client.Custom($"REDISQL.EXEC", dbName, $"CREATE INDEX jobid_idx ON jobcache (Id)"); } sw.Restart(); using (var client = redisManager.GetClient()) { // no concepts of strongly typed in redis... foreach (JObject temp in jsonObjects) { RediSqlCommand(client, dbName, $"INSERT INTO jobcache VALUES ({temp.GetValue("JobId")}, '{temp.ToString(Formatting.Indented)}')"); } } sw.Stop(); Console.WriteLine($"Adding {nbr} to RediSql took {sw.ElapsedMilliseconds} ms"); sw.Reset(); } }
public async Task ExecuteAsync() { Console.WriteLine("scopeAdmin"); { // tag::scopeAdmin[] ICluster clusterAdmin = await Cluster.ConnectAsync( "couchbase://localhost", "Administrator", "password"); IUserManager users = clusterAdmin.Users; var user = new User("scopeAdmin") { Password = "******", DisplayName = "Manage Scopes [travel-sample:*]", Roles = new List <Role>() { new Role("scope_admin", "travel-sample"), new Role("data_reader", "travel-sample") } }; await users.UpsertUserAsync(user); // end::scopeAdmin[] } ICluster cluster = await Cluster.ConnectAsync("couchbase://localhost", "scopeAdmin", "password"); IBucket bucket = await cluster.BucketAsync("travel-sample"); // tag::create-collection-manager[] ICouchbaseCollectionManager collectionMgr = bucket.Collections; // end::create-collection-manager[] { Console.WriteLine("create-scope"); // tag::create-scope[] try { await collectionMgr.CreateScopeAsync("example-scope"); } catch (ScopeExistsException) { Console.WriteLine("The scope already exists"); } // end::create-scope[] } { Console.WriteLine("create-collection"); // tag::create-collection[] var spec = new CollectionSpec("example-scope", "example-collection"); try { await collectionMgr.CreateCollectionAsync(spec); } catch (CollectionExistsException) { Console.WriteLine("Collection already exists"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified parent scope doesn't exist"); } // end::create-collection[] Console.WriteLine("listing-scope-collection"); // tag::listing-scope-collection[] var scopes = await collectionMgr.GetAllScopesAsync(); foreach (ScopeSpec scopeSpec in scopes) { Console.WriteLine($"Scope: {scopeSpec.Name}"); foreach (CollectionSpec collectionSpec in scopeSpec.Collections) { Console.WriteLine($" - {collectionSpec.Name}"); } } // end::listing-scope-collection[] Console.WriteLine("drop-collection"); // tag::drop-collection[] try { await collectionMgr.DropCollectionAsync(spec); } catch (CollectionNotFoundException) { Console.WriteLine("The specified collection doesn't exist"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified parent scope doesn't exist"); } // end::drop-collection[] } { Console.WriteLine("drop-scope"); // tag::drop-scope[] try { await collectionMgr.DropScopeAsync("example-scope"); } catch (ScopeNotFoundException) { Console.WriteLine("The specified scope doesn't exist"); } // end::drop-scope[] } }
public DiagnosticsReportTests(ClusterFixture fixture) { _fixture = fixture; _cluster = _fixture.Cluster; _cluster.BucketAsync("default").GetAwaiter().GetResult(); }
async Task QueryExamples() { // this isn't meant to run, merely to compile correctly. ICluster cluster = null; var transactions = Transactions.Create(cluster); { // tag::queryExamplesSelect[] var st = "SELECT * FROM `travel-sample`.inventory.hotel WHERE country = $1"; var transactionResult = await transactions.RunAsync(async ctx => { IQueryResult <object> qr = await ctx.QueryAsync <object>(st, new TransactionQueryOptions().Parameter("United Kingdom")); await foreach (var result in qr.Rows) { Console.Out.WriteLine($"result = {result}", result); } }); // end::queryExamplesSelect[] } { // tag::queryExamplesSelectScope[] IBucket travelSample = await cluster.BucketAsync("travel-sample"); IScope inventory = travelSample.Scope("inventory"); var transactionResult = await transactions.RunAsync(async ctx => { var st = "SELECT * FROM `travel-sample`.inventory.hotel WHERE country = $1"; IQueryResult <object> qr = await ctx.QueryAsync <object>(st, options: new TransactionQueryOptions().Parameter("United Kingdom"), scope: inventory); }); // end::queryExamplesSelectScope[] } { IBucket travelSample = await cluster.BucketAsync("travel-sample"); IScope inventory = travelSample.Scope("inventory"); // tag::queryExamplesUpdate[] var hotelChain = "http://marriot%"; var country = "United States"; await transactions.RunAsync(async ctx => { var qr = await ctx.QueryAsync <object>( statement: "UPDATE hotel SET price = $price WHERE url LIKE $url AND country = $country", configure: options => options.Parameter("price", 99.99m) .Parameter("url", hotelChain) .Parameter("country", country), scope: inventory); Console.Out.WriteLine($"Records Updated = {qr?.MetaData.Metrics.MutationCount}"); }); // end::queryExamplesUpdate[] } { IBucket travelSample = await cluster.BucketAsync("travel-sample"); IScope inventory = travelSample.Scope("inventory"); var hotelChain = "http://marriot%"; var country = "United States"; //private class Review { }; // tag::queryExamplesComplex[] await transactions.RunAsync(async ctx => { // Find all hotels of the chain IQueryResult <Review> qr = await ctx.QueryAsync <Review>( statement: "SELECT reviews FROM hotel WHERE url LIKE $1 AND country = $2", configure: options => options.Parameter(hotelChain).Parameter(country), scope: inventory); // This function (not provided here) will use a trained machine learning model to provide a // suitable price based on recent customer reviews. var updatedPrice = PriceFromRecentReviews(qr); // Set the price of all hotels in the chain await ctx.QueryAsync <object>( statement: "UPDATE hotel SET price = $1 WHERE url LIKE $2 AND country = $3", configure: options => options.Parameter(hotelChain, country, updatedPrice), scope: inventory); }); // end::queryExamplesComplex[] } { // tag::queryInsert[] await transactions.RunAsync(async ctx => { await ctx.QueryAsync <object>("INSERT INTO `default` VALUES ('doc', {'hello':'world'})", TransactionQueryConfigBuilder.Create()); // <1> // Performing a 'Read Your Own Write' var st = "SELECT `default`.* FROM `default` WHERE META().id = 'doc'"; // <2> IQueryResult <object> qr = await ctx.QueryAsync <object>(st, TransactionQueryConfigBuilder.Create()); Console.Out.WriteLine($"ResultCount = {qr?.MetaData.Metrics.ResultCount}"); }); // end::queryInsert[] } { // tag::querySingle[] var bulkLoadStatement = "<a bulk-loading N1QL statement>"; try { SingleQueryTransactionResult <object> result = await transactions.QueryAsync <object>(bulkLoadStatement); IQueryResult <object> queryResult = result.QueryResult; } catch (TransactionCommitAmbiguousException e) { Console.Error.WriteLine("Transaction possibly committed"); foreach (var log in e.Result.Logs) { Console.Error.WriteLine(log); } } catch (TransactionFailedException e) { Console.Error.WriteLine("Transaction did not reach commit point"); foreach (var log in e.Result.Logs) { Console.Error.WriteLine(log); } } // end::querySingle[] } { string bulkLoadStatement = null /* your statement here */; // tag::querySingleScoped[] IBucket travelSample = await cluster.BucketAsync("travel-sample"); IScope inventory = travelSample.Scope("inventory"); await transactions.QueryAsync <object>(bulkLoadStatement, scope : inventory); // end::querySingleScoped[] } { string bulkLoadStatement = null; /* your statement here */ // tag::querySingleConfigured[] // with the Builder pattern. await transactions.QueryAsync <object>(bulkLoadStatement, SingleQueryTransactionConfigBuilder.Create() // Single query transactions will often want to increase the default timeout .ExpirationTime(TimeSpan.FromSeconds(360))); // using the lambda style await transactions.QueryAsync <object>(bulkLoadStatement, config => config.ExpirationTime(TimeSpan.FromSeconds(360))); // end::querySingleConfigured[] } { ICouchbaseCollection collection = null; // tag::queryRyow[] await transactions.RunAsync(async ctx => { _ = await ctx.InsertAsync(collection, "doc", new { Hello = "world" }); // <1> // Performing a 'Read Your Own Write' var st = "SELECT `default`.* FROM `default` WHERE META().id = 'doc'"; // <2> var qr = await ctx.QueryAsync <object>(st); Console.Out.WriteLine($"ResultCount = {qr?.MetaData.Metrics.ResultCount}"); }); // end::queryRyow[] } { // tag::queryOptions[] await transactions.RunAsync(async ctx => { await ctx.QueryAsync <object>("INSERT INTO `default` VALUES ('doc', {'hello':'world'})", new TransactionQueryOptions().FlexIndex(true)); }); // end::queryOptions[] } { // tag::custom-metadata[] ICouchbaseCollection metadataCollection = null; // this is a Collection opened by your code earlier Transactions transactionsWithCustomMetadataCollection = Transactions.Create(cluster, TransactionConfigBuilder.Create().MetadataCollection(metadataCollection)); // end::custom-metadata[] } }
static async Task Main(string[] args) { // SETUP: connect to Couchbase _cluster = await Cluster.ConnectAsync( "couchbase://localhost", "Administrator", "password"); _bucket = await _cluster.BucketAsync("matt"); _scope = await _bucket.ScopeAsync("myScope"); _coll = await _scope.CollectionAsync("myCollection"); // SETUP: create a 'conference' document and a 'conference activities' document await SetupInitialDocuments(); // STEP 1: create transactions object var transactions = Transactions.Create(_cluster, TransactionConfigBuilder.Create() .DurabilityLevel(DurabilityLevel.MajorityAndPersistToActive) // since I have 1 node, replication must be 0, or this will throw exception .Build()); Console.WriteLine("Press ENTER to continue"); Console.ReadLine(); // STEP 2: transaction operations await transactions.RunAsync(async (ctx) => { var now = DateTime.Now; // FIRST: get the two document I want to change var confDoc = await ctx.GetAsync(_coll, "dataLove2021"); var actsDoc = await ctx.GetAsync(_coll, "dataLove2021::activities"); var conf = confDoc.ContentAs <Conference>(); var acts = actsDoc.ContentAs <ConferenceActivities>(); // SECOND: add an event to the "activities" document acts.Events.Add(new ConferenceEvent { Type = "CFP", DtActivity = now, Desc = "Submitted to the CFP" }); // acts.Events.Add(new ConferenceEvent // { // Type = "PRESENTATION", // DtActivity = now, // Desc = "Delivered ACID presentation" // }); // acts.Events.Add(new ConferenceEvent // { // Type = "SPATIAL", // DtActivity = now, // Desc = "Answered questions in Spatial Chat" // }); // THIRD: change the "conference" document conf.Followups = (conf.Followups ?? 0) + 1; conf.LastActivity = now; // FOURTH: write the changes await ctx.ReplaceAsync(confDoc, conf); // OPTIONAL STEP: fail right in the middle of the transaction making two writes // var fail = true; // if(fail) throw new Exception("Something went wrong!"); await ctx.ReplaceAsync(actsDoc, acts); // FIFTH: commit (implied) }); await _cluster.DisposeAsync(); }