1// Copyright 2018 Google LLC 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// https://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15// AUTO-GENERATED CODE. DO NOT EDIT. 16 17package container 18 19import ( 20 "context" 21 "time" 22 23 "cloud.google.com/go/internal/version" 24 gax "github.com/googleapis/gax-go/v2" 25 "google.golang.org/api/option" 26 "google.golang.org/api/transport" 27 containerpb "google.golang.org/genproto/googleapis/container/v1" 28 "google.golang.org/grpc" 29 "google.golang.org/grpc/codes" 30 "google.golang.org/grpc/metadata" 31) 32 33// ClusterManagerCallOptions contains the retry settings for each method of ClusterManagerClient. 34type ClusterManagerCallOptions struct { 35 ListClusters []gax.CallOption 36 GetCluster []gax.CallOption 37 CreateCluster []gax.CallOption 38 UpdateCluster []gax.CallOption 39 UpdateNodePool []gax.CallOption 40 SetNodePoolAutoscaling []gax.CallOption 41 SetLoggingService []gax.CallOption 42 SetMonitoringService []gax.CallOption 43 SetAddonsConfig []gax.CallOption 44 SetLocations []gax.CallOption 45 UpdateMaster []gax.CallOption 46 SetMasterAuth []gax.CallOption 47 DeleteCluster []gax.CallOption 48 ListOperations []gax.CallOption 49 GetOperation []gax.CallOption 50 CancelOperation []gax.CallOption 51 GetServerConfig []gax.CallOption 52 ListNodePools []gax.CallOption 53 GetNodePool []gax.CallOption 54 CreateNodePool []gax.CallOption 55 DeleteNodePool []gax.CallOption 56 RollbackNodePoolUpgrade []gax.CallOption 57 SetNodePoolManagement []gax.CallOption 58 SetLabels []gax.CallOption 59 SetLegacyAbac []gax.CallOption 60 StartIPRotation []gax.CallOption 61 CompleteIPRotation []gax.CallOption 62 SetNodePoolSize []gax.CallOption 63 SetNetworkPolicy []gax.CallOption 64 SetMaintenancePolicy []gax.CallOption 65} 66 67func defaultClusterManagerClientOptions() []option.ClientOption { 68 return []option.ClientOption{ 69 option.WithEndpoint("container.googleapis.com:443"), 70 option.WithScopes(DefaultAuthScopes()...), 71 } 72} 73 74func defaultClusterManagerCallOptions() *ClusterManagerCallOptions { 75 retry := map[[2]string][]gax.CallOption{ 76 {"default", "idempotent"}: { 77 gax.WithRetry(func() gax.Retryer { 78 return gax.OnCodes([]codes.Code{ 79 codes.DeadlineExceeded, 80 codes.Unavailable, 81 }, gax.Backoff{ 82 Initial: 100 * time.Millisecond, 83 Max: 60000 * time.Millisecond, 84 Multiplier: 1.3, 85 }) 86 }), 87 }, 88 } 89 return &ClusterManagerCallOptions{ 90 ListClusters: retry[[2]string{"default", "idempotent"}], 91 GetCluster: retry[[2]string{"default", "idempotent"}], 92 CreateCluster: retry[[2]string{"default", "non_idempotent"}], 93 UpdateCluster: retry[[2]string{"default", "non_idempotent"}], 94 UpdateNodePool: retry[[2]string{"default", "non_idempotent"}], 95 SetNodePoolAutoscaling: retry[[2]string{"default", "non_idempotent"}], 96 SetLoggingService: retry[[2]string{"default", "non_idempotent"}], 97 SetMonitoringService: retry[[2]string{"default", "non_idempotent"}], 98 SetAddonsConfig: retry[[2]string{"default", "non_idempotent"}], 99 SetLocations: retry[[2]string{"default", "non_idempotent"}], 100 UpdateMaster: retry[[2]string{"default", "non_idempotent"}], 101 SetMasterAuth: retry[[2]string{"default", "non_idempotent"}], 102 DeleteCluster: retry[[2]string{"default", "idempotent"}], 103 ListOperations: retry[[2]string{"default", "idempotent"}], 104 GetOperation: retry[[2]string{"default", "idempotent"}], 105 CancelOperation: retry[[2]string{"default", "non_idempotent"}], 106 GetServerConfig: retry[[2]string{"default", "idempotent"}], 107 ListNodePools: retry[[2]string{"default", "idempotent"}], 108 GetNodePool: retry[[2]string{"default", "idempotent"}], 109 CreateNodePool: retry[[2]string{"default", "non_idempotent"}], 110 DeleteNodePool: retry[[2]string{"default", "idempotent"}], 111 RollbackNodePoolUpgrade: retry[[2]string{"default", "non_idempotent"}], 112 SetNodePoolManagement: retry[[2]string{"default", "non_idempotent"}], 113 SetLabels: retry[[2]string{"default", "non_idempotent"}], 114 SetLegacyAbac: retry[[2]string{"default", "non_idempotent"}], 115 StartIPRotation: retry[[2]string{"default", "non_idempotent"}], 116 CompleteIPRotation: retry[[2]string{"default", "non_idempotent"}], 117 SetNodePoolSize: retry[[2]string{"default", "non_idempotent"}], 118 SetNetworkPolicy: retry[[2]string{"default", "non_idempotent"}], 119 SetMaintenancePolicy: retry[[2]string{"default", "non_idempotent"}], 120 } 121} 122 123// ClusterManagerClient is a client for interacting with Google Container Engine API. 124// 125// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. 126type ClusterManagerClient struct { 127 // The connection to the service. 128 conn *grpc.ClientConn 129 130 // The gRPC API client. 131 clusterManagerClient containerpb.ClusterManagerClient 132 133 // The call options for this service. 134 CallOptions *ClusterManagerCallOptions 135 136 // The x-goog-* metadata to be sent with each request. 137 xGoogMetadata metadata.MD 138} 139 140// NewClusterManagerClient creates a new cluster manager client. 141// 142// Google Container Engine Cluster Manager v1 143func NewClusterManagerClient(ctx context.Context, opts ...option.ClientOption) (*ClusterManagerClient, error) { 144 conn, err := transport.DialGRPC(ctx, append(defaultClusterManagerClientOptions(), opts...)...) 145 if err != nil { 146 return nil, err 147 } 148 c := &ClusterManagerClient{ 149 conn: conn, 150 CallOptions: defaultClusterManagerCallOptions(), 151 152 clusterManagerClient: containerpb.NewClusterManagerClient(conn), 153 } 154 c.setGoogleClientInfo() 155 return c, nil 156} 157 158// Connection returns the client's connection to the API service. 159func (c *ClusterManagerClient) Connection() *grpc.ClientConn { 160 return c.conn 161} 162 163// Close closes the connection to the API service. The user should invoke this when 164// the client is no longer required. 165func (c *ClusterManagerClient) Close() error { 166 return c.conn.Close() 167} 168 169// setGoogleClientInfo sets the name and version of the application in 170// the `x-goog-api-client` header passed on each request. Intended for 171// use by Google-written clients. 172func (c *ClusterManagerClient) setGoogleClientInfo(keyval ...string) { 173 kv := append([]string{"gl-go", version.Go()}, keyval...) 174 kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version) 175 c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) 176} 177 178// ListClusters lists all clusters owned by a project in either the specified zone or all 179// zones. 180func (c *ClusterManagerClient) ListClusters(ctx context.Context, req *containerpb.ListClustersRequest, opts ...gax.CallOption) (*containerpb.ListClustersResponse, error) { 181 ctx = insertMetadata(ctx, c.xGoogMetadata) 182 opts = append(c.CallOptions.ListClusters[0:len(c.CallOptions.ListClusters):len(c.CallOptions.ListClusters)], opts...) 183 var resp *containerpb.ListClustersResponse 184 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 185 var err error 186 resp, err = c.clusterManagerClient.ListClusters(ctx, req, settings.GRPC...) 187 return err 188 }, opts...) 189 if err != nil { 190 return nil, err 191 } 192 return resp, nil 193} 194 195// GetCluster gets the details of a specific cluster. 196func (c *ClusterManagerClient) GetCluster(ctx context.Context, req *containerpb.GetClusterRequest, opts ...gax.CallOption) (*containerpb.Cluster, error) { 197 ctx = insertMetadata(ctx, c.xGoogMetadata) 198 opts = append(c.CallOptions.GetCluster[0:len(c.CallOptions.GetCluster):len(c.CallOptions.GetCluster)], opts...) 199 var resp *containerpb.Cluster 200 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 201 var err error 202 resp, err = c.clusterManagerClient.GetCluster(ctx, req, settings.GRPC...) 203 return err 204 }, opts...) 205 if err != nil { 206 return nil, err 207 } 208 return resp, nil 209} 210 211// CreateCluster creates a cluster, consisting of the specified number and type of Google 212// Compute Engine instances. 213// 214// By default, the cluster is created in the project's 215// default network (at /compute/docs/networks-and-firewalls#networks). 216// 217// One firewall is added for the cluster. After cluster creation, 218// the cluster creates routes for each node to allow the containers 219// on that node to communicate with all other instances in the 220// cluster. 221// 222// Finally, an entry is added to the project's global metadata indicating 223// which CIDR range is being used by the cluster. 224func (c *ClusterManagerClient) CreateCluster(ctx context.Context, req *containerpb.CreateClusterRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 225 ctx = insertMetadata(ctx, c.xGoogMetadata) 226 opts = append(c.CallOptions.CreateCluster[0:len(c.CallOptions.CreateCluster):len(c.CallOptions.CreateCluster)], opts...) 227 var resp *containerpb.Operation 228 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 229 var err error 230 resp, err = c.clusterManagerClient.CreateCluster(ctx, req, settings.GRPC...) 231 return err 232 }, opts...) 233 if err != nil { 234 return nil, err 235 } 236 return resp, nil 237} 238 239// UpdateCluster updates the settings of a specific cluster. 240func (c *ClusterManagerClient) UpdateCluster(ctx context.Context, req *containerpb.UpdateClusterRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 241 ctx = insertMetadata(ctx, c.xGoogMetadata) 242 opts = append(c.CallOptions.UpdateCluster[0:len(c.CallOptions.UpdateCluster):len(c.CallOptions.UpdateCluster)], opts...) 243 var resp *containerpb.Operation 244 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 245 var err error 246 resp, err = c.clusterManagerClient.UpdateCluster(ctx, req, settings.GRPC...) 247 return err 248 }, opts...) 249 if err != nil { 250 return nil, err 251 } 252 return resp, nil 253} 254 255// UpdateNodePool updates the version and/or image type of a specific node pool. 256func (c *ClusterManagerClient) UpdateNodePool(ctx context.Context, req *containerpb.UpdateNodePoolRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 257 ctx = insertMetadata(ctx, c.xGoogMetadata) 258 opts = append(c.CallOptions.UpdateNodePool[0:len(c.CallOptions.UpdateNodePool):len(c.CallOptions.UpdateNodePool)], opts...) 259 var resp *containerpb.Operation 260 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 261 var err error 262 resp, err = c.clusterManagerClient.UpdateNodePool(ctx, req, settings.GRPC...) 263 return err 264 }, opts...) 265 if err != nil { 266 return nil, err 267 } 268 return resp, nil 269} 270 271// SetNodePoolAutoscaling sets the autoscaling settings of a specific node pool. 272func (c *ClusterManagerClient) SetNodePoolAutoscaling(ctx context.Context, req *containerpb.SetNodePoolAutoscalingRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 273 ctx = insertMetadata(ctx, c.xGoogMetadata) 274 opts = append(c.CallOptions.SetNodePoolAutoscaling[0:len(c.CallOptions.SetNodePoolAutoscaling):len(c.CallOptions.SetNodePoolAutoscaling)], opts...) 275 var resp *containerpb.Operation 276 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 277 var err error 278 resp, err = c.clusterManagerClient.SetNodePoolAutoscaling(ctx, req, settings.GRPC...) 279 return err 280 }, opts...) 281 if err != nil { 282 return nil, err 283 } 284 return resp, nil 285} 286 287// SetLoggingService sets the logging service of a specific cluster. 288func (c *ClusterManagerClient) SetLoggingService(ctx context.Context, req *containerpb.SetLoggingServiceRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 289 ctx = insertMetadata(ctx, c.xGoogMetadata) 290 opts = append(c.CallOptions.SetLoggingService[0:len(c.CallOptions.SetLoggingService):len(c.CallOptions.SetLoggingService)], opts...) 291 var resp *containerpb.Operation 292 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 293 var err error 294 resp, err = c.clusterManagerClient.SetLoggingService(ctx, req, settings.GRPC...) 295 return err 296 }, opts...) 297 if err != nil { 298 return nil, err 299 } 300 return resp, nil 301} 302 303// SetMonitoringService sets the monitoring service of a specific cluster. 304func (c *ClusterManagerClient) SetMonitoringService(ctx context.Context, req *containerpb.SetMonitoringServiceRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 305 ctx = insertMetadata(ctx, c.xGoogMetadata) 306 opts = append(c.CallOptions.SetMonitoringService[0:len(c.CallOptions.SetMonitoringService):len(c.CallOptions.SetMonitoringService)], opts...) 307 var resp *containerpb.Operation 308 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 309 var err error 310 resp, err = c.clusterManagerClient.SetMonitoringService(ctx, req, settings.GRPC...) 311 return err 312 }, opts...) 313 if err != nil { 314 return nil, err 315 } 316 return resp, nil 317} 318 319// SetAddonsConfig sets the addons of a specific cluster. 320func (c *ClusterManagerClient) SetAddonsConfig(ctx context.Context, req *containerpb.SetAddonsConfigRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 321 ctx = insertMetadata(ctx, c.xGoogMetadata) 322 opts = append(c.CallOptions.SetAddonsConfig[0:len(c.CallOptions.SetAddonsConfig):len(c.CallOptions.SetAddonsConfig)], opts...) 323 var resp *containerpb.Operation 324 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 325 var err error 326 resp, err = c.clusterManagerClient.SetAddonsConfig(ctx, req, settings.GRPC...) 327 return err 328 }, opts...) 329 if err != nil { 330 return nil, err 331 } 332 return resp, nil 333} 334 335// SetLocations sets the locations of a specific cluster. 336func (c *ClusterManagerClient) SetLocations(ctx context.Context, req *containerpb.SetLocationsRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 337 ctx = insertMetadata(ctx, c.xGoogMetadata) 338 opts = append(c.CallOptions.SetLocations[0:len(c.CallOptions.SetLocations):len(c.CallOptions.SetLocations)], opts...) 339 var resp *containerpb.Operation 340 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 341 var err error 342 resp, err = c.clusterManagerClient.SetLocations(ctx, req, settings.GRPC...) 343 return err 344 }, opts...) 345 if err != nil { 346 return nil, err 347 } 348 return resp, nil 349} 350 351// UpdateMaster updates the master of a specific cluster. 352func (c *ClusterManagerClient) UpdateMaster(ctx context.Context, req *containerpb.UpdateMasterRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 353 ctx = insertMetadata(ctx, c.xGoogMetadata) 354 opts = append(c.CallOptions.UpdateMaster[0:len(c.CallOptions.UpdateMaster):len(c.CallOptions.UpdateMaster)], opts...) 355 var resp *containerpb.Operation 356 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 357 var err error 358 resp, err = c.clusterManagerClient.UpdateMaster(ctx, req, settings.GRPC...) 359 return err 360 }, opts...) 361 if err != nil { 362 return nil, err 363 } 364 return resp, nil 365} 366 367// SetMasterAuth used to set master auth materials. Currently supports :- 368// Changing the admin password of a specific cluster. 369// This can be either via password generation or explicitly set the password. 370func (c *ClusterManagerClient) SetMasterAuth(ctx context.Context, req *containerpb.SetMasterAuthRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 371 ctx = insertMetadata(ctx, c.xGoogMetadata) 372 opts = append(c.CallOptions.SetMasterAuth[0:len(c.CallOptions.SetMasterAuth):len(c.CallOptions.SetMasterAuth)], opts...) 373 var resp *containerpb.Operation 374 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 375 var err error 376 resp, err = c.clusterManagerClient.SetMasterAuth(ctx, req, settings.GRPC...) 377 return err 378 }, opts...) 379 if err != nil { 380 return nil, err 381 } 382 return resp, nil 383} 384 385// DeleteCluster deletes the cluster, including the Kubernetes endpoint and all worker 386// nodes. 387// 388// Firewalls and routes that were configured during cluster creation 389// are also deleted. 390// 391// Other Google Compute Engine resources that might be in use by the cluster 392// (e.g. load balancer resources) will not be deleted if they weren't present 393// at the initial create time. 394func (c *ClusterManagerClient) DeleteCluster(ctx context.Context, req *containerpb.DeleteClusterRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 395 ctx = insertMetadata(ctx, c.xGoogMetadata) 396 opts = append(c.CallOptions.DeleteCluster[0:len(c.CallOptions.DeleteCluster):len(c.CallOptions.DeleteCluster)], opts...) 397 var resp *containerpb.Operation 398 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 399 var err error 400 resp, err = c.clusterManagerClient.DeleteCluster(ctx, req, settings.GRPC...) 401 return err 402 }, opts...) 403 if err != nil { 404 return nil, err 405 } 406 return resp, nil 407} 408 409// ListOperations lists all operations in a project in a specific zone or all zones. 410func (c *ClusterManagerClient) ListOperations(ctx context.Context, req *containerpb.ListOperationsRequest, opts ...gax.CallOption) (*containerpb.ListOperationsResponse, error) { 411 ctx = insertMetadata(ctx, c.xGoogMetadata) 412 opts = append(c.CallOptions.ListOperations[0:len(c.CallOptions.ListOperations):len(c.CallOptions.ListOperations)], opts...) 413 var resp *containerpb.ListOperationsResponse 414 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 415 var err error 416 resp, err = c.clusterManagerClient.ListOperations(ctx, req, settings.GRPC...) 417 return err 418 }, opts...) 419 if err != nil { 420 return nil, err 421 } 422 return resp, nil 423} 424 425// GetOperation gets the specified operation. 426func (c *ClusterManagerClient) GetOperation(ctx context.Context, req *containerpb.GetOperationRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 427 ctx = insertMetadata(ctx, c.xGoogMetadata) 428 opts = append(c.CallOptions.GetOperation[0:len(c.CallOptions.GetOperation):len(c.CallOptions.GetOperation)], opts...) 429 var resp *containerpb.Operation 430 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 431 var err error 432 resp, err = c.clusterManagerClient.GetOperation(ctx, req, settings.GRPC...) 433 return err 434 }, opts...) 435 if err != nil { 436 return nil, err 437 } 438 return resp, nil 439} 440 441// CancelOperation cancels the specified operation. 442func (c *ClusterManagerClient) CancelOperation(ctx context.Context, req *containerpb.CancelOperationRequest, opts ...gax.CallOption) error { 443 ctx = insertMetadata(ctx, c.xGoogMetadata) 444 opts = append(c.CallOptions.CancelOperation[0:len(c.CallOptions.CancelOperation):len(c.CallOptions.CancelOperation)], opts...) 445 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 446 var err error 447 _, err = c.clusterManagerClient.CancelOperation(ctx, req, settings.GRPC...) 448 return err 449 }, opts...) 450 return err 451} 452 453// GetServerConfig returns configuration info about the Container Engine service. 454func (c *ClusterManagerClient) GetServerConfig(ctx context.Context, req *containerpb.GetServerConfigRequest, opts ...gax.CallOption) (*containerpb.ServerConfig, error) { 455 ctx = insertMetadata(ctx, c.xGoogMetadata) 456 opts = append(c.CallOptions.GetServerConfig[0:len(c.CallOptions.GetServerConfig):len(c.CallOptions.GetServerConfig)], opts...) 457 var resp *containerpb.ServerConfig 458 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 459 var err error 460 resp, err = c.clusterManagerClient.GetServerConfig(ctx, req, settings.GRPC...) 461 return err 462 }, opts...) 463 if err != nil { 464 return nil, err 465 } 466 return resp, nil 467} 468 469// ListNodePools lists the node pools for a cluster. 470func (c *ClusterManagerClient) ListNodePools(ctx context.Context, req *containerpb.ListNodePoolsRequest, opts ...gax.CallOption) (*containerpb.ListNodePoolsResponse, error) { 471 ctx = insertMetadata(ctx, c.xGoogMetadata) 472 opts = append(c.CallOptions.ListNodePools[0:len(c.CallOptions.ListNodePools):len(c.CallOptions.ListNodePools)], opts...) 473 var resp *containerpb.ListNodePoolsResponse 474 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 475 var err error 476 resp, err = c.clusterManagerClient.ListNodePools(ctx, req, settings.GRPC...) 477 return err 478 }, opts...) 479 if err != nil { 480 return nil, err 481 } 482 return resp, nil 483} 484 485// GetNodePool retrieves the node pool requested. 486func (c *ClusterManagerClient) GetNodePool(ctx context.Context, req *containerpb.GetNodePoolRequest, opts ...gax.CallOption) (*containerpb.NodePool, error) { 487 ctx = insertMetadata(ctx, c.xGoogMetadata) 488 opts = append(c.CallOptions.GetNodePool[0:len(c.CallOptions.GetNodePool):len(c.CallOptions.GetNodePool)], opts...) 489 var resp *containerpb.NodePool 490 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 491 var err error 492 resp, err = c.clusterManagerClient.GetNodePool(ctx, req, settings.GRPC...) 493 return err 494 }, opts...) 495 if err != nil { 496 return nil, err 497 } 498 return resp, nil 499} 500 501// CreateNodePool creates a node pool for a cluster. 502func (c *ClusterManagerClient) CreateNodePool(ctx context.Context, req *containerpb.CreateNodePoolRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 503 ctx = insertMetadata(ctx, c.xGoogMetadata) 504 opts = append(c.CallOptions.CreateNodePool[0:len(c.CallOptions.CreateNodePool):len(c.CallOptions.CreateNodePool)], opts...) 505 var resp *containerpb.Operation 506 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 507 var err error 508 resp, err = c.clusterManagerClient.CreateNodePool(ctx, req, settings.GRPC...) 509 return err 510 }, opts...) 511 if err != nil { 512 return nil, err 513 } 514 return resp, nil 515} 516 517// DeleteNodePool deletes a node pool from a cluster. 518func (c *ClusterManagerClient) DeleteNodePool(ctx context.Context, req *containerpb.DeleteNodePoolRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 519 ctx = insertMetadata(ctx, c.xGoogMetadata) 520 opts = append(c.CallOptions.DeleteNodePool[0:len(c.CallOptions.DeleteNodePool):len(c.CallOptions.DeleteNodePool)], opts...) 521 var resp *containerpb.Operation 522 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 523 var err error 524 resp, err = c.clusterManagerClient.DeleteNodePool(ctx, req, settings.GRPC...) 525 return err 526 }, opts...) 527 if err != nil { 528 return nil, err 529 } 530 return resp, nil 531} 532 533// RollbackNodePoolUpgrade roll back the previously Aborted or Failed NodePool upgrade. 534// This will be an no-op if the last upgrade successfully completed. 535func (c *ClusterManagerClient) RollbackNodePoolUpgrade(ctx context.Context, req *containerpb.RollbackNodePoolUpgradeRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 536 ctx = insertMetadata(ctx, c.xGoogMetadata) 537 opts = append(c.CallOptions.RollbackNodePoolUpgrade[0:len(c.CallOptions.RollbackNodePoolUpgrade):len(c.CallOptions.RollbackNodePoolUpgrade)], opts...) 538 var resp *containerpb.Operation 539 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 540 var err error 541 resp, err = c.clusterManagerClient.RollbackNodePoolUpgrade(ctx, req, settings.GRPC...) 542 return err 543 }, opts...) 544 if err != nil { 545 return nil, err 546 } 547 return resp, nil 548} 549 550// SetNodePoolManagement sets the NodeManagement options for a node pool. 551func (c *ClusterManagerClient) SetNodePoolManagement(ctx context.Context, req *containerpb.SetNodePoolManagementRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 552 ctx = insertMetadata(ctx, c.xGoogMetadata) 553 opts = append(c.CallOptions.SetNodePoolManagement[0:len(c.CallOptions.SetNodePoolManagement):len(c.CallOptions.SetNodePoolManagement)], opts...) 554 var resp *containerpb.Operation 555 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 556 var err error 557 resp, err = c.clusterManagerClient.SetNodePoolManagement(ctx, req, settings.GRPC...) 558 return err 559 }, opts...) 560 if err != nil { 561 return nil, err 562 } 563 return resp, nil 564} 565 566// SetLabels sets labels on a cluster. 567func (c *ClusterManagerClient) SetLabels(ctx context.Context, req *containerpb.SetLabelsRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 568 ctx = insertMetadata(ctx, c.xGoogMetadata) 569 opts = append(c.CallOptions.SetLabels[0:len(c.CallOptions.SetLabels):len(c.CallOptions.SetLabels)], opts...) 570 var resp *containerpb.Operation 571 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 572 var err error 573 resp, err = c.clusterManagerClient.SetLabels(ctx, req, settings.GRPC...) 574 return err 575 }, opts...) 576 if err != nil { 577 return nil, err 578 } 579 return resp, nil 580} 581 582// SetLegacyAbac enables or disables the ABAC authorization mechanism on a cluster. 583func (c *ClusterManagerClient) SetLegacyAbac(ctx context.Context, req *containerpb.SetLegacyAbacRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 584 ctx = insertMetadata(ctx, c.xGoogMetadata) 585 opts = append(c.CallOptions.SetLegacyAbac[0:len(c.CallOptions.SetLegacyAbac):len(c.CallOptions.SetLegacyAbac)], opts...) 586 var resp *containerpb.Operation 587 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 588 var err error 589 resp, err = c.clusterManagerClient.SetLegacyAbac(ctx, req, settings.GRPC...) 590 return err 591 }, opts...) 592 if err != nil { 593 return nil, err 594 } 595 return resp, nil 596} 597 598// StartIPRotation start master IP rotation. 599func (c *ClusterManagerClient) StartIPRotation(ctx context.Context, req *containerpb.StartIPRotationRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 600 ctx = insertMetadata(ctx, c.xGoogMetadata) 601 opts = append(c.CallOptions.StartIPRotation[0:len(c.CallOptions.StartIPRotation):len(c.CallOptions.StartIPRotation)], opts...) 602 var resp *containerpb.Operation 603 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 604 var err error 605 resp, err = c.clusterManagerClient.StartIPRotation(ctx, req, settings.GRPC...) 606 return err 607 }, opts...) 608 if err != nil { 609 return nil, err 610 } 611 return resp, nil 612} 613 614// CompleteIPRotation completes master IP rotation. 615func (c *ClusterManagerClient) CompleteIPRotation(ctx context.Context, req *containerpb.CompleteIPRotationRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 616 ctx = insertMetadata(ctx, c.xGoogMetadata) 617 opts = append(c.CallOptions.CompleteIPRotation[0:len(c.CallOptions.CompleteIPRotation):len(c.CallOptions.CompleteIPRotation)], opts...) 618 var resp *containerpb.Operation 619 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 620 var err error 621 resp, err = c.clusterManagerClient.CompleteIPRotation(ctx, req, settings.GRPC...) 622 return err 623 }, opts...) 624 if err != nil { 625 return nil, err 626 } 627 return resp, nil 628} 629 630// SetNodePoolSize sets the size of a specific node pool. 631func (c *ClusterManagerClient) SetNodePoolSize(ctx context.Context, req *containerpb.SetNodePoolSizeRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 632 ctx = insertMetadata(ctx, c.xGoogMetadata) 633 opts = append(c.CallOptions.SetNodePoolSize[0:len(c.CallOptions.SetNodePoolSize):len(c.CallOptions.SetNodePoolSize)], opts...) 634 var resp *containerpb.Operation 635 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 636 var err error 637 resp, err = c.clusterManagerClient.SetNodePoolSize(ctx, req, settings.GRPC...) 638 return err 639 }, opts...) 640 if err != nil { 641 return nil, err 642 } 643 return resp, nil 644} 645 646// SetNetworkPolicy enables/Disables Network Policy for a cluster. 647func (c *ClusterManagerClient) SetNetworkPolicy(ctx context.Context, req *containerpb.SetNetworkPolicyRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 648 ctx = insertMetadata(ctx, c.xGoogMetadata) 649 opts = append(c.CallOptions.SetNetworkPolicy[0:len(c.CallOptions.SetNetworkPolicy):len(c.CallOptions.SetNetworkPolicy)], opts...) 650 var resp *containerpb.Operation 651 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 652 var err error 653 resp, err = c.clusterManagerClient.SetNetworkPolicy(ctx, req, settings.GRPC...) 654 return err 655 }, opts...) 656 if err != nil { 657 return nil, err 658 } 659 return resp, nil 660} 661 662// SetMaintenancePolicy sets the maintenance policy for a cluster. 663func (c *ClusterManagerClient) SetMaintenancePolicy(ctx context.Context, req *containerpb.SetMaintenancePolicyRequest, opts ...gax.CallOption) (*containerpb.Operation, error) { 664 ctx = insertMetadata(ctx, c.xGoogMetadata) 665 opts = append(c.CallOptions.SetMaintenancePolicy[0:len(c.CallOptions.SetMaintenancePolicy):len(c.CallOptions.SetMaintenancePolicy)], opts...) 666 var resp *containerpb.Operation 667 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 668 var err error 669 resp, err = c.clusterManagerClient.SetMaintenancePolicy(ctx, req, settings.GRPC...) 670 return err 671 }, opts...) 672 if err != nil { 673 return nil, err 674 } 675 return resp, nil 676} 677