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