1package compute 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "github.com/Azure/go-autorest/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// VirtualMachineScaleSetsClient is the compute Client 30type VirtualMachineScaleSetsClient struct { 31 BaseClient 32} 33 34// NewVirtualMachineScaleSetsClient creates an instance of the VirtualMachineScaleSetsClient client. 35func NewVirtualMachineScaleSetsClient(subscriptionID string) VirtualMachineScaleSetsClient { 36 return NewVirtualMachineScaleSetsClientWithBaseURI(DefaultBaseURI, subscriptionID) 37} 38 39// NewVirtualMachineScaleSetsClientWithBaseURI creates an instance of the VirtualMachineScaleSetsClient client using a 40// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, 41// Azure stack). 42func NewVirtualMachineScaleSetsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineScaleSetsClient { 43 return VirtualMachineScaleSetsClient{NewWithBaseURI(baseURI, subscriptionID)} 44} 45 46// ConvertToSinglePlacementGroup converts SinglePlacementGroup property to false for a existing virtual machine scale 47// set. 48// Parameters: 49// resourceGroupName - the name of the resource group. 50// VMScaleSetName - the name of the virtual machine scale set to create or update. 51// parameters - the input object for ConvertToSinglePlacementGroup API. 52func (client VirtualMachineScaleSetsClient) ConvertToSinglePlacementGroup(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VMScaleSetConvertToSinglePlacementGroupInput) (result autorest.Response, err error) { 53 if tracing.IsEnabled() { 54 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ConvertToSinglePlacementGroup") 55 defer func() { 56 sc := -1 57 if result.Response != nil { 58 sc = result.Response.StatusCode 59 } 60 tracing.EndSpan(ctx, sc, err) 61 }() 62 } 63 req, err := client.ConvertToSinglePlacementGroupPreparer(ctx, resourceGroupName, VMScaleSetName, parameters) 64 if err != nil { 65 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ConvertToSinglePlacementGroup", nil, "Failure preparing request") 66 return 67 } 68 69 resp, err := client.ConvertToSinglePlacementGroupSender(req) 70 if err != nil { 71 result.Response = resp 72 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ConvertToSinglePlacementGroup", resp, "Failure sending request") 73 return 74 } 75 76 result, err = client.ConvertToSinglePlacementGroupResponder(resp) 77 if err != nil { 78 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ConvertToSinglePlacementGroup", resp, "Failure responding to request") 79 } 80 81 return 82} 83 84// ConvertToSinglePlacementGroupPreparer prepares the ConvertToSinglePlacementGroup request. 85func (client VirtualMachineScaleSetsClient) ConvertToSinglePlacementGroupPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VMScaleSetConvertToSinglePlacementGroupInput) (*http.Request, error) { 86 pathParameters := map[string]interface{}{ 87 "resourceGroupName": autorest.Encode("path", resourceGroupName), 88 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 89 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 90 } 91 92 const APIVersion = "2019-12-01" 93 queryParameters := map[string]interface{}{ 94 "api-version": APIVersion, 95 } 96 97 preparer := autorest.CreatePreparer( 98 autorest.AsContentType("application/json; charset=utf-8"), 99 autorest.AsPost(), 100 autorest.WithBaseURL(client.BaseURI), 101 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/convertToSinglePlacementGroup", pathParameters), 102 autorest.WithJSON(parameters), 103 autorest.WithQueryParameters(queryParameters)) 104 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 105} 106 107// ConvertToSinglePlacementGroupSender sends the ConvertToSinglePlacementGroup request. The method will close the 108// http.Response Body if it receives an error. 109func (client VirtualMachineScaleSetsClient) ConvertToSinglePlacementGroupSender(req *http.Request) (*http.Response, error) { 110 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 111} 112 113// ConvertToSinglePlacementGroupResponder handles the response to the ConvertToSinglePlacementGroup request. The method always 114// closes the http.Response Body. 115func (client VirtualMachineScaleSetsClient) ConvertToSinglePlacementGroupResponder(resp *http.Response) (result autorest.Response, err error) { 116 err = autorest.Respond( 117 resp, 118 client.ByInspecting(), 119 azure.WithErrorUnlessStatusCode(http.StatusOK), 120 autorest.ByClosing()) 121 result.Response = resp 122 return 123} 124 125// CreateOrUpdate create or update a VM scale set. 126// Parameters: 127// resourceGroupName - the name of the resource group. 128// VMScaleSetName - the name of the VM scale set to create or update. 129// parameters - the scale set object. 130func (client VirtualMachineScaleSetsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSet) (result VirtualMachineScaleSetsCreateOrUpdateFuture, err error) { 131 if tracing.IsEnabled() { 132 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.CreateOrUpdate") 133 defer func() { 134 sc := -1 135 if result.Response() != nil { 136 sc = result.Response().StatusCode 137 } 138 tracing.EndSpan(ctx, sc, err) 139 }() 140 } 141 if err := validation.Validate([]validation.Validation{ 142 {TargetValue: parameters, 143 Constraints: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties", Name: validation.Null, Rule: false, 144 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy", Name: validation.Null, Rule: false, 145 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy", Name: validation.Null, Rule: false, 146 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxBatchInstancePercent", Name: validation.Null, Rule: false, 147 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxBatchInstancePercent", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 148 {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxBatchInstancePercent", Name: validation.InclusiveMinimum, Rule: int64(5), Chain: nil}, 149 }}, 150 {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyInstancePercent", Name: validation.Null, Rule: false, 151 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyInstancePercent", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 152 {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyInstancePercent", Name: validation.InclusiveMinimum, Rule: int64(5), Chain: nil}, 153 }}, 154 {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyUpgradedInstancePercent", Name: validation.Null, Rule: false, 155 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyUpgradedInstancePercent", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil}, 156 {Target: "parameters.VirtualMachineScaleSetProperties.UpgradePolicy.RollingUpgradePolicy.MaxUnhealthyUpgradedInstancePercent", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil}, 157 }}, 158 }}, 159 }}, 160 }}}}}); err != nil { 161 return result, validation.NewError("compute.VirtualMachineScaleSetsClient", "CreateOrUpdate", err.Error()) 162 } 163 164 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMScaleSetName, parameters) 165 if err != nil { 166 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "CreateOrUpdate", nil, "Failure preparing request") 167 return 168 } 169 170 result, err = client.CreateOrUpdateSender(req) 171 if err != nil { 172 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "CreateOrUpdate", result.Response(), "Failure sending request") 173 return 174 } 175 176 return 177} 178 179// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 180func (client VirtualMachineScaleSetsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSet) (*http.Request, error) { 181 pathParameters := map[string]interface{}{ 182 "resourceGroupName": autorest.Encode("path", resourceGroupName), 183 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 184 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 185 } 186 187 const APIVersion = "2019-12-01" 188 queryParameters := map[string]interface{}{ 189 "api-version": APIVersion, 190 } 191 192 preparer := autorest.CreatePreparer( 193 autorest.AsContentType("application/json; charset=utf-8"), 194 autorest.AsPut(), 195 autorest.WithBaseURL(client.BaseURI), 196 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters), 197 autorest.WithJSON(parameters), 198 autorest.WithQueryParameters(queryParameters)) 199 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 200} 201 202// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 203// http.Response Body if it receives an error. 204func (client VirtualMachineScaleSetsClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachineScaleSetsCreateOrUpdateFuture, err error) { 205 var resp *http.Response 206 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 207 if err != nil { 208 return 209 } 210 future.Future, err = azure.NewFutureFromResponse(resp) 211 return 212} 213 214// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 215// closes the http.Response Body. 216func (client VirtualMachineScaleSetsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachineScaleSet, err error) { 217 err = autorest.Respond( 218 resp, 219 client.ByInspecting(), 220 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 221 autorest.ByUnmarshallingJSON(&result), 222 autorest.ByClosing()) 223 result.Response = autorest.Response{Response: resp} 224 return 225} 226 227// Deallocate deallocates specific virtual machines in a VM scale set. Shuts down the virtual machines and releases the 228// compute resources. You are not billed for the compute resources that this virtual machine scale set deallocates. 229// Parameters: 230// resourceGroupName - the name of the resource group. 231// VMScaleSetName - the name of the VM scale set. 232// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 233func (client VirtualMachineScaleSetsClient) Deallocate(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsDeallocateFuture, err error) { 234 if tracing.IsEnabled() { 235 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Deallocate") 236 defer func() { 237 sc := -1 238 if result.Response() != nil { 239 sc = result.Response().StatusCode 240 } 241 tracing.EndSpan(ctx, sc, err) 242 }() 243 } 244 req, err := client.DeallocatePreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 245 if err != nil { 246 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Deallocate", nil, "Failure preparing request") 247 return 248 } 249 250 result, err = client.DeallocateSender(req) 251 if err != nil { 252 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Deallocate", result.Response(), "Failure sending request") 253 return 254 } 255 256 return 257} 258 259// DeallocatePreparer prepares the Deallocate request. 260func (client VirtualMachineScaleSetsClient) DeallocatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) { 261 pathParameters := map[string]interface{}{ 262 "resourceGroupName": autorest.Encode("path", resourceGroupName), 263 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 264 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 265 } 266 267 const APIVersion = "2019-12-01" 268 queryParameters := map[string]interface{}{ 269 "api-version": APIVersion, 270 } 271 272 preparer := autorest.CreatePreparer( 273 autorest.AsContentType("application/json; charset=utf-8"), 274 autorest.AsPost(), 275 autorest.WithBaseURL(client.BaseURI), 276 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/deallocate", pathParameters), 277 autorest.WithQueryParameters(queryParameters)) 278 if VMInstanceIDs != nil { 279 preparer = autorest.DecoratePreparer(preparer, 280 autorest.WithJSON(VMInstanceIDs)) 281 } 282 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 283} 284 285// DeallocateSender sends the Deallocate request. The method will close the 286// http.Response Body if it receives an error. 287func (client VirtualMachineScaleSetsClient) DeallocateSender(req *http.Request) (future VirtualMachineScaleSetsDeallocateFuture, err error) { 288 var resp *http.Response 289 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 290 if err != nil { 291 return 292 } 293 future.Future, err = azure.NewFutureFromResponse(resp) 294 return 295} 296 297// DeallocateResponder handles the response to the Deallocate request. The method always 298// closes the http.Response Body. 299func (client VirtualMachineScaleSetsClient) DeallocateResponder(resp *http.Response) (result autorest.Response, err error) { 300 err = autorest.Respond( 301 resp, 302 client.ByInspecting(), 303 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 304 autorest.ByClosing()) 305 result.Response = resp 306 return 307} 308 309// Delete deletes a VM scale set. 310// Parameters: 311// resourceGroupName - the name of the resource group. 312// VMScaleSetName - the name of the VM scale set. 313func (client VirtualMachineScaleSetsClient) Delete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetsDeleteFuture, err error) { 314 if tracing.IsEnabled() { 315 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Delete") 316 defer func() { 317 sc := -1 318 if result.Response() != nil { 319 sc = result.Response().StatusCode 320 } 321 tracing.EndSpan(ctx, sc, err) 322 }() 323 } 324 req, err := client.DeletePreparer(ctx, resourceGroupName, VMScaleSetName) 325 if err != nil { 326 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Delete", nil, "Failure preparing request") 327 return 328 } 329 330 result, err = client.DeleteSender(req) 331 if err != nil { 332 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Delete", result.Response(), "Failure sending request") 333 return 334 } 335 336 return 337} 338 339// DeletePreparer prepares the Delete request. 340func (client VirtualMachineScaleSetsClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) { 341 pathParameters := map[string]interface{}{ 342 "resourceGroupName": autorest.Encode("path", resourceGroupName), 343 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 344 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 345 } 346 347 const APIVersion = "2019-12-01" 348 queryParameters := map[string]interface{}{ 349 "api-version": APIVersion, 350 } 351 352 preparer := autorest.CreatePreparer( 353 autorest.AsDelete(), 354 autorest.WithBaseURL(client.BaseURI), 355 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters), 356 autorest.WithQueryParameters(queryParameters)) 357 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 358} 359 360// DeleteSender sends the Delete request. The method will close the 361// http.Response Body if it receives an error. 362func (client VirtualMachineScaleSetsClient) DeleteSender(req *http.Request) (future VirtualMachineScaleSetsDeleteFuture, err error) { 363 var resp *http.Response 364 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 365 if err != nil { 366 return 367 } 368 future.Future, err = azure.NewFutureFromResponse(resp) 369 return 370} 371 372// DeleteResponder handles the response to the Delete request. The method always 373// closes the http.Response Body. 374func (client VirtualMachineScaleSetsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 375 err = autorest.Respond( 376 resp, 377 client.ByInspecting(), 378 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 379 autorest.ByClosing()) 380 result.Response = resp 381 return 382} 383 384// DeleteInstances deletes virtual machines in a VM scale set. 385// Parameters: 386// resourceGroupName - the name of the resource group. 387// VMScaleSetName - the name of the VM scale set. 388// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 389func (client VirtualMachineScaleSetsClient) DeleteInstances(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (result VirtualMachineScaleSetsDeleteInstancesFuture, err error) { 390 if tracing.IsEnabled() { 391 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.DeleteInstances") 392 defer func() { 393 sc := -1 394 if result.Response() != nil { 395 sc = result.Response().StatusCode 396 } 397 tracing.EndSpan(ctx, sc, err) 398 }() 399 } 400 if err := validation.Validate([]validation.Validation{ 401 {TargetValue: VMInstanceIDs, 402 Constraints: []validation.Constraint{{Target: "VMInstanceIDs.InstanceIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 403 return result, validation.NewError("compute.VirtualMachineScaleSetsClient", "DeleteInstances", err.Error()) 404 } 405 406 req, err := client.DeleteInstancesPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 407 if err != nil { 408 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "DeleteInstances", nil, "Failure preparing request") 409 return 410 } 411 412 result, err = client.DeleteInstancesSender(req) 413 if err != nil { 414 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "DeleteInstances", result.Response(), "Failure sending request") 415 return 416 } 417 418 return 419} 420 421// DeleteInstancesPreparer prepares the DeleteInstances request. 422func (client VirtualMachineScaleSetsClient) DeleteInstancesPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (*http.Request, error) { 423 pathParameters := map[string]interface{}{ 424 "resourceGroupName": autorest.Encode("path", resourceGroupName), 425 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 426 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 427 } 428 429 const APIVersion = "2019-12-01" 430 queryParameters := map[string]interface{}{ 431 "api-version": APIVersion, 432 } 433 434 preparer := autorest.CreatePreparer( 435 autorest.AsContentType("application/json; charset=utf-8"), 436 autorest.AsPost(), 437 autorest.WithBaseURL(client.BaseURI), 438 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/delete", pathParameters), 439 autorest.WithJSON(VMInstanceIDs), 440 autorest.WithQueryParameters(queryParameters)) 441 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 442} 443 444// DeleteInstancesSender sends the DeleteInstances request. The method will close the 445// http.Response Body if it receives an error. 446func (client VirtualMachineScaleSetsClient) DeleteInstancesSender(req *http.Request) (future VirtualMachineScaleSetsDeleteInstancesFuture, err error) { 447 var resp *http.Response 448 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 449 if err != nil { 450 return 451 } 452 future.Future, err = azure.NewFutureFromResponse(resp) 453 return 454} 455 456// DeleteInstancesResponder handles the response to the DeleteInstances request. The method always 457// closes the http.Response Body. 458func (client VirtualMachineScaleSetsClient) DeleteInstancesResponder(resp *http.Response) (result autorest.Response, err error) { 459 err = autorest.Respond( 460 resp, 461 client.ByInspecting(), 462 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 463 autorest.ByClosing()) 464 result.Response = resp 465 return 466} 467 468// ForceRecoveryServiceFabricPlatformUpdateDomainWalk manual platform update domain walk to update virtual machines in 469// a service fabric virtual machine scale set. 470// Parameters: 471// resourceGroupName - the name of the resource group. 472// VMScaleSetName - the name of the VM scale set. 473// platformUpdateDomain - the platform update domain for which a manual recovery walk is requested 474func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalk(ctx context.Context, resourceGroupName string, VMScaleSetName string, platformUpdateDomain int32) (result RecoveryWalkResponse, err error) { 475 if tracing.IsEnabled() { 476 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ForceRecoveryServiceFabricPlatformUpdateDomainWalk") 477 defer func() { 478 sc := -1 479 if result.Response.Response != nil { 480 sc = result.Response.Response.StatusCode 481 } 482 tracing.EndSpan(ctx, sc, err) 483 }() 484 } 485 req, err := client.ForceRecoveryServiceFabricPlatformUpdateDomainWalkPreparer(ctx, resourceGroupName, VMScaleSetName, platformUpdateDomain) 486 if err != nil { 487 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ForceRecoveryServiceFabricPlatformUpdateDomainWalk", nil, "Failure preparing request") 488 return 489 } 490 491 resp, err := client.ForceRecoveryServiceFabricPlatformUpdateDomainWalkSender(req) 492 if err != nil { 493 result.Response = autorest.Response{Response: resp} 494 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ForceRecoveryServiceFabricPlatformUpdateDomainWalk", resp, "Failure sending request") 495 return 496 } 497 498 result, err = client.ForceRecoveryServiceFabricPlatformUpdateDomainWalkResponder(resp) 499 if err != nil { 500 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ForceRecoveryServiceFabricPlatformUpdateDomainWalk", resp, "Failure responding to request") 501 } 502 503 return 504} 505 506// ForceRecoveryServiceFabricPlatformUpdateDomainWalkPreparer prepares the ForceRecoveryServiceFabricPlatformUpdateDomainWalk request. 507func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalkPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, platformUpdateDomain int32) (*http.Request, error) { 508 pathParameters := map[string]interface{}{ 509 "resourceGroupName": autorest.Encode("path", resourceGroupName), 510 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 511 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 512 } 513 514 const APIVersion = "2019-12-01" 515 queryParameters := map[string]interface{}{ 516 "api-version": APIVersion, 517 "platformUpdateDomain": autorest.Encode("query", platformUpdateDomain), 518 } 519 520 preparer := autorest.CreatePreparer( 521 autorest.AsPost(), 522 autorest.WithBaseURL(client.BaseURI), 523 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/forceRecoveryServiceFabricPlatformUpdateDomainWalk", pathParameters), 524 autorest.WithQueryParameters(queryParameters)) 525 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 526} 527 528// ForceRecoveryServiceFabricPlatformUpdateDomainWalkSender sends the ForceRecoveryServiceFabricPlatformUpdateDomainWalk request. The method will close the 529// http.Response Body if it receives an error. 530func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalkSender(req *http.Request) (*http.Response, error) { 531 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 532} 533 534// ForceRecoveryServiceFabricPlatformUpdateDomainWalkResponder handles the response to the ForceRecoveryServiceFabricPlatformUpdateDomainWalk request. The method always 535// closes the http.Response Body. 536func (client VirtualMachineScaleSetsClient) ForceRecoveryServiceFabricPlatformUpdateDomainWalkResponder(resp *http.Response) (result RecoveryWalkResponse, err error) { 537 err = autorest.Respond( 538 resp, 539 client.ByInspecting(), 540 azure.WithErrorUnlessStatusCode(http.StatusOK), 541 autorest.ByUnmarshallingJSON(&result), 542 autorest.ByClosing()) 543 result.Response = autorest.Response{Response: resp} 544 return 545} 546 547// Get display information about a virtual machine scale set. 548// Parameters: 549// resourceGroupName - the name of the resource group. 550// VMScaleSetName - the name of the VM scale set. 551func (client VirtualMachineScaleSetsClient) Get(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSet, err error) { 552 if tracing.IsEnabled() { 553 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Get") 554 defer func() { 555 sc := -1 556 if result.Response.Response != nil { 557 sc = result.Response.Response.StatusCode 558 } 559 tracing.EndSpan(ctx, sc, err) 560 }() 561 } 562 req, err := client.GetPreparer(ctx, resourceGroupName, VMScaleSetName) 563 if err != nil { 564 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Get", nil, "Failure preparing request") 565 return 566 } 567 568 resp, err := client.GetSender(req) 569 if err != nil { 570 result.Response = autorest.Response{Response: resp} 571 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Get", resp, "Failure sending request") 572 return 573 } 574 575 result, err = client.GetResponder(resp) 576 if err != nil { 577 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Get", resp, "Failure responding to request") 578 } 579 580 return 581} 582 583// GetPreparer prepares the Get request. 584func (client VirtualMachineScaleSetsClient) GetPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) { 585 pathParameters := map[string]interface{}{ 586 "resourceGroupName": autorest.Encode("path", resourceGroupName), 587 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 588 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 589 } 590 591 const APIVersion = "2019-12-01" 592 queryParameters := map[string]interface{}{ 593 "api-version": APIVersion, 594 } 595 596 preparer := autorest.CreatePreparer( 597 autorest.AsGet(), 598 autorest.WithBaseURL(client.BaseURI), 599 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters), 600 autorest.WithQueryParameters(queryParameters)) 601 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 602} 603 604// GetSender sends the Get request. The method will close the 605// http.Response Body if it receives an error. 606func (client VirtualMachineScaleSetsClient) GetSender(req *http.Request) (*http.Response, error) { 607 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 608} 609 610// GetResponder handles the response to the Get request. The method always 611// closes the http.Response Body. 612func (client VirtualMachineScaleSetsClient) GetResponder(resp *http.Response) (result VirtualMachineScaleSet, err error) { 613 err = autorest.Respond( 614 resp, 615 client.ByInspecting(), 616 azure.WithErrorUnlessStatusCode(http.StatusOK), 617 autorest.ByUnmarshallingJSON(&result), 618 autorest.ByClosing()) 619 result.Response = autorest.Response{Response: resp} 620 return 621} 622 623// GetInstanceView gets the status of a VM scale set instance. 624// Parameters: 625// resourceGroupName - the name of the resource group. 626// VMScaleSetName - the name of the VM scale set. 627func (client VirtualMachineScaleSetsClient) GetInstanceView(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetInstanceView, err error) { 628 if tracing.IsEnabled() { 629 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.GetInstanceView") 630 defer func() { 631 sc := -1 632 if result.Response.Response != nil { 633 sc = result.Response.Response.StatusCode 634 } 635 tracing.EndSpan(ctx, sc, err) 636 }() 637 } 638 req, err := client.GetInstanceViewPreparer(ctx, resourceGroupName, VMScaleSetName) 639 if err != nil { 640 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetInstanceView", nil, "Failure preparing request") 641 return 642 } 643 644 resp, err := client.GetInstanceViewSender(req) 645 if err != nil { 646 result.Response = autorest.Response{Response: resp} 647 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetInstanceView", resp, "Failure sending request") 648 return 649 } 650 651 result, err = client.GetInstanceViewResponder(resp) 652 if err != nil { 653 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetInstanceView", resp, "Failure responding to request") 654 } 655 656 return 657} 658 659// GetInstanceViewPreparer prepares the GetInstanceView request. 660func (client VirtualMachineScaleSetsClient) GetInstanceViewPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) { 661 pathParameters := map[string]interface{}{ 662 "resourceGroupName": autorest.Encode("path", resourceGroupName), 663 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 664 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 665 } 666 667 const APIVersion = "2019-12-01" 668 queryParameters := map[string]interface{}{ 669 "api-version": APIVersion, 670 } 671 672 preparer := autorest.CreatePreparer( 673 autorest.AsGet(), 674 autorest.WithBaseURL(client.BaseURI), 675 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/instanceView", pathParameters), 676 autorest.WithQueryParameters(queryParameters)) 677 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 678} 679 680// GetInstanceViewSender sends the GetInstanceView request. The method will close the 681// http.Response Body if it receives an error. 682func (client VirtualMachineScaleSetsClient) GetInstanceViewSender(req *http.Request) (*http.Response, error) { 683 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 684} 685 686// GetInstanceViewResponder handles the response to the GetInstanceView request. The method always 687// closes the http.Response Body. 688func (client VirtualMachineScaleSetsClient) GetInstanceViewResponder(resp *http.Response) (result VirtualMachineScaleSetInstanceView, err error) { 689 err = autorest.Respond( 690 resp, 691 client.ByInspecting(), 692 azure.WithErrorUnlessStatusCode(http.StatusOK), 693 autorest.ByUnmarshallingJSON(&result), 694 autorest.ByClosing()) 695 result.Response = autorest.Response{Response: resp} 696 return 697} 698 699// GetOSUpgradeHistory gets list of OS upgrades on a VM scale set instance. 700// Parameters: 701// resourceGroupName - the name of the resource group. 702// VMScaleSetName - the name of the VM scale set. 703func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistory(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListOSUpgradeHistoryPage, err error) { 704 if tracing.IsEnabled() { 705 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.GetOSUpgradeHistory") 706 defer func() { 707 sc := -1 708 if result.vmsslouh.Response.Response != nil { 709 sc = result.vmsslouh.Response.Response.StatusCode 710 } 711 tracing.EndSpan(ctx, sc, err) 712 }() 713 } 714 result.fn = client.getOSUpgradeHistoryNextResults 715 req, err := client.GetOSUpgradeHistoryPreparer(ctx, resourceGroupName, VMScaleSetName) 716 if err != nil { 717 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetOSUpgradeHistory", nil, "Failure preparing request") 718 return 719 } 720 721 resp, err := client.GetOSUpgradeHistorySender(req) 722 if err != nil { 723 result.vmsslouh.Response = autorest.Response{Response: resp} 724 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetOSUpgradeHistory", resp, "Failure sending request") 725 return 726 } 727 728 result.vmsslouh, err = client.GetOSUpgradeHistoryResponder(resp) 729 if err != nil { 730 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "GetOSUpgradeHistory", resp, "Failure responding to request") 731 } 732 733 return 734} 735 736// GetOSUpgradeHistoryPreparer prepares the GetOSUpgradeHistory request. 737func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistoryPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) { 738 pathParameters := map[string]interface{}{ 739 "resourceGroupName": autorest.Encode("path", resourceGroupName), 740 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 741 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 742 } 743 744 const APIVersion = "2019-12-01" 745 queryParameters := map[string]interface{}{ 746 "api-version": APIVersion, 747 } 748 749 preparer := autorest.CreatePreparer( 750 autorest.AsGet(), 751 autorest.WithBaseURL(client.BaseURI), 752 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/osUpgradeHistory", pathParameters), 753 autorest.WithQueryParameters(queryParameters)) 754 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 755} 756 757// GetOSUpgradeHistorySender sends the GetOSUpgradeHistory request. The method will close the 758// http.Response Body if it receives an error. 759func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistorySender(req *http.Request) (*http.Response, error) { 760 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 761} 762 763// GetOSUpgradeHistoryResponder handles the response to the GetOSUpgradeHistory request. The method always 764// closes the http.Response Body. 765func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistoryResponder(resp *http.Response) (result VirtualMachineScaleSetListOSUpgradeHistory, err error) { 766 err = autorest.Respond( 767 resp, 768 client.ByInspecting(), 769 azure.WithErrorUnlessStatusCode(http.StatusOK), 770 autorest.ByUnmarshallingJSON(&result), 771 autorest.ByClosing()) 772 result.Response = autorest.Response{Response: resp} 773 return 774} 775 776// getOSUpgradeHistoryNextResults retrieves the next set of results, if any. 777func (client VirtualMachineScaleSetsClient) getOSUpgradeHistoryNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListOSUpgradeHistory) (result VirtualMachineScaleSetListOSUpgradeHistory, err error) { 778 req, err := lastResults.virtualMachineScaleSetListOSUpgradeHistoryPreparer(ctx) 779 if err != nil { 780 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "getOSUpgradeHistoryNextResults", nil, "Failure preparing next results request") 781 } 782 if req == nil { 783 return 784 } 785 resp, err := client.GetOSUpgradeHistorySender(req) 786 if err != nil { 787 result.Response = autorest.Response{Response: resp} 788 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "getOSUpgradeHistoryNextResults", resp, "Failure sending next results request") 789 } 790 result, err = client.GetOSUpgradeHistoryResponder(resp) 791 if err != nil { 792 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "getOSUpgradeHistoryNextResults", resp, "Failure responding to next results request") 793 } 794 return 795} 796 797// GetOSUpgradeHistoryComplete enumerates all values, automatically crossing page boundaries as required. 798func (client VirtualMachineScaleSetsClient) GetOSUpgradeHistoryComplete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListOSUpgradeHistoryIterator, err error) { 799 if tracing.IsEnabled() { 800 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.GetOSUpgradeHistory") 801 defer func() { 802 sc := -1 803 if result.Response().Response.Response != nil { 804 sc = result.page.Response().Response.Response.StatusCode 805 } 806 tracing.EndSpan(ctx, sc, err) 807 }() 808 } 809 result.page, err = client.GetOSUpgradeHistory(ctx, resourceGroupName, VMScaleSetName) 810 return 811} 812 813// List gets a list of all VM scale sets under a resource group. 814// Parameters: 815// resourceGroupName - the name of the resource group. 816func (client VirtualMachineScaleSetsClient) List(ctx context.Context, resourceGroupName string) (result VirtualMachineScaleSetListResultPage, err error) { 817 if tracing.IsEnabled() { 818 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.List") 819 defer func() { 820 sc := -1 821 if result.vmsslr.Response.Response != nil { 822 sc = result.vmsslr.Response.Response.StatusCode 823 } 824 tracing.EndSpan(ctx, sc, err) 825 }() 826 } 827 result.fn = client.listNextResults 828 req, err := client.ListPreparer(ctx, resourceGroupName) 829 if err != nil { 830 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "List", nil, "Failure preparing request") 831 return 832 } 833 834 resp, err := client.ListSender(req) 835 if err != nil { 836 result.vmsslr.Response = autorest.Response{Response: resp} 837 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "List", resp, "Failure sending request") 838 return 839 } 840 841 result.vmsslr, err = client.ListResponder(resp) 842 if err != nil { 843 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "List", resp, "Failure responding to request") 844 } 845 846 return 847} 848 849// ListPreparer prepares the List request. 850func (client VirtualMachineScaleSetsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 851 pathParameters := map[string]interface{}{ 852 "resourceGroupName": autorest.Encode("path", resourceGroupName), 853 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 854 } 855 856 const APIVersion = "2019-12-01" 857 queryParameters := map[string]interface{}{ 858 "api-version": APIVersion, 859 } 860 861 preparer := autorest.CreatePreparer( 862 autorest.AsGet(), 863 autorest.WithBaseURL(client.BaseURI), 864 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets", pathParameters), 865 autorest.WithQueryParameters(queryParameters)) 866 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 867} 868 869// ListSender sends the List request. The method will close the 870// http.Response Body if it receives an error. 871func (client VirtualMachineScaleSetsClient) ListSender(req *http.Request) (*http.Response, error) { 872 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 873} 874 875// ListResponder handles the response to the List request. The method always 876// closes the http.Response Body. 877func (client VirtualMachineScaleSetsClient) ListResponder(resp *http.Response) (result VirtualMachineScaleSetListResult, err error) { 878 err = autorest.Respond( 879 resp, 880 client.ByInspecting(), 881 azure.WithErrorUnlessStatusCode(http.StatusOK), 882 autorest.ByUnmarshallingJSON(&result), 883 autorest.ByClosing()) 884 result.Response = autorest.Response{Response: resp} 885 return 886} 887 888// listNextResults retrieves the next set of results, if any. 889func (client VirtualMachineScaleSetsClient) listNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListResult) (result VirtualMachineScaleSetListResult, err error) { 890 req, err := lastResults.virtualMachineScaleSetListResultPreparer(ctx) 891 if err != nil { 892 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listNextResults", nil, "Failure preparing next results request") 893 } 894 if req == nil { 895 return 896 } 897 resp, err := client.ListSender(req) 898 if err != nil { 899 result.Response = autorest.Response{Response: resp} 900 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listNextResults", resp, "Failure sending next results request") 901 } 902 result, err = client.ListResponder(resp) 903 if err != nil { 904 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listNextResults", resp, "Failure responding to next results request") 905 } 906 return 907} 908 909// ListComplete enumerates all values, automatically crossing page boundaries as required. 910func (client VirtualMachineScaleSetsClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualMachineScaleSetListResultIterator, err error) { 911 if tracing.IsEnabled() { 912 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.List") 913 defer func() { 914 sc := -1 915 if result.Response().Response.Response != nil { 916 sc = result.page.Response().Response.Response.StatusCode 917 } 918 tracing.EndSpan(ctx, sc, err) 919 }() 920 } 921 result.page, err = client.List(ctx, resourceGroupName) 922 return 923} 924 925// ListAll gets a list of all VM Scale Sets in the subscription, regardless of the associated resource group. Use 926// nextLink property in the response to get the next page of VM Scale Sets. Do this till nextLink is null to fetch all 927// the VM Scale Sets. 928func (client VirtualMachineScaleSetsClient) ListAll(ctx context.Context) (result VirtualMachineScaleSetListWithLinkResultPage, err error) { 929 if tracing.IsEnabled() { 930 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListAll") 931 defer func() { 932 sc := -1 933 if result.vmsslwlr.Response.Response != nil { 934 sc = result.vmsslwlr.Response.Response.StatusCode 935 } 936 tracing.EndSpan(ctx, sc, err) 937 }() 938 } 939 result.fn = client.listAllNextResults 940 req, err := client.ListAllPreparer(ctx) 941 if err != nil { 942 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListAll", nil, "Failure preparing request") 943 return 944 } 945 946 resp, err := client.ListAllSender(req) 947 if err != nil { 948 result.vmsslwlr.Response = autorest.Response{Response: resp} 949 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListAll", resp, "Failure sending request") 950 return 951 } 952 953 result.vmsslwlr, err = client.ListAllResponder(resp) 954 if err != nil { 955 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListAll", resp, "Failure responding to request") 956 } 957 958 return 959} 960 961// ListAllPreparer prepares the ListAll request. 962func (client VirtualMachineScaleSetsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { 963 pathParameters := map[string]interface{}{ 964 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 965 } 966 967 const APIVersion = "2019-12-01" 968 queryParameters := map[string]interface{}{ 969 "api-version": APIVersion, 970 } 971 972 preparer := autorest.CreatePreparer( 973 autorest.AsGet(), 974 autorest.WithBaseURL(client.BaseURI), 975 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachineScaleSets", pathParameters), 976 autorest.WithQueryParameters(queryParameters)) 977 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 978} 979 980// ListAllSender sends the ListAll request. The method will close the 981// http.Response Body if it receives an error. 982func (client VirtualMachineScaleSetsClient) ListAllSender(req *http.Request) (*http.Response, error) { 983 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 984} 985 986// ListAllResponder handles the response to the ListAll request. The method always 987// closes the http.Response Body. 988func (client VirtualMachineScaleSetsClient) ListAllResponder(resp *http.Response) (result VirtualMachineScaleSetListWithLinkResult, err error) { 989 err = autorest.Respond( 990 resp, 991 client.ByInspecting(), 992 azure.WithErrorUnlessStatusCode(http.StatusOK), 993 autorest.ByUnmarshallingJSON(&result), 994 autorest.ByClosing()) 995 result.Response = autorest.Response{Response: resp} 996 return 997} 998 999// listAllNextResults retrieves the next set of results, if any. 1000func (client VirtualMachineScaleSetsClient) listAllNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListWithLinkResult) (result VirtualMachineScaleSetListWithLinkResult, err error) { 1001 req, err := lastResults.virtualMachineScaleSetListWithLinkResultPreparer(ctx) 1002 if err != nil { 1003 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listAllNextResults", nil, "Failure preparing next results request") 1004 } 1005 if req == nil { 1006 return 1007 } 1008 resp, err := client.ListAllSender(req) 1009 if err != nil { 1010 result.Response = autorest.Response{Response: resp} 1011 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listAllNextResults", resp, "Failure sending next results request") 1012 } 1013 result, err = client.ListAllResponder(resp) 1014 if err != nil { 1015 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listAllNextResults", resp, "Failure responding to next results request") 1016 } 1017 return 1018} 1019 1020// ListAllComplete enumerates all values, automatically crossing page boundaries as required. 1021func (client VirtualMachineScaleSetsClient) ListAllComplete(ctx context.Context) (result VirtualMachineScaleSetListWithLinkResultIterator, err error) { 1022 if tracing.IsEnabled() { 1023 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListAll") 1024 defer func() { 1025 sc := -1 1026 if result.Response().Response.Response != nil { 1027 sc = result.page.Response().Response.Response.StatusCode 1028 } 1029 tracing.EndSpan(ctx, sc, err) 1030 }() 1031 } 1032 result.page, err = client.ListAll(ctx) 1033 return 1034} 1035 1036// ListSkus gets a list of SKUs available for your VM scale set, including the minimum and maximum VM instances allowed 1037// for each SKU. 1038// Parameters: 1039// resourceGroupName - the name of the resource group. 1040// VMScaleSetName - the name of the VM scale set. 1041func (client VirtualMachineScaleSetsClient) ListSkus(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListSkusResultPage, err error) { 1042 if tracing.IsEnabled() { 1043 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListSkus") 1044 defer func() { 1045 sc := -1 1046 if result.vmsslsr.Response.Response != nil { 1047 sc = result.vmsslsr.Response.Response.StatusCode 1048 } 1049 tracing.EndSpan(ctx, sc, err) 1050 }() 1051 } 1052 result.fn = client.listSkusNextResults 1053 req, err := client.ListSkusPreparer(ctx, resourceGroupName, VMScaleSetName) 1054 if err != nil { 1055 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListSkus", nil, "Failure preparing request") 1056 return 1057 } 1058 1059 resp, err := client.ListSkusSender(req) 1060 if err != nil { 1061 result.vmsslsr.Response = autorest.Response{Response: resp} 1062 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListSkus", resp, "Failure sending request") 1063 return 1064 } 1065 1066 result.vmsslsr, err = client.ListSkusResponder(resp) 1067 if err != nil { 1068 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ListSkus", resp, "Failure responding to request") 1069 } 1070 1071 return 1072} 1073 1074// ListSkusPreparer prepares the ListSkus request. 1075func (client VirtualMachineScaleSetsClient) ListSkusPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string) (*http.Request, error) { 1076 pathParameters := map[string]interface{}{ 1077 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1078 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1079 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1080 } 1081 1082 const APIVersion = "2019-12-01" 1083 queryParameters := map[string]interface{}{ 1084 "api-version": APIVersion, 1085 } 1086 1087 preparer := autorest.CreatePreparer( 1088 autorest.AsGet(), 1089 autorest.WithBaseURL(client.BaseURI), 1090 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/skus", pathParameters), 1091 autorest.WithQueryParameters(queryParameters)) 1092 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1093} 1094 1095// ListSkusSender sends the ListSkus request. The method will close the 1096// http.Response Body if it receives an error. 1097func (client VirtualMachineScaleSetsClient) ListSkusSender(req *http.Request) (*http.Response, error) { 1098 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1099} 1100 1101// ListSkusResponder handles the response to the ListSkus request. The method always 1102// closes the http.Response Body. 1103func (client VirtualMachineScaleSetsClient) ListSkusResponder(resp *http.Response) (result VirtualMachineScaleSetListSkusResult, err error) { 1104 err = autorest.Respond( 1105 resp, 1106 client.ByInspecting(), 1107 azure.WithErrorUnlessStatusCode(http.StatusOK), 1108 autorest.ByUnmarshallingJSON(&result), 1109 autorest.ByClosing()) 1110 result.Response = autorest.Response{Response: resp} 1111 return 1112} 1113 1114// listSkusNextResults retrieves the next set of results, if any. 1115func (client VirtualMachineScaleSetsClient) listSkusNextResults(ctx context.Context, lastResults VirtualMachineScaleSetListSkusResult) (result VirtualMachineScaleSetListSkusResult, err error) { 1116 req, err := lastResults.virtualMachineScaleSetListSkusResultPreparer(ctx) 1117 if err != nil { 1118 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listSkusNextResults", nil, "Failure preparing next results request") 1119 } 1120 if req == nil { 1121 return 1122 } 1123 resp, err := client.ListSkusSender(req) 1124 if err != nil { 1125 result.Response = autorest.Response{Response: resp} 1126 return result, autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listSkusNextResults", resp, "Failure sending next results request") 1127 } 1128 result, err = client.ListSkusResponder(resp) 1129 if err != nil { 1130 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "listSkusNextResults", resp, "Failure responding to next results request") 1131 } 1132 return 1133} 1134 1135// ListSkusComplete enumerates all values, automatically crossing page boundaries as required. 1136func (client VirtualMachineScaleSetsClient) ListSkusComplete(ctx context.Context, resourceGroupName string, VMScaleSetName string) (result VirtualMachineScaleSetListSkusResultIterator, err error) { 1137 if tracing.IsEnabled() { 1138 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ListSkus") 1139 defer func() { 1140 sc := -1 1141 if result.Response().Response.Response != nil { 1142 sc = result.page.Response().Response.Response.StatusCode 1143 } 1144 tracing.EndSpan(ctx, sc, err) 1145 }() 1146 } 1147 result.page, err = client.ListSkus(ctx, resourceGroupName, VMScaleSetName) 1148 return 1149} 1150 1151// PerformMaintenance perform maintenance on one or more virtual machines in a VM scale set. Operation on instances 1152// which are not eligible for perform maintenance will be failed. Please refer to best practices for more details: 1153// https://docs.microsoft.com/en-us/azure/virtual-machine-scale-sets/virtual-machine-scale-sets-maintenance-notifications 1154// Parameters: 1155// resourceGroupName - the name of the resource group. 1156// VMScaleSetName - the name of the VM scale set. 1157// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1158func (client VirtualMachineScaleSetsClient) PerformMaintenance(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsPerformMaintenanceFuture, err error) { 1159 if tracing.IsEnabled() { 1160 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.PerformMaintenance") 1161 defer func() { 1162 sc := -1 1163 if result.Response() != nil { 1164 sc = result.Response().StatusCode 1165 } 1166 tracing.EndSpan(ctx, sc, err) 1167 }() 1168 } 1169 req, err := client.PerformMaintenancePreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 1170 if err != nil { 1171 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PerformMaintenance", nil, "Failure preparing request") 1172 return 1173 } 1174 1175 result, err = client.PerformMaintenanceSender(req) 1176 if err != nil { 1177 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PerformMaintenance", result.Response(), "Failure sending request") 1178 return 1179 } 1180 1181 return 1182} 1183 1184// PerformMaintenancePreparer prepares the PerformMaintenance request. 1185func (client VirtualMachineScaleSetsClient) PerformMaintenancePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) { 1186 pathParameters := map[string]interface{}{ 1187 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1188 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1189 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1190 } 1191 1192 const APIVersion = "2019-12-01" 1193 queryParameters := map[string]interface{}{ 1194 "api-version": APIVersion, 1195 } 1196 1197 preparer := autorest.CreatePreparer( 1198 autorest.AsContentType("application/json; charset=utf-8"), 1199 autorest.AsPost(), 1200 autorest.WithBaseURL(client.BaseURI), 1201 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/performMaintenance", pathParameters), 1202 autorest.WithQueryParameters(queryParameters)) 1203 if VMInstanceIDs != nil { 1204 preparer = autorest.DecoratePreparer(preparer, 1205 autorest.WithJSON(VMInstanceIDs)) 1206 } 1207 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1208} 1209 1210// PerformMaintenanceSender sends the PerformMaintenance request. The method will close the 1211// http.Response Body if it receives an error. 1212func (client VirtualMachineScaleSetsClient) PerformMaintenanceSender(req *http.Request) (future VirtualMachineScaleSetsPerformMaintenanceFuture, err error) { 1213 var resp *http.Response 1214 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1215 if err != nil { 1216 return 1217 } 1218 future.Future, err = azure.NewFutureFromResponse(resp) 1219 return 1220} 1221 1222// PerformMaintenanceResponder handles the response to the PerformMaintenance request. The method always 1223// closes the http.Response Body. 1224func (client VirtualMachineScaleSetsClient) PerformMaintenanceResponder(resp *http.Response) (result autorest.Response, err error) { 1225 err = autorest.Respond( 1226 resp, 1227 client.ByInspecting(), 1228 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1229 autorest.ByClosing()) 1230 result.Response = resp 1231 return 1232} 1233 1234// PowerOff power off (stop) one or more virtual machines in a VM scale set. Note that resources are still attached and 1235// you are getting charged for the resources. Instead, use deallocate to release resources and avoid charges. 1236// Parameters: 1237// resourceGroupName - the name of the resource group. 1238// VMScaleSetName - the name of the VM scale set. 1239// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1240// skipShutdown - the parameter to request non-graceful VM shutdown. True value for this flag indicates 1241// non-graceful shutdown whereas false indicates otherwise. Default value for this flag is false if not 1242// specified 1243func (client VirtualMachineScaleSetsClient) PowerOff(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs, skipShutdown *bool) (result VirtualMachineScaleSetsPowerOffFuture, err error) { 1244 if tracing.IsEnabled() { 1245 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.PowerOff") 1246 defer func() { 1247 sc := -1 1248 if result.Response() != nil { 1249 sc = result.Response().StatusCode 1250 } 1251 tracing.EndSpan(ctx, sc, err) 1252 }() 1253 } 1254 req, err := client.PowerOffPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs, skipShutdown) 1255 if err != nil { 1256 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PowerOff", nil, "Failure preparing request") 1257 return 1258 } 1259 1260 result, err = client.PowerOffSender(req) 1261 if err != nil { 1262 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "PowerOff", result.Response(), "Failure sending request") 1263 return 1264 } 1265 1266 return 1267} 1268 1269// PowerOffPreparer prepares the PowerOff request. 1270func (client VirtualMachineScaleSetsClient) PowerOffPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs, skipShutdown *bool) (*http.Request, error) { 1271 pathParameters := map[string]interface{}{ 1272 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1273 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1274 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1275 } 1276 1277 const APIVersion = "2019-12-01" 1278 queryParameters := map[string]interface{}{ 1279 "api-version": APIVersion, 1280 } 1281 if skipShutdown != nil { 1282 queryParameters["skipShutdown"] = autorest.Encode("query", *skipShutdown) 1283 } else { 1284 queryParameters["skipShutdown"] = autorest.Encode("query", false) 1285 } 1286 1287 preparer := autorest.CreatePreparer( 1288 autorest.AsContentType("application/json; charset=utf-8"), 1289 autorest.AsPost(), 1290 autorest.WithBaseURL(client.BaseURI), 1291 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/poweroff", pathParameters), 1292 autorest.WithQueryParameters(queryParameters)) 1293 if VMInstanceIDs != nil { 1294 preparer = autorest.DecoratePreparer(preparer, 1295 autorest.WithJSON(VMInstanceIDs)) 1296 } 1297 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1298} 1299 1300// PowerOffSender sends the PowerOff request. The method will close the 1301// http.Response Body if it receives an error. 1302func (client VirtualMachineScaleSetsClient) PowerOffSender(req *http.Request) (future VirtualMachineScaleSetsPowerOffFuture, err error) { 1303 var resp *http.Response 1304 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1305 if err != nil { 1306 return 1307 } 1308 future.Future, err = azure.NewFutureFromResponse(resp) 1309 return 1310} 1311 1312// PowerOffResponder handles the response to the PowerOff request. The method always 1313// closes the http.Response Body. 1314func (client VirtualMachineScaleSetsClient) PowerOffResponder(resp *http.Response) (result autorest.Response, err error) { 1315 err = autorest.Respond( 1316 resp, 1317 client.ByInspecting(), 1318 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1319 autorest.ByClosing()) 1320 result.Response = resp 1321 return 1322} 1323 1324// Redeploy shuts down all the virtual machines in the virtual machine scale set, moves them to a new node, and powers 1325// them back on. 1326// Parameters: 1327// resourceGroupName - the name of the resource group. 1328// VMScaleSetName - the name of the VM scale set. 1329// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1330func (client VirtualMachineScaleSetsClient) Redeploy(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsRedeployFuture, err error) { 1331 if tracing.IsEnabled() { 1332 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Redeploy") 1333 defer func() { 1334 sc := -1 1335 if result.Response() != nil { 1336 sc = result.Response().StatusCode 1337 } 1338 tracing.EndSpan(ctx, sc, err) 1339 }() 1340 } 1341 req, err := client.RedeployPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 1342 if err != nil { 1343 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Redeploy", nil, "Failure preparing request") 1344 return 1345 } 1346 1347 result, err = client.RedeploySender(req) 1348 if err != nil { 1349 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Redeploy", result.Response(), "Failure sending request") 1350 return 1351 } 1352 1353 return 1354} 1355 1356// RedeployPreparer prepares the Redeploy request. 1357func (client VirtualMachineScaleSetsClient) RedeployPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) { 1358 pathParameters := map[string]interface{}{ 1359 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1360 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1361 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1362 } 1363 1364 const APIVersion = "2019-12-01" 1365 queryParameters := map[string]interface{}{ 1366 "api-version": APIVersion, 1367 } 1368 1369 preparer := autorest.CreatePreparer( 1370 autorest.AsContentType("application/json; charset=utf-8"), 1371 autorest.AsPost(), 1372 autorest.WithBaseURL(client.BaseURI), 1373 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/redeploy", pathParameters), 1374 autorest.WithQueryParameters(queryParameters)) 1375 if VMInstanceIDs != nil { 1376 preparer = autorest.DecoratePreparer(preparer, 1377 autorest.WithJSON(VMInstanceIDs)) 1378 } 1379 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1380} 1381 1382// RedeploySender sends the Redeploy request. The method will close the 1383// http.Response Body if it receives an error. 1384func (client VirtualMachineScaleSetsClient) RedeploySender(req *http.Request) (future VirtualMachineScaleSetsRedeployFuture, err error) { 1385 var resp *http.Response 1386 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1387 if err != nil { 1388 return 1389 } 1390 future.Future, err = azure.NewFutureFromResponse(resp) 1391 return 1392} 1393 1394// RedeployResponder handles the response to the Redeploy request. The method always 1395// closes the http.Response Body. 1396func (client VirtualMachineScaleSetsClient) RedeployResponder(resp *http.Response) (result autorest.Response, err error) { 1397 err = autorest.Respond( 1398 resp, 1399 client.ByInspecting(), 1400 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1401 autorest.ByClosing()) 1402 result.Response = resp 1403 return 1404} 1405 1406// Reimage reimages (upgrade the operating system) one or more virtual machines in a VM scale set which don't have a 1407// ephemeral OS disk, for virtual machines who have a ephemeral OS disk the virtual machine is reset to initial state. 1408// Parameters: 1409// resourceGroupName - the name of the resource group. 1410// VMScaleSetName - the name of the VM scale set. 1411// VMScaleSetReimageInput - parameters for Reimaging VM ScaleSet. 1412func (client VirtualMachineScaleSetsClient) Reimage(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMScaleSetReimageInput *VirtualMachineScaleSetReimageParameters) (result VirtualMachineScaleSetsReimageFuture, err error) { 1413 if tracing.IsEnabled() { 1414 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Reimage") 1415 defer func() { 1416 sc := -1 1417 if result.Response() != nil { 1418 sc = result.Response().StatusCode 1419 } 1420 tracing.EndSpan(ctx, sc, err) 1421 }() 1422 } 1423 req, err := client.ReimagePreparer(ctx, resourceGroupName, VMScaleSetName, VMScaleSetReimageInput) 1424 if err != nil { 1425 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Reimage", nil, "Failure preparing request") 1426 return 1427 } 1428 1429 result, err = client.ReimageSender(req) 1430 if err != nil { 1431 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Reimage", result.Response(), "Failure sending request") 1432 return 1433 } 1434 1435 return 1436} 1437 1438// ReimagePreparer prepares the Reimage request. 1439func (client VirtualMachineScaleSetsClient) ReimagePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMScaleSetReimageInput *VirtualMachineScaleSetReimageParameters) (*http.Request, error) { 1440 pathParameters := map[string]interface{}{ 1441 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1442 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1443 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1444 } 1445 1446 const APIVersion = "2019-12-01" 1447 queryParameters := map[string]interface{}{ 1448 "api-version": APIVersion, 1449 } 1450 1451 preparer := autorest.CreatePreparer( 1452 autorest.AsContentType("application/json; charset=utf-8"), 1453 autorest.AsPost(), 1454 autorest.WithBaseURL(client.BaseURI), 1455 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimage", pathParameters), 1456 autorest.WithQueryParameters(queryParameters)) 1457 if VMScaleSetReimageInput != nil { 1458 preparer = autorest.DecoratePreparer(preparer, 1459 autorest.WithJSON(VMScaleSetReimageInput)) 1460 } 1461 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1462} 1463 1464// ReimageSender sends the Reimage request. The method will close the 1465// http.Response Body if it receives an error. 1466func (client VirtualMachineScaleSetsClient) ReimageSender(req *http.Request) (future VirtualMachineScaleSetsReimageFuture, err error) { 1467 var resp *http.Response 1468 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1469 if err != nil { 1470 return 1471 } 1472 future.Future, err = azure.NewFutureFromResponse(resp) 1473 return 1474} 1475 1476// ReimageResponder handles the response to the Reimage request. The method always 1477// closes the http.Response Body. 1478func (client VirtualMachineScaleSetsClient) ReimageResponder(resp *http.Response) (result autorest.Response, err error) { 1479 err = autorest.Respond( 1480 resp, 1481 client.ByInspecting(), 1482 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1483 autorest.ByClosing()) 1484 result.Response = resp 1485 return 1486} 1487 1488// ReimageAll reimages all the disks ( including data disks ) in the virtual machines in a VM scale set. This operation 1489// is only supported for managed disks. 1490// Parameters: 1491// resourceGroupName - the name of the resource group. 1492// VMScaleSetName - the name of the VM scale set. 1493// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1494func (client VirtualMachineScaleSetsClient) ReimageAll(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsReimageAllFuture, err error) { 1495 if tracing.IsEnabled() { 1496 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.ReimageAll") 1497 defer func() { 1498 sc := -1 1499 if result.Response() != nil { 1500 sc = result.Response().StatusCode 1501 } 1502 tracing.EndSpan(ctx, sc, err) 1503 }() 1504 } 1505 req, err := client.ReimageAllPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 1506 if err != nil { 1507 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ReimageAll", nil, "Failure preparing request") 1508 return 1509 } 1510 1511 result, err = client.ReimageAllSender(req) 1512 if err != nil { 1513 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "ReimageAll", result.Response(), "Failure sending request") 1514 return 1515 } 1516 1517 return 1518} 1519 1520// ReimageAllPreparer prepares the ReimageAll request. 1521func (client VirtualMachineScaleSetsClient) ReimageAllPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) { 1522 pathParameters := map[string]interface{}{ 1523 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1524 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1525 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1526 } 1527 1528 const APIVersion = "2019-12-01" 1529 queryParameters := map[string]interface{}{ 1530 "api-version": APIVersion, 1531 } 1532 1533 preparer := autorest.CreatePreparer( 1534 autorest.AsContentType("application/json; charset=utf-8"), 1535 autorest.AsPost(), 1536 autorest.WithBaseURL(client.BaseURI), 1537 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimageall", pathParameters), 1538 autorest.WithQueryParameters(queryParameters)) 1539 if VMInstanceIDs != nil { 1540 preparer = autorest.DecoratePreparer(preparer, 1541 autorest.WithJSON(VMInstanceIDs)) 1542 } 1543 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1544} 1545 1546// ReimageAllSender sends the ReimageAll request. The method will close the 1547// http.Response Body if it receives an error. 1548func (client VirtualMachineScaleSetsClient) ReimageAllSender(req *http.Request) (future VirtualMachineScaleSetsReimageAllFuture, err error) { 1549 var resp *http.Response 1550 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1551 if err != nil { 1552 return 1553 } 1554 future.Future, err = azure.NewFutureFromResponse(resp) 1555 return 1556} 1557 1558// ReimageAllResponder handles the response to the ReimageAll request. The method always 1559// closes the http.Response Body. 1560func (client VirtualMachineScaleSetsClient) ReimageAllResponder(resp *http.Response) (result autorest.Response, err error) { 1561 err = autorest.Respond( 1562 resp, 1563 client.ByInspecting(), 1564 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1565 autorest.ByClosing()) 1566 result.Response = resp 1567 return 1568} 1569 1570// Restart restarts one or more virtual machines in a VM scale set. 1571// Parameters: 1572// resourceGroupName - the name of the resource group. 1573// VMScaleSetName - the name of the VM scale set. 1574// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1575func (client VirtualMachineScaleSetsClient) Restart(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsRestartFuture, err error) { 1576 if tracing.IsEnabled() { 1577 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Restart") 1578 defer func() { 1579 sc := -1 1580 if result.Response() != nil { 1581 sc = result.Response().StatusCode 1582 } 1583 tracing.EndSpan(ctx, sc, err) 1584 }() 1585 } 1586 req, err := client.RestartPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 1587 if err != nil { 1588 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Restart", nil, "Failure preparing request") 1589 return 1590 } 1591 1592 result, err = client.RestartSender(req) 1593 if err != nil { 1594 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Restart", result.Response(), "Failure sending request") 1595 return 1596 } 1597 1598 return 1599} 1600 1601// RestartPreparer prepares the Restart request. 1602func (client VirtualMachineScaleSetsClient) RestartPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) { 1603 pathParameters := map[string]interface{}{ 1604 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1605 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1606 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1607 } 1608 1609 const APIVersion = "2019-12-01" 1610 queryParameters := map[string]interface{}{ 1611 "api-version": APIVersion, 1612 } 1613 1614 preparer := autorest.CreatePreparer( 1615 autorest.AsContentType("application/json; charset=utf-8"), 1616 autorest.AsPost(), 1617 autorest.WithBaseURL(client.BaseURI), 1618 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/restart", pathParameters), 1619 autorest.WithQueryParameters(queryParameters)) 1620 if VMInstanceIDs != nil { 1621 preparer = autorest.DecoratePreparer(preparer, 1622 autorest.WithJSON(VMInstanceIDs)) 1623 } 1624 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1625} 1626 1627// RestartSender sends the Restart request. The method will close the 1628// http.Response Body if it receives an error. 1629func (client VirtualMachineScaleSetsClient) RestartSender(req *http.Request) (future VirtualMachineScaleSetsRestartFuture, err error) { 1630 var resp *http.Response 1631 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1632 if err != nil { 1633 return 1634 } 1635 future.Future, err = azure.NewFutureFromResponse(resp) 1636 return 1637} 1638 1639// RestartResponder handles the response to the Restart request. The method always 1640// closes the http.Response Body. 1641func (client VirtualMachineScaleSetsClient) RestartResponder(resp *http.Response) (result autorest.Response, err error) { 1642 err = autorest.Respond( 1643 resp, 1644 client.ByInspecting(), 1645 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1646 autorest.ByClosing()) 1647 result.Response = resp 1648 return 1649} 1650 1651// SetOrchestrationServiceState changes ServiceState property for a given service 1652// Parameters: 1653// resourceGroupName - the name of the resource group. 1654// VMScaleSetName - the name of the virtual machine scale set to create or update. 1655// parameters - the input object for SetOrchestrationServiceState API. 1656func (client VirtualMachineScaleSetsClient) SetOrchestrationServiceState(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters OrchestrationServiceStateInput) (result VirtualMachineScaleSetsSetOrchestrationServiceStateFuture, err error) { 1657 if tracing.IsEnabled() { 1658 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.SetOrchestrationServiceState") 1659 defer func() { 1660 sc := -1 1661 if result.Response() != nil { 1662 sc = result.Response().StatusCode 1663 } 1664 tracing.EndSpan(ctx, sc, err) 1665 }() 1666 } 1667 req, err := client.SetOrchestrationServiceStatePreparer(ctx, resourceGroupName, VMScaleSetName, parameters) 1668 if err != nil { 1669 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "SetOrchestrationServiceState", nil, "Failure preparing request") 1670 return 1671 } 1672 1673 result, err = client.SetOrchestrationServiceStateSender(req) 1674 if err != nil { 1675 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "SetOrchestrationServiceState", result.Response(), "Failure sending request") 1676 return 1677 } 1678 1679 return 1680} 1681 1682// SetOrchestrationServiceStatePreparer prepares the SetOrchestrationServiceState request. 1683func (client VirtualMachineScaleSetsClient) SetOrchestrationServiceStatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters OrchestrationServiceStateInput) (*http.Request, error) { 1684 pathParameters := map[string]interface{}{ 1685 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1686 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1687 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1688 } 1689 1690 const APIVersion = "2019-12-01" 1691 queryParameters := map[string]interface{}{ 1692 "api-version": APIVersion, 1693 } 1694 1695 preparer := autorest.CreatePreparer( 1696 autorest.AsContentType("application/json; charset=utf-8"), 1697 autorest.AsPost(), 1698 autorest.WithBaseURL(client.BaseURI), 1699 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/setOrchestrationServiceState", pathParameters), 1700 autorest.WithJSON(parameters), 1701 autorest.WithQueryParameters(queryParameters)) 1702 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1703} 1704 1705// SetOrchestrationServiceStateSender sends the SetOrchestrationServiceState request. The method will close the 1706// http.Response Body if it receives an error. 1707func (client VirtualMachineScaleSetsClient) SetOrchestrationServiceStateSender(req *http.Request) (future VirtualMachineScaleSetsSetOrchestrationServiceStateFuture, err error) { 1708 var resp *http.Response 1709 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1710 if err != nil { 1711 return 1712 } 1713 future.Future, err = azure.NewFutureFromResponse(resp) 1714 return 1715} 1716 1717// SetOrchestrationServiceStateResponder handles the response to the SetOrchestrationServiceState request. The method always 1718// closes the http.Response Body. 1719func (client VirtualMachineScaleSetsClient) SetOrchestrationServiceStateResponder(resp *http.Response) (result autorest.Response, err error) { 1720 err = autorest.Respond( 1721 resp, 1722 client.ByInspecting(), 1723 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1724 autorest.ByClosing()) 1725 result.Response = resp 1726 return 1727} 1728 1729// Start starts one or more virtual machines in a VM scale set. 1730// Parameters: 1731// resourceGroupName - the name of the resource group. 1732// VMScaleSetName - the name of the VM scale set. 1733// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1734func (client VirtualMachineScaleSetsClient) Start(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (result VirtualMachineScaleSetsStartFuture, err error) { 1735 if tracing.IsEnabled() { 1736 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Start") 1737 defer func() { 1738 sc := -1 1739 if result.Response() != nil { 1740 sc = result.Response().StatusCode 1741 } 1742 tracing.EndSpan(ctx, sc, err) 1743 }() 1744 } 1745 req, err := client.StartPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 1746 if err != nil { 1747 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Start", nil, "Failure preparing request") 1748 return 1749 } 1750 1751 result, err = client.StartSender(req) 1752 if err != nil { 1753 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Start", result.Response(), "Failure sending request") 1754 return 1755 } 1756 1757 return 1758} 1759 1760// StartPreparer prepares the Start request. 1761func (client VirtualMachineScaleSetsClient) StartPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs *VirtualMachineScaleSetVMInstanceIDs) (*http.Request, error) { 1762 pathParameters := map[string]interface{}{ 1763 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1764 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1765 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1766 } 1767 1768 const APIVersion = "2019-12-01" 1769 queryParameters := map[string]interface{}{ 1770 "api-version": APIVersion, 1771 } 1772 1773 preparer := autorest.CreatePreparer( 1774 autorest.AsContentType("application/json; charset=utf-8"), 1775 autorest.AsPost(), 1776 autorest.WithBaseURL(client.BaseURI), 1777 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/start", pathParameters), 1778 autorest.WithQueryParameters(queryParameters)) 1779 if VMInstanceIDs != nil { 1780 preparer = autorest.DecoratePreparer(preparer, 1781 autorest.WithJSON(VMInstanceIDs)) 1782 } 1783 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1784} 1785 1786// StartSender sends the Start request. The method will close the 1787// http.Response Body if it receives an error. 1788func (client VirtualMachineScaleSetsClient) StartSender(req *http.Request) (future VirtualMachineScaleSetsStartFuture, err error) { 1789 var resp *http.Response 1790 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1791 if err != nil { 1792 return 1793 } 1794 future.Future, err = azure.NewFutureFromResponse(resp) 1795 return 1796} 1797 1798// StartResponder handles the response to the Start request. The method always 1799// closes the http.Response Body. 1800func (client VirtualMachineScaleSetsClient) StartResponder(resp *http.Response) (result autorest.Response, err error) { 1801 err = autorest.Respond( 1802 resp, 1803 client.ByInspecting(), 1804 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1805 autorest.ByClosing()) 1806 result.Response = resp 1807 return 1808} 1809 1810// Update update a VM scale set. 1811// Parameters: 1812// resourceGroupName - the name of the resource group. 1813// VMScaleSetName - the name of the VM scale set to create or update. 1814// parameters - the scale set object. 1815func (client VirtualMachineScaleSetsClient) Update(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSetUpdate) (result VirtualMachineScaleSetsUpdateFuture, err error) { 1816 if tracing.IsEnabled() { 1817 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.Update") 1818 defer func() { 1819 sc := -1 1820 if result.Response() != nil { 1821 sc = result.Response().StatusCode 1822 } 1823 tracing.EndSpan(ctx, sc, err) 1824 }() 1825 } 1826 req, err := client.UpdatePreparer(ctx, resourceGroupName, VMScaleSetName, parameters) 1827 if err != nil { 1828 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Update", nil, "Failure preparing request") 1829 return 1830 } 1831 1832 result, err = client.UpdateSender(req) 1833 if err != nil { 1834 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "Update", result.Response(), "Failure sending request") 1835 return 1836 } 1837 1838 return 1839} 1840 1841// UpdatePreparer prepares the Update request. 1842func (client VirtualMachineScaleSetsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, parameters VirtualMachineScaleSetUpdate) (*http.Request, error) { 1843 pathParameters := map[string]interface{}{ 1844 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1845 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1846 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1847 } 1848 1849 const APIVersion = "2019-12-01" 1850 queryParameters := map[string]interface{}{ 1851 "api-version": APIVersion, 1852 } 1853 1854 preparer := autorest.CreatePreparer( 1855 autorest.AsContentType("application/json; charset=utf-8"), 1856 autorest.AsPatch(), 1857 autorest.WithBaseURL(client.BaseURI), 1858 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}", pathParameters), 1859 autorest.WithJSON(parameters), 1860 autorest.WithQueryParameters(queryParameters)) 1861 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1862} 1863 1864// UpdateSender sends the Update request. The method will close the 1865// http.Response Body if it receives an error. 1866func (client VirtualMachineScaleSetsClient) UpdateSender(req *http.Request) (future VirtualMachineScaleSetsUpdateFuture, err error) { 1867 var resp *http.Response 1868 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1869 if err != nil { 1870 return 1871 } 1872 future.Future, err = azure.NewFutureFromResponse(resp) 1873 return 1874} 1875 1876// UpdateResponder handles the response to the Update request. The method always 1877// closes the http.Response Body. 1878func (client VirtualMachineScaleSetsClient) UpdateResponder(resp *http.Response) (result VirtualMachineScaleSet, err error) { 1879 err = autorest.Respond( 1880 resp, 1881 client.ByInspecting(), 1882 azure.WithErrorUnlessStatusCode(http.StatusOK), 1883 autorest.ByUnmarshallingJSON(&result), 1884 autorest.ByClosing()) 1885 result.Response = autorest.Response{Response: resp} 1886 return 1887} 1888 1889// UpdateInstances upgrades one or more virtual machines to the latest SKU set in the VM scale set model. 1890// Parameters: 1891// resourceGroupName - the name of the resource group. 1892// VMScaleSetName - the name of the VM scale set. 1893// VMInstanceIDs - a list of virtual machine instance IDs from the VM scale set. 1894func (client VirtualMachineScaleSetsClient) UpdateInstances(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (result VirtualMachineScaleSetsUpdateInstancesFuture, err error) { 1895 if tracing.IsEnabled() { 1896 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineScaleSetsClient.UpdateInstances") 1897 defer func() { 1898 sc := -1 1899 if result.Response() != nil { 1900 sc = result.Response().StatusCode 1901 } 1902 tracing.EndSpan(ctx, sc, err) 1903 }() 1904 } 1905 if err := validation.Validate([]validation.Validation{ 1906 {TargetValue: VMInstanceIDs, 1907 Constraints: []validation.Constraint{{Target: "VMInstanceIDs.InstanceIds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 1908 return result, validation.NewError("compute.VirtualMachineScaleSetsClient", "UpdateInstances", err.Error()) 1909 } 1910 1911 req, err := client.UpdateInstancesPreparer(ctx, resourceGroupName, VMScaleSetName, VMInstanceIDs) 1912 if err != nil { 1913 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "UpdateInstances", nil, "Failure preparing request") 1914 return 1915 } 1916 1917 result, err = client.UpdateInstancesSender(req) 1918 if err != nil { 1919 err = autorest.NewErrorWithError(err, "compute.VirtualMachineScaleSetsClient", "UpdateInstances", result.Response(), "Failure sending request") 1920 return 1921 } 1922 1923 return 1924} 1925 1926// UpdateInstancesPreparer prepares the UpdateInstances request. 1927func (client VirtualMachineScaleSetsClient) UpdateInstancesPreparer(ctx context.Context, resourceGroupName string, VMScaleSetName string, VMInstanceIDs VirtualMachineScaleSetVMInstanceRequiredIDs) (*http.Request, error) { 1928 pathParameters := map[string]interface{}{ 1929 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1930 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1931 "vmScaleSetName": autorest.Encode("path", VMScaleSetName), 1932 } 1933 1934 const APIVersion = "2019-12-01" 1935 queryParameters := map[string]interface{}{ 1936 "api-version": APIVersion, 1937 } 1938 1939 preparer := autorest.CreatePreparer( 1940 autorest.AsContentType("application/json; charset=utf-8"), 1941 autorest.AsPost(), 1942 autorest.WithBaseURL(client.BaseURI), 1943 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/manualupgrade", pathParameters), 1944 autorest.WithJSON(VMInstanceIDs), 1945 autorest.WithQueryParameters(queryParameters)) 1946 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1947} 1948 1949// UpdateInstancesSender sends the UpdateInstances request. The method will close the 1950// http.Response Body if it receives an error. 1951func (client VirtualMachineScaleSetsClient) UpdateInstancesSender(req *http.Request) (future VirtualMachineScaleSetsUpdateInstancesFuture, err error) { 1952 var resp *http.Response 1953 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1954 if err != nil { 1955 return 1956 } 1957 future.Future, err = azure.NewFutureFromResponse(resp) 1958 return 1959} 1960 1961// UpdateInstancesResponder handles the response to the UpdateInstances request. The method always 1962// closes the http.Response Body. 1963func (client VirtualMachineScaleSetsClient) UpdateInstancesResponder(resp *http.Response) (result autorest.Response, err error) { 1964 err = autorest.Respond( 1965 resp, 1966 client.ByInspecting(), 1967 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1968 autorest.ByClosing()) 1969 result.Response = resp 1970 return 1971} 1972