예제 #1
0
        public void HttpClientFactoryBuildsConnectionPolicy()
        {
            string endpoint = AccountEndpoint;
            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
                accountEndpoint: endpoint,
                authKeyOrResourceToken: MockCosmosUtil.RandomInvalidCorrectlyFormatedAuthKey)
                                                      .WithHttpClientFactory(this.HttpClientFactoryDelegate);
            CosmosClient        cosmosClient  = cosmosClientBuilder.Build(new MockDocumentClient());
            CosmosClientOptions clientOptions = cosmosClient.ClientOptions;

            Assert.AreEqual(clientOptions.HttpClientFactory, this.HttpClientFactoryDelegate);
            ConnectionPolicy policy = clientOptions.GetConnectionPolicy(clientId: 0);

            Assert.AreEqual(policy.HttpClientFactory, this.HttpClientFactoryDelegate);
        }
예제 #2
0
        public override void Configure(IFunctionsHostBuilder builder)
        {
            var regionName = Environment.GetEnvironmentVariable(Constants.EnvironmentVariables.RegionName);

            if (string.IsNullOrWhiteSpace(regionName))
            {
                // Default to EastUS2 if the environment variable is missing/empty.
                regionName = Regions.EastUS2;
            }

            // Register the CosmosClient as a Singleton
            // Optimize for preferred geo-region
            builder.Services.AddSingleton((s) =>
            {
                CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(Configuration[Constants.CosmosDb.Connection])
                                                           .WithApplicationRegion(regionName);

                return(configurationBuilder.Build());
            });

            // Load configuration from Azure App Configuration
            ConfigurationBuilder.AddAzureAppConfiguration(options =>
            {
                // Use ".Connect(...)" for connection string, or use ".ConnectWithManagedIdentity(...) for managed identity"
                options.Connect(Environment.GetEnvironmentVariable("AzureAppConfigConnectionString"))
                // Load all keys that start with `EnterpriseServerless:`
                .Select("EnterpriseServerless:*")
                // Configure to reload configuration if the registered 'Sentinel' key is modified
                .ConfigureRefresh(refreshOptions =>
                                  refreshOptions.Register(key: "EnterpriseServerless:Sentinel", label: LabelFilter.Null, refreshAll: true)
                                  .SetCacheExpiration(TimeSpan.FromSeconds(30))
                                  )
                // Indicate to load feature flags
                .UseFeatureFlags();
                ConfigurationRefresher = options.GetRefresher();
            });
            Configuration = ConfigurationBuilder.Build();

            builder.Services.AddLogging();
            builder.Services.AddSingleton(Configuration);
            builder.Services.AddSingleton(ConfigurationRefresher);
            builder.Services.AddFeatureManagement(Configuration);

            builder.Services.AddSingleton <IStartCallService, StartCallService>();
            builder.Services.AddSingleton <ICallLoggingService, CallLoggingService>();
            builder.Services.AddSingleton <IMediaFileService, MediaFileService>();
            builder.Services.AddSingleton <IPostCallService, PostCallService>();
        }
예제 #3
0
        public static CosmosClient CreateMockCosmosClient(
            Action <CosmosClientBuilder> customizeClientBuilder = null,
            Cosmos.ConsistencyLevel?accountConsistencyLevel     = null,
            bool enableTelemetry = false)
        {
            DocumentClient      documentClient      = accountConsistencyLevel.HasValue ? new MockDocumentClient(accountConsistencyLevel.Value) : new MockDocumentClient();
            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("http://localhost", MockCosmosUtil.RandomInvalidCorrectlyFormatedAuthKey);

            customizeClientBuilder?.Invoke(cosmosClientBuilder);
            if (enableTelemetry)
            {
                cosmosClientBuilder.WithTelemetryEnabled();
            }

            return(cosmosClientBuilder.Build(documentClient));
        }
        public void HttpClientFactoryBuildsConnectionPolicy()
        {
            string endpoint = AccountEndpoint;
            string key      = Guid.NewGuid().ToString();
            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
                accountEndpoint: endpoint,
                authKeyOrResourceToken: key)
                                                      .WithHttpClientFactory(this.HttpClientFactoryDelegate);
            CosmosClient        cosmosClient  = cosmosClientBuilder.Build(new MockDocumentClient());
            CosmosClientOptions clientOptions = cosmosClient.ClientOptions;

            Assert.AreEqual(clientOptions.HttpClientFactory, this.HttpClientFactoryDelegate);
            ConnectionPolicy policy = clientOptions.GetConnectionPolicy();

            Assert.AreEqual(policy.HttpClientFactory, this.HttpClientFactoryDelegate);
        }
