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