lab.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/devtestlabs/mgmt/2015-05-21-preview/dtl

     1  package 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  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/tracing"
    14  	"net/http"
    15  )
    16  
    17  // LabClient is the azure DevTest Labs REST API version 2015-05-21-preview.
    18  type LabClient struct {
    19  	BaseClient
    20  }
    21  
    22  // NewLabClient creates an instance of the LabClient client.
    23  func NewLabClient(subscriptionID string) LabClient {
    24  	return NewLabClientWithBaseURI(DefaultBaseURI, subscriptionID)
    25  }
    26  
    27  // NewLabClientWithBaseURI creates an instance of the LabClient client using a custom endpoint.  Use this when
    28  // interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    29  func NewLabClientWithBaseURI(baseURI string, subscriptionID string) LabClient {
    30  	return LabClient{NewWithBaseURI(baseURI, subscriptionID)}
    31  }
    32  
    33  // CreateEnvironment create virtual machines in a Lab. This operation can take a while to complete.
    34  // Parameters:
    35  // resourceGroupName - the name of the resource group.
    36  // name - the name of the lab.
    37  func (client LabClient) CreateEnvironment(ctx context.Context, resourceGroupName string, name string, labVirtualMachine LabVirtualMachine) (result LabCreateEnvironmentFuture, err error) {
    38  	if tracing.IsEnabled() {
    39  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.CreateEnvironment")
    40  		defer func() {
    41  			sc := -1
    42  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    43  				sc = result.FutureAPI.Response().StatusCode
    44  			}
    45  			tracing.EndSpan(ctx, sc, err)
    46  		}()
    47  	}
    48  	req, err := client.CreateEnvironmentPreparer(ctx, resourceGroupName, name, labVirtualMachine)
    49  	if err != nil {
    50  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "CreateEnvironment", nil, "Failure preparing request")
    51  		return
    52  	}
    53  
    54  	result, err = client.CreateEnvironmentSender(req)
    55  	if err != nil {
    56  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "CreateEnvironment", result.Response(), "Failure sending request")
    57  		return
    58  	}
    59  
    60  	return
    61  }
    62  
    63  // CreateEnvironmentPreparer prepares the CreateEnvironment request.
    64  func (client LabClient) CreateEnvironmentPreparer(ctx context.Context, resourceGroupName string, name string, labVirtualMachine LabVirtualMachine) (*http.Request, error) {
    65  	pathParameters := map[string]interface{}{
    66  		"name":              autorest.Encode("path", name),
    67  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    68  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    69  	}
    70  
    71  	const APIVersion = "2015-05-21-preview"
    72  	queryParameters := map[string]interface{}{
    73  		"api-version": APIVersion,
    74  	}
    75  
    76  	preparer := autorest.CreatePreparer(
    77  		autorest.AsContentType("application/json; charset=utf-8"),
    78  		autorest.AsPost(),
    79  		autorest.WithBaseURL(client.BaseURI),
    80  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}/createEnvironment", pathParameters),
    81  		autorest.WithJSON(labVirtualMachine),
    82  		autorest.WithQueryParameters(queryParameters))
    83  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    84  }
    85  
    86  // CreateEnvironmentSender sends the CreateEnvironment request. The method will close the
    87  // http.Response Body if it receives an error.
    88  func (client LabClient) CreateEnvironmentSender(req *http.Request) (future LabCreateEnvironmentFuture, err error) {
    89  	var resp *http.Response
    90  	future.FutureAPI = &azure.Future{}
    91  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
    92  	if err != nil {
    93  		return
    94  	}
    95  	var azf azure.Future
    96  	azf, err = azure.NewFutureFromResponse(resp)
    97  	future.FutureAPI = &azf
    98  	future.Result = future.result
    99  	return
   100  }
   101  
   102  // CreateEnvironmentResponder handles the response to the CreateEnvironment request. The method always
   103  // closes the http.Response Body.
   104  func (client LabClient) CreateEnvironmentResponder(resp *http.Response) (result autorest.Response, err error) {
   105  	err = autorest.Respond(
   106  		resp,
   107  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   108  		autorest.ByClosing())
   109  	result.Response = resp
   110  	return
   111  }
   112  
   113  // CreateOrUpdateResource create or replace an existing Lab. This operation can take a while to complete.
   114  // Parameters:
   115  // resourceGroupName - the name of the resource group.
   116  // name - the name of the lab.
   117  func (client LabClient) CreateOrUpdateResource(ctx context.Context, resourceGroupName string, name string, lab Lab) (result LabCreateOrUpdateResourceFuture, err error) {
   118  	if tracing.IsEnabled() {
   119  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.CreateOrUpdateResource")
   120  		defer func() {
   121  			sc := -1
   122  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   123  				sc = result.FutureAPI.Response().StatusCode
   124  			}
   125  			tracing.EndSpan(ctx, sc, err)
   126  		}()
   127  	}
   128  	req, err := client.CreateOrUpdateResourcePreparer(ctx, resourceGroupName, name, lab)
   129  	if err != nil {
   130  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "CreateOrUpdateResource", nil, "Failure preparing request")
   131  		return
   132  	}
   133  
   134  	result, err = client.CreateOrUpdateResourceSender(req)
   135  	if err != nil {
   136  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "CreateOrUpdateResource", result.Response(), "Failure sending request")
   137  		return
   138  	}
   139  
   140  	return
   141  }
   142  
   143  // CreateOrUpdateResourcePreparer prepares the CreateOrUpdateResource request.
   144  func (client LabClient) CreateOrUpdateResourcePreparer(ctx context.Context, resourceGroupName string, name string, lab Lab) (*http.Request, error) {
   145  	pathParameters := map[string]interface{}{
   146  		"name":              autorest.Encode("path", name),
   147  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   148  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   149  	}
   150  
   151  	const APIVersion = "2015-05-21-preview"
   152  	queryParameters := map[string]interface{}{
   153  		"api-version": APIVersion,
   154  	}
   155  
   156  	preparer := autorest.CreatePreparer(
   157  		autorest.AsContentType("application/json; charset=utf-8"),
   158  		autorest.AsPut(),
   159  		autorest.WithBaseURL(client.BaseURI),
   160  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}", pathParameters),
   161  		autorest.WithJSON(lab),
   162  		autorest.WithQueryParameters(queryParameters))
   163  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   164  }
   165  
   166  // CreateOrUpdateResourceSender sends the CreateOrUpdateResource request. The method will close the
   167  // http.Response Body if it receives an error.
   168  func (client LabClient) CreateOrUpdateResourceSender(req *http.Request) (future LabCreateOrUpdateResourceFuture, err error) {
   169  	var resp *http.Response
   170  	future.FutureAPI = &azure.Future{}
   171  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   172  	if err != nil {
   173  		return
   174  	}
   175  	var azf azure.Future
   176  	azf, err = azure.NewFutureFromResponse(resp)
   177  	future.FutureAPI = &azf
   178  	future.Result = future.result
   179  	return
   180  }
   181  
   182  // CreateOrUpdateResourceResponder handles the response to the CreateOrUpdateResource request. The method always
   183  // closes the http.Response Body.
   184  func (client LabClient) CreateOrUpdateResourceResponder(resp *http.Response) (result Lab, err error) {
   185  	err = autorest.Respond(
   186  		resp,
   187  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   188  		autorest.ByUnmarshallingJSON(&result),
   189  		autorest.ByClosing())
   190  	result.Response = autorest.Response{Response: resp}
   191  	return
   192  }
   193  
   194  // DeleteResource delete lab. This operation can take a while to complete.
   195  // Parameters:
   196  // resourceGroupName - the name of the resource group.
   197  // name - the name of the lab.
   198  func (client LabClient) DeleteResource(ctx context.Context, resourceGroupName string, name string) (result LabDeleteResourceFuture, err error) {
   199  	if tracing.IsEnabled() {
   200  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.DeleteResource")
   201  		defer func() {
   202  			sc := -1
   203  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   204  				sc = result.FutureAPI.Response().StatusCode
   205  			}
   206  			tracing.EndSpan(ctx, sc, err)
   207  		}()
   208  	}
   209  	req, err := client.DeleteResourcePreparer(ctx, resourceGroupName, name)
   210  	if err != nil {
   211  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "DeleteResource", nil, "Failure preparing request")
   212  		return
   213  	}
   214  
   215  	result, err = client.DeleteResourceSender(req)
   216  	if err != nil {
   217  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "DeleteResource", result.Response(), "Failure sending request")
   218  		return
   219  	}
   220  
   221  	return
   222  }
   223  
   224  // DeleteResourcePreparer prepares the DeleteResource request.
   225  func (client LabClient) DeleteResourcePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
   226  	pathParameters := map[string]interface{}{
   227  		"name":              autorest.Encode("path", name),
   228  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   229  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   230  	}
   231  
   232  	const APIVersion = "2015-05-21-preview"
   233  	queryParameters := map[string]interface{}{
   234  		"api-version": APIVersion,
   235  	}
   236  
   237  	preparer := autorest.CreatePreparer(
   238  		autorest.AsDelete(),
   239  		autorest.WithBaseURL(client.BaseURI),
   240  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}", pathParameters),
   241  		autorest.WithQueryParameters(queryParameters))
   242  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   243  }
   244  
   245  // DeleteResourceSender sends the DeleteResource request. The method will close the
   246  // http.Response Body if it receives an error.
   247  func (client LabClient) DeleteResourceSender(req *http.Request) (future LabDeleteResourceFuture, err error) {
   248  	var resp *http.Response
   249  	future.FutureAPI = &azure.Future{}
   250  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   251  	if err != nil {
   252  		return
   253  	}
   254  	var azf azure.Future
   255  	azf, err = azure.NewFutureFromResponse(resp)
   256  	future.FutureAPI = &azf
   257  	future.Result = future.result
   258  	return
   259  }
   260  
   261  // DeleteResourceResponder handles the response to the DeleteResource request. The method always
   262  // closes the http.Response Body.
   263  func (client LabClient) DeleteResourceResponder(resp *http.Response) (result autorest.Response, err error) {
   264  	err = autorest.Respond(
   265  		resp,
   266  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   267  		autorest.ByClosing())
   268  	result.Response = resp
   269  	return
   270  }
   271  
   272  // GenerateUploadURI generate a URI for uploading custom disk images to a Lab.
   273  // Parameters:
   274  // resourceGroupName - the name of the resource group.
   275  // name - the name of the lab.
   276  func (client LabClient) GenerateUploadURI(ctx context.Context, resourceGroupName string, name string, generateUploadURIParameter GenerateUploadURIParameter) (result GenerateUploadURIResponse, err error) {
   277  	if tracing.IsEnabled() {
   278  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.GenerateUploadURI")
   279  		defer func() {
   280  			sc := -1
   281  			if result.Response.Response != nil {
   282  				sc = result.Response.Response.StatusCode
   283  			}
   284  			tracing.EndSpan(ctx, sc, err)
   285  		}()
   286  	}
   287  	req, err := client.GenerateUploadURIPreparer(ctx, resourceGroupName, name, generateUploadURIParameter)
   288  	if err != nil {
   289  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "GenerateUploadURI", nil, "Failure preparing request")
   290  		return
   291  	}
   292  
   293  	resp, err := client.GenerateUploadURISender(req)
   294  	if err != nil {
   295  		result.Response = autorest.Response{Response: resp}
   296  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "GenerateUploadURI", resp, "Failure sending request")
   297  		return
   298  	}
   299  
   300  	result, err = client.GenerateUploadURIResponder(resp)
   301  	if err != nil {
   302  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "GenerateUploadURI", resp, "Failure responding to request")
   303  		return
   304  	}
   305  
   306  	return
   307  }
   308  
   309  // GenerateUploadURIPreparer prepares the GenerateUploadURI request.
   310  func (client LabClient) GenerateUploadURIPreparer(ctx context.Context, resourceGroupName string, name string, generateUploadURIParameter GenerateUploadURIParameter) (*http.Request, error) {
   311  	pathParameters := map[string]interface{}{
   312  		"name":              autorest.Encode("path", name),
   313  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   314  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   315  	}
   316  
   317  	const APIVersion = "2015-05-21-preview"
   318  	queryParameters := map[string]interface{}{
   319  		"api-version": APIVersion,
   320  	}
   321  
   322  	preparer := autorest.CreatePreparer(
   323  		autorest.AsContentType("application/json; charset=utf-8"),
   324  		autorest.AsPost(),
   325  		autorest.WithBaseURL(client.BaseURI),
   326  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}/generateUploadUri", pathParameters),
   327  		autorest.WithJSON(generateUploadURIParameter),
   328  		autorest.WithQueryParameters(queryParameters))
   329  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   330  }
   331  
   332  // GenerateUploadURISender sends the GenerateUploadURI request. The method will close the
   333  // http.Response Body if it receives an error.
   334  func (client LabClient) GenerateUploadURISender(req *http.Request) (*http.Response, error) {
   335  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   336  }
   337  
   338  // GenerateUploadURIResponder handles the response to the GenerateUploadURI request. The method always
   339  // closes the http.Response Body.
   340  func (client LabClient) GenerateUploadURIResponder(resp *http.Response) (result GenerateUploadURIResponse, err error) {
   341  	err = autorest.Respond(
   342  		resp,
   343  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   344  		autorest.ByUnmarshallingJSON(&result),
   345  		autorest.ByClosing())
   346  	result.Response = autorest.Response{Response: resp}
   347  	return
   348  }
   349  
   350  // GetResource get lab.
   351  // Parameters:
   352  // resourceGroupName - the name of the resource group.
   353  // name - the name of the lab.
   354  func (client LabClient) GetResource(ctx context.Context, resourceGroupName string, name string) (result Lab, err error) {
   355  	if tracing.IsEnabled() {
   356  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.GetResource")
   357  		defer func() {
   358  			sc := -1
   359  			if result.Response.Response != nil {
   360  				sc = result.Response.Response.StatusCode
   361  			}
   362  			tracing.EndSpan(ctx, sc, err)
   363  		}()
   364  	}
   365  	req, err := client.GetResourcePreparer(ctx, resourceGroupName, name)
   366  	if err != nil {
   367  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "GetResource", nil, "Failure preparing request")
   368  		return
   369  	}
   370  
   371  	resp, err := client.GetResourceSender(req)
   372  	if err != nil {
   373  		result.Response = autorest.Response{Response: resp}
   374  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "GetResource", resp, "Failure sending request")
   375  		return
   376  	}
   377  
   378  	result, err = client.GetResourceResponder(resp)
   379  	if err != nil {
   380  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "GetResource", resp, "Failure responding to request")
   381  		return
   382  	}
   383  
   384  	return
   385  }
   386  
   387  // GetResourcePreparer prepares the GetResource request.
   388  func (client LabClient) GetResourcePreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
   389  	pathParameters := map[string]interface{}{
   390  		"name":              autorest.Encode("path", name),
   391  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   392  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   393  	}
   394  
   395  	const APIVersion = "2015-05-21-preview"
   396  	queryParameters := map[string]interface{}{
   397  		"api-version": APIVersion,
   398  	}
   399  
   400  	preparer := autorest.CreatePreparer(
   401  		autorest.AsGet(),
   402  		autorest.WithBaseURL(client.BaseURI),
   403  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}", pathParameters),
   404  		autorest.WithQueryParameters(queryParameters))
   405  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   406  }
   407  
   408  // GetResourceSender sends the GetResource request. The method will close the
   409  // http.Response Body if it receives an error.
   410  func (client LabClient) GetResourceSender(req *http.Request) (*http.Response, error) {
   411  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   412  }
   413  
   414  // GetResourceResponder handles the response to the GetResource request. The method always
   415  // closes the http.Response Body.
   416  func (client LabClient) GetResourceResponder(resp *http.Response) (result Lab, err error) {
   417  	err = autorest.Respond(
   418  		resp,
   419  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   420  		autorest.ByUnmarshallingJSON(&result),
   421  		autorest.ByClosing())
   422  	result.Response = autorest.Response{Response: resp}
   423  	return
   424  }
   425  
   426  // ListByResourceGroup list labs.
   427  // Parameters:
   428  // resourceGroupName - the name of the resource group.
   429  // filter - the filter to apply on the operation.
   430  func (client LabClient) ListByResourceGroup(ctx context.Context, resourceGroupName string, filter string, top *int32, orderBy string) (result ResponseWithContinuationLabPage, err error) {
   431  	if tracing.IsEnabled() {
   432  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.ListByResourceGroup")
   433  		defer func() {
   434  			sc := -1
   435  			if result.rwcl.Response.Response != nil {
   436  				sc = result.rwcl.Response.Response.StatusCode
   437  			}
   438  			tracing.EndSpan(ctx, sc, err)
   439  		}()
   440  	}
   441  	result.fn = client.listByResourceGroupNextResults
   442  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName, filter, top, orderBy)
   443  	if err != nil {
   444  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListByResourceGroup", nil, "Failure preparing request")
   445  		return
   446  	}
   447  
   448  	resp, err := client.ListByResourceGroupSender(req)
   449  	if err != nil {
   450  		result.rwcl.Response = autorest.Response{Response: resp}
   451  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListByResourceGroup", resp, "Failure sending request")
   452  		return
   453  	}
   454  
   455  	result.rwcl, err = client.ListByResourceGroupResponder(resp)
   456  	if err != nil {
   457  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListByResourceGroup", resp, "Failure responding to request")
   458  		return
   459  	}
   460  	if result.rwcl.hasNextLink() && result.rwcl.IsEmpty() {
   461  		err = result.NextWithContext(ctx)
   462  		return
   463  	}
   464  
   465  	return
   466  }
   467  
   468  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   469  func (client LabClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string, filter string, top *int32, orderBy string) (*http.Request, error) {
   470  	pathParameters := map[string]interface{}{
   471  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   472  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   473  	}
   474  
   475  	const APIVersion = "2015-05-21-preview"
   476  	queryParameters := map[string]interface{}{
   477  		"api-version": APIVersion,
   478  	}
   479  	if len(filter) > 0 {
   480  		queryParameters["$filter"] = autorest.Encode("query", filter)
   481  	}
   482  	if top != nil {
   483  		queryParameters["$top"] = autorest.Encode("query", *top)
   484  	}
   485  	if len(orderBy) > 0 {
   486  		queryParameters["$orderBy"] = autorest.Encode("query", orderBy)
   487  	}
   488  
   489  	preparer := autorest.CreatePreparer(
   490  		autorest.AsGet(),
   491  		autorest.WithBaseURL(client.BaseURI),
   492  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs", pathParameters),
   493  		autorest.WithQueryParameters(queryParameters))
   494  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   495  }
   496  
   497  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   498  // http.Response Body if it receives an error.
   499  func (client LabClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   500  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   501  }
   502  
   503  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   504  // closes the http.Response Body.
   505  func (client LabClient) ListByResourceGroupResponder(resp *http.Response) (result ResponseWithContinuationLab, err error) {
   506  	err = autorest.Respond(
   507  		resp,
   508  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   509  		autorest.ByUnmarshallingJSON(&result),
   510  		autorest.ByClosing())
   511  	result.Response = autorest.Response{Response: resp}
   512  	return
   513  }
   514  
   515  // listByResourceGroupNextResults retrieves the next set of results, if any.
   516  func (client LabClient) listByResourceGroupNextResults(ctx context.Context, lastResults ResponseWithContinuationLab) (result ResponseWithContinuationLab, err error) {
   517  	req, err := lastResults.responseWithContinuationLabPreparer(ctx)
   518  	if err != nil {
   519  		return result, autorest.NewErrorWithError(err, "dtl.LabClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   520  	}
   521  	if req == nil {
   522  		return
   523  	}
   524  	resp, err := client.ListByResourceGroupSender(req)
   525  	if err != nil {
   526  		result.Response = autorest.Response{Response: resp}
   527  		return result, autorest.NewErrorWithError(err, "dtl.LabClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   528  	}
   529  	result, err = client.ListByResourceGroupResponder(resp)
   530  	if err != nil {
   531  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   532  	}
   533  	return
   534  }
   535  
   536  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   537  func (client LabClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string, filter string, top *int32, orderBy string) (result ResponseWithContinuationLabIterator, err error) {
   538  	if tracing.IsEnabled() {
   539  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.ListByResourceGroup")
   540  		defer func() {
   541  			sc := -1
   542  			if result.Response().Response.Response != nil {
   543  				sc = result.page.Response().Response.Response.StatusCode
   544  			}
   545  			tracing.EndSpan(ctx, sc, err)
   546  		}()
   547  	}
   548  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName, filter, top, orderBy)
   549  	return
   550  }
   551  
   552  // ListBySubscription list labs.
   553  // Parameters:
   554  // filter - the filter to apply on the operation.
   555  func (client LabClient) ListBySubscription(ctx context.Context, filter string, top *int32, orderBy string) (result ResponseWithContinuationLabPage, err error) {
   556  	if tracing.IsEnabled() {
   557  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.ListBySubscription")
   558  		defer func() {
   559  			sc := -1
   560  			if result.rwcl.Response.Response != nil {
   561  				sc = result.rwcl.Response.Response.StatusCode
   562  			}
   563  			tracing.EndSpan(ctx, sc, err)
   564  		}()
   565  	}
   566  	result.fn = client.listBySubscriptionNextResults
   567  	req, err := client.ListBySubscriptionPreparer(ctx, filter, top, orderBy)
   568  	if err != nil {
   569  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListBySubscription", nil, "Failure preparing request")
   570  		return
   571  	}
   572  
   573  	resp, err := client.ListBySubscriptionSender(req)
   574  	if err != nil {
   575  		result.rwcl.Response = autorest.Response{Response: resp}
   576  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListBySubscription", resp, "Failure sending request")
   577  		return
   578  	}
   579  
   580  	result.rwcl, err = client.ListBySubscriptionResponder(resp)
   581  	if err != nil {
   582  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListBySubscription", resp, "Failure responding to request")
   583  		return
   584  	}
   585  	if result.rwcl.hasNextLink() && result.rwcl.IsEmpty() {
   586  		err = result.NextWithContext(ctx)
   587  		return
   588  	}
   589  
   590  	return
   591  }
   592  
   593  // ListBySubscriptionPreparer prepares the ListBySubscription request.
   594  func (client LabClient) ListBySubscriptionPreparer(ctx context.Context, filter string, top *int32, orderBy string) (*http.Request, error) {
   595  	pathParameters := map[string]interface{}{
   596  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   597  	}
   598  
   599  	const APIVersion = "2015-05-21-preview"
   600  	queryParameters := map[string]interface{}{
   601  		"api-version": APIVersion,
   602  	}
   603  	if len(filter) > 0 {
   604  		queryParameters["$filter"] = autorest.Encode("query", filter)
   605  	}
   606  	if top != nil {
   607  		queryParameters["$top"] = autorest.Encode("query", *top)
   608  	}
   609  	if len(orderBy) > 0 {
   610  		queryParameters["$orderBy"] = autorest.Encode("query", orderBy)
   611  	}
   612  
   613  	preparer := autorest.CreatePreparer(
   614  		autorest.AsGet(),
   615  		autorest.WithBaseURL(client.BaseURI),
   616  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.DevTestLab/labs", pathParameters),
   617  		autorest.WithQueryParameters(queryParameters))
   618  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   619  }
   620  
   621  // ListBySubscriptionSender sends the ListBySubscription request. The method will close the
   622  // http.Response Body if it receives an error.
   623  func (client LabClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
   624  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   625  }
   626  
   627  // ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
   628  // closes the http.Response Body.
   629  func (client LabClient) ListBySubscriptionResponder(resp *http.Response) (result ResponseWithContinuationLab, err error) {
   630  	err = autorest.Respond(
   631  		resp,
   632  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   633  		autorest.ByUnmarshallingJSON(&result),
   634  		autorest.ByClosing())
   635  	result.Response = autorest.Response{Response: resp}
   636  	return
   637  }
   638  
   639  // listBySubscriptionNextResults retrieves the next set of results, if any.
   640  func (client LabClient) listBySubscriptionNextResults(ctx context.Context, lastResults ResponseWithContinuationLab) (result ResponseWithContinuationLab, err error) {
   641  	req, err := lastResults.responseWithContinuationLabPreparer(ctx)
   642  	if err != nil {
   643  		return result, autorest.NewErrorWithError(err, "dtl.LabClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
   644  	}
   645  	if req == nil {
   646  		return
   647  	}
   648  	resp, err := client.ListBySubscriptionSender(req)
   649  	if err != nil {
   650  		result.Response = autorest.Response{Response: resp}
   651  		return result, autorest.NewErrorWithError(err, "dtl.LabClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
   652  	}
   653  	result, err = client.ListBySubscriptionResponder(resp)
   654  	if err != nil {
   655  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
   656  	}
   657  	return
   658  }
   659  
   660  // ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
   661  func (client LabClient) ListBySubscriptionComplete(ctx context.Context, filter string, top *int32, orderBy string) (result ResponseWithContinuationLabIterator, err error) {
   662  	if tracing.IsEnabled() {
   663  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.ListBySubscription")
   664  		defer func() {
   665  			sc := -1
   666  			if result.Response().Response.Response != nil {
   667  				sc = result.page.Response().Response.Response.StatusCode
   668  			}
   669  			tracing.EndSpan(ctx, sc, err)
   670  		}()
   671  	}
   672  	result.page, err = client.ListBySubscription(ctx, filter, top, orderBy)
   673  	return
   674  }
   675  
   676  // ListVhds list disk images available for custom image creation.
   677  // Parameters:
   678  // resourceGroupName - the name of the resource group.
   679  // name - the name of the lab.
   680  func (client LabClient) ListVhds(ctx context.Context, resourceGroupName string, name string) (result ResponseWithContinuationLabVhdPage, err error) {
   681  	if tracing.IsEnabled() {
   682  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.ListVhds")
   683  		defer func() {
   684  			sc := -1
   685  			if result.rwclv.Response.Response != nil {
   686  				sc = result.rwclv.Response.Response.StatusCode
   687  			}
   688  			tracing.EndSpan(ctx, sc, err)
   689  		}()
   690  	}
   691  	result.fn = client.listVhdsNextResults
   692  	req, err := client.ListVhdsPreparer(ctx, resourceGroupName, name)
   693  	if err != nil {
   694  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListVhds", nil, "Failure preparing request")
   695  		return
   696  	}
   697  
   698  	resp, err := client.ListVhdsSender(req)
   699  	if err != nil {
   700  		result.rwclv.Response = autorest.Response{Response: resp}
   701  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListVhds", resp, "Failure sending request")
   702  		return
   703  	}
   704  
   705  	result.rwclv, err = client.ListVhdsResponder(resp)
   706  	if err != nil {
   707  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "ListVhds", resp, "Failure responding to request")
   708  		return
   709  	}
   710  	if result.rwclv.hasNextLink() && result.rwclv.IsEmpty() {
   711  		err = result.NextWithContext(ctx)
   712  		return
   713  	}
   714  
   715  	return
   716  }
   717  
   718  // ListVhdsPreparer prepares the ListVhds request.
   719  func (client LabClient) ListVhdsPreparer(ctx context.Context, resourceGroupName string, name string) (*http.Request, error) {
   720  	pathParameters := map[string]interface{}{
   721  		"name":              autorest.Encode("path", name),
   722  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   723  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   724  	}
   725  
   726  	const APIVersion = "2015-05-21-preview"
   727  	queryParameters := map[string]interface{}{
   728  		"api-version": APIVersion,
   729  	}
   730  
   731  	preparer := autorest.CreatePreparer(
   732  		autorest.AsPost(),
   733  		autorest.WithBaseURL(client.BaseURI),
   734  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}/listVhds", pathParameters),
   735  		autorest.WithQueryParameters(queryParameters))
   736  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   737  }
   738  
   739  // ListVhdsSender sends the ListVhds request. The method will close the
   740  // http.Response Body if it receives an error.
   741  func (client LabClient) ListVhdsSender(req *http.Request) (*http.Response, error) {
   742  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   743  }
   744  
   745  // ListVhdsResponder handles the response to the ListVhds request. The method always
   746  // closes the http.Response Body.
   747  func (client LabClient) ListVhdsResponder(resp *http.Response) (result ResponseWithContinuationLabVhd, err error) {
   748  	err = autorest.Respond(
   749  		resp,
   750  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   751  		autorest.ByUnmarshallingJSON(&result),
   752  		autorest.ByClosing())
   753  	result.Response = autorest.Response{Response: resp}
   754  	return
   755  }
   756  
   757  // listVhdsNextResults retrieves the next set of results, if any.
   758  func (client LabClient) listVhdsNextResults(ctx context.Context, lastResults ResponseWithContinuationLabVhd) (result ResponseWithContinuationLabVhd, err error) {
   759  	req, err := lastResults.responseWithContinuationLabVhdPreparer(ctx)
   760  	if err != nil {
   761  		return result, autorest.NewErrorWithError(err, "dtl.LabClient", "listVhdsNextResults", nil, "Failure preparing next results request")
   762  	}
   763  	if req == nil {
   764  		return
   765  	}
   766  	resp, err := client.ListVhdsSender(req)
   767  	if err != nil {
   768  		result.Response = autorest.Response{Response: resp}
   769  		return result, autorest.NewErrorWithError(err, "dtl.LabClient", "listVhdsNextResults", resp, "Failure sending next results request")
   770  	}
   771  	result, err = client.ListVhdsResponder(resp)
   772  	if err != nil {
   773  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "listVhdsNextResults", resp, "Failure responding to next results request")
   774  	}
   775  	return
   776  }
   777  
   778  // ListVhdsComplete enumerates all values, automatically crossing page boundaries as required.
   779  func (client LabClient) ListVhdsComplete(ctx context.Context, resourceGroupName string, name string) (result ResponseWithContinuationLabVhdIterator, err error) {
   780  	if tracing.IsEnabled() {
   781  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.ListVhds")
   782  		defer func() {
   783  			sc := -1
   784  			if result.Response().Response.Response != nil {
   785  				sc = result.page.Response().Response.Response.StatusCode
   786  			}
   787  			tracing.EndSpan(ctx, sc, err)
   788  		}()
   789  	}
   790  	result.page, err = client.ListVhds(ctx, resourceGroupName, name)
   791  	return
   792  }
   793  
   794  // PatchResource modify properties of labs.
   795  // Parameters:
   796  // resourceGroupName - the name of the resource group.
   797  // name - the name of the lab.
   798  func (client LabClient) PatchResource(ctx context.Context, resourceGroupName string, name string, lab Lab) (result Lab, err error) {
   799  	if tracing.IsEnabled() {
   800  		ctx = tracing.StartSpan(ctx, fqdn+"/LabClient.PatchResource")
   801  		defer func() {
   802  			sc := -1
   803  			if result.Response.Response != nil {
   804  				sc = result.Response.Response.StatusCode
   805  			}
   806  			tracing.EndSpan(ctx, sc, err)
   807  		}()
   808  	}
   809  	req, err := client.PatchResourcePreparer(ctx, resourceGroupName, name, lab)
   810  	if err != nil {
   811  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "PatchResource", nil, "Failure preparing request")
   812  		return
   813  	}
   814  
   815  	resp, err := client.PatchResourceSender(req)
   816  	if err != nil {
   817  		result.Response = autorest.Response{Response: resp}
   818  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "PatchResource", resp, "Failure sending request")
   819  		return
   820  	}
   821  
   822  	result, err = client.PatchResourceResponder(resp)
   823  	if err != nil {
   824  		err = autorest.NewErrorWithError(err, "dtl.LabClient", "PatchResource", resp, "Failure responding to request")
   825  		return
   826  	}
   827  
   828  	return
   829  }
   830  
   831  // PatchResourcePreparer prepares the PatchResource request.
   832  func (client LabClient) PatchResourcePreparer(ctx context.Context, resourceGroupName string, name string, lab Lab) (*http.Request, error) {
   833  	pathParameters := map[string]interface{}{
   834  		"name":              autorest.Encode("path", name),
   835  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   836  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   837  	}
   838  
   839  	const APIVersion = "2015-05-21-preview"
   840  	queryParameters := map[string]interface{}{
   841  		"api-version": APIVersion,
   842  	}
   843  
   844  	preparer := autorest.CreatePreparer(
   845  		autorest.AsContentType("application/json; charset=utf-8"),
   846  		autorest.AsPatch(),
   847  		autorest.WithBaseURL(client.BaseURI),
   848  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DevTestLab/labs/{name}", pathParameters),
   849  		autorest.WithJSON(lab),
   850  		autorest.WithQueryParameters(queryParameters))
   851  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   852  }
   853  
   854  // PatchResourceSender sends the PatchResource request. The method will close the
   855  // http.Response Body if it receives an error.
   856  func (client LabClient) PatchResourceSender(req *http.Request) (*http.Response, error) {
   857  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   858  }
   859  
   860  // PatchResourceResponder handles the response to the PatchResource request. The method always
   861  // closes the http.Response Body.
   862  func (client LabClient) PatchResourceResponder(resp *http.Response) (result Lab, err error) {
   863  	err = autorest.Respond(
   864  		resp,
   865  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   866  		autorest.ByUnmarshallingJSON(&result),
   867  		autorest.ByClosing())
   868  	result.Response = autorest.Response{Response: resp}
   869  	return
   870  }
   871
View as plain text