예제 #5
0
        public override void Configure(IFunctionsHostBuilder builder)
        {
            // Register the Cosmos DB client as a Singleton.
            builder.Services.AddSingleton((s) => {
                var connectionString         = configuration["CosmosDBConnection"];
                var cosmosDbConnectionString = new CosmosDbConnectionString(connectionString);

                if (string.IsNullOrEmpty(connectionString))
                {
                    throw new ArgumentNullException("Please specify a value for CosmosDBConnection in the local.settings.json file or your Azure Functions Settings.");
                }

                CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(cosmosDbConnectionString.ServiceEndpoint.OriginalString, cosmosDbConnectionString.AuthKey).WithBulkExecution(true);
                return(configurationBuilder
                       .Build());
            });
        }
예제 #6
0
        public async Task ReadManyExceptionsTest(HttpStatusCode statusCode)
        {
            RequestHandler[] requestHandlers = new RequestHandler[1];
            requestHandlers[0] = new CustomHandler(statusCode);

            CosmosClientBuilder builder = TestCommon.GetDefaultConfiguration();

            builder.AddCustomHandlers(requestHandlers);
            CosmosClient client   = builder.Build();
            Database     database = await client.CreateDatabaseAsync(Guid.NewGuid().ToString());

            Container container = await database.CreateContainerAsync(Guid.NewGuid().ToString(), "/pk");

            for (int i = 0; i < 5; i++)
            {
                await container.CreateItemAsync(
                    ToDoActivity.CreateRandomToDoActivity("pk" + i, i.ToString()));
            }

            List <(string, PartitionKey)> itemList = new List <(string, PartitionKey)>();

            for (int i = 0; i < 5; i++)
            {
                itemList.Add(("IncorrectId" + i, new PartitionKey("pk" + i))); // wrong ids
            }

            using (ResponseMessage responseMessage = await container.ReadManyItemsStreamAsync(itemList))
            {
                Assert.AreEqual(responseMessage.StatusCode, statusCode);
            }

            try
            {
                await container.ReadManyItemsAsync <ToDoActivity>(itemList);

                Assert.Fail("Typed API should throw");
            }
            catch (CosmosException ex)
            {
                Assert.AreEqual(ex.StatusCode, statusCode);
            }

            await database.DeleteAsync();

            client.Dispose();
        }
예제 #7
0
        public CosmosClient CreateClient(
            string connectionString,
            string currentRegion = null)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                throw new ArgumentNullException(nameof(connectionString));
            }

            CosmosClientBuilder clientBuilder = new CosmosClientBuilder(connectionString);

            if (!string.IsNullOrEmpty(currentRegion))
            {
                clientBuilder.WithApplicationRegion(currentRegion);
            }

            return(clientBuilder.Build());
        }
        public static IServiceCollection AddCosmosDbMovieService(this IServiceCollection services)
        {
            if (services == null)
            {
                throw new ArgumentNullException(nameof(services));
            }

            ICosmosDbMovieService Factory(IServiceProvider sp)
            {
                var logger         = sp.GetService <ILogger <CosmosDbMovieService> >();
                var options        = sp.GetService <IOptions <CosmosDbClientSettings> >();
                var cosmosSettings = options.Value;

                if (string.IsNullOrEmpty(cosmosSettings.EndPointUrl))
                {
                    throw new ArgumentException("Please specify a valid endpoint in the appSettings.json file or your Azure Functions Settings.");
                }

                if (string.IsNullOrEmpty(cosmosSettings.AuthorizationKey))
                {
                    throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json file or your Azure Functions Settings.");
                }

                var clientBuilder        = new CosmosClientBuilder(cosmosSettings.EndPointUrl, cosmosSettings.AuthorizationKey);
                var client               = clientBuilder.Build();
                var cosmosDbMovieService = new CosmosDbMovieService(logger, client, cosmosSettings.DatabaseName, cosmosSettings.ContainerName);

                async void Handler(object sender, EventArgs args)
                {
                    InitializeDatabase -= Handler;
                    var databaseResponse = await client.CreateDatabaseIfNotExistsAsync(cosmosSettings.DatabaseName);

                    await databaseResponse.Database.CreateContainerIfNotExistsAsync(cosmosSettings.ContainerName, "/MovieId");
                }

                InitializeDatabase += Handler;
                InitializeDatabase(null, EventArgs.Empty); // raise event to initialize

                return(cosmosDbMovieService);
            }

            services.AddSingleton(Factory);
            return(services);
        }
