1package redisenterprise 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "github.com/Azure/go-autorest/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// DatabasesClient is the REST API for managing Redis Enterprise resources in Azure. 30type DatabasesClient struct { 31 BaseClient 32} 33 34// NewDatabasesClient creates an instance of the DatabasesClient client. 35func NewDatabasesClient(subscriptionID string) DatabasesClient { 36 return NewDatabasesClientWithBaseURI(DefaultBaseURI, subscriptionID) 37} 38 39// NewDatabasesClientWithBaseURI creates an instance of the DatabasesClient client using a custom endpoint. Use this 40// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 41func NewDatabasesClientWithBaseURI(baseURI string, subscriptionID string) DatabasesClient { 42 return DatabasesClient{NewWithBaseURI(baseURI, subscriptionID)} 43} 44 45// Create creates a database 46// Parameters: 47// resourceGroupName - the name of the resource group. 48// clusterName - the name of the RedisEnterprise cluster. 49// databaseName - the name of the database. 50// parameters - parameters supplied to the create or update database operation. 51func (client DatabasesClient) Create(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters Database) (result DatabasesCreateFuture, err error) { 52 if tracing.IsEnabled() { 53 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Create") 54 defer func() { 55 sc := -1 56 if result.Response() != nil { 57 sc = result.Response().StatusCode 58 } 59 tracing.EndSpan(ctx, sc, err) 60 }() 61 } 62 req, err := client.CreatePreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 63 if err != nil { 64 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Create", nil, "Failure preparing request") 65 return 66 } 67 68 result, err = client.CreateSender(req) 69 if err != nil { 70 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Create", nil, "Failure sending request") 71 return 72 } 73 74 return 75} 76 77// CreatePreparer prepares the Create request. 78func (client DatabasesClient) CreatePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters Database) (*http.Request, error) { 79 pathParameters := map[string]interface{}{ 80 "clusterName": autorest.Encode("path", clusterName), 81 "databaseName": autorest.Encode("path", databaseName), 82 "resourceGroupName": autorest.Encode("path", resourceGroupName), 83 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 84 } 85 86 const APIVersion = "2020-10-01-preview" 87 queryParameters := map[string]interface{}{ 88 "api-version": APIVersion, 89 } 90 91 preparer := autorest.CreatePreparer( 92 autorest.AsContentType("application/json; charset=utf-8"), 93 autorest.AsPut(), 94 autorest.WithBaseURL(client.BaseURI), 95 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}", pathParameters), 96 autorest.WithJSON(parameters), 97 autorest.WithQueryParameters(queryParameters)) 98 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 99} 100 101// CreateSender sends the Create request. The method will close the 102// http.Response Body if it receives an error. 103func (client DatabasesClient) CreateSender(req *http.Request) (future DatabasesCreateFuture, err error) { 104 var resp *http.Response 105 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 106 if err != nil { 107 return 108 } 109 var azf azure.Future 110 azf, err = azure.NewFutureFromResponse(resp) 111 future.FutureAPI = &azf 112 future.Result = func(client DatabasesClient) (d Database, err error) { 113 var done bool 114 done, err = future.DoneWithContext(context.Background(), client) 115 if err != nil { 116 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesCreateFuture", "Result", future.Response(), "Polling failure") 117 return 118 } 119 if !done { 120 err = azure.NewAsyncOpIncompleteError("redisenterprise.DatabasesCreateFuture") 121 return 122 } 123 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 124 if d.Response.Response, err = future.GetResult(sender); err == nil && d.Response.Response.StatusCode != http.StatusNoContent { 125 d, err = client.CreateResponder(d.Response.Response) 126 if err != nil { 127 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesCreateFuture", "Result", d.Response.Response, "Failure responding to request") 128 } 129 } 130 return 131 } 132 return 133} 134 135// CreateResponder handles the response to the Create request. The method always 136// closes the http.Response Body. 137func (client DatabasesClient) CreateResponder(resp *http.Response) (result Database, err error) { 138 err = autorest.Respond( 139 resp, 140 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 141 autorest.ByUnmarshallingJSON(&result), 142 autorest.ByClosing()) 143 result.Response = autorest.Response{Response: resp} 144 return 145} 146 147// Delete deletes a single database 148// Parameters: 149// resourceGroupName - the name of the resource group. 150// clusterName - the name of the RedisEnterprise cluster. 151// databaseName - the name of the database. 152func (client DatabasesClient) Delete(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabasesDeleteFuture, err error) { 153 if tracing.IsEnabled() { 154 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Delete") 155 defer func() { 156 sc := -1 157 if result.Response() != nil { 158 sc = result.Response().StatusCode 159 } 160 tracing.EndSpan(ctx, sc, err) 161 }() 162 } 163 req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName, databaseName) 164 if err != nil { 165 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Delete", nil, "Failure preparing request") 166 return 167 } 168 169 result, err = client.DeleteSender(req) 170 if err != nil { 171 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Delete", nil, "Failure sending request") 172 return 173 } 174 175 return 176} 177 178// DeletePreparer prepares the Delete request. 179func (client DatabasesClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) { 180 pathParameters := map[string]interface{}{ 181 "clusterName": autorest.Encode("path", clusterName), 182 "databaseName": autorest.Encode("path", databaseName), 183 "resourceGroupName": autorest.Encode("path", resourceGroupName), 184 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 185 } 186 187 const APIVersion = "2020-10-01-preview" 188 queryParameters := map[string]interface{}{ 189 "api-version": APIVersion, 190 } 191 192 preparer := autorest.CreatePreparer( 193 autorest.AsDelete(), 194 autorest.WithBaseURL(client.BaseURI), 195 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}", pathParameters), 196 autorest.WithQueryParameters(queryParameters)) 197 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 198} 199 200// DeleteSender sends the Delete request. The method will close the 201// http.Response Body if it receives an error. 202func (client DatabasesClient) DeleteSender(req *http.Request) (future DatabasesDeleteFuture, err error) { 203 var resp *http.Response 204 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 205 if err != nil { 206 return 207 } 208 var azf azure.Future 209 azf, err = azure.NewFutureFromResponse(resp) 210 future.FutureAPI = &azf 211 future.Result = func(client DatabasesClient) (ar autorest.Response, err error) { 212 var done bool 213 done, err = future.DoneWithContext(context.Background(), client) 214 if err != nil { 215 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesDeleteFuture", "Result", future.Response(), "Polling failure") 216 return 217 } 218 if !done { 219 err = azure.NewAsyncOpIncompleteError("redisenterprise.DatabasesDeleteFuture") 220 return 221 } 222 ar.Response = future.Response() 223 return 224 } 225 return 226} 227 228// DeleteResponder handles the response to the Delete request. The method always 229// closes the http.Response Body. 230func (client DatabasesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 231 err = autorest.Respond( 232 resp, 233 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 234 autorest.ByClosing()) 235 result.Response = resp 236 return 237} 238 239// Export exports a database file from target database. 240// Parameters: 241// resourceGroupName - the name of the resource group. 242// clusterName - the name of the RedisEnterprise cluster. 243// databaseName - the name of the database. 244// parameters - storage information for exporting into the cluster 245func (client DatabasesClient) Export(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters ExportClusterParameters) (result DatabasesExportFuture, err error) { 246 if tracing.IsEnabled() { 247 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Export") 248 defer func() { 249 sc := -1 250 if result.Response() != nil { 251 sc = result.Response().StatusCode 252 } 253 tracing.EndSpan(ctx, sc, err) 254 }() 255 } 256 if err := validation.Validate([]validation.Validation{ 257 {TargetValue: parameters, 258 Constraints: []validation.Constraint{{Target: "parameters.SasURI", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 259 return result, validation.NewError("redisenterprise.DatabasesClient", "Export", err.Error()) 260 } 261 262 req, err := client.ExportPreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 263 if err != nil { 264 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Export", nil, "Failure preparing request") 265 return 266 } 267 268 result, err = client.ExportSender(req) 269 if err != nil { 270 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Export", nil, "Failure sending request") 271 return 272 } 273 274 return 275} 276 277// ExportPreparer prepares the Export request. 278func (client DatabasesClient) ExportPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters ExportClusterParameters) (*http.Request, error) { 279 pathParameters := map[string]interface{}{ 280 "clusterName": autorest.Encode("path", clusterName), 281 "databaseName": autorest.Encode("path", databaseName), 282 "resourceGroupName": autorest.Encode("path", resourceGroupName), 283 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 284 } 285 286 const APIVersion = "2020-10-01-preview" 287 queryParameters := map[string]interface{}{ 288 "api-version": APIVersion, 289 } 290 291 preparer := autorest.CreatePreparer( 292 autorest.AsContentType("application/json; charset=utf-8"), 293 autorest.AsPost(), 294 autorest.WithBaseURL(client.BaseURI), 295 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}/export", pathParameters), 296 autorest.WithJSON(parameters), 297 autorest.WithQueryParameters(queryParameters)) 298 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 299} 300 301// ExportSender sends the Export request. The method will close the 302// http.Response Body if it receives an error. 303func (client DatabasesClient) ExportSender(req *http.Request) (future DatabasesExportFuture, err error) { 304 var resp *http.Response 305 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 306 if err != nil { 307 return 308 } 309 var azf azure.Future 310 azf, err = azure.NewFutureFromResponse(resp) 311 future.FutureAPI = &azf 312 future.Result = func(client DatabasesClient) (ar autorest.Response, err error) { 313 var done bool 314 done, err = future.DoneWithContext(context.Background(), client) 315 if err != nil { 316 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesExportFuture", "Result", future.Response(), "Polling failure") 317 return 318 } 319 if !done { 320 err = azure.NewAsyncOpIncompleteError("redisenterprise.DatabasesExportFuture") 321 return 322 } 323 ar.Response = future.Response() 324 return 325 } 326 return 327} 328 329// ExportResponder handles the response to the Export request. The method always 330// closes the http.Response Body. 331func (client DatabasesClient) ExportResponder(resp *http.Response) (result autorest.Response, err error) { 332 err = autorest.Respond( 333 resp, 334 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 335 autorest.ByClosing()) 336 result.Response = resp 337 return 338} 339 340// GetMethod gets information about a database in a RedisEnterprise cluster. 341// Parameters: 342// resourceGroupName - the name of the resource group. 343// clusterName - the name of the RedisEnterprise cluster. 344// databaseName - the name of the database. 345func (client DatabasesClient) GetMethod(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result Database, err error) { 346 if tracing.IsEnabled() { 347 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.GetMethod") 348 defer func() { 349 sc := -1 350 if result.Response.Response != nil { 351 sc = result.Response.Response.StatusCode 352 } 353 tracing.EndSpan(ctx, sc, err) 354 }() 355 } 356 req, err := client.GetMethodPreparer(ctx, resourceGroupName, clusterName, databaseName) 357 if err != nil { 358 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "GetMethod", nil, "Failure preparing request") 359 return 360 } 361 362 resp, err := client.GetMethodSender(req) 363 if err != nil { 364 result.Response = autorest.Response{Response: resp} 365 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "GetMethod", resp, "Failure sending request") 366 return 367 } 368 369 result, err = client.GetMethodResponder(resp) 370 if err != nil { 371 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "GetMethod", resp, "Failure responding to request") 372 return 373 } 374 375 return 376} 377 378// GetMethodPreparer prepares the GetMethod request. 379func (client DatabasesClient) GetMethodPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) { 380 pathParameters := map[string]interface{}{ 381 "clusterName": autorest.Encode("path", clusterName), 382 "databaseName": autorest.Encode("path", databaseName), 383 "resourceGroupName": autorest.Encode("path", resourceGroupName), 384 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 385 } 386 387 const APIVersion = "2020-10-01-preview" 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.Cache/redisEnterprise/{clusterName}/databases/{databaseName}", pathParameters), 396 autorest.WithQueryParameters(queryParameters)) 397 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 398} 399 400// GetMethodSender sends the GetMethod request. The method will close the 401// http.Response Body if it receives an error. 402func (client DatabasesClient) GetMethodSender(req *http.Request) (*http.Response, error) { 403 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 404} 405 406// GetMethodResponder handles the response to the GetMethod request. The method always 407// closes the http.Response Body. 408func (client DatabasesClient) GetMethodResponder(resp *http.Response) (result Database, 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// Import imports a database file to target database. 419// Parameters: 420// resourceGroupName - the name of the resource group. 421// clusterName - the name of the RedisEnterprise cluster. 422// databaseName - the name of the database. 423// parameters - storage information for importing into the cluster 424func (client DatabasesClient) Import(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters ImportClusterParameters) (result DatabasesImportFuture, err error) { 425 if tracing.IsEnabled() { 426 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Import") 427 defer func() { 428 sc := -1 429 if result.Response() != nil { 430 sc = result.Response().StatusCode 431 } 432 tracing.EndSpan(ctx, sc, err) 433 }() 434 } 435 if err := validation.Validate([]validation.Validation{ 436 {TargetValue: parameters, 437 Constraints: []validation.Constraint{{Target: "parameters.SasURI", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 438 return result, validation.NewError("redisenterprise.DatabasesClient", "Import", err.Error()) 439 } 440 441 req, err := client.ImportPreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 442 if err != nil { 443 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Import", nil, "Failure preparing request") 444 return 445 } 446 447 result, err = client.ImportSender(req) 448 if err != nil { 449 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Import", nil, "Failure sending request") 450 return 451 } 452 453 return 454} 455 456// ImportPreparer prepares the Import request. 457func (client DatabasesClient) ImportPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters ImportClusterParameters) (*http.Request, error) { 458 pathParameters := map[string]interface{}{ 459 "clusterName": autorest.Encode("path", clusterName), 460 "databaseName": autorest.Encode("path", databaseName), 461 "resourceGroupName": autorest.Encode("path", resourceGroupName), 462 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 463 } 464 465 const APIVersion = "2020-10-01-preview" 466 queryParameters := map[string]interface{}{ 467 "api-version": APIVersion, 468 } 469 470 preparer := autorest.CreatePreparer( 471 autorest.AsContentType("application/json; charset=utf-8"), 472 autorest.AsPost(), 473 autorest.WithBaseURL(client.BaseURI), 474 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}/import", pathParameters), 475 autorest.WithJSON(parameters), 476 autorest.WithQueryParameters(queryParameters)) 477 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 478} 479 480// ImportSender sends the Import request. The method will close the 481// http.Response Body if it receives an error. 482func (client DatabasesClient) ImportSender(req *http.Request) (future DatabasesImportFuture, err error) { 483 var resp *http.Response 484 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 485 if err != nil { 486 return 487 } 488 var azf azure.Future 489 azf, err = azure.NewFutureFromResponse(resp) 490 future.FutureAPI = &azf 491 future.Result = func(client DatabasesClient) (ar autorest.Response, err error) { 492 var done bool 493 done, err = future.DoneWithContext(context.Background(), client) 494 if err != nil { 495 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesImportFuture", "Result", future.Response(), "Polling failure") 496 return 497 } 498 if !done { 499 err = azure.NewAsyncOpIncompleteError("redisenterprise.DatabasesImportFuture") 500 return 501 } 502 ar.Response = future.Response() 503 return 504 } 505 return 506} 507 508// ImportResponder handles the response to the Import request. The method always 509// closes the http.Response Body. 510func (client DatabasesClient) ImportResponder(resp *http.Response) (result autorest.Response, err error) { 511 err = autorest.Respond( 512 resp, 513 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 514 autorest.ByClosing()) 515 result.Response = resp 516 return 517} 518 519// ListByCluster gets all databases in the specified RedisEnterprise cluster. 520// Parameters: 521// resourceGroupName - the name of the resource group. 522// clusterName - the name of the RedisEnterprise cluster. 523func (client DatabasesClient) ListByCluster(ctx context.Context, resourceGroupName string, clusterName string) (result DatabaseListPage, err error) { 524 if tracing.IsEnabled() { 525 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListByCluster") 526 defer func() { 527 sc := -1 528 if result.dl.Response.Response != nil { 529 sc = result.dl.Response.Response.StatusCode 530 } 531 tracing.EndSpan(ctx, sc, err) 532 }() 533 } 534 result.fn = client.listByClusterNextResults 535 req, err := client.ListByClusterPreparer(ctx, resourceGroupName, clusterName) 536 if err != nil { 537 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "ListByCluster", nil, "Failure preparing request") 538 return 539 } 540 541 resp, err := client.ListByClusterSender(req) 542 if err != nil { 543 result.dl.Response = autorest.Response{Response: resp} 544 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "ListByCluster", resp, "Failure sending request") 545 return 546 } 547 548 result.dl, err = client.ListByClusterResponder(resp) 549 if err != nil { 550 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "ListByCluster", resp, "Failure responding to request") 551 return 552 } 553 if result.dl.hasNextLink() && result.dl.IsEmpty() { 554 err = result.NextWithContext(ctx) 555 return 556 } 557 558 return 559} 560 561// ListByClusterPreparer prepares the ListByCluster request. 562func (client DatabasesClient) ListByClusterPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 563 pathParameters := map[string]interface{}{ 564 "clusterName": autorest.Encode("path", clusterName), 565 "resourceGroupName": autorest.Encode("path", resourceGroupName), 566 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 567 } 568 569 const APIVersion = "2020-10-01-preview" 570 queryParameters := map[string]interface{}{ 571 "api-version": APIVersion, 572 } 573 574 preparer := autorest.CreatePreparer( 575 autorest.AsGet(), 576 autorest.WithBaseURL(client.BaseURI), 577 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases", pathParameters), 578 autorest.WithQueryParameters(queryParameters)) 579 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 580} 581 582// ListByClusterSender sends the ListByCluster request. The method will close the 583// http.Response Body if it receives an error. 584func (client DatabasesClient) ListByClusterSender(req *http.Request) (*http.Response, error) { 585 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 586} 587 588// ListByClusterResponder handles the response to the ListByCluster request. The method always 589// closes the http.Response Body. 590func (client DatabasesClient) ListByClusterResponder(resp *http.Response) (result DatabaseList, err error) { 591 err = autorest.Respond( 592 resp, 593 azure.WithErrorUnlessStatusCode(http.StatusOK), 594 autorest.ByUnmarshallingJSON(&result), 595 autorest.ByClosing()) 596 result.Response = autorest.Response{Response: resp} 597 return 598} 599 600// listByClusterNextResults retrieves the next set of results, if any. 601func (client DatabasesClient) listByClusterNextResults(ctx context.Context, lastResults DatabaseList) (result DatabaseList, err error) { 602 req, err := lastResults.databaseListPreparer(ctx) 603 if err != nil { 604 return result, autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "listByClusterNextResults", nil, "Failure preparing next results request") 605 } 606 if req == nil { 607 return 608 } 609 resp, err := client.ListByClusterSender(req) 610 if err != nil { 611 result.Response = autorest.Response{Response: resp} 612 return result, autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "listByClusterNextResults", resp, "Failure sending next results request") 613 } 614 result, err = client.ListByClusterResponder(resp) 615 if err != nil { 616 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "listByClusterNextResults", resp, "Failure responding to next results request") 617 } 618 return 619} 620 621// ListByClusterComplete enumerates all values, automatically crossing page boundaries as required. 622func (client DatabasesClient) ListByClusterComplete(ctx context.Context, resourceGroupName string, clusterName string) (result DatabaseListIterator, err error) { 623 if tracing.IsEnabled() { 624 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListByCluster") 625 defer func() { 626 sc := -1 627 if result.Response().Response.Response != nil { 628 sc = result.page.Response().Response.Response.StatusCode 629 } 630 tracing.EndSpan(ctx, sc, err) 631 }() 632 } 633 result.page, err = client.ListByCluster(ctx, resourceGroupName, clusterName) 634 return 635} 636 637// ListKeys retrieves the access keys for the RedisEnterprise database. 638// Parameters: 639// resourceGroupName - the name of the resource group. 640// clusterName - the name of the RedisEnterprise cluster. 641// databaseName - the name of the database. 642func (client DatabasesClient) ListKeys(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result AccessKeys, err error) { 643 if tracing.IsEnabled() { 644 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListKeys") 645 defer func() { 646 sc := -1 647 if result.Response.Response != nil { 648 sc = result.Response.Response.StatusCode 649 } 650 tracing.EndSpan(ctx, sc, err) 651 }() 652 } 653 req, err := client.ListKeysPreparer(ctx, resourceGroupName, clusterName, databaseName) 654 if err != nil { 655 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "ListKeys", nil, "Failure preparing request") 656 return 657 } 658 659 resp, err := client.ListKeysSender(req) 660 if err != nil { 661 result.Response = autorest.Response{Response: resp} 662 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "ListKeys", resp, "Failure sending request") 663 return 664 } 665 666 result, err = client.ListKeysResponder(resp) 667 if err != nil { 668 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "ListKeys", resp, "Failure responding to request") 669 return 670 } 671 672 return 673} 674 675// ListKeysPreparer prepares the ListKeys request. 676func (client DatabasesClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) { 677 pathParameters := map[string]interface{}{ 678 "clusterName": autorest.Encode("path", clusterName), 679 "databaseName": autorest.Encode("path", databaseName), 680 "resourceGroupName": autorest.Encode("path", resourceGroupName), 681 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 682 } 683 684 const APIVersion = "2020-10-01-preview" 685 queryParameters := map[string]interface{}{ 686 "api-version": APIVersion, 687 } 688 689 preparer := autorest.CreatePreparer( 690 autorest.AsPost(), 691 autorest.WithBaseURL(client.BaseURI), 692 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}/listKeys", pathParameters), 693 autorest.WithQueryParameters(queryParameters)) 694 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 695} 696 697// ListKeysSender sends the ListKeys request. The method will close the 698// http.Response Body if it receives an error. 699func (client DatabasesClient) ListKeysSender(req *http.Request) (*http.Response, error) { 700 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 701} 702 703// ListKeysResponder handles the response to the ListKeys request. The method always 704// closes the http.Response Body. 705func (client DatabasesClient) ListKeysResponder(resp *http.Response) (result AccessKeys, err error) { 706 err = autorest.Respond( 707 resp, 708 azure.WithErrorUnlessStatusCode(http.StatusOK), 709 autorest.ByUnmarshallingJSON(&result), 710 autorest.ByClosing()) 711 result.Response = autorest.Response{Response: resp} 712 return 713} 714 715// RegenerateKey regenerates the RedisEnterprise database's access keys. 716// Parameters: 717// resourceGroupName - the name of the resource group. 718// clusterName - the name of the RedisEnterprise cluster. 719// databaseName - the name of the database. 720// parameters - specifies which key to regenerate. 721func (client DatabasesClient) RegenerateKey(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters RegenerateKeyParameters) (result DatabasesRegenerateKeyFuture, err error) { 722 if tracing.IsEnabled() { 723 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.RegenerateKey") 724 defer func() { 725 sc := -1 726 if result.Response() != nil { 727 sc = result.Response().StatusCode 728 } 729 tracing.EndSpan(ctx, sc, err) 730 }() 731 } 732 req, err := client.RegenerateKeyPreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 733 if err != nil { 734 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "RegenerateKey", nil, "Failure preparing request") 735 return 736 } 737 738 result, err = client.RegenerateKeySender(req) 739 if err != nil { 740 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "RegenerateKey", nil, "Failure sending request") 741 return 742 } 743 744 return 745} 746 747// RegenerateKeyPreparer prepares the RegenerateKey request. 748func (client DatabasesClient) RegenerateKeyPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters RegenerateKeyParameters) (*http.Request, error) { 749 pathParameters := map[string]interface{}{ 750 "clusterName": autorest.Encode("path", clusterName), 751 "databaseName": autorest.Encode("path", databaseName), 752 "resourceGroupName": autorest.Encode("path", resourceGroupName), 753 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 754 } 755 756 const APIVersion = "2020-10-01-preview" 757 queryParameters := map[string]interface{}{ 758 "api-version": APIVersion, 759 } 760 761 preparer := autorest.CreatePreparer( 762 autorest.AsContentType("application/json; charset=utf-8"), 763 autorest.AsPost(), 764 autorest.WithBaseURL(client.BaseURI), 765 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}/regenerateKey", pathParameters), 766 autorest.WithJSON(parameters), 767 autorest.WithQueryParameters(queryParameters)) 768 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 769} 770 771// RegenerateKeySender sends the RegenerateKey request. The method will close the 772// http.Response Body if it receives an error. 773func (client DatabasesClient) RegenerateKeySender(req *http.Request) (future DatabasesRegenerateKeyFuture, err error) { 774 var resp *http.Response 775 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 776 if err != nil { 777 return 778 } 779 var azf azure.Future 780 azf, err = azure.NewFutureFromResponse(resp) 781 future.FutureAPI = &azf 782 future.Result = func(client DatabasesClient) (ak AccessKeys, err error) { 783 var done bool 784 done, err = future.DoneWithContext(context.Background(), client) 785 if err != nil { 786 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesRegenerateKeyFuture", "Result", future.Response(), "Polling failure") 787 return 788 } 789 if !done { 790 err = azure.NewAsyncOpIncompleteError("redisenterprise.DatabasesRegenerateKeyFuture") 791 return 792 } 793 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 794 if ak.Response.Response, err = future.GetResult(sender); err == nil && ak.Response.Response.StatusCode != http.StatusNoContent { 795 ak, err = client.RegenerateKeyResponder(ak.Response.Response) 796 if err != nil { 797 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesRegenerateKeyFuture", "Result", ak.Response.Response, "Failure responding to request") 798 } 799 } 800 return 801 } 802 return 803} 804 805// RegenerateKeyResponder handles the response to the RegenerateKey request. The method always 806// closes the http.Response Body. 807func (client DatabasesClient) RegenerateKeyResponder(resp *http.Response) (result AccessKeys, err error) { 808 err = autorest.Respond( 809 resp, 810 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 811 autorest.ByUnmarshallingJSON(&result), 812 autorest.ByClosing()) 813 result.Response = autorest.Response{Response: resp} 814 return 815} 816 817// Update updates a database 818// Parameters: 819// resourceGroupName - the name of the resource group. 820// clusterName - the name of the RedisEnterprise cluster. 821// databaseName - the name of the database. 822// parameters - parameters supplied to the create or update database operation. 823func (client DatabasesClient) Update(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters DatabaseUpdate) (result DatabasesUpdateFuture, err error) { 824 if tracing.IsEnabled() { 825 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Update") 826 defer func() { 827 sc := -1 828 if result.Response() != nil { 829 sc = result.Response().StatusCode 830 } 831 tracing.EndSpan(ctx, sc, err) 832 }() 833 } 834 req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 835 if err != nil { 836 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Update", nil, "Failure preparing request") 837 return 838 } 839 840 result, err = client.UpdateSender(req) 841 if err != nil { 842 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesClient", "Update", nil, "Failure sending request") 843 return 844 } 845 846 return 847} 848 849// UpdatePreparer prepares the Update request. 850func (client DatabasesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters DatabaseUpdate) (*http.Request, error) { 851 pathParameters := map[string]interface{}{ 852 "clusterName": autorest.Encode("path", clusterName), 853 "databaseName": autorest.Encode("path", databaseName), 854 "resourceGroupName": autorest.Encode("path", resourceGroupName), 855 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 856 } 857 858 const APIVersion = "2020-10-01-preview" 859 queryParameters := map[string]interface{}{ 860 "api-version": APIVersion, 861 } 862 863 preparer := autorest.CreatePreparer( 864 autorest.AsContentType("application/json; charset=utf-8"), 865 autorest.AsPatch(), 866 autorest.WithBaseURL(client.BaseURI), 867 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/redisEnterprise/{clusterName}/databases/{databaseName}", pathParameters), 868 autorest.WithJSON(parameters), 869 autorest.WithQueryParameters(queryParameters)) 870 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 871} 872 873// UpdateSender sends the Update request. The method will close the 874// http.Response Body if it receives an error. 875func (client DatabasesClient) UpdateSender(req *http.Request) (future DatabasesUpdateFuture, err error) { 876 var resp *http.Response 877 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 878 if err != nil { 879 return 880 } 881 var azf azure.Future 882 azf, err = azure.NewFutureFromResponse(resp) 883 future.FutureAPI = &azf 884 future.Result = func(client DatabasesClient) (d Database, err error) { 885 var done bool 886 done, err = future.DoneWithContext(context.Background(), client) 887 if err != nil { 888 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesUpdateFuture", "Result", future.Response(), "Polling failure") 889 return 890 } 891 if !done { 892 err = azure.NewAsyncOpIncompleteError("redisenterprise.DatabasesUpdateFuture") 893 return 894 } 895 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 896 if d.Response.Response, err = future.GetResult(sender); err == nil && d.Response.Response.StatusCode != http.StatusNoContent { 897 d, err = client.UpdateResponder(d.Response.Response) 898 if err != nil { 899 err = autorest.NewErrorWithError(err, "redisenterprise.DatabasesUpdateFuture", "Result", d.Response.Response, "Failure responding to request") 900 } 901 } 902 return 903 } 904 return 905} 906 907// UpdateResponder handles the response to the Update request. The method always 908// closes the http.Response Body. 909func (client DatabasesClient) UpdateResponder(resp *http.Response) (result Database, err error) { 910 err = autorest.Respond( 911 resp, 912 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 913 autorest.ByUnmarshallingJSON(&result), 914 autorest.ByClosing()) 915 result.Response = autorest.Response{Response: resp} 916 return 917} 918