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 }