1package managednetwork 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/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// ManagedNetworksClient is the the Microsoft Azure Managed Network management API provides a RESTful set of web 30// services that interact with Microsoft Azure Networks service to programmatically view, control, change, and monitor 31// your entire Azure network centrally and with ease. 32type ManagedNetworksClient struct { 33 BaseClient 34} 35 36// NewManagedNetworksClient creates an instance of the ManagedNetworksClient client. 37func NewManagedNetworksClient(subscriptionID string) ManagedNetworksClient { 38 return NewManagedNetworksClientWithBaseURI(DefaultBaseURI, subscriptionID) 39} 40 41// NewManagedNetworksClientWithBaseURI creates an instance of the ManagedNetworksClient client using a custom endpoint. 42// Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 43func NewManagedNetworksClientWithBaseURI(baseURI string, subscriptionID string) ManagedNetworksClient { 44 return ManagedNetworksClient{NewWithBaseURI(baseURI, subscriptionID)} 45} 46 47// CreateOrUpdate the Put ManagedNetworks operation creates/updates a Managed Network Resource, specified by resource 48// group and Managed Network name 49// Parameters: 50// managedNetwork - parameters supplied to the create/update a Managed Network Resource 51// resourceGroupName - the name of the resource group. 52// managedNetworkName - the name of the Managed Network. 53func (client ManagedNetworksClient) CreateOrUpdate(ctx context.Context, managedNetwork ManagedNetwork, resourceGroupName string, managedNetworkName string) (result ManagedNetwork, err error) { 54 if tracing.IsEnabled() { 55 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.CreateOrUpdate") 56 defer func() { 57 sc := -1 58 if result.Response.Response != nil { 59 sc = result.Response.Response.StatusCode 60 } 61 tracing.EndSpan(ctx, sc, err) 62 }() 63 } 64 req, err := client.CreateOrUpdatePreparer(ctx, managedNetwork, resourceGroupName, managedNetworkName) 65 if err != nil { 66 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "CreateOrUpdate", nil, "Failure preparing request") 67 return 68 } 69 70 resp, err := client.CreateOrUpdateSender(req) 71 if err != nil { 72 result.Response = autorest.Response{Response: resp} 73 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "CreateOrUpdate", resp, "Failure sending request") 74 return 75 } 76 77 result, err = client.CreateOrUpdateResponder(resp) 78 if err != nil { 79 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "CreateOrUpdate", resp, "Failure responding to request") 80 } 81 82 return 83} 84 85// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 86func (client ManagedNetworksClient) CreateOrUpdatePreparer(ctx context.Context, managedNetwork ManagedNetwork, resourceGroupName string, managedNetworkName string) (*http.Request, error) { 87 pathParameters := map[string]interface{}{ 88 "managedNetworkName": autorest.Encode("path", managedNetworkName), 89 "resourceGroupName": autorest.Encode("path", resourceGroupName), 90 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 91 } 92 93 const APIVersion = "2019-06-01-preview" 94 queryParameters := map[string]interface{}{ 95 "api-version": APIVersion, 96 } 97 98 preparer := autorest.CreatePreparer( 99 autorest.AsContentType("application/json; charset=utf-8"), 100 autorest.AsPut(), 101 autorest.WithBaseURL(client.BaseURI), 102 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedNetwork/managedNetworks/{managedNetworkName}", pathParameters), 103 autorest.WithJSON(managedNetwork), 104 autorest.WithQueryParameters(queryParameters)) 105 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 106} 107 108// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 109// http.Response Body if it receives an error. 110func (client ManagedNetworksClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { 111 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 112} 113 114// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 115// closes the http.Response Body. 116func (client ManagedNetworksClient) CreateOrUpdateResponder(resp *http.Response) (result ManagedNetwork, err error) { 117 err = autorest.Respond( 118 resp, 119 client.ByInspecting(), 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 the Delete ManagedNetworks operation deletes a Managed Network Resource, specified by the resource group and 128// Managed Network name 129// Parameters: 130// resourceGroupName - the name of the resource group. 131// managedNetworkName - the name of the Managed Network. 132func (client ManagedNetworksClient) Delete(ctx context.Context, resourceGroupName string, managedNetworkName string) (result ManagedNetworksDeleteFutureType, err error) { 133 if tracing.IsEnabled() { 134 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.Delete") 135 defer func() { 136 sc := -1 137 if result.Response() != nil { 138 sc = result.Response().StatusCode 139 } 140 tracing.EndSpan(ctx, sc, err) 141 }() 142 } 143 req, err := client.DeletePreparer(ctx, resourceGroupName, managedNetworkName) 144 if err != nil { 145 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Delete", nil, "Failure preparing request") 146 return 147 } 148 149 result, err = client.DeleteSender(req) 150 if err != nil { 151 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Delete", result.Response(), "Failure sending request") 152 return 153 } 154 155 return 156} 157 158// DeletePreparer prepares the Delete request. 159func (client ManagedNetworksClient) DeletePreparer(ctx context.Context, resourceGroupName string, managedNetworkName string) (*http.Request, error) { 160 pathParameters := map[string]interface{}{ 161 "managedNetworkName": autorest.Encode("path", managedNetworkName), 162 "resourceGroupName": autorest.Encode("path", resourceGroupName), 163 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 164 } 165 166 const APIVersion = "2019-06-01-preview" 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.ManagedNetwork/managedNetworks/{managedNetworkName}", 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 ManagedNetworksClient) DeleteSender(req *http.Request) (future ManagedNetworksDeleteFutureType, 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 future.Future, err = azure.NewFutureFromResponse(resp) 188 return 189} 190 191// DeleteResponder handles the response to the Delete request. The method always 192// closes the http.Response Body. 193func (client ManagedNetworksClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 194 err = autorest.Respond( 195 resp, 196 client.ByInspecting(), 197 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 198 autorest.ByClosing()) 199 result.Response = resp 200 return 201} 202 203// Get the Get ManagedNetworks operation gets a Managed Network Resource, specified by the resource group and Managed 204// Network name 205// Parameters: 206// resourceGroupName - the name of the resource group. 207// managedNetworkName - the name of the Managed Network. 208func (client ManagedNetworksClient) Get(ctx context.Context, resourceGroupName string, managedNetworkName string) (result ManagedNetwork, err error) { 209 if tracing.IsEnabled() { 210 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.Get") 211 defer func() { 212 sc := -1 213 if result.Response.Response != nil { 214 sc = result.Response.Response.StatusCode 215 } 216 tracing.EndSpan(ctx, sc, err) 217 }() 218 } 219 req, err := client.GetPreparer(ctx, resourceGroupName, managedNetworkName) 220 if err != nil { 221 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Get", nil, "Failure preparing request") 222 return 223 } 224 225 resp, err := client.GetSender(req) 226 if err != nil { 227 result.Response = autorest.Response{Response: resp} 228 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Get", resp, "Failure sending request") 229 return 230 } 231 232 result, err = client.GetResponder(resp) 233 if err != nil { 234 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Get", resp, "Failure responding to request") 235 } 236 237 return 238} 239 240// GetPreparer prepares the Get request. 241func (client ManagedNetworksClient) GetPreparer(ctx context.Context, resourceGroupName string, managedNetworkName string) (*http.Request, error) { 242 pathParameters := map[string]interface{}{ 243 "managedNetworkName": autorest.Encode("path", managedNetworkName), 244 "resourceGroupName": autorest.Encode("path", resourceGroupName), 245 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 246 } 247 248 const APIVersion = "2019-06-01-preview" 249 queryParameters := map[string]interface{}{ 250 "api-version": APIVersion, 251 } 252 253 preparer := autorest.CreatePreparer( 254 autorest.AsGet(), 255 autorest.WithBaseURL(client.BaseURI), 256 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedNetwork/managedNetworks/{managedNetworkName}", pathParameters), 257 autorest.WithQueryParameters(queryParameters)) 258 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 259} 260 261// GetSender sends the Get request. The method will close the 262// http.Response Body if it receives an error. 263func (client ManagedNetworksClient) GetSender(req *http.Request) (*http.Response, error) { 264 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 265} 266 267// GetResponder handles the response to the Get request. The method always 268// closes the http.Response Body. 269func (client ManagedNetworksClient) GetResponder(resp *http.Response) (result ManagedNetwork, err error) { 270 err = autorest.Respond( 271 resp, 272 client.ByInspecting(), 273 azure.WithErrorUnlessStatusCode(http.StatusOK), 274 autorest.ByUnmarshallingJSON(&result), 275 autorest.ByClosing()) 276 result.Response = autorest.Response{Response: resp} 277 return 278} 279 280// ListByResourceGroup the ListByResourceGroup ManagedNetwork operation retrieves all the Managed Network resources in 281// a resource group in a paginated format. 282// Parameters: 283// resourceGroupName - the name of the resource group. 284// top - may be used to limit the number of results in a page for list queries. 285// skiptoken - skiptoken is only used if a previous operation returned a partial result. If a previous response 286// contains a nextLink element, the value of the nextLink element will include a skiptoken parameter that 287// specifies a starting point to use for subsequent calls. 288func (client ManagedNetworksClient) ListByResourceGroup(ctx context.Context, resourceGroupName string, top *int32, skiptoken string) (result ListResultPage, err error) { 289 if tracing.IsEnabled() { 290 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.ListByResourceGroup") 291 defer func() { 292 sc := -1 293 if result.lr.Response.Response != nil { 294 sc = result.lr.Response.Response.StatusCode 295 } 296 tracing.EndSpan(ctx, sc, err) 297 }() 298 } 299 if err := validation.Validate([]validation.Validation{ 300 {TargetValue: top, 301 Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false, 302 Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMaximum, Rule: int64(20), Chain: nil}, 303 {Target: "top", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 304 }}}}}); err != nil { 305 return result, validation.NewError("managednetwork.ManagedNetworksClient", "ListByResourceGroup", err.Error()) 306 } 307 308 result.fn = client.listByResourceGroupNextResults 309 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName, top, skiptoken) 310 if err != nil { 311 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "ListByResourceGroup", nil, "Failure preparing request") 312 return 313 } 314 315 resp, err := client.ListByResourceGroupSender(req) 316 if err != nil { 317 result.lr.Response = autorest.Response{Response: resp} 318 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "ListByResourceGroup", resp, "Failure sending request") 319 return 320 } 321 322 result.lr, err = client.ListByResourceGroupResponder(resp) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "ListByResourceGroup", resp, "Failure responding to request") 325 } 326 327 return 328} 329 330// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 331func (client ManagedNetworksClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string, top *int32, skiptoken string) (*http.Request, error) { 332 pathParameters := map[string]interface{}{ 333 "resourceGroupName": autorest.Encode("path", resourceGroupName), 334 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 335 } 336 337 const APIVersion = "2019-06-01-preview" 338 queryParameters := map[string]interface{}{ 339 "api-version": APIVersion, 340 } 341 if top != nil { 342 queryParameters["$top"] = autorest.Encode("query", *top) 343 } 344 if len(skiptoken) > 0 { 345 queryParameters["$skiptoken"] = autorest.Encode("query", skiptoken) 346 } 347 348 preparer := autorest.CreatePreparer( 349 autorest.AsGet(), 350 autorest.WithBaseURL(client.BaseURI), 351 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedNetwork/managedNetworks", pathParameters), 352 autorest.WithQueryParameters(queryParameters)) 353 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 354} 355 356// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 357// http.Response Body if it receives an error. 358func (client ManagedNetworksClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 359 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 360} 361 362// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 363// closes the http.Response Body. 364func (client ManagedNetworksClient) ListByResourceGroupResponder(resp *http.Response) (result ListResult, err error) { 365 err = autorest.Respond( 366 resp, 367 client.ByInspecting(), 368 azure.WithErrorUnlessStatusCode(http.StatusOK), 369 autorest.ByUnmarshallingJSON(&result), 370 autorest.ByClosing()) 371 result.Response = autorest.Response{Response: resp} 372 return 373} 374 375// listByResourceGroupNextResults retrieves the next set of results, if any. 376func (client ManagedNetworksClient) listByResourceGroupNextResults(ctx context.Context, lastResults ListResult) (result ListResult, err error) { 377 req, err := lastResults.listResultPreparer(ctx) 378 if err != nil { 379 return result, autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 380 } 381 if req == nil { 382 return 383 } 384 resp, err := client.ListByResourceGroupSender(req) 385 if err != nil { 386 result.Response = autorest.Response{Response: resp} 387 return result, autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 388 } 389 result, err = client.ListByResourceGroupResponder(resp) 390 if err != nil { 391 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 392 } 393 return 394} 395 396// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 397func (client ManagedNetworksClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string, top *int32, skiptoken string) (result ListResultIterator, err error) { 398 if tracing.IsEnabled() { 399 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.ListByResourceGroup") 400 defer func() { 401 sc := -1 402 if result.Response().Response.Response != nil { 403 sc = result.page.Response().Response.Response.StatusCode 404 } 405 tracing.EndSpan(ctx, sc, err) 406 }() 407 } 408 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName, top, skiptoken) 409 return 410} 411 412// ListBySubscription the ListBySubscription ManagedNetwork operation retrieves all the Managed Network Resources in 413// the current subscription in a paginated format. 414// Parameters: 415// top - may be used to limit the number of results in a page for list queries. 416// skiptoken - skiptoken is only used if a previous operation returned a partial result. If a previous response 417// contains a nextLink element, the value of the nextLink element will include a skiptoken parameter that 418// specifies a starting point to use for subsequent calls. 419func (client ManagedNetworksClient) ListBySubscription(ctx context.Context, top *int32, skiptoken string) (result ListResultPage, err error) { 420 if tracing.IsEnabled() { 421 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.ListBySubscription") 422 defer func() { 423 sc := -1 424 if result.lr.Response.Response != nil { 425 sc = result.lr.Response.Response.StatusCode 426 } 427 tracing.EndSpan(ctx, sc, err) 428 }() 429 } 430 if err := validation.Validate([]validation.Validation{ 431 {TargetValue: top, 432 Constraints: []validation.Constraint{{Target: "top", Name: validation.Null, Rule: false, 433 Chain: []validation.Constraint{{Target: "top", Name: validation.InclusiveMaximum, Rule: int64(20), Chain: nil}, 434 {Target: "top", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}, 435 }}}}}); err != nil { 436 return result, validation.NewError("managednetwork.ManagedNetworksClient", "ListBySubscription", err.Error()) 437 } 438 439 result.fn = client.listBySubscriptionNextResults 440 req, err := client.ListBySubscriptionPreparer(ctx, top, skiptoken) 441 if err != nil { 442 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "ListBySubscription", nil, "Failure preparing request") 443 return 444 } 445 446 resp, err := client.ListBySubscriptionSender(req) 447 if err != nil { 448 result.lr.Response = autorest.Response{Response: resp} 449 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "ListBySubscription", resp, "Failure sending request") 450 return 451 } 452 453 result.lr, err = client.ListBySubscriptionResponder(resp) 454 if err != nil { 455 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "ListBySubscription", resp, "Failure responding to request") 456 } 457 458 return 459} 460 461// ListBySubscriptionPreparer prepares the ListBySubscription request. 462func (client ManagedNetworksClient) ListBySubscriptionPreparer(ctx context.Context, top *int32, skiptoken string) (*http.Request, error) { 463 pathParameters := map[string]interface{}{ 464 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 465 } 466 467 const APIVersion = "2019-06-01-preview" 468 queryParameters := map[string]interface{}{ 469 "api-version": APIVersion, 470 } 471 if top != nil { 472 queryParameters["$top"] = autorest.Encode("query", *top) 473 } 474 if len(skiptoken) > 0 { 475 queryParameters["$skiptoken"] = autorest.Encode("query", skiptoken) 476 } 477 478 preparer := autorest.CreatePreparer( 479 autorest.AsGet(), 480 autorest.WithBaseURL(client.BaseURI), 481 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.ManagedNetwork/managedNetworks", pathParameters), 482 autorest.WithQueryParameters(queryParameters)) 483 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 484} 485 486// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 487// http.Response Body if it receives an error. 488func (client ManagedNetworksClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 489 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 490} 491 492// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 493// closes the http.Response Body. 494func (client ManagedNetworksClient) ListBySubscriptionResponder(resp *http.Response) (result ListResult, err error) { 495 err = autorest.Respond( 496 resp, 497 client.ByInspecting(), 498 azure.WithErrorUnlessStatusCode(http.StatusOK), 499 autorest.ByUnmarshallingJSON(&result), 500 autorest.ByClosing()) 501 result.Response = autorest.Response{Response: resp} 502 return 503} 504 505// listBySubscriptionNextResults retrieves the next set of results, if any. 506func (client ManagedNetworksClient) listBySubscriptionNextResults(ctx context.Context, lastResults ListResult) (result ListResult, err error) { 507 req, err := lastResults.listResultPreparer(ctx) 508 if err != nil { 509 return result, autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 510 } 511 if req == nil { 512 return 513 } 514 resp, err := client.ListBySubscriptionSender(req) 515 if err != nil { 516 result.Response = autorest.Response{Response: resp} 517 return result, autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") 518 } 519 result, err = client.ListBySubscriptionResponder(resp) 520 if err != nil { 521 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 522 } 523 return 524} 525 526// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 527func (client ManagedNetworksClient) ListBySubscriptionComplete(ctx context.Context, top *int32, skiptoken string) (result ListResultIterator, err error) { 528 if tracing.IsEnabled() { 529 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.ListBySubscription") 530 defer func() { 531 sc := -1 532 if result.Response().Response.Response != nil { 533 sc = result.page.Response().Response.Response.StatusCode 534 } 535 tracing.EndSpan(ctx, sc, err) 536 }() 537 } 538 result.page, err = client.ListBySubscription(ctx, top, skiptoken) 539 return 540} 541 542// Update updates the specified Managed Network resource tags. 543// Parameters: 544// parameters - parameters supplied to update application gateway tags and/or scope. 545// resourceGroupName - the name of the resource group. 546// managedNetworkName - the name of the Managed Network. 547func (client ManagedNetworksClient) Update(ctx context.Context, parameters Update, resourceGroupName string, managedNetworkName string) (result ManagedNetworksUpdateFutureType, err error) { 548 if tracing.IsEnabled() { 549 ctx = tracing.StartSpan(ctx, fqdn+"/ManagedNetworksClient.Update") 550 defer func() { 551 sc := -1 552 if result.Response() != nil { 553 sc = result.Response().StatusCode 554 } 555 tracing.EndSpan(ctx, sc, err) 556 }() 557 } 558 req, err := client.UpdatePreparer(ctx, parameters, resourceGroupName, managedNetworkName) 559 if err != nil { 560 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Update", nil, "Failure preparing request") 561 return 562 } 563 564 result, err = client.UpdateSender(req) 565 if err != nil { 566 err = autorest.NewErrorWithError(err, "managednetwork.ManagedNetworksClient", "Update", result.Response(), "Failure sending request") 567 return 568 } 569 570 return 571} 572 573// UpdatePreparer prepares the Update request. 574func (client ManagedNetworksClient) UpdatePreparer(ctx context.Context, parameters Update, resourceGroupName string, managedNetworkName string) (*http.Request, error) { 575 pathParameters := map[string]interface{}{ 576 "managedNetworkName": autorest.Encode("path", managedNetworkName), 577 "resourceGroupName": autorest.Encode("path", resourceGroupName), 578 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 579 } 580 581 const APIVersion = "2019-06-01-preview" 582 queryParameters := map[string]interface{}{ 583 "api-version": APIVersion, 584 } 585 586 preparer := autorest.CreatePreparer( 587 autorest.AsContentType("application/json; charset=utf-8"), 588 autorest.AsPatch(), 589 autorest.WithBaseURL(client.BaseURI), 590 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedNetwork/managedNetworks/{managedNetworkName}", pathParameters), 591 autorest.WithJSON(parameters), 592 autorest.WithQueryParameters(queryParameters)) 593 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 594} 595 596// UpdateSender sends the Update request. The method will close the 597// http.Response Body if it receives an error. 598func (client ManagedNetworksClient) UpdateSender(req *http.Request) (future ManagedNetworksUpdateFutureType, err error) { 599 var resp *http.Response 600 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 601 if err != nil { 602 return 603 } 604 future.Future, err = azure.NewFutureFromResponse(resp) 605 return 606} 607 608// UpdateResponder handles the response to the Update request. The method always 609// closes the http.Response Body. 610func (client ManagedNetworksClient) UpdateResponder(resp *http.Response) (result ManagedNetwork, err error) { 611 err = autorest.Respond( 612 resp, 613 client.ByInspecting(), 614 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 615 autorest.ByUnmarshallingJSON(&result), 616 autorest.ByClosing()) 617 result.Response = autorest.Response{Response: resp} 618 return 619} 620