1package network 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "github.com/Azure/go-autorest/tracing" 25 "net/http" 26) 27 28// IPGroupsClient is the network Client 29type IPGroupsClient struct { 30 BaseClient 31} 32 33// NewIPGroupsClient creates an instance of the IPGroupsClient client. 34func NewIPGroupsClient(subscriptionID string) IPGroupsClient { 35 return NewIPGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID) 36} 37 38// NewIPGroupsClientWithBaseURI creates an instance of the IPGroupsClient client using a custom endpoint. Use this 39// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 40func NewIPGroupsClientWithBaseURI(baseURI string, subscriptionID string) IPGroupsClient { 41 return IPGroupsClient{NewWithBaseURI(baseURI, subscriptionID)} 42} 43 44// CreateOrUpdate creates or updates an ipGroups in a specified resource group. 45// Parameters: 46// resourceGroupName - the name of the resource group. 47// IPGroupsName - the name of the ipGroups. 48// parameters - parameters supplied to the create or update IpGroups operation. 49func (client IPGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters IPGroup) (result IPGroupsCreateOrUpdateFuture, err error) { 50 if tracing.IsEnabled() { 51 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.CreateOrUpdate") 52 defer func() { 53 sc := -1 54 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 55 sc = result.FutureAPI.Response().StatusCode 56 } 57 tracing.EndSpan(ctx, sc, err) 58 }() 59 } 60 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, IPGroupsName, parameters) 61 if err != nil { 62 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "CreateOrUpdate", nil, "Failure preparing request") 63 return 64 } 65 66 result, err = client.CreateOrUpdateSender(req) 67 if err != nil { 68 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "CreateOrUpdate", nil, "Failure sending request") 69 return 70 } 71 72 return 73} 74 75// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 76func (client IPGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters IPGroup) (*http.Request, error) { 77 pathParameters := map[string]interface{}{ 78 "ipGroupsName": autorest.Encode("path", IPGroupsName), 79 "resourceGroupName": autorest.Encode("path", resourceGroupName), 80 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 81 } 82 83 const APIVersion = "2020-08-01" 84 queryParameters := map[string]interface{}{ 85 "api-version": APIVersion, 86 } 87 88 parameters.Etag = nil 89 preparer := autorest.CreatePreparer( 90 autorest.AsContentType("application/json; charset=utf-8"), 91 autorest.AsPut(), 92 autorest.WithBaseURL(client.BaseURI), 93 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 94 autorest.WithJSON(parameters), 95 autorest.WithQueryParameters(queryParameters)) 96 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 97} 98 99// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 100// http.Response Body if it receives an error. 101func (client IPGroupsClient) CreateOrUpdateSender(req *http.Request) (future IPGroupsCreateOrUpdateFuture, err error) { 102 var resp *http.Response 103 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 104 if err != nil { 105 return 106 } 107 var azf azure.Future 108 azf, err = azure.NewFutureFromResponse(resp) 109 future.FutureAPI = &azf 110 future.Result = func(client IPGroupsClient) (ig IPGroup, err error) { 111 var done bool 112 done, err = future.DoneWithContext(context.Background(), client) 113 if err != nil { 114 err = autorest.NewErrorWithError(err, "network.IPGroupsCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") 115 return 116 } 117 if !done { 118 err = azure.NewAsyncOpIncompleteError("network.IPGroupsCreateOrUpdateFuture") 119 return 120 } 121 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 122 ig.Response.Response, err = future.GetResult(sender) 123 if ig.Response.Response == nil && err == nil { 124 err = autorest.NewErrorWithError(err, "network.IPGroupsCreateOrUpdateFuture", "Result", nil, "received nil response and error") 125 } 126 if err == nil && ig.Response.Response.StatusCode != http.StatusNoContent { 127 ig, err = client.CreateOrUpdateResponder(ig.Response.Response) 128 if err != nil { 129 err = autorest.NewErrorWithError(err, "network.IPGroupsCreateOrUpdateFuture", "Result", ig.Response.Response, "Failure responding to request") 130 } 131 } 132 return 133 } 134 return 135} 136 137// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 138// closes the http.Response Body. 139func (client IPGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result IPGroup, err error) { 140 err = autorest.Respond( 141 resp, 142 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 143 autorest.ByUnmarshallingJSON(&result), 144 autorest.ByClosing()) 145 result.Response = autorest.Response{Response: resp} 146 return 147} 148 149// Delete deletes the specified ipGroups. 150// Parameters: 151// resourceGroupName - the name of the resource group. 152// IPGroupsName - the name of the ipGroups. 153func (client IPGroupsClient) Delete(ctx context.Context, resourceGroupName string, IPGroupsName string) (result IPGroupsDeleteFuture, err error) { 154 if tracing.IsEnabled() { 155 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.Delete") 156 defer func() { 157 sc := -1 158 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 159 sc = result.FutureAPI.Response().StatusCode 160 } 161 tracing.EndSpan(ctx, sc, err) 162 }() 163 } 164 req, err := client.DeletePreparer(ctx, resourceGroupName, IPGroupsName) 165 if err != nil { 166 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Delete", nil, "Failure preparing request") 167 return 168 } 169 170 result, err = client.DeleteSender(req) 171 if err != nil { 172 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Delete", nil, "Failure sending request") 173 return 174 } 175 176 return 177} 178 179// DeletePreparer prepares the Delete request. 180func (client IPGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, IPGroupsName string) (*http.Request, error) { 181 pathParameters := map[string]interface{}{ 182 "ipGroupsName": autorest.Encode("path", IPGroupsName), 183 "resourceGroupName": autorest.Encode("path", resourceGroupName), 184 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 185 } 186 187 const APIVersion = "2020-08-01" 188 queryParameters := map[string]interface{}{ 189 "api-version": APIVersion, 190 } 191 192 preparer := autorest.CreatePreparer( 193 autorest.AsDelete(), 194 autorest.WithBaseURL(client.BaseURI), 195 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 196 autorest.WithQueryParameters(queryParameters)) 197 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 198} 199 200// DeleteSender sends the Delete request. The method will close the 201// http.Response Body if it receives an error. 202func (client IPGroupsClient) DeleteSender(req *http.Request) (future IPGroupsDeleteFuture, err error) { 203 var resp *http.Response 204 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 205 if err != nil { 206 return 207 } 208 var azf azure.Future 209 azf, err = azure.NewFutureFromResponse(resp) 210 future.FutureAPI = &azf 211 future.Result = func(client IPGroupsClient) (ar autorest.Response, err error) { 212 var done bool 213 done, err = future.DoneWithContext(context.Background(), client) 214 if err != nil { 215 err = autorest.NewErrorWithError(err, "network.IPGroupsDeleteFuture", "Result", future.Response(), "Polling failure") 216 return 217 } 218 if !done { 219 err = azure.NewAsyncOpIncompleteError("network.IPGroupsDeleteFuture") 220 return 221 } 222 ar.Response = future.Response() 223 return 224 } 225 return 226} 227 228// DeleteResponder handles the response to the Delete request. The method always 229// closes the http.Response Body. 230func (client IPGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 231 err = autorest.Respond( 232 resp, 233 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 234 autorest.ByClosing()) 235 result.Response = resp 236 return 237} 238 239// Get gets the specified ipGroups. 240// Parameters: 241// resourceGroupName - the name of the resource group. 242// IPGroupsName - the name of the ipGroups. 243// expand - expands resourceIds (of Firewalls/Network Security Groups etc.) back referenced by the IpGroups 244// resource. 245func (client IPGroupsClient) Get(ctx context.Context, resourceGroupName string, IPGroupsName string, expand string) (result IPGroup, err error) { 246 if tracing.IsEnabled() { 247 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.Get") 248 defer func() { 249 sc := -1 250 if result.Response.Response != nil { 251 sc = result.Response.Response.StatusCode 252 } 253 tracing.EndSpan(ctx, sc, err) 254 }() 255 } 256 req, err := client.GetPreparer(ctx, resourceGroupName, IPGroupsName, expand) 257 if err != nil { 258 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Get", nil, "Failure preparing request") 259 return 260 } 261 262 resp, err := client.GetSender(req) 263 if err != nil { 264 result.Response = autorest.Response{Response: resp} 265 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Get", resp, "Failure sending request") 266 return 267 } 268 269 result, err = client.GetResponder(resp) 270 if err != nil { 271 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "Get", resp, "Failure responding to request") 272 return 273 } 274 275 return 276} 277 278// GetPreparer prepares the Get request. 279func (client IPGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, IPGroupsName string, expand string) (*http.Request, error) { 280 pathParameters := map[string]interface{}{ 281 "ipGroupsName": autorest.Encode("path", IPGroupsName), 282 "resourceGroupName": autorest.Encode("path", resourceGroupName), 283 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 284 } 285 286 const APIVersion = "2020-08-01" 287 queryParameters := map[string]interface{}{ 288 "api-version": APIVersion, 289 } 290 if len(expand) > 0 { 291 queryParameters["$expand"] = autorest.Encode("query", expand) 292 } 293 294 preparer := autorest.CreatePreparer( 295 autorest.AsGet(), 296 autorest.WithBaseURL(client.BaseURI), 297 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 298 autorest.WithQueryParameters(queryParameters)) 299 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 300} 301 302// GetSender sends the Get request. The method will close the 303// http.Response Body if it receives an error. 304func (client IPGroupsClient) GetSender(req *http.Request) (*http.Response, error) { 305 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 306} 307 308// GetResponder handles the response to the Get request. The method always 309// closes the http.Response Body. 310func (client IPGroupsClient) GetResponder(resp *http.Response) (result IPGroup, err error) { 311 err = autorest.Respond( 312 resp, 313 azure.WithErrorUnlessStatusCode(http.StatusOK), 314 autorest.ByUnmarshallingJSON(&result), 315 autorest.ByClosing()) 316 result.Response = autorest.Response{Response: resp} 317 return 318} 319 320// List gets all IpGroups in a subscription. 321func (client IPGroupsClient) List(ctx context.Context) (result IPGroupListResultPage, err error) { 322 if tracing.IsEnabled() { 323 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.List") 324 defer func() { 325 sc := -1 326 if result.iglr.Response.Response != nil { 327 sc = result.iglr.Response.Response.StatusCode 328 } 329 tracing.EndSpan(ctx, sc, err) 330 }() 331 } 332 result.fn = client.listNextResults 333 req, err := client.ListPreparer(ctx) 334 if err != nil { 335 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "List", nil, "Failure preparing request") 336 return 337 } 338 339 resp, err := client.ListSender(req) 340 if err != nil { 341 result.iglr.Response = autorest.Response{Response: resp} 342 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "List", resp, "Failure sending request") 343 return 344 } 345 346 result.iglr, err = client.ListResponder(resp) 347 if err != nil { 348 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "List", resp, "Failure responding to request") 349 return 350 } 351 if result.iglr.hasNextLink() && result.iglr.IsEmpty() { 352 err = result.NextWithContext(ctx) 353 return 354 } 355 356 return 357} 358 359// ListPreparer prepares the List request. 360func (client IPGroupsClient) ListPreparer(ctx context.Context) (*http.Request, error) { 361 pathParameters := map[string]interface{}{ 362 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 363 } 364 365 const APIVersion = "2020-08-01" 366 queryParameters := map[string]interface{}{ 367 "api-version": APIVersion, 368 } 369 370 preparer := autorest.CreatePreparer( 371 autorest.AsGet(), 372 autorest.WithBaseURL(client.BaseURI), 373 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/ipGroups", pathParameters), 374 autorest.WithQueryParameters(queryParameters)) 375 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 376} 377 378// ListSender sends the List request. The method will close the 379// http.Response Body if it receives an error. 380func (client IPGroupsClient) ListSender(req *http.Request) (*http.Response, error) { 381 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 382} 383 384// ListResponder handles the response to the List request. The method always 385// closes the http.Response Body. 386func (client IPGroupsClient) ListResponder(resp *http.Response) (result IPGroupListResult, err error) { 387 err = autorest.Respond( 388 resp, 389 azure.WithErrorUnlessStatusCode(http.StatusOK), 390 autorest.ByUnmarshallingJSON(&result), 391 autorest.ByClosing()) 392 result.Response = autorest.Response{Response: resp} 393 return 394} 395 396// listNextResults retrieves the next set of results, if any. 397func (client IPGroupsClient) listNextResults(ctx context.Context, lastResults IPGroupListResult) (result IPGroupListResult, err error) { 398 req, err := lastResults.iPGroupListResultPreparer(ctx) 399 if err != nil { 400 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listNextResults", nil, "Failure preparing next results request") 401 } 402 if req == nil { 403 return 404 } 405 resp, err := client.ListSender(req) 406 if err != nil { 407 result.Response = autorest.Response{Response: resp} 408 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listNextResults", resp, "Failure sending next results request") 409 } 410 result, err = client.ListResponder(resp) 411 if err != nil { 412 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "listNextResults", resp, "Failure responding to next results request") 413 } 414 return 415} 416 417// ListComplete enumerates all values, automatically crossing page boundaries as required. 418func (client IPGroupsClient) ListComplete(ctx context.Context) (result IPGroupListResultIterator, err error) { 419 if tracing.IsEnabled() { 420 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.List") 421 defer func() { 422 sc := -1 423 if result.Response().Response.Response != nil { 424 sc = result.page.Response().Response.Response.StatusCode 425 } 426 tracing.EndSpan(ctx, sc, err) 427 }() 428 } 429 result.page, err = client.List(ctx) 430 return 431} 432 433// ListByResourceGroup gets all IpGroups in a resource group. 434// Parameters: 435// resourceGroupName - the name of the resource group. 436func (client IPGroupsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result IPGroupListResultPage, err error) { 437 if tracing.IsEnabled() { 438 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.ListByResourceGroup") 439 defer func() { 440 sc := -1 441 if result.iglr.Response.Response != nil { 442 sc = result.iglr.Response.Response.StatusCode 443 } 444 tracing.EndSpan(ctx, sc, err) 445 }() 446 } 447 result.fn = client.listByResourceGroupNextResults 448 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 449 if err != nil { 450 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "ListByResourceGroup", nil, "Failure preparing request") 451 return 452 } 453 454 resp, err := client.ListByResourceGroupSender(req) 455 if err != nil { 456 result.iglr.Response = autorest.Response{Response: resp} 457 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "ListByResourceGroup", resp, "Failure sending request") 458 return 459 } 460 461 result.iglr, err = client.ListByResourceGroupResponder(resp) 462 if err != nil { 463 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "ListByResourceGroup", resp, "Failure responding to request") 464 return 465 } 466 if result.iglr.hasNextLink() && result.iglr.IsEmpty() { 467 err = result.NextWithContext(ctx) 468 return 469 } 470 471 return 472} 473 474// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 475func (client IPGroupsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 476 pathParameters := map[string]interface{}{ 477 "resourceGroupName": autorest.Encode("path", resourceGroupName), 478 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 479 } 480 481 const APIVersion = "2020-08-01" 482 queryParameters := map[string]interface{}{ 483 "api-version": APIVersion, 484 } 485 486 preparer := autorest.CreatePreparer( 487 autorest.AsGet(), 488 autorest.WithBaseURL(client.BaseURI), 489 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups", pathParameters), 490 autorest.WithQueryParameters(queryParameters)) 491 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 492} 493 494// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 495// http.Response Body if it receives an error. 496func (client IPGroupsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 497 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 498} 499 500// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 501// closes the http.Response Body. 502func (client IPGroupsClient) ListByResourceGroupResponder(resp *http.Response) (result IPGroupListResult, err error) { 503 err = autorest.Respond( 504 resp, 505 azure.WithErrorUnlessStatusCode(http.StatusOK), 506 autorest.ByUnmarshallingJSON(&result), 507 autorest.ByClosing()) 508 result.Response = autorest.Response{Response: resp} 509 return 510} 511 512// listByResourceGroupNextResults retrieves the next set of results, if any. 513func (client IPGroupsClient) listByResourceGroupNextResults(ctx context.Context, lastResults IPGroupListResult) (result IPGroupListResult, err error) { 514 req, err := lastResults.iPGroupListResultPreparer(ctx) 515 if err != nil { 516 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 517 } 518 if req == nil { 519 return 520 } 521 resp, err := client.ListByResourceGroupSender(req) 522 if err != nil { 523 result.Response = autorest.Response{Response: resp} 524 return result, autorest.NewErrorWithError(err, "network.IPGroupsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 525 } 526 result, err = client.ListByResourceGroupResponder(resp) 527 if err != nil { 528 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 529 } 530 return 531} 532 533// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 534func (client IPGroupsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result IPGroupListResultIterator, err error) { 535 if tracing.IsEnabled() { 536 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.ListByResourceGroup") 537 defer func() { 538 sc := -1 539 if result.Response().Response.Response != nil { 540 sc = result.page.Response().Response.Response.StatusCode 541 } 542 tracing.EndSpan(ctx, sc, err) 543 }() 544 } 545 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 546 return 547} 548 549// UpdateGroups updates tags of an IpGroups resource. 550// Parameters: 551// resourceGroupName - the name of the resource group. 552// IPGroupsName - the name of the ipGroups. 553// parameters - parameters supplied to the update ipGroups operation. 554func (client IPGroupsClient) UpdateGroups(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters TagsObject) (result IPGroup, err error) { 555 if tracing.IsEnabled() { 556 ctx = tracing.StartSpan(ctx, fqdn+"/IPGroupsClient.UpdateGroups") 557 defer func() { 558 sc := -1 559 if result.Response.Response != nil { 560 sc = result.Response.Response.StatusCode 561 } 562 tracing.EndSpan(ctx, sc, err) 563 }() 564 } 565 req, err := client.UpdateGroupsPreparer(ctx, resourceGroupName, IPGroupsName, parameters) 566 if err != nil { 567 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "UpdateGroups", nil, "Failure preparing request") 568 return 569 } 570 571 resp, err := client.UpdateGroupsSender(req) 572 if err != nil { 573 result.Response = autorest.Response{Response: resp} 574 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "UpdateGroups", resp, "Failure sending request") 575 return 576 } 577 578 result, err = client.UpdateGroupsResponder(resp) 579 if err != nil { 580 err = autorest.NewErrorWithError(err, "network.IPGroupsClient", "UpdateGroups", resp, "Failure responding to request") 581 return 582 } 583 584 return 585} 586 587// UpdateGroupsPreparer prepares the UpdateGroups request. 588func (client IPGroupsClient) UpdateGroupsPreparer(ctx context.Context, resourceGroupName string, IPGroupsName string, parameters TagsObject) (*http.Request, error) { 589 pathParameters := map[string]interface{}{ 590 "ipGroupsName": autorest.Encode("path", IPGroupsName), 591 "resourceGroupName": autorest.Encode("path", resourceGroupName), 592 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 593 } 594 595 const APIVersion = "2020-08-01" 596 queryParameters := map[string]interface{}{ 597 "api-version": APIVersion, 598 } 599 600 preparer := autorest.CreatePreparer( 601 autorest.AsContentType("application/json; charset=utf-8"), 602 autorest.AsPatch(), 603 autorest.WithBaseURL(client.BaseURI), 604 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ipGroups/{ipGroupsName}", pathParameters), 605 autorest.WithJSON(parameters), 606 autorest.WithQueryParameters(queryParameters)) 607 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 608} 609 610// UpdateGroupsSender sends the UpdateGroups request. The method will close the 611// http.Response Body if it receives an error. 612func (client IPGroupsClient) UpdateGroupsSender(req *http.Request) (*http.Response, error) { 613 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 614} 615 616// UpdateGroupsResponder handles the response to the UpdateGroups request. The method always 617// closes the http.Response Body. 618func (client IPGroupsClient) UpdateGroupsResponder(resp *http.Response) (result IPGroup, err error) { 619 err = autorest.Respond( 620 resp, 621 azure.WithErrorUnlessStatusCode(http.StatusOK), 622 autorest.ByUnmarshallingJSON(&result), 623 autorest.ByClosing()) 624 result.Response = autorest.Response{Response: resp} 625 return 626} 627