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