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