public Registry UpdateRegistry(
string resourceGroupName,
string registryName,
bool?adminUserEnabled,
string sku = null,
string storageAccountId = null,
PSNetworkRuleSet networkRuleSet = null,
IDictionary <string, string> tags = null)
{
var parameters = new RegistryUpdateParameters()
{
AdminUserEnabled = adminUserEnabled
};
if (sku != null)
{
parameters.Sku = new Management.ContainerRegistry.Models.Sku(sku);
}
if (tags != null)
{
parameters.Tags = tags;
}
if (networkRuleSet != null)
{
parameters.NetworkRuleSet = networkRuleSet.GetNetworkRuleSet();
}
return(_client.Registries.Update(resourceGroupName, registryName, parameters));
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Update Storage Account NetworkRule"))
{
if (IPRule == null && VirtualNetworkRule == null && bypass == null && defaultAction == null)
{
throw new System.ArgumentNullException("IPRules, VirtualNetworkRules, Bypass, DefaultAction", "Request must specify an account NetworkRule property to update.");
}
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet storageACL = storageAccount.NetworkRuleSet;
if (storageACL == null)
{
storageACL = new NetworkRuleSet();
}
PSNetworkRuleSet psNetworkRule = PSNetworkRuleSet.ParsePSNetworkRule(storageACL);
if (isIpRuleSet)
{
psNetworkRule.IpRules = IPRule;
}
if (isNetworkRuleSet)
{
psNetworkRule.VirtualNetworkRules = VirtualNetworkRule;
}
if (bypass != null)
{
psNetworkRule.Bypass = bypass;
}
if (defaultAction != null)
{
psNetworkRule.DefaultAction = defaultAction.Value;
}
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
updateParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(psNetworkRule);
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet));
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Update Cognitive Services Account NetworkRule"))
{
if (IpRule == null && VirtualNetworkRule == null && defaultAction == null)
{
throw new System.ArgumentNullException("IpRules, VirtualNetworkRules, DefaultAction", "Request must specify an account NetworkRule property to update.");
}
var account = this.CognitiveServicesClient.Accounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet accountACL = account.Properties.NetworkAcls;
if (accountACL == null)
{
accountACL = new NetworkRuleSet();
accountACL.DefaultAction = NetworkRuleAction.Deny;
}
PSNetworkRuleSet psNetworkRule = PSNetworkRuleSet.Create(accountACL);
if (isIpRuleSet)
{
psNetworkRule.IpRules = IpRule;
}
if (isNetworkRuleSet)
{
psNetworkRule.VirtualNetworkRules = VirtualNetworkRule;
}
if (defaultAction != null)
{
psNetworkRule.DefaultAction = defaultAction.Value;
}
var properties = new CognitiveServicesAccountProperties();
properties.NetworkAcls = psNetworkRule.ToNetworkRuleSet();
this.CognitiveServicesClient.Accounts.Update(
this.ResourceGroupName,
this.Name,
new CognitiveServicesAccount()
{
Properties = properties
}
);
account = this.CognitiveServicesClient.Accounts.GetProperties(this.ResourceGroupName, this.Name);
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls));
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
this.ResourceGroupName,
this.Name);
if (storageAccount.NetworkAcls != null)
{
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkAcls));
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var account = this.CognitiveServicesClient.Accounts.GetProperties(
this.ResourceGroupName,
this.Name);
if (account != null && account.Properties.NetworkAcls != null)
{
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls));
}
}
public PSContainerRegistry(Registry registry)
{
Id = registry?.Id;
ResourceGroupName = ConversionUtilities.ParseResourceGroupFromId(Id);
Name = registry?.Name;
Type = registry?.Type;
Location = registry?.Location;
Tags = registry?.Tags;
SkuName = registry?.Sku?.Name;
SkuTier = registry?.Sku?.Tier;
LoginServer = registry?.LoginServer;
CreationDate = registry?.CreationDate;
ProvisioningState = registry?.ProvisioningState;
AdminUserEnabled = registry?.AdminUserEnabled;
StorageAccountName = ConversionUtilities.ParseStorageAccountFromId(registry?.StorageAccount?.Id);
NetworkRuleSet = new PSNetworkRuleSet(registry?.NetworkRuleSet);
}
public override void ExecuteCmdlet()
{
if (this.IsParameterBound(c => c.InputObject))
{
if (this.IsParameterBound(c => c.DefaultAction))
{
InputObject.DefaultAction = DefaultAction;
}
InputObject.AddNetworkRules(NetworkRule);
}
else
{
InputObject = new PSNetworkRuleSet(DefaultAction, NetworkRule);
}
WriteObject(InputObject);
}
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.NetworkAcls = 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()
{
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();
if (ShouldProcess(this.Name, "Set Storage Account"))
{
if (this.force || this.AccessTier == null || ShouldContinue("Changing the access tier may result in additional charges. See (http://go.microsoft.com/fwlink/?LinkId=786482) to learn more.", ""))
{
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
if (this.SkuName != null)
{
updateParameters.Sku = new Sku(this.SkuName);
}
if (this.Tag != null)
{
Dictionary <string, string> tagDictionary = TagsConversionHelper.CreateTagDictionary(Tag, validate: true);
updateParameters.Tags = tagDictionary ?? new Dictionary <string, string>();
}
if (this.CustomDomainName != null)
{
updateParameters.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 (this.AccessTier != null)
{
updateParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
updateParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent || this.UserAssignedIdentityId != null || this.IdentityType != null)
{
updateParameters.Identity = new Identity()
{
Type = StorageModels.IdentityType.SystemAssigned
};
if (this.IdentityType != null)
{
updateParameters.Identity.Type = GetIdentityTypeString(this.IdentityType);
}
if (this.UserAssignedIdentityId != null)
{
if (updateParameters.Identity.Type != StorageModels.IdentityType.UserAssigned && updateParameters.Identity.Type != StorageModels.IdentityType.SystemAssignedUserAssigned)
{
throw new ArgumentException("UserAssignIdentityId should only be specified when AssignIdentityType is UserAssigned or SystemAssignedUserAssigned.", "UserAssignIdentityId");
}
updateParameters.Identity.UserAssignedIdentities = new Dictionary <string, UserAssignedIdentity>();
updateParameters.Identity.UserAssignedIdentities.Add(this.UserAssignedIdentityId, new UserAssignedIdentity());
var accountProperties = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (accountProperties.Identity != null && accountProperties.Identity.UserAssignedIdentities != null && accountProperties.Identity.UserAssignedIdentities.Count > 0)
{
foreach (var uid in accountProperties.Identity.UserAssignedIdentities)
{
if (!uid.Key.Equals(this.UserAssignedIdentityId, StringComparison.OrdinalIgnoreCase))
{
updateParameters.Identity.UserAssignedIdentities.Add(uid.Key, null);
}
}
}
}
}
if (StorageEncryption || ParameterSetName == KeyvaultEncryptionParameterSet || this.KeyVaultUserAssignedIdentityId != null)
{
if (ParameterSetName == KeyvaultEncryptionParameterSet)
{
keyvaultEncryption = true;
}
updateParameters.Encryption = ParseEncryption(StorageEncryption, keyvaultEncryption, KeyName, KeyVersion, KeyVaultUri);
if (this.KeyVaultUserAssignedIdentityId != null)
{
updateParameters.Encryption.EncryptionIdentity = new EncryptionIdentity();
updateParameters.Encryption.EncryptionIdentity.EncryptionUserAssignedIdentity = this.KeyVaultUserAssignedIdentityId;
}
}
if (NetworkRuleSet != null)
{
updateParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
if (UpgradeToStorageV2.IsPresent)
{
updateParameters.Kind = Kind.StorageV2;
}
if (enableAzureActiveDirectoryDomainServicesForFile != null)
{
if (enableAzureActiveDirectoryDomainServicesForFile.Value) // enable AADDS
{
//if user want to enable AADDS, must first disable AD
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication != null &&
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AD)
{
throw new System.ArgumentException("The Storage account already enabled ActiveDirectoryDomainServicesForFile, please disable it by run this cmdlets with \"-EnableActiveDirectoryDomainServicesForFile $false\" before enable AzureActiveDirectoryDomainServicesForFile.");
}
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AADDS;
}
else //Disable AADDS
{
// Only disable AADDS; else keep unchanged
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication == null ||
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AADDS)
{
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
else
{
updateParameters.AzureFilesIdentityBasedAuthentication = originStorageAccount.AzureFilesIdentityBasedAuthentication;
}
}
}
if (enableActiveDirectoryDomainServicesForFile != null)
{
if (enableActiveDirectoryDomainServicesForFile.Value) // Enable AD
{
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.");
}
//if user want to enable AD, must first disable AADDS
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication != null &&
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AADDS)
{
throw new System.ArgumentException("The Storage account already enabled AzureActiveDirectoryDomainServicesForFile, please disable it by run this cmdlets with \"-EnableAzureActiveDirectoryDomainServicesForFile $false\" before enable ActiveDirectoryDomainServicesForFile.");
}
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AD;
updateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties = new ActiveDirectoryProperties()
{
DomainName = this.ActiveDirectoryDomainName,
NetBiosDomainName = this.ActiveDirectoryNetBiosDomainName,
ForestName = this.ActiveDirectoryForestName,
DomainGuid = this.ActiveDirectoryDomainGuid,
DomainSid = this.ActiveDirectoryDomainSid,
AzureStorageSid = this.ActiveDirectoryAzureStorageSid
};
}
else // Disable AD
{
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.ArgumentException("To Disable ActiveDirectoryDomainServicesForFile, user can't specify any of: ActiveDirectoryDomainName, ActiveDirectoryNetBiosDomainName, ActiveDirectoryForestName, ActiveDirectoryDomainGuid, ActiveDirectoryDomainSid, ActiveDirectoryAzureStorageSid.");
}
// Only disable AD; else keep unchanged
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication == null ||
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AD)
{
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
else
{
updateParameters.AzureFilesIdentityBasedAuthentication = originStorageAccount.AzureFilesIdentityBasedAuthentication;
}
}
}
if (this.DefaultSharePermission != null)
{
if (updateParameters.AzureFilesIdentityBasedAuthentication == null)
{
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
}
updateParameters.AzureFilesIdentityBasedAuthentication.DefaultSharePermission = this.DefaultSharePermission;
}
if (this.EnableLargeFileShare.IsPresent)
{
updateParameters.LargeFileSharesState = LargeFileSharesState.Enabled;
}
if (this.minimumTlsVersion != null)
{
updateParameters.MinimumTlsVersion = this.minimumTlsVersion;
}
if (this.allowBlobPublicAccess != null)
{
updateParameters.AllowBlobPublicAccess = this.allowBlobPublicAccess;
}
if (this.RoutingChoice != null || this.publishMicrosoftEndpoint != null || this.publishInternetEndpoint != null)
{
updateParameters.RoutingPreference = new RoutingPreference(this.RoutingChoice, this.publishMicrosoftEndpoint, this.publishInternetEndpoint);
}
if (allowSharedKeyAccess != null)
{
updateParameters.AllowSharedKeyAccess = allowSharedKeyAccess;
}
if (SasExpirationPeriod != null && SasExpirationPeriod != TimeSpan.Zero)
{
updateParameters.SasPolicy = new SasPolicy(SasExpirationPeriod.ToString(@"d\.hh\:mm\:ss"));
}
if (keyExpirationPeriodInDay != null)
{
updateParameters.KeyPolicy = new KeyPolicy(keyExpirationPeriodInDay.Value);
}
if (allowCrossTenantReplication != null)
{
updateParameters.AllowCrossTenantReplication = allowCrossTenantReplication;
}
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
WriteStorageAccount(storageAccount);
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Set Storage Account"))
{
if (this.force || this.AccessTier == null || ShouldContinue("Changing the access tier may result in additional charges. See (http://go.microsoft.com/fwlink/?LinkId=786482) to learn more.", ""))
{
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
if (this.SkuName != null)
{
updateParameters.Sku = new Sku(this.SkuName);
}
if (this.Tag != null)
{
Dictionary <string, string> tagDictionary = TagsConversionHelper.CreateTagDictionary(Tag, validate: true);
updateParameters.Tags = tagDictionary ?? new Dictionary <string, string>();
}
if (this.CustomDomainName != null)
{
updateParameters.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 (this.AccessTier != null)
{
updateParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
updateParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent)
{
updateParameters.Identity = new Identity();
}
if (StorageEncryption || (ParameterSetName == KeyvaultEncryptionParameterSet))
{
if (ParameterSetName == KeyvaultEncryptionParameterSet)
{
keyvaultEncryption = true;
}
updateParameters.Encryption = ParseEncryption(StorageEncryption, keyvaultEncryption, KeyName, KeyVersion, KeyVaultUri);
}
if (NetworkRuleSet != null)
{
updateParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
if (UpgradeToStorageV2.IsPresent)
{
updateParameters.Kind = Kind.StorageV2;
}
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
WriteStorageAccount(storageAccount);
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Add Storage Account NetworkRules"))
{
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet storageACL = storageAccount.NetworkRuleSet;
if (storageACL == null)
{
storageACL = new NetworkRuleSet();
}
bool ruleChanged = false;
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (storageACL.VirtualNetworkRules == null)
{
storageACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
bool ruleExist = false;
foreach (VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)
{
if (originRule.VirtualNetworkResourceId.Equals(s, System.StringComparison.InvariantCultureIgnoreCase))
{
ruleExist = true;
WriteDebug(string.Format("Skip add VirtualNetworkRule as it already exist: {0}", s));
break;
}
}
if (!ruleExist)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s);
storageACL.VirtualNetworkRules.Add(rule);
ruleChanged = true;
}
}
break;
case IpRuleStringParameterSet:
if (storageACL.IpRules == null)
{
storageACL.IpRules = new List <IPRule>();
}
foreach (string s in IPAddressOrRange)
{
bool ruleExist = false;
foreach (IPRule originRule in storageACL.IpRules)
{
if (originRule.IPAddressOrRange.Equals(s, System.StringComparison.InvariantCultureIgnoreCase))
{
ruleExist = true;
WriteDebug(string.Format("Skip add IPAddressOrRange as it already exist: {0}", s));
break;
}
}
if (!ruleExist)
{
IPRule rule = new IPRule(s);
storageACL.IpRules.Add(rule);
ruleChanged = true;
}
}
break;
case ResourceAccessRuleStringParameterSet:
if (storageACL.ResourceAccessRules == null)
{
storageACL.ResourceAccessRules = new List <ResourceAccessRule>();
}
bool ResourceAccessruleExist = false;
foreach (ResourceAccessRule originRule in storageACL.ResourceAccessRules)
{
if (originRule.TenantId.Equals(this.TenantId, System.StringComparison.InvariantCultureIgnoreCase) &&
originRule.ResourceId.Equals(this.ResourceId, System.StringComparison.InvariantCultureIgnoreCase))
{
ResourceAccessruleExist = true;
WriteDebug(string.Format("Skip add ResourceAccessRule as it already exist, TenantId: {0}, ResourceId: {1}", this.TenantId, this.ResourceId));
break;
}
}
if (!ResourceAccessruleExist)
{
ResourceAccessRule rule = new ResourceAccessRule(this.TenantId, this.ResourceId);
storageACL.ResourceAccessRules.Add(rule);
ruleChanged = true;
}
break;
case NetworkRuleObjectParameterSet:
if (storageACL.VirtualNetworkRules == null)
{
storageACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
bool ruleExist = false;
foreach (VirtualNetworkRule originRule in storageACL.VirtualNetworkRules)
{
if (originRule.VirtualNetworkResourceId.Equals(rule.VirtualNetworkResourceId, System.StringComparison.InvariantCultureIgnoreCase))
{
ruleExist = true;
WriteDebug(string.Format("Skip add IPAddressOrRange as it already exist: {0}", rule.VirtualNetworkResourceId));
break;
}
}
if (!ruleExist)
{
storageACL.VirtualNetworkRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleVirtualNetworkRule(rule));
ruleChanged = true;
}
}
break;
case ResourceAccessRuleObjectParameterSet:
if (storageACL.ResourceAccessRules == null)
{
storageACL.ResourceAccessRules = new List <ResourceAccessRule>();
}
foreach (PSResourceAccessRule rule in ResourceAccessRule)
{
bool ruleExist = false;
foreach (ResourceAccessRule originRule in storageACL.ResourceAccessRules)
{
if (originRule.TenantId.Equals(rule.TenantId, System.StringComparison.InvariantCultureIgnoreCase) &&
originRule.ResourceId.Equals(rule.ResourceId, System.StringComparison.InvariantCultureIgnoreCase))
{
ruleExist = true;
WriteDebug(string.Format("Skip add ResourceAccessRule as it already exist, TenantId: {0}, ResourceId: {1}", rule.TenantId, rule.ResourceId));
break;
}
}
if (!ruleExist)
{
storageACL.ResourceAccessRules.Add(PSNetworkRuleSet.ParseStorageResourceAccessRule(rule));
ruleChanged = true;
}
}
break;
case IpRuleObjectParameterSet:
if (storageACL.IpRules == null)
{
storageACL.IpRules = new List <IPRule>();
}
foreach (PSIpRule rule in IPRule)
{
bool ruleExist = false;
foreach (IPRule originRule in storageACL.IpRules)
{
if (originRule.IPAddressOrRange.Equals(rule.IPAddressOrRange, System.StringComparison.InvariantCultureIgnoreCase))
{
ruleExist = true;
WriteDebug(string.Format("Skip add IPAddressOrRange as it already exist: {0}", rule.IPAddressOrRange));
break;
}
}
if (!ruleExist)
{
storageACL.IpRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule));
ruleChanged = true;
}
}
break;
}
if (ruleChanged)
{
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
updateParameters.NetworkRuleSet = storageACL;
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).IpRules);
break;
case ResourceAccessRuleStringParameterSet:
case ResourceAccessRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).ResourceAccessRules);
break;
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Add Cognitive Services Account NetworkRules"))
{
var account = this.CognitiveServicesClient.Accounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet accountACL = account.Properties.NetworkAcls;
if (accountACL == null)
{
accountACL = new NetworkRuleSet();
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s, null, true);
accountACL.VirtualNetworkRules.Add(rule);
}
break;
case IpRuleStringParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (string s in IpAddressOrRange)
{
IpRule rule = new IpRule(s);
accountACL.IpRules.Add(rule);
}
break;
case NetworkRuleObjectParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
accountACL.VirtualNetworkRules.Add(rule.ToVirtualNetworkRule());
}
break;
case IpRuleObjectParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (PSIpRule rule in IpRule)
{
accountACL.IpRules.Add(rule.ToIpRule());
}
break;
}
var properties = new CognitiveServicesAccountProperties();
properties.NetworkAcls = accountACL;
this.CognitiveServicesClient.Accounts.Update(
this.ResourceGroupName,
this.Name,
new CognitiveServicesAccount()
{
Properties = properties
}
);
account = this.CognitiveServicesClient.Accounts.GetProperties(this.ResourceGroupName, this.Name);
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).IpRules);
break;
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Set Storage Account"))
{
if (this.force || this.AccessTier == null || ShouldContinue("Changing the access tier may result in additional charges. See (http://go.microsoft.com/fwlink/?LinkId=786482) to learn more.", ""))
{
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
if (this.SkuName != null)
{
updateParameters.Sku = new Sku(this.SkuName);
}
if (this.Tag != null)
{
Dictionary <string, string> tagDictionary = TagsConversionHelper.CreateTagDictionary(Tag, validate: true);
updateParameters.Tags = tagDictionary ?? new Dictionary <string, string>();
}
if (this.CustomDomainName != null)
{
updateParameters.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 (this.AccessTier != null)
{
updateParameters.AccessTier = ParseAccessTier(AccessTier);
}
if (enableHttpsTrafficOnly != null)
{
updateParameters.EnableHttpsTrafficOnly = enableHttpsTrafficOnly;
}
if (AssignIdentity.IsPresent)
{
updateParameters.Identity = new Identity();
}
if (StorageEncryption || (ParameterSetName == KeyvaultEncryptionParameterSet))
{
if (ParameterSetName == KeyvaultEncryptionParameterSet)
{
keyvaultEncryption = true;
}
updateParameters.Encryption = ParseEncryption(StorageEncryption, keyvaultEncryption, KeyName, KeyVersion, KeyVaultUri);
}
if (NetworkRuleSet != null)
{
updateParameters.NetworkRuleSet = PSNetworkRuleSet.ParseStorageNetworkRule(NetworkRuleSet);
}
if (UpgradeToStorageV2.IsPresent)
{
updateParameters.Kind = Kind.StorageV2;
}
if (enableAzureActiveDirectoryDomainServicesForFile != null)
{
if (enableAzureActiveDirectoryDomainServicesForFile.Value) // enable AADDS
{
//if user want to enable AADDS, must first disable AD
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication != null &&
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AD)
{
throw new System.ArgumentException("The Storage account already enabled ActiveDirectoryDomainServicesForFile, please disable it by run this cmdlets with \"-EnableActiveDirectoryDomainServicesForFile $false\" before enable AzureActiveDirectoryDomainServicesForFile.");
}
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AADDS;
}
else //Disable AADDS
{
// Only disable AADDS; else keep unchanged
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication == null ||
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AADDS)
{
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
else
{
updateParameters.AzureFilesIdentityBasedAuthentication = originStorageAccount.AzureFilesIdentityBasedAuthentication;
}
}
}
if (enableActiveDirectoryDomainServicesForFile != null)
{
if (enableActiveDirectoryDomainServicesForFile.Value) // Enable AD
{
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.");
}
//if user want to enable AD, must first disable AADDS
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication != null &&
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AADDS)
{
throw new System.ArgumentException("The Storage account already enabled AzureActiveDirectoryDomainServicesForFile, please disable it by run this cmdlets with \"-EnableAzureActiveDirectoryDomainServicesForFile $false\" before enable ActiveDirectoryDomainServicesForFile.");
}
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.AD;
updateParameters.AzureFilesIdentityBasedAuthentication.ActiveDirectoryProperties = new ActiveDirectoryProperties()
{
DomainName = this.ActiveDirectoryDomainName,
NetBiosDomainName = this.ActiveDirectoryNetBiosDomainName,
ForestName = this.ActiveDirectoryForestName,
DomainGuid = this.ActiveDirectoryDomainGuid,
DomainSid = this.ActiveDirectoryDomainSid,
AzureStorageSid = this.ActiveDirectoryAzureStorageSid
};
}
else // Disable AD
{
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.ArgumentException("To Disable ActiveDirectoryDomainServicesForFile, user can't specify any of: ActiveDirectoryDomainName, ActiveDirectoryNetBiosDomainName, ActiveDirectoryForestName, ActiveDirectoryDomainGuid, ActiveDirectoryDomainSid, ActiveDirectoryAzureStorageSid.");
}
// Only disable AD; else keep unchanged
var originStorageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
if (originStorageAccount.AzureFilesIdentityBasedAuthentication == null ||
originStorageAccount.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions == DirectoryServiceOptions.AD)
{
updateParameters.AzureFilesIdentityBasedAuthentication = new AzureFilesIdentityBasedAuthentication();
updateParameters.AzureFilesIdentityBasedAuthentication.DirectoryServiceOptions = DirectoryServiceOptions.None;
}
else
{
updateParameters.AzureFilesIdentityBasedAuthentication = originStorageAccount.AzureFilesIdentityBasedAuthentication;
}
}
}
if (this.EnableLargeFileShare.IsPresent)
{
updateParameters.LargeFileSharesState = LargeFileSharesState.Enabled;
}
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
WriteStorageAccount(storageAccount);
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Remove Storage Account Networkrules"))
{
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet storageACL = storageAccount.NetworkRuleSet;
if (storageACL == null)
{
storageACL = new NetworkRuleSet();
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (storageACL.VirtualNetworkRules == null)
{
storageACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s);
if (!RemoveNetworkRule(storageACL.VirtualNetworkRules, rule))
{
throw new ArgumentOutOfRangeException("VirtualNetworkResourceId", String.Format("Can't remove VirtualNetworkRule with specific ResourceId since not exist: {0}", rule.VirtualNetworkResourceId));
}
}
break;
case IpRuleStringParameterSet:
if (storageACL.IpRules == null)
{
storageACL.IpRules = new List <IPRule>();
}
foreach (string s in IPAddressOrRange)
{
IPRule rule = new IPRule(s);
if (!RemoveIpRule(storageACL.IpRules, rule))
{
throw new ArgumentOutOfRangeException("IPAddressOrRange", String.Format("Can't remove IpRule with specific IPAddressOrRange since not exist: {0}", rule.IPAddressOrRange));
}
}
break;
case NetworkRuleObjectParameterSet:
if (storageACL.VirtualNetworkRules == null)
{
storageACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
if (!RemoveNetworkRule(storageACL.VirtualNetworkRules, PSNetworkRuleSet.ParseStorageNetworkRuleVirtualNetworkRule(rule)))
{
throw new ArgumentOutOfRangeException("VirtualNetworkRule", String.Format("Can't remove VirtualNetworkRule with specific ResourceId since not exist: {0}", rule.VirtualNetworkResourceId));
}
}
break;
case IpRuleObjectParameterSet:
if (storageACL.IpRules == null)
{
storageACL.IpRules = new List <IPRule>();
}
foreach (PSIpRule rule in IPRule)
{
if (!RemoveIpRule(storageACL.IpRules, PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule)))
{
throw new ArgumentOutOfRangeException("IPRule", String.Format("Can't remove IpRule with specific IPAddressOrRange since not exist: {0}", rule.IPAddressOrRange));
}
}
break;
}
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
updateParameters.NetworkRuleSet = storageACL;
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).IpRules);
break;
}
}
}
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 override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Remove Cognitive Services Account Networkrules"))
{
var account = this.CognitiveServicesClient.Accounts.Get(
this.ResourceGroupName,
this.Name);
NetworkRuleSet accountACL = account.Properties.NetworkAcls;
if (accountACL == null)
{
accountACL = new NetworkRuleSet();
accountACL.DefaultAction = NetworkRuleAction.Deny;
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s);
if (!RemoveNetworkRule(accountACL.VirtualNetworkRules, rule))
{
throw new ArgumentOutOfRangeException("VirtualNetworkResourceId", String.Format("Can't remove VirtualNetworkRule with specific ResourceId since not exist: {0}", rule.Id));
}
}
break;
case IpRuleStringParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (string s in IpAddressOrRange)
{
IpRule rule = new IpRule(s);
if (!RemoveIpRule(accountACL.IpRules, rule))
{
throw new ArgumentOutOfRangeException("IPAddressOrRange", String.Format("Can't remove IpRule with specific IPAddressOrRange since not exist: {0}", rule.Value));
}
}
break;
case NetworkRuleObjectParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
if (!RemoveNetworkRule(accountACL.VirtualNetworkRules, rule.ToVirtualNetworkRule()))
{
throw new ArgumentOutOfRangeException("VirtualNetworkRule", String.Format("Can't remove VirtualNetworkRule with specific ResourceId since not exist: {0}", rule.Id));
}
}
break;
case IpRuleObjectParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (PSIpRule rule in IpRule)
{
if (!RemoveIpRule(accountACL.IpRules, rule.ToIpRule()))
{
throw new ArgumentOutOfRangeException("IPRule", String.Format("Can't remove IpRule with specific IPAddressOrRange since not exist: {0}", rule.IpAddress));
}
}
break;
}
var properties = new AccountProperties();
properties.NetworkAcls = accountACL;
this.CognitiveServicesClient.Accounts.Update(
this.ResourceGroupName,
this.Name,
new Account()
{
Properties = properties
}
);
account = this.CognitiveServicesClient.Accounts.Get(this.ResourceGroupName, this.Name);
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).IpRules);
break;
}
}
}
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 override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Add Cognitive Services Account NetworkRules"))
{
var account = this.CognitiveServicesClient.Accounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet accountACL = account.Properties.NetworkAcls;
if (accountACL == null)
{
accountACL = new NetworkRuleSet();
// Deny is the default action value from server side,
// Specifically make default action Deny in client side as server side might want this value to be always provided in future.
accountACL.DefaultAction = NetworkRuleAction.Deny;
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s, null, true);
accountACL.VirtualNetworkRules.Add(rule);
}
break;
case IpRuleStringParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (string s in IpAddressOrRange)
{
IpRule rule = new IpRule(s);
accountACL.IpRules.Add(rule);
}
break;
case NetworkRuleObjectParameterSet:
if (accountACL.VirtualNetworkRules == null)
{
accountACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
accountACL.VirtualNetworkRules.Add(rule.ToVirtualNetworkRule());
}
break;
case IpRuleObjectParameterSet:
if (accountACL.IpRules == null)
{
accountACL.IpRules = new List <IpRule>();
}
foreach (PSIpRule rule in IpRule)
{
accountACL.IpRules.Add(rule.ToIpRule());
}
break;
}
var properties = new CognitiveServicesAccountProperties();
properties.NetworkAcls = accountACL;
this.CognitiveServicesClient.Accounts.Update(
this.ResourceGroupName,
this.Name,
new CognitiveServicesAccount()
{
Properties = properties
}
);
account = this.CognitiveServicesClient.Accounts.GetProperties(this.ResourceGroupName, this.Name);
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.Create(account.Properties.NetworkAcls).IpRules);
break;
}
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
if (ShouldProcess(this.Name, "Add Storage Account NetworkRules"))
{
var storageAccount = this.StorageClient.StorageAccounts.GetProperties(
this.ResourceGroupName,
this.Name);
NetworkRuleSet storageACL = storageAccount.NetworkRuleSet;
if (storageACL == null)
{
storageACL = new NetworkRuleSet();
}
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
if (storageACL.VirtualNetworkRules == null)
{
storageACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (string s in VirtualNetworkResourceId)
{
VirtualNetworkRule rule = new VirtualNetworkRule(s);
storageACL.VirtualNetworkRules.Add(rule);
}
break;
case IpRuleStringParameterSet:
if (storageACL.IpRules == null)
{
storageACL.IpRules = new List <IPRule>();
}
foreach (string s in IPAddressOrRange)
{
IPRule rule = new IPRule(s);
storageACL.IpRules.Add(rule);
}
break;
case NetworkRuleObjectParameterSet:
if (storageACL.VirtualNetworkRules == null)
{
storageACL.VirtualNetworkRules = new List <VirtualNetworkRule>();
}
foreach (PSVirtualNetworkRule rule in VirtualNetworkRule)
{
storageACL.VirtualNetworkRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleVirtualNetworkRule(rule));
}
break;
case IpRuleObjectParameterSet:
if (storageACL.IpRules == null)
{
storageACL.IpRules = new List <IPRule>();
}
foreach (PSIpRule rule in IPRule)
{
storageACL.IpRules.Add(PSNetworkRuleSet.ParseStorageNetworkRuleIPRule(rule));
}
break;
}
StorageAccountUpdateParameters updateParameters = new StorageAccountUpdateParameters();
updateParameters.NetworkRuleSet = storageACL;
var updatedAccountResponse = this.StorageClient.StorageAccounts.Update(
this.ResourceGroupName,
this.Name,
updateParameters);
storageAccount = this.StorageClient.StorageAccounts.GetProperties(this.ResourceGroupName, this.Name);
switch (ParameterSetName)
{
case NetWorkRuleStringParameterSet:
case NetworkRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).VirtualNetworkRules);
break;
case IpRuleStringParameterSet:
case IpRuleObjectParameterSet:
WriteObject(PSNetworkRuleSet.ParsePSNetworkRule(storageAccount.NetworkRuleSet).IpRules);
break;
}
}
}
public abstract bool SetSRPAzureStorageAccountKeyVault(string resourceGroupName, string accountName, string skuName = null, Hashtable[] tags = null, Constants.EncryptionSupportServiceEnum?enableEncryptionService = null, Constants.EncryptionSupportServiceEnum?disableEncryptionService = null, AccessTier?accessTier = null, string customDomain = null, bool?useSubdomain = null, bool?enableHttpsTrafficOnly = null, bool AssignIdentity = false, bool keyvaultEncryption = false, string keyName = null, string keyVersion = null, string keyVaultUri = null, PSNetworkRuleSet networkAcl = null);
public abstract bool CreateSRPAzureStorageAccount(string resourceGroupName, string accountName, string skuName, string location, Hashtable[] tags = null, Kind?kind = null, Constants.EncryptionSupportServiceEnum?enableEncryptionService = null, AccessTier?accessTier = null, string customDomain = null, bool?useSubdomain = null, bool?enableHttpsTrafficOnly = null, bool AssignIdentity = false, PSNetworkRuleSet networkAcl = null);