private async Task InitializeDatabase() { try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(_databaseId)); } catch (DocumentClientException dce) { if (dce.StatusCode == HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = _databaseId }); return; } throw; } }
private static async Task CreateDatabaseIfNotExistsAsync() { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(databaseName)); } catch (DocumentClientException e) { if (e.StatusCode == HttpStatusCode.NotFound) { await client.CreateDatabaseAsync(new Database { Id = databaseName }); } else { throw; } } }
private async Task CreateDataBaseIfNotExists(DocumentClient documentClient) { try { await documentClient.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(CloudConfigurationManager.GetSetting(AzureRelatedNames.DatabaseName))); } catch (DocumentClientException de) { if (de.StatusCode == HttpStatusCode.NotFound) { await documentClient.CreateDatabaseAsync(new Database { Id = CloudConfigurationManager.GetSetting(AzureRelatedNames.DatabaseName) }); } else { throw; } } }
private async Task <DocumentCollection> SetupSingleCollectionScenario() { DocumentClient client = TestCommon.CreateClient(true); await TestCommon.DeleteAllDatabasesAsync(); Database database = (await client.CreateDatabaseAsync(new Database { Id = this.DatabaseName })).Resource; DocumentCollection collection = (await client.CreateDocumentCollectionIfNotExistsAsync(database.SelfLink, new DocumentCollection { Id = this.CollectionName }, new RequestOptions { OfferThroughput = 10000 })).Resource; // await Task.Delay(30000); return(collection); }
private async Task CreateDatabaseIfNotExists() { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(dbName)); } catch (DocumentClientException de) { if (de.StatusCode == HttpStatusCode.NotFound) { await client.CreateDatabaseAsync(new Database { Id = dbName }); } else { logger.Error(de); } } }
private async Task CreateDatabaseIfNotExistsAsync() { try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(_databaseId)); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = _databaseId }); } else { throw; } } }
private async Task CreateDatabaseIfNotExists() { try { await Client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseName)); } catch (DocumentClientException ex) { if (ex.StatusCode == System.Net.HttpStatusCode.NotFound) { await Client.CreateDatabaseAsync(new Database { Id = DatabaseName }); } else { throw ex; } } }
async Task <Database> GetDatabase() { var dbs = from db in Cosmos.CreateDatabaseQuery() where db.Id == DatabaseName select db; var dbr = dbs.ToList().First(); if (dbr == null) { dbr = await Cosmos.CreateDatabaseAsync(new Database() { Id = DatabaseName }); } return(dbr); }
//method for creating database if it doesnot exist public static async Task CreateDatabaseIfNotExistsAsync() { try {//read from already created database await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseId)); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) {//if not found then create a new database await client.CreateDatabaseAsync(new Database { Id = DatabaseId }); } else { throw; } } }
private async Task CreateDatabaseIfNotExistsAsync() { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(DatabaseId)); } catch (DocumentClientException docEx) { if (docEx.StatusCode == HttpStatusCode.NotFound) { await client.CreateDatabaseAsync(new Database { Id = DatabaseId }); } else { throw; } } }
async Task createDatabaseAsync(DocumentClient client, string id) { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(id)); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await client.CreateDatabaseAsync(new Database { Id = id }); } else { throw; } } }
public async Task CreateDatabaseIfNotExistsAsync(CancellationToken cancellationToken) { try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(_builder.Database)); } catch (DocumentClientException e) { if (e.StatusCode == HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = _builder.Database }); } else { throw; } } }
private async Task CreateDatabaseIfNotExistsAsync() { try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(ConfigSettings.Database)); } catch (DocumentClientException e) { if (e.StatusCode == HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = ConfigSettings.Database }); } else { throw; } } }
#pragma warning disable 1591 // Xml Comments public void Initialize(IContainer container) { Client = new DocumentClient(new Uri(_configuration.Url), _configuration.AuthorizationKey); Client.ReadDatabaseFeedAsync() .ContinueWith(a => Database = a.Result.Where(d => d.Id == _configuration.DatabaseId).SingleOrDefault()) .Wait(); if (Database == null) { this.Database = new Database { Id = _configuration.DatabaseId }; Client.CreateDatabaseAsync(Database) .ContinueWith(d => Database = d.Result.Resource) .Wait(); } }
private async Task <Database> InitialiseDatabase() { // Check to verify a database with the id=FamilyRegistry does not exist var database = _documentClient.CreateDatabaseQuery() .Where(db => db.Id == "AssociateRecords") .AsEnumerable() .FirstOrDefault(); if (database == null) { database = await _documentClient.CreateDatabaseAsync( new Database { Id = "AssociateRecords" }); } return(database); }
private async Task CreateDatabaseIfNotExistsAsync() { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(_config.GetValue <string>("Values:COSMOSDB_DATABASE_NAME"))); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await client.CreateDatabaseAsync(new Database { Id = _config.GetValue <string>("Values:COSMOSDB_DATABASE_NAME") }); } else { throw; } } }
private async Task InitDocDbClient() { using (var client = new DocumentClient(new Uri(_cloudConfig.DocDbUri), _cloudConfig.DocDbKey)) { await client.OpenAsync(); //This code is not as efficient as storing the selfLink in the config, but //I wanted to keep it easy to configure. var dynamicDb = client.CreateDatabaseQuery("select * from root r where r.id = '" + _cloudConfig.DocDbDatabaseName + "'") .AsEnumerable().FirstOrDefault(); string dbSelfLink; if (dynamicDb == null) { var db = new Database { Id = _cloudConfig.DocDbDatabaseName }; db = await client.CreateDatabaseAsync(db); dbSelfLink = db.SelfLink; } else { dbSelfLink = dynamicDb._self; } var collectionFeed = await client.ReadDocumentCollectionFeedAsync(dbSelfLink); var collection = collectionFeed.SingleOrDefault(x => x.Id == DataTableName); if (collection == null) { collection = new DocumentCollection { Id = DataTableName }; collection = await client.CreateDocumentCollectionAsync(dbSelfLink, collection); } //Caching the selfLink will help avoid querying the collections excessively CollectionSelfLink = collection.SelfLink; } }
static void Main() { var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile($"appsettings.json"); var configuration = builder.Build(); Console.WriteLine("Obter configurações de acesso..."); DocumentClient client = new DocumentClient( new Uri(configuration.GetSection("DBCatalogo:EndpointUri").Value), configuration.GetSection("DBCatalogo:PrimaryKey").Value); Console.WriteLine("Criar banco de dados..."); client.CreateDatabaseAsync( new Database { Id = "DBCatalogo" }).Wait(); Console.WriteLine("Criar coleção..."); DocumentCollection collectionInfo = new DocumentCollection(); collectionInfo.Id = "Catalogo"; collectionInfo.IndexingPolicy = new IndexingPolicy(new RangeIndex(DataType.String) { Precision = -1 }); client.CreateDocumentCollectionAsync( UriFactory.CreateDatabaseUri("DBCatalogo"), collectionInfo, new RequestOptions { OfferThroughput = 400 }).Wait(); Console.WriteLine("Incluir produtos..."); Carga.InserirDadosProdutos(client); Console.WriteLine("Incluir serviços..."); Carga.InserirDadosServicos(client); Console.WriteLine("Finalizado!"); }
protected virtual async Task CreateDatabaseIfNotExistsAsync() { try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(_config.DatabaseId)) .ConfigureAwait(false); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = _config.DatabaseId }).ConfigureAwait(false); } else { throw; } } }
private async Task CreateDatabaseIfNotExists() { try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(DbName)); } catch (DocumentClientException de) { // If the database does not exist, create a new database if (de.StatusCode == HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = DbName }); } else { throw; } } }
private static async Task SetupEnvironmentAsync(string dbUri, string key, string collectionName) { var client = new DocumentClient(new Uri(dbUri), key); var database = new Database() { Id = DbName }; await client.CreateDatabaseAsync(database); await client.CreateDocumentCollectionAsync(UriFactory.CreateDatabaseUri(DbName), new DocumentCollection() { Id = collectionName }); await client.CreateDocumentCollectionAsync(UriFactory.CreateDatabaseUri(DbName), new DocumentCollection() { Id = $"{collectionName}.Lease.ConsoleApp" }); }
/// <summary> /// Create database if it does not exist /// </summary> /// <returns></returns> private static async Task CreateNewDatabaseAsync() { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(databaseName)); await client.DeleteDatabaseAsync(UriFactory.CreateDatabaseUri(databaseName)); } catch (DocumentClientException e) { // If we receive an error other than database not found, fail if (e.StatusCode != System.Net.HttpStatusCode.NotFound) { throw; } } await client.CreateDatabaseAsync(new Database { Id = databaseName }); }
public async Task ResourceResponseStreamingTest() { using (DocumentClient client = TestCommon.CreateClient(true)) { Database db = (await client.CreateDatabaseAsync(new Database() { Id = Guid.NewGuid().ToString() })).Resource; DocumentCollection coll = await TestCommon.CreateCollectionAsync(client, db, new DocumentCollection() { Id = Guid.NewGuid().ToString(), PartitionKey = new PartitionKeyDefinition() { Paths = new System.Collections.ObjectModel.Collection <string>() { "/id" } } }); ResourceResponse <Document> doc = await client.CreateDocumentAsync(coll.SelfLink, new Document() { Id = Guid.NewGuid().ToString() }); Assert.AreEqual(doc.ResponseStream.Position, 0); StreamReader streamReader = new StreamReader(doc.ResponseStream); string text = streamReader.ReadToEnd(); Assert.AreEqual(doc.ResponseStream.Position, doc.ResponseStream.Length); try { doc.Resource.ToString(); Assert.Fail("Deserializing Resource here should throw exception since the stream was already read"); } catch (JsonReaderException ex) { Console.WriteLine("Expected exception while deserializing Resource: " + ex.Message); } } }
private async Task <CosmosContainerSettings> SetupSingleCollectionScenario() { DocumentClient client = TestCommon.CreateClient(true); TestCommon.DeleteAllDatabasesAsync(client).Wait(); CosmosDatabaseSettings database = (await client.CreateDatabaseAsync(new CosmosDatabaseSettings { Id = this.DatabaseName })).Resource; CosmosContainerSettings collection = (await client.CreateDocumentCollectionIfNotExistsAsync(database.SelfLink, new CosmosContainerSettings { Id = this.CollectionName }, new RequestOptions { OfferThroughput = 10000 })).Resource; // await Task.Delay(30000); return(collection); }
public static async Task CreateDatabaseIfNotExistsAsync( this DocumentClient client, string databaseId) { try { await client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(databaseId)); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await client.CreateDatabaseAsync(new Database { Id = databaseId }).ConfigureAwait(false); } else { throw; } } }
private async Task CreateDatabaseIfNotExistsAsync() { // TODO: Create db with shared 400 RU/s across all containers try { await _client.ReadDatabaseAsync(UriFactory.CreateDatabaseUri(_databaseId)); } catch (DocumentClientException e) { if (e.StatusCode == System.Net.HttpStatusCode.NotFound) { await _client.CreateDatabaseAsync(new Database { Id = _databaseId }); } else { throw; } } }
public void ValidateVersionHeader() { string correctVersion = HttpConstants.Versions.CurrentVersion; try { DocumentClient client = TestCommon.CreateClient(true); var db = client.CreateDatabaseAsync(new Database() { Id = Guid.NewGuid().ToString() }).Result.Resource; var coll = client.CreateDocumentCollectionAsync(db.SelfLink, new DocumentCollection() { Id = Guid.NewGuid().ToString() }).Result.Resource; var doc = client.CreateDocumentAsync(coll.SelfLink, new Document()).Result.Resource; client = TestCommon.CreateClient(true); doc = client.CreateDocumentAsync(coll.SelfLink, new Document()).Result.Resource; HttpConstants.Versions.CurrentVersion = "2015-01-01"; client = TestCommon.CreateClient(true); try { doc = client.CreateDocumentAsync(coll.SelfLink, new Document()).Result.Resource; Assert.Fail("Should have faild because of version error"); } catch (AggregateException exception) { var dce = exception.InnerException as DocumentClientException; if (dce != null) { Assert.AreEqual(dce.StatusCode, HttpStatusCode.BadRequest); } else { Assert.Fail("Should have faild because of version error with DocumentClientException BadRequest"); } } } finally { HttpConstants.Versions.CurrentVersion = correctVersion; } }
internal void TestEtagOnUpsertOperation(DocumentClient client) { Database db = client.CreateDatabaseAsync(new Database() { Id = Guid.NewGuid().ToString() }).Result.Resource; DocumentCollection coll = TestCommon.CreateCollectionAsync(client, db, new DocumentCollection() { Id = Guid.NewGuid().ToString() }).Result; LinqGeneralBaselineTests.Book myBook = new LinqGeneralBaselineTests.Book(); myBook.Id = Guid.NewGuid().ToString(); myBook.Title = "Azure DocumentDB 101"; Document doc = client.CreateDocumentAsync(coll.SelfLink, myBook).Result.Resource; myBook.Title = "Azure DocumentDB 201"; client.ReplaceDocumentAsync(doc.SelfLink, myBook).Wait(); AccessCondition condition = new AccessCondition(); condition.Type = AccessConditionType.IfMatch; condition.Condition = doc.ETag; RequestOptions requestOptions = new RequestOptions(); requestOptions.AccessCondition = condition; myBook.Title = "Azure DocumentDB 301"; try { client.UpsertDocumentAsync(coll.SelfLink, myBook, requestOptions).Wait(); Assert.Fail("Upsert Document should fail since the Etag is not matching."); } catch (Exception ex) { var innerException = ex.InnerException as DocumentClientException; Assert.IsTrue(innerException.StatusCode == HttpStatusCode.PreconditionFailed, "Invalid status code"); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); // make sure the database exists! Database db = client.CreateDatabaseQuery().Where(d => d.Id == databaseId).AsEnumerable().FirstOrDefault() ?? client.CreateDatabaseAsync(new Database { Id = databaseId }).Result; // add Identity Server with DocumentDB stores (will store data in collections "users" and "roles") // services.AddIdentityWithDocumentDBStoresUsingCustomTypes<MyUser, MyRole>(client, databaseLink); // variant 2: services.AddIdentity <MyUser, MyRole>() .RegisterDocumentDBStores <MyUser, MyRole>(client, (p) => new DocumentCollection { Id = "userCollection" }); }
/// <summary> /// Get a Database by id, or create a new one if one with the id provided doesn't exist. /// </summary> /// <param name="client">The DocumentDB client instance.</param> /// <param name="id">The id of the Database to search for, or create.</param> /// <returns>The matched, or created, Database object</returns> private static async Task <Database> GetOrCreateDatabaseAsync(DocumentClient client, string id) { // Get the database by name, or create a new one if one with the name provided doesn't exist. // Create a query object for database, filter by name. IEnumerable <Database> query = from db in client.CreateDatabaseQuery() where db.Id == id select db; // Run the query and get the database (there should be only one) or null if the query didn't return anything. // Note: this will run synchronously. If async exectution is preferred, use IDocumentServiceQuery<T>.ExecuteNextAsync. Database database = query.FirstOrDefault(); if (database == null) { // Create the database. database = await client.CreateDatabaseAsync(new Database { Id = id }); } return(database); }