/// <summary> /// Queries by friendly name. /// </summary> private void GetByFriendlyName() { bool found = false; ProtectableItemListResponse protectableItemListResponse = RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem( Utilities.GetValueFromArmId(this.ProtectionContainer.ID, ARMResourceTypeConstants.ReplicationFabrics), this.ProtectionContainer.Name); ProtectableItem protectableItem = protectableItemListResponse.ProtectableItems.SingleOrDefault(t => string.Compare(t.Properties.FriendlyName, this.FriendlyName, StringComparison.OrdinalIgnoreCase) == 0); if (protectableItem != null) { ProtectableItemResponse protectableItemResponse = RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem( Utilities.GetValueFromArmId(this.ProtectionContainer.ID, ARMResourceTypeConstants.ReplicationFabrics), this.ProtectionContainer.Name, protectableItem.Name); WriteProtectableItem(protectableItemResponse.ProtectableItem); found = true; } if (!found) { throw new InvalidOperationException( string.Format( Properties.Resources.ProtectionEntityNotFound, this.FriendlyName, this.ProtectionContainer.FriendlyName)); } }
/// <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> /// Initializes a new instance of the <see cref="ASRProtectionEntity" /> class when it is not protected /// </summary> /// <param name="pi">Protectable Item to read values from</param> public ASRProtectionEntity(ProtectableItem pi) { this.ID = pi.Id; this.ProtectionContainerId = Utilities.GetValueFromArmId(pi.Id, ARMResourceTypeConstants.ReplicationProtectionContainers); this.Name = pi.Name; this.FriendlyName = pi.Properties.FriendlyName; this.ProtectionStatus = pi.Properties.ProtectionStatus; if (pi.Properties.CustomDetails != null) { if (0 == string.Compare( pi.Properties.CustomDetails.InstanceType, "HyperVVirtualMachine", StringComparison.OrdinalIgnoreCase)) { if (pi.Properties.CustomDetails is HyperVVirtualMachineDetails) { HyperVVirtualMachineDetails providerSettings = (HyperVVirtualMachineDetails)pi.Properties.CustomDetails; IList<DiskDetails> diskDetails = providerSettings.DiskDetailsList; this.UpdateDiskDetails(diskDetails); this.OS = providerSettings.OSDetails == null ? null : providerSettings.OSDetails.OsType; this.FabricObjectId = providerSettings.SourceItemId; } } } }
/// <summary> /// Write Protection Entity /// </summary> /// <param name="protectableItem"></param> private void WriteProtectionEntity(ProtectableItem protectableItem) { ASRVirtualMachine entity = RecoveryServicesClient.FetchProtectionEntityData <ASRVirtualMachine>( protectableItem, this.ProtectionContainer.ID, this.ProtectionContainer.Name); this.WriteObject(entity); }
/// <summary> /// Write Protection Entity /// </summary> /// <param name="protectableItem"></param> internal T FetchProtectionEntityData <T>(ProtectableItem protectableItem, string protectionContainerId, string protectionContainerName) { ReplicationProtectedItemResponse replicationProtectedItemResponse = null; if (!String.IsNullOrEmpty(protectableItem.Properties.ReplicationProtectedItemId)) { replicationProtectedItemResponse = this.GetAzureSiteRecoveryReplicationProtectedItem( Utilities.GetValueFromArmId(protectionContainerId, ARMResourceTypeConstants.ReplicationFabrics), protectionContainerName, Utilities.GetValueFromArmId(protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems)); } if (replicationProtectedItemResponse != null && replicationProtectedItemResponse.ReplicationProtectedItem != null) { PolicyResponse policyResponse = this.GetAzureSiteRecoveryPolicy(Utilities.GetValueFromArmId( replicationProtectedItemResponse.ReplicationProtectedItem.Properties.PolicyID, ARMResourceTypeConstants.ReplicationPolicies)); if (typeof(T) == typeof(ASRVirtualMachine)) { var pe = new ASRVirtualMachine(protectableItem, replicationProtectedItemResponse.ReplicationProtectedItem, policyResponse.Policy); return((T)Convert.ChangeType(pe, typeof(T))); } else { var pe = new ASRProtectionEntity(protectableItem, replicationProtectedItemResponse.ReplicationProtectedItem, policyResponse.Policy); return((T)Convert.ChangeType(pe, typeof(T))); } } else { if (typeof(T) == typeof(ASRVirtualMachine)) { var pe = new ASRVirtualMachine(protectableItem); return((T)Convert.ChangeType(pe, typeof(T))); } else { var pe = new ASRProtectionEntity(protectableItem); return((T)Convert.ChangeType(pe, typeof(T))); } } }
/// <summary> /// Write Protection Entity /// </summary> /// <param name="protectableItem"></param> private void WriteProtectionEntity(ProtectableItem protectableItem) { ReplicationProtectedItemResponse replicationProtectedItemResponse = null; if (!String.IsNullOrEmpty(protectableItem.Properties.ReplicationProtectedItemId)) { replicationProtectedItemResponse = RecoveryServicesClient.GetAzureSiteRecoveryReplicationProtectedItem( Utilities.GetValueFromArmId(this.ProtectionContainer.ID, ARMResourceTypeConstants.ReplicationFabrics), this.ProtectionContainer.Name, Utilities.GetValueFromArmId(protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems)); } if (replicationProtectedItemResponse != null && replicationProtectedItemResponse.ReplicationProtectedItem != null) { PolicyResponse policyResponse = RecoveryServicesClient.GetAzureSiteRecoveryPolicy(Utilities.GetValueFromArmId(replicationProtectedItemResponse.ReplicationProtectedItem.Properties.PolicyID, ARMResourceTypeConstants.ReplicationPolicies)); this.WriteObject(new ASRProtectionEntity(protectableItem, replicationProtectedItemResponse.ReplicationProtectedItem, policyResponse.Policy)); } else { this.WriteObject(new ASRProtectionEntity(protectableItem)); } }
/// <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 Protection Items /// </summary> /// <param name="protectableItem"></param> private void WriteProtectableItem(ProtectableItem protectableItem) { this.WriteObject(new ASRProtectableItem(protectableItem)); }
/// <summary> /// Initializes a new instance of the <see cref="ASRVirtualMachine" /> class when it is not protected /// </summary> /// <param name="pi">Protectable Item to read values from</param> public ASRVirtualMachine(ProtectableItem pi) : base(pi) { }
/// <summary> /// ProcessRecord of the command. /// </summary> public override void ExecuteSiteRecoveryCmdlet() { base.ExecuteSiteRecoveryCmdlet(); this.targetNameOrId = this.ProtectionEntity.FriendlyName; this.ConfirmAction( this.Force.IsPresent || 0 != string.CompareOrdinal(this.Protection, Constants.DisableProtection), string.Format(Properties.Resources.DisableProtectionWarning, this.targetNameOrId), string.Format(Properties.Resources.DisableProtectionWhatIfMessage, this.Protection), this.targetNameOrId, () => { if (this.Protection == Constants.EnableProtection) { if (string.Compare(this.ParameterSetName, ASRParameterSets.DisableDR, StringComparison.OrdinalIgnoreCase) == 0) { throw new PSArgumentException(Properties.Resources.PassingPolicyMandatoryForEnablingDR); } EnableProtectionProviderSpecificInput enableProtectionProviderSpecificInput = new EnableProtectionProviderSpecificInput(); EnableProtectionInputProperties inputProperties = new EnableProtectionInputProperties() { PolicyId = this.Policy.ID, ProtectableItemId = this.ProtectionEntity.ID, ProviderSpecificDetails = enableProtectionProviderSpecificInput }; EnableProtectionInput input = new EnableProtectionInput() { Properties = inputProperties }; // Process if block only if policy is not null, policy is created for E2A or B2A and parameter set is for enable DR of E2A or B2A if (this.Policy != null && 0 == string.Compare(this.Policy.ReplicationProvider, Constants.HyperVReplicaAzure, StringComparison.OrdinalIgnoreCase) && (0 == string.Compare(this.ParameterSetName, ASRParameterSets.EnterpriseToAzure, StringComparison.OrdinalIgnoreCase) || 0 == string.Compare(this.ParameterSetName, ASRParameterSets.HyperVSiteToAzure, StringComparison.OrdinalIgnoreCase))) { HyperVReplicaAzureEnableProtectionInput providerSettings = new HyperVReplicaAzureEnableProtectionInput(); providerSettings.HvHostVmId = this.ProtectionEntity.FabricObjectId; providerSettings.VmName = this.ProtectionEntity.FriendlyName; // Id disk details are missing in input PE object, get the latest PE. if (string.IsNullOrEmpty(this.ProtectionEntity.OS)) { // Just checked for OS to see whether the disk details got filled up or not ProtectableItemResponse protectableItemResponse = RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem( Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics), this.ProtectionEntity.ProtectionContainerId, this.ProtectionEntity.Name); this.ProtectionEntity = new ASRProtectionEntity(protectableItemResponse.ProtectableItem); } if (string.IsNullOrWhiteSpace(this.OS)) { providerSettings.OSType = ((string.Compare(this.ProtectionEntity.OS, Constants.OSWindows) == 0) || (string.Compare(this.ProtectionEntity.OS, Constants.OSLinux) == 0)) ? this.ProtectionEntity.OS : Constants.OSWindows; } else { providerSettings.OSType = this.OS; } if (string.IsNullOrWhiteSpace(this.OSDiskName)) { providerSettings.VhdId = this.ProtectionEntity.OSDiskId; } else { foreach (var disk in this.ProtectionEntity.Disks) { if (0 == string.Compare(disk.Name, this.OSDiskName, true)) { providerSettings.VhdId = disk.Id; break; } } } if (RecoveryAzureStorageAccountId != null) { providerSettings.TargetStorageAccountId = RecoveryAzureStorageAccountId; } input.Properties.ProviderSpecificDetails = providerSettings; } else if (this.Policy != null && 0 == string.Compare(this.Policy.ReplicationProvider, Constants.HyperVReplicaAzure, StringComparison.OrdinalIgnoreCase) && 0 == string.Compare(this.ParameterSetName, ASRParameterSets.EnterpriseToEnterprise, StringComparison.OrdinalIgnoreCase)) { throw new PSArgumentException(Properties.Resources.PassingStorageMandatoryForEnablingDRInAzureScenarios); } this.response = RecoveryServicesClient.EnableProtection( Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics), Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationProtectionContainers), this.ProtectionEntity.Name, input); } else { // fetch the latest PE object ProtectableItemResponse protectableItemResponse = RecoveryServicesClient.GetAzureSiteRecoveryProtectableItem(Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics), this.ProtectionEntity.ProtectionContainerId, this.ProtectionEntity.Name); ProtectableItem protectableItem = protectableItemResponse.ProtectableItem; if (!this.Force.IsPresent) { DisableProtectionInput input = new DisableProtectionInput(); input.Properties = new DisableProtectionInputProperties() { ProviderSettings = new DisableProtectionProviderSpecificInput() }; this.response = RecoveryServicesClient.DisableProtection( Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics), Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationProtectionContainers), Utilities.GetValueFromArmId(protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems), input); } else { this.response = RecoveryServicesClient.PurgeProtection( Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationFabrics), Utilities.GetValueFromArmId(this.ProtectionEntity.ID, ARMResourceTypeConstants.ReplicationProtectionContainers), Utilities.GetValueFromArmId(protectableItem.Properties.ReplicationProtectedItemId, ARMResourceTypeConstants.ReplicationProtectedItems) ); } } jobResponse = RecoveryServicesClient .GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location)); WriteObject(new ASRJob(jobResponse.Job)); if (this.WaitForCompletion.IsPresent) { this.WaitForJobCompletion(this.jobResponse.Job.Name); jobResponse = RecoveryServicesClient .GetAzureSiteRecoveryJobDetails(PSRecoveryServicesClient.GetJobIdFromReponseLocation(response.Location)); WriteObject(new ASRJob(jobResponse.Job)); } }); }
/// <summary> /// Lists all the protectable objects within your subscription /// according to the query filter and the pagination parameters. /// </summary> /// <param name='resourceGroupName'> /// Required. Resource group name of your recovery services vault. /// </param> /// <param name='resourceName'> /// Required. Name of your recovery services vault. /// </param> /// <param name='queryFilter'> /// Optional. /// </param> /// <param name='paginationParams'> /// Optional. Pagination parameters for controlling the response. /// </param> /// <param name='customRequestHeaders'> /// Optional. Request header parameters. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// List of protectable object resonses as returned by the list /// protectable objects API. /// </returns> public async Task <ProtectableObjectListResponse> ListAsync(string resourceGroupName, string resourceName, ProtectableObjectListQueryParameters queryFilter, PaginationRequest paginationParams, CustomRequestHeaders customRequestHeaders, CancellationToken cancellationToken) { // Validate if (resourceGroupName == null) { throw new ArgumentNullException("resourceGroupName"); } if (resourceName == null) { throw new ArgumentNullException("resourceName"); } // Tracing bool shouldTrace = TracingAdapter.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = TracingAdapter.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceGroupName", resourceGroupName); tracingParameters.Add("resourceName", resourceName); tracingParameters.Add("queryFilter", queryFilter); tracingParameters.Add("paginationParams", paginationParams); tracingParameters.Add("customRequestHeaders", customRequestHeaders); TracingAdapter.Enter(invocationId, this, "ListAsync", tracingParameters); } // Construct URL string url = ""; url = url + "/Subscriptions/"; if (this.Client.Credentials.SubscriptionId != null) { url = url + Uri.EscapeDataString(this.Client.Credentials.SubscriptionId.ToString()); } url = url + "/resourceGroups/"; url = url + Uri.EscapeDataString(resourceGroupName); url = url + "/providers/"; if (this.Client.ResourceNamespace != null) { url = url + Uri.EscapeDataString(this.Client.ResourceNamespace); } url = url + "/"; url = url + "vaults"; url = url + "/"; url = url + Uri.EscapeDataString(resourceName); url = url + "/backupProtectableItems"; List <string> queryParameters = new List <string>(); queryParameters.Add("api-version=2016-05-01"); List <string> odataFilter = new List <string>(); if (queryFilter != null && queryFilter.BackupManagementType != null) { odataFilter.Add("backupManagementType eq '" + Uri.EscapeDataString(queryFilter.BackupManagementType) + "'"); } if (queryFilter != null && queryFilter.Status != null) { odataFilter.Add("status eq '" + Uri.EscapeDataString(queryFilter.Status) + "'"); } if (queryFilter != null && queryFilter.FriendlyName != null) { odataFilter.Add("friendlyName eq '" + Uri.EscapeDataString(queryFilter.FriendlyName) + "'"); } if (odataFilter.Count > 0) { queryParameters.Add("$filter=" + string.Join(" and ", odataFilter)); } if (paginationParams != null && paginationParams.SkipToken != null) { queryParameters.Add("$skiptoken=" + Uri.EscapeDataString(paginationParams.SkipToken)); } if (paginationParams != null && paginationParams.Top != null) { queryParameters.Add("$top=" + Uri.EscapeDataString(paginationParams.Top)); } if (queryParameters.Count > 0) { url = url + "?" + string.Join("&", queryParameters); } string baseUrl = this.Client.BaseUri.AbsoluteUri; // Trim '/' character from the end of baseUrl and beginning of url. if (baseUrl[baseUrl.Length - 1] == '/') { baseUrl = baseUrl.Substring(0, baseUrl.Length - 1); } if (url[0] == '/') { url = url.Substring(1); } url = baseUrl + "/" + url; url = url.Replace(" ", "%20"); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("Accept-Language", customRequestHeaders.Culture); httpRequest.Headers.Add("x-ms-client-request-id", customRequestHeaders.ClientRequestId); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { TracingAdapter.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { TracingAdapter.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { TracingAdapter.Error(invocationId, ex); } throw ex; } // Create Result ProtectableObjectListResponse result = null; // Deserialize Response if (statusCode == HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new ProtectableObjectListResponse(); JToken responseDoc = null; if (string.IsNullOrEmpty(responseContent) == false) { responseDoc = JToken.Parse(responseContent); } if (responseDoc != null && responseDoc.Type != JTokenType.Null) { ProtectableObjectResourceList itemListInstance = new ProtectableObjectResourceList(); result.ItemList = itemListInstance; JToken valueArray = responseDoc["value"]; if (valueArray != null && valueArray.Type != JTokenType.Null) { foreach (JToken valueValue in ((JArray)valueArray)) { ProtectableObjectResource protectableObjectResourceInstance = new ProtectableObjectResource(); itemListInstance.ProtectableObjects.Add(protectableObjectResourceInstance); JToken propertiesValue = valueValue["properties"]; if (propertiesValue != null && propertiesValue.Type != JTokenType.Null) { string typeName = ((string)propertiesValue["protectableItemType"]); if (typeName == "ProtectableItem") { ProtectableItem protectableItemInstance = new ProtectableItem(); JToken friendlyNameValue = propertiesValue["friendlyName"]; if (friendlyNameValue != null && friendlyNameValue.Type != JTokenType.Null) { string friendlyNameInstance = ((string)friendlyNameValue); protectableItemInstance.FriendlyName = friendlyNameInstance; } JToken protectionStateValue = propertiesValue["protectionState"]; if (protectionStateValue != null && protectionStateValue.Type != JTokenType.Null) { string protectionStateInstance = ((string)protectionStateValue); protectableItemInstance.ProtectionState = protectionStateInstance; } JToken protectableItemTypeValue = propertiesValue["protectableItemType"]; if (protectableItemTypeValue != null && protectableItemTypeValue.Type != JTokenType.Null) { string protectableItemTypeInstance = ((string)protectableItemTypeValue); protectableItemInstance.ProtectableItemType = protectableItemTypeInstance; } JToken backupManagementTypeValue = propertiesValue["backupManagementType"]; if (backupManagementTypeValue != null && backupManagementTypeValue.Type != JTokenType.Null) { string backupManagementTypeInstance = ((string)backupManagementTypeValue); protectableItemInstance.BackupManagementType = backupManagementTypeInstance; } protectableObjectResourceInstance.Properties = protectableItemInstance; } if (typeName == "IaaSVMProtectableItem") { AzureIaaSVMProtectableItem azureIaaSVMProtectableItemInstance = new AzureIaaSVMProtectableItem(); JToken virtualMachineIdValue = propertiesValue["virtualMachineId"]; if (virtualMachineIdValue != null && virtualMachineIdValue.Type != JTokenType.Null) { string virtualMachineIdInstance = ((string)virtualMachineIdValue); azureIaaSVMProtectableItemInstance.VirtualMachineId = virtualMachineIdInstance; } JToken friendlyNameValue2 = propertiesValue["friendlyName"]; if (friendlyNameValue2 != null && friendlyNameValue2.Type != JTokenType.Null) { string friendlyNameInstance2 = ((string)friendlyNameValue2); azureIaaSVMProtectableItemInstance.FriendlyName = friendlyNameInstance2; } JToken protectionStateValue2 = propertiesValue["protectionState"]; if (protectionStateValue2 != null && protectionStateValue2.Type != JTokenType.Null) { string protectionStateInstance2 = ((string)protectionStateValue2); azureIaaSVMProtectableItemInstance.ProtectionState = protectionStateInstance2; } JToken protectableItemTypeValue2 = propertiesValue["protectableItemType"]; if (protectableItemTypeValue2 != null && protectableItemTypeValue2.Type != JTokenType.Null) { string protectableItemTypeInstance2 = ((string)protectableItemTypeValue2); azureIaaSVMProtectableItemInstance.ProtectableItemType = protectableItemTypeInstance2; } JToken backupManagementTypeValue2 = propertiesValue["backupManagementType"]; if (backupManagementTypeValue2 != null && backupManagementTypeValue2.Type != JTokenType.Null) { string backupManagementTypeInstance2 = ((string)backupManagementTypeValue2); azureIaaSVMProtectableItemInstance.BackupManagementType = backupManagementTypeInstance2; } protectableObjectResourceInstance.Properties = azureIaaSVMProtectableItemInstance; } if (typeName == "Microsoft.ClassicCompute/virtualMachines") { AzureIaaSClassicComputeVMProtectableItem azureIaaSClassicComputeVMProtectableItemInstance = new AzureIaaSClassicComputeVMProtectableItem(); JToken virtualMachineIdValue2 = propertiesValue["virtualMachineId"]; if (virtualMachineIdValue2 != null && virtualMachineIdValue2.Type != JTokenType.Null) { string virtualMachineIdInstance2 = ((string)virtualMachineIdValue2); azureIaaSClassicComputeVMProtectableItemInstance.VirtualMachineId = virtualMachineIdInstance2; } JToken friendlyNameValue3 = propertiesValue["friendlyName"]; if (friendlyNameValue3 != null && friendlyNameValue3.Type != JTokenType.Null) { string friendlyNameInstance3 = ((string)friendlyNameValue3); azureIaaSClassicComputeVMProtectableItemInstance.FriendlyName = friendlyNameInstance3; } JToken protectionStateValue3 = propertiesValue["protectionState"]; if (protectionStateValue3 != null && protectionStateValue3.Type != JTokenType.Null) { string protectionStateInstance3 = ((string)protectionStateValue3); azureIaaSClassicComputeVMProtectableItemInstance.ProtectionState = protectionStateInstance3; } JToken protectableItemTypeValue3 = propertiesValue["protectableItemType"]; if (protectableItemTypeValue3 != null && protectableItemTypeValue3.Type != JTokenType.Null) { string protectableItemTypeInstance3 = ((string)protectableItemTypeValue3); azureIaaSClassicComputeVMProtectableItemInstance.ProtectableItemType = protectableItemTypeInstance3; } JToken backupManagementTypeValue3 = propertiesValue["backupManagementType"]; if (backupManagementTypeValue3 != null && backupManagementTypeValue3.Type != JTokenType.Null) { string backupManagementTypeInstance3 = ((string)backupManagementTypeValue3); azureIaaSClassicComputeVMProtectableItemInstance.BackupManagementType = backupManagementTypeInstance3; } protectableObjectResourceInstance.Properties = azureIaaSClassicComputeVMProtectableItemInstance; } if (typeName == "Microsoft.Compute/virtualMachines") { AzureIaaSComputeVMProtectableItem azureIaaSComputeVMProtectableItemInstance = new AzureIaaSComputeVMProtectableItem(); JToken virtualMachineIdValue3 = propertiesValue["virtualMachineId"]; if (virtualMachineIdValue3 != null && virtualMachineIdValue3.Type != JTokenType.Null) { string virtualMachineIdInstance3 = ((string)virtualMachineIdValue3); azureIaaSComputeVMProtectableItemInstance.VirtualMachineId = virtualMachineIdInstance3; } JToken friendlyNameValue4 = propertiesValue["friendlyName"]; if (friendlyNameValue4 != null && friendlyNameValue4.Type != JTokenType.Null) { string friendlyNameInstance4 = ((string)friendlyNameValue4); azureIaaSComputeVMProtectableItemInstance.FriendlyName = friendlyNameInstance4; } JToken protectionStateValue4 = propertiesValue["protectionState"]; if (protectionStateValue4 != null && protectionStateValue4.Type != JTokenType.Null) { string protectionStateInstance4 = ((string)protectionStateValue4); azureIaaSComputeVMProtectableItemInstance.ProtectionState = protectionStateInstance4; } JToken protectableItemTypeValue4 = propertiesValue["protectableItemType"]; if (protectableItemTypeValue4 != null && protectableItemTypeValue4.Type != JTokenType.Null) { string protectableItemTypeInstance4 = ((string)protectableItemTypeValue4); azureIaaSComputeVMProtectableItemInstance.ProtectableItemType = protectableItemTypeInstance4; } JToken backupManagementTypeValue4 = propertiesValue["backupManagementType"]; if (backupManagementTypeValue4 != null && backupManagementTypeValue4.Type != JTokenType.Null) { string backupManagementTypeInstance4 = ((string)backupManagementTypeValue4); azureIaaSComputeVMProtectableItemInstance.BackupManagementType = backupManagementTypeInstance4; } protectableObjectResourceInstance.Properties = azureIaaSComputeVMProtectableItemInstance; } } JToken idValue = valueValue["id"]; if (idValue != null && idValue.Type != JTokenType.Null) { string idInstance = ((string)idValue); protectableObjectResourceInstance.Id = idInstance; } JToken nameValue = valueValue["name"]; if (nameValue != null && nameValue.Type != JTokenType.Null) { string nameInstance = ((string)nameValue); protectableObjectResourceInstance.Name = nameInstance; } JToken typeValue = valueValue["type"]; if (typeValue != null && typeValue.Type != JTokenType.Null) { string typeInstance = ((string)typeValue); protectableObjectResourceInstance.Type = typeInstance; } JToken locationValue = valueValue["location"]; if (locationValue != null && locationValue.Type != JTokenType.Null) { string locationInstance = ((string)locationValue); protectableObjectResourceInstance.Location = locationInstance; } JToken tagsSequenceElement = ((JToken)valueValue["tags"]); if (tagsSequenceElement != null && tagsSequenceElement.Type != JTokenType.Null) { foreach (JProperty property in tagsSequenceElement) { string tagsKey = ((string)property.Name); string tagsValue = ((string)property.Value); protectableObjectResourceInstance.Tags.Add(tagsKey, tagsValue); } } JToken eTagValue = valueValue["eTag"]; if (eTagValue != null && eTagValue.Type != JTokenType.Null) { string eTagInstance = ((string)eTagValue); protectableObjectResourceInstance.ETag = eTagInstance; } } } JToken nextLinkValue = responseDoc["nextLink"]; if (nextLinkValue != null && nextLinkValue.Type != JTokenType.Null) { string nextLinkInstance = ((string)nextLinkValue); itemListInstance.NextLink = nextLinkInstance; } } } result.StatusCode = statusCode; if (shouldTrace) { TracingAdapter.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }
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(); } }
public static ReplicationProtectedItemOperationResponse EnableDR( this SiteRecoveryManagementClient client, Fabric primaryFabric, ProtectionContainer protectionContainer, Policy policy, ProtectableItem protectableItem, string armResourceName) { if (policy.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplicaAzure") { string vhdId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails) .DiskDetailsList[0].VhdId; DiskDetails osDisk = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).DiskDetailsList .FirstOrDefault(item => item.VhdType == "OperatingSystem"); if (osDisk != null) { vhdId = osDisk.VhdId; } HyperVReplicaAzureEnableProtectionInput hvrAEnableDRInput = new HyperVReplicaAzureEnableProtectionInput() { HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId, OSType = "Windows", VhdId = vhdId, VmName = protectableItem.Properties.FriendlyName, TargetStorageAccountId = (policy.Properties.ProviderSpecificDetails as HyperVReplicaAzurePolicyDetails) .ActiveStorageAccountId, }; EnableProtectionInputProperties enableDRProp = new EnableProtectionInputProperties() { PolicyId = policy.Id, ProtectableItemId = protectableItem.Id, ProviderSpecificDetails = hvrAEnableDRInput }; EnableProtectionInput enableDRInput = new EnableProtectionInput() { Properties = enableDRProp }; return(client.ReplicationProtectedItem.EnableProtection( primaryFabric.Name, protectionContainer.Name, armResourceName, enableDRInput, GetRequestHeaders()) as ReplicationProtectedItemOperationResponse); } else if (policy.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplica2012" || policy.Properties.ProviderSpecificDetails.InstanceType == "HyperVReplica2012R2") { var enableDRProp = new EnableProtectionInputProperties() { PolicyId = policy.Id, ProtectableItemId = protectableItem.Id, ProviderSpecificDetails = new EnableProtectionProviderSpecificInput() }; EnableProtectionInput enableInput = new EnableProtectionInput() { Properties = enableDRProp }; return(client.ReplicationProtectedItem.EnableProtection( primaryFabric.Name, protectionContainer.Name, armResourceName, enableInput, GetRequestHeaders()) as ReplicationProtectedItemOperationResponse); } else { throw new NotImplementedException(); } }
public void EndToEndB2ASingleVM() { using (UndoContext context = UndoContext.Current) { context.Start(); var client = GetSiteRecoveryClient(CustomHttpHandler); bool createPolicy = true; bool pairClouds = true; bool enableDR = true; bool pfo = true; bool commit = true; bool tfo = true; bool pfoReverse = true; bool commitReverse = true; bool reprotect = true; bool disableDR = true; bool unpair = true; bool removePolicy = true; // Process Variables string fabricName = string.Empty; string recCldName = "Microsoft Azure"; string priCldName = string.Empty; string policyName = "Hydra-EndToEndB2ASingleVM-" + (new Random()).Next(); string mappingName = "Mapping-EndToEndB2ASingleVM-" + (new Random()).Next(); string enableDRName = string.Empty; string protectedItemName = "PE" + (new Random()).Next(); // Data Variables Fabric selectedFabric = null; ProtectionContainer primaryCloud = null; Policy selectedPolicy = null; ProtectableItem protectableItem = null; ReplicationProtectedItem protectedItem = null; // Fetch HyperV if (string.IsNullOrEmpty(fabricName)) { var fabrics = client.Fabrics.List(RequestHeaders); foreach (var fabric in fabrics.Fabrics) { if (fabric.Properties.CustomDetails.InstanceType.Contains("HyperV")) { selectedFabric = fabric; fabricName = selectedFabric.Name; } } } else { selectedFabric = client.Fabrics.Get(fabricName, RequestHeaders).Fabric; } // Fetch Cloud primaryCloud = client.ProtectionContainer.List(selectedFabric.Name, RequestHeaders).ProtectionContainers[0]; priCldName = primaryCloud.Name; if (createPolicy) { HyperVReplicaAzurePolicyInput hvrAPolicy = new HyperVReplicaAzurePolicyInput() { ApplicationConsistentSnapshotFrequencyInHours = 0, Encryption = "Disable", OnlineIrStartTime = null, RecoveryPointHistoryDuration = 0, ReplicationInterval = 30, StorageAccounts = new List <string>() { "/subscriptions/19b823e2-d1f3-4805-93d7-401c5d8230d5/resourceGroups/Default-Storage-WestUS/providers/Microsoft.ClassicStorage/storageAccounts/bvtmapped2storacc" } }; CreatePolicyInputProperties createInputProp = new CreatePolicyInputProperties() { ProviderSpecificInput = hvrAPolicy }; CreatePolicyInput policyInput = new CreatePolicyInput() { Properties = createInputProp }; selectedPolicy = (client.Policies.Create(policyName, policyInput, RequestHeaders) as CreatePolicyOperationResponse).Policy; } else { selectedPolicy = client.Policies.Get(policyName, RequestHeaders).Policy; } if (pairClouds) { CreateProtectionContainerMappingInputProperties pairingProps = new CreateProtectionContainerMappingInputProperties() { PolicyId = selectedPolicy.Id, TargetProtectionContainerId = recCldName, ProviderSpecificInput = new ReplicationProviderContainerMappingInput() }; CreateProtectionContainerMappingInput pairingInput = new CreateProtectionContainerMappingInput() { Properties = pairingProps }; var pairingResponse = client.ProtectionContainerMapping.ConfigureProtection( selectedFabric.Name, primaryCloud.Name, mappingName, pairingInput, RequestHeaders); } if (enableDR) { if (string.IsNullOrEmpty(enableDRName)) { protectableItem = client.ProtectableItem.List(selectedFabric.Name, primaryCloud.Name, "Unprotected", RequestHeaders).ProtectableItems[0]; enableDRName = protectableItem.Name; } else { protectableItem = client.ProtectableItem.Get(selectedFabric.Name, primaryCloud.Name, enableDRName, RequestHeaders).ProtectableItem; } HyperVReplicaAzureEnableProtectionInput hvrAEnableDRInput = new HyperVReplicaAzureEnableProtectionInput() { HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId, OSType = "Windows", VhdId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).DiskDetailsList[0].VhdId, VmName = protectableItem.Properties.FriendlyName, TargetStorageAccountId = "/subscriptions/19b823e2-d1f3-4805-93d7-401c5d8230d5/resourceGroups/Default-Storage-WestUS/providers/Microsoft.ClassicStorage/storageAccounts/bvtmapped2storacc", }; EnableProtectionInputProperties enableDRProp = new EnableProtectionInputProperties() { PolicyId = selectedPolicy.Id, ProtectableItemId = protectableItem.Id, ProviderSpecificDetails = hvrAEnableDRInput }; EnableProtectionInput enableDRInput = new EnableProtectionInput() { Properties = enableDRProp }; DateTime enablStartTime = DateTime.UtcNow; protectedItem = ( client.ReplicationProtectedItem.EnableProtection( selectedFabric.Name, primaryCloud.Name, protectedItemName, enableDRInput, RequestHeaders) as ReplicationProtectedItemOperationResponse).ReplicationProtectedItem; MonitoringHelper.MonitorJobs(MonitoringHelper.AzureIrJobName, enablStartTime, client, RequestHeaders); } if (pfo || commit || tfo || pfoReverse || commitReverse || reprotect || disableDR) { protectableItem = client.ProtectableItem.Get(selectedFabric.Name, primaryCloud.Name, enableDRName, RequestHeaders).ProtectableItem; protectedItem = client.ReplicationProtectedItem.Get(selectedFabric.Name, primaryCloud.Name, protectedItemName, RequestHeaders).ReplicationProtectedItem; // Create Input for Operations ///////////////////////////// PFO ///////////////////////////////////// HyperVReplicaAzureFailoverProviderInput hvrAFOInput = new HyperVReplicaAzureFailoverProviderInput() { VaultLocation = "West US", }; PlannedFailoverInputProperties plannedFailoverProp = new PlannedFailoverInputProperties() { FailoverDirection = "", ProviderSpecificDetails = hvrAFOInput }; PlannedFailoverInput plannedFailoverInput = new PlannedFailoverInput() { Properties = plannedFailoverProp }; HyperVReplicaAzureFailbackProviderInput hvrAFBInput = new HyperVReplicaAzureFailbackProviderInput() { RecoveryVmCreationOption = "NoAction", DataSyncOption = "ForSyncronization" }; PlannedFailoverInputProperties plannedFailbackProp = new PlannedFailoverInputProperties() { FailoverDirection = "", ProviderSpecificDetails = hvrAFBInput }; PlannedFailoverInput plannedFailbackInput = new PlannedFailoverInput() { Properties = plannedFailbackProp }; ////////////////////////////// Reprotect ////////////////////////////////////// HyperVReplicaAzureReprotectInput hvrARRInput = new HyperVReplicaAzureReprotectInput() { HvHostVmId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).SourceItemId, OSType = "Windows", VHDId = (protectableItem.Properties.CustomDetails as HyperVVirtualMachineDetails).DiskDetailsList[0].VhdId, VmName = protectableItem.Properties.FriendlyName, StorageAccountId = "/subscriptions/19b823e2-d1f3-4805-93d7-401c5d8230d5/resourceGroups/Default-Storage-WestUS/providers/Microsoft.ClassicStorage/storageAccounts/bvtmapped2storacc", }; ReverseReplicationInputProperties rrProp = new ReverseReplicationInputProperties() { FailoverDirection = "", ProviderSpecificDetails = hvrARRInput }; ReverseReplicationInput rrInput = new ReverseReplicationInput() { Properties = rrProp }; ////////////////////////////////// UFO ///////////////////////////////////////// UnplannedFailoverInputProperties ufoProp = new UnplannedFailoverInputProperties() { ProviderSpecificDetails = hvrAFOInput, SourceSiteOperations = "NotRequired" }; UnplannedFailoverInput ufoInput = new UnplannedFailoverInput() { Properties = ufoProp }; /////////////////////////////////// TFO ///////////////////////////////////////////// TestFailoverInputProperties tfoProp = new TestFailoverInputProperties() { ProviderSpecificDetails = hvrAFOInput }; TestFailoverInput tfoInput = new TestFailoverInput() { Properties = tfoProp }; ////////////////////////////////////////////////////////////////////////////////////////// if (pfo) { var plannedfailover = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, plannedFailoverInput, RequestHeaders); } if (commit) { var commitFailover = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, RequestHeaders); } if (pfoReverse) { //var unplannedFailoverReverse = client.ReplicationProtectedItem.UnplannedFailover(selectedFabric.Name, priCld, replicationProtectedItems.ReplicationProtectedItems[0].Name, ufoInput, RequestHeaders); var plannedFailoverReverse = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, plannedFailbackInput, RequestHeaders); } if (commitReverse) { var commitFailoverReverse = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, RequestHeaders); } if (reprotect) { var reprotectStartTime = DateTime.UtcNow; var rrReverseOp = client.ReplicationProtectedItem.Reprotect(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, rrInput, RequestHeaders); MonitoringHelper.MonitorJobs(MonitoringHelper.AzureIrJobName, reprotectStartTime, client, RequestHeaders); } if (tfo) { DateTime startTFO = DateTime.UtcNow; var tfoOp = client.ReplicationProtectedItem.TestFailover(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, tfoInput, RequestHeaders); var jobs = MonitoringHelper.GetJobId(MonitoringHelper.TestFailoverJobName, startTFO, client, RequestHeaders); ResumeJobParamsProperties resProp = new ResumeJobParamsProperties() { Comments = "Res TFO" }; ResumeJobParams resParam = new ResumeJobParams() { Properties = resProp }; var resJob = client.Jobs.Resume(jobs.Name, resParam, RequestHeaders); } if (disableDR) { var disableDROperation = client.ReplicationProtectedItem.DisableProtection(selectedFabric.Name, primaryCloud.Name, protectedItem.Name, new DisableProtectionInput(), RequestHeaders); } if (unpair) { var unpairClouds = client.ProtectionContainerMapping.UnconfigureProtection( selectedFabric.Name, primaryCloud.Name, mappingName, new RemoveProtectionContainerMappingInput(), RequestHeaders); } } if (removePolicy) { var policyDeletion = client.Policies.Delete(selectedPolicy.Name, RequestHeaders); } } }