/// <summary>
        ///     Update replication protection direction for replication protected item.
        /// </summary>
        private void SetRPIReprotect()
        {
            var plannedFailoverInputProperties = new ReverseReplicationInputProperties
            {
                FailoverDirection       = this.Direction,
                ProviderSpecificDetails = new ReverseReplicationProviderSpecificInput()
            };

            var input = new ReverseReplicationInput {
                Properties = plannedFailoverInputProperties
            };

            // fetch the latest Protectable item objects
            var replicationProtectedItemResponse = this.RecoveryServicesClient
                                                   .GetAzureSiteRecoveryReplicationProtectedItem(
                this.fabricName,
                this.protectionContainerName,
                this.ReplicationProtectedItem.Name);

            validateRPISwitchParam();

            var protectableItemResponse = this.RecoveryServicesClient
                                          .GetAzureSiteRecoveryProtectableItem(
                this.fabricName,
                this.protectionContainerName,
                Utilities.GetValueFromArmId(
                    replicationProtectedItemResponse.Properties.ProtectableItemId,
                    ARMResourceTypeConstants.ProtectableItems));

            var asrProtectableItem = new ASRProtectableItem(protectableItemResponse);

            if (0 ==
                string.Compare(
                    this.ReplicationProtectedItem.ReplicationProvider,
                    Constants.HyperVReplicaAzure,
                    StringComparison.OrdinalIgnoreCase))
            {
                if (this.Direction == Constants.PrimaryToRecovery)
                {
                    var reprotectInput = new HyperVReplicaAzureReprotectInput
                    {
                        HvHostVmId = asrProtectableItem.FabricObjectId,
                        VmName     = asrProtectableItem.FriendlyName,
                        OsType     = string.Compare(
                            asrProtectableItem.OS,
                            "Windows") ==
                                     0 ||
                                     string.Compare(
                            asrProtectableItem.OS,
                            "Linux") ==
                                     0
                                ? asrProtectableItem.OS
                                : "Windows",
                        VHDId = asrProtectableItem.OSDiskId
                    };

                    var providerSpecificDetails =
                        (HyperVReplicaAzureReplicationDetails)replicationProtectedItemResponse
                        .Properties.ProviderSpecificDetails;

                    reprotectInput.StorageAccountId = this.RecoveryAzureStorageAccountId == null ?
                                                      providerSpecificDetails.RecoveryAzureStorageAccount
                        : this.RecoveryAzureStorageAccountId;

                    reprotectInput.LogStorageAccountId = this.LogStorageAccountId == null ?
                                                         providerSpecificDetails.RecoveryAzureLogStorageAccountId
                        : this.LogStorageAccountId;

                    input.Properties.ProviderSpecificDetails = reprotectInput;
                }
            }
            else if (string.Compare(
                         this.ReplicationProtectedItem.ReplicationProvider,
                         Constants.InMageAzureV2,
                         StringComparison.OrdinalIgnoreCase) ==
                     0)
            {
                // Validate the direction as RecoveryToPrimary.
                if (this.Direction == Constants.RecoveryToPrimary)
                {
                    // Set the InMage Provider specific input in the Reprotect Input.
                    var reprotectInput = new InMageReprotectInput
                    {
                        ProcessServerId = this.ProcessServer.Id,
                        MasterTargetId  = this.MasterTarget != null
                            ? this.MasterTarget.Id
                            : this.ProcessServer
                                          .Id, // Assumption: PS and MT may or may not be same.
                        RunAsAccountId     = this.Account != null ? this.Account.AccountId : null,
                        RetentionDrive     = this.RetentionVolume.VolumeName,
                        DatastoreName      = this.DataStore.SymbolicName,
                        ProfileId          = this.ProtectionContainerMapping.PolicyId,
                        DiskExclusionInput = new InMageDiskExclusionInput
                        {
                            VolumeOptions        = new List <InMageVolumeExclusionOptions>(),
                            DiskSignatureOptions = null
                        },
                        DisksToInclude = null
                    };

                    // excluding the azure temporary storage.
                    reprotectInput.DiskExclusionInput.VolumeOptions.Add(
                        new InMageVolumeExclusionOptions
                    {
                        VolumeLabel = Constants.TemporaryStorage,
                        OnlyExcludeIfSingleVolume = Constants.Yes
                    });

                    input.Properties.ProviderSpecificDetails = reprotectInput;
                }
                else
                {
                    // PrimaryToRecovery Direction is Invalid for InMageAzureV2.
                    new ArgumentException(Resources.InvalidDirectionForAzureToVMWare);
                }
            }
            else if (string.Compare(
                         this.ReplicationProtectedItem.ReplicationProvider,
                         Constants.InMage,
                         StringComparison.OrdinalIgnoreCase) ==
                     0)
            {
                // Validate the Direction as RecoveryToPrimary.
                if (this.Direction == Constants.RecoveryToPrimary)
                {
                    // Set the InMageAzureV2 Provider specific input in the Reprotect Input.
                    var reprotectInput = new InMageAzureV2ReprotectInput
                    {
                        ProcessServerId = this.ProcessServer.Id,
                        MasterTargetId  = this.MasterTarget != null
                            ? this.MasterTarget.Id
                            : this.ProcessServer
                                          .Id, // Assumption: PS and MT are same.
                        RunAsAccountId      = this.Account.AccountId,
                        PolicyId            = this.ProtectionContainerMapping.PolicyId,
                        StorageAccountId    = this.RecoveryAzureStorageAccountId,
                        LogStorageAccountId = this.LogStorageAccountId,
                        DisksToInclude      = null
                    };
                    input.Properties.ProviderSpecificDetails = reprotectInput;
                }
                else
                {
                    // PrimaryToRecovery Direction is Invalid for InMage.
                    new ArgumentException(Resources.InvalidDirectionForVMWareToAzure);
                }
            }

            var response = this.RecoveryServicesClient.StartAzureSiteRecoveryReprotection(
                this.fabricName,
                this.protectionContainerName,
                this.ReplicationProtectedItem.Name,
                input);

            var jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
                PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location));

            this.WriteObject(new ASRJob(jobResponse));
        }
