disks.go

Documentation: github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2021-12-01/compute

     1  package compute
     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/autorest/validation"
    14  	"github.com/Azure/go-autorest/tracing"
    15  	"net/http"
    16  )
    17  
    18  // DisksClient is the compute Client
    19  type DisksClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewDisksClient creates an instance of the DisksClient client.
    24  func NewDisksClient(subscriptionID string) DisksClient {
    25  	return NewDisksClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewDisksClientWithBaseURI creates an instance of the DisksClient client using a custom endpoint.  Use this when
    29  // interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    30  func NewDisksClientWithBaseURI(baseURI string, subscriptionID string) DisksClient {
    31  	return DisksClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdate creates or updates a disk.
    35  // Parameters:
    36  // resourceGroupName - the name of the resource group.
    37  // diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
    38  // created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80
    39  // characters.
    40  // disk - disk object supplied in the body of the Put disk operation.
    41  func (client DisksClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, diskName string, disk Disk) (result DisksCreateOrUpdateFuture, err error) {
    42  	if tracing.IsEnabled() {
    43  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.CreateOrUpdate")
    44  		defer func() {
    45  			sc := -1
    46  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    47  				sc = result.FutureAPI.Response().StatusCode
    48  			}
    49  			tracing.EndSpan(ctx, sc, err)
    50  		}()
    51  	}
    52  	if err := validation.Validate([]validation.Validation{
    53  		{TargetValue: disk,
    54  			Constraints: []validation.Constraint{{Target: "disk.DiskProperties", Name: validation.Null, Rule: false,
    55  				Chain: []validation.Constraint{{Target: "disk.DiskProperties.PurchasePlan", Name: validation.Null, Rule: false,
    56  					Chain: []validation.Constraint{{Target: "disk.DiskProperties.PurchasePlan.Publisher", Name: validation.Null, Rule: true, Chain: nil},
    57  						{Target: "disk.DiskProperties.PurchasePlan.Name", Name: validation.Null, Rule: true, Chain: nil},
    58  						{Target: "disk.DiskProperties.PurchasePlan.Product", Name: validation.Null, Rule: true, Chain: nil},
    59  					}},
    60  					{Target: "disk.DiskProperties.CreationData", Name: validation.Null, Rule: true,
    61  						Chain: []validation.Constraint{{Target: "disk.DiskProperties.CreationData.ImageReference", Name: validation.Null, Rule: false,
    62  							Chain: []validation.Constraint{{Target: "disk.DiskProperties.CreationData.ImageReference.ID", Name: validation.Null, Rule: true, Chain: nil}}},
    63  							{Target: "disk.DiskProperties.CreationData.GalleryImageReference", Name: validation.Null, Rule: false,
    64  								Chain: []validation.Constraint{{Target: "disk.DiskProperties.CreationData.GalleryImageReference.ID", Name: validation.Null, Rule: true, Chain: nil}}},
    65  						}},
    66  					{Target: "disk.DiskProperties.EncryptionSettingsCollection", Name: validation.Null, Rule: false,
    67  						Chain: []validation.Constraint{{Target: "disk.DiskProperties.EncryptionSettingsCollection.Enabled", Name: validation.Null, Rule: true, Chain: nil}}},
    68  				}}}}}); err != nil {
    69  		return result, validation.NewError("compute.DisksClient", "CreateOrUpdate", err.Error())
    70  	}
    71  
    72  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, diskName, disk)
    73  	if err != nil {
    74  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "CreateOrUpdate", nil, "Failure preparing request")
    75  		return
    76  	}
    77  
    78  	result, err = client.CreateOrUpdateSender(req)
    79  	if err != nil {
    80  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "CreateOrUpdate", result.Response(), "Failure sending request")
    81  		return
    82  	}
    83  
    84  	return
    85  }
    86  
    87  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    88  func (client DisksClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, diskName string, disk Disk) (*http.Request, error) {
    89  	pathParameters := map[string]interface{}{
    90  		"diskName":          autorest.Encode("path", diskName),
    91  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    92  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    93  	}
    94  
    95  	const APIVersion = "2021-12-01"
    96  	queryParameters := map[string]interface{}{
    97  		"api-version": APIVersion,
    98  	}
    99  
   100  	disk.ManagedBy = nil
   101  	disk.ManagedByExtended = nil
   102  	preparer := autorest.CreatePreparer(
   103  		autorest.AsContentType("application/json; charset=utf-8"),
   104  		autorest.AsPut(),
   105  		autorest.WithBaseURL(client.BaseURI),
   106  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
   107  		autorest.WithJSON(disk),
   108  		autorest.WithQueryParameters(queryParameters))
   109  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   110  }
   111  
   112  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   113  // http.Response Body if it receives an error.
   114  func (client DisksClient) CreateOrUpdateSender(req *http.Request) (future DisksCreateOrUpdateFuture, err error) {
   115  	var resp *http.Response
   116  	future.FutureAPI = &azure.Future{}
   117  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   118  	if err != nil {
   119  		return
   120  	}
   121  	var azf azure.Future
   122  	azf, err = azure.NewFutureFromResponse(resp)
   123  	future.FutureAPI = &azf
   124  	future.Result = future.result
   125  	return
   126  }
   127  
   128  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   129  // closes the http.Response Body.
   130  func (client DisksClient) CreateOrUpdateResponder(resp *http.Response) (result Disk, err error) {
   131  	err = autorest.Respond(
   132  		resp,
   133  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   134  		autorest.ByUnmarshallingJSON(&result),
   135  		autorest.ByClosing())
   136  	result.Response = autorest.Response{Response: resp}
   137  	return
   138  }
   139  
   140  // Delete deletes a disk.
   141  // Parameters:
   142  // resourceGroupName - the name of the resource group.
   143  // diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
   144  // created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80
   145  // characters.
   146  func (client DisksClient) Delete(ctx context.Context, resourceGroupName string, diskName string) (result DisksDeleteFuture, err error) {
   147  	if tracing.IsEnabled() {
   148  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.Delete")
   149  		defer func() {
   150  			sc := -1
   151  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   152  				sc = result.FutureAPI.Response().StatusCode
   153  			}
   154  			tracing.EndSpan(ctx, sc, err)
   155  		}()
   156  	}
   157  	req, err := client.DeletePreparer(ctx, resourceGroupName, diskName)
   158  	if err != nil {
   159  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Delete", nil, "Failure preparing request")
   160  		return
   161  	}
   162  
   163  	result, err = client.DeleteSender(req)
   164  	if err != nil {
   165  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Delete", result.Response(), "Failure sending request")
   166  		return
   167  	}
   168  
   169  	return
   170  }
   171  
   172  // DeletePreparer prepares the Delete request.
   173  func (client DisksClient) DeletePreparer(ctx context.Context, resourceGroupName string, diskName string) (*http.Request, error) {
   174  	pathParameters := map[string]interface{}{
   175  		"diskName":          autorest.Encode("path", diskName),
   176  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   177  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   178  	}
   179  
   180  	const APIVersion = "2021-12-01"
   181  	queryParameters := map[string]interface{}{
   182  		"api-version": APIVersion,
   183  	}
   184  
   185  	preparer := autorest.CreatePreparer(
   186  		autorest.AsDelete(),
   187  		autorest.WithBaseURL(client.BaseURI),
   188  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
   189  		autorest.WithQueryParameters(queryParameters))
   190  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   191  }
   192  
   193  // DeleteSender sends the Delete request. The method will close the
   194  // http.Response Body if it receives an error.
   195  func (client DisksClient) DeleteSender(req *http.Request) (future DisksDeleteFuture, err error) {
   196  	var resp *http.Response
   197  	future.FutureAPI = &azure.Future{}
   198  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   199  	if err != nil {
   200  		return
   201  	}
   202  	var azf azure.Future
   203  	azf, err = azure.NewFutureFromResponse(resp)
   204  	future.FutureAPI = &azf
   205  	future.Result = future.result
   206  	return
   207  }
   208  
   209  // DeleteResponder handles the response to the Delete request. The method always
   210  // closes the http.Response Body.
   211  func (client DisksClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   212  	err = autorest.Respond(
   213  		resp,
   214  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   215  		autorest.ByClosing())
   216  	result.Response = resp
   217  	return
   218  }
   219  
   220  // Get gets information about a disk.
   221  // Parameters:
   222  // resourceGroupName - the name of the resource group.
   223  // diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
   224  // created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80
   225  // characters.
   226  func (client DisksClient) Get(ctx context.Context, resourceGroupName string, diskName string) (result Disk, err error) {
   227  	if tracing.IsEnabled() {
   228  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.Get")
   229  		defer func() {
   230  			sc := -1
   231  			if result.Response.Response != nil {
   232  				sc = result.Response.Response.StatusCode
   233  			}
   234  			tracing.EndSpan(ctx, sc, err)
   235  		}()
   236  	}
   237  	req, err := client.GetPreparer(ctx, resourceGroupName, diskName)
   238  	if err != nil {
   239  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Get", nil, "Failure preparing request")
   240  		return
   241  	}
   242  
   243  	resp, err := client.GetSender(req)
   244  	if err != nil {
   245  		result.Response = autorest.Response{Response: resp}
   246  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Get", resp, "Failure sending request")
   247  		return
   248  	}
   249  
   250  	result, err = client.GetResponder(resp)
   251  	if err != nil {
   252  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Get", resp, "Failure responding to request")
   253  		return
   254  	}
   255  
   256  	return
   257  }
   258  
   259  // GetPreparer prepares the Get request.
   260  func (client DisksClient) GetPreparer(ctx context.Context, resourceGroupName string, diskName string) (*http.Request, error) {
   261  	pathParameters := map[string]interface{}{
   262  		"diskName":          autorest.Encode("path", diskName),
   263  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   264  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   265  	}
   266  
   267  	const APIVersion = "2021-12-01"
   268  	queryParameters := map[string]interface{}{
   269  		"api-version": APIVersion,
   270  	}
   271  
   272  	preparer := autorest.CreatePreparer(
   273  		autorest.AsGet(),
   274  		autorest.WithBaseURL(client.BaseURI),
   275  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
   276  		autorest.WithQueryParameters(queryParameters))
   277  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   278  }
   279  
   280  // GetSender sends the Get request. The method will close the
   281  // http.Response Body if it receives an error.
   282  func (client DisksClient) GetSender(req *http.Request) (*http.Response, error) {
   283  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   284  }
   285  
   286  // GetResponder handles the response to the Get request. The method always
   287  // closes the http.Response Body.
   288  func (client DisksClient) GetResponder(resp *http.Response) (result Disk, err error) {
   289  	err = autorest.Respond(
   290  		resp,
   291  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   292  		autorest.ByUnmarshallingJSON(&result),
   293  		autorest.ByClosing())
   294  	result.Response = autorest.Response{Response: resp}
   295  	return
   296  }
   297  
   298  // GrantAccess grants access to a disk.
   299  // Parameters:
   300  // resourceGroupName - the name of the resource group.
   301  // diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
   302  // created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80
   303  // characters.
   304  // grantAccessData - access data object supplied in the body of the get disk access operation.
   305  func (client DisksClient) GrantAccess(ctx context.Context, resourceGroupName string, diskName string, grantAccessData GrantAccessData) (result DisksGrantAccessFuture, err error) {
   306  	if tracing.IsEnabled() {
   307  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.GrantAccess")
   308  		defer func() {
   309  			sc := -1
   310  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   311  				sc = result.FutureAPI.Response().StatusCode
   312  			}
   313  			tracing.EndSpan(ctx, sc, err)
   314  		}()
   315  	}
   316  	if err := validation.Validate([]validation.Validation{
   317  		{TargetValue: grantAccessData,
   318  			Constraints: []validation.Constraint{{Target: "grantAccessData.DurationInSeconds", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
   319  		return result, validation.NewError("compute.DisksClient", "GrantAccess", err.Error())
   320  	}
   321  
   322  	req, err := client.GrantAccessPreparer(ctx, resourceGroupName, diskName, grantAccessData)
   323  	if err != nil {
   324  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "GrantAccess", nil, "Failure preparing request")
   325  		return
   326  	}
   327  
   328  	result, err = client.GrantAccessSender(req)
   329  	if err != nil {
   330  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "GrantAccess", result.Response(), "Failure sending request")
   331  		return
   332  	}
   333  
   334  	return
   335  }
   336  
   337  // GrantAccessPreparer prepares the GrantAccess request.
   338  func (client DisksClient) GrantAccessPreparer(ctx context.Context, resourceGroupName string, diskName string, grantAccessData GrantAccessData) (*http.Request, error) {
   339  	pathParameters := map[string]interface{}{
   340  		"diskName":          autorest.Encode("path", diskName),
   341  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   342  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   343  	}
   344  
   345  	const APIVersion = "2021-12-01"
   346  	queryParameters := map[string]interface{}{
   347  		"api-version": APIVersion,
   348  	}
   349  
   350  	preparer := autorest.CreatePreparer(
   351  		autorest.AsContentType("application/json; charset=utf-8"),
   352  		autorest.AsPost(),
   353  		autorest.WithBaseURL(client.BaseURI),
   354  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}/beginGetAccess", pathParameters),
   355  		autorest.WithJSON(grantAccessData),
   356  		autorest.WithQueryParameters(queryParameters))
   357  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   358  }
   359  
   360  // GrantAccessSender sends the GrantAccess request. The method will close the
   361  // http.Response Body if it receives an error.
   362  func (client DisksClient) GrantAccessSender(req *http.Request) (future DisksGrantAccessFuture, err error) {
   363  	var resp *http.Response
   364  	future.FutureAPI = &azure.Future{}
   365  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   366  	if err != nil {
   367  		return
   368  	}
   369  	var azf azure.Future
   370  	azf, err = azure.NewFutureFromResponse(resp)
   371  	future.FutureAPI = &azf
   372  	future.Result = future.result
   373  	return
   374  }
   375  
   376  // GrantAccessResponder handles the response to the GrantAccess request. The method always
   377  // closes the http.Response Body.
   378  func (client DisksClient) GrantAccessResponder(resp *http.Response) (result AccessURI, err error) {
   379  	err = autorest.Respond(
   380  		resp,
   381  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   382  		autorest.ByUnmarshallingJSON(&result),
   383  		autorest.ByClosing())
   384  	result.Response = autorest.Response{Response: resp}
   385  	return
   386  }
   387  
   388  // List lists all the disks under a subscription.
   389  func (client DisksClient) List(ctx context.Context) (result DiskListPage, err error) {
   390  	if tracing.IsEnabled() {
   391  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.List")
   392  		defer func() {
   393  			sc := -1
   394  			if result.dl.Response.Response != nil {
   395  				sc = result.dl.Response.Response.StatusCode
   396  			}
   397  			tracing.EndSpan(ctx, sc, err)
   398  		}()
   399  	}
   400  	result.fn = client.listNextResults
   401  	req, err := client.ListPreparer(ctx)
   402  	if err != nil {
   403  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "List", nil, "Failure preparing request")
   404  		return
   405  	}
   406  
   407  	resp, err := client.ListSender(req)
   408  	if err != nil {
   409  		result.dl.Response = autorest.Response{Response: resp}
   410  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "List", resp, "Failure sending request")
   411  		return
   412  	}
   413  
   414  	result.dl, err = client.ListResponder(resp)
   415  	if err != nil {
   416  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "List", resp, "Failure responding to request")
   417  		return
   418  	}
   419  	if result.dl.hasNextLink() && result.dl.IsEmpty() {
   420  		err = result.NextWithContext(ctx)
   421  		return
   422  	}
   423  
   424  	return
   425  }
   426  
   427  // ListPreparer prepares the List request.
   428  func (client DisksClient) ListPreparer(ctx context.Context) (*http.Request, error) {
   429  	pathParameters := map[string]interface{}{
   430  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   431  	}
   432  
   433  	const APIVersion = "2021-12-01"
   434  	queryParameters := map[string]interface{}{
   435  		"api-version": APIVersion,
   436  	}
   437  
   438  	preparer := autorest.CreatePreparer(
   439  		autorest.AsGet(),
   440  		autorest.WithBaseURL(client.BaseURI),
   441  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/disks", pathParameters),
   442  		autorest.WithQueryParameters(queryParameters))
   443  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   444  }
   445  
   446  // ListSender sends the List request. The method will close the
   447  // http.Response Body if it receives an error.
   448  func (client DisksClient) ListSender(req *http.Request) (*http.Response, error) {
   449  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   450  }
   451  
   452  // ListResponder handles the response to the List request. The method always
   453  // closes the http.Response Body.
   454  func (client DisksClient) ListResponder(resp *http.Response) (result DiskList, err error) {
   455  	err = autorest.Respond(
   456  		resp,
   457  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   458  		autorest.ByUnmarshallingJSON(&result),
   459  		autorest.ByClosing())
   460  	result.Response = autorest.Response{Response: resp}
   461  	return
   462  }
   463  
   464  // listNextResults retrieves the next set of results, if any.
   465  func (client DisksClient) listNextResults(ctx context.Context, lastResults DiskList) (result DiskList, err error) {
   466  	req, err := lastResults.diskListPreparer(ctx)
   467  	if err != nil {
   468  		return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listNextResults", nil, "Failure preparing next results request")
   469  	}
   470  	if req == nil {
   471  		return
   472  	}
   473  	resp, err := client.ListSender(req)
   474  	if err != nil {
   475  		result.Response = autorest.Response{Response: resp}
   476  		return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listNextResults", resp, "Failure sending next results request")
   477  	}
   478  	result, err = client.ListResponder(resp)
   479  	if err != nil {
   480  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "listNextResults", resp, "Failure responding to next results request")
   481  	}
   482  	return
   483  }
   484  
   485  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   486  func (client DisksClient) ListComplete(ctx context.Context) (result DiskListIterator, err error) {
   487  	if tracing.IsEnabled() {
   488  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.List")
   489  		defer func() {
   490  			sc := -1
   491  			if result.Response().Response.Response != nil {
   492  				sc = result.page.Response().Response.Response.StatusCode
   493  			}
   494  			tracing.EndSpan(ctx, sc, err)
   495  		}()
   496  	}
   497  	result.page, err = client.List(ctx)
   498  	return
   499  }
   500  
   501  // ListByResourceGroup lists all the disks under a resource group.
   502  // Parameters:
   503  // resourceGroupName - the name of the resource group.
   504  func (client DisksClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result DiskListPage, err error) {
   505  	if tracing.IsEnabled() {
   506  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.ListByResourceGroup")
   507  		defer func() {
   508  			sc := -1
   509  			if result.dl.Response.Response != nil {
   510  				sc = result.dl.Response.Response.StatusCode
   511  			}
   512  			tracing.EndSpan(ctx, sc, err)
   513  		}()
   514  	}
   515  	result.fn = client.listByResourceGroupNextResults
   516  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
   517  	if err != nil {
   518  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "ListByResourceGroup", nil, "Failure preparing request")
   519  		return
   520  	}
   521  
   522  	resp, err := client.ListByResourceGroupSender(req)
   523  	if err != nil {
   524  		result.dl.Response = autorest.Response{Response: resp}
   525  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "ListByResourceGroup", resp, "Failure sending request")
   526  		return
   527  	}
   528  
   529  	result.dl, err = client.ListByResourceGroupResponder(resp)
   530  	if err != nil {
   531  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "ListByResourceGroup", resp, "Failure responding to request")
   532  		return
   533  	}
   534  	if result.dl.hasNextLink() && result.dl.IsEmpty() {
   535  		err = result.NextWithContext(ctx)
   536  		return
   537  	}
   538  
   539  	return
   540  }
   541  
   542  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   543  func (client DisksClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   544  	pathParameters := map[string]interface{}{
   545  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   546  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   547  	}
   548  
   549  	const APIVersion = "2021-12-01"
   550  	queryParameters := map[string]interface{}{
   551  		"api-version": APIVersion,
   552  	}
   553  
   554  	preparer := autorest.CreatePreparer(
   555  		autorest.AsGet(),
   556  		autorest.WithBaseURL(client.BaseURI),
   557  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks", pathParameters),
   558  		autorest.WithQueryParameters(queryParameters))
   559  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   560  }
   561  
   562  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   563  // http.Response Body if it receives an error.
   564  func (client DisksClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   565  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   566  }
   567  
   568  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   569  // closes the http.Response Body.
   570  func (client DisksClient) ListByResourceGroupResponder(resp *http.Response) (result DiskList, err error) {
   571  	err = autorest.Respond(
   572  		resp,
   573  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   574  		autorest.ByUnmarshallingJSON(&result),
   575  		autorest.ByClosing())
   576  	result.Response = autorest.Response{Response: resp}
   577  	return
   578  }
   579  
   580  // listByResourceGroupNextResults retrieves the next set of results, if any.
   581  func (client DisksClient) listByResourceGroupNextResults(ctx context.Context, lastResults DiskList) (result DiskList, err error) {
   582  	req, err := lastResults.diskListPreparer(ctx)
   583  	if err != nil {
   584  		return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   585  	}
   586  	if req == nil {
   587  		return
   588  	}
   589  	resp, err := client.ListByResourceGroupSender(req)
   590  	if err != nil {
   591  		result.Response = autorest.Response{Response: resp}
   592  		return result, autorest.NewErrorWithError(err, "compute.DisksClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   593  	}
   594  	result, err = client.ListByResourceGroupResponder(resp)
   595  	if err != nil {
   596  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   597  	}
   598  	return
   599  }
   600  
   601  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   602  func (client DisksClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result DiskListIterator, err error) {
   603  	if tracing.IsEnabled() {
   604  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.ListByResourceGroup")
   605  		defer func() {
   606  			sc := -1
   607  			if result.Response().Response.Response != nil {
   608  				sc = result.page.Response().Response.Response.StatusCode
   609  			}
   610  			tracing.EndSpan(ctx, sc, err)
   611  		}()
   612  	}
   613  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
   614  	return
   615  }
   616  
   617  // RevokeAccess revokes access to a disk.
   618  // Parameters:
   619  // resourceGroupName - the name of the resource group.
   620  // diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
   621  // created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80
   622  // characters.
   623  func (client DisksClient) RevokeAccess(ctx context.Context, resourceGroupName string, diskName string) (result DisksRevokeAccessFuture, err error) {
   624  	if tracing.IsEnabled() {
   625  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.RevokeAccess")
   626  		defer func() {
   627  			sc := -1
   628  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   629  				sc = result.FutureAPI.Response().StatusCode
   630  			}
   631  			tracing.EndSpan(ctx, sc, err)
   632  		}()
   633  	}
   634  	req, err := client.RevokeAccessPreparer(ctx, resourceGroupName, diskName)
   635  	if err != nil {
   636  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "RevokeAccess", nil, "Failure preparing request")
   637  		return
   638  	}
   639  
   640  	result, err = client.RevokeAccessSender(req)
   641  	if err != nil {
   642  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "RevokeAccess", result.Response(), "Failure sending request")
   643  		return
   644  	}
   645  
   646  	return
   647  }
   648  
   649  // RevokeAccessPreparer prepares the RevokeAccess request.
   650  func (client DisksClient) RevokeAccessPreparer(ctx context.Context, resourceGroupName string, diskName string) (*http.Request, error) {
   651  	pathParameters := map[string]interface{}{
   652  		"diskName":          autorest.Encode("path", diskName),
   653  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   654  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   655  	}
   656  
   657  	const APIVersion = "2021-12-01"
   658  	queryParameters := map[string]interface{}{
   659  		"api-version": APIVersion,
   660  	}
   661  
   662  	preparer := autorest.CreatePreparer(
   663  		autorest.AsPost(),
   664  		autorest.WithBaseURL(client.BaseURI),
   665  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}/endGetAccess", pathParameters),
   666  		autorest.WithQueryParameters(queryParameters))
   667  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   668  }
   669  
   670  // RevokeAccessSender sends the RevokeAccess request. The method will close the
   671  // http.Response Body if it receives an error.
   672  func (client DisksClient) RevokeAccessSender(req *http.Request) (future DisksRevokeAccessFuture, err error) {
   673  	var resp *http.Response
   674  	future.FutureAPI = &azure.Future{}
   675  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   676  	if err != nil {
   677  		return
   678  	}
   679  	var azf azure.Future
   680  	azf, err = azure.NewFutureFromResponse(resp)
   681  	future.FutureAPI = &azf
   682  	future.Result = future.result
   683  	return
   684  }
   685  
   686  // RevokeAccessResponder handles the response to the RevokeAccess request. The method always
   687  // closes the http.Response Body.
   688  func (client DisksClient) RevokeAccessResponder(resp *http.Response) (result autorest.Response, err error) {
   689  	err = autorest.Respond(
   690  		resp,
   691  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   692  		autorest.ByClosing())
   693  	result.Response = resp
   694  	return
   695  }
   696  
   697  // Update updates (patches) a disk.
   698  // Parameters:
   699  // resourceGroupName - the name of the resource group.
   700  // diskName - the name of the managed disk that is being created. The name can't be changed after the disk is
   701  // created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80
   702  // characters.
   703  // disk - disk object supplied in the body of the Patch disk operation.
   704  func (client DisksClient) Update(ctx context.Context, resourceGroupName string, diskName string, disk DiskUpdate) (result DisksUpdateFuture, err error) {
   705  	if tracing.IsEnabled() {
   706  		ctx = tracing.StartSpan(ctx, fqdn+"/DisksClient.Update")
   707  		defer func() {
   708  			sc := -1
   709  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   710  				sc = result.FutureAPI.Response().StatusCode
   711  			}
   712  			tracing.EndSpan(ctx, sc, err)
   713  		}()
   714  	}
   715  	req, err := client.UpdatePreparer(ctx, resourceGroupName, diskName, disk)
   716  	if err != nil {
   717  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Update", nil, "Failure preparing request")
   718  		return
   719  	}
   720  
   721  	result, err = client.UpdateSender(req)
   722  	if err != nil {
   723  		err = autorest.NewErrorWithError(err, "compute.DisksClient", "Update", result.Response(), "Failure sending request")
   724  		return
   725  	}
   726  
   727  	return
   728  }
   729  
   730  // UpdatePreparer prepares the Update request.
   731  func (client DisksClient) UpdatePreparer(ctx context.Context, resourceGroupName string, diskName string, disk DiskUpdate) (*http.Request, error) {
   732  	pathParameters := map[string]interface{}{
   733  		"diskName":          autorest.Encode("path", diskName),
   734  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   735  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   736  	}
   737  
   738  	const APIVersion = "2021-12-01"
   739  	queryParameters := map[string]interface{}{
   740  		"api-version": APIVersion,
   741  	}
   742  
   743  	preparer := autorest.CreatePreparer(
   744  		autorest.AsContentType("application/json; charset=utf-8"),
   745  		autorest.AsPatch(),
   746  		autorest.WithBaseURL(client.BaseURI),
   747  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}", pathParameters),
   748  		autorest.WithJSON(disk),
   749  		autorest.WithQueryParameters(queryParameters))
   750  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   751  }
   752  
   753  // UpdateSender sends the Update request. The method will close the
   754  // http.Response Body if it receives an error.
   755  func (client DisksClient) UpdateSender(req *http.Request) (future DisksUpdateFuture, err error) {
   756  	var resp *http.Response
   757  	future.FutureAPI = &azure.Future{}
   758  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   759  	if err != nil {
   760  		return
   761  	}
   762  	var azf azure.Future
   763  	azf, err = azure.NewFutureFromResponse(resp)
   764  	future.FutureAPI = &azf
   765  	future.Result = future.result
   766  	return
   767  }
   768  
   769  // UpdateResponder handles the response to the Update request. The method always
   770  // closes the http.Response Body.
   771  func (client DisksClient) UpdateResponder(resp *http.Response) (result Disk, err error) {
   772  	err = autorest.Respond(
   773  		resp,
   774  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   775  		autorest.ByUnmarshallingJSON(&result),
   776  		autorest.ByClosing())
   777  	result.Response = autorest.Response{Response: resp}
   778  	return
   779  }
   780
View as plain text