1 package network
2
3
4
5
6
7
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/autorest/validation"
14 "github.com/Azure/go-autorest/tracing"
15 "net/http"
16 )
17
18
19 type VirtualRoutersClient struct {
20 BaseClient
21 }
22
23
24 func NewVirtualRoutersClient(subscriptionID string) VirtualRoutersClient {
25 return NewVirtualRoutersClientWithBaseURI(DefaultBaseURI, subscriptionID)
26 }
27
28
29
30 func NewVirtualRoutersClientWithBaseURI(baseURI string, subscriptionID string) VirtualRoutersClient {
31 return VirtualRoutersClient{NewWithBaseURI(baseURI, subscriptionID)}
32 }
33
34
35
36
37
38
39 func (client VirtualRoutersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualRouterName string, parameters VirtualRouter) (result VirtualRoutersCreateOrUpdateFuture, err error) {
40 if tracing.IsEnabled() {
41 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.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 if err := validation.Validate([]validation.Validation{
51 {TargetValue: parameters,
52 Constraints: []validation.Constraint{{Target: "parameters.VirtualRouterPropertiesFormat", Name: validation.Null, Rule: false,
53 Chain: []validation.Constraint{{Target: "parameters.VirtualRouterPropertiesFormat.VirtualRouterAsn", Name: validation.Null, Rule: false,
54 Chain: []validation.Constraint{{Target: "parameters.VirtualRouterPropertiesFormat.VirtualRouterAsn", Name: validation.InclusiveMaximum, Rule: int64(4294967295), Chain: nil},
55 {Target: "parameters.VirtualRouterPropertiesFormat.VirtualRouterAsn", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil},
56 }},
57 }}}}}); err != nil {
58 return result, validation.NewError("network.VirtualRoutersClient", "CreateOrUpdate", err.Error())
59 }
60
61 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualRouterName, parameters)
62 if err != nil {
63 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "CreateOrUpdate", nil, "Failure preparing request")
64 return
65 }
66
67 result, err = client.CreateOrUpdateSender(req)
68 if err != nil {
69 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "CreateOrUpdate", result.Response(), "Failure sending request")
70 return
71 }
72
73 return
74 }
75
76
77 func (client VirtualRoutersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualRouterName string, parameters VirtualRouter) (*http.Request, error) {
78 pathParameters := map[string]interface{}{
79 "resourceGroupName": autorest.Encode("path", resourceGroupName),
80 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
81 "virtualRouterName": autorest.Encode("path", virtualRouterName),
82 }
83
84 const APIVersion = "2022-05-01"
85 queryParameters := map[string]interface{}{
86 "api-version": APIVersion,
87 }
88
89 parameters.Etag = nil
90 preparer := autorest.CreatePreparer(
91 autorest.AsContentType("application/json; charset=utf-8"),
92 autorest.AsPut(),
93 autorest.WithBaseURL(client.BaseURI),
94 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualRouters/{virtualRouterName}", pathParameters),
95 autorest.WithJSON(parameters),
96 autorest.WithQueryParameters(queryParameters))
97 return preparer.Prepare((&http.Request{}).WithContext(ctx))
98 }
99
100
101
102 func (client VirtualRoutersClient) CreateOrUpdateSender(req *http.Request) (future VirtualRoutersCreateOrUpdateFuture, err error) {
103 var resp *http.Response
104 future.FutureAPI = &azure.Future{}
105 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
106 if err != nil {
107 return
108 }
109 var azf azure.Future
110 azf, err = azure.NewFutureFromResponse(resp)
111 future.FutureAPI = &azf
112 future.Result = future.result
113 return
114 }
115
116
117
118 func (client VirtualRoutersClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualRouter, err error) {
119 err = autorest.Respond(
120 resp,
121 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
122 autorest.ByUnmarshallingJSON(&result),
123 autorest.ByClosing())
124 result.Response = autorest.Response{Response: resp}
125 return
126 }
127
128
129
130
131
132 func (client VirtualRoutersClient) Delete(ctx context.Context, resourceGroupName string, virtualRouterName string) (result VirtualRoutersDeleteFuture, err error) {
133 if tracing.IsEnabled() {
134 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.Delete")
135 defer func() {
136 sc := -1
137 if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
138 sc = result.FutureAPI.Response().StatusCode
139 }
140 tracing.EndSpan(ctx, sc, err)
141 }()
142 }
143 req, err := client.DeletePreparer(ctx, resourceGroupName, virtualRouterName)
144 if err != nil {
145 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "Delete", nil, "Failure preparing request")
146 return
147 }
148
149 result, err = client.DeleteSender(req)
150 if err != nil {
151 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "Delete", result.Response(), "Failure sending request")
152 return
153 }
154
155 return
156 }
157
158
159 func (client VirtualRoutersClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualRouterName string) (*http.Request, error) {
160 pathParameters := map[string]interface{}{
161 "resourceGroupName": autorest.Encode("path", resourceGroupName),
162 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
163 "virtualRouterName": autorest.Encode("path", virtualRouterName),
164 }
165
166 const APIVersion = "2022-05-01"
167 queryParameters := map[string]interface{}{
168 "api-version": APIVersion,
169 }
170
171 preparer := autorest.CreatePreparer(
172 autorest.AsDelete(),
173 autorest.WithBaseURL(client.BaseURI),
174 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualRouters/{virtualRouterName}", pathParameters),
175 autorest.WithQueryParameters(queryParameters))
176 return preparer.Prepare((&http.Request{}).WithContext(ctx))
177 }
178
179
180
181 func (client VirtualRoutersClient) DeleteSender(req *http.Request) (future VirtualRoutersDeleteFuture, err error) {
182 var resp *http.Response
183 future.FutureAPI = &azure.Future{}
184 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
185 if err != nil {
186 return
187 }
188 var azf azure.Future
189 azf, err = azure.NewFutureFromResponse(resp)
190 future.FutureAPI = &azf
191 future.Result = future.result
192 return
193 }
194
195
196
197 func (client VirtualRoutersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
198 err = autorest.Respond(
199 resp,
200 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
201 autorest.ByClosing())
202 result.Response = resp
203 return
204 }
205
206
207
208
209
210
211 func (client VirtualRoutersClient) Get(ctx context.Context, resourceGroupName string, virtualRouterName string, expand string) (result VirtualRouter, err error) {
212 if tracing.IsEnabled() {
213 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.Get")
214 defer func() {
215 sc := -1
216 if result.Response.Response != nil {
217 sc = result.Response.Response.StatusCode
218 }
219 tracing.EndSpan(ctx, sc, err)
220 }()
221 }
222 req, err := client.GetPreparer(ctx, resourceGroupName, virtualRouterName, expand)
223 if err != nil {
224 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "Get", nil, "Failure preparing request")
225 return
226 }
227
228 resp, err := client.GetSender(req)
229 if err != nil {
230 result.Response = autorest.Response{Response: resp}
231 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "Get", resp, "Failure sending request")
232 return
233 }
234
235 result, err = client.GetResponder(resp)
236 if err != nil {
237 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "Get", resp, "Failure responding to request")
238 return
239 }
240
241 return
242 }
243
244
245 func (client VirtualRoutersClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualRouterName string, expand string) (*http.Request, error) {
246 pathParameters := map[string]interface{}{
247 "resourceGroupName": autorest.Encode("path", resourceGroupName),
248 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
249 "virtualRouterName": autorest.Encode("path", virtualRouterName),
250 }
251
252 const APIVersion = "2022-05-01"
253 queryParameters := map[string]interface{}{
254 "api-version": APIVersion,
255 }
256 if len(expand) > 0 {
257 queryParameters["$expand"] = autorest.Encode("query", expand)
258 }
259
260 preparer := autorest.CreatePreparer(
261 autorest.AsGet(),
262 autorest.WithBaseURL(client.BaseURI),
263 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualRouters/{virtualRouterName}", pathParameters),
264 autorest.WithQueryParameters(queryParameters))
265 return preparer.Prepare((&http.Request{}).WithContext(ctx))
266 }
267
268
269
270 func (client VirtualRoutersClient) GetSender(req *http.Request) (*http.Response, error) {
271 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
272 }
273
274
275
276 func (client VirtualRoutersClient) GetResponder(resp *http.Response) (result VirtualRouter, err error) {
277 err = autorest.Respond(
278 resp,
279 azure.WithErrorUnlessStatusCode(http.StatusOK),
280 autorest.ByUnmarshallingJSON(&result),
281 autorest.ByClosing())
282 result.Response = autorest.Response{Response: resp}
283 return
284 }
285
286
287 func (client VirtualRoutersClient) List(ctx context.Context) (result VirtualRouterListResultPage, err error) {
288 if tracing.IsEnabled() {
289 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.List")
290 defer func() {
291 sc := -1
292 if result.vrlr.Response.Response != nil {
293 sc = result.vrlr.Response.Response.StatusCode
294 }
295 tracing.EndSpan(ctx, sc, err)
296 }()
297 }
298 result.fn = client.listNextResults
299 req, err := client.ListPreparer(ctx)
300 if err != nil {
301 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "List", nil, "Failure preparing request")
302 return
303 }
304
305 resp, err := client.ListSender(req)
306 if err != nil {
307 result.vrlr.Response = autorest.Response{Response: resp}
308 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "List", resp, "Failure sending request")
309 return
310 }
311
312 result.vrlr, err = client.ListResponder(resp)
313 if err != nil {
314 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "List", resp, "Failure responding to request")
315 return
316 }
317 if result.vrlr.hasNextLink() && result.vrlr.IsEmpty() {
318 err = result.NextWithContext(ctx)
319 return
320 }
321
322 return
323 }
324
325
326 func (client VirtualRoutersClient) ListPreparer(ctx context.Context) (*http.Request, error) {
327 pathParameters := map[string]interface{}{
328 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
329 }
330
331 const APIVersion = "2022-05-01"
332 queryParameters := map[string]interface{}{
333 "api-version": APIVersion,
334 }
335
336 preparer := autorest.CreatePreparer(
337 autorest.AsGet(),
338 autorest.WithBaseURL(client.BaseURI),
339 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/virtualRouters", pathParameters),
340 autorest.WithQueryParameters(queryParameters))
341 return preparer.Prepare((&http.Request{}).WithContext(ctx))
342 }
343
344
345
346 func (client VirtualRoutersClient) ListSender(req *http.Request) (*http.Response, error) {
347 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
348 }
349
350
351
352 func (client VirtualRoutersClient) ListResponder(resp *http.Response) (result VirtualRouterListResult, err error) {
353 err = autorest.Respond(
354 resp,
355 azure.WithErrorUnlessStatusCode(http.StatusOK),
356 autorest.ByUnmarshallingJSON(&result),
357 autorest.ByClosing())
358 result.Response = autorest.Response{Response: resp}
359 return
360 }
361
362
363 func (client VirtualRoutersClient) listNextResults(ctx context.Context, lastResults VirtualRouterListResult) (result VirtualRouterListResult, err error) {
364 req, err := lastResults.virtualRouterListResultPreparer(ctx)
365 if err != nil {
366 return result, autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "listNextResults", nil, "Failure preparing next results request")
367 }
368 if req == nil {
369 return
370 }
371 resp, err := client.ListSender(req)
372 if err != nil {
373 result.Response = autorest.Response{Response: resp}
374 return result, autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "listNextResults", resp, "Failure sending next results request")
375 }
376 result, err = client.ListResponder(resp)
377 if err != nil {
378 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "listNextResults", resp, "Failure responding to next results request")
379 }
380 return
381 }
382
383
384 func (client VirtualRoutersClient) ListComplete(ctx context.Context) (result VirtualRouterListResultIterator, err error) {
385 if tracing.IsEnabled() {
386 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.List")
387 defer func() {
388 sc := -1
389 if result.Response().Response.Response != nil {
390 sc = result.page.Response().Response.Response.StatusCode
391 }
392 tracing.EndSpan(ctx, sc, err)
393 }()
394 }
395 result.page, err = client.List(ctx)
396 return
397 }
398
399
400
401
402 func (client VirtualRoutersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result VirtualRouterListResultPage, err error) {
403 if tracing.IsEnabled() {
404 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.ListByResourceGroup")
405 defer func() {
406 sc := -1
407 if result.vrlr.Response.Response != nil {
408 sc = result.vrlr.Response.Response.StatusCode
409 }
410 tracing.EndSpan(ctx, sc, err)
411 }()
412 }
413 result.fn = client.listByResourceGroupNextResults
414 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
415 if err != nil {
416 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "ListByResourceGroup", nil, "Failure preparing request")
417 return
418 }
419
420 resp, err := client.ListByResourceGroupSender(req)
421 if err != nil {
422 result.vrlr.Response = autorest.Response{Response: resp}
423 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "ListByResourceGroup", resp, "Failure sending request")
424 return
425 }
426
427 result.vrlr, err = client.ListByResourceGroupResponder(resp)
428 if err != nil {
429 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "ListByResourceGroup", resp, "Failure responding to request")
430 return
431 }
432 if result.vrlr.hasNextLink() && result.vrlr.IsEmpty() {
433 err = result.NextWithContext(ctx)
434 return
435 }
436
437 return
438 }
439
440
441 func (client VirtualRoutersClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
442 pathParameters := map[string]interface{}{
443 "resourceGroupName": autorest.Encode("path", resourceGroupName),
444 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
445 }
446
447 const APIVersion = "2022-05-01"
448 queryParameters := map[string]interface{}{
449 "api-version": APIVersion,
450 }
451
452 preparer := autorest.CreatePreparer(
453 autorest.AsGet(),
454 autorest.WithBaseURL(client.BaseURI),
455 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualRouters", pathParameters),
456 autorest.WithQueryParameters(queryParameters))
457 return preparer.Prepare((&http.Request{}).WithContext(ctx))
458 }
459
460
461
462 func (client VirtualRoutersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
463 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
464 }
465
466
467
468 func (client VirtualRoutersClient) ListByResourceGroupResponder(resp *http.Response) (result VirtualRouterListResult, err error) {
469 err = autorest.Respond(
470 resp,
471 azure.WithErrorUnlessStatusCode(http.StatusOK),
472 autorest.ByUnmarshallingJSON(&result),
473 autorest.ByClosing())
474 result.Response = autorest.Response{Response: resp}
475 return
476 }
477
478
479 func (client VirtualRoutersClient) listByResourceGroupNextResults(ctx context.Context, lastResults VirtualRouterListResult) (result VirtualRouterListResult, err error) {
480 req, err := lastResults.virtualRouterListResultPreparer(ctx)
481 if err != nil {
482 return result, autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
483 }
484 if req == nil {
485 return
486 }
487 resp, err := client.ListByResourceGroupSender(req)
488 if err != nil {
489 result.Response = autorest.Response{Response: resp}
490 return result, autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
491 }
492 result, err = client.ListByResourceGroupResponder(resp)
493 if err != nil {
494 err = autorest.NewErrorWithError(err, "network.VirtualRoutersClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
495 }
496 return
497 }
498
499
500 func (client VirtualRoutersClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result VirtualRouterListResultIterator, err error) {
501 if tracing.IsEnabled() {
502 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualRoutersClient.ListByResourceGroup")
503 defer func() {
504 sc := -1
505 if result.Response().Response.Response != nil {
506 sc = result.page.Response().Response.Response.StatusCode
507 }
508 tracing.EndSpan(ctx, sc, err)
509 }()
510 }
511 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
512 return
513 }
514
View as plain text