/// <summary> /// Select the most "packed" host. /// </summary> /// <param name="hostList">Dedicated Host collection.</param> public DedicatedHost SelectMostPackedHost(IList <DedicatedHost> hostList) { double? minCount = double.MaxValue; DedicatedHost selectedHost = null; if (hostList == null) { throw new ArgumentNullException(nameof(hostList)); } if (hostList.Count() == 1) { return(hostList.First()); } foreach (var host in hostList) { var count = host.InstanceView?.AvailableCapacity?.AllocatableVMs? .First(v => v.VmSize.Equals(_config.HostSelectorVmSize, StringComparison.InvariantCultureIgnoreCase)).Count; if (count < minCount) { minCount = count; selectedHost = host; } } if (selectedHost == null) { _logger.LogError("Could not select a host from the given host list."); } return(selectedHost); }
public async Task <Response <DedicatedHost> > GetAsync(string resourceGroupName, string hostGroupName, string hostName, CancellationToken cancellationToken = default) { if (resourceGroupName == null) { throw new ArgumentNullException(nameof(resourceGroupName)); } if (hostGroupName == null) { throw new ArgumentNullException(nameof(hostGroupName)); } if (hostName == null) { throw new ArgumentNullException(nameof(hostName)); } using var message = CreateGetRequest(resourceGroupName, hostGroupName, hostName); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 200: { DedicatedHost value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); if (document.RootElement.ValueKind == JsonValueKind.Null) { value = null; } else { value = DedicatedHost.DeserializeDedicatedHost(document.RootElement); } return(Response.FromValue(value, message.Response)); }
public async Task Get() { var hostName = Recording.GenerateAssetName("testHost-"); var host1 = await CreateDedicatedHostAsync(hostName); DedicatedHost host2 = await host1.GetAsync(); ResourceDataHelper.AssertHost(host1.Data, host2.Data); }
/// <summary> /// Retrieves VMs (number and type) that can be allocated on a Dedicated Host. /// </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="hostGroupName">Dedicated host group name.</param> /// <param name="dedicatedHost">Dedicated Host object.</param> /// <param name="dictionary">Dictionary object.</param> public virtual async Task GetAllocatableVmsOnHost( string token, AzureEnvironment azureEnvironment, string tenantId, string subscriptionId, string resourceGroup, string hostGroupName, DedicatedHost dedicatedHost, IDictionary <DedicatedHost, List <DedicatedHostAllocatableVM> > dictionary) { 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)); } var azureCredentials = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, azureEnvironment); var computeManagementClient = await _dhmComputeClient.GetComputeManagementClient( subscriptionId, azureCredentials, azureEnvironment); var dedicatedHostDetails = await computeManagementClient.DedicatedHosts.GetAsync( resourceGroup, hostGroupName, dedicatedHost.Name, InstanceViewTypes.InstanceView, default(CancellationToken)); var virtualMachineList = dedicatedHostDetails?.InstanceView?.AvailableCapacity?.AllocatableVMs?.ToList(); if (virtualMachineList == null) { _logger.LogError($"Could not get available VM list for {dedicatedHost.Id}"); return; } dictionary[dedicatedHost] = virtualMachineList; }
public async Task Get() { var collection = await GetDedicatedHostCollectionAsync(); var hostName = Recording.GenerateAssetName("testHost-"); var input = ResourceDataHelper.GetBasicDedicatedHost(DefaultLocation, "DSv3-Type1", 0); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, hostName, input); DedicatedHost host1 = lro.Value; DedicatedHost host2 = await collection.GetAsync(hostName); ResourceDataHelper.AssertHost(host1.Data, host2.Data); }
public async Task Exists() { var collection = await GetDedicatedHostCollectionAsync(); var hostName = Recording.GenerateAssetName("testHost-"); var input = ResourceDataHelper.GetBasicDedicatedHost(DefaultLocation, "DSv3-Type1", 0); var lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, hostName, input); DedicatedHost host = lro.Value; Assert.IsTrue(await collection.ExistsAsync(hostName)); Assert.IsFalse(await collection.ExistsAsync(hostName + "1")); Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await collection.ExistsAsync(null)); }
public async Task Update() { var hostName = Recording.GenerateAssetName("testHost-"); DedicatedHost dedicatedHost = await CreateDedicatedHostAsync(hostName); var updatedAutoReplaceOnFailure = false; var update = new PatchableDedicatedHostData() { AutoReplaceOnFailure = updatedAutoReplaceOnFailure }; var lro = await dedicatedHost.UpdateAsync(WaitUntil.Completed, update); DedicatedHost updatedHost = lro.Value; Assert.AreEqual(updatedAutoReplaceOnFailure, updatedHost.Data.AutoReplaceOnFailure); }
public async Task Update() { var hostName = Recording.GenerateAssetName("testHost-"); DedicatedHost dedicatedHost = await CreateDedicatedHostAsync(hostName); var updatedAutoReplaceOnFailure = false; var update = new DedicatedHostUpdateOptions() { AutoReplaceOnFailure = updatedAutoReplaceOnFailure }; var lro = await dedicatedHost.UpdateAsync(true, update); DedicatedHost updatedHost = lro.Value; Assert.AreEqual(updatedAutoReplaceOnFailure, updatedHost.Data.AutoReplaceOnFailure); }
public override async Task GetAllocatableVmsOnHost(string token, AzureEnvironment azureEnvironment, string tenantId, string subscriptionId, string resourceGroup, string hostGroupName, DedicatedHost dedicatedHost, IDictionary <DedicatedHost, List <DedicatedHostAllocatableVM> > dictionary) { var dedicatedHostList = JsonConvert.DeserializeObject <List <DedicatedHost> >( File.ReadAllText(@"TestData\dedicatedHostsInput1.json")); var host = dedicatedHostList.First(h => h.Name.Equals(dedicatedHost.Name, StringComparison.InvariantCultureIgnoreCase)); dictionary[dedicatedHost] = host.InstanceView.AvailableCapacity.AllocatableVMs.ToList(); }
public override void ExecuteCmdlet() { base.ExecuteCmdlet(); ExecuteClientAction(() => { if (ShouldProcess(this.Name, VerbsCommon.New)) { string resourceGroupName = this.ResourceGroupName; string hostGroupName = this.HostGroupName; string hostName = this.Name; DedicatedHost parameters = new DedicatedHost(); parameters.Location = this.Location; parameters.Sku = new Sku(this.Sku, null, null);; if (this.IsParameterBound(c => c.PlatformFaultDomain)) { parameters.PlatformFaultDomain = this.PlatformFaultDomain; } if (this.IsParameterBound(c => c.AutoReplaceOnFailure)) { parameters.AutoReplaceOnFailure = this.AutoReplaceOnFailure; } if (this.IsParameterBound(c => c.LicenseType)) { parameters.LicenseType = this.LicenseType; } if (this.MyInvocation.BoundParameters.ContainsKey("Tag")) { parameters.Tags = this.Tag.Cast <DictionaryEntry>().ToDictionary(ht => (string)ht.Key, ht => (string)ht.Value); } var result = DedicatedHostsClient.CreateOrUpdate(resourceGroupName, hostGroupName, hostName, parameters); var psObject = new PSHost(); ComputeAutomationAutoMapperProfile.Mapper.Map <DedicatedHost, PSHost>(result, psObject); WriteObject(psObject); } }); }
private void ValidateDedicatedHost(DedicatedHost expectedDH, DedicatedHost actualDH) { if (expectedDH == null) { Assert.Null(actualDH); } else { Assert.NotNull(actualDH); if (expectedDH.VirtualMachines == null) { Assert.Null(actualDH.VirtualMachines); } else { Assert.NotNull(actualDH); Assert.True(actualDH.VirtualMachines.SequenceEqual(expectedDH.VirtualMachines)); } Assert.Equal(expectedDH.Location, actualDH.Location); Assert.Equal(expectedDH.Name, actualDH.Name); Assert.Equal(expectedDH.HostId, actualDH.HostId); } }
/// <summary> /// Deletes a VM running on a Dedicated Host, and the Host too if it does not have /// any more VMs running. /// </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="dedicatedHostGroup">Dedicated Host group name.</param> /// <param name="vmName">VM name.</param> /// <returns></returns> public async Task DeleteVmOnDedicatedHost( string token, AzureEnvironment azureEnvironment, string tenantId, string subscriptionId, string resourceGroup, string dedicatedHostGroup, string vmName) { 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 ArgumentNullException(nameof(subscriptionId)); } if (string.IsNullOrEmpty(resourceGroup)) { throw new ArgumentNullException(nameof(resourceGroup)); } if (string.IsNullOrEmpty(dedicatedHostGroup)) { throw new ArgumentNullException(nameof(dedicatedHostGroup)); } if (string.IsNullOrEmpty(vmName)) { throw new ArgumentNullException(nameof(vmName)); } var azureCredentials = new AzureCredentials( new TokenCredentials(token), new TokenCredentials(token), tenantId, azureEnvironment); var computeManagementClient = await _dhmComputeClient.GetComputeManagementClient( subscriptionId, azureCredentials, azureEnvironment); var retryCountToCheckVm = _config.RetryCountToCheckVmState; var dedicatedHostCacheTtlMin = _config.DedicatedHostCacheTtlMin; VirtualMachine virtualMachine = null; DedicatedHost dedicatedHost = null; string hostId = null; await Policy .Handle <CloudException>() .WaitAndRetryAsync( retryCountToCheckVm, r => TimeSpan.FromSeconds(2 * r), onRetry: (ex, ts, r) => _logger.LogInformation( $"Could not get VM details for {vmName}. Attempt #{r}/{retryCountToCheckVm}. Will try again in {ts.TotalSeconds} seconds. Exception={ex}")) .ExecuteAsync(async() => { virtualMachine = await computeManagementClient.VirtualMachines.GetAsync(resourceGroup, vmName); hostId = virtualMachine?.Host?.Id; var hostName = hostId?.Split(new[] { '/' }).Last(); await computeManagementClient.VirtualMachines.DeleteAsync(resourceGroup, vmName); dedicatedHost = await computeManagementClient.DedicatedHosts.GetAsync(resourceGroup, dedicatedHostGroup, hostName, InstanceViewTypes.InstanceView); }); if (string.IsNullOrEmpty(hostId)) { _logger.LogInformation($"Could not find Host for {vmName}."); return; } if (dedicatedHost?.VirtualMachines.Count == 0) { // Avoid locking for now; revisit if needed _dedicatedHostStateManager.MarkHostForDeletion(hostId.ToLower(), DateTimeOffset.Now.ToString(), TimeSpan.FromMinutes(dedicatedHostCacheTtlMin)); if (!_dedicatedHostStateManager.IsHostInUsage(hostId.ToLower())) { await computeManagementClient.DedicatedHosts.DeleteAsync(resourceGroup, dedicatedHostGroup, dedicatedHost.Name); _dedicatedHostStateManager.UnmarkHostForDeletion(hostId.ToLower()); } } }
internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string hostGroupName, string hostName, DedicatedHost 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.AppendPath("/hosts/", false); uri.AppendPath(hostName, 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 DedicatedHostsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string hostGroupName, string hostName, DedicatedHost parameters, CancellationToken cancellationToken = default) { if (resourceGroupName == null) { throw new ArgumentNullException(nameof(resourceGroupName)); } if (hostGroupName == null) { throw new ArgumentNullException(nameof(hostGroupName)); } if (hostName == null) { throw new ArgumentNullException(nameof(hostName)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } using var scope = _clientDiagnostics.CreateScope("DedicatedHostsClient.StartCreateOrUpdate"); scope.Start(); try { var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, hostGroupName, hostName, parameters, cancellationToken); return(new DedicatedHostsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, hostGroupName, hostName, parameters).Request, originalResponse)); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Create or update a dedicated host . /// </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='hostName'> /// The name of the dedicated host . /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Dedicated Host. /// </param> public static DedicatedHost CreateOrUpdate(this IDedicatedHostsOperations operations, string resourceGroupName, string hostGroupName, string hostName, DedicatedHost parameters) { return(operations.CreateOrUpdateAsync(resourceGroupName, hostGroupName, hostName, parameters).GetAwaiter().GetResult()); }
/// <summary> /// Create or update a dedicated host . /// </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='hostName'> /// The name of the dedicated host . /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Dedicated Host. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <DedicatedHost> CreateOrUpdateAsync(this IDedicatedHostsOperations operations, string resourceGroupName, string hostGroupName, string hostName, DedicatedHost parameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, hostGroupName, hostName, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public async Task <Response> CreateOrUpdateAsync(string resourceGroupName, string hostGroupName, string hostName, DedicatedHost parameters, CancellationToken cancellationToken = default) { if (resourceGroupName == null) { throw new ArgumentNullException(nameof(resourceGroupName)); } if (hostGroupName == null) { throw new ArgumentNullException(nameof(hostGroupName)); } if (hostName == null) { throw new ArgumentNullException(nameof(hostName)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } using var message = CreateCreateOrUpdateRequest(resourceGroupName, hostGroupName, hostName, parameters); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 200: case 201: return(message.Response); default: throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false); } }