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