public SingleMultiRegion()
{
string endpoint, key, region;
databaseName = Environment.GetEnvironmentVariable("database");
containerName = Environment.GetEnvironmentVariable("container");
storedProcName = Environment.GetEnvironmentVariable("storedproc");
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName);
//Single-Region account client
endpoint = Environment.GetEnvironmentVariable("SingleRegionEndpoint");
key = Environment.GetEnvironmentVariable("SingleRegionKey");
region = Environment.GetEnvironmentVariable("SingleRegionRegion");
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
policy.SetCurrentLocation(region);
clientSingle = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientSingle.OpenAsync().GetAwaiter().GetResult();
//Multi-Region account client
endpoint = Environment.GetEnvironmentVariable("MultiRegionEndpoint");
key = Environment.GetEnvironmentVariable("MultiRegionKey");
region = Environment.GetEnvironmentVariable("MultiRegionRegion");
policy.SetCurrentLocation(region);
clientMulti = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientMulti.OpenAsync().GetAwaiter().GetResult();
}
private DocumentClient readClient; //Read from West US
public async Task Initialize(Uri accountEndpoint, string key)
{
//Write Policy
ConnectionPolicy writeConnectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
//Write to West US 2
writeConnectionPolicy.SetCurrentLocation(LocationNames.WestUS2);
//Read Policy
ConnectionPolicy readConnectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
//Read from West US
readConnectionPolicy.SetCurrentLocation(LocationNames.WestUS);
writeClient = new DocumentClient(accountEndpoint, key, writeConnectionPolicy);
readClient = new DocumentClient(accountEndpoint, key, readConnectionPolicy);
await Task.WhenAll(new Task[]
{
writeClient.OpenAsync(),
readClient.OpenAsync()
});
}
internal ConnectionPolicy GetConnectionPolicy()
{
ConnectionPolicy connectionPolicy = new ConnectionPolicy
{
EnableEndpointDiscovery = true,
UseMultipleWriteLocations = true,
UserAgentSuffix = string.Format(" {0}/{1} {2}", "cosmos-table-sdk", "1.0.4", UserAgentSuffix)
};
if (UseConnectionModeDirect)
{
connectionPolicy.ConnectionMode = ConnectionMode.Direct;
connectionPolicy.ConnectionProtocol = Microsoft.Azure.Documents.Client.Protocol.Tcp;
}
else
{
connectionPolicy.ConnectionMode = ConnectionMode.Gateway;
connectionPolicy.ConnectionProtocol = Microsoft.Azure.Documents.Client.Protocol.Https;
MaxConnectionLimit = MaxConnectionLimit;
}
if (!string.IsNullOrEmpty(CurrentRegion))
{
connectionPolicy.SetCurrentLocation(CurrentRegion);
}
if (MaxRetryAttemptsOnThrottledRequests.HasValue)
{
connectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = MaxRetryAttemptsOnThrottledRequests.Value;
}
if (MaxRetryWaitTimeOnThrottledRequests.HasValue)
{
connectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = MaxRetryWaitTimeOnThrottledRequests.Value;
}
return(connectionPolicy);
}
public Conflicts()
{
databaseName = Environment.GetEnvironmentVariable("database");
lwwContainerName = Environment.GetEnvironmentVariable("LwwPolicyContainer");
udpContainerName = Environment.GetEnvironmentVariable("UdpPolicyContainer");
noneContainerName = Environment.GetEnvironmentVariable("NoPolicyContainer");
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
lwwContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, lwwContainerName);
udpContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, udpContainerName);
noneContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, noneContainerName);
string endpoint = Environment.GetEnvironmentVariable("MultiMasterEndpoint");
string key = Environment.GetEnvironmentVariable("MultiMasterKey");
List <string> regions = Environment.GetEnvironmentVariable("ConflictRegions").Split(';').ToList();
clients = new List <DocumentClient>();
foreach (string region in regions)
{
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true //Multiple write locations
};
policy.SetCurrentLocation(region);
DocumentClient client = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
client.OpenAsync().GetAwaiter().GetResult();
clients.Add(client);
}
}
public CustomSynchronization()
{
string endpoint, key, writeRegion, readRegion;
databaseName = ConfigurationManager.AppSettings["database"];
containerName = ConfigurationManager.AppSettings["container"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
writeRegion = ConfigurationManager.AppSettings["WriteRegion"];
readRegion = ConfigurationManager.AppSettings["readRegion"];
Console.WriteLine("Custom Synchronization for Stronger Consistency without Latency");
Console.WriteLine("---------------------------------------------------------------");
//Shared endpoint and key
endpoint = ConfigurationManager.AppSettings["CustomSyncEndpoint"];
key = ConfigurationManager.AppSettings["CustomSyncKey"];
//Write client
ConnectionPolicy writePolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true
};
writePolicy.SetCurrentLocation(writeRegion);
writeClient = new DocumentClient(new Uri(endpoint), key, writePolicy);
Console.WriteLine($"Created Write Client with Session consistency in: {writeRegion}.");
//Read client policy
ConnectionPolicy readPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
readPolicy.SetCurrentLocation(readRegion);
readClient = new DocumentClient(new Uri(endpoint), key, readPolicy, ConsistencyLevel.Session);
Console.WriteLine($"Created Read Client with Session consistency in: {readRegion}.");
//Strong consistency client
ConnectionPolicy strongPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
strongPolicy.SetCurrentLocation(writeRegion);
endpoint = ConfigurationManager.AppSettings["StrongEndpoint"];
key = ConfigurationManager.AppSettings["StrongKey"];
strongClient = new DocumentClient(new Uri(endpoint), key, strongPolicy, ConsistencyLevel.Strong);
Console.WriteLine($"Created client with Strong consistency in: {writeRegion}.");
Console.WriteLine();
writeClient.OpenAsync();
readClient.OpenAsync();
strongClient.OpenAsync();
}
public SingleMultiRegion()
{
Console.WriteLine("Single Region vs Multi-Region Read Latency");
Console.WriteLine("-------------------------------------------------------------------------");
string endpoint, key, region;
databaseName = ConfigurationManager.AppSettings["database"];
containerName = ConfigurationManager.AppSettings["container"];
storedProcName = ConfigurationManager.AppSettings["storedproc"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName);
//Single-Region account client
endpoint = ConfigurationManager.AppSettings["SingleRegionEndpoint"];
key = ConfigurationManager.AppSettings["SingleRegionKey"];
region = ConfigurationManager.AppSettings["SingleRegionRegion"];
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
policy.SetCurrentLocation(region);
clientSingle = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientSingle.OpenAsync();
Console.WriteLine($"Created DocumentClient for Single-Region account in: {region}.");
//Multi-Region account client
endpoint = ConfigurationManager.AppSettings["MultiRegionEndpoint"];
key = ConfigurationManager.AppSettings["MultiRegionKey"];
region = ConfigurationManager.AppSettings["MultiRegionRegion"];
policy.SetCurrentLocation(region);
clientMulti = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientMulti.OpenAsync();
Console.WriteLine($"Created DocumentClient for Multi-Region account in: {region}.");
Console.WriteLine();
}
public SingleMultiMaster()
{
string endpoint, key, region;
databaseName = ConfigurationManager.AppSettings["database"];
containerName = ConfigurationManager.AppSettings["container"];
storedProcName = ConfigurationManager.AppSettings["storedproc"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName);
Console.WriteLine($"Single-Master vs Multi-Master Latency");
Console.WriteLine("--------------------------------------");
//Single-Master Connection Policy
ConnectionPolicy policySingleMaster = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
region = ConfigurationManager.AppSettings["SingleMultiMasterRegion"];
policySingleMaster.SetCurrentLocation(region);
// Create the Single-Master account client
endpoint = ConfigurationManager.AppSettings["SingleMasterEndpoint"];
key = ConfigurationManager.AppSettings["SingleMasterKey"];
clientSingle = new DocumentClient(new Uri(endpoint), key, policySingleMaster, ConsistencyLevel.Eventual);
clientSingle.OpenAsync();
Console.WriteLine($"Created DocumentClient for Single-Master account in: {region}.");
//Multi-Master Connection Policy
ConnectionPolicy policyMultiMaster = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true //Required for Multi-Master
};
region = ConfigurationManager.AppSettings["SingleMultiMasterRegion"];
policyMultiMaster.SetCurrentLocation(region); //Enable multi-homing
// Create the Multi-Master account client
endpoint = ConfigurationManager.AppSettings["MultiMasterEndpoint"];
key = ConfigurationManager.AppSettings["MultiMasterKey"];
clientMulti = new DocumentClient(new Uri(endpoint), key, policyMultiMaster, ConsistencyLevel.Eventual);
clientMulti.OpenAsync();
Console.WriteLine($"Created DocumentClient for Multi-Master account in: {region}.");
Console.WriteLine();
}
public CustomSynchronization()
{
string endpoint, key, writeRegion, readRegion;
databaseName = Environment.GetEnvironmentVariable("database");
containerName = Environment.GetEnvironmentVariable("container");
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
writeRegion = Environment.GetEnvironmentVariable("WriteRegion");
readRegion = Environment.GetEnvironmentVariable("readRegion");
//Shared endpoint and key
endpoint = Environment.GetEnvironmentVariable("CustomSyncEndpoint");
key = Environment.GetEnvironmentVariable("CustomSyncKey");
//Write client
ConnectionPolicy writePolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true
};
writePolicy.SetCurrentLocation(writeRegion);
writeClient = new DocumentClient(new Uri(endpoint), key, writePolicy);
//Read client policy
ConnectionPolicy readPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp
};
readPolicy.SetCurrentLocation(readRegion);
readClient = new DocumentClient(new Uri(endpoint), key, readPolicy, ConsistencyLevel.Session);
//Strong consistency client
ConnectionPolicy strongPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
strongPolicy.SetCurrentLocation(writeRegion);
endpoint = Environment.GetEnvironmentVariable("StrongEndpoint");
key = Environment.GetEnvironmentVariable("StrongKey");
strongClient = new DocumentClient(new Uri(endpoint), key, strongPolicy, ConsistencyLevel.Strong);
writeClient.OpenAsync().GetAwaiter().GetResult();
readClient.OpenAsync().GetAwaiter().GetResult();
strongClient.OpenAsync().GetAwaiter().GetResult();
}
/// <summary>
/// Main method for the sample.
/// </summary>
/// <param name="args">command line arguments.</param>
public static void Main(string[] args)
{
ThreadPool.SetMinThreads(MinThreadPoolSize, MinThreadPoolSize);
string endpoint = ConfigurationManager.AppSettings["EndPointUrl"];
string authKey = ConfigurationManager.AppSettings["AuthorizationKey"];
Console.WriteLine("Summary:");
Console.WriteLine("--------------------------------------------------------------------- ");
Console.WriteLine("Endpoint: {0}", endpoint);
Console.WriteLine("Collection : {0}.{1} at {2} request units per second", DatabaseName, DataCollectionName, ConfigurationManager.AppSettings["CollectionThroughput"]);
Console.WriteLine("Document Template*: {0}", ConfigurationManager.AppSettings["DocumentTemplateFile"]);
Console.WriteLine("Degree of parallelism*: {0}", ConfigurationManager.AppSettings["DegreeOfParallelism"]);
Console.WriteLine("--------------------------------------------------------------------- ");
Console.WriteLine();
Console.WriteLine("CosmosDBBenchmark starting...");
try
{
ConnectionPolicy.SetCurrentLocation(LocationNames.WestUS2);
ConnectionPolicy.UseMultipleWriteLocations = true;
using (var client = new DocumentClient(
new Uri(endpoint),
authKey,
ConnectionPolicy))
{
var program = new Program(client);
program.RunAsync().Wait();
Console.WriteLine("Cosmos DB Benchmark completed successfully.");
}
}
#if !DEBUG
catch (Exception e)
{
// If the Exception is a DocumentClientException, the "StatusCode" value might help identity
// the source of the problem.
Console.WriteLine("Samples failed with exception:{0}", e);
}
#endif
finally
{
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
}
public ConsistencyLatency()
{
string endpoint, key, region;
databaseName = ConfigurationManager.AppSettings["database"];
containerName = ConfigurationManager.AppSettings["container"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
region = ConfigurationManager.AppSettings["ConsistencyLatencyRegion"];
Console.WriteLine("Latency vs Eventual and Strong Consistency");
Console.WriteLine("-------------------------------------------------------------------------------------");
//Shared connection policy
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
policy.SetCurrentLocation(region);
//Eventual consistency client
endpoint = ConfigurationManager.AppSettings["EventualEndpoint"];
key = ConfigurationManager.AppSettings["EventualKey"];
clientEventual = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientEventual.OpenAsync();
Console.WriteLine($"Created DocumentClient with Eventual consistency in: {region}.");
//Strong consistency client 1K miles
endpoint = ConfigurationManager.AppSettings["Strong1kMilesEndpoint"];
key = ConfigurationManager.AppSettings["Strong1kMilesKey"];
clientStrong1kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong);
clientStrong1kMiles.OpenAsync();
Console.WriteLine($"Created DocumentClient with Strong consistency in: {region} replicating 1000 miles.");
//Strong consistency client 2K miles
endpoint = ConfigurationManager.AppSettings["Strong2kMilesEndpoint"];
key = ConfigurationManager.AppSettings["Strong2kMilesKey"];
clientStrong2kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong);
clientStrong2kMiles.OpenAsync();
Console.WriteLine($"Created DocumentClient with Strong consistency in: {region} replicating 2000 miles.");
Console.WriteLine();
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args).
UseApplicationInsights().
ConfigureAppConfiguration((hostingContext, config) =>
{
Configuration = config.Build();
}).
ConfigureServices(s =>
{
s.AddMvc();
#region CosmosDB
var cosmosDbConfig = ConfigurationBinder.Get <CosmosDbConfig>(Configuration.GetSection("CosmosDb"));
s.AddSingleton(cosmosDbConfig);
var connectionPolicy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true
};
if (cosmosDbConfig.PreferredLocations != null && cosmosDbConfig.PreferredLocations.Any() && cosmosDbConfig.PreferredLocations.All(l => AllowedLocations.Contains(l)))
{
// write
connectionPolicy.SetCurrentLocation(cosmosDbConfig.PreferredLocations.First());
// read
foreach (var location in cosmosDbConfig.PreferredLocations)
{
connectionPolicy.PreferredLocations.Add(location);
}
}
var client = new DocumentClient(new Uri(cosmosDbConfig.Endpoint), cosmosDbConfig.Key, connectionPolicy);
client.OpenAsync().GetAwaiter().GetResult();
s.AddSingleton(client);
#endregion
}).
Configure(app =>
{
app.UseHttpsRedirection();
app.UseMvc();
});
public SingleMultiMaster()
{
string endpoint, key, region;
databaseName = Environment.GetEnvironmentVariable("database");
containerName = Environment.GetEnvironmentVariable("container");
storedProcName = Environment.GetEnvironmentVariable("storedproc");
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName);
//Single-Master Connection Policy
ConnectionPolicy policySingleMaster = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
region = Environment.GetEnvironmentVariable("SingleMultiMasterRegion");
policySingleMaster.SetCurrentLocation(region);
// Create the Single-Master account client
endpoint = Environment.GetEnvironmentVariable("SingleMasterEndpoint");
key = Environment.GetEnvironmentVariable("SingleMasterKey");
clientSingle = new DocumentClient(new Uri(endpoint), key, policySingleMaster, ConsistencyLevel.Eventual);
clientSingle.OpenAsync().GetAwaiter().GetResult();
//Multi-Master Connection Policy
ConnectionPolicy policyMultiMaster = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true //Required for Multi-Master
};
region = Environment.GetEnvironmentVariable("SingleMultiMasterRegion");
policyMultiMaster.SetCurrentLocation(region); //Enable multi-homing
// Create the Multi-Master account client
endpoint = Environment.GetEnvironmentVariable("MultiMasterEndpoint");
key = Environment.GetEnvironmentVariable("MultiMasterKey");
clientMulti = new DocumentClient(new Uri(endpoint), key, policyMultiMaster, ConsistencyLevel.Eventual);
clientMulti.OpenAsync().GetAwaiter().GetResult();
}
public ConsistencyLatency()
{
string endpoint, key, region;
databaseName = Environment.GetEnvironmentVariable("database");
containerName = Environment.GetEnvironmentVariable("container");
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName);
region = Environment.GetEnvironmentVariable("ConsistencyLatencyRegion");
//Shared connection policy
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
};
policy.SetCurrentLocation(region);
//Eventual consistency client
endpoint = Environment.GetEnvironmentVariable("EventualEndpoint");
key = Environment.GetEnvironmentVariable("EventualKey");
clientEventual = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
clientEventual.OpenAsync().GetAwaiter().GetResult();
//Strong consistency client 1K miles
endpoint = Environment.GetEnvironmentVariable("Strong1kMilesEndpoint");
key = Environment.GetEnvironmentVariable("Strong1kMilesKey");
clientStrong1kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong);
clientStrong1kMiles.OpenAsync().GetAwaiter().GetResult();
//Strong consistency client 2K miles
endpoint = Environment.GetEnvironmentVariable("Strong2kMilesEndpoint");
key = Environment.GetEnvironmentVariable("Strong2kMilesKey");
clientStrong2kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong);
clientStrong2kMiles.OpenAsync().GetAwaiter().GetResult();
}
public Conflicts()
{
databaseName = ConfigurationManager.AppSettings["database"];
lwwContainerName = ConfigurationManager.AppSettings["LwwPolicyContainer"];
udpContainerName = ConfigurationManager.AppSettings["UdpPolicyContainer"];
noneContainerName = ConfigurationManager.AppSettings["NoPolicyContainer"];
databaseUri = UriFactory.CreateDatabaseUri(databaseName);
lwwContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, lwwContainerName);
udpContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, udpContainerName);
noneContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, noneContainerName);
Console.WriteLine("Multi Master: Conflict Resolution");
Console.WriteLine("---------------------------------");
string endpoint = ConfigurationManager.AppSettings["MultiMasterEndpoint"];
string key = ConfigurationManager.AppSettings["MultiMasterKey"];
List <string> regions = ConfigurationManager.AppSettings["ConflictRegions"].Split(';').ToList();
clients = new List <DocumentClient>();
foreach (string region in regions)
{
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true //Multiple write locations
};
policy.SetCurrentLocation(region);
DocumentClient client = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual);
client.OpenAsync();
clients.Add(client);
Console.WriteLine($"Created Multi-Master DocumentClient in: {region}");
}
Console.WriteLine();
}
public static async Task Run([EventHubTrigger("melonhubs", Connection = "EventHubConnectionAppSetting")] EventData[] events, ILogger log)
{
var exceptions = new List <Exception>();
foreach (EventData eventData in events)
{
try
{
string messageBody = Encoding.UTF8.GetString(eventData.Body.Array, eventData.Body.Offset, eventData.Body.Count);
// Replace these two lines with your processing logic.
log.LogInformation($"C# Event Hub trigger function processed a message: {messageBody}");
Uri collectionLink = UriFactory.CreateDocumentCollectionUri(Environment.GetEnvironmentVariable($"database_name"), Environment.GetEnvironmentVariable($"lwwcollection"));
// Art of possible :
Entity entity = JsonConvert.DeserializeObject <Entity>(messageBody);
ConnectionPolicy policy = new ConnectionPolicy
{
ConnectionMode = ConnectionMode.Direct,
ConnectionProtocol = Protocol.Tcp,
UseMultipleWriteLocations = true
};
policy.SetCurrentLocation("North Europe");
DocumentCollection lwwCollection = await client.CreateDocumentCollectionIfNotExistsAsync(
UriFactory.CreateDatabaseUri(Environment.GetEnvironmentVariable($"database_name")), new DocumentCollection
{
Id = Environment.GetEnvironmentVariable($"lwwcollection"),
ConflictResolutionPolicy = new ConflictResolutionPolicy
{
Mode = ConflictResolutionMode.LastWriterWins,
ConflictResolutionPath = "/id",
},
});
WriteToCosmos(client, entity, collectionLink);
await Task.Yield();
}
catch (Exception e)
{
// We need to keep processing the rest of the batch - capture this exception and continue.
// Also, consider capturing details of the message that failed processing so it can be processed again later.
exceptions.Add(e);
}
}
// Once processing of the batch is complete, if any messages in the batch failed processing throw an exception so that there is a record of the failure.
if (exceptions.Count > 1)
{
throw new AggregateException(exceptions);
}
if (exceptions.Count == 1)
{
throw exceptions.Single();
}
}
