private static void Main(string[] args)
{
_subscriptionId = args[0];
_thumbprint = args[1];
_alertEmailAddress = args[2];
_cloudServiceName = args[3];
_deploymentName = args[4];
SubscriptionCloudCredentials credentials = new CertificateCloudCredentials(_subscriptionId,
GetStoreCertificate(_thumbprint));
var metricsClient = new MetricsClient(credentials);
var resourceId = ResourceIdBuilder.BuildCloudServiceResourceId(_cloudServiceName, _deploymentName);
Console.WriteLine("Resource Id: {0}", resourceId);
GetMetricDefinitions(metricsClient, resourceId);
var alertsClient = new AlertsClient(credentials);
DisplayAzureAlertRules(alertsClient);
var response = CreateAzureAlert(resourceId, alertsClient);
Console.WriteLine("Create alert rule response: " + response.Result.StatusCode);
Console.ReadLine();
}
public AzureScheduler(X509Certificate2 subscriptionCertificate, string subscriptionId,
string cloudServiceName, string jobCollectionName)
{
cloudCredentials = new CertificateCloudCredentials(subscriptionId, subscriptionCertificate);
this.cloudServiceName = cloudServiceName;
this.jobCollectionName = jobCollectionName;
}
/// <summary>
/// Processes the Push-CloudServices commandlet synchronously.
/// </summary>
protected override void ProcessRecord()
{
var azureSubscription = new AzureSubscription(SettingsPath, SubscriptionId);
var azureCert = new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate));
var credentials = new CertificateCloudCredentials(SubscriptionId, azureCert);
FlexStreams.UseThreadQueue(ThreadAdapter);
using (EventStream.Subscribe(e => WriteObject(e.Message)))
using (var computeClient = new ComputeManagementClient(credentials))
using (var storageClient = new StorageManagementClient(credentials))
{
var targetSlot = VipSwap ? DeploymentSlot.Staging : DeploymentSlot.Production;
var storageAccount = storageClient.CreateContainerIfNotExistsAsync(
StorageAccountName,
StorageContainer,
BlobContainerPublicAccessType.Off, SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.List).Result;
var blobClient = storageAccount.CreateCloudBlobClient();
var container = blobClient.GetContainerReference(StorageContainer);
ProcessAsyncWork(ServiceNames.Select((t, i) => DeployCloudServiceAsync(computeClient, container, t, PackagePaths[i], ConfigurationPaths[i], DiagnosticsConfigurationPaths?[i], targetSlot))
.ToArray());
}
WriteObject("Push-CloudServices completed!");
base.ProcessRecord();
}
public string SetVm(Subscription Subscription, string VmName, bool SetToRunning)
{
CertificateCloudCredentials creds = this.GetCredentials(Subscription);
using (ComputeManagementClient vmClient = new ComputeManagementClient(creds)) {
// No idea why it wants the same name again and again or when this name would not be the same
DeploymentGetResponse response = vmClient.Deployments.GetByName(VmName, VmName);
if (response.Status != DeploymentStatus.Running && SetToRunning)
{
// Start it
vmClient.VirtualMachines.Start(VmName, VmName, VmName);
}
if (response.Status == DeploymentStatus.Running && !SetToRunning)
{
// Stop it
vmClient.VirtualMachines.Shutdown(
VmName, VmName, VmName,
new VirtualMachineShutdownParameters {
PostShutdownAction = PostShutdownAction.StoppedDeallocated
}
);
}
// What is it now?
response = vmClient.Deployments.GetByName(VmName, VmName);
return(response.Status.ToString());
}
}
public List <AzureInfo> GetServers(Subscription Subscription)
{
List <AzureInfo> results = new List <AzureInfo>();
CertificateCloudCredentials creds = this.GetCredentials(Subscription);
using (ComputeManagementClient vmClient = new ComputeManagementClient(creds)) {
List <HostedServiceListResponse.HostedService> vms = vmClient.HostedServices.List().ToList();
results.AddRange(
from vm in vms
let vmDetails = vmClient.Deployments.GetByName(vm.ServiceName, vm.ServiceName)
let vmController = vmClient.VirtualMachines.Get(vm.ServiceName, vm.ServiceName, vm.ServiceName)
select new AzureInfo {
SubscriptionId = Subscription.SubscriptionId,
Name = vm.ServiceName,
Status = vmDetails.Status.ToString(),
Location = vm.Properties.Location,
Size = vmController.RoleSize,
Online = vmDetails.Status == DeploymentStatus.Running
}
);
}
return(results);
}
public BatchManagementClient GetBatchManagementClient(RecordedDelegatingHandler handler)
{
var certCreds = new CertificateCloudCredentials(Guid.NewGuid().ToString(), new System.Security.Cryptography.X509Certificates.X509Certificate2());
handler.IsPassThrough = false;
return(new BatchManagementClient(certCreds).WithHandler(handler));
}
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);
}
/// <summary>
/// Get the test environment from a connection string specifying a certificate
/// </summary>
/// <param name="testConnectionString">The connetcion string to parse</param>
/// <returns>The test environment from parsing the connection string.</returns>
protected virtual TestEnvironment GetCertificateTestEnvironmentFromConnectionString(string testConnectionString)
{
IDictionary <string, string> connections = ParseConnectionString(testConnectionString);
string certificateReference = connections[ManagementCertificateKey];
string subscriptionId = connections[SubscriptionIdKey];
Assert.IsNotNull(certificateReference);
X509Certificate2 managementCertificate;
if (IsCertificateReference(certificateReference))
{
managementCertificate = GetCertificateFromReference(certificateReference);
}
else
{
managementCertificate = GetCertificateFromBase64String(certificateReference);
}
CertificateCloudCredentials credentials = new CertificateCloudCredentials(subscriptionId, managementCertificate);
TestEnvironment currentEnvironment = new TestEnvironment {
Credentials = credentials
};
if (connections.ContainsKey(BaseUriKey))
{
currentEnvironment.BaseUri = new Uri(connections[BaseUriKey]);
}
return(currentEnvironment);
}
public static SubscriptionCloudCredentials GetCredentialsByPublishSettingFile(string fileName)
{
var doc = new XmlDocument( );
doc.Load(fileName);
var certNode = doc.SelectSingleNode("/PublishData/PublishProfile/@ManagementCertificate");
// Some publishsettings files (with multiple subscriptions?) have the management publisherCertificate under the Subscription
if (certNode == null)
{
certNode =
doc.SelectSingleNode(
"/PublishData/PublishProfile/Subscription/@ManagementCertificate");
}
X509Certificate2 ManagementCertificate = new X509Certificate2(Convert.FromBase64String(certNode.Value));
var subNode =
doc.SelectSingleNode("/PublishData/PublishProfile/Subscription/@Id");
string SubscriptionId = subNode.Value;
// Obtain management via .publishsettings file from https://manage.windowsazure.com/publishsettings/index?schemaversion=2.0
CertificateCloudCredentials creds = new CertificateCloudCredentials(SubscriptionId, ManagementCertificate);
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 AzureManagementService(string subscriptionId, string base64Certificate)
{
cloudCredentials = new CertificateCloudCredentials(
subscriptionId,
new X509Certificate2(Convert.FromBase64String(base64Certificate)));
storageClient = CloudContext.Clients.CreateStorageManagementClient(cloudCredentials);
computeClient = CloudContext.Clients.CreateComputeManagementClient(cloudCredentials);
}
public static void CreateVMSteps(string message, TextWriter log)
{
RootCreateVMObject r = JsonConvert.DeserializeObject <RootCreateVMObject>(message);
log.WriteLine("Received message to deploy {0}", r.createvm.Service.ServiceName);
// get the subscription details from configuration
Subscription sub = Subscriptions.Instance.Get(r.createvm.SubscriptionName);
if (sub == null)
{
string msg = string.Format("Subscription name {0} not found in configuration file.", r.createvm.SubscriptionName);
Common.LogExit(msg, r.createvm.Service.ServiceName, log);
return;
}
// create credentials object based on management certificate
CertificateCloudCredentials creds = new CertificateCloudCredentials(sub.SubscriptionId, sub.MgtCertificate);
// see if the cloud service already exists
bool nameIsAvailable = Common.CheckServiceNameAvailability(r.createvm.Service.ServiceName, creds);
// if not and create if not exists, create it.
if (nameIsAvailable && r.createvm.Service.CreateServiceIfNotExist)
{
log.WriteLine("Creating hosted service: {0}", r.createvm.Service.ServiceName);
HttpStatusCode code = Common.CreateService(creds, r, sub, log);
log.WriteLine("Code returned from CreateService: {0}", code.ToString());
}
bool deploymentExists = DeploymentExists(creds, r, sub, log);
string requestId = null;
if (deploymentExists)
{
requestId = CreateVM(creds, r, sub, log);
}
else
{
requestId = CreateDeployment(creds, r, sub, log);
}
if (string.IsNullOrEmpty(requestId))
{
string msg = string.Format("Creation of VM on service {0} did not succeed.", r.createvm.Service.ServiceName);
string consoleMsg = string.Format("Creation of VM on service {0} failed. Check the log for details.", r.createvm.Service.ServiceName);
Common.LogExit(msg, consoleMsg, r.createvm.Service.ServiceName, log);
return;
}
else
{
string msg = string.Format("Creation of VM on service {0} succeeded with request ID: {1}.", r.createvm.Service.ServiceName, requestId);
string consoleMsg = string.Format("Creation of VM on service {0} succeeded. Check the log for details.", r.createvm.Service.ServiceName);
Common.LogSuccess(msg, consoleMsg, r.createvm.Service.ServiceName, log);
return;
}
}
public ScalingAgent(string subscriptionID, string subscriptionManagementCertificateThumbprint, StoreLocation storeLocation)
{
X509Certificate2 managementCert = subscriptionManagementCertificateThumbprint.FindX509CertificateByThumbprint(storeLocation);
SubscriptionCloudCredentials creds = new CertificateCloudCredentials(subscriptionID, managementCert);
this.computeManagementClient = CloudContext.Clients.CreateComputeManagementClient(creds);
this.storageManagementClient = CloudContext.Clients.CreateStorageManagementClient(creds);
this.cloudServiceManagementClient = CloudContext.Clients.CreateCloudServiceManagementClient(creds);
this.managementClient = CloudContext.Clients.CreateManagementClient(creds);
}
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 ScheduledAutoTestApi(string subscriptionId, X509Certificate2 managementCertificate, IQueue queue, string jobCollectionName, string storageAccountName, string sasToken, int minutesToKeepInCache)
{
var credentials = new CertificateCloudCredentials(subscriptionId, managementCertificate);
_schedulerClient = new SchedulerClient(CloudService, jobCollectionName, credentials);
_queue = queue;
_storageAccountName = storageAccountName;
_sasToken = sasToken;
_minutesToKeepInCache = minutesToKeepInCache;
_needRefresh = false;
}
public static ExpressRouteManagementClient GetProviderExpressRouteManagementClient()
{
string managementCertificate = "";
string baseUri;
string subscriptionId;
if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
baseUri = HttpMockServer.Variables["TEST_PROVIDER_BASE_URI"];
subscriptionId = HttpMockServer.Variables["TEST_PROVIDER_SUBSCRIPTION_ID"];
managementCertificate = HttpMockServer.Variables["TEST_PROVIDER_MANAGEMENT_CERTIFICATE"];
}
else
{
string publishSettingsFile = Environment.GetEnvironmentVariable("TEST_PUBLISHSETTINGS_FILE_P");
if (string.IsNullOrEmpty(publishSettingsFile))
{
// Take default path
publishSettingsFile = @"C:\Powershell\PublishSettings\defaultProvider.publishsettings";
}
PublishData publishData = XmlSerializationHelpers.DeserializeXmlFile <PublishData>(publishSettingsFile);
managementCertificate = Enumerable.First <PublishDataPublishProfile>((IEnumerable <PublishDataPublishProfile>)publishData.Items).ManagementCertificate;
if (string.IsNullOrEmpty(managementCertificate))
{
managementCertificate = Enumerable.First <PublishDataPublishProfileSubscription>((IEnumerable <PublishDataPublishProfileSubscription>)Enumerable.First <PublishDataPublishProfile>((IEnumerable <PublishDataPublishProfile>)publishData.Items).Subscription).ManagementCertificate;
}
if (string.IsNullOrEmpty(managementCertificate))
{
throw new ArgumentException(string.Format("{0} is not a valid publish settings file, you must provide a valid publish settings file in the environment variable {1}", (object)publishSettingsFile, (object)"TEST_PROVIDER_PUBLISHSETTINGS_FILE"));
}
subscriptionId = Enumerable.First <PublishDataPublishProfileSubscription>((IEnumerable <PublishDataPublishProfileSubscription>)Enumerable.First <PublishDataPublishProfile>((IEnumerable <PublishDataPublishProfile>)publishData.Items).Subscription).Id;
baseUri = Enumerable.First <PublishDataPublishProfileSubscription>(
(IEnumerable <PublishDataPublishProfileSubscription>)
Enumerable.First <PublishDataPublishProfile>(
(IEnumerable <PublishDataPublishProfile>)publishData.Items).Subscription)
.ServiceManagementUrl ?? publishData.Items[0].Url;
HttpMockServer.Variables["TEST_PROVIDER_MANAGEMENT_CERTIFICATE"] = managementCertificate;
HttpMockServer.Variables["TEST_PROVIDER_SUBSCRIPTION_ID"] = subscriptionId;
HttpMockServer.Variables["TEST_PROVIDER_BASE_URI"] = baseUri;
}
var credentials = new CertificateCloudCredentials(subscriptionId, new X509Certificate2(Convert.FromBase64String(managementCertificate), string.Empty));
var client = new ExpressRouteManagementClient(credentials, new Uri(baseUri));
client.AddHandlerToPipeline(HttpMockServer.CreateInstance());
return(client);
}
public void ManagementClientReturnsLocationList()
{
// Import certificate
CertificateEnrollmentManager.ImportPfxDataAsync(_certificateString, _certificatePassword, ExportOption.NotExportable,
KeyProtectionLevel.NoConsent, InstallOptions.None,
"test").AsTask().Wait();
var credentials = new CertificateCloudCredentials(_subscription);
var client = new ManagementClient(credentials);
var result = client.Locations.List();
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.IsTrue(result.Locations.Count > 0);
}
public void ManagementClientReturnsLocationList()
{
// Import certificate
CertificateEnrollmentManager.ImportPfxDataAsync(_certificateString, _certificatePassword, ExportOption.NotExportable,
KeyProtectionLevel.NoConsent, InstallOptions.None,
"test").AsTask().Wait();
var credentials = new CertificateCloudCredentials(_subscription);
var client = new ManagementClient(credentials);
var result = client.Locations.List();
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.IsTrue(result.Locations.Count > 0);
}
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]);
}
public VMManagement(string subscriptionId, byte[] managementCertificate,
string certificateKey, string blobStorageName, string blobStorageKey, ILogger logger)
{
_managementCertificate = new X509Certificate2(managementCertificate, certificateKey, X509KeyStorageFlags.MachineKeySet);
_subscriptionId = subscriptionId;
CertificateCloudCredentials cloudCredentials = new CertificateCloudCredentials(_subscriptionId, _managementCertificate);
_datacenter = new ManagementClient(cloudCredentials);// CloudContext.Clients.CreateManagementClient(cloudCredentials);
//var roleSizes = _datacenter.RoleSizes.List();
_compute = new ComputeManagementClient(cloudCredentials);// CloudContext.Clients.CreateComputeManagementClient(cloudCredentials);
_storage = new StorageManagementClient(cloudCredentials);// CloudContext.Clients.CreateStorageManagementClient(cloudCredentials);
}
public static void StartRolesSteps(string message, TextWriter log)
{
RootStartVMsObject r = JsonConvert.DeserializeObject <RootStartVMsObject>(message);
log.WriteLine("Received message to start VM(s) on service {0}", r.startvms.Service.ServiceName);
// get the subscription details from configuration
Subscription sub = Subscriptions.Instance.Get(r.startvms.SubscriptionName);
if (sub == null)
{
string msg = string.Format("Subscription name {0} not found in configuration file.",
r.startvms.SubscriptionName);
Common.LogExit(msg, r.startvms.Service.ServiceName, log);
return;
}
// create credentials object based on management certificate
CertificateCloudCredentials creds = new CertificateCloudCredentials(sub.SubscriptionId, sub.MgtCertificate);
// see if the cloud service exists
bool nameIsAvailable = Common.CheckServiceNameAvailability(r.startvms.Service.ServiceName, creds);
// if so, nothing to do.
if (nameIsAvailable)
{
log.WriteLine("Hosted service {0} does not exist. Nothing to do.", r.startvms.Service.ServiceName);
return;
}
string requestId = StartVMs(creds, r, sub, log);
if (string.IsNullOrEmpty(requestId))
{
string msg = string.Format("Start of VMs on service {0} did not succeed.", r.startvms.Service.ServiceName);
string consoleMsg = string.Format("Start of VMs on service {0} failed. Check the log for details.", r.startvms.Service.ServiceName);
Common.LogExit(msg, consoleMsg, r.startvms.Service.ServiceName, log);
return;
}
else
{
string msg = string.Format("Start of VMs on service {0} succeeded with request ID: {1}.", r.startvms.Service.ServiceName, requestId);
string consoleMsg = string.Format("Start of VMs on service {0} succeeded. Check the log for details.", r.startvms.Service.ServiceName);
Common.LogSuccess(msg, consoleMsg, r.startvms.Service.ServiceName, log);
return;
}
}
private async Task <Dictionary <string, string> > ListStorageAccounts()
{
Dictionary <string, string> accountDictionary = new Dictionary <string, string>();
CertificateCloudCredentials creds = new CertificateCloudCredentials(_id, _certificate);
StorageManagementClient client = new StorageManagementClient(creds);
StorageAccountListResponse accounts = await client.StorageAccounts.ListAsync();
foreach (var account in accounts)
{
StorageAccountGetKeysResponse keys = await client.StorageAccounts.GetKeysAsync(account.Name);
accountDictionary.Add(account.Name, keys.PrimaryKey);
}
return(accountDictionary);
}
static void Main(string[] args)
{
var credential = new CertificateCloudCredentials(SubscriptionId, cert);
_WebSiteClient = new WebSiteManagementClient(credential);
var web = _WebSiteClient.WebSites.Get(webspace, websitename, null).WebSite;
web.HostNames.Add("www.example.com");
var updates = new WebSiteUpdateParameters {
HostNames = web.HostNames,
ServerFarm = web.ServerFarm,
State = web.State
};
_WebSiteClient.WebSites.Update(webspaces, websitename, updates);
System.Console.WriteLine("Press ENTER to continue");
System.Console.ReadLine();
}
public static void QueryRegisteredSchedulerProperties(CertificateCloudCredentials credentials)
{
try
{
var schedulerServiceClient = new SchedulerManagementClient(credentials);
var result3 = schedulerServiceClient.GetResourceProviderProperties();
foreach (var prop in result3.Properties)
{
Console.WriteLine("QueryRegisteredSchedulerProperties :\n" + prop.Key + ": " + prop.Value);
}
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("QueryRegisteredSchedulerProperties Exception :\n" + e.Message);
throw;
}
}
private static string DeleteService(CertificateCloudCredentials creds, RootDeleteServiceObject r, Subscription sub, TextWriter log)
{
try
{
using (var client = new ComputeManagementClient(creds))
{
OperationResponse resp = client.HostedServices.Delete(
r.deleteservice.Service.ServiceName);
return(resp.RequestId);
}
}
catch (Exception ex)
{
// get a 404 if the cloud service doesn't exist
string msg = string.Format("Exception deleting service: {0}", ex.Message);
Common.LogExit(msg, r.deleteservice.Service.ServiceName, log);
return(null);
}
}
/// <summary>
/// Performs the execution of the activity.
/// </summary>
/// <param name="context">The execution context under which the activity executes.</param>
protected override void Execute(CodeActivityContext context)
{
var azureSubscription = new AzureSubscription(SettingsPath, SubscriptionId);
var credentials = new CertificateCloudCredentials(
SubscriptionId,
new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate)));
var tasks = VirtualMachines.Get(context).Select(
async vm =>
{
using (var client = new ComputeManagementClient(credentials))
{
switch (vm.Size)
{
case VirtualMachineSize.Stop:
await client.DeallocateVmAsync(vm.Name);
break;
case VirtualMachineSize.Small:
case VirtualMachineSize.ExtraSmall:
case VirtualMachineSize.Large:
case VirtualMachineSize.Medium:
case VirtualMachineSize.ExtraLarge:
case VirtualMachineSize.A5:
case VirtualMachineSize.A6:
case VirtualMachineSize.A7:
case VirtualMachineSize.A8:
case VirtualMachineSize.A9:
await client.ResizeVmAsync(vm.Name, vm.Size.GetEnumDescription());
break;
default:
throw new ArgumentOutOfRangeException(
nameof(context),
@"Unknown VM Size, this shouldn't happen, but the enumeration value isn't implemented in the acitivity switch");
}
}
});
Task.WhenAll(tasks);
}
/// <summary>
/// Performs the execution of the activity.
/// </summary>
/// <param name="context">The execution context under which the activity executes.</param>
protected override void Execute(CodeActivityContext context)
{
var azureSubscription = new AzureSubscription(SettingsPath, SubscriptionId);
var credentials = new CertificateCloudCredentials(
SubscriptionId,
new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate)));
var tasks = VirtualMachines.Get(context).Select(
async vm =>
{
using (var client = new ComputeManagementClient(credentials))
{
switch (vm.Size)
{
case VirtualMachineSize.Stop:
await client.DeallocateVmAsync(vm.Name);
break;
case VirtualMachineSize.Small:
case VirtualMachineSize.ExtraSmall:
case VirtualMachineSize.Large:
case VirtualMachineSize.Medium:
case VirtualMachineSize.ExtraLarge:
case VirtualMachineSize.A5:
case VirtualMachineSize.A6:
case VirtualMachineSize.A7:
case VirtualMachineSize.A8:
case VirtualMachineSize.A9:
await client.ResizeVmAsync(vm.Name, vm.Size.GetEnumDescription());
break;
default:
throw new ArgumentOutOfRangeException(
nameof(context),
@"Unknown VM Size, this shouldn't happen, but the enumeration value isn't implemented in the acitivity switch");
}
}
});
Task.WhenAll(tasks);
}
private static void Main(String[] args)
{
var subscription = " "; //oc
var credentials = new CertificateCloudCredentials(subscription, GetCertificate());
using (var computeManagementClient = new ComputeManagementClient(credentials, new Uri("https://management.core.windows.net")))
{
//HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create("https://management.core.windows.net/" + subscription + "/services/hostedservices");
//request.ClientCertificates.Add(GetCertificate());
//request.Headers.Add("x-ms-version", "2015-04-01");
//request.ContentType = "application/xml";
//var response = request.GetResponse();
//var responseStream = response.GetResponseStream();
var services = computeManagementClient.HostedServices.List();
foreach (var item in services)
{
var serviceDetail = computeManagementClient.HostedServices.GetDetailed(item.ServiceName);
var deployments = new List <HostedServiceGetDetailedResponse.Deployment>();
foreach (var deployment in serviceDetail.Deployments)
{
var tempDeployment = new HostedServiceGetDetailedResponse.Deployment
{
DeploymentSlot = (DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), deployment.DeploymentSlot.ToString()), RoleInstances = new List <RoleInstance>()
};
foreach (var roleInstance in deployment.RoleInstances)
{
}
tempDeployment.Roles = new List <Role>();
foreach (var role in deployment.Roles)
{
}
tempDeployment.Status = (DeploymentStatus)Enum.Parse(typeof(DeploymentStatus), deployment.Status.ToString());
deployments.Add(tempDeployment);
}
}
}
}
public static void RegisterScheduleResourceProvider(CertificateCloudCredentials credentials)
{
var schedulerServiceClient = new SchedulerManagementClient(credentials);
try
{
var result2 = schedulerServiceClient.RegisterResourceProvider();
Console.WriteLine("RegisterScheduleResourceProvider :\n" + result2.RequestId);
Console.WriteLine("RegisterScheduleResourceProvider :\n" + result2.StatusCode);
Console.ReadLine();
}
catch (CloudException exc)
{
if (exc.Response.StatusCode != HttpStatusCode.Conflict)
{
Console.WriteLine("RegisterScheduleResourceProvider Exception :\n" + exc.Message);
throw;
}
}
}
public SubscriptionCloudCredentials GetManagementCredentials()
{
var subscription = ActiveSubscription;
var settings = new Dictionary <string, object>
{
{ "SubscriptionId", subscription.SubscriptionId },
{ "ManagementCertificate", subscription.ManagementCertificate.Thumbprint ?? subscription.ManagementCertificate.Base64Data }
};
var credentials = CertificateCloudCredentials.Create(settings);
if (credentials == null)
{
var message = String.Format("The Subscription for '{0}' did not have valid subscription details configured.", subscription.Name);
_logger.ErrorFormat(message);
throw new CredentialException(message);
}
return(credentials);
}
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 static CertificateCloudCredentials GetCredentialsByPublishSettingFile(string fileName)
{
var doc = new XmlDocument( );
doc.Load( fileName );
var certNode = doc.SelectSingleNode( "/PublishData/PublishProfile/@ManagementCertificate" );
// Some publishsettings files (with multiple subscriptions?) have the management publisherCertificate under the Subscription
if( certNode == null )
{
certNode =
doc.SelectSingleNode(
"/PublishData/PublishProfile/Subscription/@ManagementCertificate" );
}
X509Certificate2 ManagementCertificate = new X509Certificate2( Convert.FromBase64String( certNode.Value ) );
var subNode =
doc.SelectSingleNode( "/PublishData/PublishProfile/Subscription/@Id" );
string SubscriptionId = subNode.Value;
// Obtain management via .publishsettings file from https://manage.windowsazure.com/publishsettings/index?schemaversion=2.0
CertificateCloudCredentials creds = new CertificateCloudCredentials( SubscriptionId, ManagementCertificate );
return creds;
}
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();
}
}
// Entrypoint and main method
static void Main(string[] args)
{
// The azure subscription id
SubscriptionId = "{subscriptionId}";
// Management Certificate thumbprint
CertificateThumbprint = "{thumbprint}";
// Creates credentials / Management operations require the X509Certificate2 type
CertificateCloudCredentials credential = new CertificateCloudCredentials(SubscriptionId, GetStoreCertificate(CertificateThumbprint));
using (var computeClient = new ComputeManagementClient(credential))
{
//Gets a list of Cloud Services inside the Subscription
var myCloudServices = computeClient.HostedServices.List();
// Loops the the HostedServices object
foreach (HostedServiceListResponse.HostedService cs in myCloudServices)
{
// Prints every Cloud Service found
Console.WriteLine(cs.ServiceName);
}
// Gets a specific Cloud Service
var result = computeClient.HostedServices.GetDetailed("{cloud-service-name}");
var productionDeployment = result.Deployments.Where(d => d.DeploymentSlot == DeploymentSlot.Production).FirstOrDefault();
// Prints a specific Cloud Service Details
Console.WriteLine("Service Name: " + result.ServiceName);
Console.WriteLine("Status: " + productionDeployment.Status);
Console.WriteLine("Public IP address: " + productionDeployment.VirtualIPAddresses[0].Address);
Console.WriteLine("Deployment name: " + productionDeployment.Name);
Console.WriteLine("Deployment label: " + productionDeployment.Label);
Console.WriteLine("Deployment ID: " + productionDeployment.PrivateId);
}
Console.WriteLine("press any key to exit...");
Console.ReadKey();
}
/// <summary>
/// Validates and converts input parameters 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,
MigrateDeallocatedVms = parameters[Constants.Parameters.MigrateDeallocatedVms]
};
return exportParams;
}
/// <summary>
/// Validates and converts input parameters 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 import 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;
}
private XElement GetConfigXml()
{
XElement configXml = null;
if(!RoleEnvironment.IsAvailable/*as local web project*/ || RoleEnvironment.IsEmulated /*as azure emulator project*/)
{
try
{
var localConfigFile =
new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).Parent.EnumerateFiles(
"*Local.cscfg", SearchOption.AllDirectories).FirstOrDefault();
if (localConfigFile == null)
{
return null;
}
XmlDocument doc = new XmlDocument();
doc.Load(localConfigFile.FullName);
configXml = XElement.Parse(doc.InnerXml);
}
catch(Exception) // happens in some projects when using Full Emulator
{
throw; // intended - just marking - will catch it above
}
}
else
{
var managementCertificate = new X509Certificate2(Convert.FromBase64String(_managementCertContents));
var credentials = new CertificateCloudCredentials(_subscriptionId, managementCertificate);
var computeManagementClient = new ComputeManagementClient(credentials);
var response = computeManagementClient.HostedServices.GetDetailed(_cloudServiceName);
HostedServiceGetDetailedResponse.Deployment deployment = null;
var isProduction = Convert.ToBoolean(CloudConfigurationManager.GetSetting("IsProduction"));
if(isProduction)
{
deployment = response.Deployments.FirstOrDefault(d => d.DeploymentSlot == DeploymentSlot.Production);
}
else
{
deployment = response.Deployments.FirstOrDefault(d => d.DeploymentSlot == DeploymentSlot.Staging);
}
if(deployment != null)
{
var config = deployment.Configuration;
configXml = XElement.Parse(config);
}
}
return configXml;
}
public BatchManagementClient GetBatchManagementClient(RecordedDelegatingHandler handler)
{
var certCreds = new CertificateCloudCredentials(Guid.NewGuid().ToString(), new System.Security.Cryptography.X509Certificates.X509Certificate2());
handler.IsPassThrough = false;
return new BatchManagementClient(certCreds).WithHandler(handler);
}
/// <summary>
/// Get the test environment from a connection string specifying a certificate
/// </summary>
/// <param name="testConnectionString">The connetcion string to parse</param>
/// <returns>The test environment from parsing the connection string.</returns>
protected virtual TestEnvironment GetCertificateTestEnvironmentFromConnectionString(string testConnectionString)
{
IDictionary<string, string> connections = ParseConnectionString(testConnectionString);
string certificateReference = connections[ManagementCertificateKey];
string subscriptionId = connections[SubscriptionIdKey];
Assert.IsNotNull(certificateReference);
X509Certificate2 managementCertificate;
if (IsCertificateReference(certificateReference))
{
managementCertificate = GetCertificateFromReference(certificateReference);
}
else
{
managementCertificate = GetCertificateFromBase64String(certificateReference);
}
CertificateCloudCredentials credentials = new CertificateCloudCredentials(subscriptionId, managementCertificate);
TestEnvironment currentEnvironment = new TestEnvironment { Credentials = credentials };
if (connections.ContainsKey(BaseUriKey))
{
currentEnvironment.BaseUri = new Uri(connections[BaseUriKey]);
}
return currentEnvironment;
}
public static ExpressRouteManagementClient GetSecondCustomerExpressRouteManagementClient()
{
string managementCertificate = "";
string baseUri;
string subscriptionId;
if (HttpMockServer.Mode == HttpRecorderMode.Playback)
{
baseUri = HttpMockServer.Variables["TEST_CUSTOMER2_BASE_URI"];
subscriptionId = HttpMockServer.Variables["TEST_CUSTOMER2_SUBSCRIPTION_ID"];
managementCertificate = HttpMockServer.Variables["TEST_CUSTOMER2_MANAGEMENT_CERTIFICATE"];
}
else
{
string publishSettingsFile = Environment.GetEnvironmentVariable("TEST_CUSTOMER2_PUBLISHSETTINGS_FILE");
PublishData publishData = XmlSerializationHelpers.DeserializeXmlFile<PublishData>(publishSettingsFile);
managementCertificate = Enumerable.First<PublishDataPublishProfile>((IEnumerable<PublishDataPublishProfile>) publishData.Items).ManagementCertificate;
if (string.IsNullOrEmpty(managementCertificate))
managementCertificate = Enumerable.First<PublishDataPublishProfileSubscription>((IEnumerable<PublishDataPublishProfileSubscription>) Enumerable.First<PublishDataPublishProfile>((IEnumerable<PublishDataPublishProfile>) publishData.Items).Subscription).ManagementCertificate;
if (string.IsNullOrEmpty(managementCertificate))
throw new ArgumentException(string.Format("{0} is not a valid publish settings file, you must provide a valid publish settings file in the environment variable {1}", (object) publishSettingsFile, (object) "TEST_PUBLISHSETTINGS_FILE"));
subscriptionId = Enumerable.First<PublishDataPublishProfileSubscription>((IEnumerable<PublishDataPublishProfileSubscription>) Enumerable.First<PublishDataPublishProfile>((IEnumerable<PublishDataPublishProfile>) publishData.Items).Subscription).Id;
baseUri = Enumerable.First<PublishDataPublishProfileSubscription>(
(IEnumerable<PublishDataPublishProfileSubscription>)
Enumerable.First<PublishDataPublishProfile>(
(IEnumerable<PublishDataPublishProfile>) publishData.Items).Subscription)
.ServiceManagementUrl ?? publishData.Items[0].Url;
HttpMockServer.Variables["TEST_CUSTOMER2_MANAGEMENT_CERTIFICATE"] = managementCertificate;
HttpMockServer.Variables["TEST_CUSTOMER2_SUBSCRIPTION_ID"] = subscriptionId;
HttpMockServer.Variables["TEST_CUSTOMER2_BASE_URI"] = baseUri;
}
var credentials = new CertificateCloudCredentials(subscriptionId, new X509Certificate2(Convert.FromBase64String(managementCertificate), string.Empty));
var client = new ExpressRouteManagementClient(credentials, new Uri(baseUri));
client.AddHandlerToPipeline(HttpMockServer.CreateInstance());
return client;
}
