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