mirror of
https://github.com/hanzoai/tasks.git
synced 2026-10-04 02:04:03 +00:00
David ReissandGitHub
f64d1adaeb
## What changed? - Matching server propagates partition counts in ephemeral data. - Matching server validates partition counts sent by client, and rejects if they are too far. ## Why? Next part of dynamic partitioning. ## 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) - covered by future integration tests ## Potential risks No change in behavior at this point, partition scale info is always nil, so nothing will be rejected. The server will start sending grpc trailers though.
1322 lines
51 KiB
Go
1322 lines
51 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"`
|
|
// 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) 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"`
|
|
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
|
|
}
|
|
|
|
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\"X\n" +
|
|
"\x12PartitionScaleInfo\x12\x12\n" +
|
|
"\x04read\x18\x01 \x01(\x05R\x04read\x12\x14\n" +
|
|
"\x05write\x18\x02 \x01(\x05R\x05write\x12\x18\n" +
|
|
"\aversion\x18\n" +
|
|
" \x01(\x10R\aversion\"A\n" +
|
|
"\x15ClientPartitionCounts\x12\x12\n" +
|
|
"\x04read\x18\x01 \x01(\x05R\x04read\x12\x14\n" +
|
|
"\x05write\x18\x02 \x01(\x05R\x05writeB2Z0go.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
|
|
}
|