예제 #9
0
        public override void Configure(IFunctionsHostBuilder builder)
        {
            // Add a new HttpClientFactory that can be injected into the functions.
            // We add resilience and transient fault-handling capabilities to the HttpClient instances that the factory creates
            // by adding a Polly Retry policy with a very brief back-off starting at quarter-of-a-second to two seconds.
            // We want the HTTP requests that are sent to the downstream Logic App service to wait before attempting to try
            // sending the message, giving it some "breathing room" in case the service is overwhelmed. We chose to make
            // the time between retries relatively brief so as not to disrupt Cosmos DB message processing for too long, but
            // enough time to hopefully allow the downstream service to recover.
            // See the following for more information:
            // https://docs.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/implement-http-call-retries-exponential-backoff-polly
            builder.Services.AddHttpClient(NamedHttpClients.LogicAppClient, client =>
            {
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            })
            .AddTransientHttpErrorPolicy(policyBuilder => policyBuilder.WaitAndRetryAsync(new[]
            {
                TimeSpan.FromMilliseconds(250),
                TimeSpan.FromMilliseconds(500),
                TimeSpan.FromMilliseconds(1000),
                TimeSpan.FromMilliseconds(2000)
            }));

            // Register the Cosmos DB client as a Singleton.
            builder.Services.AddSingleton((s) => {
                var connectionString         = configuration["CosmosDBConnection"];
                var cosmosDbConnectionString = new CosmosDbConnectionString(connectionString);

                if (string.IsNullOrEmpty(connectionString))
                {
                    throw new ArgumentNullException("Please specify a value for CosmosDBConnection in the local.settings.json file or your Azure Functions Settings.");
                }

                CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(cosmosDbConnectionString.ServiceEndpoint.OriginalString, cosmosDbConnectionString.AuthKey);
                return(configurationBuilder
                       .Build());
            });

            // Create Azure Storage queue client reference and create any queues that do not yet exist, through the
            // CreateKnownAzureQueues method.
            builder.Services.Configure <AzureStorageSettings>(configuration);
            StorageQueuesHelper.CreateKnownAzureQueues(configuration["ColdStorageAccount"]);
            builder.Services.AddTransient <IQueueResolver, QueueResolver>();
        }
예제 #10
0
        private static Lazy <CosmosClient> SetupClient(ICosmosContainerOptions options)
        {
            var csb      = ValidatInput(options.ConnectionString, options.DatabaseId, options.ContainerId);
            var cacheKey = $"{options.DatabaseId}_{options.UseGatewayMode}_{ToSHA256(csb.Key)}";

            return(new Lazy <CosmosClient>(() =>
            {
                CosmosClient client = null;
                bool fromCache = false;
                if (_clientCache.ContainsKey(cacheKey))
                {
                    client = _clientCache[cacheKey];
                    if (client != null)
                    {
                        fromCache = true;
                    }
                }

                if (!fromCache)
                {
                    var builder = new CosmosClientBuilder(options.ConnectionString);
                    builder
                    .WithThrottlingRetryOptions(TimeSpan.FromSeconds(30), 10);

                    if (options.UseGatewayMode)
                    {
                        builder.WithConnectionModeGateway(options.ConcurrentConnections);
                    }

                    foreach (var region in options.AzureRegions ?? new List <string>())
                    {
                        builder.WithApplicationRegion(region);
                    }
                    client = builder.Build();

                    _clientCache[cacheKey] = client;
                }

                CreateDatabaseIfNotExistsAsync(client, options).GetAwaiter().GetResult();
                return client;
            }));
        }
        public async Task QueryActivityIdTests()
        {
            RequestHandler[] requestHandlers = new RequestHandler[1];
            requestHandlers[0] = new CustomHandler();

            CosmosClientBuilder builder = TestCommon.GetDefaultConfiguration();

            builder.AddCustomHandlers(requestHandlers);

            CosmosClient cosmosClient = builder.Build();
            Database     database     = await cosmosClient.CreateDatabaseAsync(Guid.NewGuid().ToString());

            Container container = await database.CreateContainerAsync(Guid.NewGuid().ToString(),
                                                                      "/pk",
                                                                      throughput : 12000);

            // Create items
            for (int i = 0; i < 500; i++)
            {
                await container.CreateItemAsync <ToDoActivity>(ToDoActivity.CreateRandomToDoActivity());
            }

            QueryRequestOptions queryRequestOptions = new QueryRequestOptions
            {
                MaxItemCount = 50
            };

            FeedIterator <ToDoActivity> feedIterator = container.GetItemQueryIterator <ToDoActivity>(
                "select * from c",
                null,
                queryRequestOptions);

            while (feedIterator.HasMoreResults)
            {
                await feedIterator.ReadNextAsync();
            }

            await database.DeleteAsync();

            cosmosClient.Dispose();
        }
        public void VerifyHttpClientHandlerIsSet()
        {
            string endpoint = AccountEndpoint;
            string key      = "425Mcv8CXQqzRNCgFNjIhT424GK99CKJvASowTnq15Vt8LeahXTcN5wt3342vQ==";

            IWebProxy webProxy = new TestWebProxy();

            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
                accountEndpoint: endpoint,
                authKeyOrResourceToken: key);

            cosmosClientBuilder.WithConnectionModeGateway(
                maxConnectionLimit: null,
                webProxy: webProxy);

            CosmosClient      cosmosClient     = cosmosClientBuilder.Build();
            CosmosHttpClient  cosmosHttpClient = cosmosClient.DocumentClient.httpClient;
            HttpClientHandler handler          = (HttpClientHandler)cosmosHttpClient.HttpMessageHandler;

            Assert.IsTrue(object.ReferenceEquals(webProxy, handler.Proxy));
        }
