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 = "2018-03-01-preview" 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 *CreateParameters) (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.Location", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { 144 return result, validation.NewError("signalr.Client", "CreateOrUpdate", err.Error()) 145 } 146 147 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, parameters) 148 if err != nil { 149 err = autorest.NewErrorWithError(err, "signalr.Client", "CreateOrUpdate", nil, "Failure preparing request") 150 return 151 } 152 153 result, err = client.CreateOrUpdateSender(req) 154 if err != nil { 155 err = autorest.NewErrorWithError(err, "signalr.Client", "CreateOrUpdate", nil, "Failure sending request") 156 return 157 } 158 159 return 160} 161 162// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 163func (client Client) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters *CreateParameters) (*http.Request, error) { 164 pathParameters := map[string]interface{}{ 165 "resourceGroupName": autorest.Encode("path", resourceGroupName), 166 "resourceName": autorest.Encode("path", resourceName), 167 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 168 } 169 170 const APIVersion = "2018-03-01-preview" 171 queryParameters := map[string]interface{}{ 172 "api-version": APIVersion, 173 } 174 175 preparer := autorest.CreatePreparer( 176 autorest.AsContentType("application/json; charset=utf-8"), 177 autorest.AsPut(), 178 autorest.WithBaseURL(client.BaseURI), 179 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR/{resourceName}", pathParameters), 180 autorest.WithQueryParameters(queryParameters)) 181 if parameters != nil { 182 preparer = autorest.DecoratePreparer(preparer, 183 autorest.WithJSON(parameters)) 184 } 185 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 186} 187 188// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 189// http.Response Body if it receives an error. 190func (client Client) CreateOrUpdateSender(req *http.Request) (future CreateOrUpdateFuture, err error) { 191 var resp *http.Response 192 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 193 if err != nil { 194 return 195 } 196 var azf azure.Future 197 azf, err = azure.NewFutureFromResponse(resp) 198 future.FutureAPI = &azf 199 future.Result = future.result 200 return 201} 202 203// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 204// closes the http.Response Body. 205func (client Client) CreateOrUpdateResponder(resp *http.Response) (result ResourceType, err error) { 206 err = autorest.Respond( 207 resp, 208 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 209 autorest.ByUnmarshallingJSON(&result), 210 autorest.ByClosing()) 211 result.Response = autorest.Response{Response: resp} 212 return 213} 214 215// Delete operation to delete a SignalR service. 216// Parameters: 217// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 218// from the Azure Resource Manager API or the portal. 219// resourceName - the name of the SignalR resource. 220func (client Client) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result DeleteFuture, err error) { 221 if tracing.IsEnabled() { 222 ctx = tracing.StartSpan(ctx, fqdn+"/Client.Delete") 223 defer func() { 224 sc := -1 225 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 226 sc = result.FutureAPI.Response().StatusCode 227 } 228 tracing.EndSpan(ctx, sc, err) 229 }() 230 } 231 req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName) 232 if err != nil { 233 err = autorest.NewErrorWithError(err, "signalr.Client", "Delete", nil, "Failure preparing request") 234 return 235 } 236 237 result, err = client.DeleteSender(req) 238 if err != nil { 239 err = autorest.NewErrorWithError(err, "signalr.Client", "Delete", nil, "Failure sending request") 240 return 241 } 242 243 return 244} 245 246// DeletePreparer prepares the Delete request. 247func (client Client) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 248 pathParameters := map[string]interface{}{ 249 "resourceGroupName": autorest.Encode("path", resourceGroupName), 250 "resourceName": autorest.Encode("path", resourceName), 251 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 252 } 253 254 const APIVersion = "2018-03-01-preview" 255 queryParameters := map[string]interface{}{ 256 "api-version": APIVersion, 257 } 258 259 preparer := autorest.CreatePreparer( 260 autorest.AsDelete(), 261 autorest.WithBaseURL(client.BaseURI), 262 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR/{resourceName}", pathParameters), 263 autorest.WithQueryParameters(queryParameters)) 264 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 265} 266 267// DeleteSender sends the Delete request. The method will close the 268// http.Response Body if it receives an error. 269func (client Client) DeleteSender(req *http.Request) (future DeleteFuture, err error) { 270 var resp *http.Response 271 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 272 if err != nil { 273 return 274 } 275 var azf azure.Future 276 azf, err = azure.NewFutureFromResponse(resp) 277 future.FutureAPI = &azf 278 future.Result = future.result 279 return 280} 281 282// DeleteResponder handles the response to the Delete request. The method always 283// closes the http.Response Body. 284func (client Client) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 285 err = autorest.Respond( 286 resp, 287 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 288 autorest.ByClosing()) 289 result.Response = resp 290 return 291} 292 293// Get get the SignalR service and its properties. 294// Parameters: 295// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 296// from the Azure Resource Manager API or the portal. 297// resourceName - the name of the SignalR resource. 298func (client Client) Get(ctx context.Context, resourceGroupName string, resourceName string) (result ResourceType, err error) { 299 if tracing.IsEnabled() { 300 ctx = tracing.StartSpan(ctx, fqdn+"/Client.Get") 301 defer func() { 302 sc := -1 303 if result.Response.Response != nil { 304 sc = result.Response.Response.StatusCode 305 } 306 tracing.EndSpan(ctx, sc, err) 307 }() 308 } 309 req, err := client.GetPreparer(ctx, resourceGroupName, resourceName) 310 if err != nil { 311 err = autorest.NewErrorWithError(err, "signalr.Client", "Get", nil, "Failure preparing request") 312 return 313 } 314 315 resp, err := client.GetSender(req) 316 if err != nil { 317 result.Response = autorest.Response{Response: resp} 318 err = autorest.NewErrorWithError(err, "signalr.Client", "Get", resp, "Failure sending request") 319 return 320 } 321 322 result, err = client.GetResponder(resp) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "signalr.Client", "Get", resp, "Failure responding to request") 325 return 326 } 327 328 return 329} 330 331// GetPreparer prepares the Get request. 332func (client Client) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 333 pathParameters := map[string]interface{}{ 334 "resourceGroupName": autorest.Encode("path", resourceGroupName), 335 "resourceName": autorest.Encode("path", resourceName), 336 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 337 } 338 339 const APIVersion = "2018-03-01-preview" 340 queryParameters := map[string]interface{}{ 341 "api-version": APIVersion, 342 } 343 344 preparer := autorest.CreatePreparer( 345 autorest.AsGet(), 346 autorest.WithBaseURL(client.BaseURI), 347 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR/{resourceName}", pathParameters), 348 autorest.WithQueryParameters(queryParameters)) 349 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 350} 351 352// GetSender sends the Get request. The method will close the 353// http.Response Body if it receives an error. 354func (client Client) GetSender(req *http.Request) (*http.Response, error) { 355 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 356} 357 358// GetResponder handles the response to the Get request. The method always 359// closes the http.Response Body. 360func (client Client) GetResponder(resp *http.Response) (result ResourceType, err error) { 361 err = autorest.Respond( 362 resp, 363 azure.WithErrorUnlessStatusCode(http.StatusOK), 364 autorest.ByUnmarshallingJSON(&result), 365 autorest.ByClosing()) 366 result.Response = autorest.Response{Response: resp} 367 return 368} 369 370// ListByResourceGroup handles requests to list all resources in a resource group. 371// Parameters: 372// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 373// from the Azure Resource Manager API or the portal. 374func (client Client) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ResourceListPage, err error) { 375 if tracing.IsEnabled() { 376 ctx = tracing.StartSpan(ctx, fqdn+"/Client.ListByResourceGroup") 377 defer func() { 378 sc := -1 379 if result.rl.Response.Response != nil { 380 sc = result.rl.Response.Response.StatusCode 381 } 382 tracing.EndSpan(ctx, sc, err) 383 }() 384 } 385 result.fn = client.listByResourceGroupNextResults 386 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 387 if err != nil { 388 err = autorest.NewErrorWithError(err, "signalr.Client", "ListByResourceGroup", nil, "Failure preparing request") 389 return 390 } 391 392 resp, err := client.ListByResourceGroupSender(req) 393 if err != nil { 394 result.rl.Response = autorest.Response{Response: resp} 395 err = autorest.NewErrorWithError(err, "signalr.Client", "ListByResourceGroup", resp, "Failure sending request") 396 return 397 } 398 399 result.rl, err = client.ListByResourceGroupResponder(resp) 400 if err != nil { 401 err = autorest.NewErrorWithError(err, "signalr.Client", "ListByResourceGroup", resp, "Failure responding to request") 402 return 403 } 404 if result.rl.hasNextLink() && result.rl.IsEmpty() { 405 err = result.NextWithContext(ctx) 406 return 407 } 408 409 return 410} 411 412// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 413func (client Client) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 414 pathParameters := map[string]interface{}{ 415 "resourceGroupName": autorest.Encode("path", resourceGroupName), 416 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 417 } 418 419 const APIVersion = "2018-03-01-preview" 420 queryParameters := map[string]interface{}{ 421 "api-version": APIVersion, 422 } 423 424 preparer := autorest.CreatePreparer( 425 autorest.AsGet(), 426 autorest.WithBaseURL(client.BaseURI), 427 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR", pathParameters), 428 autorest.WithQueryParameters(queryParameters)) 429 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 430} 431 432// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 433// http.Response Body if it receives an error. 434func (client Client) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 435 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 436} 437 438// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 439// closes the http.Response Body. 440func (client Client) ListByResourceGroupResponder(resp *http.Response) (result ResourceList, err error) { 441 err = autorest.Respond( 442 resp, 443 azure.WithErrorUnlessStatusCode(http.StatusOK), 444 autorest.ByUnmarshallingJSON(&result), 445 autorest.ByClosing()) 446 result.Response = autorest.Response{Response: resp} 447 return 448} 449 450// listByResourceGroupNextResults retrieves the next set of results, if any. 451func (client Client) listByResourceGroupNextResults(ctx context.Context, lastResults ResourceList) (result ResourceList, err error) { 452 req, err := lastResults.resourceListPreparer(ctx) 453 if err != nil { 454 return result, autorest.NewErrorWithError(err, "signalr.Client", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 455 } 456 if req == nil { 457 return 458 } 459 resp, err := client.ListByResourceGroupSender(req) 460 if err != nil { 461 result.Response = autorest.Response{Response: resp} 462 return result, autorest.NewErrorWithError(err, "signalr.Client", "listByResourceGroupNextResults", resp, "Failure sending next results request") 463 } 464 result, err = client.ListByResourceGroupResponder(resp) 465 if err != nil { 466 err = autorest.NewErrorWithError(err, "signalr.Client", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 467 } 468 return 469} 470 471// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 472func (client Client) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ResourceListIterator, err error) { 473 if tracing.IsEnabled() { 474 ctx = tracing.StartSpan(ctx, fqdn+"/Client.ListByResourceGroup") 475 defer func() { 476 sc := -1 477 if result.Response().Response.Response != nil { 478 sc = result.page.Response().Response.Response.StatusCode 479 } 480 tracing.EndSpan(ctx, sc, err) 481 }() 482 } 483 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 484 return 485} 486 487// ListBySubscription handles requests to list all resources in a subscription. 488func (client Client) ListBySubscription(ctx context.Context) (result ResourceListPage, err error) { 489 if tracing.IsEnabled() { 490 ctx = tracing.StartSpan(ctx, fqdn+"/Client.ListBySubscription") 491 defer func() { 492 sc := -1 493 if result.rl.Response.Response != nil { 494 sc = result.rl.Response.Response.StatusCode 495 } 496 tracing.EndSpan(ctx, sc, err) 497 }() 498 } 499 result.fn = client.listBySubscriptionNextResults 500 req, err := client.ListBySubscriptionPreparer(ctx) 501 if err != nil { 502 err = autorest.NewErrorWithError(err, "signalr.Client", "ListBySubscription", nil, "Failure preparing request") 503 return 504 } 505 506 resp, err := client.ListBySubscriptionSender(req) 507 if err != nil { 508 result.rl.Response = autorest.Response{Response: resp} 509 err = autorest.NewErrorWithError(err, "signalr.Client", "ListBySubscription", resp, "Failure sending request") 510 return 511 } 512 513 result.rl, err = client.ListBySubscriptionResponder(resp) 514 if err != nil { 515 err = autorest.NewErrorWithError(err, "signalr.Client", "ListBySubscription", resp, "Failure responding to request") 516 return 517 } 518 if result.rl.hasNextLink() && result.rl.IsEmpty() { 519 err = result.NextWithContext(ctx) 520 return 521 } 522 523 return 524} 525 526// ListBySubscriptionPreparer prepares the ListBySubscription request. 527func (client Client) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { 528 pathParameters := map[string]interface{}{ 529 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 530 } 531 532 const APIVersion = "2018-03-01-preview" 533 queryParameters := map[string]interface{}{ 534 "api-version": APIVersion, 535 } 536 537 preparer := autorest.CreatePreparer( 538 autorest.AsGet(), 539 autorest.WithBaseURL(client.BaseURI), 540 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.SignalRService/SignalR", pathParameters), 541 autorest.WithQueryParameters(queryParameters)) 542 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 543} 544 545// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 546// http.Response Body if it receives an error. 547func (client Client) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 548 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 549} 550 551// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 552// closes the http.Response Body. 553func (client Client) ListBySubscriptionResponder(resp *http.Response) (result ResourceList, err error) { 554 err = autorest.Respond( 555 resp, 556 azure.WithErrorUnlessStatusCode(http.StatusOK), 557 autorest.ByUnmarshallingJSON(&result), 558 autorest.ByClosing()) 559 result.Response = autorest.Response{Response: resp} 560 return 561} 562 563// listBySubscriptionNextResults retrieves the next set of results, if any. 564func (client Client) listBySubscriptionNextResults(ctx context.Context, lastResults ResourceList) (result ResourceList, err error) { 565 req, err := lastResults.resourceListPreparer(ctx) 566 if err != nil { 567 return result, autorest.NewErrorWithError(err, "signalr.Client", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 568 } 569 if req == nil { 570 return 571 } 572 resp, err := client.ListBySubscriptionSender(req) 573 if err != nil { 574 result.Response = autorest.Response{Response: resp} 575 return result, autorest.NewErrorWithError(err, "signalr.Client", "listBySubscriptionNextResults", resp, "Failure sending next results request") 576 } 577 result, err = client.ListBySubscriptionResponder(resp) 578 if err != nil { 579 err = autorest.NewErrorWithError(err, "signalr.Client", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 580 } 581 return 582} 583 584// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 585func (client Client) ListBySubscriptionComplete(ctx context.Context) (result ResourceListIterator, err error) { 586 if tracing.IsEnabled() { 587 ctx = tracing.StartSpan(ctx, fqdn+"/Client.ListBySubscription") 588 defer func() { 589 sc := -1 590 if result.Response().Response.Response != nil { 591 sc = result.page.Response().Response.Response.StatusCode 592 } 593 tracing.EndSpan(ctx, sc, err) 594 }() 595 } 596 result.page, err = client.ListBySubscription(ctx) 597 return 598} 599 600// ListKeys get the access keys of the SignalR resource. 601// Parameters: 602// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 603// from the Azure Resource Manager API or the portal. 604// resourceName - the name of the SignalR resource. 605func (client Client) ListKeys(ctx context.Context, resourceGroupName string, resourceName string) (result Keys, err error) { 606 if tracing.IsEnabled() { 607 ctx = tracing.StartSpan(ctx, fqdn+"/Client.ListKeys") 608 defer func() { 609 sc := -1 610 if result.Response.Response != nil { 611 sc = result.Response.Response.StatusCode 612 } 613 tracing.EndSpan(ctx, sc, err) 614 }() 615 } 616 req, err := client.ListKeysPreparer(ctx, resourceGroupName, resourceName) 617 if err != nil { 618 err = autorest.NewErrorWithError(err, "signalr.Client", "ListKeys", nil, "Failure preparing request") 619 return 620 } 621 622 resp, err := client.ListKeysSender(req) 623 if err != nil { 624 result.Response = autorest.Response{Response: resp} 625 err = autorest.NewErrorWithError(err, "signalr.Client", "ListKeys", resp, "Failure sending request") 626 return 627 } 628 629 result, err = client.ListKeysResponder(resp) 630 if err != nil { 631 err = autorest.NewErrorWithError(err, "signalr.Client", "ListKeys", resp, "Failure responding to request") 632 return 633 } 634 635 return 636} 637 638// ListKeysPreparer prepares the ListKeys request. 639func (client Client) ListKeysPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 640 pathParameters := map[string]interface{}{ 641 "resourceGroupName": autorest.Encode("path", resourceGroupName), 642 "resourceName": autorest.Encode("path", resourceName), 643 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 644 } 645 646 const APIVersion = "2018-03-01-preview" 647 queryParameters := map[string]interface{}{ 648 "api-version": APIVersion, 649 } 650 651 preparer := autorest.CreatePreparer( 652 autorest.AsPost(), 653 autorest.WithBaseURL(client.BaseURI), 654 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR/{resourceName}/listKeys", pathParameters), 655 autorest.WithQueryParameters(queryParameters)) 656 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 657} 658 659// ListKeysSender sends the ListKeys request. The method will close the 660// http.Response Body if it receives an error. 661func (client Client) ListKeysSender(req *http.Request) (*http.Response, error) { 662 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 663} 664 665// ListKeysResponder handles the response to the ListKeys request. The method always 666// closes the http.Response Body. 667func (client Client) ListKeysResponder(resp *http.Response) (result Keys, err error) { 668 err = autorest.Respond( 669 resp, 670 azure.WithErrorUnlessStatusCode(http.StatusOK), 671 autorest.ByUnmarshallingJSON(&result), 672 autorest.ByClosing()) 673 result.Response = autorest.Response{Response: resp} 674 return 675} 676 677// RegenerateKey regenerate SignalR service access key. PrimaryKey and SecondaryKey cannot be regenerated at the same 678// time. 679// Parameters: 680// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 681// from the Azure Resource Manager API or the portal. 682// resourceName - the name of the SignalR resource. 683// parameters - parameter that describes the Regenerate Key Operation. 684func (client Client) RegenerateKey(ctx context.Context, resourceGroupName string, resourceName string, parameters *RegenerateKeyParameters) (result RegenerateKeyFuture, err error) { 685 if tracing.IsEnabled() { 686 ctx = tracing.StartSpan(ctx, fqdn+"/Client.RegenerateKey") 687 defer func() { 688 sc := -1 689 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 690 sc = result.FutureAPI.Response().StatusCode 691 } 692 tracing.EndSpan(ctx, sc, err) 693 }() 694 } 695 req, err := client.RegenerateKeyPreparer(ctx, resourceGroupName, resourceName, parameters) 696 if err != nil { 697 err = autorest.NewErrorWithError(err, "signalr.Client", "RegenerateKey", nil, "Failure preparing request") 698 return 699 } 700 701 result, err = client.RegenerateKeySender(req) 702 if err != nil { 703 err = autorest.NewErrorWithError(err, "signalr.Client", "RegenerateKey", nil, "Failure sending request") 704 return 705 } 706 707 return 708} 709 710// RegenerateKeyPreparer prepares the RegenerateKey request. 711func (client Client) RegenerateKeyPreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters *RegenerateKeyParameters) (*http.Request, error) { 712 pathParameters := map[string]interface{}{ 713 "resourceGroupName": autorest.Encode("path", resourceGroupName), 714 "resourceName": autorest.Encode("path", resourceName), 715 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 716 } 717 718 const APIVersion = "2018-03-01-preview" 719 queryParameters := map[string]interface{}{ 720 "api-version": APIVersion, 721 } 722 723 preparer := autorest.CreatePreparer( 724 autorest.AsContentType("application/json; charset=utf-8"), 725 autorest.AsPost(), 726 autorest.WithBaseURL(client.BaseURI), 727 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR/{resourceName}/regenerateKey", pathParameters), 728 autorest.WithQueryParameters(queryParameters)) 729 if parameters != nil { 730 preparer = autorest.DecoratePreparer(preparer, 731 autorest.WithJSON(parameters)) 732 } 733 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 734} 735 736// RegenerateKeySender sends the RegenerateKey request. The method will close the 737// http.Response Body if it receives an error. 738func (client Client) RegenerateKeySender(req *http.Request) (future RegenerateKeyFuture, err error) { 739 var resp *http.Response 740 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 741 if err != nil { 742 return 743 } 744 var azf azure.Future 745 azf, err = azure.NewFutureFromResponse(resp) 746 future.FutureAPI = &azf 747 future.Result = future.result 748 return 749} 750 751// RegenerateKeyResponder handles the response to the RegenerateKey request. The method always 752// closes the http.Response Body. 753func (client Client) RegenerateKeyResponder(resp *http.Response) (result Keys, err error) { 754 err = autorest.Respond( 755 resp, 756 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 757 autorest.ByUnmarshallingJSON(&result), 758 autorest.ByClosing()) 759 result.Response = autorest.Response{Response: resp} 760 return 761} 762 763// Update operation to update an exiting SignalR service. 764// Parameters: 765// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 766// from the Azure Resource Manager API or the portal. 767// resourceName - the name of the SignalR resource. 768// parameters - parameters for the update operation 769func (client Client) Update(ctx context.Context, resourceGroupName string, resourceName string, parameters *UpdateParameters) (result UpdateFuture, err error) { 770 if tracing.IsEnabled() { 771 ctx = tracing.StartSpan(ctx, fqdn+"/Client.Update") 772 defer func() { 773 sc := -1 774 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 775 sc = result.FutureAPI.Response().StatusCode 776 } 777 tracing.EndSpan(ctx, sc, err) 778 }() 779 } 780 req, err := client.UpdatePreparer(ctx, resourceGroupName, resourceName, parameters) 781 if err != nil { 782 err = autorest.NewErrorWithError(err, "signalr.Client", "Update", nil, "Failure preparing request") 783 return 784 } 785 786 result, err = client.UpdateSender(req) 787 if err != nil { 788 err = autorest.NewErrorWithError(err, "signalr.Client", "Update", nil, "Failure sending request") 789 return 790 } 791 792 return 793} 794 795// UpdatePreparer prepares the Update request. 796func (client Client) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters *UpdateParameters) (*http.Request, error) { 797 pathParameters := map[string]interface{}{ 798 "resourceGroupName": autorest.Encode("path", resourceGroupName), 799 "resourceName": autorest.Encode("path", resourceName), 800 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 801 } 802 803 const APIVersion = "2018-03-01-preview" 804 queryParameters := map[string]interface{}{ 805 "api-version": APIVersion, 806 } 807 808 preparer := autorest.CreatePreparer( 809 autorest.AsContentType("application/json; charset=utf-8"), 810 autorest.AsPatch(), 811 autorest.WithBaseURL(client.BaseURI), 812 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/SignalR/{resourceName}", pathParameters), 813 autorest.WithQueryParameters(queryParameters)) 814 if parameters != nil { 815 preparer = autorest.DecoratePreparer(preparer, 816 autorest.WithJSON(parameters)) 817 } 818 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 819} 820 821// UpdateSender sends the Update request. The method will close the 822// http.Response Body if it receives an error. 823func (client Client) UpdateSender(req *http.Request) (future UpdateFuture, err error) { 824 var resp *http.Response 825 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 826 if err != nil { 827 return 828 } 829 var azf azure.Future 830 azf, err = azure.NewFutureFromResponse(resp) 831 future.FutureAPI = &azf 832 future.Result = future.result 833 return 834} 835 836// UpdateResponder handles the response to the Update request. The method always 837// closes the http.Response Body. 838func (client Client) UpdateResponder(resp *http.Response) (result ResourceType, err error) { 839 err = autorest.Respond( 840 resp, 841 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 842 autorest.ByUnmarshallingJSON(&result), 843 autorest.ByClosing()) 844 result.Response = autorest.Response{Response: resp} 845 return 846} 847