/// <summary> /// Exports list of SubscriptionId specific dataCenters. /// </summary> ///<param name="credentials"> Subscription credentials</param> /// <param name="retryCount"> No. of times to retry in case of exception</param> /// <param name="minBackOff">Minimum backoff in seconds</param> /// <param name="maxBackOff">Maximum backoff in seconds</param> /// <param name="deltaBackOff">Delta Backoff in seconds</param> /// <returns>List of SubscriptionId specific dataCenters.</returns> private static List <string> ExportDataCenterLocations(SubscriptionCloudCredentials credentials, int retryCount, double minBackOff, double maxBackOff, double deltaBackOff) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted); try { using (var client = new ManagementClient(credentials)) { BaseParameters baseParams = new BaseParameters() { RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff) }; // Call management API to get list of locations. var locations = Retry.RetryOperation(() => client.Locations.List(), baseParams, ResourceType.None); Logger.Info(methodName, ProgressResources.ExecutionCompleted); return(locations.Select(l => l.Name).ToList()); } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.None.ToString()); throw; } }
/// <summary> /// Gets list of hosted service operation response from MS azure using API call. /// </summary> /// <param name="credentials">credentials</param> /// <param name="serviceUrl">serviceUrl</param> /// <returns>List of hosted service operation response for subscription </returns> private HostedServiceListResponse GetCloudServiceListResponseFromMSAzure(SubscriptionCloudCredentials credentials, Uri serviceUrl) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetServicesFromMSAzureStarted, ResourceType.CloudService.ToString()); dcMigration.ReportProgress(ProgressResources.GetServicesFromMSAzureStarted); try { using (var client = new ComputeManagementClient(credentials, serviceUrl)) { ////Call management API to get list of CloudServices. ////HostedServiceListResponse serviceResponse = Retry.RetryOperation(() => client.HostedServices.List(), exportParameters.RetryCount, exportParameters.MinBackOff, exportParameters.MaxBackOff, exportParameters.DeltaBackOff, ResourceType.CloudService); HostedServiceListResponse serviceResponse = Retry.RetryOperation(() => client.HostedServices.List(), (BaseParameters)exportParameters, ResourceType.CloudService); Logger.Info(methodName, ProgressResources.GetServicesFromMSAzureCompleted, ResourceType.CloudService.ToString()); return(serviceResponse); } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.CloudService.ToString()); throw; } }
/// <summary> /// Rollback all imported affinity groups. /// </summary> /// <param name="affinityGroups">Affinity groups to be deleted.</param> private void RollBackAffinityGroups(List <string> affinityGroups) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.AffinityGroup.ToString()); dcMigrationManager.ReportProgress(ProgressResources.RollbackAffinityGroups); Logger.Info(methodName, ProgressResources.RollbackAffinityGroups, ResourceType.AffinityGroup.ToString()); Stopwatch swTotalAffGrp = new Stopwatch(); swTotalAffGrp.Start(); if (affinityGroups.Count > 0) { using (var client = new ManagementClient(importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl)) { Parallel.ForEach(affinityGroups, affinityGroup => { Stopwatch swAffinityGroup = new Stopwatch(); swAffinityGroup.Start(); try { Retry.RetryOperation(() => client.AffinityGroups.Delete(affinityGroup), (BaseParameters)importParameters, ResourceType.AffinityGroup, affinityGroup, ignoreResourceNotFoundEx: true); resourceImporter.UpdateMedatadaFile(ResourceType.AffinityGroup, affinityGroup, false); swAffinityGroup.Stop(); Logger.Info(methodName, string.Format(ProgressResources.RollbackAffinityGroup, affinityGroup, swAffinityGroup.Elapsed.Days, swAffinityGroup.Elapsed.Hours, swAffinityGroup.Elapsed.Minutes, swAffinityGroup.Elapsed.Seconds), ResourceType.AffinityGroup.ToString(), affinityGroup); } catch (AggregateException exAgg) { foreach (var ex in exAgg.InnerExceptions) { Logger.Error(methodName, exAgg, ResourceType.AffinityGroup.ToString(), affinityGroup); } throw; } }); dcMigrationManager.ReportProgress(ProgressResources.RollbackAffinityGroupsWaiting); Logger.Info(methodName, ProgressResources.RollbackAffinityGroupsWaiting, ResourceType.AffinityGroup.ToString()); Task.Delay(Constants.DelayTimeInMilliseconds_Rollback).Wait(); } } swTotalAffGrp.Stop(); Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime, swTotalAffGrp.Elapsed.Days, swTotalAffGrp.Elapsed.Hours, swTotalAffGrp.Elapsed.Minutes, swTotalAffGrp.Elapsed.Seconds), ResourceType.AffinityGroup.ToString()); }
/// <summary> /// Gets list of affinity group operation response from MS azure using API call. /// </summary> /// <param name="credentials">Subscription Cloud Credentials</param> /// <param name="importParameters">object of <see cref="ImportParameters"/> which contains the input parameters passed for import functionality </param> /// <returns>List of affinity group operation response for subscription </returns> private static AffinityGroupListResponse GetAffinityGroupListResponseFromMSAzure(SubscriptionCloudCredentials credentials, ImportParameters importParameters) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.GetAffinityGroupsFromMSAzureStarted, ResourceType.AffinityGroup.ToString()); using (var client = new ManagementClient(credentials)) { // Call management API to get list of affinity groups. AffinityGroupListResponse agResponse = Retry.RetryOperation(() => client.AffinityGroups.List(), (BaseParameters)importParameters, ResourceType.AffinityGroup); Logger.Info(methodName, ProgressResources.GetAffinityGroupsFromMSAzureCompleted, ResourceType.AffinityGroup.ToString()); return(agResponse); } }
private StorageAccountGetKeysResponse GetStorageAccountKeysFromMSAzure(SubscriptionCloudCredentials credentials, string storageAccountName) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; using (var client = new StorageManagementClient(credentials)) { Logger.Info(methodName, string.Format(ProgressResources.GetStorageAccountKeysStarted, storageAccountName), ResourceType.StorageAccount.ToString(), storageAccountName); ////Call management API to get keys of storage account. StorageAccountGetKeysResponse storageKeyResponse = Retry.RetryOperation(() => client.StorageAccounts.GetKeys(storageAccountName), (BaseParameters)exportParameters, ResourceType.StorageAccount, storageAccountName); Logger.Info(methodName, string.Format(ProgressResources.GetStorageAccountKeysCompleted, storageAccountName), ResourceType.StorageAccount.ToString(), storageAccountName); return(storageKeyResponse); } }
/// <summary> /// Gets list of storage account operation response from MS azure using API call. /// </summary> /// <param name="credentials">Source Subscription Credentials</param> /// <returns>list of storage account</returns> internal StorageAccountListResponse GetStorageAccountListResponseFromMSAzure(SubscriptionCloudCredentials credentials) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; dcMigration.ReportProgress(ProgressResources.GetStorageAccountsFromMSAzureStarted); try { Logger.Info(methodName, ProgressResources.GetStorageAccountsFromMSAzureStarted, ResourceType.StorageAccount.ToString()); using (var client = new StorageManagementClient(credentials)) { // Call management API to get list of storage accounts. StorageAccountListResponse storageResponse = Retry.RetryOperation(() => client.StorageAccounts.List(), (BaseParameters)exportParameters, ResourceType.StorageAccount); Logger.Info(methodName, ProgressResources.GetStorageAccountsFromMSAzureCompleted, ResourceType.StorageAccount.ToString()); return(storageResponse); } } catch (Exception ex) { Logger.Error(methodName, ex, ResourceType.StorageAccount.ToString()); throw; } }
/// <summary> /// Rollback all virtual networks /// </summary> /// <param name="networkConfiguration">Network configuration</param> private void RollBackVirtualNetworks(NetworkConfiguration networkConfiguration) { Stopwatch swVirtualNetwork = new Stopwatch(); swVirtualNetwork.Start(); string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.NetworkConfiguration.ToString()); // Get destination subscription network configuration NetworkGetConfigurationResponse destinationNetworkResponse = GetNetworkConfigurationFromMSAzure( importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl); NetworkConfiguration destinationNetConfiguration = null; XmlSerializer serializer = new XmlSerializer(typeof(NetworkConfiguration)); if (destinationNetworkResponse != null && !(string.IsNullOrEmpty(destinationNetworkResponse.Configuration))) { var destinationReader = new StringReader(destinationNetworkResponse.Configuration); destinationNetConfiguration = (NetworkConfiguration)serializer.Deserialize(destinationReader); } try { if (networkConfiguration != null) { if (networkConfiguration.VirtualNetworkConfiguration != null) { if (networkConfiguration.VirtualNetworkConfiguration.Dns != null && networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null && destinationNetConfiguration != null && destinationNetConfiguration.VirtualNetworkConfiguration != null && destinationNetConfiguration.VirtualNetworkConfiguration.Dns != null && destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers != null) { foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites) { foreach (var dns in networkConfiguration.VirtualNetworkConfiguration.Dns.DnsServers) { string dnsDestination = resourceImporter.GetDestinationResourceName(ResourceType.DnsServer, dns.name, ResourceType.VirtualNetworkSite, resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite, virtualNetworkSite.name)); if (!string.IsNullOrEmpty(dnsDestination)) { destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers = destinationNetConfiguration.VirtualNetworkConfiguration.Dns.DnsServers.Where(s => s.name != dnsDestination).ToArray(); } } } } if (networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null && destinationNetConfiguration != null && destinationNetConfiguration.VirtualNetworkConfiguration != null && destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites != null) { foreach (var virtualNetworkSite in networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites) { foreach (var localNetwork in networkConfiguration.VirtualNetworkConfiguration.LocalNetworkSites) { string localNetworkDestination = resourceImporter.GetDestinationResourceName(ResourceType.LocalNetworkSite, localNetwork.name, ResourceType.VirtualNetworkSite, resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite, virtualNetworkSite.name)); if (!string.IsNullOrEmpty(localNetworkDestination)) { destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites = destinationNetConfiguration.VirtualNetworkConfiguration.LocalNetworkSites.Where(s => s.name != localNetworkDestination).ToArray(); } } } } if (networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null && destinationNetConfiguration != null && destinationNetConfiguration.VirtualNetworkConfiguration != null && destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites != null) { destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites = destinationNetConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites. Where(x => !networkConfiguration.VirtualNetworkConfiguration.VirtualNetworkSites. Any(x1 => resourceImporter.GetDestinationResourceName(ResourceType.VirtualNetworkSite, x1.name) == x.name)).ToArray(); } } } MemoryStream memoryStream = new MemoryStream(); XmlWriter writer = XmlWriter.Create(memoryStream, new XmlWriterSettings { Encoding = Encoding.UTF8 }); serializer.Serialize(writer, destinationNetConfiguration); using (var vnetClient = new NetworkManagementClient(importParameters.DestinationSubscriptionSettings.Credentials, importParameters.DestinationSubscriptionSettings.ServiceUrl)) { OperationStatusResponse response = Retry.RetryOperation(() => vnetClient.Networks.SetConfiguration( new NetworkSetConfigurationParameters { Configuration = Encoding.UTF8.GetString(memoryStream.ToArray()) }), (BaseParameters)importParameters, ResourceType.NetworkConfiguration); } writer.Close(); memoryStream.Close(); resourceImporter.UpdateMedatadaFile(ResourceType.NetworkConfiguration, null, false); Logger.Info(methodName, ProgressResources.RollbackVirtualNetworksWaiting, ResourceType.NetworkConfiguration.ToString()); dcMigrationManager.ReportProgress(ProgressResources.RollbackVirtualNetworksWaiting); Task.Delay(Constants.DelayTimeInMilliseconds_Rollback).Wait(); Logger.Info(methodName, ProgressResources.RollbackVirtualNetwork, ResourceType.NetworkConfiguration.ToString()); swVirtualNetwork.Stop(); Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime, swVirtualNetwork.Elapsed.Days, swVirtualNetwork.Elapsed.Hours, swVirtualNetwork.Elapsed.Minutes, swVirtualNetwork.Elapsed.Seconds), ResourceType.NetworkConfiguration.ToString()); } catch (CloudException ex) { if (string.Compare(ex.ErrorCode, Constants.ResourceNotFound, StringComparison.CurrentCultureIgnoreCase) != 0) { Logger.Error(methodName, ex, ResourceType.VirtualNetwork.ToString()); } else { throw; } } }
/// <summary> /// Rollback all imported cloud services. /// </summary> /// <param name="cloudServices">Cloud services to be deleted.</param> private void RollBackServices(List <string> cloudServices) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.CloudService.ToString()); Logger.Info(methodName, ProgressResources.RollbackCloudServices, ResourceType.CloudService.ToString()); dcMigrationManager.ReportProgress(ProgressResources.RollbackCloudServices); Stopwatch swTotalServices = new Stopwatch(); swTotalServices.Start(); //string origServiceName = null; if (cloudServices.Count > 0) { using (var client = new ComputeManagementClient(importParameters.DestinationSubscriptionSettings.Credentials)) { Parallel.ForEach(cloudServices, cloudService => { try { Stopwatch swService = new Stopwatch(); swService.Start(); string origServiceName = resourceImporter.GetSourceResourceName(ResourceType.CloudService, cloudService); Retry.RetryOperation(() => client.HostedServices.DeleteAll(cloudService), (BaseParameters)importParameters, ResourceType.CloudService, cloudService, ignoreResourceNotFoundEx: true); CloudService service = subscription.DataCenters.FirstOrDefault().CloudServices. Where(ser => (ser.CloudServiceDetails.ServiceName == origServiceName)).FirstOrDefault(); if (service.DeploymentDetails != null) { string deploymentName = resourceImporter.GetDestinationResourceName( ResourceType.Deployment, service.DeploymentDetails.Name, ResourceType.CloudService, resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName) ); resourceImporter.UpdateMedatadaFile(ResourceType.Deployment, deploymentName, false, resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName) ); Logger.Info(methodName, string.Format(ProgressResources.RollbackDeployment, service.DeploymentDetails.Name, service.DeploymentDetails.Name), ResourceType.Deployment.ToString(), service.DeploymentDetails.Name); foreach (VirtualMachine vm in service.DeploymentDetails.VirtualMachines) { string virtualmachineName = resourceImporter.GetDestinationResourceName( ResourceType.VirtualMachine, vm.VirtualMachineDetails.RoleName, ResourceType.CloudService, resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName) ); resourceImporter.UpdateMedatadaFile(ResourceType.VirtualMachine, virtualmachineName, false, resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName) ); Logger.Info(methodName, string.Format(ProgressResources.RollbackVirtualMachine, vm.VirtualMachineDetails.RoleName), ResourceType.VirtualMachine.ToString(), vm.VirtualMachineDetails.RoleName); } } resourceImporter.UpdateMedatadaFile(ResourceType.CloudService, cloudService, false); swService.Stop(); Logger.Info(methodName, string.Format(ProgressResources.RollbackCloudService, cloudService, swService.Elapsed.Days, swService.Elapsed.Hours, swService.Elapsed.Minutes, swService.Elapsed.Seconds), ResourceType.CloudService.ToString(), cloudService); } catch (AggregateException exAgg) { foreach (var ex in exAgg.InnerExceptions) { Logger.Error(methodName, exAgg, ResourceType.CloudService.ToString(), cloudService); } throw; } }); Logger.Info(methodName, ProgressResources.RollbackCloudServicesWaiting, ResourceType.CloudService.ToString()); dcMigrationManager.ReportProgress(ProgressResources.RollbackCloudServicesWaiting); Task.Delay(Constants.DelayTimeInMilliseconds_Rollback).Wait(); } } swTotalServices.Stop(); Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime, swTotalServices.Elapsed.Days, swTotalServices.Elapsed.Hours, swTotalServices.Elapsed.Minutes, swTotalServices.Elapsed.Seconds), ResourceType.CloudService.ToString()); }
/// <summary> /// Validates and converts input paramters into <see cref="ExportParameters"/> class. /// </summary> /// <param name="parameters">Collection of input parameters stored in key value pairs /// <example> Operation "Export" SourceSubscriptionID "5d14d4a2-8c5a-4fc5-8d7d-86efb48b3a07" SourceDCName "East Asia" /// ExportMetadataFolderPath "D:\\DataCenterMigration" SourcePublishSettingsFilePath "D:\\PublishSettings.PublishSettings" /// QuietMode "True" </example> </param> /// <returns>Parameters required for export functionality</returns> internal static ExportParameters ValidateAndConvertExportParameters(IDictionary <string, string> parameters) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted); Logger.Info(methodName, ProgressResources.ParameterValidationStarted); #region Check for missing required parameters // PublishSettingsFilePath / CertificateThumbprint if (!parameters.Keys.Contains(Constants.Parameters.SourcePublishSettingsFilePath) && !parameters.Keys.Contains( Constants.Parameters.SourceCertificateThumbprint)) { throw new ValidationException(string.Format(StringResources.MissingCredentialsFile, StringResources.Source, Constants.AppConfigArguments)); } // ExportMetadataFolderPath if (!parameters.Keys.Contains(Constants.Parameters.ExportMetadataFolderPath)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.ExportMetadataFolderPath, Constants.AppConfigArguments)); } // SourceSubscriptionID if (!parameters.Keys.Contains(Constants.Parameters.SourceSubscriptionID)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.SourceSubscriptionID, Constants.AppConfigArguments)); } // SourceDCName if (!parameters.Keys.Contains(Constants.Parameters.SourceDCName)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.SourceDCName, Constants.AppConfigArguments)); } #endregion #region Check for null or empty values // PublishSettingsFilePath if ((parameters.ContainsKey(Constants.Parameters.SourcePublishSettingsFilePath) && string.IsNullOrEmpty(parameters[Constants.Parameters.SourcePublishSettingsFilePath])) || (parameters.ContainsKey(Constants.Parameters.SourceCertificateThumbprint) && string.IsNullOrEmpty(parameters[Constants.Parameters.SourceCertificateThumbprint]))) { throw new ValidationException(string.Format(StringResources.MissingCredentialsFile, StringResources.Source, Constants.AppConfigArguments)); } // ExportMetadataFolderPath if (string.IsNullOrEmpty(parameters[Constants.Parameters.ExportMetadataFolderPath])) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.ExportMetadataFolderPath)); } // SourceSubscriptionID if (string.IsNullOrEmpty(parameters[Constants.Parameters.SourceSubscriptionID])) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.SourceSubscriptionID)); } // SourceDCName if (string.IsNullOrEmpty(parameters[Constants.Parameters.SourceDCName])) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.SourceDCName)); } #endregion #region Validate parameter's value // Validate PublishSettingsFilePath if (parameters.ContainsKey(Constants.Parameters.SourcePublishSettingsFilePath) && !File.Exists(parameters[Constants.Parameters.SourcePublishSettingsFilePath])) { throw new ValidationException(string.Format(StringResources.InvalidParameterValue, Constants.Parameters.SourcePublishSettingsFilePath), new FileNotFoundException(StringResources.PublishSettingsFilePathParamException)); } // Validate ExportMetadataFolderPath string folderPath = parameters[Constants.Parameters.ExportMetadataFolderPath]; if (!Directory.Exists(parameters[Constants.Parameters.ExportMetadataFolderPath])) { throw new ValidationException(string.Format(StringResources.InvalidParameterValue, Constants.Parameters.ExportMetadataFolderPath), new DirectoryNotFoundException(StringResources.ExportMetadataFolderPathParamException)); } int retryCount; Double minBackOff; Double maxBackOff; Double deltaBackOff; bool generateMapperXmlValue; if (!parameters.Keys.Contains(Constants.Parameters.RetryCount)) { retryCount = Int32.Parse(Constants.RetryCountDefault); } else { Int32.TryParse(parameters[Constants.Parameters.RetryCount], out retryCount); } if (!parameters.Keys.Contains(Constants.Parameters.MinBackoff)) { minBackOff = Double.Parse(Constants.MinBackoffDefault); } else { Double.TryParse(parameters[Constants.Parameters.MinBackoff], out minBackOff); } if (!parameters.Keys.Contains(Constants.Parameters.MaxBackoff)) { maxBackOff = Double.Parse(Constants.MaxBackoffDefault); } else { Double.TryParse(parameters[Constants.Parameters.MaxBackoff], out maxBackOff); } if (!parameters.Keys.Contains(Constants.Parameters.DeltaBackoff)) { deltaBackOff = Double.Parse(Constants.DeltaBackoffDefault); } else { Double.TryParse(parameters[Constants.Parameters.DeltaBackoff], out deltaBackOff); } if (!parameters.Keys.Contains(Constants.Parameters.GenerateMapperXml)) { generateMapperXmlValue = false; } else { bool.TryParse(parameters[Constants.Parameters.GenerateMapperXml], out generateMapperXmlValue); } // Validate SourceSubscriptionID PublishSettings publishSettingsFile = null; PublishSetting subscription = null; if (parameters.ContainsKey(Constants.Parameters.SourcePublishSettingsFilePath)) { try { var fileContents = File.ReadAllText(parameters[Constants.Parameters.SourcePublishSettingsFilePath]); publishSettingsFile = new PublishSettings(fileContents); } catch (Exception xmlEx) { throw new ValidationException(string.Format(StringResources.XMLParsingException + " =>" + xmlEx.Message, parameters[Constants.Parameters.SourcePublishSettingsFilePath])); } // Check whether subscriptionId exists in publish settings file subscription = publishSettingsFile.Subscriptions.FirstOrDefault(a => string.Compare(a.Id, parameters[Constants.Parameters.SourceSubscriptionID], StringComparison.InvariantCultureIgnoreCase) == 0); if (subscription == null) { throw new ValidationException(string.Format(StringResources.SubscriptionIdParamException, parameters[Constants.Parameters.SourceSubscriptionID], parameters[Constants.Parameters.SourcePublishSettingsFilePath])); } } else { string thumbprint = parameters[Constants.Parameters.SourceCertificateThumbprint]; X509Certificate2 certificate = GetStoreCertificate(thumbprint); if (!certificate.HasPrivateKey) { throw new ValidationException(string.Format( StringResources.MissingPrivateKeyInCertificate, StringResources.Source, thumbprint)); } var sourceCredentials = new CertificateCloudCredentials(parameters[Constants.Parameters.SourceSubscriptionID], certificate); string sourceSubscriptionName = null; using (var client = new ManagementClient(sourceCredentials)) { BaseParameters baseParams = new BaseParameters() { RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff) }; SubscriptionGetResponse subscriptionResponse = Retry.RetryOperation(() => client.Subscriptions.Get(), baseParams, ResourceType.None); sourceSubscriptionName = subscriptionResponse.SubscriptionName; } subscription = new PublishSetting() { Id = parameters[Constants.Parameters.SourceSubscriptionID], Name = sourceSubscriptionName, ServiceUrl = new Uri(Constants.ServiceManagementUrlValue), Credentials = sourceCredentials }; } List <string> locations = ExportDataCenterLocations(subscription.Credentials, retryCount, minBackOff, maxBackOff, deltaBackOff); // Check whether SourceDc name exists in subscription bool sourceLocationNamePresent = locations.Any((l => string.Compare(l, parameters[Constants.Parameters.SourceDCName], StringComparison.CurrentCultureIgnoreCase) == 0)); if (!sourceLocationNamePresent) { throw new ValidationException(string.Format(StringResources.DCParamException, parameters[Constants.Parameters.SourceDCName])); } Logger.Info(methodName, ProgressResources.ParametersValidationCompleted); #endregion // Stores validated parameters in class. ExportParameters exportParams = new ExportParameters() { SourceDCName = parameters[Constants.Parameters.SourceDCName], ExportMetadataFolderPath = Path.Combine(parameters[Constants.Parameters.ExportMetadataFolderPath], string.Format(Constants.MetadataFileName, parameters[Constants.Parameters.SourceDCName], DateTime.Now.ToString(Constants.ExportMetadataFileNameFormat))), SourceSubscriptionSettings = subscription, RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff), GenerateMapperXml = generateMapperXmlValue, DestinationPrefixName = parameters.Keys.Contains(Constants.Parameters.DestinationPrefixName) ? parameters[Constants.Parameters.DestinationPrefixName].ToLower() : Constants.DestinationPrefixValue, }; return(exportParams); }
/// <summary> /// Validates and converts input paramters into <see cref="ImportParameters"/> class. /// </summary> /// <param name="parameters">Collection of input parameters stored in key value pairs /// <example> Operation "Import" SourceSubscriptionID "5d14d4a2-8c5a-4fc5-8d7d-86efb48b3a07" /// DestinationSubscriptionID "5d14d4a2-8c5a-4fc5-8d7d-86efb48b3a07" DestinationDCName "West US" /// SourcePublishSettingsFilePath "D:\\PublishSettings.PublishSettings" /// DestinationPublishSettingsFilePath "D:\\PublishSettings.PublishSettings" /// ImportMetadataFilePath "D:\\DataCenterMigration\mydata.json" DestinationPrefixName "dc" QuietMode "True" /// RollBackOnFailure "True" ResumeImport "True" </example> </param> /// <param name="validateForImport">True if the function will be called for imort functionality. /// False if it is called for Migrate functionality</param> /// <returns>Parameters required for import functionality</returns> internal static ImportParameters ValidateAndConvertImportParameters(IDictionary <string, string> parameters, bool validateForImport) { string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name; Logger.Info(methodName, ProgressResources.ExecutionStarted); Logger.Info(methodName, ProgressResources.ParameterValidationStarted); #region Check for missing required parameters // SourcePublishSettingsFilePath/ CertificateThumbprint if (!parameters.Keys.Contains(Constants.Parameters.SourcePublishSettingsFilePath) && !parameters.Keys.Contains(Constants.Parameters.SourceCertificateThumbprint)) { throw new ValidationException(string.Format(StringResources.MissingCredentialsFile, StringResources.Source, Constants.AppConfigArguments)); } // DestinationPublishSettingsFilePath if (!parameters.Keys.Contains(Constants.Parameters.DestinationPublishSettingsFilePath) && !parameters.Keys.Contains(Constants.Parameters.DestinationCertificateThumbprint)) { throw new ValidationException(string.Format(StringResources.MissingCredentialsFile, StringResources.Destination, Constants.AppConfigArguments)); } // SourceSubscriptionID if (!parameters.Keys.Contains(Constants.Parameters.SourceSubscriptionID)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.SourceSubscriptionID, Constants.AppConfigArguments)); } // DestinationSubscriptionID if (!parameters.Keys.Contains(Constants.Parameters.DestinationSubscriptionID)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.DestinationSubscriptionID, Constants.AppConfigArguments)); } // DestinationDCName if (!parameters.Keys.Contains(Constants.Parameters.DestinationDCName)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.DestinationDCName, Constants.AppConfigArguments)); } //DestinationPrefixName & MapperXmlFilePath. if (!validateForImport) { if (!parameters.Keys.Contains(Constants.Parameters.DestinationPrefixName)) { throw new ValidationException(string.Format(StringResources.MissingRequiredParameter, Constants.Parameters.DestinationPrefixName, Constants.AppConfigArguments)); } } else { if (!parameters.Keys.Contains(Constants.Parameters.DestinationPrefixName) && !parameters.Keys.Contains(Constants.Parameters.MapperXmlFilePath)) { throw new ValidationException(string.Format(StringResources.MissingMapperAndPrefix, StringResources.Destination, Constants.AppConfigArguments)); } } #endregion #region Check for null or empty values //SourcePublishSettingsFilePath if ((parameters.ContainsKey(Constants.Parameters.SourcePublishSettingsFilePath) && string.IsNullOrEmpty(parameters[Constants.Parameters.SourcePublishSettingsFilePath])) || (parameters.ContainsKey(Constants.Parameters.SourceCertificateThumbprint) && string.IsNullOrEmpty(parameters[Constants.Parameters.SourceCertificateThumbprint]))) { throw new ValidationException(string.Format(StringResources.MissingCredentialsFile, StringResources.Source, Constants.AppConfigArguments)); } // DestinationPublishSettingsFilePath if ((parameters.ContainsKey(Constants.Parameters.DestinationPublishSettingsFilePath) && string.IsNullOrEmpty(parameters[Constants.Parameters.DestinationPublishSettingsFilePath])) || (parameters.ContainsKey(Constants.Parameters.DestinationCertificateThumbprint) && string.IsNullOrEmpty(parameters[Constants.Parameters.DestinationCertificateThumbprint]))) { throw new ValidationException(string.Format(StringResources.MissingCredentialsFile, StringResources.Destination, Constants.AppConfigArguments)); } // ImportMetadataFilePath if (validateForImport && (string.IsNullOrEmpty(parameters[Constants.Parameters.ImportMetadataFilePath]))) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.ImportMetadataFilePath)); } // DestinationSubscriptionID if (string.IsNullOrEmpty(parameters[Constants.Parameters.DestinationSubscriptionID])) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.DestinationSubscriptionID)); } // DestinationDCName if (string.IsNullOrEmpty(parameters[Constants.Parameters.DestinationDCName])) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.DestinationDCName)); } //DestinationPrefixName & MapperXmlFilePath. if (!validateForImport) { if (string.IsNullOrEmpty(parameters[Constants.Parameters.DestinationPrefixName])) { throw new ValidationException(string.Format(StringResources.EmptyOrNullParameter, Constants.Parameters.DestinationPrefixName)); } } else { if ((parameters.ContainsKey(Constants.Parameters.DestinationPrefixName) && string.IsNullOrEmpty(parameters[Constants.Parameters.DestinationPrefixName])) || (parameters.ContainsKey(Constants.Parameters.MapperXmlFilePath) && string.IsNullOrEmpty(parameters[Constants.Parameters.MapperXmlFilePath]))) { throw new ValidationException(string.Format(StringResources.MissingMapperAndPrefix, StringResources.Destination, Constants.AppConfigArguments)); } } #endregion #region Validate parameter's value. // Validate SourcePublishSettingsFilePath if ((parameters.ContainsKey(Constants.Parameters.SourcePublishSettingsFilePath) && !File.Exists(parameters[Constants.Parameters.SourcePublishSettingsFilePath]))) { throw new ValidationException(string.Format(StringResources.InvalidParameterValue, Constants.Parameters.SourcePublishSettingsFilePath), new FileNotFoundException(StringResources.PublishSettingsFilePathParamException)); } // Validate DestinationPublishSettingsFilePath if ((parameters.ContainsKey(Constants.Parameters.DestinationPublishSettingsFilePath) && !File.Exists(parameters[Constants.Parameters.DestinationPublishSettingsFilePath]))) { throw new ValidationException(string.Format(StringResources.InvalidParameterValue, Constants.Parameters.DestinationPublishSettingsFilePath), new FileNotFoundException(StringResources.PublishSettingsFilePathParamException)); } string importMapperXmlFilePath = string.Empty; string destinationPrefix = string.Empty; // Validate MapperXmlFilePath if provided if (validateForImport && parameters.ContainsKey(Constants.Parameters.MapperXmlFilePath)) { importMapperXmlFilePath = parameters[Constants.Parameters.MapperXmlFilePath]; if (!File.Exists(importMapperXmlFilePath)) { throw new ValidationException(string.Format(StringResources.InvalidParameterValue, Constants.Parameters.MapperXmlFilePath), new FileNotFoundException(StringResources.MapperFilePathParamException)); } if (!Path.GetExtension(importMapperXmlFilePath).Equals(Constants.MapperFileExtension, StringComparison.InvariantCultureIgnoreCase)) { throw new ValidationException(string.Format(StringResources.InvalidExtensionMapperFile, Constants.Parameters.MapperXmlFilePath), new FileNotFoundException(StringResources.MapperFilePathParamException)); } } destinationPrefix = parameters.Keys.Contains(Constants.Parameters.DestinationPrefixName) ? parameters[Constants.Parameters.DestinationPrefixName].ToLower() : Constants.DestinationPrefixValue; // Validate ImportMetadataFilePath if (validateForImport) { if (!string.IsNullOrEmpty(parameters[Constants.Parameters.ImportMetadataFilePath])) { string filePath = parameters[Constants.Parameters.ImportMetadataFilePath]; if (!File.Exists(filePath)) { throw new ValidationException(string.Format(StringResources.InvalidParameterValue, Constants.Parameters.ImportMetadataFilePath), new FileNotFoundException(StringResources.ImportMetadataFilePathParamException)); } if (!Path.GetExtension(filePath).Equals(Constants.MetadataFileExtension, StringComparison.InvariantCultureIgnoreCase)) { throw new ValidationException(string.Format(StringResources.InvalidExtensionMetadataFile, Constants.Parameters.ImportMetadataFilePath), new FileNotFoundException(StringResources.ImportMetadataFilePathParamException)); } } } bool rollBackBoolValue; bool resumeImportBoolValue; int retryCount; Double minBackOff; Double maxBackOff; Double deltaBackOff; if (!parameters.Keys.Contains(Constants.Parameters.RollBackOnFailure)) { rollBackBoolValue = false; } else { bool.TryParse(parameters[Constants.Parameters.RollBackOnFailure], out rollBackBoolValue); } if (!parameters.Keys.Contains(Constants.Parameters.ResumeImport)) { resumeImportBoolValue = false; } else { bool.TryParse(parameters[Constants.Parameters.ResumeImport], out resumeImportBoolValue); } if (!parameters.Keys.Contains(Constants.Parameters.RetryCount)) { retryCount = Int32.Parse(Constants.RetryCountDefault); } else { Int32.TryParse(parameters[Constants.Parameters.RetryCount], out retryCount); } if (!parameters.Keys.Contains(Constants.Parameters.MinBackoff)) { minBackOff = Double.Parse(Constants.MinBackoffDefault); } else { Double.TryParse(parameters[Constants.Parameters.MinBackoff], out minBackOff); } if (!parameters.Keys.Contains(Constants.Parameters.MaxBackoff)) { maxBackOff = Double.Parse(Constants.MaxBackoffDefault); } else { Double.TryParse(parameters[Constants.Parameters.MaxBackoff], out maxBackOff); } if (!parameters.Keys.Contains(Constants.Parameters.DeltaBackoff)) { deltaBackOff = Double.Parse(Constants.DeltaBackoffDefault); } else { Double.TryParse(parameters[Constants.Parameters.DeltaBackoff], out deltaBackOff); } // Validate SourcePublishSettings File PublishSettings sourcePublishSettingsFile = null; PublishSetting sourceSubscription = null; if (parameters.ContainsKey(Constants.Parameters.SourcePublishSettingsFilePath)) { try { var fileContents = File.ReadAllText(parameters[Constants.Parameters.SourcePublishSettingsFilePath]); sourcePublishSettingsFile = new PublishSettings(fileContents); } catch (Exception xmlEx) { throw new ValidationException(string.Format(StringResources.XMLParsingException + " =>" + xmlEx.Message, parameters[Constants.Parameters.SourcePublishSettingsFilePath])); } // Check whether sourceSubscriptionId exists in publish settings file sourceSubscription = sourcePublishSettingsFile.Subscriptions.FirstOrDefault(a => string.Compare(a.Id, parameters[Constants.Parameters.SourceSubscriptionID], StringComparison.InvariantCultureIgnoreCase) == 0); if (sourceSubscription == null) { throw new ValidationException(string.Format(StringResources.SubscriptionIdParamException, parameters[Constants.Parameters.SourceSubscriptionID], parameters[Constants.Parameters.SourcePublishSettingsFilePath])); } } else { string thumbprint = parameters[Constants.Parameters.SourceCertificateThumbprint]; X509Certificate2 certificate = GetStoreCertificate(thumbprint); if (!certificate.HasPrivateKey) { throw new ValidationException(string.Format( StringResources.MissingPrivateKeyInCertificate, StringResources.Source, thumbprint)); } var sourceCredentials = new CertificateCloudCredentials(parameters[Constants.Parameters.SourceSubscriptionID], certificate); string sourceSubscriptionName = null; using (var client = new ManagementClient(sourceCredentials)) { BaseParameters baseParams = new BaseParameters() { RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff) }; SubscriptionGetResponse subscriptionResponse = Retry.RetryOperation(() => client.Subscriptions.Get(), baseParams, ResourceType.None); sourceSubscriptionName = subscriptionResponse.SubscriptionName; } sourceSubscription = new PublishSetting() { Id = parameters[Constants.Parameters.SourceSubscriptionID], Name = sourceSubscriptionName, ServiceUrl = new Uri(Constants.ServiceManagementUrlValue), Credentials = sourceCredentials }; } // Validate DestinationPublishSettings File PublishSettings destPublishSettingsFile = null; PublishSetting destSubscription = null; if (parameters.ContainsKey(Constants.Parameters.DestinationPublishSettingsFilePath)) { try { var fileContents = File.ReadAllText(parameters[Constants.Parameters.DestinationPublishSettingsFilePath]); destPublishSettingsFile = new PublishSettings(fileContents); } catch (Exception xmlEx) { throw new ValidationException(string.Format(StringResources.XMLParsingException + " =>" + xmlEx.Message, parameters[Constants.Parameters.DestinationPublishSettingsFilePath])); } // Check whether destSubscriptionId exists in publish settings file destSubscription = destPublishSettingsFile.Subscriptions.FirstOrDefault(a => string.Compare(a.Id, parameters[Constants.Parameters.DestinationSubscriptionID], StringComparison.InvariantCultureIgnoreCase) == 0); if (destSubscription == null) { throw new ValidationException(string.Format(StringResources.SubscriptionIdParamException, parameters[Constants.Parameters.DestinationSubscriptionID], parameters[Constants.Parameters.DestinationPublishSettingsFilePath])); } } else { string thumbprint = parameters[Constants.Parameters.DestinationCertificateThumbprint]; X509Certificate2 certificate = GetStoreCertificate(thumbprint); if (!certificate.HasPrivateKey) { throw new ValidationException(string.Format( StringResources.MissingPrivateKeyInCertificate, StringResources.Destination, thumbprint)); } var destCredentials = new CertificateCloudCredentials(parameters[Constants.Parameters.DestinationSubscriptionID], certificate); string destSubscriptionName = null; using (var client = new ManagementClient(destCredentials)) { BaseParameters baseParams = new BaseParameters() { RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff) }; SubscriptionGetResponse subscriptionResponse = Retry.RetryOperation(() => client.Subscriptions.Get(), baseParams, ResourceType.None); destSubscriptionName = subscriptionResponse.SubscriptionName; } destSubscription = new PublishSetting() { Id = parameters[Constants.Parameters.DestinationSubscriptionID], Name = destSubscriptionName, ServiceUrl = new Uri(Constants.ServiceManagementUrlValue), Credentials = destCredentials }; } // Check whether DestinationDCName exists in subscription List <string> locations = ExportDataCenterLocations(destSubscription.Credentials, retryCount, minBackOff, maxBackOff, deltaBackOff); bool destinationLocationNamePresent = locations.Any((l => string.Compare(l, parameters[Constants.Parameters.DestinationDCName], StringComparison.CurrentCultureIgnoreCase) == 0)); if (!destinationLocationNamePresent) { throw new ValidationException(string.Format(StringResources.DCParamException, parameters[Constants.Parameters.DestinationDCName])); } // Valiadte DestinationPrefixName if (parameters.ContainsKey(Constants.Parameters.DestinationPrefixName) && (parameters[Constants.Parameters.DestinationPrefixName].Length < 1 || parameters[Constants.Parameters.DestinationPrefixName].Length > 5)) { throw new ValidationException(string.Format(StringResources.InvalidDestinationPrefixName, parameters[Constants.Parameters.DestinationPrefixName])); } #endregion // Stores validated parameters in class. ImportParameters importParams = new ImportParameters() { DestinationDCName = parameters[Constants.Parameters.DestinationDCName], ImportMetadataFilePath = (!validateForImport) ? null : parameters[Constants.Parameters.ImportMetadataFilePath], MapperXmlFilePath = importMapperXmlFilePath, DestinationPrefixName = destinationPrefix, DestinationSubscriptionSettings = destSubscription, RollBackOnFailure = rollBackBoolValue, ResumeImport = resumeImportBoolValue, RetryCount = retryCount, MinBackOff = TimeSpan.FromSeconds(minBackOff), MaxBackOff = TimeSpan.FromSeconds(maxBackOff), DeltaBackOff = TimeSpan.FromSeconds(deltaBackOff), SourceSubscriptionSettings = sourceSubscription }; Logger.Info(methodName, ProgressResources.ParametersValidationCompleted); return(importParams); }