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