public async Task CreateGetUpdateDeleteDisasterRecovery()
{
IgnoreTestInLiveMode();
_resourceGroup = await CreateResourceGroupAsync();
//create namespace1
string namespaceName1 = await CreateValidNamespaceName("testnamespacemgmt");
ServiceBusNamespaceCollection namespaceCollection = _resourceGroup.GetServiceBusNamespaces();
ServiceBusNamespaceData parameters1 = new ServiceBusNamespaceData(DefaultLocation)
{
Sku = new Models.Sku(SkuName.Premium)
{
Tier = SkuTier.Premium,
Capacity = 1
}
};
ServiceBusNamespace serviceBusNamespace1 = (await namespaceCollection.CreateOrUpdateAsync(true, namespaceName1, parameters1)).Value;
//create namespace2 with a different location
string namespaceName2 = await CreateValidNamespaceName("testnamespacemgmt");
ServiceBusNamespaceData parameters2 = new ServiceBusNamespaceData(AzureLocation.EastUS)
{
Sku = new Models.Sku(SkuName.Premium)
{
Tier = SkuTier.Premium,
Capacity = 1
}
};
ServiceBusNamespace serviceBusNamespace2 = (await namespaceCollection.CreateOrUpdateAsync(true, namespaceName2, parameters2)).Value;
//create authorization rule on namespace1
string ruleName = Recording.GenerateAssetName("authorizationrule");
ServiceBusAuthorizationRuleData ruleParameter = new ServiceBusAuthorizationRuleData()
{
Rights = { AccessRights.Listen, AccessRights.Send }
};
NamespaceAuthorizationRule authorizationRule = (await serviceBusNamespace1.GetNamespaceAuthorizationRules().CreateOrUpdateAsync(true, ruleName, ruleParameter)).Value;
Assert.NotNull(authorizationRule);
Assert.AreEqual(authorizationRule.Data.Rights.Count, ruleParameter.Rights.Count);
//create a disaster recovery
string disasterRecoveryName = Recording.GenerateAssetName("disasterrecovery");
DisasterRecoveryData parameter = new DisasterRecoveryData()
{
PartnerNamespace = serviceBusNamespace2.Id
};
DisasterRecovery disasterRecovery = (await serviceBusNamespace1.GetDisasterRecoveries().CreateOrUpdateAsync(true, disasterRecoveryName, parameter)).Value;
Assert.NotNull(disasterRecovery);
Assert.AreEqual(disasterRecovery.Id.Name, disasterRecoveryName);
Assert.AreEqual(disasterRecovery.Data.PartnerNamespace, serviceBusNamespace2.Id.ToString());
//get the disaster recovery - primary
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
Assert.AreEqual(disasterRecovery.Data.Role, RoleDisasterRecovery.Primary);
//get the disaster recovery - secondary
DisasterRecovery disasterRecoverySec = await serviceBusNamespace2.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
Assert.AreEqual(disasterRecoverySec.Data.Role, RoleDisasterRecovery.Secondary);
//wait for completion, this may take several minutes in live and record mode
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
int i = 0;
while (disasterRecovery.Data.ProvisioningState != ProvisioningStateDisasterRecovery.Succeeded && i < 100)
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(5000);
}
i++;
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
}
//check name availability
CheckNameAvailabilityResult nameAvailability = await serviceBusNamespace1.CheckDisasterRecoveryNameAvailabilityAsync(new CheckNameAvailability(disasterRecoveryName));
Assert.IsFalse(nameAvailability.NameAvailable);
List <NamespaceDisasterRecoveryAuthorizationRule> rules = await disasterRecovery.GetNamespaceDisasterRecoveryAuthorizationRules().GetAllAsync().ToEnumerableAsync();
Assert.IsTrue(rules.Count > 0);
//get access keys of the authorization rule
NamespaceDisasterRecoveryAuthorizationRule rule = rules.First();
AccessKeys keys = await rule.GetKeysAsync();
Assert.NotNull(keys);
//break pairing and wait for competion
await disasterRecovery.BreakPairingAsync();
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
i = 0;
while (disasterRecovery.Data.ProvisioningState != ProvisioningStateDisasterRecovery.Succeeded && i < 100)
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(5000);
}
i++;
disasterRecovery = await serviceBusNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
}
//get all disaster recoveries for a name space
List <DisasterRecovery> disasterRcoveries = await serviceBusNamespace1.GetDisasterRecoveries().GetAllAsync().ToEnumerableAsync();
Assert.IsTrue(disasterRcoveries.Count >= 1);
//delete disaster recovery;
await disasterRecovery.DeleteAsync(true);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
CheckNameAvailabilityResult checkNameAvailabilityResult = this.StorageClient.StorageAccounts.CheckNameAvailability(this.Name);
if (!checkNameAvailabilityResult.NameAvailable.Value)
{
throw new System.ArgumentException(checkNameAvailabilityResult.Message, "Name");
}
StorageAccountCreateParameters createParameters = new StorageAccountCreateParameters()
{
Location = this.Location,
Sku = new Sku(this.SkuName),
Tags = TagsConversionHelper.CreateTagDictionary(Tag, validate: true),
};
if (this.CustomDomainName != null)
{
createParameters.CustomDomain = new CustomDomain()
{
Name = CustomDomainName,
UseSubDomainName = UseSubDomain
};
}
else if (UseSubDomain != null)
{
throw new System.ArgumentException(string.Format("UseSubDomain must be set together with CustomDomainName."));
}
if (kind != null)
{
createParameters.Kind = kind;
}
if (this.AccessTier != null)
{
createParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
createParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent)
{
createParameters.Identity = new Identity()
{
Type = IdentityType.SystemAssigned
};
}
if (NetworkRuleSet != null)
{
createParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
if (enableHierarchicalNamespace != null)
{
createParameters.IsHnsEnabled = enableHierarchicalNamespace;
}
if (enableAzureActiveDirectoryDomainServicesForFile != null || enableActiveDirectoryDomainServicesForFile != null)
{
createParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
if (enableAzureActiveDirectoryDomainServicesForFile != null && enableAzureActiveDirectoryDomainServicesForFile.Value)
{
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AADDS;
}
else if (enableActiveDirectoryDomainServicesForFile != null && enableActiveDirectoryDomainServicesForFile.Value)
{
if (string.IsNullOrEmpty(this.ActiveDirectoryDomainName) ||
string.IsNullOrEmpty(this.ActiveDirectoryNetBiosDomainName) ||
string.IsNullOrEmpty(this.ActiveDirectoryForestName) ||
string.IsNullOrEmpty(this.ActiveDirectoryDomainGuid) ||
string.IsNullOrEmpty(this.ActiveDirectoryDomainSid) ||
string.IsNullOrEmpty(this.ActiveDirectoryAzureStorageSid)
)
{
throw new System.ArgumentNullException("ActiveDirectoryDomainName, ActiveDirectoryNetBiosDomainName, ActiveDirectoryForestName, ActiveDirectoryDomainGuid, ActiveDirectoryDomainSid, ActiveDirectoryAzureStorageSid",
"To enable ActiveDirectoryDomainServicesForFile, user must specify all of: ActiveDirectoryDomainName, ActiveDirectoryNetBiosDomainName, ActiveDirectoryForestName, ActiveDirectoryDomainGuid, ActiveDirectoryDomainSid, ActiveDirectoryAzureStorageSid.");
}
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AD;
createParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties = new ActiveDirectoryProperties()
{
DomainName = this.ActiveDirectoryDomainName,
NetBiosDomainName = this.ActiveDirectoryNetBiosDomainName,
ForestName = this.ActiveDirectoryForestName,
DomainGuid = this.ActiveDirectoryDomainGuid,
DomainSid = this.ActiveDirectoryDomainSid,
AzureStorageSid = this.ActiveDirectoryAzureStorageSid
};
}
else
{
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
}
if (this.EnableLargeFileShare.IsPresent)
{
createParameters.LargeFileSharesState = LargeFileSharesState.Enabled;
}
if (this.EncryptionKeyTypeForQueue != null || this.EncryptionKeyTypeForTable != null || this.RequireInfrastructureEncryption.IsPresent)
{
createParameters.Encryption = new Encryption();
createParameters.Encryption.KeySource = KeySource.MicrosoftStorage;
if (this.EncryptionKeyTypeForQueue != null || this.EncryptionKeyTypeForTable != null)
{
createParameters.Encryption.Services = new EncryptionServices();
if (this.EncryptionKeyTypeForQueue != null)
{
createParameters.Encryption.Services.Queue = new EncryptionService(keyType: this.EncryptionKeyTypeForQueue);
}
if (this.EncryptionKeyTypeForTable != null)
{
createParameters.Encryption.Services.Table = new EncryptionService(keyType: this.EncryptionKeyTypeForTable);
}
}
if (this.RequireInfrastructureEncryption.IsPresent)
{
createParameters.Encryption.RequireInfrastructureEncryption = true;
if (createParameters.Encryption.Services is null)
{
createParameters.Encryption.Services = new EncryptionServices();
createParameters.Encryption.Services.Blob = new EncryptionService();
}
}
}
if (this.minimumTlsVersion != null)
{
createParameters.MinimumTlsVersion = this.minimumTlsVersion;
}
if (this.allowBlobPublicAccess != null)
{
createParameters.AllowBlobPublicAccess = this.allowBlobPublicAccess;
}
if (this.RoutingChoice != null || this.publishMicrosoftEndpoint != null || this.publishInternetEndpoint != null)
{
createParameters.RoutingPreference = new RoutingPreference(this.RoutingChoice, this.publishMicrosoftEndpoint, this.publishInternetEndpoint);
}
if (allowSharedKeyAccess != null)
{
createParameters.AllowSharedKeyAccess = allowSharedKeyAccess;
}
var createAccountResponse = this.StorageClient.StorageAccounts.Create(
this.ResourceGroupName,
this.Name,
createParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
this.WriteStorageAccount(storageAccount);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
CheckNameAvailabilityResult checkNameAvailabilityResult = this.StorageClient.StorageAccounts.CheckNameAvailability(this.Name);
if (!checkNameAvailabilityResult.NameAvailable.Value)
{
throw new System.ArgumentException(checkNameAvailabilityResult.Message, "Name");
}
StorageAccountCreateParameters createParameters = new StorageAccountCreateParameters()
{
Location = this.Location,
Sku = new Sku(this.SkuName),
Tags = TagsConversionHelper.CreateTagDictionary(Tag, validate: true),
};
if (this.CustomDomainName != null)
{
createParameters.CustomDomain = new CustomDomain()
{
Name = CustomDomainName,
UseSubDomainName = UseSubDomain
};
}
else if (UseSubDomain != null)
{
throw new System.ArgumentException(string.Format("UseSubDomain must be set together with CustomDomainName."));
}
if (kind != null)
{
createParameters.Kind = kind;
}
if (this.AccessTier != null)
{
createParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
createParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent || this.UserAssignedIdentityId != null || this.IdentityType != null)
{
createParameters.Identity = new Identity()
{
Type = StorageModels.IdentityType.SystemAssigned
};
if (this.IdentityType != null)
{
createParameters.Identity.Type = GetIdentityTypeString(this.IdentityType);
}
if (this.UserAssignedIdentityId != null)
{
if (createParameters.Identity.Type != StorageModels.IdentityType.UserAssigned && createParameters.Identity.Type != StorageModels.IdentityType.SystemAssignedUserAssigned)
{
throw new ArgumentException("UserAssignIdentityId should only be specified when AssignIdentityType is UserAssigned or SystemAssignedUserAssigned.", "UserAssignIdentityId");
}
createParameters.Identity.UserAssignedIdentities = new Dictionary <string, UserAssignedIdentity>();
createParameters.Identity.UserAssignedIdentities.Add(this.UserAssignedIdentityId, new UserAssignedIdentity());
}
}
if (NetworkRuleSet != null)
{
createParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
if (enableHierarchicalNamespace != null)
{
createParameters.IsHnsEnabled = enableHierarchicalNamespace;
}
if (enableAzureActiveDirectoryDomainServicesForFile != null || enableActiveDirectoryDomainServicesForFile != null)
{
createParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
if (enableAzureActiveDirectoryDomainServicesForFile != null && enableAzureActiveDirectoryDomainServicesForFile.Value)
{
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AADDS;
}
else if (enableActiveDirectoryDomainServicesForFile != null && enableActiveDirectoryDomainServicesForFile.Value)
{
if (string.IsNullOrEmpty(this.ActiveDirectoryDomainName) ||
string.IsNullOrEmpty(this.ActiveDirectoryNetBiosDomainName) ||
string.IsNullOrEmpty(this.ActiveDirectoryForestName) ||
string.IsNullOrEmpty(this.ActiveDirectoryDomainGuid) ||
string.IsNullOrEmpty(this.ActiveDirectoryDomainSid) ||
string.IsNullOrEmpty(this.ActiveDirectoryAzureStorageSid)
)
{
throw new System.ArgumentNullException("ActiveDirectoryDomainName, ActiveDirectoryNetBiosDomainName, ActiveDirectoryForestName, ActiveDirectoryDomainGuid, ActiveDirectoryDomainSid, ActiveDirectoryAzureStorageSid",
"To enable ActiveDirectoryDomainServicesForFile, user must specify all of: ActiveDirectoryDomainName, ActiveDirectoryNetBiosDomainName, ActiveDirectoryForestName, ActiveDirectoryDomainGuid, ActiveDirectoryDomainSid, ActiveDirectoryAzureStorageSid.");
}
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AD;
createParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties = new ActiveDirectoryProperties()
{
DomainName = this.ActiveDirectoryDomainName,
NetBiosDomainName = this.ActiveDirectoryNetBiosDomainName,
ForestName = this.ActiveDirectoryForestName,
DomainGuid = this.ActiveDirectoryDomainGuid,
DomainSid = this.ActiveDirectoryDomainSid,
AzureStorageSid = this.ActiveDirectoryAzureStorageSid,
SamAccountName = this.ActiveDirectorySamAccountName,
AccountType = this.ActiveDirectoryAccountType
};
}
else
{
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
}
if (this.DefaultSharePermission != null)
{
if (enableAzureActiveDirectoryDomainServicesForFile == null && enableActiveDirectoryDomainServicesForFile == null)
{
throw new ArgumentException("'-DefaultSharePermission' need be specify together with '-EnableAzureActiveDirectoryDomainServicesForFile' or '-EnableActiveDirectoryDomainServicesForFile'.");
}
if (createParameters.AzureFilesIdentityBasedAuthentication == null)
{
createParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
}
createParameters.AzureFilesIdentityBasedAuthentication.DefaultSharePermission = this.DefaultSharePermission;
}
if (this.EnableLargeFileShare.IsPresent)
{
createParameters.LargeFileSharesState = LargeFileSharesState.Enabled;
}
if (this.EncryptionKeyTypeForQueue != null || this.EncryptionKeyTypeForTable != null || this.RequireInfrastructureEncryption.IsPresent)
{
createParameters.Encryption = new Encryption();
createParameters.Encryption.KeySource = KeySource.MicrosoftStorage;
if (this.EncryptionKeyTypeForQueue != null || this.EncryptionKeyTypeForTable != null)
{
createParameters.Encryption.Services = new EncryptionServices();
if (this.EncryptionKeyTypeForQueue != null)
{
createParameters.Encryption.Services.Queue = new EncryptionService(keyType: this.EncryptionKeyTypeForQueue);
}
if (this.EncryptionKeyTypeForTable != null)
{
createParameters.Encryption.Services.Table = new EncryptionService(keyType: this.EncryptionKeyTypeForTable);
}
}
if (this.RequireInfrastructureEncryption.IsPresent)
{
createParameters.Encryption.RequireInfrastructureEncryption = true;
if (createParameters.Encryption.Services is null)
{
createParameters.Encryption.Services = new EncryptionServices();
createParameters.Encryption.Services.Blob = new EncryptionService();
}
}
}
if (this.KeyVaultUri != null || this.KeyName != null || this.KeyVersion != null || this.KeyVaultUserAssignedIdentityId != null)
{
if ((this.KeyVaultUri != null && this.KeyName == null) || (this.KeyVaultUri == null && this.KeyName != null))
{
throw new ArgumentException("KeyVaultUri and KeyName must be specify together");
}
if (this.KeyVersion != null && (this.KeyVaultUri == null || this.KeyName == null))
{
throw new ArgumentException("KeyVersion can only be specified when specify KeyVaultUri and KeyName together.", "KeyVersion");
}
if (this.KeyVaultUserAssignedIdentityId != null && (this.KeyVaultUri == null || this.KeyName == null))
{
throw new ArgumentException("KeyVaultUserAssignedIdentityId can only be specified when specify KeyVaultUri and KeyName together.", "KeyVaultUserAssignedIdentityId");
}
if (createParameters.Encryption == null)
{
createParameters.Encryption = new Encryption();
createParameters.Encryption.KeySource = KeySource.MicrosoftStorage;
}
if (createParameters.Encryption.Services is null)
{
createParameters.Encryption.Services = new EncryptionServices();
createParameters.Encryption.Services.Blob = new EncryptionService();
}
if (this.KeyVaultUri != null || this.KeyName != null || this.KeyVersion != null)
{
createParameters.Encryption.KeySource = KeySource.MicrosoftKeyvault;
createParameters.Encryption.KeyVaultProperties = new KeyVaultProperties(this.KeyName, this.KeyVersion, this.KeyVaultUri);
}
if (this.KeyVaultUserAssignedIdentityId != null)
{
createParameters.Encryption.EncryptionIdentity = new EncryptionIdentity();
createParameters.Encryption.EncryptionIdentity.EncryptionUserAssignedIdentity = this.KeyVaultUserAssignedIdentityId;
}
}
if (this.minimumTlsVersion != null)
{
createParameters.MinimumTlsVersion = this.minimumTlsVersion;
}
if (this.allowBlobPublicAccess != null)
{
createParameters.AllowBlobPublicAccess = this.allowBlobPublicAccess;
}
if (this.RoutingChoice != null || this.publishMicrosoftEndpoint != null || this.publishInternetEndpoint != null)
{
createParameters.RoutingPreference = new RoutingPreference(this.RoutingChoice, this.publishMicrosoftEndpoint, this.publishInternetEndpoint);
}
if (allowSharedKeyAccess != null)
{
createParameters.AllowSharedKeyAccess = allowSharedKeyAccess;
}
if (enableNfsV3 != null)
{
createParameters.EnableNfsV3 = enableNfsV3;
}
if (this.EdgeZone != null)
{
createParameters.ExtendedLocation = new ExtendedLocation()
{
Type = ExtendedLocationTypes.EdgeZone,
Name = this.EdgeZone
};
}
if (sasExpirationPeriod != null)
{
createParameters.SasPolicy = new SasPolicy(sasExpirationPeriod.Value.ToString(@"d\.hh\:mm\:ss"));
}
if (keyExpirationPeriodInDay != null)
{
createParameters.KeyPolicy = new KeyPolicy(keyExpirationPeriodInDay.Value);
}
if (allowCrossTenantReplication != null)
{
createParameters.AllowCrossTenantReplication = allowCrossTenantReplication;
}
if (this.PublicNetworkAccess != null)
{
createParameters.PublicNetworkAccess = this.PublicNetworkAccess;
}
if (EnableAccountLevelImmutability.IsPresent || this.immutabilityPeriod != null || this.ImmutabilityPolicyState != null)
{
if (!EnableAccountLevelImmutability.IsPresent)
{
throw new ArgumentException("ImmutabilityPeriod, ImmutabilityPolicyState and AllowProtectedAppendWrite, can only be specified with -EnableAccountLevelImmutability.");
}
createParameters.ImmutableStorageWithVersioning = new ImmutableStorageAccount();
createParameters.ImmutableStorageWithVersioning.Enabled = this.EnableAccountLevelImmutability.IsPresent;
if (this.immutabilityPeriod != null || this.ImmutabilityPolicyState != null)
{
createParameters.ImmutableStorageWithVersioning.ImmutabilityPolicy = new AccountImmutabilityPolicyProperties();
createParameters.ImmutableStorageWithVersioning.ImmutabilityPolicy.ImmutabilityPeriodSinceCreationInDays = this.immutabilityPeriod;
createParameters.ImmutableStorageWithVersioning.ImmutabilityPolicy.State = this.ImmutabilityPolicyState;
}
}
var createAccountResponse = this.StorageClient.StorageAccounts.Create(
this.ResourceGroupName,
this.Name,
createParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
this.WriteStorageAccount(storageAccount);
}
public async Task CreateGetUpdateDeleteDisasterRecovery()
{
_resourceGroup = await CreateResourceGroupAsync();
//create namespace1
string namespaceName1 = await CreateValidNamespaceName("testnamespacemgmt");
EventHubNamespaceCollection namespaceCollection = _resourceGroup.GetEventHubNamespaces();
EventHubNamespaceResource eHNamespace1 = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName1, new EventHubNamespaceData(DefaultLocation))).Value;
//create namespace2 with a different location
string namespaceName2 = await CreateValidNamespaceName("testnamespacemgmt");
EventHubNamespaceResource eHNamespace2 = (await namespaceCollection.CreateOrUpdateAsync(WaitUntil.Completed, namespaceName2, new EventHubNamespaceData(AzureLocation.EastUS))).Value;
//create authorization rule on namespace1
string ruleName = Recording.GenerateAssetName("authorizationrule");
AuthorizationRuleData ruleParameter = new AuthorizationRuleData()
{
Rights = { AccessRights.Listen, AccessRights.Send }
};
NamespaceAuthorizationRuleResource authorizationRule = (await eHNamespace1.GetNamespaceAuthorizationRules().CreateOrUpdateAsync(WaitUntil.Completed, ruleName, ruleParameter)).Value;
Assert.NotNull(authorizationRule);
Assert.AreEqual(authorizationRule.Data.Rights.Count, ruleParameter.Rights.Count);
//create a disaster recovery
string disasterRecoveryName = Recording.GenerateAssetName("disasterrecovery");
DisasterRecoveryData parameter = new DisasterRecoveryData()
{
PartnerNamespace = eHNamespace2.Id
};
DisasterRecoveryResource armDisasterRecovery = (await eHNamespace1.GetDisasterRecoveries().CreateOrUpdateAsync(WaitUntil.Completed, disasterRecoveryName, parameter)).Value;
Assert.NotNull(armDisasterRecovery);
Assert.AreEqual(armDisasterRecovery.Id.Name, disasterRecoveryName);
Assert.AreEqual(armDisasterRecovery.Data.PartnerNamespace, eHNamespace2.Id.ToString());
//get the disaster recovery - primary
armDisasterRecovery = await eHNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
Assert.AreEqual(armDisasterRecovery.Data.Role, RoleDisasterRecovery.Primary);
//get the disaster recovery - secondary
DisasterRecoveryResource armDisasterRecoverySec = await eHNamespace2.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
Assert.AreEqual(armDisasterRecoverySec.Data.Role, RoleDisasterRecovery.Secondary);
//wait for completion, this may take several minutes in live and record mode
armDisasterRecovery = await eHNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
int i = 0;
while (armDisasterRecovery.Data.ProvisioningState != ProvisioningStateDisasterRecovery.Succeeded && i < 100)
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(5000);
}
i++;
armDisasterRecovery = await eHNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
}
System.Console.WriteLine(i);
//check name availability
CheckNameAvailabilityResult nameAvailability = await eHNamespace1.CheckDisasterRecoveryNameAvailabilityAsync(new CheckNameAvailabilityOptions(disasterRecoveryName));
Assert.IsFalse(nameAvailability.NameAvailable);
List <DisasterRecoveryAuthorizationRuleResource> rules = await armDisasterRecovery.GetDisasterRecoveryAuthorizationRules().GetAllAsync().ToEnumerableAsync();
Assert.IsTrue(rules.Count > 0);
//get access keys of the authorization rule
DisasterRecoveryAuthorizationRuleResource rule = rules.First();
AccessKeys keys = await rule.GetKeysAsync();
Assert.NotNull(keys);
//break pairing and wait for completion
await armDisasterRecovery.BreakPairingAsync();
armDisasterRecovery = await eHNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
i = 0;
while (armDisasterRecovery.Data.ProvisioningState != ProvisioningStateDisasterRecovery.Succeeded && i < 100)
{
if (Mode != RecordedTestMode.Playback)
{
await Task.Delay(5000);
}
i++;
armDisasterRecovery = await eHNamespace1.GetDisasterRecoveries().GetAsync(disasterRecoveryName);
}
//get all disaster recoveries for a name space
List <DisasterRecoveryResource> disasterRcoveries = await eHNamespace1.GetDisasterRecoveries().GetAllAsync().ToEnumerableAsync();
Assert.IsTrue(disasterRcoveries.Count >= 1);
//delete disaster recovery;
await armDisasterRecovery.DeleteAsync(WaitUntil.Completed);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
CheckNameAvailabilityResult checkNameAvailabilityResult = this.StorageClient.StorageAccounts.CheckNameAvailability(this.Name);
if (!checkNameAvailabilityResult.NameAvailable.Value)
{
throw new System.ArgumentException(checkNameAvailabilityResult.Message, "Name");
}
StorageAccountCreateParameters createParameters = new StorageAccountCreateParameters()
{
Location = this.Location,
Sku = new Sku(ParseSkuName(this.SkuName)),
Tags = TagsConversionHelper.CreateTagDictionary(Tag, validate: true),
};
if (this.CustomDomainName != null)
{
createParameters.CustomDomain = new CustomDomain()
{
Name = CustomDomainName,
UseSubDomain = UseSubDomain
};
}
else if (UseSubDomain != null)
{
throw new System.ArgumentException(string.Format("UseSubDomain must be set together with CustomDomainName."));
}
if (Kind != null)
{
createParameters.Kind = ParseAccountKind(Kind);
}
if (this.EnableEncryptionService != null)
{
createParameters.Encryption = ParseEncryption(EnableEncryptionService);
createParameters.Encryption.KeySource = "Microsoft.Storage";
}
if (this.AccessTier != null)
{
createParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
createParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent)
{
createParameters.Identity = new Identity();
}
if (NetworkRuleSet != null)
{
createParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
var createAccountResponse = this.StorageClient.StorageAccounts.Create(
this.ResourceGroupName,
this.Name,
createParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
this.WriteStorageAccount(storageAccount);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
CheckNameAvailabilityResult checkNameAvailabilityResult = this.StorageClient.StorageAccounts.CheckNameAvailability(this.Name);
if (!checkNameAvailabilityResult.NameAvailable.Value)
{
throw new System.ArgumentException(checkNameAvailabilityResult.Message, "Name");
}
StorageAccountCreateParameters createParameters = new StorageAccountCreateParameters()
{
Location = this.Location,
Sku = new Sku(this.SkuName),
Tags = TagsConversionHelper.CreateTagDictionary(Tag, validate: true),
};
if (this.CustomDomainName != null)
{
createParameters.CustomDomain = new CustomDomain()
{
Name = CustomDomainName,
UseSubDomainName = UseSubDomain
};
}
else if (UseSubDomain != null)
{
throw new System.ArgumentException(string.Format("UseSubDomain must be set together with CustomDomainName."));
}
if (kind != null)
{
createParameters.Kind = kind;
}
if (this.AccessTier != null)
{
createParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
createParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent)
{
createParameters.Identity = new Identity();
}
if (NetworkRuleSet != null)
{
createParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
if (enableHierarchicalNamespace != null)
{
createParameters.IsHnsEnabled = enableHierarchicalNamespace;
}
if (enableAzureActiveDirectoryDomainServicesForFile != null)
{
createParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
if (enableAzureActiveDirectoryDomainServicesForFile.Value)
{
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AADDS;
}
else
{
createParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
}
if (this.EnableLargeFileShare.IsPresent)
{
createParameters.LargeFileSharesState = LargeFileSharesState.Enabled;
}
if (this.EncryptionKeyTypeForQueue != null || this.EncryptionKeyTypeForTable != null)
{
createParameters.Encryption = new Encryption();
createParameters.Encryption.KeySource = KeySource.MicrosoftStorage;
createParameters.Encryption.Services = new EncryptionServices();
if (this.EncryptionKeyTypeForQueue != null)
{
createParameters.Encryption.Services.Queue = new EncryptionService(keyType: this.EncryptionKeyTypeForQueue);
}
if (this.EncryptionKeyTypeForTable != null)
{
createParameters.Encryption.Services.Table = new EncryptionService(keyType: this.EncryptionKeyTypeForTable);
}
}
var createAccountResponse = this.StorageClient.StorageAccounts.Create(
this.ResourceGroupName,
this.Name,
createParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
this.WriteStorageAccount(storageAccount);
}
public PsManagementGroupNameAvailabilityResult(CheckNameAvailabilityResult result)
{
NameAvailable = result.NameAvailable;
Reason = result.Reason.ToString();
Message = result.Message;
}
