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();
}