1package 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 9import ( 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// VirtualNetworksClient is the network Client 18type VirtualNetworksClient struct { 19 BaseClient 20} 21 22// NewVirtualNetworksClient creates an instance of the VirtualNetworksClient client. 23func NewVirtualNetworksClient(subscriptionID string) VirtualNetworksClient { 24 return NewVirtualNetworksClientWithBaseURI(DefaultBaseURI, subscriptionID) 25} 26 27// NewVirtualNetworksClientWithBaseURI creates an instance of the VirtualNetworksClient client using a custom endpoint. 28// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 29func NewVirtualNetworksClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworksClient { 30 return VirtualNetworksClient{NewWithBaseURI(baseURI, subscriptionID)} 31} 32 33// CheckIPAddressAvailability checks whether a private IP address is available for use. 34// Parameters: 35// resourceGroupName - the name of the resource group. 36// virtualNetworkName - the name of the virtual network. 37// IPAddress - the private IP address to be verified. 38func (client VirtualNetworksClient) CheckIPAddressAvailability(ctx context.Context, resourceGroupName string, virtualNetworkName string, IPAddress string) (result IPAddressAvailabilityResult, err error) { 39 if tracing.IsEnabled() { 40 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.CheckIPAddressAvailability") 41 defer func() { 42 sc := -1 43 if result.Response.Response != nil { 44 sc = result.Response.Response.StatusCode 45 } 46 tracing.EndSpan(ctx, sc, err) 47 }() 48 } 49 req, err := client.CheckIPAddressAvailabilityPreparer(ctx, resourceGroupName, virtualNetworkName, IPAddress) 50 if err != nil { 51 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CheckIPAddressAvailability", nil, "Failure preparing request") 52 return 53 } 54 55 resp, err := client.CheckIPAddressAvailabilitySender(req) 56 if err != nil { 57 result.Response = autorest.Response{Response: resp} 58 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CheckIPAddressAvailability", resp, "Failure sending request") 59 return 60 } 61 62 result, err = client.CheckIPAddressAvailabilityResponder(resp) 63 if err != nil { 64 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CheckIPAddressAvailability", resp, "Failure responding to request") 65 return 66 } 67 68 return 69} 70 71// CheckIPAddressAvailabilityPreparer prepares the CheckIPAddressAvailability request. 72func (client VirtualNetworksClient) CheckIPAddressAvailabilityPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, IPAddress string) (*http.Request, error) { 73 pathParameters := map[string]interface{}{ 74 "resourceGroupName": autorest.Encode("path", resourceGroupName), 75 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 76 "virtualNetworkName": autorest.Encode("path", virtualNetworkName), 77 } 78 79 const APIVersion = "2019-06-01" 80 queryParameters := map[string]interface{}{ 81 "api-version": APIVersion, 82 "ipAddress": autorest.Encode("query", IPAddress), 83 } 84 85 preparer := autorest.CreatePreparer( 86 autorest.AsGet(), 87 autorest.WithBaseURL(client.BaseURI), 88 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/CheckIPAddressAvailability", pathParameters), 89 autorest.WithQueryParameters(queryParameters)) 90 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 91} 92 93// CheckIPAddressAvailabilitySender sends the CheckIPAddressAvailability request. The method will close the 94// http.Response Body if it receives an error. 95func (client VirtualNetworksClient) CheckIPAddressAvailabilitySender(req *http.Request) (*http.Response, error) { 96 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 97} 98 99// CheckIPAddressAvailabilityResponder handles the response to the CheckIPAddressAvailability request. The method always 100// closes the http.Response Body. 101func (client VirtualNetworksClient) CheckIPAddressAvailabilityResponder(resp *http.Response) (result IPAddressAvailabilityResult, err error) { 102 err = autorest.Respond( 103 resp, 104 azure.WithErrorUnlessStatusCode(http.StatusOK), 105 autorest.ByUnmarshallingJSON(&result), 106 autorest.ByClosing()) 107 result.Response = autorest.Response{Response: resp} 108 return 109} 110 111// CreateOrUpdate creates or updates a virtual network in the specified resource group. 112// Parameters: 113// resourceGroupName - the name of the resource group. 114// virtualNetworkName - the name of the virtual network. 115// parameters - parameters supplied to the create or update virtual network operation. 116func (client VirtualNetworksClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork) (result VirtualNetworksCreateOrUpdateFuture, err error) { 117 if tracing.IsEnabled() { 118 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.CreateOrUpdate") 119 defer func() { 120 sc := -1 121 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 122 sc = result.FutureAPI.Response().StatusCode 123 } 124 tracing.EndSpan(ctx, sc, err) 125 }() 126 } 127 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkName, parameters) 128 if err != nil { 129 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CreateOrUpdate", nil, "Failure preparing request") 130 return 131 } 132 133 result, err = client.CreateOrUpdateSender(req) 134 if err != nil { 135 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "CreateOrUpdate", nil, "Failure sending request") 136 return 137 } 138 139 return 140} 141 142// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 143func (client VirtualNetworksClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork) (*http.Request, error) { 144 pathParameters := map[string]interface{}{ 145 "resourceGroupName": autorest.Encode("path", resourceGroupName), 146 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 147 "virtualNetworkName": autorest.Encode("path", virtualNetworkName), 148 } 149 150 const APIVersion = "2019-06-01" 151 queryParameters := map[string]interface{}{ 152 "api-version": APIVersion, 153 } 154 155 preparer := autorest.CreatePreparer( 156 autorest.AsContentType("application/json; charset=utf-8"), 157 autorest.AsPut(), 158 autorest.WithBaseURL(client.BaseURI), 159 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters), 160 autorest.WithJSON(parameters), 161 autorest.WithQueryParameters(queryParameters)) 162 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 163} 164 165// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 166// http.Response Body if it receives an error. 167func (client VirtualNetworksClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworksCreateOrUpdateFuture, err error) { 168 var resp *http.Response 169 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 170 if err != nil { 171 return 172 } 173 var azf azure.Future 174 azf, err = azure.NewFutureFromResponse(resp) 175 future.FutureAPI = &azf 176 future.Result = future.result 177 return 178} 179 180// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 181// closes the http.Response Body. 182func (client VirtualNetworksClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetwork, err error) { 183 err = autorest.Respond( 184 resp, 185 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 186 autorest.ByUnmarshallingJSON(&result), 187 autorest.ByClosing()) 188 result.Response = autorest.Response{Response: resp} 189 return 190} 191 192// Delete deletes the specified virtual network. 193// Parameters: 194// resourceGroupName - the name of the resource group. 195// virtualNetworkName - the name of the virtual network. 196func (client VirtualNetworksClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworksDeleteFuture, err error) { 197 if tracing.IsEnabled() { 198 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.Delete") 199 defer func() { 200 sc := -1 201 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 202 sc = result.FutureAPI.Response().StatusCode 203 } 204 tracing.EndSpan(ctx, sc, err) 205 }() 206 } 207 req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkName) 208 if err != nil { 209 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Delete", nil, "Failure preparing request") 210 return 211 } 212 213 result, err = client.DeleteSender(req) 214 if err != nil { 215 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Delete", nil, "Failure sending request") 216 return 217 } 218 219 return 220} 221 222// DeletePreparer prepares the Delete request. 223func (client VirtualNetworksClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string) (*http.Request, error) { 224 pathParameters := map[string]interface{}{ 225 "resourceGroupName": autorest.Encode("path", resourceGroupName), 226 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 227 "virtualNetworkName": autorest.Encode("path", virtualNetworkName), 228 } 229 230 const APIVersion = "2019-06-01" 231 queryParameters := map[string]interface{}{ 232 "api-version": APIVersion, 233 } 234 235 preparer := autorest.CreatePreparer( 236 autorest.AsDelete(), 237 autorest.WithBaseURL(client.BaseURI), 238 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters), 239 autorest.WithQueryParameters(queryParameters)) 240 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 241} 242 243// DeleteSender sends the Delete request. The method will close the 244// http.Response Body if it receives an error. 245func (client VirtualNetworksClient) DeleteSender(req *http.Request) (future VirtualNetworksDeleteFuture, err error) { 246 var resp *http.Response 247 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 248 if err != nil { 249 return 250 } 251 var azf azure.Future 252 azf, err = azure.NewFutureFromResponse(resp) 253 future.FutureAPI = &azf 254 future.Result = future.result 255 return 256} 257 258// DeleteResponder handles the response to the Delete request. The method always 259// closes the http.Response Body. 260func (client VirtualNetworksClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 261 err = autorest.Respond( 262 resp, 263 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 264 autorest.ByClosing()) 265 result.Response = resp 266 return 267} 268 269// Get gets the specified virtual network by resource group. 270// Parameters: 271// resourceGroupName - the name of the resource group. 272// virtualNetworkName - the name of the virtual network. 273// expand - expands referenced resources. 274func (client VirtualNetworksClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkName string, expand string) (result VirtualNetwork, err error) { 275 if tracing.IsEnabled() { 276 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.Get") 277 defer func() { 278 sc := -1 279 if result.Response.Response != nil { 280 sc = result.Response.Response.StatusCode 281 } 282 tracing.EndSpan(ctx, sc, err) 283 }() 284 } 285 req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkName, expand) 286 if err != nil { 287 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Get", nil, "Failure preparing request") 288 return 289 } 290 291 resp, err := client.GetSender(req) 292 if err != nil { 293 result.Response = autorest.Response{Response: resp} 294 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Get", resp, "Failure sending request") 295 return 296 } 297 298 result, err = client.GetResponder(resp) 299 if err != nil { 300 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "Get", resp, "Failure responding to request") 301 return 302 } 303 304 return 305} 306 307// GetPreparer prepares the Get request. 308func (client VirtualNetworksClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, expand string) (*http.Request, error) { 309 pathParameters := map[string]interface{}{ 310 "resourceGroupName": autorest.Encode("path", resourceGroupName), 311 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 312 "virtualNetworkName": autorest.Encode("path", virtualNetworkName), 313 } 314 315 const APIVersion = "2019-06-01" 316 queryParameters := map[string]interface{}{ 317 "api-version": APIVersion, 318 } 319 if len(expand) > 0 { 320 queryParameters["$expand"] = autorest.Encode("query", expand) 321 } 322 323 preparer := autorest.CreatePreparer( 324 autorest.AsGet(), 325 autorest.WithBaseURL(client.BaseURI), 326 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters), 327 autorest.WithQueryParameters(queryParameters)) 328 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 329} 330 331// GetSender sends the Get request. The method will close the 332// http.Response Body if it receives an error. 333func (client VirtualNetworksClient) GetSender(req *http.Request) (*http.Response, error) { 334 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 335} 336 337// GetResponder handles the response to the Get request. The method always 338// closes the http.Response Body. 339func (client VirtualNetworksClient) GetResponder(resp *http.Response) (result VirtualNetwork, 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// List gets all virtual networks in a resource group. 350// Parameters: 351// resourceGroupName - the name of the resource group. 352func (client VirtualNetworksClient) List(ctx context.Context, resourceGroupName string) (result VirtualNetworkListResultPage, err error) { 353 if tracing.IsEnabled() { 354 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.List") 355 defer func() { 356 sc := -1 357 if result.vnlr.Response.Response != nil { 358 sc = result.vnlr.Response.Response.StatusCode 359 } 360 tracing.EndSpan(ctx, sc, err) 361 }() 362 } 363 result.fn = client.listNextResults 364 req, err := client.ListPreparer(ctx, resourceGroupName) 365 if err != nil { 366 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "List", nil, "Failure preparing request") 367 return 368 } 369 370 resp, err := client.ListSender(req) 371 if err != nil { 372 result.vnlr.Response = autorest.Response{Response: resp} 373 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "List", resp, "Failure sending request") 374 return 375 } 376 377 result.vnlr, err = client.ListResponder(resp) 378 if err != nil { 379 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "List", resp, "Failure responding to request") 380 return 381 } 382 if result.vnlr.hasNextLink() && result.vnlr.IsEmpty() { 383 err = result.NextWithContext(ctx) 384 return 385 } 386 387 return 388} 389 390// ListPreparer prepares the List request. 391func (client VirtualNetworksClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 392 pathParameters := map[string]interface{}{ 393 "resourceGroupName": autorest.Encode("path", resourceGroupName), 394 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 395 } 396 397 const APIVersion = "2019-06-01" 398 queryParameters := map[string]interface{}{ 399 "api-version": APIVersion, 400 } 401 402 preparer := autorest.CreatePreparer( 403 autorest.AsGet(), 404 autorest.WithBaseURL(client.BaseURI), 405 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks", pathParameters), 406 autorest.WithQueryParameters(queryParameters)) 407 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 408} 409 410// ListSender sends the List request. The method will close the 411// http.Response Body if it receives an error. 412func (client VirtualNetworksClient) ListSender(req *http.Request) (*http.Response, error) { 413 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 414} 415 416// ListResponder handles the response to the List request. The method always 417// closes the http.Response Body. 418func (client VirtualNetworksClient) ListResponder(resp *http.Response) (result VirtualNetworkListResult, err error) { 419 err = autorest.Respond( 420 resp, 421 azure.WithErrorUnlessStatusCode(http.StatusOK), 422 autorest.ByUnmarshallingJSON(&result), 423 autorest.ByClosing()) 424 result.Response = autorest.Response{Response: resp} 425 return 426} 427 428// listNextResults retrieves the next set of results, if any. 429func (client VirtualNetworksClient) listNextResults(ctx context.Context, lastResults VirtualNetworkListResult) (result VirtualNetworkListResult, err error) { 430 req, err := lastResults.virtualNetworkListResultPreparer(ctx) 431 if err != nil { 432 return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listNextResults", nil, "Failure preparing next results request") 433 } 434 if req == nil { 435 return 436 } 437 resp, err := client.ListSender(req) 438 if err != nil { 439 result.Response = autorest.Response{Response: resp} 440 return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listNextResults", resp, "Failure sending next results request") 441 } 442 result, err = client.ListResponder(resp) 443 if err != nil { 444 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listNextResults", resp, "Failure responding to next results request") 445 } 446 return 447} 448 449// ListComplete enumerates all values, automatically crossing page boundaries as required. 450func (client VirtualNetworksClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualNetworkListResultIterator, err error) { 451 if tracing.IsEnabled() { 452 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.List") 453 defer func() { 454 sc := -1 455 if result.Response().Response.Response != nil { 456 sc = result.page.Response().Response.Response.StatusCode 457 } 458 tracing.EndSpan(ctx, sc, err) 459 }() 460 } 461 result.page, err = client.List(ctx, resourceGroupName) 462 return 463} 464 465// ListAll gets all virtual networks in a subscription. 466func (client VirtualNetworksClient) ListAll(ctx context.Context) (result VirtualNetworkListResultPage, err error) { 467 if tracing.IsEnabled() { 468 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListAll") 469 defer func() { 470 sc := -1 471 if result.vnlr.Response.Response != nil { 472 sc = result.vnlr.Response.Response.StatusCode 473 } 474 tracing.EndSpan(ctx, sc, err) 475 }() 476 } 477 result.fn = client.listAllNextResults 478 req, err := client.ListAllPreparer(ctx) 479 if err != nil { 480 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListAll", nil, "Failure preparing request") 481 return 482 } 483 484 resp, err := client.ListAllSender(req) 485 if err != nil { 486 result.vnlr.Response = autorest.Response{Response: resp} 487 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListAll", resp, "Failure sending request") 488 return 489 } 490 491 result.vnlr, err = client.ListAllResponder(resp) 492 if err != nil { 493 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListAll", resp, "Failure responding to request") 494 return 495 } 496 if result.vnlr.hasNextLink() && result.vnlr.IsEmpty() { 497 err = result.NextWithContext(ctx) 498 return 499 } 500 501 return 502} 503 504// ListAllPreparer prepares the ListAll request. 505func (client VirtualNetworksClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { 506 pathParameters := map[string]interface{}{ 507 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 508 } 509 510 const APIVersion = "2019-06-01" 511 queryParameters := map[string]interface{}{ 512 "api-version": APIVersion, 513 } 514 515 preparer := autorest.CreatePreparer( 516 autorest.AsGet(), 517 autorest.WithBaseURL(client.BaseURI), 518 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/virtualNetworks", pathParameters), 519 autorest.WithQueryParameters(queryParameters)) 520 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 521} 522 523// ListAllSender sends the ListAll request. The method will close the 524// http.Response Body if it receives an error. 525func (client VirtualNetworksClient) ListAllSender(req *http.Request) (*http.Response, error) { 526 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 527} 528 529// ListAllResponder handles the response to the ListAll request. The method always 530// closes the http.Response Body. 531func (client VirtualNetworksClient) ListAllResponder(resp *http.Response) (result VirtualNetworkListResult, err error) { 532 err = autorest.Respond( 533 resp, 534 azure.WithErrorUnlessStatusCode(http.StatusOK), 535 autorest.ByUnmarshallingJSON(&result), 536 autorest.ByClosing()) 537 result.Response = autorest.Response{Response: resp} 538 return 539} 540 541// listAllNextResults retrieves the next set of results, if any. 542func (client VirtualNetworksClient) listAllNextResults(ctx context.Context, lastResults VirtualNetworkListResult) (result VirtualNetworkListResult, err error) { 543 req, err := lastResults.virtualNetworkListResultPreparer(ctx) 544 if err != nil { 545 return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listAllNextResults", nil, "Failure preparing next results request") 546 } 547 if req == nil { 548 return 549 } 550 resp, err := client.ListAllSender(req) 551 if err != nil { 552 result.Response = autorest.Response{Response: resp} 553 return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listAllNextResults", resp, "Failure sending next results request") 554 } 555 result, err = client.ListAllResponder(resp) 556 if err != nil { 557 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listAllNextResults", resp, "Failure responding to next results request") 558 } 559 return 560} 561 562// ListAllComplete enumerates all values, automatically crossing page boundaries as required. 563func (client VirtualNetworksClient) ListAllComplete(ctx context.Context) (result VirtualNetworkListResultIterator, err error) { 564 if tracing.IsEnabled() { 565 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListAll") 566 defer func() { 567 sc := -1 568 if result.Response().Response.Response != nil { 569 sc = result.page.Response().Response.Response.StatusCode 570 } 571 tracing.EndSpan(ctx, sc, err) 572 }() 573 } 574 result.page, err = client.ListAll(ctx) 575 return 576} 577 578// ListUsage lists usage stats. 579// Parameters: 580// resourceGroupName - the name of the resource group. 581// virtualNetworkName - the name of the virtual network. 582func (client VirtualNetworksClient) ListUsage(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworkListUsageResultPage, err error) { 583 if tracing.IsEnabled() { 584 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListUsage") 585 defer func() { 586 sc := -1 587 if result.vnlur.Response.Response != nil { 588 sc = result.vnlur.Response.Response.StatusCode 589 } 590 tracing.EndSpan(ctx, sc, err) 591 }() 592 } 593 result.fn = client.listUsageNextResults 594 req, err := client.ListUsagePreparer(ctx, resourceGroupName, virtualNetworkName) 595 if err != nil { 596 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListUsage", nil, "Failure preparing request") 597 return 598 } 599 600 resp, err := client.ListUsageSender(req) 601 if err != nil { 602 result.vnlur.Response = autorest.Response{Response: resp} 603 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListUsage", resp, "Failure sending request") 604 return 605 } 606 607 result.vnlur, err = client.ListUsageResponder(resp) 608 if err != nil { 609 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "ListUsage", resp, "Failure responding to request") 610 return 611 } 612 if result.vnlur.hasNextLink() && result.vnlur.IsEmpty() { 613 err = result.NextWithContext(ctx) 614 return 615 } 616 617 return 618} 619 620// ListUsagePreparer prepares the ListUsage request. 621func (client VirtualNetworksClient) ListUsagePreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string) (*http.Request, error) { 622 pathParameters := map[string]interface{}{ 623 "resourceGroupName": autorest.Encode("path", resourceGroupName), 624 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 625 "virtualNetworkName": autorest.Encode("path", virtualNetworkName), 626 } 627 628 const APIVersion = "2019-06-01" 629 queryParameters := map[string]interface{}{ 630 "api-version": APIVersion, 631 } 632 633 preparer := autorest.CreatePreparer( 634 autorest.AsGet(), 635 autorest.WithBaseURL(client.BaseURI), 636 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/usages", pathParameters), 637 autorest.WithQueryParameters(queryParameters)) 638 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 639} 640 641// ListUsageSender sends the ListUsage request. The method will close the 642// http.Response Body if it receives an error. 643func (client VirtualNetworksClient) ListUsageSender(req *http.Request) (*http.Response, error) { 644 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 645} 646 647// ListUsageResponder handles the response to the ListUsage request. The method always 648// closes the http.Response Body. 649func (client VirtualNetworksClient) ListUsageResponder(resp *http.Response) (result VirtualNetworkListUsageResult, err error) { 650 err = autorest.Respond( 651 resp, 652 azure.WithErrorUnlessStatusCode(http.StatusOK), 653 autorest.ByUnmarshallingJSON(&result), 654 autorest.ByClosing()) 655 result.Response = autorest.Response{Response: resp} 656 return 657} 658 659// listUsageNextResults retrieves the next set of results, if any. 660func (client VirtualNetworksClient) listUsageNextResults(ctx context.Context, lastResults VirtualNetworkListUsageResult) (result VirtualNetworkListUsageResult, err error) { 661 req, err := lastResults.virtualNetworkListUsageResultPreparer(ctx) 662 if err != nil { 663 return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listUsageNextResults", nil, "Failure preparing next results request") 664 } 665 if req == nil { 666 return 667 } 668 resp, err := client.ListUsageSender(req) 669 if err != nil { 670 result.Response = autorest.Response{Response: resp} 671 return result, autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listUsageNextResults", resp, "Failure sending next results request") 672 } 673 result, err = client.ListUsageResponder(resp) 674 if err != nil { 675 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "listUsageNextResults", resp, "Failure responding to next results request") 676 } 677 return 678} 679 680// ListUsageComplete enumerates all values, automatically crossing page boundaries as required. 681func (client VirtualNetworksClient) ListUsageComplete(ctx context.Context, resourceGroupName string, virtualNetworkName string) (result VirtualNetworkListUsageResultIterator, err error) { 682 if tracing.IsEnabled() { 683 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.ListUsage") 684 defer func() { 685 sc := -1 686 if result.Response().Response.Response != nil { 687 sc = result.page.Response().Response.Response.StatusCode 688 } 689 tracing.EndSpan(ctx, sc, err) 690 }() 691 } 692 result.page, err = client.ListUsage(ctx, resourceGroupName, virtualNetworkName) 693 return 694} 695 696// UpdateTags updates a virtual network tags. 697// Parameters: 698// resourceGroupName - the name of the resource group. 699// virtualNetworkName - the name of the virtual network. 700// parameters - parameters supplied to update virtual network tags. 701func (client VirtualNetworksClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters TagsObject) (result VirtualNetworksUpdateTagsFuture, err error) { 702 if tracing.IsEnabled() { 703 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworksClient.UpdateTags") 704 defer func() { 705 sc := -1 706 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 707 sc = result.FutureAPI.Response().StatusCode 708 } 709 tracing.EndSpan(ctx, sc, err) 710 }() 711 } 712 req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, virtualNetworkName, parameters) 713 if err != nil { 714 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "UpdateTags", nil, "Failure preparing request") 715 return 716 } 717 718 result, err = client.UpdateTagsSender(req) 719 if err != nil { 720 err = autorest.NewErrorWithError(err, "network.VirtualNetworksClient", "UpdateTags", nil, "Failure sending request") 721 return 722 } 723 724 return 725} 726 727// UpdateTagsPreparer prepares the UpdateTags request. 728func (client VirtualNetworksClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters TagsObject) (*http.Request, error) { 729 pathParameters := map[string]interface{}{ 730 "resourceGroupName": autorest.Encode("path", resourceGroupName), 731 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 732 "virtualNetworkName": autorest.Encode("path", virtualNetworkName), 733 } 734 735 const APIVersion = "2019-06-01" 736 queryParameters := map[string]interface{}{ 737 "api-version": APIVersion, 738 } 739 740 preparer := autorest.CreatePreparer( 741 autorest.AsContentType("application/json; charset=utf-8"), 742 autorest.AsPatch(), 743 autorest.WithBaseURL(client.BaseURI), 744 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}", pathParameters), 745 autorest.WithJSON(parameters), 746 autorest.WithQueryParameters(queryParameters)) 747 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 748} 749 750// UpdateTagsSender sends the UpdateTags request. The method will close the 751// http.Response Body if it receives an error. 752func (client VirtualNetworksClient) UpdateTagsSender(req *http.Request) (future VirtualNetworksUpdateTagsFuture, err error) { 753 var resp *http.Response 754 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 755 if err != nil { 756 return 757 } 758 var azf azure.Future 759 azf, err = azure.NewFutureFromResponse(resp) 760 future.FutureAPI = &azf 761 future.Result = future.result 762 return 763} 764 765// UpdateTagsResponder handles the response to the UpdateTags request. The method always 766// closes the http.Response Body. 767func (client VirtualNetworksClient) UpdateTagsResponder(resp *http.Response) (result VirtualNetwork, err error) { 768 err = autorest.Respond( 769 resp, 770 azure.WithErrorUnlessStatusCode(http.StatusOK), 771 autorest.ByUnmarshallingJSON(&result), 772 autorest.ByClosing()) 773 result.Response = autorest.Response{Response: resp} 774 return 775} 776