1// Copyright 2019 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// Code generated by gapic-generator. DO NOT EDIT. 16 17package cloudtasks 18 19import ( 20 "context" 21 "fmt" 22 "math" 23 "time" 24 25 "github.com/golang/protobuf/proto" 26 gax "github.com/googleapis/gax-go/v2" 27 "google.golang.org/api/iterator" 28 "google.golang.org/api/option" 29 "google.golang.org/api/transport" 30 taskspb "google.golang.org/genproto/googleapis/cloud/tasks/v2beta3" 31 iampb "google.golang.org/genproto/googleapis/iam/v1" 32 "google.golang.org/grpc" 33 "google.golang.org/grpc/codes" 34 "google.golang.org/grpc/metadata" 35) 36 37// CallOptions contains the retry settings for each method of Client. 38type CallOptions struct { 39 ListQueues []gax.CallOption 40 GetQueue []gax.CallOption 41 CreateQueue []gax.CallOption 42 UpdateQueue []gax.CallOption 43 DeleteQueue []gax.CallOption 44 PurgeQueue []gax.CallOption 45 PauseQueue []gax.CallOption 46 ResumeQueue []gax.CallOption 47 GetIamPolicy []gax.CallOption 48 SetIamPolicy []gax.CallOption 49 TestIamPermissions []gax.CallOption 50 ListTasks []gax.CallOption 51 GetTask []gax.CallOption 52 CreateTask []gax.CallOption 53 DeleteTask []gax.CallOption 54 RunTask []gax.CallOption 55} 56 57func defaultClientOptions() []option.ClientOption { 58 return []option.ClientOption{ 59 option.WithEndpoint("cloudtasks.googleapis.com:443"), 60 option.WithScopes(DefaultAuthScopes()...), 61 } 62} 63 64func defaultCallOptions() *CallOptions { 65 retry := map[[2]string][]gax.CallOption{ 66 {"default", "idempotent"}: { 67 gax.WithRetry(func() gax.Retryer { 68 return gax.OnCodes([]codes.Code{ 69 codes.DeadlineExceeded, 70 codes.Unavailable, 71 }, gax.Backoff{ 72 Initial: 100 * time.Millisecond, 73 Max: 60000 * time.Millisecond, 74 Multiplier: 1.3, 75 }) 76 }), 77 }, 78 } 79 return &CallOptions{ 80 ListQueues: retry[[2]string{"default", "idempotent"}], 81 GetQueue: retry[[2]string{"default", "idempotent"}], 82 CreateQueue: retry[[2]string{"default", "non_idempotent"}], 83 UpdateQueue: retry[[2]string{"default", "non_idempotent"}], 84 DeleteQueue: retry[[2]string{"default", "idempotent"}], 85 PurgeQueue: retry[[2]string{"default", "non_idempotent"}], 86 PauseQueue: retry[[2]string{"default", "non_idempotent"}], 87 ResumeQueue: retry[[2]string{"default", "non_idempotent"}], 88 GetIamPolicy: retry[[2]string{"default", "idempotent"}], 89 SetIamPolicy: retry[[2]string{"default", "non_idempotent"}], 90 TestIamPermissions: retry[[2]string{"default", "idempotent"}], 91 ListTasks: retry[[2]string{"default", "idempotent"}], 92 GetTask: retry[[2]string{"default", "idempotent"}], 93 CreateTask: retry[[2]string{"default", "non_idempotent"}], 94 DeleteTask: retry[[2]string{"default", "idempotent"}], 95 RunTask: retry[[2]string{"default", "non_idempotent"}], 96 } 97} 98 99// Client is a client for interacting with Cloud Tasks API. 100// 101// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. 102type Client struct { 103 // The connection to the service. 104 conn *grpc.ClientConn 105 106 // The gRPC API client. 107 client taskspb.CloudTasksClient 108 109 // The call options for this service. 110 CallOptions *CallOptions 111 112 // The x-goog-* metadata to be sent with each request. 113 xGoogMetadata metadata.MD 114} 115 116// NewClient creates a new cloud tasks client. 117// 118// Cloud Tasks allows developers to manage the execution of background 119// work in their applications. 120func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) { 121 conn, err := transport.DialGRPC(ctx, append(defaultClientOptions(), opts...)...) 122 if err != nil { 123 return nil, err 124 } 125 c := &Client{ 126 conn: conn, 127 CallOptions: defaultCallOptions(), 128 129 client: taskspb.NewCloudTasksClient(conn), 130 } 131 c.setGoogleClientInfo() 132 return c, nil 133} 134 135// Connection returns the client's connection to the API service. 136func (c *Client) Connection() *grpc.ClientConn { 137 return c.conn 138} 139 140// Close closes the connection to the API service. The user should invoke this when 141// the client is no longer required. 142func (c *Client) Close() error { 143 return c.conn.Close() 144} 145 146// setGoogleClientInfo sets the name and version of the application in 147// the `x-goog-api-client` header passed on each request. Intended for 148// use by Google-written clients. 149func (c *Client) setGoogleClientInfo(keyval ...string) { 150 kv := append([]string{"gl-go", versionGo()}, keyval...) 151 kv = append(kv, "gapic", versionClient, "gax", gax.Version, "grpc", grpc.Version) 152 c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) 153} 154 155// ListQueues lists queues. 156// 157// Queues are returned in lexicographical order. 158func (c *Client) ListQueues(ctx context.Context, req *taskspb.ListQueuesRequest, opts ...gax.CallOption) *QueueIterator { 159 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", req.GetParent())) 160 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 161 opts = append(c.CallOptions.ListQueues[0:len(c.CallOptions.ListQueues):len(c.CallOptions.ListQueues)], opts...) 162 it := &QueueIterator{} 163 req = proto.Clone(req).(*taskspb.ListQueuesRequest) 164 it.InternalFetch = func(pageSize int, pageToken string) ([]*taskspb.Queue, string, error) { 165 var resp *taskspb.ListQueuesResponse 166 req.PageToken = pageToken 167 if pageSize > math.MaxInt32 { 168 req.PageSize = math.MaxInt32 169 } else { 170 req.PageSize = int32(pageSize) 171 } 172 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 173 var err error 174 resp, err = c.client.ListQueues(ctx, req, settings.GRPC...) 175 return err 176 }, opts...) 177 if err != nil { 178 return nil, "", err 179 } 180 return resp.Queues, resp.NextPageToken, nil 181 } 182 fetch := func(pageSize int, pageToken string) (string, error) { 183 items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) 184 if err != nil { 185 return "", err 186 } 187 it.items = append(it.items, items...) 188 return nextPageToken, nil 189 } 190 it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) 191 it.pageInfo.MaxSize = int(req.PageSize) 192 it.pageInfo.Token = req.PageToken 193 return it 194} 195 196// GetQueue gets a queue. 197func (c *Client) GetQueue(ctx context.Context, req *taskspb.GetQueueRequest, opts ...gax.CallOption) (*taskspb.Queue, error) { 198 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 199 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 200 opts = append(c.CallOptions.GetQueue[0:len(c.CallOptions.GetQueue):len(c.CallOptions.GetQueue)], opts...) 201 var resp *taskspb.Queue 202 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 203 var err error 204 resp, err = c.client.GetQueue(ctx, req, settings.GRPC...) 205 return err 206 }, opts...) 207 if err != nil { 208 return nil, err 209 } 210 return resp, nil 211} 212 213// CreateQueue creates a queue. 214// 215// Queues created with this method allow tasks to live for a maximum of 31 216// days. After a task is 31 days old, the task will be deleted regardless of whether 217// it was dispatched or not. 218// 219// WARNING: Using this method may have unintended side effects if you are 220// using an App Engine queue.yaml or queue.xml file to manage your queues. 221// Read 222// Overview of Queue Management and 223// queue.yaml (at https://cloud.google.com/tasks/docs/queue-yaml) before using 224// this method. 225func (c *Client) CreateQueue(ctx context.Context, req *taskspb.CreateQueueRequest, opts ...gax.CallOption) (*taskspb.Queue, error) { 226 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", req.GetParent())) 227 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 228 opts = append(c.CallOptions.CreateQueue[0:len(c.CallOptions.CreateQueue):len(c.CallOptions.CreateQueue)], opts...) 229 var resp *taskspb.Queue 230 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 231 var err error 232 resp, err = c.client.CreateQueue(ctx, req, settings.GRPC...) 233 return err 234 }, opts...) 235 if err != nil { 236 return nil, err 237 } 238 return resp, nil 239} 240 241// UpdateQueue updates a queue. 242// 243// This method creates the queue if it does not exist and updates 244// the queue if it does exist. 245// 246// Queues created with this method allow tasks to live for a maximum of 31 247// days. After a task is 31 days old, the task will be deleted regardless of whether 248// it was dispatched or not. 249// 250// WARNING: Using this method may have unintended side effects if you are 251// using an App Engine queue.yaml or queue.xml file to manage your queues. 252// Read 253// Overview of Queue Management and 254// queue.yaml (at https://cloud.google.com/tasks/docs/queue-yaml) before using 255// this method. 256func (c *Client) UpdateQueue(ctx context.Context, req *taskspb.UpdateQueueRequest, opts ...gax.CallOption) (*taskspb.Queue, error) { 257 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "queue.name", req.GetQueue().GetName())) 258 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 259 opts = append(c.CallOptions.UpdateQueue[0:len(c.CallOptions.UpdateQueue):len(c.CallOptions.UpdateQueue)], opts...) 260 var resp *taskspb.Queue 261 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 262 var err error 263 resp, err = c.client.UpdateQueue(ctx, req, settings.GRPC...) 264 return err 265 }, opts...) 266 if err != nil { 267 return nil, err 268 } 269 return resp, nil 270} 271 272// DeleteQueue deletes a queue. 273// 274// This command will delete the queue even if it has tasks in it. 275// 276// Note: If you delete a queue, a queue with the same name can't be created 277// for 7 days. 278// 279// WARNING: Using this method may have unintended side effects if you are 280// using an App Engine queue.yaml or queue.xml file to manage your queues. 281// Read 282// Overview of Queue Management and 283// queue.yaml (at https://cloud.google.com/tasks/docs/queue-yaml) before using 284// this method. 285func (c *Client) DeleteQueue(ctx context.Context, req *taskspb.DeleteQueueRequest, opts ...gax.CallOption) error { 286 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 287 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 288 opts = append(c.CallOptions.DeleteQueue[0:len(c.CallOptions.DeleteQueue):len(c.CallOptions.DeleteQueue)], opts...) 289 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 290 var err error 291 _, err = c.client.DeleteQueue(ctx, req, settings.GRPC...) 292 return err 293 }, opts...) 294 return err 295} 296 297// PurgeQueue purges a queue by deleting all of its tasks. 298// 299// All tasks created before this method is called are permanently deleted. 300// 301// Purge operations can take up to one minute to take effect. Tasks 302// might be dispatched before the purge takes effect. A purge is irreversible. 303func (c *Client) PurgeQueue(ctx context.Context, req *taskspb.PurgeQueueRequest, opts ...gax.CallOption) (*taskspb.Queue, error) { 304 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 305 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 306 opts = append(c.CallOptions.PurgeQueue[0:len(c.CallOptions.PurgeQueue):len(c.CallOptions.PurgeQueue)], opts...) 307 var resp *taskspb.Queue 308 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 309 var err error 310 resp, err = c.client.PurgeQueue(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// PauseQueue pauses the queue. 320// 321// If a queue is paused then the system will stop dispatching tasks 322// until the queue is resumed via 323// [ResumeQueue][google.cloud.tasks.v2beta3.CloudTasks.ResumeQueue]. Tasks can still be added 324// when the queue is paused. A queue is paused if its 325// [state][google.cloud.tasks.v2beta3.Queue.state] is [PAUSED][google.cloud.tasks.v2beta3.Queue.State.PAUSED]. 326func (c *Client) PauseQueue(ctx context.Context, req *taskspb.PauseQueueRequest, opts ...gax.CallOption) (*taskspb.Queue, error) { 327 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 328 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 329 opts = append(c.CallOptions.PauseQueue[0:len(c.CallOptions.PauseQueue):len(c.CallOptions.PauseQueue)], opts...) 330 var resp *taskspb.Queue 331 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 332 var err error 333 resp, err = c.client.PauseQueue(ctx, req, settings.GRPC...) 334 return err 335 }, opts...) 336 if err != nil { 337 return nil, err 338 } 339 return resp, nil 340} 341 342// ResumeQueue resume a queue. 343// 344// This method resumes a queue after it has been 345// [PAUSED][google.cloud.tasks.v2beta3.Queue.State.PAUSED] or 346// [DISABLED][google.cloud.tasks.v2beta3.Queue.State.DISABLED]. The state of a queue is stored 347// in the queue's [state][google.cloud.tasks.v2beta3.Queue.state]; after calling this method it 348// will be set to [RUNNING][google.cloud.tasks.v2beta3.Queue.State.RUNNING]. 349// 350// WARNING: Resuming many high-QPS queues at the same time can 351// lead to target overloading. If you are resuming high-QPS 352// queues, follow the 500/50/5 pattern described in 353// Managing Cloud Tasks Scaling 354// Risks (at https://cloud.google.com/tasks/docs/manage-cloud-task-scaling). 355func (c *Client) ResumeQueue(ctx context.Context, req *taskspb.ResumeQueueRequest, opts ...gax.CallOption) (*taskspb.Queue, error) { 356 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 357 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 358 opts = append(c.CallOptions.ResumeQueue[0:len(c.CallOptions.ResumeQueue):len(c.CallOptions.ResumeQueue)], opts...) 359 var resp *taskspb.Queue 360 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 361 var err error 362 resp, err = c.client.ResumeQueue(ctx, req, settings.GRPC...) 363 return err 364 }, opts...) 365 if err != nil { 366 return nil, err 367 } 368 return resp, nil 369} 370 371// GetIamPolicy gets the access control policy for a [Queue][google.cloud.tasks.v2beta3.Queue]. 372// Returns an empty policy if the resource exists and does not have a policy 373// set. 374// 375// Authorization requires the following 376// Google IAM (at https://cloud.google.com/iam) permission on the specified 377// resource parent: 378// 379// cloudtasks.queues.getIamPolicy 380func (c *Client) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) { 381 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "resource", req.GetResource())) 382 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 383 opts = append(c.CallOptions.GetIamPolicy[0:len(c.CallOptions.GetIamPolicy):len(c.CallOptions.GetIamPolicy)], opts...) 384 var resp *iampb.Policy 385 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 386 var err error 387 resp, err = c.client.GetIamPolicy(ctx, req, settings.GRPC...) 388 return err 389 }, opts...) 390 if err != nil { 391 return nil, err 392 } 393 return resp, nil 394} 395 396// SetIamPolicy sets the access control policy for a [Queue][google.cloud.tasks.v2beta3.Queue]. Replaces any existing 397// policy. 398// 399// Note: The Cloud Console does not check queue-level IAM permissions yet. 400// Project-level permissions are required to use the Cloud Console. 401// 402// Authorization requires the following 403// Google IAM (at https://cloud.google.com/iam) permission on the specified 404// resource parent: 405// 406// cloudtasks.queues.setIamPolicy 407func (c *Client) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) { 408 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "resource", req.GetResource())) 409 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 410 opts = append(c.CallOptions.SetIamPolicy[0:len(c.CallOptions.SetIamPolicy):len(c.CallOptions.SetIamPolicy)], opts...) 411 var resp *iampb.Policy 412 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 413 var err error 414 resp, err = c.client.SetIamPolicy(ctx, req, settings.GRPC...) 415 return err 416 }, opts...) 417 if err != nil { 418 return nil, err 419 } 420 return resp, nil 421} 422 423// TestIamPermissions returns permissions that a caller has on a [Queue][google.cloud.tasks.v2beta3.Queue]. 424// If the resource does not exist, this will return an empty set of 425// permissions, not a [NOT_FOUND][google.rpc.Code.NOT_FOUND] error. 426// 427// Note: This operation is designed to be used for building permission-aware 428// UIs and command-line tools, not for authorization checking. This operation 429// may "fail open" without warning. 430func (c *Client) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error) { 431 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "resource", req.GetResource())) 432 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 433 opts = append(c.CallOptions.TestIamPermissions[0:len(c.CallOptions.TestIamPermissions):len(c.CallOptions.TestIamPermissions)], opts...) 434 var resp *iampb.TestIamPermissionsResponse 435 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 436 var err error 437 resp, err = c.client.TestIamPermissions(ctx, req, settings.GRPC...) 438 return err 439 }, opts...) 440 if err != nil { 441 return nil, err 442 } 443 return resp, nil 444} 445 446// ListTasks lists the tasks in a queue. 447// 448// By default, only the [BASIC][google.cloud.tasks.v2beta3.Task.View.BASIC] view is retrieved 449// due to performance considerations; 450// [response_view][google.cloud.tasks.v2beta3.ListTasksRequest.response_view] controls the 451// subset of information which is returned. 452// 453// The tasks may be returned in any order. The ordering may change at any 454// time. 455func (c *Client) ListTasks(ctx context.Context, req *taskspb.ListTasksRequest, opts ...gax.CallOption) *TaskIterator { 456 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", req.GetParent())) 457 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 458 opts = append(c.CallOptions.ListTasks[0:len(c.CallOptions.ListTasks):len(c.CallOptions.ListTasks)], opts...) 459 it := &TaskIterator{} 460 req = proto.Clone(req).(*taskspb.ListTasksRequest) 461 it.InternalFetch = func(pageSize int, pageToken string) ([]*taskspb.Task, string, error) { 462 var resp *taskspb.ListTasksResponse 463 req.PageToken = pageToken 464 if pageSize > math.MaxInt32 { 465 req.PageSize = math.MaxInt32 466 } else { 467 req.PageSize = int32(pageSize) 468 } 469 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 470 var err error 471 resp, err = c.client.ListTasks(ctx, req, settings.GRPC...) 472 return err 473 }, opts...) 474 if err != nil { 475 return nil, "", err 476 } 477 return resp.Tasks, resp.NextPageToken, nil 478 } 479 fetch := func(pageSize int, pageToken string) (string, error) { 480 items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) 481 if err != nil { 482 return "", err 483 } 484 it.items = append(it.items, items...) 485 return nextPageToken, nil 486 } 487 it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) 488 it.pageInfo.MaxSize = int(req.PageSize) 489 it.pageInfo.Token = req.PageToken 490 return it 491} 492 493// GetTask gets a task. 494func (c *Client) GetTask(ctx context.Context, req *taskspb.GetTaskRequest, opts ...gax.CallOption) (*taskspb.Task, error) { 495 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 496 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 497 opts = append(c.CallOptions.GetTask[0:len(c.CallOptions.GetTask):len(c.CallOptions.GetTask)], opts...) 498 var resp *taskspb.Task 499 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 500 var err error 501 resp, err = c.client.GetTask(ctx, req, settings.GRPC...) 502 return err 503 }, opts...) 504 if err != nil { 505 return nil, err 506 } 507 return resp, nil 508} 509 510// CreateTask creates a task and adds it to a queue. 511// 512// Tasks cannot be updated after creation; there is no UpdateTask command. 513// 514// The maximum task size is 100KB. 515func (c *Client) CreateTask(ctx context.Context, req *taskspb.CreateTaskRequest, opts ...gax.CallOption) (*taskspb.Task, error) { 516 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", req.GetParent())) 517 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 518 opts = append(c.CallOptions.CreateTask[0:len(c.CallOptions.CreateTask):len(c.CallOptions.CreateTask)], opts...) 519 var resp *taskspb.Task 520 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 521 var err error 522 resp, err = c.client.CreateTask(ctx, req, settings.GRPC...) 523 return err 524 }, opts...) 525 if err != nil { 526 return nil, err 527 } 528 return resp, nil 529} 530 531// DeleteTask deletes a task. 532// 533// A task can be deleted if it is scheduled or dispatched. A task 534// cannot be deleted if it has executed successfully or permanently 535// failed. 536func (c *Client) DeleteTask(ctx context.Context, req *taskspb.DeleteTaskRequest, opts ...gax.CallOption) error { 537 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 538 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 539 opts = append(c.CallOptions.DeleteTask[0:len(c.CallOptions.DeleteTask):len(c.CallOptions.DeleteTask)], opts...) 540 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 541 var err error 542 _, err = c.client.DeleteTask(ctx, req, settings.GRPC...) 543 return err 544 }, opts...) 545 return err 546} 547 548// RunTask forces a task to run now. 549// 550// When this method is called, Cloud Tasks will dispatch the task, even if 551// the task is already running, the queue has reached its [RateLimits][google.cloud.tasks.v2beta3.RateLimits] or 552// is [PAUSED][google.cloud.tasks.v2beta3.Queue.State.PAUSED]. 553// 554// This command is meant to be used for manual debugging. For 555// example, [RunTask][google.cloud.tasks.v2beta3.CloudTasks.RunTask] can be used to retry a failed 556// task after a fix has been made or to manually force a task to be 557// dispatched now. 558// 559// The dispatched task is returned. That is, the task that is returned 560// contains the [status][Task.status] after the task is dispatched but 561// before the task is received by its target. 562// 563// If Cloud Tasks receives a successful response from the task's 564// target, then the task will be deleted; otherwise the task's 565// [schedule_time][google.cloud.tasks.v2beta3.Task.schedule_time] will be reset to the time that 566// [RunTask][google.cloud.tasks.v2beta3.CloudTasks.RunTask] was called plus the retry delay specified 567// in the queue's [RetryConfig][google.cloud.tasks.v2beta3.RetryConfig]. 568// 569// [RunTask][google.cloud.tasks.v2beta3.CloudTasks.RunTask] returns 570// [NOT_FOUND][google.rpc.Code.NOT_FOUND] when it is called on a 571// task that has already succeeded or permanently failed. 572func (c *Client) RunTask(ctx context.Context, req *taskspb.RunTaskRequest, opts ...gax.CallOption) (*taskspb.Task, error) { 573 md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", req.GetName())) 574 ctx = insertMetadata(ctx, c.xGoogMetadata, md) 575 opts = append(c.CallOptions.RunTask[0:len(c.CallOptions.RunTask):len(c.CallOptions.RunTask)], opts...) 576 var resp *taskspb.Task 577 err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { 578 var err error 579 resp, err = c.client.RunTask(ctx, req, settings.GRPC...) 580 return err 581 }, opts...) 582 if err != nil { 583 return nil, err 584 } 585 return resp, nil 586} 587 588// QueueIterator manages a stream of *taskspb.Queue. 589type QueueIterator struct { 590 items []*taskspb.Queue 591 pageInfo *iterator.PageInfo 592 nextFunc func() error 593 594 // InternalFetch is for use by the Google Cloud Libraries only. 595 // It is not part of the stable interface of this package. 596 // 597 // InternalFetch returns results from a single call to the underlying RPC. 598 // The number of results is no greater than pageSize. 599 // If there are no more results, nextPageToken is empty and err is nil. 600 InternalFetch func(pageSize int, pageToken string) (results []*taskspb.Queue, nextPageToken string, err error) 601} 602 603// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. 604func (it *QueueIterator) PageInfo() *iterator.PageInfo { 605 return it.pageInfo 606} 607 608// Next returns the next result. Its second return value is iterator.Done if there are no more 609// results. Once Next returns Done, all subsequent calls will return Done. 610func (it *QueueIterator) Next() (*taskspb.Queue, error) { 611 var item *taskspb.Queue 612 if err := it.nextFunc(); err != nil { 613 return item, err 614 } 615 item = it.items[0] 616 it.items = it.items[1:] 617 return item, nil 618} 619 620func (it *QueueIterator) bufLen() int { 621 return len(it.items) 622} 623 624func (it *QueueIterator) takeBuf() interface{} { 625 b := it.items 626 it.items = nil 627 return b 628} 629 630// TaskIterator manages a stream of *taskspb.Task. 631type TaskIterator struct { 632 items []*taskspb.Task 633 pageInfo *iterator.PageInfo 634 nextFunc func() error 635 636 // InternalFetch is for use by the Google Cloud Libraries only. 637 // It is not part of the stable interface of this package. 638 // 639 // InternalFetch returns results from a single call to the underlying RPC. 640 // The number of results is no greater than pageSize. 641 // If there are no more results, nextPageToken is empty and err is nil. 642 InternalFetch func(pageSize int, pageToken string) (results []*taskspb.Task, nextPageToken string, err error) 643} 644 645// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. 646func (it *TaskIterator) PageInfo() *iterator.PageInfo { 647 return it.pageInfo 648} 649 650// Next returns the next result. Its second return value is iterator.Done if there are no more 651// results. Once Next returns Done, all subsequent calls will return Done. 652func (it *TaskIterator) Next() (*taskspb.Task, error) { 653 var item *taskspb.Task 654 if err := it.nextFunc(); err != nil { 655 return item, err 656 } 657 item = it.items[0] 658 it.items = it.items[1:] 659 return item, nil 660} 661 662func (it *TaskIterator) bufLen() int { 663 return len(it.items) 664} 665 666func (it *TaskIterator) takeBuf() interface{} { 667 b := it.items 668 it.items = nil 669 return b 670} 671