1// +build go1.13
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// Code generated by Microsoft (R) AutoRest Code Generator.
6// Changes may cause incorrect behavior and will be lost if the code is regenerated.
7
8package armnetwork
9
10import (
11	"context"
12	"errors"
13	"fmt"
14	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
15	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
16	"net/http"
17	"net/url"
18	"strings"
19	"time"
20)
21
22// ExpressRouteCrossConnectionsClient contains the methods for the ExpressRouteCrossConnections group.
23// Don't use this type directly, use NewExpressRouteCrossConnectionsClient() instead.
24type ExpressRouteCrossConnectionsClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewExpressRouteCrossConnectionsClient creates a new instance of ExpressRouteCrossConnectionsClient with the specified values.
30func NewExpressRouteCrossConnectionsClient(con *armcore.Connection, subscriptionID string) *ExpressRouteCrossConnectionsClient {
31	return &ExpressRouteCrossConnectionsClient{con: con, subscriptionID: subscriptionID}
32}
33
34// BeginCreateOrUpdate - Update the specified ExpressRouteCrossConnection.
35// If the operation fails it returns the *CloudError error type.
36func (client *ExpressRouteCrossConnectionsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, crossConnectionName string, parameters ExpressRouteCrossConnection, options *ExpressRouteCrossConnectionsBeginCreateOrUpdateOptions) (ExpressRouteCrossConnectionPollerResponse, error) {
37	resp, err := client.createOrUpdate(ctx, resourceGroupName, crossConnectionName, parameters, options)
38	if err != nil {
39		return ExpressRouteCrossConnectionPollerResponse{}, err
40	}
41	result := ExpressRouteCrossConnectionPollerResponse{
42		RawResponse: resp.Response,
43	}
44	pt, err := armcore.NewLROPoller("ExpressRouteCrossConnectionsClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
45	if err != nil {
46		return ExpressRouteCrossConnectionPollerResponse{}, err
47	}
48	poller := &expressRouteCrossConnectionPoller{
49		pt: pt,
50	}
51	result.Poller = poller
52	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCrossConnectionResponse, error) {
53		return poller.pollUntilDone(ctx, frequency)
54	}
55	return result, nil
56}
57
58// ResumeCreateOrUpdate creates a new ExpressRouteCrossConnectionPoller from the specified resume token.
59// token - The value must come from a previous call to ExpressRouteCrossConnectionPoller.ResumeToken().
60func (client *ExpressRouteCrossConnectionsClient) ResumeCreateOrUpdate(ctx context.Context, token string) (ExpressRouteCrossConnectionPollerResponse, error) {
61	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCrossConnectionsClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
62	if err != nil {
63		return ExpressRouteCrossConnectionPollerResponse{}, err
64	}
65	poller := &expressRouteCrossConnectionPoller{
66		pt: pt,
67	}
68	resp, err := poller.Poll(ctx)
69	if err != nil {
70		return ExpressRouteCrossConnectionPollerResponse{}, err
71	}
72	result := ExpressRouteCrossConnectionPollerResponse{
73		RawResponse: resp,
74	}
75	result.Poller = poller
76	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCrossConnectionResponse, error) {
77		return poller.pollUntilDone(ctx, frequency)
78	}
79	return result, nil
80}
81
82// CreateOrUpdate - Update the specified ExpressRouteCrossConnection.
83// If the operation fails it returns the *CloudError error type.
84func (client *ExpressRouteCrossConnectionsClient) createOrUpdate(ctx context.Context, resourceGroupName string, crossConnectionName string, parameters ExpressRouteCrossConnection, options *ExpressRouteCrossConnectionsBeginCreateOrUpdateOptions) (*azcore.Response, error) {
85	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, crossConnectionName, parameters, options)
86	if err != nil {
87		return nil, err
88	}
89	resp, err := client.con.Pipeline().Do(req)
90	if err != nil {
91		return nil, err
92	}
93	if !resp.HasStatusCode(http.StatusOK) {
94		return nil, client.createOrUpdateHandleError(resp)
95	}
96	return resp, nil
97}
98
99// createOrUpdateCreateRequest creates the CreateOrUpdate request.
100func (client *ExpressRouteCrossConnectionsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, crossConnectionName string, parameters ExpressRouteCrossConnection, options *ExpressRouteCrossConnectionsBeginCreateOrUpdateOptions) (*azcore.Request, error) {
101	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections/{crossConnectionName}"
102	if resourceGroupName == "" {
103		return nil, errors.New("parameter resourceGroupName cannot be empty")
104	}
105	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
106	if crossConnectionName == "" {
107		return nil, errors.New("parameter crossConnectionName cannot be empty")
108	}
109	urlPath = strings.ReplaceAll(urlPath, "{crossConnectionName}", url.PathEscape(crossConnectionName))
110	if client.subscriptionID == "" {
111		return nil, errors.New("parameter client.subscriptionID cannot be empty")
112	}
113	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
114	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
115	if err != nil {
116		return nil, err
117	}
118	req.Telemetry(telemetryInfo)
119	reqQP := req.URL.Query()
120	reqQP.Set("api-version", "2021-02-01")
121	req.URL.RawQuery = reqQP.Encode()
122	req.Header.Set("Accept", "application/json")
123	return req, req.MarshalAsJSON(parameters)
124}
125
126// createOrUpdateHandleError handles the CreateOrUpdate error response.
127func (client *ExpressRouteCrossConnectionsClient) createOrUpdateHandleError(resp *azcore.Response) error {
128	body, err := resp.Payload()
129	if err != nil {
130		return azcore.NewResponseError(err, resp.Response)
131	}
132	errType := CloudError{raw: string(body)}
133	if err := resp.UnmarshalAsJSON(&errType); err != nil {
134		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
135	}
136	return azcore.NewResponseError(&errType, resp.Response)
137}
138
139// Get - Gets details about the specified ExpressRouteCrossConnection.
140// If the operation fails it returns the *CloudError error type.
141func (client *ExpressRouteCrossConnectionsClient) Get(ctx context.Context, resourceGroupName string, crossConnectionName string, options *ExpressRouteCrossConnectionsGetOptions) (ExpressRouteCrossConnectionResponse, error) {
142	req, err := client.getCreateRequest(ctx, resourceGroupName, crossConnectionName, options)
143	if err != nil {
144		return ExpressRouteCrossConnectionResponse{}, err
145	}
146	resp, err := client.con.Pipeline().Do(req)
147	if err != nil {
148		return ExpressRouteCrossConnectionResponse{}, err
149	}
150	if !resp.HasStatusCode(http.StatusOK) {
151		return ExpressRouteCrossConnectionResponse{}, client.getHandleError(resp)
152	}
153	return client.getHandleResponse(resp)
154}
155
156// getCreateRequest creates the Get request.
157func (client *ExpressRouteCrossConnectionsClient) getCreateRequest(ctx context.Context, resourceGroupName string, crossConnectionName string, options *ExpressRouteCrossConnectionsGetOptions) (*azcore.Request, error) {
158	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections/{crossConnectionName}"
159	if resourceGroupName == "" {
160		return nil, errors.New("parameter resourceGroupName cannot be empty")
161	}
162	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
163	if crossConnectionName == "" {
164		return nil, errors.New("parameter crossConnectionName cannot be empty")
165	}
166	urlPath = strings.ReplaceAll(urlPath, "{crossConnectionName}", url.PathEscape(crossConnectionName))
167	if client.subscriptionID == "" {
168		return nil, errors.New("parameter client.subscriptionID cannot be empty")
169	}
170	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
171	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
172	if err != nil {
173		return nil, err
174	}
175	req.Telemetry(telemetryInfo)
176	reqQP := req.URL.Query()
177	reqQP.Set("api-version", "2021-02-01")
178	req.URL.RawQuery = reqQP.Encode()
179	req.Header.Set("Accept", "application/json")
180	return req, nil
181}
182
183// getHandleResponse handles the Get response.
184func (client *ExpressRouteCrossConnectionsClient) getHandleResponse(resp *azcore.Response) (ExpressRouteCrossConnectionResponse, error) {
185	var val *ExpressRouteCrossConnection
186	if err := resp.UnmarshalAsJSON(&val); err != nil {
187		return ExpressRouteCrossConnectionResponse{}, err
188	}
189	return ExpressRouteCrossConnectionResponse{RawResponse: resp.Response, ExpressRouteCrossConnection: val}, nil
190}
191
192// getHandleError handles the Get error response.
193func (client *ExpressRouteCrossConnectionsClient) getHandleError(resp *azcore.Response) error {
194	body, err := resp.Payload()
195	if err != nil {
196		return azcore.NewResponseError(err, resp.Response)
197	}
198	errType := CloudError{raw: string(body)}
199	if err := resp.UnmarshalAsJSON(&errType); err != nil {
200		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
201	}
202	return azcore.NewResponseError(&errType, resp.Response)
203}
204
205// List - Retrieves all the ExpressRouteCrossConnections in a subscription.
206// If the operation fails it returns the *CloudError error type.
207func (client *ExpressRouteCrossConnectionsClient) List(options *ExpressRouteCrossConnectionsListOptions) ExpressRouteCrossConnectionListResultPager {
208	return &expressRouteCrossConnectionListResultPager{
209		pipeline: client.con.Pipeline(),
210		requester: func(ctx context.Context) (*azcore.Request, error) {
211			return client.listCreateRequest(ctx, options)
212		},
213		responder: client.listHandleResponse,
214		errorer:   client.listHandleError,
215		advancer: func(ctx context.Context, resp ExpressRouteCrossConnectionListResultResponse) (*azcore.Request, error) {
216			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRouteCrossConnectionListResult.NextLink)
217		},
218		statusCodes: []int{http.StatusOK},
219	}
220}
221
222// listCreateRequest creates the List request.
223func (client *ExpressRouteCrossConnectionsClient) listCreateRequest(ctx context.Context, options *ExpressRouteCrossConnectionsListOptions) (*azcore.Request, error) {
224	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/expressRouteCrossConnections"
225	if client.subscriptionID == "" {
226		return nil, errors.New("parameter client.subscriptionID cannot be empty")
227	}
228	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
229	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
230	if err != nil {
231		return nil, err
232	}
233	req.Telemetry(telemetryInfo)
234	reqQP := req.URL.Query()
235	reqQP.Set("api-version", "2021-02-01")
236	req.URL.RawQuery = reqQP.Encode()
237	req.Header.Set("Accept", "application/json")
238	return req, nil
239}
240
241// listHandleResponse handles the List response.
242func (client *ExpressRouteCrossConnectionsClient) listHandleResponse(resp *azcore.Response) (ExpressRouteCrossConnectionListResultResponse, error) {
243	var val *ExpressRouteCrossConnectionListResult
244	if err := resp.UnmarshalAsJSON(&val); err != nil {
245		return ExpressRouteCrossConnectionListResultResponse{}, err
246	}
247	return ExpressRouteCrossConnectionListResultResponse{RawResponse: resp.Response, ExpressRouteCrossConnectionListResult: val}, nil
248}
249
250// listHandleError handles the List error response.
251func (client *ExpressRouteCrossConnectionsClient) listHandleError(resp *azcore.Response) error {
252	body, err := resp.Payload()
253	if err != nil {
254		return azcore.NewResponseError(err, resp.Response)
255	}
256	errType := CloudError{raw: string(body)}
257	if err := resp.UnmarshalAsJSON(&errType); err != nil {
258		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
259	}
260	return azcore.NewResponseError(&errType, resp.Response)
261}
262
263// BeginListArpTable - Gets the currently advertised ARP table associated with the express route cross connection in a resource group.
264// If the operation fails it returns the *CloudError error type.
265func (client *ExpressRouteCrossConnectionsClient) BeginListArpTable(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListArpTableOptions) (ExpressRouteCircuitsArpTableListResultPollerResponse, error) {
266	resp, err := client.listArpTable(ctx, resourceGroupName, crossConnectionName, peeringName, devicePath, options)
267	if err != nil {
268		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
269	}
270	result := ExpressRouteCircuitsArpTableListResultPollerResponse{
271		RawResponse: resp.Response,
272	}
273	pt, err := armcore.NewLROPoller("ExpressRouteCrossConnectionsClient.ListArpTable", "location", resp, client.con.Pipeline(), client.listArpTableHandleError)
274	if err != nil {
275		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
276	}
277	poller := &expressRouteCircuitsArpTableListResultPoller{
278		pt: pt,
279	}
280	result.Poller = poller
281	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsArpTableListResultResponse, error) {
282		return poller.pollUntilDone(ctx, frequency)
283	}
284	return result, nil
285}
286
287// ResumeListArpTable creates a new ExpressRouteCircuitsArpTableListResultPoller from the specified resume token.
288// token - The value must come from a previous call to ExpressRouteCircuitsArpTableListResultPoller.ResumeToken().
289func (client *ExpressRouteCrossConnectionsClient) ResumeListArpTable(ctx context.Context, token string) (ExpressRouteCircuitsArpTableListResultPollerResponse, error) {
290	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCrossConnectionsClient.ListArpTable", token, client.con.Pipeline(), client.listArpTableHandleError)
291	if err != nil {
292		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
293	}
294	poller := &expressRouteCircuitsArpTableListResultPoller{
295		pt: pt,
296	}
297	resp, err := poller.Poll(ctx)
298	if err != nil {
299		return ExpressRouteCircuitsArpTableListResultPollerResponse{}, err
300	}
301	result := ExpressRouteCircuitsArpTableListResultPollerResponse{
302		RawResponse: resp,
303	}
304	result.Poller = poller
305	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsArpTableListResultResponse, error) {
306		return poller.pollUntilDone(ctx, frequency)
307	}
308	return result, nil
309}
310
311// ListArpTable - Gets the currently advertised ARP table associated with the express route cross connection in a resource group.
312// If the operation fails it returns the *CloudError error type.
313func (client *ExpressRouteCrossConnectionsClient) listArpTable(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListArpTableOptions) (*azcore.Response, error) {
314	req, err := client.listArpTableCreateRequest(ctx, resourceGroupName, crossConnectionName, peeringName, devicePath, options)
315	if err != nil {
316		return nil, err
317	}
318	resp, err := client.con.Pipeline().Do(req)
319	if err != nil {
320		return nil, err
321	}
322	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
323		return nil, client.listArpTableHandleError(resp)
324	}
325	return resp, nil
326}
327
328// listArpTableCreateRequest creates the ListArpTable request.
329func (client *ExpressRouteCrossConnectionsClient) listArpTableCreateRequest(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListArpTableOptions) (*azcore.Request, error) {
330	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections/{crossConnectionName}/peerings/{peeringName}/arpTables/{devicePath}"
331	if resourceGroupName == "" {
332		return nil, errors.New("parameter resourceGroupName cannot be empty")
333	}
334	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
335	if crossConnectionName == "" {
336		return nil, errors.New("parameter crossConnectionName cannot be empty")
337	}
338	urlPath = strings.ReplaceAll(urlPath, "{crossConnectionName}", url.PathEscape(crossConnectionName))
339	if peeringName == "" {
340		return nil, errors.New("parameter peeringName cannot be empty")
341	}
342	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
343	if devicePath == "" {
344		return nil, errors.New("parameter devicePath cannot be empty")
345	}
346	urlPath = strings.ReplaceAll(urlPath, "{devicePath}", url.PathEscape(devicePath))
347	if client.subscriptionID == "" {
348		return nil, errors.New("parameter client.subscriptionID cannot be empty")
349	}
350	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
351	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
352	if err != nil {
353		return nil, err
354	}
355	req.Telemetry(telemetryInfo)
356	reqQP := req.URL.Query()
357	reqQP.Set("api-version", "2021-02-01")
358	req.URL.RawQuery = reqQP.Encode()
359	req.Header.Set("Accept", "application/json")
360	return req, nil
361}
362
363// listArpTableHandleError handles the ListArpTable error response.
364func (client *ExpressRouteCrossConnectionsClient) listArpTableHandleError(resp *azcore.Response) error {
365	body, err := resp.Payload()
366	if err != nil {
367		return azcore.NewResponseError(err, resp.Response)
368	}
369	errType := CloudError{raw: string(body)}
370	if err := resp.UnmarshalAsJSON(&errType); err != nil {
371		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
372	}
373	return azcore.NewResponseError(&errType, resp.Response)
374}
375
376// ListByResourceGroup - Retrieves all the ExpressRouteCrossConnections in a resource group.
377// If the operation fails it returns the *CloudError error type.
378func (client *ExpressRouteCrossConnectionsClient) ListByResourceGroup(resourceGroupName string, options *ExpressRouteCrossConnectionsListByResourceGroupOptions) ExpressRouteCrossConnectionListResultPager {
379	return &expressRouteCrossConnectionListResultPager{
380		pipeline: client.con.Pipeline(),
381		requester: func(ctx context.Context) (*azcore.Request, error) {
382			return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options)
383		},
384		responder: client.listByResourceGroupHandleResponse,
385		errorer:   client.listByResourceGroupHandleError,
386		advancer: func(ctx context.Context, resp ExpressRouteCrossConnectionListResultResponse) (*azcore.Request, error) {
387			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRouteCrossConnectionListResult.NextLink)
388		},
389		statusCodes: []int{http.StatusOK},
390	}
391}
392
393// listByResourceGroupCreateRequest creates the ListByResourceGroup request.
394func (client *ExpressRouteCrossConnectionsClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *ExpressRouteCrossConnectionsListByResourceGroupOptions) (*azcore.Request, error) {
395	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections"
396	if resourceGroupName == "" {
397		return nil, errors.New("parameter resourceGroupName cannot be empty")
398	}
399	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
400	if client.subscriptionID == "" {
401		return nil, errors.New("parameter client.subscriptionID cannot be empty")
402	}
403	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
404	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
405	if err != nil {
406		return nil, err
407	}
408	req.Telemetry(telemetryInfo)
409	reqQP := req.URL.Query()
410	reqQP.Set("api-version", "2021-02-01")
411	req.URL.RawQuery = reqQP.Encode()
412	req.Header.Set("Accept", "application/json")
413	return req, nil
414}
415
416// listByResourceGroupHandleResponse handles the ListByResourceGroup response.
417func (client *ExpressRouteCrossConnectionsClient) listByResourceGroupHandleResponse(resp *azcore.Response) (ExpressRouteCrossConnectionListResultResponse, error) {
418	var val *ExpressRouteCrossConnectionListResult
419	if err := resp.UnmarshalAsJSON(&val); err != nil {
420		return ExpressRouteCrossConnectionListResultResponse{}, err
421	}
422	return ExpressRouteCrossConnectionListResultResponse{RawResponse: resp.Response, ExpressRouteCrossConnectionListResult: val}, nil
423}
424
425// listByResourceGroupHandleError handles the ListByResourceGroup error response.
426func (client *ExpressRouteCrossConnectionsClient) listByResourceGroupHandleError(resp *azcore.Response) error {
427	body, err := resp.Payload()
428	if err != nil {
429		return azcore.NewResponseError(err, resp.Response)
430	}
431	errType := CloudError{raw: string(body)}
432	if err := resp.UnmarshalAsJSON(&errType); err != nil {
433		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
434	}
435	return azcore.NewResponseError(&errType, resp.Response)
436}
437
438// BeginListRoutesTable - Gets the currently advertised routes table associated with the express route cross connection in a resource group.
439// If the operation fails it returns the *CloudError error type.
440func (client *ExpressRouteCrossConnectionsClient) BeginListRoutesTable(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListRoutesTableOptions) (ExpressRouteCircuitsRoutesTableListResultPollerResponse, error) {
441	resp, err := client.listRoutesTable(ctx, resourceGroupName, crossConnectionName, peeringName, devicePath, options)
442	if err != nil {
443		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
444	}
445	result := ExpressRouteCircuitsRoutesTableListResultPollerResponse{
446		RawResponse: resp.Response,
447	}
448	pt, err := armcore.NewLROPoller("ExpressRouteCrossConnectionsClient.ListRoutesTable", "location", resp, client.con.Pipeline(), client.listRoutesTableHandleError)
449	if err != nil {
450		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
451	}
452	poller := &expressRouteCircuitsRoutesTableListResultPoller{
453		pt: pt,
454	}
455	result.Poller = poller
456	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsRoutesTableListResultResponse, error) {
457		return poller.pollUntilDone(ctx, frequency)
458	}
459	return result, nil
460}
461
462// ResumeListRoutesTable creates a new ExpressRouteCircuitsRoutesTableListResultPoller from the specified resume token.
463// token - The value must come from a previous call to ExpressRouteCircuitsRoutesTableListResultPoller.ResumeToken().
464func (client *ExpressRouteCrossConnectionsClient) ResumeListRoutesTable(ctx context.Context, token string) (ExpressRouteCircuitsRoutesTableListResultPollerResponse, error) {
465	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCrossConnectionsClient.ListRoutesTable", token, client.con.Pipeline(), client.listRoutesTableHandleError)
466	if err != nil {
467		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
468	}
469	poller := &expressRouteCircuitsRoutesTableListResultPoller{
470		pt: pt,
471	}
472	resp, err := poller.Poll(ctx)
473	if err != nil {
474		return ExpressRouteCircuitsRoutesTableListResultPollerResponse{}, err
475	}
476	result := ExpressRouteCircuitsRoutesTableListResultPollerResponse{
477		RawResponse: resp,
478	}
479	result.Poller = poller
480	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCircuitsRoutesTableListResultResponse, error) {
481		return poller.pollUntilDone(ctx, frequency)
482	}
483	return result, nil
484}
485
486// ListRoutesTable - Gets the currently advertised routes table associated with the express route cross connection in a resource group.
487// If the operation fails it returns the *CloudError error type.
488func (client *ExpressRouteCrossConnectionsClient) listRoutesTable(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListRoutesTableOptions) (*azcore.Response, error) {
489	req, err := client.listRoutesTableCreateRequest(ctx, resourceGroupName, crossConnectionName, peeringName, devicePath, options)
490	if err != nil {
491		return nil, err
492	}
493	resp, err := client.con.Pipeline().Do(req)
494	if err != nil {
495		return nil, err
496	}
497	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
498		return nil, client.listRoutesTableHandleError(resp)
499	}
500	return resp, nil
501}
502
503// listRoutesTableCreateRequest creates the ListRoutesTable request.
504func (client *ExpressRouteCrossConnectionsClient) listRoutesTableCreateRequest(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListRoutesTableOptions) (*azcore.Request, error) {
505	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections/{crossConnectionName}/peerings/{peeringName}/routeTables/{devicePath}"
506	if resourceGroupName == "" {
507		return nil, errors.New("parameter resourceGroupName cannot be empty")
508	}
509	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
510	if crossConnectionName == "" {
511		return nil, errors.New("parameter crossConnectionName cannot be empty")
512	}
513	urlPath = strings.ReplaceAll(urlPath, "{crossConnectionName}", url.PathEscape(crossConnectionName))
514	if peeringName == "" {
515		return nil, errors.New("parameter peeringName cannot be empty")
516	}
517	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
518	if devicePath == "" {
519		return nil, errors.New("parameter devicePath cannot be empty")
520	}
521	urlPath = strings.ReplaceAll(urlPath, "{devicePath}", url.PathEscape(devicePath))
522	if client.subscriptionID == "" {
523		return nil, errors.New("parameter client.subscriptionID cannot be empty")
524	}
525	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
526	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
527	if err != nil {
528		return nil, err
529	}
530	req.Telemetry(telemetryInfo)
531	reqQP := req.URL.Query()
532	reqQP.Set("api-version", "2021-02-01")
533	req.URL.RawQuery = reqQP.Encode()
534	req.Header.Set("Accept", "application/json")
535	return req, nil
536}
537
538// listRoutesTableHandleError handles the ListRoutesTable error response.
539func (client *ExpressRouteCrossConnectionsClient) listRoutesTableHandleError(resp *azcore.Response) error {
540	body, err := resp.Payload()
541	if err != nil {
542		return azcore.NewResponseError(err, resp.Response)
543	}
544	errType := CloudError{raw: string(body)}
545	if err := resp.UnmarshalAsJSON(&errType); err != nil {
546		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
547	}
548	return azcore.NewResponseError(&errType, resp.Response)
549}
550
551// BeginListRoutesTableSummary - Gets the route table summary associated with the express route cross connection in a resource group.
552// If the operation fails it returns the *CloudError error type.
553func (client *ExpressRouteCrossConnectionsClient) BeginListRoutesTableSummary(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListRoutesTableSummaryOptions) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse, error) {
554	resp, err := client.listRoutesTableSummary(ctx, resourceGroupName, crossConnectionName, peeringName, devicePath, options)
555	if err != nil {
556		return ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse{}, err
557	}
558	result := ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse{
559		RawResponse: resp.Response,
560	}
561	pt, err := armcore.NewLROPoller("ExpressRouteCrossConnectionsClient.ListRoutesTableSummary", "location", resp, client.con.Pipeline(), client.listRoutesTableSummaryHandleError)
562	if err != nil {
563		return ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse{}, err
564	}
565	poller := &expressRouteCrossConnectionsRoutesTableSummaryListResultPoller{
566		pt: pt,
567	}
568	result.Poller = poller
569	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse, error) {
570		return poller.pollUntilDone(ctx, frequency)
571	}
572	return result, nil
573}
574
575// ResumeListRoutesTableSummary creates a new ExpressRouteCrossConnectionsRoutesTableSummaryListResultPoller from the specified resume token.
576// token - The value must come from a previous call to ExpressRouteCrossConnectionsRoutesTableSummaryListResultPoller.ResumeToken().
577func (client *ExpressRouteCrossConnectionsClient) ResumeListRoutesTableSummary(ctx context.Context, token string) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse, error) {
578	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRouteCrossConnectionsClient.ListRoutesTableSummary", token, client.con.Pipeline(), client.listRoutesTableSummaryHandleError)
579	if err != nil {
580		return ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse{}, err
581	}
582	poller := &expressRouteCrossConnectionsRoutesTableSummaryListResultPoller{
583		pt: pt,
584	}
585	resp, err := poller.Poll(ctx)
586	if err != nil {
587		return ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse{}, err
588	}
589	result := ExpressRouteCrossConnectionsRoutesTableSummaryListResultPollerResponse{
590		RawResponse: resp,
591	}
592	result.Poller = poller
593	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRouteCrossConnectionsRoutesTableSummaryListResultResponse, error) {
594		return poller.pollUntilDone(ctx, frequency)
595	}
596	return result, nil
597}
598
599// ListRoutesTableSummary - Gets the route table summary associated with the express route cross connection in a resource group.
600// If the operation fails it returns the *CloudError error type.
601func (client *ExpressRouteCrossConnectionsClient) listRoutesTableSummary(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListRoutesTableSummaryOptions) (*azcore.Response, error) {
602	req, err := client.listRoutesTableSummaryCreateRequest(ctx, resourceGroupName, crossConnectionName, peeringName, devicePath, options)
603	if err != nil {
604		return nil, err
605	}
606	resp, err := client.con.Pipeline().Do(req)
607	if err != nil {
608		return nil, err
609	}
610	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
611		return nil, client.listRoutesTableSummaryHandleError(resp)
612	}
613	return resp, nil
614}
615
616// listRoutesTableSummaryCreateRequest creates the ListRoutesTableSummary request.
617func (client *ExpressRouteCrossConnectionsClient) listRoutesTableSummaryCreateRequest(ctx context.Context, resourceGroupName string, crossConnectionName string, peeringName string, devicePath string, options *ExpressRouteCrossConnectionsBeginListRoutesTableSummaryOptions) (*azcore.Request, error) {
618	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections/{crossConnectionName}/peerings/{peeringName}/routeTablesSummary/{devicePath}"
619	if resourceGroupName == "" {
620		return nil, errors.New("parameter resourceGroupName cannot be empty")
621	}
622	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
623	if crossConnectionName == "" {
624		return nil, errors.New("parameter crossConnectionName cannot be empty")
625	}
626	urlPath = strings.ReplaceAll(urlPath, "{crossConnectionName}", url.PathEscape(crossConnectionName))
627	if peeringName == "" {
628		return nil, errors.New("parameter peeringName cannot be empty")
629	}
630	urlPath = strings.ReplaceAll(urlPath, "{peeringName}", url.PathEscape(peeringName))
631	if devicePath == "" {
632		return nil, errors.New("parameter devicePath cannot be empty")
633	}
634	urlPath = strings.ReplaceAll(urlPath, "{devicePath}", url.PathEscape(devicePath))
635	if client.subscriptionID == "" {
636		return nil, errors.New("parameter client.subscriptionID cannot be empty")
637	}
638	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
639	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
640	if err != nil {
641		return nil, err
642	}
643	req.Telemetry(telemetryInfo)
644	reqQP := req.URL.Query()
645	reqQP.Set("api-version", "2021-02-01")
646	req.URL.RawQuery = reqQP.Encode()
647	req.Header.Set("Accept", "application/json")
648	return req, nil
649}
650
651// listRoutesTableSummaryHandleError handles the ListRoutesTableSummary error response.
652func (client *ExpressRouteCrossConnectionsClient) listRoutesTableSummaryHandleError(resp *azcore.Response) error {
653	body, err := resp.Payload()
654	if err != nil {
655		return azcore.NewResponseError(err, resp.Response)
656	}
657	errType := CloudError{raw: string(body)}
658	if err := resp.UnmarshalAsJSON(&errType); err != nil {
659		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
660	}
661	return azcore.NewResponseError(&errType, resp.Response)
662}
663
664// UpdateTags - Updates an express route cross connection tags.
665// If the operation fails it returns the *CloudError error type.
666func (client *ExpressRouteCrossConnectionsClient) UpdateTags(ctx context.Context, resourceGroupName string, crossConnectionName string, crossConnectionParameters TagsObject, options *ExpressRouteCrossConnectionsUpdateTagsOptions) (ExpressRouteCrossConnectionResponse, error) {
667	req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, crossConnectionName, crossConnectionParameters, options)
668	if err != nil {
669		return ExpressRouteCrossConnectionResponse{}, err
670	}
671	resp, err := client.con.Pipeline().Do(req)
672	if err != nil {
673		return ExpressRouteCrossConnectionResponse{}, err
674	}
675	if !resp.HasStatusCode(http.StatusOK) {
676		return ExpressRouteCrossConnectionResponse{}, client.updateTagsHandleError(resp)
677	}
678	return client.updateTagsHandleResponse(resp)
679}
680
681// updateTagsCreateRequest creates the UpdateTags request.
682func (client *ExpressRouteCrossConnectionsClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, crossConnectionName string, crossConnectionParameters TagsObject, options *ExpressRouteCrossConnectionsUpdateTagsOptions) (*azcore.Request, error) {
683	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRouteCrossConnections/{crossConnectionName}"
684	if resourceGroupName == "" {
685		return nil, errors.New("parameter resourceGroupName cannot be empty")
686	}
687	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
688	if crossConnectionName == "" {
689		return nil, errors.New("parameter crossConnectionName cannot be empty")
690	}
691	urlPath = strings.ReplaceAll(urlPath, "{crossConnectionName}", url.PathEscape(crossConnectionName))
692	if client.subscriptionID == "" {
693		return nil, errors.New("parameter client.subscriptionID cannot be empty")
694	}
695	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
696	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
697	if err != nil {
698		return nil, err
699	}
700	req.Telemetry(telemetryInfo)
701	reqQP := req.URL.Query()
702	reqQP.Set("api-version", "2021-02-01")
703	req.URL.RawQuery = reqQP.Encode()
704	req.Header.Set("Accept", "application/json")
705	return req, req.MarshalAsJSON(crossConnectionParameters)
706}
707
708// updateTagsHandleResponse handles the UpdateTags response.
709func (client *ExpressRouteCrossConnectionsClient) updateTagsHandleResponse(resp *azcore.Response) (ExpressRouteCrossConnectionResponse, error) {
710	var val *ExpressRouteCrossConnection
711	if err := resp.UnmarshalAsJSON(&val); err != nil {
712		return ExpressRouteCrossConnectionResponse{}, err
713	}
714	return ExpressRouteCrossConnectionResponse{RawResponse: resp.Response, ExpressRouteCrossConnection: val}, nil
715}
716
717// updateTagsHandleError handles the UpdateTags error response.
718func (client *ExpressRouteCrossConnectionsClient) updateTagsHandleError(resp *azcore.Response) error {
719	body, err := resp.Payload()
720	if err != nil {
721		return azcore.NewResponseError(err, resp.Response)
722	}
723	errType := CloudError{raw: string(body)}
724	if err := resp.UnmarshalAsJSON(&errType); err != nil {
725		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
726	}
727	return azcore.NewResponseError(&errType, resp.Response)
728}
729