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