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