예제 #13
0
        public static IServiceCollection AddDataAccessDependencies(this IServiceCollection serviceCollection, IConfiguration configuration)
        {
            _ = configuration ?? throw new ArgumentNullException(nameof(configuration));

            serviceCollection.Configure <CosmosConfiguration>(cc => configuration.Bind("CosmosConfiguration", cc));
            serviceCollection.AddSingleton <IAzureServiceTokenProviderWrapper, AzureServiceTokenProviderWrapper>();
            serviceCollection.AddSingleton((sp) =>
            {
                var options             = sp.GetRequiredService <IOptions <CosmosConfiguration> >();
                var cosmosConfiguration = options.Value;

                var cosmosClientBuilder = new CosmosClientBuilder(cosmosConfiguration.EndpointLocation, cosmosConfiguration.PrimaryKey);
                return(cosmosClientBuilder
                       .Build());
            });

            serviceCollection.AddSingleton(typeof(ICosmosClientWrapper <>), typeof(CosmosClientWrapper <>));
            serviceCollection.AddSingleton(typeof(IDataRepository <>), typeof(DataRepository <>));

            return(serviceCollection);
        }
예제 #14
0
        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));
        }
        public static CosmosClient CreateMockCosmosClient(
            Action <CosmosClientBuilder> customizeClientBuilder = null,
            Cosmos.ConsistencyLevel?accountConsistencyLevel     = null)
        {
            DocumentClient documentClient;

            if (accountConsistencyLevel.HasValue)
            {
                documentClient = new MockDocumentClient(accountConsistencyLevel.Value);
            }
            else
            {
                documentClient = new MockDocumentClient();
            }

            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("http://localhost", MockCosmosUtil.RandomInvalidCorrectlyFormatedAuthKey);

            customizeClientBuilder?.Invoke(cosmosClientBuilder);

            return(cosmosClientBuilder.Build(documentClient));
        }
        /// <summary>
        ///     Protected Constructor
        /// </summary>
        /// <param name="settings"></param>
        /// <param name="connectionPolicy"></param>
        /// <param name="logger"></param>
        protected CosmosDbContextBase(
            IOptions <CosmosDbConfiguration> settings,
            ConnectionPolicy connectionPolicy = null,
            ILogger logger = null)
        {
            Guard.ForNullOrDefault(settings.Value, nameof(settings));
            Guard.ForNullOrDefault(settings.Value.EndPointUrl, nameof(settings.Value.EndPointUrl));
            Guard.ForNullOrDefault(settings.Value.PrimaryKey, nameof(settings.Value.PrimaryKey));
            _logger       = logger;
            Configuration = settings.Value;

            var serviceEndPoint = new Uri(settings.Value.EndPointUrl);

            if (Configuration.DangerousAcceptAnyServerCertificateValidator)
            {
                CosmosClientOptions cosmosClientOptions = new CosmosClientOptions()
                {
                    HttpClientFactory = () =>
                    {
                        HttpMessageHandler httpMessageHandler = new HttpClientHandler()
                        {
                            ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
                        };

                        return(new HttpClient(httpMessageHandler));
                    },
                    ConnectionMode = Microsoft.Azure.Cosmos.ConnectionMode.Gateway
                };
                CosmosClient = new CosmosClient(serviceEndPoint.AbsoluteUri, settings.Value.PrimaryKey, cosmosClientOptions);
            }
            else
            {
                CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(serviceEndPoint.AbsoluteUri, settings.Value.PrimaryKey);
                CosmosClient = configurationBuilder.Build();
            }

            //         DocumentClient = new DocumentClient(serviceEndPoint, settings.Value.PrimaryKey,connectionPolicy ?? ConnectionPolicy.Default);

//            EnsureDatabaseCreated(Configuration.DatabaseName).Wait();
        }