Exemplo n.º 2
0
        /// <summary>
        ///     RPI Reprotect.
        /// </summary>
        private void SetRPIReprotect()
        {
            var plannedFailoverInputProperties = new ReverseReplicationInputProperties
            {
                FailoverDirection       = this.Direction,
                ProviderSpecificDetails = new ReverseReplicationProviderSpecificInput()
            };

            var input = new ReverseReplicationInput {
                Properties = plannedFailoverInputProperties
            };

            // fetch the latest Protectable item objects
            var replicationProtectedItemResponse = this.RecoveryServicesClient
                                                   .GetAzureSiteRecoveryReplicationProtectedItem(
                this.fabricName,
                this.protectionContainerName,
                this.ReplicationProtectedItem.Name);

            var protectableItemResponse = this.RecoveryServicesClient
                                          .GetAzureSiteRecoveryProtectableItem(
                this.fabricName,
                this.protectionContainerName,
                Utilities.GetValueFromArmId(
                    replicationProtectedItemResponse.Properties.ProtectableItemId,
                    ARMResourceTypeConstants.ProtectableItems));

            var aSRProtectableItem = new ASRProtectableItem(protectableItemResponse);

            if (0 ==
                string.Compare(
                    this.ReplicationProtectedItem.ReplicationProvider,
                    Constants.HyperVReplicaAzure,
                    StringComparison.OrdinalIgnoreCase))
            {
                if (this.Direction == Constants.PrimaryToRecovery)
                {
                    var reprotectInput = new HyperVReplicaAzureReprotectInput
                    {
                        HvHostVmId = aSRProtectableItem.FabricObjectId,
                        VmName     = aSRProtectableItem.FriendlyName,
                        OsType     = (string.Compare(
                                          aSRProtectableItem.OS,
                                          "Windows") ==
                                      0) ||
                                     (string.Compare(
                                          aSRProtectableItem.OS,
                                          "Linux") ==
                                      0) ? aSRProtectableItem.OS : "Windows",
                        VHDId = aSRProtectableItem.OSDiskId
                    };

                    var providerSpecificDetails =
                        (HyperVReplicaAzureReplicationDetails)replicationProtectedItemResponse
                        .Properties.ProviderSpecificDetails;

                    reprotectInput.StorageAccountId =
                        providerSpecificDetails.RecoveryAzureStorageAccount;

                    input.Properties.ProviderSpecificDetails = reprotectInput;
                }
            }

            var response = this.RecoveryServicesClient.StartAzureSiteRecoveryReprotection(
                this.fabricName,
                this.protectionContainerName,
                this.ReplicationProtectedItem.Name,
                input);

            var jobResponse = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
                PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location));

            this.WriteObject(new ASRJob(jobResponse));
        }
