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