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