Exemplo n.º 3
0
        /// <summary>
        /// PE Reprotect.
        /// </summary>
        private void SetPEReprotect()
        {
            ReverseReplicationInputProperties plannedFailoverInputProperties = new ReverseReplicationInputProperties()
            {
                FailoverDirection       = this.Direction,
                ProviderSpecificDetails = new ReverseReplicationProviderSpecificInput()
            };

            ReverseReplicationInput input = new ReverseReplicationInput()
            {
                Properties = plannedFailoverInputProperties
            };

            // fetch the latest PE object
            ProtectableItemResponse protectableItemResponse =
                RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem(this.fabricName,
                                                                           this.ProtectionEntity.ProtectionContainerId, this.ProtectionEntity.Name);

            ReplicationProtectedItemResponse replicationProtectedItemResponse =
                RecoveryServicesClient.GetAzureSiteRecoveryReplicationProtectedItem(this.fabricName,
                                                                                    this.ProtectionEntity.ProtectionContainerId, Utilities.GetValueFromArmId(protectableItemResponse.ProtectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems));

            PolicyResponse policyResponse = RecoveryServicesClient.GetAzureSiteRecoveryPolicy(Utilities.GetValueFromArmId(replicationProtectedItemResponse.ReplicationProtectedItem.Properties.PolicyID, ARMResourceTypeConstants.ReplicationPolicies));

            this.ProtectionEntity = new ASRProtectionEntity(protectableItemResponse.ProtectableItem, replicationProtectedItemResponse.ReplicationProtectedItem);

            if (0 == string.Compare(
                    this.ProtectionEntity.ReplicationProvider,
                    Constants.HyperVReplicaAzure,
                    StringComparison.OrdinalIgnoreCase))
            {
                if (this.Direction == Constants.PrimaryToRecovery)
                {
                    HyperVReplicaAzureReprotectInput reprotectInput = new HyperVReplicaAzureReprotectInput()
                    {
                        HvHostVmId = this.ProtectionEntity.FabricObjectId,
                        VmName     = this.ProtectionEntity.FriendlyName,
                        OSType     = ((string.Compare(this.ProtectionEntity.OS, "Windows") == 0) || (string.Compare(this.ProtectionEntity.OS, "Linux") == 0)) ? this.ProtectionEntity.OS : "Windows",
                        VHDId      = this.ProtectionEntity.OSDiskId
                    };

                    HyperVReplicaAzureReplicationDetails providerSpecificDetails =
                        (HyperVReplicaAzureReplicationDetails)replicationProtectedItemResponse.ReplicationProtectedItem.Properties.ProviderSpecificDetails;

                    reprotectInput.StorageAccountId = providerSpecificDetails.RecoveryAzureStorageAccount;

                    input.Properties.ProviderSpecificDetails = reprotectInput;
                }
            }

            LongRunningOperationResponse response =
                RecoveryServicesClient.StartAzureSiteRecoveryReprotection(
                    this.fabricName,
                    this.protectionContainerName,
                    Utilities.GetValueFromArmId(replicationProtectedItemResponse.ReplicationProtectedItem.Id, ARMResourceTypeConstants.ReplicationProtectedItems),
                    input);

            JobResponse jobResponse =
                RecoveryServicesClient
                .GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location));

            WriteObject(new ASRJob(jobResponse.Job));
        }
Exemplo n.º 4
0
        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();
            }
        }
Exemplo n.º 5
0
        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);
                }
            }
        }