예제 #17
0
        public override void Configure(IFunctionsHostBuilder builder)
        {
            // Register the CosmosClient as a Singleton

            builder.Services.AddSingleton((s) => {
                string endpoint = configuration["EndPointUrl"];
                if (string.IsNullOrEmpty(endpoint))
                {
                    throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json file or your Azure Functions Settings.");
                }

                string authKey = configuration["AuthorizationKey"];
                if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
                {
                    throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json file or your Azure Functions Settings.");
                }

                CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(endpoint, authKey);
                return(configurationBuilder
                       .Build());
            });
        }
        /// <summary>
        ///     Protected Constructor
        /// </summary>
        /// <param name="settings"></param>
        /// <param name="connectionPolicy"></param>
        /// <param name="logger"></param>
        protected CosmosDbContextBase(
            IOptions <CosmosDbConfiguration <T> > settings,
            ConnectionPolicy connectionPolicy = null,
            ILogger logger = null)
        {
            Guard.ForNullOrDefault(settings.Value, nameof(settings));
            Guard.ForNullOrDefault(settings.Value.EndPointUrl, nameof(settings.Value.EndPointUrl));
            Guard.ForNullOrDefault(settings.Value.PrimaryKey, nameof(settings.Value.PrimaryKey));
            Guard.ForNullOrDefault(settings.Value.DatabaseName, nameof(settings.Value.EndPointUrl));
            Logger        = logger;
            Configuration = settings.Value;

            var serviceEndPoint = new Uri(settings.Value.EndPointUrl);

            CosmosClientBuilder configurationBuilder = new CosmosClientBuilder(serviceEndPoint.AbsoluteUri, settings.Value.PrimaryKey);

            CosmosClient   = configurationBuilder.Build();
            DocumentClient = new DocumentClient(serviceEndPoint, settings.Value.PrimaryKey,
                                                connectionPolicy ?? ConnectionPolicy.Default);

            EnsureDatabaseCreated(Configuration.DatabaseName).Wait();
        }
        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));
        }
        /// <inheritdoc />
        public CosmosClient CreateCosmosClient(CosmosDataStoreConfiguration configuration)
        {
            EnsureArg.IsNotNull(configuration, nameof(configuration));

            var host = configuration.Host;
            var key  = configuration.Key;

            if (string.IsNullOrWhiteSpace(host) && string.IsNullOrWhiteSpace(key))
            {
                _logger.LogWarning("No connection string provided, attempting to connect to local emulator.");

                host = CosmosDbLocalEmulator.Host;
                key  = CosmosDbLocalEmulator.Key;
            }

            _logger.LogInformation("Creating CosmosClient instance for {DatabaseId}, Host: {Host}", configuration.DatabaseId, host);

            IEnumerable <RequestHandler> requestHandlers = _requestHandlerFactory.Invoke();

            var builder = new CosmosClientBuilder(host, key)
                          .WithConnectionModeDirect(enableTcpConnectionEndpointRediscovery: true)
                          .WithCustomSerializer(new FhirCosmosSerializer())
                          .WithThrottlingRetryOptions(TimeSpan.FromSeconds(configuration.RetryOptions.MaxWaitTimeInSeconds), configuration.RetryOptions.MaxNumberOfRetries)
                          .AddCustomHandlers(requestHandlers.ToArray());

            if (configuration.PreferredLocations?.Any() == true)
            {
                builder.WithApplicationPreferredRegions(configuration.PreferredLocations?.ToArray());
            }

            if (configuration.DefaultConsistencyLevel != null)
            {
                builder.WithConsistencyLevel(configuration.DefaultConsistencyLevel.Value);
            }

            return(builder.Build());
        }
        private static CosmosClient CreateCosmosClient(string connectionString, CosmosOptions cosmosOptions)
        {
            GuardEmptyString(connectionString, "cosmosDbConnectionString");
            cosmosOptions.Guard();

            var builder = new CosmosClientBuilder(connectionString);

            // ConnectionPolicy のDefault値は、SDKのConnectionPolicy.csで設定されています。

            // ## Connection Mode について
            // Default で ConnectionMode.Direct/Protocol.Tcp で接続されます。
            // もしGateway(ConnectionMode.Gateway/Protocol.Https) を使いたければ、以下メソッドを呼ぶ
            // builder.UseConnectionModeGateway(maxConnectionLimit: ??);

            // Default: CamelCase Serialize/Deserialize and ignore Readonly property
            // TODO: 設定変更用のconfigは未実装
            //var settings = JsonSerializerSettingsFactory.CreateForReadonlyIgnoreAndCamelCase();
            var settings = JsonSerializerSettingsFactory.CreateForCamelCase();

            builder.WithCustomSerializer(new CustomizableCaseJsonSerializer(settings));

            if (cosmosOptions.ThrottlingRetryOptions != null)
            {
                builder.WithThrottlingRetryOptions(
                    cosmosOptions.ThrottlingRetryOptions.MaxRetryWaitTimeOnThrottledRequests,
                    cosmosOptions.ThrottlingRetryOptions.MaxRetryAttemptsOnThrottledRequests);
            }

            // multi-master support
            if (!string.IsNullOrEmpty(cosmosOptions.CurrentRegion))
            {
                builder.WithApplicationRegion(cosmosOptions.CurrentRegion);
            }

            return(builder.Build());
        }
        public static CosmosClient CreateMockCosmosClient(
            Action <CosmosClientBuilder> customizeClientBuilder = null,
            Cosmos.ConsistencyLevel?accountConsistencyLevel     = null)
        {
            DocumentClient documentClient;

            if (accountConsistencyLevel.HasValue)
            {
                documentClient = new MockDocumentClient(accountConsistencyLevel.Value);
            }
            else
            {
                documentClient = new MockDocumentClient();
            }

            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder("http://localhost", Guid.NewGuid().ToString());

            if (customizeClientBuilder != null)
            {
                customizeClientBuilder(cosmosClientBuilder);
            }

            return(cosmosClientBuilder.Build(documentClient));
        }
        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            = CosmosRegions.WestCentralUS;
            ConnectionMode       connectionMode    = ConnectionMode.Gateway;
            TimeSpan             requestTimeout    = TimeSpan.FromDays(1);
            int                  maxConnections    = 9001;
            string               userAgentSuffix   = "testSuffix";
            CosmosRequestHandler preProcessHandler = new TestHandler();
            ApiType              apiType           = ApiType.Sql;
            int                  maxRetryAttemptsOnThrottledRequests = 9999;
            TimeSpan             maxRetryWaitTime = TimeSpan.FromHours(6);

            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
                accountEndPoint: endpoint,
                accountKey: key);

            CosmosClient cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
            CosmosClientConfiguration configuration = cosmosClient.Configuration;

            Assert.AreEqual(endpoint, configuration.AccountEndPoint.OriginalString, "AccountEndPoint did not save correctly");
            Assert.AreEqual(key, configuration.AccountKey, "AccountKey did not save correctly");

            //Verify the default values are different from the new values
            Assert.AreNotEqual(region, configuration.CurrentRegion);
            Assert.AreNotEqual(connectionMode, configuration.ConnectionMode);
            Assert.AreNotEqual(maxConnections, configuration.MaxConnectionLimit);
            Assert.AreNotEqual(requestTimeout, configuration.RequestTimeout);
            Assert.AreNotEqual(userAgentSuffix, configuration.UserAgentSuffix);
            Assert.AreNotEqual(apiType, configuration.ApiType);
            Assert.IsNull(configuration.CustomHandlers);

            //Verify GetConnectionPolicy returns the correct values for default
            ConnectionPolicy policy = configuration.GetConnectionPolicy();

            Assert.AreEqual(ConnectionMode.Direct, policy.ConnectionMode);
            Assert.AreEqual(Protocol.Tcp, policy.ConnectionProtocol);
            Assert.AreEqual(configuration.MaxConnectionLimit, policy.MaxConnectionLimit);
            Assert.AreEqual(configuration.RequestTimeout, policy.RequestTimeout);

            cosmosClientBuilder.UseCurrentRegion(region)
            .UseConnectionModeGateway(maxConnections)
            .UseRequestTimeout(requestTimeout)
            .UseUserAgentSuffix(userAgentSuffix)
            .AddCustomHandlers(preProcessHandler)
            .UseApiType(apiType)
            .UseThrottlingRetryOptions(maxRetryWaitTime, maxRetryAttemptsOnThrottledRequests);

            cosmosClient  = cosmosClientBuilder.Build(new MockDocumentClient());
            configuration = cosmosClient.Configuration;

            //Verify all the values are updated
            Assert.AreEqual(region, configuration.CurrentRegion);
            Assert.AreEqual(connectionMode, configuration.ConnectionMode);
            Assert.AreEqual(maxConnections, configuration.MaxConnectionLimit);
            Assert.AreEqual(requestTimeout, configuration.RequestTimeout);
            Assert.AreEqual(userAgentSuffix, configuration.UserAgentSuffix);
            Assert.AreEqual(preProcessHandler, configuration.CustomHandlers[0]);
            Assert.AreEqual(apiType, configuration.ApiType);
            Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, configuration.MaxRetryAttemptsOnThrottledRequests);
            Assert.AreEqual(maxRetryWaitTime, configuration.MaxRetryWaitTimeOnThrottledRequests);

            //Verify GetConnectionPolicy returns the correct values
            policy = configuration.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.AreEqual(userAgentSuffix, policy.UserAgentSuffix);
            Assert.IsTrue(policy.UseMultipleWriteLocations);
            Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, policy.RetryOptions.MaxRetryAttemptsOnThrottledRequests);
            Assert.AreEqual((int)maxRetryWaitTime.TotalSeconds, policy.RetryOptions.MaxRetryWaitTimeInSeconds);
        }
        // Async main requires c# 7.1 which is set in the csproj with the LangVersion attribute
        // <Main>
        public static async Task Main(string[] args)
        {
            IConfigurationRoot configuration = new ConfigurationBuilder()
                                               .AddJsonFile("appSettings.json")
                                               .Build();

            string endpoint = configuration["EndPointUrl"];

            if (string.IsNullOrEmpty(endpoint))
            {
                throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
            }

            string authKey = configuration["AuthorizationKey"];

            if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
            {
                throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json");
            }

            // Connecting to Emulator. Change if you want a live account
            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(endpoint, authKey);

            cosmosClientBuilder.AddCustomHandlers(
                new LoggingHandler(),
                new ConcurrencyHandler(),
                new ThrottlingHandler()
                );

            CosmosClient client = cosmosClientBuilder.Build();

            DatabaseResponse databaseResponse = await client.CreateDatabaseIfNotExistsAsync("mydb");

            Database database = databaseResponse.Database;

            ContainerResponse containerResponse = await database.CreateContainerIfNotExistsAsync("mycoll", "/id");

            Container container = containerResponse.Container;

            Item item = new Item()
            {
                Id          = Guid.NewGuid().ToString(),
                Name        = "Test Item",
                Description = "Some random test item",
                Completed   = false
            };

            // Create
            await container.CreateItemAsync <Item>(item, new PartitionKey(item.Id));

            item.Completed = true;

            // Replace
            await container.ReplaceItemAsync <Item>(item, item.Id, new PartitionKey(item.Id));

            // Querying
            FeedIterator <Item> query = container.GetItemQueryIterator <Item>(new QueryDefinition("SELECT * FROM c"), requestOptions: new QueryRequestOptions()
            {
                MaxConcurrency = 1
            });
            List <Item> results = new List <Item>();

            while (query.HasMoreResults)
            {
                FeedResponse <Item> response = await query.ReadNextAsync();

                results.AddRange(response.ToList());
            }

            // Read Item

            ItemResponse <Item> cosmosItemResponse = await container.ReadItemAsync <Item>(item.Id, new PartitionKey(item.Id));

            ItemRequestOptions itemRequestOptions = new ItemRequestOptions()
            {
                IfMatchEtag = cosmosItemResponse.ETag
            };

            // Concurrency

            List <Task <ItemResponse <Item> > > tasks = new List <Task <ItemResponse <Item> > >
            {
                UpdateItemForConcurrency(container, itemRequestOptions, item),
                UpdateItemForConcurrency(container, itemRequestOptions, item)
            };

            try
            {
                await Task.WhenAll(tasks);
            }
            catch (CosmosException ex)
            {
                // Verify that our custom handler caught the scenario
                Debug.Assert(999.Equals(ex.SubStatusCode));
            }

            // Delete
            await container.DeleteItemAsync <Item>(item.Id, new PartitionKey(item.Id));
        }
