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); }