public override void ExecuteCmdlet()
{
if (ShouldProcess(Resources.VaultTarget, "set"))
{
try
{
Vault vault = null;
IdentityData MSI = new IdentityData();
if (IdentityType == MSIdentity.SystemAssigned)
{
MSI.Type = MSIdentity.SystemAssigned.ToString();
}
else if (IdentityType == MSIdentity.None)
{
MSI.Type = MSIdentity.None.ToString();
}
PatchVault patchVault = new PatchVault();
patchVault.Identity = MSI;
vault = RecoveryServicesClient.UpdateRSVault(this.ResourceGroupName, this.Name, patchVault);
WriteObject(new ARSVault(vault));
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}
}
/// <summary>
/// Updates the vault.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group where the recovery services vault is
/// present.
/// </param>
/// <param name='vaultName'>
/// The name of the recovery services vault.
/// </param>
/// <param name='vault'>
/// Recovery Services Vault to be created.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Vault> BeginUpdateAsync(this IVaultsOperations operations, string resourceGroupName, string vaultName, PatchVault vault, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginUpdateWithHttpMessagesAsync(resourceGroupName, vaultName, vault, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Updates the vault.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group where the recovery services vault is
/// present.
/// </param>
/// <param name='vaultName'>
/// The name of the recovery services vault.
/// </param>
/// <param name='vault'>
/// Recovery Services Vault to be created.
/// </param>
public static Vault BeginUpdate(this IVaultsOperations operations, string resourceGroupName, string vaultName, PatchVault vault)
{
return(operations.BeginUpdateAsync(resourceGroupName, vaultName, vault).GetAwaiter().GetResult());
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
try
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
if (SoftDeleteFeatureState != null || DisableHybridBackupSecurityFeature != null)
{
BackupResourceVaultConfigResource currentConfig = ServiceClientAdapter.GetVaultProperty(vaultName, resourceGroupName);
BackupResourceVaultConfigResource param = new BackupResourceVaultConfigResource();
param.Properties = new BackupResourceVaultConfig();
param.Properties.SoftDeleteFeatureState = (SoftDeleteFeatureState != null) ? SoftDeleteFeatureState + "d" : currentConfig.Properties.SoftDeleteFeatureState;
param.Properties.EnhancedSecurityState = (DisableHybridBackupSecurityFeature != null) ? (((bool)DisableHybridBackupSecurityFeature) ? "Disabled" : "Enabled") : currentConfig.Properties.EnhancedSecurityState;
bool isMUAProtected = checkMUAForSoftDelete(currentConfig, param);
BackupResourceVaultConfigResource result = ServiceClientAdapter.SetVaultProperty(vaultName, resourceGroupName, param, Token, isMUAProtected);
WriteObject(result.Properties);
}
else if (EncryptionKeyId != null)
{
BackupResourceEncryptionConfigResource vaultEncryptionSettings = new BackupResourceEncryptionConfigResource();
vaultEncryptionSettings.Properties = new BackupResourceEncryptionConfig();
PatchVault patchVault = new PatchVault();
patchVault.Properties = new VaultProperties();
VaultPropertiesEncryption vaultEncryption = new VaultPropertiesEncryption();
vaultEncryption.KeyVaultProperties = new CmkKeyVaultProperties();
vaultEncryption.KekIdentity = new CmkKekIdentity();
vaultEncryption.KeyVaultProperties.KeyUri = EncryptionKeyId;
if (InfrastructureEncryption.IsPresent)
{
vaultEncryption.InfrastructureEncryption = "Enabled";
}
vaultEncryption.KekIdentity.UseSystemAssignedIdentity = UseSystemAssignedIdentity;
if (!UseSystemAssignedIdentity && (UserAssignedIdentity == null || UserAssignedIdentity == ""))
{
throw new ArgumentException(Resources.IdentityIdRequiredForCMK);
}
else if (!UseSystemAssignedIdentity)
{
vaultEncryption.KekIdentity.UserAssignedIdentity = UserAssignedIdentity;
}
patchVault.Properties.Encryption = vaultEncryption;
ServiceClientAdapter.UpdateRSVault(resourceGroupName, vaultName, patchVault);
}
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}, ShouldProcess(VaultId, VerbsCommon.Set));
}
public override void ExecuteCmdlet()
{
if (ShouldProcess(Resources.VaultTarget, "set"))
{
try
{
IdentityData MSI = new IdentityData();
Vault vault = RecoveryServicesClient.GetVault(this.ResourceGroupName, this.Name);
if (ParameterSetName == AzureRSVaultAddMSIdentity)
{
if (IdentityType == MSIdentity.SystemAssigned)
{
if (IdentityId != null)
{
throw new ArgumentException(Resources.InvalidParameterIdentityId);
}
if (vault.Identity != null && vault.Identity.Type.ToLower().Contains("userassigned"))
{
MSI.Type = MSIdentity.SystemAssigned.ToString() + "," + MSIdentity.UserAssigned.ToString();
}
else
{
MSI.Type = MSIdentity.SystemAssigned.ToString();
}
}
else if (IdentityType == MSIdentity.None)
{
MSI.Type = MSIdentity.None.ToString();
}
else if (IdentityType == MSIdentity.UserAssigned)
{
if (IdentityId == null)
{
throw new ArgumentException(Resources.IdentityIdRequired);
}
if (vault.Identity != null && vault.Identity.Type.ToLower().Contains("systemassigned"))
{
MSI.Type = MSIdentity.SystemAssigned.ToString() + "," + MSIdentity.UserAssigned.ToString();
}
else
{
MSI.Type = MSIdentity.UserAssigned.ToString();
}
MSI.UserAssignedIdentities = new Dictionary <string, UserIdentity>();
foreach (string userIdentityId in IdentityId)
{
MSI.UserAssignedIdentities.Add(userIdentityId, new UserIdentity());
}
}
}
else
{
if (RemoveSystemAssigned.IsPresent)
{
if (IdentityId != null || RemoveUserAssigned.IsPresent)
{
throw new ArgumentException(Resources.InvalidIdentityRemove);
}
if (vault.Identity != null && vault.Identity.Type.ToLower().Contains("systemassigned"))
{
if (vault.Identity.Type.ToLower().Contains("userassigned"))
{
MSI.Type = MSIdentity.UserAssigned.ToString();
}
else
{
MSI.Type = MSIdentity.None.ToString();
}
}
}
else if (RemoveUserAssigned.IsPresent)
{
if (IdentityId == null)
{
throw new ArgumentException(Resources.IdentityIdRequired);
}
foreach (string identity in IdentityId)
{
if (!vault.Identity.UserAssignedIdentities.ContainsKey(identity))
{
throw new ArgumentException(String.Format(Resources.InvalidIdentityId, identity));
}
}
if (vault.Identity != null && vault.Identity.Type.ToLower().Contains("userassigned"))
{
if (vault.Identity.Type.ToLower().Contains("systemassigned"))
{
if (vault.Identity.UserAssignedIdentities.Keys.Count == IdentityId.Length)
{
MSI.Type = MSIdentity.SystemAssigned.ToString();
}
else
{
MSI.Type = MSIdentity.SystemAssigned.ToString() + "," + MSIdentity.UserAssigned.ToString();
}
}
else
{
if (vault.Identity.UserAssignedIdentities.Keys.Count == IdentityId.Length)
{
MSI.Type = MSIdentity.None.ToString();
}
else
{
MSI.Type = MSIdentity.UserAssigned.ToString();
}
}
if (MSI.Type != "SystemAssigned" && MSI.Type != "None")
{
MSI.UserAssignedIdentities = new Dictionary <string, UserIdentity>();
foreach (string userIdentityId in IdentityId)
{
MSI.UserAssignedIdentities.Add(userIdentityId, null);
}
}
}
}
else
{
throw new ArgumentException(Resources.InvalidParameterSet);
}
}
PatchVault patchVault = new PatchVault();
patchVault.Identity = MSI;
vault = RecoveryServicesClient.UpdateRSVault(this.ResourceGroupName, this.Name, patchVault);
WriteObject(new ARSVault(vault));
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}
}
/// <summary>
/// Method to create or update Recovery Services Vault.
/// </summary>
/// <param name="resouceGroupName">Name of the resouce group</param>
/// <param name="vaultName">Name of the vault</param>
/// <param name="patchVault">patch vault object to patch the recovery services Vault</param>
/// <returns>Azure Recovery Services Vault.</returns>
public Vault UpdateRSVault(string resouceGroupName, string vaultName, PatchVault patchVault)
{
var response = RSAdapter.Client.Vaults.UpdateWithHttpMessagesAsync(resouceGroupName, vaultName, patchVault).Result;
return(response.Body);
}
/// <summary>
/// Method to create or update Recovery Services Vault.
/// </summary>
/// <param name="resouceGroupName">Name of the resouce group</param>
/// <param name="vaultName">Name of the vault</param>
/// <param name="vault">patch vault object to patch the recovery services Vault</param>
/// <returns>Azure Recovery Services Vault.</returns>
public Vault UpdateRSVault(string resouceGroupName, string vaultName, PatchVault vault)
{
var response = GetRecoveryServicesClient.Vaults.UpdateWithHttpMessagesAsync(resouceGroupName, vaultName, vault).Result;
return(response.Body);
}
