private void VerifyCosmosDBAccount(DatabaseAccount databaseAccount, PatchableDatabaseAccountData parameters) { Assert.True(databaseAccount.Data.Tags.SequenceEqual(parameters.Tags)); Assert.AreEqual(databaseAccount.Data.IsVirtualNetworkFilterEnabled, parameters.IsVirtualNetworkFilterEnabled); Assert.AreEqual(databaseAccount.Data.EnableAutomaticFailover, parameters.EnableAutomaticFailover); Assert.AreEqual(databaseAccount.Data.DisableKeyBasedMetadataWriteAccess, parameters.DisableKeyBasedMetadataWriteAccess); }
private void VerifyCosmosDBAccount(DatabaseAccount expectedValue, DatabaseAccount actualValue) { var expectedData = expectedValue.Data; var actualData = actualValue.Data; Assert.AreEqual(expectedData.Name, actualData.Name); Assert.AreEqual(expectedData.Location, actualData.Location); Assert.True(expectedData.Tags.SequenceEqual(actualData.Tags)); Assert.AreEqual(expectedData.Kind, actualData.Kind); Assert.AreEqual(expectedData.ProvisioningState, actualData.ProvisioningState); Assert.AreEqual(expectedData.DocumentEndpoint, actualData.DocumentEndpoint); Assert.AreEqual(expectedData.DatabaseAccountOfferType, actualData.DatabaseAccountOfferType); Assert.AreEqual(expectedData.IpRules.Count, actualData.IpRules.Count); Assert.AreEqual(expectedData.IpRules[0].IpAddressOrRangeValue, actualData.IpRules[0].IpAddressOrRangeValue); Assert.AreEqual(expectedData.IsVirtualNetworkFilterEnabled, actualData.IsVirtualNetworkFilterEnabled); Assert.AreEqual(expectedData.EnableAutomaticFailover, actualData.EnableAutomaticFailover); VerifyConsistencyPolicy(expectedData.ConsistencyPolicy, actualData.ConsistencyPolicy); Assert.AreEqual(expectedData.Capabilities.Count, actualData.Capabilities.Count); VerifyLocations(expectedData.WriteLocations, actualData.WriteLocations); VerifyLocations(expectedData.ReadLocations, actualData.ReadLocations); VerifyLocations(expectedData.Locations, actualData.Locations); VerifyFailoverPolicies(expectedData.FailoverPolicies, actualData.FailoverPolicies); Assert.AreEqual(expectedData.VirtualNetworkRules.Count, actualData.VirtualNetworkRules.Count); Assert.AreEqual(expectedData.PrivateEndpointConnections.Count, actualData.PrivateEndpointConnections.Count); Assert.AreEqual(expectedData.EnableMultipleWriteLocations, actualData.EnableMultipleWriteLocations); Assert.AreEqual(expectedData.EnableCassandraConnector, actualData.EnableCassandraConnector); Assert.AreEqual(expectedData.ConnectorOffer, actualData.ConnectorOffer); Assert.AreEqual(expectedData.DisableKeyBasedMetadataWriteAccess, actualData.DisableKeyBasedMetadataWriteAccess); Assert.AreEqual(expectedData.KeyVaultKeyUri, actualData.KeyVaultKeyUri); Assert.AreEqual(expectedData.PublicNetworkAccess, actualData.PublicNetworkAccess); Assert.AreEqual(expectedData.EnableFreeTier, actualData.EnableFreeTier); Assert.AreEqual(expectedData.ApiProperties.ServerVersion.ToString(), actualData.ApiProperties.ServerVersion.ToString()); Assert.AreEqual(expectedData.EnableAnalyticalStorage, actualData.EnableAnalyticalStorage); Assert.AreEqual(expectedData.Cors.Count, actualData.Cors.Count); }
private async Task PrepareDatabaseAccount() { var locations = new List <Location>() { { new Location( id: default(string), locationName: location, documentEndpoint: default(string), provisioningState: default(string), failoverPriority: default(int?), isZoneRedundant: default(bool?)) } }; DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations) { Location = location, Kind = DatabaseAccountKind.GlobalDocumentDB, }; DatabaseAccount databaseAccount = await WaitForCompletionAsync( await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters)); Assert.AreEqual(databaseAccount.Name, databaseAccountName); var isDatabaseNameExists = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName); Assert.AreEqual(true, isDatabaseNameExists.Value); Assert.AreEqual(200, isDatabaseNameExists.GetRawResponse().Status); }
public async Task SetUp() { // need to overwrite with the resource group fetched by ArmClient, otherwise it won't be recorded _resourceGroup = await ArmClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync(); _databaseAccount = await ArmClient.GetDatabaseAccount(_databaseAccountIdentifier).GetAsync(); }
public async Task <StatusResultServiceModel> StatusAsync() { var result = new StatusResultServiceModel(false, "Storage check failed"); try { DatabaseAccount response = null; if (this.client != null) { // make generic call to see if storage client can be reached response = await this.client.GetDatabaseAccountAsync(); } if (response != null) { result.IsHealthy = true; result.Message = "Alive and Well!"; } } catch (Exception e) { this.logger.LogInformation(e, result.Message); } return(result); }
public async Task RestorableDatabaseAccountListByLocation() { _restorableDatabaseAccount = await CreateRestorableDatabaseAccount(Recording.GenerateAssetName("r-database-account-")); var restorableAccounts = await(await ArmClient.GetDefaultSubscriptionAsync()).GetRestorableDatabaseAccounts(AzureLocation.WestUS).GetAllAsync().ToEnumerableAsync(); Assert.That(restorableAccounts.Any(account => account.Data.AccountName == _restorableDatabaseAccount.Data.Name)); }
public async Task DatabaseAccountCreateAndUpdateTest() { var locations = new List <Location>(); locations.Add(new Location(id: null, locationName: location, documentEndpoint: null, provisioningState: null, failoverPriority: null, isZoneRedundant: false)); var databaseAccountCreateOrUpdateParameters = new DatabaseAccountCreateUpdateParameters(locations); databaseAccountCreateOrUpdateParameters.Location = location; databaseAccountCreateOrUpdateParameters.Tags.Add("key1", "value1"); databaseAccountCreateOrUpdateParameters.Tags.Add("key2", "value2"); databaseAccountCreateOrUpdateParameters.Kind = DatabaseAccountKind.MongoDB; databaseAccountCreateOrUpdateParameters.ConsistencyPolicy = new ConsistencyPolicy(DefaultConsistencyLevel.BoundedStaleness, maxStalenessPrefix, maxIntervalInSeconds); databaseAccountCreateOrUpdateParameters.IpRules.Add(new IpAddressOrRange("23.43.230.120")); databaseAccountCreateOrUpdateParameters.IsVirtualNetworkFilterEnabled = true; databaseAccountCreateOrUpdateParameters.EnableAutomaticFailover = false; databaseAccountCreateOrUpdateParameters.ConnectorOffer = "Small"; databaseAccountCreateOrUpdateParameters.DisableKeyBasedMetadataWriteAccess = false; DatabaseAccount databaseAccount1 = await WaitForCompletionAsync( await CosmosDBManagementClient.DatabaseAccounts.StartCreateOrUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountCreateOrUpdateParameters)); var response = await CosmosDBManagementClient.DatabaseAccounts.CheckNameExistsAsync(databaseAccountName); Assert.AreEqual(true, response.Value); Assert.AreEqual(200, response.GetRawResponse().Status); DatabaseAccount databaseAccount2 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName); VerifyCosmosDBAccount(databaseAccount1, databaseAccount2); var databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters(); databaseAccountUpdateParameters.Tags.Add("key3", "value3"); databaseAccountUpdateParameters.Tags.Add("key4", "value4"); databaseAccountUpdateParameters.IsVirtualNetworkFilterEnabled = false; databaseAccountUpdateParameters.EnableAutomaticFailover = true; databaseAccountUpdateParameters.DisableKeyBasedMetadataWriteAccess = true; await WaitForCompletionAsync( await CosmosDBManagementClient.DatabaseAccounts.StartUpdateAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters)); var failoverPolicyList = new List <FailoverPolicy>(); failoverPolicyList.Add(new FailoverPolicy() { LocationName = location, FailoverPriority = 0 }); FailoverPolicies failoverPolicies = new FailoverPolicies(failoverPolicyList); await WaitForCompletionAsync( await CosmosDBManagementClient.DatabaseAccounts.StartFailoverPriorityChangeAsync(resourceGroupName, databaseAccountName, failoverPolicies)); DatabaseAccount databaseAccount3 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName); VerifyCosmosDBAccount(databaseAccount3, databaseAccountUpdateParameters); VerifyFailoverPolicies(failoverPolicyList, databaseAccount3.FailoverPolicies); }
private void CreateCosmosDB(string location, string cosmosDBAccountName, ResourceGroup resourceGroup) { var dbAccount = new DatabaseAccount(cosmosDBAccountName, new DatabaseAccountArgs { AccountName = cosmosDBAccountName, ResourceGroupName = resourceGroup.Name, Location = resourceGroup.Location, Locations = { new LocationArgs { LocationName = location, FailoverPriority = 0 } }, DatabaseAccountOfferType = DatabaseAccountOfferType.Standard, Capabilities = new[] { new Pulumi.AzureNextGen.DocumentDB.Latest.Inputs.CapabilityArgs { Name = "EnableServerless" } } }); // Export the primary key of the Storage Account this.CosmosConnectionString = Output.Tuple(resourceGroup.Name, dbAccount.Name).Apply(names => Output.CreateSecret(GetCosmosConnectionString(names.Item1, names.Item2))); var dbName = "todos-db"; var cosmosSqlDB = new SqlResourceSqlDatabase(dbName, new SqlResourceSqlDatabaseArgs { AccountName = dbAccount.Name, DatabaseName = dbName, Options = new CreateUpdateOptionsArgs(), Resource = new SqlDatabaseResourceArgs { Id = dbName }, ResourceGroupName = resourceGroup.Name, Location = resourceGroup.Location }); var containerName = "todos-sql-Container"; var dbContainer = new SqlResourceSqlContainer(containerName, new SqlResourceSqlContainerArgs { AccountName = dbAccount.Name, ContainerName = containerName, DatabaseName = cosmosSqlDB.Name, ResourceGroupName = resourceGroup.Name, Location = resourceGroup.Location, Options = new CreateUpdateOptionsArgs(), Resource = new SqlContainerResourceArgs { Id = containerName } }); }
public async Task TestTearDown() { DatabaseAccount account = await DatabaseAccountCollection.GetIfExistsAsync(_databaseAccountName); if (account != null) { await account.DeleteAsync(WaitUntil.Completed); } }
public static DatabaseAccount GetDatabaseAccount(this ArmClient client, ResourceIdentifier id) { return(client.GetClient(() => { DatabaseAccount.ValidateResourceId(id); return new DatabaseAccount(client, id); } )); }
public async Task TestTearDown() { DatabaseAccount account = await DatabaseAccountCollection.GetIfExistsAsync(_databaseAccountName); if (account != null) { await account.Delete().WaitForCompletionResponseAsync(); } }
public async Task GlobalSetup() { _resourceGroup = await GlobalClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync(); _databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.MongoDB); _mongoDBDatabaseId = (await MongoDBDatabaseTests.CreateMongoDBDatabase(SessionRecording.GenerateAssetName("mongodb-"), null, _databaseAccount.GetMongoDBDatabases())).Id; await StopSessionRecordingAsync(); }
public async Task DatabaseAccountListByResourceGroupTest() { List <DatabaseAccount> databaseAccounts = await CosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName).ToEnumerableAsync(); Assert.IsNotNull(databaseAccounts); Assert.AreEqual(1, databaseAccounts.Count); DatabaseAccount expectedDatabaseAccount = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName); VerifyCosmosDBAccount(expectedDatabaseAccount, databaseAccounts[0]); }
public async Task GlobalSetup() { _resourceGroup = await GlobalClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync(); _databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.GlobalDocumentDB, new DatabaseAccountCapability("EnableCassandra")); _cassandraKeyspaceId = (await CassandraKeyspaceTests.CreateCassandraKeyspace(SessionRecording.GenerateAssetName("cassandra-keyspace-"), null, _databaseAccount.GetCassandraKeyspaces())).Id; await StopSessionRecordingAsync(); }
protected override void ProcessRecord() { var uri = base.Context.Properties["Uri"].Value.ToString(); var key = base.Context.Properties["Key"].Value.ToString(); var client = new DocumentClient(new Uri(uri), key); var task = client.GetDatabaseAccountAsync(); task.Wait(); DatabaseAccount db = task.Result; WriteObject(db.ConsistencyPolicy.DefaultConsistencyLevel); }
public async Task GlobalSetup() { _resourceGroup = await GlobalClient.GetResourceGroup(_resourceGroupIdentifier).GetAsync(); _databaseAccount = await CreateDatabaseAccount(SessionRecording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.GlobalDocumentDB); _sqlDatabase = await SqlDatabaseTests.CreateSqlDatabase(SessionRecording.GenerateAssetName("sql-db-"), null, _databaseAccount.GetSqlDatabases()); _sqlContainerId = (await SqlContainerTests.CreateSqlContainer(SessionRecording.GenerateAssetName("sql-container-"), null, _sqlDatabase.GetSqlContainers())).Id; await StopSessionRecordingAsync(); }
public static async Task Main(string[] args) { Console.WriteLine("Started"); using (DocumentClient client = new DocumentClient(endPointUri, primaryKey)) { DatabaseAccount account = await client.GetDatabaseAccountAsync(); await client.OpenAsync(); await CreateDatabase(client); await CreateDefaultCollection(client); bool isSQL = IsSQLAPI(account); await CreateCustomCollectionsAndIndexingPolicies(client); await Populator.PopulateUnlimitedCollectionWithData(client); } }
public CosmosDBMongoDB(string name, CosmosDBMongoDBArgs args) : base("example:component:CosmosDBMongoDB", name) { var config = new Config("azure-native"); var location = config.Require("location"); var databaseAccount = new DatabaseAccount("cosmos-mongodb", new DatabaseAccountArgs { ResourceGroupName = args.ResourceGroupName, DatabaseAccountOfferType = DatabaseAccountOfferType.Standard, Kind = DatabaseAccountKind.MongoDB, ConsistencyPolicy = new ConsistencyPolicyArgs { DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness, MaxIntervalInSeconds = 10, MaxStalenessPrefix = 200, }, Locations = { new LocationArgs { FailoverPriority = 0, LocationName = location } } }, new CustomResourceOptions { Parent = this }); this.AccountName = databaseAccount.Name; var database = new MongoDBResourceMongoDBDatabase(args.DatabaseName, new MongoDBResourceMongoDBDatabaseArgs { ResourceGroupName = args.ResourceGroupName, AccountName = databaseAccount.Name, Resource = new MongoDBDatabaseResourceArgs { Id = args.DatabaseName } }, new CustomResourceOptions { Parent = this }); this.DatabaseName = database.Name; }
// 利用可能リージョンを追加 private static async Task <ConnectionPolicy> AddPreferredLocations(ConnectionPolicy cp) { var preClient = new DocumentClient( new Uri(ConfigurationManager.AppSettings["endpoint"]), ConfigurationManager.AppSettings["authKey"] ); DatabaseAccount db = await preClient.GetDatabaseAccountAsync(); var locations = db.ReadableLocations; foreach (var l in locations) { if (l.Name != ConfigurationManager.AppSettings["appRegion"]) { cp.PreferredLocations.Add(l.Name); } } preClient.Dispose(); return(cp); }
public async Task DatabaseAccountListBySubscriptionTest() { List <DatabaseAccount> databaseAccounts = await CosmosDBManagementClient.DatabaseAccounts.ListAsync().ToEnumerableAsync(); Assert.IsNotNull(databaseAccounts); bool databaseAccountFound = false; DatabaseAccount actualDatabaseAccount = null; foreach (DatabaseAccount databaseAccount in databaseAccounts) { if (databaseAccount.Name == databaseAccountName) { databaseAccountFound = true; actualDatabaseAccount = databaseAccount; } } Assert.AreEqual(true, databaseAccountFound); DatabaseAccount expectedDatabaseAccount = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName); VerifyCosmosDBAccount(expectedDatabaseAccount, actualDatabaseAccount); }
public async Task DatabaseAccountCreateAndUpdateTest() { var account = await CreateDatabaseAccount(Recording.GenerateAssetName("dbaccount-"), DatabaseAccountKind.MongoDB); bool ifExists = await DatabaseAccountCollection.ExistsAsync(_databaseAccountName); Assert.AreEqual(true, ifExists); DatabaseAccount account2 = await DatabaseAccountCollection.GetAsync(_databaseAccountName); VerifyCosmosDBAccount(account, account2); var updateOptions = new PatchableDatabaseAccountData() { IsVirtualNetworkFilterEnabled = false, EnableAutomaticFailover = true, DisableKeyBasedMetadataWriteAccess = true, }; updateOptions.Tags.Add("key3", "value3"); updateOptions.Tags.Add("key4", "value4"); await account2.UpdateAsync(WaitUntil.Completed, updateOptions); var failoverPolicyList = new List <FailoverPolicy> { new FailoverPolicy() { LocationName = AzureLocation.WestUS, FailoverPriority = 0 } }; FailoverPolicies failoverPolicies = new FailoverPolicies(failoverPolicyList); await account2.FailoverPriorityChangeAsync(WaitUntil.Completed, new FailoverPolicies(failoverPolicyList)); DatabaseAccount account3 = await DatabaseAccountCollection.GetAsync(_databaseAccountName); VerifyCosmosDBAccount(account3, updateOptions); VerifyFailoverPolicies(failoverPolicyList, account3.Data.FailoverPolicies); }
public MyStack() { Config config = new Config(); // Create an Azure Resource Group var resourceGroup = new ResourceGroup("resourceGroup", new ResourceGroupArgs { ResourceGroupName = "pulumidemo", Location = "AustraliaSouthEast" }); // Create a Cosmos DB Database string cosmosAccountName = "mypulumidemo-dev"; var cosmosAccount = new DatabaseAccount(cosmosAccountName, new DatabaseAccountArgs() { AccountName = cosmosAccountName, ResourceGroupName = resourceGroup.Name, Location = resourceGroup.Location, ConsistencyPolicy = new ConsistencyPolicyArgs() { DefaultConsistencyLevel = "Session" }, DatabaseAccountOfferType = "Standard", EnableFreeTier = false, EnableMultipleWriteLocations = false, IsVirtualNetworkFilterEnabled = false, Locations = { new LocationArgs { FailoverPriority = 0, IsZoneRedundant = false, LocationName = resourceGroup.Location, } } }); // Export the CosmosDb Connection String this.CosmosDatabaseConnectionString = Output .Tuple(resourceGroup.Name, cosmosAccount.Name) .Apply(names => Output.CreateSecret(GetCosmosDatabaseConnectionString(names.Item1, names.Item2))); // set with > pulumi config set myCosmosDb.autoScaleThroughput 4000 int autoScaleThroughput = config.RequireInt32("myCosmosDb.autoScaleThroughput"); string cosmosDatabaseName = "myCosmosDatabase"; var cosmosSqlDatabase = new SqlResourceSqlDatabase(cosmosDatabaseName, new SqlResourceSqlDatabaseArgs() { DatabaseName = cosmosDatabaseName, AccountName = cosmosAccount.Name, ResourceGroupName = resourceGroup.Name, Location = resourceGroup.Location, Resource = new SqlDatabaseResourceArgs() { Id = cosmosDatabaseName }, Options = new CreateUpdateOptionsArgs() { AutoscaleSettings = new AutoscaleSettingsArgs() { MaxThroughput = autoScaleThroughput } } }); string rulesContainerName = "rules"; var rulesContainer = new SqlResourceSqlContainer(rulesContainerName, new SqlResourceSqlContainerArgs { AccountName = cosmosAccount.Name, ContainerName = rulesContainerName, DatabaseName = cosmosSqlDatabase.Name, ResourceGroupName = resourceGroup.Name, Location = resourceGroup.Location, Options = new CreateUpdateOptionsArgs() { }, Resource = new SqlContainerResourceArgs { Id = rulesContainerName, IndexingPolicy = new IndexingPolicyArgs { Automatic = true, IndexingMode = "Consistent", }, PartitionKey = new ContainerPartitionKeyArgs { Kind = "Hash", Paths = { "/id", }, } } }); // Create an AppService Plan (Web Server) string appServicePlanName = "myRulesServer"; var appServicePlan = new AppServicePlan(appServicePlanName, new AppServicePlanArgs { Name = appServicePlanName, Location = resourceGroup.Location, ResourceGroupName = resourceGroup.Name, Kind = "app", Sku = new SkuDescriptionArgs { Capacity = 1, Family = "P", Name = "P1", Size = "P1", Tier = "Premium", } }); // Create a WebApp string appServiceName = "myRulesApp"; var appService = new WebApp(appServiceName, new WebAppArgs { Name = appServiceName, Location = resourceGroup.Location, ResourceGroupName = resourceGroup.Name, ServerFarmId = appServicePlan.Id, SiteConfig = new SiteConfigArgs() { AlwaysOn = true, AppSettings = new InputList <NameValuePairArgs>() { }, ConnectionStrings = new InputList <ConnStringInfoArgs>() { new ConnStringInfoArgs() { Name = "RulesDatabase", Type = "Custom", ConnectionString = Output .Tuple(resourceGroup.Name, cosmosAccount.Name) .Apply(names => Output.Create(GetCosmosDatabaseConnectionString(names.Item1, names.Item2))) } } } }); }
private static bool IsSQLAPI(DatabaseAccount account) { //TODO - Check for a simple write and read. The exception will occur if CosmosDB Account is not SQL API. Differentiate the exception and determine the API model. return(true); }
public async Task SetUp() { _databaseAccount = await ArmClient.GetDatabaseAccount(_databaseAccountIdentifier).GetAsync(); }
public static DatabaseAccount GetDatabaseAccount(this ArmClient armClient, ResourceIdentifier id) { DatabaseAccount.ValidateResourceId(id); return(new DatabaseAccount(armClient, id)); }