public static CreatePolicyOperationResponse CreateHyperV2012R2Policy( this SiteRecoveryManagementClient client, string armResourceName) { 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 }; return(client.Policies.Create( armResourceName, policyCreationInput, GetRequestHeaders()) as CreatePolicyOperationResponse); }
public void CreateHyperVAzureProfile() { using (UndoContext context = UndoContext.Current) { context.Start(); var client = GetSiteRecoveryClient(CustomHttpHandler); string policyName = "Hydra-Profile-HyperVAzure"; HyperVReplicaAzurePolicyInput hvrAPolicy = new HyperVReplicaAzurePolicyInput() { ApplicationConsistentSnapshotFrequencyInHours = 0, Encryption = "Disable", OnlineIrStartTime = null, RecoveryPointHistoryDuration = 0, ReplicationInterval = 30, StorageAccounts = new List <string>() { "/subscriptions/c89695cf-3a29-4ff0-86da-2696d2c5322b/resourceGroups/Default-Storage-SoutheastAsia/providers/Microsoft.ClassicStorage/storageAccounts/sa03sub10v1sea" } }; CreatePolicyInputProperties createInputProp = new CreatePolicyInputProperties() { ProviderSpecificInput = hvrAPolicy }; CreatePolicyInput policyInput = new CreatePolicyInput() { Properties = createInputProp }; var policy = client.Policies.Create(policyName, policyInput, RequestHeaders); //var selectedPolicy = (client.Policies.Create(policyName, policyInput, RequestHeaders) as CreatePolicyOperationResponse).Policy; } }
public static CreatePolicyOperationResponse CreateHyperVReplicaAzurePolicy( this SiteRecoveryManagementClient client, string armResourceName, string storageAccountArmId) { HyperVReplicaAzurePolicyInput hvrAPolicy = new HyperVReplicaAzurePolicyInput() { ApplicationConsistentSnapshotFrequencyInHours = 0, Encryption = "Disable", OnlineIrStartTime = null, RecoveryPointHistoryDuration = 0, ReplicationInterval = 30, StorageAccounts = new List <string>() { storageAccountArmId } }; CreatePolicyInputProperties createInputProp = new CreatePolicyInputProperties() { ProviderSpecificInput = hvrAPolicy }; CreatePolicyInput policyInput = new CreatePolicyInput() { Properties = createInputProp }; return(client.Policies.Create(armResourceName, policyInput, GetRequestHeaders()) as CreatePolicyOperationResponse); }
/// <summary> /// Creates an E2A Policy Object /// </summary> private void HyperVToAzurePolicyObject() { if (string.Compare( this.ReplicationProvider, Constants.HyperVReplicaAzure, StringComparison.OrdinalIgnoreCase) != 0) { throw new InvalidOperationException( string.Format( Resources.IncorrectReplicationProvider, this.ReplicationProvider)); } PSRecoveryServicesClient.ValidateReplicationStartTime(this.ReplicationStartTime); var replicationFrequencyInSeconds = PSRecoveryServicesClient.ConvertReplicationFrequencyToUshort( this.ReplicationFrequencyInSeconds); var hyperVReplicaAzurePolicyInput = new HyperVReplicaAzurePolicyInput { ApplicationConsistentSnapshotFrequencyInHours = this.ApplicationConsistentSnapshotFrequencyInHours, OnlineReplicationStartTime = this.ReplicationStartTime == null ? null : this.ReplicationStartTime.ToString(), RecoveryPointHistoryDuration = this.NumberOfRecoveryPointsToRetain, ReplicationInterval = replicationFrequencyInSeconds }; hyperVReplicaAzurePolicyInput.StorageAccounts = new List <string>(); if (this.RecoveryAzureStorageAccountId != null) { var storageAccount = this.RecoveryAzureStorageAccountId; hyperVReplicaAzurePolicyInput.StorageAccounts.Add(storageAccount); } var createPolicyInputProperties = new CreatePolicyInputProperties { ProviderSpecificInput = hyperVReplicaAzurePolicyInput }; var createPolicyInput = new CreatePolicyInput { Properties = createPolicyInputProperties }; var response = this.RecoveryServicesClient.CreatePolicy( this.Name, createPolicyInput); var jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails( PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location)); this.WriteObject(new ASRJob(jobResponse)); }
/// <summary> /// Creates an E2A Policy Object /// </summary> private void EnterpriseToAzurePolicyObject() { if (string.Compare(this.ReplicationProvider, Constants.HyperVReplicaAzure, StringComparison.OrdinalIgnoreCase) != 0) { throw new InvalidOperationException( string.Format( Properties.Resources.IncorrectReplicationProvider, this.ReplicationProvider)); } PSRecoveryServicesClient.ValidateReplicationStartTime(this.ReplicationStartTime); ushort replicationFrequencyInSeconds = PSRecoveryServicesClient.ConvertReplicationFrequencyToUshort(this.ReplicationFrequencyInSeconds); var hyperVReplicaAzurePolicyInput = new HyperVReplicaAzurePolicyInput() { ApplicationConsistentSnapshotFrequencyInHours = this.ApplicationConsistentSnapshotFrequencyInHours, Encryption = this.MyInvocation.BoundParameters.ContainsKey(Utilities.GetMemberName(() => this.Encryption)) ? this.Encryption : Constants.Disable, OnlineIrStartTime = this.ReplicationStartTime, RecoveryPointHistoryDuration = this.RecoveryPoints, ReplicationInterval = replicationFrequencyInSeconds }; hyperVReplicaAzurePolicyInput.StorageAccounts = new System.Collections.Generic.List <string>(); if (RecoveryAzureStorageAccountId != null) { string storageAccount = this.RecoveryAzureStorageAccountId; hyperVReplicaAzurePolicyInput.StorageAccounts.Add(storageAccount); } var createPolicyInputProperties = new CreatePolicyInputProperties() { ProviderSpecificInput = hyperVReplicaAzurePolicyInput }; var createPolicyInput = new CreatePolicyInput() { Properties = createPolicyInputProperties }; LongRunningOperationResponse response = RecoveryServicesClient.CreatePolicy(this.Name, createPolicyInput); JobResponse jobResponse = RecoveryServicesClient .GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location)); WriteObject(new ASRJob(jobResponse.Job)); }
public void CreateHyperV2012R2Profile() { using (UndoContext context = UndoContext.Current) { context.Start(); var client = GetSiteRecoveryClient(CustomHttpHandler); string policyName = "Hydra-Profile-HyperV-2012-R2-" + new Random().Next(); HyperVReplica2012R2PolicyInput hvrProfileInput = new HyperVReplica2012R2PolicyInput() { ApplicationConsistentSnapshotFrequencyInHours = 0, AllowedAuthenticationType = 1, Compression = "Enable", InitialReplicationMethod = "OverNetwork", OnlineReplicationStartTime = null, RecoveryPoints = 0, ReplicaDeletion = "Required", ReplicationPort = 8083, ReplicationFrequencyInSeconds = 300 }; CreatePolicyInputProperties createInputProp = new CreatePolicyInputProperties() { ProviderSpecificInput = hvrProfileInput }; CreatePolicyInput policyInput = new CreatePolicyInput() { Properties = createInputProp }; var response = client.Policies.Create(policyName, policyInput, RequestHeaders); Assert.NotNull(response); Assert.Equal(response.Status, OperationStatus.Succeeded); var policyResponse = response as CreatePolicyOperationResponse; Assert.NotNull(policyResponse); Assert.NotNull(policyResponse.Policy); Assert.Equal(policyResponse.Policy.Name, policyName); } }
/// <summary> /// Creates an A2A Policy. /// </summary> private void CreateA2APolicy() { this.MultiVmSyncStatus = this.MyInvocation.BoundParameters.ContainsKey( Utilities.GetMemberName(() => this.MultiVmSyncStatus)) ? this.MultiVmSyncStatus : Constants.Enable; var crashConsistentFrequencyInMinutes = 5; var a2aPolicyCreationInput = new A2APolicyCreationInput() { AppConsistentFrequencyInMinutes = this.ApplicationConsistentSnapshotFrequencyInHours * 60, CrashConsistentFrequencyInMinutes = crashConsistentFrequencyInMinutes, MultiVmSyncStatus = (SetMultiVmSyncStatus)Enum.Parse( typeof(SetMultiVmSyncStatus), this.MultiVmSyncStatus), RecoveryPointHistory = this.RecoveryPointRetentionInHours * 60 }; var createPolicyInputProperties = new CreatePolicyInputProperties() { ProviderSpecificInput = a2aPolicyCreationInput }; var createPolicyInput = new CreatePolicyInput() { Properties = createPolicyInputProperties }; var response = RecoveryServicesClient.CreatePolicy(this.Name, createPolicyInput); string jobId = PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location); var jobResponse = RecoveryServicesClient .GetAzureSiteRecoveryJobDetails(jobId); WriteObject(new ASRJob(jobResponse)); }
public void CreateVMwareAzureV2Profile() { using (UndoContext context = UndoContext.Current) { context.Start(); var client = GetSiteRecoveryClient(CustomHttpHandler); string policyName = "Hitesh-VMwareAzureV2-Profile"; VMwareAzureV2PolicyInput input = new VMwareAzureV2PolicyInput { AppConsistentFrequencyInMinutes = 15, CrashConsistentFrequencyInMinutes = 15, MultiVmSyncStatus = "Disable", RecoveryPointHistory = 15, RecoveryPointThresholdInMinutes = 30 }; CreatePolicyInputProperties createInputProp = new CreatePolicyInputProperties() { ProviderSpecificInput = input }; CreatePolicyInput policyInput = new CreatePolicyInput() { Properties = createInputProp }; var response = client.Policies.Create(policyName, policyInput, RequestHeaders); Assert.NotNull(response); Assert.Equal(response.Status, OperationStatus.Succeeded); var policyResponse = response as CreatePolicyOperationResponse; Assert.NotNull(policyResponse); Assert.NotNull(policyResponse.Policy); Assert.Equal(policyResponse.Policy.Name, policyName); } }
/// <summary> /// Creates an E2E Policy object /// </summary> private void EnterpriseToEnterprisePolicyObject() { if (string.Compare(this.ReplicationProvider, Constants.HyperVReplica2012, StringComparison.OrdinalIgnoreCase) != 0 && string.Compare(this.ReplicationProvider, Constants.HyperVReplica2012R2, StringComparison.OrdinalIgnoreCase) != 0) { throw new InvalidOperationException( string.Format( Properties.Resources.IncorrectReplicationProvider, this.ReplicationProvider)); } PSRecoveryServicesClient.ValidateReplicationStartTime(this.ReplicationStartTime); ushort replicationFrequencyInSeconds = PSRecoveryServicesClient.ConvertReplicationFrequencyToUshort(this.ReplicationFrequencyInSeconds); var createPolicyInputProperties = new CreatePolicyInputProperties(); if (string.Compare(this.ReplicationProvider, Constants.HyperVReplica2012, StringComparison.OrdinalIgnoreCase) == 0) { createPolicyInputProperties.ProviderSpecificInput = new HyperVReplica2012PolicyInput() { AllowedAuthenticationType = (ushort)((string.Compare(this.Authentication, Constants.AuthenticationTypeKerberos, StringComparison.OrdinalIgnoreCase) == 0) ? 1 : 2), ApplicationConsistentSnapshotFrequencyInHours = this.ApplicationConsistentSnapshotFrequencyInHours, Compression = this.CompressionEnabled == true ? "Enable" : "Disable", InitialReplicationMethod = (string.Compare(this.ReplicationMethod, Constants.OnlineReplicationMethod, StringComparison.OrdinalIgnoreCase) == 0) ? "OverNetwork" : "Offline", OnlineReplicationStartTime = this.ReplicationStartTime, RecoveryPoints = this.RecoveryPoints, ReplicaDeletion = this.AllowReplicaDeletion == true ? "Required" : "NotRequired", ReplicationPort = this.ReplicationPort }; } else { createPolicyInputProperties.ProviderSpecificInput = new HyperVReplica2012R2PolicyInput() { AllowedAuthenticationType = (ushort)((string.Compare(this.Authentication, Constants.AuthenticationTypeKerberos, StringComparison.OrdinalIgnoreCase) == 0) ? 1 : 2), ApplicationConsistentSnapshotFrequencyInHours = this.ApplicationConsistentSnapshotFrequencyInHours, Compression = this.CompressionEnabled == true ? "Enable" : "Disable", InitialReplicationMethod = (string.Compare(this.ReplicationMethod, Constants.OnlineReplicationMethod, StringComparison.OrdinalIgnoreCase) == 0) ? "OverNetwork" : "Offline", OnlineReplicationStartTime = this.ReplicationStartTime, RecoveryPoints = this.RecoveryPoints, ReplicaDeletion = this.AllowReplicaDeletion == true ? "Required" : "NotRequired", ReplicationFrequencyInSeconds = replicationFrequencyInSeconds, ReplicationPort = this.ReplicationPort }; } var createPolicyInput = new CreatePolicyInput() { Properties = createPolicyInputProperties }; LongRunningOperationResponse responseBlue = RecoveryServicesClient.CreatePolicy(this.Name, createPolicyInput); JobResponse jobResponseBlue = RecoveryServicesClient .GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(responseBlue.Location)); WriteObject(new ASRJob(jobResponseBlue.Job)); }
/// <summary> /// Creates an E2E Policy object /// </summary> private void EnterpriseToEnterprisePolicyObject() { if ((string.Compare( this.ReplicationProvider, Constants.HyperVReplica2012, StringComparison.OrdinalIgnoreCase) != 0) && (string.Compare( this.ReplicationProvider, Constants.HyperVReplica2012R2, StringComparison.OrdinalIgnoreCase) != 0)) { throw new InvalidOperationException( string.Format( Resources.IncorrectReplicationProvider, this.ReplicationProvider)); } PSRecoveryServicesClient.ValidateReplicationStartTime(this.ReplicationStartTime); var replicationFrequencyInSeconds = PSRecoveryServicesClient.ConvertReplicationFrequencyToUshort( this.ReplicationFrequencyInSeconds); var createPolicyInputProperties = new CreatePolicyInputProperties(); if (string.Compare( this.ReplicationProvider, Constants.HyperVReplica2012, StringComparison.OrdinalIgnoreCase) == 0) { createPolicyInputProperties.ProviderSpecificInput = new HyperVReplicaPolicyInput { AllowedAuthenticationType = (ushort)(string.Compare( this.Authentication, Constants.AuthenticationTypeKerberos, StringComparison.OrdinalIgnoreCase) == 0 ? 1 : 2), ApplicationConsistentSnapshotFrequencyInHours = this.ApplicationConsistentSnapshotFrequencyInHours, Compression = this.MyInvocation.BoundParameters.ContainsKey( Utilities.GetMemberName(() => this.Compression)) ? this.Compression : Constants.Disable, InitialReplicationMethod = string.Compare( this.ReplicationMethod, Constants.OnlineReplicationMethod, StringComparison.OrdinalIgnoreCase) == 0 ? "OverNetwork" : "Offline", OnlineReplicationStartTime = this.ReplicationStartTime.ToString(), RecoveryPoints = this.NumberOfRecoveryPointsToRetain, ReplicaDeletion = this.MyInvocation.BoundParameters.ContainsKey( Utilities.GetMemberName(() => this.ReplicaDeletion)) ? this.ReplicaDeletion : Constants.NotRequired, ReplicationPort = this.ReplicationPort }; } else { createPolicyInputProperties.ProviderSpecificInput = new HyperVReplicaBluePolicyInput { AllowedAuthenticationType = (ushort)(string.Compare( this.Authentication, Constants .AuthenticationTypeKerberos, StringComparison .OrdinalIgnoreCase) == 0 ? 1 : 2), ApplicationConsistentSnapshotFrequencyInHours = this.ApplicationConsistentSnapshotFrequencyInHours, Compression = this.MyInvocation.BoundParameters.ContainsKey( Utilities.GetMemberName(() => this.Compression)) ? this.Compression : Constants.Disable, InitialReplicationMethod = string.Compare( this.ReplicationMethod, Constants.OnlineReplicationMethod, StringComparison.OrdinalIgnoreCase) == 0 ? "OverNetwork" : "Offline", OnlineReplicationStartTime = this.ReplicationStartTime.ToString(), RecoveryPoints = this.NumberOfRecoveryPointsToRetain, ReplicaDeletion = this.MyInvocation.BoundParameters.ContainsKey( Utilities.GetMemberName(() => this.ReplicaDeletion)) ? this.ReplicaDeletion : Constants.NotRequired, ReplicationFrequencyInSeconds = replicationFrequencyInSeconds, ReplicationPort = this.ReplicationPort }; } var createPolicyInput = new CreatePolicyInput { Properties = createPolicyInputProperties }; var responseBlue = this.RecoveryServicesClient.CreatePolicy( this.Name, createPolicyInput); var jobResponseBlue = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails( PSRecoveryServicesClient.GetJobIdFromReponseLocation(responseBlue.Location)); this.WriteObject(new ASRJob(jobResponseBlue)); }
public void PairClouds() { using (UndoContext context = UndoContext.Current) { context.Start(); var client = GetSiteRecoveryClient(CustomHttpHandler); string priCld = string.Empty; string recCldGuid = string.Empty; string recCld = string.Empty; string policyName = "Hydra" + (new Random()).Next(); Fabric selectedFabric = null; Policy currentPolicy = null; var fabrics = client.Fabrics.List(RequestHeaders); foreach (var fabric in fabrics.Fabrics) { if (fabric.Properties.CustomDetails.InstanceType.Contains("VMM")) { selectedFabric = fabric; } } var containers = client.ProtectionContainer.List(selectedFabric.Name, RequestHeaders); foreach (var container in containers.ProtectionContainers) { if (client.ProtectionContainerMapping.List(selectedFabric.Name, container.Name, RequestHeaders).ProtectionContainerMappings.Count == 0) { if (string.IsNullOrEmpty(priCld)) { priCld = container.Name; } else if (string.IsNullOrEmpty(recCld)) { recCld = container.Id; recCldGuid = container.Name; } } } HyperVReplica2012R2PolicyInput hvrProfileInput = new HyperVReplica2012R2PolicyInput() { ApplicationConsistentSnapshotFrequencyInHours = 0, AllowedAuthenticationType = 1, Compression = "Enable", InitialReplicationMethod = "OverNetwork", OnlineReplicationStartTime = null, RecoveryPoints = 0, ReplicaDeletion = "Required" }; 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, ProviderSpecificInput = new ReplicationProviderContainerMappingInput(), TargetProtectionContainerId = recCld }; CreateProtectionContainerMappingInput pairingInput = new CreateProtectionContainerMappingInput() { Properties = pairingProps }; var pairingResp = client.ProtectionContainerMapping.ConfigureProtection(selectedFabric.Name, priCld, "Mapping01", pairingInput, RequestHeaders); } }
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); } } }