public async Task GetIfExistsAvailabilitySet()
{
#region Snippet:Managing_Availability_Set_GetIfExistsForAvailabilitySet
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroup collection for that subscription
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
string rgName = "myRgName";
ResourceGroup resourceGroup = await rgCollection.GetAsync(rgName);
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySet availabilitySet = await availabilitySetCollection.GetIfExistsAsync(availabilitySetName);
if (availabilitySet == null)
{
Console.WriteLine($"Availability Set {availabilitySetName} does not exist.");
return;
}
// At this point, we are sure that availabilitySet is a not null Availability Set, so we can use this object to perform any operations we want.
#endregion Snippet:Managing_Availability_Set_GetIfExistsForAvailabilitySet
}
public override void ExecuteCmdlet()
{
if (this.ShouldProcess(AvailabilitySet.Name, VerbsData.Update))
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var avSetParams = new AvailabilitySet
{
Location = this.AvailabilitySet.Location,
PlatformUpdateDomainCount = this.AvailabilitySet.PlatformUpdateDomainCount,
PlatformFaultDomainCount = this.AvailabilitySet.PlatformFaultDomainCount,
Tags = Tag == null ? null : Tag.Cast <DictionaryEntry>().ToDictionary(d => (string)d.Key, d => (string)d.Value),
Sku = new Sku(this.IsParameterBound(c => c.Sku) ? this.Sku : this.AvailabilitySet.Sku, null, null),
ProximityPlacementGroup = this.IsParameterBound(c => c.ProximityPlacementGroupId)
? new SubResource(this.ProximityPlacementGroupId)
: this.AvailabilitySet.ProximityPlacementGroup
};
var result = this.AvailabilitySetClient.CreateOrUpdateWithHttpMessagesAsync(
this.AvailabilitySet.ResourceGroupName,
this.AvailabilitySet.Name,
avSetParams).GetAwaiter().GetResult();
var psResult = ComputeAutoMapperProfile.Mapper.Map <PSAvailabilitySet>(result);
if (result.Body != null)
{
psResult = ComputeAutoMapperProfile.Mapper.Map(result.Body, psResult);
}
WriteObject(psResult);
});
}
}
public async Task UpdateAvailabilitySet()
{
#region Snippet:Managing_Availability_Set_UpdateAnAvailabilitySet
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroup collection for that subscription
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
// With the collection, we can create a new resource group with an specific name
string rgName = "myRgName";
ResourceGroup resourceGroup = await rgCollection.GetAsync(rgName);
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySet availabilitySet = await availabilitySetCollection.GetAsync(availabilitySetName);
// availabilitySet is an AvailabilitySet instance created above
AvailabilitySetUpdate update = new AvailabilitySetUpdate()
{
PlatformFaultDomainCount = 3
};
AvailabilitySet updatedAvailabilitySet = await availabilitySet.UpdateAsync(update);
#endregion Snippet:Managing_Availability_Set_UpdateAnAvailabilitySet
}
public async Task GetAllInSubscription()
{
var container = await GetAvailabilitySetContainerAsync();
var setName1 = Recording.GenerateAssetName("testAS-");
var setName2 = Recording.GenerateAssetName("testAS-");
var input = ResourceDataHelper.GetBasicAvailabilitySetData(DefaultLocation);
input.Tags.ReplaceWith(new Dictionary <string, string>
{
{ "key", "value" }
});
_ = await container.CreateOrUpdateAsync(setName1, input);
_ = await container.CreateOrUpdateAsync(setName2, input);
AvailabilitySet set1 = null, set2 = null;
await foreach (var availabilitySet in DefaultSubscription.GetAvailabilitySetsAsync())
{
if (availabilitySet.Data.Name == setName1)
{
set1 = availabilitySet;
}
if (availabilitySet.Data.Name == setName2)
{
set2 = availabilitySet;
}
}
Assert.NotNull(set1);
Assert.NotNull(set2);
}
private async Task VerifyNonDefaultValuesSucceed()
{
// Negative tests for a bug in 5.0.0 that read-only fields have side-effect on the request body
var testStatus = new InstanceViewStatus
{
Code = "test",
DisplayStatus = "test",
Message = "test"
};
string inputAvailabilitySetName = Recording.GenerateAssetName("asnondefault");
var inputAvailabilitySet = new AvailabilitySet(TestEnvironment.Location)
{
Tags =
{
{ "RG", "rg" },
{ "testTag", "1" },
},
PlatformFaultDomainCount = nonDefaultFD,
PlatformUpdateDomainCount = nonDefaultUD
};
var createOrUpdateResponse = (await AvailabilitySetsOperations.CreateOrUpdateAsync(
resourceGroup1Name,
inputAvailabilitySetName,
inputAvailabilitySet)).Value;
// This call will also delete the Availability Set
await ValidateResults(createOrUpdateResponse, inputAvailabilitySet, resourceGroup1Name, inputAvailabilitySetName, nonDefaultFD, nonDefaultUD);
}
private void VerifyDefaultValuesSucceed()
{
var inputAvailabilitySetName = ComputeManagementTestUtilities.GenerateName("asdefaultvalues");
var inputAvailabilitySet = new AvailabilitySet
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "RG", "rg" },
{ "testTag", "1" },
},
};
var createOrUpdateResponse = computeClient.AvailabilitySets.CreateOrUpdate(
resourceGroupName,
inputAvailabilitySetName,
inputAvailabilitySet);
// List AvailabilitySets
string expectedAvailabilitySetId = Helpers.GetAvailabilitySetRef(subId, resourceGroupName, inputAvailabilitySetName);
var listResponse = computeClient.AvailabilitySets.List(resourceGroupName);
ValidateAvailabilitySet(inputAvailabilitySet, listResponse.FirstOrDefault(x => x.Name == inputAvailabilitySetName),
inputAvailabilitySetName, expectedAvailabilitySetId, defaultFD, defaultUD);
// This call will also delete the Availability Set
ValidateResults(createOrUpdateResponse, inputAvailabilitySet, inputAvailabilitySetName, defaultFD, defaultUD);
}
private void CreateVms(ResourceGroup resourceGroup, AvailabilitySet aset, SubnetOperations subnet)
{
List <ArmOperation <VirtualMachine> > operations = new List <ArmOperation <VirtualMachine> >();
for (int i = 0; i < 10; i++)
{
// Create IP Address
Console.WriteLine("--------Start create IP Address--------");
var ipAddress = resourceGroup.PublicIpAddresses().Construct().Create($"{Context.VmName}_{i}_ip").Value;
// Create Network Interface
Console.WriteLine("--------Start create Network Interface--------");
var nic = resourceGroup.NetworkInterfaces().Construct(ipAddress.Data, subnet.Id).Create($"{Context.VmName}_{i}_nic").Value;
// Create VM
string num = i % 2 == 0 ? "-e" : "-o";
string name = $"{Context.VmName}{i}{num}";
Console.WriteLine("--------Start create VM {0}--------", i);
var vmOp = resourceGroup.VirtualMachines().Construct(name, "admin-user", "!@#$%asdfA", nic.Id, aset.Data).StartCreate(name);
operations.Add(vmOp);
}
foreach (var operation in operations)
{
var vm = operation.WaitForCompletionAsync().ConfigureAwait(false).GetAwaiter().GetResult().Value;
Console.WriteLine($"--------Finished creating VM {vm.Id.Name}");
}
}
public async Task <Response <AvailabilitySet> > CreateOrUpdateAsync(string resourceGroupName, string availabilitySetName, AvailabilitySet parameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (availabilitySetName == null)
{
throw new ArgumentNullException(nameof(availabilitySetName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var message = CreateCreateOrUpdateRequest(resourceGroupName, availabilitySetName, parameters);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
AvailabilitySet value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = AvailabilitySet.DeserializeAvailabilitySet(document.RootElement);
return(Response.FromValue(value, message.Response));
}
private void VerifyNonDefaultValuesSucceed()
{
// Negative tests for a bug in 5.0.0 that read-only fields have side-effect on the request body
var testStatus = new InstanceViewStatus
{
Code = "test",
DisplayStatus = "test",
Message = "test"
};
var inputAvailabilitySet = new AvailabilitySet
{
Location = location,
Name = TestUtilities.GenerateName("asnondefault"),
Tags = new Dictionary <string, string>()
{
{ "RG", "rg" },
{ "testTag", "1" },
},
PlatformFaultDomainCount = nonDefaultFD,
PlatformUpdateDomainCount = nonDefaultUD,
Statuses = new List <InstanceViewStatus>()
{
testStatus
}
};
var createOrUpdateResponse = computeClient.AvailabilitySets.CreateOrUpdate(
resourceGroupName,
inputAvailabilitySet);
// This call will also delete the Availability Set
ValidateResults(createOrUpdateResponse, inputAvailabilitySet, nonDefaultFD, nonDefaultUD);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var avSetParams = new AvailabilitySet
{
Location = this.Location,
PlatformUpdateDomainCount = this.PlatformUpdateDomainCount,
PlatformFaultDomainCount = this.PlatformFaultDomainCount
};
var result = this.AvailabilitySetClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.Name,
avSetParams).GetAwaiter().GetResult();
var psResult = Mapper.Map <PSAvailabilitySet>(result);
if (result.Body != null)
{
psResult = Mapper.Map(result.Body, psResult);
}
WriteObject(psResult);
});
}
public async Task CreateAvailabilitySet()
{
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroup collection for that subscription
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
// With the collection, we can create a new resource group with an specific name
string rgName = "myRgName";
AzureLocation location = AzureLocation.WestUS2;
ResourceGroupCreateOrUpdateOperation rgLro = await rgCollection.CreateOrUpdateAsync(rgName, new ResourceGroupData(location));
ResourceGroup resourceGroup = rgLro.Value;
#region Snippet:Managing_Availability_Set_CreateAnAvailabilitySet
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
string availabilitySetName = "myAvailabilitySet";
AvailabilitySetData input = new AvailabilitySetData(location);
AvailabilitySetCreateOrUpdateOperation lro = await availabilitySetCollection.CreateOrUpdateAsync(true, availabilitySetName, input);
AvailabilitySet availabilitySet = lro.Value;
#endregion Snippet:Managing_Availability_Set_CreateAnAvailabilitySet
}
internal void Bind(TreeNode availabilitySetNode)
{
_armAvailabilitySetNode = availabilitySetNode;
AvailabilitySet armAvailabilitySet = (AvailabilitySet)_armAvailabilitySetNode.Tag;
//lblAccountType.Text = asmCloudService.AccountType;
txtTargetName.Text = armAvailabilitySet.TargetName;
}
public async Task Get()
{
var setName = Recording.GenerateAssetName("testAS-");
var set1 = await CreateAvailabilitySetAsync(setName);
AvailabilitySet set2 = await set1.GetAsync();
ResourceDataHelper.AssertAvailabilitySet(set1.Data, set2.Data);
}
public async Task PlacementGroupId()
{
var asetName = Recording.GenerateAssetName("aset-");
AvailabilitySet aset = await CreateAvailabilitySetAsync(asetName);
var beforeAdd = aset.Data.ProximityPlacementGroupId;
ResourceGroup rg = Client.GetResourceGroup(ResourceGroup.CreateResourceIdentifier(aset.Id.SubscriptionId, aset.Id.ResourceGroupName));
var proxGrpName = Recording.GenerateAssetName("proxGrp-");
ProximityPlacementGroup proxGrp = (await rg.GetProximityPlacementGroups().CreateOrUpdateAsync(true, proxGrpName, new ProximityPlacementGroupData(DefaultLocation))).Value;
AvailabilitySetUpdateOptions updateOptions = new AvailabilitySetUpdateOptions();
updateOptions.ProximityPlacementGroupId = proxGrp.Id;
aset = await aset.UpdateAsync(updateOptions);
var addIdResult = aset.Data.ProximityPlacementGroupId;
updateOptions.ProximityPlacementGroupId = null;
aset = await aset.UpdateAsync(updateOptions);
var removeIdResult = aset.Data.ProximityPlacementGroupId;
var asetName2 = Recording.GenerateAssetName("aset-");
AvailabilitySet aset2 = await CreateAvailabilitySetAsync(asetName2);
var newBeforeAdd = aset2.Data.ProximityPlacementGroup?.Id;
AvailabilitySetUpdateOptions updateOptions2 = new AvailabilitySetUpdateOptions();
updateOptions2.ProximityPlacementGroup = new Resources.Models.WritableSubResource();
updateOptions2.ProximityPlacementGroup.Id = proxGrp.Id;
aset2 = await aset2.UpdateAsync(updateOptions2);
var newAddIdResult = aset2.Data.ProximityPlacementGroup.Id;
updateOptions2.ProximityPlacementGroup.Id = null;
aset2 = await aset2.UpdateAsync(updateOptions2);
var newRemoveIdResult = aset2.Data.ProximityPlacementGroup?.Id;
updateOptions2.ProximityPlacementGroup.Id = proxGrp.Id;
aset2 = await aset2.UpdateAsync(updateOptions2);
Assert.NotNull(aset2.Data.ProximityPlacementGroup.Id);
updateOptions2.ProximityPlacementGroup = null;
aset2 = await aset2.UpdateAsync(updateOptions2);
var newRemoveOuterIdResult = aset2.Data.ProximityPlacementGroup?.Id;
Assert.AreEqual(beforeAdd, newBeforeAdd);
Assert.AreEqual(addIdResult, newAddIdResult);
Assert.AreEqual(removeIdResult, newRemoveIdResult);
Assert.AreEqual(removeIdResult, newRemoveOuterIdResult);
}
protected PSArgument[] CreateAvailabilitySetCreateOrUpdateParameters()
{
string resourceGroupName = string.Empty;
string name = string.Empty;
AvailabilitySet parameters = new AvailabilitySet();
return(ConvertFromObjectsToArguments(
new string[] { "ResourceGroupName", "Name", "Parameters" },
new object[] { resourceGroupName, name, parameters }));
}
protected void ExecuteAvailabilitySetCreateOrUpdateMethod(object[] invokeMethodInputParameters)
{
string resourceGroupName = (string)ParseParameter(invokeMethodInputParameters[0]);
string name = (string)ParseParameter(invokeMethodInputParameters[1]);
AvailabilitySet parameters = (AvailabilitySet)ParseParameter(invokeMethodInputParameters[2]);
var result = AvailabilitySetsClient.CreateOrUpdate(resourceGroupName, name, parameters);
WriteObject(result);
}
private void txtTargetName_TextChanged(object sender, EventArgs e)
{
TextBox txtSender = (TextBox)sender;
AvailabilitySet armAvailabilitySet = (AvailabilitySet)_armAvailabilitySetNode.Tag;
armAvailabilitySet.TargetName = txtSender.Text;
_armAvailabilitySetNode.Text = armAvailabilitySet.GetFinalTargetName();
PropertyChanged();
}
public async Task Update()
{
var setName = Recording.GenerateAssetName("testAS-");
var set = await CreateAvailabilitySetAsync(setName);
var updatedPlatformFaultDomainCount = 3;
var update = new AvailabilitySetUpdate()
{
PlatformFaultDomainCount = updatedPlatformFaultDomainCount
};
AvailabilitySet updatedSet = await set.UpdateAsync(update);
Assert.AreEqual(updatedPlatformFaultDomainCount, updatedSet.Data.PlatformFaultDomainCount);
}
private AvailabilitySet BuildAvailabilitySet(bool protect)
{
var _ = new AvailabilitySet("foodAvailabilitySet2", new AvailabilitySetArgs
{
ResourceGroupName = _ResourceGroup.Name,
Location = _ResourceGroup.Location,
Name = "foodAvailabilitySet2"
}, new CustomResourceOptions
{
Protect = protect
});
return(_);
}
/// <summary>
/// Create a virtual machine availability set.
/// </summary>
/// <param name="bearerToken">Authorization bearer token</param>
/// <param name="availabilitySettings">Settings of the VM availability set to create or update. Note that not all settings work!</param>
/// <returns>Virtual Machine availability set. NULL if there was a problem</returns>
public static async Task <AvailabilitySet?> Update(string bearerToken, AvailabilitySet availabilitySettings)
{
if (string.IsNullOrWhiteSpace(bearerToken))
{
throw new ArgumentNullException(nameof(bearerToken));
}
if (availabilitySettings == null)
{
throw new ArgumentNullException(nameof(availabilitySettings));
}
RestApiResponse response = await RestApiClient.PUT(
bearerToken,
$"https://management.azure.com/{availabilitySettings.ResourceId[1..]}",
public async Task ManageAvailabilitySetOld()
{
#region Snippet:Readme_ManageAvailabilitySetOld
ResourceIdentifier id = new ResourceIdentifier("/subscriptions/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/resourceGroups/workshop2021-rg/providers/Microsoft.Compute/availabilitySets/ws2021availSet");
// We construct a new armClient to work with
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Next we get the specific subscription this resource belongs to
Subscription subscription = await armClient.GetSubscriptions().GetAsync(id.SubscriptionId);
// Next we get the specific resource group this resource belongs to
ResourceGroup resourceGroup = await subscription.GetResourceGroups().GetAsync(id.ResourceGroupName);
// Finally we get the resource itself
// Note: for this last step in this example, Azure.ResourceManager.Compute is needed
AvailabilitySet availabilitySet = await resourceGroup.GetAvailabilitySets().GetAsync(id.Name);
#endregion Snippet:Readme_ManageAvailabilitySetOld
}
public async Task <AvailabilitySet> GetCalenderInormationAsync(IConfiguration configuration, ILogger _logger, RequestParameters requestparams)
{
var EnvironmentVariable = configuration.GetSection("EnvironmentVariable");
var availabilitySet = new AvailabilitySet
{
AvailabilityRecord = new List <AvailabilityRecord>()
};
logger = _logger;
try
{
clientURL = EnvironmentVariable.GetValue <string>("GraphAPIEndpointUri");
String bearerToken = "Bearer " + EnvironmentVariable.GetValue <string>("AccessToken");
var parameters = new CalenderScheduleParameters
{
availabilityViewInterval = EnvironmentVariable.GetValue <string>("availabilityViewInterval")
};
parameters.StartTime = new StartTime
{
dateTime = requestparams.StartDate.Value.Date,
timeZone = requestparams.TimeZone
};
parameters.EndTime = new EndTime
{
dateTime = requestparams.EndDate.Value.Date.AddHours(23).AddMinutes(59).AddSeconds(59),
timeZone = requestparams.TimeZone
};
var batchSize = 1;
int numberOfBatches = (int)Math.Ceiling((double)requestparams.EmailId.Count() / batchSize);
var tasks = new List <Task <List <AvailabilityRecord> > >();
for (int i = 0; i < numberOfBatches; i++)
{
var currentIds = requestparams.EmailId.Skip(i * batchSize).Take(batchSize);
tasks.Add(GetAvailability(parameters, currentIds, bearerToken));
}
var result = (await Task.WhenAll(tasks)).SelectMany(u => u);
availabilitySet.AvailabilityRecord.AddRange(result);
}
catch (Exception ex)
{
logger.LogError($"Error in GRAPH API Call {ex.Message}");
}
return(availabilitySet);
}
public async Task ManageAvailabilitySetNow()
{
#region Snippet:Readme_ManageAvailabilitySetNow
ResourceIdentifier resourceId = new ResourceIdentifier("/subscriptions/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/resourceGroups/workshop2021-rg/providers/Microsoft.Compute/availabilitySets/ws2021availSet");
// We construct a new client to work with
ArmClient client = new ArmClient(new DefaultAzureCredential());
// Next we get the AvailabilitySet resource client from the client
// The method takes in a ResourceIdentifier but we can use the implicit cast from string
AvailabilitySet availabilitySet = client.GetAvailabilitySet(resourceId);
// At this point availabilitySet.Data will be null and trying to access it will throw
// If we want to retrieve the objects data we can simply call get
availabilitySet = await availabilitySet.GetAsync();
// we now have the data representing the availabilitySet
Console.WriteLine(availabilitySet.Data.Name);
#endregion Snippet:Readme_ManageAvailabilitySetNow
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var avSetParams = new AvailabilitySet
{
Location = this.Location,
PlatformUpdateDomainCount = this.PlatformUpdateDomainCount,
PlatformFaultDomainCount = this.PlatformFaultDomainCount,
#pragma warning disable CS0618 // Type or member is obsolete
Managed = this.Managed.IsPresent ? (bool?)true : null
#pragma warning restore CS0618 // Type or member is obsolete
};
#pragma warning disable CS0618 // Type or member is obsolete
if (this.Managed.IsPresent || !string.IsNullOrEmpty(this.Sku))
#pragma warning restore CS0618 // Type or member is obsolete
{
avSetParams.Sku = new Sku();
if (!string.IsNullOrEmpty(this.Sku))
{
avSetParams.Sku.Name = this.Sku;
}
#pragma warning disable CS0618 // Type or member is obsolete
if (this.Managed.IsPresent)
#pragma warning restore CS0618 // Type or member is obsolete
{
avSetParams.Sku.Name = "Aligned";
}
}
var result = this.AvailabilitySetClient.CreateOrUpdateWithHttpMessagesAsync(
this.ResourceGroupName,
this.Name,
avSetParams).GetAwaiter().GetResult();
var psResult = Mapper.Map <PSAvailabilitySet>(result);
if (result.Body != null)
{
psResult = Mapper.Map(result.Body, psResult);
}
WriteObject(psResult);
});
}
/// <summary>
/// Virtual Machine property
/// </summary>
/// <param name="_multiVM"></param>
/// <param name="_hasDataDisk"></param>
/// <param name="_useAvSet"></param>
/// <param name="_useDiagAcc"></param>
public Property_VirtualMachine(bool _multiVM, bool _hasDataDisk, bool _useAvSet, bool _useDiagAcc)
{
osProfile = new OsProfile(_multiVM);
hardwareProfile = new HardwareProfile();
storageProfile = new StorageProfile(_hasDataDisk);
networkProfile = new NetworkProfile(_multiVM);
// Diagnostic Account
if (_useDiagAcc)
{
diagnosticsProfile = new DiagnosticsProfile();
}
// Availability Set
if (_useAvSet)
{
availabilitySet = new AvailabilitySet();
}
}
public override void ExecuteCmdlet()
{
if (this.ShouldProcess(AvailabilitySet.Name, VerbsData.Update))
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var avSetParams = new AvailabilitySet
{
Location = this.AvailabilitySet.Location,
PlatformUpdateDomainCount = this.AvailabilitySet.PlatformUpdateDomainCount,
PlatformFaultDomainCount = this.AvailabilitySet.PlatformFaultDomainCount,
Tags = Tag == null ? null : Tag.Cast <DictionaryEntry>().ToDictionary(d => (string)d.Key, d => (string)d.Value)
};
if (this.ParameterSetName.Equals(ManagedParamterSetName))
{
avSetParams.Sku = new Sku
{
Name = "Aligned"
};
}
else
{
avSetParams.Sku = new Sku
{
Name = this.Sku
};
}
var result = this.AvailabilitySetClient.CreateOrUpdateWithHttpMessagesAsync(
this.AvailabilitySet.ResourceGroupName,
this.AvailabilitySet.Name,
avSetParams).GetAwaiter().GetResult();
var psResult = ComputeAutoMapperProfile.Mapper.Map <PSAvailabilitySet>(result);
if (result.Body != null)
{
psResult = ComputeAutoMapperProfile.Mapper.Map(result.Body, psResult);
}
WriteObject(psResult);
});
}
}
public override void ExecuteCmdlet()
{
if (this.ShouldProcess(AvailabilitySet.Name, VerbsData.Update))
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
var avSetParams = new AvailabilitySet
{
Location = this.AvailabilitySet.Location,
PlatformUpdateDomainCount = this.AvailabilitySet.PlatformUpdateDomainCount,
PlatformFaultDomainCount = this.AvailabilitySet.PlatformFaultDomainCount
};
if (this.ParameterSetName.Equals(ManagedParamterSetName))
{
avSetParams.Managed = true;
avSetParams.Sku = new Sku
{
Name = "Aligned"
};
}
else
{
avSetParams.Sku = new Sku
{
Name = this.Sku
};
}
var result = this.AvailabilitySetClient.CreateOrUpdateWithHttpMessagesAsync(
this.AvailabilitySet.ResourceGroupName,
this.AvailabilitySet.Name,
avSetParams).GetAwaiter().GetResult();
var psResult = Mapper.Map <PSAvailabilitySet>(result);
if (result.Body != null)
{
psResult = Mapper.Map(result.Body, psResult);
}
WriteObject(psResult);
});
}
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
var avSetParams = new AvailabilitySet
{
Name = this.Name,
Location = this.Location,
PlatformUpdateDomainCount = this.PlatformUpdateDomainCount,
PlatformFaultDomainCount = this.PlatformFaultDomainCount
};
var op = this.AvailabilitySetClient.CreateOrUpdate(
this.ResourceGroupName,
avSetParams);
WriteObject(op);
}
public async Task Get()
{
var container = await GetAvailabilitySetContainerAsync();
var setName = Recording.GenerateAssetName("testAS-");
var input = ResourceDataHelper.GetBasicAvailabilitySetData(DefaultLocation);
input.Tags.ReplaceWith(new Dictionary <string, string>
{
{ "key", "value" }
});
var lro = await container.CreateOrUpdateAsync(setName, input);
AvailabilitySet set1 = lro.Value;
AvailabilitySet set2 = await container.GetAsync(setName);
ResourceDataHelper.AssertAvailabilitySet(set1.Data, set2.Data);
}
public async Task ManageAvailabilitySetPieces()
{
#region Snippet:Readme_ManageAvailabilitySetPieces
string subscriptionId = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
string resourceGroupName = "workshop2021-rg";
string availabilitySetName = "ws2021availSet";
ResourceIdentifier resourceId = AvailabilitySet.CreateResourceIdentifier(subscriptionId, resourceGroupName, availabilitySetName);
// We construct a new armClient to work with
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Next we get the AvailabilitySet resource client from the armClient
// The method takes in a ResourceIdentifier but we can use the implicit cast from string
AvailabilitySet availabilitySet = armClient.GetAvailabilitySet(resourceId);
// At this point availabilitySet.Data will be null and trying to access it will throw
// If we want to retrieve the objects data we can simply call get
availabilitySet = await availabilitySet.GetAsync();
// we now have the data representing the availabilitySet
Console.WriteLine(availabilitySet.Data.Name);
#endregion Snippet:Readme_ManageAvailabilitySetPieces
}
