public async Task DefaultThroughputTest() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerIfNotExistsAsync(containerName, partitionKeyPath); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); CosmosContainer cosmosContainer = this.cosmosDatabase.Containers[containerName]; int?readThroughput = await cosmosContainer.ReadProvisionedThroughputAsync(); Assert.IsNotNull(readThroughput); containerResponse = await cosmosContainer.DeleteAsync(); Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode); }
public async Task <OperationResult> DeleteContainerAsync(CosmosContainer container, CancellationToken cancellationToken) { try { var c = _databaseGetter().GetContainer(container.Id); await c.DeleteContainerAsync(new ContainerRequestOptions { IfMatchEtag = container.ETag }, cancellationToken); return(OperationResult.Success); } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.Conflict) { return(OperationResult.EditConflict); } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.NotFound) { return(OperationResult.NotFound); } }
public async Task ChangeFeedTestInit() { await base.TestInit(); string PartitionKey = "/id"; ContainerResponse response = await this.database.CreateContainerAsync( new CosmosContainerProperties(id : "monitored", partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); this.Container = response; response = await this.database.CreateContainerAsync( new CosmosContainerProperties(id : "leases", partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); this.LeaseContainer = response; }
public async Task DeleteAsync(string entityId) { try { CosmosContainer container = GetContainer(); await container.DeleteItemAsync <T>(entityId, new PartitionKey(entityId)); } catch (CosmosException ex) { _logger.LogError(ex.Message); if (ex.Status != (int)HttpStatusCode.NotFound) { throw; } } }
/// <summary> /// Run a query (using Azure Cosmos DB SQL syntax) against the container /// </summary> private static async Task QueryItemsAsync(CosmosClient cosmosClient) { var sqlQueryText = "SELECT * FROM c WHERE c.LastName = 'Andersen'"; Console.WriteLine("Running query: {0}\n", sqlQueryText); CosmosContainer container = cosmosClient.GetContainer(Program.DatabaseId, Program.ContainerId); QueryDefinition queryDefinition = new QueryDefinition(sqlQueryText); List <Family> families = new List <Family>(); await foreach (Family family in container.GetItemQueryIterator <Family>(queryDefinition)) { families.Add(family); Console.WriteLine("\tRead {0}\n", family); } }
private static async Task ReplaceFamilyItemAsync(CosmosClient cosmosClient) { CosmosContainer container = cosmosClient.GetContainer(Program.DatabaseId, Program.ContainerId); ItemResponse <Family> wakefieldFamilyResponse = await container.ReadItemAsync <Family> ("Wakefield.7", new PartitionKey ("Wakefield")); Family itemBody = wakefieldFamilyResponse; // update registration status from false to true itemBody.IsRegistered = true; // update grade of child itemBody.Children[0].Grade = 6; // replace the item with the updated content wakefieldFamilyResponse = await container.ReplaceItemAsync <Family> (itemBody, itemBody.Id, new PartitionKey (itemBody.LastName)); Console.WriteLine("Updated Family [{0},{1}].\n \tBody is now: {2}\n", itemBody.LastName, itemBody.Id, wakefieldFamilyResponse.Value); }
public static async Task Initialize(IConfiguration configuration) { databaseId = configuration.GetSection("CosmosDb").GetSection("Database").Value ?? "Tasks"; containerId = configuration.GetSection("CosmosDb").GetSection("Container").Value ?? "Items"; endpoint = configuration.GetSection("CosmosDb").GetSection("Endpoint").Value; primaryKey = configuration.GetSection("CosmosDb").GetSection("PrimaryKey").Value; var config = new CosmosConfiguration(endpoint, primaryKey); client = new CosmosClient(config); CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId); CosmosContainer container = await database.Containers.CreateContainerIfNotExistsAsync(containerId, "/category"); items = container.Items; }
public async Task CosmosConflictsStreamIteratorBuildsSettings() { string conflictResponsePayload = @"{ 'Data':[{ id: 'Conflict1', operationType: 'Replace', resourceType: 'trigger' }]}"; CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.WithConnectionModeDirect()); CosmosContainer container = mockClient.GetContainer("database", "container"); FeedIterator feedIterator = container.GetConflicts().GetConflictsStreamIterator(); TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.AreEqual(OperationType.ReadFeed, request.OperationType); Assert.AreEqual(ResourceType.Conflict, request.ResourceType); CosmosResponseMessage handlerResponse = TestHandler.ReturnSuccess().Result; MemoryStream stream = new MemoryStream(); StreamWriter writer = new StreamWriter(stream); writer.Write(conflictResponsePayload); writer.Flush(); stream.Position = 0; handlerResponse.Content = stream; return(Task.FromResult(handlerResponse)); }); mockClient.RequestHandler.InnerHandler = testHandler; CosmosResponseMessage streamResponse = await feedIterator.FetchNextSetAsync(); Collection <CosmosConflictSettings> response = new CosmosJsonSerializerCore().FromStream <CosmosFeedResponseUtil <CosmosConflictSettings> >(streamResponse.Content).Data; Assert.AreEqual(1, response.Count()); CosmosConflictSettings responseSettings = response.FirstOrDefault(); Assert.IsNotNull(responseSettings); Assert.AreEqual("Conflict1", responseSettings.Id); Assert.AreEqual(Cosmos.OperationKind.Replace, responseSettings.OperationKind); Assert.AreEqual(typeof(CosmosTriggerSettings), responseSettings.ResourceType); }
public async Task VerifyCosmosDefaultResultSetStreamIteratorOperationType() { CosmosClient mockClient = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.UseConnectionModeDirect()); CosmosContainer container = mockClient.Databases["database"].Containers["container"]; CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r"); CosmosResultSetIterator setIterator = container.Items.CreateItemQueryAsStream( sqlQueryDefinition: sql, maxConcurrency: 1, partitionKey: "pk", requestOptions: new CosmosQueryRequestOptions()); TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.AreEqual( 15, //OperationType.SqlQuery (int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null) ); return(TestHandler.ReturnSuccess()); }); mockClient.RequestHandler.InnerHandler = testHandler; CosmosQueryResponse response = await setIterator.FetchNextSetAsync(); //Test gateway mode mockClient = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.UseConnectionModeGateway()); container = mockClient.Databases["database"].Containers["container"]; setIterator = container.Items.CreateItemQueryAsStream( sqlQueryDefinition: sql, maxConcurrency: 1, partitionKey: "pk", requestOptions: new CosmosQueryRequestOptions()); testHandler = new TestHandler((request, cancellationToken) => { Assert.AreEqual( 14, //OperationType.Query (int)request.GetType().GetProperty("OperationType", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(request, null) ); return(TestHandler.ReturnSuccess()); }); mockClient.RequestHandler.InnerHandler = testHandler; response = await setIterator.FetchNextSetAsync(); }
public async Task <Item> Get(string partitionKey, string id) { CosmosDatabase database = await client.Databases.CreateDatabaseIfNotExistsAsync(DatabaseName); CosmosContainer container = await database.Containers.CreateContainerIfNotExistsAsync(ContainerName, PartitionKeyPath); var query = new CosmosSqlQueryDefinition("SELECT * FROM x WHERE x.id = @id") .UseParameter("@id", id); List <Item> results = new List <Item>(); var resultSetIterator = container.Items.CreateItemQuery <Item>(query, partitionKey: partitionKey); while (resultSetIterator.HasMoreResults) { results.AddRange((await resultSetIterator.FetchNextSetAsync())); } return(results.Any() ? results.ElementAt(0) : null); }
private static async Task ItemFeed(CosmosContainer container) { List <Family> families = new List <Family>(); // SQL FeedIterator <Family> setIterator = container.GetItemsIterator <Family>(maxItemCount: 1); while (setIterator.HasMoreResults) { int count = 0; foreach (Family item in await setIterator.FetchNextSetAsync()) { Assert("Should only return 1 result at a time.", count <= 1); families.Add(item); } } Assert("Expected two families", families.ToList().Count == 2); }
public async Task PartitionedCRUDTest() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; ContainerResponse containerResponse = await this.cosmosDatabase.CreateContainerAsync(containerName, partitionKeyPath); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); CosmosContainerSettings settings = new CosmosContainerSettings(containerName, partitionKeyPath) { IndexingPolicy = new Cosmos.IndexingPolicy() { IndexingMode = Cosmos.IndexingMode.None, Automatic = false } }; CosmosContainer cosmosContainer = containerResponse; containerResponse = await cosmosContainer.ReplaceAsync(settings); Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode); Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic); containerResponse = await cosmosContainer.ReadAsync(); Assert.AreEqual(HttpStatusCode.OK, containerResponse.StatusCode); Assert.AreEqual(containerName, containerResponse.Resource.Id); Assert.AreEqual(Cosmos.PartitionKeyDefinitionVersion.V2, containerResponse.Resource.PartitionKeyDefinitionVersion); Assert.AreEqual(partitionKeyPath, containerResponse.Resource.PartitionKey.Paths.First()); Assert.AreEqual(Cosmos.IndexingMode.None, containerResponse.Resource.IndexingPolicy.IndexingMode); Assert.IsFalse(containerResponse.Resource.IndexingPolicy.Automatic); containerResponse = await containerResponse.Container.DeleteAsync(); Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode); }
public async Task TestPreProcessingHandler() { CosmosRequestHandler preProcessHandler = new PreProcessingTestHandler(); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient((builder) => builder.AddCustomHandlers(preProcessHandler)); Assert.IsTrue(typeof(RequestInvokerHandler).Equals(client.RequestHandler.GetType())); Assert.IsTrue(typeof(PreProcessingTestHandler).Equals(client.RequestHandler.InnerHandler.GetType())); CosmosContainer container = client.Databases["testdb"] .Containers["testcontainer"]; HttpStatusCode[] testHttpStatusCodes = new HttpStatusCode[] { HttpStatusCode.OK, HttpStatusCode.NotFound }; // User operations foreach (HttpStatusCode code in testHttpStatusCodes) { ItemRequestOptions options = new ItemRequestOptions(); options.Properties = new Dictionary <string, object>(); options.Properties.Add(PreProcessingTestHandler.StatusCodeName, code); ItemResponse <object> response = await container.ReadItemAsync <object>("pk1", "id1", options); Console.WriteLine($"Got status code {response.StatusCode}"); Assert.AreEqual(code, response.StatusCode); } // Meta-data operations foreach (HttpStatusCode code in testHttpStatusCodes) { ContainerRequestOptions options = new ContainerRequestOptions(); options.Properties = new Dictionary <string, object>(); options.Properties.Add(PreProcessingTestHandler.StatusCodeName, code); ContainerResponse response = await container.DeleteAsync(options); Console.WriteLine($"Got status code {response.StatusCode}"); Assert.AreEqual(code, response.StatusCode); } }
public GenericCosmosDbRepository(IConfiguration configuration, IWebHostEnvironment env) { _configuration = configuration; string endpointUri = _configuration["CosmosDbRepository:EndpointUri"]; string primaryKey = _configuration["CosmosDbRepository:PrimaryKey"]; _cosmosClient = new CosmosClient(endpointUri, primaryKey); _databaseId = _configuration["CosmosDbRepository:DatabaseId"]; _containerId = typeof(T).Name; _container = _cosmosClient.GetContainer(_databaseId, _containerId); if (env.IsDevelopment()) { Setup(); } }
private static async Task QueryWithSqlParameters(CosmosContainer container) { // Query using two properties within each item. WHERE Id == "" AND Address.City == "" // notice here how we are doing an equality comparison on the string value of City CosmosSqlQueryDefinition query = new CosmosSqlQueryDefinition("SELECT * FROM Families f WHERE f.id = @id AND f.Address.City = @city") .UseParameter("@id", "AndersonFamily") .UseParameter("@city", "Seattle"); List <Family> results = new List <Family>(); FeedIterator <Family> resultSetIterator = container.CreateItemQuery <Family>(query, partitionKey: new PartitionKey("Anderson")); while (resultSetIterator.HasMoreResults) { results.AddRange((await resultSetIterator.FetchNextSetAsync())); } Assert("Expected only 1 family", results.Count == 1); }
/// <summary> /// Run through basic container access methods as a console app demo. /// </summary> /// <returns></returns> private static async Task RunContainerDemo(CosmosClient client) { // Create the database if necessary await Program.Setup(client); CosmosContainer simpleContainer = await Program.CreateContainer(); await Program.CreateContainerWithCustomIndexingPolicy(); await Program.CreateContainerWithTtlExpiration(); await Program.GetAndChangeContainerPerformance(simpleContainer); await Program.ReadContainerProperties(); await Program.ListContainersInDatabase(); // Uncomment to delete container! // await Program.DeleteContainer(); }
public async Task TimeToLiveTest() { string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; TimeSpan timeToLive = TimeSpan.FromSeconds(1); CosmosContainerSettings setting = new CosmosContainerSettings() { Id = containerName, PartitionKey = new PartitionKeyDefinition() { Paths = new Collection <string> { partitionKeyPath }, Kind = PartitionKind.Hash }, DefaultTimeToLive = timeToLive }; CosmosContainerResponse containerResponse = await this.cosmosDatabase.Containers.CreateContainerIfNotExistsAsync(setting); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); CosmosContainer cosmosContainer = containerResponse; CosmosContainerSettings responseSettings = containerResponse; Assert.AreEqual(timeToLive.TotalSeconds, responseSettings.DefaultTimeToLive.Value.TotalSeconds); CosmosContainerResponse readResponse = await cosmosContainer.ReadAsync(); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); Assert.AreEqual(timeToLive.TotalSeconds, readResponse.Resource.DefaultTimeToLive.Value.TotalSeconds); JObject itemTest = JObject.FromObject(new { id = Guid.NewGuid().ToString(), users = "testUser42" }); CosmosItemResponse <JObject> createResponse = await cosmosContainer.Items.CreateItemAsync <JObject>(partitionKey : itemTest["users"].ToString(), item : itemTest); JObject responseItem = createResponse; Assert.IsNull(responseItem["ttl"]); containerResponse = await cosmosContainer.DeleteAsync(); Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode); }
public async Task <T> AddAsync(T newEntity) { try { CosmosContainer container = GetContainer(); ItemResponse <T> createResponse = await container.CreateItemAsync(newEntity); return(createResponse.Value); } catch (CosmosException ex) { _logger.LogError(ex.Message); if (ex.Status != (int)HttpStatusCode.NotFound) { throw; } return(null); } }
private static async Task Initialize(CosmosClient client) { database = await client.Databases.CreateDatabaseIfNotExistsAsync(databaseId); // Delete the existing container to prevent create item conflicts await database.Containers[containerId].DeleteAsync(); // We create a partitioned collection here which needs a partition key. Partitioned collections // can be created with very high values of provisioned throughput (up to Throughput = 250,000) // and used to store up to 250 GB of data. You can also skip specifying a partition key to create // single partition collections that store up to 10 GB of data. // For this demo, we create a collection to store SalesOrders. We set the partition key to the account // number so that we can retrieve all sales orders for an account efficiently from a single partition, // and perform transactions across multiple sales order for a single account number. CosmosContainerSettings containerSettings = new CosmosContainerSettings(containerId, partitionKeyPath: "/AccountNumber"); // Create with a throughput of 1000 RU/s container = await database.Containers.CreateContainerIfNotExistsAsync( containerSettings, throughput : 1000); }
public async Task <T> GetAsync(string entityId, string partionKey) { try { CosmosContainer container = GetContainer(); ItemResponse <T> entityResult = await container.ReadItemAsync <T>(entityId, new PartitionKey(partionKey)); return(entityResult.Value); } catch (CosmosException ex) { Log.Error($"Entity with ID: {entityId} was not retrieved successfully - error details: {ex.Message}"); if (ex.ErrorCode != "404") { throw; } return(null); } }
private static async Task RunDemoAsync(CosmosClient client) { cosmosDatabase = await client.CreateDatabaseIfNotExistsAsync(CosmosDatabaseId); CosmosContainer container = await Program.GetOrCreateContainerAsync(cosmosDatabase, containerId); await Program.CreateItems(container); await Program.ItemFeed(container); await Program.ItemStreamFeed(container); await Program.QueryItemsInPartitionAsStreams(container); await Program.QueryPartitionedContainerInParallelAsync(container); await Program.QueryWithSqlParameters(container); // Uncomment to Cleanup //await cosmosDatabase.DeleteAsync(); }
public async Task <T> AddAsync(T newEntity) { try { CosmosContainer container = GetContainer(); ItemResponse <T> createResponse = await container.CreateItemAsync(newEntity); return(createResponse.Value); } catch (CosmosException ex) { Log.Error($"New entity with ID: {newEntity.Id} was not added successfully - error details: {ex.Message}"); if (ex.Status != (int)HttpStatusCode.NotFound) { throw; } return(null); } }
public AdRepository(string cacheConnectionString, string cosmosEndpointUri, string cosmosKey) { try { Lazy <ConnectionMultiplexer> lazyConnection = GetLazyConnection(cacheConnectionString); cache = lazyConnection.Value.GetDatabase(); client = new CosmosClient(cosmosEndpointUri, cosmosKey); container = client.Databases[databaseId].Containers[containerId]; } catch (Exception ex) when(ex is RedisConnectionException || ex is RedisException) { throw new AdRepositoryException("Redis connection initialization error", ex); } catch (Exception ex) when(ex is CosmosException) { throw new AdRepositoryException("Cosmos initialization error", ex); } }
public async Task ThroughputTest() { int expectedThroughput = 2400; string containerName = Guid.NewGuid().ToString(); string partitionKeyPath = "/users"; ContainerResponse containerResponse = await this.database.DefineContainer(containerName, partitionKeyPath) .CreateAsync(expectedThroughput); Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode); CosmosContainer cosmosContainer = this.database.GetContainer(containerName); int?readThroughput = await cosmosContainer.ReadProvisionedThroughputAsync(); Assert.IsNotNull(readThroughput); Assert.AreEqual(expectedThroughput, readThroughput); containerResponse = await cosmosContainer.DeleteAsync(); Assert.AreEqual(HttpStatusCode.NoContent, containerResponse.StatusCode); }
public async Task <T> GetAsync(string entityId) { try { CosmosContainer container = GetContainer(); ItemResponse <T> entityResult = await container.ReadItemAsync <T>(entityId, new PartitionKey(entityId)); return(entityResult.Value); } catch (CosmosException ex) { _logger.LogError(ex.Message); if (ex.Status != (int)HttpStatusCode.NotFound) { throw; } return(null); } }
private async void dataGridView1_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e) { this.Cursor = System.Windows.Forms.Cursors.WaitCursor; var clickedId = dataGridView1.Rows[e.Row.Index].Cells[0].Value.ToString(); try { CosmosContainer container = cosmosClient.GetContainer(_settings.DatabaseId, _settings.ContainerId); Session session = new Session(); ItemResponse <Session> sessionCosmos = await container.DeleteItemAsync <Session>(clickedId, new PartitionKey(session.partition)); _allSessions.Remove(_allSessions.Where(c => c.id.Equals(clickedId)).FirstOrDefault()); } catch (Exception) { this.Cursor = System.Windows.Forms.Cursors.Default; } Thread.Sleep(100); this.Cursor = System.Windows.Forms.Cursors.Default; }
public FeedProcessorFactoryCore( CosmosContainer container, ChangeFeedProcessorOptions changeFeedProcessorOptions, DocumentServiceLeaseCheckpointer leaseCheckpointer) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (changeFeedProcessorOptions == null) { throw new ArgumentNullException(nameof(changeFeedProcessorOptions)); } if (leaseCheckpointer == null) { throw new ArgumentNullException(nameof(leaseCheckpointer)); } this.container = container; this.changeFeedProcessorOptions = changeFeedProcessorOptions; this.leaseCheckpointer = leaseCheckpointer; }
public async Task <OperationResult> CreateContainerAsync(CosmosContainer container, int?throughput, CancellationToken cancellationToken) { var properties = new ContainerProperties(container.Id, container.PartitionKeyPath) { DefaultTimeToLive = container.DefaultTTL, PartitionKeyDefinitionVersion = container.LargePartitionKey ? PartitionKeyDefinitionVersion.V2 : PartitionKeyDefinitionVersion.V1 }; try { var response = await _databaseGetter().CreateContainerAsync(properties, throughput, cancellationToken: cancellationToken); container.ETag = response.Resource.ETag; return(OperationResult.Success); } catch (CosmosException ex) when(ex.StatusCode == HttpStatusCode.Conflict) { return(OperationResult.AlreadyExists); } }
public RemainingWorkEstimatorCore( DocumentServiceLeaseContainer leaseContainer, CosmosContainer container, int degreeOfParallelism) { if (leaseContainer == null) { throw new ArgumentNullException(nameof(leaseContainer)); } if (container == null) { throw new ArgumentNullException(nameof(container)); } if (degreeOfParallelism < 1) { throw new ArgumentException("Degree of parallelism is out of range", nameof(degreeOfParallelism)); } this.leaseContainer = leaseContainer; this.container = container; this.degreeOfParallelism = degreeOfParallelism; }
public async Task TestInitialize() { this.cancellationTokenSource = new CancellationTokenSource(); this.cancellationToken = this.cancellationTokenSource.Token; this.cosmosClient = TestCommon.CreateCosmosClient(); this.database = await this.cosmosClient.Databases.CreateDatabaseAsync(Guid.NewGuid().ToString(), cancellationToken : this.cancellationToken); this.documentClient = TestCommon.CreateClient(true, defaultConsistencyLevel: Documents.ConsistencyLevel.Session); string PartitionKey = "/partitionKey"; CosmosContainerResponse response = await this.database.Containers.CreateContainerAsync( new CosmosContainerSettings(id : Guid.NewGuid().ToString(), partitionKeyPath : PartitionKey), cancellationToken : this.cancellationToken); Assert.IsNotNull(response); Assert.IsNotNull(response.Container); Assert.IsNotNull(response.Resource); this.Container = response; this.jsonSerializer = new CosmosDefaultJsonSerializer(); }