/// <summary>
/// Method to execute the command
/// </summary>
private void GetVaultSettingsFile()
{
AzureSubscription subscription = DefaultProfile.Context.Subscription;
// Generate certificate
X509Certificate2 cert = CertUtils.CreateSelfSignedCertificate(VaultCertificateExpiryInHoursForHRM, subscription.Id.ToString(), this.Vault.Name);
ASRSite site = new ASRSite();
if (!string.IsNullOrEmpty(this.SiteIdentifier) && !string.IsNullOrEmpty(this.SiteFriendlyName))
{
site.ID = this.SiteIdentifier;
site.Name = this.SiteFriendlyName;
}
// Generate file.
ASRVaultCreds vaultCreds = RecoveryServicesClient.GenerateVaultCredential(
cert,
this.Vault,
site);
string filePath = string.IsNullOrEmpty(this.Path) ? Utilities.GetDefaultPath() : this.Path;
string fileName = this.GenerateFileName();
// write the content to a file.
VaultSettingsFilePath output = new VaultSettingsFilePath()
{
FilePath = Utilities.WriteToFile <ASRVaultCreds>(vaultCreds, filePath, fileName)
};
// print the path to the user.
this.WriteObject(output, true);
}
/// <summary>
/// Method to generate the credential file content
/// </summary>
/// <param name="managementCert">management cert</param>
/// <param name="acsDetails">ACS details</param>
/// <param name="channelIntegrityKey">Integrity key</param>
/// <param name="vault">vault object</param>
/// <param name="site">site object</param>
/// <returns>vault credential object</returns>
private ASRVaultCreds GenerateCredentialObject(
X509Certificate2 managementCert,
VaultCertificateResponse acsDetails,
string channelIntegrityKey,
ARSVault vault,
ASRSite site)
{
string serializedCertificate = Convert.ToBase64String(managementCert.Export(X509ContentType.Pfx));
AcsNamespace acsNamespace = new AcsNamespace(acsDetails.Properties as ResourceCertificateAndAcsDetails);
string resourceProviderNamespace = string.Empty;
string resourceType = string.Empty;
Utilities.GetResourceProviderNamespaceAndType(vault.ID, out resourceProviderNamespace, out resourceType);
ASRVaultCreds vaultCreds = new ASRVaultCreds(
vault.SubscriptionId,
vault.Name,
serializedCertificate,
acsNamespace,
channelIntegrityKey,
vault.ResourceGroupName,
site.ID,
site.Name,
resourceProviderNamespace,
resourceType,
vault.Location);
return(vaultCreds);
}
private ASRVaultCreds ReadAadASRVaultCreds()
{
ASRVaultCreds asrVaultCreds;
var serializer = new DataContractSerializer(typeof(RSVaultAsrCreds));
using (var s = new FileStream(
this.Path,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
RSVaultAsrCreds aadCreds = (RSVaultAsrCreds)serializer.ReadObject(s);
asrVaultCreds = new ASRVaultCreds();
asrVaultCreds.ChannelIntegrityKey = aadCreds.ChannelIntegrityKey;
asrVaultCreds.ResourceGroupName = aadCreds.VaultDetails.ResourceGroup;
asrVaultCreds.Version = aadCreds.Version;
asrVaultCreds.SiteId = aadCreds.SiteId;
asrVaultCreds.SiteName = aadCreds.SiteName;
asrVaultCreds.ResourceNamespace = aadCreds.VaultDetails.ProviderNamespace;
asrVaultCreds.ARMResourceType = aadCreds.VaultDetails.ResourceType;
asrVaultCreds.ResourceName = aadCreds.VaultDetails.ResourceName;
asrVaultCreds.PrivateEndpointStateForSiteRecovery = aadCreds.PrivateEndpointStateForSiteRecovery;
}
return(asrVaultCreds);
}
/// <summary>
/// Initializes a new instance of the <see cref="ASRVaultSettings" /> class
/// </summary>
/// <param name="asrVaultCreds">Vault credentails</param>
public ASRVaultSettings(ASRVaultCreds asrVaultCreds)
{
this.ResourceName = asrVaultCreds.ResourceName;
this.ResouceGroupName = asrVaultCreds.ResourceGroupName;
this.ResourceNamespace = asrVaultCreds.ResourceNamespace;
this.ResouceType = asrVaultCreds.ARMResourceType;
}
/// <summary>
/// Gets the vault credential object
/// </summary>
/// <param name="managementCert">certificate to be uploaded</param>
/// <param name="vault">vault object</param>
/// <returns>credential object</returns>
public ASRVaultCreds GenerateVaultCredential(X509Certificate2 managementCert, ASRVault vault, ASRSite site)
{
ASRVaultCreds currentVaultContext = new ASRVaultCreds(
PSRecoveryServicesClient.asrVaultCreds.SubscriptionId,
PSRecoveryServicesClient.asrVaultCreds.ResourceName,
PSRecoveryServicesClient.asrVaultCreds.ManagementCert,
PSRecoveryServicesClient.asrVaultCreds.AcsNamespace,
PSRecoveryServicesClient.asrVaultCreds.ChannelIntegrityKey,
PSRecoveryServicesClient.asrVaultCreds.ResourceGroupName,
PSRecoveryServicesClient.asrVaultCreds.SiteId,
PSRecoveryServicesClient.asrVaultCreds.SiteName,
PSRecoveryServicesClient.asrVaultCreds.ResourceNamespace,
PSRecoveryServicesClient.asrVaultCreds.ResourceType);
string resourceProviderNamespace = string.Empty;
string resourceType = string.Empty;
Utilities.GetResourceProviderNamespaceAndType(vault.ID, out resourceProviderNamespace, out resourceType);
// Update vault settings with the working vault to generate file
Utilities.UpdateCurrentVaultContext(new ASRVaultCreds()
{
ResourceGroupName = vault.ResourceGroupName,
ResourceName = vault.Name,
ResourceNamespace = resourceProviderNamespace,
ARMResourceType = resourceType
});
// Get Channel Integrity key
string channelIntegrityKey;
Task <string> getChannelIntegrityKey = this.GetChannelIntegrityKey();
// Making sure we can generate the file, once the SDK and portal are inter-operable
// upload certificate and fetch of ACIK can be made parallel to improvve the performace.
getChannelIntegrityKey.Wait();
// Upload certificate
UploadCertificateResponse acsDetails;
Task <UploadCertificateResponse> uploadCertificate = this.UpdateVaultCertificate(managementCert);
uploadCertificate.Wait();
acsDetails = uploadCertificate.Result;
channelIntegrityKey = getChannelIntegrityKey.Result;
ASRVaultCreds asrVaultCreds = this.GenerateCredentialObject(
managementCert,
acsDetails,
channelIntegrityKey,
vault,
site);
// Update back the original vault settings
Utilities.UpdateCurrentVaultContext(currentVaultContext);
return(asrVaultCreds);
}
protected RecoveryServicesTestsBase()
{
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("VAULT_SETTINGS_FILE_PATH")))
{
Environment.SetEnvironmentVariable(
"VAULT_SETTINGS_FILE_PATH",
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ScenarioTests", "vaultSettings.vaultcredentials"));
}
this.vaultSettingsFilePath = Environment.GetEnvironmentVariable("VAULT_SETTINGS_FILE_PATH");
this.vaultName = "VaultUpgrade";
this.location = "South India";
this.resourceType = "HyperVRecoveryManagerVault";
this.targetRgName = "test-rg";
this.resourceNamespace = "WAHyperVRecoveryManager";
this.cloudServiceName = "CS-South-India-RecoveryServices";
if (string.IsNullOrEmpty(vaultSettingsFilePath))
{
throw new Exception("Please set VAULT_SETTINGS_FILE_PATH environment variable before running the tests");
}
if (File.Exists(this.vaultSettingsFilePath))
{
try
{
var serializer1 = new DataContractSerializer(typeof(ASRVaultCreds));
using (var s = new FileStream(
this.vaultSettingsFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
asrVaultCreds = (ASRVaultCreds)serializer1.ReadObject(s);
}
}
catch (XmlException xmlException)
{
throw new XmlException(
"XML is malformed or file is empty", xmlException);
}
catch (SerializationException serializationException)
{
throw new SerializationException(
"XML is malformed or file is empty", serializationException);
}
}
else
{
throw new FileNotFoundException(
"Vault settings file not found, please pass the file downloaded from portal");
}
helper = new EnvironmentSetupHelper();
}
/// <summary>
/// Gets the vault credential object
/// </summary>
/// <param name="managementCert">certificate to be uploaded</param>
/// <param name="vault">vault object</param>
/// <param name="site">site object</param>
/// <param name="authType">authentication type</param>
/// <returns>credential object</returns>
public ASRVaultCreds GenerateVaultCredential(
X509Certificate2 managementCert,
ARSVault vault,
ASRSite site,
string authType)
{
ASRVaultCreds currentVaultContext = PSRecoveryServicesClient.arsVaultCreds;
string resourceProviderNamespace = string.Empty;
string resourceType = string.Empty;
Utilities.GetResourceProviderNamespaceAndType(vault.ID, out resourceProviderNamespace, out resourceType);
Logger.Instance.WriteDebug(string.Format(
"GenerateVaultCredential resourceProviderNamespace = {0}, resourceType = {1}",
resourceProviderNamespace,
resourceType));
// Update vault settings with the working vault to generate file
Utilities.UpdateCurrentVaultContext(new ASRVaultCreds()
{
ResourceGroupName = vault.ResourceGroupName,
ResourceName = vault.Name,
ResourceNamespace = resourceProviderNamespace,
ARMResourceType = resourceType
});
// Get Channel Integrity key
string channelIntegrityKey;
string getChannelIntegrityKey = this.GetCurrentVaultChannelIntegrityKey();
// Making sure we can generate the file, once the SDK and portal are inter-operable
// upload certificate and fetch of ACIK can be made parallel to improvve the performace.
// Upload certificate
VaultCertificateResponse uploadCertificate = this.UpdateVaultCertificate(
managementCert,
authType);
channelIntegrityKey = getChannelIntegrityKey;
ASRVaultCreds arsVaultCreds = this.GenerateCredentialObject(
managementCert,
uploadCertificate,
channelIntegrityKey,
vault,
site);
// Update back the original vault settings
Utilities.UpdateCurrentVaultContext(currentVaultContext);
return(arsVaultCreds);
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
protected override void ProcessRecord()
{
// Validate the Vault
RecoveryServicesClient.ValidateVaultSettings(
this.Vault.Name,
this.Vault.ResouceGroupName);
// Change the vault context
ASRVaultCreds vaultCreds = RecoveryServicesClient.ChangeVaultContext(this.Vault);
this.WriteObject(new ASRVaultSettings(PSRecoveryServicesClient.asrVaultCreds));
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteCmdlet()
{
// Validate the Vault
RecoveryServicesClient.ValidateVaultSettings(
this.Vault.Name,
this.Vault.ResouceGroupName);
// Change the vault context
ASRVaultCreds vaultCreds = RecoveryServicesClient.ChangeVaultContext(this.Vault);
this.WriteObject(new ASRVaultSettings(
PSRecoveryServicesClient.asrVaultCreds.ResourceName,
PSRecoveryServicesClient.asrVaultCreds.ResourceGroupName));
}
/// <summary>
/// Imports Azure Site Recovery Vault settings.
/// </summary>
/// <param name="asrVaultCreds">ASR Vault credentials</param>
public void ImportAzureSiteRecoveryVaultSettings(ASRVaultCreds asrVaultCreds)
{
object updateVaultSettingsOneAtATime = new object();
lock (updateVaultSettingsOneAtATime)
{
PSRecoveryServicesClient.asrVaultCreds.ResourceName =
asrVaultCreds.ResourceName;
PSRecoveryServicesClient.asrVaultCreds.CloudServiceName =
asrVaultCreds.CloudServiceName;
PSRecoveryServicesClient.asrVaultCreds.ChannelIntegrityKey =
asrVaultCreds.ChannelIntegrityKey;
}
}
/// <summary>
/// Imports Azure Site Recovery Vault settings.
/// </summary>
/// <param name="asrVaultCreds">ASR Vault credentials</param>
public static void UpdateVaultSettings(ASRVaultCreds asrVaultCreds)
{
object updateVaultSettingsOneAtATime = new object();
lock (updateVaultSettingsOneAtATime)
{
PSRecoveryServicesClient.asrVaultCreds.ResourceName =
asrVaultCreds.ResourceName;
PSRecoveryServicesClient.asrVaultCreds.ResourceGroupName =
asrVaultCreds.ResourceGroupName;
PSRecoveryServicesClient.asrVaultCreds.ChannelIntegrityKey =
asrVaultCreds.ChannelIntegrityKey;
}
}
/// <summary>
/// Method to generate the credential file content
/// </summary>
/// <param name="managementCert">management cert</param>
/// <param name="acsDetails">ACS details</param>
/// <param name="channelIntegrityKey">Integrity key</param>
/// <param name="vault">vault object</param>
/// <param name="site">site object</param>
/// <returns>vault credential object</returns>
private ASRVaultCreds GenerateCredentialObject(X509Certificate2 managementCert, UploadCertificateResponse acsDetails, string channelIntegrityKey, ASRVault vault)
{
string serializedCertifivate = Convert.ToBase64String(managementCert.Export(X509ContentType.Pfx));
AcsNamespace acsNamespace = new AcsNamespace(acsDetails);
ASRVaultCreds vaultCreds = new ASRVaultCreds(
vault.SubscriptionId,
vault.Name,
serializedCertifivate,
acsNamespace,
channelIntegrityKey,
vault.ResouceGroupName);
return(vaultCreds);
}
protected RecoveryServicesTestsBase()
{
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("VAULT_SETTINGS_FILE_PATH")))
{
Environment.SetEnvironmentVariable("VAULT_SETTINGS_FILE_PATH", "ScenarioTests\\vaultSettings.vaultcredentials");
}
this.vaultSettingsFilePath = Environment.GetEnvironmentVariable("VAULT_SETTINGS_FILE_PATH");
if (string.IsNullOrEmpty(vaultSettingsFilePath))
{
throw new Exception("Please set VAULT_SETTINGS_FILE_PATH environment variable before running the tests");
}
if (File.Exists(this.vaultSettingsFilePath))
{
try
{
var serializer1 = new DataContractSerializer(typeof(ASRVaultCreds));
using (var s = new FileStream(
this.vaultSettingsFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
asrVaultCreds = (ASRVaultCreds)serializer1.ReadObject(s);
}
}
catch (XmlException xmlException)
{
throw new XmlException(
"XML is malformed or file is empty", xmlException);
}
catch (SerializationException serializationException)
{
throw new SerializationException(
"XML is malformed or file is empty", serializationException);
}
}
else
{
throw new FileNotFoundException(
"Vault settings file not found, please pass the file downloaded from portal");
}
helper = new EnvironmentSetupHelper();
}
/// <summary>
/// Gets the vault credential object
/// </summary>
/// <param name="managementCert">certificate to be uploaded</param>
/// <param name="vault">vault object</param>
/// <param name="site">site object </param>
/// <returns>credential object</returns>
public ASRVaultCreds GenerateVaultCredential(X509Certificate2 managementCert, ASRVault vault, Site site)
{
string currentResourceName = PSRecoveryServicesClient.asrVaultCreds.ResourceName;
string currentCloudServiceName = PSRecoveryServicesClient.asrVaultCreds.CloudServiceName;
// Update vault settings with the working vault to generate file
Utilities.UpdateVaultSettings(new ASRVaultCreds()
{
CloudServiceName = vault.CloudServiceName,
ResourceName = vault.Name
});
// Get Channel Integrity key
string channelIntegrityKey;
Task <string> getChannelIntegrityKey = this.GetChannelIntegrityKey();
// Making sure we can generate the file, once the SDK and portal are inter-operable
// upload certificate and fetch of ACIK can be made parallel to improvve the performace.
getChannelIntegrityKey.Wait();
// Upload certificate
UploadCertificateResponse acsDetails;
Task <UploadCertificateResponse> uploadCertificate = this.UpdateVaultCertificate(managementCert);
uploadCertificate.Wait();
acsDetails = uploadCertificate.Result;
channelIntegrityKey = getChannelIntegrityKey.Result;
ASRVaultCreds asrVaultCreds = this.GenerateCredentialObject(
managementCert,
acsDetails,
channelIntegrityKey,
vault,
site);
// Update back the original vault settings
Utilities.UpdateVaultSettings(new ASRVaultCreds()
{
CloudServiceName = currentCloudServiceName,
ResourceName = currentResourceName
});
return(asrVaultCreds);
}
/// <summary>
/// Set Azure Recovery Services Vault context.
/// </summary>
private void SetARSVaultContext(
ARSVault arsVault)
{
try
{
VaultExtendedInfoResource vaultExtendedInfo = null;
try
{
vaultExtendedInfo = this.RecoveryServicesClient
.GetVaultExtendedInfo(this.Vault.ResourceGroupName, this.Vault.Name);
}
catch (Exception ex)
{
// code interanally handled the cloud exception thrown earlier.But still there are changes of other exception.
// suggesting alternate way to user to unblock if this command is failing.
Logger.Instance.WriteWarning(ex.Message);
throw new Exception(Resources.TryDownloadingVaultFile);
}
ASRVaultCreds asrVaultCreds = new ASRVaultCreds();
asrVaultCreds.ResourceName = this.Vault.Name;
asrVaultCreds.ResourceGroupName = this.Vault.ResourceGroupName;
asrVaultCreds.ChannelIntegrityKey = vaultExtendedInfo.IntegrityKey;
asrVaultCreds.ResourceNamespace = ARMResourceTypeConstants
.RecoveryServicesResourceProviderNameSpace;
asrVaultCreds.ARMResourceType = ARMResourceTypeConstants.RecoveryServicesVault;
asrVaultCreds.PrivateEndpointStateForSiteRecovery = this.Vault.Properties.PrivateEndpointStateForSiteRecovery;
Utilities.UpdateCurrentVaultContext(asrVaultCreds);
this.RecoveryServicesClient.ValidateVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.ResourceGroupName);
this.WriteObject(new ASRVaultSettings(asrVaultCreds));
}
catch (InvalidOperationException e)
{
this.WriteDebug(e.Message);
}
}
/// <summary>
/// Updates current Vault context.
/// </summary>
/// <param name="asrVaultCreds">ASR Vault credentials</param>
public static void UpdateCurrentVaultContext(
ASRVaultCreds asrVaultCreds)
{
var updateVaultContextOneAtATime = new object();
lock (updateVaultContextOneAtATime)
{
PSRecoveryServicesClient.asrVaultCreds.ResourceName = asrVaultCreds.ResourceName;
PSRecoveryServicesClient.asrVaultCreds.ResourceGroupName =
asrVaultCreds.ResourceGroupName;
PSRecoveryServicesClient.asrVaultCreds.ChannelIntegrityKey =
asrVaultCreds.ChannelIntegrityKey;
PSRecoveryServicesClient.asrVaultCreds.ResourceNamespace =
asrVaultCreds.ResourceNamespace;
PSRecoveryServicesClient.asrVaultCreds.ARMResourceType =
asrVaultCreds.ARMResourceType;
}
}
protected AsrTestsBase()
{
this.vaultSettingsFilePath = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
"ScenarioTests\\vaultSettings.VaultCredentials");
if (File.Exists(this.vaultSettingsFilePath))
{
try
{
var serializer1 = new DataContractSerializer(typeof(ASRVaultCreds));
using (var s = new FileStream(
this.vaultSettingsFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
this.asrVaultCreds = (ASRVaultCreds)serializer1.ReadObject(s);
}
}
catch (XmlException xmlException)
{
throw new XmlException(
"XML is malformed or file is empty",
xmlException);
}
catch (SerializationException serializationException)
{
throw new SerializationException(
"XML is malformed or file is empty",
serializationException);
}
}
else
{
throw new FileNotFoundException(
string.Format(
"Vault settings file not found at '{0}', please pass the file downloaded from portal",
this.vaultSettingsFilePath));
}
this.helper = new EnvironmentSetupHelper();
}
/// <summary>
/// Set Azure Recovery Services Vault context.
/// </summary>
private void SetARSVaultContext(
ARSVault arsVault)
{
try
{
VaultExtendedInfoResource vaultExtendedInfo = null;
try
{
vaultExtendedInfo = this.RecoveryServicesClient
.GetVaultExtendedInfo(this.Vault.ResourceGroupName, this.Vault.Name);
}
catch (CloudException ex)
{
throw new Exception(Resources.TryDownloadingVaultFile);
}
ASRVaultCreds asrVaultCreds = new ASRVaultCreds();
asrVaultCreds.ResourceName = this.Vault.Name;
asrVaultCreds.ResourceGroupName = this.Vault.ResourceGroupName;
asrVaultCreds.ChannelIntegrityKey = vaultExtendedInfo.IntegrityKey;
asrVaultCreds.ResourceNamespace = ARMResourceTypeConstants
.RecoveryServicesResourceProviderNameSpace;
asrVaultCreds.ARMResourceType = ARMResourceTypeConstants.RecoveryServicesVault;
Utilities.UpdateCurrentVaultContext(asrVaultCreds);
this.RecoveryServicesClient.ValidateVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.ResourceGroupName);
this.WriteObject(new ASRVaultSettings(asrVaultCreds));
}
catch (InvalidOperationException e)
{
this.WriteDebug(e.Message);
}
}
/// <summary>
/// Method to execute the command
/// </summary>
private void GetByObject()
{
IAzureSubscription subscription = this.Profile.Context.Subscription;
this.Vault.SubscriptionId = subscription.Id.ToString();
CloudService cloudService = RecoveryServicesClient.GetCloudServiceForVault(this.Vault);
this.Vault.CloudServiceName = cloudService.Name;
// Generate certificate
X509Certificate2 cert = CertUtils.CreateSelfSignedCertificate(VaultCertificateExpiryInHoursForHRM, subscription.Id.ToString(), this.Vault.Name);
var site = new Site();
if (this.Site != null)
{
site.ID = this.Site.ID;
site.Name = this.Site.Name;
site.Type = this.Site.Type;
}
// Generate file.
ASRVaultCreds vaultCreds = RecoveryServicesClient.GenerateVaultCredential(
cert,
this.Vault,
site);
string filePath = string.IsNullOrEmpty(this.Path) ? Utilities.GetDefaultPath() : this.Path;
string fileName = this.GenerateFileName();
// write the content to a file.
VaultSettingsFilePath output = new VaultSettingsFilePath()
{
FilePath = Utilities.WriteToFile <ASRVaultCreds>(vaultCreds, filePath, fileName)
};
// print the path to the user.
this.WriteObject(output, true);
}
/// <summary>
/// Set Azure Recovery Services Vault context.
/// </summary>
private void SetARSVaultContext(
ARSVault arsVault)
{
try
{
using (var powerShell = System.Management.Automation.PowerShell.Create())
{
var vaultExtendedInfo = this.RecoveryServicesClient
.GetVaultExtendedInfo(this.Vault.ResourceGroupName, this.Vault.Name);
ASRVaultCreds asrVaultCreds = new ASRVaultCreds();
asrVaultCreds.ResourceName = this.Vault.Name;
asrVaultCreds.ResourceGroupName = this.Vault.ResourceGroupName;
asrVaultCreds.ChannelIntegrityKey = vaultExtendedInfo.IntegrityKey;
asrVaultCreds.ResourceNamespace = ARMResourceTypeConstants
.RecoveryServicesResourceProviderNameSpace;
asrVaultCreds.ARMResourceType = ARMResourceTypeConstants.RecoveryServicesVault;
Utilities.UpdateCurrentVaultContext(asrVaultCreds);
this.RecoveryServicesClient.ValidateVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.ResourceGroupName);
this.WriteObject(new ASRVaultSettings(asrVaultCreds));
powerShell.Commands.Clear();
}
}
catch (InvalidOperationException e)
{
this.WriteDebug(e.Message);
}
}
protected SiteRecoveryTestsBase()
{
this.vaultSettingsFilePath = "ScenarioTests\\vaultSettings.VaultCredentials";
if (File.Exists(this.vaultSettingsFilePath))
{
try
{
var serializer1 = new DataContractSerializer(typeof(ASRVaultCreds));
using (var s = new FileStream(
this.vaultSettingsFilePath,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
asrVaultCreds = (ASRVaultCreds)serializer1.ReadObject(s);
}
}
catch (XmlException xmlException)
{
throw new XmlException(
"XML is malformed or file is empty", xmlException);
}
catch (SerializationException serializationException)
{
throw new SerializationException(
"XML is malformed or file is empty", serializationException);
}
}
else
{
throw new FileNotFoundException(
"Vault settings file not found, please pass the file downloaded from portal");
}
helper = new EnvironmentSetupHelper();
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteSiteRecoveryCmdlet()
{
base.ExecuteSiteRecoveryCmdlet();
if (this.ShouldProcess(
"Vault Setting file",
VerbsData.Import))
{
this.WriteVerbose("Vault Settings File path: " + this.Path);
ASRVaultCreds asrVaultCreds = null;
if (File.Exists(this.Path))
{
try
{
if (FileUtilities.DataStore.ReadFileAsText(this.Path).ToLower().Contains("<asrvaultcreds"))
{
asrVaultCreds = ReadAcsASRVaultCreds();
}
else
{
asrVaultCreds = ReadAadASRVaultCreds();
}
}
catch (XmlException xmlException)
{
throw new XmlException(
string.Format(
Resources.InvalidXml,
xmlException));
}
catch (SerializationException serializationException)
{
throw new SerializationException(
string.Format(
Resources.InvalidXml,
serializationException));
}
}
else
{
throw new FileNotFoundException(
Resources.VaultSettingFileNotFound,
this.Path);
}
// Validate required parameters taken from the Vault settings file.
if (string.IsNullOrEmpty(asrVaultCreds.ResourceName))
{
throw new ArgumentException(
Resources.ResourceNameNullOrEmpty,
asrVaultCreds.ResourceName);
}
if (string.IsNullOrEmpty(asrVaultCreds.ResourceGroupName))
{
throw new ArgumentException(
Resources.CloudServiceNameNullOrEmpty,
asrVaultCreds.ResourceGroupName);
}
Utilities.UpdateCurrentVaultContext(asrVaultCreds);
this.RecoveryServicesClient.ValidateVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.ResourceGroupName);
this.WriteObject(new ASRVaultSettings(asrVaultCreds));
}
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteCmdlet()
{
this.WriteVerbose("Vault Settings File path: " + this.Path);
ASRVaultCreds asrVaultCreds = null;
if (File.Exists(this.Path))
{
try
{
this.WriteWarningWithTimestamp(
string.Format(
Properties.Resources.CmdletWillBeDeprecatedSoon,
this.MyInvocation.MyCommand.Name));
var serializer = new DataContractSerializer(typeof(ASRVaultCreds));
using (var s = new FileStream(
this.Path,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
asrVaultCreds = (ASRVaultCreds)serializer.ReadObject(s);
}
}
catch (XmlException xmlException)
{
throw new XmlException(
string.Format(Properties.Resources.InvalidXml, xmlException));
}
catch (SerializationException serializationException)
{
throw new SerializationException(
string.Format(Properties.Resources.InvalidXml, serializationException));
}
}
else
{
throw new FileNotFoundException(
Properties.Resources.VaultSettingFileNotFound,
this.Path);
}
// Validate required parameters taken from the Vault settings file.
if (string.IsNullOrEmpty(asrVaultCreds.ResourceName))
{
throw new ArgumentException(
Properties.Resources.ResourceNameNullOrEmpty,
asrVaultCreds.ResourceName);
}
if (string.IsNullOrEmpty(asrVaultCreds.CloudServiceName))
{
throw new ArgumentException(
Properties.Resources.CloudServiceNameNullOrEmpty,
asrVaultCreds.CloudServiceName);
}
try
{
RecoveryServicesClient.ValidateVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.CloudServiceName);
Utilities.UpdateVaultSettings(asrVaultCreds);
this.WriteObject(new ASRVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.CloudServiceName));
}
catch (Exception exception)
{
this.HandleException(exception);
}
}
/// <summary>
/// Method to execute the command
/// </summary>
private void GetSiteRecoveryCredentials()
{
IAzureSubscription subscription = DefaultProfile.DefaultContext.Subscription;
// Generate certificate
X509Certificate2 cert = CertUtils.CreateSelfSignedCertificate(
VaultCertificateExpiryInHoursForHRM,
subscription.Id.ToString(),
this.Vault.Name);
ASRSite site = new ASRSite();
if (!string.IsNullOrEmpty(this.SiteIdentifier) &&
!string.IsNullOrEmpty(this.SiteFriendlyName))
{
site.ID = this.SiteIdentifier;
site.Name = this.SiteFriendlyName;
}
string fileName = this.GenerateFileName();
string filePath = string.IsNullOrEmpty(this.Path) ? Utilities.GetDefaultPath() : this.Path;
// Generate file.
if (RecoveryServicesClient.getVaultAuthType(this.Vault.ResourceGroupName, this.Vault.Name) == 0)
{
ASRVaultCreds vaultCreds = RecoveryServicesClient.GenerateVaultCredential(
cert,
this.Vault,
site,
AuthType.ACS);
// write the content to a file.
VaultSettingsFilePath output = new VaultSettingsFilePath()
{
FilePath = Utilities.WriteToFile <ASRVaultCreds>(vaultCreds, filePath, fileName)
};
// print the path to the user.
this.WriteObject(output, true);
}
else
{
string fullFilePath = System.IO.Path.Combine(filePath, fileName);
WriteDebug(
string.Format(
CultureInfo.InvariantCulture,
Resources.ExecutingGetVaultCredCmdlet,
subscription.Id,
this.Vault.ResourceGroupName,
this.Vault.Name,
fullFilePath));
VaultCertificateResponse vaultCertificateResponse = null;
try
{
// Upload cert into ID Mgmt
WriteDebug(string.Format(CultureInfo.InvariantCulture, Resources.UploadingCertToIdmgmt));
vaultCertificateResponse = UploadCert(cert);
WriteDebug(string.Format(CultureInfo.InvariantCulture, Resources.UploadedCertToIdmgmt));
// generate vault credentials
string vaultCredsFileContent = GenerateVaultCredsForSiteRecovery(
cert,
subscription.Id,
vaultCertificateResponse,
site);
WriteDebug(string.Format(Resources.SavingVaultCred, fullFilePath));
File.WriteAllBytes(fullFilePath, Encoding.UTF8.GetBytes(vaultCredsFileContent));
VaultSettingsFilePath output = new VaultSettingsFilePath()
{
FilePath = fullFilePath,
};
// Output filename back to user
WriteObject(output, true);
}
catch (Exception exception)
{
throw exception;
}
}
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteSiteRecoveryCmdlet()
{
base.ExecuteSiteRecoveryCmdlet();
this.WriteVerbose("Vault Settings File path: " + this.Path);
ASRVaultCreds asrVaultCreds = null;
if (File.Exists(this.Path))
{
try
{
var serializer = new DataContractSerializer(typeof(ASRVaultCreds));
using (var s = new FileStream(
this.Path,
FileMode.Open,
FileAccess.Read,
FileShare.Read))
{
asrVaultCreds = (ASRVaultCreds)serializer.ReadObject(s);
}
}
catch (XmlException xmlException)
{
throw new XmlException(
string.Format(Properties.Resources.InvalidXml, xmlException));
}
catch (SerializationException serializationException)
{
throw new SerializationException(
string.Format(Properties.Resources.InvalidXml, serializationException));
}
}
else
{
throw new FileNotFoundException(
Properties.Resources.VaultSettingFileNotFound,
this.Path);
}
// Validate required parameters taken from the Vault settings file.
if (string.IsNullOrEmpty(asrVaultCreds.ResourceName))
{
throw new ArgumentException(
Properties.Resources.ResourceNameNullOrEmpty,
asrVaultCreds.ResourceName);
}
if (string.IsNullOrEmpty(asrVaultCreds.ResourceGroupName))
{
throw new ArgumentException(
Properties.Resources.CloudServiceNameNullOrEmpty,
asrVaultCreds.ResourceGroupName);
}
Utilities.UpdateCurrentVaultContext(asrVaultCreds);
RecoveryServicesClient.ValidateVaultSettings(
asrVaultCreds.ResourceName,
asrVaultCreds.ResourceGroupName);
this.WriteObject(new ASRVaultSettings(asrVaultCreds));
}
