1package hybridkubernetes 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// ConnectedClusterClient is the azure Connected Cluster Resource Provider API for adopting any Kubernetes Cluster 19type ConnectedClusterClient struct { 20 BaseClient 21} 22 23// NewConnectedClusterClient creates an instance of the ConnectedClusterClient client. 24func NewConnectedClusterClient(subscriptionID string) ConnectedClusterClient { 25 return NewConnectedClusterClientWithBaseURI(DefaultBaseURI, subscriptionID) 26} 27 28// NewConnectedClusterClientWithBaseURI creates an instance of the ConnectedClusterClient 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 NewConnectedClusterClientWithBaseURI(baseURI string, subscriptionID string) ConnectedClusterClient { 32 return ConnectedClusterClient{NewWithBaseURI(baseURI, subscriptionID)} 33} 34 35// Create API to register a new Kubernetes cluster and create a tracked resource in Azure Resource Manager (ARM). 36// Parameters: 37// resourceGroupName - the name of the resource group. The name is case insensitive. 38// clusterName - the name of the Kubernetes cluster on which get is called. 39// connectedCluster - parameters supplied to Create a Connected Cluster. 40func (client ConnectedClusterClient) Create(ctx context.Context, resourceGroupName string, clusterName string, connectedCluster ConnectedCluster) (result ConnectedClusterCreateFuture, err error) { 41 if tracing.IsEnabled() { 42 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.Create") 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: client.SubscriptionID, 53 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 54 {TargetValue: resourceGroupName, 55 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 56 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 57 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 58 {TargetValue: connectedCluster, 59 Constraints: []validation.Constraint{{Target: "connectedCluster.Identity", Name: validation.Null, Rule: true, Chain: nil}, 60 {Target: "connectedCluster.ConnectedClusterProperties", Name: validation.Null, Rule: true, 61 Chain: []validation.Constraint{{Target: "connectedCluster.ConnectedClusterProperties.AgentPublicKeyCertificate", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { 62 return result, validation.NewError("hybridkubernetes.ConnectedClusterClient", "Create", err.Error()) 63 } 64 65 req, err := client.CreatePreparer(ctx, resourceGroupName, clusterName, connectedCluster) 66 if err != nil { 67 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Create", nil, "Failure preparing request") 68 return 69 } 70 71 result, err = client.CreateSender(req) 72 if err != nil { 73 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Create", nil, "Failure sending request") 74 return 75 } 76 77 return 78} 79 80// CreatePreparer prepares the Create request. 81func (client ConnectedClusterClient) CreatePreparer(ctx context.Context, resourceGroupName string, clusterName string, connectedCluster ConnectedCluster) (*http.Request, error) { 82 pathParameters := map[string]interface{}{ 83 "clusterName": autorest.Encode("path", clusterName), 84 "resourceGroupName": autorest.Encode("path", resourceGroupName), 85 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 86 } 87 88 const APIVersion = "2021-03-01" 89 queryParameters := map[string]interface{}{ 90 "api-version": APIVersion, 91 } 92 93 connectedCluster.SystemData = nil 94 preparer := autorest.CreatePreparer( 95 autorest.AsContentType("application/json; charset=utf-8"), 96 autorest.AsPut(), 97 autorest.WithBaseURL(client.BaseURI), 98 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Kubernetes/connectedClusters/{clusterName}", pathParameters), 99 autorest.WithJSON(connectedCluster), 100 autorest.WithQueryParameters(queryParameters)) 101 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 102} 103 104// CreateSender sends the Create request. The method will close the 105// http.Response Body if it receives an error. 106func (client ConnectedClusterClient) CreateSender(req *http.Request) (future ConnectedClusterCreateFuture, err error) { 107 var resp *http.Response 108 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 109 if err != nil { 110 return 111 } 112 var azf azure.Future 113 azf, err = azure.NewFutureFromResponse(resp) 114 future.FutureAPI = &azf 115 future.Result = future.result 116 return 117} 118 119// CreateResponder handles the response to the Create request. The method always 120// closes the http.Response Body. 121func (client ConnectedClusterClient) CreateResponder(resp *http.Response) (result ConnectedCluster, err error) { 122 err = autorest.Respond( 123 resp, 124 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 125 autorest.ByUnmarshallingJSON(&result), 126 autorest.ByClosing()) 127 result.Response = autorest.Response{Response: resp} 128 return 129} 130 131// Delete delete a connected cluster, removing the tracked resource in Azure Resource Manager (ARM). 132// Parameters: 133// resourceGroupName - the name of the resource group. The name is case insensitive. 134// clusterName - the name of the Kubernetes cluster on which get is called. 135func (client ConnectedClusterClient) Delete(ctx context.Context, resourceGroupName string, clusterName string) (result ConnectedClusterDeleteFuture, err error) { 136 if tracing.IsEnabled() { 137 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.Delete") 138 defer func() { 139 sc := -1 140 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 141 sc = result.FutureAPI.Response().StatusCode 142 } 143 tracing.EndSpan(ctx, sc, err) 144 }() 145 } 146 if err := validation.Validate([]validation.Validation{ 147 {TargetValue: client.SubscriptionID, 148 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 149 {TargetValue: resourceGroupName, 150 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 151 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 152 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 153 return result, validation.NewError("hybridkubernetes.ConnectedClusterClient", "Delete", err.Error()) 154 } 155 156 req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName) 157 if err != nil { 158 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Delete", nil, "Failure preparing request") 159 return 160 } 161 162 result, err = client.DeleteSender(req) 163 if err != nil { 164 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Delete", nil, "Failure sending request") 165 return 166 } 167 168 return 169} 170 171// DeletePreparer prepares the Delete request. 172func (client ConnectedClusterClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 173 pathParameters := map[string]interface{}{ 174 "clusterName": autorest.Encode("path", clusterName), 175 "resourceGroupName": autorest.Encode("path", resourceGroupName), 176 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 177 } 178 179 const APIVersion = "2021-03-01" 180 queryParameters := map[string]interface{}{ 181 "api-version": APIVersion, 182 } 183 184 preparer := autorest.CreatePreparer( 185 autorest.AsDelete(), 186 autorest.WithBaseURL(client.BaseURI), 187 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Kubernetes/connectedClusters/{clusterName}", pathParameters), 188 autorest.WithQueryParameters(queryParameters)) 189 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 190} 191 192// DeleteSender sends the Delete request. The method will close the 193// http.Response Body if it receives an error. 194func (client ConnectedClusterClient) DeleteSender(req *http.Request) (future ConnectedClusterDeleteFuture, err error) { 195 var resp *http.Response 196 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 197 if err != nil { 198 return 199 } 200 var azf azure.Future 201 azf, err = azure.NewFutureFromResponse(resp) 202 future.FutureAPI = &azf 203 future.Result = future.result 204 return 205} 206 207// DeleteResponder handles the response to the Delete request. The method always 208// closes the http.Response Body. 209func (client ConnectedClusterClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 210 err = autorest.Respond( 211 resp, 212 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 213 autorest.ByClosing()) 214 result.Response = resp 215 return 216} 217 218// Get returns the properties of the specified connected cluster, including name, identity, properties, and additional 219// cluster details. 220// Parameters: 221// resourceGroupName - the name of the resource group. The name is case insensitive. 222// clusterName - the name of the Kubernetes cluster on which get is called. 223func (client ConnectedClusterClient) Get(ctx context.Context, resourceGroupName string, clusterName string) (result ConnectedCluster, err error) { 224 if tracing.IsEnabled() { 225 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.Get") 226 defer func() { 227 sc := -1 228 if result.Response.Response != nil { 229 sc = result.Response.Response.StatusCode 230 } 231 tracing.EndSpan(ctx, sc, err) 232 }() 233 } 234 if err := validation.Validate([]validation.Validation{ 235 {TargetValue: client.SubscriptionID, 236 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 237 {TargetValue: resourceGroupName, 238 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 239 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 240 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 241 return result, validation.NewError("hybridkubernetes.ConnectedClusterClient", "Get", err.Error()) 242 } 243 244 req, err := client.GetPreparer(ctx, resourceGroupName, clusterName) 245 if err != nil { 246 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Get", nil, "Failure preparing request") 247 return 248 } 249 250 resp, err := client.GetSender(req) 251 if err != nil { 252 result.Response = autorest.Response{Response: resp} 253 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Get", resp, "Failure sending request") 254 return 255 } 256 257 result, err = client.GetResponder(resp) 258 if err != nil { 259 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Get", resp, "Failure responding to request") 260 return 261 } 262 263 return 264} 265 266// GetPreparer prepares the Get request. 267func (client ConnectedClusterClient) GetPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 268 pathParameters := map[string]interface{}{ 269 "clusterName": autorest.Encode("path", clusterName), 270 "resourceGroupName": autorest.Encode("path", resourceGroupName), 271 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 272 } 273 274 const APIVersion = "2021-03-01" 275 queryParameters := map[string]interface{}{ 276 "api-version": APIVersion, 277 } 278 279 preparer := autorest.CreatePreparer( 280 autorest.AsGet(), 281 autorest.WithBaseURL(client.BaseURI), 282 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Kubernetes/connectedClusters/{clusterName}", pathParameters), 283 autorest.WithQueryParameters(queryParameters)) 284 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 285} 286 287// GetSender sends the Get request. The method will close the 288// http.Response Body if it receives an error. 289func (client ConnectedClusterClient) GetSender(req *http.Request) (*http.Response, error) { 290 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 291} 292 293// GetResponder handles the response to the Get request. The method always 294// closes the http.Response Body. 295func (client ConnectedClusterClient) GetResponder(resp *http.Response) (result ConnectedCluster, err error) { 296 err = autorest.Respond( 297 resp, 298 azure.WithErrorUnlessStatusCode(http.StatusOK), 299 autorest.ByUnmarshallingJSON(&result), 300 autorest.ByClosing()) 301 result.Response = autorest.Response{Response: resp} 302 return 303} 304 305// ListByResourceGroup API to enumerate registered connected K8s clusters under a Resource Group 306// Parameters: 307// resourceGroupName - the name of the resource group. The name is case insensitive. 308func (client ConnectedClusterClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ConnectedClusterListPage, err error) { 309 if tracing.IsEnabled() { 310 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.ListByResourceGroup") 311 defer func() { 312 sc := -1 313 if result.ccl.Response.Response != nil { 314 sc = result.ccl.Response.Response.StatusCode 315 } 316 tracing.EndSpan(ctx, sc, err) 317 }() 318 } 319 if err := validation.Validate([]validation.Validation{ 320 {TargetValue: client.SubscriptionID, 321 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 322 {TargetValue: resourceGroupName, 323 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 324 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 325 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 326 return result, validation.NewError("hybridkubernetes.ConnectedClusterClient", "ListByResourceGroup", err.Error()) 327 } 328 329 result.fn = client.listByResourceGroupNextResults 330 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 331 if err != nil { 332 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "ListByResourceGroup", nil, "Failure preparing request") 333 return 334 } 335 336 resp, err := client.ListByResourceGroupSender(req) 337 if err != nil { 338 result.ccl.Response = autorest.Response{Response: resp} 339 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "ListByResourceGroup", resp, "Failure sending request") 340 return 341 } 342 343 result.ccl, err = client.ListByResourceGroupResponder(resp) 344 if err != nil { 345 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "ListByResourceGroup", resp, "Failure responding to request") 346 return 347 } 348 if result.ccl.hasNextLink() && result.ccl.IsEmpty() { 349 err = result.NextWithContext(ctx) 350 return 351 } 352 353 return 354} 355 356// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 357func (client ConnectedClusterClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 358 pathParameters := map[string]interface{}{ 359 "resourceGroupName": autorest.Encode("path", resourceGroupName), 360 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 361 } 362 363 const APIVersion = "2021-03-01" 364 queryParameters := map[string]interface{}{ 365 "api-version": APIVersion, 366 } 367 368 preparer := autorest.CreatePreparer( 369 autorest.AsGet(), 370 autorest.WithBaseURL(client.BaseURI), 371 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Kubernetes/connectedClusters", pathParameters), 372 autorest.WithQueryParameters(queryParameters)) 373 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 374} 375 376// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 377// http.Response Body if it receives an error. 378func (client ConnectedClusterClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 379 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 380} 381 382// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 383// closes the http.Response Body. 384func (client ConnectedClusterClient) ListByResourceGroupResponder(resp *http.Response) (result ConnectedClusterList, err error) { 385 err = autorest.Respond( 386 resp, 387 azure.WithErrorUnlessStatusCode(http.StatusOK), 388 autorest.ByUnmarshallingJSON(&result), 389 autorest.ByClosing()) 390 result.Response = autorest.Response{Response: resp} 391 return 392} 393 394// listByResourceGroupNextResults retrieves the next set of results, if any. 395func (client ConnectedClusterClient) listByResourceGroupNextResults(ctx context.Context, lastResults ConnectedClusterList) (result ConnectedClusterList, err error) { 396 req, err := lastResults.connectedClusterListPreparer(ctx) 397 if err != nil { 398 return result, autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 399 } 400 if req == nil { 401 return 402 } 403 resp, err := client.ListByResourceGroupSender(req) 404 if err != nil { 405 result.Response = autorest.Response{Response: resp} 406 return result, autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 407 } 408 result, err = client.ListByResourceGroupResponder(resp) 409 if err != nil { 410 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 411 } 412 return 413} 414 415// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 416func (client ConnectedClusterClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ConnectedClusterListIterator, err error) { 417 if tracing.IsEnabled() { 418 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.ListByResourceGroup") 419 defer func() { 420 sc := -1 421 if result.Response().Response.Response != nil { 422 sc = result.page.Response().Response.Response.StatusCode 423 } 424 tracing.EndSpan(ctx, sc, err) 425 }() 426 } 427 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 428 return 429} 430 431// ListBySubscription API to enumerate registered connected K8s clusters under a Subscription 432func (client ConnectedClusterClient) ListBySubscription(ctx context.Context) (result ConnectedClusterListPage, err error) { 433 if tracing.IsEnabled() { 434 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.ListBySubscription") 435 defer func() { 436 sc := -1 437 if result.ccl.Response.Response != nil { 438 sc = result.ccl.Response.Response.StatusCode 439 } 440 tracing.EndSpan(ctx, sc, err) 441 }() 442 } 443 if err := validation.Validate([]validation.Validation{ 444 {TargetValue: client.SubscriptionID, 445 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil { 446 return result, validation.NewError("hybridkubernetes.ConnectedClusterClient", "ListBySubscription", err.Error()) 447 } 448 449 result.fn = client.listBySubscriptionNextResults 450 req, err := client.ListBySubscriptionPreparer(ctx) 451 if err != nil { 452 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "ListBySubscription", nil, "Failure preparing request") 453 return 454 } 455 456 resp, err := client.ListBySubscriptionSender(req) 457 if err != nil { 458 result.ccl.Response = autorest.Response{Response: resp} 459 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "ListBySubscription", resp, "Failure sending request") 460 return 461 } 462 463 result.ccl, err = client.ListBySubscriptionResponder(resp) 464 if err != nil { 465 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "ListBySubscription", resp, "Failure responding to request") 466 return 467 } 468 if result.ccl.hasNextLink() && result.ccl.IsEmpty() { 469 err = result.NextWithContext(ctx) 470 return 471 } 472 473 return 474} 475 476// ListBySubscriptionPreparer prepares the ListBySubscription request. 477func (client ConnectedClusterClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) { 478 pathParameters := map[string]interface{}{ 479 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 480 } 481 482 const APIVersion = "2021-03-01" 483 queryParameters := map[string]interface{}{ 484 "api-version": APIVersion, 485 } 486 487 preparer := autorest.CreatePreparer( 488 autorest.AsGet(), 489 autorest.WithBaseURL(client.BaseURI), 490 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Kubernetes/connectedClusters", pathParameters), 491 autorest.WithQueryParameters(queryParameters)) 492 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 493} 494 495// ListBySubscriptionSender sends the ListBySubscription request. The method will close the 496// http.Response Body if it receives an error. 497func (client ConnectedClusterClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) { 498 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 499} 500 501// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always 502// closes the http.Response Body. 503func (client ConnectedClusterClient) ListBySubscriptionResponder(resp *http.Response) (result ConnectedClusterList, err error) { 504 err = autorest.Respond( 505 resp, 506 azure.WithErrorUnlessStatusCode(http.StatusOK), 507 autorest.ByUnmarshallingJSON(&result), 508 autorest.ByClosing()) 509 result.Response = autorest.Response{Response: resp} 510 return 511} 512 513// listBySubscriptionNextResults retrieves the next set of results, if any. 514func (client ConnectedClusterClient) listBySubscriptionNextResults(ctx context.Context, lastResults ConnectedClusterList) (result ConnectedClusterList, err error) { 515 req, err := lastResults.connectedClusterListPreparer(ctx) 516 if err != nil { 517 return result, autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request") 518 } 519 if req == nil { 520 return 521 } 522 resp, err := client.ListBySubscriptionSender(req) 523 if err != nil { 524 result.Response = autorest.Response{Response: resp} 525 return result, autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "listBySubscriptionNextResults", resp, "Failure sending next results request") 526 } 527 result, err = client.ListBySubscriptionResponder(resp) 528 if err != nil { 529 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request") 530 } 531 return 532} 533 534// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required. 535func (client ConnectedClusterClient) ListBySubscriptionComplete(ctx context.Context) (result ConnectedClusterListIterator, err error) { 536 if tracing.IsEnabled() { 537 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.ListBySubscription") 538 defer func() { 539 sc := -1 540 if result.Response().Response.Response != nil { 541 sc = result.page.Response().Response.Response.StatusCode 542 } 543 tracing.EndSpan(ctx, sc, err) 544 }() 545 } 546 result.page, err = client.ListBySubscription(ctx) 547 return 548} 549 550// Update API to update certain properties of the connected cluster resource 551// Parameters: 552// resourceGroupName - the name of the resource group. The name is case insensitive. 553// clusterName - the name of the Kubernetes cluster on which get is called. 554// connectedClusterPatch - parameters supplied to update Connected Cluster. 555func (client ConnectedClusterClient) Update(ctx context.Context, resourceGroupName string, clusterName string, connectedClusterPatch ConnectedClusterPatch) (result ConnectedCluster, err error) { 556 if tracing.IsEnabled() { 557 ctx = tracing.StartSpan(ctx, fqdn+"/ConnectedClusterClient.Update") 558 defer func() { 559 sc := -1 560 if result.Response.Response != nil { 561 sc = result.Response.Response.StatusCode 562 } 563 tracing.EndSpan(ctx, sc, err) 564 }() 565 } 566 if err := validation.Validate([]validation.Validation{ 567 {TargetValue: client.SubscriptionID, 568 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}}, 569 {TargetValue: resourceGroupName, 570 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 571 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 572 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 573 return result, validation.NewError("hybridkubernetes.ConnectedClusterClient", "Update", err.Error()) 574 } 575 576 req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, connectedClusterPatch) 577 if err != nil { 578 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Update", nil, "Failure preparing request") 579 return 580 } 581 582 resp, err := client.UpdateSender(req) 583 if err != nil { 584 result.Response = autorest.Response{Response: resp} 585 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Update", resp, "Failure sending request") 586 return 587 } 588 589 result, err = client.UpdateResponder(resp) 590 if err != nil { 591 err = autorest.NewErrorWithError(err, "hybridkubernetes.ConnectedClusterClient", "Update", resp, "Failure responding to request") 592 return 593 } 594 595 return 596} 597 598// UpdatePreparer prepares the Update request. 599func (client ConnectedClusterClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, connectedClusterPatch ConnectedClusterPatch) (*http.Request, error) { 600 pathParameters := map[string]interface{}{ 601 "clusterName": autorest.Encode("path", clusterName), 602 "resourceGroupName": autorest.Encode("path", resourceGroupName), 603 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 604 } 605 606 const APIVersion = "2021-03-01" 607 queryParameters := map[string]interface{}{ 608 "api-version": APIVersion, 609 } 610 611 preparer := autorest.CreatePreparer( 612 autorest.AsContentType("application/json; charset=utf-8"), 613 autorest.AsPatch(), 614 autorest.WithBaseURL(client.BaseURI), 615 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Kubernetes/connectedClusters/{clusterName}", pathParameters), 616 autorest.WithJSON(connectedClusterPatch), 617 autorest.WithQueryParameters(queryParameters)) 618 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 619} 620 621// UpdateSender sends the Update request. The method will close the 622// http.Response Body if it receives an error. 623func (client ConnectedClusterClient) UpdateSender(req *http.Request) (*http.Response, error) { 624 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 625} 626 627// UpdateResponder handles the response to the Update request. The method always 628// closes the http.Response Body. 629func (client ConnectedClusterClient) UpdateResponder(resp *http.Response) (result ConnectedCluster, err error) { 630 err = autorest.Respond( 631 resp, 632 azure.WithErrorUnlessStatusCode(http.StatusOK), 633 autorest.ByUnmarshallingJSON(&result), 634 autorest.ByClosing()) 635 result.Response = autorest.Response{Response: resp} 636 return 637} 638