/// <summary>
/// Initializes a new instance of the AzureAccount class.
/// </summary>
/// <param name="subscriptionId">Subscription ID of the Azure account.</param>
/// <param name="cert">X509 certificate used for authentication.</param>
public AzureAccount(string subscriptionId, X509Certificate2 cert)
{
this.credentials = new CertificateCloudCredentials(subscriptionId, cert);
this.computeManager = CloudContext.Clients.CreateComputeManagementClient(this.credentials);
this.storageManager = CloudContext.Clients.CreateStorageManagementClient(this.credentials);
}
/// <author>Bart</author>
/// <summary>
/// Deze methode wordt gebruikt om nieuwe CloudServices aan te maken in Azure. Location of Affinitygroup mag null zijn.
/// </summary>
/// <param name="cloudServiceName">Is de naam die de CloudService gaat hebben.</param>
/// <param name="location">Is de geografische lokatie die de CloudService zal hebben.</param>
/// <param name="affinityGroupName">Is de groep waar deze CloudService bij hoort.</param>
/// <returns>Een true of false respectiefelijk aan of de actie geslaagt is of niet.</returns>
public Boolean CreateCloudService(string cloudServiceName, string location, string affinityGroupName = null)
{
ComputeManagementClient client = new ComputeManagementClient(cloudCredentials);
HostedServiceCreateParameters hostedServiceCreateParams = new HostedServiceCreateParameters();
if (location != null)
{
hostedServiceCreateParams = new HostedServiceCreateParameters
{
ServiceName = cloudServiceName,
Location = location,
Label = EncodeToBase64(cloudServiceName),
};
}
else if (affinityGroupName != null)
{
hostedServiceCreateParams = new HostedServiceCreateParameters
{
ServiceName = cloudServiceName,
AffinityGroup = affinityGroupName,
Label = EncodeToBase64(cloudServiceName),
};
}
try
{
client.HostedServices.Create(hostedServiceCreateParams);
return true;
}
catch (CloudException)
{
return false;
}
}
public static void CreateAzureVirtualMachine(ComputeManagementClient computeClient, string serviceName, string deploymentName, string storageAccountName, string blobUrl)
{
VirtualMachineOSImageListResponse imagesList = computeClient.VirtualMachineOSImages.List();
VirtualMachineOSImageListResponse.VirtualMachineOSImage imageToGet =
imagesList.Images.FirstOrDefault(i => string.Equals(i.OperatingSystemType, "Windows", StringComparison.OrdinalIgnoreCase));
VirtualMachineOSImageGetResponse gottenImage = computeClient.VirtualMachineOSImages.Get(imageToGet.Name);
VirtualMachineCreateDeploymentParameters parameters = CreateVMParameters(gottenImage, deploymentName, storageAccountName, "SampleLabel", blobUrl);
parameters.Roles[0].ConfigurationSets.Add(new ConfigurationSet
{
AdminUserName = "******",
AdminPassword = "******",
ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration,
ComputerName = serviceName,
HostName = string.Format("{0}.cloudapp.net", serviceName),
EnableAutomaticUpdates = false,
TimeZone = "Pacific Standard Time"
});
OperationStatusResponse opResp =
computeClient.VirtualMachines.CreateDeployment(serviceName, parameters);
Assert.Equal(opResp.Status, OperationStatus.Succeeded);
}
/// <summary>
/// Returns a list of Deployment objects for a given subscription
/// </summary>
/// <param name="serviceName">The name of the cloud service</param>
/// <param name="slot">The slot being either Production or Staging</param>
/// <returns></returns>
protected DeploymentGetResponse GetAzureDeyployment(string serviceName, DeploymentSlot slot)
{
ComputeManagementClient client = new ComputeManagementClient(MyCloudCredentials);
try
{
try
{
return client.Deployments.GetBySlot(serviceName, slot);
}
catch (CloudException ex)
{
if (ex.ErrorCode == "ResourceNotFound")
{
Logger.Warn(ex, String.Format("Resource not found during retrieval of Deployment object for service: {0}, {1}", serviceName, ex.ErrorCode));
return null;
}
else
{
Logger.Warn(ex, String.Format("Exception during retrieval of Deployment objects for the service: {0}, Errorcode: {1}", serviceName, ex.ErrorCode));
return null;
}
}
}
catch (Exception e)
{
Logger.Warn(e, String.Format("Exception during retrieval of Deployment objects for the service: {0}", serviceName));
return null;
}
}
public TestClientProvider(ManagementClient mgmtClient, ComputeManagementClient computeClient,
StorageManagementClient storageClient, NetworkManagementClient networkClient)
{
this.managementClient = mgmtClient;
this.computeManagementClient = computeClient;
this.storageManagementClient = storageClient;
this.networkManagementClient = networkClient;
}
static void Main(string[] args)
{
if (args.Length < 1)
{
throw new ArgumentNullException("publish settings informations");
}
SubscriptionCloudCredentials cred = GetCredentials(args[0]);
//WATM
TrafficManagerManagementClient watmClient = new TrafficManagerManagementClient(cred);
string atmDns = "adxsdk12345.trafficmanager.net";
DnsPrefixAvailabilityCheckResponse watmResp =
watmClient.Profiles.CheckDnsPrefixAvailability("adxsdk12345.trafficmanager.net");
Console.WriteLine("Invoke WATM->CheckDnsPrefixAvailability(\'{0}\'). Result: {1}", atmDns, watmResp.Result);
//Compute
ComputeManagementClient computeClient = new ComputeManagementClient(cred);
string hostServiceName = "adxsdk12345";
HostedServiceCheckNameAvailabilityResponse computeResp =
computeClient.HostedServices.CheckNameAvailability(hostServiceName);
Console.WriteLine("Invoke Compute->CheckNameAvailability(\'{0}\'). Result: {1}",
hostServiceName, computeResp.IsAvailable);
//Websites
WebSiteManagementClient websiteClient = new WebSiteManagementClient(cred);
string webSiteName = "adxsdk12345";
WebSiteIsHostnameAvailableResponse webSiteResp = websiteClient.WebSites.IsHostnameAvailable(webSiteName);
Console.WriteLine("Invoke WebSite->IsHostnameAvailable(\'{0}\'). Result: {1}",
webSiteName, webSiteResp.IsAvailable);
//Scheduler
SchedulerManagementClient schedulerClient = new SchedulerManagementClient(cred);
string schedulerCloudServiceName = "foobarrr";
string expectedSchedulerException = string.Format(
"ResourceNotFound: The cloud service with name {0} was not found.", schedulerCloudServiceName);
bool exceptionFromSchedulerServiceOccurred = false;
try
{
schedulerClient.JobCollections.CheckNameAvailability(schedulerCloudServiceName, "doesnotmatter");
}
catch (Exception ex)
{
if (ex.Message == expectedSchedulerException)
{
exceptionFromSchedulerServiceOccurred = true;
Console.WriteLine("Invoke Scheduler->CheckNameAvailability(\'{0}\'). Get back correct exception",
schedulerCloudServiceName, expectedSchedulerException);
}
}
if (!exceptionFromSchedulerServiceOccurred)
{
throw new Exception("we didn't get expected exception message from scheduler service");
}
Console.WriteLine("Smoke test is good");
}
public VMManagementController(VMManagementControllerParameters parameters)
{
_parameters = parameters;
// To authenticate against the Microsoft Azure service management API we require management certificate
// load this from a publish settings file and later use it with the Service Management Libraries
var credentials = GetSubscriptionCloudCredentials(parameters.PublishSettingsFilePath);
_storageManagementClient = CloudContext.Clients.CreateStorageManagementClient(credentials);
_computeManagementClient = CloudContext.Clients.CreateComputeManagementClient(credentials);
}
public void SubscriptionChanged()
{
if (_computeManagementClient != null)
_computeManagementClient.Dispose();
_computeManagementClient = new ComputeManagementClient(
new CertificateCloudCredentials(Host.SelectedSubscription.SubscriptionId,
new X509Certificate2(
Convert.FromBase64String(
Host.SelectedSubscription.ManagementCertificate))));
}
private VirtualMachineService()
{
_serviceName = System.Configuration.ConfigurationManager.AppSettings["serviceName"];
_deploymentName = System.Configuration.ConfigurationManager.AppSettings["deploymentName"];
_virtualMachineName = System.Configuration.ConfigurationManager.AppSettings["virtualMachineName"];
var subscriptionId = System.Configuration.ConfigurationManager.AppSettings["subscriptionId"];
var certificate = System.Configuration.ConfigurationManager.AppSettings["base64EncodedCertificate"];
_client = new ComputeManagementClient(GetCredentials(subscriptionId, certificate));
}
internal ManagementController(ManagementControllerParamters parameters)
{
_parameters = parameters;
var credential = CertificateAuthenticationHelper.GetCredentials(
parameters.SubscriptionId,
parameters.Base64EncodedCertificate);
_storageManagementClient = CloudContext.Clients.CreateStorageManagementClient(credential);
_computeManagementClient = CloudContext.Clients.CreateComputeManagementClient(credential);
}
public EarzyProvisioningCore()
{
//Get credentials from subscription ID & Certificate
var credential = CertificateAuthenticationHelper.GetCredentials(
ConfigurationManager.AppSettings["SubscriptionId"],
ConfigurationManager.AppSettings["Certificate"]);
//Initialize clients
_storageManagementClient = CloudContext.Clients.CreateStorageManagementClient(credential);
_computeManagementClient = CloudContext.Clients.CreateComputeManagementClient(credential);
_webSitesManagementClient = CloudContext.Clients.CreateWebSiteManagementClient(credential);
}
/// <summary>
/// Provisions all the services in the <see cref="IEnumerable{T}"/> of <see cref="AzureCloudService"/>.
/// </summary>
/// <param name="services">The list of <see cref="AzureCloudService"/> to provision.</param>
/// <param name="client">The <see cref="ComputeManagementClient"/> that is performing the operation.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task ProvisionAllAsync(this IEnumerable<AzureCloudService> services, ComputeManagementClient client)
{
Contract.Requires(services != null);
Contract.Requires(client != null);
var tasks = services.Select(
async s =>
{
await client.CreateServiceIfNotExistsAsync(s);
});
await Task.WhenAll(tasks);
}
public IEnumerable<string> GetVirtualMachineImagesList()
{
using (var computeClient = new ComputeManagementClient(_credentials))
{
var operatingSystemImageListResult =
computeClient.VirtualMachineOSImages.ListAsync().Result;
return from image in operatingSystemImageListResult
select image.Name;
}
}
/// <author>Bart</author>
/// <summary>
/// Deze methode kijkt of er al een deployment bestaat in de Cloudservice.
/// </summary>
/// <param name="serviveName">Is de naam van de CloudService waar het om gaat.</param>
/// <returns>Een true of false respectiefelijk aan of er wel of geen deployment bestaat.</returns>
public Boolean CheckDeployment(string serviceName)
{
ComputeManagementClient client = new ComputeManagementClient(cloudCredentials);
try
{
client.Deployments.GetByName(serviceName, "VMs");
return true;
}
catch (CloudException)
{
return false;
}
}
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 CreateHostedService(string location, ComputeManagementClient computeClient, string serviceName,
out bool hostedServiceCreated)
{
AzureOperationResponse hostedServiceCreate = computeClient.HostedServices.Create(
new HostedServiceCreateParameters
{
Location = location,
Label = serviceName,
ServiceName = serviceName
});
Assert.True(hostedServiceCreate.StatusCode == HttpStatusCode.Created);
hostedServiceCreated = true;
}
public static void createCloudServiceByAffinityGroup(string cloudServiceName, string affinityGroupName)
{
ComputeManagementClient client = new ComputeManagementClient(getCredentials());
HostedServiceCreateParameters hostedServiceCreateParams = new HostedServiceCreateParameters
{
ServiceName = cloudServiceName,
AffinityGroup = affinityGroupName,
Label = EncodeToBase64(cloudServiceName),
};
try
{
client.HostedServices.Create(hostedServiceCreateParams);
}
catch (CloudException e)
{
throw e;
}
}
/// <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>
/// Downloads an RDP file for each of the Elastic (Web and Worker based) Roles in a given subscription
/// </summary>
/// <returns>List of RdpFileObject containing the RDP file name and a byte[] with the RDP file</returns>
public List<RdpFileObject> GetAllElasticRoleRdpFiles()
{
ComputeManagementClient client = new ComputeManagementClient(MyCloudCredentials);
try
{
var rdpFiles = new List<RdpFileObject>();
RdpFileObject rdpFile = null;
var hostedServices = client.HostedServices.List();
if (hostedServices.Count() > 0)
{
foreach (var service in hostedServices)
{
var deployment = GetAzureDeyployment(service.ServiceName, DeploymentSlot.Production);
if (deployment != null)
{
var instances = client.Deployments.GetBySlot(service.ServiceName, DeploymentSlot.Production).RoleInstances;
if (instances != null)
{
if (instances.Count > 0)
{
foreach (RoleInstance instance in instances)
{
var rdpFileName = String.Format("rdp--{0}--{1}--{2}.rdp", service.ServiceName, deployment.Name, instance.InstanceName);
rdpFile = new RdpFileObject(rdpFileName, client.VirtualMachines.GetRemoteDesktopFile(service.ServiceName, deployment.Name, instance.InstanceName));
rdpFiles.Add(rdpFile);
}
}
}
}
}
return rdpFiles;
}
}
catch (CloudException ce)
{
Logger.Warn(ce, String.Format("Exception durign retrieval of Web Role RDP files - exception: {0}", ce));
}
return null;
}
private async static Task<OperationResponse> RemoveCloudService(SubscriptionCloudCredentials credentials,
string serviceName)
{
OperationResponse response;
Console.WriteLine("Removing Cloud Service '{0}'.", serviceName);
using (var client = new ComputeManagementClient(credentials))
{
response = await client.HostedServices.DeleteAllAsync(serviceName);
}
return response;
}
public StoreClient(
AzureSubscription subscription,
ComputeManagementClient compute,
StoreManagementClient store,
MarketplaceClient marketplace,
ManagementClient management)
{
this.subscriptionId = subscription.Id.ToString();
computeClient = compute;
storeClient = store;
MarketplaceClient = marketplace;
managementClient = management;
}
private async static Task<OperationResponse> DeployCloudService(SubscriptionCloudCredentials credentials, string storageAccountName,
string serviceName)
{
Console.WriteLine("Deploying to Cloud Service {0}", serviceName);
OperationResponse response = null;
string storageAccountKey = null;
using (var client = new StorageManagementClient(credentials))
{
var keys = await client.StorageAccounts.GetKeysAsync(storageAccountName);
storageAccountKey = keys.PrimaryKey;
}
string storageConnectionString =
string.Format("DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}", storageAccountName,
storageAccountKey);
CloudStorageAccount account = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient blobClient = account.CreateCloudBlobClient();
CloudBlobContainer deploymentContainer = blobClient.GetContainerReference("maml-deployment");
await deploymentContainer.CreateIfNotExistsAsync();
CloudBlockBlob deploymentBlob = deploymentContainer.GetBlockBlobReference("AzureCloudService1.cspkg");
await deploymentBlob.UploadFromFileAsync(@"C:\Projects\Demos\AzureAutomationDemos\AzureAutomation\AzureCloudService1\bin\Release\app.publish\AzureCloudService1.cspkg", FileMode.Open);
using (var client = new ComputeManagementClient(credentials))
{
response = await client.Deployments.CreateAsync(serviceName,
DeploymentSlot.Production,
new DeploymentCreateParameters
{
Label = serviceName,
Name = serviceName + "Prod",
PackageUri = deploymentBlob.Uri,
Configuration = File.ReadAllText(@"C:\Projects\Demos\AzureAutomationDemos\AzureAutomation\AzureCloudService1\bin\Release\app.publish\ServiceConfiguration.Cloud.cscfg"),
StartDeployment = true
});
}
return response;
}
private async static Task<string> CreateCloudService(SubscriptionCloudCredentials credentials)
{
Console.WriteLine("Creating new Cloud Service . . .");
OperationResponse response;
string name = string.Format("{0}{1}", ResourceName, new Random().Next(1, 200));
using (var client = new ComputeManagementClient(credentials))
{
response = await client.HostedServices.CreateAsync(new HostedServiceCreateParameters
{
ServiceName = name,
Location = LocationNames.EastUS,
Label = string.Format("{0} Demo Service", ResourceName)
});
}
return name;
}
private string GetOsImageUri(string imageName)
{
ComputeManagementClient computeClient = new ComputeManagementClient(this.Client.Credentials, this.Client.BaseUri);
VirtualMachineOSImageGetResponse imageGetResponse = null;
ErrorRecord er = null;
try
{
imageGetResponse = computeClient.VirtualMachineOSImages.Get(imageName);
}
catch (Hyak.Common.CloudException cloudEx)
{
// If the image was created in azure with Vm capture, GetOsImageUri won't find that. Don't terminate in this case
if (cloudEx.Error.Code != "ResourceNotFound")
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
cloudEx.Message,
String.Empty,
Client.TemplateImages,
ErrorCategory.InvalidArgument
);
ThrowTerminatingError(er);
}
}
catch (Exception ex)
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
ex.Message,
String.Empty,
Client.TemplateImages,
ErrorCategory.InvalidArgument
);
ThrowTerminatingError(er);
}
if (imageGetResponse != null)
{
ValidateImageOsType(imageGetResponse.OperatingSystemType);
ValidateImageMediaLink(imageGetResponse.MediaLinkUri);
return imageGetResponse.MediaLinkUri.AbsoluteUri;
}
else
{
return null;
}
}
private string GetVmImageUri(string imageName)
{
ComputeManagementClient computeClient = new ComputeManagementClient(this.Client.Credentials, this.Client.BaseUri);
VirtualMachineVMImageListResponse vmList = null;
ErrorRecord er = null;
string imageUri = null;
try
{
vmList = computeClient.VirtualMachineVMImages.List();
}
catch (Exception ex)
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
ex.Message,
String.Empty,
Client.TemplateImages,
ErrorCategory.InvalidArgument
);
ThrowTerminatingError(er);
}
foreach (VirtualMachineVMImageListResponse.VirtualMachineVMImage image in vmList.VMImages)
{
if (string.Compare(image.Name, imageName, true) == 0)
{
if (image.OSDiskConfiguration != null)
{
ValidateImageOsType(image.OSDiskConfiguration.OperatingSystem);
ValidateImageMediaLink(image.OSDiskConfiguration.MediaLink);
imageUri = image.OSDiskConfiguration.MediaLink.AbsoluteUri;
break;
}
else
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
string.Format(Commands_RemoteApp.NoOsDiskFoundErrorFormat, imageName),
String.Empty,
Client.TemplateImages,
ErrorCategory.InvalidArgument
);
ThrowTerminatingError(er);
}
}
}
if (imageUri == null)
{
er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
string.Format(Commands_RemoteApp.NoVmImageFoundErrorFormat, imageName),
String.Empty,
Client.TemplateImages,
ErrorCategory.InvalidArgument
);
ThrowTerminatingError(er);
}
return imageUri;
}
/// <summary>
/// Rollback all imported cloud services.
/// </summary>
/// <param name="cloudServices">Cloud services to be deleted.</param>
private void RollBackServices(List<string> cloudServices)
{
string methodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Logger.Info(methodName, ProgressResources.ExecutionStarted, ResourceType.CloudService.ToString());
Logger.Info(methodName, ProgressResources.RollbackCloudServices, ResourceType.CloudService.ToString());
dcMigrationManager.ReportProgress(ProgressResources.RollbackCloudServices);
Stopwatch swTotalServices = new Stopwatch();
swTotalServices.Start();
//string origServiceName = null;
if (cloudServices.Count > 0)
{
using (var client = new ComputeManagementClient(importParameters.DestinationSubscriptionSettings.Credentials))
{
Parallel.ForEach(cloudServices, cloudService =>
{
try
{
Stopwatch swService = new Stopwatch();
swService.Start();
string origServiceName = resourceImporter.GetSourceResourceName(ResourceType.CloudService, cloudService);
Retry.RetryOperation(() => client.HostedServices.DeleteAll(cloudService),
(BaseParameters)importParameters, ResourceType.CloudService, cloudService, ignoreResourceNotFoundEx:true);
CloudService service = subscription.DataCenters.FirstOrDefault().CloudServices.
Where(ser => (ser.CloudServiceDetails.ServiceName == origServiceName)).FirstOrDefault();
if (service.DeploymentDetails != null)
{
string deploymentName = resourceImporter.GetDestinationResourceName(
ResourceType.Deployment, service.DeploymentDetails.Name, ResourceType.CloudService,
resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName)
);
resourceImporter.UpdateMedatadaFile(ResourceType.Deployment, deploymentName, false,
resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName)
);
Logger.Info(methodName, string.Format(ProgressResources.RollbackDeployment, service.DeploymentDetails.Name,
service.DeploymentDetails.Name), ResourceType.Deployment.ToString(), service.DeploymentDetails.Name);
foreach (VirtualMachine vm in service.DeploymentDetails.VirtualMachines)
{
string virtualmachineName = resourceImporter.GetDestinationResourceName(
ResourceType.VirtualMachine, vm.VirtualMachineDetails.RoleName, ResourceType.CloudService,
resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName)
);
resourceImporter.UpdateMedatadaFile(ResourceType.VirtualMachine, virtualmachineName, false,
resourceImporter.GetDestinationResourceName(ResourceType.CloudService, service.CloudServiceDetails.ServiceName)
);
Logger.Info(methodName, string.Format(ProgressResources.RollbackVirtualMachine, vm.VirtualMachineDetails.RoleName),
ResourceType.VirtualMachine.ToString(), vm.VirtualMachineDetails.RoleName);
}
}
resourceImporter.UpdateMedatadaFile(ResourceType.CloudService, cloudService, false);
swService.Stop();
Logger.Info(methodName, string.Format(ProgressResources.RollbackCloudService, cloudService,swService.Elapsed.Days, swService.Elapsed.Hours,
swService.Elapsed.Minutes, swService.Elapsed.Seconds), ResourceType.CloudService.ToString(), cloudService);
}
catch (AggregateException exAgg)
{
foreach (var ex in exAgg.InnerExceptions)
{
Logger.Error(methodName, exAgg, ResourceType.CloudService.ToString(), cloudService);
}
throw;
}
});
Logger.Info(methodName, ProgressResources.RollbackCloudServicesWaiting, ResourceType.CloudService.ToString());
dcMigrationManager.ReportProgress(ProgressResources.RollbackCloudServicesWaiting);
Task.Delay(Constants.DelayTimeInMilliseconds_Rollback).Wait();
}
}
swTotalServices.Stop();
Logger.Info(methodName, string.Format(ProgressResources.ExecutionCompletedWithTime,swTotalServices.Elapsed.Days, swTotalServices.Elapsed.Hours, swTotalServices.Elapsed.Minutes,
swTotalServices.Elapsed.Seconds), ResourceType.CloudService.ToString());
}
public DeploymentGetResponse CreateMultivipDeploymentAndAssertSuccess(NetworkManagementClient networkClient, ComputeManagementClient computeClient, List<string> vipNames, string serviceName, string deploymentName, string storageAccountName, string location)
{
Utilities.CreateAzureVirtualMachine(computeClient, serviceName, deploymentName,
storageAccountName, "blob.core.windows.net");
DeploymentGetResponse depRetrieved =
computeClient.Deployments.GetByName(serviceName: serviceName, deploymentName: deploymentName);
List<ConfigurationSet> endpointCfgSets = new List<ConfigurationSet>
{
new ConfigurationSet
{
ConfigurationSetType = "NetworkConfiguration",
InputEndpoints =
new List<InputEndpoint>
{
new InputEndpoint()
{
LocalPort = 3387,
Name = "RDP2",
Port = 52777,
Protocol = InputEndpointTransportProtocol.Tcp,
EnableDirectServerReturn = false
},
}
}
};
// Update with single endpoint
var updateParams = Utilities.GetVMUpdateParameters(depRetrieved.Roles.First(),
storageAccountName, endpointCfgSets, preserveOriginalConfigSets: false);
computeClient.VirtualMachines.Update(
serviceName,
deploymentName,
depRetrieved.Roles.First().RoleName,
updateParams);
int i = 1;
foreach (var vip in vipNames)
{
i++;
OperationStatusResponse virtualIPCreate =
networkClient.VirtualIPs.Add(serviceName: serviceName,
deploymentName: deploymentName, virtualIPName: vip);
Assert.True(virtualIPCreate.StatusCode == HttpStatusCode.OK);
depRetrieved = Utilities.AssertLogicalVipWithoutIPPresentOrAbsent(computeClient, serviceName: serviceName,
deploymentName: deploymentName, virtualIPName: vip, expectedVipCount: i, present: true);
endpointCfgSets.First().InputEndpoints.Add(
new InputEndpoint()
{
LocalPort = 3387 + i,
Name = "RDPS" + i,
Port = 52777 + i,
Protocol = InputEndpointTransportProtocol.Tcp,
EnableDirectServerReturn = false,
VirtualIPName = vip
});
}
updateParams = Utilities.GetVMUpdateParameters(depRetrieved.Roles.First(),
storageAccountName, endpointCfgSets, preserveOriginalConfigSets: false);
computeClient.VirtualMachines.Update(
serviceName,
deploymentName,
depRetrieved.Roles.First().RoleName,
updateParams);
depRetrieved =
computeClient.Deployments.GetByName(serviceName: serviceName, deploymentName: deploymentName);
Assert.NotNull(depRetrieved);
Assert.NotNull(depRetrieved.VirtualIPAddresses);
Assert.True(depRetrieved.VirtualIPAddresses.Count == vipNames.Count + 1);
foreach (var virtualIpAddress in depRetrieved.VirtualIPAddresses)
{
Assert.NotNull(virtualIpAddress.Address);
}
return depRetrieved;
}
public StoreClient(
WindowsAzureSubscription subscription,
ComputeManagementClient compute,
StoreManagementClient store,
MarketplaceClient marketplace,
ManagementClient management)
{
Validate.ValidateStringIsNullOrEmpty(subscription.SubscriptionId, null, true);
this.subscriptionId = subscription.SubscriptionId;
computeClient = compute;
storeClient = store;
MarketplaceClient = marketplace;
managementClient = management;
}
public VirtualMachineImageHelper(ComputeManagementClient computeClient)
{
this.computeClient = computeClient;
}
internal CloudServiceClient(
AzureSubscription subscription,
ManagementClient managementClient,
StorageManagementClient storageManagementClient,
ComputeManagementClient computeManagementClient)
: this((string)null, null, null, null)
{
Subscription = subscription;
CurrentDirectory = null;
DebugStream = null;
VerboseStream = null;
WarningStream = null;
CloudBlobUtility = new CloudBlobUtility();
ManagementClient = managementClient;
StorageClient = storageManagementClient;
ComputeClient = computeManagementClient;
}