computepolicies.go

Documentation: github.com/Azure/azure-sdk-for-go/services/datalake/analytics/mgmt/2016-11-01/account

     1  package account
     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  // ComputePoliciesClient is the creates an Azure Data Lake Analytics account management client.
    19  type ComputePoliciesClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewComputePoliciesClient creates an instance of the ComputePoliciesClient client.
    24  func NewComputePoliciesClient(subscriptionID string) ComputePoliciesClient {
    25  	return NewComputePoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewComputePoliciesClientWithBaseURI creates an instance of the ComputePoliciesClient 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).
    30  func NewComputePoliciesClientWithBaseURI(baseURI string, subscriptionID string) ComputePoliciesClient {
    31  	return ComputePoliciesClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdate creates or updates the specified compute policy. During update, the compute policy with the specified
    35  // name will be replaced with this new compute policy. An account supports, at most, 50 policies
    36  // Parameters:
    37  // resourceGroupName - the name of the Azure resource group.
    38  // accountName - the name of the Data Lake Analytics account.
    39  // computePolicyName - the name of the compute policy to create or update.
    40  // parameters - parameters supplied to create or update the compute policy. The max degree of parallelism per
    41  // job property, min priority per job property, or both must be present.
    42  func (client ComputePoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, parameters CreateOrUpdateComputePolicyParameters) (result ComputePolicy, err error) {
    43  	if tracing.IsEnabled() {
    44  		ctx = tracing.StartSpan(ctx, fqdn+"/ComputePoliciesClient.CreateOrUpdate")
    45  		defer func() {
    46  			sc := -1
    47  			if result.Response.Response != nil {
    48  				sc = result.Response.Response.StatusCode
    49  			}
    50  			tracing.EndSpan(ctx, sc, err)
    51  		}()
    52  	}
    53  	if err := validation.Validate([]validation.Validation{
    54  		{TargetValue: parameters,
    55  			Constraints: []validation.Constraint{{Target: "parameters.CreateOrUpdateComputePolicyProperties", Name: validation.Null, Rule: true,
    56  				Chain: []validation.Constraint{{Target: "parameters.CreateOrUpdateComputePolicyProperties.ObjectID", Name: validation.Null, Rule: true, Chain: nil},
    57  					{Target: "parameters.CreateOrUpdateComputePolicyProperties.MaxDegreeOfParallelismPerJob", Name: validation.Null, Rule: false,
    58  						Chain: []validation.Constraint{{Target: "parameters.CreateOrUpdateComputePolicyProperties.MaxDegreeOfParallelismPerJob", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
    59  					{Target: "parameters.CreateOrUpdateComputePolicyProperties.MinPriorityPerJob", Name: validation.Null, Rule: false,
    60  						Chain: []validation.Constraint{{Target: "parameters.CreateOrUpdateComputePolicyProperties.MinPriorityPerJob", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
    61  				}}}}}); err != nil {
    62  		return result, validation.NewError("account.ComputePoliciesClient", "CreateOrUpdate", err.Error())
    63  	}
    64  
    65  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, accountName, computePolicyName, parameters)
    66  	if err != nil {
    67  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "CreateOrUpdate", nil, "Failure preparing request")
    68  		return
    69  	}
    70  
    71  	resp, err := client.CreateOrUpdateSender(req)
    72  	if err != nil {
    73  		result.Response = autorest.Response{Response: resp}
    74  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "CreateOrUpdate", resp, "Failure sending request")
    75  		return
    76  	}
    77  
    78  	result, err = client.CreateOrUpdateResponder(resp)
    79  	if err != nil {
    80  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "CreateOrUpdate", resp, "Failure responding to request")
    81  		return
    82  	}
    83  
    84  	return
    85  }
    86  
    87  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    88  func (client ComputePoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, parameters CreateOrUpdateComputePolicyParameters) (*http.Request, error) {
    89  	pathParameters := map[string]interface{}{
    90  		"accountName":       autorest.Encode("path", accountName),
    91  		"computePolicyName": autorest.Encode("path", computePolicyName),
    92  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    93  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    94  	}
    95  
    96  	const APIVersion = "2016-11-01"
    97  	queryParameters := map[string]interface{}{
    98  		"api-version": APIVersion,
    99  	}
   100  
   101  	preparer := autorest.CreatePreparer(
   102  		autorest.AsContentType("application/json; charset=utf-8"),
   103  		autorest.AsPut(),
   104  		autorest.WithBaseURL(client.BaseURI),
   105  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}", pathParameters),
   106  		autorest.WithJSON(parameters),
   107  		autorest.WithQueryParameters(queryParameters))
   108  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   109  }
   110  
   111  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   112  // http.Response Body if it receives an error.
   113  func (client ComputePoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
   114  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   115  }
   116  
   117  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   118  // closes the http.Response Body.
   119  func (client ComputePoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result ComputePolicy, err error) {
   120  	err = autorest.Respond(
   121  		resp,
   122  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   123  		autorest.ByUnmarshallingJSON(&result),
   124  		autorest.ByClosing())
   125  	result.Response = autorest.Response{Response: resp}
   126  	return
   127  }
   128  
   129  // Delete deletes the specified compute policy from the specified Data Lake Analytics account
   130  // Parameters:
   131  // resourceGroupName - the name of the Azure resource group.
   132  // accountName - the name of the Data Lake Analytics account.
   133  // computePolicyName - the name of the compute policy to delete.
   134  func (client ComputePoliciesClient) Delete(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string) (result autorest.Response, err error) {
   135  	if tracing.IsEnabled() {
   136  		ctx = tracing.StartSpan(ctx, fqdn+"/ComputePoliciesClient.Delete")
   137  		defer func() {
   138  			sc := -1
   139  			if result.Response != nil {
   140  				sc = result.Response.StatusCode
   141  			}
   142  			tracing.EndSpan(ctx, sc, err)
   143  		}()
   144  	}
   145  	req, err := client.DeletePreparer(ctx, resourceGroupName, accountName, computePolicyName)
   146  	if err != nil {
   147  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Delete", nil, "Failure preparing request")
   148  		return
   149  	}
   150  
   151  	resp, err := client.DeleteSender(req)
   152  	if err != nil {
   153  		result.Response = resp
   154  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Delete", resp, "Failure sending request")
   155  		return
   156  	}
   157  
   158  	result, err = client.DeleteResponder(resp)
   159  	if err != nil {
   160  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Delete", resp, "Failure responding to request")
   161  		return
   162  	}
   163  
   164  	return
   165  }
   166  
   167  // DeletePreparer prepares the Delete request.
   168  func (client ComputePoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string) (*http.Request, error) {
   169  	pathParameters := map[string]interface{}{
   170  		"accountName":       autorest.Encode("path", accountName),
   171  		"computePolicyName": autorest.Encode("path", computePolicyName),
   172  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   173  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   174  	}
   175  
   176  	const APIVersion = "2016-11-01"
   177  	queryParameters := map[string]interface{}{
   178  		"api-version": APIVersion,
   179  	}
   180  
   181  	preparer := autorest.CreatePreparer(
   182  		autorest.AsDelete(),
   183  		autorest.WithBaseURL(client.BaseURI),
   184  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}", pathParameters),
   185  		autorest.WithQueryParameters(queryParameters))
   186  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   187  }
   188  
   189  // DeleteSender sends the Delete request. The method will close the
   190  // http.Response Body if it receives an error.
   191  func (client ComputePoliciesClient) DeleteSender(req *http.Request) (*http.Response, error) {
   192  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   193  }
   194  
   195  // DeleteResponder handles the response to the Delete request. The method always
   196  // closes the http.Response Body.
   197  func (client ComputePoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   198  	err = autorest.Respond(
   199  		resp,
   200  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent),
   201  		autorest.ByClosing())
   202  	result.Response = resp
   203  	return
   204  }
   205  
   206  // Get gets the specified Data Lake Analytics compute policy.
   207  // Parameters:
   208  // resourceGroupName - the name of the Azure resource group.
   209  // accountName - the name of the Data Lake Analytics account.
   210  // computePolicyName - the name of the compute policy to retrieve.
   211  func (client ComputePoliciesClient) Get(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string) (result ComputePolicy, err error) {
   212  	if tracing.IsEnabled() {
   213  		ctx = tracing.StartSpan(ctx, fqdn+"/ComputePoliciesClient.Get")
   214  		defer func() {
   215  			sc := -1
   216  			if result.Response.Response != nil {
   217  				sc = result.Response.Response.StatusCode
   218  			}
   219  			tracing.EndSpan(ctx, sc, err)
   220  		}()
   221  	}
   222  	req, err := client.GetPreparer(ctx, resourceGroupName, accountName, computePolicyName)
   223  	if err != nil {
   224  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Get", nil, "Failure preparing request")
   225  		return
   226  	}
   227  
   228  	resp, err := client.GetSender(req)
   229  	if err != nil {
   230  		result.Response = autorest.Response{Response: resp}
   231  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Get", resp, "Failure sending request")
   232  		return
   233  	}
   234  
   235  	result, err = client.GetResponder(resp)
   236  	if err != nil {
   237  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Get", resp, "Failure responding to request")
   238  		return
   239  	}
   240  
   241  	return
   242  }
   243  
   244  // GetPreparer prepares the Get request.
   245  func (client ComputePoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string) (*http.Request, error) {
   246  	pathParameters := map[string]interface{}{
   247  		"accountName":       autorest.Encode("path", accountName),
   248  		"computePolicyName": autorest.Encode("path", computePolicyName),
   249  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   250  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   251  	}
   252  
   253  	const APIVersion = "2016-11-01"
   254  	queryParameters := map[string]interface{}{
   255  		"api-version": APIVersion,
   256  	}
   257  
   258  	preparer := autorest.CreatePreparer(
   259  		autorest.AsGet(),
   260  		autorest.WithBaseURL(client.BaseURI),
   261  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}", pathParameters),
   262  		autorest.WithQueryParameters(queryParameters))
   263  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   264  }
   265  
   266  // GetSender sends the Get request. The method will close the
   267  // http.Response Body if it receives an error.
   268  func (client ComputePoliciesClient) GetSender(req *http.Request) (*http.Response, error) {
   269  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   270  }
   271  
   272  // GetResponder handles the response to the Get request. The method always
   273  // closes the http.Response Body.
   274  func (client ComputePoliciesClient) GetResponder(resp *http.Response) (result ComputePolicy, err error) {
   275  	err = autorest.Respond(
   276  		resp,
   277  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   278  		autorest.ByUnmarshallingJSON(&result),
   279  		autorest.ByClosing())
   280  	result.Response = autorest.Response{Response: resp}
   281  	return
   282  }
   283  
   284  // ListByAccount lists the Data Lake Analytics compute policies within the specified Data Lake Analytics account. An
   285  // account supports, at most, 50 policies
   286  // Parameters:
   287  // resourceGroupName - the name of the Azure resource group.
   288  // accountName - the name of the Data Lake Analytics account.
   289  func (client ComputePoliciesClient) ListByAccount(ctx context.Context, resourceGroupName string, accountName string) (result ComputePolicyListResultPage, err error) {
   290  	if tracing.IsEnabled() {
   291  		ctx = tracing.StartSpan(ctx, fqdn+"/ComputePoliciesClient.ListByAccount")
   292  		defer func() {
   293  			sc := -1
   294  			if result.cplr.Response.Response != nil {
   295  				sc = result.cplr.Response.Response.StatusCode
   296  			}
   297  			tracing.EndSpan(ctx, sc, err)
   298  		}()
   299  	}
   300  	result.fn = client.listByAccountNextResults
   301  	req, err := client.ListByAccountPreparer(ctx, resourceGroupName, accountName)
   302  	if err != nil {
   303  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "ListByAccount", nil, "Failure preparing request")
   304  		return
   305  	}
   306  
   307  	resp, err := client.ListByAccountSender(req)
   308  	if err != nil {
   309  		result.cplr.Response = autorest.Response{Response: resp}
   310  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "ListByAccount", resp, "Failure sending request")
   311  		return
   312  	}
   313  
   314  	result.cplr, err = client.ListByAccountResponder(resp)
   315  	if err != nil {
   316  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "ListByAccount", resp, "Failure responding to request")
   317  		return
   318  	}
   319  	if result.cplr.hasNextLink() && result.cplr.IsEmpty() {
   320  		err = result.NextWithContext(ctx)
   321  		return
   322  	}
   323  
   324  	return
   325  }
   326  
   327  // ListByAccountPreparer prepares the ListByAccount request.
   328  func (client ComputePoliciesClient) ListByAccountPreparer(ctx context.Context, resourceGroupName string, accountName string) (*http.Request, error) {
   329  	pathParameters := map[string]interface{}{
   330  		"accountName":       autorest.Encode("path", accountName),
   331  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   332  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   333  	}
   334  
   335  	const APIVersion = "2016-11-01"
   336  	queryParameters := map[string]interface{}{
   337  		"api-version": APIVersion,
   338  	}
   339  
   340  	preparer := autorest.CreatePreparer(
   341  		autorest.AsGet(),
   342  		autorest.WithBaseURL(client.BaseURI),
   343  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies", pathParameters),
   344  		autorest.WithQueryParameters(queryParameters))
   345  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   346  }
   347  
   348  // ListByAccountSender sends the ListByAccount request. The method will close the
   349  // http.Response Body if it receives an error.
   350  func (client ComputePoliciesClient) ListByAccountSender(req *http.Request) (*http.Response, error) {
   351  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   352  }
   353  
   354  // ListByAccountResponder handles the response to the ListByAccount request. The method always
   355  // closes the http.Response Body.
   356  func (client ComputePoliciesClient) ListByAccountResponder(resp *http.Response) (result ComputePolicyListResult, err error) {
   357  	err = autorest.Respond(
   358  		resp,
   359  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   360  		autorest.ByUnmarshallingJSON(&result),
   361  		autorest.ByClosing())
   362  	result.Response = autorest.Response{Response: resp}
   363  	return
   364  }
   365  
   366  // listByAccountNextResults retrieves the next set of results, if any.
   367  func (client ComputePoliciesClient) listByAccountNextResults(ctx context.Context, lastResults ComputePolicyListResult) (result ComputePolicyListResult, err error) {
   368  	req, err := lastResults.computePolicyListResultPreparer(ctx)
   369  	if err != nil {
   370  		return result, autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "listByAccountNextResults", nil, "Failure preparing next results request")
   371  	}
   372  	if req == nil {
   373  		return
   374  	}
   375  	resp, err := client.ListByAccountSender(req)
   376  	if err != nil {
   377  		result.Response = autorest.Response{Response: resp}
   378  		return result, autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "listByAccountNextResults", resp, "Failure sending next results request")
   379  	}
   380  	result, err = client.ListByAccountResponder(resp)
   381  	if err != nil {
   382  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "listByAccountNextResults", resp, "Failure responding to next results request")
   383  	}
   384  	return
   385  }
   386  
   387  // ListByAccountComplete enumerates all values, automatically crossing page boundaries as required.
   388  func (client ComputePoliciesClient) ListByAccountComplete(ctx context.Context, resourceGroupName string, accountName string) (result ComputePolicyListResultIterator, err error) {
   389  	if tracing.IsEnabled() {
   390  		ctx = tracing.StartSpan(ctx, fqdn+"/ComputePoliciesClient.ListByAccount")
   391  		defer func() {
   392  			sc := -1
   393  			if result.Response().Response.Response != nil {
   394  				sc = result.page.Response().Response.Response.StatusCode
   395  			}
   396  			tracing.EndSpan(ctx, sc, err)
   397  		}()
   398  	}
   399  	result.page, err = client.ListByAccount(ctx, resourceGroupName, accountName)
   400  	return
   401  }
   402  
   403  // Update updates the specified compute policy.
   404  // Parameters:
   405  // resourceGroupName - the name of the Azure resource group.
   406  // accountName - the name of the Data Lake Analytics account.
   407  // computePolicyName - the name of the compute policy to update.
   408  // parameters - parameters supplied to update the compute policy.
   409  func (client ComputePoliciesClient) Update(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, parameters *UpdateComputePolicyParameters) (result ComputePolicy, err error) {
   410  	if tracing.IsEnabled() {
   411  		ctx = tracing.StartSpan(ctx, fqdn+"/ComputePoliciesClient.Update")
   412  		defer func() {
   413  			sc := -1
   414  			if result.Response.Response != nil {
   415  				sc = result.Response.Response.StatusCode
   416  			}
   417  			tracing.EndSpan(ctx, sc, err)
   418  		}()
   419  	}
   420  	req, err := client.UpdatePreparer(ctx, resourceGroupName, accountName, computePolicyName, parameters)
   421  	if err != nil {
   422  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Update", nil, "Failure preparing request")
   423  		return
   424  	}
   425  
   426  	resp, err := client.UpdateSender(req)
   427  	if err != nil {
   428  		result.Response = autorest.Response{Response: resp}
   429  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Update", resp, "Failure sending request")
   430  		return
   431  	}
   432  
   433  	result, err = client.UpdateResponder(resp)
   434  	if err != nil {
   435  		err = autorest.NewErrorWithError(err, "account.ComputePoliciesClient", "Update", resp, "Failure responding to request")
   436  		return
   437  	}
   438  
   439  	return
   440  }
   441  
   442  // UpdatePreparer prepares the Update request.
   443  func (client ComputePoliciesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, accountName string, computePolicyName string, parameters *UpdateComputePolicyParameters) (*http.Request, error) {
   444  	pathParameters := map[string]interface{}{
   445  		"accountName":       autorest.Encode("path", accountName),
   446  		"computePolicyName": autorest.Encode("path", computePolicyName),
   447  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   448  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   449  	}
   450  
   451  	const APIVersion = "2016-11-01"
   452  	queryParameters := map[string]interface{}{
   453  		"api-version": APIVersion,
   454  	}
   455  
   456  	preparer := autorest.CreatePreparer(
   457  		autorest.AsContentType("application/json; charset=utf-8"),
   458  		autorest.AsPatch(),
   459  		autorest.WithBaseURL(client.BaseURI),
   460  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}", pathParameters),
   461  		autorest.WithQueryParameters(queryParameters))
   462  	if parameters != nil {
   463  		preparer = autorest.DecoratePreparer(preparer,
   464  			autorest.WithJSON(parameters))
   465  	}
   466  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   467  }
   468  
   469  // UpdateSender sends the Update request. The method will close the
   470  // http.Response Body if it receives an error.
   471  func (client ComputePoliciesClient) UpdateSender(req *http.Request) (*http.Response, error) {
   472  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   473  }
   474  
   475  // UpdateResponder handles the response to the Update request. The method always
   476  // closes the http.Response Body.
   477  func (client ComputePoliciesClient) UpdateResponder(resp *http.Response) (result ComputePolicy, err error) {
   478  	err = autorest.Respond(
   479  		resp,
   480  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   481  		autorest.ByUnmarshallingJSON(&result),
   482  		autorest.ByClosing())
   483  	result.Response = autorest.Response{Response: resp}
   484  	return
   485  }
   486
View as plain text