예제 #26
0
        // Async main requires c# 7.1 which is set in the csproj with the LangVersion attribute
        // <Main>
        public static async Task Main(string[] args)
        {
            IConfigurationRoot configuration = new ConfigurationBuilder()
                                               .AddJsonFile("appSettings.json")
                                               .Build();

            string endpoint = configuration["EndPointUrl"];

            if (string.IsNullOrEmpty(endpoint))
            {
                throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
            }

            string authKey = configuration["AuthorizationKey"];

            if (string.IsNullOrEmpty(authKey) || string.Equals(authKey, "Super secret key"))
            {
                throw new ArgumentException("Please specify a valid AuthorizationKey in the appSettings.json");
            }

            // Connecting to Emulator. Change if you want a live account
            CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(endpoint, authKey);

            // Declare a JSON schema to use with the schema validation handler
            var myContainerSchema = JSchema.Parse(@"{
  'type': 'object',
  'properties': {
    'name': {'type': 'string'}
  },
  'required': ['name']
}");

            cosmosClientBuilder.AddCustomHandlers(
                new LoggingHandler(),
                new ConcurrencyHandler(),
                new ThrottlingHandler(),
                new SchemaValidationHandler((database: "mydb", container: "mycoll2", schema: myContainerSchema))
                );

            CosmosClient client = cosmosClientBuilder.Build();

            DatabaseResponse databaseResponse = await client.CreateDatabaseIfNotExistsAsync("mydb");

            Database database = databaseResponse.Database;

            ContainerResponse containerResponse = await database.CreateContainerIfNotExistsAsync("mycoll", "/id");

            Container container = containerResponse.Container;

            Item item = new Item()
            {
                Id          = Guid.NewGuid().ToString(),
                Name        = "Test Item",
                Description = "Some random test item",
                Completed   = false
            };

            // Create
            await container.CreateItemAsync <Item>(item, new PartitionKey(item.Id));

            item.Completed = true;

            // Replace
            await container.ReplaceItemAsync <Item>(item, item.Id, new PartitionKey(item.Id));

            // Querying
            List <Item> results = new List <Item>();

            using (FeedIterator <Item> query = container.GetItemQueryIterator <Item>(new QueryDefinition("SELECT * FROM c"), requestOptions: new QueryRequestOptions()
            {
                MaxConcurrency = 1
            }))
            {
                while (query.HasMoreResults)
                {
                    FeedResponse <Item> response = await query.ReadNextAsync();

                    results.AddRange(response.ToList());
                }
            }

            // Read Item

            ItemResponse <Item> cosmosItemResponse = await container.ReadItemAsync <Item>(item.Id, new PartitionKey(item.Id));

            ItemRequestOptions itemRequestOptions = new ItemRequestOptions()
            {
                IfMatchEtag = cosmosItemResponse.ETag
            };

            // Concurrency

            List <Task <ItemResponse <Item> > > tasks = new List <Task <ItemResponse <Item> > >
            {
                UpdateItemForConcurrency(container, itemRequestOptions, item),
                UpdateItemForConcurrency(container, itemRequestOptions, item)
            };

            try
            {
                await Task.WhenAll(tasks);
            }
            catch (CosmosException ex)
            {
                // Verify that our custom handler caught the scenario
                Debug.Assert(999.Equals(ex.SubStatusCode));
            }

            // Delete
            await container.DeleteItemAsync <Item>(item.Id, new PartitionKey(item.Id));

            // Schema validation

            containerResponse = await database.CreateContainerIfNotExistsAsync("mycoll2", "/id");

            container = containerResponse.Container;

            // Insert an item with invalid schema
            var writeSucceeded = true;

            try
            {
                await container.CreateItemAsync(new { id = "12345" });
            }
            catch (InvalidItemSchemaException)
            {
                writeSucceeded = false;
            }
            Debug.Assert(!writeSucceeded);

            // Insert an item with valid schema
            try
            {
                await container.CreateItemAsync(new { id = "12345", name = "Youri" });

                writeSucceeded = true;
            }
            catch (InvalidItemSchemaException)
            {
                writeSucceeded = false;
            }
            Debug.Assert(writeSucceeded);

            // Update an item with invalid schema
            try
            {
                await container.ReplaceItemAsync(new { id = "12345" }, "12345");

                writeSucceeded = true;
            }
            catch (InvalidItemSchemaException)
            {
                writeSucceeded = false;
            }
            Debug.Assert(!writeSucceeded);

            // Update an item with valid schema
            try
            {
                await container.ReplaceItemAsync(new { id = "12345", name = "Vladimir" }, "12345");

                writeSucceeded = true;
            }
            catch (InvalidItemSchemaException)
            {
                writeSucceeded = false;
            }
            Debug.Assert(writeSucceeded);
        }
