1package sql 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 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/tracing" 14 "net/http" 15) 16 17// SyncGroupsClient is the the Azure SQL Database management API provides a RESTful set of web services that interact 18// with Azure SQL Database services to manage your databases. The API enables you to create, retrieve, update, and 19// delete databases. 20type SyncGroupsClient struct { 21 BaseClient 22} 23 24// NewSyncGroupsClient creates an instance of the SyncGroupsClient client. 25func NewSyncGroupsClient(subscriptionID string) SyncGroupsClient { 26 return NewSyncGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID) 27} 28 29// NewSyncGroupsClientWithBaseURI creates an instance of the SyncGroupsClient client using a custom endpoint. Use this 30// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 31func NewSyncGroupsClientWithBaseURI(baseURI string, subscriptionID string) SyncGroupsClient { 32 return SyncGroupsClient{NewWithBaseURI(baseURI, subscriptionID)} 33} 34 35// CancelSync cancels a sync group synchronization. 36// Parameters: 37// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 38// from the Azure Resource Manager API or the portal. 39// serverName - the name of the server. 40// databaseName - the name of the database on which the sync group is hosted. 41// syncGroupName - the name of the sync group. 42func (client SyncGroupsClient) CancelSync(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result autorest.Response, err error) { 43 if tracing.IsEnabled() { 44 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.CancelSync") 45 defer func() { 46 sc := -1 47 if result.Response != nil { 48 sc = result.Response.StatusCode 49 } 50 tracing.EndSpan(ctx, sc, err) 51 }() 52 } 53 req, err := client.CancelSyncPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 54 if err != nil { 55 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CancelSync", nil, "Failure preparing request") 56 return 57 } 58 59 resp, err := client.CancelSyncSender(req) 60 if err != nil { 61 result.Response = resp 62 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CancelSync", resp, "Failure sending request") 63 return 64 } 65 66 result, err = client.CancelSyncResponder(resp) 67 if err != nil { 68 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CancelSync", resp, "Failure responding to request") 69 return 70 } 71 72 return 73} 74 75// CancelSyncPreparer prepares the CancelSync request. 76func (client SyncGroupsClient) CancelSyncPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 77 pathParameters := map[string]interface{}{ 78 "databaseName": autorest.Encode("path", databaseName), 79 "resourceGroupName": autorest.Encode("path", resourceGroupName), 80 "serverName": autorest.Encode("path", serverName), 81 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 82 "syncGroupName": autorest.Encode("path", syncGroupName), 83 } 84 85 const APIVersion = "2019-06-01-preview" 86 queryParameters := map[string]interface{}{ 87 "api-version": APIVersion, 88 } 89 90 preparer := autorest.CreatePreparer( 91 autorest.AsPost(), 92 autorest.WithBaseURL(client.BaseURI), 93 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/cancelSync", pathParameters), 94 autorest.WithQueryParameters(queryParameters)) 95 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 96} 97 98// CancelSyncSender sends the CancelSync request. The method will close the 99// http.Response Body if it receives an error. 100func (client SyncGroupsClient) CancelSyncSender(req *http.Request) (*http.Response, error) { 101 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 102} 103 104// CancelSyncResponder handles the response to the CancelSync request. The method always 105// closes the http.Response Body. 106func (client SyncGroupsClient) CancelSyncResponder(resp *http.Response) (result autorest.Response, err error) { 107 err = autorest.Respond( 108 resp, 109 azure.WithErrorUnlessStatusCode(http.StatusOK), 110 autorest.ByClosing()) 111 result.Response = resp 112 return 113} 114 115// CreateOrUpdate creates or updates a sync group. 116// Parameters: 117// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 118// from the Azure Resource Manager API or the portal. 119// serverName - the name of the server. 120// databaseName - the name of the database on which the sync group is hosted. 121// syncGroupName - the name of the sync group. 122// parameters - the requested sync group resource state. 123func (client SyncGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (result SyncGroupsCreateOrUpdateFuture, err error) { 124 if tracing.IsEnabled() { 125 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.CreateOrUpdate") 126 defer func() { 127 sc := -1 128 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 129 sc = result.FutureAPI.Response().StatusCode 130 } 131 tracing.EndSpan(ctx, sc, err) 132 }() 133 } 134 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName, parameters) 135 if err != nil { 136 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CreateOrUpdate", nil, "Failure preparing request") 137 return 138 } 139 140 result, err = client.CreateOrUpdateSender(req) 141 if err != nil { 142 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "CreateOrUpdate", nil, "Failure sending request") 143 return 144 } 145 146 return 147} 148 149// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 150func (client SyncGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (*http.Request, error) { 151 pathParameters := map[string]interface{}{ 152 "databaseName": autorest.Encode("path", databaseName), 153 "resourceGroupName": autorest.Encode("path", resourceGroupName), 154 "serverName": autorest.Encode("path", serverName), 155 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 156 "syncGroupName": autorest.Encode("path", syncGroupName), 157 } 158 159 const APIVersion = "2019-06-01-preview" 160 queryParameters := map[string]interface{}{ 161 "api-version": APIVersion, 162 } 163 164 preparer := autorest.CreatePreparer( 165 autorest.AsContentType("application/json; charset=utf-8"), 166 autorest.AsPut(), 167 autorest.WithBaseURL(client.BaseURI), 168 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 169 autorest.WithJSON(parameters), 170 autorest.WithQueryParameters(queryParameters)) 171 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 172} 173 174// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 175// http.Response Body if it receives an error. 176func (client SyncGroupsClient) CreateOrUpdateSender(req *http.Request) (future SyncGroupsCreateOrUpdateFuture, err error) { 177 var resp *http.Response 178 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 179 if err != nil { 180 return 181 } 182 var azf azure.Future 183 azf, err = azure.NewFutureFromResponse(resp) 184 future.FutureAPI = &azf 185 future.Result = future.result 186 return 187} 188 189// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 190// closes the http.Response Body. 191func (client SyncGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result SyncGroup, err error) { 192 err = autorest.Respond( 193 resp, 194 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 195 autorest.ByUnmarshallingJSON(&result), 196 autorest.ByClosing()) 197 result.Response = autorest.Response{Response: resp} 198 return 199} 200 201// Delete deletes a sync group. 202// Parameters: 203// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 204// from the Azure Resource Manager API or the portal. 205// serverName - the name of the server. 206// databaseName - the name of the database on which the sync group is hosted. 207// syncGroupName - the name of the sync group. 208func (client SyncGroupsClient) Delete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncGroupsDeleteFuture, err error) { 209 if tracing.IsEnabled() { 210 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.Delete") 211 defer func() { 212 sc := -1 213 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 214 sc = result.FutureAPI.Response().StatusCode 215 } 216 tracing.EndSpan(ctx, sc, err) 217 }() 218 } 219 req, err := client.DeletePreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 220 if err != nil { 221 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Delete", nil, "Failure preparing request") 222 return 223 } 224 225 result, err = client.DeleteSender(req) 226 if err != nil { 227 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Delete", nil, "Failure sending request") 228 return 229 } 230 231 return 232} 233 234// DeletePreparer prepares the Delete request. 235func (client SyncGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 236 pathParameters := map[string]interface{}{ 237 "databaseName": autorest.Encode("path", databaseName), 238 "resourceGroupName": autorest.Encode("path", resourceGroupName), 239 "serverName": autorest.Encode("path", serverName), 240 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 241 "syncGroupName": autorest.Encode("path", syncGroupName), 242 } 243 244 const APIVersion = "2019-06-01-preview" 245 queryParameters := map[string]interface{}{ 246 "api-version": APIVersion, 247 } 248 249 preparer := autorest.CreatePreparer( 250 autorest.AsDelete(), 251 autorest.WithBaseURL(client.BaseURI), 252 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 253 autorest.WithQueryParameters(queryParameters)) 254 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 255} 256 257// DeleteSender sends the Delete request. The method will close the 258// http.Response Body if it receives an error. 259func (client SyncGroupsClient) DeleteSender(req *http.Request) (future SyncGroupsDeleteFuture, err error) { 260 var resp *http.Response 261 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 262 if err != nil { 263 return 264 } 265 var azf azure.Future 266 azf, err = azure.NewFutureFromResponse(resp) 267 future.FutureAPI = &azf 268 future.Result = future.result 269 return 270} 271 272// DeleteResponder handles the response to the Delete request. The method always 273// closes the http.Response Body. 274func (client SyncGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 275 err = autorest.Respond( 276 resp, 277 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 278 autorest.ByClosing()) 279 result.Response = resp 280 return 281} 282 283// Get gets a sync group. 284// Parameters: 285// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 286// from the Azure Resource Manager API or the portal. 287// serverName - the name of the server. 288// databaseName - the name of the database on which the sync group is hosted. 289// syncGroupName - the name of the sync group. 290func (client SyncGroupsClient) Get(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncGroup, err error) { 291 if tracing.IsEnabled() { 292 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.Get") 293 defer func() { 294 sc := -1 295 if result.Response.Response != nil { 296 sc = result.Response.Response.StatusCode 297 } 298 tracing.EndSpan(ctx, sc, err) 299 }() 300 } 301 req, err := client.GetPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 302 if err != nil { 303 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Get", nil, "Failure preparing request") 304 return 305 } 306 307 resp, err := client.GetSender(req) 308 if err != nil { 309 result.Response = autorest.Response{Response: resp} 310 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Get", resp, "Failure sending request") 311 return 312 } 313 314 result, err = client.GetResponder(resp) 315 if err != nil { 316 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Get", resp, "Failure responding to request") 317 return 318 } 319 320 return 321} 322 323// GetPreparer prepares the Get request. 324func (client SyncGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 325 pathParameters := map[string]interface{}{ 326 "databaseName": autorest.Encode("path", databaseName), 327 "resourceGroupName": autorest.Encode("path", resourceGroupName), 328 "serverName": autorest.Encode("path", serverName), 329 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 330 "syncGroupName": autorest.Encode("path", syncGroupName), 331 } 332 333 const APIVersion = "2019-06-01-preview" 334 queryParameters := map[string]interface{}{ 335 "api-version": APIVersion, 336 } 337 338 preparer := autorest.CreatePreparer( 339 autorest.AsGet(), 340 autorest.WithBaseURL(client.BaseURI), 341 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 342 autorest.WithQueryParameters(queryParameters)) 343 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 344} 345 346// GetSender sends the Get request. The method will close the 347// http.Response Body if it receives an error. 348func (client SyncGroupsClient) GetSender(req *http.Request) (*http.Response, error) { 349 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 350} 351 352// GetResponder handles the response to the Get request. The method always 353// closes the http.Response Body. 354func (client SyncGroupsClient) GetResponder(resp *http.Response) (result SyncGroup, err error) { 355 err = autorest.Respond( 356 resp, 357 azure.WithErrorUnlessStatusCode(http.StatusOK), 358 autorest.ByUnmarshallingJSON(&result), 359 autorest.ByClosing()) 360 result.Response = autorest.Response{Response: resp} 361 return 362} 363 364// ListByDatabase lists sync groups under a hub database. 365// Parameters: 366// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 367// from the Azure Resource Manager API or the portal. 368// serverName - the name of the server. 369// databaseName - the name of the database on which the sync group is hosted. 370func (client SyncGroupsClient) ListByDatabase(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (result SyncGroupListResultPage, err error) { 371 if tracing.IsEnabled() { 372 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListByDatabase") 373 defer func() { 374 sc := -1 375 if result.sglr.Response.Response != nil { 376 sc = result.sglr.Response.Response.StatusCode 377 } 378 tracing.EndSpan(ctx, sc, err) 379 }() 380 } 381 result.fn = client.listByDatabaseNextResults 382 req, err := client.ListByDatabasePreparer(ctx, resourceGroupName, serverName, databaseName) 383 if err != nil { 384 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListByDatabase", nil, "Failure preparing request") 385 return 386 } 387 388 resp, err := client.ListByDatabaseSender(req) 389 if err != nil { 390 result.sglr.Response = autorest.Response{Response: resp} 391 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListByDatabase", resp, "Failure sending request") 392 return 393 } 394 395 result.sglr, err = client.ListByDatabaseResponder(resp) 396 if err != nil { 397 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListByDatabase", resp, "Failure responding to request") 398 return 399 } 400 if result.sglr.hasNextLink() && result.sglr.IsEmpty() { 401 err = result.NextWithContext(ctx) 402 return 403 } 404 405 return 406} 407 408// ListByDatabasePreparer prepares the ListByDatabase request. 409func (client SyncGroupsClient) ListByDatabasePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (*http.Request, error) { 410 pathParameters := map[string]interface{}{ 411 "databaseName": autorest.Encode("path", databaseName), 412 "resourceGroupName": autorest.Encode("path", resourceGroupName), 413 "serverName": autorest.Encode("path", serverName), 414 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 415 } 416 417 const APIVersion = "2019-06-01-preview" 418 queryParameters := map[string]interface{}{ 419 "api-version": APIVersion, 420 } 421 422 preparer := autorest.CreatePreparer( 423 autorest.AsGet(), 424 autorest.WithBaseURL(client.BaseURI), 425 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups", pathParameters), 426 autorest.WithQueryParameters(queryParameters)) 427 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 428} 429 430// ListByDatabaseSender sends the ListByDatabase request. The method will close the 431// http.Response Body if it receives an error. 432func (client SyncGroupsClient) ListByDatabaseSender(req *http.Request) (*http.Response, error) { 433 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 434} 435 436// ListByDatabaseResponder handles the response to the ListByDatabase request. The method always 437// closes the http.Response Body. 438func (client SyncGroupsClient) ListByDatabaseResponder(resp *http.Response) (result SyncGroupListResult, err error) { 439 err = autorest.Respond( 440 resp, 441 azure.WithErrorUnlessStatusCode(http.StatusOK), 442 autorest.ByUnmarshallingJSON(&result), 443 autorest.ByClosing()) 444 result.Response = autorest.Response{Response: resp} 445 return 446} 447 448// listByDatabaseNextResults retrieves the next set of results, if any. 449func (client SyncGroupsClient) listByDatabaseNextResults(ctx context.Context, lastResults SyncGroupListResult) (result SyncGroupListResult, err error) { 450 req, err := lastResults.syncGroupListResultPreparer(ctx) 451 if err != nil { 452 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listByDatabaseNextResults", nil, "Failure preparing next results request") 453 } 454 if req == nil { 455 return 456 } 457 resp, err := client.ListByDatabaseSender(req) 458 if err != nil { 459 result.Response = autorest.Response{Response: resp} 460 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listByDatabaseNextResults", resp, "Failure sending next results request") 461 } 462 result, err = client.ListByDatabaseResponder(resp) 463 if err != nil { 464 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listByDatabaseNextResults", resp, "Failure responding to next results request") 465 } 466 return 467} 468 469// ListByDatabaseComplete enumerates all values, automatically crossing page boundaries as required. 470func (client SyncGroupsClient) ListByDatabaseComplete(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (result SyncGroupListResultIterator, err error) { 471 if tracing.IsEnabled() { 472 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListByDatabase") 473 defer func() { 474 sc := -1 475 if result.Response().Response.Response != nil { 476 sc = result.page.Response().Response.Response.StatusCode 477 } 478 tracing.EndSpan(ctx, sc, err) 479 }() 480 } 481 result.page, err = client.ListByDatabase(ctx, resourceGroupName, serverName, databaseName) 482 return 483} 484 485// ListHubSchemas gets a collection of hub database schemas. 486// Parameters: 487// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 488// from the Azure Resource Manager API or the portal. 489// serverName - the name of the server. 490// databaseName - the name of the database on which the sync group is hosted. 491// syncGroupName - the name of the sync group. 492func (client SyncGroupsClient) ListHubSchemas(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncFullSchemaPropertiesListResultPage, err error) { 493 if tracing.IsEnabled() { 494 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListHubSchemas") 495 defer func() { 496 sc := -1 497 if result.sfsplr.Response.Response != nil { 498 sc = result.sfsplr.Response.Response.StatusCode 499 } 500 tracing.EndSpan(ctx, sc, err) 501 }() 502 } 503 result.fn = client.listHubSchemasNextResults 504 req, err := client.ListHubSchemasPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 505 if err != nil { 506 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListHubSchemas", nil, "Failure preparing request") 507 return 508 } 509 510 resp, err := client.ListHubSchemasSender(req) 511 if err != nil { 512 result.sfsplr.Response = autorest.Response{Response: resp} 513 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListHubSchemas", resp, "Failure sending request") 514 return 515 } 516 517 result.sfsplr, err = client.ListHubSchemasResponder(resp) 518 if err != nil { 519 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListHubSchemas", resp, "Failure responding to request") 520 return 521 } 522 if result.sfsplr.hasNextLink() && result.sfsplr.IsEmpty() { 523 err = result.NextWithContext(ctx) 524 return 525 } 526 527 return 528} 529 530// ListHubSchemasPreparer prepares the ListHubSchemas request. 531func (client SyncGroupsClient) ListHubSchemasPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 532 pathParameters := map[string]interface{}{ 533 "databaseName": autorest.Encode("path", databaseName), 534 "resourceGroupName": autorest.Encode("path", resourceGroupName), 535 "serverName": autorest.Encode("path", serverName), 536 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 537 "syncGroupName": autorest.Encode("path", syncGroupName), 538 } 539 540 const APIVersion = "2019-06-01-preview" 541 queryParameters := map[string]interface{}{ 542 "api-version": APIVersion, 543 } 544 545 preparer := autorest.CreatePreparer( 546 autorest.AsGet(), 547 autorest.WithBaseURL(client.BaseURI), 548 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/hubSchemas", pathParameters), 549 autorest.WithQueryParameters(queryParameters)) 550 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 551} 552 553// ListHubSchemasSender sends the ListHubSchemas request. The method will close the 554// http.Response Body if it receives an error. 555func (client SyncGroupsClient) ListHubSchemasSender(req *http.Request) (*http.Response, error) { 556 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 557} 558 559// ListHubSchemasResponder handles the response to the ListHubSchemas request. The method always 560// closes the http.Response Body. 561func (client SyncGroupsClient) ListHubSchemasResponder(resp *http.Response) (result SyncFullSchemaPropertiesListResult, err error) { 562 err = autorest.Respond( 563 resp, 564 azure.WithErrorUnlessStatusCode(http.StatusOK), 565 autorest.ByUnmarshallingJSON(&result), 566 autorest.ByClosing()) 567 result.Response = autorest.Response{Response: resp} 568 return 569} 570 571// listHubSchemasNextResults retrieves the next set of results, if any. 572func (client SyncGroupsClient) listHubSchemasNextResults(ctx context.Context, lastResults SyncFullSchemaPropertiesListResult) (result SyncFullSchemaPropertiesListResult, err error) { 573 req, err := lastResults.syncFullSchemaPropertiesListResultPreparer(ctx) 574 if err != nil { 575 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listHubSchemasNextResults", nil, "Failure preparing next results request") 576 } 577 if req == nil { 578 return 579 } 580 resp, err := client.ListHubSchemasSender(req) 581 if err != nil { 582 result.Response = autorest.Response{Response: resp} 583 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listHubSchemasNextResults", resp, "Failure sending next results request") 584 } 585 result, err = client.ListHubSchemasResponder(resp) 586 if err != nil { 587 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listHubSchemasNextResults", resp, "Failure responding to next results request") 588 } 589 return 590} 591 592// ListHubSchemasComplete enumerates all values, automatically crossing page boundaries as required. 593func (client SyncGroupsClient) ListHubSchemasComplete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncFullSchemaPropertiesListResultIterator, err error) { 594 if tracing.IsEnabled() { 595 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListHubSchemas") 596 defer func() { 597 sc := -1 598 if result.Response().Response.Response != nil { 599 sc = result.page.Response().Response.Response.StatusCode 600 } 601 tracing.EndSpan(ctx, sc, err) 602 }() 603 } 604 result.page, err = client.ListHubSchemas(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 605 return 606} 607 608// ListLogs gets a collection of sync group logs. 609// Parameters: 610// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 611// from the Azure Resource Manager API or the portal. 612// serverName - the name of the server. 613// databaseName - the name of the database on which the sync group is hosted. 614// syncGroupName - the name of the sync group. 615// startTime - get logs generated after this time. 616// endTime - get logs generated before this time. 617// typeParameter - the types of logs to retrieve. 618// continuationToken - the continuation token for this operation. 619func (client SyncGroupsClient) ListLogs(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, startTime string, endTime string, typeParameter string, continuationToken string) (result SyncGroupLogListResultPage, err error) { 620 if tracing.IsEnabled() { 621 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListLogs") 622 defer func() { 623 sc := -1 624 if result.sgllr.Response.Response != nil { 625 sc = result.sgllr.Response.Response.StatusCode 626 } 627 tracing.EndSpan(ctx, sc, err) 628 }() 629 } 630 result.fn = client.listLogsNextResults 631 req, err := client.ListLogsPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName, startTime, endTime, typeParameter, continuationToken) 632 if err != nil { 633 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListLogs", nil, "Failure preparing request") 634 return 635 } 636 637 resp, err := client.ListLogsSender(req) 638 if err != nil { 639 result.sgllr.Response = autorest.Response{Response: resp} 640 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListLogs", resp, "Failure sending request") 641 return 642 } 643 644 result.sgllr, err = client.ListLogsResponder(resp) 645 if err != nil { 646 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListLogs", resp, "Failure responding to request") 647 return 648 } 649 if result.sgllr.hasNextLink() && result.sgllr.IsEmpty() { 650 err = result.NextWithContext(ctx) 651 return 652 } 653 654 return 655} 656 657// ListLogsPreparer prepares the ListLogs request. 658func (client SyncGroupsClient) ListLogsPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, startTime string, endTime string, typeParameter string, continuationToken string) (*http.Request, error) { 659 pathParameters := map[string]interface{}{ 660 "databaseName": autorest.Encode("path", databaseName), 661 "resourceGroupName": autorest.Encode("path", resourceGroupName), 662 "serverName": autorest.Encode("path", serverName), 663 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 664 "syncGroupName": autorest.Encode("path", syncGroupName), 665 } 666 667 const APIVersion = "2019-06-01-preview" 668 queryParameters := map[string]interface{}{ 669 "api-version": APIVersion, 670 "endTime": autorest.Encode("query", endTime), 671 "startTime": autorest.Encode("query", startTime), 672 "type": autorest.Encode("query", typeParameter), 673 } 674 if len(continuationToken) > 0 { 675 queryParameters["continuationToken"] = autorest.Encode("query", continuationToken) 676 } 677 678 preparer := autorest.CreatePreparer( 679 autorest.AsGet(), 680 autorest.WithBaseURL(client.BaseURI), 681 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/logs", pathParameters), 682 autorest.WithQueryParameters(queryParameters)) 683 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 684} 685 686// ListLogsSender sends the ListLogs request. The method will close the 687// http.Response Body if it receives an error. 688func (client SyncGroupsClient) ListLogsSender(req *http.Request) (*http.Response, error) { 689 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 690} 691 692// ListLogsResponder handles the response to the ListLogs request. The method always 693// closes the http.Response Body. 694func (client SyncGroupsClient) ListLogsResponder(resp *http.Response) (result SyncGroupLogListResult, err error) { 695 err = autorest.Respond( 696 resp, 697 azure.WithErrorUnlessStatusCode(http.StatusOK), 698 autorest.ByUnmarshallingJSON(&result), 699 autorest.ByClosing()) 700 result.Response = autorest.Response{Response: resp} 701 return 702} 703 704// listLogsNextResults retrieves the next set of results, if any. 705func (client SyncGroupsClient) listLogsNextResults(ctx context.Context, lastResults SyncGroupLogListResult) (result SyncGroupLogListResult, err error) { 706 req, err := lastResults.syncGroupLogListResultPreparer(ctx) 707 if err != nil { 708 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listLogsNextResults", nil, "Failure preparing next results request") 709 } 710 if req == nil { 711 return 712 } 713 resp, err := client.ListLogsSender(req) 714 if err != nil { 715 result.Response = autorest.Response{Response: resp} 716 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listLogsNextResults", resp, "Failure sending next results request") 717 } 718 result, err = client.ListLogsResponder(resp) 719 if err != nil { 720 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listLogsNextResults", resp, "Failure responding to next results request") 721 } 722 return 723} 724 725// ListLogsComplete enumerates all values, automatically crossing page boundaries as required. 726func (client SyncGroupsClient) ListLogsComplete(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, startTime string, endTime string, typeParameter string, continuationToken string) (result SyncGroupLogListResultIterator, err error) { 727 if tracing.IsEnabled() { 728 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListLogs") 729 defer func() { 730 sc := -1 731 if result.Response().Response.Response != nil { 732 sc = result.page.Response().Response.Response.StatusCode 733 } 734 tracing.EndSpan(ctx, sc, err) 735 }() 736 } 737 result.page, err = client.ListLogs(ctx, resourceGroupName, serverName, databaseName, syncGroupName, startTime, endTime, typeParameter, continuationToken) 738 return 739} 740 741// ListSyncDatabaseIds gets a collection of sync database ids. 742// Parameters: 743// locationName - the name of the region where the resource is located. 744func (client SyncGroupsClient) ListSyncDatabaseIds(ctx context.Context, locationName string) (result SyncDatabaseIDListResultPage, err error) { 745 if tracing.IsEnabled() { 746 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListSyncDatabaseIds") 747 defer func() { 748 sc := -1 749 if result.sdilr.Response.Response != nil { 750 sc = result.sdilr.Response.Response.StatusCode 751 } 752 tracing.EndSpan(ctx, sc, err) 753 }() 754 } 755 result.fn = client.listSyncDatabaseIdsNextResults 756 req, err := client.ListSyncDatabaseIdsPreparer(ctx, locationName) 757 if err != nil { 758 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListSyncDatabaseIds", nil, "Failure preparing request") 759 return 760 } 761 762 resp, err := client.ListSyncDatabaseIdsSender(req) 763 if err != nil { 764 result.sdilr.Response = autorest.Response{Response: resp} 765 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListSyncDatabaseIds", resp, "Failure sending request") 766 return 767 } 768 769 result.sdilr, err = client.ListSyncDatabaseIdsResponder(resp) 770 if err != nil { 771 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "ListSyncDatabaseIds", resp, "Failure responding to request") 772 return 773 } 774 if result.sdilr.hasNextLink() && result.sdilr.IsEmpty() { 775 err = result.NextWithContext(ctx) 776 return 777 } 778 779 return 780} 781 782// ListSyncDatabaseIdsPreparer prepares the ListSyncDatabaseIds request. 783func (client SyncGroupsClient) ListSyncDatabaseIdsPreparer(ctx context.Context, locationName string) (*http.Request, error) { 784 pathParameters := map[string]interface{}{ 785 "locationName": autorest.Encode("path", locationName), 786 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 787 } 788 789 const APIVersion = "2019-06-01-preview" 790 queryParameters := map[string]interface{}{ 791 "api-version": APIVersion, 792 } 793 794 preparer := autorest.CreatePreparer( 795 autorest.AsGet(), 796 autorest.WithBaseURL(client.BaseURI), 797 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Sql/locations/{locationName}/syncDatabaseIds", pathParameters), 798 autorest.WithQueryParameters(queryParameters)) 799 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 800} 801 802// ListSyncDatabaseIdsSender sends the ListSyncDatabaseIds request. The method will close the 803// http.Response Body if it receives an error. 804func (client SyncGroupsClient) ListSyncDatabaseIdsSender(req *http.Request) (*http.Response, error) { 805 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 806} 807 808// ListSyncDatabaseIdsResponder handles the response to the ListSyncDatabaseIds request. The method always 809// closes the http.Response Body. 810func (client SyncGroupsClient) ListSyncDatabaseIdsResponder(resp *http.Response) (result SyncDatabaseIDListResult, err error) { 811 err = autorest.Respond( 812 resp, 813 azure.WithErrorUnlessStatusCode(http.StatusOK), 814 autorest.ByUnmarshallingJSON(&result), 815 autorest.ByClosing()) 816 result.Response = autorest.Response{Response: resp} 817 return 818} 819 820// listSyncDatabaseIdsNextResults retrieves the next set of results, if any. 821func (client SyncGroupsClient) listSyncDatabaseIdsNextResults(ctx context.Context, lastResults SyncDatabaseIDListResult) (result SyncDatabaseIDListResult, err error) { 822 req, err := lastResults.syncDatabaseIDListResultPreparer(ctx) 823 if err != nil { 824 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listSyncDatabaseIdsNextResults", nil, "Failure preparing next results request") 825 } 826 if req == nil { 827 return 828 } 829 resp, err := client.ListSyncDatabaseIdsSender(req) 830 if err != nil { 831 result.Response = autorest.Response{Response: resp} 832 return result, autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listSyncDatabaseIdsNextResults", resp, "Failure sending next results request") 833 } 834 result, err = client.ListSyncDatabaseIdsResponder(resp) 835 if err != nil { 836 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "listSyncDatabaseIdsNextResults", resp, "Failure responding to next results request") 837 } 838 return 839} 840 841// ListSyncDatabaseIdsComplete enumerates all values, automatically crossing page boundaries as required. 842func (client SyncGroupsClient) ListSyncDatabaseIdsComplete(ctx context.Context, locationName string) (result SyncDatabaseIDListResultIterator, err error) { 843 if tracing.IsEnabled() { 844 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.ListSyncDatabaseIds") 845 defer func() { 846 sc := -1 847 if result.Response().Response.Response != nil { 848 sc = result.page.Response().Response.Response.StatusCode 849 } 850 tracing.EndSpan(ctx, sc, err) 851 }() 852 } 853 result.page, err = client.ListSyncDatabaseIds(ctx, locationName) 854 return 855} 856 857// RefreshHubSchema refreshes a hub database schema. 858// Parameters: 859// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 860// from the Azure Resource Manager API or the portal. 861// serverName - the name of the server. 862// databaseName - the name of the database on which the sync group is hosted. 863// syncGroupName - the name of the sync group. 864func (client SyncGroupsClient) RefreshHubSchema(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result SyncGroupsRefreshHubSchemaFuture, err error) { 865 if tracing.IsEnabled() { 866 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.RefreshHubSchema") 867 defer func() { 868 sc := -1 869 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 870 sc = result.FutureAPI.Response().StatusCode 871 } 872 tracing.EndSpan(ctx, sc, err) 873 }() 874 } 875 req, err := client.RefreshHubSchemaPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 876 if err != nil { 877 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "RefreshHubSchema", nil, "Failure preparing request") 878 return 879 } 880 881 result, err = client.RefreshHubSchemaSender(req) 882 if err != nil { 883 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "RefreshHubSchema", nil, "Failure sending request") 884 return 885 } 886 887 return 888} 889 890// RefreshHubSchemaPreparer prepares the RefreshHubSchema request. 891func (client SyncGroupsClient) RefreshHubSchemaPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 892 pathParameters := map[string]interface{}{ 893 "databaseName": autorest.Encode("path", databaseName), 894 "resourceGroupName": autorest.Encode("path", resourceGroupName), 895 "serverName": autorest.Encode("path", serverName), 896 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 897 "syncGroupName": autorest.Encode("path", syncGroupName), 898 } 899 900 const APIVersion = "2019-06-01-preview" 901 queryParameters := map[string]interface{}{ 902 "api-version": APIVersion, 903 } 904 905 preparer := autorest.CreatePreparer( 906 autorest.AsPost(), 907 autorest.WithBaseURL(client.BaseURI), 908 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/refreshHubSchema", pathParameters), 909 autorest.WithQueryParameters(queryParameters)) 910 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 911} 912 913// RefreshHubSchemaSender sends the RefreshHubSchema request. The method will close the 914// http.Response Body if it receives an error. 915func (client SyncGroupsClient) RefreshHubSchemaSender(req *http.Request) (future SyncGroupsRefreshHubSchemaFuture, err error) { 916 var resp *http.Response 917 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 918 if err != nil { 919 return 920 } 921 var azf azure.Future 922 azf, err = azure.NewFutureFromResponse(resp) 923 future.FutureAPI = &azf 924 future.Result = future.result 925 return 926} 927 928// RefreshHubSchemaResponder handles the response to the RefreshHubSchema request. The method always 929// closes the http.Response Body. 930func (client SyncGroupsClient) RefreshHubSchemaResponder(resp *http.Response) (result autorest.Response, err error) { 931 err = autorest.Respond( 932 resp, 933 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 934 autorest.ByClosing()) 935 result.Response = resp 936 return 937} 938 939// TriggerSync triggers a sync group synchronization. 940// Parameters: 941// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 942// from the Azure Resource Manager API or the portal. 943// serverName - the name of the server. 944// databaseName - the name of the database on which the sync group is hosted. 945// syncGroupName - the name of the sync group. 946func (client SyncGroupsClient) TriggerSync(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (result autorest.Response, err error) { 947 if tracing.IsEnabled() { 948 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.TriggerSync") 949 defer func() { 950 sc := -1 951 if result.Response != nil { 952 sc = result.Response.StatusCode 953 } 954 tracing.EndSpan(ctx, sc, err) 955 }() 956 } 957 req, err := client.TriggerSyncPreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName) 958 if err != nil { 959 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "TriggerSync", nil, "Failure preparing request") 960 return 961 } 962 963 resp, err := client.TriggerSyncSender(req) 964 if err != nil { 965 result.Response = resp 966 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "TriggerSync", resp, "Failure sending request") 967 return 968 } 969 970 result, err = client.TriggerSyncResponder(resp) 971 if err != nil { 972 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "TriggerSync", resp, "Failure responding to request") 973 return 974 } 975 976 return 977} 978 979// TriggerSyncPreparer prepares the TriggerSync request. 980func (client SyncGroupsClient) TriggerSyncPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string) (*http.Request, error) { 981 pathParameters := map[string]interface{}{ 982 "databaseName": autorest.Encode("path", databaseName), 983 "resourceGroupName": autorest.Encode("path", resourceGroupName), 984 "serverName": autorest.Encode("path", serverName), 985 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 986 "syncGroupName": autorest.Encode("path", syncGroupName), 987 } 988 989 const APIVersion = "2019-06-01-preview" 990 queryParameters := map[string]interface{}{ 991 "api-version": APIVersion, 992 } 993 994 preparer := autorest.CreatePreparer( 995 autorest.AsPost(), 996 autorest.WithBaseURL(client.BaseURI), 997 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}/triggerSync", pathParameters), 998 autorest.WithQueryParameters(queryParameters)) 999 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1000} 1001 1002// TriggerSyncSender sends the TriggerSync request. The method will close the 1003// http.Response Body if it receives an error. 1004func (client SyncGroupsClient) TriggerSyncSender(req *http.Request) (*http.Response, error) { 1005 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1006} 1007 1008// TriggerSyncResponder handles the response to the TriggerSync request. The method always 1009// closes the http.Response Body. 1010func (client SyncGroupsClient) TriggerSyncResponder(resp *http.Response) (result autorest.Response, err error) { 1011 err = autorest.Respond( 1012 resp, 1013 azure.WithErrorUnlessStatusCode(http.StatusOK), 1014 autorest.ByClosing()) 1015 result.Response = resp 1016 return 1017} 1018 1019// Update updates a sync group. 1020// Parameters: 1021// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 1022// from the Azure Resource Manager API or the portal. 1023// serverName - the name of the server. 1024// databaseName - the name of the database on which the sync group is hosted. 1025// syncGroupName - the name of the sync group. 1026// parameters - the requested sync group resource state. 1027func (client SyncGroupsClient) Update(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (result SyncGroupsUpdateFuture, err error) { 1028 if tracing.IsEnabled() { 1029 ctx = tracing.StartSpan(ctx, fqdn+"/SyncGroupsClient.Update") 1030 defer func() { 1031 sc := -1 1032 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1033 sc = result.FutureAPI.Response().StatusCode 1034 } 1035 tracing.EndSpan(ctx, sc, err) 1036 }() 1037 } 1038 req, err := client.UpdatePreparer(ctx, resourceGroupName, serverName, databaseName, syncGroupName, parameters) 1039 if err != nil { 1040 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Update", nil, "Failure preparing request") 1041 return 1042 } 1043 1044 result, err = client.UpdateSender(req) 1045 if err != nil { 1046 err = autorest.NewErrorWithError(err, "sql.SyncGroupsClient", "Update", nil, "Failure sending request") 1047 return 1048 } 1049 1050 return 1051} 1052 1053// UpdatePreparer prepares the Update request. 1054func (client SyncGroupsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, syncGroupName string, parameters SyncGroup) (*http.Request, error) { 1055 pathParameters := map[string]interface{}{ 1056 "databaseName": autorest.Encode("path", databaseName), 1057 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1058 "serverName": autorest.Encode("path", serverName), 1059 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1060 "syncGroupName": autorest.Encode("path", syncGroupName), 1061 } 1062 1063 const APIVersion = "2019-06-01-preview" 1064 queryParameters := map[string]interface{}{ 1065 "api-version": APIVersion, 1066 } 1067 1068 preparer := autorest.CreatePreparer( 1069 autorest.AsContentType("application/json; charset=utf-8"), 1070 autorest.AsPatch(), 1071 autorest.WithBaseURL(client.BaseURI), 1072 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/syncGroups/{syncGroupName}", pathParameters), 1073 autorest.WithJSON(parameters), 1074 autorest.WithQueryParameters(queryParameters)) 1075 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1076} 1077 1078// UpdateSender sends the Update request. The method will close the 1079// http.Response Body if it receives an error. 1080func (client SyncGroupsClient) UpdateSender(req *http.Request) (future SyncGroupsUpdateFuture, err error) { 1081 var resp *http.Response 1082 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1083 if err != nil { 1084 return 1085 } 1086 var azf azure.Future 1087 azf, err = azure.NewFutureFromResponse(resp) 1088 future.FutureAPI = &azf 1089 future.Result = future.result 1090 return 1091} 1092 1093// UpdateResponder handles the response to the Update request. The method always 1094// closes the http.Response Body. 1095func (client SyncGroupsClient) UpdateResponder(resp *http.Response) (result SyncGroup, err error) { 1096 err = autorest.Respond( 1097 resp, 1098 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1099 autorest.ByUnmarshallingJSON(&result), 1100 autorest.ByClosing()) 1101 result.Response = autorest.Response{Response: resp} 1102 return 1103} 1104