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 = "2016-03-30" 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 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 111 var resp *http.Response 112 resp, err = autorest.SendWithSender(client, req, sd...) 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// CreateOrUpdate the operation to create or update a virtual machine. 134// Parameters: 135// resourceGroupName - the name of the resource group. 136// VMName - the name of the virtual machine. 137// parameters - parameters supplied to the Create Virtual Machine operation. 138func (client VirtualMachinesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachine) (result VirtualMachinesCreateOrUpdateFuture, err error) { 139 if tracing.IsEnabled() { 140 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.CreateOrUpdate") 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 if err := validation.Validate([]validation.Validation{ 150 {TargetValue: parameters, 151 Constraints: []validation.Constraint{{Target: "parameters.VirtualMachineProperties", Name: validation.Null, Rule: false, 152 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile", Name: validation.Null, Rule: false, 153 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk", Name: validation.Null, Rule: false, 154 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings", Name: validation.Null, Rule: false, 155 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey", Name: validation.Null, Rule: false, 156 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey.SecretURL", Name: validation.Null, Rule: true, Chain: nil}, 157 {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.DiskEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil}, 158 }}, 159 {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey", Name: validation.Null, Rule: false, 160 Chain: []validation.Constraint{{Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey.KeyURL", Name: validation.Null, Rule: true, Chain: nil}, 161 {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.EncryptionSettings.KeyEncryptionKey.SourceVault", Name: validation.Null, Rule: true, Chain: nil}, 162 }}, 163 }}, 164 {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.Name", Name: validation.Null, Rule: true, Chain: nil}, 165 {Target: "parameters.VirtualMachineProperties.StorageProfile.OsDisk.Vhd", Name: validation.Null, Rule: true, Chain: nil}, 166 }}, 167 }}, 168 }}}}}); err != nil { 169 return result, validation.NewError("compute.VirtualMachinesClient", "CreateOrUpdate", err.Error()) 170 } 171 172 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMName, parameters) 173 if err != nil { 174 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "CreateOrUpdate", nil, "Failure preparing request") 175 return 176 } 177 178 result, err = client.CreateOrUpdateSender(req) 179 if err != nil { 180 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "CreateOrUpdate", result.Response(), "Failure sending request") 181 return 182 } 183 184 return 185} 186 187// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 188func (client VirtualMachinesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, parameters VirtualMachine) (*http.Request, error) { 189 pathParameters := map[string]interface{}{ 190 "resourceGroupName": autorest.Encode("path", resourceGroupName), 191 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 192 "vmName": autorest.Encode("path", VMName), 193 } 194 195 const APIVersion = "2016-03-30" 196 queryParameters := map[string]interface{}{ 197 "api-version": APIVersion, 198 } 199 200 parameters.Resources = nil 201 preparer := autorest.CreatePreparer( 202 autorest.AsContentType("application/json; charset=utf-8"), 203 autorest.AsPut(), 204 autorest.WithBaseURL(client.BaseURI), 205 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters), 206 autorest.WithJSON(parameters), 207 autorest.WithQueryParameters(queryParameters)) 208 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 209} 210 211// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 212// http.Response Body if it receives an error. 213func (client VirtualMachinesClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachinesCreateOrUpdateFuture, err error) { 214 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 215 var resp *http.Response 216 resp, err = autorest.SendWithSender(client, req, sd...) 217 if err != nil { 218 return 219 } 220 future.Future, err = azure.NewFutureFromResponse(resp) 221 return 222} 223 224// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 225// closes the http.Response Body. 226func (client VirtualMachinesClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachine, err error) { 227 err = autorest.Respond( 228 resp, 229 client.ByInspecting(), 230 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 231 autorest.ByUnmarshallingJSON(&result), 232 autorest.ByClosing()) 233 result.Response = autorest.Response{Response: resp} 234 return 235} 236 237// Deallocate shuts down the virtual machine and releases the compute resources. You are not billed for the compute 238// resources that this virtual machine uses. 239// Parameters: 240// resourceGroupName - the name of the resource group. 241// VMName - the name of the virtual machine. 242func (client VirtualMachinesClient) Deallocate(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesDeallocateFuture, err error) { 243 if tracing.IsEnabled() { 244 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Deallocate") 245 defer func() { 246 sc := -1 247 if result.Response() != nil { 248 sc = result.Response().StatusCode 249 } 250 tracing.EndSpan(ctx, sc, err) 251 }() 252 } 253 req, err := client.DeallocatePreparer(ctx, resourceGroupName, VMName) 254 if err != nil { 255 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Deallocate", nil, "Failure preparing request") 256 return 257 } 258 259 result, err = client.DeallocateSender(req) 260 if err != nil { 261 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Deallocate", result.Response(), "Failure sending request") 262 return 263 } 264 265 return 266} 267 268// DeallocatePreparer prepares the Deallocate request. 269func (client VirtualMachinesClient) DeallocatePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 270 pathParameters := map[string]interface{}{ 271 "resourceGroupName": autorest.Encode("path", resourceGroupName), 272 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 273 "vmName": autorest.Encode("path", VMName), 274 } 275 276 const APIVersion = "2016-03-30" 277 queryParameters := map[string]interface{}{ 278 "api-version": APIVersion, 279 } 280 281 preparer := autorest.CreatePreparer( 282 autorest.AsPost(), 283 autorest.WithBaseURL(client.BaseURI), 284 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate", pathParameters), 285 autorest.WithQueryParameters(queryParameters)) 286 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 287} 288 289// DeallocateSender sends the Deallocate request. The method will close the 290// http.Response Body if it receives an error. 291func (client VirtualMachinesClient) DeallocateSender(req *http.Request) (future VirtualMachinesDeallocateFuture, err error) { 292 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 293 var resp *http.Response 294 resp, err = autorest.SendWithSender(client, req, sd...) 295 if err != nil { 296 return 297 } 298 future.Future, err = azure.NewFutureFromResponse(resp) 299 return 300} 301 302// DeallocateResponder handles the response to the Deallocate request. The method always 303// closes the http.Response Body. 304func (client VirtualMachinesClient) DeallocateResponder(resp *http.Response) (result OperationStatusResponse, err error) { 305 err = autorest.Respond( 306 resp, 307 client.ByInspecting(), 308 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 309 autorest.ByUnmarshallingJSON(&result), 310 autorest.ByClosing()) 311 result.Response = autorest.Response{Response: resp} 312 return 313} 314 315// Delete the operation to delete a virtual machine. 316// Parameters: 317// resourceGroupName - the name of the resource group. 318// VMName - the name of the virtual machine. 319func (client VirtualMachinesClient) Delete(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesDeleteFuture, err error) { 320 if tracing.IsEnabled() { 321 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Delete") 322 defer func() { 323 sc := -1 324 if result.Response() != nil { 325 sc = result.Response().StatusCode 326 } 327 tracing.EndSpan(ctx, sc, err) 328 }() 329 } 330 req, err := client.DeletePreparer(ctx, resourceGroupName, VMName) 331 if err != nil { 332 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Delete", nil, "Failure preparing request") 333 return 334 } 335 336 result, err = client.DeleteSender(req) 337 if err != nil { 338 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Delete", result.Response(), "Failure sending request") 339 return 340 } 341 342 return 343} 344 345// DeletePreparer prepares the Delete request. 346func (client VirtualMachinesClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 347 pathParameters := map[string]interface{}{ 348 "resourceGroupName": autorest.Encode("path", resourceGroupName), 349 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 350 "vmName": autorest.Encode("path", VMName), 351 } 352 353 const APIVersion = "2016-03-30" 354 queryParameters := map[string]interface{}{ 355 "api-version": APIVersion, 356 } 357 358 preparer := autorest.CreatePreparer( 359 autorest.AsDelete(), 360 autorest.WithBaseURL(client.BaseURI), 361 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters), 362 autorest.WithQueryParameters(queryParameters)) 363 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 364} 365 366// DeleteSender sends the Delete request. The method will close the 367// http.Response Body if it receives an error. 368func (client VirtualMachinesClient) DeleteSender(req *http.Request) (future VirtualMachinesDeleteFuture, err error) { 369 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 370 var resp *http.Response 371 resp, err = autorest.SendWithSender(client, req, sd...) 372 if err != nil { 373 return 374 } 375 future.Future, err = azure.NewFutureFromResponse(resp) 376 return 377} 378 379// DeleteResponder handles the response to the Delete request. The method always 380// closes the http.Response Body. 381func (client VirtualMachinesClient) DeleteResponder(resp *http.Response) (result OperationStatusResponse, err error) { 382 err = autorest.Respond( 383 resp, 384 client.ByInspecting(), 385 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 386 autorest.ByUnmarshallingJSON(&result), 387 autorest.ByClosing()) 388 result.Response = autorest.Response{Response: resp} 389 return 390} 391 392// Generalize sets the state of the virtual machine to generalized. 393// Parameters: 394// resourceGroupName - the name of the resource group. 395// VMName - the name of the virtual machine. 396func (client VirtualMachinesClient) Generalize(ctx context.Context, resourceGroupName string, VMName string) (result OperationStatusResponse, err error) { 397 if tracing.IsEnabled() { 398 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Generalize") 399 defer func() { 400 sc := -1 401 if result.Response.Response != nil { 402 sc = result.Response.Response.StatusCode 403 } 404 tracing.EndSpan(ctx, sc, err) 405 }() 406 } 407 req, err := client.GeneralizePreparer(ctx, resourceGroupName, VMName) 408 if err != nil { 409 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Generalize", nil, "Failure preparing request") 410 return 411 } 412 413 resp, err := client.GeneralizeSender(req) 414 if err != nil { 415 result.Response = autorest.Response{Response: resp} 416 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Generalize", resp, "Failure sending request") 417 return 418 } 419 420 result, err = client.GeneralizeResponder(resp) 421 if err != nil { 422 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Generalize", resp, "Failure responding to request") 423 } 424 425 return 426} 427 428// GeneralizePreparer prepares the Generalize request. 429func (client VirtualMachinesClient) GeneralizePreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 430 pathParameters := map[string]interface{}{ 431 "resourceGroupName": autorest.Encode("path", resourceGroupName), 432 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 433 "vmName": autorest.Encode("path", VMName), 434 } 435 436 const APIVersion = "2016-03-30" 437 queryParameters := map[string]interface{}{ 438 "api-version": APIVersion, 439 } 440 441 preparer := autorest.CreatePreparer( 442 autorest.AsPost(), 443 autorest.WithBaseURL(client.BaseURI), 444 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/generalize", pathParameters), 445 autorest.WithQueryParameters(queryParameters)) 446 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 447} 448 449// GeneralizeSender sends the Generalize request. The method will close the 450// http.Response Body if it receives an error. 451func (client VirtualMachinesClient) GeneralizeSender(req *http.Request) (*http.Response, error) { 452 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 453 return autorest.SendWithSender(client, req, sd...) 454} 455 456// GeneralizeResponder handles the response to the Generalize request. The method always 457// closes the http.Response Body. 458func (client VirtualMachinesClient) GeneralizeResponder(resp *http.Response) (result OperationStatusResponse, err error) { 459 err = autorest.Respond( 460 resp, 461 client.ByInspecting(), 462 azure.WithErrorUnlessStatusCode(http.StatusOK), 463 autorest.ByUnmarshallingJSON(&result), 464 autorest.ByClosing()) 465 result.Response = autorest.Response{Response: resp} 466 return 467} 468 469// Get retrieves information about the model view or the instance view of a virtual machine. 470// Parameters: 471// resourceGroupName - the name of the resource group. 472// VMName - the name of the virtual machine. 473// expand - the expand expression to apply on the operation. 474func (client VirtualMachinesClient) Get(ctx context.Context, resourceGroupName string, VMName string, expand InstanceViewTypes) (result VirtualMachine, err error) { 475 if tracing.IsEnabled() { 476 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Get") 477 defer func() { 478 sc := -1 479 if result.Response.Response != nil { 480 sc = result.Response.Response.StatusCode 481 } 482 tracing.EndSpan(ctx, sc, err) 483 }() 484 } 485 req, err := client.GetPreparer(ctx, resourceGroupName, VMName, expand) 486 if err != nil { 487 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Get", nil, "Failure preparing request") 488 return 489 } 490 491 resp, err := client.GetSender(req) 492 if err != nil { 493 result.Response = autorest.Response{Response: resp} 494 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Get", resp, "Failure sending request") 495 return 496 } 497 498 result, err = client.GetResponder(resp) 499 if err != nil { 500 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Get", resp, "Failure responding to request") 501 } 502 503 return 504} 505 506// GetPreparer prepares the Get request. 507func (client VirtualMachinesClient) GetPreparer(ctx context.Context, resourceGroupName string, VMName string, expand InstanceViewTypes) (*http.Request, error) { 508 pathParameters := map[string]interface{}{ 509 "resourceGroupName": autorest.Encode("path", resourceGroupName), 510 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 511 "vmName": autorest.Encode("path", VMName), 512 } 513 514 const APIVersion = "2016-03-30" 515 queryParameters := map[string]interface{}{ 516 "api-version": APIVersion, 517 } 518 if len(string(expand)) > 0 { 519 queryParameters["$expand"] = autorest.Encode("query", expand) 520 } 521 522 preparer := autorest.CreatePreparer( 523 autorest.AsGet(), 524 autorest.WithBaseURL(client.BaseURI), 525 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}", pathParameters), 526 autorest.WithQueryParameters(queryParameters)) 527 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 528} 529 530// GetSender sends the Get request. The method will close the 531// http.Response Body if it receives an error. 532func (client VirtualMachinesClient) GetSender(req *http.Request) (*http.Response, error) { 533 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 534 return autorest.SendWithSender(client, req, sd...) 535} 536 537// GetResponder handles the response to the Get request. The method always 538// closes the http.Response Body. 539func (client VirtualMachinesClient) GetResponder(resp *http.Response) (result VirtualMachine, err error) { 540 err = autorest.Respond( 541 resp, 542 client.ByInspecting(), 543 azure.WithErrorUnlessStatusCode(http.StatusOK), 544 autorest.ByUnmarshallingJSON(&result), 545 autorest.ByClosing()) 546 result.Response = autorest.Response{Response: resp} 547 return 548} 549 550// GetExtensions the operation to get all extensions of a Virtual Machine. 551// Parameters: 552// resourceGroupName - the name of the resource group. 553// VMName - the name of the virtual machine containing the extension. 554// expand - the expand expression to apply on the operation. 555func (client VirtualMachinesClient) GetExtensions(ctx context.Context, resourceGroupName string, VMName string, expand string) (result VirtualMachineExtensionsListResult, err error) { 556 if tracing.IsEnabled() { 557 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.GetExtensions") 558 defer func() { 559 sc := -1 560 if result.Response.Response != nil { 561 sc = result.Response.Response.StatusCode 562 } 563 tracing.EndSpan(ctx, sc, err) 564 }() 565 } 566 req, err := client.GetExtensionsPreparer(ctx, resourceGroupName, VMName, expand) 567 if err != nil { 568 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "GetExtensions", nil, "Failure preparing request") 569 return 570 } 571 572 resp, err := client.GetExtensionsSender(req) 573 if err != nil { 574 result.Response = autorest.Response{Response: resp} 575 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "GetExtensions", resp, "Failure sending request") 576 return 577 } 578 579 result, err = client.GetExtensionsResponder(resp) 580 if err != nil { 581 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "GetExtensions", resp, "Failure responding to request") 582 } 583 584 return 585} 586 587// GetExtensionsPreparer prepares the GetExtensions request. 588func (client VirtualMachinesClient) GetExtensionsPreparer(ctx context.Context, resourceGroupName string, VMName string, expand string) (*http.Request, error) { 589 pathParameters := map[string]interface{}{ 590 "resourceGroupName": autorest.Encode("path", resourceGroupName), 591 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 592 "vmName": autorest.Encode("path", VMName), 593 } 594 595 const APIVersion = "2016-03-30" 596 queryParameters := map[string]interface{}{ 597 "api-version": APIVersion, 598 } 599 if len(expand) > 0 { 600 queryParameters["$expand"] = autorest.Encode("query", expand) 601 } 602 603 preparer := autorest.CreatePreparer( 604 autorest.AsGet(), 605 autorest.WithBaseURL(client.BaseURI), 606 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions", pathParameters), 607 autorest.WithQueryParameters(queryParameters)) 608 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 609} 610 611// GetExtensionsSender sends the GetExtensions request. The method will close the 612// http.Response Body if it receives an error. 613func (client VirtualMachinesClient) GetExtensionsSender(req *http.Request) (*http.Response, error) { 614 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 615 return autorest.SendWithSender(client, req, sd...) 616} 617 618// GetExtensionsResponder handles the response to the GetExtensions request. The method always 619// closes the http.Response Body. 620func (client VirtualMachinesClient) GetExtensionsResponder(resp *http.Response) (result VirtualMachineExtensionsListResult, err error) { 621 err = autorest.Respond( 622 resp, 623 client.ByInspecting(), 624 azure.WithErrorUnlessStatusCode(http.StatusOK), 625 autorest.ByUnmarshallingJSON(&result), 626 autorest.ByClosing()) 627 result.Response = autorest.Response{Response: resp} 628 return 629} 630 631// List lists all of the virtual machines in the specified resource group. Use the nextLink property in the response to 632// get the next page of virtual machines. 633// Parameters: 634// resourceGroupName - the name of the resource group. 635func (client VirtualMachinesClient) List(ctx context.Context, resourceGroupName string) (result VirtualMachineListResultPage, err error) { 636 if tracing.IsEnabled() { 637 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.List") 638 defer func() { 639 sc := -1 640 if result.vmlr.Response.Response != nil { 641 sc = result.vmlr.Response.Response.StatusCode 642 } 643 tracing.EndSpan(ctx, sc, err) 644 }() 645 } 646 result.fn = client.listNextResults 647 req, err := client.ListPreparer(ctx, resourceGroupName) 648 if err != nil { 649 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "List", nil, "Failure preparing request") 650 return 651 } 652 653 resp, err := client.ListSender(req) 654 if err != nil { 655 result.vmlr.Response = autorest.Response{Response: resp} 656 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "List", resp, "Failure sending request") 657 return 658 } 659 660 result.vmlr, err = client.ListResponder(resp) 661 if err != nil { 662 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "List", resp, "Failure responding to request") 663 } 664 665 return 666} 667 668// ListPreparer prepares the List request. 669func (client VirtualMachinesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 670 pathParameters := map[string]interface{}{ 671 "resourceGroupName": autorest.Encode("path", resourceGroupName), 672 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 673 } 674 675 const APIVersion = "2016-03-30" 676 queryParameters := map[string]interface{}{ 677 "api-version": APIVersion, 678 } 679 680 preparer := autorest.CreatePreparer( 681 autorest.AsGet(), 682 autorest.WithBaseURL(client.BaseURI), 683 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines", pathParameters), 684 autorest.WithQueryParameters(queryParameters)) 685 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 686} 687 688// ListSender sends the List request. The method will close the 689// http.Response Body if it receives an error. 690func (client VirtualMachinesClient) ListSender(req *http.Request) (*http.Response, error) { 691 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 692 return autorest.SendWithSender(client, req, sd...) 693} 694 695// ListResponder handles the response to the List request. The method always 696// closes the http.Response Body. 697func (client VirtualMachinesClient) ListResponder(resp *http.Response) (result VirtualMachineListResult, err error) { 698 err = autorest.Respond( 699 resp, 700 client.ByInspecting(), 701 azure.WithErrorUnlessStatusCode(http.StatusOK), 702 autorest.ByUnmarshallingJSON(&result), 703 autorest.ByClosing()) 704 result.Response = autorest.Response{Response: resp} 705 return 706} 707 708// listNextResults retrieves the next set of results, if any. 709func (client VirtualMachinesClient) listNextResults(ctx context.Context, lastResults VirtualMachineListResult) (result VirtualMachineListResult, err error) { 710 req, err := lastResults.virtualMachineListResultPreparer(ctx) 711 if err != nil { 712 return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listNextResults", nil, "Failure preparing next results request") 713 } 714 if req == nil { 715 return 716 } 717 resp, err := client.ListSender(req) 718 if err != nil { 719 result.Response = autorest.Response{Response: resp} 720 return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listNextResults", resp, "Failure sending next results request") 721 } 722 result, err = client.ListResponder(resp) 723 if err != nil { 724 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listNextResults", resp, "Failure responding to next results request") 725 } 726 return 727} 728 729// ListComplete enumerates all values, automatically crossing page boundaries as required. 730func (client VirtualMachinesClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualMachineListResultIterator, err error) { 731 if tracing.IsEnabled() { 732 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.List") 733 defer func() { 734 sc := -1 735 if result.Response().Response.Response != nil { 736 sc = result.page.Response().Response.Response.StatusCode 737 } 738 tracing.EndSpan(ctx, sc, err) 739 }() 740 } 741 result.page, err = client.List(ctx, resourceGroupName) 742 return 743} 744 745// ListAll lists all of the virtual machines in the specified subscription. Use the nextLink property in the response 746// to get the next page of virtual machines. 747func (client VirtualMachinesClient) ListAll(ctx context.Context) (result VirtualMachineListResultPage, err error) { 748 if tracing.IsEnabled() { 749 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListAll") 750 defer func() { 751 sc := -1 752 if result.vmlr.Response.Response != nil { 753 sc = result.vmlr.Response.Response.StatusCode 754 } 755 tracing.EndSpan(ctx, sc, err) 756 }() 757 } 758 result.fn = client.listAllNextResults 759 req, err := client.ListAllPreparer(ctx) 760 if err != nil { 761 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAll", nil, "Failure preparing request") 762 return 763 } 764 765 resp, err := client.ListAllSender(req) 766 if err != nil { 767 result.vmlr.Response = autorest.Response{Response: resp} 768 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAll", resp, "Failure sending request") 769 return 770 } 771 772 result.vmlr, err = client.ListAllResponder(resp) 773 if err != nil { 774 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAll", resp, "Failure responding to request") 775 } 776 777 return 778} 779 780// ListAllPreparer prepares the ListAll request. 781func (client VirtualMachinesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { 782 pathParameters := map[string]interface{}{ 783 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 784 } 785 786 const APIVersion = "2016-03-30" 787 queryParameters := map[string]interface{}{ 788 "api-version": APIVersion, 789 } 790 791 preparer := autorest.CreatePreparer( 792 autorest.AsGet(), 793 autorest.WithBaseURL(client.BaseURI), 794 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachines", pathParameters), 795 autorest.WithQueryParameters(queryParameters)) 796 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 797} 798 799// ListAllSender sends the ListAll request. The method will close the 800// http.Response Body if it receives an error. 801func (client VirtualMachinesClient) ListAllSender(req *http.Request) (*http.Response, error) { 802 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 803 return autorest.SendWithSender(client, req, sd...) 804} 805 806// ListAllResponder handles the response to the ListAll request. The method always 807// closes the http.Response Body. 808func (client VirtualMachinesClient) ListAllResponder(resp *http.Response) (result VirtualMachineListResult, err error) { 809 err = autorest.Respond( 810 resp, 811 client.ByInspecting(), 812 azure.WithErrorUnlessStatusCode(http.StatusOK), 813 autorest.ByUnmarshallingJSON(&result), 814 autorest.ByClosing()) 815 result.Response = autorest.Response{Response: resp} 816 return 817} 818 819// listAllNextResults retrieves the next set of results, if any. 820func (client VirtualMachinesClient) listAllNextResults(ctx context.Context, lastResults VirtualMachineListResult) (result VirtualMachineListResult, err error) { 821 req, err := lastResults.virtualMachineListResultPreparer(ctx) 822 if err != nil { 823 return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listAllNextResults", nil, "Failure preparing next results request") 824 } 825 if req == nil { 826 return 827 } 828 resp, err := client.ListAllSender(req) 829 if err != nil { 830 result.Response = autorest.Response{Response: resp} 831 return result, autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listAllNextResults", resp, "Failure sending next results request") 832 } 833 result, err = client.ListAllResponder(resp) 834 if err != nil { 835 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "listAllNextResults", resp, "Failure responding to next results request") 836 } 837 return 838} 839 840// ListAllComplete enumerates all values, automatically crossing page boundaries as required. 841func (client VirtualMachinesClient) ListAllComplete(ctx context.Context) (result VirtualMachineListResultIterator, err error) { 842 if tracing.IsEnabled() { 843 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListAll") 844 defer func() { 845 sc := -1 846 if result.Response().Response.Response != nil { 847 sc = result.page.Response().Response.Response.StatusCode 848 } 849 tracing.EndSpan(ctx, sc, err) 850 }() 851 } 852 result.page, err = client.ListAll(ctx) 853 return 854} 855 856// ListAvailableSizes lists all available virtual machine sizes to which the specified virtual machine can be resized. 857// Parameters: 858// resourceGroupName - the name of the resource group. 859// VMName - the name of the virtual machine. 860func (client VirtualMachinesClient) ListAvailableSizes(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachineSizeListResult, err error) { 861 if tracing.IsEnabled() { 862 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListAvailableSizes") 863 defer func() { 864 sc := -1 865 if result.Response.Response != nil { 866 sc = result.Response.Response.StatusCode 867 } 868 tracing.EndSpan(ctx, sc, err) 869 }() 870 } 871 req, err := client.ListAvailableSizesPreparer(ctx, resourceGroupName, VMName) 872 if err != nil { 873 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAvailableSizes", nil, "Failure preparing request") 874 return 875 } 876 877 resp, err := client.ListAvailableSizesSender(req) 878 if err != nil { 879 result.Response = autorest.Response{Response: resp} 880 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAvailableSizes", resp, "Failure sending request") 881 return 882 } 883 884 result, err = client.ListAvailableSizesResponder(resp) 885 if err != nil { 886 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "ListAvailableSizes", resp, "Failure responding to request") 887 } 888 889 return 890} 891 892// ListAvailableSizesPreparer prepares the ListAvailableSizes request. 893func (client VirtualMachinesClient) ListAvailableSizesPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 894 pathParameters := map[string]interface{}{ 895 "resourceGroupName": autorest.Encode("path", resourceGroupName), 896 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 897 "vmName": autorest.Encode("path", VMName), 898 } 899 900 const APIVersion = "2016-03-30" 901 queryParameters := map[string]interface{}{ 902 "api-version": APIVersion, 903 } 904 905 preparer := autorest.CreatePreparer( 906 autorest.AsGet(), 907 autorest.WithBaseURL(client.BaseURI), 908 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/vmSizes", pathParameters), 909 autorest.WithQueryParameters(queryParameters)) 910 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 911} 912 913// ListAvailableSizesSender sends the ListAvailableSizes request. The method will close the 914// http.Response Body if it receives an error. 915func (client VirtualMachinesClient) ListAvailableSizesSender(req *http.Request) (*http.Response, error) { 916 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 917 return autorest.SendWithSender(client, req, sd...) 918} 919 920// ListAvailableSizesResponder handles the response to the ListAvailableSizes request. The method always 921// closes the http.Response Body. 922func (client VirtualMachinesClient) ListAvailableSizesResponder(resp *http.Response) (result VirtualMachineSizeListResult, err error) { 923 err = autorest.Respond( 924 resp, 925 client.ByInspecting(), 926 azure.WithErrorUnlessStatusCode(http.StatusOK), 927 autorest.ByUnmarshallingJSON(&result), 928 autorest.ByClosing()) 929 result.Response = autorest.Response{Response: resp} 930 return 931} 932 933// PowerOff the operation to power off (stop) a virtual machine. The virtual machine can be restarted with the same 934// provisioned resources. You are still charged for this virtual machine. 935// Parameters: 936// resourceGroupName - the name of the resource group. 937// VMName - the name of the virtual machine. 938func (client VirtualMachinesClient) PowerOff(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesPowerOffFuture, err error) { 939 if tracing.IsEnabled() { 940 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.PowerOff") 941 defer func() { 942 sc := -1 943 if result.Response() != nil { 944 sc = result.Response().StatusCode 945 } 946 tracing.EndSpan(ctx, sc, err) 947 }() 948 } 949 req, err := client.PowerOffPreparer(ctx, resourceGroupName, VMName) 950 if err != nil { 951 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "PowerOff", nil, "Failure preparing request") 952 return 953 } 954 955 result, err = client.PowerOffSender(req) 956 if err != nil { 957 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "PowerOff", result.Response(), "Failure sending request") 958 return 959 } 960 961 return 962} 963 964// PowerOffPreparer prepares the PowerOff request. 965func (client VirtualMachinesClient) PowerOffPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 966 pathParameters := map[string]interface{}{ 967 "resourceGroupName": autorest.Encode("path", resourceGroupName), 968 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 969 "vmName": autorest.Encode("path", VMName), 970 } 971 972 const APIVersion = "2016-03-30" 973 queryParameters := map[string]interface{}{ 974 "api-version": APIVersion, 975 } 976 977 preparer := autorest.CreatePreparer( 978 autorest.AsPost(), 979 autorest.WithBaseURL(client.BaseURI), 980 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/powerOff", pathParameters), 981 autorest.WithQueryParameters(queryParameters)) 982 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 983} 984 985// PowerOffSender sends the PowerOff request. The method will close the 986// http.Response Body if it receives an error. 987func (client VirtualMachinesClient) PowerOffSender(req *http.Request) (future VirtualMachinesPowerOffFuture, err error) { 988 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 989 var resp *http.Response 990 resp, err = autorest.SendWithSender(client, req, sd...) 991 if err != nil { 992 return 993 } 994 future.Future, err = azure.NewFutureFromResponse(resp) 995 return 996} 997 998// PowerOffResponder handles the response to the PowerOff request. The method always 999// closes the http.Response Body. 1000func (client VirtualMachinesClient) PowerOffResponder(resp *http.Response) (result OperationStatusResponse, err error) { 1001 err = autorest.Respond( 1002 resp, 1003 client.ByInspecting(), 1004 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1005 autorest.ByUnmarshallingJSON(&result), 1006 autorest.ByClosing()) 1007 result.Response = autorest.Response{Response: resp} 1008 return 1009} 1010 1011// Redeploy shuts down the virtual machine, moves it to a new node, and powers it back on. 1012// Parameters: 1013// resourceGroupName - the name of the resource group. 1014// VMName - the name of the virtual machine. 1015func (client VirtualMachinesClient) Redeploy(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesRedeployFuture, err error) { 1016 if tracing.IsEnabled() { 1017 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Redeploy") 1018 defer func() { 1019 sc := -1 1020 if result.Response() != nil { 1021 sc = result.Response().StatusCode 1022 } 1023 tracing.EndSpan(ctx, sc, err) 1024 }() 1025 } 1026 req, err := client.RedeployPreparer(ctx, resourceGroupName, VMName) 1027 if err != nil { 1028 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Redeploy", nil, "Failure preparing request") 1029 return 1030 } 1031 1032 result, err = client.RedeploySender(req) 1033 if err != nil { 1034 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Redeploy", result.Response(), "Failure sending request") 1035 return 1036 } 1037 1038 return 1039} 1040 1041// RedeployPreparer prepares the Redeploy request. 1042func (client VirtualMachinesClient) RedeployPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 1043 pathParameters := map[string]interface{}{ 1044 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1045 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1046 "vmName": autorest.Encode("path", VMName), 1047 } 1048 1049 const APIVersion = "2016-03-30" 1050 queryParameters := map[string]interface{}{ 1051 "api-version": APIVersion, 1052 } 1053 1054 preparer := autorest.CreatePreparer( 1055 autorest.AsPost(), 1056 autorest.WithBaseURL(client.BaseURI), 1057 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy", pathParameters), 1058 autorest.WithQueryParameters(queryParameters)) 1059 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1060} 1061 1062// RedeploySender sends the Redeploy request. The method will close the 1063// http.Response Body if it receives an error. 1064func (client VirtualMachinesClient) RedeploySender(req *http.Request) (future VirtualMachinesRedeployFuture, err error) { 1065 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 1066 var resp *http.Response 1067 resp, err = autorest.SendWithSender(client, req, sd...) 1068 if err != nil { 1069 return 1070 } 1071 future.Future, err = azure.NewFutureFromResponse(resp) 1072 return 1073} 1074 1075// RedeployResponder handles the response to the Redeploy request. The method always 1076// closes the http.Response Body. 1077func (client VirtualMachinesClient) RedeployResponder(resp *http.Response) (result OperationStatusResponse, err error) { 1078 err = autorest.Respond( 1079 resp, 1080 client.ByInspecting(), 1081 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1082 autorest.ByUnmarshallingJSON(&result), 1083 autorest.ByClosing()) 1084 result.Response = autorest.Response{Response: resp} 1085 return 1086} 1087 1088// Restart the operation to restart a virtual machine. 1089// Parameters: 1090// resourceGroupName - the name of the resource group. 1091// VMName - the name of the virtual machine. 1092func (client VirtualMachinesClient) Restart(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesRestartFuture, err error) { 1093 if tracing.IsEnabled() { 1094 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Restart") 1095 defer func() { 1096 sc := -1 1097 if result.Response() != nil { 1098 sc = result.Response().StatusCode 1099 } 1100 tracing.EndSpan(ctx, sc, err) 1101 }() 1102 } 1103 req, err := client.RestartPreparer(ctx, resourceGroupName, VMName) 1104 if err != nil { 1105 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Restart", nil, "Failure preparing request") 1106 return 1107 } 1108 1109 result, err = client.RestartSender(req) 1110 if err != nil { 1111 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Restart", result.Response(), "Failure sending request") 1112 return 1113 } 1114 1115 return 1116} 1117 1118// RestartPreparer prepares the Restart request. 1119func (client VirtualMachinesClient) RestartPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 1120 pathParameters := map[string]interface{}{ 1121 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1122 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1123 "vmName": autorest.Encode("path", VMName), 1124 } 1125 1126 const APIVersion = "2016-03-30" 1127 queryParameters := map[string]interface{}{ 1128 "api-version": APIVersion, 1129 } 1130 1131 preparer := autorest.CreatePreparer( 1132 autorest.AsPost(), 1133 autorest.WithBaseURL(client.BaseURI), 1134 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart", pathParameters), 1135 autorest.WithQueryParameters(queryParameters)) 1136 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1137} 1138 1139// RestartSender sends the Restart request. The method will close the 1140// http.Response Body if it receives an error. 1141func (client VirtualMachinesClient) RestartSender(req *http.Request) (future VirtualMachinesRestartFuture, err error) { 1142 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 1143 var resp *http.Response 1144 resp, err = autorest.SendWithSender(client, req, sd...) 1145 if err != nil { 1146 return 1147 } 1148 future.Future, err = azure.NewFutureFromResponse(resp) 1149 return 1150} 1151 1152// RestartResponder handles the response to the Restart request. The method always 1153// closes the http.Response Body. 1154func (client VirtualMachinesClient) RestartResponder(resp *http.Response) (result OperationStatusResponse, err error) { 1155 err = autorest.Respond( 1156 resp, 1157 client.ByInspecting(), 1158 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1159 autorest.ByUnmarshallingJSON(&result), 1160 autorest.ByClosing()) 1161 result.Response = autorest.Response{Response: resp} 1162 return 1163} 1164 1165// Start the operation to start a virtual machine. 1166// Parameters: 1167// resourceGroupName - the name of the resource group. 1168// VMName - the name of the virtual machine. 1169func (client VirtualMachinesClient) Start(ctx context.Context, resourceGroupName string, VMName string) (result VirtualMachinesStartFuture, err error) { 1170 if tracing.IsEnabled() { 1171 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Start") 1172 defer func() { 1173 sc := -1 1174 if result.Response() != nil { 1175 sc = result.Response().StatusCode 1176 } 1177 tracing.EndSpan(ctx, sc, err) 1178 }() 1179 } 1180 req, err := client.StartPreparer(ctx, resourceGroupName, VMName) 1181 if err != nil { 1182 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Start", nil, "Failure preparing request") 1183 return 1184 } 1185 1186 result, err = client.StartSender(req) 1187 if err != nil { 1188 err = autorest.NewErrorWithError(err, "compute.VirtualMachinesClient", "Start", result.Response(), "Failure sending request") 1189 return 1190 } 1191 1192 return 1193} 1194 1195// StartPreparer prepares the Start request. 1196func (client VirtualMachinesClient) StartPreparer(ctx context.Context, resourceGroupName string, VMName string) (*http.Request, error) { 1197 pathParameters := map[string]interface{}{ 1198 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1199 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1200 "vmName": autorest.Encode("path", VMName), 1201 } 1202 1203 const APIVersion = "2016-03-30" 1204 queryParameters := map[string]interface{}{ 1205 "api-version": APIVersion, 1206 } 1207 1208 preparer := autorest.CreatePreparer( 1209 autorest.AsPost(), 1210 autorest.WithBaseURL(client.BaseURI), 1211 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start", pathParameters), 1212 autorest.WithQueryParameters(queryParameters)) 1213 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1214} 1215 1216// StartSender sends the Start request. The method will close the 1217// http.Response Body if it receives an error. 1218func (client VirtualMachinesClient) StartSender(req *http.Request) (future VirtualMachinesStartFuture, err error) { 1219 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 1220 var resp *http.Response 1221 resp, err = autorest.SendWithSender(client, req, sd...) 1222 if err != nil { 1223 return 1224 } 1225 future.Future, err = azure.NewFutureFromResponse(resp) 1226 return 1227} 1228 1229// StartResponder handles the response to the Start request. The method always 1230// closes the http.Response Body. 1231func (client VirtualMachinesClient) StartResponder(resp *http.Response) (result OperationStatusResponse, err error) { 1232 err = autorest.Respond( 1233 resp, 1234 client.ByInspecting(), 1235 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1236 autorest.ByUnmarshallingJSON(&result), 1237 autorest.ByClosing()) 1238 result.Response = autorest.Response{Response: resp} 1239 return 1240} 1241