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// PublicIPAddressesClient is the network Client 19type PublicIPAddressesClient struct { 20 BaseClient 21} 22 23// NewPublicIPAddressesClient creates an instance of the PublicIPAddressesClient client. 24func NewPublicIPAddressesClient(subscriptionID string) PublicIPAddressesClient { 25 return NewPublicIPAddressesClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewPublicIPAddressesClientWithBaseURI creates an instance of the PublicIPAddressesClient client using a custom 29// endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure 30// stack). 31func NewPublicIPAddressesClientWithBaseURI(baseURI string, subscriptionID string) PublicIPAddressesClient { 32 return PublicIPAddressesClient{NewWithBaseURI(baseURI, subscriptionID)} 33} 34 35// CreateOrUpdate creates or updates a static or dynamic public IP address. 36// Parameters: 37// resourceGroupName - the name of the resource group. 38// publicIPAddressName - the name of the public IP address. 39// parameters - parameters supplied to the create or update public IP address operation. 40func (client PublicIPAddressesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters PublicIPAddress) (result PublicIPAddressesCreateOrUpdateFuture, err error) { 41 if tracing.IsEnabled() { 42 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.CreateOrUpdate") 43 defer func() { 44 sc := -1 45 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 46 sc = result.FutureAPI.Response().StatusCode 47 } 48 tracing.EndSpan(ctx, sc, err) 49 }() 50 } 51 if err := validation.Validate([]validation.Validation{ 52 {TargetValue: parameters, 53 Constraints: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat", Name: validation.Null, Rule: false, 54 Chain: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat.IPConfiguration", Name: validation.Null, Rule: false, 55 Chain: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat.IPConfiguration.IPConfigurationPropertiesFormat", Name: validation.Null, Rule: false, 56 Chain: []validation.Constraint{{Target: "parameters.PublicIPAddressPropertiesFormat.IPConfiguration.IPConfigurationPropertiesFormat.PublicIPAddress", Name: validation.Null, Rule: false, Chain: nil}}}, 57 }}, 58 }}}}}); err != nil { 59 return result, validation.NewError("network.PublicIPAddressesClient", "CreateOrUpdate", err.Error()) 60 } 61 62 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, publicIPAddressName, parameters) 63 if err != nil { 64 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "CreateOrUpdate", nil, "Failure preparing request") 65 return 66 } 67 68 result, err = client.CreateOrUpdateSender(req) 69 if err != nil { 70 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "CreateOrUpdate", nil, "Failure sending request") 71 return 72 } 73 74 return 75} 76 77// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 78func (client PublicIPAddressesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters PublicIPAddress) (*http.Request, error) { 79 pathParameters := map[string]interface{}{ 80 "publicIpAddressName": autorest.Encode("path", publicIPAddressName), 81 "resourceGroupName": autorest.Encode("path", resourceGroupName), 82 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 83 } 84 85 const APIVersion = "2019-09-01" 86 queryParameters := map[string]interface{}{ 87 "api-version": APIVersion, 88 } 89 90 parameters.Etag = nil 91 preparer := autorest.CreatePreparer( 92 autorest.AsContentType("application/json; charset=utf-8"), 93 autorest.AsPut(), 94 autorest.WithBaseURL(client.BaseURI), 95 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters), 96 autorest.WithJSON(parameters), 97 autorest.WithQueryParameters(queryParameters)) 98 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 99} 100 101// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 102// http.Response Body if it receives an error. 103func (client PublicIPAddressesClient) CreateOrUpdateSender(req *http.Request) (future PublicIPAddressesCreateOrUpdateFuture, err error) { 104 var resp *http.Response 105 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 106 if err != nil { 107 return 108 } 109 var azf azure.Future 110 azf, err = azure.NewFutureFromResponse(resp) 111 future.FutureAPI = &azf 112 future.Result = future.result 113 return 114} 115 116// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 117// closes the http.Response Body. 118func (client PublicIPAddressesClient) CreateOrUpdateResponder(resp *http.Response) (result PublicIPAddress, err error) { 119 err = autorest.Respond( 120 resp, 121 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 122 autorest.ByUnmarshallingJSON(&result), 123 autorest.ByClosing()) 124 result.Response = autorest.Response{Response: resp} 125 return 126} 127 128// Delete deletes the specified public IP address. 129// Parameters: 130// resourceGroupName - the name of the resource group. 131// publicIPAddressName - the name of the subnet. 132func (client PublicIPAddressesClient) Delete(ctx context.Context, resourceGroupName string, publicIPAddressName string) (result PublicIPAddressesDeleteFuture, err error) { 133 if tracing.IsEnabled() { 134 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.Delete") 135 defer func() { 136 sc := -1 137 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 138 sc = result.FutureAPI.Response().StatusCode 139 } 140 tracing.EndSpan(ctx, sc, err) 141 }() 142 } 143 req, err := client.DeletePreparer(ctx, resourceGroupName, publicIPAddressName) 144 if err != nil { 145 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Delete", nil, "Failure preparing request") 146 return 147 } 148 149 result, err = client.DeleteSender(req) 150 if err != nil { 151 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Delete", nil, "Failure sending request") 152 return 153 } 154 155 return 156} 157 158// DeletePreparer prepares the Delete request. 159func (client PublicIPAddressesClient) DeletePreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string) (*http.Request, error) { 160 pathParameters := map[string]interface{}{ 161 "publicIpAddressName": autorest.Encode("path", publicIPAddressName), 162 "resourceGroupName": autorest.Encode("path", resourceGroupName), 163 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 164 } 165 166 const APIVersion = "2019-09-01" 167 queryParameters := map[string]interface{}{ 168 "api-version": APIVersion, 169 } 170 171 preparer := autorest.CreatePreparer( 172 autorest.AsDelete(), 173 autorest.WithBaseURL(client.BaseURI), 174 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters), 175 autorest.WithQueryParameters(queryParameters)) 176 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 177} 178 179// DeleteSender sends the Delete request. The method will close the 180// http.Response Body if it receives an error. 181func (client PublicIPAddressesClient) DeleteSender(req *http.Request) (future PublicIPAddressesDeleteFuture, err error) { 182 var resp *http.Response 183 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 184 if err != nil { 185 return 186 } 187 var azf azure.Future 188 azf, err = azure.NewFutureFromResponse(resp) 189 future.FutureAPI = &azf 190 future.Result = future.result 191 return 192} 193 194// DeleteResponder handles the response to the Delete request. The method always 195// closes the http.Response Body. 196func (client PublicIPAddressesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 197 err = autorest.Respond( 198 resp, 199 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 200 autorest.ByClosing()) 201 result.Response = resp 202 return 203} 204 205// Get gets the specified public IP address in a specified resource group. 206// Parameters: 207// resourceGroupName - the name of the resource group. 208// publicIPAddressName - the name of the subnet. 209// expand - expands referenced resources. 210func (client PublicIPAddressesClient) Get(ctx context.Context, resourceGroupName string, publicIPAddressName string, expand string) (result PublicIPAddress, err error) { 211 if tracing.IsEnabled() { 212 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.Get") 213 defer func() { 214 sc := -1 215 if result.Response.Response != nil { 216 sc = result.Response.Response.StatusCode 217 } 218 tracing.EndSpan(ctx, sc, err) 219 }() 220 } 221 req, err := client.GetPreparer(ctx, resourceGroupName, publicIPAddressName, expand) 222 if err != nil { 223 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Get", nil, "Failure preparing request") 224 return 225 } 226 227 resp, err := client.GetSender(req) 228 if err != nil { 229 result.Response = autorest.Response{Response: resp} 230 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Get", resp, "Failure sending request") 231 return 232 } 233 234 result, err = client.GetResponder(resp) 235 if err != nil { 236 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "Get", resp, "Failure responding to request") 237 return 238 } 239 240 return 241} 242 243// GetPreparer prepares the Get request. 244func (client PublicIPAddressesClient) GetPreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string, expand string) (*http.Request, error) { 245 pathParameters := map[string]interface{}{ 246 "publicIpAddressName": autorest.Encode("path", publicIPAddressName), 247 "resourceGroupName": autorest.Encode("path", resourceGroupName), 248 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 249 } 250 251 const APIVersion = "2019-09-01" 252 queryParameters := map[string]interface{}{ 253 "api-version": APIVersion, 254 } 255 if len(expand) > 0 { 256 queryParameters["$expand"] = autorest.Encode("query", expand) 257 } 258 259 preparer := autorest.CreatePreparer( 260 autorest.AsGet(), 261 autorest.WithBaseURL(client.BaseURI), 262 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters), 263 autorest.WithQueryParameters(queryParameters)) 264 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 265} 266 267// GetSender sends the Get request. The method will close the 268// http.Response Body if it receives an error. 269func (client PublicIPAddressesClient) GetSender(req *http.Request) (*http.Response, error) { 270 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 271} 272 273// GetResponder handles the response to the Get request. The method always 274// closes the http.Response Body. 275func (client PublicIPAddressesClient) GetResponder(resp *http.Response) (result PublicIPAddress, err error) { 276 err = autorest.Respond( 277 resp, 278 azure.WithErrorUnlessStatusCode(http.StatusOK), 279 autorest.ByUnmarshallingJSON(&result), 280 autorest.ByClosing()) 281 result.Response = autorest.Response{Response: resp} 282 return 283} 284 285// GetVirtualMachineScaleSetPublicIPAddress get the specified public IP address in a virtual machine scale set. 286// Parameters: 287// resourceGroupName - the name of the resource group. 288// virtualMachineScaleSetName - the name of the virtual machine scale set. 289// virtualmachineIndex - the virtual machine index. 290// networkInterfaceName - the name of the network interface. 291// IPConfigurationName - the name of the IP configuration. 292// publicIPAddressName - the name of the public IP Address. 293// expand - expands referenced resources. 294func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddress(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string, publicIPAddressName string, expand string) (result PublicIPAddress, err error) { 295 if tracing.IsEnabled() { 296 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.GetVirtualMachineScaleSetPublicIPAddress") 297 defer func() { 298 sc := -1 299 if result.Response.Response != nil { 300 sc = result.Response.Response.StatusCode 301 } 302 tracing.EndSpan(ctx, sc, err) 303 }() 304 } 305 req, err := client.GetVirtualMachineScaleSetPublicIPAddressPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName, publicIPAddressName, expand) 306 if err != nil { 307 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "GetVirtualMachineScaleSetPublicIPAddress", nil, "Failure preparing request") 308 return 309 } 310 311 resp, err := client.GetVirtualMachineScaleSetPublicIPAddressSender(req) 312 if err != nil { 313 result.Response = autorest.Response{Response: resp} 314 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "GetVirtualMachineScaleSetPublicIPAddress", resp, "Failure sending request") 315 return 316 } 317 318 result, err = client.GetVirtualMachineScaleSetPublicIPAddressResponder(resp) 319 if err != nil { 320 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "GetVirtualMachineScaleSetPublicIPAddress", resp, "Failure responding to request") 321 return 322 } 323 324 return 325} 326 327// GetVirtualMachineScaleSetPublicIPAddressPreparer prepares the GetVirtualMachineScaleSetPublicIPAddress request. 328func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string, publicIPAddressName string, expand string) (*http.Request, error) { 329 pathParameters := map[string]interface{}{ 330 "ipConfigurationName": autorest.Encode("path", IPConfigurationName), 331 "networkInterfaceName": autorest.Encode("path", networkInterfaceName), 332 "publicIpAddressName": autorest.Encode("path", publicIPAddressName), 333 "resourceGroupName": autorest.Encode("path", resourceGroupName), 334 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 335 "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex), 336 "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName), 337 } 338 339 const APIVersion = "2018-10-01" 340 queryParameters := map[string]interface{}{ 341 "api-version": APIVersion, 342 } 343 if len(expand) > 0 { 344 queryParameters["$expand"] = autorest.Encode("query", expand) 345 } 346 347 preparer := autorest.CreatePreparer( 348 autorest.AsGet(), 349 autorest.WithBaseURL(client.BaseURI), 350 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}/ipconfigurations/{ipConfigurationName}/publicipaddresses/{publicIpAddressName}", pathParameters), 351 autorest.WithQueryParameters(queryParameters)) 352 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 353} 354 355// GetVirtualMachineScaleSetPublicIPAddressSender sends the GetVirtualMachineScaleSetPublicIPAddress request. The method will close the 356// http.Response Body if it receives an error. 357func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressSender(req *http.Request) (*http.Response, error) { 358 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 359} 360 361// GetVirtualMachineScaleSetPublicIPAddressResponder handles the response to the GetVirtualMachineScaleSetPublicIPAddress request. The method always 362// closes the http.Response Body. 363func (client PublicIPAddressesClient) GetVirtualMachineScaleSetPublicIPAddressResponder(resp *http.Response) (result PublicIPAddress, err error) { 364 err = autorest.Respond( 365 resp, 366 azure.WithErrorUnlessStatusCode(http.StatusOK), 367 autorest.ByUnmarshallingJSON(&result), 368 autorest.ByClosing()) 369 result.Response = autorest.Response{Response: resp} 370 return 371} 372 373// List gets all public IP addresses in a resource group. 374// Parameters: 375// resourceGroupName - the name of the resource group. 376func (client PublicIPAddressesClient) List(ctx context.Context, resourceGroupName string) (result PublicIPAddressListResultPage, err error) { 377 if tracing.IsEnabled() { 378 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.List") 379 defer func() { 380 sc := -1 381 if result.pialr.Response.Response != nil { 382 sc = result.pialr.Response.Response.StatusCode 383 } 384 tracing.EndSpan(ctx, sc, err) 385 }() 386 } 387 result.fn = client.listNextResults 388 req, err := client.ListPreparer(ctx, resourceGroupName) 389 if err != nil { 390 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "List", nil, "Failure preparing request") 391 return 392 } 393 394 resp, err := client.ListSender(req) 395 if err != nil { 396 result.pialr.Response = autorest.Response{Response: resp} 397 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "List", resp, "Failure sending request") 398 return 399 } 400 401 result.pialr, err = client.ListResponder(resp) 402 if err != nil { 403 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "List", resp, "Failure responding to request") 404 return 405 } 406 if result.pialr.hasNextLink() && result.pialr.IsEmpty() { 407 err = result.NextWithContext(ctx) 408 return 409 } 410 411 return 412} 413 414// ListPreparer prepares the List request. 415func (client PublicIPAddressesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 416 pathParameters := map[string]interface{}{ 417 "resourceGroupName": autorest.Encode("path", resourceGroupName), 418 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 419 } 420 421 const APIVersion = "2019-09-01" 422 queryParameters := map[string]interface{}{ 423 "api-version": APIVersion, 424 } 425 426 preparer := autorest.CreatePreparer( 427 autorest.AsGet(), 428 autorest.WithBaseURL(client.BaseURI), 429 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses", pathParameters), 430 autorest.WithQueryParameters(queryParameters)) 431 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 432} 433 434// ListSender sends the List request. The method will close the 435// http.Response Body if it receives an error. 436func (client PublicIPAddressesClient) ListSender(req *http.Request) (*http.Response, error) { 437 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 438} 439 440// ListResponder handles the response to the List request. The method always 441// closes the http.Response Body. 442func (client PublicIPAddressesClient) ListResponder(resp *http.Response) (result PublicIPAddressListResult, err error) { 443 err = autorest.Respond( 444 resp, 445 azure.WithErrorUnlessStatusCode(http.StatusOK), 446 autorest.ByUnmarshallingJSON(&result), 447 autorest.ByClosing()) 448 result.Response = autorest.Response{Response: resp} 449 return 450} 451 452// listNextResults retrieves the next set of results, if any. 453func (client PublicIPAddressesClient) listNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) { 454 req, err := lastResults.publicIPAddressListResultPreparer(ctx) 455 if err != nil { 456 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listNextResults", nil, "Failure preparing next results request") 457 } 458 if req == nil { 459 return 460 } 461 resp, err := client.ListSender(req) 462 if err != nil { 463 result.Response = autorest.Response{Response: resp} 464 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listNextResults", resp, "Failure sending next results request") 465 } 466 result, err = client.ListResponder(resp) 467 if err != nil { 468 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listNextResults", resp, "Failure responding to next results request") 469 } 470 return 471} 472 473// ListComplete enumerates all values, automatically crossing page boundaries as required. 474func (client PublicIPAddressesClient) ListComplete(ctx context.Context, resourceGroupName string) (result PublicIPAddressListResultIterator, err error) { 475 if tracing.IsEnabled() { 476 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.List") 477 defer func() { 478 sc := -1 479 if result.Response().Response.Response != nil { 480 sc = result.page.Response().Response.Response.StatusCode 481 } 482 tracing.EndSpan(ctx, sc, err) 483 }() 484 } 485 result.page, err = client.List(ctx, resourceGroupName) 486 return 487} 488 489// ListAll gets all the public IP addresses in a subscription. 490func (client PublicIPAddressesClient) ListAll(ctx context.Context) (result PublicIPAddressListResultPage, err error) { 491 if tracing.IsEnabled() { 492 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListAll") 493 defer func() { 494 sc := -1 495 if result.pialr.Response.Response != nil { 496 sc = result.pialr.Response.Response.StatusCode 497 } 498 tracing.EndSpan(ctx, sc, err) 499 }() 500 } 501 result.fn = client.listAllNextResults 502 req, err := client.ListAllPreparer(ctx) 503 if err != nil { 504 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListAll", nil, "Failure preparing request") 505 return 506 } 507 508 resp, err := client.ListAllSender(req) 509 if err != nil { 510 result.pialr.Response = autorest.Response{Response: resp} 511 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListAll", resp, "Failure sending request") 512 return 513 } 514 515 result.pialr, err = client.ListAllResponder(resp) 516 if err != nil { 517 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListAll", resp, "Failure responding to request") 518 return 519 } 520 if result.pialr.hasNextLink() && result.pialr.IsEmpty() { 521 err = result.NextWithContext(ctx) 522 return 523 } 524 525 return 526} 527 528// ListAllPreparer prepares the ListAll request. 529func (client PublicIPAddressesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { 530 pathParameters := map[string]interface{}{ 531 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 532 } 533 534 const APIVersion = "2019-09-01" 535 queryParameters := map[string]interface{}{ 536 "api-version": APIVersion, 537 } 538 539 preparer := autorest.CreatePreparer( 540 autorest.AsGet(), 541 autorest.WithBaseURL(client.BaseURI), 542 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/publicIPAddresses", pathParameters), 543 autorest.WithQueryParameters(queryParameters)) 544 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 545} 546 547// ListAllSender sends the ListAll request. The method will close the 548// http.Response Body if it receives an error. 549func (client PublicIPAddressesClient) ListAllSender(req *http.Request) (*http.Response, error) { 550 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 551} 552 553// ListAllResponder handles the response to the ListAll request. The method always 554// closes the http.Response Body. 555func (client PublicIPAddressesClient) ListAllResponder(resp *http.Response) (result PublicIPAddressListResult, err error) { 556 err = autorest.Respond( 557 resp, 558 azure.WithErrorUnlessStatusCode(http.StatusOK), 559 autorest.ByUnmarshallingJSON(&result), 560 autorest.ByClosing()) 561 result.Response = autorest.Response{Response: resp} 562 return 563} 564 565// listAllNextResults retrieves the next set of results, if any. 566func (client PublicIPAddressesClient) listAllNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) { 567 req, err := lastResults.publicIPAddressListResultPreparer(ctx) 568 if err != nil { 569 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listAllNextResults", nil, "Failure preparing next results request") 570 } 571 if req == nil { 572 return 573 } 574 resp, err := client.ListAllSender(req) 575 if err != nil { 576 result.Response = autorest.Response{Response: resp} 577 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listAllNextResults", resp, "Failure sending next results request") 578 } 579 result, err = client.ListAllResponder(resp) 580 if err != nil { 581 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listAllNextResults", resp, "Failure responding to next results request") 582 } 583 return 584} 585 586// ListAllComplete enumerates all values, automatically crossing page boundaries as required. 587func (client PublicIPAddressesClient) ListAllComplete(ctx context.Context) (result PublicIPAddressListResultIterator, err error) { 588 if tracing.IsEnabled() { 589 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListAll") 590 defer func() { 591 sc := -1 592 if result.Response().Response.Response != nil { 593 sc = result.page.Response().Response.Response.StatusCode 594 } 595 tracing.EndSpan(ctx, sc, err) 596 }() 597 } 598 result.page, err = client.ListAll(ctx) 599 return 600} 601 602// ListVirtualMachineScaleSetPublicIPAddresses gets information about all public IP addresses on a virtual machine 603// scale set level. 604// Parameters: 605// resourceGroupName - the name of the resource group. 606// virtualMachineScaleSetName - the name of the virtual machine scale set. 607func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddresses(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (result PublicIPAddressListResultPage, err error) { 608 if tracing.IsEnabled() { 609 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetPublicIPAddresses") 610 defer func() { 611 sc := -1 612 if result.pialr.Response.Response != nil { 613 sc = result.pialr.Response.Response.StatusCode 614 } 615 tracing.EndSpan(ctx, sc, err) 616 }() 617 } 618 result.fn = client.listVirtualMachineScaleSetPublicIPAddressesNextResults 619 req, err := client.ListVirtualMachineScaleSetPublicIPAddressesPreparer(ctx, resourceGroupName, virtualMachineScaleSetName) 620 if err != nil { 621 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetPublicIPAddresses", nil, "Failure preparing request") 622 return 623 } 624 625 resp, err := client.ListVirtualMachineScaleSetPublicIPAddressesSender(req) 626 if err != nil { 627 result.pialr.Response = autorest.Response{Response: resp} 628 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetPublicIPAddresses", resp, "Failure sending request") 629 return 630 } 631 632 result.pialr, err = client.ListVirtualMachineScaleSetPublicIPAddressesResponder(resp) 633 if err != nil { 634 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetPublicIPAddresses", resp, "Failure responding to request") 635 return 636 } 637 if result.pialr.hasNextLink() && result.pialr.IsEmpty() { 638 err = result.NextWithContext(ctx) 639 return 640 } 641 642 return 643} 644 645// ListVirtualMachineScaleSetPublicIPAddressesPreparer prepares the ListVirtualMachineScaleSetPublicIPAddresses request. 646func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (*http.Request, error) { 647 pathParameters := map[string]interface{}{ 648 "resourceGroupName": autorest.Encode("path", resourceGroupName), 649 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 650 "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName), 651 } 652 653 const APIVersion = "2018-10-01" 654 queryParameters := map[string]interface{}{ 655 "api-version": APIVersion, 656 } 657 658 preparer := autorest.CreatePreparer( 659 autorest.AsGet(), 660 autorest.WithBaseURL(client.BaseURI), 661 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/publicipaddresses", pathParameters), 662 autorest.WithQueryParameters(queryParameters)) 663 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 664} 665 666// ListVirtualMachineScaleSetPublicIPAddressesSender sends the ListVirtualMachineScaleSetPublicIPAddresses request. The method will close the 667// http.Response Body if it receives an error. 668func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesSender(req *http.Request) (*http.Response, error) { 669 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 670} 671 672// ListVirtualMachineScaleSetPublicIPAddressesResponder handles the response to the ListVirtualMachineScaleSetPublicIPAddresses request. The method always 673// closes the http.Response Body. 674func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesResponder(resp *http.Response) (result PublicIPAddressListResult, err error) { 675 err = autorest.Respond( 676 resp, 677 azure.WithErrorUnlessStatusCode(http.StatusOK), 678 autorest.ByUnmarshallingJSON(&result), 679 autorest.ByClosing()) 680 result.Response = autorest.Response{Response: resp} 681 return 682} 683 684// listVirtualMachineScaleSetPublicIPAddressesNextResults retrieves the next set of results, if any. 685func (client PublicIPAddressesClient) listVirtualMachineScaleSetPublicIPAddressesNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) { 686 req, err := lastResults.publicIPAddressListResultPreparer(ctx) 687 if err != nil { 688 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetPublicIPAddressesNextResults", nil, "Failure preparing next results request") 689 } 690 if req == nil { 691 return 692 } 693 resp, err := client.ListVirtualMachineScaleSetPublicIPAddressesSender(req) 694 if err != nil { 695 result.Response = autorest.Response{Response: resp} 696 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetPublicIPAddressesNextResults", resp, "Failure sending next results request") 697 } 698 result, err = client.ListVirtualMachineScaleSetPublicIPAddressesResponder(resp) 699 if err != nil { 700 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetPublicIPAddressesNextResults", resp, "Failure responding to next results request") 701 } 702 return 703} 704 705// ListVirtualMachineScaleSetPublicIPAddressesComplete enumerates all values, automatically crossing page boundaries as required. 706func (client PublicIPAddressesClient) ListVirtualMachineScaleSetPublicIPAddressesComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string) (result PublicIPAddressListResultIterator, err error) { 707 if tracing.IsEnabled() { 708 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetPublicIPAddresses") 709 defer func() { 710 sc := -1 711 if result.Response().Response.Response != nil { 712 sc = result.page.Response().Response.Response.StatusCode 713 } 714 tracing.EndSpan(ctx, sc, err) 715 }() 716 } 717 result.page, err = client.ListVirtualMachineScaleSetPublicIPAddresses(ctx, resourceGroupName, virtualMachineScaleSetName) 718 return 719} 720 721// ListVirtualMachineScaleSetVMPublicIPAddresses gets information about all public IP addresses in a virtual machine IP 722// configuration in a virtual machine scale set. 723// Parameters: 724// resourceGroupName - the name of the resource group. 725// virtualMachineScaleSetName - the name of the virtual machine scale set. 726// virtualmachineIndex - the virtual machine index. 727// networkInterfaceName - the network interface name. 728// IPConfigurationName - the IP configuration name. 729func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddresses(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string) (result PublicIPAddressListResultPage, err error) { 730 if tracing.IsEnabled() { 731 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetVMPublicIPAddresses") 732 defer func() { 733 sc := -1 734 if result.pialr.Response.Response != nil { 735 sc = result.pialr.Response.Response.StatusCode 736 } 737 tracing.EndSpan(ctx, sc, err) 738 }() 739 } 740 result.fn = client.listVirtualMachineScaleSetVMPublicIPAddressesNextResults 741 req, err := client.ListVirtualMachineScaleSetVMPublicIPAddressesPreparer(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName) 742 if err != nil { 743 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetVMPublicIPAddresses", nil, "Failure preparing request") 744 return 745 } 746 747 resp, err := client.ListVirtualMachineScaleSetVMPublicIPAddressesSender(req) 748 if err != nil { 749 result.pialr.Response = autorest.Response{Response: resp} 750 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetVMPublicIPAddresses", resp, "Failure sending request") 751 return 752 } 753 754 result.pialr, err = client.ListVirtualMachineScaleSetVMPublicIPAddressesResponder(resp) 755 if err != nil { 756 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "ListVirtualMachineScaleSetVMPublicIPAddresses", resp, "Failure responding to request") 757 return 758 } 759 if result.pialr.hasNextLink() && result.pialr.IsEmpty() { 760 err = result.NextWithContext(ctx) 761 return 762 } 763 764 return 765} 766 767// ListVirtualMachineScaleSetVMPublicIPAddressesPreparer prepares the ListVirtualMachineScaleSetVMPublicIPAddresses request. 768func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesPreparer(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string) (*http.Request, error) { 769 pathParameters := map[string]interface{}{ 770 "ipConfigurationName": autorest.Encode("path", IPConfigurationName), 771 "networkInterfaceName": autorest.Encode("path", networkInterfaceName), 772 "resourceGroupName": autorest.Encode("path", resourceGroupName), 773 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 774 "virtualmachineIndex": autorest.Encode("path", virtualmachineIndex), 775 "virtualMachineScaleSetName": autorest.Encode("path", virtualMachineScaleSetName), 776 } 777 778 const APIVersion = "2018-10-01" 779 queryParameters := map[string]interface{}{ 780 "api-version": APIVersion, 781 } 782 783 preparer := autorest.CreatePreparer( 784 autorest.AsGet(), 785 autorest.WithBaseURL(client.BaseURI), 786 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{virtualMachineScaleSetName}/virtualMachines/{virtualmachineIndex}/networkInterfaces/{networkInterfaceName}/ipconfigurations/{ipConfigurationName}/publicipaddresses", pathParameters), 787 autorest.WithQueryParameters(queryParameters)) 788 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 789} 790 791// ListVirtualMachineScaleSetVMPublicIPAddressesSender sends the ListVirtualMachineScaleSetVMPublicIPAddresses request. The method will close the 792// http.Response Body if it receives an error. 793func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesSender(req *http.Request) (*http.Response, error) { 794 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 795} 796 797// ListVirtualMachineScaleSetVMPublicIPAddressesResponder handles the response to the ListVirtualMachineScaleSetVMPublicIPAddresses request. The method always 798// closes the http.Response Body. 799func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesResponder(resp *http.Response) (result PublicIPAddressListResult, err error) { 800 err = autorest.Respond( 801 resp, 802 azure.WithErrorUnlessStatusCode(http.StatusOK), 803 autorest.ByUnmarshallingJSON(&result), 804 autorest.ByClosing()) 805 result.Response = autorest.Response{Response: resp} 806 return 807} 808 809// listVirtualMachineScaleSetVMPublicIPAddressesNextResults retrieves the next set of results, if any. 810func (client PublicIPAddressesClient) listVirtualMachineScaleSetVMPublicIPAddressesNextResults(ctx context.Context, lastResults PublicIPAddressListResult) (result PublicIPAddressListResult, err error) { 811 req, err := lastResults.publicIPAddressListResultPreparer(ctx) 812 if err != nil { 813 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetVMPublicIPAddressesNextResults", nil, "Failure preparing next results request") 814 } 815 if req == nil { 816 return 817 } 818 resp, err := client.ListVirtualMachineScaleSetVMPublicIPAddressesSender(req) 819 if err != nil { 820 result.Response = autorest.Response{Response: resp} 821 return result, autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetVMPublicIPAddressesNextResults", resp, "Failure sending next results request") 822 } 823 result, err = client.ListVirtualMachineScaleSetVMPublicIPAddressesResponder(resp) 824 if err != nil { 825 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "listVirtualMachineScaleSetVMPublicIPAddressesNextResults", resp, "Failure responding to next results request") 826 } 827 return 828} 829 830// ListVirtualMachineScaleSetVMPublicIPAddressesComplete enumerates all values, automatically crossing page boundaries as required. 831func (client PublicIPAddressesClient) ListVirtualMachineScaleSetVMPublicIPAddressesComplete(ctx context.Context, resourceGroupName string, virtualMachineScaleSetName string, virtualmachineIndex string, networkInterfaceName string, IPConfigurationName string) (result PublicIPAddressListResultIterator, err error) { 832 if tracing.IsEnabled() { 833 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.ListVirtualMachineScaleSetVMPublicIPAddresses") 834 defer func() { 835 sc := -1 836 if result.Response().Response.Response != nil { 837 sc = result.page.Response().Response.Response.StatusCode 838 } 839 tracing.EndSpan(ctx, sc, err) 840 }() 841 } 842 result.page, err = client.ListVirtualMachineScaleSetVMPublicIPAddresses(ctx, resourceGroupName, virtualMachineScaleSetName, virtualmachineIndex, networkInterfaceName, IPConfigurationName) 843 return 844} 845 846// UpdateTags updates public IP address tags. 847// Parameters: 848// resourceGroupName - the name of the resource group. 849// publicIPAddressName - the name of the public IP address. 850// parameters - parameters supplied to update public IP address tags. 851func (client PublicIPAddressesClient) UpdateTags(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters TagsObject) (result PublicIPAddress, err error) { 852 if tracing.IsEnabled() { 853 ctx = tracing.StartSpan(ctx, fqdn+"/PublicIPAddressesClient.UpdateTags") 854 defer func() { 855 sc := -1 856 if result.Response.Response != nil { 857 sc = result.Response.Response.StatusCode 858 } 859 tracing.EndSpan(ctx, sc, err) 860 }() 861 } 862 req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, publicIPAddressName, parameters) 863 if err != nil { 864 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "UpdateTags", nil, "Failure preparing request") 865 return 866 } 867 868 resp, err := client.UpdateTagsSender(req) 869 if err != nil { 870 result.Response = autorest.Response{Response: resp} 871 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "UpdateTags", resp, "Failure sending request") 872 return 873 } 874 875 result, err = client.UpdateTagsResponder(resp) 876 if err != nil { 877 err = autorest.NewErrorWithError(err, "network.PublicIPAddressesClient", "UpdateTags", resp, "Failure responding to request") 878 return 879 } 880 881 return 882} 883 884// UpdateTagsPreparer prepares the UpdateTags request. 885func (client PublicIPAddressesClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, publicIPAddressName string, parameters TagsObject) (*http.Request, error) { 886 pathParameters := map[string]interface{}{ 887 "publicIpAddressName": autorest.Encode("path", publicIPAddressName), 888 "resourceGroupName": autorest.Encode("path", resourceGroupName), 889 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 890 } 891 892 const APIVersion = "2019-09-01" 893 queryParameters := map[string]interface{}{ 894 "api-version": APIVersion, 895 } 896 897 preparer := autorest.CreatePreparer( 898 autorest.AsContentType("application/json; charset=utf-8"), 899 autorest.AsPatch(), 900 autorest.WithBaseURL(client.BaseURI), 901 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPAddresses/{publicIpAddressName}", pathParameters), 902 autorest.WithJSON(parameters), 903 autorest.WithQueryParameters(queryParameters)) 904 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 905} 906 907// UpdateTagsSender sends the UpdateTags request. The method will close the 908// http.Response Body if it receives an error. 909func (client PublicIPAddressesClient) UpdateTagsSender(req *http.Request) (*http.Response, error) { 910 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 911} 912 913// UpdateTagsResponder handles the response to the UpdateTags request. The method always 914// closes the http.Response Body. 915func (client PublicIPAddressesClient) UpdateTagsResponder(resp *http.Response) (result PublicIPAddress, err error) { 916 err = autorest.Respond( 917 resp, 918 azure.WithErrorUnlessStatusCode(http.StatusOK), 919 autorest.ByUnmarshallingJSON(&result), 920 autorest.ByClosing()) 921 result.Response = autorest.Response{Response: resp} 922 return 923} 924