Source file src/github.com/Azure/azure-sdk-for-go/services/storsimple1200series/mgmt/2016-10-01/storsimple/backups.go

Documentation: github.com/Azure/azure-sdk-for-go/services/storsimple1200series/mgmt/2016-10-01/storsimple

     1  package storsimple
     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  // BackupsClient is the client for the Backups methods of the Storsimple service.
    19  type BackupsClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewBackupsClient creates an instance of the BackupsClient client.
    24  func NewBackupsClient(subscriptionID string) BackupsClient {
    25  	return NewBackupsClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewBackupsClientWithBaseURI creates an instance of the BackupsClient 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 NewBackupsClientWithBaseURI(baseURI string, subscriptionID string) BackupsClient {
    31  	return BackupsClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // Clone clones the given backup element to a new disk or share with given details.
    35  // Parameters:
    36  // deviceName - the device name.
    37  // backupName - the backup name.
    38  // elementName - the backup element name.
    39  // cloneRequest - the clone request.
    40  // resourceGroupName - the resource group name
    41  // managerName - the manager name
    42  func (client BackupsClient) Clone(ctx context.Context, deviceName string, backupName string, elementName string, cloneRequest CloneRequest, resourceGroupName string, managerName string) (result BackupsCloneFuture, err error) {
    43  	if tracing.IsEnabled() {
    44  		ctx = tracing.StartSpan(ctx, fqdn+"/BackupsClient.Clone")
    45  		defer func() {
    46  			sc := -1
    47  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    48  				sc = result.FutureAPI.Response().StatusCode
    49  			}
    50  			tracing.EndSpan(ctx, sc, err)
    51  		}()
    52  	}
    53  	if err := validation.Validate([]validation.Validation{
    54  		{TargetValue: cloneRequest,
    55  			Constraints: []validation.Constraint{{Target: "cloneRequest.CloneRequestProperties", Name: validation.Null, Rule: true,
    56  				Chain: []validation.Constraint{{Target: "cloneRequest.CloneRequestProperties.TargetDeviceID", Name: validation.Null, Rule: true, Chain: nil},
    57  					{Target: "cloneRequest.CloneRequestProperties.TargetAccessPointID", Name: validation.Null, Rule: true, Chain: nil},
    58  					{Target: "cloneRequest.CloneRequestProperties.NewEndpointName", Name: validation.Null, Rule: true, Chain: nil},
    59  					{Target: "cloneRequest.CloneRequestProperties.Share", Name: validation.Null, Rule: false,
    60  						Chain: []validation.Constraint{{Target: "cloneRequest.CloneRequestProperties.Share.FileShareProperties", Name: validation.Null, Rule: true,
    61  							Chain: []validation.Constraint{{Target: "cloneRequest.CloneRequestProperties.Share.FileShareProperties.AdminUser", Name: validation.Null, Rule: true, Chain: nil},
    62  								{Target: "cloneRequest.CloneRequestProperties.Share.FileShareProperties.ProvisionedCapacityInBytes", Name: validation.Null, Rule: true, Chain: nil},
    63  							}},
    64  						}},
    65  					{Target: "cloneRequest.CloneRequestProperties.Disk", Name: validation.Null, Rule: false,
    66  						Chain: []validation.Constraint{{Target: "cloneRequest.CloneRequestProperties.Disk.ISCSIDiskProperties", Name: validation.Null, Rule: true,
    67  							Chain: []validation.Constraint{{Target: "cloneRequest.CloneRequestProperties.Disk.ISCSIDiskProperties.AccessControlRecords", Name: validation.Null, Rule: true, Chain: nil},
    68  								{Target: "cloneRequest.CloneRequestProperties.Disk.ISCSIDiskProperties.ProvisionedCapacityInBytes", Name: validation.Null, Rule: true, Chain: nil},
    69  							}},
    70  						}},
    71  				}}}},
    72  		{TargetValue: managerName,
    73  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
    74  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
    75  		return result, validation.NewError("storsimple.BackupsClient", "Clone", err.Error())
    76  	}
    77  
    78  	req, err := client.ClonePreparer(ctx, deviceName, backupName, elementName, cloneRequest, resourceGroupName, managerName)
    79  	if err != nil {
    80  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "Clone", nil, "Failure preparing request")
    81  		return
    82  	}
    83  
    84  	result, err = client.CloneSender(req)
    85  	if err != nil {
    86  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "Clone", result.Response(), "Failure sending request")
    87  		return
    88  	}
    89  
    90  	return
    91  }
    92  
    93  // ClonePreparer prepares the Clone request.
    94  func (client BackupsClient) ClonePreparer(ctx context.Context, deviceName string, backupName string, elementName string, cloneRequest CloneRequest, resourceGroupName string, managerName string) (*http.Request, error) {
    95  	pathParameters := map[string]interface{}{
    96  		"backupName":        autorest.Encode("path", backupName),
    97  		"deviceName":        autorest.Encode("path", deviceName),
    98  		"elementName":       autorest.Encode("path", elementName),
    99  		"managerName":       autorest.Encode("path", managerName),
   100  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   101  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   102  	}
   103  
   104  	const APIVersion = "2016-10-01"
   105  	queryParameters := map[string]interface{}{
   106  		"api-version": APIVersion,
   107  	}
   108  
   109  	preparer := autorest.CreatePreparer(
   110  		autorest.AsContentType("application/json; charset=utf-8"),
   111  		autorest.AsPost(),
   112  		autorest.WithBaseURL(client.BaseURI),
   113  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/backups/{backupName}/elements/{elementName}/clone", pathParameters),
   114  		autorest.WithJSON(cloneRequest),
   115  		autorest.WithQueryParameters(queryParameters))
   116  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   117  }
   118  
   119  // CloneSender sends the Clone request. The method will close the
   120  // http.Response Body if it receives an error.
   121  func (client BackupsClient) CloneSender(req *http.Request) (future BackupsCloneFuture, err error) {
   122  	var resp *http.Response
   123  	future.FutureAPI = &azure.Future{}
   124  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   125  	if err != nil {
   126  		return
   127  	}
   128  	var azf azure.Future
   129  	azf, err = azure.NewFutureFromResponse(resp)
   130  	future.FutureAPI = &azf
   131  	future.Result = future.result
   132  	return
   133  }
   134  
   135  // CloneResponder handles the response to the Clone request. The method always
   136  // closes the http.Response Body.
   137  func (client BackupsClient) CloneResponder(resp *http.Response) (result autorest.Response, err error) {
   138  	err = autorest.Respond(
   139  		resp,
   140  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   141  		autorest.ByClosing())
   142  	result.Response = resp
   143  	return
   144  }
   145  
   146  // Delete deletes the backup.
   147  // Parameters:
   148  // deviceName - the device name.
   149  // backupName - the backup name.
   150  // resourceGroupName - the resource group name
   151  // managerName - the manager name
   152  func (client BackupsClient) Delete(ctx context.Context, deviceName string, backupName string, resourceGroupName string, managerName string) (result BackupsDeleteFuture, err error) {
   153  	if tracing.IsEnabled() {
   154  		ctx = tracing.StartSpan(ctx, fqdn+"/BackupsClient.Delete")
   155  		defer func() {
   156  			sc := -1
   157  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   158  				sc = result.FutureAPI.Response().StatusCode
   159  			}
   160  			tracing.EndSpan(ctx, sc, err)
   161  		}()
   162  	}
   163  	if err := validation.Validate([]validation.Validation{
   164  		{TargetValue: managerName,
   165  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   166  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   167  		return result, validation.NewError("storsimple.BackupsClient", "Delete", err.Error())
   168  	}
   169  
   170  	req, err := client.DeletePreparer(ctx, deviceName, backupName, resourceGroupName, managerName)
   171  	if err != nil {
   172  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "Delete", nil, "Failure preparing request")
   173  		return
   174  	}
   175  
   176  	result, err = client.DeleteSender(req)
   177  	if err != nil {
   178  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "Delete", result.Response(), "Failure sending request")
   179  		return
   180  	}
   181  
   182  	return
   183  }
   184  
   185  // DeletePreparer prepares the Delete request.
   186  func (client BackupsClient) DeletePreparer(ctx context.Context, deviceName string, backupName string, resourceGroupName string, managerName string) (*http.Request, error) {
   187  	pathParameters := map[string]interface{}{
   188  		"backupName":        autorest.Encode("path", backupName),
   189  		"deviceName":        autorest.Encode("path", deviceName),
   190  		"managerName":       autorest.Encode("path", managerName),
   191  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   192  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   193  	}
   194  
   195  	const APIVersion = "2016-10-01"
   196  	queryParameters := map[string]interface{}{
   197  		"api-version": APIVersion,
   198  	}
   199  
   200  	preparer := autorest.CreatePreparer(
   201  		autorest.AsDelete(),
   202  		autorest.WithBaseURL(client.BaseURI),
   203  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/backups/{backupName}", pathParameters),
   204  		autorest.WithQueryParameters(queryParameters))
   205  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   206  }
   207  
   208  // DeleteSender sends the Delete request. The method will close the
   209  // http.Response Body if it receives an error.
   210  func (client BackupsClient) DeleteSender(req *http.Request) (future BackupsDeleteFuture, err error) {
   211  	var resp *http.Response
   212  	future.FutureAPI = &azure.Future{}
   213  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   214  	if err != nil {
   215  		return
   216  	}
   217  	var azf azure.Future
   218  	azf, err = azure.NewFutureFromResponse(resp)
   219  	future.FutureAPI = &azf
   220  	future.Result = future.result
   221  	return
   222  }
   223  
   224  // DeleteResponder handles the response to the Delete request. The method always
   225  // closes the http.Response Body.
   226  func (client BackupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   227  	err = autorest.Respond(
   228  		resp,
   229  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   230  		autorest.ByClosing())
   231  	result.Response = resp
   232  	return
   233  }
   234  
   235  // ListByDevice retrieves all the backups in a device. Can be used to get the backups for failover also.
   236  // Parameters:
   237  // deviceName - the device name.
   238  // resourceGroupName - the resource group name
   239  // managerName - the manager name
   240  // forFailover - set to true if you need backups which can be used for failover.
   241  // filter - oData Filter options
   242  func (client BackupsClient) ListByDevice(ctx context.Context, deviceName string, resourceGroupName string, managerName string, forFailover *bool, filter string) (result BackupListPage, err error) {
   243  	if tracing.IsEnabled() {
   244  		ctx = tracing.StartSpan(ctx, fqdn+"/BackupsClient.ListByDevice")
   245  		defer func() {
   246  			sc := -1
   247  			if result.bl.Response.Response != nil {
   248  				sc = result.bl.Response.Response.StatusCode
   249  			}
   250  			tracing.EndSpan(ctx, sc, err)
   251  		}()
   252  	}
   253  	if err := validation.Validate([]validation.Validation{
   254  		{TargetValue: managerName,
   255  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   256  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   257  		return result, validation.NewError("storsimple.BackupsClient", "ListByDevice", err.Error())
   258  	}
   259  
   260  	result.fn = client.listByDeviceNextResults
   261  	req, err := client.ListByDevicePreparer(ctx, deviceName, resourceGroupName, managerName, forFailover, filter)
   262  	if err != nil {
   263  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "ListByDevice", nil, "Failure preparing request")
   264  		return
   265  	}
   266  
   267  	resp, err := client.ListByDeviceSender(req)
   268  	if err != nil {
   269  		result.bl.Response = autorest.Response{Response: resp}
   270  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "ListByDevice", resp, "Failure sending request")
   271  		return
   272  	}
   273  
   274  	result.bl, err = client.ListByDeviceResponder(resp)
   275  	if err != nil {
   276  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "ListByDevice", resp, "Failure responding to request")
   277  		return
   278  	}
   279  	if result.bl.hasNextLink() && result.bl.IsEmpty() {
   280  		err = result.NextWithContext(ctx)
   281  		return
   282  	}
   283  
   284  	return
   285  }
   286  
   287  // ListByDevicePreparer prepares the ListByDevice request.
   288  func (client BackupsClient) ListByDevicePreparer(ctx context.Context, deviceName string, resourceGroupName string, managerName string, forFailover *bool, filter string) (*http.Request, error) {
   289  	pathParameters := map[string]interface{}{
   290  		"deviceName":        autorest.Encode("path", deviceName),
   291  		"managerName":       autorest.Encode("path", managerName),
   292  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   293  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   294  	}
   295  
   296  	const APIVersion = "2016-10-01"
   297  	queryParameters := map[string]interface{}{
   298  		"api-version": APIVersion,
   299  	}
   300  	if forFailover != nil {
   301  		queryParameters["forFailover"] = autorest.Encode("query", *forFailover)
   302  	}
   303  	if len(filter) > 0 {
   304  		queryParameters["$filter"] = autorest.Encode("query", filter)
   305  	}
   306  
   307  	preparer := autorest.CreatePreparer(
   308  		autorest.AsGet(),
   309  		autorest.WithBaseURL(client.BaseURI),
   310  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/devices/{deviceName}/backups", pathParameters),
   311  		autorest.WithQueryParameters(queryParameters))
   312  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   313  }
   314  
   315  // ListByDeviceSender sends the ListByDevice request. The method will close the
   316  // http.Response Body if it receives an error.
   317  func (client BackupsClient) ListByDeviceSender(req *http.Request) (*http.Response, error) {
   318  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   319  }
   320  
   321  // ListByDeviceResponder handles the response to the ListByDevice request. The method always
   322  // closes the http.Response Body.
   323  func (client BackupsClient) ListByDeviceResponder(resp *http.Response) (result BackupList, err error) {
   324  	err = autorest.Respond(
   325  		resp,
   326  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   327  		autorest.ByUnmarshallingJSON(&result),
   328  		autorest.ByClosing())
   329  	result.Response = autorest.Response{Response: resp}
   330  	return
   331  }
   332  
   333  // listByDeviceNextResults retrieves the next set of results, if any.
   334  func (client BackupsClient) listByDeviceNextResults(ctx context.Context, lastResults BackupList) (result BackupList, err error) {
   335  	req, err := lastResults.backupListPreparer(ctx)
   336  	if err != nil {
   337  		return result, autorest.NewErrorWithError(err, "storsimple.BackupsClient", "listByDeviceNextResults", nil, "Failure preparing next results request")
   338  	}
   339  	if req == nil {
   340  		return
   341  	}
   342  	resp, err := client.ListByDeviceSender(req)
   343  	if err != nil {
   344  		result.Response = autorest.Response{Response: resp}
   345  		return result, autorest.NewErrorWithError(err, "storsimple.BackupsClient", "listByDeviceNextResults", resp, "Failure sending next results request")
   346  	}
   347  	result, err = client.ListByDeviceResponder(resp)
   348  	if err != nil {
   349  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "listByDeviceNextResults", resp, "Failure responding to next results request")
   350  	}
   351  	return
   352  }
   353  
   354  // ListByDeviceComplete enumerates all values, automatically crossing page boundaries as required.
   355  func (client BackupsClient) ListByDeviceComplete(ctx context.Context, deviceName string, resourceGroupName string, managerName string, forFailover *bool, filter string) (result BackupListIterator, err error) {
   356  	if tracing.IsEnabled() {
   357  		ctx = tracing.StartSpan(ctx, fqdn+"/BackupsClient.ListByDevice")
   358  		defer func() {
   359  			sc := -1
   360  			if result.Response().Response.Response != nil {
   361  				sc = result.page.Response().Response.Response.StatusCode
   362  			}
   363  			tracing.EndSpan(ctx, sc, err)
   364  		}()
   365  	}
   366  	result.page, err = client.ListByDevice(ctx, deviceName, resourceGroupName, managerName, forFailover, filter)
   367  	return
   368  }
   369  
   370  // ListByManager retrieves all the backups in a manager.
   371  // Parameters:
   372  // resourceGroupName - the resource group name
   373  // managerName - the manager name
   374  // filter - oData Filter options
   375  func (client BackupsClient) ListByManager(ctx context.Context, resourceGroupName string, managerName string, filter string) (result BackupListPage, err error) {
   376  	if tracing.IsEnabled() {
   377  		ctx = tracing.StartSpan(ctx, fqdn+"/BackupsClient.ListByManager")
   378  		defer func() {
   379  			sc := -1
   380  			if result.bl.Response.Response != nil {
   381  				sc = result.bl.Response.Response.StatusCode
   382  			}
   383  			tracing.EndSpan(ctx, sc, err)
   384  		}()
   385  	}
   386  	if err := validation.Validate([]validation.Validation{
   387  		{TargetValue: managerName,
   388  			Constraints: []validation.Constraint{{Target: "managerName", Name: validation.MaxLength, Rule: 50, Chain: nil},
   389  				{Target: "managerName", Name: validation.MinLength, Rule: 2, Chain: nil}}}}); err != nil {
   390  		return result, validation.NewError("storsimple.BackupsClient", "ListByManager", err.Error())
   391  	}
   392  
   393  	result.fn = client.listByManagerNextResults
   394  	req, err := client.ListByManagerPreparer(ctx, resourceGroupName, managerName, filter)
   395  	if err != nil {
   396  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "ListByManager", nil, "Failure preparing request")
   397  		return
   398  	}
   399  
   400  	resp, err := client.ListByManagerSender(req)
   401  	if err != nil {
   402  		result.bl.Response = autorest.Response{Response: resp}
   403  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "ListByManager", resp, "Failure sending request")
   404  		return
   405  	}
   406  
   407  	result.bl, err = client.ListByManagerResponder(resp)
   408  	if err != nil {
   409  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "ListByManager", resp, "Failure responding to request")
   410  		return
   411  	}
   412  	if result.bl.hasNextLink() && result.bl.IsEmpty() {
   413  		err = result.NextWithContext(ctx)
   414  		return
   415  	}
   416  
   417  	return
   418  }
   419  
   420  // ListByManagerPreparer prepares the ListByManager request.
   421  func (client BackupsClient) ListByManagerPreparer(ctx context.Context, resourceGroupName string, managerName string, filter string) (*http.Request, error) {
   422  	pathParameters := map[string]interface{}{
   423  		"managerName":       autorest.Encode("path", managerName),
   424  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   425  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   426  	}
   427  
   428  	const APIVersion = "2016-10-01"
   429  	queryParameters := map[string]interface{}{
   430  		"api-version": APIVersion,
   431  	}
   432  	if len(filter) > 0 {
   433  		queryParameters["$filter"] = autorest.Encode("query", filter)
   434  	}
   435  
   436  	preparer := autorest.CreatePreparer(
   437  		autorest.AsGet(),
   438  		autorest.WithBaseURL(client.BaseURI),
   439  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.StorSimple/managers/{managerName}/backups", pathParameters),
   440  		autorest.WithQueryParameters(queryParameters))
   441  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   442  }
   443  
   444  // ListByManagerSender sends the ListByManager request. The method will close the
   445  // http.Response Body if it receives an error.
   446  func (client BackupsClient) ListByManagerSender(req *http.Request) (*http.Response, error) {
   447  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   448  }
   449  
   450  // ListByManagerResponder handles the response to the ListByManager request. The method always
   451  // closes the http.Response Body.
   452  func (client BackupsClient) ListByManagerResponder(resp *http.Response) (result BackupList, err error) {
   453  	err = autorest.Respond(
   454  		resp,
   455  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   456  		autorest.ByUnmarshallingJSON(&result),
   457  		autorest.ByClosing())
   458  	result.Response = autorest.Response{Response: resp}
   459  	return
   460  }
   461  
   462  // listByManagerNextResults retrieves the next set of results, if any.
   463  func (client BackupsClient) listByManagerNextResults(ctx context.Context, lastResults BackupList) (result BackupList, err error) {
   464  	req, err := lastResults.backupListPreparer(ctx)
   465  	if err != nil {
   466  		return result, autorest.NewErrorWithError(err, "storsimple.BackupsClient", "listByManagerNextResults", nil, "Failure preparing next results request")
   467  	}
   468  	if req == nil {
   469  		return
   470  	}
   471  	resp, err := client.ListByManagerSender(req)
   472  	if err != nil {
   473  		result.Response = autorest.Response{Response: resp}
   474  		return result, autorest.NewErrorWithError(err, "storsimple.BackupsClient", "listByManagerNextResults", resp, "Failure sending next results request")
   475  	}
   476  	result, err = client.ListByManagerResponder(resp)
   477  	if err != nil {
   478  		err = autorest.NewErrorWithError(err, "storsimple.BackupsClient", "listByManagerNextResults", resp, "Failure responding to next results request")
   479  	}
   480  	return
   481  }
   482  
   483  // ListByManagerComplete enumerates all values, automatically crossing page boundaries as required.
   484  func (client BackupsClient) ListByManagerComplete(ctx context.Context, resourceGroupName string, managerName string, filter string) (result BackupListIterator, err error) {
   485  	if tracing.IsEnabled() {
   486  		ctx = tracing.StartSpan(ctx, fqdn+"/BackupsClient.ListByManager")
   487  		defer func() {
   488  			sc := -1
   489  			if result.Response().Response.Response != nil {
   490  				sc = result.page.Response().Response.Response.StatusCode
   491  			}
   492  			tracing.EndSpan(ctx, sc, err)
   493  		}()
   494  	}
   495  	result.page, err = client.ListByManager(ctx, resourceGroupName, managerName, filter)
   496  	return
   497  }
   498  

View as plain text