private void VerifyCosmosDBAccount(DatabaseAccountResource databaseAccount, DatabaseAccountUpdateParameters parameters)
{
Assert.True(databaseAccount.Tags.SequenceEqual(parameters.Tags));
Assert.AreEqual(databaseAccount.IsVirtualNetworkFilterEnabled, parameters.IsVirtualNetworkFilterEnabled);
Assert.AreEqual(databaseAccount.EnableAutomaticFailover, parameters.EnableAutomaticFailover);
Assert.AreEqual(databaseAccount.DisableKeyBasedMetadataWriteAccess, parameters.DisableKeyBasedMetadataWriteAccess);
}
private DatabaseAccountUpdateParameters UpdateParametersInner(DatabaseAccountGetResultsInner inner)
{
this.EnsureFailoverIsInitialized();
var updateParametersInner = new DatabaseAccountUpdateParameters();
updateParametersInner.Tags = inner.Tags;
updateParametersInner.Location = this.RegionName.ToLower();
updateParametersInner.ConsistencyPolicy = inner.ConsistencyPolicy;
updateParametersInner.IpRangeFilter = inner.IpRangeFilter;
updateParametersInner.IsVirtualNetworkFilterEnabled = inner.IsVirtualNetworkFilterEnabled;
updateParametersInner.EnableAutomaticFailover = inner.EnableAutomaticFailover;
updateParametersInner.Capabilities = inner.Capabilities;
updateParametersInner.EnableMultipleWriteLocations = inner.EnableMultipleWriteLocations;
updateParametersInner.EnableCassandraConnector = inner.EnableCassandraConnector;
updateParametersInner.ConnectorOffer = inner.ConnectorOffer;
updateParametersInner.DisableKeyBasedMetadataWriteAccess = inner.DisableKeyBasedMetadataWriteAccess;
updateParametersInner.KeyVaultKeyUri = inner.KeyVaultKeyUri;
if (virtualNetworkRulesMap != null)
{
updateParametersInner.VirtualNetworkRules = this.virtualNetworkRulesMap.Values.SelectMany(l => l).ToList();
this.virtualNetworkRulesMap = null;
}
AddLocationsForParameters(new UpdateLocationParameters(updateParametersInner), this.failoverPolicies);
return(updateParametersInner);
}
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;
DatabaseAccountGetResults databaseAccountGetResults1 =
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);
DatabaseAccountGetResults databaseAccountGetResults2 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(databaseAccountGetResults1, databaseAccountGetResults2);
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));
DatabaseAccountGetResults databaseAccountGetResults3 = await CosmosDBManagementClient.DatabaseAccounts.GetAsync(resourceGroupName, databaseAccountName);
VerifyCosmosDBAccount(databaseAccountGetResults3, databaseAccountUpdateParameters);
VerifyFailoverPolicies(failoverPolicyList, databaseAccountGetResults3.FailoverPolicies);
}
public override void ExecuteCmdlet()
{
if (!ParameterSetName.Equals(NameParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = null;
if (ParameterSetName.Equals(ResourceIdParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(ResourceId);
}
else if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(InputObject.Id);
}
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
}
List <Location> locations = new List <Location>();
if (Location != null || LocationObject != null)
{
if (Location != null && Location.Length > 0)
{
int failoverPriority = 0;
foreach (string location in Location)
{
locations.Add(new Location(locationName: location, failoverPriority: failoverPriority));
failoverPriority++;
}
}
if (LocationObject != null && LocationObject.Length > 0)
{
foreach (PSLocation psLocation in LocationObject)
{
locations.Add(PSLocation.ConvertPSLocationToLocation(psLocation));
}
}
}
else
{
WriteWarning("Cannot Add Region if no location is provided.");
return;
}
DatabaseAccountUpdateParameters createUpdateParameters = new DatabaseAccountUpdateParameters(locations: locations);
if (ShouldProcess(Name, "Updating Database Account Region"))
{
CosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(ResourceGroupName, Name, createUpdateParameters).GetAwaiter().GetResult();
DatabaseAccountGetResults databaseAccount = CosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(ResourceGroupName, Name).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccount(databaseAccount));
}
return;
}
public void DatabaseAccountCRUDTests()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = CosmosDBTestUtilities.CreateResourceGroup(resourcesClient);
string databaseAccountName = TestUtilities.GenerateName(prefix: "accountname");
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: location));
DefaultRequestDatabaseAccountCreateUpdateProperties databaseAccountCreateUpdateProperties = new DefaultRequestDatabaseAccountCreateUpdateProperties
{
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = locations,
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = true,
EnableAutomaticFailover = false,
EnableMultipleWriteLocations = true,
EnableCassandraConnector = true,
ConnectorOffer = "Small",
DisableKeyBasedMetadataWriteAccess = false
};
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = location,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
Properties = databaseAccountCreateUpdateProperties
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(databaseAccount, databaseAccountCreateUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
DatabaseAccountGetResults readDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(readDatabaseAccount, databaseAccountCreateUpdateParameters);
Assert.Equal(databaseAccountName, readDatabaseAccount.Name);
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = location,
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = locations,
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
EnableCassandraConnector = true,
ConnectorOffer = "Small",
DisableKeyBasedMetadataWriteAccess = true
};
DatabaseAccountGetResults updatedDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(updatedDatabaseAccount, databaseAccountUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
IEnumerable <DatabaseAccountGetResults> databaseAccounts = cosmosDBManagementClient.DatabaseAccounts.ListWithHttpMessagesAsync().GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccounts);
IEnumerable <DatabaseAccountGetResults> databaseAccountsByResourceGroupName = cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountsByResourceGroupName);
DatabaseAccountListKeysResult databaseAccountListKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListKeysResult.PrimaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.PrimaryReadonlyMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryReadonlyMasterKey);
DatabaseAccountListConnectionStringsResult databaseAccountListConnectionStringsResult = cosmosDBManagementClient.DatabaseAccounts.ListConnectionStringsWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListConnectionStringsResult);
DatabaseAccountListReadOnlyKeysResult databaseAccountGetReadOnlyKeysResult = cosmosDBManagementClient.DatabaseAccounts.GetReadOnlyKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountGetReadOnlyKeysResult);
DatabaseAccountListReadOnlyKeysResult databaseAccountListReadOnlyKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListReadOnlyKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListReadOnlyKeysResult);
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primary"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondary"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primaryReadonly"
});
cosmosDBManagementClient.DatabaseAccounts.RegenerateKeyWithHttpMessagesAsync(resourceGroupName, databaseAccountName, new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondaryReadonly"
});
DatabaseAccountListKeysResult databaseAccountListRegeneratedKeysResult = cosmosDBManagementClient.DatabaseAccounts.ListKeysWithHttpMessagesAsync(resourceGroupName, databaseAccountName).GetAwaiter().GetResult().Body;
cosmosDBManagementClient.DatabaseAccounts.DeleteWithHttpMessagesAsync(resourceGroupName, databaseAccountName);
}
}
private static void VerifyCosmosDBAccount(DatabaseAccountGetResults databaseAccount, DatabaseAccountUpdateParameters parameters)
{
Assert.Equal(databaseAccount.Location.ToLower(), parameters.Location.ToLower());
Assert.Equal(databaseAccount.Tags.Count, parameters.Tags.Count);
Assert.True(databaseAccount.Tags.SequenceEqual(parameters.Tags));
VerifyConsistencyPolicy(databaseAccount.ConsistencyPolicy, parameters.ConsistencyPolicy);
Assert.Equal(databaseAccount.IsVirtualNetworkFilterEnabled, parameters.IsVirtualNetworkFilterEnabled);
Assert.Equal(databaseAccount.EnableAutomaticFailover, parameters.EnableAutomaticFailover);
Assert.Equal(databaseAccount.EnableCassandraConnector, parameters.EnableCassandraConnector);
Assert.Equal(databaseAccount.ConnectorOffer, parameters.ConnectorOffer);
Assert.Equal(databaseAccount.DisableKeyBasedMetadataWriteAccess, parameters.DisableKeyBasedMetadataWriteAccess);
}
public override void ExecuteCmdlet()
{
if (!ParameterSetName.Equals(NameParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = null;
if (ParameterSetName.Equals(ResourceIdParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(ResourceId);
}
else if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(InputObject.Id);
}
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
}
DatabaseAccountGetResults readDatabase = CosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(ResourceGroupName, Name).GetAwaiter().GetResult().Body;
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters(locations: readDatabase.Locations, location: readDatabase.WriteLocations.ElementAt(0).LocationName);
if (EnableMultipleWriteLocations != null)
{
databaseAccountUpdateParameters.EnableMultipleWriteLocations = EnableMultipleWriteLocations;
}
if (EnableVirtualNetwork != null)
{
databaseAccountUpdateParameters.IsVirtualNetworkFilterEnabled = EnableVirtualNetwork;
}
if (EnableAutomaticFailover != null)
{
databaseAccountUpdateParameters.EnableAutomaticFailover = EnableAutomaticFailover;
}
if (DisableKeyBasedMetadataWriteAccess != null)
{
databaseAccountUpdateParameters.DisableKeyBasedMetadataWriteAccess = DisableKeyBasedMetadataWriteAccess;
}
if (PublicNetworkAccess != null)
{
databaseAccountUpdateParameters.PublicNetworkAccess = PublicNetworkAccess;
}
if (KeyVaultKeyUri != null)
{
databaseAccountUpdateParameters.KeyVaultKeyUri = KeyVaultKeyUri;
}
if (EnableAnalyticalStorage != null)
{
databaseAccountUpdateParameters.EnableAnalyticalStorage = EnableAnalyticalStorage;
}
if (NetworkAclBypass != null)
{
databaseAccountUpdateParameters.NetworkAclBypass =
NetworkAclBypass == "AzureServices" ? SDKModel.NetworkAclBypass.AzureServices : SDKModel.NetworkAclBypass.None;
}
if (!string.IsNullOrEmpty(DefaultConsistencyLevel))
{
databaseAccountUpdateParameters.ConsistencyPolicy = base.PopoulateConsistencyPolicy(DefaultConsistencyLevel, MaxStalenessIntervalInSeconds, MaxStalenessPrefix);
}
if (Tag != null)
{
databaseAccountUpdateParameters.Tags = base.PopulateTags(Tag);
}
if (VirtualNetworkRule != null || VirtualNetworkRuleObject != null)
{
Collection <VirtualNetworkRule> virtualNetworkRule = new Collection <VirtualNetworkRule>();
if (VirtualNetworkRule != null && VirtualNetworkRule.Length > 0)
{
foreach (string id in VirtualNetworkRule)
{
virtualNetworkRule.Add(new VirtualNetworkRule(id: id));
}
}
if (VirtualNetworkRuleObject != null && VirtualNetworkRuleObject.Length > 0)
{
foreach (PSVirtualNetworkRule psVirtualNetworkRule in VirtualNetworkRuleObject)
{
virtualNetworkRule.Add(PSVirtualNetworkRule.ToSDKModel(psVirtualNetworkRule));
}
}
databaseAccountUpdateParameters.VirtualNetworkRules = virtualNetworkRule;
}
if (IpRule != null)
{
// not checking IpRules.Length > 0, to handle the removal of IpRules case
databaseAccountUpdateParameters.IpRules = base.PopulateIpRules(IpRule);
}
if (ServerVersion != null)
{
if (databaseAccountUpdateParameters.ApiProperties == null)
{
databaseAccountUpdateParameters.ApiProperties = new ApiProperties();
}
databaseAccountUpdateParameters.ApiProperties.ServerVersion = ServerVersion;
}
if (NetworkAclBypassResourceId != null)
{
Collection <string> networkAclBypassResourceId = new Collection <string>(NetworkAclBypassResourceId);
databaseAccountUpdateParameters.NetworkAclBypassResourceIds = networkAclBypassResourceId;
}
if (BackupIntervalInMinutes.HasValue || BackupRetentionIntervalInHours.HasValue || !string.IsNullOrEmpty(BackupStorageRedundancy))
{
if (BackupPolicyType == "Continuous")
{
WriteWarning("Cannot set BackupPolicyType along with BackupInterval or BackupRetention parameters");
return;
}
if (readDatabase.BackupPolicy is PeriodicModeBackupPolicy)
{
databaseAccountUpdateParameters.BackupPolicy = new PeriodicModeBackupPolicy()
{
PeriodicModeProperties = new PeriodicModeProperties()
{
BackupIntervalInMinutes = BackupIntervalInMinutes,
BackupRetentionIntervalInHours = BackupRetentionIntervalInHours,
BackupStorageRedundancy = BackupStorageRedundancy
}
};
}
else
{
WriteWarning("Can accept BackupInterval or BackupRetention parameters only for accounts with PeriodicMode backup policy");
return;
}
}
// Update backup policy to ContinuousModeBackupPolicy
if (BackupPolicyType == "Continuous" && readDatabase.BackupPolicy is PeriodicModeBackupPolicy)
{
databaseAccountUpdateParameters.BackupPolicy = new ContinuousModeBackupPolicy();
}
// Update analytical storage schema type.
databaseAccountUpdateParameters.AnalyticalStorageConfiguration = CreateAnalyticalStorageConfiguration(AnalyticalStorageSchemaType);
if (ShouldProcess(Name, "Updating Database Account"))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(ResourceGroupName, Name, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccountGetResults(cosmosDBAccount));
}
return;
}
public override void ExecuteCmdlet()
{
if (!ParameterSetName.Equals(NameParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = null;
if (ParameterSetName.Equals(ResourceIdParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(ResourceId);
}
else if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(InputObject.Id);
}
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
}
DatabaseAccountGetResults readDatabase = CosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(ResourceGroupName, Name).GetAwaiter().GetResult().Body;
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters(locations: readDatabase.Locations, location: readDatabase.WriteLocations.ElementAt(0).LocationName);
if (EnableMultipleWriteLocations != null)
{
databaseAccountUpdateParameters.EnableMultipleWriteLocations = EnableMultipleWriteLocations;
}
if (EnableVirtualNetwork != null)
{
databaseAccountUpdateParameters.IsVirtualNetworkFilterEnabled = EnableVirtualNetwork;
}
if (EnableAutomaticFailover != null)
{
databaseAccountUpdateParameters.EnableAutomaticFailover = EnableAutomaticFailover;
}
if (DisableKeyBasedMetadataWriteAccess != null)
{
databaseAccountUpdateParameters.DisableKeyBasedMetadataWriteAccess = DisableKeyBasedMetadataWriteAccess;
}
if (PublicNetworkAccess != null)
{
databaseAccountUpdateParameters.PublicNetworkAccess = PublicNetworkAccess;
}
if (!string.IsNullOrEmpty(DefaultConsistencyLevel))
{
ConsistencyPolicy consistencyPolicy = new ConsistencyPolicy();
{
switch (DefaultConsistencyLevel)
{
case "Strong":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Strong;
break;
case "Session":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Session;
break;
case "Eventual":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Eventual;
break;
case "ConsistentPrefix":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.ConsistentPrefix;
break;
case "BoundedStaleness":
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.BoundedStaleness;
consistencyPolicy.MaxIntervalInSeconds = MaxStalenessIntervalInSeconds;
consistencyPolicy.MaxStalenessPrefix = MaxStalenessPrefix;
break;
default:
consistencyPolicy.DefaultConsistencyLevel = Management.CosmosDB.Models.DefaultConsistencyLevel.Session;
break;
}
databaseAccountUpdateParameters.ConsistencyPolicy = consistencyPolicy;
}
}
if (Tag != null)
{
Dictionary <string, string> tags = new Dictionary <string, string>();
foreach (string key in Tag.Keys)
{
tags.Add(key, Tag[key].ToString());
}
databaseAccountUpdateParameters.Tags = tags;
}
if (VirtualNetworkRule != null || VirtualNetworkRuleObject != null)
{
Collection <VirtualNetworkRule> virtualNetworkRule = new Collection <VirtualNetworkRule>();
if (VirtualNetworkRule != null && VirtualNetworkRule.Length > 0)
{
foreach (string id in VirtualNetworkRule)
{
virtualNetworkRule.Add(new VirtualNetworkRule(id: id));
}
}
if (VirtualNetworkRuleObject != null && VirtualNetworkRuleObject.Length > 0)
{
foreach (PSVirtualNetworkRule psVirtualNetworkRule in VirtualNetworkRuleObject)
{
virtualNetworkRule.Add(PSVirtualNetworkRule.ConvertPSVirtualNetworkRuleToVirtualNetworkRule(psVirtualNetworkRule));
}
}
databaseAccountUpdateParameters.VirtualNetworkRules = virtualNetworkRule;
}
if (IpRangeFilter != null)
{
string IpRangeFilterAsString = IpRangeFilter?.Aggregate(string.Empty, (output, next) => string.Concat(output, (!string.IsNullOrWhiteSpace(output) && !string.IsNullOrWhiteSpace(next) ? "," : string.Empty), next)) ?? string.Empty;
databaseAccountUpdateParameters.IpRangeFilter = IpRangeFilterAsString;
}
if (ShouldProcess(Name, "Updating Database Account"))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(ResourceGroupName, Name, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccount(cosmosDBAccount));
}
return;
}
public async Task RestorableSqlDatabaseResourceFeedTest()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ResourceManagementClient resourcesClient = CosmosDBTestUtilities.GetResourceManagementClient(context, handler2);
string resourceGroupName = CosmosDBTestUtilities.CreateResourceGroup(resourcesClient);
string databaseAccountName = TestUtilities.GenerateName(prefix: "accountname");
List <Location> locations = new List <Location>();
locations.Add(new Location(locationName: "East US 2"));
DatabaseAccountCreateUpdateParameters databaseAccountCreateUpdateParameters = new DatabaseAccountCreateUpdateParameters
{
Location = "EAST US 2",
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = locations
};
DatabaseAccountGetResults databaseAccount = cosmosDBManagementClient.DatabaseAccounts.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountCreateUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccount);
List <DatabaseAccountGetResults> databaseFeedResult = (await cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName)).ToList();
Assert.Single(databaseFeedResult);
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = "EAST US 2",
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = locations,
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
DisableKeyBasedMetadataWriteAccess = true,
NetworkAclBypass = NetworkAclBypass.AzureServices,
NetworkAclBypassResourceIds = new List <string>
{
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName",
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName2"
}
};
DatabaseAccountGetResults updatedDatabaseAccount = cosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(resourceGroupName, databaseAccountName, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
Assert.NotNull(updatedDatabaseAccount);
databaseFeedResult = (await cosmosDBManagementClient.DatabaseAccounts.ListByResourceGroupAsync(resourceGroupName)).ToList();
Assert.Single(databaseFeedResult);
await cosmosDBManagementClient.DatabaseAccounts.DeleteWithHttpMessagesAsync(resourceGroupName, databaseAccountName);
}
}
public UpdateLocationParameters(DatabaseAccountUpdateParameters updateParameters)
{
parameters = updateParameters;
}
public void DatabaseAccountCRUDTests()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
var databaseAccountName = TestUtilities.GenerateName(prefix: "accountname");
var accountClient = this.fixture.CosmosDBManagementClient.DatabaseAccounts;
// Create and check
var parameters = new DatabaseAccountCreateUpdateParameters
{
Location = this.fixture.Location,
Tags = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" }
},
Kind = "MongoDB",
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.BoundedStaleness,
MaxStalenessPrefix = 300,
MaxIntervalInSeconds = 1000
},
Locations = new List <Location> {
new Location(locationName: this.fixture.Location)
},
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = true,
EnableAutomaticFailover = false,
EnableMultipleWriteLocations = true,
DisableKeyBasedMetadataWriteAccess = false,
NetworkAclBypass = NetworkAclBypass.AzureServices,
NetworkAclBypassResourceIds = new List <string>
{
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName"
},
CreateMode = CreateMode.Default
};
var databaseAccount = accountClient.CreateOrUpdateWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
parameters
).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(databaseAccount, parameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
// Read and check
var readDatabaseAccount = accountClient.GetWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(readDatabaseAccount, parameters);
Assert.Equal(databaseAccountName, readDatabaseAccount.Name);
// Update and check
var databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters
{
Location = this.fixture.Location,
Tags = new Dictionary <string, string>
{
{ "key3", "value3" },
{ "key4", "value4" }
},
ConsistencyPolicy = new ConsistencyPolicy
{
DefaultConsistencyLevel = DefaultConsistencyLevel.Session,
MaxStalenessPrefix = 1300,
MaxIntervalInSeconds = 12000
},
Locations = new List <Location> {
new Location(locationName: this.fixture.Location)
},
IpRules = new List <IpAddressOrRange>
{
new IpAddressOrRange("23.43.230.120")
},
IsVirtualNetworkFilterEnabled = false,
EnableAutomaticFailover = true,
DisableKeyBasedMetadataWriteAccess = true,
NetworkAclBypass = NetworkAclBypass.AzureServices,
NetworkAclBypassResourceIds = new List <string>
{
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName",
"/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName2"
}
};
var updatedDatabaseAccount = accountClient.UpdateWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
databaseAccountUpdateParameters
).GetAwaiter().GetResult().Body;
VerifyCosmosDBAccount(updatedDatabaseAccount, databaseAccountUpdateParameters);
Assert.Equal(databaseAccountName, databaseAccount.Name);
// List database accounts, should not be empty
var databaseAccounts = accountClient.ListWithHttpMessagesAsync().GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccounts);
var databaseAccountsByResourceGroupName = accountClient.ListByResourceGroupWithHttpMessagesAsync(
this.fixture.ResourceGroupName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountsByResourceGroupName);
var databaseAccountListKeysResult = accountClient.ListKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListKeysResult.PrimaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryMasterKey);
Assert.NotNull(databaseAccountListKeysResult.PrimaryReadonlyMasterKey);
Assert.NotNull(databaseAccountListKeysResult.SecondaryReadonlyMasterKey);
var databaseAccountListConnectionStringsResult = accountClient.ListConnectionStringsWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListConnectionStringsResult);
var databaseAccountGetReadOnlyKeysResult = accountClient.GetReadOnlyKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountGetReadOnlyKeysResult);
var databaseAccountListReadOnlyKeysResult = accountClient.ListReadOnlyKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
Assert.NotNull(databaseAccountListReadOnlyKeysResult);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primary"
}
);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondary"
}
);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "primaryReadonly"
}
);
accountClient.RegenerateKeyWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName,
new DatabaseAccountRegenerateKeyParameters {
KeyKind = "secondaryReadonly"
}
);
var databaseAccountListRegeneratedKeysResult = accountClient.ListKeysWithHttpMessagesAsync(
this.fixture.ResourceGroupName,
databaseAccountName
).GetAwaiter().GetResult().Body;
accountClient.DeleteWithHttpMessagesAsync(this.fixture.ResourceGroupName, databaseAccountName);
}
}
/// <summary>
/// Updates the properties of an existing Azure Cosmos DB database account.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of an Azure resource group.
/// </param>
/// <param name='accountName'>
/// Cosmos DB database account name.
/// </param>
/// <param name='updateParameters'>
/// The parameters to provide for the current database account.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <DatabaseAccountGetResultsInner> UpdateAsync(this IDatabaseAccountsOperations operations, string resourceGroupName, string accountName, DatabaseAccountUpdateParameters updateParameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, accountName, updateParameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public override void ExecuteCmdlet()
{
if (!ParameterSetName.Equals(NameParameterSet, StringComparison.Ordinal))
{
ResourceIdentifier resourceIdentifier = null;
if (ParameterSetName.Equals(ResourceIdParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(ResourceId);
}
else if (ParameterSetName.Equals(ObjectParameterSet, StringComparison.Ordinal))
{
resourceIdentifier = new ResourceIdentifier(InputObject.Id);
}
ResourceGroupName = resourceIdentifier.ResourceGroupName;
Name = resourceIdentifier.ResourceName;
}
DatabaseAccountGetResults readDatabase = CosmosDBManagementClient.DatabaseAccounts.GetWithHttpMessagesAsync(ResourceGroupName, Name).GetAwaiter().GetResult().Body;
DatabaseAccountUpdateParameters databaseAccountUpdateParameters = new DatabaseAccountUpdateParameters(locations: readDatabase.Locations, location: readDatabase.WriteLocations.ElementAt(0).LocationName);
if (EnableMultipleWriteLocations != null)
{
databaseAccountUpdateParameters.EnableMultipleWriteLocations = EnableMultipleWriteLocations;
}
if (EnableVirtualNetwork != null)
{
databaseAccountUpdateParameters.IsVirtualNetworkFilterEnabled = EnableVirtualNetwork;
}
if (EnableAutomaticFailover != null)
{
databaseAccountUpdateParameters.EnableAutomaticFailover = EnableAutomaticFailover;
}
if (DisableKeyBasedMetadataWriteAccess != null)
{
databaseAccountUpdateParameters.DisableKeyBasedMetadataWriteAccess = DisableKeyBasedMetadataWriteAccess;
}
if (PublicNetworkAccess != null)
{
databaseAccountUpdateParameters.PublicNetworkAccess = PublicNetworkAccess;
}
if (KeyVaultKeyUri != null)
{
databaseAccountUpdateParameters.KeyVaultKeyUri = KeyVaultKeyUri;
}
if (EnableAnalyticalStorage != null)
{
databaseAccountUpdateParameters.EnableAnalyticalStorage = EnableAnalyticalStorage;
}
if (!string.IsNullOrEmpty(DefaultConsistencyLevel))
{
databaseAccountUpdateParameters.ConsistencyPolicy = base.PopoulateConsistencyPolicy(DefaultConsistencyLevel, MaxStalenessIntervalInSeconds, MaxStalenessPrefix);
}
if (Tag != null)
{
databaseAccountUpdateParameters.Tags = base.PopulateTags(Tag);
}
if (VirtualNetworkRule != null || VirtualNetworkRuleObject != null)
{
Collection <VirtualNetworkRule> virtualNetworkRule = new Collection <VirtualNetworkRule>();
if (VirtualNetworkRule != null && VirtualNetworkRule.Length > 0)
{
foreach (string id in VirtualNetworkRule)
{
virtualNetworkRule.Add(new VirtualNetworkRule(id: id));
}
}
if (VirtualNetworkRuleObject != null && VirtualNetworkRuleObject.Length > 0)
{
foreach (PSVirtualNetworkRule psVirtualNetworkRule in VirtualNetworkRuleObject)
{
virtualNetworkRule.Add(PSVirtualNetworkRule.ToSDKModel(psVirtualNetworkRule));
}
}
databaseAccountUpdateParameters.VirtualNetworkRules = virtualNetworkRule;
}
if (IpRule != null)
{
// not checking IpRules.Length > 0, to handle the removal of IpRules case
databaseAccountUpdateParameters.IpRules = base.PopulateIpRules(IpRule);
}
if (ShouldProcess(Name, "Updating Database Account"))
{
DatabaseAccountGetResults cosmosDBAccount = CosmosDBManagementClient.DatabaseAccounts.UpdateWithHttpMessagesAsync(ResourceGroupName, Name, databaseAccountUpdateParameters).GetAwaiter().GetResult().Body;
WriteObject(new PSDatabaseAccountGetResults(cosmosDBAccount));
}
return;
}
