1package dtl 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 "net/http" 25) 26 27// VirtualMachineClient is the azure DevTest Labs REST API version 2015-05-21-preview. 28type VirtualMachineClient struct { 29 BaseClient 30} 31 32// NewVirtualMachineClient creates an instance of the VirtualMachineClient client. 33func NewVirtualMachineClient(subscriptionID string) VirtualMachineClient { 34 return NewVirtualMachineClientWithBaseURI(DefaultBaseURI, subscriptionID) 35} 36 37// NewVirtualMachineClientWithBaseURI creates an instance of the VirtualMachineClient client. 38func NewVirtualMachineClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineClient { 39 return VirtualMachineClient{NewWithBaseURI(baseURI, subscriptionID)} 40} 41 42// ApplyArtifacts apply artifacts to Lab VM. This operation can take a while to complete. 43// Parameters: 44// resourceGroupName - the name of the resource group. 45// labName - the name of the lab. 46// name - the name of the virtual Machine. 47func (client VirtualMachineClient) ApplyArtifacts(ctx context.Context, resourceGroupName string, labName string, name string, applyArtifactsRequest ApplyArtifactsRequest) (result VirtualMachineApplyArtifactsFuture, err error) { 48 req, err := client.ApplyArtifactsPreparer(ctx, resourceGroupName, labName, name, applyArtifactsRequest) 49 if err != nil { 50 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "ApplyArtifacts", nil, "Failure preparing request") 51 return 52 } 53 54 result, err = client.ApplyArtifactsSender(req) 55 if err != nil { 56 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "ApplyArtifacts", result.Response(), "Failure sending request") 57 return 58 } 59 60 return 61} 62 63// ApplyArtifactsPreparer prepares the ApplyArtifacts request. 64func (client VirtualMachineClient) ApplyArtifactsPreparer(ctx context.Context, resourceGroupName string, labName string, name string, applyArtifactsRequest ApplyArtifactsRequest) (*http.Request, error) { 65 pathParameters := map[string]interface{}{ 66 "labName": autorest.Encode("path", labName), 67 "name": autorest.Encode("path", name), 68 "resourceGroupName": autorest.Encode("path", resourceGroupName), 69 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 70 } 71 72 const APIVersion = "2015-05-21-preview" 73 queryParameters := map[string]interface{}{ 74 "api-version": APIVersion, 75 } 76 77 preparer := autorest.CreatePreparer( 78 autorest.AsContentType("application/json; charset=utf-8"), 79 autorest.AsPost(), 80 autorest.WithBaseURL(client.BaseURI), 81 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/applyArtifacts", pathParameters), 82 autorest.WithJSON(applyArtifactsRequest), 83 autorest.WithQueryParameters(queryParameters)) 84 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 85} 86 87// ApplyArtifactsSender sends the ApplyArtifacts request. The method will close the 88// http.Response Body if it receives an error. 89func (client VirtualMachineClient) ApplyArtifactsSender(req *http.Request) (future VirtualMachineApplyArtifactsFuture, err error) { 90 var resp *http.Response 91 resp, err = autorest.SendWithSender(client, req, 92 azure.DoRetryWithRegistration(client.Client)) 93 if err != nil { 94 return 95 } 96 err = autorest.Respond(resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted)) 97 if err != nil { 98 return 99 } 100 future.Future, err = azure.NewFutureFromResponse(resp) 101 return 102} 103 104// ApplyArtifactsResponder handles the response to the ApplyArtifacts request. The method always 105// closes the http.Response Body. 106func (client VirtualMachineClient) ApplyArtifactsResponder(resp *http.Response) (result autorest.Response, err error) { 107 err = autorest.Respond( 108 resp, 109 client.ByInspecting(), 110 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 111 autorest.ByClosing()) 112 result.Response = resp 113 return 114} 115 116// CreateOrUpdateResource create or replace an existing Virtual Machine. This operation can take a while to complete. 117// Parameters: 118// resourceGroupName - the name of the resource group. 119// labName - the name of the lab. 120// name - the name of the virtual Machine. 121func (client VirtualMachineClient) CreateOrUpdateResource(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachine) (result VirtualMachineCreateOrUpdateResourceFuture, err error) { 122 req, err := client.CreateOrUpdateResourcePreparer(ctx, resourceGroupName, labName, name, labVirtualMachine) 123 if err != nil { 124 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "CreateOrUpdateResource", nil, "Failure preparing request") 125 return 126 } 127 128 result, err = client.CreateOrUpdateResourceSender(req) 129 if err != nil { 130 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "CreateOrUpdateResource", result.Response(), "Failure sending request") 131 return 132 } 133 134 return 135} 136 137// CreateOrUpdateResourcePreparer prepares the CreateOrUpdateResource request. 138func (client VirtualMachineClient) CreateOrUpdateResourcePreparer(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachine) (*http.Request, error) { 139 pathParameters := map[string]interface{}{ 140 "labName": autorest.Encode("path", labName), 141 "name": autorest.Encode("path", name), 142 "resourceGroupName": autorest.Encode("path", resourceGroupName), 143 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 144 } 145 146 const APIVersion = "2015-05-21-preview" 147 queryParameters := map[string]interface{}{ 148 "api-version": APIVersion, 149 } 150 151 preparer := autorest.CreatePreparer( 152 autorest.AsContentType("application/json; charset=utf-8"), 153 autorest.AsPut(), 154 autorest.WithBaseURL(client.BaseURI), 155 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 156 autorest.WithJSON(labVirtualMachine), 157 autorest.WithQueryParameters(queryParameters)) 158 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 159} 160 161// CreateOrUpdateResourceSender sends the CreateOrUpdateResource request. The method will close the 162// http.Response Body if it receives an error. 163func (client VirtualMachineClient) CreateOrUpdateResourceSender(req *http.Request) (future VirtualMachineCreateOrUpdateResourceFuture, err error) { 164 var resp *http.Response 165 resp, err = autorest.SendWithSender(client, req, 166 azure.DoRetryWithRegistration(client.Client)) 167 if err != nil { 168 return 169 } 170 err = autorest.Respond(resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated)) 171 if err != nil { 172 return 173 } 174 future.Future, err = azure.NewFutureFromResponse(resp) 175 return 176} 177 178// CreateOrUpdateResourceResponder handles the response to the CreateOrUpdateResource request. The method always 179// closes the http.Response Body. 180func (client VirtualMachineClient) CreateOrUpdateResourceResponder(resp *http.Response) (result LabVirtualMachine, err error) { 181 err = autorest.Respond( 182 resp, 183 client.ByInspecting(), 184 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 185 autorest.ByUnmarshallingJSON(&result), 186 autorest.ByClosing()) 187 result.Response = autorest.Response{Response: resp} 188 return 189} 190 191// DeleteResource delete virtual machine. This operation can take a while to complete. 192// Parameters: 193// resourceGroupName - the name of the resource group. 194// labName - the name of the lab. 195// name - the name of the virtual Machine. 196func (client VirtualMachineClient) DeleteResource(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachineDeleteResourceFuture, err error) { 197 req, err := client.DeleteResourcePreparer(ctx, resourceGroupName, labName, name) 198 if err != nil { 199 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "DeleteResource", nil, "Failure preparing request") 200 return 201 } 202 203 result, err = client.DeleteResourceSender(req) 204 if err != nil { 205 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "DeleteResource", result.Response(), "Failure sending request") 206 return 207 } 208 209 return 210} 211 212// DeleteResourcePreparer prepares the DeleteResource request. 213func (client VirtualMachineClient) DeleteResourcePreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 214 pathParameters := map[string]interface{}{ 215 "labName": autorest.Encode("path", labName), 216 "name": autorest.Encode("path", name), 217 "resourceGroupName": autorest.Encode("path", resourceGroupName), 218 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 219 } 220 221 const APIVersion = "2015-05-21-preview" 222 queryParameters := map[string]interface{}{ 223 "api-version": APIVersion, 224 } 225 226 preparer := autorest.CreatePreparer( 227 autorest.AsDelete(), 228 autorest.WithBaseURL(client.BaseURI), 229 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 230 autorest.WithQueryParameters(queryParameters)) 231 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 232} 233 234// DeleteResourceSender sends the DeleteResource request. The method will close the 235// http.Response Body if it receives an error. 236func (client VirtualMachineClient) DeleteResourceSender(req *http.Request) (future VirtualMachineDeleteResourceFuture, err error) { 237 var resp *http.Response 238 resp, err = autorest.SendWithSender(client, req, 239 azure.DoRetryWithRegistration(client.Client)) 240 if err != nil { 241 return 242 } 243 err = autorest.Respond(resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent)) 244 if err != nil { 245 return 246 } 247 future.Future, err = azure.NewFutureFromResponse(resp) 248 return 249} 250 251// DeleteResourceResponder handles the response to the DeleteResource request. The method always 252// closes the http.Response Body. 253func (client VirtualMachineClient) DeleteResourceResponder(resp *http.Response) (result autorest.Response, err error) { 254 err = autorest.Respond( 255 resp, 256 client.ByInspecting(), 257 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 258 autorest.ByClosing()) 259 result.Response = resp 260 return 261} 262 263// GetResource get virtual machine. 264// Parameters: 265// resourceGroupName - the name of the resource group. 266// labName - the name of the lab. 267// name - the name of the virtual Machine. 268func (client VirtualMachineClient) GetResource(ctx context.Context, resourceGroupName string, labName string, name string) (result LabVirtualMachine, err error) { 269 req, err := client.GetResourcePreparer(ctx, resourceGroupName, labName, name) 270 if err != nil { 271 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "GetResource", nil, "Failure preparing request") 272 return 273 } 274 275 resp, err := client.GetResourceSender(req) 276 if err != nil { 277 result.Response = autorest.Response{Response: resp} 278 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "GetResource", resp, "Failure sending request") 279 return 280 } 281 282 result, err = client.GetResourceResponder(resp) 283 if err != nil { 284 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "GetResource", resp, "Failure responding to request") 285 } 286 287 return 288} 289 290// GetResourcePreparer prepares the GetResource request. 291func (client VirtualMachineClient) GetResourcePreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 292 pathParameters := map[string]interface{}{ 293 "labName": autorest.Encode("path", labName), 294 "name": autorest.Encode("path", name), 295 "resourceGroupName": autorest.Encode("path", resourceGroupName), 296 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 297 } 298 299 const APIVersion = "2015-05-21-preview" 300 queryParameters := map[string]interface{}{ 301 "api-version": APIVersion, 302 } 303 304 preparer := autorest.CreatePreparer( 305 autorest.AsGet(), 306 autorest.WithBaseURL(client.BaseURI), 307 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 308 autorest.WithQueryParameters(queryParameters)) 309 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 310} 311 312// GetResourceSender sends the GetResource request. The method will close the 313// http.Response Body if it receives an error. 314func (client VirtualMachineClient) GetResourceSender(req *http.Request) (*http.Response, error) { 315 return autorest.SendWithSender(client, req, 316 azure.DoRetryWithRegistration(client.Client)) 317} 318 319// GetResourceResponder handles the response to the GetResource request. The method always 320// closes the http.Response Body. 321func (client VirtualMachineClient) GetResourceResponder(resp *http.Response) (result LabVirtualMachine, err error) { 322 err = autorest.Respond( 323 resp, 324 client.ByInspecting(), 325 azure.WithErrorUnlessStatusCode(http.StatusOK), 326 autorest.ByUnmarshallingJSON(&result), 327 autorest.ByClosing()) 328 result.Response = autorest.Response{Response: resp} 329 return 330} 331 332// List list virtual machines. 333// Parameters: 334// resourceGroupName - the name of the resource group. 335// labName - the name of the lab. 336// filter - the filter to apply on the operation. 337func (client VirtualMachineClient) List(ctx context.Context, resourceGroupName string, labName string, filter string, top *int32, orderBy string) (result ResponseWithContinuationLabVirtualMachinePage, err error) { 338 result.fn = client.listNextResults 339 req, err := client.ListPreparer(ctx, resourceGroupName, labName, filter, top, orderBy) 340 if err != nil { 341 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "List", nil, "Failure preparing request") 342 return 343 } 344 345 resp, err := client.ListSender(req) 346 if err != nil { 347 result.rwclvm.Response = autorest.Response{Response: resp} 348 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "List", resp, "Failure sending request") 349 return 350 } 351 352 result.rwclvm, err = client.ListResponder(resp) 353 if err != nil { 354 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "List", resp, "Failure responding to request") 355 } 356 357 return 358} 359 360// ListPreparer prepares the List request. 361func (client VirtualMachineClient) ListPreparer(ctx context.Context, resourceGroupName string, labName string, filter string, top *int32, orderBy string) (*http.Request, error) { 362 pathParameters := map[string]interface{}{ 363 "labName": autorest.Encode("path", labName), 364 "resourceGroupName": autorest.Encode("path", resourceGroupName), 365 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 366 } 367 368 const APIVersion = "2015-05-21-preview" 369 queryParameters := map[string]interface{}{ 370 "api-version": APIVersion, 371 } 372 if len(filter) > 0 { 373 queryParameters["$filter"] = autorest.Encode("query", filter) 374 } 375 if top != nil { 376 queryParameters["$top"] = autorest.Encode("query", *top) 377 } 378 if len(orderBy) > 0 { 379 queryParameters["$orderBy"] = autorest.Encode("query", orderBy) 380 } 381 382 preparer := autorest.CreatePreparer( 383 autorest.AsGet(), 384 autorest.WithBaseURL(client.BaseURI), 385 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines", pathParameters), 386 autorest.WithQueryParameters(queryParameters)) 387 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 388} 389 390// ListSender sends the List request. The method will close the 391// http.Response Body if it receives an error. 392func (client VirtualMachineClient) ListSender(req *http.Request) (*http.Response, error) { 393 return autorest.SendWithSender(client, req, 394 azure.DoRetryWithRegistration(client.Client)) 395} 396 397// ListResponder handles the response to the List request. The method always 398// closes the http.Response Body. 399func (client VirtualMachineClient) ListResponder(resp *http.Response) (result ResponseWithContinuationLabVirtualMachine, err error) { 400 err = autorest.Respond( 401 resp, 402 client.ByInspecting(), 403 azure.WithErrorUnlessStatusCode(http.StatusOK), 404 autorest.ByUnmarshallingJSON(&result), 405 autorest.ByClosing()) 406 result.Response = autorest.Response{Response: resp} 407 return 408} 409 410// listNextResults retrieves the next set of results, if any. 411func (client VirtualMachineClient) listNextResults(lastResults ResponseWithContinuationLabVirtualMachine) (result ResponseWithContinuationLabVirtualMachine, err error) { 412 req, err := lastResults.responseWithContinuationLabVirtualMachinePreparer() 413 if err != nil { 414 return result, autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "listNextResults", nil, "Failure preparing next results request") 415 } 416 if req == nil { 417 return 418 } 419 resp, err := client.ListSender(req) 420 if err != nil { 421 result.Response = autorest.Response{Response: resp} 422 return result, autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "listNextResults", resp, "Failure sending next results request") 423 } 424 result, err = client.ListResponder(resp) 425 if err != nil { 426 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "listNextResults", resp, "Failure responding to next results request") 427 } 428 return 429} 430 431// ListComplete enumerates all values, automatically crossing page boundaries as required. 432func (client VirtualMachineClient) ListComplete(ctx context.Context, resourceGroupName string, labName string, filter string, top *int32, orderBy string) (result ResponseWithContinuationLabVirtualMachineIterator, err error) { 433 result.page, err = client.List(ctx, resourceGroupName, labName, filter, top, orderBy) 434 return 435} 436 437// PatchResource modify properties of virtual machines. 438// Parameters: 439// resourceGroupName - the name of the resource group. 440// labName - the name of the lab. 441// name - the name of the virtual Machine. 442func (client VirtualMachineClient) PatchResource(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachine) (result LabVirtualMachine, err error) { 443 req, err := client.PatchResourcePreparer(ctx, resourceGroupName, labName, name, labVirtualMachine) 444 if err != nil { 445 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "PatchResource", nil, "Failure preparing request") 446 return 447 } 448 449 resp, err := client.PatchResourceSender(req) 450 if err != nil { 451 result.Response = autorest.Response{Response: resp} 452 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "PatchResource", resp, "Failure sending request") 453 return 454 } 455 456 result, err = client.PatchResourceResponder(resp) 457 if err != nil { 458 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "PatchResource", resp, "Failure responding to request") 459 } 460 461 return 462} 463 464// PatchResourcePreparer prepares the PatchResource request. 465func (client VirtualMachineClient) PatchResourcePreparer(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachine) (*http.Request, error) { 466 pathParameters := map[string]interface{}{ 467 "labName": autorest.Encode("path", labName), 468 "name": autorest.Encode("path", name), 469 "resourceGroupName": autorest.Encode("path", resourceGroupName), 470 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 471 } 472 473 const APIVersion = "2015-05-21-preview" 474 queryParameters := map[string]interface{}{ 475 "api-version": APIVersion, 476 } 477 478 preparer := autorest.CreatePreparer( 479 autorest.AsContentType("application/json; charset=utf-8"), 480 autorest.AsPatch(), 481 autorest.WithBaseURL(client.BaseURI), 482 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 483 autorest.WithJSON(labVirtualMachine), 484 autorest.WithQueryParameters(queryParameters)) 485 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 486} 487 488// PatchResourceSender sends the PatchResource request. The method will close the 489// http.Response Body if it receives an error. 490func (client VirtualMachineClient) PatchResourceSender(req *http.Request) (*http.Response, error) { 491 return autorest.SendWithSender(client, req, 492 azure.DoRetryWithRegistration(client.Client)) 493} 494 495// PatchResourceResponder handles the response to the PatchResource request. The method always 496// closes the http.Response Body. 497func (client VirtualMachineClient) PatchResourceResponder(resp *http.Response) (result LabVirtualMachine, err error) { 498 err = autorest.Respond( 499 resp, 500 client.ByInspecting(), 501 azure.WithErrorUnlessStatusCode(http.StatusOK), 502 autorest.ByUnmarshallingJSON(&result), 503 autorest.ByClosing()) 504 result.Response = autorest.Response{Response: resp} 505 return 506} 507 508// Start start a Lab VM. This operation can take a while to complete. 509// Parameters: 510// resourceGroupName - the name of the resource group. 511// labName - the name of the lab. 512// name - the name of the virtual Machine. 513func (client VirtualMachineClient) Start(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachineStartFuture, err error) { 514 req, err := client.StartPreparer(ctx, resourceGroupName, labName, name) 515 if err != nil { 516 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "Start", nil, "Failure preparing request") 517 return 518 } 519 520 result, err = client.StartSender(req) 521 if err != nil { 522 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "Start", result.Response(), "Failure sending request") 523 return 524 } 525 526 return 527} 528 529// StartPreparer prepares the Start request. 530func (client VirtualMachineClient) StartPreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 531 pathParameters := map[string]interface{}{ 532 "labName": autorest.Encode("path", labName), 533 "name": autorest.Encode("path", name), 534 "resourceGroupName": autorest.Encode("path", resourceGroupName), 535 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 536 } 537 538 const APIVersion = "2015-05-21-preview" 539 queryParameters := map[string]interface{}{ 540 "api-version": APIVersion, 541 } 542 543 preparer := autorest.CreatePreparer( 544 autorest.AsPost(), 545 autorest.WithBaseURL(client.BaseURI), 546 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/start", pathParameters), 547 autorest.WithQueryParameters(queryParameters)) 548 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 549} 550 551// StartSender sends the Start request. The method will close the 552// http.Response Body if it receives an error. 553func (client VirtualMachineClient) StartSender(req *http.Request) (future VirtualMachineStartFuture, err error) { 554 var resp *http.Response 555 resp, err = autorest.SendWithSender(client, req, 556 azure.DoRetryWithRegistration(client.Client)) 557 if err != nil { 558 return 559 } 560 err = autorest.Respond(resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted)) 561 if err != nil { 562 return 563 } 564 future.Future, err = azure.NewFutureFromResponse(resp) 565 return 566} 567 568// StartResponder handles the response to the Start request. The method always 569// closes the http.Response Body. 570func (client VirtualMachineClient) StartResponder(resp *http.Response) (result autorest.Response, err error) { 571 err = autorest.Respond( 572 resp, 573 client.ByInspecting(), 574 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 575 autorest.ByClosing()) 576 result.Response = resp 577 return 578} 579 580// Stop stop a Lab VM. This operation can take a while to complete. 581// Parameters: 582// resourceGroupName - the name of the resource group. 583// labName - the name of the lab. 584// name - the name of the virtual Machine. 585func (client VirtualMachineClient) Stop(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachineStopFuture, err error) { 586 req, err := client.StopPreparer(ctx, resourceGroupName, labName, name) 587 if err != nil { 588 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "Stop", nil, "Failure preparing request") 589 return 590 } 591 592 result, err = client.StopSender(req) 593 if err != nil { 594 err = autorest.NewErrorWithError(err, "dtl.VirtualMachineClient", "Stop", result.Response(), "Failure sending request") 595 return 596 } 597 598 return 599} 600 601// StopPreparer prepares the Stop request. 602func (client VirtualMachineClient) StopPreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 603 pathParameters := map[string]interface{}{ 604 "labName": autorest.Encode("path", labName), 605 "name": autorest.Encode("path", name), 606 "resourceGroupName": autorest.Encode("path", resourceGroupName), 607 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 608 } 609 610 const APIVersion = "2015-05-21-preview" 611 queryParameters := map[string]interface{}{ 612 "api-version": APIVersion, 613 } 614 615 preparer := autorest.CreatePreparer( 616 autorest.AsPost(), 617 autorest.WithBaseURL(client.BaseURI), 618 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/stop", pathParameters), 619 autorest.WithQueryParameters(queryParameters)) 620 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 621} 622 623// StopSender sends the Stop request. The method will close the 624// http.Response Body if it receives an error. 625func (client VirtualMachineClient) StopSender(req *http.Request) (future VirtualMachineStopFuture, err error) { 626 var resp *http.Response 627 resp, err = autorest.SendWithSender(client, req, 628 azure.DoRetryWithRegistration(client.Client)) 629 if err != nil { 630 return 631 } 632 err = autorest.Respond(resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted)) 633 if err != nil { 634 return 635 } 636 future.Future, err = azure.NewFutureFromResponse(resp) 637 return 638} 639 640// StopResponder handles the response to the Stop request. The method always 641// closes the http.Response Body. 642func (client VirtualMachineClient) StopResponder(resp *http.Response) (result autorest.Response, err error) { 643 err = autorest.Respond( 644 resp, 645 client.ByInspecting(), 646 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 647 autorest.ByClosing()) 648 result.Response = resp 649 return 650} 651