1package sql 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// ManagedInstancesClient is the the Azure SQL Database management API provides a RESTful set of web services that 30// interact with Azure SQL Database services to manage your databases. The API enables you to create, retrieve, update, 31// and delete databases. 32type ManagedInstancesClient struct { 33 BaseClient 34} 35 36// NewManagedInstancesClient creates an instance of the ManagedInstancesClient client. 37func NewManagedInstancesClient(subscriptionID string) ManagedInstancesClient { 38 return NewManagedInstancesClientWithBaseURI(DefaultBaseURI, subscriptionID) 39} 40 41// NewManagedInstancesClientWithBaseURI creates an instance of the ManagedInstancesClient client using a custom 42// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure 43// stack). 44func NewManagedInstancesClientWithBaseURI(baseURI string, subscriptionID string) ManagedInstancesClient { 45 return ManagedInstancesClient{NewWithBaseURI(baseURI, subscriptionID)} 46} 47 48// CreateOrUpdate creates or updates a managed instance. 49// Parameters: 50// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 51// from the Azure Resource Manager API or the portal. 52// managedInstanceName - the name of the managed instance. 53// parameters - the requested managed instance resource state. 54func (client ManagedInstancesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, managedInstanceName string, parameters ManagedInstance) (result ManagedInstancesCreateOrUpdateFuture, err error) { 55 if tracing.IsEnabled() { 56 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.CreateOrUpdate") 57 defer func() { 58 sc := -1 59 if result.Response() != nil { 60 sc = result.Response().StatusCode 61 } 62 tracing.EndSpan(ctx, sc, err) 63 }() 64 } 65 if err := validation.Validate([]validation.Validation{ 66 {TargetValue: parameters, 67 Constraints: []validation.Constraint{{Target: "parameters.Sku", Name: validation.Null, Rule: false, 68 Chain: []validation.Constraint{{Target: "parameters.Sku.Name", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { 69 return result, validation.NewError("sql.ManagedInstancesClient", "CreateOrUpdate", err.Error()) 70 } 71 72 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, managedInstanceName, parameters) 73 if err != nil { 74 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "CreateOrUpdate", nil, "Failure preparing request") 75 return 76 } 77 78 result, err = client.CreateOrUpdateSender(req) 79 if err != nil { 80 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "CreateOrUpdate", nil, "Failure sending request") 81 return 82 } 83 84 return 85} 86 87// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 88func (client ManagedInstancesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, managedInstanceName string, parameters ManagedInstance) (*http.Request, error) { 89 pathParameters := map[string]interface{}{ 90 "managedInstanceName": autorest.Encode("path", managedInstanceName), 91 "resourceGroupName": autorest.Encode("path", resourceGroupName), 92 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 93 } 94 95 const APIVersion = "2020-02-02-preview" 96 queryParameters := map[string]interface{}{ 97 "api-version": APIVersion, 98 } 99 100 preparer := autorest.CreatePreparer( 101 autorest.AsContentType("application/json; charset=utf-8"), 102 autorest.AsPut(), 103 autorest.WithBaseURL(client.BaseURI), 104 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/managedInstances/{managedInstanceName}", pathParameters), 105 autorest.WithJSON(parameters), 106 autorest.WithQueryParameters(queryParameters)) 107 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 108} 109 110// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 111// http.Response Body if it receives an error. 112func (client ManagedInstancesClient) CreateOrUpdateSender(req *http.Request) (future ManagedInstancesCreateOrUpdateFuture, err error) { 113 var resp *http.Response 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 = func(client ManagedInstancesClient) (mi ManagedInstance, err error) { 122 var done bool 123 done, err = future.DoneWithContext(context.Background(), client) 124 if err != nil { 125 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") 126 return 127 } 128 if !done { 129 err = azure.NewAsyncOpIncompleteError("sql.ManagedInstancesCreateOrUpdateFuture") 130 return 131 } 132 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 133 if mi.Response.Response, err = future.GetResult(sender); err == nil && mi.Response.Response.StatusCode != http.StatusNoContent { 134 mi, err = client.CreateOrUpdateResponder(mi.Response.Response) 135 if err != nil { 136 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesCreateOrUpdateFuture", "Result", mi.Response.Response, "Failure responding to request") 137 } 138 } 139 return 140 } 141 return 142} 143 144// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 145// closes the http.Response Body. 146func (client ManagedInstancesClient) CreateOrUpdateResponder(resp *http.Response) (result ManagedInstance, err error) { 147 err = autorest.Respond( 148 resp, 149 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 150 autorest.ByUnmarshallingJSON(&result), 151 autorest.ByClosing()) 152 result.Response = autorest.Response{Response: resp} 153 return 154} 155 156// Delete deletes a managed instance. 157// Parameters: 158// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 159// from the Azure Resource Manager API or the portal. 160// managedInstanceName - the name of the managed instance. 161func (client ManagedInstancesClient) Delete(ctx context.Context, resourceGroupName string, managedInstanceName string) (result ManagedInstancesDeleteFuture, err error) { 162 if tracing.IsEnabled() { 163 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.Delete") 164 defer func() { 165 sc := -1 166 if result.Response() != nil { 167 sc = result.Response().StatusCode 168 } 169 tracing.EndSpan(ctx, sc, err) 170 }() 171 } 172 req, err := client.DeletePreparer(ctx, resourceGroupName, managedInstanceName) 173 if err != nil { 174 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Delete", nil, "Failure preparing request") 175 return 176 } 177 178 result, err = client.DeleteSender(req) 179 if err != nil { 180 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Delete", nil, "Failure sending request") 181 return 182 } 183 184 return 185} 186 187// DeletePreparer prepares the Delete request. 188func (client ManagedInstancesClient) DeletePreparer(ctx context.Context, resourceGroupName string, managedInstanceName string) (*http.Request, error) { 189 pathParameters := map[string]interface{}{ 190 "managedInstanceName": autorest.Encode("path", managedInstanceName), 191 "resourceGroupName": autorest.Encode("path", resourceGroupName), 192 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 193 } 194 195 const APIVersion = "2020-02-02-preview" 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.Sql/managedInstances/{managedInstanceName}", 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. 210func (client ManagedInstancesClient) DeleteSender(req *http.Request) (future ManagedInstancesDeleteFuture, err error) { 211 var resp *http.Response 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 = func(client ManagedInstancesClient) (ar autorest.Response, err error) { 220 var done bool 221 done, err = future.DoneWithContext(context.Background(), client) 222 if err != nil { 223 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesDeleteFuture", "Result", future.Response(), "Polling failure") 224 return 225 } 226 if !done { 227 err = azure.NewAsyncOpIncompleteError("sql.ManagedInstancesDeleteFuture") 228 return 229 } 230 ar.Response = future.Response() 231 return 232 } 233 return 234} 235 236// DeleteResponder handles the response to the Delete request. The method always 237// closes the http.Response Body. 238func (client ManagedInstancesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 239 err = autorest.Respond( 240 resp, 241 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 242 autorest.ByClosing()) 243 result.Response = resp 244 return 245} 246 247// Failover failovers a managed instance. 248// Parameters: 249// resourceGroupName - the name of the resource group. The name is case insensitive. 250// managedInstanceName - the name of the managed instance. 251// replicaType - the type of replica to be failed over. 252func (client ManagedInstancesClient) Failover(ctx context.Context, resourceGroupName string, managedInstanceName string, replicaType ReplicaType) (result ManagedInstancesFailoverFuture, err error) { 253 if tracing.IsEnabled() { 254 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.Failover") 255 defer func() { 256 sc := -1 257 if result.Response() != nil { 258 sc = result.Response().StatusCode 259 } 260 tracing.EndSpan(ctx, sc, err) 261 }() 262 } 263 if err := validation.Validate([]validation.Validation{ 264 {TargetValue: resourceGroupName, 265 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 266 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 267 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 268 return result, validation.NewError("sql.ManagedInstancesClient", "Failover", err.Error()) 269 } 270 271 req, err := client.FailoverPreparer(ctx, resourceGroupName, managedInstanceName, replicaType) 272 if err != nil { 273 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Failover", nil, "Failure preparing request") 274 return 275 } 276 277 result, err = client.FailoverSender(req) 278 if err != nil { 279 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Failover", nil, "Failure sending request") 280 return 281 } 282 283 return 284} 285 286// FailoverPreparer prepares the Failover request. 287func (client ManagedInstancesClient) FailoverPreparer(ctx context.Context, resourceGroupName string, managedInstanceName string, replicaType ReplicaType) (*http.Request, error) { 288 pathParameters := map[string]interface{}{ 289 "managedInstanceName": autorest.Encode("path", managedInstanceName), 290 "resourceGroupName": autorest.Encode("path", resourceGroupName), 291 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 292 } 293 294 const APIVersion = "2019-06-01-preview" 295 queryParameters := map[string]interface{}{ 296 "api-version": APIVersion, 297 } 298 if len(string(replicaType)) > 0 { 299 queryParameters["replicaType"] = autorest.Encode("query", replicaType) 300 } 301 302 preparer := autorest.CreatePreparer( 303 autorest.AsPost(), 304 autorest.WithBaseURL(client.BaseURI), 305 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/managedInstances/{managedInstanceName}/failover", pathParameters), 306 autorest.WithQueryParameters(queryParameters)) 307 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 308} 309 310// FailoverSender sends the Failover request. The method will close the 311// http.Response Body if it receives an error. 312func (client ManagedInstancesClient) FailoverSender(req *http.Request) (future ManagedInstancesFailoverFuture, err error) { 313 var resp *http.Response 314 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 315 if err != nil { 316 return 317 } 318 var azf azure.Future 319 azf, err = azure.NewFutureFromResponse(resp) 320 future.FutureAPI = &azf 321 future.Result = func(client ManagedInstancesClient) (ar autorest.Response, err error) { 322 var done bool 323 done, err = future.DoneWithContext(context.Background(), client) 324 if err != nil { 325 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesFailoverFuture", "Result", future.Response(), "Polling failure") 326 return 327 } 328 if !done { 329 err = azure.NewAsyncOpIncompleteError("sql.ManagedInstancesFailoverFuture") 330 return 331 } 332 ar.Response = future.Response() 333 return 334 } 335 return 336} 337 338// FailoverResponder handles the response to the Failover request. The method always 339// closes the http.Response Body. 340func (client ManagedInstancesClient) FailoverResponder(resp *http.Response) (result autorest.Response, err error) { 341 err = autorest.Respond( 342 resp, 343 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 344 autorest.ByClosing()) 345 result.Response = resp 346 return 347} 348 349// Get gets a managed instance. 350// Parameters: 351// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 352// from the Azure Resource Manager API or the portal. 353// managedInstanceName - the name of the managed instance. 354func (client ManagedInstancesClient) Get(ctx context.Context, resourceGroupName string, managedInstanceName string) (result ManagedInstance, err error) { 355 if tracing.IsEnabled() { 356 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.Get") 357 defer func() { 358 sc := -1 359 if result.Response.Response != nil { 360 sc = result.Response.Response.StatusCode 361 } 362 tracing.EndSpan(ctx, sc, err) 363 }() 364 } 365 req, err := client.GetPreparer(ctx, resourceGroupName, managedInstanceName) 366 if err != nil { 367 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Get", nil, "Failure preparing request") 368 return 369 } 370 371 resp, err := client.GetSender(req) 372 if err != nil { 373 result.Response = autorest.Response{Response: resp} 374 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Get", resp, "Failure sending request") 375 return 376 } 377 378 result, err = client.GetResponder(resp) 379 if err != nil { 380 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Get", resp, "Failure responding to request") 381 return 382 } 383 384 return 385} 386 387// GetPreparer prepares the Get request. 388func (client ManagedInstancesClient) GetPreparer(ctx context.Context, resourceGroupName string, managedInstanceName string) (*http.Request, error) { 389 pathParameters := map[string]interface{}{ 390 "managedInstanceName": autorest.Encode("path", managedInstanceName), 391 "resourceGroupName": autorest.Encode("path", resourceGroupName), 392 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 393 } 394 395 const APIVersion = "2020-02-02-preview" 396 queryParameters := map[string]interface{}{ 397 "api-version": APIVersion, 398 } 399 400 preparer := autorest.CreatePreparer( 401 autorest.AsGet(), 402 autorest.WithBaseURL(client.BaseURI), 403 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/managedInstances/{managedInstanceName}", pathParameters), 404 autorest.WithQueryParameters(queryParameters)) 405 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 406} 407 408// GetSender sends the Get request. The method will close the 409// http.Response Body if it receives an error. 410func (client ManagedInstancesClient) GetSender(req *http.Request) (*http.Response, error) { 411 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 412} 413 414// GetResponder handles the response to the Get request. The method always 415// closes the http.Response Body. 416func (client ManagedInstancesClient) GetResponder(resp *http.Response) (result ManagedInstance, err error) { 417 err = autorest.Respond( 418 resp, 419 azure.WithErrorUnlessStatusCode(http.StatusOK), 420 autorest.ByUnmarshallingJSON(&result), 421 autorest.ByClosing()) 422 result.Response = autorest.Response{Response: resp} 423 return 424} 425 426// List gets a list of all managed instances in the subscription. 427func (client ManagedInstancesClient) List(ctx context.Context) (result ManagedInstanceListResultPage, err error) { 428 if tracing.IsEnabled() { 429 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.List") 430 defer func() { 431 sc := -1 432 if result.milr.Response.Response != nil { 433 sc = result.milr.Response.Response.StatusCode 434 } 435 tracing.EndSpan(ctx, sc, err) 436 }() 437 } 438 result.fn = client.listNextResults 439 req, err := client.ListPreparer(ctx) 440 if err != nil { 441 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "List", nil, "Failure preparing request") 442 return 443 } 444 445 resp, err := client.ListSender(req) 446 if err != nil { 447 result.milr.Response = autorest.Response{Response: resp} 448 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "List", resp, "Failure sending request") 449 return 450 } 451 452 result.milr, err = client.ListResponder(resp) 453 if err != nil { 454 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "List", resp, "Failure responding to request") 455 return 456 } 457 if result.milr.hasNextLink() && result.milr.IsEmpty() { 458 err = result.NextWithContext(ctx) 459 return 460 } 461 462 return 463} 464 465// ListPreparer prepares the List request. 466func (client ManagedInstancesClient) ListPreparer(ctx context.Context) (*http.Request, error) { 467 pathParameters := map[string]interface{}{ 468 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 469 } 470 471 const APIVersion = "2020-02-02-preview" 472 queryParameters := map[string]interface{}{ 473 "api-version": APIVersion, 474 } 475 476 preparer := autorest.CreatePreparer( 477 autorest.AsGet(), 478 autorest.WithBaseURL(client.BaseURI), 479 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Sql/managedInstances", pathParameters), 480 autorest.WithQueryParameters(queryParameters)) 481 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 482} 483 484// ListSender sends the List request. The method will close the 485// http.Response Body if it receives an error. 486func (client ManagedInstancesClient) ListSender(req *http.Request) (*http.Response, error) { 487 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 488} 489 490// ListResponder handles the response to the List request. The method always 491// closes the http.Response Body. 492func (client ManagedInstancesClient) ListResponder(resp *http.Response) (result ManagedInstanceListResult, err error) { 493 err = autorest.Respond( 494 resp, 495 azure.WithErrorUnlessStatusCode(http.StatusOK), 496 autorest.ByUnmarshallingJSON(&result), 497 autorest.ByClosing()) 498 result.Response = autorest.Response{Response: resp} 499 return 500} 501 502// listNextResults retrieves the next set of results, if any. 503func (client ManagedInstancesClient) listNextResults(ctx context.Context, lastResults ManagedInstanceListResult) (result ManagedInstanceListResult, err error) { 504 req, err := lastResults.managedInstanceListResultPreparer(ctx) 505 if err != nil { 506 return result, autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listNextResults", nil, "Failure preparing next results request") 507 } 508 if req == nil { 509 return 510 } 511 resp, err := client.ListSender(req) 512 if err != nil { 513 result.Response = autorest.Response{Response: resp} 514 return result, autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listNextResults", resp, "Failure sending next results request") 515 } 516 result, err = client.ListResponder(resp) 517 if err != nil { 518 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listNextResults", resp, "Failure responding to next results request") 519 } 520 return 521} 522 523// ListComplete enumerates all values, automatically crossing page boundaries as required. 524func (client ManagedInstancesClient) ListComplete(ctx context.Context) (result ManagedInstanceListResultIterator, err error) { 525 if tracing.IsEnabled() { 526 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.List") 527 defer func() { 528 sc := -1 529 if result.Response().Response.Response != nil { 530 sc = result.page.Response().Response.Response.StatusCode 531 } 532 tracing.EndSpan(ctx, sc, err) 533 }() 534 } 535 result.page, err = client.List(ctx) 536 return 537} 538 539// ListByInstancePool gets a list of all managed instances in an instance pool. 540// Parameters: 541// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 542// from the Azure Resource Manager API or the portal. 543// instancePoolName - the instance pool name. 544func (client ManagedInstancesClient) ListByInstancePool(ctx context.Context, resourceGroupName string, instancePoolName string) (result ManagedInstanceListResultPage, err error) { 545 if tracing.IsEnabled() { 546 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.ListByInstancePool") 547 defer func() { 548 sc := -1 549 if result.milr.Response.Response != nil { 550 sc = result.milr.Response.Response.StatusCode 551 } 552 tracing.EndSpan(ctx, sc, err) 553 }() 554 } 555 result.fn = client.listByInstancePoolNextResults 556 req, err := client.ListByInstancePoolPreparer(ctx, resourceGroupName, instancePoolName) 557 if err != nil { 558 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "ListByInstancePool", nil, "Failure preparing request") 559 return 560 } 561 562 resp, err := client.ListByInstancePoolSender(req) 563 if err != nil { 564 result.milr.Response = autorest.Response{Response: resp} 565 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "ListByInstancePool", resp, "Failure sending request") 566 return 567 } 568 569 result.milr, err = client.ListByInstancePoolResponder(resp) 570 if err != nil { 571 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "ListByInstancePool", resp, "Failure responding to request") 572 return 573 } 574 if result.milr.hasNextLink() && result.milr.IsEmpty() { 575 err = result.NextWithContext(ctx) 576 return 577 } 578 579 return 580} 581 582// ListByInstancePoolPreparer prepares the ListByInstancePool request. 583func (client ManagedInstancesClient) ListByInstancePoolPreparer(ctx context.Context, resourceGroupName string, instancePoolName string) (*http.Request, error) { 584 pathParameters := map[string]interface{}{ 585 "instancePoolName": autorest.Encode("path", instancePoolName), 586 "resourceGroupName": autorest.Encode("path", resourceGroupName), 587 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 588 } 589 590 const APIVersion = "2020-02-02-preview" 591 queryParameters := map[string]interface{}{ 592 "api-version": APIVersion, 593 } 594 595 preparer := autorest.CreatePreparer( 596 autorest.AsGet(), 597 autorest.WithBaseURL(client.BaseURI), 598 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/instancePools/{instancePoolName}/managedInstances", pathParameters), 599 autorest.WithQueryParameters(queryParameters)) 600 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 601} 602 603// ListByInstancePoolSender sends the ListByInstancePool request. The method will close the 604// http.Response Body if it receives an error. 605func (client ManagedInstancesClient) ListByInstancePoolSender(req *http.Request) (*http.Response, error) { 606 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 607} 608 609// ListByInstancePoolResponder handles the response to the ListByInstancePool request. The method always 610// closes the http.Response Body. 611func (client ManagedInstancesClient) ListByInstancePoolResponder(resp *http.Response) (result ManagedInstanceListResult, err error) { 612 err = autorest.Respond( 613 resp, 614 azure.WithErrorUnlessStatusCode(http.StatusOK), 615 autorest.ByUnmarshallingJSON(&result), 616 autorest.ByClosing()) 617 result.Response = autorest.Response{Response: resp} 618 return 619} 620 621// listByInstancePoolNextResults retrieves the next set of results, if any. 622func (client ManagedInstancesClient) listByInstancePoolNextResults(ctx context.Context, lastResults ManagedInstanceListResult) (result ManagedInstanceListResult, err error) { 623 req, err := lastResults.managedInstanceListResultPreparer(ctx) 624 if err != nil { 625 return result, autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listByInstancePoolNextResults", nil, "Failure preparing next results request") 626 } 627 if req == nil { 628 return 629 } 630 resp, err := client.ListByInstancePoolSender(req) 631 if err != nil { 632 result.Response = autorest.Response{Response: resp} 633 return result, autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listByInstancePoolNextResults", resp, "Failure sending next results request") 634 } 635 result, err = client.ListByInstancePoolResponder(resp) 636 if err != nil { 637 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listByInstancePoolNextResults", resp, "Failure responding to next results request") 638 } 639 return 640} 641 642// ListByInstancePoolComplete enumerates all values, automatically crossing page boundaries as required. 643func (client ManagedInstancesClient) ListByInstancePoolComplete(ctx context.Context, resourceGroupName string, instancePoolName string) (result ManagedInstanceListResultIterator, err error) { 644 if tracing.IsEnabled() { 645 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.ListByInstancePool") 646 defer func() { 647 sc := -1 648 if result.Response().Response.Response != nil { 649 sc = result.page.Response().Response.Response.StatusCode 650 } 651 tracing.EndSpan(ctx, sc, err) 652 }() 653 } 654 result.page, err = client.ListByInstancePool(ctx, resourceGroupName, instancePoolName) 655 return 656} 657 658// ListByResourceGroup gets a list of managed instances in a resource group. 659// Parameters: 660// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 661// from the Azure Resource Manager API or the portal. 662func (client ManagedInstancesClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ManagedInstanceListResultPage, err error) { 663 if tracing.IsEnabled() { 664 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.ListByResourceGroup") 665 defer func() { 666 sc := -1 667 if result.milr.Response.Response != nil { 668 sc = result.milr.Response.Response.StatusCode 669 } 670 tracing.EndSpan(ctx, sc, err) 671 }() 672 } 673 result.fn = client.listByResourceGroupNextResults 674 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 675 if err != nil { 676 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "ListByResourceGroup", nil, "Failure preparing request") 677 return 678 } 679 680 resp, err := client.ListByResourceGroupSender(req) 681 if err != nil { 682 result.milr.Response = autorest.Response{Response: resp} 683 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "ListByResourceGroup", resp, "Failure sending request") 684 return 685 } 686 687 result.milr, err = client.ListByResourceGroupResponder(resp) 688 if err != nil { 689 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "ListByResourceGroup", resp, "Failure responding to request") 690 return 691 } 692 if result.milr.hasNextLink() && result.milr.IsEmpty() { 693 err = result.NextWithContext(ctx) 694 return 695 } 696 697 return 698} 699 700// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 701func (client ManagedInstancesClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 702 pathParameters := map[string]interface{}{ 703 "resourceGroupName": autorest.Encode("path", resourceGroupName), 704 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 705 } 706 707 const APIVersion = "2020-02-02-preview" 708 queryParameters := map[string]interface{}{ 709 "api-version": APIVersion, 710 } 711 712 preparer := autorest.CreatePreparer( 713 autorest.AsGet(), 714 autorest.WithBaseURL(client.BaseURI), 715 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/managedInstances", pathParameters), 716 autorest.WithQueryParameters(queryParameters)) 717 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 718} 719 720// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 721// http.Response Body if it receives an error. 722func (client ManagedInstancesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 723 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 724} 725 726// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 727// closes the http.Response Body. 728func (client ManagedInstancesClient) ListByResourceGroupResponder(resp *http.Response) (result ManagedInstanceListResult, err error) { 729 err = autorest.Respond( 730 resp, 731 azure.WithErrorUnlessStatusCode(http.StatusOK), 732 autorest.ByUnmarshallingJSON(&result), 733 autorest.ByClosing()) 734 result.Response = autorest.Response{Response: resp} 735 return 736} 737 738// listByResourceGroupNextResults retrieves the next set of results, if any. 739func (client ManagedInstancesClient) listByResourceGroupNextResults(ctx context.Context, lastResults ManagedInstanceListResult) (result ManagedInstanceListResult, err error) { 740 req, err := lastResults.managedInstanceListResultPreparer(ctx) 741 if err != nil { 742 return result, autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 743 } 744 if req == nil { 745 return 746 } 747 resp, err := client.ListByResourceGroupSender(req) 748 if err != nil { 749 result.Response = autorest.Response{Response: resp} 750 return result, autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 751 } 752 result, err = client.ListByResourceGroupResponder(resp) 753 if err != nil { 754 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 755 } 756 return 757} 758 759// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 760func (client ManagedInstancesClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ManagedInstanceListResultIterator, err error) { 761 if tracing.IsEnabled() { 762 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.ListByResourceGroup") 763 defer func() { 764 sc := -1 765 if result.Response().Response.Response != nil { 766 sc = result.page.Response().Response.Response.StatusCode 767 } 768 tracing.EndSpan(ctx, sc, err) 769 }() 770 } 771 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 772 return 773} 774 775// Update updates a managed instance. 776// Parameters: 777// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 778// from the Azure Resource Manager API or the portal. 779// managedInstanceName - the name of the managed instance. 780// parameters - the requested managed instance resource state. 781func (client ManagedInstancesClient) Update(ctx context.Context, resourceGroupName string, managedInstanceName string, parameters ManagedInstanceUpdate) (result ManagedInstancesUpdateFuture, err error) { 782 if tracing.IsEnabled() { 783 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedInstancesClient.Update") 784 defer func() { 785 sc := -1 786 if result.Response() != nil { 787 sc = result.Response().StatusCode 788 } 789 tracing.EndSpan(ctx, sc, err) 790 }() 791 } 792 req, err := client.UpdatePreparer(ctx, resourceGroupName, managedInstanceName, parameters) 793 if err != nil { 794 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Update", nil, "Failure preparing request") 795 return 796 } 797 798 result, err = client.UpdateSender(req) 799 if err != nil { 800 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesClient", "Update", nil, "Failure sending request") 801 return 802 } 803 804 return 805} 806 807// UpdatePreparer prepares the Update request. 808func (client ManagedInstancesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, managedInstanceName string, parameters ManagedInstanceUpdate) (*http.Request, error) { 809 pathParameters := map[string]interface{}{ 810 "managedInstanceName": autorest.Encode("path", managedInstanceName), 811 "resourceGroupName": autorest.Encode("path", resourceGroupName), 812 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 813 } 814 815 const APIVersion = "2020-02-02-preview" 816 queryParameters := map[string]interface{}{ 817 "api-version": APIVersion, 818 } 819 820 preparer := autorest.CreatePreparer( 821 autorest.AsContentType("application/json; charset=utf-8"), 822 autorest.AsPatch(), 823 autorest.WithBaseURL(client.BaseURI), 824 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/managedInstances/{managedInstanceName}", pathParameters), 825 autorest.WithJSON(parameters), 826 autorest.WithQueryParameters(queryParameters)) 827 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 828} 829 830// UpdateSender sends the Update request. The method will close the 831// http.Response Body if it receives an error. 832func (client ManagedInstancesClient) UpdateSender(req *http.Request) (future ManagedInstancesUpdateFuture, err error) { 833 var resp *http.Response 834 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 835 if err != nil { 836 return 837 } 838 var azf azure.Future 839 azf, err = azure.NewFutureFromResponse(resp) 840 future.FutureAPI = &azf 841 future.Result = func(client ManagedInstancesClient) (mi ManagedInstance, err error) { 842 var done bool 843 done, err = future.DoneWithContext(context.Background(), client) 844 if err != nil { 845 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesUpdateFuture", "Result", future.Response(), "Polling failure") 846 return 847 } 848 if !done { 849 err = azure.NewAsyncOpIncompleteError("sql.ManagedInstancesUpdateFuture") 850 return 851 } 852 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 853 if mi.Response.Response, err = future.GetResult(sender); err == nil && mi.Response.Response.StatusCode != http.StatusNoContent { 854 mi, err = client.UpdateResponder(mi.Response.Response) 855 if err != nil { 856 err = autorest.NewErrorWithError(err, "sql.ManagedInstancesUpdateFuture", "Result", mi.Response.Response, "Failure responding to request") 857 } 858 } 859 return 860 } 861 return 862} 863 864// UpdateResponder handles the response to the Update request. The method always 865// closes the http.Response Body. 866func (client ManagedInstancesClient) UpdateResponder(resp *http.Response) (result ManagedInstance, err error) { 867 err = autorest.Respond( 868 resp, 869 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 870 autorest.ByUnmarshallingJSON(&result), 871 autorest.ByClosing()) 872 result.Response = autorest.Response{Response: resp} 873 return 874} 875