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