replicationpolicies.go

Documentation: github.com/Azure/azure-sdk-for-go/services/recoveryservices/mgmt/2018-01-10/siterecovery

     1  package siterecovery
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  //
     6  // Code generated by Microsoft (R) AutoRest Code Generator.
     7  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
     8  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/tracing"
    14  	"net/http"
    15  )
    16  
    17  // ReplicationPoliciesClient is the client for the ReplicationPolicies methods of the Siterecovery service.
    18  type ReplicationPoliciesClient struct {
    19  	BaseClient
    20  }
    21  
    22  // NewReplicationPoliciesClient creates an instance of the ReplicationPoliciesClient client.
    23  func NewReplicationPoliciesClient(subscriptionID string, resourceGroupName string, resourceName string) ReplicationPoliciesClient {
    24  	return NewReplicationPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID, resourceGroupName, resourceName)
    25  }
    26  
    27  // NewReplicationPoliciesClientWithBaseURI creates an instance of the ReplicationPoliciesClient client using a custom
    28  // endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
    29  // stack).
    30  func NewReplicationPoliciesClientWithBaseURI(baseURI string, subscriptionID string, resourceGroupName string, resourceName string) ReplicationPoliciesClient {
    31  	return ReplicationPoliciesClient{NewWithBaseURI(baseURI, subscriptionID, resourceGroupName, resourceName)}
    32  }
    33  
    34  // Create the operation to create a replication policy
    35  // Parameters:
    36  // policyName - replication policy name
    37  // input - create policy input
    38  func (client ReplicationPoliciesClient) Create(ctx context.Context, policyName string, input CreatePolicyInput) (result ReplicationPoliciesCreateFuture, err error) {
    39  	if tracing.IsEnabled() {
    40  		ctx = tracing.StartSpan(ctx, fqdn+"/ReplicationPoliciesClient.Create")
    41  		defer func() {
    42  			sc := -1
    43  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    44  				sc = result.FutureAPI.Response().StatusCode
    45  			}
    46  			tracing.EndSpan(ctx, sc, err)
    47  		}()
    48  	}
    49  	req, err := client.CreatePreparer(ctx, policyName, input)
    50  	if err != nil {
    51  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Create", nil, "Failure preparing request")
    52  		return
    53  	}
    54  
    55  	result, err = client.CreateSender(req)
    56  	if err != nil {
    57  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Create", result.Response(), "Failure sending request")
    58  		return
    59  	}
    60  
    61  	return
    62  }
    63  
    64  // CreatePreparer prepares the Create request.
    65  func (client ReplicationPoliciesClient) CreatePreparer(ctx context.Context, policyName string, input CreatePolicyInput) (*http.Request, error) {
    66  	pathParameters := map[string]interface{}{
    67  		"policyName":        autorest.Encode("path", policyName),
    68  		"resourceGroupName": autorest.Encode("path", client.ResourceGroupName),
    69  		"resourceName":      autorest.Encode("path", client.ResourceName),
    70  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    71  	}
    72  
    73  	const APIVersion = "2018-01-10"
    74  	queryParameters := map[string]interface{}{
    75  		"api-version": APIVersion,
    76  	}
    77  
    78  	preparer := autorest.CreatePreparer(
    79  		autorest.AsContentType("application/json; charset=utf-8"),
    80  		autorest.AsPut(),
    81  		autorest.WithBaseURL(client.BaseURI),
    82  		autorest.WithPathParameters("/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{resourceName}/replicationPolicies/{policyName}", pathParameters),
    83  		autorest.WithJSON(input),
    84  		autorest.WithQueryParameters(queryParameters))
    85  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    86  }
    87  
    88  // CreateSender sends the Create request. The method will close the
    89  // http.Response Body if it receives an error.
    90  func (client ReplicationPoliciesClient) CreateSender(req *http.Request) (future ReplicationPoliciesCreateFuture, err error) {
    91  	var resp *http.Response
    92  	future.FutureAPI = &azure.Future{}
    93  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
    94  	if err != nil {
    95  		return
    96  	}
    97  	var azf azure.Future
    98  	azf, err = azure.NewFutureFromResponse(resp)
    99  	future.FutureAPI = &azf
   100  	future.Result = future.result
   101  	return
   102  }
   103  
   104  // CreateResponder handles the response to the Create request. The method always
   105  // closes the http.Response Body.
   106  func (client ReplicationPoliciesClient) CreateResponder(resp *http.Response) (result Policy, err error) {
   107  	err = autorest.Respond(
   108  		resp,
   109  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   110  		autorest.ByUnmarshallingJSON(&result),
   111  		autorest.ByClosing())
   112  	result.Response = autorest.Response{Response: resp}
   113  	return
   114  }
   115  
   116  // Delete the operation to delete a replication policy.
   117  // Parameters:
   118  // policyName - replication policy name.
   119  func (client ReplicationPoliciesClient) Delete(ctx context.Context, policyName string) (result ReplicationPoliciesDeleteFuture, err error) {
   120  	if tracing.IsEnabled() {
   121  		ctx = tracing.StartSpan(ctx, fqdn+"/ReplicationPoliciesClient.Delete")
   122  		defer func() {
   123  			sc := -1
   124  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   125  				sc = result.FutureAPI.Response().StatusCode
   126  			}
   127  			tracing.EndSpan(ctx, sc, err)
   128  		}()
   129  	}
   130  	req, err := client.DeletePreparer(ctx, policyName)
   131  	if err != nil {
   132  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Delete", nil, "Failure preparing request")
   133  		return
   134  	}
   135  
   136  	result, err = client.DeleteSender(req)
   137  	if err != nil {
   138  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Delete", result.Response(), "Failure sending request")
   139  		return
   140  	}
   141  
   142  	return
   143  }
   144  
   145  // DeletePreparer prepares the Delete request.
   146  func (client ReplicationPoliciesClient) DeletePreparer(ctx context.Context, policyName string) (*http.Request, error) {
   147  	pathParameters := map[string]interface{}{
   148  		"policyName":        autorest.Encode("path", policyName),
   149  		"resourceGroupName": autorest.Encode("path", client.ResourceGroupName),
   150  		"resourceName":      autorest.Encode("path", client.ResourceName),
   151  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   152  	}
   153  
   154  	const APIVersion = "2018-01-10"
   155  	queryParameters := map[string]interface{}{
   156  		"api-version": APIVersion,
   157  	}
   158  
   159  	preparer := autorest.CreatePreparer(
   160  		autorest.AsDelete(),
   161  		autorest.WithBaseURL(client.BaseURI),
   162  		autorest.WithPathParameters("/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{resourceName}/replicationPolicies/{policyName}", pathParameters),
   163  		autorest.WithQueryParameters(queryParameters))
   164  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   165  }
   166  
   167  // DeleteSender sends the Delete request. The method will close the
   168  // http.Response Body if it receives an error.
   169  func (client ReplicationPoliciesClient) DeleteSender(req *http.Request) (future ReplicationPoliciesDeleteFuture, err error) {
   170  	var resp *http.Response
   171  	future.FutureAPI = &azure.Future{}
   172  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   173  	if err != nil {
   174  		return
   175  	}
   176  	var azf azure.Future
   177  	azf, err = azure.NewFutureFromResponse(resp)
   178  	future.FutureAPI = &azf
   179  	future.Result = future.result
   180  	return
   181  }
   182  
   183  // DeleteResponder handles the response to the Delete request. The method always
   184  // closes the http.Response Body.
   185  func (client ReplicationPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   186  	err = autorest.Respond(
   187  		resp,
   188  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   189  		autorest.ByClosing())
   190  	result.Response = resp
   191  	return
   192  }
   193  
   194  // Get gets the details of a replication policy.
   195  // Parameters:
   196  // policyName - replication policy name.
   197  func (client ReplicationPoliciesClient) Get(ctx context.Context, policyName string) (result Policy, err error) {
   198  	if tracing.IsEnabled() {
   199  		ctx = tracing.StartSpan(ctx, fqdn+"/ReplicationPoliciesClient.Get")
   200  		defer func() {
   201  			sc := -1
   202  			if result.Response.Response != nil {
   203  				sc = result.Response.Response.StatusCode
   204  			}
   205  			tracing.EndSpan(ctx, sc, err)
   206  		}()
   207  	}
   208  	req, err := client.GetPreparer(ctx, policyName)
   209  	if err != nil {
   210  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Get", nil, "Failure preparing request")
   211  		return
   212  	}
   213  
   214  	resp, err := client.GetSender(req)
   215  	if err != nil {
   216  		result.Response = autorest.Response{Response: resp}
   217  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Get", resp, "Failure sending request")
   218  		return
   219  	}
   220  
   221  	result, err = client.GetResponder(resp)
   222  	if err != nil {
   223  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Get", resp, "Failure responding to request")
   224  		return
   225  	}
   226  
   227  	return
   228  }
   229  
   230  // GetPreparer prepares the Get request.
   231  func (client ReplicationPoliciesClient) GetPreparer(ctx context.Context, policyName string) (*http.Request, error) {
   232  	pathParameters := map[string]interface{}{
   233  		"policyName":        autorest.Encode("path", policyName),
   234  		"resourceGroupName": autorest.Encode("path", client.ResourceGroupName),
   235  		"resourceName":      autorest.Encode("path", client.ResourceName),
   236  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   237  	}
   238  
   239  	const APIVersion = "2018-01-10"
   240  	queryParameters := map[string]interface{}{
   241  		"api-version": APIVersion,
   242  	}
   243  
   244  	preparer := autorest.CreatePreparer(
   245  		autorest.AsGet(),
   246  		autorest.WithBaseURL(client.BaseURI),
   247  		autorest.WithPathParameters("/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{resourceName}/replicationPolicies/{policyName}", pathParameters),
   248  		autorest.WithQueryParameters(queryParameters))
   249  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   250  }
   251  
   252  // GetSender sends the Get request. The method will close the
   253  // http.Response Body if it receives an error.
   254  func (client ReplicationPoliciesClient) GetSender(req *http.Request) (*http.Response, error) {
   255  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   256  }
   257  
   258  // GetResponder handles the response to the Get request. The method always
   259  // closes the http.Response Body.
   260  func (client ReplicationPoliciesClient) GetResponder(resp *http.Response) (result Policy, err error) {
   261  	err = autorest.Respond(
   262  		resp,
   263  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   264  		autorest.ByUnmarshallingJSON(&result),
   265  		autorest.ByClosing())
   266  	result.Response = autorest.Response{Response: resp}
   267  	return
   268  }
   269  
   270  // List lists the replication policies for a vault.
   271  func (client ReplicationPoliciesClient) List(ctx context.Context) (result PolicyCollectionPage, err error) {
   272  	if tracing.IsEnabled() {
   273  		ctx = tracing.StartSpan(ctx, fqdn+"/ReplicationPoliciesClient.List")
   274  		defer func() {
   275  			sc := -1
   276  			if result.pc.Response.Response != nil {
   277  				sc = result.pc.Response.Response.StatusCode
   278  			}
   279  			tracing.EndSpan(ctx, sc, err)
   280  		}()
   281  	}
   282  	result.fn = client.listNextResults
   283  	req, err := client.ListPreparer(ctx)
   284  	if err != nil {
   285  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "List", nil, "Failure preparing request")
   286  		return
   287  	}
   288  
   289  	resp, err := client.ListSender(req)
   290  	if err != nil {
   291  		result.pc.Response = autorest.Response{Response: resp}
   292  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "List", resp, "Failure sending request")
   293  		return
   294  	}
   295  
   296  	result.pc, err = client.ListResponder(resp)
   297  	if err != nil {
   298  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "List", resp, "Failure responding to request")
   299  		return
   300  	}
   301  	if result.pc.hasNextLink() && result.pc.IsEmpty() {
   302  		err = result.NextWithContext(ctx)
   303  		return
   304  	}
   305  
   306  	return
   307  }
   308  
   309  // ListPreparer prepares the List request.
   310  func (client ReplicationPoliciesClient) ListPreparer(ctx context.Context) (*http.Request, error) {
   311  	pathParameters := map[string]interface{}{
   312  		"resourceGroupName": autorest.Encode("path", client.ResourceGroupName),
   313  		"resourceName":      autorest.Encode("path", client.ResourceName),
   314  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   315  	}
   316  
   317  	const APIVersion = "2018-01-10"
   318  	queryParameters := map[string]interface{}{
   319  		"api-version": APIVersion,
   320  	}
   321  
   322  	preparer := autorest.CreatePreparer(
   323  		autorest.AsGet(),
   324  		autorest.WithBaseURL(client.BaseURI),
   325  		autorest.WithPathParameters("/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{resourceName}/replicationPolicies", pathParameters),
   326  		autorest.WithQueryParameters(queryParameters))
   327  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   328  }
   329  
   330  // ListSender sends the List request. The method will close the
   331  // http.Response Body if it receives an error.
   332  func (client ReplicationPoliciesClient) ListSender(req *http.Request) (*http.Response, error) {
   333  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   334  }
   335  
   336  // ListResponder handles the response to the List request. The method always
   337  // closes the http.Response Body.
   338  func (client ReplicationPoliciesClient) ListResponder(resp *http.Response) (result PolicyCollection, err error) {
   339  	err = autorest.Respond(
   340  		resp,
   341  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   342  		autorest.ByUnmarshallingJSON(&result),
   343  		autorest.ByClosing())
   344  	result.Response = autorest.Response{Response: resp}
   345  	return
   346  }
   347  
   348  // listNextResults retrieves the next set of results, if any.
   349  func (client ReplicationPoliciesClient) listNextResults(ctx context.Context, lastResults PolicyCollection) (result PolicyCollection, err error) {
   350  	req, err := lastResults.policyCollectionPreparer(ctx)
   351  	if err != nil {
   352  		return result, autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "listNextResults", nil, "Failure preparing next results request")
   353  	}
   354  	if req == nil {
   355  		return
   356  	}
   357  	resp, err := client.ListSender(req)
   358  	if err != nil {
   359  		result.Response = autorest.Response{Response: resp}
   360  		return result, autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "listNextResults", resp, "Failure sending next results request")
   361  	}
   362  	result, err = client.ListResponder(resp)
   363  	if err != nil {
   364  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "listNextResults", resp, "Failure responding to next results request")
   365  	}
   366  	return
   367  }
   368  
   369  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   370  func (client ReplicationPoliciesClient) ListComplete(ctx context.Context) (result PolicyCollectionIterator, err error) {
   371  	if tracing.IsEnabled() {
   372  		ctx = tracing.StartSpan(ctx, fqdn+"/ReplicationPoliciesClient.List")
   373  		defer func() {
   374  			sc := -1
   375  			if result.Response().Response.Response != nil {
   376  				sc = result.page.Response().Response.Response.StatusCode
   377  			}
   378  			tracing.EndSpan(ctx, sc, err)
   379  		}()
   380  	}
   381  	result.page, err = client.List(ctx)
   382  	return
   383  }
   384  
   385  // Update the operation to update a replication policy.
   386  // Parameters:
   387  // policyName - policy Id.
   388  // input - update Policy Input
   389  func (client ReplicationPoliciesClient) Update(ctx context.Context, policyName string, input UpdatePolicyInput) (result ReplicationPoliciesUpdateFuture, err error) {
   390  	if tracing.IsEnabled() {
   391  		ctx = tracing.StartSpan(ctx, fqdn+"/ReplicationPoliciesClient.Update")
   392  		defer func() {
   393  			sc := -1
   394  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   395  				sc = result.FutureAPI.Response().StatusCode
   396  			}
   397  			tracing.EndSpan(ctx, sc, err)
   398  		}()
   399  	}
   400  	req, err := client.UpdatePreparer(ctx, policyName, input)
   401  	if err != nil {
   402  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Update", nil, "Failure preparing request")
   403  		return
   404  	}
   405  
   406  	result, err = client.UpdateSender(req)
   407  	if err != nil {
   408  		err = autorest.NewErrorWithError(err, "siterecovery.ReplicationPoliciesClient", "Update", result.Response(), "Failure sending request")
   409  		return
   410  	}
   411  
   412  	return
   413  }
   414  
   415  // UpdatePreparer prepares the Update request.
   416  func (client ReplicationPoliciesClient) UpdatePreparer(ctx context.Context, policyName string, input UpdatePolicyInput) (*http.Request, error) {
   417  	pathParameters := map[string]interface{}{
   418  		"policyName":        autorest.Encode("path", policyName),
   419  		"resourceGroupName": autorest.Encode("path", client.ResourceGroupName),
   420  		"resourceName":      autorest.Encode("path", client.ResourceName),
   421  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   422  	}
   423  
   424  	const APIVersion = "2018-01-10"
   425  	queryParameters := map[string]interface{}{
   426  		"api-version": APIVersion,
   427  	}
   428  
   429  	preparer := autorest.CreatePreparer(
   430  		autorest.AsContentType("application/json; charset=utf-8"),
   431  		autorest.AsPatch(),
   432  		autorest.WithBaseURL(client.BaseURI),
   433  		autorest.WithPathParameters("/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{resourceName}/replicationPolicies/{policyName}", pathParameters),
   434  		autorest.WithJSON(input),
   435  		autorest.WithQueryParameters(queryParameters))
   436  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   437  }
   438  
   439  // UpdateSender sends the Update request. The method will close the
   440  // http.Response Body if it receives an error.
   441  func (client ReplicationPoliciesClient) UpdateSender(req *http.Request) (future ReplicationPoliciesUpdateFuture, err error) {
   442  	var resp *http.Response
   443  	future.FutureAPI = &azure.Future{}
   444  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   445  	if err != nil {
   446  		return
   447  	}
   448  	var azf azure.Future
   449  	azf, err = azure.NewFutureFromResponse(resp)
   450  	future.FutureAPI = &azf
   451  	future.Result = future.result
   452  	return
   453  }
   454  
   455  // UpdateResponder handles the response to the Update request. The method always
   456  // closes the http.Response Body.
   457  func (client ReplicationPoliciesClient) UpdateResponder(resp *http.Response) (result Policy, err error) {
   458  	err = autorest.Respond(
   459  		resp,
   460  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   461  		autorest.ByUnmarshallingJSON(&result),
   462  		autorest.ByClosing())
   463  	result.Response = autorest.Response{Response: resp}
   464  	return
   465  }
   466
View as plain text