private static HttpStatusCode UploadNewManagementCert(string subscriptionId, X509Certificate2 existingCertificate, string newCertificateCerFilePath) { var statusCode = HttpStatusCode.Unused; var newCertificate = new X509Certificate2(newCertificateCerFilePath); var creds = new CertificateCloudCredentials(subscriptionId, existingCertificate); var client = new ManagementClient(creds); var parm = new ManagementCertificateCreateParameters() { Data = newCertificate.RawData, PublicKey = newCertificate.GetPublicKey(), Thumbprint = newCertificate.Thumbprint }; //Hyak throws an exception for a Created result, which is actually the success code try { var response = client.ManagementCertificates.Create(parm); } catch (CloudException ex) { statusCode = ex.Response.StatusCode; } return statusCode; }
public AzureController() { base64EncodedCertificate = sc.GetValue("base64EncodedCertificate"); subscriptionId = sc.GetValue("subscriptionId"); relatedStorageAccountName = sc.GetValue("relatedStorageAccountName"); cloudCredentials = new CertificateCloudCredentials(subscriptionId, new System.Security.Cryptography.X509Certificates.X509Certificate2(Convert.FromBase64String(base64EncodedCertificate))); }
public override void ExecuteCommand() { var cred = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate); var csman = CloudContext.Clients.CreateCloudServiceManagementClient(cred); var svcs = csman.CloudServices.ListAsync(CancellationToken.None).Result; foreach (var svc in svcs) { Log.Info("* {0} ({1}): {2}", svc.Name, svc.GeoRegion, svc.Description); } }
public CloudServiceController() { this.token = new CancellationTokenSource(); this.subscriptionId = ConfigurationManager.AppSettings["SubscriptionId"]; var certificateString = ConfigurationManager.AppSettings["SubscriptionCertificate"]; this.certificate = new X509Certificate2(Convert.FromBase64String(certificateString), ""); //This line will not work in a Azure Website, as it requires access to the certificate store. var cred = new CertificateCloudCredentials(subscriptionId, certificate); this.client = CloudContext.Clients.CreateComputeManagementClient(cred); this.storageAccount = CloudStorageAccount.Parse(ConfigurationManager.AppSettings["DataConnectionString"]); this.blobClient = storageAccount.CreateCloudBlobClient(); }
public static CertificateCloudCredentials GetCredentials() { //Create a new instance of the X509 certificate X509Certificate2 cert = new X509Certificate2( Program.CERT_PATH); //Pass your subscription id and the certificate to the CertificateCloudCredentials //class constructor CertificateCloudCredentials creds = new CertificateCloudCredentials( Program.SUBS_ID, cert); return creds; }
public override void ExecuteCommand() { var cred = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate); var csman = CloudContext.Clients.CreateCloudServiceManagementClient(cred); var result = csman.CloudServices.CreateAsync( Arguments[0], new CloudServiceCreateParameters() { Label = Label, GeoRegion = Region, Email = Email, Description = Description }, CancellationToken.None).Result; Log.Info("Created Cloud Service {0}", Arguments[0]); }
/// <summary> /// Create the storage account /// </summary> /// <param name="credentials"></param> private static void CreateStorageAccountOLD(CertificateCloudCredentials credentials) { //var storageClient = CloudContext.Clients.CreateStorageManagementClient(credentials); //var response = storageClient.StorageAccounts.Create(new StorageAccountCreateParameters() //{ // Location = LocationNames.NorthEurope, // Name = "ninostorage2", // Description = "storage from code", // AccountType = StorageAccountTypes.StandardGRS //}); //Console.WriteLine(response.StatusCode); }
private static X509Certificate2 GetExistingManagementCertificate(string subscriptionId) { var certStore = new X509Store(StoreName.My, StoreLocation.CurrentUser); certStore.Open(OpenFlags.ReadOnly); var azureCerts = certStore.Certificates.Find(X509FindType.FindByIssuerName, "Windows Azure Tools", false); foreach (var cert in azureCerts) { var creds = new CertificateCloudCredentials(subscriptionId, cert); var client = new ManagementClient(creds); try { var v = client.Locations.List(); return cert; } catch (CloudException) { } } return null; }
public override void ExecuteCommand() { var cred = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate); var schman = CloudContext.Clients.CreateSchedulerManagementClient(cred); var createParams = new JobCollectionCreateParameters() { Label = Label, IntrinsicSettings = new JobCollectionIntrinsicSettings() { Plan = Plan, Quota = new JobCollectionQuota() { MaxJobCount = MaxJobCount, MaxJobOccurrence = MaxJobOccurrence, MaxRecurrence = MaxRecurrenceFrequency.HasValue ? new JobCollectionMaxRecurrence() { Frequency = MaxRecurrenceFrequency.Value, Interval = MaxRecurrenceInterval.Value } : null } } }; if (WhatIf) { Log.Info("Would create job collection {0} in {1} with the following params:", Arguments[0], CloudService); Log.Info(JsonConvert.SerializeObject(createParams, new StringEnumConverter())); } else { Log.Info("Creating job collection {0} in {1}...", Arguments[0], CloudService); schman.JobCollections.CreateAsync( CloudService, Arguments[0], createParams, CancellationToken.None).Wait(); } }
public int Run() { // Obtain management via .publishsettings file from https://manage.windowsazure.com/publishsettings/index?schemaversion=2.0 var creds = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate); // Create Namespace var sbMgmt = new ServiceBusManagementClient(creds); ServiceBusNamespaceResponse nsResponse = null; Console.WriteLine("Creating Service Bus namespace {0} in location {1}", SBNamespace, Location); try { var resultSb = sbMgmt.Namespaces.Create(SBNamespace, Location); if (resultSb.StatusCode != System.Net.HttpStatusCode.OK) { Console.WriteLine("Error creating Service Bus namespace {0} in Location {1}: {2}", SBNamespace, Location, resultSb.StatusCode); return 1; } } catch (CloudException) { try { // There is (currently) no clean error code returned when the namespace already exists // Check if it does nsResponse = sbMgmt.Namespaces.Get(SBNamespace); Console.WriteLine("Service Bus namespace {0} already existed.", SBNamespace); } catch (Exception) { nsResponse = null; } if (nsResponse == null) { throw; } } // Wait until the namespace is active while (nsResponse == null || nsResponse.Namespace.Status != "Active") { nsResponse = sbMgmt.Namespaces.Get(SBNamespace); if (nsResponse.Namespace.Status == "Active") { break; } Console.WriteLine("Namespace {0} in state {1}. Waiting...", SBNamespace, nsResponse.Namespace.Status); System.Threading.Thread.Sleep(5000); } // Get the namespace connection string var nsDescription = sbMgmt.Namespaces.GetNamespaceDescription(SBNamespace); var nsConnectionString = nsDescription.NamespaceDescriptions.First( (d) => String.Equals(d.AuthorizationType, "SharedAccessAuthorization") ).ConnectionString; // Create EHs + device keys + consumer keys (WebSite*) var nsManager = NamespaceManager.CreateFromConnectionString(nsConnectionString); var ehDescriptionDevices = new EventHubDescription(EventHubNameDevices) { PartitionCount = 8, }; ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D1", new List<AccessRights> { AccessRights.Send })); ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D2", new List<AccessRights> { AccessRights.Send })); ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D3", new List<AccessRights> { AccessRights.Send })); ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("D4", new List<AccessRights> { AccessRights.Send })); ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("WebSite", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send })); ehDescriptionDevices.Authorization.Add(new SharedAccessAuthorizationRule("StreamingAnalytics", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send })); Console.WriteLine("Creating Event Hub {0}", EventHubNameDevices); EventHubDescription ehDevices = null; do { try { ehDevices = nsManager.CreateEventHubIfNotExists(ehDescriptionDevices); } catch (System.UnauthorizedAccessException) { Console.WriteLine("Service Bus connection string not valid yet. Waiting..."); System.Threading.Thread.Sleep(5000); } } while (ehDevices == null); var ehDescriptionAlerts = new EventHubDescription(EventHubNameAlerts) { PartitionCount = 8, }; ehDescriptionAlerts.Authorization.Add(new SharedAccessAuthorizationRule("WebSite", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send })); ehDescriptionAlerts.Authorization.Add(new SharedAccessAuthorizationRule("StreamingAnalytics", new List<AccessRights> { AccessRights.Manage, AccessRights.Listen, AccessRights.Send })); Console.WriteLine("Creating Event Hub {0}", EventHubNameAlerts); var ehAlerts = nsManager.CreateEventHubIfNotExists(ehDescriptionAlerts); // Create Storage Account for Event Hub Processor var stgMgmt = new StorageManagementClient(creds); try { Console.WriteLine("Creating Storage Account {0} in location {1}", StorageAccountName, Location); var resultStg = stgMgmt.StorageAccounts.Create( new StorageAccountCreateParameters { Name = StorageAccountName.ToLowerInvariant(), Location = Location, AccountType = "Standard_LRS" }); if (resultStg.StatusCode != System.Net.HttpStatusCode.OK) { Console.WriteLine("Error creating storage account {0} in Location {1}: {2}", StorageAccountName, Location, resultStg.StatusCode); return 1; } } catch (CloudException ce) { if (String.Equals(ce.ErrorCode, "ConflictError", StringComparison.InvariantCultureIgnoreCase)) { Console.WriteLine("Storage account {0} already existed.", StorageAccountName); } else { throw; } } var keyResponse = stgMgmt.StorageAccounts.GetKeys(StorageAccountName.ToLowerInvariant()); if (keyResponse.StatusCode != System.Net.HttpStatusCode.OK) { Console.WriteLine("Error retrieving access keys for storage account {0} in Location {1}: {2}", StorageAccountName, Location, keyResponse.StatusCode); return 1; } var storageKey = keyResponse.PrimaryKey; string ehDevicesWebSiteConnectionString = new ServiceBusConnectionStringBuilder(nsConnectionString) { SharedAccessKeyName = "WebSite", SharedAccessKey = (ehDevices.Authorization.First((d) => String.Equals(d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey, }.ToString(); string ehAlertsWebSiteConnectionString = new ServiceBusConnectionStringBuilder(nsConnectionString) { SharedAccessKeyName = "WebSite", SharedAccessKey = (ehAlerts.Authorization.First((d) => String.Equals(d.KeyName, "WebSite", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey, }.ToString(); // Write a new web.config template file var doc = new XmlDocument(); doc.PreserveWhitespace = true; var inputFileName = (this.Transform ? "\\web.PublishTemplate.config" : "\\web.config"); var outputFileName = (this.Transform ? String.Format("\\web.{0}.config", NamePrefix) : "\\web.config"); doc.Load(WebSiteDirectory + inputFileName); doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubDevices']/@value").Value = EventHubNameDevices; doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.EventHubAlerts']/@value").Value = EventHubNameAlerts; doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionString']/@value").Value = nsConnectionString; doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringDevices']/@value").Value = ehDevicesWebSiteConnectionString; doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.ServiceBus.ConnectionStringAlerts']/@value").Value = ehAlertsWebSiteConnectionString; doc.SelectSingleNode("/configuration/appSettings/add[@key='Microsoft.Storage.ConnectionString']/@value").Value = String.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", StorageAccountName, storageKey); var outputFile = System.IO.Path.GetFullPath(WebSiteDirectory + outputFileName); doc.Save(outputFile); Console.WriteLine(); Console.WriteLine("Service Bus management connection string (i.e. for use in Service Bus Explorer):"); Console.WriteLine(nsConnectionString); Console.WriteLine(); Console.WriteLine("Device AMQP address strings (for Raspberry PI/devices):"); for (int i = 1; i <= 4; i++) { var deviceKeyName = String.Format("D{0}", i); var deviceKey = (ehDevices.Authorization.First((d) => String.Equals(d.KeyName, deviceKeyName, StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey; Console.WriteLine("amqps://{0}:{1}@{2}.servicebus.windows.net", deviceKeyName, Uri.EscapeDataString(deviceKey), SBNamespace); //Console.WriteLine(new ServiceBusConnectionStringBuilder(nsConnectionString) //{ // SharedAccessKeyName = deviceKeyName, // SharedAccessKey = deviceKey, //}.ToString()); } Console.WriteLine(); Console.WriteLine("Web.Config saved to {0}", outputFile); #if AZURESTREAMANALYTICS // Create StreamAnalyticsJobs + inputs + outputs + enter keys // Untested code. May require AAD authentication, no support for management cert? // Create Resource Group for the Stream Analytics jobs var groupCreateRequest = WebRequest.Create(String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}?api-version=2014-04-01-preview", SubscriptionId, StreamAnalyticsGroup)) as HttpWebRequest; groupCreateRequest.ClientCertificates.Add(creds.ManagementCertificate); groupCreateRequest.ContentType = "application/json"; groupCreateRequest.Method = "PUT"; groupCreateRequest.KeepAlive = true; var bytesGroup = Encoding.UTF8.GetBytes("{\"location\":\"Central US\"}"); groupCreateRequest.ContentLength = bytesGroup.Length; groupCreateRequest.GetRequestStream().Write(bytesGroup, 0, bytesGroup.Length); var groupCreateResponse = groupCreateRequest.GetResponse(); //var streamMgmt = new ManagementClient(creds); //, new Uri("https://management.azure.com")); //HttpClient client = streamMgmt.HttpClient; var createJob = new StreamAnalyticsJob() { location = Location, inputs = new List<StreamAnalyticsEntity> { new StreamAnalyticsEntity { name = "devicesInput", properties = new Dictionary<string,object> { { "type" , "stream" }, { "serialization" , new Dictionary<string,object> { { "type", "JSON"}, { "properties", new Dictionary<string, object> { { "encoding", "UTF8"}, } } } }, { "datasource", new Dictionary<string,object> { { "type", "Microsoft.ServiceBus/EventHub" }, { "properties", new Dictionary<string,object> { { "eventHubNamespace", Namespace }, { "eventHubName", EventHubDevices }, { "sharedAccessPolicyName", "StreamingAnalytics" }, { "sharedAccessPolicyKey", (ehDevices.Authorization.First( (d) => String.Equals(d.KeyName, "StreamingAnalytics", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey }, } } } } }, }, }, transformation = new StreamAnalyticsEntity() { name = "Aggregates", properties = new Dictionary<string,object> { { "streamingUnits", 1 }, { "query" , "select * from devicesInput" }, } }, outputs = new List<StreamAnalyticsEntity> { new StreamAnalyticsEntity { name = "output", properties = new Dictionary<string,object> { { "datasource", new Dictionary<string,object> { { "type", "Microsoft.ServiceBus/EventHub" }, { "properties", new Dictionary<string,object> { { "eventHubNamespace", Namespace }, { "eventHubName", EventHubAlerts }, { "sharedAccessPolicyName", "StreamingAnalytics" }, { "sharedAccessPolicyKey", (ehAlerts.Authorization.First( (d) => String.Equals(d.KeyName, "StreamingAnalytics", StringComparison.InvariantCultureIgnoreCase)) as SharedAccessAuthorizationRule).PrimaryKey }, } } } }, { "serialization" , new Dictionary<string,object> { { "type", "JSON"}, { "properties", new Dictionary<string, object> { { "encoding", "UTF8"}, } } } }, }, }, } }; var jobCreateRequest = WebRequest.Create(String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}/Microsoft.StreamAnalytics/streamingjobs/{2}?api-version=2014-10-01", SubscriptionId, StreamAnalyticsGroup, JobAggregates)) as HttpWebRequest; jobCreateRequest.ClientCertificates.Add(creds.ManagementCertificate); jobCreateRequest.ContentType = "application/json"; jobCreateRequest.Method = "PUT"; jobCreateRequest.KeepAlive = true; var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(createJob)); jobCreateRequest.ContentLength = bytes.Length; jobCreateRequest.GetRequestStream().Write(bytes, 0, bytes.Length); var jobCreateResponse = jobCreateRequest.GetResponse(); //var jobCreateTask = streamMgmt.HttpClient.PutAsync( // String.Format("https://management.azure.com/subscriptions/{0}/resourcegroups/{1}/Microsoft.StreamAnalytics/streamingjobs/{2}?api-version=2014-10-01", // SubscriptionId, StreamAnalyticsGroup, JobAggregates), // new StringContent(JsonConvert.SerializeObject(createJob))); //jobCreateTask.Wait(); //var jobCreateResponse = jobCreateTask.Result; #endif return 0; }
public AzureCloudServicesClient(AzureManagementRestClient client, CertificateCloudCredentials credentials) { _azureCloudServiceInfoClient = new AzureCloudServiceInfoApiClient(client); _azureMetricsApiClient = new AzureCloudServiceMetricsApiClient(new AzureMetricsApiClient(credentials)); }
private static AzureManagementRestClient GetClient(CertificateCloudCredentials credentials) { return new AzureManagementRestClient(credentials); }
public static SubscriptionCloudCredentials GetManagementCredentials() { var subscriptionID = ConfigurationManager.AppSettings["AzureSubscriptionID"]; var creds = new CertificateCloudCredentials(subscriptionID, GetCertificate()); return creds; }
public AzureWebsitesUsageClient(AzureManagementRestClient client, CertificateCloudCredentials credentials) { var azureWebsiteApiClient = new AzureWebsiteApiClient(client); _azureWebsitesInfoClient = new AzureWebsitesInfoApiClient(azureWebsiteApiClient); _azureWebsitesMetricsClient = new AzureWebsitesMetricsApiClient(azureWebsiteApiClient); _metricsApiClient = new AzureMetricsApiClient(credentials); }
public AzureMetricsApiClient(CertificateCloudCredentials credentials) { _credentials = credentials; }
public AzureUsageClient(MetricsEndpointConfiguration config) { _credentials = config.GetCertificateCloudCredentials(); _client = GetClient(config.GetCertificateCloudCredentials()); }
/// <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; }
/// <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; }
static void Main(string[] args) { //var token = GetAuthorizationHeader(); //var credential = new TokenCloudCredentials( // "ed0caab7-c6d4-45e9-9289-c7e5997c9241", token); // CreateVM(credential); #region var x509Certificate2 = new X509Certificate2(@"D:/aktest.cer"); CertificateCloudCredentials cer = new CertificateCloudCredentials("ed0caab7-c6d4-45e9-9289-c7e5997c9241", x509Certificate2); // CreateResources(credential); //var storageClient=CloudContext.Clients.CreateStorageManagementClient(cer); //storageClient.StorageAccounts.Create(new StorageAccountCreateParameters //{ // AccountType= "Standard_LRS", // // GeoReplicationEnabled = false, // Label = "Sample Storage Account", // Location = "East US", // Name = "mbjastorage" //}); var windowsConfigSet = new ConfigurationSet { ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration, AdminPassword = "******", AdminUserName = "******", ComputerName = "libraryvm01", HostName = string.Format("{0}.cloudapp.net", "libraryvm01") }; var vmClient = CloudContext.Clients.CreateComputeManagementClient(cer); var operatingSystemImageListResult = vmClient.VirtualMachineOSImages.List(); var imageName = operatingSystemImageListResult.Images.FirstOrDefault( x => x.Label.Contains( "SQL Server 2014 RTM Standard on Windows Server 2012 R2")).Name; var networkConfigSet = new ConfigurationSet { ConfigurationSetType = "NetworkConfiguration", InputEndpoints = new List<InputEndpoint> { new InputEndpoint { Name = "PowerShell", LocalPort = 5986, Protocol = "tcp", Port = 5986, }, new InputEndpoint { Name = "Remote Desktop", LocalPort = 3389, Protocol = "tcp", Port = 3389, } } }; var vhd = new OSVirtualHardDisk { SourceImageName = imageName, HostCaching = VirtualHardDiskHostCaching.ReadWrite, MediaLink = new Uri(string.Format( "https://{0}.blob.core.windows.net/vhds/{1}.vhd", "willshao", imageName)) }; var deploymentAttributes = new Role { RoleName = "libraryvm01", RoleSize = VirtualMachineRoleSize.Small, RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(), OSVirtualHardDisk = vhd, ConfigurationSets = new List<ConfigurationSet> { windowsConfigSet, networkConfigSet }, ProvisionGuestAgent = true }; var createDeploymentParameters = new VirtualMachineCreateDeploymentParameters { Name = "libraryvm01", Label = "libraryvm01", DeploymentSlot = DeploymentSlot.Production, Roles = new List<Role> { deploymentAttributes } }; try { var mymachine= vmClient.VirtualMachines.Get("javmtest", "javmtest", "javmtest"); vmClient.VirtualMachines.CreateDeploymentAsync( "libraryvm01", createDeploymentParameters); } catch (Exception e) { } #endregion Console.ReadLine(); }