/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteSiteRecoveryCmdlet()
{
base.ExecuteSiteRecoveryCmdlet();
if (this.ShouldProcess(this.Name, VerbsCommon.New))
{
var policy = this.RecoveryServicesClient.GetAzureSiteRecoveryPolicy(
Utilities.GetValueFromArmId(
this.ProtectionContainerMapping.PolicyId,
ARMResourceTypeConstants.ReplicationPolicies));
var policyInstanceType = policy.Properties.ProviderSpecificDetails;
var enableProtectionProviderSpecificInput =
new EnableProtectionProviderSpecificInput();
var inputProperties = new EnableProtectionInputProperties
{
PolicyId = this.ProtectionContainerMapping.PolicyId,
// A2A there is no ProtectableItem
ProtectableItemId = this.ProtectableItem == null ? null : this.ProtectableItem.ID,
ProviderSpecificDetails = enableProtectionProviderSpecificInput
};
var input = new EnableProtectionInput {
Properties = inputProperties
};
switch (this.ParameterSetName)
{
case ASRParameterSets.EnterpriseToEnterprise:
if (!(policyInstanceType is HyperVReplicaPolicyDetails) &&
!(policyInstanceType is HyperVReplicaBluePolicyDetails))
{
throw new PSArgumentException(
string.Format(
Resources.ContainerMappingParameterSetMismatch,
this.ProtectionContainerMapping.Name,
policyInstanceType));
}
break;
case ASRParameterSets.EnterpriseToAzure:
case ASRParameterSets.HyperVSiteToAzure:
if (!(policyInstanceType is HyperVReplicaAzurePolicyDetails))
{
throw new PSArgumentException(
string.Format(
Resources.ContainerMappingParameterSetMismatch,
this.ProtectionContainerMapping.Name,
policyInstanceType));
}
EnterpriseAndHyperVToAzure(input);
break;
case VMwareToAzureWithDiskType:
case VMwareToAzureParameterSet:
if (!(policyInstanceType is InMageAzureV2PolicyDetails))
{
throw new PSArgumentException(
string.Format(
Resources.ContainerMappingParameterSetMismatch,
this.ProtectionContainerMapping.Name,
policyInstanceType));
}
VMwareToAzureReplication(input);
break;
case ASRParameterSets.AzureToAzureWithoutDiskDetails:
case ASRParameterSets.AzureToAzure:
if (!(policyInstanceType is A2APolicyDetails))
{
throw new PSArgumentException(
string.Format(
Properties.Resources.ContainerMappingParameterSetMismatch,
this.ProtectionContainerMapping.Name,
policyInstanceType));
}
AzureToAzureReplication(input);
break;
default:
break;
}
this.response = this.RecoveryServicesClient.EnableProtection(
Utilities.GetValueFromArmId(
this.ProtectionContainerMapping.ID,
ARMResourceTypeConstants.ReplicationFabrics),
Utilities.GetValueFromArmId(
this.ProtectionContainerMapping.ID,
ARMResourceTypeConstants.ReplicationProtectionContainers),
this.Name,
input);
this.jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
PSRecoveryServicesClient.GetJobIdFromReponseLocation(this.response.Location));
this.WriteObject(new ASRJob(this.jobResponse));
if (this.WaitForCompletion.IsPresent)
{
this.WaitForJobCompletion(this.jobResponse.Name);
this.jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
PSRecoveryServicesClient
.GetJobIdFromReponseLocation(this.response.Location));
this.WriteObject(new ASRJob(this.jobResponse));
}
}
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteSiteRecoveryCmdlet()
{
base.ExecuteSiteRecoveryCmdlet();
this.targetNameOrId = this.ProtectionEntity.FriendlyName;
this.ConfirmAction(
this.Force.IsPresent || 0 != string.CompareOrdinal(this.Protection, Constants.DisableProtection),
string.Format(Properties.Resources.DisableProtectionWarning, this.targetNameOrId),
string.Format(Properties.Resources.DisableProtectionWhatIfMessage, this.Protection),
this.targetNameOrId,
() =>
{
if (this.Protection == Constants.EnableProtection)
{
if (string.Compare(this.ParameterSetName, ASRParameterSets.DisableDR, StringComparison.OrdinalIgnoreCase) == 0)
{
throw new PSArgumentException(Properties.Resources.PassingPolicyMandatoryForEnablingDR);
}
EnableProtectionProviderSpecificInput enableProtectionProviderSpecificInput = new EnableProtectionProviderSpecificInput();
EnableProtectionInputProperties inputProperties = new EnableProtectionInputProperties()
{
PolicyId = this.Policy.ID,
ProtectableItemId = this.ProtectionEntity.ID,
ProviderSpecificDetails = enableProtectionProviderSpecificInput
};
EnableProtectionInput input = new EnableProtectionInput()
{
Properties = inputProperties
};
// Process if block only if policy is not null, policy is created for E2A or B2A and parameter set is for enable DR of E2A or B2A
if (this.Policy != null &&
0 == string.Compare(this.Policy.ReplicationProvider, Constants.HyperVReplicaAzure, StringComparison.OrdinalIgnoreCase) &&
(0 == string.Compare(this.ParameterSetName, ASRParameterSets.EnterpriseToAzure, StringComparison.OrdinalIgnoreCase) ||
0 == string.Compare(this.ParameterSetName, ASRParameterSets.HyperVSiteToAzure, StringComparison.OrdinalIgnoreCase)))
{
HyperVReplicaAzureEnableProtectionInput providerSettings = new HyperVReplicaAzureEnableProtectionInput();
providerSettings.HvHostVmId = this.ProtectionEntity.FabricObjectId;
providerSettings.VmName = this.ProtectionEntity.FriendlyName;
// Id disk details are missing in input PE object, get the latest PE.
if (string.IsNullOrEmpty(this.ProtectionEntity.OS))
{
// Just checked for OS to see whether the disk details got filled up or not
ProtectableItemResponse protectableItemResponse =
RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem(
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics),
this.ProtectionEntity.ProtectionContainerId,
this.ProtectionEntity.Name);
this.ProtectionEntity = new ASRProtectionEntity(protectableItemResponse.ProtectableItem);
}
if (string.IsNullOrWhiteSpace(this.OS))
{
providerSettings.OSType = ((string.Compare(this.ProtectionEntity.OS, Constants.OSWindows) == 0) || (string.Compare(this.ProtectionEntity.OS, Constants.OSLinux) == 0)) ? this.ProtectionEntity.OS : Constants.OSWindows;
}
else
{
providerSettings.OSType = this.OS;
}
if (string.IsNullOrWhiteSpace(this.OSDiskName))
{
providerSettings.VhdId = this.ProtectionEntity.OSDiskId;
}
else
{
foreach (var disk in this.ProtectionEntity.Disks)
{
if (0 == string.Compare(disk.Name, this.OSDiskName, true))
{
providerSettings.VhdId = disk.Id;
break;
}
}
}
if (RecoveryAzureStorageAccountId != null)
{
providerSettings.TargetStorageAccountId = RecoveryAzureStorageAccountId;
}
input.Properties.ProviderSpecificDetails = providerSettings;
}
else if (this.Policy != null &&
0 == string.Compare(this.Policy.ReplicationProvider, Constants.HyperVReplicaAzure, StringComparison.OrdinalIgnoreCase) &&
0 == string.Compare(this.ParameterSetName, ASRParameterSets.EnterpriseToEnterprise, StringComparison.OrdinalIgnoreCase))
{
throw new PSArgumentException(Properties.Resources.PassingStorageMandatoryForEnablingDRInAzureScenarios);
}
this.response =
RecoveryServicesClient.EnableProtection(
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics),
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationProtectionContainers),
this.ProtectionEntity.Name,
input);
}
else
{
// fetch the latest PE object
ProtectableItemResponse protectableItemResponse =
RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem(Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics),
this.ProtectionEntity.ProtectionContainerId, this.ProtectionEntity.Name);
ProtectableItem protectableItem = protectableItemResponse.ProtectableItem;
if (!this.Force.IsPresent)
{
DisableProtectionInput input = new DisableProtectionInput();
input.Properties = new DisableProtectionInputProperties()
{
ProviderSettings = new DisableProtectionProviderSpecificInput()
};
this.response =
RecoveryServicesClient.DisableProtection(
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics),
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationProtectionContainers),
Utilities.GetValueFromArmId(protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems),
input);
}
else
{
this.response =
RecoveryServicesClient.PurgeProtection(
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics),
Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationProtectionContainers),
Utilities.GetValueFromArmId(protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems)
);
}
}
jobResponse =
RecoveryServicesClient
.GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location));
WriteObject(new ASRJob(jobResponse.Job));
if (this.WaitForCompletion.IsPresent)
{
this.WaitForJobCompletion(this.jobResponse.Job.Name);
jobResponse =
RecoveryServicesClient
.GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location));
WriteObject(new ASRJob(jobResponse.Job));
}
});
}
/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteSiteRecoveryCmdlet()
{
base.ExecuteSiteRecoveryCmdlet();
if (this.ShouldProcess(
this.Name,
VerbsCommon.New))
{
var policy = this.RecoveryServicesClient.GetAzureSiteRecoveryPolicy(
Utilities.GetValueFromArmId(
this.ProtectionContainerMapping.PolicyId,
ARMResourceTypeConstants.ReplicationPolicies));
var policyInstanceType = policy.Properties.ProviderSpecificDetails;
switch (this.ParameterSetName)
{
case ASRParameterSets.EnterpriseToEnterprise:
if (!(policyInstanceType is HyperVReplicaPolicyDetails) &&
!(policyInstanceType is HyperVReplicaBluePolicyDetails))
{
throw new PSArgumentException(
string.Format(
Resources.ContainerMappingParameterSetMismatch,
this.ProtectionContainerMapping.Name,
policyInstanceType));
}
break;
case ASRParameterSets.EnterpriseToAzure:
case ASRParameterSets.HyperVSiteToAzure:
if (!(policyInstanceType is HyperVReplicaAzurePolicyDetails))
{
throw new PSArgumentException(
string.Format(
Resources.ContainerMappingParameterSetMismatch,
this.ProtectionContainerMapping.Name,
policyInstanceType));
}
break;
default:
break;
}
var enableProtectionProviderSpecificInput =
new EnableProtectionProviderSpecificInput();
var inputProperties = new EnableProtectionInputProperties
{
PolicyId = this.ProtectionContainerMapping.PolicyId,
ProtectableItemId = this.ProtectableItem.ID,
ProviderSpecificDetails = enableProtectionProviderSpecificInput
};
var input = new EnableProtectionInput {
Properties = inputProperties
};
// E2A and B2A.
if ((0 ==
string.Compare(
this.ParameterSetName,
ASRParameterSets.EnterpriseToAzure,
StringComparison.OrdinalIgnoreCase)) ||
(0 ==
string.Compare(
this.ParameterSetName,
ASRParameterSets.HyperVSiteToAzure,
StringComparison.OrdinalIgnoreCase)))
{
var providerSettings = new HyperVReplicaAzureEnableProtectionInput();
providerSettings.HvHostVmId = this.ProtectableItem.FabricObjectId;
providerSettings.VmName = this.ProtectableItem.FriendlyName;
providerSettings.TargetAzureVmName = this.ProtectableItem.FriendlyName;
// Id disk details are missing in input PE object, get the latest PE.
if (string.IsNullOrEmpty(this.ProtectableItem.OS))
{
// Just checked for OS to see whether the disk details got filled up or not
var protectableItemResponse = this.RecoveryServicesClient
.GetAzureSiteRecoveryProtectableItem(
Utilities.GetValueFromArmId(
this.ProtectableItem.ID,
ARMResourceTypeConstants.ReplicationFabrics),
this.ProtectableItem.ProtectionContainerId,
this.ProtectableItem.Name);
this.ProtectableItem = new ASRProtectableItem(protectableItemResponse);
}
if (string.IsNullOrWhiteSpace(this.OS))
{
providerSettings.OsType = (string.Compare(
this.ProtectableItem.OS,
Constants.OSWindows,
StringComparison.OrdinalIgnoreCase) ==
0) ||
(string.Compare(
this.ProtectableItem.OS,
Constants.OSLinux) ==
0) ? this.ProtectableItem.OS
: Constants.OSWindows;
}
else
{
providerSettings.OsType = this.OS;
}
if (string.IsNullOrWhiteSpace(this.OSDiskName))
{
providerSettings.VhdId = this.ProtectableItem.OSDiskId;
}
else
{
foreach (var disk in this.ProtectableItem.Disks)
{
if (0 ==
string.Compare(
disk.Name,
this.OSDiskName,
true))
{
providerSettings.VhdId = disk.Id;
break;
}
}
}
if (this.RecoveryAzureStorageAccountId != null)
{
providerSettings.TargetStorageAccountId =
this.RecoveryAzureStorageAccountId;
}
var deploymentType = Utilities.GetValueFromArmId(
this.RecoveryAzureStorageAccountId,
ARMResourceTypeConstants.Providers);
if (deploymentType.ToLower()
.Contains(Constants.Classic.ToLower()))
{
providerSettings.TargetAzureV1ResourceGroupId =
this.RecoveryResourceGroupId;
providerSettings.TargetAzureV2ResourceGroupId = null;
}
else
{
providerSettings.TargetAzureV1ResourceGroupId = null;
providerSettings.TargetAzureV2ResourceGroupId =
this.RecoveryResourceGroupId;
}
input.Properties.ProviderSpecificDetails = providerSettings;
}
this.response = this.RecoveryServicesClient.EnableProtection(
Utilities.GetValueFromArmId(
this.ProtectableItem.ID,
ARMResourceTypeConstants.ReplicationFabrics),
Utilities.GetValueFromArmId(
this.ProtectableItem.ID,
ARMResourceTypeConstants.ReplicationProtectionContainers),
this.Name,
input);
this.jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
PSRecoveryServicesClient.GetJobIdFromReponseLocation(this.response.Location));
this.WriteObject(new ASRJob(this.jobResponse));
if (this.WaitForCompletion.IsPresent)
{
this.WaitForJobCompletion(this.jobResponse.Name);
this.jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
PSRecoveryServicesClient
.GetJobIdFromReponseLocation(this.response.Location));
this.WriteObject(new ASRJob(this.jobResponse));
}
}
}
public static ReplicationProtectedItemOperationResponse EnableDR(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
ProtectionContainer protectionContainer,
Policy policy,
ProtectableItem protectableItem,
string armResourceName)
{
if (policy.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplicaAzure")
{
string vhdId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails)
.DiskDetailsList[0].VhdId;
DiskDetails osDisk = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).DiskDetailsList
.FirstOrDefault(item => item.VhdType == "OperatingSystem");
if (osDisk != null)
{
vhdId = osDisk.VhdId;
}
HyperVReplicaAzureEnableProtectionInput hvrAEnableDRInput =
new HyperVReplicaAzureEnableProtectionInput()
{
HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId,
OSType = "Windows",
VhdId = vhdId,
VmName = protectableItem.Properties.FriendlyName,
TargetStorageAccountId =
(policy.Properties.ProviderSpecificDetails as HyperVReplicaAzurePolicyDetails)
.ActiveStorageAccountId,
};
EnableProtectionInputProperties enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = policy.Id,
ProtectableItemId = protectableItem.Id,
ProviderSpecificDetails = hvrAEnableDRInput
};
EnableProtectionInput enableDRInput = new EnableProtectionInput()
{
Properties = enableDRProp
};
return(client.ReplicationProtectedItem.EnableProtection(
primaryFabric.Name,
protectionContainer.Name,
armResourceName,
enableDRInput,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
else if (policy.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplica2012" ||
policy.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplica2012R2")
{
var enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = policy.Id,
ProtectableItemId = protectableItem.Id,
ProviderSpecificDetails = new EnableProtectionProviderSpecificInput()
};
EnableProtectionInput enableInput = new EnableProtectionInput()
{
Properties = enableDRProp
};
return(client.ReplicationProtectedItem.EnableProtection(
primaryFabric.Name,
protectionContainer.Name,
armResourceName,
enableInput,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
else
{
throw new NotImplementedException();
}
}
public void EndToEndB2ASingleVM()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var client = GetSiteRecoveryClient(CustomHttpHandler);
bool createPolicy = true;
bool pairClouds = true;
bool enableDR = true;
bool pfo = true;
bool commit = true;
bool tfo = true;
bool pfoReverse = true;
bool commitReverse = true;
bool reprotect = true;
bool disableDR = true;
bool unpair = true;
bool removePolicy = true;
// Process Variables
string fabricName = string.Empty;
string recCldName = "Microsoft Azure";
string priCldName = string.Empty;
string policyName = "Hydra-EndToEndB2ASingleVM-" + (new Random()).Next();
string mappingName = "Mapping-EndToEndB2ASingleVM-" + (new Random()).Next();
string enableDRName = string.Empty;
string protectedItemName = "PE" + (new Random()).Next();
// Data Variables
Fabric selectedFabric = null;
ProtectionContainer primaryCloud = null;
Policy selectedPolicy = null;
ProtectableItem protectableItem = null;
ReplicationProtectedItem protectedItem = null;
// Fetch HyperV
if (string.IsNullOrEmpty(fabricName))
{
var fabrics = client.Fabrics.List(RequestHeaders);
foreach (var fabric in fabrics.Fabrics)
{
if (fabric.Properties.CustomDetails.InstanceType.Contains("HyperV"))
{
selectedFabric = fabric;
fabricName = selectedFabric.Name;
}
}
}
else
{
selectedFabric = client.Fabrics.Get(fabricName, RequestHeaders).Fabric;
}
// Fetch Cloud
primaryCloud = client.ProtectionContainer.List(selectedFabric.Name, RequestHeaders).ProtectionContainers[0];
priCldName = primaryCloud.Name;
if (createPolicy)
{
HyperVReplicaAzurePolicyInput hvrAPolicy = new HyperVReplicaAzurePolicyInput()
{
ApplicationConsistentSnapshotFrequencyInHours = 0,
Encryption = "Disable",
OnlineIrStartTime = null,
RecoveryPointHistoryDuration = 0,
ReplicationInterval = 30,
StorageAccounts = new List <string>()
{
"/subscriptions/19b823e2-d1f3-4805-93d7-401c5d8230d5/resourceGroups/Default-Storage-WestUS/providers/Microsoft.ClassicStorage/storageAccounts/bvtmapped2storacc"
}
};
CreatePolicyInputProperties createInputProp = new CreatePolicyInputProperties()
{
ProviderSpecificInput = hvrAPolicy
};
CreatePolicyInput policyInput = new CreatePolicyInput()
{
Properties = createInputProp
};
selectedPolicy = (client.Policies.Create(policyName, policyInput, RequestHeaders) as CreatePolicyOperationResponse).Policy;
}
else
{
selectedPolicy = client.Policies.Get(policyName, RequestHeaders).Policy;
}
if (pairClouds)
{
CreateProtectionContainerMappingInputProperties pairingProps = new CreateProtectionContainerMappingInputProperties()
{
PolicyId = selectedPolicy.Id,
TargetProtectionContainerId = recCldName,
ProviderSpecificInput = new ReplicationProviderContainerMappingInput()
};
CreateProtectionContainerMappingInput pairingInput = new CreateProtectionContainerMappingInput()
{
Properties = pairingProps
};
var pairingResponse = client.ProtectionContainerMapping.ConfigureProtection(
selectedFabric.Name,
primaryCloud.Name,
mappingName,
pairingInput,
RequestHeaders);
}
if (enableDR)
{
if (string.IsNullOrEmpty(enableDRName))
{
protectableItem = client.ProtectableItem.List(selectedFabric.Name, primaryCloud.Name, "Unprotected", RequestHeaders).ProtectableItems[0];
enableDRName = protectableItem.Name;
}
else
{
protectableItem = client.ProtectableItem.Get(selectedFabric.Name, primaryCloud.Name, enableDRName, RequestHeaders).ProtectableItem;
}
HyperVReplicaAzureEnableProtectionInput hvrAEnableDRInput = new HyperVReplicaAzureEnableProtectionInput()
{
HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId,
OSType = "Windows",
VhdId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).DiskDetailsList[0].VhdId,
VmName = protectableItem.Properties.FriendlyName,
TargetStorageAccountId = "/subscriptions/19b823e2-d1f3-4805-93d7-401c5d8230d5/resourceGroups/Default-Storage-WestUS/providers/Microsoft.ClassicStorage/storageAccounts/bvtmapped2storacc",
};
EnableProtectionInputProperties enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = selectedPolicy.Id,
ProtectableItemId = protectableItem.Id,
ProviderSpecificDetails = hvrAEnableDRInput
};
EnableProtectionInput enableDRInput = new EnableProtectionInput()
{
Properties = enableDRProp
};
DateTime enablStartTime = DateTime.UtcNow;
protectedItem = (
client.ReplicationProtectedItem.EnableProtection(
selectedFabric.Name,
primaryCloud.Name,
protectedItemName,
enableDRInput,
RequestHeaders) as ReplicationProtectedItemOperationResponse).ReplicationProtectedItem;
MonitoringHelper.MonitorJobs(MonitoringHelper.AzureIrJobName, enablStartTime, client, RequestHeaders);
}
if (pfo || commit || tfo || pfoReverse || commitReverse || reprotect || disableDR)
{
protectableItem = client.ProtectableItem.Get(selectedFabric.Name, primaryCloud.Name, enableDRName, RequestHeaders).ProtectableItem;
protectedItem = client.ReplicationProtectedItem.Get(selectedFabric.Name, primaryCloud.Name, protectedItemName, RequestHeaders).ReplicationProtectedItem;
// Create Input for Operations
///////////////////////////// PFO /////////////////////////////////////
HyperVReplicaAzureFailoverProviderInput hvrAFOInput = new HyperVReplicaAzureFailoverProviderInput()
{
VaultLocation = "West US",
};
PlannedFailoverInputProperties plannedFailoverProp = new PlannedFailoverInputProperties()
{
FailoverDirection = "",
ProviderSpecificDetails = hvrAFOInput
};
PlannedFailoverInput plannedFailoverInput = new PlannedFailoverInput()
{
Properties = plannedFailoverProp
};
HyperVReplicaAzureFailbackProviderInput hvrAFBInput = new HyperVReplicaAzureFailbackProviderInput()
{
RecoveryVmCreationOption = "NoAction",
DataSyncOption = "ForSyncronization"
};
PlannedFailoverInputProperties plannedFailbackProp = new PlannedFailoverInputProperties()
{
FailoverDirection = "",
ProviderSpecificDetails = hvrAFBInput
};
PlannedFailoverInput plannedFailbackInput = new PlannedFailoverInput()
{
Properties = plannedFailbackProp
};
////////////////////////////// Reprotect //////////////////////////////////////
HyperVReplicaAzureReprotectInput hvrARRInput = new HyperVReplicaAzureReprotectInput()
{
HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId,
OSType = "Windows",
VHDId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).DiskDetailsList[0].VhdId,
VmName = protectableItem.Properties.FriendlyName,
StorageAccountId = "/subscriptions/19b823e2-d1f3-4805-93d7-401c5d8230d5/resourceGroups/Default-Storage-WestUS/providers/Microsoft.ClassicStorage/storageAccounts/bvtmapped2storacc",
};
ReverseReplicationInputProperties rrProp = new ReverseReplicationInputProperties()
{
FailoverDirection = "",
ProviderSpecificDetails = hvrARRInput
};
ReverseReplicationInput rrInput = new ReverseReplicationInput()
{
Properties = rrProp
};
////////////////////////////////// UFO /////////////////////////////////////////
UnplannedFailoverInputProperties ufoProp = new UnplannedFailoverInputProperties()
{
ProviderSpecificDetails = hvrAFOInput,
SourceSiteOperations = "NotRequired"
};
UnplannedFailoverInput ufoInput = new UnplannedFailoverInput()
{
Properties = ufoProp
};
/////////////////////////////////// TFO /////////////////////////////////////////////
TestFailoverInputProperties tfoProp = new TestFailoverInputProperties()
{
ProviderSpecificDetails = hvrAFOInput
};
TestFailoverInput tfoInput = new TestFailoverInput()
{
Properties = tfoProp
};
//////////////////////////////////////////////////////////////////////////////////////////
if (pfo)
{
var plannedfailover = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, plannedFailoverInput, RequestHeaders);
}
if (commit)
{
var commitFailover = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, RequestHeaders);
}
if (pfoReverse)
{
//var unplannedFailoverReverse = client.ReplicationProtectedItem.UnplannedFailover(selectedFabric.Name, priCld, replicationProtectedItems.ReplicationProtectedItems[0].Name, ufoInput, RequestHeaders);
var plannedFailoverReverse = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, plannedFailbackInput, RequestHeaders);
}
if (commitReverse)
{
var commitFailoverReverse = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, RequestHeaders);
}
if (reprotect)
{
var reprotectStartTime = DateTime.UtcNow;
var rrReverseOp = client.ReplicationProtectedItem.Reprotect(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, rrInput, RequestHeaders);
MonitoringHelper.MonitorJobs(MonitoringHelper.AzureIrJobName, reprotectStartTime, client, RequestHeaders);
}
if (tfo)
{
DateTime startTFO = DateTime.UtcNow;
var tfoOp = client.ReplicationProtectedItem.TestFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, tfoInput, RequestHeaders);
var jobs = MonitoringHelper.GetJobId(MonitoringHelper.TestFailoverJobName, startTFO, client, RequestHeaders);
ResumeJobParamsProperties resProp = new ResumeJobParamsProperties()
{
Comments = "Res TFO"
};
ResumeJobParams resParam = new ResumeJobParams()
{
Properties = resProp
};
var resJob = client.Jobs.Resume(jobs.Name, resParam, RequestHeaders);
}
if (disableDR)
{
var disableDROperation = client.ReplicationProtectedItem.DisableProtection(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, new DisableProtectionInput(), RequestHeaders);
}
if (unpair)
{
var unpairClouds = client.ProtectionContainerMapping.UnconfigureProtection(
selectedFabric.Name,
primaryCloud.Name,
mappingName,
new RemoveProtectionContainerMappingInput(),
RequestHeaders);
}
}
if (removePolicy)
{
var policyDeletion = client.Policies.Delete(selectedPolicy.Name, RequestHeaders);
}
}
}
public void EndToEndE2ESingleVM()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var client = GetSiteRecoveryClient(CustomHttpHandler);
bool pairClouds = true;
bool enableDR = true;
bool pfo = true;
bool commit = true;
bool tfo = true;
bool pfoReverse = true;
bool commitReverse = true;
bool rr = true;
bool rrReverse = true;
bool disableDR = true;
bool unpair = true;
bool removePolicy = true;
var fabrics = client.Fabrics.List(RequestHeaders);
Fabric selectedFabric = null;
foreach (var fabric in fabrics.Fabrics)
{
if (fabric.Properties.CustomDetails.InstanceType.Contains("VMM"))
{
selectedFabric = fabric;
}
}
string priCld = string.Empty;
string recCldGuid = string.Empty;
string recCld = string.Empty;
string policyName = "Hydra-EndToEndE2ESingleVM-" + (new Random()).Next();
string mappingName = "Mapping-EndToEndE2ESingleVM-" + (new Random()).Next();
string replicationProtectedItemName = "PE" + (new Random()).Next();
string enableDRVmName = string.Empty;
Policy currentPolicy = null;
var policies = client.Policies.List(RequestHeaders);
if (string.IsNullOrEmpty(recCldGuid))
{
var containers = client.ProtectionContainer.List(selectedFabric.Name, RequestHeaders);
foreach (var container in containers.ProtectionContainers)
{
if (container.Properties.PairingStatus.Equals("NotPaired", StringComparison.InvariantCultureIgnoreCase))
{
if (string.IsNullOrEmpty(priCld))
{
priCld = container.Name;
}
else if (string.IsNullOrEmpty(recCld) && priCld != container.Name)
{
recCld = container.Id;
recCldGuid = container.Name;
}
}
}
}
else
{
recCld = client.ProtectionContainer.Get(selectedFabric.Name, recCldGuid, RequestHeaders).ProtectionContainer.Id;
}
if (pairClouds)
{
HyperVReplica2012R2PolicyInput hvrProfileInput = new HyperVReplica2012R2PolicyInput()
{
ApplicationConsistentSnapshotFrequencyInHours = 0,
AllowedAuthenticationType = 1,
Compression = "Enable",
InitialReplicationMethod = "OverNetwork",
OnlineReplicationStartTime = null,
RecoveryPoints = 0,
ReplicaDeletion = "Required",
ReplicationPort = 8083,
ReplicationFrequencyInSeconds = 300
};
CreatePolicyInputProperties policyCreationProp = new CreatePolicyInputProperties()
{
ProviderSpecificInput = hvrProfileInput
};
CreatePolicyInput policyCreationInput = new CreatePolicyInput()
{
Properties = policyCreationProp
};
var policyCreateResp = client.Policies.Create(policyName, policyCreationInput, RequestHeaders);
currentPolicy = client.Policies.Get(policyName, RequestHeaders).Policy;
CreateProtectionContainerMappingInputProperties pairingProps = new CreateProtectionContainerMappingInputProperties()
{
PolicyId = currentPolicy.Id,
TargetProtectionContainerId = recCld,
ProviderSpecificInput = new ReplicationProviderContainerMappingInput()
};
CreateProtectionContainerMappingInput pairingInput = new CreateProtectionContainerMappingInput()
{
Properties = pairingProps
};
var pairingResponse = client.ProtectionContainerMapping.ConfigureProtection(
selectedFabric.Name,
priCld,
mappingName,
pairingInput,
RequestHeaders);
// Adding SP1 Profile too
HyperVReplica2012PolicyInput hvrsp1ProfileInput = new HyperVReplica2012PolicyInput()
{
ApplicationConsistentSnapshotFrequencyInHours = 0,
AllowedAuthenticationType = 1,
Compression = "Enable",
InitialReplicationMethod = "OverNetwork",
OnlineReplicationStartTime = null,
RecoveryPoints = 0,
ReplicaDeletion = "Required",
ReplicationPort = 8083
};
CreatePolicyInputProperties policySp1CreationProp = new CreatePolicyInputProperties()
{
ProviderSpecificInput = hvrsp1ProfileInput
};
CreatePolicyInput policySp1CreationInput = new CreatePolicyInput()
{
Properties = policySp1CreationProp
};
var policySp1CreateResp = client.Policies.Create(policyName + "SP1", policySp1CreationInput, RequestHeaders);
var currentSp1Policy = client.Policies.Get(policyName + "SP1", RequestHeaders).Policy;
CreateProtectionContainerMappingInputProperties pairingSp1Props = new CreateProtectionContainerMappingInputProperties()
{
PolicyId = currentSp1Policy.Id,
TargetProtectionContainerId = recCld,
ProviderSpecificInput = new ReplicationProviderContainerMappingInput()
};
CreateProtectionContainerMappingInput pairingSp1Input = new CreateProtectionContainerMappingInput()
{
Properties = pairingSp1Props
};
var pairingSp1Response = client.ProtectionContainerMapping.ConfigureProtection(
selectedFabric.Name,
priCld,
mappingName + "sp1",
pairingSp1Input,
RequestHeaders);
}
else
{
currentPolicy = client.Policies.Get(policyName, RequestHeaders).Policy;
}
if (enableDR)
{
EnableProtectionInputProperties enableDRProp = new EnableProtectionInputProperties();
if (string.IsNullOrEmpty(enableDRVmName))
{
var protectableItems = client.ProtectableItem.List(selectedFabric.Name, priCld, "Unprotected", RequestHeaders);
enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = currentPolicy.Id,
ProtectableItemId = protectableItems.ProtectableItems[0].Id,
ProviderSpecificDetails = new EnableProtectionProviderSpecificInput()
};
}
else
{
var item = client.ProtectableItem.Get(selectedFabric.Name, priCld, enableDRVmName, RequestHeaders);
enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = currentPolicy.Id,
ProtectableItemId = item.ProtectableItem.Id,
ProviderSpecificDetails = new EnableProtectionProviderSpecificInput()
};
}
EnableProtectionInput enableInput = new EnableProtectionInput()
{
Properties = enableDRProp
};
var enableDRStartTime = DateTime.Now;
var enableDRresp = client.ReplicationProtectedItem.EnableProtection(
selectedFabric.Name,
priCld,
replicationProtectedItemName,
enableInput,
RequestHeaders);
MonitoringHelper.MonitorJobs(MonitoringHelper.SecondaryIrJobName, enableDRStartTime, client, RequestHeaders);
}
///////////////////////////// PFO ////////////////////////////////
PlannedFailoverInputProperties plannedFailoverProp = new PlannedFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput()
};
PlannedFailoverInput plannedFailoverInput = new PlannedFailoverInput()
{
Properties = plannedFailoverProp
};
////////////////////////////// RR ////////////////////////////////
ReverseReplicationInputProperties rrProp = new ReverseReplicationInputProperties()
{
ProviderSpecificDetails = new ReverseReplicationProviderSpecificInput()
};
ReverseReplicationInput rrInput = new ReverseReplicationInput()
{
Properties = rrProp
};
////////////////////////////////// UFO /////////////////////////////
UnplannedFailoverInputProperties ufoProp = new UnplannedFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput(),
SourceSiteOperations = "NotRequired"
};
UnplannedFailoverInput ufoInput = new UnplannedFailoverInput()
{
Properties = ufoProp
};
/////////////////////////////////// TFO //////////////////////////////
TestFailoverInputProperties tfoProp = new TestFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput()
};
TestFailoverInput tfoInput = new TestFailoverInput()
{
Properties = tfoProp
};
/////////////////////////////////////
if (pfo)
{
var protectedItem = client.ReplicationProtectedItem.Get(
selectedFabric.Name,
priCld,
replicationProtectedItemName,
RequestHeaders);
var plannedfailover = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, priCld, replicationProtectedItemName, plannedFailoverInput, RequestHeaders);
//var unplannedFailoverReverse = client.ReplicationProtectedItem.UnplannedFailover(
// selectedFabric.Name,
// priCld,
// replicationProtectedItemName,
// ufoInput,
// RequestHeaders);
}
if (commit)
{
var commitFailover = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, priCld, replicationProtectedItemName, RequestHeaders);
}
if (rr)
{
var rrOp = client.ReplicationProtectedItem.Reprotect(selectedFabric.Name, priCld, replicationProtectedItemName, rrInput, RequestHeaders);
}
if (pfoReverse)
{
//var unplannedFailoverReverse = client.ReplicationProtectedItem.UnplannedFailover(
// selectedFabric.Name, priCld, replicationProtectedItemName, ufoInput, RequestHeaders);
var plannedFailoverReverse = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, priCld, replicationProtectedItemName, plannedFailoverInput, RequestHeaders);
}
if (commitReverse)
{
var commitFailoverReverse = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, priCld, replicationProtectedItemName, RequestHeaders);
}
if (rrReverse)
{
DateTime rrPostUfoStartTime = DateTime.UtcNow;
var rrReverseOp = client.ReplicationProtectedItem.Reprotect(selectedFabric.Name, priCld, replicationProtectedItemName, rrInput, RequestHeaders);
/*while (true)
* {
* Thread.Sleep(5000 * 60);
* Job ufoJob = MonitoringHelper.GetJobId(
* MonitoringHelper.ReverseReplicationJobName,
* rrPostUfoStartTime,
* client,
* RequestHeaders);
*
* if (ufoJob.Properties.StateDescription.Equals(
* "WaitingForFinalizeProtection",
* StringComparison.InvariantCultureIgnoreCase))
* {
* break;
* }
* }
*
* MonitoringHelper.MonitorJobs(MonitoringHelper.PrimaryIrJobName, rrPostUfoStartTime, client, RequestHeaders);
* MonitoringHelper.MonitorJobs(MonitoringHelper.SecondaryIrJobName, rrPostUfoStartTime, client, RequestHeaders);*/
}
if (tfo)
{
DateTime startTFO = DateTime.UtcNow;
var tfoOp = client.ReplicationProtectedItem.TestFailover(selectedFabric.Name, priCld, replicationProtectedItemName, tfoInput, RequestHeaders);
var jobs = MonitoringHelper.GetJobId(MonitoringHelper.TestFailoverJobName, startTFO, client, RequestHeaders);
ResumeJobParamsProperties resProp = new ResumeJobParamsProperties()
{
Comments = "Res TFO"
};
ResumeJobParams resParam = new ResumeJobParams()
{
Properties = resProp
};
var resJob = client.Jobs.Resume(jobs.Name, resParam, RequestHeaders);
}
if (disableDR)
{
var disableDROperation = client.ReplicationProtectedItem.DisableProtection(selectedFabric.Name, priCld, replicationProtectedItemName, new DisableProtectionInput(), RequestHeaders);
}
if (unpair)
{
var unpaiClouds = client.ProtectionContainerMapping.UnconfigureProtection(
selectedFabric.Name,
priCld,
mappingName,
new RemoveProtectionContainerMappingInput(),
RequestHeaders);
}
if (removePolicy)
{
var policyDeletion = client.Policies.Delete(currentPolicy.Name, RequestHeaders);
}
}
}
