public static async Task <CosmosDatabaseService> InitializeCosmosDatabaseInstance(IConfigurationSection configurationSection)
{
string dataBaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string primaryKey = configurationSection.GetSection("PrimaryKey").Value;
string endPointUrl = configurationSection.GetSection("EndpointUrl").Value;
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(endPointUrl, primaryKey);
CosmosClient cosmosClient = cosmosClientBuilder.WithConnectionModeDirect().Build();
CosmosDatabaseService cosmosDatabaseService = new CosmosDatabaseService(cosmosClient, dataBaseName, containerName);
DatabaseResponse databaseResponse = await cosmosClient.CreateDatabaseIfNotExistsAsync(dataBaseName);
await databaseResponse.Database.CreateContainerIfNotExistsAsync(containerName, "/ServiceType");
return(cosmosDatabaseService);
}
public async Task <DatabaseResponse> CreateDatabase()
{
_databaseName = _webHostEnvironment.EnvironmentName == "Production" ? _configuration["cosmosDb.Production:SystemDatabaseName"] : _configuration["cosmosDb.Localhost:SystemDatabaseName"];
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(_uri, _primaryKey);
_dbClient = clientBuilder.WithConnectionModeDirect().Build();
DatabaseResponse response = await _dbClient.CreateDatabaseIfNotExistsAsync(_databaseName);
if (response.StatusCode == HttpStatusCode.OK)
{
response = await DeleteDatabase();
response = await _dbClient.CreateDatabaseAsync(_databaseName);
}
_database = response.Database;
return(response);
}
public override void Configure(IFunctionsHostBuilder builder)
{
builder.Services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddFilter(level => true);
});
var config = (IConfiguration)builder.Services.First(d => d.ServiceType == typeof(IConfiguration)).ImplementationInstance;
builder.Services.AddSingleton((s) =>
{
// Provide your own primary connection key
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("");
return(cosmosClientBuilder.WithConnectionModeDirect()
.WithApplicationRegion("Australia East")
.WithBulkExecution(true)
.Build());
});
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews()
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
});
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
services.Configure <HackerNewsConfig>(Configuration.GetSection("HackerNewsConfig"));
services.Configure <CosmosDbConfig>(Configuration.GetSection("CosmosDb"));
services.AddHttpClient <IStoryService, HackerNewsService>();
services.AddSingleton <ICosmosDbService, CosmosDbService>((provider) =>
{
var config = provider.GetRequiredService <IOptions <CosmosDbConfig> >();
var clientBuilder = new CosmosClientBuilder(config.Value.ConnectionString);
var client = clientBuilder.WithConnectionModeDirect()
.Build();
var database = client.GetDatabase(config.Value.DatabaseName);
if (database == null)
{
throw new CosmosDbException($"Database '{config.Value.DatabaseName}' does not exist.");
}
var container = database.GetContainer(config.Value.ContainerName);
if (container == null)
{
throw new CosmosDbException($"Container '{config.Value.ContainerName}' does not exist.");
}
return(new CosmosDbService(container));
});
}
//**** PRIVATE METHODS ****//
private static async Task <CosmosClient> GetCosmosClient(ISettingService settingService)
{
if (_cosmosSingletonClient == null)
{
var cosmosDbName = settingService.GetCosmosDbDatabaseName();
var cosmosDbEndpoint = settingService.GetCosmosDbEndpoint();
var cosmosDbApiKey = settingService.GetCosmosDbApiKey();
var cosmosDbContainerName = settingService.GetCosmosDbMainContainerName();
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(cosmosDbEndpoint, cosmosDbApiKey);
_cosmosSingletonClient = clientBuilder
.WithConnectionModeDirect()
.Build();
//Create Database or Container if they don't exist
DatabaseResponse database = await _cosmosSingletonClient.CreateDatabaseIfNotExistsAsync(cosmosDbName);
await database.Database.CreateContainerIfNotExistsAsync(cosmosDbContainerName, "/id");
}
return(_cosmosSingletonClient);
}
public BaseDbService(IServiceProvider serviceProvider, string dbName)
{
var configuration = serviceProvider.GetService <IConfiguration>();
var configurationSection = configuration.GetSection("CosmosDb");
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient dbClient = clientBuilder
.WithConnectionModeDirect()
.Build();
DatabaseResponse database = dbClient.CreateDatabaseIfNotExistsAsync(dbName).GetAwaiter().GetResult();
var partitionKey = typeof(T).GetProperties().Where(p => p.GetCustomAttributes(false).Where(a => a.GetType() == typeof(KeyAttribute)).Count() > 0).FirstOrDefault();
database.Database.CreateContainerIfNotExistsAsync(typeof(T).Name, $"/{partitionKey.Name.ToLower()}").GetAwaiter().GetResult();
DbContainer = dbClient.GetContainer(dbName, typeof(T).Name);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string resourceContainerName = configurationSection.GetSection("resourceContainerName").Value;
string userContainerName = configurationSection.GetSection("userContainerName").Value;
string needContainerName = configurationSection.GetSection("needContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
var clientBuilder = new CosmosClientBuilder(account, key);
var client = clientBuilder.WithConnectionModeDirect().Build();
var cosmosDbService = new CosmosDbService(client, databaseName, resourceContainerName, userContainerName, needContainerName);
var database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(resourceContainerName, "/Category");
await database.Database.CreateContainerIfNotExistsAsync(userContainerName, "/PhoneNumber");
await database.Database.CreateContainerIfNotExistsAsync(needContainerName, "/Category");
return(cosmosDbService);
}
public override void Configure(IFunctionsHostBuilder builder)
{
builder.Services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddFilter(level => true);
});
//var config = (IConfiguration)builder.Services.First(d => d.ServiceType == typeof(IConfiguration)).ImplementationInstance;
builder.Services.AddSingleton((s) =>
{
//CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(config[Constants.CONNECTION_STRING]);
CosmosClientBuilder cosmosClientBuilder =
new CosmosClientBuilder(System.Environment.GetEnvironmentVariable(Constants.CONNECTION_STRING, EnvironmentVariableTarget.Process));
return(cosmosClientBuilder.WithConnectionModeDirect()
.WithApplicationRegion("North Europe")
.WithBulkExecution(true)
.Build());
});
}
public static CosmosClient CreateMockCosmosClient(
bool useCustomSerializer = false,
Action <CosmosClientBuilder> customizeClientBuilder = null)
{
DocumentClient documentClient = new MockDocumentClient();
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("http://localhost", Guid.NewGuid().ToString());
cosmosClientBuilder.WithConnectionModeDirect();
customizeClientBuilder?.Invoke(cosmosClientBuilder);
if (useCustomSerializer)
{
cosmosClientBuilder.WithSerializerOptions(
new CosmosSerializationOptions()
{
IgnoreNullValues = true,
});
}
return(cosmosClientBuilder.Build(documentClient));
}
private async Task <CosmosService> InitializeCosmosClientInstanseAsync(IConfiguration configuration)
{
string databaseName = Configuration["DatabaseName"];
string account = Configuration["Endpoint"];
string key = Configuration["Key"];
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosService eventService = new CosmosService(client, databaseName, "events");
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync("events", "/id");
await database.Database.CreateContainerIfNotExistsAsync("tickets", "/id");
await database.Database.CreateContainerIfNotExistsAsync("categories", "/id");
return(eventService);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync()
{
string databaseName = "Car";
string containerName = "Models";
string containerNameWheels = "Wheels";
string account = "https://localhost:8081";
string key = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
//The 2nd parameter is the partion key [MWH]
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/VehicleModel");
await database.Database.CreateContainerIfNotExistsAsync(containerNameWheels, "/WheelDimensions/Width");
return(cosmosDbService);
}
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
var databaseName = configurationSection.GetSection("DatabaseName").Value;
var containerName = configurationSection.GetSection("ContainerName").Value;
var account = configurationSection.GetSection("Account").Value;
var key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
Database database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
public static async Task <IVehicleImageService> InitializeCosmosClientInstanceAsync(IConfigurationSection configSection)
{
var connectionString = configSection.GetSection("PrimaryConnectionString").Value;
var databaseName = configSection.GetSection("DatabaseName").Value;
var containerName = configSection.GetSection("ContainerName").Value;
var partitionKey = configSection.GetSection("PartitionKey").Value;
var rebuildContainer = (bool)configSection.GetValue(typeof(Boolean), "RebuildContainer", false);
var clientBuilder = new CosmosClientBuilder(connectionString);
CosmosClient client = clientBuilder.WithConnectionModeDirect().Build();
// Create database
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
// Recreate container
if (rebuildContainer)
{
try
{
var cn = client.GetContainer(databaseName, containerName);
await cn.DeleteContainerAsync();
}
catch (CosmosException ex) when(ex.StatusCode == System.Net.HttpStatusCode.NotFound)
{
// NOP
}
}
// Define the unique key as ImageId + VehicleId
await database.Database.DefineContainer(name : containerName, partitionKeyPath : partitionKey)
.WithUniqueKey()
.Path("/ImageId")
.Path("/VehicleId")
.Attach()
.CreateIfNotExistsAsync();
var container = client.GetContainer(databaseName, containerName);
return(new VehicleImageService(container));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <ICosmosDbService>(InitializeCosmosClientInstanceAsync(Configuration.GetSection("CosmosDb")).GetAwaiter().GetResult());
async Task <CosmosDBService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDBService cosmosDbService = new CosmosDBService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DDAC3Context")));
services.AddDefaultIdentity <IdentityUser>()
.AddEntityFrameworkStores <ApplicationDbContext>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddDbContext <DDAC3Context>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DDAC3Context")));
}
/// <summary>
/// Retrieves a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
private static CosmosDbService InitializeCosmosClientInstance(IConfiguration configuration)
{
var databaseName = configuration["DatabaseName"];
var containerName = configuration["ContainerName"];
var alertsContainerName = configuration["AlertsContainerName"];
var connectionString = configuration["CosmosDBConnection"];
var cosmosDbConnectionString = new CosmosDbConnectionString(connectionString);
// Define the container name collection. The first container name listed is the default container
// the Cosmos DB service class uses if no container name is provided within its methods.
var containerNames = new List <string> {
containerName, alertsContainerName
};
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(cosmosDbConnectionString.ServiceEndpoint.OriginalString, cosmosDbConnectionString.AuthKey);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerNames);
return(cosmosDbService);
}
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection, IConfiguration configuration)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
var containerNames = new List <string>();
configurationSection.GetSection("ContainerNames").Bind(containerNames);
string account = configurationSection.GetSection("Account").Value;
string key = configuration["CosmosDBKey"];
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerNames);
var database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
foreach (var containerName in containerNames)
{
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
}
return(cosmosDbService);
}
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
if (account.StartsWith("<"))
{
account = File.ReadAllText("C:\\apikeys\\sql-api-dotnet-application\\endpointurl.txt");
}
if (key.StartsWith("<"))
{
key = File.ReadAllText("C:\\apikeys\\sql-api-dotnet-application\\authorizationkey.txt");
}
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder.WithConnectionModeDirect().Build();
CosmosDbService cosmosDbService = new CosmosDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id"); return(cosmosDbService);
}
public ThreadStatsCosmosDbService(IOptions <CosmosDbOptions> options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (String.IsNullOrWhiteSpace(options.Value.EndpointUrl))
{
throw new ArgumentNullException(nameof(CosmosDbOptions.EndpointUrl));
}
if (String.IsNullOrWhiteSpace(options.Value.AuthorizationKey))
{
throw new ArgumentNullException(nameof(CosmosDbOptions.AuthorizationKey));
}
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(options.Value.EndpointUrl, options.Value.AuthorizationKey);
_cosmosClient = clientBuilder
.WithConnectionModeDirect()
.Build();
}
private ICosmosDbService InitializeCosmosClientInstanceAsync(IConfiguration configuration)
{
// string dbId = Environment.GetEnvironmentVariable("COSMOS_DB_NAME", EnvironmentVariableTarget.Process);
// string containerId = Environment.GetEnvironmentVariable("COSMOS_CONTAINER_NAME", EnvironmentVariableTarget.Process);
// string account = Environment.GetEnvironmentVariable("COSMOS_ACCOUNT", EnvironmentVariableTarget.Process);
// string key = Environment.GetEnvironmentVariable("COSMOS_PRIMARY_KEY", EnvironmentVariableTarget.Process);
string dbId = configuration["COSMOS_DB_NAME"];
string containerId = configuration["COSMOS_CONTAINER_NAME"];
string account = configuration["COSMOS_ACCOUNT"];
string key = configuration["COSMOS_PRIMARY_KEY"];
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
ICosmosDbService cosmosDbService = new CosmosDbService(client, dbId, containerId);
//DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
//await database.Database.CreateContainerIfNotExistsAsync(containerName, "/app");
return(cosmosDbService);
}
private static async Task <ChillerDbService> InitializeCosmosClientInstanceAsync(IConfigurationSection configurationSection)
{
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
var chillerDbService = new ChillerDbService(client, databaseName, containerName);
DatabaseResponse database = await client.CreateDatabaseIfNotExistsAsync(databaseName);
//await database.Database.CreateContainerIfNotExistsAsync(containerName, "/deviceId");
await database.Database.CreateContainerIfNotExistsAsync(new ContainerProperties
{
Id = containerName,
PartitionKeyPath = "/deviceId",
DefaultTimeToLive = 1 * 60 * 60 * 24 // 1 day
});
return(chillerDbService);
}
public void Configure(IWebJobsBuilder builder)
{
builder.Services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddFilter(level => true);
});
var config = (IConfiguration)builder.Services.First(d => d.ServiceType == typeof(IConfiguration)).ImplementationInstance;
builder.Services.AddPredictionEnginePool <TaxiTrip, TaxiTripFarePrediction>()
.FromUri(
modelName: "TaxiTripModel",
uri: config[Settings.MODEL_URL],
period: TimeSpan.FromMinutes(1));
builder.Services.AddSingleton((s) =>
{
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(config[Settings.COSMOS_DB_CONNECTION_STRING]);
return(cosmosClientBuilder.WithConnectionModeDirect()
.Build());
});
}
public bool InitializeCosmosClient()
{
bool result = false;
try
{
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(this._cosmosServiceName, this._cosmosServiceKey);
this._client = clientBuilder
.WithConnectionModeDirect()
.WithApplicationRegion(this._cosmosRegion)
.Build();
if (this._client != null)
{
this._employees = this._client.GetContainer(this._cosmosDatabaseName, _employeesContainerName);
result = true;
}
}
catch (Exception ex)
{
_logger.LogError("Exception while initializing the Cosmos DB Client : ", ex.Message);
}
return(result);
}
public override void Configure(IFunctionsHostBuilder builder)
{
builder.Services.AddLogging(loggingBuilder =>
{
loggingBuilder.AddFilter(level => true);
});
builder.Services.AddSingleton(s =>
{
CosmosClientBuilder builder = new CosmosClientBuilder(Environment.GetEnvironmentVariable("ConnectionStrings:CosmosDBConnectionString"));
var client = builder.WithConnectionModeDirect()
.WithBulkExecution(true)
.Build();
client.CreateDatabaseIfNotExistsAsync("ACMonitor").Wait();
var db = client.GetDatabase("ACMonitor");
db.CreateContainerIfNotExistsAsync(new ContainerProperties {
PartitionKeyPath = "/networkId", DefaultTimeToLive = 1200, Id = "Logs"
}).Wait();
return(client);
});
}
public static CosmosClient CreateMockCosmosClient(
bool useCustomSerializer = false,
bool?isClientTelemetryEnabled = null,
Action <CosmosClientBuilder> customizeClientBuilder = null)
{
MockDocumentClient documentClient = new MockDocumentClient();
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("http://localhost", Convert.ToBase64String(Guid.NewGuid().ToByteArray()));
cosmosClientBuilder.WithConnectionModeDirect();
customizeClientBuilder?.Invoke(cosmosClientBuilder);
if (useCustomSerializer)
{
cosmosClientBuilder.WithSerializerOptions(
new CosmosSerializationOptions()
{
IgnoreNullValues = true,
});
}
if (isClientTelemetryEnabled.HasValue && isClientTelemetryEnabled.Value)
{
cosmosClientBuilder.WithTelemetryEnabled();
}
documentClient.dummyHeaderNames = new string[100];
for (int i = 0; i < documentClient.dummyHeaderNames.Length; i++)
{
documentClient.dummyHeaderNames[i] = Guid.NewGuid().ToString();
}
documentClient.dummyHeaderNames[0] = HttpConstants.HttpHeaders.ActivityId;
documentClient.dummyHeaderNames[1] = HttpConstants.HttpHeaders.SessionToken;
documentClient.dummyHeaderNames[2] = HttpConstants.HttpHeaders.ConsistencyLevel;
documentClient.dummyHeaderNames[3] = HttpConstants.HttpHeaders.XDate;
return(cosmosClientBuilder.Build(documentClient));
}
public Region(string region, CosmosClientBuilder cosmosClientBuilder, string database, string container, string leasesContainer)
{
_region = region;
_client = cosmosClientBuilder
.WithConnectionModeDirect()
.WithApplicationRegion(region)
.WithConsistencyLevel(ConsistencyLevel.Eventual)
.Build();
NonBlockingConsole.WriteLine($"Connecting to {_client.Endpoint.AbsoluteUri} ({region})");
_container = _client.GetDatabase(database).GetContainer(container);
var leases = _client.GetContainer(database, leasesContainer);
_changeFeedProcessor = _client
.GetContainer(database, container)
.GetChangeFeedProcessorBuilder <Item>(_region, HandleChangesAsync)
.WithInstanceName(_region)
.WithLeaseContainer(leases)
.WithStartTime(DateTime.UtcNow)
.Build();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddOData();
services.AddControllers(mvcOptions =>
mvcOptions.EnableEndpointRouting = false);
IConfigurationSection configurationSection = Configuration.GetSection("CosmosDb");
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
DatabaseResponse database = client.CreateDatabaseIfNotExistsAsync(databaseName).GetAwaiter().GetResult();
database.Database.CreateContainerIfNotExistsAsync(containerName, "/entity").GetAwaiter().GetResult();
CosmosDBService <Journey> journeyService = new CosmosDBService <Journey>(client, databaseName, containerName);
services.AddSingleton <ICosmosDBService <Journey> >(journeyService);
CosmosDBService <Driver> driverService = new CosmosDBService <Driver>(client, databaseName, containerName);
services.AddSingleton <ICosmosDBService <Driver> >(driverService);
CosmosDBService <Location> locationService = new CosmosDBService <Location>(client, databaseName, containerName);
services.AddSingleton <ICosmosDBService <Location> >(locationService);
CosmosDBService <Vehicle> vehicleService = new CosmosDBService <Vehicle>(client, databaseName, containerName);
services.AddSingleton <ICosmosDBService <Vehicle> >(vehicleService);
services.AddControllers();
BaseDataService.GenerateBaseData(client, databaseName, containerName);
StartChangeFeedProcessorAsync(client, Configuration).GetAwaiter().GetResult();;
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//services.AddScoped<ICommandAPIRepo, SqlCommandAPIRepo>();
IConfigurationSection configurationSection = Configuration.GetSection("CosmosDB");
string databaseName = configurationSection.GetSection("DatabaseName").Value;
string containerName = configurationSection.GetSection("ContainerName").Value;
string account = configurationSection.GetSection("Account").Value;
string key = configurationSection.GetSection("Key").Value;
CosmosClientBuilder clientBuilder = new CosmosClientBuilder(account, key);
CosmosClient client = clientBuilder
.WithConnectionModeDirect()
.Build();
DatabaseResponse database = client.CreateDatabaseIfNotExistsAsync(databaseName).GetAwaiter().GetResult();
database.Database.CreateContainerIfNotExistsAsync(containerName, "/id").GetAwaiter().GetResult();
SqlCommandAPIRepo commandsService = new SqlCommandAPIRepo(client, databaseName, containerName);
services.AddSingleton <ICommandAPIRepo>(commandsService);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
//GremlinClient
GremlinServer gremlinServer = null;
GremlinClient gremlinClient = null;
try
{
gremlinServer = new GremlinServer(
"localhost", 8901, false, "/dbs/example-db/colls/main", "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
);
gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);
}
catch (Exception e)
{
//Log the error
}
services.AddSingleton <IGremlinClient>(gremlinClient);
//CosmosClient
string connectionString = "AccountEndpoint=https://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==";
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(connectionString);
var cosmosClient = cosmosClientBuilder.WithConnectionModeDirect().WithSerializerOptions(new CosmosSerializationOptions()
{
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase
}).Build();
services.AddSingleton <CosmosClient>(cosmosClient);
//Inject services
services.AddTransient <IBaseGremlinService, BaseGremlinService>();
}
public void VerifyCosmosConfigurationPropertiesGetUpdated()
{
string endpoint = AccountEndpoint;
string key = MockCosmosUtil.RandomInvalidCorrectlyFormatedAuthKey;
string region = Regions.WestCentralUS;
ConnectionMode connectionMode = ConnectionMode.Gateway;
TimeSpan requestTimeout = TimeSpan.FromDays(1);
int maxConnections = 9001;
string userAgentSuffix = "testSuffix";
RequestHandler preProcessHandler = new TestHandler();
ApiType apiType = ApiType.Sql;
int maxRetryAttemptsOnThrottledRequests = 9999;
TimeSpan maxRetryWaitTime = TimeSpan.FromHours(6);
bool enableTcpConnectionEndpointRediscovery = true;
CosmosSerializationOptions cosmosSerializerOptions = new CosmosSerializationOptions()
{
IgnoreNullValues = true,
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase,
};
TimeSpan idleTcpConnectionTimeout = new TimeSpan(0, 10, 0);
TimeSpan openTcpConnectionTimeout = new TimeSpan(0, 0, 5);
int maxRequestsPerTcpConnection = 30;
int maxTcpConnectionsPerEndpoint = 65535;
Cosmos.PortReuseMode portReuseMode = Cosmos.PortReuseMode.PrivatePortPool;
IWebProxy webProxy = new TestWebProxy();
Cosmos.ConsistencyLevel consistencyLevel = Cosmos.ConsistencyLevel.ConsistentPrefix;
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: endpoint,
authKeyOrResourceToken: key);
CosmosClient cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
CosmosClientOptions clientOptions = cosmosClient.ClientOptions;
Assert.AreEqual(endpoint, cosmosClient.Endpoint.OriginalString, "AccountEndpoint did not save correctly");
Assert.AreEqual(key, cosmosClient.AccountKey, "AccountKey did not save correctly");
//Verify the default values are different from the new values
Assert.AreNotEqual(region, clientOptions.ApplicationRegion);
Assert.IsNull(clientOptions.ApplicationPreferredRegions);
Assert.AreNotEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreNotEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreNotEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreNotEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreNotEqual(apiType, clientOptions.ApiType);
Assert.IsFalse(clientOptions.AllowBulkExecution);
Assert.AreEqual(0, clientOptions.CustomHandlers.Count);
Assert.IsNull(clientOptions.SerializerOptions);
Assert.IsNotNull(clientOptions.Serializer);
Assert.IsNull(clientOptions.WebProxy);
Assert.IsFalse(clientOptions.LimitToEndpoint);
Assert.IsTrue(clientOptions.EnableTcpConnectionEndpointRediscovery);
Assert.IsNull(clientOptions.HttpClientFactory);
Assert.AreNotEqual(consistencyLevel, clientOptions.ConsistencyLevel);
Assert.IsFalse(clientOptions.EnablePartitionLevelFailover);
//Verify GetConnectionPolicy returns the correct values for default
ConnectionPolicy policy = clientOptions.GetConnectionPolicy(clientId: 0);
Assert.AreEqual(ConnectionMode.Direct, policy.ConnectionMode);
Assert.AreEqual(Protocol.Tcp, policy.ConnectionProtocol);
Assert.AreEqual(clientOptions.GatewayModeMaxConnectionLimit, policy.MaxConnectionLimit);
Assert.AreEqual(clientOptions.RequestTimeout, policy.RequestTimeout);
Assert.IsNull(policy.IdleTcpConnectionTimeout);
Assert.IsNull(policy.OpenTcpConnectionTimeout);
Assert.IsNull(policy.MaxRequestsPerTcpConnection);
Assert.IsNull(policy.MaxTcpConnectionsPerEndpoint);
Assert.IsTrue(policy.EnableEndpointDiscovery);
Assert.IsTrue(policy.EnableTcpConnectionEndpointRediscovery);
Assert.IsNull(policy.HttpClientFactory);
Assert.AreNotEqual(Cosmos.ConsistencyLevel.Session, clientOptions.ConsistencyLevel);
Assert.IsFalse(policy.EnablePartitionLevelFailover);
cosmosClientBuilder.WithApplicationRegion(region)
.WithConnectionModeGateway(maxConnections, webProxy)
.WithRequestTimeout(requestTimeout)
.WithApplicationName(userAgentSuffix)
.AddCustomHandlers(preProcessHandler)
.WithApiType(apiType)
.WithThrottlingRetryOptions(maxRetryWaitTime, maxRetryAttemptsOnThrottledRequests)
.WithBulkExecution(true)
.WithSerializerOptions(cosmosSerializerOptions)
.WithConsistencyLevel(consistencyLevel)
.WithPartitionLevelFailoverEnabled();
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(region, clientOptions.ApplicationRegion);
Assert.IsNull(clientOptions.ApplicationPreferredRegions);
Assert.AreEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreEqual(preProcessHandler, clientOptions.CustomHandlers[0]);
Assert.AreEqual(apiType, clientOptions.ApiType);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, clientOptions.MaxRetryAttemptsOnRateLimitedRequests);
Assert.AreEqual(maxRetryWaitTime, clientOptions.MaxRetryWaitTimeOnRateLimitedRequests);
Assert.AreEqual(cosmosSerializerOptions.IgnoreNullValues, clientOptions.SerializerOptions.IgnoreNullValues);
Assert.AreEqual(cosmosSerializerOptions.PropertyNamingPolicy, clientOptions.SerializerOptions.PropertyNamingPolicy);
Assert.AreEqual(cosmosSerializerOptions.Indented, clientOptions.SerializerOptions.Indented);
Assert.IsTrue(object.ReferenceEquals(webProxy, clientOptions.WebProxy));
Assert.IsTrue(clientOptions.AllowBulkExecution);
Assert.AreEqual(consistencyLevel, clientOptions.ConsistencyLevel);
Assert.IsTrue(clientOptions.EnablePartitionLevelFailover);
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy(clientId: 0);
Assert.AreEqual(region, policy.PreferredLocations[0]);
Assert.AreEqual(ConnectionMode.Gateway, policy.ConnectionMode);
Assert.AreEqual(Protocol.Https, policy.ConnectionProtocol);
Assert.AreEqual(maxConnections, policy.MaxConnectionLimit);
Assert.AreEqual(requestTimeout, policy.RequestTimeout);
Assert.IsTrue(policy.UserAgentSuffix.Contains(userAgentSuffix));
Assert.IsTrue(policy.UseMultipleWriteLocations);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, policy.RetryOptions.MaxRetryAttemptsOnThrottledRequests);
Assert.AreEqual((int)maxRetryWaitTime.TotalSeconds, policy.RetryOptions.MaxRetryWaitTimeInSeconds);
Assert.AreEqual((Documents.ConsistencyLevel)consistencyLevel, clientOptions.GetDocumentsConsistencyLevel());
Assert.IsTrue(policy.EnablePartitionLevelFailover);
IReadOnlyList <string> preferredLocations = new List <string>()
{
Regions.AustraliaCentral, Regions.AustraliaCentral2
};
//Verify Direct Mode settings
cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: endpoint,
authKeyOrResourceToken: key);
cosmosClientBuilder.WithConnectionModeDirect(
idleTcpConnectionTimeout,
openTcpConnectionTimeout,
maxRequestsPerTcpConnection,
maxTcpConnectionsPerEndpoint,
portReuseMode,
enableTcpConnectionEndpointRediscovery)
.WithApplicationPreferredRegions(preferredLocations);
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(idleTcpConnectionTimeout, clientOptions.IdleTcpConnectionTimeout);
Assert.AreEqual(openTcpConnectionTimeout, clientOptions.OpenTcpConnectionTimeout);
Assert.AreEqual(maxRequestsPerTcpConnection, clientOptions.MaxRequestsPerTcpConnection);
Assert.AreEqual(maxTcpConnectionsPerEndpoint, clientOptions.MaxTcpConnectionsPerEndpoint);
Assert.AreEqual(portReuseMode, clientOptions.PortReuseMode);
Assert.IsTrue(clientOptions.EnableTcpConnectionEndpointRediscovery);
CollectionAssert.AreEqual(preferredLocations.ToArray(), clientOptions.ApplicationPreferredRegions.ToArray());
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy(clientId: 0);
Assert.AreEqual(idleTcpConnectionTimeout, policy.IdleTcpConnectionTimeout);
Assert.AreEqual(openTcpConnectionTimeout, policy.OpenTcpConnectionTimeout);
Assert.AreEqual(maxRequestsPerTcpConnection, policy.MaxRequestsPerTcpConnection);
Assert.AreEqual(maxTcpConnectionsPerEndpoint, policy.MaxTcpConnectionsPerEndpoint);
Assert.AreEqual(portReuseMode, policy.PortReuseMode);
Assert.IsTrue(policy.EnableTcpConnectionEndpointRediscovery);
CollectionAssert.AreEqual(preferredLocations.ToArray(), policy.PreferredLocations.ToArray());
}
public void VerifyCosmosConfigurationPropertiesGetUpdated()
{
string endpoint = AccountEndpoint;
string key = Guid.NewGuid().ToString();
string region = Regions.WestCentralUS;
ConnectionMode connectionMode = ConnectionMode.Gateway;
TimeSpan requestTimeout = TimeSpan.FromDays(1);
int maxConnections = 9001;
string userAgentSuffix = "testSuffix";
RequestHandler preProcessHandler = new TestHandler();
ApiType apiType = ApiType.Sql;
int maxRetryAttemptsOnThrottledRequests = 9999;
TimeSpan maxRetryWaitTime = TimeSpan.FromHours(6);
CosmosSerializationOptions cosmosSerializerOptions = new CosmosSerializationOptions()
{
IgnoreNullValues = true,
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase,
};
TimeSpan idleTcpConnectionTimeout = new TimeSpan(0, 10, 0);
TimeSpan openTcpConnectionTimeout = new TimeSpan(0, 0, 5);
int maxRequestsPerTcpConnection = 30;
int maxTcpConnectionsPerEndpoint = 65535;
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: endpoint,
accountKey: key);
CosmosClient cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
CosmosClientOptions clientOptions = cosmosClient.ClientOptions;
Assert.AreEqual(endpoint, cosmosClient.Endpoint.OriginalString, "AccountEndpoint did not save correctly");
Assert.AreEqual(key, cosmosClient.AccountKey, "AccountKey did not save correctly");
//Verify the default values are different from the new values
Assert.AreNotEqual(region, clientOptions.ApplicationRegion);
Assert.AreNotEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreNotEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreNotEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreNotEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreNotEqual(apiType, clientOptions.ApiType);
Assert.AreEqual(0, clientOptions.CustomHandlers.Count);
Assert.IsNull(clientOptions.SerializerOptions);
Assert.IsNull(clientOptions.Serializer);
//Verify GetConnectionPolicy returns the correct values for default
ConnectionPolicy policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(ConnectionMode.Direct, policy.ConnectionMode);
Assert.AreEqual(Protocol.Tcp, policy.ConnectionProtocol);
Assert.AreEqual(clientOptions.GatewayModeMaxConnectionLimit, policy.MaxConnectionLimit);
Assert.AreEqual(clientOptions.RequestTimeout, policy.RequestTimeout);
Assert.IsNull(policy.IdleTcpConnectionTimeout);
Assert.IsNull(policy.OpenTcpConnectionTimeout);
Assert.IsNull(policy.MaxRequestsPerTcpConnection);
Assert.IsNull(policy.MaxTcpConnectionsPerEndpoint);
cosmosClientBuilder.WithApplicationRegion(region)
.WithConnectionModeGateway(maxConnections)
.WithRequestTimeout(requestTimeout)
.WithApplicationName(userAgentSuffix)
.AddCustomHandlers(preProcessHandler)
.WithApiType(apiType)
.WithThrottlingRetryOptions(maxRetryWaitTime, maxRetryAttemptsOnThrottledRequests)
.WithSerializerOptions(cosmosSerializerOptions);
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(region, clientOptions.ApplicationRegion);
Assert.AreEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreEqual(preProcessHandler, clientOptions.CustomHandlers[0]);
Assert.AreEqual(apiType, clientOptions.ApiType);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, clientOptions.MaxRetryAttemptsOnRateLimitedRequests);
Assert.AreEqual(maxRetryWaitTime, clientOptions.MaxRetryWaitTimeOnRateLimitedRequests);
Assert.AreEqual(cosmosSerializerOptions.IgnoreNullValues, clientOptions.SerializerOptions.IgnoreNullValues);
Assert.AreEqual(cosmosSerializerOptions.PropertyNamingPolicy, clientOptions.SerializerOptions.PropertyNamingPolicy);
Assert.AreEqual(cosmosSerializerOptions.Indented, clientOptions.SerializerOptions.Indented);
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(region, policy.PreferredLocations[0]);
Assert.AreEqual(ConnectionMode.Gateway, policy.ConnectionMode);
Assert.AreEqual(Protocol.Https, policy.ConnectionProtocol);
Assert.AreEqual(maxConnections, policy.MaxConnectionLimit);
Assert.AreEqual(requestTimeout, policy.RequestTimeout);
Assert.IsTrue(policy.UserAgentSuffix.Contains(userAgentSuffix));
Assert.IsTrue(policy.UseMultipleWriteLocations);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, policy.RetryOptions.MaxRetryAttemptsOnThrottledRequests);
Assert.AreEqual((int)maxRetryWaitTime.TotalSeconds, policy.RetryOptions.MaxRetryWaitTimeInSeconds);
//Verify Direct Mode settings
cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: endpoint,
accountKey: key);
cosmosClientBuilder.WithConnectionModeDirect(
idleTcpConnectionTimeout,
openTcpConnectionTimeout,
maxRequestsPerTcpConnection,
maxTcpConnectionsPerEndpoint
);
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(idleTcpConnectionTimeout, clientOptions.IdleTcpConnectionTimeout);
Assert.AreEqual(openTcpConnectionTimeout, clientOptions.OpenTcpConnectionTimeout);
Assert.AreEqual(maxRequestsPerTcpConnection, clientOptions.MaxRequestsPerTcpConnection);
Assert.AreEqual(maxTcpConnectionsPerEndpoint, clientOptions.MaxTcpConnectionsPerEndpoint);
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(idleTcpConnectionTimeout, policy.IdleTcpConnectionTimeout);
Assert.AreEqual(openTcpConnectionTimeout, policy.OpenTcpConnectionTimeout);
Assert.AreEqual(maxRequestsPerTcpConnection, policy.MaxRequestsPerTcpConnection);
Assert.AreEqual(maxTcpConnectionsPerEndpoint, policy.MaxTcpConnectionsPerEndpoint);
}