/// <summary>
/// Initializes a new instance of the <see cref="ASRVirtualMachine" /> class when it is protected
/// </summary>
/// <param name="pi">Protectable Item to read values from</param>
/// <param name="rpi">Replication Protected Item to read values from</param>
public ASRVirtualMachine(ProtectableItem pi, ReplicationProtectedItem rpi, Policy policy = null)
: base(pi, rpi, policy)
{
if (0 == string.Compare(
rpi.Properties.ProviderSpecificDetails.InstanceType,
Constants.HyperVReplicaAzure,
StringComparison.OrdinalIgnoreCase))
{
HyperVReplicaAzureReplicationDetails providerSpecificDetails =
(HyperVReplicaAzureReplicationDetails)rpi.Properties.ProviderSpecificDetails;
RecoveryAzureVMName = providerSpecificDetails.RecoveryAzureVMName;
RecoveryAzureVMSize = providerSpecificDetails.RecoveryAzureVMSize;
RecoveryAzureStorageAccount = providerSpecificDetails.RecoveryAzureStorageAccount;
SelectedRecoveryAzureNetworkId = providerSpecificDetails.SelectedRecoveryAzureNetworkId;
if (providerSpecificDetails.VMNics != null)
{
NicDetailsList = new List<ASRVMNicDetails>();
foreach(VMNicDetails n in providerSpecificDetails.VMNics)
{
NicDetailsList.Add(new ASRVMNicDetails(n));
}
}
}
}
/// <summary>
/// Queries by friendly name.
/// </summary>
private void GetByFriendlyName()
{
bool found = false;
ReplicationProtectedItemListResponse replicationProtectedItemListResponse = RecoveryServicesClient.GetAzureSiteRecoveryReplicationProtectedItem(
Utilities.GetValueFromArmId(this.ProtectionContainer.ID, ARMResourceTypeConstants.ReplicationFabrics),
this.ProtectionContainer.Name);
ReplicationProtectedItem replicationProtectedItem =
replicationProtectedItemListResponse.ReplicationProtectedItems.SingleOrDefault(t =>
string.Compare(t.Properties.FriendlyName, this.FriendlyName, StringComparison.OrdinalIgnoreCase) == 0);
if (replicationProtectedItem != null)
{
ReplicationProtectedItemResponse replicationProtectedItemResponse = RecoveryServicesClient.GetAzureSiteRecoveryReplicationProtectedItem(
Utilities.GetValueFromArmId(this.ProtectionContainer.ID, ARMResourceTypeConstants.ReplicationFabrics),
this.ProtectionContainer.Name,
replicationProtectedItem.Name);
WriteReplicationProtectedItem(replicationProtectedItemResponse.ReplicationProtectedItem);
found = true;
}
if (!found)
{
throw new InvalidOperationException(
string.Format(
Properties.Resources.ProtectionEntityNotFound,
this.FriendlyName,
this.ProtectionContainer.FriendlyName));
}
}
private void populateManagedDiskInputDetails(
A2ASwitchProtectionInput a2aSwitchInput,
ReplicationProtectedItem replicationProtectedItemResponse)
{
if (this.AzureToAzureDiskReplicationConfiguration == null ||
this.AzureToAzureDiskReplicationConfiguration.Length == 0)
{
var a2aReplicationDetails = ((A2AReplicationDetails)replicationProtectedItemResponse.Properties.ProviderSpecificDetails);
if (!a2aReplicationDetails.FabricObjectId.ToLower().Contains(ARMResourceTypeConstants.Compute.ToLower()))
{
throw new Exception("Pass AzureToAzureDiskReplicationConfiguration for classic VMs");
}
var vmName = a2aReplicationDetails.RecoveryAzureVMName;
var vmRg = Utilities.GetValueFromArmId(
a2aReplicationDetails.RecoveryAzureResourceGroupId,
ARMResourceTypeConstants.ResourceGroups);
var virtualMachine = this.ComputeManagementClient.GetComputeManagementClient.
VirtualMachines.GetWithHttpMessagesAsync(vmRg, vmName).GetAwaiter().GetResult().Body;
// Passing all managedDisk data if no details is passed.
var osDisk = virtualMachine.StorageProfile.OsDisk;
a2aSwitchInput.VmManagedDisks.Add(new A2AVmManagedDiskInputDetails
{
DiskId = osDisk.ManagedDisk.Id,
RecoveryResourceGroupId = this.RecoveryResourceGroupId,
PrimaryStagingAzureStorageAccountId = this.LogStorageAccountId,
RecoveryReplicaDiskAccountType = osDisk.ManagedDisk.StorageAccountType.toStorageString(),
RecoveryTargetDiskAccountType = osDisk.ManagedDisk.StorageAccountType.toStorageString()
});
if (virtualMachine.StorageProfile.DataDisks != null)
{
foreach (var dataDisk in virtualMachine.StorageProfile.DataDisks)
{
a2aSwitchInput.VmManagedDisks.Add(new A2AVmManagedDiskInputDetails
{
DiskId = dataDisk.ManagedDisk.Id,
RecoveryResourceGroupId = this.RecoveryResourceGroupId,
PrimaryStagingAzureStorageAccountId = this.LogStorageAccountId,
RecoveryReplicaDiskAccountType = dataDisk.ManagedDisk.StorageAccountType.toStorageString(),
RecoveryTargetDiskAccountType = dataDisk.ManagedDisk.StorageAccountType.toStorageString()
});
}
}
}
else
{
foreach (ASRAzuretoAzureDiskReplicationConfig disk in this.AzureToAzureDiskReplicationConfiguration)
{
a2aSwitchInput.VmManagedDisks.Add(new A2AVmManagedDiskInputDetails
{
DiskId = disk.DiskId,
RecoveryResourceGroupId = disk.RecoveryResourceGroupId,
RecoveryReplicaDiskAccountType = disk.RecoveryReplicaDiskAccountType,
RecoveryTargetDiskAccountType = disk.RecoveryTargetDiskAccountType,
PrimaryStagingAzureStorageAccountId = this.LogStorageAccountId,
});
}
}
}
public static LongRunningOperationResponse TestFailover(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
ProtectionContainer protectionContainer,
ReplicationProtectedItem protectedItem)
{
TestFailoverInput tfoInput = new TestFailoverInput()
{
Properties = new TestFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput()
}
};
if (protectedItem.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplicaAzure")
{
HyperVReplicaAzureFailoverProviderInput hvrAFOInput =
new HyperVReplicaAzureFailoverProviderInput()
{
VaultLocation = "West US",
};
string networkId = (protectedItem.Properties.ProviderSpecificDetails as HyperVReplicaAzureReplicationDetails)
.SelectedRecoveryAzureNetworkId;
TestFailoverInputProperties tfoProp = new TestFailoverInputProperties()
{
ProviderSpecificDetails = hvrAFOInput,
NetworkType = string.IsNullOrEmpty(networkId) ? null : "VmNetworkAsInput",
NetworkId = networkId
};
tfoInput.Properties = tfoProp;
}
DateTime startTFO = DateTime.UtcNow;
var tfoOp = client.ReplicationProtectedItem.TestFailover(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Name,
tfoInput,
GetRequestHeaders());
var jobs = MonitoringHelper.GetJobId(MonitoringHelper.TestFailoverJobName, startTFO, client, GetRequestHeaders());
ResumeJobParamsProperties resProp = new ResumeJobParamsProperties()
{
Comments = "Res TFO"
};
ResumeJobParams resParam = new ResumeJobParams()
{
Properties = resProp
};
return(client.Jobs.Resume(jobs.Name, resParam, GetRequestHeaders()));
}
private void populateUnManagedDiskInputDetails(string fabricFriendlyName,
A2ASwitchProtectionInput a2aSwitchInput,
ReplicationProtectedItem replicationProtectedItemResponse)
{
if (this.AzureToAzureDiskReplicationConfiguration == null ||
this.AzureToAzureDiskReplicationConfiguration.Length == 0)
{
if (fabricFriendlyName !=
this.ProtectionContainerMapping.TargetFabricFriendlyName &&
this.RecoveryAzureStorageAccountId == null)
{
throw new ArgumentException(string.Format(Resources.InvalidRecoveryAzureStorageAccountIdDiskInput));
}
foreach (var disk in ((A2AReplicationDetails)replicationProtectedItemResponse
.Properties.ProviderSpecificDetails)
.ProtectedDisks)
{
a2aSwitchInput.VmDisks.Add(new A2AVmDiskInputDetails
{
DiskUri = disk.RecoveryDiskUri,
RecoveryAzureStorageAccountId =
fabricFriendlyName ==
this.ProtectionContainerMapping.TargetFabricFriendlyName &&
this.RecoveryAzureStorageAccountId == null ?
disk.PrimaryDiskAzureStorageAccountId :
this.RecoveryAzureStorageAccountId,
PrimaryStagingAzureStorageAccountId =
this.LogStorageAccountId,
});
}
}
else
{
foreach (ASRAzuretoAzureDiskReplicationConfig disk in this.AzureToAzureDiskReplicationConfiguration)
{
// logstorage account id in required param cann't be null.
if (string.IsNullOrEmpty(disk.RecoveryAzureStorageAccountId))
{
throw new PSArgumentException(
string.Format(
Properties.Resources.InvalidRecoveryAzureStorageAccountIdDiskInput,
disk.VhdUri));
}
a2aSwitchInput.VmDisks.Add(new A2AVmDiskInputDetails
{
DiskUri = disk.VhdUri,
RecoveryAzureStorageAccountId = disk.RecoveryAzureStorageAccountId,
PrimaryStagingAzureStorageAccountId =
disk.LogStorageAccountId
});
}
}
}
public static ReplicationProtectedItemOperationResponse CommitFailover(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
ProtectionContainer protectionContainer,
ReplicationProtectedItem protectedItem)
{
return(client.ReplicationProtectedItem.CommitFailover(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Name,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
public static ReplicationProtectedItemOperationResponse PlannedFailover(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
ProtectionContainer protectionContainer,
ReplicationProtectedItem protectedItem)
{
PlannedFailoverInputProperties plannedFailoverProp =
new PlannedFailoverInputProperties();
if (protectedItem.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplicaAzure")
{
if (protectedItem.Properties.ActiveLocation == "Recovery")
{
HyperVReplicaAzureFailbackProviderInput hvrAFBInput = new HyperVReplicaAzureFailbackProviderInput()
{
RecoveryVmCreationOption = "NoAction",
DataSyncOption = "ForSyncronization"
};
plannedFailoverProp.ProviderSpecificDetails = hvrAFBInput;
}
else
{
HyperVReplicaAzureFailoverProviderInput hvrAFOInput =
new HyperVReplicaAzureFailoverProviderInput()
{
VaultLocation = "West US",
};
plannedFailoverProp.ProviderSpecificDetails = hvrAFOInput;
}
}
PlannedFailoverInput pfoInput = new PlannedFailoverInput()
{
Properties = plannedFailoverProp
};
return(client.ReplicationProtectedItem.PlannedFailover(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Name,
pfoInput,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
public static ReplicationProtectedItemOperationResponse UnplannedFailover(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
ProtectionContainer protectionContainer,
ReplicationProtectedItem protectedItem)
{
UnplannedFailoverInput ufoInput = new UnplannedFailoverInput()
{
Properties = new UnplannedFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput()
}
};
if (protectedItem.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplicaAzure")
{
HyperVReplicaAzureFailoverProviderInput hvrAFOInput =
new HyperVReplicaAzureFailoverProviderInput()
{
VaultLocation = "West US",
};
UnplannedFailoverInputProperties ufoProp = new UnplannedFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput(),
SourceSiteOperations = "NotRequired"
};
ufoInput.Properties = ufoProp;
}
return(client.ReplicationProtectedItem.UnplannedFailover(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Name,
ufoInput,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
/// <summary>
/// Initializes a new instance of the <see cref="ASRProtectionEntity" /> class when it is protected
/// </summary>
/// <param name="pi">Protectable Item to read values from</param>
/// <param name="rpi">Replication Protected Item to read values from</param>
public ASRProtectionEntity(ProtectableItem pi, ReplicationProtectedItem rpi, Policy policy = null) : this(pi)
{
this.Type = rpi.Type;
this.ProtectionStateDescription = rpi.Properties.ProtectionStateDescription;
if (rpi.Properties.AllowedOperations != null)
{
this.AllowedOperations = new List<string>();
foreach (String op in rpi.Properties.AllowedOperations)
{
AllowedOperations.Add(op);
}
}
this.ReplicationProvider = rpi.Properties.ProviderSpecificDetails.InstanceType;
this.ActiveLocation = rpi.Properties.ActiveLocation;
this.ReplicationHealth = rpi.Properties.ReplicationHealth;
this.TestFailoverStateDescription = rpi.Properties.TestFailoverStateDescription;
this.ProtectionStatus = rpi.Properties.ProtectionState;
if (policy != null)
{
this.Policy = new ASRPolicy(policy);
}
}
/// <summary>
/// Write Protected Items
/// </summary>
/// <param name="replicationProtectedItem"></param>
private void WriteReplicationProtectedItem(
ReplicationProtectedItem replicationProtectedItem)
{
this.WriteObject(new ASRReplicationProtectedItem(replicationProtectedItem));
}
public static ReplicationProtectedItemOperationResponse ReverseReplication(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
ProtectionContainer protectionContainer,
ReplicationProtectedItem protectedItem)
{
if (protectedItem.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplicaAzure")
{
ProtectableItem protectableItem = client.ProtectableItem.Get(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Properties.ProtectableItemId.Substring(
protectedItem.Properties.ProtectableItemId.LastIndexOf("/") + 1),
GetRequestHeaders()).ProtectableItem;
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;
}
string storageAccount =
(protectedItem.Properties.ProviderSpecificDetails as HyperVReplicaAzureReplicationDetails)
.RecoveryAzureStorageAccount;
HyperVReplicaAzureReprotectInput hvrARRInput = new HyperVReplicaAzureReprotectInput()
{
HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId,
OSType = "Windows",
VHDId = vhdId,
VmName = protectableItem.Properties.FriendlyName,
StorageAccountId = storageAccount,
};
ReverseReplicationInputProperties rrProp = new ReverseReplicationInputProperties()
{
FailoverDirection = "",
ProviderSpecificDetails = hvrARRInput
};
ReverseReplicationInput rrInput = new ReverseReplicationInput()
{
Properties = rrProp
};
return(client.ReplicationProtectedItem.Reprotect(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Name,
rrInput,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
else if (protectedItem.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplica2012" ||
protectedItem.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplica2012R2")
{
ReverseReplicationInputProperties rrProp = new ReverseReplicationInputProperties()
{
ProviderSpecificDetails = new ReverseReplicationProviderSpecificInput()
};
ReverseReplicationInput rrInput = new ReverseReplicationInput()
{
Properties = rrProp
};
return(client.ReplicationProtectedItem.Reprotect(
primaryFabric.Name,
protectionContainer.Name,
protectedItem.Name,
rrInput,
GetRequestHeaders()) as ReplicationProtectedItemOperationResponse);
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// Write Protection Entities
/// </summary>
/// <param name="protectableItems">List of protectable items</param>
internal List <T> FetchProtectionEntitiesData <T>(IList <ProtectableItem> protectableItems, string protectionContainerId, string protectionContainerName)
{
List <ASRProtectionEntity> asrProtectionEntityList = new List <ASRProtectionEntity>();
Dictionary <string, Policy> policyCache = new Dictionary <string, Policy>();
Dictionary <string, ReplicationProtectedItem> protectedItemCache = new Dictionary <string, ReplicationProtectedItem>();
// Check even if an single item is protected then we will get all the protecteditems & policies.
if (protectableItems.Select(p => 0 == string.Compare(p.Properties.ProtectionStatus, "protected", StringComparison.OrdinalIgnoreCase)) != null)
{
// Get all the protected items for the container.
ReplicationProtectedItemListResponse ReplicationProtectedItemListResponse =
this.GetAzureSiteRecoveryReplicationProtectedItem(
Utilities.GetValueFromArmId(protectionContainerId, ARMResourceTypeConstants.ReplicationFabrics),
protectionContainerName);
// Fill all protected items in dictionary for quick access.
foreach (ReplicationProtectedItem protectedItem in ReplicationProtectedItemListResponse.ReplicationProtectedItems)
{
protectedItemCache.Add(protectedItem.Name.ToLower(), protectedItem);
}
// Get all policies and fill up the dictionary once for quick access.
PolicyListResponse policyListResponse = this.GetAzureSiteRecoveryPolicy();
foreach (Policy policy in policyListResponse.Policies)
{
policyCache.Add(policy.Name.ToLower(), policy);
}
}
List <T> entities = new List <T>();
// Fill up powershell entity with all the data.
foreach (ProtectableItem protectableItem in protectableItems)
{
if (0 == string.Compare(protectableItem.Properties.ProtectionStatus, "protected", StringComparison.OrdinalIgnoreCase))
{
string protectedItemName = Utilities.GetValueFromArmId(
protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems).ToLower();
ReplicationProtectedItem protectedItem = protectedItemCache[protectedItemName];
string policyName = Utilities.GetValueFromArmId(protectedItem.Properties.PolicyID, ARMResourceTypeConstants.ReplicationPolicies).ToLower();
Policy asrPolicy = policyCache[policyName];
if (typeof(T) == typeof(ASRVirtualMachine))
{
entities.Add((T)Convert.ChangeType(new ASRVirtualMachine(protectableItem, protectedItem, asrPolicy), typeof(T)));
}
else
{
entities.Add((T)Convert.ChangeType(new ASRProtectionEntity(protectableItem, protectedItem, asrPolicy), typeof(T)));
}
}
else
{
if (typeof(T) == typeof(ASRVirtualMachine))
{
entities.Add((T)Convert.ChangeType(new ASRVirtualMachine(protectableItem), typeof(T)));
}
else
{
entities.Add((T)Convert.ChangeType(new ASRProtectionEntity(protectableItem), typeof(T)));
}
}
}
asrProtectionEntityList.Sort((x, y) => x.FriendlyName.CompareTo(y.FriendlyName));
return(entities);
}
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);
}
}
}