예제 #27
0
        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);
        }
        public void WithUnrecognizedApplicationRegionThrows()
        {
            string notAValidAzureRegion = Guid.NewGuid().ToString();

            {
                CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
                    accountEndpoint: AccountEndpoint,
                    authKeyOrResourceToken: MockCosmosUtil.RandomInvalidCorrectlyFormatedAuthKey)
                                                          .WithApplicationRegion(notAValidAzureRegion);

                ArgumentException argumentException = Assert.ThrowsException <ArgumentException>(() => cosmosClientBuilder.Build(new MockDocumentClient()));

                Assert.IsTrue(argumentException.Message.Contains(notAValidAzureRegion), $"Expected error message to contain {notAValidAzureRegion} but got: {argumentException.Message}");
            }

            {
                CosmosClientOptions cosmosClientOptions = new CosmosClientOptions()
                {
                    ApplicationRegion = notAValidAzureRegion
                };

                ArgumentException argumentException = Assert.ThrowsException <ArgumentException>(() => new CosmosClient(AccountEndpoint, MockCosmosUtil.RandomInvalidCorrectlyFormatedAuthKey, cosmosClientOptions));

                Assert.IsTrue(argumentException.Message.Contains(notAValidAzureRegion), $"Expected error message to contain {notAValidAzureRegion} but got: {argumentException.Message}");
            }
        }
