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	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
13	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
14	"net/http"
15	"net/url"
16	"strings"
17	"time"
18)
19
20// ExpressRoutePortsClient contains the methods for the ExpressRoutePorts group.
21// Don't use this type directly, use NewExpressRoutePortsClient() instead.
22type ExpressRoutePortsClient struct {
23	con            *armcore.Connection
24	subscriptionID string
25}
26
27// NewExpressRoutePortsClient creates a new instance of ExpressRoutePortsClient with the specified values.
28func NewExpressRoutePortsClient(con *armcore.Connection, subscriptionID string) *ExpressRoutePortsClient {
29	return &ExpressRoutePortsClient{con: con, subscriptionID: subscriptionID}
30}
31
32// BeginCreateOrUpdate - Creates or updates the specified ExpressRoutePort resource.
33func (client *ExpressRoutePortsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters ExpressRoutePort, options *ExpressRoutePortsBeginCreateOrUpdateOptions) (ExpressRoutePortPollerResponse, error) {
34	resp, err := client.createOrUpdate(ctx, resourceGroupName, expressRoutePortName, parameters, options)
35	if err != nil {
36		return ExpressRoutePortPollerResponse{}, err
37	}
38	result := ExpressRoutePortPollerResponse{
39		RawResponse: resp.Response,
40	}
41	pt, err := armcore.NewPoller("ExpressRoutePortsClient.CreateOrUpdate", "azure-async-operation", resp, client.createOrUpdateHandleError)
42	if err != nil {
43		return ExpressRoutePortPollerResponse{}, err
44	}
45	poller := &expressRoutePortPoller{
46		pt:       pt,
47		pipeline: client.con.Pipeline(),
48	}
49	result.Poller = poller
50	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRoutePortResponse, error) {
51		return poller.pollUntilDone(ctx, frequency)
52	}
53	return result, nil
54}
55
56// ResumeCreateOrUpdate creates a new ExpressRoutePortPoller from the specified resume token.
57// token - The value must come from a previous call to ExpressRoutePortPoller.ResumeToken().
58func (client *ExpressRoutePortsClient) ResumeCreateOrUpdate(token string) (ExpressRoutePortPoller, error) {
59	pt, err := armcore.NewPollerFromResumeToken("ExpressRoutePortsClient.CreateOrUpdate", token, client.createOrUpdateHandleError)
60	if err != nil {
61		return nil, err
62	}
63	return &expressRoutePortPoller{
64		pipeline: client.con.Pipeline(),
65		pt:       pt,
66	}, nil
67}
68
69// CreateOrUpdate - Creates or updates the specified ExpressRoutePort resource.
70func (client *ExpressRoutePortsClient) createOrUpdate(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters ExpressRoutePort, options *ExpressRoutePortsBeginCreateOrUpdateOptions) (*azcore.Response, error) {
71	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, expressRoutePortName, parameters, options)
72	if err != nil {
73		return nil, err
74	}
75	resp, err := client.con.Pipeline().Do(req)
76	if err != nil {
77		return nil, err
78	}
79	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
80		return nil, client.createOrUpdateHandleError(resp)
81	}
82	return resp, nil
83}
84
85// createOrUpdateCreateRequest creates the CreateOrUpdate request.
86func (client *ExpressRoutePortsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters ExpressRoutePort, options *ExpressRoutePortsBeginCreateOrUpdateOptions) (*azcore.Request, error) {
87	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
88	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
89	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
90	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
91	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
92	if err != nil {
93		return nil, err
94	}
95	req.Telemetry(telemetryInfo)
96	query := req.URL.Query()
97	query.Set("api-version", "2020-07-01")
98	req.URL.RawQuery = query.Encode()
99	req.Header.Set("Accept", "application/json")
100	return req, req.MarshalAsJSON(parameters)
101}
102
103// createOrUpdateHandleResponse handles the CreateOrUpdate response.
104func (client *ExpressRoutePortsClient) createOrUpdateHandleResponse(resp *azcore.Response) (ExpressRoutePortResponse, error) {
105	var val *ExpressRoutePort
106	if err := resp.UnmarshalAsJSON(&val); err != nil {
107		return ExpressRoutePortResponse{}, err
108	}
109	return ExpressRoutePortResponse{RawResponse: resp.Response, ExpressRoutePort: val}, nil
110}
111
112// createOrUpdateHandleError handles the CreateOrUpdate error response.
113func (client *ExpressRoutePortsClient) createOrUpdateHandleError(resp *azcore.Response) error {
114	var err CloudError
115	if err := resp.UnmarshalAsJSON(&err); err != nil {
116		return err
117	}
118	return azcore.NewResponseError(&err, resp.Response)
119}
120
121// BeginDelete - Deletes the specified ExpressRoutePort resource.
122func (client *ExpressRoutePortsClient) BeginDelete(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsBeginDeleteOptions) (HTTPPollerResponse, error) {
123	resp, err := client.delete(ctx, resourceGroupName, expressRoutePortName, options)
124	if err != nil {
125		return HTTPPollerResponse{}, err
126	}
127	result := HTTPPollerResponse{
128		RawResponse: resp.Response,
129	}
130	pt, err := armcore.NewPoller("ExpressRoutePortsClient.Delete", "location", resp, client.deleteHandleError)
131	if err != nil {
132		return HTTPPollerResponse{}, err
133	}
134	poller := &httpPoller{
135		pt:       pt,
136		pipeline: client.con.Pipeline(),
137	}
138	result.Poller = poller
139	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
140		return poller.pollUntilDone(ctx, frequency)
141	}
142	return result, nil
143}
144
145// ResumeDelete creates a new HTTPPoller from the specified resume token.
146// token - The value must come from a previous call to HTTPPoller.ResumeToken().
147func (client *ExpressRoutePortsClient) ResumeDelete(token string) (HTTPPoller, error) {
148	pt, err := armcore.NewPollerFromResumeToken("ExpressRoutePortsClient.Delete", token, client.deleteHandleError)
149	if err != nil {
150		return nil, err
151	}
152	return &httpPoller{
153		pipeline: client.con.Pipeline(),
154		pt:       pt,
155	}, nil
156}
157
158// Delete - Deletes the specified ExpressRoutePort resource.
159func (client *ExpressRoutePortsClient) delete(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsBeginDeleteOptions) (*azcore.Response, error) {
160	req, err := client.deleteCreateRequest(ctx, resourceGroupName, expressRoutePortName, options)
161	if err != nil {
162		return nil, err
163	}
164	resp, err := client.con.Pipeline().Do(req)
165	if err != nil {
166		return nil, err
167	}
168	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
169		return nil, client.deleteHandleError(resp)
170	}
171	return resp, nil
172}
173
174// deleteCreateRequest creates the Delete request.
175func (client *ExpressRoutePortsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsBeginDeleteOptions) (*azcore.Request, error) {
176	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
177	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
178	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
179	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
180	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
181	if err != nil {
182		return nil, err
183	}
184	req.Telemetry(telemetryInfo)
185	query := req.URL.Query()
186	query.Set("api-version", "2020-07-01")
187	req.URL.RawQuery = query.Encode()
188	req.Header.Set("Accept", "application/json")
189	return req, nil
190}
191
192// deleteHandleError handles the Delete error response.
193func (client *ExpressRoutePortsClient) deleteHandleError(resp *azcore.Response) error {
194	var err CloudError
195	if err := resp.UnmarshalAsJSON(&err); err != nil {
196		return err
197	}
198	return azcore.NewResponseError(&err, resp.Response)
199}
200
201// GenerateLoa - Generate a letter of authorization for the requested ExpressRoutePort resource.
202func (client *ExpressRoutePortsClient) GenerateLoa(ctx context.Context, resourceGroupName string, expressRoutePortName string, request GenerateExpressRoutePortsLoaRequest, options *ExpressRoutePortsGenerateLoaOptions) (GenerateExpressRoutePortsLoaResultResponse, error) {
203	req, err := client.generateLoaCreateRequest(ctx, resourceGroupName, expressRoutePortName, request, options)
204	if err != nil {
205		return GenerateExpressRoutePortsLoaResultResponse{}, err
206	}
207	resp, err := client.con.Pipeline().Do(req)
208	if err != nil {
209		return GenerateExpressRoutePortsLoaResultResponse{}, err
210	}
211	if !resp.HasStatusCode(http.StatusOK) {
212		return GenerateExpressRoutePortsLoaResultResponse{}, client.generateLoaHandleError(resp)
213	}
214	return client.generateLoaHandleResponse(resp)
215}
216
217// generateLoaCreateRequest creates the GenerateLoa request.
218func (client *ExpressRoutePortsClient) generateLoaCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, request GenerateExpressRoutePortsLoaRequest, options *ExpressRoutePortsGenerateLoaOptions) (*azcore.Request, error) {
219	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRoutePorts/{expressRoutePortName}/generateLoa"
220	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
221	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
222	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
223	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
224	if err != nil {
225		return nil, err
226	}
227	req.Telemetry(telemetryInfo)
228	query := req.URL.Query()
229	query.Set("api-version", "2020-07-01")
230	req.URL.RawQuery = query.Encode()
231	req.Header.Set("Accept", "application/json")
232	return req, req.MarshalAsJSON(request)
233}
234
235// generateLoaHandleResponse handles the GenerateLoa response.
236func (client *ExpressRoutePortsClient) generateLoaHandleResponse(resp *azcore.Response) (GenerateExpressRoutePortsLoaResultResponse, error) {
237	var val *GenerateExpressRoutePortsLoaResult
238	if err := resp.UnmarshalAsJSON(&val); err != nil {
239		return GenerateExpressRoutePortsLoaResultResponse{}, err
240	}
241	return GenerateExpressRoutePortsLoaResultResponse{RawResponse: resp.Response, GenerateExpressRoutePortsLoaResult: val}, nil
242}
243
244// generateLoaHandleError handles the GenerateLoa error response.
245func (client *ExpressRoutePortsClient) generateLoaHandleError(resp *azcore.Response) error {
246	var err CloudError
247	if err := resp.UnmarshalAsJSON(&err); err != nil {
248		return err
249	}
250	return azcore.NewResponseError(&err, resp.Response)
251}
252
253// Get - Retrieves the requested ExpressRoutePort resource.
254func (client *ExpressRoutePortsClient) Get(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsGetOptions) (ExpressRoutePortResponse, error) {
255	req, err := client.getCreateRequest(ctx, resourceGroupName, expressRoutePortName, options)
256	if err != nil {
257		return ExpressRoutePortResponse{}, err
258	}
259	resp, err := client.con.Pipeline().Do(req)
260	if err != nil {
261		return ExpressRoutePortResponse{}, err
262	}
263	if !resp.HasStatusCode(http.StatusOK) {
264		return ExpressRoutePortResponse{}, client.getHandleError(resp)
265	}
266	return client.getHandleResponse(resp)
267}
268
269// getCreateRequest creates the Get request.
270func (client *ExpressRoutePortsClient) getCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsGetOptions) (*azcore.Request, error) {
271	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
272	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
273	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
274	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
275	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
276	if err != nil {
277		return nil, err
278	}
279	req.Telemetry(telemetryInfo)
280	query := req.URL.Query()
281	query.Set("api-version", "2020-07-01")
282	req.URL.RawQuery = query.Encode()
283	req.Header.Set("Accept", "application/json")
284	return req, nil
285}
286
287// getHandleResponse handles the Get response.
288func (client *ExpressRoutePortsClient) getHandleResponse(resp *azcore.Response) (ExpressRoutePortResponse, error) {
289	var val *ExpressRoutePort
290	if err := resp.UnmarshalAsJSON(&val); err != nil {
291		return ExpressRoutePortResponse{}, err
292	}
293	return ExpressRoutePortResponse{RawResponse: resp.Response, ExpressRoutePort: val}, nil
294}
295
296// getHandleError handles the Get error response.
297func (client *ExpressRoutePortsClient) getHandleError(resp *azcore.Response) error {
298	var err CloudError
299	if err := resp.UnmarshalAsJSON(&err); err != nil {
300		return err
301	}
302	return azcore.NewResponseError(&err, resp.Response)
303}
304
305// List - List all the ExpressRoutePort resources in the specified subscription.
306func (client *ExpressRoutePortsClient) List(options *ExpressRoutePortsListOptions) ExpressRoutePortListResultPager {
307	return &expressRoutePortListResultPager{
308		pipeline: client.con.Pipeline(),
309		requester: func(ctx context.Context) (*azcore.Request, error) {
310			return client.listCreateRequest(ctx, options)
311		},
312		responder: client.listHandleResponse,
313		errorer:   client.listHandleError,
314		advancer: func(ctx context.Context, resp ExpressRoutePortListResultResponse) (*azcore.Request, error) {
315			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRoutePortListResult.NextLink)
316		},
317		statusCodes: []int{http.StatusOK},
318	}
319}
320
321// listCreateRequest creates the List request.
322func (client *ExpressRoutePortsClient) listCreateRequest(ctx context.Context, options *ExpressRoutePortsListOptions) (*azcore.Request, error) {
323	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/ExpressRoutePorts"
324	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
325	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
326	if err != nil {
327		return nil, err
328	}
329	req.Telemetry(telemetryInfo)
330	query := req.URL.Query()
331	query.Set("api-version", "2020-07-01")
332	req.URL.RawQuery = query.Encode()
333	req.Header.Set("Accept", "application/json")
334	return req, nil
335}
336
337// listHandleResponse handles the List response.
338func (client *ExpressRoutePortsClient) listHandleResponse(resp *azcore.Response) (ExpressRoutePortListResultResponse, error) {
339	var val *ExpressRoutePortListResult
340	if err := resp.UnmarshalAsJSON(&val); err != nil {
341		return ExpressRoutePortListResultResponse{}, err
342	}
343	return ExpressRoutePortListResultResponse{RawResponse: resp.Response, ExpressRoutePortListResult: val}, nil
344}
345
346// listHandleError handles the List error response.
347func (client *ExpressRoutePortsClient) listHandleError(resp *azcore.Response) error {
348	var err CloudError
349	if err := resp.UnmarshalAsJSON(&err); err != nil {
350		return err
351	}
352	return azcore.NewResponseError(&err, resp.Response)
353}
354
355// ListByResourceGroup - List all the ExpressRoutePort resources in the specified resource group.
356func (client *ExpressRoutePortsClient) ListByResourceGroup(resourceGroupName string, options *ExpressRoutePortsListByResourceGroupOptions) ExpressRoutePortListResultPager {
357	return &expressRoutePortListResultPager{
358		pipeline: client.con.Pipeline(),
359		requester: func(ctx context.Context) (*azcore.Request, error) {
360			return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options)
361		},
362		responder: client.listByResourceGroupHandleResponse,
363		errorer:   client.listByResourceGroupHandleError,
364		advancer: func(ctx context.Context, resp ExpressRoutePortListResultResponse) (*azcore.Request, error) {
365			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRoutePortListResult.NextLink)
366		},
367		statusCodes: []int{http.StatusOK},
368	}
369}
370
371// listByResourceGroupCreateRequest creates the ListByResourceGroup request.
372func (client *ExpressRoutePortsClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *ExpressRoutePortsListByResourceGroupOptions) (*azcore.Request, error) {
373	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts"
374	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
375	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
376	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
377	if err != nil {
378		return nil, err
379	}
380	req.Telemetry(telemetryInfo)
381	query := req.URL.Query()
382	query.Set("api-version", "2020-07-01")
383	req.URL.RawQuery = query.Encode()
384	req.Header.Set("Accept", "application/json")
385	return req, nil
386}
387
388// listByResourceGroupHandleResponse handles the ListByResourceGroup response.
389func (client *ExpressRoutePortsClient) listByResourceGroupHandleResponse(resp *azcore.Response) (ExpressRoutePortListResultResponse, error) {
390	var val *ExpressRoutePortListResult
391	if err := resp.UnmarshalAsJSON(&val); err != nil {
392		return ExpressRoutePortListResultResponse{}, err
393	}
394	return ExpressRoutePortListResultResponse{RawResponse: resp.Response, ExpressRoutePortListResult: val}, nil
395}
396
397// listByResourceGroupHandleError handles the ListByResourceGroup error response.
398func (client *ExpressRoutePortsClient) listByResourceGroupHandleError(resp *azcore.Response) error {
399	var err CloudError
400	if err := resp.UnmarshalAsJSON(&err); err != nil {
401		return err
402	}
403	return azcore.NewResponseError(&err, resp.Response)
404}
405
406// UpdateTags - Update ExpressRoutePort tags.
407func (client *ExpressRoutePortsClient) UpdateTags(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters TagsObject, options *ExpressRoutePortsUpdateTagsOptions) (ExpressRoutePortResponse, error) {
408	req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, expressRoutePortName, parameters, options)
409	if err != nil {
410		return ExpressRoutePortResponse{}, err
411	}
412	resp, err := client.con.Pipeline().Do(req)
413	if err != nil {
414		return ExpressRoutePortResponse{}, err
415	}
416	if !resp.HasStatusCode(http.StatusOK) {
417		return ExpressRoutePortResponse{}, client.updateTagsHandleError(resp)
418	}
419	return client.updateTagsHandleResponse(resp)
420}
421
422// updateTagsCreateRequest creates the UpdateTags request.
423func (client *ExpressRoutePortsClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters TagsObject, options *ExpressRoutePortsUpdateTagsOptions) (*azcore.Request, error) {
424	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
425	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
426	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
427	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
428	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
429	if err != nil {
430		return nil, err
431	}
432	req.Telemetry(telemetryInfo)
433	query := req.URL.Query()
434	query.Set("api-version", "2020-07-01")
435	req.URL.RawQuery = query.Encode()
436	req.Header.Set("Accept", "application/json")
437	return req, req.MarshalAsJSON(parameters)
438}
439
440// updateTagsHandleResponse handles the UpdateTags response.
441func (client *ExpressRoutePortsClient) updateTagsHandleResponse(resp *azcore.Response) (ExpressRoutePortResponse, error) {
442	var val *ExpressRoutePort
443	if err := resp.UnmarshalAsJSON(&val); err != nil {
444		return ExpressRoutePortResponse{}, err
445	}
446	return ExpressRoutePortResponse{RawResponse: resp.Response, ExpressRoutePort: val}, nil
447}
448
449// updateTagsHandleError handles the UpdateTags error response.
450func (client *ExpressRoutePortsClient) updateTagsHandleError(resp *azcore.Response) error {
451	var err CloudError
452	if err := resp.UnmarshalAsJSON(&err); err != nil {
453		return err
454	}
455	return azcore.NewResponseError(&err, resp.Response)
456}
457