dataset.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/synapse/2019-06-01-preview/artifacts

     1  package artifacts
     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  // DatasetClient is the client for the Dataset methods of the Artifacts service.
    19  type DatasetClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewDatasetClient creates an instance of the DatasetClient client.
    24  func NewDatasetClient(endpoint string) DatasetClient {
    25  	return DatasetClient{New(endpoint)}
    26  }
    27  
    28  // CreateOrUpdateDataset creates or updates a dataset.
    29  // Parameters:
    30  // datasetName - the dataset name.
    31  // dataset - dataset resource definition.
    32  // ifMatch - eTag of the dataset entity.  Should only be specified for update, for which it should match
    33  // existing entity or can be * for unconditional update.
    34  func (client DatasetClient) CreateOrUpdateDataset(ctx context.Context, datasetName string, dataset DatasetResource, ifMatch string) (result DatasetCreateOrUpdateDatasetFuture, err error) {
    35  	if tracing.IsEnabled() {
    36  		ctx = tracing.StartSpan(ctx, fqdn+"/DatasetClient.CreateOrUpdateDataset")
    37  		defer func() {
    38  			sc := -1
    39  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    40  				sc = result.FutureAPI.Response().StatusCode
    41  			}
    42  			tracing.EndSpan(ctx, sc, err)
    43  		}()
    44  	}
    45  	if err := validation.Validate([]validation.Validation{
    46  		{TargetValue: datasetName,
    47  			Constraints: []validation.Constraint{{Target: "datasetName", Name: validation.MaxLength, Rule: 260, Chain: nil},
    48  				{Target: "datasetName", Name: validation.MinLength, Rule: 1, Chain: nil},
    49  				{Target: "datasetName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
    50  		return result, validation.NewError("artifacts.DatasetClient", "CreateOrUpdateDataset", err.Error())
    51  	}
    52  
    53  	req, err := client.CreateOrUpdateDatasetPreparer(ctx, datasetName, dataset, ifMatch)
    54  	if err != nil {
    55  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "CreateOrUpdateDataset", nil, "Failure preparing request")
    56  		return
    57  	}
    58  
    59  	result, err = client.CreateOrUpdateDatasetSender(req)
    60  	if err != nil {
    61  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "CreateOrUpdateDataset", nil, "Failure sending request")
    62  		return
    63  	}
    64  
    65  	return
    66  }
    67  
    68  // CreateOrUpdateDatasetPreparer prepares the CreateOrUpdateDataset request.
    69  func (client DatasetClient) CreateOrUpdateDatasetPreparer(ctx context.Context, datasetName string, dataset DatasetResource, ifMatch string) (*http.Request, error) {
    70  	urlParameters := map[string]interface{}{
    71  		"endpoint": client.Endpoint,
    72  	}
    73  
    74  	pathParameters := map[string]interface{}{
    75  		"datasetName": autorest.Encode("path", datasetName),
    76  	}
    77  
    78  	const APIVersion = "2019-06-01-preview"
    79  	queryParameters := map[string]interface{}{
    80  		"api-version": APIVersion,
    81  	}
    82  
    83  	preparer := autorest.CreatePreparer(
    84  		autorest.AsContentType("application/json; charset=utf-8"),
    85  		autorest.AsPut(),
    86  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
    87  		autorest.WithPathParameters("/datasets/{datasetName}", pathParameters),
    88  		autorest.WithJSON(dataset),
    89  		autorest.WithQueryParameters(queryParameters))
    90  	if len(ifMatch) > 0 {
    91  		preparer = autorest.DecoratePreparer(preparer,
    92  			autorest.WithHeader("If-Match", autorest.String(ifMatch)))
    93  	}
    94  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    95  }
    96  
    97  // CreateOrUpdateDatasetSender sends the CreateOrUpdateDataset request. The method will close the
    98  // http.Response Body if it receives an error.
    99  func (client DatasetClient) CreateOrUpdateDatasetSender(req *http.Request) (future DatasetCreateOrUpdateDatasetFuture, err error) {
   100  	var resp *http.Response
   101  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   102  	if err != nil {
   103  		return
   104  	}
   105  	var azf azure.Future
   106  	azf, err = azure.NewFutureFromResponse(resp)
   107  	future.FutureAPI = &azf
   108  	future.Result = future.result
   109  	return
   110  }
   111  
   112  // CreateOrUpdateDatasetResponder handles the response to the CreateOrUpdateDataset request. The method always
   113  // closes the http.Response Body.
   114  func (client DatasetClient) CreateOrUpdateDatasetResponder(resp *http.Response) (result DatasetResource, err error) {
   115  	err = autorest.Respond(
   116  		resp,
   117  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   118  		autorest.ByUnmarshallingJSON(&result),
   119  		autorest.ByClosing())
   120  	result.Response = autorest.Response{Response: resp}
   121  	return
   122  }
   123  
   124  // DeleteDataset deletes a dataset.
   125  // Parameters:
   126  // datasetName - the dataset name.
   127  func (client DatasetClient) DeleteDataset(ctx context.Context, datasetName string) (result DatasetDeleteDatasetFuture, err error) {
   128  	if tracing.IsEnabled() {
   129  		ctx = tracing.StartSpan(ctx, fqdn+"/DatasetClient.DeleteDataset")
   130  		defer func() {
   131  			sc := -1
   132  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   133  				sc = result.FutureAPI.Response().StatusCode
   134  			}
   135  			tracing.EndSpan(ctx, sc, err)
   136  		}()
   137  	}
   138  	if err := validation.Validate([]validation.Validation{
   139  		{TargetValue: datasetName,
   140  			Constraints: []validation.Constraint{{Target: "datasetName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   141  				{Target: "datasetName", Name: validation.MinLength, Rule: 1, Chain: nil},
   142  				{Target: "datasetName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   143  		return result, validation.NewError("artifacts.DatasetClient", "DeleteDataset", err.Error())
   144  	}
   145  
   146  	req, err := client.DeleteDatasetPreparer(ctx, datasetName)
   147  	if err != nil {
   148  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "DeleteDataset", nil, "Failure preparing request")
   149  		return
   150  	}
   151  
   152  	result, err = client.DeleteDatasetSender(req)
   153  	if err != nil {
   154  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "DeleteDataset", nil, "Failure sending request")
   155  		return
   156  	}
   157  
   158  	return
   159  }
   160  
   161  // DeleteDatasetPreparer prepares the DeleteDataset request.
   162  func (client DatasetClient) DeleteDatasetPreparer(ctx context.Context, datasetName string) (*http.Request, error) {
   163  	urlParameters := map[string]interface{}{
   164  		"endpoint": client.Endpoint,
   165  	}
   166  
   167  	pathParameters := map[string]interface{}{
   168  		"datasetName": autorest.Encode("path", datasetName),
   169  	}
   170  
   171  	const APIVersion = "2019-06-01-preview"
   172  	queryParameters := map[string]interface{}{
   173  		"api-version": APIVersion,
   174  	}
   175  
   176  	preparer := autorest.CreatePreparer(
   177  		autorest.AsDelete(),
   178  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   179  		autorest.WithPathParameters("/datasets/{datasetName}", pathParameters),
   180  		autorest.WithQueryParameters(queryParameters))
   181  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   182  }
   183  
   184  // DeleteDatasetSender sends the DeleteDataset request. The method will close the
   185  // http.Response Body if it receives an error.
   186  func (client DatasetClient) DeleteDatasetSender(req *http.Request) (future DatasetDeleteDatasetFuture, err error) {
   187  	var resp *http.Response
   188  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   189  	if err != nil {
   190  		return
   191  	}
   192  	var azf azure.Future
   193  	azf, err = azure.NewFutureFromResponse(resp)
   194  	future.FutureAPI = &azf
   195  	future.Result = future.result
   196  	return
   197  }
   198  
   199  // DeleteDatasetResponder handles the response to the DeleteDataset request. The method always
   200  // closes the http.Response Body.
   201  func (client DatasetClient) DeleteDatasetResponder(resp *http.Response) (result autorest.Response, err error) {
   202  	err = autorest.Respond(
   203  		resp,
   204  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   205  		autorest.ByClosing())
   206  	result.Response = resp
   207  	return
   208  }
   209  
   210  // GetDataset gets a dataset.
   211  // Parameters:
   212  // datasetName - the dataset name.
   213  // ifNoneMatch - eTag of the dataset entity. Should only be specified for get. If the ETag matches the existing
   214  // entity tag, or if * was provided, then no content will be returned.
   215  func (client DatasetClient) GetDataset(ctx context.Context, datasetName string, ifNoneMatch string) (result DatasetResource, err error) {
   216  	if tracing.IsEnabled() {
   217  		ctx = tracing.StartSpan(ctx, fqdn+"/DatasetClient.GetDataset")
   218  		defer func() {
   219  			sc := -1
   220  			if result.Response.Response != nil {
   221  				sc = result.Response.Response.StatusCode
   222  			}
   223  			tracing.EndSpan(ctx, sc, err)
   224  		}()
   225  	}
   226  	if err := validation.Validate([]validation.Validation{
   227  		{TargetValue: datasetName,
   228  			Constraints: []validation.Constraint{{Target: "datasetName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   229  				{Target: "datasetName", Name: validation.MinLength, Rule: 1, Chain: nil},
   230  				{Target: "datasetName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}}}); err != nil {
   231  		return result, validation.NewError("artifacts.DatasetClient", "GetDataset", err.Error())
   232  	}
   233  
   234  	req, err := client.GetDatasetPreparer(ctx, datasetName, ifNoneMatch)
   235  	if err != nil {
   236  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "GetDataset", nil, "Failure preparing request")
   237  		return
   238  	}
   239  
   240  	resp, err := client.GetDatasetSender(req)
   241  	if err != nil {
   242  		result.Response = autorest.Response{Response: resp}
   243  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "GetDataset", resp, "Failure sending request")
   244  		return
   245  	}
   246  
   247  	result, err = client.GetDatasetResponder(resp)
   248  	if err != nil {
   249  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "GetDataset", resp, "Failure responding to request")
   250  		return
   251  	}
   252  
   253  	return
   254  }
   255  
   256  // GetDatasetPreparer prepares the GetDataset request.
   257  func (client DatasetClient) GetDatasetPreparer(ctx context.Context, datasetName string, ifNoneMatch string) (*http.Request, error) {
   258  	urlParameters := map[string]interface{}{
   259  		"endpoint": client.Endpoint,
   260  	}
   261  
   262  	pathParameters := map[string]interface{}{
   263  		"datasetName": autorest.Encode("path", datasetName),
   264  	}
   265  
   266  	const APIVersion = "2019-06-01-preview"
   267  	queryParameters := map[string]interface{}{
   268  		"api-version": APIVersion,
   269  	}
   270  
   271  	preparer := autorest.CreatePreparer(
   272  		autorest.AsGet(),
   273  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   274  		autorest.WithPathParameters("/datasets/{datasetName}", pathParameters),
   275  		autorest.WithQueryParameters(queryParameters))
   276  	if len(ifNoneMatch) > 0 {
   277  		preparer = autorest.DecoratePreparer(preparer,
   278  			autorest.WithHeader("If-None-Match", autorest.String(ifNoneMatch)))
   279  	}
   280  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   281  }
   282  
   283  // GetDatasetSender sends the GetDataset request. The method will close the
   284  // http.Response Body if it receives an error.
   285  func (client DatasetClient) GetDatasetSender(req *http.Request) (*http.Response, error) {
   286  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   287  }
   288  
   289  // GetDatasetResponder handles the response to the GetDataset request. The method always
   290  // closes the http.Response Body.
   291  func (client DatasetClient) GetDatasetResponder(resp *http.Response) (result DatasetResource, err error) {
   292  	err = autorest.Respond(
   293  		resp,
   294  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNotModified),
   295  		autorest.ByUnmarshallingJSON(&result),
   296  		autorest.ByClosing())
   297  	result.Response = autorest.Response{Response: resp}
   298  	return
   299  }
   300  
   301  // GetDatasetsByWorkspace lists datasets.
   302  func (client DatasetClient) GetDatasetsByWorkspace(ctx context.Context) (result DatasetListResponsePage, err error) {
   303  	if tracing.IsEnabled() {
   304  		ctx = tracing.StartSpan(ctx, fqdn+"/DatasetClient.GetDatasetsByWorkspace")
   305  		defer func() {
   306  			sc := -1
   307  			if result.dlr.Response.Response != nil {
   308  				sc = result.dlr.Response.Response.StatusCode
   309  			}
   310  			tracing.EndSpan(ctx, sc, err)
   311  		}()
   312  	}
   313  	result.fn = client.getDatasetsByWorkspaceNextResults
   314  	req, err := client.GetDatasetsByWorkspacePreparer(ctx)
   315  	if err != nil {
   316  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "GetDatasetsByWorkspace", nil, "Failure preparing request")
   317  		return
   318  	}
   319  
   320  	resp, err := client.GetDatasetsByWorkspaceSender(req)
   321  	if err != nil {
   322  		result.dlr.Response = autorest.Response{Response: resp}
   323  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "GetDatasetsByWorkspace", resp, "Failure sending request")
   324  		return
   325  	}
   326  
   327  	result.dlr, err = client.GetDatasetsByWorkspaceResponder(resp)
   328  	if err != nil {
   329  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "GetDatasetsByWorkspace", resp, "Failure responding to request")
   330  		return
   331  	}
   332  	if result.dlr.hasNextLink() && result.dlr.IsEmpty() {
   333  		err = result.NextWithContext(ctx)
   334  		return
   335  	}
   336  
   337  	return
   338  }
   339  
   340  // GetDatasetsByWorkspacePreparer prepares the GetDatasetsByWorkspace request.
   341  func (client DatasetClient) GetDatasetsByWorkspacePreparer(ctx context.Context) (*http.Request, error) {
   342  	urlParameters := map[string]interface{}{
   343  		"endpoint": client.Endpoint,
   344  	}
   345  
   346  	const APIVersion = "2019-06-01-preview"
   347  	queryParameters := map[string]interface{}{
   348  		"api-version": APIVersion,
   349  	}
   350  
   351  	preparer := autorest.CreatePreparer(
   352  		autorest.AsGet(),
   353  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   354  		autorest.WithPath("/datasets"),
   355  		autorest.WithQueryParameters(queryParameters))
   356  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   357  }
   358  
   359  // GetDatasetsByWorkspaceSender sends the GetDatasetsByWorkspace request. The method will close the
   360  // http.Response Body if it receives an error.
   361  func (client DatasetClient) GetDatasetsByWorkspaceSender(req *http.Request) (*http.Response, error) {
   362  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   363  }
   364  
   365  // GetDatasetsByWorkspaceResponder handles the response to the GetDatasetsByWorkspace request. The method always
   366  // closes the http.Response Body.
   367  func (client DatasetClient) GetDatasetsByWorkspaceResponder(resp *http.Response) (result DatasetListResponse, err error) {
   368  	err = autorest.Respond(
   369  		resp,
   370  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   371  		autorest.ByUnmarshallingJSON(&result),
   372  		autorest.ByClosing())
   373  	result.Response = autorest.Response{Response: resp}
   374  	return
   375  }
   376  
   377  // getDatasetsByWorkspaceNextResults retrieves the next set of results, if any.
   378  func (client DatasetClient) getDatasetsByWorkspaceNextResults(ctx context.Context, lastResults DatasetListResponse) (result DatasetListResponse, err error) {
   379  	req, err := lastResults.datasetListResponsePreparer(ctx)
   380  	if err != nil {
   381  		return result, autorest.NewErrorWithError(err, "artifacts.DatasetClient", "getDatasetsByWorkspaceNextResults", nil, "Failure preparing next results request")
   382  	}
   383  	if req == nil {
   384  		return
   385  	}
   386  	resp, err := client.GetDatasetsByWorkspaceSender(req)
   387  	if err != nil {
   388  		result.Response = autorest.Response{Response: resp}
   389  		return result, autorest.NewErrorWithError(err, "artifacts.DatasetClient", "getDatasetsByWorkspaceNextResults", resp, "Failure sending next results request")
   390  	}
   391  	result, err = client.GetDatasetsByWorkspaceResponder(resp)
   392  	if err != nil {
   393  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "getDatasetsByWorkspaceNextResults", resp, "Failure responding to next results request")
   394  	}
   395  	return
   396  }
   397  
   398  // GetDatasetsByWorkspaceComplete enumerates all values, automatically crossing page boundaries as required.
   399  func (client DatasetClient) GetDatasetsByWorkspaceComplete(ctx context.Context) (result DatasetListResponseIterator, err error) {
   400  	if tracing.IsEnabled() {
   401  		ctx = tracing.StartSpan(ctx, fqdn+"/DatasetClient.GetDatasetsByWorkspace")
   402  		defer func() {
   403  			sc := -1
   404  			if result.Response().Response.Response != nil {
   405  				sc = result.page.Response().Response.Response.StatusCode
   406  			}
   407  			tracing.EndSpan(ctx, sc, err)
   408  		}()
   409  	}
   410  	result.page, err = client.GetDatasetsByWorkspace(ctx)
   411  	return
   412  }
   413  
   414  // RenameDataset renames a dataset.
   415  // Parameters:
   416  // datasetName - the dataset name.
   417  // request - proposed new name.
   418  func (client DatasetClient) RenameDataset(ctx context.Context, datasetName string, request RenameRequest) (result DatasetRenameDatasetFuture, err error) {
   419  	if tracing.IsEnabled() {
   420  		ctx = tracing.StartSpan(ctx, fqdn+"/DatasetClient.RenameDataset")
   421  		defer func() {
   422  			sc := -1
   423  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   424  				sc = result.FutureAPI.Response().StatusCode
   425  			}
   426  			tracing.EndSpan(ctx, sc, err)
   427  		}()
   428  	}
   429  	if err := validation.Validate([]validation.Validation{
   430  		{TargetValue: datasetName,
   431  			Constraints: []validation.Constraint{{Target: "datasetName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   432  				{Target: "datasetName", Name: validation.MinLength, Rule: 1, Chain: nil},
   433  				{Target: "datasetName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil}}},
   434  		{TargetValue: request,
   435  			Constraints: []validation.Constraint{{Target: "request.NewName", Name: validation.Null, Rule: false,
   436  				Chain: []validation.Constraint{{Target: "request.NewName", Name: validation.MaxLength, Rule: 260, Chain: nil},
   437  					{Target: "request.NewName", Name: validation.MinLength, Rule: 1, Chain: nil},
   438  					{Target: "request.NewName", Name: validation.Pattern, Rule: `^[A-Za-z0-9_][^<>*#.%&:\\+?/]*$`, Chain: nil},
   439  				}}}}}); err != nil {
   440  		return result, validation.NewError("artifacts.DatasetClient", "RenameDataset", err.Error())
   441  	}
   442  
   443  	req, err := client.RenameDatasetPreparer(ctx, datasetName, request)
   444  	if err != nil {
   445  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "RenameDataset", nil, "Failure preparing request")
   446  		return
   447  	}
   448  
   449  	result, err = client.RenameDatasetSender(req)
   450  	if err != nil {
   451  		err = autorest.NewErrorWithError(err, "artifacts.DatasetClient", "RenameDataset", nil, "Failure sending request")
   452  		return
   453  	}
   454  
   455  	return
   456  }
   457  
   458  // RenameDatasetPreparer prepares the RenameDataset request.
   459  func (client DatasetClient) RenameDatasetPreparer(ctx context.Context, datasetName string, request RenameRequest) (*http.Request, error) {
   460  	urlParameters := map[string]interface{}{
   461  		"endpoint": client.Endpoint,
   462  	}
   463  
   464  	pathParameters := map[string]interface{}{
   465  		"datasetName": autorest.Encode("path", datasetName),
   466  	}
   467  
   468  	const APIVersion = "2019-06-01-preview"
   469  	queryParameters := map[string]interface{}{
   470  		"api-version": APIVersion,
   471  	}
   472  
   473  	preparer := autorest.CreatePreparer(
   474  		autorest.AsContentType("application/json; charset=utf-8"),
   475  		autorest.AsPost(),
   476  		autorest.WithCustomBaseURL("{endpoint}", urlParameters),
   477  		autorest.WithPathParameters("/datasets/{datasetName}/rename", pathParameters),
   478  		autorest.WithJSON(request),
   479  		autorest.WithQueryParameters(queryParameters))
   480  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   481  }
   482  
   483  // RenameDatasetSender sends the RenameDataset request. The method will close the
   484  // http.Response Body if it receives an error.
   485  func (client DatasetClient) RenameDatasetSender(req *http.Request) (future DatasetRenameDatasetFuture, err error) {
   486  	var resp *http.Response
   487  	resp, err = client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   488  	if err != nil {
   489  		return
   490  	}
   491  	var azf azure.Future
   492  	azf, err = azure.NewFutureFromResponse(resp)
   493  	future.FutureAPI = &azf
   494  	future.Result = future.result
   495  	return
   496  }
   497  
   498  // RenameDatasetResponder handles the response to the RenameDataset request. The method always
   499  // closes the http.Response Body.
   500  func (client DatasetClient) RenameDatasetResponder(resp *http.Response) (result autorest.Response, err error) {
   501  	err = autorest.Respond(
   502  		resp,
   503  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   504  		autorest.ByClosing())
   505  	result.Response = resp
   506  	return
   507  }
   508
View as plain text