예제 #29
0
        /// <summary>
        /// DI Configure using Autofac container
        /// </summary>
        /// <param name="builder"></param>
        private void ConfigureAutofacContainer(ContainerBuilder builder)
        {
            builder.Register(activator =>
            {
                var xeroConfig = new XeroConfiguration();

                var config = activator.Resolve <IConfiguration>();
                config.GetSection(nameof(XeroConfiguration)).Bind(xeroConfig);

                return(xeroConfig);
            })
            .AsSelf()
            .SingleInstance();

            // register azure storage account
            builder.Register(activator =>
            {
                var storageAccount = activator.Resolve <StorageAccountProvider>().GetHost();

                return(storageAccount);
            })
            .AsSelf()
            .SingleInstance();

            // register Cosmos DB
            builder.Register(activator =>
            {
                var config           = activator.Resolve <IConfiguration>();
                var connectionString = config["CosmosDB:ConnectionString"];

                var serializerOptions = new CosmosSerializationOptions()
                {
                    IgnoreNullValues     = true,
                    Indented             = false,
                    PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase
                };

                var cosmosClientBuilder = new CosmosClientBuilder(connectionString)
                                          .WithSerializerOptions(serializerOptions);

                return(cosmosClientBuilder.Build());
            })
            .AsSelf()
            .SingleInstance();

            // Register all functions that resides in a given namespace
            // The function class itself will be created using autofac
            builder
            .RegisterAssemblyTypes(typeof(Startup).Assembly)
            .InNamespace(typeof(IAzFunc).Namespace ?? string.Empty)
            .AsSelf()                     // Azure Functions core code resolves a function class by itself.
            .InstancePerTriggerRequest(); // This will scope nested dependencies to each function execution

            builder
            .RegisterAssemblyTypes(typeof(Startup).Assembly)
            .InNamespace(typeof(IStorageEnitity).Namespace ?? string.Empty)
            .AsImplementedInterfaces()
            .SingleInstance();     // This will scope nested dependencies to each function execution

            builder
            .RegisterAssemblyTypes(typeof(AccountingApi).Assembly)
            .InNamespace(typeof(AccountingApi).Namespace ?? string.Empty)
            .AsSelf()
            .SingleInstance();

            builder.RegisterType <TokenTable>()
            .As <ITokenStore>()
            .SingleInstance();
        }