Source file src/github.com/Azure/azure-sdk-for-go/services/network/mgmt/2021-08-01/network/expressroutecircuits.go

Documentation: github.com/Azure/azure-sdk-for-go/services/network/mgmt/2021-08-01/network

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

View as plain text