mirror of
https://github.com/temporalio/temporal.git
synced 2026-08-31 02:51:51 -07:00
7709660eed
## What changed? Include backlog counts (quanitzed) in partition scale state and info, and use them in simple scaler. ## Why? Scaling based on large backlogs, and later load balancing based on backlog too. ## How did you test it? - [ ] built - [ ] run locally and tested manually - [ ] covered by existing tests - [x] added new unit test(s) - [x] added new functional test(s)
1364 lines
52 KiB
Go
1364 lines
52 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// plugins:
|
|
// protoc-gen-go
|
|
// protoc
|
|
// source: temporal/server/api/taskqueue/v1/message.proto
|
|
|
|
package taskqueue
|
|
|
|
import (
|
|
reflect "reflect"
|
|
sync "sync"
|
|
unsafe "unsafe"
|
|
|
|
v11 "go.temporal.io/api/deployment/v1"
|
|
v1 "go.temporal.io/api/enums/v1"
|
|
v13 "go.temporal.io/api/taskqueue/v1"
|
|
v12 "go.temporal.io/server/api/deployment/v1"
|
|
v14 "go.temporal.io/server/api/enums/v1"
|
|
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
|
|
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
|
|
emptypb "google.golang.org/protobuf/types/known/emptypb"
|
|
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
|
|
)
|
|
|
|
const (
|
|
// Verify that this generated code is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
|
|
// Verify that runtime/protoimpl is sufficiently up-to-date.
|
|
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
|
|
)
|
|
|
|
// TaskVersionDirective controls how matching should direct a task.
|
|
type TaskVersionDirective struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Default (if build_id is not present) is "unversioned":
|
|
// Use the unversioned task queue, even if the task queue has versioning data.
|
|
// Absent value means the task is the non-starting task of an unversioned execution so it should remain unversioned.
|
|
// Deprecated. Use deployment_version.
|
|
//
|
|
// Types that are valid to be assigned to BuildId:
|
|
//
|
|
// *TaskVersionDirective_UseAssignmentRules
|
|
// *TaskVersionDirective_AssignedBuildId
|
|
BuildId isTaskVersionDirective_BuildId `protobuf_oneof:"build_id"`
|
|
// Workflow's effective behavior when the task is scheduled.
|
|
Behavior v1.VersioningBehavior `protobuf:"varint,3,opt,name=behavior,proto3,enum=temporal.api.enums.v1.VersioningBehavior" json:"behavior,omitempty"`
|
|
// Workflow's effective deployment when the task is scheduled.
|
|
// Deprecated. Use deployment_version.
|
|
Deployment *v11.Deployment `protobuf:"bytes,4,opt,name=deployment,proto3" json:"deployment,omitempty"`
|
|
// Workflow's effective deployment version when the task is scheduled.
|
|
DeploymentVersion *v12.WorkerDeploymentVersion `protobuf:"bytes,5,opt,name=deployment_version,json=deploymentVersion,proto3" json:"deployment_version,omitempty"`
|
|
// Counter copied from the workflow execution's WorkflowExecutionVersioningInfo
|
|
// during enqueue time.
|
|
RevisionNumber int64 `protobuf:"varint,6,opt,name=revision_number,json=revisionNumber,proto3" json:"revision_number,omitempty"`
|
|
// If behavior is AutoUpgrade and use_ramping_version is true, then this task should use the
|
|
// Ramping Version of its Task Queue regardless of workflow_id and ramp_percentage.
|
|
// If there is no Ramping Version at the time of task dispatch, the Current Version will be used instead.
|
|
//
|
|
// If use_ramping_version is false, the Target Version is chosen with the default formula:
|
|
//
|
|
// if calcRampThreshold(workflow_id) <= ramp_percentage:
|
|
// target=ramping_version
|
|
// else:
|
|
// target=current_version
|
|
UseRampingVersion bool `protobuf:"varint,7,opt,name=use_ramping_version,json=useRampingVersion,proto3" json:"use_ramping_version,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TaskVersionDirective) Reset() {
|
|
*x = TaskVersionDirective{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TaskVersionDirective) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TaskVersionDirective) ProtoMessage() {}
|
|
|
|
func (x *TaskVersionDirective) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TaskVersionDirective.ProtoReflect.Descriptor instead.
|
|
func (*TaskVersionDirective) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{0}
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetBuildId() isTaskVersionDirective_BuildId {
|
|
if x != nil {
|
|
return x.BuildId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetUseAssignmentRules() *emptypb.Empty {
|
|
if x != nil {
|
|
if x, ok := x.BuildId.(*TaskVersionDirective_UseAssignmentRules); ok {
|
|
return x.UseAssignmentRules
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetAssignedBuildId() string {
|
|
if x != nil {
|
|
if x, ok := x.BuildId.(*TaskVersionDirective_AssignedBuildId); ok {
|
|
return x.AssignedBuildId
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetBehavior() v1.VersioningBehavior {
|
|
if x != nil {
|
|
return x.Behavior
|
|
}
|
|
return v1.VersioningBehavior(0)
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetDeployment() *v11.Deployment {
|
|
if x != nil {
|
|
return x.Deployment
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetDeploymentVersion() *v12.WorkerDeploymentVersion {
|
|
if x != nil {
|
|
return x.DeploymentVersion
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetRevisionNumber() int64 {
|
|
if x != nil {
|
|
return x.RevisionNumber
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *TaskVersionDirective) GetUseRampingVersion() bool {
|
|
if x != nil {
|
|
return x.UseRampingVersion
|
|
}
|
|
return false
|
|
}
|
|
|
|
type isTaskVersionDirective_BuildId interface {
|
|
isTaskVersionDirective_BuildId()
|
|
}
|
|
|
|
type TaskVersionDirective_UseAssignmentRules struct {
|
|
// If use_assignment_rules is present, matching should use the assignment rules
|
|
// to determine the build ID.
|
|
// WV1: the task should be assigned the default version for the task queue. [cleanup-old-wv]
|
|
UseAssignmentRules *emptypb.Empty `protobuf:"bytes,1,opt,name=use_assignment_rules,json=useAssignmentRules,proto3,oneof"`
|
|
}
|
|
|
|
type TaskVersionDirective_AssignedBuildId struct {
|
|
// This means the task is already assigned to `build_id`
|
|
// WV1: If assigned_build_id is present, use the default version in the compatible set
|
|
// containing this build ID. [cleanup-old-wv]
|
|
AssignedBuildId string `protobuf:"bytes,2,opt,name=assigned_build_id,json=assignedBuildId,proto3,oneof"`
|
|
}
|
|
|
|
func (*TaskVersionDirective_UseAssignmentRules) isTaskVersionDirective_BuildId() {}
|
|
|
|
func (*TaskVersionDirective_AssignedBuildId) isTaskVersionDirective_BuildId() {}
|
|
|
|
type FairLevel struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
TaskPass int64 `protobuf:"varint,1,opt,name=task_pass,json=taskPass,proto3" json:"task_pass,omitempty"`
|
|
TaskId int64 `protobuf:"varint,2,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *FairLevel) Reset() {
|
|
*x = FairLevel{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[1]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *FairLevel) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*FairLevel) ProtoMessage() {}
|
|
|
|
func (x *FairLevel) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[1]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use FairLevel.ProtoReflect.Descriptor instead.
|
|
func (*FairLevel) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{1}
|
|
}
|
|
|
|
func (x *FairLevel) GetTaskPass() int64 {
|
|
if x != nil {
|
|
return x.TaskPass
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *FairLevel) GetTaskId() int64 {
|
|
if x != nil {
|
|
return x.TaskId
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type InternalTaskQueueStatus struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
ReadLevel int64 `protobuf:"varint,1,opt,name=read_level,json=readLevel,proto3" json:"read_level,omitempty"`
|
|
FairReadLevel *FairLevel `protobuf:"bytes,7,opt,name=fair_read_level,json=fairReadLevel,proto3" json:"fair_read_level,omitempty"`
|
|
AckLevel int64 `protobuf:"varint,2,opt,name=ack_level,json=ackLevel,proto3" json:"ack_level,omitempty"`
|
|
FairAckLevel *FairLevel `protobuf:"bytes,8,opt,name=fair_ack_level,json=fairAckLevel,proto3" json:"fair_ack_level,omitempty"`
|
|
TaskIdBlock *v13.TaskIdBlock `protobuf:"bytes,3,opt,name=task_id_block,json=taskIdBlock,proto3" json:"task_id_block,omitempty"`
|
|
LoadedTasks int64 `protobuf:"varint,4,opt,name=loaded_tasks,json=loadedTasks,proto3" json:"loaded_tasks,omitempty"`
|
|
ApproximateBacklogCount int64 `protobuf:"varint,5,opt,name=approximate_backlog_count,json=approximateBacklogCount,proto3" json:"approximate_backlog_count,omitempty"`
|
|
MaxReadLevel int64 `protobuf:"varint,6,opt,name=max_read_level,json=maxReadLevel,proto3" json:"max_read_level,omitempty"`
|
|
FairMaxReadLevel *FairLevel `protobuf:"bytes,9,opt,name=fair_max_read_level,json=fairMaxReadLevel,proto3" json:"fair_max_read_level,omitempty"`
|
|
// Draining means that this status is from a queue that is being drained to
|
|
// migrate from v1 to v2 tasks persistence (or backwards).
|
|
Draining bool `protobuf:"varint,10,opt,name=draining,proto3" json:"draining,omitempty"`
|
|
// BacklogDrained means this queue has an empty backlog at the time this status
|
|
// was generated. This is inherently racy — new tasks may arrive after this
|
|
// check. Consumers must use version-based validation (see scaleManager) to
|
|
// ensure correctness.
|
|
BacklogDrained bool `protobuf:"varint,11,opt,name=backlog_drained,json=backlogDrained,proto3" json:"backlog_drained,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) Reset() {
|
|
*x = InternalTaskQueueStatus{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[2]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*InternalTaskQueueStatus) ProtoMessage() {}
|
|
|
|
func (x *InternalTaskQueueStatus) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[2]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use InternalTaskQueueStatus.ProtoReflect.Descriptor instead.
|
|
func (*InternalTaskQueueStatus) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{2}
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetReadLevel() int64 {
|
|
if x != nil {
|
|
return x.ReadLevel
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetFairReadLevel() *FairLevel {
|
|
if x != nil {
|
|
return x.FairReadLevel
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetAckLevel() int64 {
|
|
if x != nil {
|
|
return x.AckLevel
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetFairAckLevel() *FairLevel {
|
|
if x != nil {
|
|
return x.FairAckLevel
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetTaskIdBlock() *v13.TaskIdBlock {
|
|
if x != nil {
|
|
return x.TaskIdBlock
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetLoadedTasks() int64 {
|
|
if x != nil {
|
|
return x.LoadedTasks
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetApproximateBacklogCount() int64 {
|
|
if x != nil {
|
|
return x.ApproximateBacklogCount
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetMaxReadLevel() int64 {
|
|
if x != nil {
|
|
return x.MaxReadLevel
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetFairMaxReadLevel() *FairLevel {
|
|
if x != nil {
|
|
return x.FairMaxReadLevel
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetDraining() bool {
|
|
if x != nil {
|
|
return x.Draining
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (x *InternalTaskQueueStatus) GetBacklogDrained() bool {
|
|
if x != nil {
|
|
return x.BacklogDrained
|
|
}
|
|
return false
|
|
}
|
|
|
|
type TaskQueueVersionInfoInternal struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
PhysicalTaskQueueInfo *PhysicalTaskQueueInfo `protobuf:"bytes,2,opt,name=physical_task_queue_info,json=physicalTaskQueueInfo,proto3" json:"physical_task_queue_info,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TaskQueueVersionInfoInternal) Reset() {
|
|
*x = TaskQueueVersionInfoInternal{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[3]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TaskQueueVersionInfoInternal) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TaskQueueVersionInfoInternal) ProtoMessage() {}
|
|
|
|
func (x *TaskQueueVersionInfoInternal) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[3]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TaskQueueVersionInfoInternal.ProtoReflect.Descriptor instead.
|
|
func (*TaskQueueVersionInfoInternal) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{3}
|
|
}
|
|
|
|
func (x *TaskQueueVersionInfoInternal) GetPhysicalTaskQueueInfo() *PhysicalTaskQueueInfo {
|
|
if x != nil {
|
|
return x.PhysicalTaskQueueInfo
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type PhysicalTaskQueueInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Unversioned workers (with `useVersioning=false`) are reported in unversioned result even if they set a Build ID.
|
|
Pollers []*v13.PollerInfo `protobuf:"bytes,1,rep,name=pollers,proto3" json:"pollers,omitempty"`
|
|
InternalTaskQueueStatus []*InternalTaskQueueStatus `protobuf:"bytes,3,rep,name=internal_task_queue_status,json=internalTaskQueueStatus,proto3" json:"internal_task_queue_status,omitempty"`
|
|
TaskQueueStats *v13.TaskQueueStats `protobuf:"bytes,2,opt,name=task_queue_stats,json=taskQueueStats,proto3" json:"task_queue_stats,omitempty"`
|
|
// (-- api-linter: core::0140::prepositions=disabled
|
|
//
|
|
// aip.dev/not-precedent: "by" is used to clarify the keys. --)
|
|
TaskQueueStatsByPriorityKey map[int32]*v13.TaskQueueStats `protobuf:"bytes,4,rep,name=task_queue_stats_by_priority_key,json=taskQueueStatsByPriorityKey,proto3" json:"task_queue_stats_by_priority_key,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PhysicalTaskQueueInfo) Reset() {
|
|
*x = PhysicalTaskQueueInfo{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[4]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PhysicalTaskQueueInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PhysicalTaskQueueInfo) ProtoMessage() {}
|
|
|
|
func (x *PhysicalTaskQueueInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[4]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PhysicalTaskQueueInfo.ProtoReflect.Descriptor instead.
|
|
func (*PhysicalTaskQueueInfo) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{4}
|
|
}
|
|
|
|
func (x *PhysicalTaskQueueInfo) GetPollers() []*v13.PollerInfo {
|
|
if x != nil {
|
|
return x.Pollers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PhysicalTaskQueueInfo) GetInternalTaskQueueStatus() []*InternalTaskQueueStatus {
|
|
if x != nil {
|
|
return x.InternalTaskQueueStatus
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PhysicalTaskQueueInfo) GetTaskQueueStats() *v13.TaskQueueStats {
|
|
if x != nil {
|
|
return x.TaskQueueStats
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PhysicalTaskQueueInfo) GetTaskQueueStatsByPriorityKey() map[int32]*v13.TaskQueueStats {
|
|
if x != nil {
|
|
return x.TaskQueueStatsByPriorityKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Internal representation of a task queue partition, used for server-to-server RPCs.
|
|
// This is the internal equivalent of temporal.api.taskqueue.v1.TaskQueue.
|
|
type TaskQueuePartition struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// This is the user-facing name for this task queue
|
|
TaskQueue string `protobuf:"bytes,1,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"`
|
|
TaskQueueType v1.TaskQueueType `protobuf:"varint,2,opt,name=task_queue_type,json=taskQueueType,proto3,enum=temporal.api.enums.v1.TaskQueueType" json:"task_queue_type,omitempty"`
|
|
// Absent means normal root partition (normal_partition_id=0)
|
|
//
|
|
// Types that are valid to be assigned to PartitionId:
|
|
//
|
|
// *TaskQueuePartition_NormalPartitionId
|
|
// *TaskQueuePartition_StickyName
|
|
// *TaskQueuePartition_WorkerCommands
|
|
PartitionId isTaskQueuePartition_PartitionId `protobuf_oneof:"partition_id"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TaskQueuePartition) Reset() {
|
|
*x = TaskQueuePartition{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TaskQueuePartition) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TaskQueuePartition) ProtoMessage() {}
|
|
|
|
func (x *TaskQueuePartition) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TaskQueuePartition.ProtoReflect.Descriptor instead.
|
|
func (*TaskQueuePartition) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{5}
|
|
}
|
|
|
|
func (x *TaskQueuePartition) GetTaskQueue() string {
|
|
if x != nil {
|
|
return x.TaskQueue
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TaskQueuePartition) GetTaskQueueType() v1.TaskQueueType {
|
|
if x != nil {
|
|
return x.TaskQueueType
|
|
}
|
|
return v1.TaskQueueType(0)
|
|
}
|
|
|
|
func (x *TaskQueuePartition) GetPartitionId() isTaskQueuePartition_PartitionId {
|
|
if x != nil {
|
|
return x.PartitionId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskQueuePartition) GetNormalPartitionId() int32 {
|
|
if x != nil {
|
|
if x, ok := x.PartitionId.(*TaskQueuePartition_NormalPartitionId); ok {
|
|
return x.NormalPartitionId
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *TaskQueuePartition) GetStickyName() string {
|
|
if x != nil {
|
|
if x, ok := x.PartitionId.(*TaskQueuePartition_StickyName); ok {
|
|
return x.StickyName
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TaskQueuePartition) GetWorkerCommands() *WorkerCommandsPartitionId {
|
|
if x != nil {
|
|
if x, ok := x.PartitionId.(*TaskQueuePartition_WorkerCommands); ok {
|
|
return x.WorkerCommands
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type isTaskQueuePartition_PartitionId interface {
|
|
isTaskQueuePartition_PartitionId()
|
|
}
|
|
|
|
type TaskQueuePartition_NormalPartitionId struct {
|
|
NormalPartitionId int32 `protobuf:"varint,3,opt,name=normal_partition_id,json=normalPartitionId,proto3,oneof"`
|
|
}
|
|
|
|
type TaskQueuePartition_StickyName struct {
|
|
StickyName string `protobuf:"bytes,4,opt,name=sticky_name,json=stickyName,proto3,oneof"`
|
|
}
|
|
|
|
type TaskQueuePartition_WorkerCommands struct {
|
|
WorkerCommands *WorkerCommandsPartitionId `protobuf:"bytes,5,opt,name=worker_commands,json=workerCommands,proto3,oneof"`
|
|
}
|
|
|
|
func (*TaskQueuePartition_NormalPartitionId) isTaskQueuePartition_PartitionId() {}
|
|
|
|
func (*TaskQueuePartition_StickyName) isTaskQueuePartition_PartitionId() {}
|
|
|
|
func (*TaskQueuePartition_WorkerCommands) isTaskQueuePartition_PartitionId() {}
|
|
|
|
type WorkerCommandsPartitionId struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *WorkerCommandsPartitionId) Reset() {
|
|
*x = WorkerCommandsPartitionId{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[6]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *WorkerCommandsPartitionId) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*WorkerCommandsPartitionId) ProtoMessage() {}
|
|
|
|
func (x *WorkerCommandsPartitionId) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[6]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use WorkerCommandsPartitionId.ProtoReflect.Descriptor instead.
|
|
func (*WorkerCommandsPartitionId) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{6}
|
|
}
|
|
|
|
// Information about redirect intention sent by Matching to History in Record*TaskStarted calls.
|
|
// Deprecated.
|
|
type BuildIdRedirectInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// build ID asked by History in the directive or the one calculated based on the assignment rules.
|
|
// this is the source of the redirect rule chain applied. (the target of the redirect rule chain is
|
|
// the poller's build ID reported in WorkerVersionCapabilities)
|
|
AssignedBuildId string `protobuf:"bytes,1,opt,name=assigned_build_id,json=assignedBuildId,proto3" json:"assigned_build_id,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *BuildIdRedirectInfo) Reset() {
|
|
*x = BuildIdRedirectInfo{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[7]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *BuildIdRedirectInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*BuildIdRedirectInfo) ProtoMessage() {}
|
|
|
|
func (x *BuildIdRedirectInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[7]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use BuildIdRedirectInfo.ProtoReflect.Descriptor instead.
|
|
func (*BuildIdRedirectInfo) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{7}
|
|
}
|
|
|
|
func (x *BuildIdRedirectInfo) GetAssignedBuildId() string {
|
|
if x != nil {
|
|
return x.AssignedBuildId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Information about task forwarding from one partition to its parent.
|
|
type TaskForwardInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// RPC name of the partition forwarded the task.
|
|
// In case of multiple hops, this is the source partition of the last hop.
|
|
SourcePartition string `protobuf:"bytes,1,opt,name=source_partition,json=sourcePartition,proto3" json:"source_partition,omitempty"`
|
|
TaskSource v14.TaskSource `protobuf:"varint,2,opt,name=task_source,json=taskSource,proto3,enum=temporal.server.api.enums.v1.TaskSource" json:"task_source,omitempty"`
|
|
// The partition where the task was initially forwarded from.
|
|
// Unlike source_partition which gets overwritten at each hop, origin_partition
|
|
// persists across all forwarding hops.
|
|
OriginPartition string `protobuf:"bytes,6,opt,name=origin_partition,json=originPartition,proto3" json:"origin_partition,omitempty"`
|
|
// For tasks that are forwarded, we should keep the original creation time that comes from the
|
|
// source partition. Used for dispatch latency metrics.
|
|
CreateTime *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
|
|
// Redirect info is not present for Query and Nexus tasks. Versioning decisions for activity/workflow
|
|
// tasks are made at the source partition and sent to the parent partition in this message so that parent partition
|
|
// does not have to make versioning decision again. For Query/Nexus tasks, this works differently as the child's
|
|
// versioning decision is ignored and the parent partition makes a fresh decision.
|
|
// Deprecated. [cleanup-old-wv]
|
|
RedirectInfo *BuildIdRedirectInfo `protobuf:"bytes,3,opt,name=redirect_info,json=redirectInfo,proto3" json:"redirect_info,omitempty"`
|
|
// Build ID that should be used to dispatch the task to. Ignored in Query and Nexus tasks.
|
|
// Deprecated. [cleanup-old-wv]
|
|
DispatchBuildId string `protobuf:"bytes,4,opt,name=dispatch_build_id,json=dispatchBuildId,proto3" json:"dispatch_build_id,omitempty"`
|
|
// Only used for old versioning. [cleanup-old-wv]
|
|
// Deprecated. [cleanup-old-wv]
|
|
DispatchVersionSet string `protobuf:"bytes,5,opt,name=dispatch_version_set,json=dispatchVersionSet,proto3" json:"dispatch_version_set,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *TaskForwardInfo) Reset() {
|
|
*x = TaskForwardInfo{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[8]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *TaskForwardInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*TaskForwardInfo) ProtoMessage() {}
|
|
|
|
func (x *TaskForwardInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[8]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use TaskForwardInfo.ProtoReflect.Descriptor instead.
|
|
func (*TaskForwardInfo) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{8}
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetSourcePartition() string {
|
|
if x != nil {
|
|
return x.SourcePartition
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetTaskSource() v14.TaskSource {
|
|
if x != nil {
|
|
return x.TaskSource
|
|
}
|
|
return v14.TaskSource(0)
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetOriginPartition() string {
|
|
if x != nil {
|
|
return x.OriginPartition
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetCreateTime() *timestamppb.Timestamp {
|
|
if x != nil {
|
|
return x.CreateTime
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetRedirectInfo() *BuildIdRedirectInfo {
|
|
if x != nil {
|
|
return x.RedirectInfo
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetDispatchBuildId() string {
|
|
if x != nil {
|
|
return x.DispatchBuildId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (x *TaskForwardInfo) GetDispatchVersionSet() string {
|
|
if x != nil {
|
|
return x.DispatchVersionSet
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// EphemeralData is data that we want to propagate among task queue partitions, but is not persisted.
|
|
// Ephemeral data is propagated alongside "task queue user data", but while user data applies to a
|
|
// task queue family (all queues with the same name, across types), ephemeral data applies only to
|
|
// one type at a time.
|
|
type EphemeralData struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Partition []*EphemeralData_ByPartition `protobuf:"bytes,1,rep,name=partition,proto3" json:"partition,omitempty"`
|
|
// Current state of dynamic partition scaling
|
|
Scale *PartitionScaleInfo `protobuf:"bytes,2,opt,name=scale,proto3" json:"scale,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *EphemeralData) Reset() {
|
|
*x = EphemeralData{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[9]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *EphemeralData) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*EphemeralData) ProtoMessage() {}
|
|
|
|
func (x *EphemeralData) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[9]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use EphemeralData.ProtoReflect.Descriptor instead.
|
|
func (*EphemeralData) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{9}
|
|
}
|
|
|
|
func (x *EphemeralData) GetPartition() []*EphemeralData_ByPartition {
|
|
if x != nil {
|
|
return x.Partition
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *EphemeralData) GetScale() *PartitionScaleInfo {
|
|
if x != nil {
|
|
return x.Scale
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type VersionedEphemeralData struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Data *EphemeralData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
|
|
Version int64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *VersionedEphemeralData) Reset() {
|
|
*x = VersionedEphemeralData{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[10]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *VersionedEphemeralData) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*VersionedEphemeralData) ProtoMessage() {}
|
|
|
|
func (x *VersionedEphemeralData) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[10]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use VersionedEphemeralData.ProtoReflect.Descriptor instead.
|
|
func (*VersionedEphemeralData) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{10}
|
|
}
|
|
|
|
func (x *VersionedEphemeralData) GetData() *EphemeralData {
|
|
if x != nil {
|
|
return x.Data
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *VersionedEphemeralData) GetVersion() int64 {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// PartitionScaleInfo is propagated among task queue partitions in ephemeral data.
|
|
type PartitionScaleInfo struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Read int32 `protobuf:"varint,1,opt,name=read,proto3" json:"read,omitempty"`
|
|
Write int32 `protobuf:"varint,2,opt,name=write,proto3" json:"write,omitempty"`
|
|
// Backlog counts per partition, 8 bits per partition (see common/number/compact8.go).
|
|
BacklogCounts []byte `protobuf:"bytes,3,opt,name=backlog_counts,json=backlogCounts,proto3" json:"backlog_counts,omitempty"`
|
|
// Backlog load balancing config from scaler, in compact8 format.
|
|
BacklogCap int32 `protobuf:"varint,4,opt,name=backlog_cap,json=backlogCap,proto3" json:"backlog_cap,omitempty"`
|
|
// version identifies a specific version of the scale state, which changes when the target
|
|
// number of partitions (i.e. the write count) changes. It may not change for other changes
|
|
// to scale state/info. This is used by the scale manager to know that a partition is
|
|
// operating with the latest scale info, to avoid ABA problems, i.e. to differentiate from a
|
|
// previous version whose read and write counts happen to be the same numbers.
|
|
Version int64 `protobuf:"fixed64,10,opt,name=version,proto3" json:"version,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) Reset() {
|
|
*x = PartitionScaleInfo{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[11]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*PartitionScaleInfo) ProtoMessage() {}
|
|
|
|
func (x *PartitionScaleInfo) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[11]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use PartitionScaleInfo.ProtoReflect.Descriptor instead.
|
|
func (*PartitionScaleInfo) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{11}
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) GetRead() int32 {
|
|
if x != nil {
|
|
return x.Read
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) GetWrite() int32 {
|
|
if x != nil {
|
|
return x.Write
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) GetBacklogCounts() []byte {
|
|
if x != nil {
|
|
return x.BacklogCounts
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) GetBacklogCap() int32 {
|
|
if x != nil {
|
|
return x.BacklogCap
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *PartitionScaleInfo) GetVersion() int64 {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// ClientPartitionCounts is propagated from the matching service to clients in grpc headers/trailers.
|
|
// It may be a subset of PartitionScaleInfo.
|
|
type ClientPartitionCounts struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Read int32 `protobuf:"varint,1,opt,name=read,proto3" json:"read,omitempty"`
|
|
Write int32 `protobuf:"varint,2,opt,name=write,proto3" json:"write,omitempty"`
|
|
// Backlog counts per partition, 8 bits per partition (see common/number/compact8.go).
|
|
BacklogCount []byte `protobuf:"bytes,3,opt,name=backlog_count,json=backlogCount,proto3" json:"backlog_count,omitempty"`
|
|
// Backlog load balancing config from scaler, in compact8 format.
|
|
BacklogCap int32 `protobuf:"varint,4,opt,name=backlog_cap,json=backlogCap,proto3" json:"backlog_cap,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *ClientPartitionCounts) Reset() {
|
|
*x = ClientPartitionCounts{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[12]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *ClientPartitionCounts) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*ClientPartitionCounts) ProtoMessage() {}
|
|
|
|
func (x *ClientPartitionCounts) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[12]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use ClientPartitionCounts.ProtoReflect.Descriptor instead.
|
|
func (*ClientPartitionCounts) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{12}
|
|
}
|
|
|
|
func (x *ClientPartitionCounts) GetRead() int32 {
|
|
if x != nil {
|
|
return x.Read
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ClientPartitionCounts) GetWrite() int32 {
|
|
if x != nil {
|
|
return x.Write
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *ClientPartitionCounts) GetBacklogCount() []byte {
|
|
if x != nil {
|
|
return x.BacklogCount
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *ClientPartitionCounts) GetBacklogCap() int32 {
|
|
if x != nil {
|
|
return x.BacklogCap
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type EphemeralData_ByVersion struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
// Key for this data. Data for the unversioned queue has no version field present.
|
|
// All following fields are data associated with this versioned queue.
|
|
Version *v12.WorkerDeploymentVersion `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
|
|
// This is a bit field of priority levels that have "significant" backlog (defined by
|
|
// the server configuration). Priority key k corresponds to 1<<k.
|
|
BacklogPriorityLevels int64 `protobuf:"varint,2,opt,name=backlog_priority_levels,json=backlogPriorityLevels,proto3" json:"backlog_priority_levels,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *EphemeralData_ByVersion) Reset() {
|
|
*x = EphemeralData_ByVersion{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[14]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *EphemeralData_ByVersion) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*EphemeralData_ByVersion) ProtoMessage() {}
|
|
|
|
func (x *EphemeralData_ByVersion) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[14]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use EphemeralData_ByVersion.ProtoReflect.Descriptor instead.
|
|
func (*EphemeralData_ByVersion) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{9, 0}
|
|
}
|
|
|
|
func (x *EphemeralData_ByVersion) GetVersion() *v12.WorkerDeploymentVersion {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (x *EphemeralData_ByVersion) GetBacklogPriorityLevels() int64 {
|
|
if x != nil {
|
|
return x.BacklogPriorityLevels
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type EphemeralData_ByPartition struct {
|
|
state protoimpl.MessageState `protogen:"open.v1"`
|
|
Partition int32 `protobuf:"varint,1,opt,name=partition,proto3" json:"partition,omitempty"`
|
|
Version []*EphemeralData_ByVersion `protobuf:"bytes,2,rep,name=version,proto3" json:"version,omitempty"`
|
|
unknownFields protoimpl.UnknownFields
|
|
sizeCache protoimpl.SizeCache
|
|
}
|
|
|
|
func (x *EphemeralData_ByPartition) Reset() {
|
|
*x = EphemeralData_ByPartition{}
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[15]
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
|
|
func (x *EphemeralData_ByPartition) String() string {
|
|
return protoimpl.X.MessageStringOf(x)
|
|
}
|
|
|
|
func (*EphemeralData_ByPartition) ProtoMessage() {}
|
|
|
|
func (x *EphemeralData_ByPartition) ProtoReflect() protoreflect.Message {
|
|
mi := &file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[15]
|
|
if x != nil {
|
|
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
|
if ms.LoadMessageInfo() == nil {
|
|
ms.StoreMessageInfo(mi)
|
|
}
|
|
return ms
|
|
}
|
|
return mi.MessageOf(x)
|
|
}
|
|
|
|
// Deprecated: Use EphemeralData_ByPartition.ProtoReflect.Descriptor instead.
|
|
func (*EphemeralData_ByPartition) Descriptor() ([]byte, []int) {
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP(), []int{9, 1}
|
|
}
|
|
|
|
func (x *EphemeralData_ByPartition) GetPartition() int32 {
|
|
if x != nil {
|
|
return x.Partition
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (x *EphemeralData_ByPartition) GetVersion() []*EphemeralData_ByVersion {
|
|
if x != nil {
|
|
return x.Version
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var File_temporal_server_api_taskqueue_v1_message_proto protoreflect.FileDescriptor
|
|
|
|
const file_temporal_server_api_taskqueue_v1_message_proto_rawDesc = "" +
|
|
"\n" +
|
|
".temporal/server/api/taskqueue/v1/message.proto\x12 temporal.server.api.taskqueue.v1\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a(temporal/api/deployment/v1/message.proto\x1a&temporal/api/enums/v1/task_queue.proto\x1a$temporal/api/enums/v1/workflow.proto\x1a'temporal/api/taskqueue/v1/message.proto\x1a/temporal/server/api/deployment/v1/message.proto\x1a'temporal/server/api/enums/v1/task.proto\"\xef\x03\n" +
|
|
"\x14TaskVersionDirective\x12J\n" +
|
|
"\x14use_assignment_rules\x18\x01 \x01(\v2\x16.google.protobuf.EmptyH\x00R\x12useAssignmentRules\x12,\n" +
|
|
"\x11assigned_build_id\x18\x02 \x01(\tH\x00R\x0fassignedBuildId\x12E\n" +
|
|
"\bbehavior\x18\x03 \x01(\x0e2).temporal.api.enums.v1.VersioningBehaviorR\bbehavior\x12F\n" +
|
|
"\n" +
|
|
"deployment\x18\x04 \x01(\v2&.temporal.api.deployment.v1.DeploymentR\n" +
|
|
"deployment\x12i\n" +
|
|
"\x12deployment_version\x18\x05 \x01(\v2:.temporal.server.api.deployment.v1.WorkerDeploymentVersionR\x11deploymentVersion\x12'\n" +
|
|
"\x0frevision_number\x18\x06 \x01(\x03R\x0erevisionNumber\x12.\n" +
|
|
"\x13use_ramping_version\x18\a \x01(\bR\x11useRampingVersionB\n" +
|
|
"\n" +
|
|
"\bbuild_id\"A\n" +
|
|
"\tFairLevel\x12\x1b\n" +
|
|
"\ttask_pass\x18\x01 \x01(\x03R\btaskPass\x12\x17\n" +
|
|
"\atask_id\x18\x02 \x01(\x03R\x06taskId\"\xef\x04\n" +
|
|
"\x17InternalTaskQueueStatus\x12\x1d\n" +
|
|
"\n" +
|
|
"read_level\x18\x01 \x01(\x03R\treadLevel\x12S\n" +
|
|
"\x0ffair_read_level\x18\a \x01(\v2+.temporal.server.api.taskqueue.v1.FairLevelR\rfairReadLevel\x12\x1b\n" +
|
|
"\tack_level\x18\x02 \x01(\x03R\backLevel\x12Q\n" +
|
|
"\x0efair_ack_level\x18\b \x01(\v2+.temporal.server.api.taskqueue.v1.FairLevelR\ffairAckLevel\x12J\n" +
|
|
"\rtask_id_block\x18\x03 \x01(\v2&.temporal.api.taskqueue.v1.TaskIdBlockR\vtaskIdBlock\x12!\n" +
|
|
"\floaded_tasks\x18\x04 \x01(\x03R\vloadedTasks\x12:\n" +
|
|
"\x19approximate_backlog_count\x18\x05 \x01(\x03R\x17approximateBacklogCount\x12$\n" +
|
|
"\x0emax_read_level\x18\x06 \x01(\x03R\fmaxReadLevel\x12Z\n" +
|
|
"\x13fair_max_read_level\x18\t \x01(\v2+.temporal.server.api.taskqueue.v1.FairLevelR\x10fairMaxReadLevel\x12\x1a\n" +
|
|
"\bdraining\x18\n" +
|
|
" \x01(\bR\bdraining\x12'\n" +
|
|
"\x0fbacklog_drained\x18\v \x01(\bR\x0ebacklogDrained\"\x90\x01\n" +
|
|
"\x1cTaskQueueVersionInfoInternal\x12p\n" +
|
|
"\x18physical_task_queue_info\x18\x02 \x01(\v27.temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfoR\x15physicalTaskQueueInfo\"\xc2\x04\n" +
|
|
"\x15PhysicalTaskQueueInfo\x12?\n" +
|
|
"\apollers\x18\x01 \x03(\v2%.temporal.api.taskqueue.v1.PollerInfoR\apollers\x12v\n" +
|
|
"\x1ainternal_task_queue_status\x18\x03 \x03(\v29.temporal.server.api.taskqueue.v1.InternalTaskQueueStatusR\x17internalTaskQueueStatus\x12S\n" +
|
|
"\x10task_queue_stats\x18\x02 \x01(\v2).temporal.api.taskqueue.v1.TaskQueueStatsR\x0etaskQueueStats\x12\x9f\x01\n" +
|
|
" task_queue_stats_by_priority_key\x18\x04 \x03(\v2X.temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntryR\x1btaskQueueStatsByPriorityKey\x1ay\n" +
|
|
" TaskQueueStatsByPriorityKeyEntry\x12\x10\n" +
|
|
"\x03key\x18\x01 \x01(\x05R\x03key\x12?\n" +
|
|
"\x05value\x18\x02 \x01(\v2).temporal.api.taskqueue.v1.TaskQueueStatsR\x05value:\x028\x01\"\xce\x02\n" +
|
|
"\x12TaskQueuePartition\x12\x1d\n" +
|
|
"\n" +
|
|
"task_queue\x18\x01 \x01(\tR\ttaskQueue\x12L\n" +
|
|
"\x0ftask_queue_type\x18\x02 \x01(\x0e2$.temporal.api.enums.v1.TaskQueueTypeR\rtaskQueueType\x120\n" +
|
|
"\x13normal_partition_id\x18\x03 \x01(\x05H\x00R\x11normalPartitionId\x12!\n" +
|
|
"\vsticky_name\x18\x04 \x01(\tH\x00R\n" +
|
|
"stickyName\x12f\n" +
|
|
"\x0fworker_commands\x18\x05 \x01(\v2;.temporal.server.api.taskqueue.v1.WorkerCommandsPartitionIdH\x00R\x0eworkerCommandsB\x0e\n" +
|
|
"\fpartition_id\"\x1b\n" +
|
|
"\x19WorkerCommandsPartitionId\"A\n" +
|
|
"\x13BuildIdRedirectInfo\x12*\n" +
|
|
"\x11assigned_build_id\x18\x01 \x01(\tR\x0fassignedBuildId\"\xa9\x03\n" +
|
|
"\x0fTaskForwardInfo\x12)\n" +
|
|
"\x10source_partition\x18\x01 \x01(\tR\x0fsourcePartition\x12I\n" +
|
|
"\vtask_source\x18\x02 \x01(\x0e2(.temporal.server.api.enums.v1.TaskSourceR\n" +
|
|
"taskSource\x12)\n" +
|
|
"\x10origin_partition\x18\x06 \x01(\tR\x0foriginPartition\x12;\n" +
|
|
"\vcreate_time\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\n" +
|
|
"createTime\x12Z\n" +
|
|
"\rredirect_info\x18\x03 \x01(\v25.temporal.server.api.taskqueue.v1.BuildIdRedirectInfoR\fredirectInfo\x12*\n" +
|
|
"\x11dispatch_build_id\x18\x04 \x01(\tR\x0fdispatchBuildId\x120\n" +
|
|
"\x14dispatch_version_set\x18\x05 \x01(\tR\x12dispatchVersionSet\"\xd5\x03\n" +
|
|
"\rEphemeralData\x12Y\n" +
|
|
"\tpartition\x18\x01 \x03(\v2;.temporal.server.api.taskqueue.v1.EphemeralData.ByPartitionR\tpartition\x12J\n" +
|
|
"\x05scale\x18\x02 \x01(\v24.temporal.server.api.taskqueue.v1.PartitionScaleInfoR\x05scale\x1a\x99\x01\n" +
|
|
"\tByVersion\x12T\n" +
|
|
"\aversion\x18\x01 \x01(\v2:.temporal.server.api.deployment.v1.WorkerDeploymentVersionR\aversion\x126\n" +
|
|
"\x17backlog_priority_levels\x18\x02 \x01(\x03R\x15backlogPriorityLevels\x1a\x80\x01\n" +
|
|
"\vByPartition\x12\x1c\n" +
|
|
"\tpartition\x18\x01 \x01(\x05R\tpartition\x12S\n" +
|
|
"\aversion\x18\x02 \x03(\v29.temporal.server.api.taskqueue.v1.EphemeralData.ByVersionR\aversion\"w\n" +
|
|
"\x16VersionedEphemeralData\x12C\n" +
|
|
"\x04data\x18\x01 \x01(\v2/.temporal.server.api.taskqueue.v1.EphemeralDataR\x04data\x12\x18\n" +
|
|
"\aversion\x18\x02 \x01(\x03R\aversion\"\xa0\x01\n" +
|
|
"\x12PartitionScaleInfo\x12\x12\n" +
|
|
"\x04read\x18\x01 \x01(\x05R\x04read\x12\x14\n" +
|
|
"\x05write\x18\x02 \x01(\x05R\x05write\x12%\n" +
|
|
"\x0ebacklog_counts\x18\x03 \x01(\fR\rbacklogCounts\x12\x1f\n" +
|
|
"\vbacklog_cap\x18\x04 \x01(\x05R\n" +
|
|
"backlogCap\x12\x18\n" +
|
|
"\aversion\x18\n" +
|
|
" \x01(\x10R\aversion\"\x87\x01\n" +
|
|
"\x15ClientPartitionCounts\x12\x12\n" +
|
|
"\x04read\x18\x01 \x01(\x05R\x04read\x12\x14\n" +
|
|
"\x05write\x18\x02 \x01(\x05R\x05write\x12#\n" +
|
|
"\rbacklog_count\x18\x03 \x01(\fR\fbacklogCount\x12\x1f\n" +
|
|
"\vbacklog_cap\x18\x04 \x01(\x05R\n" +
|
|
"backlogCapB2Z0go.temporal.io/server/api/taskqueue/v1;taskqueueb\x06proto3"
|
|
|
|
var (
|
|
file_temporal_server_api_taskqueue_v1_message_proto_rawDescOnce sync.Once
|
|
file_temporal_server_api_taskqueue_v1_message_proto_rawDescData []byte
|
|
)
|
|
|
|
func file_temporal_server_api_taskqueue_v1_message_proto_rawDescGZIP() []byte {
|
|
file_temporal_server_api_taskqueue_v1_message_proto_rawDescOnce.Do(func() {
|
|
file_temporal_server_api_taskqueue_v1_message_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)))
|
|
})
|
|
return file_temporal_server_api_taskqueue_v1_message_proto_rawDescData
|
|
}
|
|
|
|
var file_temporal_server_api_taskqueue_v1_message_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
|
|
var file_temporal_server_api_taskqueue_v1_message_proto_goTypes = []any{
|
|
(*TaskVersionDirective)(nil), // 0: temporal.server.api.taskqueue.v1.TaskVersionDirective
|
|
(*FairLevel)(nil), // 1: temporal.server.api.taskqueue.v1.FairLevel
|
|
(*InternalTaskQueueStatus)(nil), // 2: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus
|
|
(*TaskQueueVersionInfoInternal)(nil), // 3: temporal.server.api.taskqueue.v1.TaskQueueVersionInfoInternal
|
|
(*PhysicalTaskQueueInfo)(nil), // 4: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo
|
|
(*TaskQueuePartition)(nil), // 5: temporal.server.api.taskqueue.v1.TaskQueuePartition
|
|
(*WorkerCommandsPartitionId)(nil), // 6: temporal.server.api.taskqueue.v1.WorkerCommandsPartitionId
|
|
(*BuildIdRedirectInfo)(nil), // 7: temporal.server.api.taskqueue.v1.BuildIdRedirectInfo
|
|
(*TaskForwardInfo)(nil), // 8: temporal.server.api.taskqueue.v1.TaskForwardInfo
|
|
(*EphemeralData)(nil), // 9: temporal.server.api.taskqueue.v1.EphemeralData
|
|
(*VersionedEphemeralData)(nil), // 10: temporal.server.api.taskqueue.v1.VersionedEphemeralData
|
|
(*PartitionScaleInfo)(nil), // 11: temporal.server.api.taskqueue.v1.PartitionScaleInfo
|
|
(*ClientPartitionCounts)(nil), // 12: temporal.server.api.taskqueue.v1.ClientPartitionCounts
|
|
nil, // 13: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntry
|
|
(*EphemeralData_ByVersion)(nil), // 14: temporal.server.api.taskqueue.v1.EphemeralData.ByVersion
|
|
(*EphemeralData_ByPartition)(nil), // 15: temporal.server.api.taskqueue.v1.EphemeralData.ByPartition
|
|
(*emptypb.Empty)(nil), // 16: google.protobuf.Empty
|
|
(v1.VersioningBehavior)(0), // 17: temporal.api.enums.v1.VersioningBehavior
|
|
(*v11.Deployment)(nil), // 18: temporal.api.deployment.v1.Deployment
|
|
(*v12.WorkerDeploymentVersion)(nil), // 19: temporal.server.api.deployment.v1.WorkerDeploymentVersion
|
|
(*v13.TaskIdBlock)(nil), // 20: temporal.api.taskqueue.v1.TaskIdBlock
|
|
(*v13.PollerInfo)(nil), // 21: temporal.api.taskqueue.v1.PollerInfo
|
|
(*v13.TaskQueueStats)(nil), // 22: temporal.api.taskqueue.v1.TaskQueueStats
|
|
(v1.TaskQueueType)(0), // 23: temporal.api.enums.v1.TaskQueueType
|
|
(v14.TaskSource)(0), // 24: temporal.server.api.enums.v1.TaskSource
|
|
(*timestamppb.Timestamp)(nil), // 25: google.protobuf.Timestamp
|
|
}
|
|
var file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = []int32{
|
|
16, // 0: temporal.server.api.taskqueue.v1.TaskVersionDirective.use_assignment_rules:type_name -> google.protobuf.Empty
|
|
17, // 1: temporal.server.api.taskqueue.v1.TaskVersionDirective.behavior:type_name -> temporal.api.enums.v1.VersioningBehavior
|
|
18, // 2: temporal.server.api.taskqueue.v1.TaskVersionDirective.deployment:type_name -> temporal.api.deployment.v1.Deployment
|
|
19, // 3: temporal.server.api.taskqueue.v1.TaskVersionDirective.deployment_version:type_name -> temporal.server.api.deployment.v1.WorkerDeploymentVersion
|
|
1, // 4: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.fair_read_level:type_name -> temporal.server.api.taskqueue.v1.FairLevel
|
|
1, // 5: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.fair_ack_level:type_name -> temporal.server.api.taskqueue.v1.FairLevel
|
|
20, // 6: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.task_id_block:type_name -> temporal.api.taskqueue.v1.TaskIdBlock
|
|
1, // 7: temporal.server.api.taskqueue.v1.InternalTaskQueueStatus.fair_max_read_level:type_name -> temporal.server.api.taskqueue.v1.FairLevel
|
|
4, // 8: temporal.server.api.taskqueue.v1.TaskQueueVersionInfoInternal.physical_task_queue_info:type_name -> temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo
|
|
21, // 9: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.pollers:type_name -> temporal.api.taskqueue.v1.PollerInfo
|
|
2, // 10: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.internal_task_queue_status:type_name -> temporal.server.api.taskqueue.v1.InternalTaskQueueStatus
|
|
22, // 11: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.task_queue_stats:type_name -> temporal.api.taskqueue.v1.TaskQueueStats
|
|
13, // 12: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.task_queue_stats_by_priority_key:type_name -> temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntry
|
|
23, // 13: temporal.server.api.taskqueue.v1.TaskQueuePartition.task_queue_type:type_name -> temporal.api.enums.v1.TaskQueueType
|
|
6, // 14: temporal.server.api.taskqueue.v1.TaskQueuePartition.worker_commands:type_name -> temporal.server.api.taskqueue.v1.WorkerCommandsPartitionId
|
|
24, // 15: temporal.server.api.taskqueue.v1.TaskForwardInfo.task_source:type_name -> temporal.server.api.enums.v1.TaskSource
|
|
25, // 16: temporal.server.api.taskqueue.v1.TaskForwardInfo.create_time:type_name -> google.protobuf.Timestamp
|
|
7, // 17: temporal.server.api.taskqueue.v1.TaskForwardInfo.redirect_info:type_name -> temporal.server.api.taskqueue.v1.BuildIdRedirectInfo
|
|
15, // 18: temporal.server.api.taskqueue.v1.EphemeralData.partition:type_name -> temporal.server.api.taskqueue.v1.EphemeralData.ByPartition
|
|
11, // 19: temporal.server.api.taskqueue.v1.EphemeralData.scale:type_name -> temporal.server.api.taskqueue.v1.PartitionScaleInfo
|
|
9, // 20: temporal.server.api.taskqueue.v1.VersionedEphemeralData.data:type_name -> temporal.server.api.taskqueue.v1.EphemeralData
|
|
22, // 21: temporal.server.api.taskqueue.v1.PhysicalTaskQueueInfo.TaskQueueStatsByPriorityKeyEntry.value:type_name -> temporal.api.taskqueue.v1.TaskQueueStats
|
|
19, // 22: temporal.server.api.taskqueue.v1.EphemeralData.ByVersion.version:type_name -> temporal.server.api.deployment.v1.WorkerDeploymentVersion
|
|
14, // 23: temporal.server.api.taskqueue.v1.EphemeralData.ByPartition.version:type_name -> temporal.server.api.taskqueue.v1.EphemeralData.ByVersion
|
|
24, // [24:24] is the sub-list for method output_type
|
|
24, // [24:24] is the sub-list for method input_type
|
|
24, // [24:24] is the sub-list for extension type_name
|
|
24, // [24:24] is the sub-list for extension extendee
|
|
0, // [0:24] is the sub-list for field type_name
|
|
}
|
|
|
|
func init() { file_temporal_server_api_taskqueue_v1_message_proto_init() }
|
|
func file_temporal_server_api_taskqueue_v1_message_proto_init() {
|
|
if File_temporal_server_api_taskqueue_v1_message_proto != nil {
|
|
return
|
|
}
|
|
file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[0].OneofWrappers = []any{
|
|
(*TaskVersionDirective_UseAssignmentRules)(nil),
|
|
(*TaskVersionDirective_AssignedBuildId)(nil),
|
|
}
|
|
file_temporal_server_api_taskqueue_v1_message_proto_msgTypes[5].OneofWrappers = []any{
|
|
(*TaskQueuePartition_NormalPartitionId)(nil),
|
|
(*TaskQueuePartition_StickyName)(nil),
|
|
(*TaskQueuePartition_WorkerCommands)(nil),
|
|
}
|
|
type x struct{}
|
|
out := protoimpl.TypeBuilder{
|
|
File: protoimpl.DescBuilder{
|
|
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
|
RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc), len(file_temporal_server_api_taskqueue_v1_message_proto_rawDesc)),
|
|
NumEnums: 0,
|
|
NumMessages: 16,
|
|
NumExtensions: 0,
|
|
NumServices: 0,
|
|
},
|
|
GoTypes: file_temporal_server_api_taskqueue_v1_message_proto_goTypes,
|
|
DependencyIndexes: file_temporal_server_api_taskqueue_v1_message_proto_depIdxs,
|
|
MessageInfos: file_temporal_server_api_taskqueue_v1_message_proto_msgTypes,
|
|
}.Build()
|
|
File_temporal_server_api_taskqueue_v1_message_proto = out.File
|
|
file_temporal_server_api_taskqueue_v1_message_proto_goTypes = nil
|
|
file_temporal_server_api_taskqueue_v1_message_proto_depIdxs = nil
|
|
}
|