Source file src/github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2022-05-15/documentdb/cassandradatacenters.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cosmos-db/mgmt/2022-05-15/documentdb

     1  package documentdb
     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  // CassandraDataCentersClient is the client for the CassandraDataCenters methods of the Documentdb service.
    19  type CassandraDataCentersClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewCassandraDataCentersClient creates an instance of the CassandraDataCentersClient client.
    24  func NewCassandraDataCentersClient(subscriptionID string) CassandraDataCentersClient {
    25  	return NewCassandraDataCentersClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewCassandraDataCentersClientWithBaseURI creates an instance of the CassandraDataCentersClient client using a custom
    29  // endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure
    30  // stack).
    31  func NewCassandraDataCentersClientWithBaseURI(baseURI string, subscriptionID string) CassandraDataCentersClient {
    32  	return CassandraDataCentersClient{NewWithBaseURI(baseURI, subscriptionID)}
    33  }
    34  
    35  // CreateUpdate create or update a managed Cassandra data center. When updating, overwrite all properties. To update
    36  // only some properties, use PATCH.
    37  // Parameters:
    38  // resourceGroupName - the name of the resource group. The name is case insensitive.
    39  // clusterName - managed Cassandra cluster name.
    40  // dataCenterName - data center name in a managed Cassandra cluster.
    41  // body - parameters specifying the managed Cassandra data center.
    42  func (client CassandraDataCentersClient) CreateUpdate(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string, body DataCenterResource) (result CassandraDataCentersCreateUpdateFuture, err error) {
    43  	if tracing.IsEnabled() {
    44  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraDataCentersClient.CreateUpdate")
    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: client.SubscriptionID,
    55  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
    56  		{TargetValue: resourceGroupName,
    57  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
    58  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
    59  		{TargetValue: clusterName,
    60  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
    61  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
    62  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}},
    63  		{TargetValue: dataCenterName,
    64  			Constraints: []validation.Constraint{{Target: "dataCenterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
    65  				{Target: "dataCenterName", Name: validation.MinLength, Rule: 1, Chain: nil},
    66  				{Target: "dataCenterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}}}); err != nil {
    67  		return result, validation.NewError("documentdb.CassandraDataCentersClient", "CreateUpdate", err.Error())
    68  	}
    69  
    70  	req, err := client.CreateUpdatePreparer(ctx, resourceGroupName, clusterName, dataCenterName, body)
    71  	if err != nil {
    72  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "CreateUpdate", nil, "Failure preparing request")
    73  		return
    74  	}
    75  
    76  	result, err = client.CreateUpdateSender(req)
    77  	if err != nil {
    78  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "CreateUpdate", result.Response(), "Failure sending request")
    79  		return
    80  	}
    81  
    82  	return
    83  }
    84  
    85  // CreateUpdatePreparer prepares the CreateUpdate request.
    86  func (client CassandraDataCentersClient) CreateUpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string, body DataCenterResource) (*http.Request, error) {
    87  	pathParameters := map[string]interface{}{
    88  		"clusterName":       autorest.Encode("path", clusterName),
    89  		"dataCenterName":    autorest.Encode("path", dataCenterName),
    90  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    91  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    92  	}
    93  
    94  	const APIVersion = "2022-05-15"
    95  	queryParameters := map[string]interface{}{
    96  		"api-version": APIVersion,
    97  	}
    98  
    99  	preparer := autorest.CreatePreparer(
   100  		autorest.AsContentType("application/json; charset=utf-8"),
   101  		autorest.AsPut(),
   102  		autorest.WithBaseURL(client.BaseURI),
   103  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/cassandraClusters/{clusterName}/dataCenters/{dataCenterName}", pathParameters),
   104  		autorest.WithJSON(body),
   105  		autorest.WithQueryParameters(queryParameters))
   106  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   107  }
   108  
   109  // CreateUpdateSender sends the CreateUpdate request. The method will close the
   110  // http.Response Body if it receives an error.
   111  func (client CassandraDataCentersClient) CreateUpdateSender(req *http.Request) (future CassandraDataCentersCreateUpdateFuture, err error) {
   112  	var resp *http.Response
   113  	future.FutureAPI = &azure.Future{}
   114  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   115  	if err != nil {
   116  		return
   117  	}
   118  	var azf azure.Future
   119  	azf, err = azure.NewFutureFromResponse(resp)
   120  	future.FutureAPI = &azf
   121  	future.Result = future.result
   122  	return
   123  }
   124  
   125  // CreateUpdateResponder handles the response to the CreateUpdate request. The method always
   126  // closes the http.Response Body.
   127  func (client CassandraDataCentersClient) CreateUpdateResponder(resp *http.Response) (result DataCenterResource, err error) {
   128  	err = autorest.Respond(
   129  		resp,
   130  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   131  		autorest.ByUnmarshallingJSON(&result),
   132  		autorest.ByClosing())
   133  	result.Response = autorest.Response{Response: resp}
   134  	return
   135  }
   136  
   137  // Delete delete a managed Cassandra data center.
   138  // Parameters:
   139  // resourceGroupName - the name of the resource group. The name is case insensitive.
   140  // clusterName - managed Cassandra cluster name.
   141  // dataCenterName - data center name in a managed Cassandra cluster.
   142  func (client CassandraDataCentersClient) Delete(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string) (result CassandraDataCentersDeleteFuture, err error) {
   143  	if tracing.IsEnabled() {
   144  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraDataCentersClient.Delete")
   145  		defer func() {
   146  			sc := -1
   147  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   148  				sc = result.FutureAPI.Response().StatusCode
   149  			}
   150  			tracing.EndSpan(ctx, sc, err)
   151  		}()
   152  	}
   153  	if err := validation.Validate([]validation.Validation{
   154  		{TargetValue: client.SubscriptionID,
   155  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   156  		{TargetValue: resourceGroupName,
   157  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   158  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   159  		{TargetValue: clusterName,
   160  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   161  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   162  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}},
   163  		{TargetValue: dataCenterName,
   164  			Constraints: []validation.Constraint{{Target: "dataCenterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   165  				{Target: "dataCenterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   166  				{Target: "dataCenterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}}}); err != nil {
   167  		return result, validation.NewError("documentdb.CassandraDataCentersClient", "Delete", err.Error())
   168  	}
   169  
   170  	req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName, dataCenterName)
   171  	if err != nil {
   172  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Delete", nil, "Failure preparing request")
   173  		return
   174  	}
   175  
   176  	result, err = client.DeleteSender(req)
   177  	if err != nil {
   178  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Delete", result.Response(), "Failure sending request")
   179  		return
   180  	}
   181  
   182  	return
   183  }
   184  
   185  // DeletePreparer prepares the Delete request.
   186  func (client CassandraDataCentersClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string) (*http.Request, error) {
   187  	pathParameters := map[string]interface{}{
   188  		"clusterName":       autorest.Encode("path", clusterName),
   189  		"dataCenterName":    autorest.Encode("path", dataCenterName),
   190  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   191  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   192  	}
   193  
   194  	const APIVersion = "2022-05-15"
   195  	queryParameters := map[string]interface{}{
   196  		"api-version": APIVersion,
   197  	}
   198  
   199  	preparer := autorest.CreatePreparer(
   200  		autorest.AsDelete(),
   201  		autorest.WithBaseURL(client.BaseURI),
   202  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/cassandraClusters/{clusterName}/dataCenters/{dataCenterName}", pathParameters),
   203  		autorest.WithQueryParameters(queryParameters))
   204  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   205  }
   206  
   207  // DeleteSender sends the Delete request. The method will close the
   208  // http.Response Body if it receives an error.
   209  func (client CassandraDataCentersClient) DeleteSender(req *http.Request) (future CassandraDataCentersDeleteFuture, err error) {
   210  	var resp *http.Response
   211  	future.FutureAPI = &azure.Future{}
   212  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   213  	if err != nil {
   214  		return
   215  	}
   216  	var azf azure.Future
   217  	azf, err = azure.NewFutureFromResponse(resp)
   218  	future.FutureAPI = &azf
   219  	future.Result = future.result
   220  	return
   221  }
   222  
   223  // DeleteResponder handles the response to the Delete request. The method always
   224  // closes the http.Response Body.
   225  func (client CassandraDataCentersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   226  	err = autorest.Respond(
   227  		resp,
   228  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   229  		autorest.ByClosing())
   230  	result.Response = resp
   231  	return
   232  }
   233  
   234  // Get get the properties of a managed Cassandra data center.
   235  // Parameters:
   236  // resourceGroupName - the name of the resource group. The name is case insensitive.
   237  // clusterName - managed Cassandra cluster name.
   238  // dataCenterName - data center name in a managed Cassandra cluster.
   239  func (client CassandraDataCentersClient) Get(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string) (result DataCenterResource, err error) {
   240  	if tracing.IsEnabled() {
   241  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraDataCentersClient.Get")
   242  		defer func() {
   243  			sc := -1
   244  			if result.Response.Response != nil {
   245  				sc = result.Response.Response.StatusCode
   246  			}
   247  			tracing.EndSpan(ctx, sc, err)
   248  		}()
   249  	}
   250  	if err := validation.Validate([]validation.Validation{
   251  		{TargetValue: client.SubscriptionID,
   252  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   253  		{TargetValue: resourceGroupName,
   254  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   255  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   256  		{TargetValue: clusterName,
   257  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   258  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   259  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}},
   260  		{TargetValue: dataCenterName,
   261  			Constraints: []validation.Constraint{{Target: "dataCenterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   262  				{Target: "dataCenterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   263  				{Target: "dataCenterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}}}); err != nil {
   264  		return result, validation.NewError("documentdb.CassandraDataCentersClient", "Get", err.Error())
   265  	}
   266  
   267  	req, err := client.GetPreparer(ctx, resourceGroupName, clusterName, dataCenterName)
   268  	if err != nil {
   269  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Get", nil, "Failure preparing request")
   270  		return
   271  	}
   272  
   273  	resp, err := client.GetSender(req)
   274  	if err != nil {
   275  		result.Response = autorest.Response{Response: resp}
   276  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Get", resp, "Failure sending request")
   277  		return
   278  	}
   279  
   280  	result, err = client.GetResponder(resp)
   281  	if err != nil {
   282  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Get", resp, "Failure responding to request")
   283  		return
   284  	}
   285  
   286  	return
   287  }
   288  
   289  // GetPreparer prepares the Get request.
   290  func (client CassandraDataCentersClient) GetPreparer(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string) (*http.Request, error) {
   291  	pathParameters := map[string]interface{}{
   292  		"clusterName":       autorest.Encode("path", clusterName),
   293  		"dataCenterName":    autorest.Encode("path", dataCenterName),
   294  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   295  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   296  	}
   297  
   298  	const APIVersion = "2022-05-15"
   299  	queryParameters := map[string]interface{}{
   300  		"api-version": APIVersion,
   301  	}
   302  
   303  	preparer := autorest.CreatePreparer(
   304  		autorest.AsGet(),
   305  		autorest.WithBaseURL(client.BaseURI),
   306  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/cassandraClusters/{clusterName}/dataCenters/{dataCenterName}", pathParameters),
   307  		autorest.WithQueryParameters(queryParameters))
   308  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   309  }
   310  
   311  // GetSender sends the Get request. The method will close the
   312  // http.Response Body if it receives an error.
   313  func (client CassandraDataCentersClient) GetSender(req *http.Request) (*http.Response, error) {
   314  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   315  }
   316  
   317  // GetResponder handles the response to the Get request. The method always
   318  // closes the http.Response Body.
   319  func (client CassandraDataCentersClient) GetResponder(resp *http.Response) (result DataCenterResource, err error) {
   320  	err = autorest.Respond(
   321  		resp,
   322  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   323  		autorest.ByUnmarshallingJSON(&result),
   324  		autorest.ByClosing())
   325  	result.Response = autorest.Response{Response: resp}
   326  	return
   327  }
   328  
   329  // List list all data centers in a particular managed Cassandra cluster.
   330  // Parameters:
   331  // resourceGroupName - the name of the resource group. The name is case insensitive.
   332  // clusterName - managed Cassandra cluster name.
   333  func (client CassandraDataCentersClient) List(ctx context.Context, resourceGroupName string, clusterName string) (result ListDataCenters, err error) {
   334  	if tracing.IsEnabled() {
   335  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraDataCentersClient.List")
   336  		defer func() {
   337  			sc := -1
   338  			if result.Response.Response != nil {
   339  				sc = result.Response.Response.StatusCode
   340  			}
   341  			tracing.EndSpan(ctx, sc, err)
   342  		}()
   343  	}
   344  	if err := validation.Validate([]validation.Validation{
   345  		{TargetValue: client.SubscriptionID,
   346  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   347  		{TargetValue: resourceGroupName,
   348  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   349  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   350  		{TargetValue: clusterName,
   351  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   352  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   353  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}}}); err != nil {
   354  		return result, validation.NewError("documentdb.CassandraDataCentersClient", "List", err.Error())
   355  	}
   356  
   357  	req, err := client.ListPreparer(ctx, resourceGroupName, clusterName)
   358  	if err != nil {
   359  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "List", nil, "Failure preparing request")
   360  		return
   361  	}
   362  
   363  	resp, err := client.ListSender(req)
   364  	if err != nil {
   365  		result.Response = autorest.Response{Response: resp}
   366  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "List", resp, "Failure sending request")
   367  		return
   368  	}
   369  
   370  	result, err = client.ListResponder(resp)
   371  	if err != nil {
   372  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "List", resp, "Failure responding to request")
   373  		return
   374  	}
   375  
   376  	return
   377  }
   378  
   379  // ListPreparer prepares the List request.
   380  func (client CassandraDataCentersClient) ListPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) {
   381  	pathParameters := map[string]interface{}{
   382  		"clusterName":       autorest.Encode("path", clusterName),
   383  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   384  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   385  	}
   386  
   387  	const APIVersion = "2022-05-15"
   388  	queryParameters := map[string]interface{}{
   389  		"api-version": APIVersion,
   390  	}
   391  
   392  	preparer := autorest.CreatePreparer(
   393  		autorest.AsGet(),
   394  		autorest.WithBaseURL(client.BaseURI),
   395  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/cassandraClusters/{clusterName}/dataCenters", pathParameters),
   396  		autorest.WithQueryParameters(queryParameters))
   397  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   398  }
   399  
   400  // ListSender sends the List request. The method will close the
   401  // http.Response Body if it receives an error.
   402  func (client CassandraDataCentersClient) ListSender(req *http.Request) (*http.Response, error) {
   403  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   404  }
   405  
   406  // ListResponder handles the response to the List request. The method always
   407  // closes the http.Response Body.
   408  func (client CassandraDataCentersClient) ListResponder(resp *http.Response) (result ListDataCenters, err error) {
   409  	err = autorest.Respond(
   410  		resp,
   411  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   412  		autorest.ByUnmarshallingJSON(&result),
   413  		autorest.ByClosing())
   414  	result.Response = autorest.Response{Response: resp}
   415  	return
   416  }
   417  
   418  // Update update some of the properties of a managed Cassandra data center.
   419  // Parameters:
   420  // resourceGroupName - the name of the resource group. The name is case insensitive.
   421  // clusterName - managed Cassandra cluster name.
   422  // dataCenterName - data center name in a managed Cassandra cluster.
   423  // body - parameters to provide for specifying the managed Cassandra data center.
   424  func (client CassandraDataCentersClient) Update(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string, body DataCenterResource) (result CassandraDataCentersUpdateFuture, err error) {
   425  	if tracing.IsEnabled() {
   426  		ctx = tracing.StartSpan(ctx, fqdn+"/CassandraDataCentersClient.Update")
   427  		defer func() {
   428  			sc := -1
   429  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   430  				sc = result.FutureAPI.Response().StatusCode
   431  			}
   432  			tracing.EndSpan(ctx, sc, err)
   433  		}()
   434  	}
   435  	if err := validation.Validate([]validation.Validation{
   436  		{TargetValue: client.SubscriptionID,
   437  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   438  		{TargetValue: resourceGroupName,
   439  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   440  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   441  		{TargetValue: clusterName,
   442  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   443  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   444  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}},
   445  		{TargetValue: dataCenterName,
   446  			Constraints: []validation.Constraint{{Target: "dataCenterName", Name: validation.MaxLength, Rule: 100, Chain: nil},
   447  				{Target: "dataCenterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   448  				{Target: "dataCenterName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*$`, Chain: nil}}}}); err != nil {
   449  		return result, validation.NewError("documentdb.CassandraDataCentersClient", "Update", err.Error())
   450  	}
   451  
   452  	req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, dataCenterName, body)
   453  	if err != nil {
   454  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Update", nil, "Failure preparing request")
   455  		return
   456  	}
   457  
   458  	result, err = client.UpdateSender(req)
   459  	if err != nil {
   460  		err = autorest.NewErrorWithError(err, "documentdb.CassandraDataCentersClient", "Update", result.Response(), "Failure sending request")
   461  		return
   462  	}
   463  
   464  	return
   465  }
   466  
   467  // UpdatePreparer prepares the Update request.
   468  func (client CassandraDataCentersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, dataCenterName string, body DataCenterResource) (*http.Request, error) {
   469  	pathParameters := map[string]interface{}{
   470  		"clusterName":       autorest.Encode("path", clusterName),
   471  		"dataCenterName":    autorest.Encode("path", dataCenterName),
   472  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   473  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   474  	}
   475  
   476  	const APIVersion = "2022-05-15"
   477  	queryParameters := map[string]interface{}{
   478  		"api-version": APIVersion,
   479  	}
   480  
   481  	preparer := autorest.CreatePreparer(
   482  		autorest.AsContentType("application/json; charset=utf-8"),
   483  		autorest.AsPatch(),
   484  		autorest.WithBaseURL(client.BaseURI),
   485  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/cassandraClusters/{clusterName}/dataCenters/{dataCenterName}", pathParameters),
   486  		autorest.WithJSON(body),
   487  		autorest.WithQueryParameters(queryParameters))
   488  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   489  }
   490  
   491  // UpdateSender sends the Update request. The method will close the
   492  // http.Response Body if it receives an error.
   493  func (client CassandraDataCentersClient) UpdateSender(req *http.Request) (future CassandraDataCentersUpdateFuture, err error) {
   494  	var resp *http.Response
   495  	future.FutureAPI = &azure.Future{}
   496  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   497  	if err != nil {
   498  		return
   499  	}
   500  	var azf azure.Future
   501  	azf, err = azure.NewFutureFromResponse(resp)
   502  	future.FutureAPI = &azf
   503  	future.Result = future.result
   504  	return
   505  }
   506  
   507  // UpdateResponder handles the response to the Update request. The method always
   508  // closes the http.Response Body.
   509  func (client CassandraDataCentersClient) UpdateResponder(resp *http.Response) (result DataCenterResource, err error) {
   510  	err = autorest.Respond(
   511  		resp,
   512  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   513  		autorest.ByUnmarshallingJSON(&result),
   514  		autorest.ByClosing())
   515  	result.Response = autorest.Response{Response: resp}
   516  	return
   517  }
   518  

View as plain text