public override void Configure(IFunctionsHostBuilder builder)
{
var connectionString = Environment.GetEnvironmentVariable("COSMOS_CONNECTIONSTRING", EnvironmentVariableTarget.Process);
var databaseName = Environment.GetEnvironmentVariable("COSMOS_DATABASENAME", EnvironmentVariableTarget.Process);
var collectionName = Environment.GetEnvironmentVariable("COSMOS_COLLECTIONNAME", EnvironmentVariableTarget.Process);
var partitionKey = Environment.GetEnvironmentVariable("COSMOS_PARTITIONKEY", EnvironmentVariableTarget.Process);
var cosmosDBConnectionString = new CosmosDBConnectionString(connectionString);
var documentClient = new DocumentClient(cosmosDBConnectionString.ServiceEndpoint, cosmosDBConnectionString.AuthKey, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
documentClient.OpenAsync().Wait();
builder.Services.AddSingleton <ICosmosDbRespository <MigrationTask> >(
new CosmosDbRespository <MigrationTask>(
new CosmosDbClient(databaseName, collectionName, documentClient),
partitionKey
)
);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "get", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
var connectionString = Environment.GetEnvironmentVariable("DOCDBCONNSTR_DocDb");
var cosmosDBConnectionString = new CosmosDBConnectionString(connectionString);
using (var client = new DocumentClient(cosmosDBConnectionString.ServiceEndpoint, cosmosDBConnectionString.AuthKey))
{
var feedOptions = new FeedOptions {
MaxItemCount = -1
};
var documents = client.CreateDocumentQuery <Sample>(UriFactory.CreateDocumentCollectionUri("ToDoList", "Items"), feedOptions);
foreach (var document in documents)
{
log.LogInformation($"{document.Id} - {document.Content}");
}
}
var environment = Environment.GetEnvironmentVariable("IAC_ENVIRONMENT");
var response = $"{environment} - {Environment.MachineName}";
return(new OkObjectResult(response));
}
private CosmosHelper()
{
var connectionString = Environment.GetEnvironmentVariable(dbConnectionStringParam);
var cosmosDBConnectionString = new CosmosDBConnectionString(connectionString);
client = new DocumentClient(cosmosDBConnectionString.ServiceEndpoint, cosmosDBConnectionString.AuthKey);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Environment.GetEnvironmentVariable("DOCDBCONNSTR_DocDb");
var cosmosDBConnectionString = new CosmosDBConnectionString(connectionString);
services.AddSingleton <CosmosDbClient>((s) => new CosmosDbClient(
cosmosDBConnectionString.ServiceEndpoint,
cosmosDBConnectionString.AuthKey));
services.AddControllers();
}
public CosmosDBService(string connectionString, ConnectionPolicy connectionPolicy)
{
CosmosDBConnectionString connection = new CosmosDBConnectionString(connectionString);
if (connectionPolicy == null)
{
connectionPolicy = new ConnectionPolicy();
}
_client = new DocumentClient(connection.ServiceEndpoint, connection.AuthKey, connectionPolicy);
}
public override void Configure(IFunctionsHostBuilder builder)
{
CosmosDBConnectionString cosmosDBConnectionString = new CosmosDBConnectionString(CosmosDBConnectionString.GetCosmosConnectionString("cosmosConnectionString"));
IDocumentClient client = new DocumentClient(cosmosDBConnectionString.ServiceEndpoint, cosmosDBConnectionString.AuthKey);
builder.Services.AddScoped <IStorageProvider <ImageObject>, CosmosStorageProvider <ImageObject> >((s) => { return(new CosmosStorageProvider <ImageObject>(client, _imageCollectionUri, _databaseId, _imageCollectionName)); });
builder.Services.AddScoped <IStorageProvider <NewsObject>, CosmosStorageProvider <NewsObject> >((s) => { return(new CosmosStorageProvider <NewsObject>(client, _newsCollectionUri, _databaseId, _newsCollectionName)); });
builder.Services.AddScoped <IStorageProvider <ShowObject>, CosmosStorageProvider <ShowObject> >((s) => { return(new CosmosStorageProvider <ShowObject>(client, _showCollectionUri, _databaseId, _showCollectionName)); });
builder.Services.AddScoped <IStorageProvider <ShowListObject>, CosmosStorageProvider <ShowListObject> >((s) => { return(new CosmosStorageProvider <ShowListObject>(client, _showlistCollectionUri, _databaseId, _showlistCollectionName)); });
builder.Services.AddScoped <IDataLayer, DataLayer>();
builder.Services.AddScoped <IShowDomain, ShowDomain>();
}
public void Constructor_ParsesCorrectly(string connectionString, string expectedUri, string expectedKey)
{
// Act
var docDBConnStr = new CosmosDBConnectionString(connectionString);
// Assert
if (expectedUri == null)
{
Assert.Null(docDBConnStr.ServiceEndpoint);
}
else
{
Assert.Equal(expectedUri, docDBConnStr.ServiceEndpoint.ToString());
}
Assert.Equal(expectedKey, docDBConnStr.AuthKey);
}
public CosmosDBService(string connectionString, ConnectionMode?connectionMode, Protocol?protocol)
{
CosmosDBConnectionString connection = new CosmosDBConnectionString(connectionString);
_client = new DocumentClient(connection.ServiceEndpoint, connection.AuthKey);
if (connectionMode.HasValue)
{
// Default is Gateway
// Source: https://docs.microsoft.com/dotnet/api/microsoft.azure.documents.client.connectionpolicy.connectionmode
_client.ConnectionPolicy.ConnectionMode = connectionMode.Value;
}
if (protocol.HasValue)
{
_client.ConnectionPolicy.ConnectionProtocol = protocol.Value;
}
}
public static IRemainingWorkEstimator GetRemainingWorkEstimator(
DocumentClient monitoredCollectionClient,
DocumentClient leaseCollectionClient)
{
if (remainingWorkEstimator == null)
{
// Pull the Connection string from the environment, Environment.GetEnvironmentVariable will read the local.settings.json file or the deployed Function App configuration
CosmosDBConnectionString cosmosDBConnectionString = new CosmosDBConnectionString(Environment.GetEnvironmentVariable("CosmosDB"));
remainingWorkEstimator = new Lazy <IRemainingWorkEstimator>(() =>
{
var builder = new ChangeFeedProcessorBuilder()
.WithHostName("monitor") // Can be a random name
.WithProcessorOptions(new ChangeFeedProcessorOptions()
{
LeasePrefix = Environment.GetEnvironmentVariable("MonitoredDatabaseLeasePrefix")
})
.WithFeedCollection(new DocumentCollectionInfo()
{
Uri = cosmosDBConnectionString.ServiceEndpoint,
MasterKey = cosmosDBConnectionString.AuthKey,
CollectionName = Environment.GetEnvironmentVariable("MonitoredCollection"),
DatabaseName = Environment.GetEnvironmentVariable("MonitoredDatabase")
})
.WithLeaseCollection(new DocumentCollectionInfo()
{
Uri = cosmosDBConnectionString.ServiceEndpoint,
MasterKey = cosmosDBConnectionString.AuthKey,
CollectionName = "leases",
DatabaseName = Environment.GetEnvironmentVariable("MonitoredDatabase")
})
.WithFeedDocumentClient(monitoredCollectionClient)
.WithLeaseDocumentClient(leaseCollectionClient);
return(builder.BuildEstimatorAsync().Result);
});
}
return(remainingWorkEstimator.Value);
}
public CosmosDBService(string connectionString, ConnectionPolicy connectionPolicy, bool useDefaultJsonSerialization)
{
CosmosDBConnectionString connection = new CosmosDBConnectionString(connectionString);
if (connectionPolicy == null)
{
connectionPolicy = new ConnectionPolicy();
}
if (useDefaultJsonSerialization)
{
if (JsonConvert.DefaultSettings == null)
{
throw new ArgumentNullException("If UseDefaultJsonSerialization is enabled, JsonConvert.DefaultSettings should be configured.");
}
_client = new DocumentClient(connection.ServiceEndpoint, connection.AuthKey, connectionPolicy, null, JsonConvert.DefaultSettings.Invoke());
}
else
{
_client = new DocumentClient(connection.ServiceEndpoint, connection.AuthKey, connectionPolicy);
}
}
private static DocumentClient NewClient()
{
IConfigurationRoot config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string connectionStringValue = config.GetConnectionString(CosmosDBConnectionString.KeyName);
if (String.IsNullOrWhiteSpace(connectionStringValue))
{
throw new InvalidOperationException(
Invariant($"Connection string '{CosmosDBConnectionString.KeyName}' has not been defined."));
}
var connectionString = CosmosDBConnectionString.Parse(connectionStringValue);
return(new DocumentClient(
connectionString.Endpoint,
connectionString.AuthKey,
CosmosDBConnectionString.DefaultPolicy));
}
public async Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
// Tries to parse the context parameters and see if it belongs to this [CosmosDBTrigger] binder
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
CosmosDBTriggerAttribute attribute = parameter.GetCustomAttribute <CosmosDBTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(null);
}
ConnectionMode?desiredConnectionMode = _options.ConnectionMode;
Protocol? desiredConnectionProtocol = _options.Protocol;
DocumentCollectionInfo documentCollectionLocation;
DocumentCollectionInfo leaseCollectionLocation;
ChangeFeedProcessorOptions processorOptions = BuildProcessorOptions(attribute);
processorOptions.StartFromBeginning = attribute.StartFromBeginning;
if (attribute.MaxItemsPerInvocation > 0)
{
processorOptions.MaxItemCount = attribute.MaxItemsPerInvocation;
}
ICosmosDBService monitoredCosmosDBService;
ICosmosDBService leaseCosmosDBService;
try
{
string triggerConnectionString = ResolveAttributeConnectionString(attribute);
CosmosDBConnectionString triggerConnection = new CosmosDBConnectionString(triggerConnectionString);
if (triggerConnection.ServiceEndpoint == null)
{
throw new InvalidOperationException("The connection string for the monitored collection is in an invalid format, please use AccountEndpoint=XXXXXX;AccountKey=XXXXXX;.");
}
string leasesConnectionString = ResolveAttributeLeasesConnectionString(attribute);
CosmosDBConnectionString leasesConnection = new CosmosDBConnectionString(leasesConnectionString);
if (leasesConnection.ServiceEndpoint == null)
{
throw new InvalidOperationException("The connection string for the leases collection is in an invalid format, please use AccountEndpoint=XXXXXX;AccountKey=XXXXXX;.");
}
documentCollectionLocation = new DocumentCollectionInfo
{
Uri = triggerConnection.ServiceEndpoint,
MasterKey = triggerConnection.AuthKey,
DatabaseName = ResolveAttributeValue(attribute.DatabaseName),
CollectionName = ResolveAttributeValue(attribute.CollectionName)
};
documentCollectionLocation.ConnectionPolicy.UserAgentSuffix = CosmosDBTriggerUserAgentSuffix;
if (desiredConnectionMode.HasValue)
{
documentCollectionLocation.ConnectionPolicy.ConnectionMode = desiredConnectionMode.Value;
}
if (desiredConnectionProtocol.HasValue)
{
documentCollectionLocation.ConnectionPolicy.ConnectionProtocol = desiredConnectionProtocol.Value;
}
leaseCollectionLocation = new DocumentCollectionInfo
{
Uri = leasesConnection.ServiceEndpoint,
MasterKey = leasesConnection.AuthKey,
DatabaseName = ResolveAttributeValue(attribute.LeaseDatabaseName),
CollectionName = ResolveAttributeValue(attribute.LeaseCollectionName)
};
leaseCollectionLocation.ConnectionPolicy.UserAgentSuffix = CosmosDBTriggerUserAgentSuffix;
if (desiredConnectionMode.HasValue)
{
leaseCollectionLocation.ConnectionPolicy.ConnectionMode = desiredConnectionMode.Value;
}
if (desiredConnectionProtocol.HasValue)
{
leaseCollectionLocation.ConnectionPolicy.ConnectionProtocol = desiredConnectionProtocol.Value;
}
string resolvedPreferredLocations = ResolveAttributeValue(attribute.PreferredLocations);
foreach (var location in CosmosDBUtility.ParsePreferredLocations(resolvedPreferredLocations))
{
documentCollectionLocation.ConnectionPolicy.PreferredLocations.Add(location);
leaseCollectionLocation.ConnectionPolicy.PreferredLocations.Add(location);
}
if (string.IsNullOrEmpty(documentCollectionLocation.DatabaseName) ||
string.IsNullOrEmpty(documentCollectionLocation.CollectionName) ||
string.IsNullOrEmpty(leaseCollectionLocation.DatabaseName) ||
string.IsNullOrEmpty(leaseCollectionLocation.CollectionName))
{
throw new InvalidOperationException("Cannot establish database and collection values. If you are using environment and configuration values, please ensure these are correctly set.");
}
if (documentCollectionLocation.Uri.Equals(leaseCollectionLocation.Uri) &&
documentCollectionLocation.DatabaseName.Equals(leaseCollectionLocation.DatabaseName) &&
documentCollectionLocation.CollectionName.Equals(leaseCollectionLocation.CollectionName))
{
throw new InvalidOperationException("The monitored collection cannot be the same as the collection storing the leases.");
}
monitoredCosmosDBService = _configProvider.GetService(triggerConnectionString, resolvedPreferredLocations);
leaseCosmosDBService = _configProvider.GetService(leasesConnectionString, resolvedPreferredLocations);
if (attribute.CreateLeaseCollectionIfNotExists)
{
await CreateLeaseCollectionIfNotExistsAsync(leaseCosmosDBService, leaseCollectionLocation.DatabaseName, leaseCollectionLocation.CollectionName, attribute.LeasesCollectionThroughput);
}
}
catch (Exception ex)
{
throw new InvalidOperationException(string.Format("Cannot create Collection Information for {0} in database {1} with lease {2} in database {3} : {4}", attribute.CollectionName, attribute.DatabaseName, attribute.LeaseCollectionName, attribute.LeaseDatabaseName, ex.Message), ex);
}
return(new CosmosDBTriggerBinding(
parameter,
documentCollectionLocation,
leaseCollectionLocation,
processorOptions,
monitoredCosmosDBService,
leaseCosmosDBService,
_logger));
}
public CosmosManager(CosmosDBConnectionString conn)
{
ConnectionString = conn;
}
public static CosmosManager CreateByConnectionString(string connectionString, string dbId, string collectionId)
{
return(new CosmosManager(CosmosDBConnectionString.Create(connectionString, dbId, collectionId)));
}
public async Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
// Tries to parse the context parameters and see if it belongs to this [CosmosDBTrigger] binder
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
CosmosDBTriggerAttribute attribute = parameter.GetCustomAttribute <CosmosDBTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(null);
}
_monitorConnectionString = _nameResolver.Resolve(CosmosDBConfiguration.AzureWebJobsCosmosDBConnectionStringName);
_leasesConnectionString = _nameResolver.Resolve(CosmosDBConfiguration.AzureWebJobsCosmosDBConnectionStringName);
DocumentCollectionInfo documentCollectionLocation;
DocumentCollectionInfo leaseCollectionLocation;
ChangeFeedHostOptions leaseHostOptions = ResolveLeaseOptions(attribute);
int?maxItemCount = null;
if (attribute.MaxItemsPerInvocation > 0)
{
maxItemCount = attribute.MaxItemsPerInvocation;
}
try
{
string triggerConnectionString = ResolveAttributeConnectionString(attribute);
CosmosDBConnectionString triggerConnection = new CosmosDBConnectionString(triggerConnectionString);
if (triggerConnection.ServiceEndpoint == null)
{
throw new InvalidOperationException("The connection string for the monitored collection is in an invalid format, please use AccountEndpoint=XXXXXX;AccountKey=XXXXXX;.");
}
string leasesConnectionString = ResolveAttributeLeasesConnectionString(attribute, triggerConnectionString);
CosmosDBConnectionString leasesConnection = new CosmosDBConnectionString(leasesConnectionString);
if (leasesConnection.ServiceEndpoint == null)
{
throw new InvalidOperationException("The connection string for the leases collection is in an invalid format, please use AccountEndpoint=XXXXXX;AccountKey=XXXXXX;.");
}
documentCollectionLocation = new DocumentCollectionInfo
{
Uri = triggerConnection.ServiceEndpoint,
MasterKey = triggerConnection.AuthKey,
DatabaseName = ResolveAttributeValue(attribute.DatabaseName),
CollectionName = ResolveAttributeValue(attribute.CollectionName)
};
documentCollectionLocation.ConnectionPolicy.UserAgentSuffix = CosmosDBTriggerUserAgentSuffix;
leaseCollectionLocation = new DocumentCollectionInfo
{
Uri = leasesConnection.ServiceEndpoint,
MasterKey = leasesConnection.AuthKey,
DatabaseName = ResolveAttributeValue(attribute.LeaseDatabaseName),
CollectionName = ResolveAttributeValue(attribute.LeaseCollectionName)
};
leaseCollectionLocation.ConnectionPolicy.UserAgentSuffix = CosmosDBTriggerUserAgentSuffix;
if (string.IsNullOrEmpty(documentCollectionLocation.DatabaseName) ||
string.IsNullOrEmpty(documentCollectionLocation.CollectionName) ||
string.IsNullOrEmpty(leaseCollectionLocation.DatabaseName) ||
string.IsNullOrEmpty(leaseCollectionLocation.CollectionName))
{
throw new InvalidOperationException("Cannot establish database and collection values. If you are using environment and configuration values, please ensure these are correctly set.");
}
if (documentCollectionLocation.Uri.Equals(leaseCollectionLocation.Uri) &&
documentCollectionLocation.DatabaseName.Equals(leaseCollectionLocation.DatabaseName) &&
documentCollectionLocation.CollectionName.Equals(leaseCollectionLocation.CollectionName))
{
throw new InvalidOperationException("The monitored collection cannot be the same as the collection storing the leases.");
}
if (attribute.CreateLeaseCollectionIfNotExists)
{
// Not disposing this because it might be reused on other Trigger since Triggers could share lease collection
ICosmosDBService service = _config.GetService(leasesConnectionString);
await CosmosDBUtility.CreateDatabaseAndCollectionIfNotExistAsync(service, leaseCollectionLocation.DatabaseName, leaseCollectionLocation.CollectionName, null, attribute.LeasesCollectionThroughput);
}
}
catch (Exception ex)
{
throw new InvalidOperationException(string.Format("Cannot create Collection Information for {0} in database {1} with lease {2} in database {3} : {4}", attribute.CollectionName, attribute.DatabaseName, attribute.LeaseCollectionName, attribute.LeaseDatabaseName, ex.Message), ex);
}
return(new CosmosDBTriggerBinding(parameter, documentCollectionLocation, leaseCollectionLocation, leaseHostOptions, maxItemCount));
}
public CosmosDBService(string connectionString)
{
CosmosDBConnectionString connection = new CosmosDBConnectionString(connectionString);
_client = new DocumentClient(connection.ServiceEndpoint, connection.AuthKey);
}
private static DocumentClient DocumentClientFactory()
{
var connectionString = new CosmosDBConnectionString(Config.CosmosDBConnectionString);
return(new DocumentClient(connectionString.ServiceEndpoint, connectionString.AuthKey));
}
public async Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var parameter = context.Parameter;
var attribute = parameter.GetCustomAttribute <CosmosStoreTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(null);
}
var desiredConnectionMode = _bindingOptions.ConnectionMode;
var desiredConnectionProtocol = _bindingOptions.Protocol;
DocumentCollectionInfo documentCollectionLocation;
DocumentCollectionInfo leaseCollectionLocation;
var processorOptions = BuildProcessorOptions(attribute);
processorOptions.StartFromBeginning = attribute.StartFromBeginning;
if (attribute.MaxItemsPerInvocation > 0)
{
processorOptions.MaxItemCount = attribute.MaxItemsPerInvocation;
}
IDocumentClient monitoredDocumentClient;
IDocumentClient leaseDocumentClient;
try
{
var monitoredConnectionString = ResolveConnectionString(attribute.ConnectionStringSetting, nameof(CosmosStoreTriggerAttribute.ConnectionStringSetting));
if (string.IsNullOrEmpty(monitoredConnectionString))
{
throw new InvalidOperationException("The connection string for the monitored collection is in an invalid format, please use AccountEndpoint=XXXXXX;AccountKey=XXXXXX;.");
}
var monitoredCosmosDbConnectionString = new CosmosDBConnectionString(monitoredConnectionString);
var leasesConnectionString = ResolveAttributeLeasesConnectionString(attribute);
var leasesConnection = new CosmosDBConnectionString(leasesConnectionString);
if (leasesConnection.ServiceEndpoint == null)
{
throw new InvalidOperationException("The connection string for the leases collection is in an invalid format, please use AccountEndpoint=XXXXXX;AccountKey=XXXXXX;.");
}
var monitoredCollectionName = GetMonitoredCollectionName(attribute);
documentCollectionLocation = new DocumentCollectionInfo
{
Uri = monitoredCosmosDbConnectionString.ServiceEndpoint,
MasterKey = monitoredCosmosDbConnectionString.AuthKey,
DatabaseName = ResolveAttributeValue(attribute.DatabaseName),
CollectionName = monitoredCollectionName,
ConnectionPolicy = { UserAgentSuffix = CosmosStoreTriggerUserAgentSuffix }
};
if (desiredConnectionMode.HasValue)
{
documentCollectionLocation.ConnectionPolicy.ConnectionMode = desiredConnectionMode.Value;
}
if (desiredConnectionProtocol.HasValue)
{
documentCollectionLocation.ConnectionPolicy.ConnectionProtocol = desiredConnectionProtocol.Value;
}
leaseCollectionLocation = new DocumentCollectionInfo
{
Uri = leasesConnection.ServiceEndpoint,
MasterKey = leasesConnection.AuthKey,
DatabaseName = ResolveAttributeValue(attribute.LeaseDatabaseName),
CollectionName = ResolveAttributeValue(attribute.LeaseCollectionName)
};
leaseCollectionLocation.ConnectionPolicy.UserAgentSuffix = CosmosStoreTriggerUserAgentSuffix;
if (desiredConnectionMode.HasValue)
{
leaseCollectionLocation.ConnectionPolicy.ConnectionMode = desiredConnectionMode.Value;
}
if (desiredConnectionProtocol.HasValue)
{
leaseCollectionLocation.ConnectionPolicy.ConnectionProtocol = desiredConnectionProtocol.Value;
}
var resolvedPreferredLocations = ResolveAttributeValue(attribute.PreferredLocations);
foreach (var location in CosmosDBUtility.ParsePreferredLocations(resolvedPreferredLocations))
{
documentCollectionLocation.ConnectionPolicy.PreferredLocations.Add(location);
leaseCollectionLocation.ConnectionPolicy.PreferredLocations.Add(location);
}
if (string.IsNullOrEmpty(documentCollectionLocation.DatabaseName) ||
string.IsNullOrEmpty(documentCollectionLocation.CollectionName) ||
string.IsNullOrEmpty(leaseCollectionLocation.DatabaseName) ||
string.IsNullOrEmpty(leaseCollectionLocation.CollectionName))
{
throw new InvalidOperationException("Cannot establish database and collection values. If you are using environment and configuration values, please ensure these are correctly set.");
}
if (documentCollectionLocation.Uri.Equals(leaseCollectionLocation.Uri) &&
documentCollectionLocation.DatabaseName.Equals(leaseCollectionLocation.DatabaseName) &&
documentCollectionLocation.CollectionName.Equals(leaseCollectionLocation.CollectionName))
{
throw new InvalidOperationException("The monitored collection cannot be the same as the collection storing the leases.");
}
var cosmosStore = new CosmosStore <T>(new CosmosStoreSettings(documentCollectionLocation.DatabaseName,
documentCollectionLocation.Uri, documentCollectionLocation.MasterKey),
attribute.CollectionName);
monitoredDocumentClient = cosmosStore.CosmonautClient.DocumentClient;
leaseDocumentClient = new DocumentClient(leasesConnection.ServiceEndpoint, leasesConnection.AuthKey, leaseCollectionLocation.ConnectionPolicy);
if (attribute.CreateLeaseCollectionIfNotExists)
{
await CreateLeaseCollectionIfNotExistsAsync(leaseDocumentClient, leaseCollectionLocation.DatabaseName, leaseCollectionLocation.CollectionName, attribute.LeasesCollectionThroughput);
}
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"Cannot create Collection Information for {attribute.CollectionName} in database {attribute.DatabaseName} with lease {attribute.LeaseCollectionName} in database {attribute.LeaseDatabaseName} : {ex.Message}", ex);
}
return(new CosmosStoreTriggerBinding <T>(parameter, documentCollectionLocation, leaseCollectionLocation, monitoredDocumentClient, leaseDocumentClient, processorOptions, _logger));
}
