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