1package dtl 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/autorest/validation" 14 "github.com/Azure/go-autorest/tracing" 15 "net/http" 16) 17 18// VirtualMachinesClient is the the DevTest Labs Client. 19type VirtualMachinesClient struct { 20 BaseClient 21} 22 23// NewVirtualMachinesClient creates an instance of the VirtualMachinesClient client. 24func NewVirtualMachinesClient(subscriptionID string) VirtualMachinesClient { 25 return NewVirtualMachinesClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewVirtualMachinesClientWithBaseURI creates an instance of the VirtualMachinesClient client using a custom endpoint. 29// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 30func NewVirtualMachinesClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachinesClient { 31 return VirtualMachinesClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// AddDataDisk attach a new or existing data disk to virtual machine. This operation can take a while to complete. 35// Parameters: 36// resourceGroupName - the name of the resource group. 37// labName - the name of the lab. 38// name - the name of the virtual machine. 39// dataDiskProperties - request body for adding a new or existing data disk to a virtual machine. 40func (client VirtualMachinesClient) AddDataDisk(ctx context.Context, resourceGroupName string, labName string, name string, dataDiskProperties DataDiskProperties) (result VirtualMachinesAddDataDiskFuture, err error) { 41 if tracing.IsEnabled() { 42 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.AddDataDisk") 43 defer func() { 44 sc := -1 45 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 46 sc = result.FutureAPI.Response().StatusCode 47 } 48 tracing.EndSpan(ctx, sc, err) 49 }() 50 } 51 req, err := client.AddDataDiskPreparer(ctx, resourceGroupName, labName, name, dataDiskProperties) 52 if err != nil { 53 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "AddDataDisk", nil, "Failure preparing request") 54 return 55 } 56 57 result, err = client.AddDataDiskSender(req) 58 if err != nil { 59 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "AddDataDisk", nil, "Failure sending request") 60 return 61 } 62 63 return 64} 65 66// AddDataDiskPreparer prepares the AddDataDisk request. 67func (client VirtualMachinesClient) AddDataDiskPreparer(ctx context.Context, resourceGroupName string, labName string, name string, dataDiskProperties DataDiskProperties) (*http.Request, error) { 68 pathParameters := map[string]interface{}{ 69 "labName": autorest.Encode("path", labName), 70 "name": autorest.Encode("path", name), 71 "resourceGroupName": autorest.Encode("path", resourceGroupName), 72 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 73 } 74 75 const APIVersion = "2016-05-15" 76 queryParameters := map[string]interface{}{ 77 "api-version": APIVersion, 78 } 79 80 preparer := autorest.CreatePreparer( 81 autorest.AsContentType("application/json; charset=utf-8"), 82 autorest.AsPost(), 83 autorest.WithBaseURL(client.BaseURI), 84 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/addDataDisk", pathParameters), 85 autorest.WithJSON(dataDiskProperties), 86 autorest.WithQueryParameters(queryParameters)) 87 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 88} 89 90// AddDataDiskSender sends the AddDataDisk request. The method will close the 91// http.Response Body if it receives an error. 92func (client VirtualMachinesClient) AddDataDiskSender(req *http.Request) (future VirtualMachinesAddDataDiskFuture, err error) { 93 var resp *http.Response 94 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 95 if err != nil { 96 return 97 } 98 var azf azure.Future 99 azf, err = azure.NewFutureFromResponse(resp) 100 future.FutureAPI = &azf 101 future.Result = future.result 102 return 103} 104 105// AddDataDiskResponder handles the response to the AddDataDisk request. The method always 106// closes the http.Response Body. 107func (client VirtualMachinesClient) AddDataDiskResponder(resp *http.Response) (result autorest.Response, err error) { 108 err = autorest.Respond( 109 resp, 110 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 111 autorest.ByClosing()) 112 result.Response = resp 113 return 114} 115 116// ApplyArtifacts apply artifacts to 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. 121// applyArtifactsRequest - request body for applying artifacts to a virtual machine. 122func (client VirtualMachinesClient) ApplyArtifacts(ctx context.Context, resourceGroupName string, labName string, name string, applyArtifactsRequest ApplyArtifactsRequest) (result VirtualMachinesApplyArtifactsFuture, err error) { 123 if tracing.IsEnabled() { 124 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ApplyArtifacts") 125 defer func() { 126 sc := -1 127 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 128 sc = result.FutureAPI.Response().StatusCode 129 } 130 tracing.EndSpan(ctx, sc, err) 131 }() 132 } 133 req, err := client.ApplyArtifactsPreparer(ctx, resourceGroupName, labName, name, applyArtifactsRequest) 134 if err != nil { 135 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "ApplyArtifacts", nil, "Failure preparing request") 136 return 137 } 138 139 result, err = client.ApplyArtifactsSender(req) 140 if err != nil { 141 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "ApplyArtifacts", nil, "Failure sending request") 142 return 143 } 144 145 return 146} 147 148// ApplyArtifactsPreparer prepares the ApplyArtifacts request. 149func (client VirtualMachinesClient) ApplyArtifactsPreparer(ctx context.Context, resourceGroupName string, labName string, name string, applyArtifactsRequest ApplyArtifactsRequest) (*http.Request, error) { 150 pathParameters := map[string]interface{}{ 151 "labName": autorest.Encode("path", labName), 152 "name": autorest.Encode("path", name), 153 "resourceGroupName": autorest.Encode("path", resourceGroupName), 154 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 155 } 156 157 const APIVersion = "2016-05-15" 158 queryParameters := map[string]interface{}{ 159 "api-version": APIVersion, 160 } 161 162 preparer := autorest.CreatePreparer( 163 autorest.AsContentType("application/json; charset=utf-8"), 164 autorest.AsPost(), 165 autorest.WithBaseURL(client.BaseURI), 166 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/applyArtifacts", pathParameters), 167 autorest.WithJSON(applyArtifactsRequest), 168 autorest.WithQueryParameters(queryParameters)) 169 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 170} 171 172// ApplyArtifactsSender sends the ApplyArtifacts request. The method will close the 173// http.Response Body if it receives an error. 174func (client VirtualMachinesClient) ApplyArtifactsSender(req *http.Request) (future VirtualMachinesApplyArtifactsFuture, err error) { 175 var resp *http.Response 176 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 177 if err != nil { 178 return 179 } 180 var azf azure.Future 181 azf, err = azure.NewFutureFromResponse(resp) 182 future.FutureAPI = &azf 183 future.Result = future.result 184 return 185} 186 187// ApplyArtifactsResponder handles the response to the ApplyArtifacts request. The method always 188// closes the http.Response Body. 189func (client VirtualMachinesClient) ApplyArtifactsResponder(resp *http.Response) (result autorest.Response, err error) { 190 err = autorest.Respond( 191 resp, 192 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 193 autorest.ByClosing()) 194 result.Response = resp 195 return 196} 197 198// Claim take ownership of an existing virtual machine This operation can take a while to complete. 199// Parameters: 200// resourceGroupName - the name of the resource group. 201// labName - the name of the lab. 202// name - the name of the virtual machine. 203func (client VirtualMachinesClient) Claim(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachinesClaimFuture, err error) { 204 if tracing.IsEnabled() { 205 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Claim") 206 defer func() { 207 sc := -1 208 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 209 sc = result.FutureAPI.Response().StatusCode 210 } 211 tracing.EndSpan(ctx, sc, err) 212 }() 213 } 214 req, err := client.ClaimPreparer(ctx, resourceGroupName, labName, name) 215 if err != nil { 216 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Claim", nil, "Failure preparing request") 217 return 218 } 219 220 result, err = client.ClaimSender(req) 221 if err != nil { 222 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Claim", nil, "Failure sending request") 223 return 224 } 225 226 return 227} 228 229// ClaimPreparer prepares the Claim request. 230func (client VirtualMachinesClient) ClaimPreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 231 pathParameters := map[string]interface{}{ 232 "labName": autorest.Encode("path", labName), 233 "name": autorest.Encode("path", name), 234 "resourceGroupName": autorest.Encode("path", resourceGroupName), 235 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 236 } 237 238 const APIVersion = "2016-05-15" 239 queryParameters := map[string]interface{}{ 240 "api-version": APIVersion, 241 } 242 243 preparer := autorest.CreatePreparer( 244 autorest.AsPost(), 245 autorest.WithBaseURL(client.BaseURI), 246 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/claim", pathParameters), 247 autorest.WithQueryParameters(queryParameters)) 248 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 249} 250 251// ClaimSender sends the Claim request. The method will close the 252// http.Response Body if it receives an error. 253func (client VirtualMachinesClient) ClaimSender(req *http.Request) (future VirtualMachinesClaimFuture, err error) { 254 var resp *http.Response 255 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 256 if err != nil { 257 return 258 } 259 var azf azure.Future 260 azf, err = azure.NewFutureFromResponse(resp) 261 future.FutureAPI = &azf 262 future.Result = future.result 263 return 264} 265 266// ClaimResponder handles the response to the Claim request. The method always 267// closes the http.Response Body. 268func (client VirtualMachinesClient) ClaimResponder(resp *http.Response) (result autorest.Response, err error) { 269 err = autorest.Respond( 270 resp, 271 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 272 autorest.ByClosing()) 273 result.Response = resp 274 return 275} 276 277// CreateOrUpdate create or replace an existing Virtual machine. This operation can take a while to complete. 278// Parameters: 279// resourceGroupName - the name of the resource group. 280// labName - the name of the lab. 281// name - the name of the virtual machine. 282// labVirtualMachine - a virtual machine. 283func (client VirtualMachinesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachine) (result VirtualMachinesCreateOrUpdateFuture, err error) { 284 if tracing.IsEnabled() { 285 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.CreateOrUpdate") 286 defer func() { 287 sc := -1 288 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 289 sc = result.FutureAPI.Response().StatusCode 290 } 291 tracing.EndSpan(ctx, sc, err) 292 }() 293 } 294 if err := validation.Validate([]validation.Validation{ 295 {TargetValue: labVirtualMachine, 296 Constraints: []validation.Constraint{{Target: "labVirtualMachine.LabVirtualMachineProperties", Name: validation.Null, Rule: true, 297 Chain: []validation.Constraint{{Target: "labVirtualMachine.LabVirtualMachineProperties.ApplicableSchedule", Name: validation.Null, Rule: false, 298 Chain: []validation.Constraint{{Target: "labVirtualMachine.LabVirtualMachineProperties.ApplicableSchedule.ApplicableScheduleProperties", Name: validation.Null, Rule: true, 299 Chain: []validation.Constraint{{Target: "labVirtualMachine.LabVirtualMachineProperties.ApplicableSchedule.ApplicableScheduleProperties.LabVmsShutdown", Name: validation.Null, Rule: false, 300 Chain: []validation.Constraint{{Target: "labVirtualMachine.LabVirtualMachineProperties.ApplicableSchedule.ApplicableScheduleProperties.LabVmsShutdown.ScheduleProperties", Name: validation.Null, Rule: true, Chain: nil}}}, 301 {Target: "labVirtualMachine.LabVirtualMachineProperties.ApplicableSchedule.ApplicableScheduleProperties.LabVmsStartup", Name: validation.Null, Rule: false, 302 Chain: []validation.Constraint{{Target: "labVirtualMachine.LabVirtualMachineProperties.ApplicableSchedule.ApplicableScheduleProperties.LabVmsStartup.ScheduleProperties", Name: validation.Null, Rule: true, Chain: nil}}}, 303 }}, 304 }}, 305 }}}}}); err != nil { 306 return result, validation.NewError("dtl.VirtualMachinesClient", "CreateOrUpdate", err.Error()) 307 } 308 309 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, labName, name, labVirtualMachine) 310 if err != nil { 311 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "CreateOrUpdate", nil, "Failure preparing request") 312 return 313 } 314 315 result, err = client.CreateOrUpdateSender(req) 316 if err != nil { 317 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "CreateOrUpdate", nil, "Failure sending request") 318 return 319 } 320 321 return 322} 323 324// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 325func (client VirtualMachinesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachine) (*http.Request, error) { 326 pathParameters := map[string]interface{}{ 327 "labName": autorest.Encode("path", labName), 328 "name": autorest.Encode("path", name), 329 "resourceGroupName": autorest.Encode("path", resourceGroupName), 330 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 331 } 332 333 const APIVersion = "2016-05-15" 334 queryParameters := map[string]interface{}{ 335 "api-version": APIVersion, 336 } 337 338 preparer := autorest.CreatePreparer( 339 autorest.AsContentType("application/json; charset=utf-8"), 340 autorest.AsPut(), 341 autorest.WithBaseURL(client.BaseURI), 342 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 343 autorest.WithJSON(labVirtualMachine), 344 autorest.WithQueryParameters(queryParameters)) 345 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 346} 347 348// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 349// http.Response Body if it receives an error. 350func (client VirtualMachinesClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachinesCreateOrUpdateFuture, err error) { 351 var resp *http.Response 352 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 353 if err != nil { 354 return 355 } 356 var azf azure.Future 357 azf, err = azure.NewFutureFromResponse(resp) 358 future.FutureAPI = &azf 359 future.Result = future.result 360 return 361} 362 363// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 364// closes the http.Response Body. 365func (client VirtualMachinesClient) CreateOrUpdateResponder(resp *http.Response) (result LabVirtualMachine, err error) { 366 err = autorest.Respond( 367 resp, 368 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 369 autorest.ByUnmarshallingJSON(&result), 370 autorest.ByClosing()) 371 result.Response = autorest.Response{Response: resp} 372 return 373} 374 375// Delete delete virtual machine. This operation can take a while to complete. 376// Parameters: 377// resourceGroupName - the name of the resource group. 378// labName - the name of the lab. 379// name - the name of the virtual machine. 380func (client VirtualMachinesClient) Delete(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachinesDeleteFuture, err error) { 381 if tracing.IsEnabled() { 382 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Delete") 383 defer func() { 384 sc := -1 385 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 386 sc = result.FutureAPI.Response().StatusCode 387 } 388 tracing.EndSpan(ctx, sc, err) 389 }() 390 } 391 req, err := client.DeletePreparer(ctx, resourceGroupName, labName, name) 392 if err != nil { 393 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Delete", nil, "Failure preparing request") 394 return 395 } 396 397 result, err = client.DeleteSender(req) 398 if err != nil { 399 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Delete", nil, "Failure sending request") 400 return 401 } 402 403 return 404} 405 406// DeletePreparer prepares the Delete request. 407func (client VirtualMachinesClient) DeletePreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 408 pathParameters := map[string]interface{}{ 409 "labName": autorest.Encode("path", labName), 410 "name": autorest.Encode("path", name), 411 "resourceGroupName": autorest.Encode("path", resourceGroupName), 412 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 413 } 414 415 const APIVersion = "2016-05-15" 416 queryParameters := map[string]interface{}{ 417 "api-version": APIVersion, 418 } 419 420 preparer := autorest.CreatePreparer( 421 autorest.AsDelete(), 422 autorest.WithBaseURL(client.BaseURI), 423 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 424 autorest.WithQueryParameters(queryParameters)) 425 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 426} 427 428// DeleteSender sends the Delete request. The method will close the 429// http.Response Body if it receives an error. 430func (client VirtualMachinesClient) DeleteSender(req *http.Request) (future VirtualMachinesDeleteFuture, err error) { 431 var resp *http.Response 432 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 433 if err != nil { 434 return 435 } 436 var azf azure.Future 437 azf, err = azure.NewFutureFromResponse(resp) 438 future.FutureAPI = &azf 439 future.Result = future.result 440 return 441} 442 443// DeleteResponder handles the response to the Delete request. The method always 444// closes the http.Response Body. 445func (client VirtualMachinesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 446 err = autorest.Respond( 447 resp, 448 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 449 autorest.ByClosing()) 450 result.Response = resp 451 return 452} 453 454// DetachDataDisk detach the specified disk from the virtual machine. This operation can take a while to complete. 455// Parameters: 456// resourceGroupName - the name of the resource group. 457// labName - the name of the lab. 458// name - the name of the virtual machine. 459// detachDataDiskProperties - request body for detaching data disk from a virtual machine. 460func (client VirtualMachinesClient) DetachDataDisk(ctx context.Context, resourceGroupName string, labName string, name string, detachDataDiskProperties DetachDataDiskProperties) (result VirtualMachinesDetachDataDiskFuture, err error) { 461 if tracing.IsEnabled() { 462 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.DetachDataDisk") 463 defer func() { 464 sc := -1 465 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 466 sc = result.FutureAPI.Response().StatusCode 467 } 468 tracing.EndSpan(ctx, sc, err) 469 }() 470 } 471 req, err := client.DetachDataDiskPreparer(ctx, resourceGroupName, labName, name, detachDataDiskProperties) 472 if err != nil { 473 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "DetachDataDisk", nil, "Failure preparing request") 474 return 475 } 476 477 result, err = client.DetachDataDiskSender(req) 478 if err != nil { 479 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "DetachDataDisk", nil, "Failure sending request") 480 return 481 } 482 483 return 484} 485 486// DetachDataDiskPreparer prepares the DetachDataDisk request. 487func (client VirtualMachinesClient) DetachDataDiskPreparer(ctx context.Context, resourceGroupName string, labName string, name string, detachDataDiskProperties DetachDataDiskProperties) (*http.Request, error) { 488 pathParameters := map[string]interface{}{ 489 "labName": autorest.Encode("path", labName), 490 "name": autorest.Encode("path", name), 491 "resourceGroupName": autorest.Encode("path", resourceGroupName), 492 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 493 } 494 495 const APIVersion = "2016-05-15" 496 queryParameters := map[string]interface{}{ 497 "api-version": APIVersion, 498 } 499 500 preparer := autorest.CreatePreparer( 501 autorest.AsContentType("application/json; charset=utf-8"), 502 autorest.AsPost(), 503 autorest.WithBaseURL(client.BaseURI), 504 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/detachDataDisk", pathParameters), 505 autorest.WithJSON(detachDataDiskProperties), 506 autorest.WithQueryParameters(queryParameters)) 507 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 508} 509 510// DetachDataDiskSender sends the DetachDataDisk request. The method will close the 511// http.Response Body if it receives an error. 512func (client VirtualMachinesClient) DetachDataDiskSender(req *http.Request) (future VirtualMachinesDetachDataDiskFuture, err error) { 513 var resp *http.Response 514 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 515 if err != nil { 516 return 517 } 518 var azf azure.Future 519 azf, err = azure.NewFutureFromResponse(resp) 520 future.FutureAPI = &azf 521 future.Result = future.result 522 return 523} 524 525// DetachDataDiskResponder handles the response to the DetachDataDisk request. The method always 526// closes the http.Response Body. 527func (client VirtualMachinesClient) DetachDataDiskResponder(resp *http.Response) (result autorest.Response, err error) { 528 err = autorest.Respond( 529 resp, 530 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 531 autorest.ByClosing()) 532 result.Response = resp 533 return 534} 535 536// Get get virtual machine. 537// Parameters: 538// resourceGroupName - the name of the resource group. 539// labName - the name of the lab. 540// name - the name of the virtual machine. 541// expand - specify the $expand query. Example: 542// 'properties($expand=artifacts,computeVm,networkInterface,applicableSchedule)' 543func (client VirtualMachinesClient) Get(ctx context.Context, resourceGroupName string, labName string, name string, expand string) (result LabVirtualMachine, err error) { 544 if tracing.IsEnabled() { 545 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Get") 546 defer func() { 547 sc := -1 548 if result.Response.Response != nil { 549 sc = result.Response.Response.StatusCode 550 } 551 tracing.EndSpan(ctx, sc, err) 552 }() 553 } 554 req, err := client.GetPreparer(ctx, resourceGroupName, labName, name, expand) 555 if err != nil { 556 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Get", nil, "Failure preparing request") 557 return 558 } 559 560 resp, err := client.GetSender(req) 561 if err != nil { 562 result.Response = autorest.Response{Response: resp} 563 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Get", resp, "Failure sending request") 564 return 565 } 566 567 result, err = client.GetResponder(resp) 568 if err != nil { 569 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Get", resp, "Failure responding to request") 570 return 571 } 572 573 return 574} 575 576// GetPreparer prepares the Get request. 577func (client VirtualMachinesClient) GetPreparer(ctx context.Context, resourceGroupName string, labName string, name string, expand string) (*http.Request, error) { 578 pathParameters := map[string]interface{}{ 579 "labName": autorest.Encode("path", labName), 580 "name": autorest.Encode("path", name), 581 "resourceGroupName": autorest.Encode("path", resourceGroupName), 582 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 583 } 584 585 const APIVersion = "2016-05-15" 586 queryParameters := map[string]interface{}{ 587 "api-version": APIVersion, 588 } 589 if len(expand) > 0 { 590 queryParameters["$expand"] = autorest.Encode("query", expand) 591 } 592 593 preparer := autorest.CreatePreparer( 594 autorest.AsGet(), 595 autorest.WithBaseURL(client.BaseURI), 596 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 597 autorest.WithQueryParameters(queryParameters)) 598 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 599} 600 601// GetSender sends the Get request. The method will close the 602// http.Response Body if it receives an error. 603func (client VirtualMachinesClient) GetSender(req *http.Request) (*http.Response, error) { 604 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 605} 606 607// GetResponder handles the response to the Get request. The method always 608// closes the http.Response Body. 609func (client VirtualMachinesClient) GetResponder(resp *http.Response) (result LabVirtualMachine, err error) { 610 err = autorest.Respond( 611 resp, 612 azure.WithErrorUnlessStatusCode(http.StatusOK), 613 autorest.ByUnmarshallingJSON(&result), 614 autorest.ByClosing()) 615 result.Response = autorest.Response{Response: resp} 616 return 617} 618 619// List list virtual machines in a given lab. 620// Parameters: 621// resourceGroupName - the name of the resource group. 622// labName - the name of the lab. 623// expand - specify the $expand query. Example: 624// 'properties($expand=artifacts,computeVm,networkInterface,applicableSchedule)' 625// filter - the filter to apply to the operation. 626// top - the maximum number of resources to return from the operation. 627// orderby - the ordering expression for the results, using OData notation. 628func (client VirtualMachinesClient) List(ctx context.Context, resourceGroupName string, labName string, expand string, filter string, top *int32, orderby string) (result ResponseWithContinuationLabVirtualMachinePage, err error) { 629 if tracing.IsEnabled() { 630 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.List") 631 defer func() { 632 sc := -1 633 if result.rwclvm.Response.Response != nil { 634 sc = result.rwclvm.Response.Response.StatusCode 635 } 636 tracing.EndSpan(ctx, sc, err) 637 }() 638 } 639 result.fn = client.listNextResults 640 req, err := client.ListPreparer(ctx, resourceGroupName, labName, expand, filter, top, orderby) 641 if err != nil { 642 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "List", nil, "Failure preparing request") 643 return 644 } 645 646 resp, err := client.ListSender(req) 647 if err != nil { 648 result.rwclvm.Response = autorest.Response{Response: resp} 649 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "List", resp, "Failure sending request") 650 return 651 } 652 653 result.rwclvm, err = client.ListResponder(resp) 654 if err != nil { 655 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "List", resp, "Failure responding to request") 656 return 657 } 658 if result.rwclvm.hasNextLink() && result.rwclvm.IsEmpty() { 659 err = result.NextWithContext(ctx) 660 return 661 } 662 663 return 664} 665 666// ListPreparer prepares the List request. 667func (client VirtualMachinesClient) ListPreparer(ctx context.Context, resourceGroupName string, labName string, expand string, filter string, top *int32, orderby string) (*http.Request, error) { 668 pathParameters := map[string]interface{}{ 669 "labName": autorest.Encode("path", labName), 670 "resourceGroupName": autorest.Encode("path", resourceGroupName), 671 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 672 } 673 674 const APIVersion = "2016-05-15" 675 queryParameters := map[string]interface{}{ 676 "api-version": APIVersion, 677 } 678 if len(expand) > 0 { 679 queryParameters["$expand"] = autorest.Encode("query", expand) 680 } 681 if len(filter) > 0 { 682 queryParameters["$filter"] = autorest.Encode("query", filter) 683 } 684 if top != nil { 685 queryParameters["$top"] = autorest.Encode("query", *top) 686 } 687 if len(orderby) > 0 { 688 queryParameters["$orderby"] = autorest.Encode("query", orderby) 689 } 690 691 preparer := autorest.CreatePreparer( 692 autorest.AsGet(), 693 autorest.WithBaseURL(client.BaseURI), 694 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines", pathParameters), 695 autorest.WithQueryParameters(queryParameters)) 696 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 697} 698 699// ListSender sends the List request. The method will close the 700// http.Response Body if it receives an error. 701func (client VirtualMachinesClient) ListSender(req *http.Request) (*http.Response, error) { 702 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 703} 704 705// ListResponder handles the response to the List request. The method always 706// closes the http.Response Body. 707func (client VirtualMachinesClient) ListResponder(resp *http.Response) (result ResponseWithContinuationLabVirtualMachine, err error) { 708 err = autorest.Respond( 709 resp, 710 azure.WithErrorUnlessStatusCode(http.StatusOK), 711 autorest.ByUnmarshallingJSON(&result), 712 autorest.ByClosing()) 713 result.Response = autorest.Response{Response: resp} 714 return 715} 716 717// listNextResults retrieves the next set of results, if any. 718func (client VirtualMachinesClient) listNextResults(ctx context.Context, lastResults ResponseWithContinuationLabVirtualMachine) (result ResponseWithContinuationLabVirtualMachine, err error) { 719 req, err := lastResults.responseWithContinuationLabVirtualMachinePreparer(ctx) 720 if err != nil { 721 return result, autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "listNextResults", nil, "Failure preparing next results request") 722 } 723 if req == nil { 724 return 725 } 726 resp, err := client.ListSender(req) 727 if err != nil { 728 result.Response = autorest.Response{Response: resp} 729 return result, autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "listNextResults", resp, "Failure sending next results request") 730 } 731 result, err = client.ListResponder(resp) 732 if err != nil { 733 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "listNextResults", resp, "Failure responding to next results request") 734 } 735 return 736} 737 738// ListComplete enumerates all values, automatically crossing page boundaries as required. 739func (client VirtualMachinesClient) ListComplete(ctx context.Context, resourceGroupName string, labName string, expand string, filter string, top *int32, orderby string) (result ResponseWithContinuationLabVirtualMachineIterator, err error) { 740 if tracing.IsEnabled() { 741 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.List") 742 defer func() { 743 sc := -1 744 if result.Response().Response.Response != nil { 745 sc = result.page.Response().Response.Response.StatusCode 746 } 747 tracing.EndSpan(ctx, sc, err) 748 }() 749 } 750 result.page, err = client.List(ctx, resourceGroupName, labName, expand, filter, top, orderby) 751 return 752} 753 754// ListApplicableSchedules lists all applicable schedules 755// Parameters: 756// resourceGroupName - the name of the resource group. 757// labName - the name of the lab. 758// name - the name of the virtual machine. 759func (client VirtualMachinesClient) ListApplicableSchedules(ctx context.Context, resourceGroupName string, labName string, name string) (result ApplicableSchedule, err error) { 760 if tracing.IsEnabled() { 761 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.ListApplicableSchedules") 762 defer func() { 763 sc := -1 764 if result.Response.Response != nil { 765 sc = result.Response.Response.StatusCode 766 } 767 tracing.EndSpan(ctx, sc, err) 768 }() 769 } 770 req, err := client.ListApplicableSchedulesPreparer(ctx, resourceGroupName, labName, name) 771 if err != nil { 772 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "ListApplicableSchedules", nil, "Failure preparing request") 773 return 774 } 775 776 resp, err := client.ListApplicableSchedulesSender(req) 777 if err != nil { 778 result.Response = autorest.Response{Response: resp} 779 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "ListApplicableSchedules", resp, "Failure sending request") 780 return 781 } 782 783 result, err = client.ListApplicableSchedulesResponder(resp) 784 if err != nil { 785 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "ListApplicableSchedules", resp, "Failure responding to request") 786 return 787 } 788 789 return 790} 791 792// ListApplicableSchedulesPreparer prepares the ListApplicableSchedules request. 793func (client VirtualMachinesClient) ListApplicableSchedulesPreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 794 pathParameters := map[string]interface{}{ 795 "labName": autorest.Encode("path", labName), 796 "name": autorest.Encode("path", name), 797 "resourceGroupName": autorest.Encode("path", resourceGroupName), 798 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 799 } 800 801 const APIVersion = "2016-05-15" 802 queryParameters := map[string]interface{}{ 803 "api-version": APIVersion, 804 } 805 806 preparer := autorest.CreatePreparer( 807 autorest.AsPost(), 808 autorest.WithBaseURL(client.BaseURI), 809 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/listApplicableSchedules", pathParameters), 810 autorest.WithQueryParameters(queryParameters)) 811 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 812} 813 814// ListApplicableSchedulesSender sends the ListApplicableSchedules request. The method will close the 815// http.Response Body if it receives an error. 816func (client VirtualMachinesClient) ListApplicableSchedulesSender(req *http.Request) (*http.Response, error) { 817 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 818} 819 820// ListApplicableSchedulesResponder handles the response to the ListApplicableSchedules request. The method always 821// closes the http.Response Body. 822func (client VirtualMachinesClient) ListApplicableSchedulesResponder(resp *http.Response) (result ApplicableSchedule, err error) { 823 err = autorest.Respond( 824 resp, 825 azure.WithErrorUnlessStatusCode(http.StatusOK), 826 autorest.ByUnmarshallingJSON(&result), 827 autorest.ByClosing()) 828 result.Response = autorest.Response{Response: resp} 829 return 830} 831 832// Start start a virtual machine. This operation can take a while to complete. 833// Parameters: 834// resourceGroupName - the name of the resource group. 835// labName - the name of the lab. 836// name - the name of the virtual machine. 837func (client VirtualMachinesClient) Start(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachinesStartFuture, err error) { 838 if tracing.IsEnabled() { 839 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Start") 840 defer func() { 841 sc := -1 842 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 843 sc = result.FutureAPI.Response().StatusCode 844 } 845 tracing.EndSpan(ctx, sc, err) 846 }() 847 } 848 req, err := client.StartPreparer(ctx, resourceGroupName, labName, name) 849 if err != nil { 850 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Start", nil, "Failure preparing request") 851 return 852 } 853 854 result, err = client.StartSender(req) 855 if err != nil { 856 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Start", nil, "Failure sending request") 857 return 858 } 859 860 return 861} 862 863// StartPreparer prepares the Start request. 864func (client VirtualMachinesClient) StartPreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 865 pathParameters := map[string]interface{}{ 866 "labName": autorest.Encode("path", labName), 867 "name": autorest.Encode("path", name), 868 "resourceGroupName": autorest.Encode("path", resourceGroupName), 869 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 870 } 871 872 const APIVersion = "2016-05-15" 873 queryParameters := map[string]interface{}{ 874 "api-version": APIVersion, 875 } 876 877 preparer := autorest.CreatePreparer( 878 autorest.AsPost(), 879 autorest.WithBaseURL(client.BaseURI), 880 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/start", pathParameters), 881 autorest.WithQueryParameters(queryParameters)) 882 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 883} 884 885// StartSender sends the Start request. The method will close the 886// http.Response Body if it receives an error. 887func (client VirtualMachinesClient) StartSender(req *http.Request) (future VirtualMachinesStartFuture, err error) { 888 var resp *http.Response 889 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 890 if err != nil { 891 return 892 } 893 var azf azure.Future 894 azf, err = azure.NewFutureFromResponse(resp) 895 future.FutureAPI = &azf 896 future.Result = future.result 897 return 898} 899 900// StartResponder handles the response to the Start request. The method always 901// closes the http.Response Body. 902func (client VirtualMachinesClient) StartResponder(resp *http.Response) (result autorest.Response, err error) { 903 err = autorest.Respond( 904 resp, 905 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 906 autorest.ByClosing()) 907 result.Response = resp 908 return 909} 910 911// Stop stop a virtual machine This operation can take a while to complete. 912// Parameters: 913// resourceGroupName - the name of the resource group. 914// labName - the name of the lab. 915// name - the name of the virtual machine. 916func (client VirtualMachinesClient) Stop(ctx context.Context, resourceGroupName string, labName string, name string) (result VirtualMachinesStopFuture, err error) { 917 if tracing.IsEnabled() { 918 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Stop") 919 defer func() { 920 sc := -1 921 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 922 sc = result.FutureAPI.Response().StatusCode 923 } 924 tracing.EndSpan(ctx, sc, err) 925 }() 926 } 927 req, err := client.StopPreparer(ctx, resourceGroupName, labName, name) 928 if err != nil { 929 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Stop", nil, "Failure preparing request") 930 return 931 } 932 933 result, err = client.StopSender(req) 934 if err != nil { 935 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Stop", nil, "Failure sending request") 936 return 937 } 938 939 return 940} 941 942// StopPreparer prepares the Stop request. 943func (client VirtualMachinesClient) StopPreparer(ctx context.Context, resourceGroupName string, labName string, name string) (*http.Request, error) { 944 pathParameters := map[string]interface{}{ 945 "labName": autorest.Encode("path", labName), 946 "name": autorest.Encode("path", name), 947 "resourceGroupName": autorest.Encode("path", resourceGroupName), 948 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 949 } 950 951 const APIVersion = "2016-05-15" 952 queryParameters := map[string]interface{}{ 953 "api-version": APIVersion, 954 } 955 956 preparer := autorest.CreatePreparer( 957 autorest.AsPost(), 958 autorest.WithBaseURL(client.BaseURI), 959 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}/stop", pathParameters), 960 autorest.WithQueryParameters(queryParameters)) 961 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 962} 963 964// StopSender sends the Stop request. The method will close the 965// http.Response Body if it receives an error. 966func (client VirtualMachinesClient) StopSender(req *http.Request) (future VirtualMachinesStopFuture, err error) { 967 var resp *http.Response 968 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 969 if err != nil { 970 return 971 } 972 var azf azure.Future 973 azf, err = azure.NewFutureFromResponse(resp) 974 future.FutureAPI = &azf 975 future.Result = future.result 976 return 977} 978 979// StopResponder handles the response to the Stop request. The method always 980// closes the http.Response Body. 981func (client VirtualMachinesClient) StopResponder(resp *http.Response) (result autorest.Response, err error) { 982 err = autorest.Respond( 983 resp, 984 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 985 autorest.ByClosing()) 986 result.Response = resp 987 return 988} 989 990// Update modify properties of virtual machines. 991// Parameters: 992// resourceGroupName - the name of the resource group. 993// labName - the name of the lab. 994// name - the name of the virtual machine. 995// labVirtualMachine - a virtual machine. 996func (client VirtualMachinesClient) Update(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachineFragment) (result LabVirtualMachine, err error) { 997 if tracing.IsEnabled() { 998 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachinesClient.Update") 999 defer func() { 1000 sc := -1 1001 if result.Response.Response != nil { 1002 sc = result.Response.Response.StatusCode 1003 } 1004 tracing.EndSpan(ctx, sc, err) 1005 }() 1006 } 1007 req, err := client.UpdatePreparer(ctx, resourceGroupName, labName, name, labVirtualMachine) 1008 if err != nil { 1009 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Update", nil, "Failure preparing request") 1010 return 1011 } 1012 1013 resp, err := client.UpdateSender(req) 1014 if err != nil { 1015 result.Response = autorest.Response{Response: resp} 1016 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Update", resp, "Failure sending request") 1017 return 1018 } 1019 1020 result, err = client.UpdateResponder(resp) 1021 if err != nil { 1022 err = autorest.NewErrorWithError(err, "dtl.VirtualMachinesClient", "Update", resp, "Failure responding to request") 1023 return 1024 } 1025 1026 return 1027} 1028 1029// UpdatePreparer prepares the Update request. 1030func (client VirtualMachinesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, labName string, name string, labVirtualMachine LabVirtualMachineFragment) (*http.Request, error) { 1031 pathParameters := map[string]interface{}{ 1032 "labName": autorest.Encode("path", labName), 1033 "name": autorest.Encode("path", name), 1034 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1035 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1036 } 1037 1038 const APIVersion = "2016-05-15" 1039 queryParameters := map[string]interface{}{ 1040 "api-version": APIVersion, 1041 } 1042 1043 preparer := autorest.CreatePreparer( 1044 autorest.AsContentType("application/json; charset=utf-8"), 1045 autorest.AsPatch(), 1046 autorest.WithBaseURL(client.BaseURI), 1047 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{labName}/virtualmachines/{name}", pathParameters), 1048 autorest.WithJSON(labVirtualMachine), 1049 autorest.WithQueryParameters(queryParameters)) 1050 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1051} 1052 1053// UpdateSender sends the Update request. The method will close the 1054// http.Response Body if it receives an error. 1055func (client VirtualMachinesClient) UpdateSender(req *http.Request) (*http.Response, error) { 1056 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1057} 1058 1059// UpdateResponder handles the response to the Update request. The method always 1060// closes the http.Response Body. 1061func (client VirtualMachinesClient) UpdateResponder(resp *http.Response) (result LabVirtualMachine, err error) { 1062 err = autorest.Respond( 1063 resp, 1064 azure.WithErrorUnlessStatusCode(http.StatusOK), 1065 autorest.ByUnmarshallingJSON(&result), 1066 autorest.ByClosing()) 1067 result.Response = autorest.Response{Response: resp} 1068 return 1069} 1070