1package network 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/tracing" 14 "net/http" 15) 16 17// ExpressRouteCircuitsClient is the network Client 18type ExpressRouteCircuitsClient struct { 19 BaseClient 20} 21 22// NewExpressRouteCircuitsClient creates an instance of the ExpressRouteCircuitsClient client. 23func NewExpressRouteCircuitsClient(subscriptionID string) ExpressRouteCircuitsClient { 24 return NewExpressRouteCircuitsClientWithBaseURI(DefaultBaseURI, subscriptionID) 25} 26 27// NewExpressRouteCircuitsClientWithBaseURI creates an instance of the ExpressRouteCircuitsClient client using a custom 28// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure 29// stack). 30func NewExpressRouteCircuitsClientWithBaseURI(baseURI string, subscriptionID string) ExpressRouteCircuitsClient { 31 return ExpressRouteCircuitsClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// CreateOrUpdate creates or updates an express route circuit. 35// Parameters: 36// resourceGroupName - the name of the resource group. 37// circuitName - the name of the circuit. 38// parameters - parameters supplied to the create or update express route circuit operation. 39func (client ExpressRouteCircuitsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit) (result ExpressRouteCircuitsCreateOrUpdateFuture, err error) { 40 if tracing.IsEnabled() { 41 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.CreateOrUpdate") 42 defer func() { 43 sc := -1 44 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 45 sc = result.FutureAPI.Response().StatusCode 46 } 47 tracing.EndSpan(ctx, sc, err) 48 }() 49 } 50 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, circuitName, parameters) 51 if err != nil { 52 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "CreateOrUpdate", nil, "Failure preparing request") 53 return 54 } 55 56 result, err = client.CreateOrUpdateSender(req) 57 if err != nil { 58 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "CreateOrUpdate", nil, "Failure sending request") 59 return 60 } 61 62 return 63} 64 65// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 66func (client ExpressRouteCircuitsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, circuitName string, parameters ExpressRouteCircuit) (*http.Request, error) { 67 pathParameters := map[string]interface{}{ 68 "circuitName": autorest.Encode("path", circuitName), 69 "resourceGroupName": autorest.Encode("path", resourceGroupName), 70 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 71 } 72 73 const APIVersion = "2020-11-01" 74 queryParameters := map[string]interface{}{ 75 "api-version": APIVersion, 76 } 77 78 parameters.Etag = nil 79 preparer := autorest.CreatePreparer( 80 autorest.AsContentType("application/json; charset=utf-8"), 81 autorest.AsPut(), 82 autorest.WithBaseURL(client.BaseURI), 83 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters), 84 autorest.WithJSON(parameters), 85 autorest.WithQueryParameters(queryParameters)) 86 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 87} 88 89// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 90// http.Response Body if it receives an error. 91func (client ExpressRouteCircuitsClient) CreateOrUpdateSender(req *http.Request) (future ExpressRouteCircuitsCreateOrUpdateFuture, err error) { 92 var resp *http.Response 93 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 94 if err != nil { 95 return 96 } 97 var azf azure.Future 98 azf, err = azure.NewFutureFromResponse(resp) 99 future.FutureAPI = &azf 100 future.Result = future.result 101 return 102} 103 104// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 105// closes the http.Response Body. 106func (client ExpressRouteCircuitsClient) CreateOrUpdateResponder(resp *http.Response) (result ExpressRouteCircuit, err error) { 107 err = autorest.Respond( 108 resp, 109 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 110 autorest.ByUnmarshallingJSON(&result), 111 autorest.ByClosing()) 112 result.Response = autorest.Response{Response: resp} 113 return 114} 115 116// Delete deletes the specified express route circuit. 117// Parameters: 118// resourceGroupName - the name of the resource group. 119// circuitName - the name of the express route circuit. 120func (client ExpressRouteCircuitsClient) Delete(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuitsDeleteFuture, err error) { 121 if tracing.IsEnabled() { 122 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.Delete") 123 defer func() { 124 sc := -1 125 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 126 sc = result.FutureAPI.Response().StatusCode 127 } 128 tracing.EndSpan(ctx, sc, err) 129 }() 130 } 131 req, err := client.DeletePreparer(ctx, resourceGroupName, circuitName) 132 if err != nil { 133 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Delete", nil, "Failure preparing request") 134 return 135 } 136 137 result, err = client.DeleteSender(req) 138 if err != nil { 139 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Delete", nil, "Failure sending request") 140 return 141 } 142 143 return 144} 145 146// DeletePreparer prepares the Delete request. 147func (client ExpressRouteCircuitsClient) DeletePreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) { 148 pathParameters := map[string]interface{}{ 149 "circuitName": autorest.Encode("path", circuitName), 150 "resourceGroupName": autorest.Encode("path", resourceGroupName), 151 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 152 } 153 154 const APIVersion = "2020-11-01" 155 queryParameters := map[string]interface{}{ 156 "api-version": APIVersion, 157 } 158 159 preparer := autorest.CreatePreparer( 160 autorest.AsDelete(), 161 autorest.WithBaseURL(client.BaseURI), 162 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters), 163 autorest.WithQueryParameters(queryParameters)) 164 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 165} 166 167// DeleteSender sends the Delete request. The method will close the 168// http.Response Body if it receives an error. 169func (client ExpressRouteCircuitsClient) DeleteSender(req *http.Request) (future ExpressRouteCircuitsDeleteFuture, err error) { 170 var resp *http.Response 171 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 172 if err != nil { 173 return 174 } 175 var azf azure.Future 176 azf, err = azure.NewFutureFromResponse(resp) 177 future.FutureAPI = &azf 178 future.Result = future.result 179 return 180} 181 182// DeleteResponder handles the response to the Delete request. The method always 183// closes the http.Response Body. 184func (client ExpressRouteCircuitsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 185 err = autorest.Respond( 186 resp, 187 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 188 autorest.ByClosing()) 189 result.Response = resp 190 return 191} 192 193// Get gets information about the specified express route circuit. 194// Parameters: 195// resourceGroupName - the name of the resource group. 196// circuitName - the name of express route circuit. 197func (client ExpressRouteCircuitsClient) Get(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuit, err error) { 198 if tracing.IsEnabled() { 199 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.Get") 200 defer func() { 201 sc := -1 202 if result.Response.Response != nil { 203 sc = result.Response.Response.StatusCode 204 } 205 tracing.EndSpan(ctx, sc, err) 206 }() 207 } 208 req, err := client.GetPreparer(ctx, resourceGroupName, circuitName) 209 if err != nil { 210 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Get", nil, "Failure preparing request") 211 return 212 } 213 214 resp, err := client.GetSender(req) 215 if err != nil { 216 result.Response = autorest.Response{Response: resp} 217 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Get", resp, "Failure sending request") 218 return 219 } 220 221 result, err = client.GetResponder(resp) 222 if err != nil { 223 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "Get", resp, "Failure responding to request") 224 return 225 } 226 227 return 228} 229 230// GetPreparer prepares the Get request. 231func (client ExpressRouteCircuitsClient) GetPreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) { 232 pathParameters := map[string]interface{}{ 233 "circuitName": autorest.Encode("path", circuitName), 234 "resourceGroupName": autorest.Encode("path", resourceGroupName), 235 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 236 } 237 238 const APIVersion = "2020-11-01" 239 queryParameters := map[string]interface{}{ 240 "api-version": APIVersion, 241 } 242 243 preparer := autorest.CreatePreparer( 244 autorest.AsGet(), 245 autorest.WithBaseURL(client.BaseURI), 246 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters), 247 autorest.WithQueryParameters(queryParameters)) 248 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 249} 250 251// GetSender sends the Get request. The method will close the 252// http.Response Body if it receives an error. 253func (client ExpressRouteCircuitsClient) GetSender(req *http.Request) (*http.Response, error) { 254 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 255} 256 257// GetResponder handles the response to the Get request. The method always 258// closes the http.Response Body. 259func (client ExpressRouteCircuitsClient) GetResponder(resp *http.Response) (result ExpressRouteCircuit, err error) { 260 err = autorest.Respond( 261 resp, 262 azure.WithErrorUnlessStatusCode(http.StatusOK), 263 autorest.ByUnmarshallingJSON(&result), 264 autorest.ByClosing()) 265 result.Response = autorest.Response{Response: resp} 266 return 267} 268 269// GetPeeringStats gets all stats from an express route circuit in a resource group. 270// Parameters: 271// resourceGroupName - the name of the resource group. 272// circuitName - the name of the express route circuit. 273// peeringName - the name of the peering. 274func (client ExpressRouteCircuitsClient) GetPeeringStats(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (result ExpressRouteCircuitStats, err error) { 275 if tracing.IsEnabled() { 276 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.GetPeeringStats") 277 defer func() { 278 sc := -1 279 if result.Response.Response != nil { 280 sc = result.Response.Response.StatusCode 281 } 282 tracing.EndSpan(ctx, sc, err) 283 }() 284 } 285 req, err := client.GetPeeringStatsPreparer(ctx, resourceGroupName, circuitName, peeringName) 286 if err != nil { 287 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetPeeringStats", nil, "Failure preparing request") 288 return 289 } 290 291 resp, err := client.GetPeeringStatsSender(req) 292 if err != nil { 293 result.Response = autorest.Response{Response: resp} 294 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetPeeringStats", resp, "Failure sending request") 295 return 296 } 297 298 result, err = client.GetPeeringStatsResponder(resp) 299 if err != nil { 300 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetPeeringStats", resp, "Failure responding to request") 301 return 302 } 303 304 return 305} 306 307// GetPeeringStatsPreparer prepares the GetPeeringStats request. 308func (client ExpressRouteCircuitsClient) GetPeeringStatsPreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string) (*http.Request, error) { 309 pathParameters := map[string]interface{}{ 310 "circuitName": autorest.Encode("path", circuitName), 311 "peeringName": autorest.Encode("path", peeringName), 312 "resourceGroupName": autorest.Encode("path", resourceGroupName), 313 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 314 } 315 316 const APIVersion = "2020-11-01" 317 queryParameters := map[string]interface{}{ 318 "api-version": APIVersion, 319 } 320 321 preparer := autorest.CreatePreparer( 322 autorest.AsGet(), 323 autorest.WithBaseURL(client.BaseURI), 324 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/stats", pathParameters), 325 autorest.WithQueryParameters(queryParameters)) 326 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 327} 328 329// GetPeeringStatsSender sends the GetPeeringStats request. The method will close the 330// http.Response Body if it receives an error. 331func (client ExpressRouteCircuitsClient) GetPeeringStatsSender(req *http.Request) (*http.Response, error) { 332 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 333} 334 335// GetPeeringStatsResponder handles the response to the GetPeeringStats request. The method always 336// closes the http.Response Body. 337func (client ExpressRouteCircuitsClient) GetPeeringStatsResponder(resp *http.Response) (result ExpressRouteCircuitStats, err error) { 338 err = autorest.Respond( 339 resp, 340 azure.WithErrorUnlessStatusCode(http.StatusOK), 341 autorest.ByUnmarshallingJSON(&result), 342 autorest.ByClosing()) 343 result.Response = autorest.Response{Response: resp} 344 return 345} 346 347// GetStats gets all the stats from an express route circuit in a resource group. 348// Parameters: 349// resourceGroupName - the name of the resource group. 350// circuitName - the name of the express route circuit. 351func (client ExpressRouteCircuitsClient) GetStats(ctx context.Context, resourceGroupName string, circuitName string) (result ExpressRouteCircuitStats, err error) { 352 if tracing.IsEnabled() { 353 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.GetStats") 354 defer func() { 355 sc := -1 356 if result.Response.Response != nil { 357 sc = result.Response.Response.StatusCode 358 } 359 tracing.EndSpan(ctx, sc, err) 360 }() 361 } 362 req, err := client.GetStatsPreparer(ctx, resourceGroupName, circuitName) 363 if err != nil { 364 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetStats", nil, "Failure preparing request") 365 return 366 } 367 368 resp, err := client.GetStatsSender(req) 369 if err != nil { 370 result.Response = autorest.Response{Response: resp} 371 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetStats", resp, "Failure sending request") 372 return 373 } 374 375 result, err = client.GetStatsResponder(resp) 376 if err != nil { 377 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "GetStats", resp, "Failure responding to request") 378 return 379 } 380 381 return 382} 383 384// GetStatsPreparer prepares the GetStats request. 385func (client ExpressRouteCircuitsClient) GetStatsPreparer(ctx context.Context, resourceGroupName string, circuitName string) (*http.Request, error) { 386 pathParameters := map[string]interface{}{ 387 "circuitName": autorest.Encode("path", circuitName), 388 "resourceGroupName": autorest.Encode("path", resourceGroupName), 389 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 390 } 391 392 const APIVersion = "2020-11-01" 393 queryParameters := map[string]interface{}{ 394 "api-version": APIVersion, 395 } 396 397 preparer := autorest.CreatePreparer( 398 autorest.AsGet(), 399 autorest.WithBaseURL(client.BaseURI), 400 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/stats", pathParameters), 401 autorest.WithQueryParameters(queryParameters)) 402 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 403} 404 405// GetStatsSender sends the GetStats request. The method will close the 406// http.Response Body if it receives an error. 407func (client ExpressRouteCircuitsClient) GetStatsSender(req *http.Request) (*http.Response, error) { 408 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 409} 410 411// GetStatsResponder handles the response to the GetStats request. The method always 412// closes the http.Response Body. 413func (client ExpressRouteCircuitsClient) GetStatsResponder(resp *http.Response) (result ExpressRouteCircuitStats, err error) { 414 err = autorest.Respond( 415 resp, 416 azure.WithErrorUnlessStatusCode(http.StatusOK), 417 autorest.ByUnmarshallingJSON(&result), 418 autorest.ByClosing()) 419 result.Response = autorest.Response{Response: resp} 420 return 421} 422 423// List gets all the express route circuits in a resource group. 424// Parameters: 425// resourceGroupName - the name of the resource group. 426func (client ExpressRouteCircuitsClient) List(ctx context.Context, resourceGroupName string) (result ExpressRouteCircuitListResultPage, err error) { 427 if tracing.IsEnabled() { 428 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.List") 429 defer func() { 430 sc := -1 431 if result.erclr.Response.Response != nil { 432 sc = result.erclr.Response.Response.StatusCode 433 } 434 tracing.EndSpan(ctx, sc, err) 435 }() 436 } 437 result.fn = client.listNextResults 438 req, err := client.ListPreparer(ctx, resourceGroupName) 439 if err != nil { 440 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "List", nil, "Failure preparing request") 441 return 442 } 443 444 resp, err := client.ListSender(req) 445 if err != nil { 446 result.erclr.Response = autorest.Response{Response: resp} 447 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "List", resp, "Failure sending request") 448 return 449 } 450 451 result.erclr, err = client.ListResponder(resp) 452 if err != nil { 453 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "List", resp, "Failure responding to request") 454 return 455 } 456 if result.erclr.hasNextLink() && result.erclr.IsEmpty() { 457 err = result.NextWithContext(ctx) 458 return 459 } 460 461 return 462} 463 464// ListPreparer prepares the List request. 465func (client ExpressRouteCircuitsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 466 pathParameters := map[string]interface{}{ 467 "resourceGroupName": autorest.Encode("path", resourceGroupName), 468 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 469 } 470 471 const APIVersion = "2020-11-01" 472 queryParameters := map[string]interface{}{ 473 "api-version": APIVersion, 474 } 475 476 preparer := autorest.CreatePreparer( 477 autorest.AsGet(), 478 autorest.WithBaseURL(client.BaseURI), 479 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits", pathParameters), 480 autorest.WithQueryParameters(queryParameters)) 481 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 482} 483 484// ListSender sends the List request. The method will close the 485// http.Response Body if it receives an error. 486func (client ExpressRouteCircuitsClient) ListSender(req *http.Request) (*http.Response, error) { 487 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 488} 489 490// ListResponder handles the response to the List request. The method always 491// closes the http.Response Body. 492func (client ExpressRouteCircuitsClient) ListResponder(resp *http.Response) (result ExpressRouteCircuitListResult, err error) { 493 err = autorest.Respond( 494 resp, 495 azure.WithErrorUnlessStatusCode(http.StatusOK), 496 autorest.ByUnmarshallingJSON(&result), 497 autorest.ByClosing()) 498 result.Response = autorest.Response{Response: resp} 499 return 500} 501 502// listNextResults retrieves the next set of results, if any. 503func (client ExpressRouteCircuitsClient) listNextResults(ctx context.Context, lastResults ExpressRouteCircuitListResult) (result ExpressRouteCircuitListResult, err error) { 504 req, err := lastResults.expressRouteCircuitListResultPreparer(ctx) 505 if err != nil { 506 return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listNextResults", nil, "Failure preparing next results request") 507 } 508 if req == nil { 509 return 510 } 511 resp, err := client.ListSender(req) 512 if err != nil { 513 result.Response = autorest.Response{Response: resp} 514 return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listNextResults", resp, "Failure sending next results request") 515 } 516 result, err = client.ListResponder(resp) 517 if err != nil { 518 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listNextResults", resp, "Failure responding to next results request") 519 } 520 return 521} 522 523// ListComplete enumerates all values, automatically crossing page boundaries as required. 524func (client ExpressRouteCircuitsClient) ListComplete(ctx context.Context, resourceGroupName string) (result ExpressRouteCircuitListResultIterator, err error) { 525 if tracing.IsEnabled() { 526 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.List") 527 defer func() { 528 sc := -1 529 if result.Response().Response.Response != nil { 530 sc = result.page.Response().Response.Response.StatusCode 531 } 532 tracing.EndSpan(ctx, sc, err) 533 }() 534 } 535 result.page, err = client.List(ctx, resourceGroupName) 536 return 537} 538 539// ListAll gets all the express route circuits in a subscription. 540func (client ExpressRouteCircuitsClient) ListAll(ctx context.Context) (result ExpressRouteCircuitListResultPage, err error) { 541 if tracing.IsEnabled() { 542 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListAll") 543 defer func() { 544 sc := -1 545 if result.erclr.Response.Response != nil { 546 sc = result.erclr.Response.Response.StatusCode 547 } 548 tracing.EndSpan(ctx, sc, err) 549 }() 550 } 551 result.fn = client.listAllNextResults 552 req, err := client.ListAllPreparer(ctx) 553 if err != nil { 554 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListAll", nil, "Failure preparing request") 555 return 556 } 557 558 resp, err := client.ListAllSender(req) 559 if err != nil { 560 result.erclr.Response = autorest.Response{Response: resp} 561 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListAll", resp, "Failure sending request") 562 return 563 } 564 565 result.erclr, err = client.ListAllResponder(resp) 566 if err != nil { 567 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListAll", resp, "Failure responding to request") 568 return 569 } 570 if result.erclr.hasNextLink() && result.erclr.IsEmpty() { 571 err = result.NextWithContext(ctx) 572 return 573 } 574 575 return 576} 577 578// ListAllPreparer prepares the ListAll request. 579func (client ExpressRouteCircuitsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { 580 pathParameters := map[string]interface{}{ 581 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 582 } 583 584 const APIVersion = "2020-11-01" 585 queryParameters := map[string]interface{}{ 586 "api-version": APIVersion, 587 } 588 589 preparer := autorest.CreatePreparer( 590 autorest.AsGet(), 591 autorest.WithBaseURL(client.BaseURI), 592 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/expressRouteCircuits", pathParameters), 593 autorest.WithQueryParameters(queryParameters)) 594 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 595} 596 597// ListAllSender sends the ListAll request. The method will close the 598// http.Response Body if it receives an error. 599func (client ExpressRouteCircuitsClient) ListAllSender(req *http.Request) (*http.Response, error) { 600 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 601} 602 603// ListAllResponder handles the response to the ListAll request. The method always 604// closes the http.Response Body. 605func (client ExpressRouteCircuitsClient) ListAllResponder(resp *http.Response) (result ExpressRouteCircuitListResult, err error) { 606 err = autorest.Respond( 607 resp, 608 azure.WithErrorUnlessStatusCode(http.StatusOK), 609 autorest.ByUnmarshallingJSON(&result), 610 autorest.ByClosing()) 611 result.Response = autorest.Response{Response: resp} 612 return 613} 614 615// listAllNextResults retrieves the next set of results, if any. 616func (client ExpressRouteCircuitsClient) listAllNextResults(ctx context.Context, lastResults ExpressRouteCircuitListResult) (result ExpressRouteCircuitListResult, err error) { 617 req, err := lastResults.expressRouteCircuitListResultPreparer(ctx) 618 if err != nil { 619 return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listAllNextResults", nil, "Failure preparing next results request") 620 } 621 if req == nil { 622 return 623 } 624 resp, err := client.ListAllSender(req) 625 if err != nil { 626 result.Response = autorest.Response{Response: resp} 627 return result, autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listAllNextResults", resp, "Failure sending next results request") 628 } 629 result, err = client.ListAllResponder(resp) 630 if err != nil { 631 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "listAllNextResults", resp, "Failure responding to next results request") 632 } 633 return 634} 635 636// ListAllComplete enumerates all values, automatically crossing page boundaries as required. 637func (client ExpressRouteCircuitsClient) ListAllComplete(ctx context.Context) (result ExpressRouteCircuitListResultIterator, err error) { 638 if tracing.IsEnabled() { 639 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListAll") 640 defer func() { 641 sc := -1 642 if result.Response().Response.Response != nil { 643 sc = result.page.Response().Response.Response.StatusCode 644 } 645 tracing.EndSpan(ctx, sc, err) 646 }() 647 } 648 result.page, err = client.ListAll(ctx) 649 return 650} 651 652// ListArpTable gets the currently advertised ARP table associated with the express route circuit in a resource group. 653// Parameters: 654// resourceGroupName - the name of the resource group. 655// circuitName - the name of the express route circuit. 656// peeringName - the name of the peering. 657// devicePath - the path of the device. 658func (client ExpressRouteCircuitsClient) ListArpTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (result ExpressRouteCircuitsListArpTableFuture, err error) { 659 if tracing.IsEnabled() { 660 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListArpTable") 661 defer func() { 662 sc := -1 663 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 664 sc = result.FutureAPI.Response().StatusCode 665 } 666 tracing.EndSpan(ctx, sc, err) 667 }() 668 } 669 req, err := client.ListArpTablePreparer(ctx, resourceGroupName, circuitName, peeringName, devicePath) 670 if err != nil { 671 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListArpTable", nil, "Failure preparing request") 672 return 673 } 674 675 result, err = client.ListArpTableSender(req) 676 if err != nil { 677 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListArpTable", nil, "Failure sending request") 678 return 679 } 680 681 return 682} 683 684// ListArpTablePreparer prepares the ListArpTable request. 685func (client ExpressRouteCircuitsClient) ListArpTablePreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (*http.Request, error) { 686 pathParameters := map[string]interface{}{ 687 "circuitName": autorest.Encode("path", circuitName), 688 "devicePath": autorest.Encode("path", devicePath), 689 "peeringName": autorest.Encode("path", peeringName), 690 "resourceGroupName": autorest.Encode("path", resourceGroupName), 691 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 692 } 693 694 const APIVersion = "2020-11-01" 695 queryParameters := map[string]interface{}{ 696 "api-version": APIVersion, 697 } 698 699 preparer := autorest.CreatePreparer( 700 autorest.AsPost(), 701 autorest.WithBaseURL(client.BaseURI), 702 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/arpTables/{devicePath}", pathParameters), 703 autorest.WithQueryParameters(queryParameters)) 704 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 705} 706 707// ListArpTableSender sends the ListArpTable request. The method will close the 708// http.Response Body if it receives an error. 709func (client ExpressRouteCircuitsClient) ListArpTableSender(req *http.Request) (future ExpressRouteCircuitsListArpTableFuture, err error) { 710 var resp *http.Response 711 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 712 if err != nil { 713 return 714 } 715 var azf azure.Future 716 azf, err = azure.NewFutureFromResponse(resp) 717 future.FutureAPI = &azf 718 future.Result = future.result 719 return 720} 721 722// ListArpTableResponder handles the response to the ListArpTable request. The method always 723// closes the http.Response Body. 724func (client ExpressRouteCircuitsClient) ListArpTableResponder(resp *http.Response) (result ExpressRouteCircuitsArpTableListResult, err error) { 725 err = autorest.Respond( 726 resp, 727 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 728 autorest.ByUnmarshallingJSON(&result), 729 autorest.ByClosing()) 730 result.Response = autorest.Response{Response: resp} 731 return 732} 733 734// ListRoutesTable gets the currently advertised routes table associated with the express route circuit in a resource 735// group. 736// Parameters: 737// resourceGroupName - the name of the resource group. 738// circuitName - the name of the express route circuit. 739// peeringName - the name of the peering. 740// devicePath - the path of the device. 741func (client ExpressRouteCircuitsClient) ListRoutesTable(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (result ExpressRouteCircuitsListRoutesTableFuture, err error) { 742 if tracing.IsEnabled() { 743 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListRoutesTable") 744 defer func() { 745 sc := -1 746 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 747 sc = result.FutureAPI.Response().StatusCode 748 } 749 tracing.EndSpan(ctx, sc, err) 750 }() 751 } 752 req, err := client.ListRoutesTablePreparer(ctx, resourceGroupName, circuitName, peeringName, devicePath) 753 if err != nil { 754 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTable", nil, "Failure preparing request") 755 return 756 } 757 758 result, err = client.ListRoutesTableSender(req) 759 if err != nil { 760 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTable", nil, "Failure sending request") 761 return 762 } 763 764 return 765} 766 767// ListRoutesTablePreparer prepares the ListRoutesTable request. 768func (client ExpressRouteCircuitsClient) ListRoutesTablePreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (*http.Request, error) { 769 pathParameters := map[string]interface{}{ 770 "circuitName": autorest.Encode("path", circuitName), 771 "devicePath": autorest.Encode("path", devicePath), 772 "peeringName": autorest.Encode("path", peeringName), 773 "resourceGroupName": autorest.Encode("path", resourceGroupName), 774 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 775 } 776 777 const APIVersion = "2020-11-01" 778 queryParameters := map[string]interface{}{ 779 "api-version": APIVersion, 780 } 781 782 preparer := autorest.CreatePreparer( 783 autorest.AsPost(), 784 autorest.WithBaseURL(client.BaseURI), 785 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/routeTables/{devicePath}", pathParameters), 786 autorest.WithQueryParameters(queryParameters)) 787 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 788} 789 790// ListRoutesTableSender sends the ListRoutesTable request. The method will close the 791// http.Response Body if it receives an error. 792func (client ExpressRouteCircuitsClient) ListRoutesTableSender(req *http.Request) (future ExpressRouteCircuitsListRoutesTableFuture, err error) { 793 var resp *http.Response 794 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 795 if err != nil { 796 return 797 } 798 var azf azure.Future 799 azf, err = azure.NewFutureFromResponse(resp) 800 future.FutureAPI = &azf 801 future.Result = future.result 802 return 803} 804 805// ListRoutesTableResponder handles the response to the ListRoutesTable request. The method always 806// closes the http.Response Body. 807func (client ExpressRouteCircuitsClient) ListRoutesTableResponder(resp *http.Response) (result ExpressRouteCircuitsRoutesTableListResult, err error) { 808 err = autorest.Respond( 809 resp, 810 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 811 autorest.ByUnmarshallingJSON(&result), 812 autorest.ByClosing()) 813 result.Response = autorest.Response{Response: resp} 814 return 815} 816 817// ListRoutesTableSummary gets the currently advertised routes table summary associated with the express route circuit 818// in a resource group. 819// Parameters: 820// resourceGroupName - the name of the resource group. 821// circuitName - the name of the express route circuit. 822// peeringName - the name of the peering. 823// devicePath - the path of the device. 824func (client ExpressRouteCircuitsClient) ListRoutesTableSummary(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (result ExpressRouteCircuitsListRoutesTableSummaryFuture, err error) { 825 if tracing.IsEnabled() { 826 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.ListRoutesTableSummary") 827 defer func() { 828 sc := -1 829 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 830 sc = result.FutureAPI.Response().StatusCode 831 } 832 tracing.EndSpan(ctx, sc, err) 833 }() 834 } 835 req, err := client.ListRoutesTableSummaryPreparer(ctx, resourceGroupName, circuitName, peeringName, devicePath) 836 if err != nil { 837 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTableSummary", nil, "Failure preparing request") 838 return 839 } 840 841 result, err = client.ListRoutesTableSummarySender(req) 842 if err != nil { 843 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "ListRoutesTableSummary", nil, "Failure sending request") 844 return 845 } 846 847 return 848} 849 850// ListRoutesTableSummaryPreparer prepares the ListRoutesTableSummary request. 851func (client ExpressRouteCircuitsClient) ListRoutesTableSummaryPreparer(ctx context.Context, resourceGroupName string, circuitName string, peeringName string, devicePath string) (*http.Request, error) { 852 pathParameters := map[string]interface{}{ 853 "circuitName": autorest.Encode("path", circuitName), 854 "devicePath": autorest.Encode("path", devicePath), 855 "peeringName": autorest.Encode("path", peeringName), 856 "resourceGroupName": autorest.Encode("path", resourceGroupName), 857 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 858 } 859 860 const APIVersion = "2020-11-01" 861 queryParameters := map[string]interface{}{ 862 "api-version": APIVersion, 863 } 864 865 preparer := autorest.CreatePreparer( 866 autorest.AsPost(), 867 autorest.WithBaseURL(client.BaseURI), 868 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}/peerings/{peeringName}/routeTablesSummary/{devicePath}", pathParameters), 869 autorest.WithQueryParameters(queryParameters)) 870 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 871} 872 873// ListRoutesTableSummarySender sends the ListRoutesTableSummary request. The method will close the 874// http.Response Body if it receives an error. 875func (client ExpressRouteCircuitsClient) ListRoutesTableSummarySender(req *http.Request) (future ExpressRouteCircuitsListRoutesTableSummaryFuture, err error) { 876 var resp *http.Response 877 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 878 if err != nil { 879 return 880 } 881 var azf azure.Future 882 azf, err = azure.NewFutureFromResponse(resp) 883 future.FutureAPI = &azf 884 future.Result = future.result 885 return 886} 887 888// ListRoutesTableSummaryResponder handles the response to the ListRoutesTableSummary request. The method always 889// closes the http.Response Body. 890func (client ExpressRouteCircuitsClient) ListRoutesTableSummaryResponder(resp *http.Response) (result ExpressRouteCircuitsRoutesTableSummaryListResult, err error) { 891 err = autorest.Respond( 892 resp, 893 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 894 autorest.ByUnmarshallingJSON(&result), 895 autorest.ByClosing()) 896 result.Response = autorest.Response{Response: resp} 897 return 898} 899 900// UpdateTags updates an express route circuit tags. 901// Parameters: 902// resourceGroupName - the name of the resource group. 903// circuitName - the name of the circuit. 904// parameters - parameters supplied to update express route circuit tags. 905func (client ExpressRouteCircuitsClient) UpdateTags(ctx context.Context, resourceGroupName string, circuitName string, parameters TagsObject) (result ExpressRouteCircuit, err error) { 906 if tracing.IsEnabled() { 907 ctx = tracing.StartSpan(ctx, fqdn+"/ExpressRouteCircuitsClient.UpdateTags") 908 defer func() { 909 sc := -1 910 if result.Response.Response != nil { 911 sc = result.Response.Response.StatusCode 912 } 913 tracing.EndSpan(ctx, sc, err) 914 }() 915 } 916 req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, circuitName, parameters) 917 if err != nil { 918 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "UpdateTags", nil, "Failure preparing request") 919 return 920 } 921 922 resp, err := client.UpdateTagsSender(req) 923 if err != nil { 924 result.Response = autorest.Response{Response: resp} 925 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "UpdateTags", resp, "Failure sending request") 926 return 927 } 928 929 result, err = client.UpdateTagsResponder(resp) 930 if err != nil { 931 err = autorest.NewErrorWithError(err, "network.ExpressRouteCircuitsClient", "UpdateTags", resp, "Failure responding to request") 932 return 933 } 934 935 return 936} 937 938// UpdateTagsPreparer prepares the UpdateTags request. 939func (client ExpressRouteCircuitsClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, circuitName string, parameters TagsObject) (*http.Request, error) { 940 pathParameters := map[string]interface{}{ 941 "circuitName": autorest.Encode("path", circuitName), 942 "resourceGroupName": autorest.Encode("path", resourceGroupName), 943 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 944 } 945 946 const APIVersion = "2020-11-01" 947 queryParameters := map[string]interface{}{ 948 "api-version": APIVersion, 949 } 950 951 preparer := autorest.CreatePreparer( 952 autorest.AsContentType("application/json; charset=utf-8"), 953 autorest.AsPatch(), 954 autorest.WithBaseURL(client.BaseURI), 955 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCircuits/{circuitName}", pathParameters), 956 autorest.WithJSON(parameters), 957 autorest.WithQueryParameters(queryParameters)) 958 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 959} 960 961// UpdateTagsSender sends the UpdateTags request. The method will close the 962// http.Response Body if it receives an error. 963func (client ExpressRouteCircuitsClient) UpdateTagsSender(req *http.Request) (*http.Response, error) { 964 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 965} 966 967// UpdateTagsResponder handles the response to the UpdateTags request. The method always 968// closes the http.Response Body. 969func (client ExpressRouteCircuitsClient) UpdateTagsResponder(resp *http.Response) (result ExpressRouteCircuit, err error) { 970 err = autorest.Respond( 971 resp, 972 azure.WithErrorUnlessStatusCode(http.StatusOK), 973 autorest.ByUnmarshallingJSON(&result), 974 autorest.ByClosing()) 975 result.Response = autorest.Response{Response: resp} 976 return 977} 978