You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
388 lines
16 KiB
388 lines
16 KiB
// Copyright 2018 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
syntax = "proto3";
|
|
|
|
package google.cloud.tasks.v2beta2;
|
|
|
|
import "google/api/annotations.proto";
|
|
import "google/cloud/tasks/v2beta2/target.proto";
|
|
import "google/protobuf/duration.proto";
|
|
import "google/protobuf/timestamp.proto";
|
|
|
|
option go_package = "google.golang.org/genproto/googleapis/cloud/tasks/v2beta2;tasks";
|
|
option java_multiple_files = true;
|
|
option java_outer_classname = "QueueProto";
|
|
option java_package = "com.google.cloud.tasks.v2beta2";
|
|
|
|
// A queue is a container of related tasks. Queues are configured to manage
|
|
// how those tasks are dispatched. Configurable properties include rate limits,
|
|
// retry options, target types, and others.
|
|
message Queue {
|
|
// State of the queue.
|
|
enum State {
|
|
// Unspecified state.
|
|
STATE_UNSPECIFIED = 0;
|
|
|
|
// The queue is running. Tasks can be dispatched.
|
|
//
|
|
// If the queue was created using Cloud Tasks and the queue has
|
|
// had no activity (method calls or task dispatches) for 30 days,
|
|
// the queue may take a few minutes to re-activate. Some method
|
|
// calls may return [NOT_FOUND][google.rpc.Code.NOT_FOUND] and
|
|
// tasks may not be dispatched for a few minutes until the queue
|
|
// has been re-activated.
|
|
RUNNING = 1;
|
|
|
|
// Tasks are paused by the user. If the queue is paused then Cloud
|
|
// Tasks will stop delivering tasks from it, but more tasks can
|
|
// still be added to it by the user. When a pull queue is paused,
|
|
// all [LeaseTasks][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks] calls
|
|
// will return a [FAILED_PRECONDITION][google.rpc.Code.FAILED_PRECONDITION].
|
|
PAUSED = 2;
|
|
|
|
// The queue is disabled.
|
|
//
|
|
// A queue becomes `DISABLED` when
|
|
// [queue.yaml](https://cloud.google.com/appengine/docs/python/config/queueref)
|
|
// or
|
|
// [queue.xml](https://cloud.google.com/appengine/docs/standard/java/config/queueref)
|
|
// is uploaded which does not contain the queue. You cannot directly disable
|
|
// a queue.
|
|
//
|
|
// When a queue is disabled, tasks can still be added to a queue
|
|
// but the tasks are not dispatched and
|
|
// [LeaseTasks][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks] calls
|
|
// return a `FAILED_PRECONDITION` error.
|
|
//
|
|
// To permanently delete this queue and all of its tasks, call
|
|
// [DeleteQueue][google.cloud.tasks.v2beta2.CloudTasks.DeleteQueue].
|
|
DISABLED = 3;
|
|
}
|
|
|
|
// Caller-specified and required in
|
|
// [CreateQueue][google.cloud.tasks.v2beta2.CloudTasks.CreateQueue], after
|
|
// which it becomes output only.
|
|
//
|
|
// The queue name.
|
|
//
|
|
// The queue name must have the following format:
|
|
// `projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID`
|
|
//
|
|
// * `PROJECT_ID` can contain letters ([A-Za-z]), numbers ([0-9]),
|
|
// hyphens (-), colons (:), or periods (.).
|
|
// For more information, see
|
|
// [Identifying
|
|
// projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)
|
|
// * `LOCATION_ID` is the canonical ID for the queue's location.
|
|
// The list of available locations can be obtained by calling
|
|
// [ListLocations][google.cloud.location.Locations.ListLocations].
|
|
// For more information, see https://cloud.google.com/about/locations/.
|
|
// * `QUEUE_ID` can contain letters ([A-Za-z]), numbers ([0-9]), or
|
|
// hyphens (-). The maximum length is 100 characters.
|
|
string name = 1;
|
|
|
|
// Caller-specified and required in
|
|
// [CreateQueue][google.cloud.tasks.v2beta2.CloudTasks.CreateQueue][], after
|
|
// which the queue config type becomes output only, though fields within the
|
|
// config are mutable.
|
|
//
|
|
// The queue's target.
|
|
//
|
|
// The target applies to all tasks in the queue.
|
|
oneof target_type {
|
|
// App Engine HTTP target.
|
|
//
|
|
// An App Engine queue is a queue that has an
|
|
// [AppEngineHttpTarget][google.cloud.tasks.v2beta2.AppEngineHttpTarget].
|
|
AppEngineHttpTarget app_engine_http_target = 3;
|
|
|
|
// Pull target.
|
|
//
|
|
// A pull queue is a queue that has a
|
|
// [PullTarget][google.cloud.tasks.v2beta2.PullTarget].
|
|
PullTarget pull_target = 4;
|
|
}
|
|
|
|
// Rate limits for task dispatches.
|
|
//
|
|
// [rate_limits][google.cloud.tasks.v2beta2.Queue.rate_limits] and
|
|
// [retry_config][google.cloud.tasks.v2beta2.Queue.retry_config] are related
|
|
// because they both control task attempts however they control how tasks are
|
|
// attempted in different ways:
|
|
//
|
|
// * [rate_limits][google.cloud.tasks.v2beta2.Queue.rate_limits] controls the
|
|
// total rate of
|
|
// dispatches from a queue (i.e. all traffic dispatched from the
|
|
// queue, regardless of whether the dispatch is from a first
|
|
// attempt or a retry).
|
|
// * [retry_config][google.cloud.tasks.v2beta2.Queue.retry_config] controls
|
|
// what happens to
|
|
// particular a task after its first attempt fails. That is,
|
|
// [retry_config][google.cloud.tasks.v2beta2.Queue.retry_config] controls
|
|
// task retries (the second attempt, third attempt, etc).
|
|
RateLimits rate_limits = 5;
|
|
|
|
// Settings that determine the retry behavior.
|
|
//
|
|
// * For tasks created using Cloud Tasks: the queue-level retry settings
|
|
// apply to all tasks in the queue that were created using Cloud Tasks.
|
|
// Retry settings cannot be set on individual tasks.
|
|
// * For tasks created using the App Engine SDK: the queue-level retry
|
|
// settings apply to all tasks in the queue which do not have retry settings
|
|
// explicitly set on the task and were created by the App Engine SDK. See
|
|
// [App Engine
|
|
// documentation](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/retrying-tasks).
|
|
RetryConfig retry_config = 6;
|
|
|
|
// Output only. The state of the queue.
|
|
//
|
|
// `state` can only be changed by called
|
|
// [PauseQueue][google.cloud.tasks.v2beta2.CloudTasks.PauseQueue],
|
|
// [ResumeQueue][google.cloud.tasks.v2beta2.CloudTasks.ResumeQueue], or
|
|
// uploading
|
|
// [queue.yaml/xml](https://cloud.google.com/appengine/docs/python/config/queueref).
|
|
// [UpdateQueue][google.cloud.tasks.v2beta2.CloudTasks.UpdateQueue] cannot be
|
|
// used to change `state`.
|
|
State state = 7;
|
|
|
|
// Output only. The last time this queue was purged.
|
|
//
|
|
// All tasks that were [created][google.cloud.tasks.v2beta2.Task.create_time]
|
|
// before this time were purged.
|
|
//
|
|
// A queue can be purged using
|
|
// [PurgeQueue][google.cloud.tasks.v2beta2.CloudTasks.PurgeQueue], the [App
|
|
// Engine Task Queue SDK, or the Cloud
|
|
// Console](https://cloud.google.com/appengine/docs/standard/python/taskqueue/push/deleting-tasks-and-queues#purging_all_tasks_from_a_queue).
|
|
//
|
|
// Purge time will be truncated to the nearest microsecond. Purge
|
|
// time will be unset if the queue has never been purged.
|
|
google.protobuf.Timestamp purge_time = 8;
|
|
}
|
|
|
|
// Rate limits.
|
|
//
|
|
// This message determines the maximum rate that tasks can be dispatched by a
|
|
// queue, regardless of whether the dispatch is a first task attempt or a retry.
|
|
//
|
|
// Note: The debugging command,
|
|
// [RunTask][google.cloud.tasks.v2beta2.CloudTasks.RunTask], will run a task
|
|
// even if the queue has reached its
|
|
// [RateLimits][google.cloud.tasks.v2beta2.RateLimits].
|
|
message RateLimits {
|
|
// The maximum rate at which tasks are dispatched from this queue.
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
// * For [App Engine queues][google.cloud.tasks.v2beta2.AppEngineHttpTarget],
|
|
// the maximum allowed value
|
|
// is 500.
|
|
// * This field is output only for [pull
|
|
// queues][google.cloud.tasks.v2beta2.PullTarget]. In addition to the
|
|
// `max_tasks_dispatched_per_second` limit, a maximum of 10 QPS of
|
|
// [LeaseTasks][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks] requests
|
|
// are allowed per pull queue.
|
|
//
|
|
//
|
|
// This field has the same meaning as
|
|
// [rate in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#rate).
|
|
double max_tasks_dispatched_per_second = 1;
|
|
|
|
// Output only. The max burst size.
|
|
//
|
|
// Max burst size limits how fast tasks in queue are processed when
|
|
// many tasks are in the queue and the rate is high. This field
|
|
// allows the queue to have a high rate so processing starts shortly
|
|
// after a task is enqueued, but still limits resource usage when
|
|
// many tasks are enqueued in a short period of time.
|
|
//
|
|
// The [token bucket](https://wikipedia.org/wiki/Token_Bucket)
|
|
// algorithm is used to control the rate of task dispatches. Each
|
|
// queue has a token bucket that holds tokens, up to the maximum
|
|
// specified by `max_burst_size`. Each time a task is dispatched, a
|
|
// token is removed from the bucket. Tasks will be dispatched until
|
|
// the queue's bucket runs out of tokens. The bucket will be
|
|
// continuously refilled with new tokens based on
|
|
// [max_tasks_dispatched_per_second][google.cloud.tasks.v2beta2.RateLimits.max_tasks_dispatched_per_second].
|
|
//
|
|
// Cloud Tasks will pick the value of `max_burst_size` based on the
|
|
// value of
|
|
// [max_tasks_dispatched_per_second][google.cloud.tasks.v2beta2.RateLimits.max_tasks_dispatched_per_second].
|
|
//
|
|
// For App Engine queues that were created or updated using
|
|
// `queue.yaml/xml`, `max_burst_size` is equal to
|
|
// [bucket_size](https://cloud.google.com/appengine/docs/standard/python/config/queueref#bucket_size).
|
|
// Since `max_burst_size` is output only, if
|
|
// [UpdateQueue][google.cloud.tasks.v2beta2.CloudTasks.UpdateQueue] is called
|
|
// on a queue created by `queue.yaml/xml`, `max_burst_size` will be reset
|
|
// based on the value of
|
|
// [max_tasks_dispatched_per_second][google.cloud.tasks.v2beta2.RateLimits.max_tasks_dispatched_per_second],
|
|
// regardless of whether
|
|
// [max_tasks_dispatched_per_second][google.cloud.tasks.v2beta2.RateLimits.max_tasks_dispatched_per_second]
|
|
// is updated.
|
|
//
|
|
int32 max_burst_size = 2;
|
|
|
|
// The maximum number of concurrent tasks that Cloud Tasks allows
|
|
// to be dispatched for this queue. After this threshold has been
|
|
// reached, Cloud Tasks stops dispatching tasks until the number of
|
|
// concurrent requests decreases.
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
//
|
|
// The maximum allowed value is 5,000.
|
|
//
|
|
// This field is output only for
|
|
// [pull queues][google.cloud.tasks.v2beta2.PullTarget] and always -1, which
|
|
// indicates no limit. No other queue types can have `max_concurrent_tasks`
|
|
// set to -1.
|
|
//
|
|
//
|
|
// This field has the same meaning as
|
|
// [max_concurrent_requests in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#max_concurrent_requests).
|
|
int32 max_concurrent_tasks = 3;
|
|
}
|
|
|
|
// Retry config.
|
|
//
|
|
// These settings determine how a failed task attempt is retried.
|
|
message RetryConfig {
|
|
// Number of attempts per task.
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
//
|
|
//
|
|
// This field has the same meaning as
|
|
// [task_retry_limit in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
|
|
oneof num_attempts {
|
|
// The maximum number of attempts for a task.
|
|
//
|
|
// Cloud Tasks will attempt the task `max_attempts` times (that
|
|
// is, if the first attempt fails, then there will be
|
|
// `max_attempts - 1` retries). Must be > 0.
|
|
int32 max_attempts = 1;
|
|
|
|
// If true, then the number of attempts is unlimited.
|
|
bool unlimited_attempts = 2;
|
|
}
|
|
|
|
// If positive, `max_retry_duration` specifies the time limit for
|
|
// retrying a failed task, measured from when the task was first
|
|
// attempted. Once `max_retry_duration` time has passed *and* the
|
|
// task has been attempted
|
|
// [max_attempts][google.cloud.tasks.v2beta2.RetryConfig.max_attempts] times,
|
|
// no further attempts will be made and the task will be deleted.
|
|
//
|
|
// If zero, then the task age is unlimited.
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
// This field is output only for [pull
|
|
// queues][google.cloud.tasks.v2beta2.PullTarget].
|
|
//
|
|
//
|
|
// `max_retry_duration` will be truncated to the nearest second.
|
|
//
|
|
// This field has the same meaning as
|
|
// [task_age_limit in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
|
|
google.protobuf.Duration max_retry_duration = 3;
|
|
|
|
// A task will be [scheduled][google.cloud.tasks.v2beta2.Task.schedule_time]
|
|
// for retry between
|
|
// [min_backoff][google.cloud.tasks.v2beta2.RetryConfig.min_backoff] and
|
|
// [max_backoff][google.cloud.tasks.v2beta2.RetryConfig.max_backoff] duration
|
|
// after it fails, if the queue's
|
|
// [RetryConfig][google.cloud.tasks.v2beta2.RetryConfig] specifies that the
|
|
// task should be retried.
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
// This field is output only for [pull
|
|
// queues][google.cloud.tasks.v2beta2.PullTarget].
|
|
//
|
|
//
|
|
// `min_backoff` will be truncated to the nearest second.
|
|
//
|
|
// This field has the same meaning as
|
|
// [min_backoff_seconds in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
|
|
google.protobuf.Duration min_backoff = 4;
|
|
|
|
// A task will be [scheduled][google.cloud.tasks.v2beta2.Task.schedule_time]
|
|
// for retry between
|
|
// [min_backoff][google.cloud.tasks.v2beta2.RetryConfig.min_backoff] and
|
|
// [max_backoff][google.cloud.tasks.v2beta2.RetryConfig.max_backoff] duration
|
|
// after it fails, if the queue's
|
|
// [RetryConfig][google.cloud.tasks.v2beta2.RetryConfig] specifies that the
|
|
// task should be retried.
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
// This field is output only for [pull
|
|
// queues][google.cloud.tasks.v2beta2.PullTarget].
|
|
//
|
|
//
|
|
// `max_backoff` will be truncated to the nearest second.
|
|
//
|
|
// This field has the same meaning as
|
|
// [max_backoff_seconds in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
|
|
google.protobuf.Duration max_backoff = 5;
|
|
|
|
// The time between retries will double `max_doublings` times.
|
|
//
|
|
// A task's retry interval starts at
|
|
// [min_backoff][google.cloud.tasks.v2beta2.RetryConfig.min_backoff], then
|
|
// doubles `max_doublings` times, then increases linearly, and finally retries
|
|
// retries at intervals of
|
|
// [max_backoff][google.cloud.tasks.v2beta2.RetryConfig.max_backoff] up to
|
|
// [max_attempts][google.cloud.tasks.v2beta2.RetryConfig.max_attempts] times.
|
|
//
|
|
// For example, if
|
|
// [min_backoff][google.cloud.tasks.v2beta2.RetryConfig.min_backoff] is 10s,
|
|
// [max_backoff][google.cloud.tasks.v2beta2.RetryConfig.max_backoff] is 300s,
|
|
// and `max_doublings` is 3, then the a task will first be retried in 10s. The
|
|
// retry interval will double three times, and then increase linearly by 2^3 *
|
|
// 10s. Finally, the task will retry at intervals of
|
|
// [max_backoff][google.cloud.tasks.v2beta2.RetryConfig.max_backoff] until the
|
|
// task has been attempted
|
|
// [max_attempts][google.cloud.tasks.v2beta2.RetryConfig.max_attempts] times.
|
|
// Thus, the requests will retry at 10s, 20s, 40s, 80s, 160s, 240s, 300s,
|
|
// 300s, ....
|
|
//
|
|
// If unspecified when the queue is created, Cloud Tasks will pick the
|
|
// default.
|
|
//
|
|
// This field is output only for [pull
|
|
// queues][google.cloud.tasks.v2beta2.PullTarget].
|
|
//
|
|
//
|
|
// This field has the same meaning as
|
|
// [max_doublings in
|
|
// queue.yaml/xml](https://cloud.google.com/appengine/docs/standard/python/config/queueref#retry_parameters).
|
|
int32 max_doublings = 6;
|
|
}
|
|
|