public async Task GetAllInSubscription() { var collection = await GetDedicatedHostGroupCollectionAsync(); var groupName1 = Recording.GenerateAssetName("testDHG-"); var groupName2 = Recording.GenerateAssetName("testDHG-"); var input = ResourceDataHelper.GetBasicDedicatedHostGroup(DefaultLocation, 2); _ = await collection.CreateOrUpdateAsync(groupName1, input); _ = await collection.CreateOrUpdateAsync(groupName2, input); DedicatedHostGroup group1 = null, group2 = null; await foreach (var group in DefaultSubscription.GetDedicatedHostGroupsAsync()) { if (group.Data.Name == groupName1) { group1 = group; } if (group.Data.Name == groupName2) { group2 = group; } } Assert.NotNull(group1); Assert.NotNull(group2); }
public async Task <Response <DedicatedHostGroup> > CreateOrUpdateAsync(string resourceGroupName, string hostGroupName, DedicatedHostGroup parameters, CancellationToken cancellationToken = default) { if (resourceGroupName == null) { throw new ArgumentNullException(nameof(resourceGroupName)); } if (hostGroupName == null) { throw new ArgumentNullException(nameof(hostGroupName)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } using var message = CreateCreateOrUpdateRequest(resourceGroupName, hostGroupName, parameters); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 200: case 201: { DedicatedHostGroup value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); value = DedicatedHostGroup.DeserializeDedicatedHostGroup(document.RootElement); return(Response.FromValue(value, message.Response)); }
public override void ExecuteCmdlet() { base.ExecuteCmdlet(); ExecuteClientAction(() => { if (ShouldProcess(this.Name, VerbsCommon.New)) { string resourceGroupName = this.ResourceGroupName; string hostGroupName = this.Name; DedicatedHostGroup parameters = new DedicatedHostGroup(); parameters.Location = this.Location; parameters.PlatformFaultDomainCount = this.PlatformFaultDomain; if (this.IsParameterBound(c => c.Zone)) { parameters.Zones = this.Zone; } if (this.IsParameterBound(c => c.SupportAutomaticPlacement)) { parameters.SupportAutomaticPlacement = this.SupportAutomaticPlacement; } if (this.IsParameterBound(c => c.Tag)) { parameters.Tags = this.Tag.Cast <DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value); } var result = DedicatedHostGroupsClient.CreateOrUpdate(resourceGroupName, hostGroupName, parameters); var psObject = new PSHostGroup(); ComputeAutomationAutoMapperProfile.Mapper.Map <DedicatedHostGroup, PSHostGroup>(result, psObject); WriteObject(psObject); } }); }
private void ValidateDedicatedHostGroup(DedicatedHostGroup expectedDHG, DedicatedHostGroup actualDHG) { if (expectedDHG == null) { Assert.Null(actualDHG); } else { Assert.NotNull(actualDHG); if (expectedDHG.Hosts == null) { Assert.Null(actualDHG.Hosts); } else { Assert.NotNull(actualDHG); Assert.True(actualDHG.Hosts.SequenceEqual(expectedDHG.Hosts)); } Assert.Equal(expectedDHG.Location, actualDHG.Location); Assert.Equal(expectedDHG.Name, actualDHG.Name); Assert.Equal(expectedDHG.SupportAutomaticPlacement, actualDHG.SupportAutomaticPlacement); if (expectedDHG.AdditionalCapabilities != null) { Assert.NotNull(actualDHG.AdditionalCapabilities); Assert.Equal(expectedDHG.AdditionalCapabilities.UltraSSDEnabled, actualDHG.AdditionalCapabilities.UltraSSDEnabled); } } }
private void ValidateDedicatedHostGroupInstanceView(DedicatedHostGroup actualDHGWithInstanceView, params DedicatedHost[] expectedDedicatedHostsInInstanceView) { Assert.NotNull(actualDHGWithInstanceView); Assert.Equal(expectedDedicatedHostsInInstanceView.Count(), actualDHGWithInstanceView.InstanceView.Hosts.Count); foreach (DedicatedHost dedicatedHost in expectedDedicatedHostsInInstanceView) { Assert.True(actualDHGWithInstanceView.InstanceView.Hosts.FirstOrDefault(host => host.Name.Equals(dedicatedHost.Name)) != null); } }
public async Task Get() { var groupName = Recording.GenerateAssetName("testDHG-"); var group1 = await CreateDedicatedHostGroupAsync(groupName); DedicatedHostGroup group2 = await group1.GetAsync(); ResourceDataHelper.AssertGroup(group1.Data, group2.Data); }
public async Task Get() { var collection = await GetDedicatedHostGroupCollectionAsync(); var groupName = Recording.GenerateAssetName("testDHG-"); var input = ResourceDataHelper.GetBasicDedicatedHostGroup(DefaultLocation, 2); var lro = await collection.CreateOrUpdateAsync(groupName, input); DedicatedHostGroup group1 = lro.Value; DedicatedHostGroup group2 = await collection.GetAsync(groupName); ResourceDataHelper.AssertGroup(group1.Data, group2.Data); }
private IList <(int fd, int numberOfHosts)> CalculatePlatformFaultDomainToHost( DedicatedHostGroup dhGroup, IList <DedicatedHost> existingHostsOnDHGroup, string vmSku, int vmInstancesRequested, int vmCapacityPerHost, int?platformFaultDomain) { var dedicatedHosts = new List <(int fd, int numberOfHosts)>(); var platformFaultDomains = DetermineFaultDomainsForPlacement(dhGroup.PlatformFaultDomainCount, platformFaultDomain); var vmsRequiredPerFaultDomain = (int)Math.Round((decimal)vmInstancesRequested / platformFaultDomains.Length, MidpointRounding.ToPositiveInfinity); foreach (var fd in platformFaultDomains) { var dhInFaultDomain = existingHostsOnDHGroup.Where(c => c.PlatformFaultDomain == fd); var availableVMCapacityInFaultDomain = 0; foreach (var host in dhInFaultDomain) { // Existing hosts can be different sku then DH Sku determined for VM size. availableVMCapacityInFaultDomain += (int)(host.InstanceView?.AvailableCapacity?.AllocatableVMs? .FirstOrDefault(v => v.VmSize.Equals(vmSku, StringComparison.InvariantCultureIgnoreCase))?.Count ?? 0); } if (vmsRequiredPerFaultDomain > availableVMCapacityInFaultDomain) { var fdHostsToBeAdded = (int)(Math.Round(((decimal)vmsRequiredPerFaultDomain - availableVMCapacityInFaultDomain) / vmCapacityPerHost, MidpointRounding.ToPositiveInfinity)); dedicatedHosts.Add((fd, fdHostsToBeAdded)); _logger.LogInformation(@$ "{fdHostsToBeAdded} Hosts to be added to PlatformFaultDomain - '{fd}'"); } } return(dedicatedHosts); int[] DetermineFaultDomainsForPlacement(int dhGroupFaultDomainCount, int?platformFaultDomain) { if (platformFaultDomain != null && platformFaultDomain > (dhGroupFaultDomainCount - 1)) { throw new Exception($"Invalid requested Platform Fault domain -Dedicated Host Group Fault Domains = {dhGroupFaultDomainCount}, requested Platform Fault domain = {platformFaultDomain}"); } return(platformFaultDomain switch { 0 => new int[] { 0 }, 1 => new int[] { 1 }, 2 => new int[] { 2 }, _ => Enumerable.Range(0, dhGroupFaultDomainCount).ToArray() // As # of small, perf of using Range not significant }); }
public void TestDedicatedHostRestart() { string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"); using (MockContext context = MockContext.Start(this.GetType())) { Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "centraluseuap"); EnsureClientsInitialized(context); string baseRGName = ComputeManagementTestUtilities.GenerateName(TestPrefix); string rgName = baseRGName + "DH"; string dhgName = "DHG-1"; string dhName = "DH-1"; try { // Create a dedicated host group, then get the dedicated host group and validate that they match DedicatedHostGroup createdDHG = CreateDedicatedHostGroup(rgName, dhgName, availabilityZone: null); DedicatedHostGroup returnedDHG = m_CrpClient.DedicatedHostGroups.Get(rgName, dhgName); ValidateDedicatedHostGroup(createdDHG, returnedDHG); //Create DedicatedHost within the DedicatedHostGroup and validate var createdDH = CreateDedicatedHost(rgName, dhgName, dhName, "ESv3-Type1"); var returnedDH = m_CrpClient.DedicatedHosts.Get(rgName, dhgName, dhName); ValidateDedicatedHost(createdDH, returnedDH); // Validate dedicated host group instance view DedicatedHostGroup returnedDHGWithInstanceView = m_CrpClient.DedicatedHostGroups.Get(rgName, dhgName, InstanceViewTypes.InstanceView); ValidateDedicatedHostGroupInstanceView(returnedDHGWithInstanceView, createdDH); // Restart the DedicatedHost m_CrpClient.DedicatedHosts.Restart(rgName, dhgName, dhName); // Delete DedicatedHost and DedicatedHostGroup m_CrpClient.DedicatedHosts.Delete(rgName, dhgName, dhName); m_CrpClient.DedicatedHostGroups.Delete(rgName, dhgName); } finally { m_ResourcesClient.ResourceGroups.Delete(rgName); Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation); } } }
private void ValidateDedicatedHostGroup(DedicatedHostGroup expectedDHG, DedicatedHostGroup actualDHG) { if (expectedDHG == null) { Assert.Null(actualDHG); } else { Assert.NotNull(actualDHG); if (expectedDHG.Hosts == null) { Assert.Null(actualDHG.Hosts); } else { Assert.NotNull(actualDHG); Assert.True(actualDHG.Hosts.SequenceEqual(expectedDHG.Hosts)); } Assert.AreEqual(expectedDHG.Location, actualDHG.Location); Assert.AreEqual(expectedDHG.Name, actualDHG.Name); } }
internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string hostGroupName, DedicatedHostGroup parameters) { var message = _pipeline.CreateMessage(); var request = message.Request; request.Method = RequestMethod.Put; var uri = new RawRequestUriBuilder(); uri.Reset(endpoint); uri.AppendPath("/subscriptions/", false); uri.AppendPath(subscriptionId, true); uri.AppendPath("/resourceGroups/", false); uri.AppendPath(resourceGroupName, true); uri.AppendPath("/providers/Microsoft.Compute/hostGroups/", false); uri.AppendPath(hostGroupName, true); uri.AppendQuery("api-version", "2019-12-01", true); request.Uri = uri; request.Headers.Add("Content-Type", "application/json"); var content = new Utf8JsonRequestContent(); content.JsonWriter.WriteObjectValue(parameters); request.Content = content; return(message); }
public virtual Response <DedicatedHostGroup> CreateOrUpdate(string resourceGroupName, string hostGroupName, DedicatedHostGroup parameters, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("DedicatedHostGroupsOperations.CreateOrUpdate"); scope.Start(); try { return(RestClient.CreateOrUpdate(resourceGroupName, hostGroupName, parameters, cancellationToken)); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Creates a Dedicated Host Group. /// </summary> /// <param name="token">Auth token.</param> /// <param name="azureEnvironment">Azure cloud.</param> /// <param name="tenantId">Tenant ID.</param> /// <param name="subscriptionId">Subscription ID.</param> /// <param name="resourceGroup">Resource group.</param> /// <param name="dhgName">Dedicated Host group name.</param> /// <param name="azName">Availability zone.</param> /// <param name="platformFaultDomainCount">Fault domain count.</param> /// <param name="location">Location/region.</param> public async Task <AzureOperationResponse <DedicatedHostGroup> > CreateDedicatedHostGroup( string token, AzureEnvironment azureEnvironment, string tenantId, string subscriptionId, string resourceGroup, string dhgName, string azName, int platformFaultDomainCount, string location) { if (string.IsNullOrEmpty(token)) { throw new ArgumentNullException(nameof(token)); } if (azureEnvironment == null) { throw new ArgumentNullException(nameof(azureEnvironment)); } if (string.IsNullOrEmpty(tenantId)) { throw new ArgumentNullException(nameof(tenantId)); } if (string.IsNullOrEmpty(subscriptionId)) { throw new ArgumentException(nameof(subscriptionId)); } if (string.IsNullOrEmpty(resourceGroup)) { throw new ArgumentException(nameof(resourceGroup)); } if (string.IsNullOrEmpty(dhgName)) { throw new ArgumentException(nameof(dhgName)); } if (string.IsNullOrEmpty(location)) { throw new ArgumentException(nameof(location)); } var azureCredentials = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, azureEnvironment); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = platformFaultDomainCount }; if (!string.IsNullOrEmpty(azName)) { newDedicatedHostGroup.Zones = new List <string> { azName }; } var dhgCreateRetryCount = _config.DhgCreateRetryCount; var computeManagementClient = await _dhmComputeClient.GetComputeManagementClient( subscriptionId, azureCredentials, azureEnvironment); var response = new AzureOperationResponse <DedicatedHostGroup>(); await Policy .Handle <CloudException>() .WaitAndRetryAsync( dhgCreateRetryCount, r => TimeSpan.FromSeconds(2 * r), (ex, ts, r) => _logger.LogInformation( $"Create host group {dhgName} failed. Attempt #{r}/{dhgCreateRetryCount}. Will try again in {ts.TotalSeconds} seconds. Exception={ex}")) .ExecuteAsync(async() => { response = await computeManagementClient.DedicatedHostGroups.CreateOrUpdateWithHttpMessagesAsync( resourceGroup, dhgName, newDedicatedHostGroup, null, default(CancellationToken)); }); return(response); }
public async Task TestDedicatedHostOperations() { EnsureClientsInitialized(LocationEastUs2UpperCase.ToLower()); string baseRGName = Recording.GenerateAssetName(TestPrefix); string rgName = baseRGName + "DH"; string dhgName = "DHG-1"; string dhName = "DH-1"; // Create a dedicated host group, then get the dedicated host group and validate that they match DedicatedHostGroup createdDHG = await CreateDedicatedHostGroup(rgName, dhgName); DedicatedHostGroup returnedDHG = await DedicatedHostGroupsOperations.GetAsync(rgName, dhgName); ValidateDedicatedHostGroup(createdDHG, returnedDHG); // Update existing dedicated host group DedicatedHostGroupUpdate updateDHGInput = new DedicatedHostGroupUpdate() { Tags = { { "testKey", "testValue" } } }; createdDHG.Tags.InitializeFrom(updateDHGInput.Tags); updateDHGInput.PlatformFaultDomainCount = returnedDHG.PlatformFaultDomainCount; // There is a bug in PATCH. PlatformFaultDomainCount is a required property now. returnedDHG = await DedicatedHostGroupsOperations.UpdateAsync(rgName, dhgName, updateDHGInput); ValidateDedicatedHostGroup(createdDHG, returnedDHG); //List DedicatedHostGroups by subscription and by resourceGroup var listDHGsResponse = DedicatedHostGroupsOperations.ListByResourceGroupAsync(rgName); var listDHGsResponseRes = await listDHGsResponse.ToEnumerableAsync(); Assert.IsTrue(listDHGsResponseRes.Count() == 1); //Assert.Single(listDHGsResponse); ValidateDedicatedHostGroup(createdDHG, listDHGsResponseRes.First()); listDHGsResponse = DedicatedHostGroupsOperations.ListBySubscriptionAsync(); listDHGsResponseRes = await listDHGsResponse.ToEnumerableAsync(); //There might be multiple dedicated host groups in the subscription, we only care about the one that we created. returnedDHG = listDHGsResponseRes.First(dhg => dhg.Id == createdDHG.Id); Assert.NotNull(returnedDHG); ValidateDedicatedHostGroup(createdDHG, returnedDHG); //Create DedicatedHost within the DedicatedHostGroup and validate var createdDH = await CreateDedicatedHost(rgName, dhgName, dhName); var returnedDH = await DedicatedHostsOperations.GetAsync(rgName, dhgName, dhName); ValidateDedicatedHost(createdDH, returnedDH); //List DedicatedHosts var listDHsResponse = DedicatedHostsOperations.ListByHostGroupAsync(rgName, dhgName); var listDHsResponseRes = await listDHsResponse.ToEnumerableAsync(); Assert.IsTrue(listDHsResponseRes.Count() == 1); ValidateDedicatedHost(createdDH, listDHsResponseRes.First()); //Delete DedicatedHosts and DedicatedHostGroups await WaitForCompletionAsync(await DedicatedHostsOperations.StartDeleteAsync(rgName, dhgName, dhName)); await DedicatedHostGroupsOperations.DeleteAsync(rgName, dhgName); WaitMinutes(1); }
public async Task <IActionResult> TestDhmConcurrentVmCreation( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(ResourceGroupName) || string.IsNullOrEmpty(parameters[ResourceGroupName])) { return(new BadRequestObjectResult("Resource group name was missing in the query parameters.")); } if (!parameters.ContainsKey(HostGroupName) || string.IsNullOrEmpty(parameters[HostGroupName])) { return(new BadRequestObjectResult("Host group name was missing in the query parameters.")); } if (!parameters.ContainsKey(VmCount) || string.IsNullOrEmpty(parameters[VmCount])) { return(new BadRequestObjectResult("VmCount was missing in the query parameters.")); } if (!parameters.ContainsKey(VmSku) || string.IsNullOrEmpty(parameters[VmSku])) { return(new BadRequestObjectResult("VM SKU was missing in the query parameters.")); } var authEndpoint = _configuration["AuthEndpoint"]; var azureRmEndpoint = _configuration["AzureRmEndpoint"]; var location = _configuration["Location"]; var virtualMachineSize = parameters[VmSku]; var numVirtualMachines = int.Parse(parameters[VmCount]); var tenantId = _configuration["TenantId"]; var clientId = _configuration["ClientId"]; var clientSecret = _configuration["FairfaxClientSecret"]; var subscriptionId = _configuration["SubscriptionId"]; var resourceGroupName = parameters[ResourceGroupName]; var hostGroupName = parameters[HostGroupName]; log.LogInformation($"Generating auth token..."); var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(_configuration["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(_configuration["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(_configuration["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; log.LogInformation($"Creating resource group ({resourceGroupName}), if needed"); var resourceGroup = azure.ResourceGroups.Define(resourceGroupName) .WithRegion(location) .Create(); log.LogInformation($"Creating host group ({hostGroupName}), if needed"); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = 1 }; await computeManagementClient.DedicatedHostGroups.CreateOrUpdateAsync( resourceGroupName, hostGroupName, newDedicatedHostGroup); var taskList = new List <Task <HttpResponseMessage> >(); var inputDictionary = new Dictionary <string, StringContent>(); for (var i = 0; i < numVirtualMachines; i++) { var vmName = $"vm{i}-{new Random().Next(1, 10000)}"; log.LogInformation($"Configuring (not provisioning) VM: {vmName}"); var virtualMachine = CreateVmHelper.CreateVirtualMachine( computeManagementClient, azure, Region.Create(location), resourceGroupName, vmName, virtualMachineSize, null, "pip-" + Guid.NewGuid(), "adh-poc-vnet", "nic-" + Guid.NewGuid()); #if DEBUG var createVmUri = $"http://localhost:7071/api/CreateVm" + $"?token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #else var createVmUri = _configuration["DhmCreateVmnUri"] + $"&token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #endif var httpContent = new StringContent(JsonConvert.SerializeObject(virtualMachine), Encoding.UTF8, "application/json"); inputDictionary[createVmUri] = httpContent; } foreach (var item in inputDictionary) { taskList.Add(_httpClient.PostAsync(item.Key, item.Value)); } await Task.WhenAll(taskList); return(new OkObjectResult($"VM provisioning kicked off successfully for {numVirtualMachines} VMs - exiting.")); }
/// <summary> /// Create or update a dedicated host group. For details of Dedicated Host and /// Dedicated Host Groups please see [Dedicated Host Documentation] /// (https://go.microsoft.com/fwlink/?linkid=2082596) /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='hostGroupName'> /// The name of the dedicated host group. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Dedicated Host Group. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <DedicatedHostGroup> CreateOrUpdateAsync(this IDedicatedHostGroupsOperations operations, string resourceGroupName, string hostGroupName, DedicatedHostGroup parameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, hostGroupName, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Create or update a dedicated host group. For details of Dedicated Host and /// Dedicated Host Groups please see [Dedicated Host Documentation] /// (https://go.microsoft.com/fwlink/?linkid=2082596) /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='hostGroupName'> /// The name of the dedicated host group. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Dedicated Host Group. /// </param> public static DedicatedHostGroup CreateOrUpdate(this IDedicatedHostGroupsOperations operations, string resourceGroupName, string hostGroupName, DedicatedHostGroup parameters) { return(operations.CreateOrUpdateAsync(resourceGroupName, hostGroupName, parameters).GetAwaiter().GetResult()); }
public static async Task Main(string[] args) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddUserSecrets <DedicatedHostsManagerConsoleClient>() .Build(); var resourceGroupName = config["ResourceGroupName"]; var authEndpoint = config["AuthEndpoint"]; var azureRmEndpoint = config["AzureRmEndpoint"]; var location = config["Location"]; var virtualMachineSize = config["VirtualMachineSize"]; var numVirtualMachines = int.Parse(config["NumVirtualMachines"]); var tenantId = config["TenantId"]; var clientId = config["ClientId"]; var clientSecret = config["FairfaxClientSecret"]; var subscriptionId = config["SubscriptionId"]; var hostGroupName = config["HostGroupName"]; var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(config["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(config["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(config["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; var resourceGroup = azure.ResourceGroups.Define(resourceGroupName) .WithRegion(location) .Create(); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = 1 }; await computeManagementClient.DedicatedHostGroups.CreateOrUpdateAsync( resourceGroupName, hostGroupName, newDedicatedHostGroup); var taskList = new List <Task <HttpResponseMessage> >(); var inputDictionary = new Dictionary <string, StringContent>(); for (var i = 0; i < numVirtualMachines; i++) { var vmName = $"vm{i}-{new Random().Next(1,10000)}"; var virtualMachine = CreateVmHelper.CreateVirtualMachine( computeManagementClient, azure, Region.Create(location), resourceGroupName, vmName, virtualMachineSize, null, "pip-" + Guid.NewGuid(), "adh-poc-vnet", "nic-" + Guid.NewGuid()); #if DEBUG var createVmUri = $"http://localhost:7071/api/CreateVm" + $"?token={token}" + $"&cloudName={config["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #else var createVmUri = config["DhmCreateVmnUri"] + $"&token={token}" + $"&cloudName={config["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&location={location}" + $"&vmSku={virtualMachineSize}" + $"&vmName={vmName}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&platformFaultDomainCount=1"; #endif var httpContent = new StringContent(JsonConvert.SerializeObject(virtualMachine), Encoding.UTF8, "application/json"); inputDictionary[createVmUri] = httpContent; } foreach (var item in inputDictionary) { taskList.Add(HttpClient.PostAsync(item.Key, item.Value)); } var results = await Task.WhenAll(taskList); }
public async Task <IActionResult> TestPrepareDedicatedHostGroup( [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, ILogger log) { var parameters = req.GetQueryParameterDictionary(); if (!parameters.ContainsKey(ResourceGroupName) || string.IsNullOrEmpty(parameters[ResourceGroupName])) { return(new BadRequestObjectResult("Resource group name was missing in the query parameters.")); } if (!parameters.ContainsKey(HostGroupName) || string.IsNullOrEmpty(parameters[HostGroupName])) { return(new BadRequestObjectResult("Host group name was missing in the query parameters.")); } if (!parameters.ContainsKey(VmCount) || !Int32.TryParse(parameters[VmCount], out int numVirtualMachines)) { return(new BadRequestObjectResult("VmCount was missing in the query parameters.")); } if (!parameters.ContainsKey(VmSku) || string.IsNullOrEmpty(parameters[VmSku])) { return(new BadRequestObjectResult("VM SKU was missing in the query parameters.")); } var authEndpoint = _configuration["AuthEndpoint"]; var azureRmEndpoint = _configuration["AzureRmEndpoint"]; var location = _configuration["Location"]; var virtualMachineSize = parameters[VmSku]; var tenantId = _configuration["TenantId"]; var clientId = _configuration["ClientId"]; var clientSecret = _configuration["FairfaxClientSecret"]; var subscriptionId = _configuration["SubscriptionId"]; var resourceGroupName = parameters[ResourceGroupName]; var hostGroupName = parameters[HostGroupName]; log.LogInformation($"Generating auth token..."); var token = await TokenHelper.GetToken( authEndpoint, azureRmEndpoint, tenantId, clientId, clientSecret); var customTokenProvider = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, AzureEnvironment.FromName(_configuration["CloudName"])); var client = RestClient .Configure() .WithEnvironment(AzureEnvironment.FromName(_configuration["CloudName"])) .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic) .WithCredentials(customTokenProvider) .Build(); var azure = Azure.Authenticate(client, tenantId).WithSubscription(subscriptionId); var computeManagementClient = new ComputeManagementClient(customTokenProvider) { SubscriptionId = subscriptionId, BaseUri = new Uri(_configuration["ResourceManagerUri"]), LongRunningOperationRetryTimeout = 5 }; log.LogInformation($"Creating resource group ({resourceGroupName}), if needed"); var resourceGroup = azure.ResourceGroups.Define(resourceGroupName) .WithRegion(location) .Create(); log.LogInformation($"Creating host group ({hostGroupName}), if needed"); var newDedicatedHostGroup = new DedicatedHostGroup() { Location = location, PlatformFaultDomainCount = 1 }; await computeManagementClient.DedicatedHostGroups.CreateOrUpdateAsync( resourceGroupName, hostGroupName, newDedicatedHostGroup); #if DEBUG var prepareDHGroup = $"http://localhost:7071/api/PrepareDedicatedHostGroup" + $"?token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&vmSku={virtualMachineSize}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&vmCount={numVirtualMachines}" + $"&platformFaultDomain=0"; #else var prepareDHGroup = _configuration["PrepareDHGroupUri"] + $"&token={token}" + $"&cloudName={_configuration["CloudName"]}" + $"&tenantId={tenantId}" + $"&subscriptionId={subscriptionId}" + $"&resourceGroup={resourceGroupName}" + $"&vmSku={virtualMachineSize}" + $"&dedicatedHostGroupName={hostGroupName}" + $"&vmCount={numVirtualMachines}" + $"&platformFaultDomain=0"; #endif var response = await _httpClient.GetAsync(prepareDHGroup); if (response.StatusCode != HttpStatusCode.OK) { return(new ObjectResult(new { error = $"Exception thrown by {await response.Content.ReadAsStringAsync()}" }) { StatusCode = (int)response.StatusCode }); } var dhCreated = await response.Content.ReadAsAsync <List <DedicatedHost> >(); return(new OkObjectResult($"Prepared Dedicated Host Group completed successfully {string.Join(",", dhCreated.Select(c => c.Name))} VM.")); }
public void TestDedicatedHostOperations() { string originalTestLocation = Environment.GetEnvironmentVariable("AZURE_VM_TEST_LOCATION"); using (MockContext context = MockContext.Start(this.GetType())) { Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", "eastus2"); EnsureClientsInitialized(context); string baseRGName = ComputeManagementTestUtilities.GenerateName(TestPrefix); string rgName = baseRGName + "DH"; string dhgName = "DHG-1"; string dhName = "DH-1"; try { // Create a dedicated host group, then get the dedicated host group and validate that they match DedicatedHostGroup createdDHG = CreateDedicatedHostGroup(rgName, dhgName); DedicatedHostGroup returnedDHG = m_CrpClient.DedicatedHostGroups.Get(rgName, dhgName); ValidateDedicatedHostGroup(createdDHG, returnedDHG); // Update existing dedicated host group DedicatedHostGroupUpdate updateDHGInput = new DedicatedHostGroupUpdate() { Tags = new Dictionary <string, string>() { { "testKey", "testValue" } } }; createdDHG.Tags = updateDHGInput.Tags; updateDHGInput.PlatformFaultDomainCount = returnedDHG.PlatformFaultDomainCount; // There is a bug in PATCH. PlatformFaultDomainCount is a required property now. returnedDHG = m_CrpClient.DedicatedHostGroups.Update(rgName, dhgName, updateDHGInput); ValidateDedicatedHostGroup(createdDHG, returnedDHG); //List DedicatedHostGroups by subscription and by resourceGroup var listDHGsResponse = m_CrpClient.DedicatedHostGroups.ListByResourceGroup(rgName); Assert.Single(listDHGsResponse); ValidateDedicatedHostGroup(createdDHG, listDHGsResponse.First()); listDHGsResponse = m_CrpClient.DedicatedHostGroups.ListBySubscription(); //There might be multiple dedicated host groups in the subscription, we only care about the one that we created. returnedDHG = listDHGsResponse.First(dhg => dhg.Id == createdDHG.Id); Assert.NotNull(returnedDHG); ValidateDedicatedHostGroup(createdDHG, returnedDHG); //Create DedicatedHost within the DedicatedHostGroup and validate var createdDH = CreateDedicatedHost(rgName, dhgName, dhName, "ESv3-Type1"); var returnedDH = m_CrpClient.DedicatedHosts.Get(rgName, dhgName, dhName); ValidateDedicatedHost(createdDH, returnedDH); //List DedicatedHosts var listDHsResponse = m_CrpClient.DedicatedHosts.ListByHostGroup(rgName, dhgName); Assert.Single(listDHsResponse); ValidateDedicatedHost(createdDH, listDHsResponse.First()); //Delete DedicatedHosts and DedicatedHostGroups m_CrpClient.DedicatedHosts.Delete(rgName, dhgName, dhName); m_CrpClient.DedicatedHostGroups.Delete(rgName, dhgName); } finally { m_ResourcesClient.ResourceGroups.Delete(rgName); Environment.SetEnvironmentVariable("AZURE_VM_TEST_LOCATION", originalTestLocation); } } }
public virtual async Task <Response <DedicatedHostGroup> > CreateOrUpdateAsync(string resourceGroupName, string hostGroupName, DedicatedHostGroup parameters, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("DedicatedHostGroupsClient.CreateOrUpdate"); scope.Start(); try { return(await RestClient.CreateOrUpdateAsync(resourceGroupName, hostGroupName, parameters, cancellationToken).ConfigureAwait(false)); } catch (Exception e) { scope.Failed(e); throw; } }