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