Github-Mirror/seaweedfs
1
0
Fork 0
mirror of https://github.com/seaweedfs/seaweedfs.git synced 2026-09-14 18:40:48 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
af8d4e00eea6fbf4b8ff5dbe4904e2b2132e91a4
seaweedfs/weed/pb/worker_pb/worker.pb.go
T
Chris Lu 532b088262 fix(ec): preserve source disk type across EC encoding (#9423) (#9449) 
* fix(ec): carry source disk type on VolumeEcShardsMount (#9423)

When EC shards land on a target whose disk type differs from the
source volume's, master heartbeats wrongly reported under the target
disk's type. Add source_disk_type to VolumeEcShardsMountRequest; the
target server applies it to the in-memory EcVolume via SetDiskType so
the mount notification and steady-state heartbeat both carry the
source's disk type. Empty value falls back to the location's disk
type (used by disk-scan reload paths).

The override is not persisted with the volume — disk type stays an
environmental property and .vif remains portable.

* fix(ec): plumb source disk type through plugin worker (#9423)

Add source_disk_type to ErasureCodingTaskParams (field 8; 7 reserved),
populate it from the metric the detector already collects, thread it
through ec_task into the MountEcShards helper, and forward it on the
VolumeEcShardsMount RPC.

* fix(ec): mirror source disk type plumbing in rust volume server (#9423)

The volume_ec_shards_mount handler now forwards source_disk_type into
mount_ec_shard → DiskLocation::mount_ec_shards. When non-empty it
overrides ec_vol.disk_type (and each mounted shard's disk_type) via
the new set_disk_type method; empty value keeps the location's disk
type, so disk-scan reload and reconcile paths are unchanged.

Also picks up two pre-existing proto drifts that 'make gen' synced
from weed/pb (LockRingUpdate in master.proto, listing_cache_ttl_seconds
in remote.proto).

* feat(ec): bias placement toward preferred disk type (#9423)

Add DiskCandidate.DiskType and PlacementRequest.PreferredDiskType.
When PreferredDiskType is non-empty, SelectDestinations partitions
suitable disks into matching/fallback tiers and runs the rack/server/
disk-diversity passes on the matching tier first; the fallback tier
is only consulted if the matching pool can't satisfy ShardsNeeded.
PlacementResult.SpilledToOtherDiskType lets callers warn on spillover.

Empty PreferredDiskType keeps the existing single-pool behavior.

* fix(ec): plumb source disk type into placement planner (#9423)

diskInfosToCandidates now copies DiskInfo.DiskType into the placement
candidate, and ecPlacementPlanner.selectDestinations forwards
metric.DiskType as PreferredDiskType so EC shards land on disks
matching the source volume's disk type when possible. A glog warning
fires when placement had to spill to other disk types.

* test(ec): integration coverage for source-disk-type plumbing (#9423)

store_ec_disk_type_test exercises Store.MountEcShards end-to-end: a
shard physically lives on an HDD location, MountEcShards is called
with sourceDiskType="ssd", and the test asserts that the in-memory
EcVolume, the mounted shard, the NewEcShardsChan notification, and
the steady-state heartbeat all report under the source's disk type.
A companion test pins the empty-source path so disk-scan reload
keeps the location's disk type.

detection_disk_type_test exercises the worker plumbing: with a
cluster of nodes carrying both HDD and SSD disks, planECDestinations
must place every shard on SSD when metric.DiskType="ssd"; with only
one SSD node and 13 HDD nodes it must still satisfy a 10+4 layout
via spillover (and log a warning).

* revert(ec): drop unrelated proto drift in seaweed-volume/proto (#9423)

make gen pulled two pre-existing OSS changes into the rust proto
tree (LockRingUpdate / by_plugin in master.proto,
listing_cache_ttl_seconds in remote.proto). Reviewers flagged it as
scope creep — none of the rust EC fix references those fields.
Restore both files to origin/master so this branch only touches
EC-related symbols.

* fix(ec placement): treat empty disk type as hdd and skip used racks on spill (#9423)

partitionByDiskType used raw string comparison, so a PreferredDiskType
of "hdd" never matched candidates whose DiskType is "" (the
HardDriveType sentinel that weed/storage/types uses). EC encoding of
an HDD source would spill onto any HDD reporting "" even when the
cluster has plenty of matching capacity. Normalize both sides
through normalizeDiskType, which lowercases and folds "" → "hdd",
mirroring types.ToDiskType without taking a dependency on it.

selectFromTier's rack-diversity pass also kept revisiting racks the
preferred tier had already used when running on the fallback tier,
which negated PreferDifferentRacks on spillover. Skip racks already
in usedRacks so fallback placements still spread onto new racks.

* fix(ec): empty-source remount must not clobber existing disk type (#9423)

mount_ec_shards_with_idx_dir runs more than once per vid (RPC mount,
disk-scan reload, orphan-shard reconcile). After an RPC sets the
source-derived disk type, any later call passing source_disk_type=""
was resetting ec_vol.disk_type back to the location's value, which
reintroduces the heartbeat drift this PR is meant to fix. Only
default to the location's disk type when the EC volume is fresh
(no shards mounted yet); otherwise leave the recorded type alone so
empty-source reloads preserve whatever the original mount RPC set.
2026-05-11 20:21:50 -07:00

4507 lines
147 KiB
Go
Raw Blame History

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.36.6
// protoc v6.33.4
// source: worker.proto
package worker_pb
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
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)
)
// Zero is an UNSPECIFIED sentinel: a TaskParams payload whose subtype is
// unset must not silently route into a READ task. Callers always populate
// one of READ / BOOTSTRAP / DRAIN.
type S3LifecycleParams_Subtype int32
const (
S3LifecycleParams_SUBTYPE_UNSPECIFIED S3LifecycleParams_Subtype = 0
S3LifecycleParams_READ S3LifecycleParams_Subtype = 1
S3LifecycleParams_BOOTSTRAP S3LifecycleParams_Subtype = 2
S3LifecycleParams_DRAIN S3LifecycleParams_Subtype = 3
)
// Enum value maps for S3LifecycleParams_Subtype.
var (
S3LifecycleParams_Subtype_name = map[int32]string{
0: "SUBTYPE_UNSPECIFIED",
1: "READ",
2: "BOOTSTRAP",
3: "DRAIN",
}
S3LifecycleParams_Subtype_value = map[string]int32{
"SUBTYPE_UNSPECIFIED": 0,
"READ": 1,
"BOOTSTRAP": 2,
"DRAIN": 3,
}
)
func (x S3LifecycleParams_Subtype) Enum() *S3LifecycleParams_Subtype {
p := new(S3LifecycleParams_Subtype)
*p = x
return p
}
func (x S3LifecycleParams_Subtype) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (S3LifecycleParams_Subtype) Descriptor() protoreflect.EnumDescriptor {
return file_worker_proto_enumTypes[0].Descriptor()
}
func (S3LifecycleParams_Subtype) Type() protoreflect.EnumType {
return &file_worker_proto_enumTypes[0]
}
func (x S3LifecycleParams_Subtype) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use S3LifecycleParams_Subtype.Descriptor instead.
func (S3LifecycleParams_Subtype) EnumDescriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{9, 0}
}
// WorkerMessage represents messages from worker to admin
type WorkerMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
WorkerId string `protobuf:"bytes,1,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
// Types that are valid to be assigned to Message:
//
// *WorkerMessage_Registration
// *WorkerMessage_Heartbeat
// *WorkerMessage_TaskRequest
// *WorkerMessage_TaskUpdate
// *WorkerMessage_TaskComplete
// *WorkerMessage_Shutdown
// *WorkerMessage_TaskLogResponse
Message isWorkerMessage_Message `protobuf_oneof:"message"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *WorkerMessage) Reset() {
*x = WorkerMessage{}
mi := &file_worker_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *WorkerMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WorkerMessage) ProtoMessage() {}
func (x *WorkerMessage) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 WorkerMessage.ProtoReflect.Descriptor instead.
func (*WorkerMessage) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{0}
}
func (x *WorkerMessage) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *WorkerMessage) GetTimestamp() int64 {
if x != nil {
return x.Timestamp
}
return 0
}
func (x *WorkerMessage) GetMessage() isWorkerMessage_Message {
if x != nil {
return x.Message
}
return nil
}
func (x *WorkerMessage) GetRegistration() *WorkerRegistration {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_Registration); ok {
return x.Registration
}
}
return nil
}
func (x *WorkerMessage) GetHeartbeat() *WorkerHeartbeat {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_Heartbeat); ok {
return x.Heartbeat
}
}
return nil
}
func (x *WorkerMessage) GetTaskRequest() *TaskRequest {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_TaskRequest); ok {
return x.TaskRequest
}
}
return nil
}
func (x *WorkerMessage) GetTaskUpdate() *TaskUpdate {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_TaskUpdate); ok {
return x.TaskUpdate
}
}
return nil
}
func (x *WorkerMessage) GetTaskComplete() *TaskComplete {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_TaskComplete); ok {
return x.TaskComplete
}
}
return nil
}
func (x *WorkerMessage) GetShutdown() *WorkerShutdown {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_Shutdown); ok {
return x.Shutdown
}
}
return nil
}
func (x *WorkerMessage) GetTaskLogResponse() *TaskLogResponse {
if x != nil {
if x, ok := x.Message.(*WorkerMessage_TaskLogResponse); ok {
return x.TaskLogResponse
}
}
return nil
}
type isWorkerMessage_Message interface {
isWorkerMessage_Message()
}
type WorkerMessage_Registration struct {
Registration *WorkerRegistration `protobuf:"bytes,3,opt,name=registration,proto3,oneof"`
}
type WorkerMessage_Heartbeat struct {
Heartbeat *WorkerHeartbeat `protobuf:"bytes,4,opt,name=heartbeat,proto3,oneof"`
}
type WorkerMessage_TaskRequest struct {
TaskRequest *TaskRequest `protobuf:"bytes,5,opt,name=task_request,json=taskRequest,proto3,oneof"`
}
type WorkerMessage_TaskUpdate struct {
TaskUpdate *TaskUpdate `protobuf:"bytes,6,opt,name=task_update,json=taskUpdate,proto3,oneof"`
}
type WorkerMessage_TaskComplete struct {
TaskComplete *TaskComplete `protobuf:"bytes,7,opt,name=task_complete,json=taskComplete,proto3,oneof"`
}
type WorkerMessage_Shutdown struct {
Shutdown *WorkerShutdown `protobuf:"bytes,8,opt,name=shutdown,proto3,oneof"`
}
type WorkerMessage_TaskLogResponse struct {
TaskLogResponse *TaskLogResponse `protobuf:"bytes,9,opt,name=task_log_response,json=taskLogResponse,proto3,oneof"`
}
func (*WorkerMessage_Registration) isWorkerMessage_Message() {}
func (*WorkerMessage_Heartbeat) isWorkerMessage_Message() {}
func (*WorkerMessage_TaskRequest) isWorkerMessage_Message() {}
func (*WorkerMessage_TaskUpdate) isWorkerMessage_Message() {}
func (*WorkerMessage_TaskComplete) isWorkerMessage_Message() {}
func (*WorkerMessage_Shutdown) isWorkerMessage_Message() {}
func (*WorkerMessage_TaskLogResponse) isWorkerMessage_Message() {}
// AdminMessage represents messages from admin to worker
type AdminMessage struct {
state protoimpl.MessageState `protogen:"open.v1"`
AdminId string `protobuf:"bytes,1,opt,name=admin_id,json=adminId,proto3" json:"admin_id,omitempty"`
Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
// Types that are valid to be assigned to Message:
//
// *AdminMessage_RegistrationResponse
// *AdminMessage_HeartbeatResponse
// *AdminMessage_TaskAssignment
// *AdminMessage_TaskCancellation
// *AdminMessage_AdminShutdown
// *AdminMessage_TaskLogRequest
Message isAdminMessage_Message `protobuf_oneof:"message"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *AdminMessage) Reset() {
*x = AdminMessage{}
mi := &file_worker_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *AdminMessage) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AdminMessage) ProtoMessage() {}
func (x *AdminMessage) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 AdminMessage.ProtoReflect.Descriptor instead.
func (*AdminMessage) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{1}
}
func (x *AdminMessage) GetAdminId() string {
if x != nil {
return x.AdminId
}
return ""
}
func (x *AdminMessage) GetTimestamp() int64 {
if x != nil {
return x.Timestamp
}
return 0
}
func (x *AdminMessage) GetMessage() isAdminMessage_Message {
if x != nil {
return x.Message
}
return nil
}
func (x *AdminMessage) GetRegistrationResponse() *RegistrationResponse {
if x != nil {
if x, ok := x.Message.(*AdminMessage_RegistrationResponse); ok {
return x.RegistrationResponse
}
}
return nil
}
func (x *AdminMessage) GetHeartbeatResponse() *HeartbeatResponse {
if x != nil {
if x, ok := x.Message.(*AdminMessage_HeartbeatResponse); ok {
return x.HeartbeatResponse
}
}
return nil
}
func (x *AdminMessage) GetTaskAssignment() *TaskAssignment {
if x != nil {
if x, ok := x.Message.(*AdminMessage_TaskAssignment); ok {
return x.TaskAssignment
}
}
return nil
}
func (x *AdminMessage) GetTaskCancellation() *TaskCancellation {
if x != nil {
if x, ok := x.Message.(*AdminMessage_TaskCancellation); ok {
return x.TaskCancellation
}
}
return nil
}
func (x *AdminMessage) GetAdminShutdown() *AdminShutdown {
if x != nil {
if x, ok := x.Message.(*AdminMessage_AdminShutdown); ok {
return x.AdminShutdown
}
}
return nil
}
func (x *AdminMessage) GetTaskLogRequest() *TaskLogRequest {
if x != nil {
if x, ok := x.Message.(*AdminMessage_TaskLogRequest); ok {
return x.TaskLogRequest
}
}
return nil
}
type isAdminMessage_Message interface {
isAdminMessage_Message()
}
type AdminMessage_RegistrationResponse struct {
RegistrationResponse *RegistrationResponse `protobuf:"bytes,3,opt,name=registration_response,json=registrationResponse,proto3,oneof"`
}
type AdminMessage_HeartbeatResponse struct {
HeartbeatResponse *HeartbeatResponse `protobuf:"bytes,4,opt,name=heartbeat_response,json=heartbeatResponse,proto3,oneof"`
}
type AdminMessage_TaskAssignment struct {
TaskAssignment *TaskAssignment `protobuf:"bytes,5,opt,name=task_assignment,json=taskAssignment,proto3,oneof"`
}
type AdminMessage_TaskCancellation struct {
TaskCancellation *TaskCancellation `protobuf:"bytes,6,opt,name=task_cancellation,json=taskCancellation,proto3,oneof"`
}
type AdminMessage_AdminShutdown struct {
AdminShutdown *AdminShutdown `protobuf:"bytes,7,opt,name=admin_shutdown,json=adminShutdown,proto3,oneof"`
}
type AdminMessage_TaskLogRequest struct {
TaskLogRequest *TaskLogRequest `protobuf:"bytes,8,opt,name=task_log_request,json=taskLogRequest,proto3,oneof"`
}
func (*AdminMessage_RegistrationResponse) isAdminMessage_Message() {}
func (*AdminMessage_HeartbeatResponse) isAdminMessage_Message() {}
func (*AdminMessage_TaskAssignment) isAdminMessage_Message() {}
func (*AdminMessage_TaskCancellation) isAdminMessage_Message() {}
func (*AdminMessage_AdminShutdown) isAdminMessage_Message() {}
func (*AdminMessage_TaskLogRequest) isAdminMessage_Message() {}
// WorkerRegistration message when worker connects
type WorkerRegistration struct {
state protoimpl.MessageState `protogen:"open.v1"`
WorkerId string `protobuf:"bytes,1,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
Capabilities []string `protobuf:"bytes,3,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
MaxConcurrent int32 `protobuf:"varint,4,opt,name=max_concurrent,json=maxConcurrent,proto3" json:"max_concurrent,omitempty"`
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *WorkerRegistration) Reset() {
*x = WorkerRegistration{}
mi := &file_worker_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *WorkerRegistration) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WorkerRegistration) ProtoMessage() {}
func (x *WorkerRegistration) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 WorkerRegistration.ProtoReflect.Descriptor instead.
func (*WorkerRegistration) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{2}
}
func (x *WorkerRegistration) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *WorkerRegistration) GetAddress() string {
if x != nil {
return x.Address
}
return ""
}
func (x *WorkerRegistration) GetCapabilities() []string {
if x != nil {
return x.Capabilities
}
return nil
}
func (x *WorkerRegistration) GetMaxConcurrent() int32 {
if x != nil {
return x.MaxConcurrent
}
return 0
}
func (x *WorkerRegistration) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// RegistrationResponse confirms worker registration
type RegistrationResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
AssignedWorkerId string `protobuf:"bytes,3,opt,name=assigned_worker_id,json=assignedWorkerId,proto3" json:"assigned_worker_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *RegistrationResponse) Reset() {
*x = RegistrationResponse{}
mi := &file_worker_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *RegistrationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RegistrationResponse) ProtoMessage() {}
func (x *RegistrationResponse) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 RegistrationResponse.ProtoReflect.Descriptor instead.
func (*RegistrationResponse) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{3}
}
func (x *RegistrationResponse) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
func (x *RegistrationResponse) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *RegistrationResponse) GetAssignedWorkerId() string {
if x != nil {
return x.AssignedWorkerId
}
return ""
}
// WorkerHeartbeat sent periodically by worker
type WorkerHeartbeat struct {
state protoimpl.MessageState `protogen:"open.v1"`
WorkerId string `protobuf:"bytes,1,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Status string `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
CurrentLoad int32 `protobuf:"varint,3,opt,name=current_load,json=currentLoad,proto3" json:"current_load,omitempty"`
MaxConcurrent int32 `protobuf:"varint,4,opt,name=max_concurrent,json=maxConcurrent,proto3" json:"max_concurrent,omitempty"`
CurrentTaskIds []string `protobuf:"bytes,5,rep,name=current_task_ids,json=currentTaskIds,proto3" json:"current_task_ids,omitempty"`
TasksCompleted int32 `protobuf:"varint,6,opt,name=tasks_completed,json=tasksCompleted,proto3" json:"tasks_completed,omitempty"`
TasksFailed int32 `protobuf:"varint,7,opt,name=tasks_failed,json=tasksFailed,proto3" json:"tasks_failed,omitempty"`
UptimeSeconds int64 `protobuf:"varint,8,opt,name=uptime_seconds,json=uptimeSeconds,proto3" json:"uptime_seconds,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *WorkerHeartbeat) Reset() {
*x = WorkerHeartbeat{}
mi := &file_worker_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *WorkerHeartbeat) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WorkerHeartbeat) ProtoMessage() {}
func (x *WorkerHeartbeat) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 WorkerHeartbeat.ProtoReflect.Descriptor instead.
func (*WorkerHeartbeat) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{4}
}
func (x *WorkerHeartbeat) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *WorkerHeartbeat) GetStatus() string {
if x != nil {
return x.Status
}
return ""
}
func (x *WorkerHeartbeat) GetCurrentLoad() int32 {
if x != nil {
return x.CurrentLoad
}
return 0
}
func (x *WorkerHeartbeat) GetMaxConcurrent() int32 {
if x != nil {
return x.MaxConcurrent
}
return 0
}
func (x *WorkerHeartbeat) GetCurrentTaskIds() []string {
if x != nil {
return x.CurrentTaskIds
}
return nil
}
func (x *WorkerHeartbeat) GetTasksCompleted() int32 {
if x != nil {
return x.TasksCompleted
}
return 0
}
func (x *WorkerHeartbeat) GetTasksFailed() int32 {
if x != nil {
return x.TasksFailed
}
return 0
}
func (x *WorkerHeartbeat) GetUptimeSeconds() int64 {
if x != nil {
return x.UptimeSeconds
}
return 0
}
// HeartbeatResponse acknowledges heartbeat
type HeartbeatResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *HeartbeatResponse) Reset() {
*x = HeartbeatResponse{}
mi := &file_worker_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *HeartbeatResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HeartbeatResponse) ProtoMessage() {}
func (x *HeartbeatResponse) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 HeartbeatResponse.ProtoReflect.Descriptor instead.
func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{5}
}
func (x *HeartbeatResponse) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
func (x *HeartbeatResponse) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
// TaskRequest from worker asking for new tasks
type TaskRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
WorkerId string `protobuf:"bytes,1,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Capabilities []string `protobuf:"bytes,2,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
AvailableSlots int32 `protobuf:"varint,3,opt,name=available_slots,json=availableSlots,proto3" json:"available_slots,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskRequest) Reset() {
*x = TaskRequest{}
mi := &file_worker_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskRequest) ProtoMessage() {}
func (x *TaskRequest) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 TaskRequest.ProtoReflect.Descriptor instead.
func (*TaskRequest) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{6}
}
func (x *TaskRequest) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskRequest) GetCapabilities() []string {
if x != nil {
return x.Capabilities
}
return nil
}
func (x *TaskRequest) GetAvailableSlots() int32 {
if x != nil {
return x.AvailableSlots
}
return 0
}
// TaskAssignment from admin to worker
type TaskAssignment struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
TaskType string `protobuf:"bytes,2,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"`
Params *TaskParams `protobuf:"bytes,3,opt,name=params,proto3" json:"params,omitempty"`
Priority int32 `protobuf:"varint,4,opt,name=priority,proto3" json:"priority,omitempty"`
CreatedTime int64 `protobuf:"varint,5,opt,name=created_time,json=createdTime,proto3" json:"created_time,omitempty"`
Metadata map[string]string `protobuf:"bytes,6,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskAssignment) Reset() {
*x = TaskAssignment{}
mi := &file_worker_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskAssignment) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskAssignment) ProtoMessage() {}
func (x *TaskAssignment) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 TaskAssignment.ProtoReflect.Descriptor instead.
func (*TaskAssignment) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{7}
}
func (x *TaskAssignment) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskAssignment) GetTaskType() string {
if x != nil {
return x.TaskType
}
return ""
}
func (x *TaskAssignment) GetParams() *TaskParams {
if x != nil {
return x.Params
}
return nil
}
func (x *TaskAssignment) GetPriority() int32 {
if x != nil {
return x.Priority
}
return 0
}
func (x *TaskAssignment) GetCreatedTime() int64 {
if x != nil {
return x.CreatedTime
}
return 0
}
func (x *TaskAssignment) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// TaskParams contains task-specific parameters with typed variants
type TaskParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` // ActiveTopology task ID for lifecycle management
VolumeId uint32 `protobuf:"varint,2,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"` // Primary volume ID for the task
Collection string `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"` // Collection name
DataCenter string `protobuf:"bytes,4,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"` // Primary data center
Rack string `protobuf:"bytes,5,opt,name=rack,proto3" json:"rack,omitempty"` // Primary rack
VolumeSize uint64 `protobuf:"varint,6,opt,name=volume_size,json=volumeSize,proto3" json:"volume_size,omitempty"` // Original volume size in bytes for tracking size changes
// Unified source and target arrays for all task types
Sources []*TaskSource `protobuf:"bytes,7,rep,name=sources,proto3" json:"sources,omitempty"` // Source locations (volume replicas, EC shards, etc.)
Targets []*TaskTarget `protobuf:"bytes,8,rep,name=targets,proto3" json:"targets,omitempty"` // Target locations (destinations, new replicas, etc.)
// Typed task parameters
//
// Types that are valid to be assigned to TaskParams:
//
// *TaskParams_VacuumParams
// *TaskParams_ErasureCodingParams
// *TaskParams_BalanceParams
// *TaskParams_ReplicationParams
// *TaskParams_EcBalanceParams
// *TaskParams_S3LifecycleParams
TaskParams isTaskParams_TaskParams `protobuf_oneof:"task_params"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskParams) Reset() {
*x = TaskParams{}
mi := &file_worker_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskParams) ProtoMessage() {}
func (x *TaskParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 TaskParams.ProtoReflect.Descriptor instead.
func (*TaskParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{8}
}
func (x *TaskParams) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskParams) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *TaskParams) GetCollection() string {
if x != nil {
return x.Collection
}
return ""
}
func (x *TaskParams) GetDataCenter() string {
if x != nil {
return x.DataCenter
}
return ""
}
func (x *TaskParams) GetRack() string {
if x != nil {
return x.Rack
}
return ""
}
func (x *TaskParams) GetVolumeSize() uint64 {
if x != nil {
return x.VolumeSize
}
return 0
}
func (x *TaskParams) GetSources() []*TaskSource {
if x != nil {
return x.Sources
}
return nil
}
func (x *TaskParams) GetTargets() []*TaskTarget {
if x != nil {
return x.Targets
}
return nil
}
func (x *TaskParams) GetTaskParams() isTaskParams_TaskParams {
if x != nil {
return x.TaskParams
}
return nil
}
func (x *TaskParams) GetVacuumParams() *VacuumTaskParams {
if x != nil {
if x, ok := x.TaskParams.(*TaskParams_VacuumParams); ok {
return x.VacuumParams
}
}
return nil
}
func (x *TaskParams) GetErasureCodingParams() *ErasureCodingTaskParams {
if x != nil {
if x, ok := x.TaskParams.(*TaskParams_ErasureCodingParams); ok {
return x.ErasureCodingParams
}
}
return nil
}
func (x *TaskParams) GetBalanceParams() *BalanceTaskParams {
if x != nil {
if x, ok := x.TaskParams.(*TaskParams_BalanceParams); ok {
return x.BalanceParams
}
}
return nil
}
func (x *TaskParams) GetReplicationParams() *ReplicationTaskParams {
if x != nil {
if x, ok := x.TaskParams.(*TaskParams_ReplicationParams); ok {
return x.ReplicationParams
}
}
return nil
}
func (x *TaskParams) GetEcBalanceParams() *EcBalanceTaskParams {
if x != nil {
if x, ok := x.TaskParams.(*TaskParams_EcBalanceParams); ok {
return x.EcBalanceParams
}
}
return nil
}
func (x *TaskParams) GetS3LifecycleParams() *S3LifecycleParams {
if x != nil {
if x, ok := x.TaskParams.(*TaskParams_S3LifecycleParams); ok {
return x.S3LifecycleParams
}
}
return nil
}
type isTaskParams_TaskParams interface {
isTaskParams_TaskParams()
}
type TaskParams_VacuumParams struct {
VacuumParams *VacuumTaskParams `protobuf:"bytes,9,opt,name=vacuum_params,json=vacuumParams,proto3,oneof"`
}
type TaskParams_ErasureCodingParams struct {
ErasureCodingParams *ErasureCodingTaskParams `protobuf:"bytes,10,opt,name=erasure_coding_params,json=erasureCodingParams,proto3,oneof"`
}
type TaskParams_BalanceParams struct {
BalanceParams *BalanceTaskParams `protobuf:"bytes,11,opt,name=balance_params,json=balanceParams,proto3,oneof"`
}
type TaskParams_ReplicationParams struct {
ReplicationParams *ReplicationTaskParams `protobuf:"bytes,12,opt,name=replication_params,json=replicationParams,proto3,oneof"`
}
type TaskParams_EcBalanceParams struct {
EcBalanceParams *EcBalanceTaskParams `protobuf:"bytes,13,opt,name=ec_balance_params,json=ecBalanceParams,proto3,oneof"`
}
type TaskParams_S3LifecycleParams struct {
S3LifecycleParams *S3LifecycleParams `protobuf:"bytes,14,opt,name=s3_lifecycle_params,json=s3LifecycleParams,proto3,oneof"`
}
func (*TaskParams_VacuumParams) isTaskParams_TaskParams() {}
func (*TaskParams_ErasureCodingParams) isTaskParams_TaskParams() {}
func (*TaskParams_BalanceParams) isTaskParams_TaskParams() {}
func (*TaskParams_ReplicationParams) isTaskParams_TaskParams() {}
func (*TaskParams_EcBalanceParams) isTaskParams_TaskParams() {}
func (*TaskParams_S3LifecycleParams) isTaskParams_TaskParams() {}
// S3LifecycleParams routes a worker task to one of the three lifecycle
// subroutines. READ is the per-shard meta-log reader (one task per shard_id
// at a time); BOOTSTRAP walks a single bucket; DRAIN drains pending
// exceptions for a single rule.
type S3LifecycleParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
Subtype S3LifecycleParams_Subtype `protobuf:"varint,1,opt,name=subtype,proto3,enum=worker_pb.S3LifecycleParams_Subtype" json:"subtype,omitempty"`
// Required for BOOTSTRAP and DRAIN; ignored for READ. rule_hash is
// optional for BOOTSTRAP (omitting walks all rules for the bucket).
Bucket string `protobuf:"bytes,2,opt,name=bucket,proto3" json:"bucket,omitempty"`
RuleHash []byte `protobuf:"bytes,3,opt,name=rule_hash,json=ruleHash,proto3" json:"rule_hash,omitempty"` // 8 bytes when present
Force bool `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"` // operator override; bypasses scheduling guards
BatchTimeBudgetNs int64 `protobuf:"varint,5,opt,name=batch_time_budget_ns,json=batchTimeBudgetNs,proto3" json:"batch_time_budget_ns,omitempty"` // 0 = use default
BatchEventBudget int32 `protobuf:"varint,6,opt,name=batch_event_budget,json=batchEventBudget,proto3" json:"batch_event_budget,omitempty"` // 0 = use default
Continuation *ContinuationHint `protobuf:"bytes,7,opt,name=continuation,proto3" json:"continuation,omitempty"` // resume hint for kill-resume tasks
// READ only: which (bucket, key-prefix-hash) shard this task processes.
// Range 0..S3LifecycleShardCount-1 (16 shards). Required for READ; ignored
// for BOOTSTRAP and DRAIN. Workers receive one READ task per owned shard;
// shards distribute across workers via the existing scheduler.
ShardId int32 `protobuf:"varint,8,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *S3LifecycleParams) Reset() {
*x = S3LifecycleParams{}
mi := &file_worker_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *S3LifecycleParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*S3LifecycleParams) ProtoMessage() {}
func (x *S3LifecycleParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 S3LifecycleParams.ProtoReflect.Descriptor instead.
func (*S3LifecycleParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{9}
}
func (x *S3LifecycleParams) GetSubtype() S3LifecycleParams_Subtype {
if x != nil {
return x.Subtype
}
return S3LifecycleParams_SUBTYPE_UNSPECIFIED
}
func (x *S3LifecycleParams) GetBucket() string {
if x != nil {
return x.Bucket
}
return ""
}
func (x *S3LifecycleParams) GetRuleHash() []byte {
if x != nil {
return x.RuleHash
}
return nil
}
func (x *S3LifecycleParams) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
func (x *S3LifecycleParams) GetBatchTimeBudgetNs() int64 {
if x != nil {
return x.BatchTimeBudgetNs
}
return 0
}
func (x *S3LifecycleParams) GetBatchEventBudget() int32 {
if x != nil {
return x.BatchEventBudget
}
return 0
}
func (x *S3LifecycleParams) GetContinuation() *ContinuationHint {
if x != nil {
return x.Continuation
}
return nil
}
func (x *S3LifecycleParams) GetShardId() int32 {
if x != nil {
return x.ShardId
}
return 0
}
// ContinuationHint lets a long-running BOOTSTRAP or READ task hand its
// resume point to the next scheduled invocation without going through
// durable state. The durable state files are still authoritative; this
// is just a scheduling hint to skip an unnecessary fresh start.
type ContinuationHint struct {
state protoimpl.MessageState `protogen:"open.v1"`
LastScannedPath string `protobuf:"bytes,1,opt,name=last_scanned_path,json=lastScannedPath,proto3" json:"last_scanned_path,omitempty"` // BOOTSTRAP only
LastPositionNs int64 `protobuf:"varint,2,opt,name=last_position_ns,json=lastPositionNs,proto3" json:"last_position_ns,omitempty"` // READ only (advisory)
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ContinuationHint) Reset() {
*x = ContinuationHint{}
mi := &file_worker_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ContinuationHint) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ContinuationHint) ProtoMessage() {}
func (x *ContinuationHint) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 ContinuationHint.ProtoReflect.Descriptor instead.
func (*ContinuationHint) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{10}
}
func (x *ContinuationHint) GetLastScannedPath() string {
if x != nil {
return x.LastScannedPath
}
return ""
}
func (x *ContinuationHint) GetLastPositionNs() int64 {
if x != nil {
return x.LastPositionNs
}
return 0
}
// VacuumTaskParams for vacuum operations
type VacuumTaskParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
GarbageThreshold float64 `protobuf:"fixed64,1,opt,name=garbage_threshold,json=garbageThreshold,proto3" json:"garbage_threshold,omitempty"` // Minimum garbage ratio to trigger vacuum
ForceVacuum bool `protobuf:"varint,2,opt,name=force_vacuum,json=forceVacuum,proto3" json:"force_vacuum,omitempty"` // Force vacuum even if below threshold
BatchSize int32 `protobuf:"varint,3,opt,name=batch_size,json=batchSize,proto3" json:"batch_size,omitempty"` // Number of files to process per batch
WorkingDir string `protobuf:"bytes,4,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"` // Working directory for temporary files
VerifyChecksum bool `protobuf:"varint,5,opt,name=verify_checksum,json=verifyChecksum,proto3" json:"verify_checksum,omitempty"` // Verify file checksums during vacuum
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *VacuumTaskParams) Reset() {
*x = VacuumTaskParams{}
mi := &file_worker_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *VacuumTaskParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VacuumTaskParams) ProtoMessage() {}
func (x *VacuumTaskParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 VacuumTaskParams.ProtoReflect.Descriptor instead.
func (*VacuumTaskParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{11}
}
func (x *VacuumTaskParams) GetGarbageThreshold() float64 {
if x != nil {
return x.GarbageThreshold
}
return 0
}
func (x *VacuumTaskParams) GetForceVacuum() bool {
if x != nil {
return x.ForceVacuum
}
return false
}
func (x *VacuumTaskParams) GetBatchSize() int32 {
if x != nil {
return x.BatchSize
}
return 0
}
func (x *VacuumTaskParams) GetWorkingDir() string {
if x != nil {
return x.WorkingDir
}
return ""
}
func (x *VacuumTaskParams) GetVerifyChecksum() bool {
if x != nil {
return x.VerifyChecksum
}
return false
}
// ErasureCodingTaskParams for EC encoding operations
type ErasureCodingTaskParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
EstimatedShardSize uint64 `protobuf:"varint,1,opt,name=estimated_shard_size,json=estimatedShardSize,proto3" json:"estimated_shard_size,omitempty"` // Estimated size per shard
DataShards int32 `protobuf:"varint,2,opt,name=data_shards,json=dataShards,proto3" json:"data_shards,omitempty"` // Number of data shards (default: 10)
ParityShards int32 `protobuf:"varint,3,opt,name=parity_shards,json=parityShards,proto3" json:"parity_shards,omitempty"` // Number of parity shards (default: 4)
WorkingDir string `protobuf:"bytes,4,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"` // Working directory for EC processing
MasterClient string `protobuf:"bytes,5,opt,name=master_client,json=masterClient,proto3" json:"master_client,omitempty"` // Master server address
CleanupSource bool `protobuf:"varint,6,opt,name=cleanup_source,json=cleanupSource,proto3" json:"cleanup_source,omitempty"` // Whether to cleanup source volume after EC
SourceDiskType string `protobuf:"bytes,8,opt,name=source_disk_type,json=sourceDiskType,proto3" json:"source_disk_type,omitempty"` // Source volume's disk type, passed to VolumeEcShardsMount so shards report under it (#9423)
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ErasureCodingTaskParams) Reset() {
*x = ErasureCodingTaskParams{}
mi := &file_worker_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ErasureCodingTaskParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ErasureCodingTaskParams) ProtoMessage() {}
func (x *ErasureCodingTaskParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 ErasureCodingTaskParams.ProtoReflect.Descriptor instead.
func (*ErasureCodingTaskParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{12}
}
func (x *ErasureCodingTaskParams) GetEstimatedShardSize() uint64 {
if x != nil {
return x.EstimatedShardSize
}
return 0
}
func (x *ErasureCodingTaskParams) GetDataShards() int32 {
if x != nil {
return x.DataShards
}
return 0
}
func (x *ErasureCodingTaskParams) GetParityShards() int32 {
if x != nil {
return x.ParityShards
}
return 0
}
func (x *ErasureCodingTaskParams) GetWorkingDir() string {
if x != nil {
return x.WorkingDir
}
return ""
}
func (x *ErasureCodingTaskParams) GetMasterClient() string {
if x != nil {
return x.MasterClient
}
return ""
}
func (x *ErasureCodingTaskParams) GetCleanupSource() bool {
if x != nil {
return x.CleanupSource
}
return false
}
func (x *ErasureCodingTaskParams) GetSourceDiskType() string {
if x != nil {
return x.SourceDiskType
}
return ""
}
// TaskSource represents a unified source location for any task type
type TaskSource struct {
state protoimpl.MessageState `protogen:"open.v1"`
Node string `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"` // Source server address
DiskId uint32 `protobuf:"varint,2,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"` // Source disk ID
Rack string `protobuf:"bytes,3,opt,name=rack,proto3" json:"rack,omitempty"` // Source rack for tracking
DataCenter string `protobuf:"bytes,4,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"` // Source data center for tracking
VolumeId uint32 `protobuf:"varint,5,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"` // Volume ID (for volume operations)
ShardIds []uint32 `protobuf:"varint,6,rep,packed,name=shard_ids,json=shardIds,proto3" json:"shard_ids,omitempty"` // Shard IDs (for EC shard operations)
EstimatedSize uint64 `protobuf:"varint,7,opt,name=estimated_size,json=estimatedSize,proto3" json:"estimated_size,omitempty"` // Estimated size to be processed
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskSource) Reset() {
*x = TaskSource{}
mi := &file_worker_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskSource) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskSource) ProtoMessage() {}
func (x *TaskSource) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[13]
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 TaskSource.ProtoReflect.Descriptor instead.
func (*TaskSource) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{13}
}
func (x *TaskSource) GetNode() string {
if x != nil {
return x.Node
}
return ""
}
func (x *TaskSource) GetDiskId() uint32 {
if x != nil {
return x.DiskId
}
return 0
}
func (x *TaskSource) GetRack() string {
if x != nil {
return x.Rack
}
return ""
}
func (x *TaskSource) GetDataCenter() string {
if x != nil {
return x.DataCenter
}
return ""
}
func (x *TaskSource) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *TaskSource) GetShardIds() []uint32 {
if x != nil {
return x.ShardIds
}
return nil
}
func (x *TaskSource) GetEstimatedSize() uint64 {
if x != nil {
return x.EstimatedSize
}
return 0
}
// TaskTarget represents a unified target location for any task type
type TaskTarget struct {
state protoimpl.MessageState `protogen:"open.v1"`
Node string `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"` // Target server address
DiskId uint32 `protobuf:"varint,2,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"` // Target disk ID
Rack string `protobuf:"bytes,3,opt,name=rack,proto3" json:"rack,omitempty"` // Target rack for tracking
DataCenter string `protobuf:"bytes,4,opt,name=data_center,json=dataCenter,proto3" json:"data_center,omitempty"` // Target data center for tracking
VolumeId uint32 `protobuf:"varint,5,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"` // Volume ID (for volume operations)
ShardIds []uint32 `protobuf:"varint,6,rep,packed,name=shard_ids,json=shardIds,proto3" json:"shard_ids,omitempty"` // Shard IDs (for EC shard operations)
EstimatedSize uint64 `protobuf:"varint,7,opt,name=estimated_size,json=estimatedSize,proto3" json:"estimated_size,omitempty"` // Estimated size to be created
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskTarget) Reset() {
*x = TaskTarget{}
mi := &file_worker_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskTarget) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskTarget) ProtoMessage() {}
func (x *TaskTarget) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 TaskTarget.ProtoReflect.Descriptor instead.
func (*TaskTarget) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{14}
}
func (x *TaskTarget) GetNode() string {
if x != nil {
return x.Node
}
return ""
}
func (x *TaskTarget) GetDiskId() uint32 {
if x != nil {
return x.DiskId
}
return 0
}
func (x *TaskTarget) GetRack() string {
if x != nil {
return x.Rack
}
return ""
}
func (x *TaskTarget) GetDataCenter() string {
if x != nil {
return x.DataCenter
}
return ""
}
func (x *TaskTarget) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *TaskTarget) GetShardIds() []uint32 {
if x != nil {
return x.ShardIds
}
return nil
}
func (x *TaskTarget) GetEstimatedSize() uint64 {
if x != nil {
return x.EstimatedSize
}
return 0
}
// BalanceMoveSpec describes a single volume move within a batch balance job
type BalanceMoveSpec struct {
state protoimpl.MessageState `protogen:"open.v1"`
VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"` // Volume to move
SourceNode string `protobuf:"bytes,2,opt,name=source_node,json=sourceNode,proto3" json:"source_node,omitempty"` // Source server address (host:port)
TargetNode string `protobuf:"bytes,3,opt,name=target_node,json=targetNode,proto3" json:"target_node,omitempty"` // Destination server address (host:port)
Collection string `protobuf:"bytes,4,opt,name=collection,proto3" json:"collection,omitempty"` // Collection name
VolumeSize uint64 `protobuf:"varint,5,opt,name=volume_size,json=volumeSize,proto3" json:"volume_size,omitempty"` // Volume size in bytes (informational)
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *BalanceMoveSpec) Reset() {
*x = BalanceMoveSpec{}
mi := &file_worker_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *BalanceMoveSpec) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BalanceMoveSpec) ProtoMessage() {}
func (x *BalanceMoveSpec) ProtoReflect() protoreflect.Message {
mi := &file_worker_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 BalanceMoveSpec.ProtoReflect.Descriptor instead.
func (*BalanceMoveSpec) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{15}
}
func (x *BalanceMoveSpec) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *BalanceMoveSpec) GetSourceNode() string {
if x != nil {
return x.SourceNode
}
return ""
}
func (x *BalanceMoveSpec) GetTargetNode() string {
if x != nil {
return x.TargetNode
}
return ""
}
func (x *BalanceMoveSpec) GetCollection() string {
if x != nil {
return x.Collection
}
return ""
}
func (x *BalanceMoveSpec) GetVolumeSize() uint64 {
if x != nil {
return x.VolumeSize
}
return 0
}
// BalanceTaskParams for volume balancing operations
type BalanceTaskParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
ForceMove bool `protobuf:"varint,1,opt,name=force_move,json=forceMove,proto3" json:"force_move,omitempty"` // Force move even with conflicts
TimeoutSeconds int32 `protobuf:"varint,2,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"` // Operation timeout
MaxConcurrentMoves int32 `protobuf:"varint,3,opt,name=max_concurrent_moves,json=maxConcurrentMoves,proto3" json:"max_concurrent_moves,omitempty"` // Max concurrent moves in a batch job (0 = default 5)
Moves []*BalanceMoveSpec `protobuf:"bytes,4,rep,name=moves,proto3" json:"moves,omitempty"` // Batch: multiple volume moves in one job
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *BalanceTaskParams) Reset() {
*x = BalanceTaskParams{}
mi := &file_worker_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *BalanceTaskParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BalanceTaskParams) ProtoMessage() {}
func (x *BalanceTaskParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[16]
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 BalanceTaskParams.ProtoReflect.Descriptor instead.
func (*BalanceTaskParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{16}
}
func (x *BalanceTaskParams) GetForceMove() bool {
if x != nil {
return x.ForceMove
}
return false
}
func (x *BalanceTaskParams) GetTimeoutSeconds() int32 {
if x != nil {
return x.TimeoutSeconds
}
return 0
}
func (x *BalanceTaskParams) GetMaxConcurrentMoves() int32 {
if x != nil {
return x.MaxConcurrentMoves
}
return 0
}
func (x *BalanceTaskParams) GetMoves() []*BalanceMoveSpec {
if x != nil {
return x.Moves
}
return nil
}
// ReplicationTaskParams for adding replicas
type ReplicationTaskParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
ReplicaCount int32 `protobuf:"varint,1,opt,name=replica_count,json=replicaCount,proto3" json:"replica_count,omitempty"` // Target replica count
VerifyConsistency bool `protobuf:"varint,2,opt,name=verify_consistency,json=verifyConsistency,proto3" json:"verify_consistency,omitempty"` // Verify replica consistency after creation
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ReplicationTaskParams) Reset() {
*x = ReplicationTaskParams{}
mi := &file_worker_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ReplicationTaskParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReplicationTaskParams) ProtoMessage() {}
func (x *ReplicationTaskParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[17]
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 ReplicationTaskParams.ProtoReflect.Descriptor instead.
func (*ReplicationTaskParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{17}
}
func (x *ReplicationTaskParams) GetReplicaCount() int32 {
if x != nil {
return x.ReplicaCount
}
return 0
}
func (x *ReplicationTaskParams) GetVerifyConsistency() bool {
if x != nil {
return x.VerifyConsistency
}
return false
}
// TaskUpdate reports task progress
type TaskUpdate struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
WorkerId string `protobuf:"bytes,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Status string `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
Progress float32 `protobuf:"fixed32,4,opt,name=progress,proto3" json:"progress,omitempty"`
Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
Metadata map[string]string `protobuf:"bytes,6,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskUpdate) Reset() {
*x = TaskUpdate{}
mi := &file_worker_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskUpdate) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskUpdate) ProtoMessage() {}
func (x *TaskUpdate) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[18]
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 TaskUpdate.ProtoReflect.Descriptor instead.
func (*TaskUpdate) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{18}
}
func (x *TaskUpdate) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskUpdate) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskUpdate) GetStatus() string {
if x != nil {
return x.Status
}
return ""
}
func (x *TaskUpdate) GetProgress() float32 {
if x != nil {
return x.Progress
}
return 0
}
func (x *TaskUpdate) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *TaskUpdate) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// TaskComplete reports task completion
type TaskComplete struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
WorkerId string `protobuf:"bytes,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Success bool `protobuf:"varint,3,opt,name=success,proto3" json:"success,omitempty"`
ErrorMessage string `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
CompletionTime int64 `protobuf:"varint,5,opt,name=completion_time,json=completionTime,proto3" json:"completion_time,omitempty"`
ResultMetadata map[string]string `protobuf:"bytes,6,rep,name=result_metadata,json=resultMetadata,proto3" json:"result_metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskComplete) Reset() {
*x = TaskComplete{}
mi := &file_worker_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskComplete) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskComplete) ProtoMessage() {}
func (x *TaskComplete) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[19]
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 TaskComplete.ProtoReflect.Descriptor instead.
func (*TaskComplete) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{19}
}
func (x *TaskComplete) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskComplete) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskComplete) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
func (x *TaskComplete) GetErrorMessage() string {
if x != nil {
return x.ErrorMessage
}
return ""
}
func (x *TaskComplete) GetCompletionTime() int64 {
if x != nil {
return x.CompletionTime
}
return 0
}
func (x *TaskComplete) GetResultMetadata() map[string]string {
if x != nil {
return x.ResultMetadata
}
return nil
}
// TaskCancellation from admin to cancel a task
type TaskCancellation struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
Force bool `protobuf:"varint,3,opt,name=force,proto3" json:"force,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskCancellation) Reset() {
*x = TaskCancellation{}
mi := &file_worker_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskCancellation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskCancellation) ProtoMessage() {}
func (x *TaskCancellation) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[20]
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 TaskCancellation.ProtoReflect.Descriptor instead.
func (*TaskCancellation) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{20}
}
func (x *TaskCancellation) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskCancellation) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
func (x *TaskCancellation) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
// WorkerShutdown notifies admin that worker is shutting down
type WorkerShutdown struct {
state protoimpl.MessageState `protogen:"open.v1"`
WorkerId string `protobuf:"bytes,1,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
PendingTaskIds []string `protobuf:"bytes,3,rep,name=pending_task_ids,json=pendingTaskIds,proto3" json:"pending_task_ids,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *WorkerShutdown) Reset() {
*x = WorkerShutdown{}
mi := &file_worker_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *WorkerShutdown) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*WorkerShutdown) ProtoMessage() {}
func (x *WorkerShutdown) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[21]
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 WorkerShutdown.ProtoReflect.Descriptor instead.
func (*WorkerShutdown) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{21}
}
func (x *WorkerShutdown) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *WorkerShutdown) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
func (x *WorkerShutdown) GetPendingTaskIds() []string {
if x != nil {
return x.PendingTaskIds
}
return nil
}
// AdminShutdown notifies worker that admin is shutting down
type AdminShutdown struct {
state protoimpl.MessageState `protogen:"open.v1"`
Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"`
GracefulShutdownSeconds int32 `protobuf:"varint,2,opt,name=graceful_shutdown_seconds,json=gracefulShutdownSeconds,proto3" json:"graceful_shutdown_seconds,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *AdminShutdown) Reset() {
*x = AdminShutdown{}
mi := &file_worker_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *AdminShutdown) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AdminShutdown) ProtoMessage() {}
func (x *AdminShutdown) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[22]
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 AdminShutdown.ProtoReflect.Descriptor instead.
func (*AdminShutdown) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{22}
}
func (x *AdminShutdown) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
func (x *AdminShutdown) GetGracefulShutdownSeconds() int32 {
if x != nil {
return x.GracefulShutdownSeconds
}
return 0
}
// TaskLogRequest requests logs for a specific task
type TaskLogRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
WorkerId string `protobuf:"bytes,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
IncludeMetadata bool `protobuf:"varint,3,opt,name=include_metadata,json=includeMetadata,proto3" json:"include_metadata,omitempty"` // Include task metadata
MaxEntries int32 `protobuf:"varint,4,opt,name=max_entries,json=maxEntries,proto3" json:"max_entries,omitempty"` // Maximum number of log entries (0 = all)
LogLevel string `protobuf:"bytes,5,opt,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"` // Filter by log level (INFO, WARNING, ERROR, DEBUG)
StartTime int64 `protobuf:"varint,6,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` // Unix timestamp for start time filter
EndTime int64 `protobuf:"varint,7,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` // Unix timestamp for end time filter
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskLogRequest) Reset() {
*x = TaskLogRequest{}
mi := &file_worker_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskLogRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskLogRequest) ProtoMessage() {}
func (x *TaskLogRequest) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[23]
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 TaskLogRequest.ProtoReflect.Descriptor instead.
func (*TaskLogRequest) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{23}
}
func (x *TaskLogRequest) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskLogRequest) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskLogRequest) GetIncludeMetadata() bool {
if x != nil {
return x.IncludeMetadata
}
return false
}
func (x *TaskLogRequest) GetMaxEntries() int32 {
if x != nil {
return x.MaxEntries
}
return 0
}
func (x *TaskLogRequest) GetLogLevel() string {
if x != nil {
return x.LogLevel
}
return ""
}
func (x *TaskLogRequest) GetStartTime() int64 {
if x != nil {
return x.StartTime
}
return 0
}
func (x *TaskLogRequest) GetEndTime() int64 {
if x != nil {
return x.EndTime
}
return 0
}
// TaskLogResponse returns task logs and metadata
type TaskLogResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
WorkerId string `protobuf:"bytes,2,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Success bool `protobuf:"varint,3,opt,name=success,proto3" json:"success,omitempty"`
ErrorMessage string `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
Metadata *TaskLogMetadata `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"`
LogEntries []*TaskLogEntry `protobuf:"bytes,6,rep,name=log_entries,json=logEntries,proto3" json:"log_entries,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskLogResponse) Reset() {
*x = TaskLogResponse{}
mi := &file_worker_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskLogResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskLogResponse) ProtoMessage() {}
func (x *TaskLogResponse) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[24]
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 TaskLogResponse.ProtoReflect.Descriptor instead.
func (*TaskLogResponse) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{24}
}
func (x *TaskLogResponse) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskLogResponse) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskLogResponse) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
func (x *TaskLogResponse) GetErrorMessage() string {
if x != nil {
return x.ErrorMessage
}
return ""
}
func (x *TaskLogResponse) GetMetadata() *TaskLogMetadata {
if x != nil {
return x.Metadata
}
return nil
}
func (x *TaskLogResponse) GetLogEntries() []*TaskLogEntry {
if x != nil {
return x.LogEntries
}
return nil
}
// TaskLogMetadata contains metadata about task execution
type TaskLogMetadata struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
TaskType string `protobuf:"bytes,2,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"`
WorkerId string `protobuf:"bytes,3,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
StartTime int64 `protobuf:"varint,4,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
EndTime int64 `protobuf:"varint,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
DurationMs int64 `protobuf:"varint,6,opt,name=duration_ms,json=durationMs,proto3" json:"duration_ms,omitempty"`
Status string `protobuf:"bytes,7,opt,name=status,proto3" json:"status,omitempty"`
Progress float32 `protobuf:"fixed32,8,opt,name=progress,proto3" json:"progress,omitempty"`
VolumeId uint32 `protobuf:"varint,9,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
Server string `protobuf:"bytes,10,opt,name=server,proto3" json:"server,omitempty"`
Collection string `protobuf:"bytes,11,opt,name=collection,proto3" json:"collection,omitempty"`
LogFilePath string `protobuf:"bytes,12,opt,name=log_file_path,json=logFilePath,proto3" json:"log_file_path,omitempty"`
CreatedAt int64 `protobuf:"varint,13,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
CustomData map[string]string `protobuf:"bytes,14,rep,name=custom_data,json=customData,proto3" json:"custom_data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskLogMetadata) Reset() {
*x = TaskLogMetadata{}
mi := &file_worker_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskLogMetadata) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskLogMetadata) ProtoMessage() {}
func (x *TaskLogMetadata) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[25]
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 TaskLogMetadata.ProtoReflect.Descriptor instead.
func (*TaskLogMetadata) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{25}
}
func (x *TaskLogMetadata) GetTaskId() string {
if x != nil {
return x.TaskId
}
return ""
}
func (x *TaskLogMetadata) GetTaskType() string {
if x != nil {
return x.TaskType
}
return ""
}
func (x *TaskLogMetadata) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskLogMetadata) GetStartTime() int64 {
if x != nil {
return x.StartTime
}
return 0
}
func (x *TaskLogMetadata) GetEndTime() int64 {
if x != nil {
return x.EndTime
}
return 0
}
func (x *TaskLogMetadata) GetDurationMs() int64 {
if x != nil {
return x.DurationMs
}
return 0
}
func (x *TaskLogMetadata) GetStatus() string {
if x != nil {
return x.Status
}
return ""
}
func (x *TaskLogMetadata) GetProgress() float32 {
if x != nil {
return x.Progress
}
return 0
}
func (x *TaskLogMetadata) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *TaskLogMetadata) GetServer() string {
if x != nil {
return x.Server
}
return ""
}
func (x *TaskLogMetadata) GetCollection() string {
if x != nil {
return x.Collection
}
return ""
}
func (x *TaskLogMetadata) GetLogFilePath() string {
if x != nil {
return x.LogFilePath
}
return ""
}
func (x *TaskLogMetadata) GetCreatedAt() int64 {
if x != nil {
return x.CreatedAt
}
return 0
}
func (x *TaskLogMetadata) GetCustomData() map[string]string {
if x != nil {
return x.CustomData
}
return nil
}
// TaskLogEntry represents a single log entry
type TaskLogEntry struct {
state protoimpl.MessageState `protogen:"open.v1"`
Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
Level string `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"`
Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
Fields map[string]string `protobuf:"bytes,4,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
Progress float32 `protobuf:"fixed32,5,opt,name=progress,proto3" json:"progress,omitempty"`
Status string `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskLogEntry) Reset() {
*x = TaskLogEntry{}
mi := &file_worker_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskLogEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskLogEntry) ProtoMessage() {}
func (x *TaskLogEntry) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[26]
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 TaskLogEntry.ProtoReflect.Descriptor instead.
func (*TaskLogEntry) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{26}
}
func (x *TaskLogEntry) GetTimestamp() int64 {
if x != nil {
return x.Timestamp
}
return 0
}
func (x *TaskLogEntry) GetLevel() string {
if x != nil {
return x.Level
}
return ""
}
func (x *TaskLogEntry) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *TaskLogEntry) GetFields() map[string]string {
if x != nil {
return x.Fields
}
return nil
}
func (x *TaskLogEntry) GetProgress() float32 {
if x != nil {
return x.Progress
}
return 0
}
func (x *TaskLogEntry) GetStatus() string {
if x != nil {
return x.Status
}
return ""
}
// MaintenanceConfig holds configuration for the maintenance system
type MaintenanceConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
ScanIntervalSeconds int32 `protobuf:"varint,2,opt,name=scan_interval_seconds,json=scanIntervalSeconds,proto3" json:"scan_interval_seconds,omitempty"` // How often to scan for maintenance needs
WorkerTimeoutSeconds int32 `protobuf:"varint,3,opt,name=worker_timeout_seconds,json=workerTimeoutSeconds,proto3" json:"worker_timeout_seconds,omitempty"` // Worker heartbeat timeout
TaskTimeoutSeconds int32 `protobuf:"varint,4,opt,name=task_timeout_seconds,json=taskTimeoutSeconds,proto3" json:"task_timeout_seconds,omitempty"` // Individual task timeout
RetryDelaySeconds int32 `protobuf:"varint,5,opt,name=retry_delay_seconds,json=retryDelaySeconds,proto3" json:"retry_delay_seconds,omitempty"` // Delay between retries
MaxRetries int32 `protobuf:"varint,6,opt,name=max_retries,json=maxRetries,proto3" json:"max_retries,omitempty"` // Default max retries for tasks
CleanupIntervalSeconds int32 `protobuf:"varint,7,opt,name=cleanup_interval_seconds,json=cleanupIntervalSeconds,proto3" json:"cleanup_interval_seconds,omitempty"` // How often to clean up old tasks
TaskRetentionSeconds int32 `protobuf:"varint,8,opt,name=task_retention_seconds,json=taskRetentionSeconds,proto3" json:"task_retention_seconds,omitempty"` // How long to keep completed/failed tasks
Policy *MaintenancePolicy `protobuf:"bytes,9,opt,name=policy,proto3" json:"policy,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *MaintenanceConfig) Reset() {
*x = MaintenanceConfig{}
mi := &file_worker_proto_msgTypes[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MaintenanceConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MaintenanceConfig) ProtoMessage() {}
func (x *MaintenanceConfig) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[27]
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 MaintenanceConfig.ProtoReflect.Descriptor instead.
func (*MaintenanceConfig) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{27}
}
func (x *MaintenanceConfig) GetEnabled() bool {
if x != nil {
return x.Enabled
}
return false
}
func (x *MaintenanceConfig) GetScanIntervalSeconds() int32 {
if x != nil {
return x.ScanIntervalSeconds
}
return 0
}
func (x *MaintenanceConfig) GetWorkerTimeoutSeconds() int32 {
if x != nil {
return x.WorkerTimeoutSeconds
}
return 0
}
func (x *MaintenanceConfig) GetTaskTimeoutSeconds() int32 {
if x != nil {
return x.TaskTimeoutSeconds
}
return 0
}
func (x *MaintenanceConfig) GetRetryDelaySeconds() int32 {
if x != nil {
return x.RetryDelaySeconds
}
return 0
}
func (x *MaintenanceConfig) GetMaxRetries() int32 {
if x != nil {
return x.MaxRetries
}
return 0
}
func (x *MaintenanceConfig) GetCleanupIntervalSeconds() int32 {
if x != nil {
return x.CleanupIntervalSeconds
}
return 0
}
func (x *MaintenanceConfig) GetTaskRetentionSeconds() int32 {
if x != nil {
return x.TaskRetentionSeconds
}
return 0
}
func (x *MaintenanceConfig) GetPolicy() *MaintenancePolicy {
if x != nil {
return x.Policy
}
return nil
}
// MaintenancePolicy defines policies for maintenance operations
type MaintenancePolicy struct {
state protoimpl.MessageState `protogen:"open.v1"`
TaskPolicies map[string]*TaskPolicy `protobuf:"bytes,1,rep,name=task_policies,json=taskPolicies,proto3" json:"task_policies,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // Task type -> policy mapping
GlobalMaxConcurrent int32 `protobuf:"varint,2,opt,name=global_max_concurrent,json=globalMaxConcurrent,proto3" json:"global_max_concurrent,omitempty"` // Overall limit across all task types
DefaultRepeatIntervalSeconds int32 `protobuf:"varint,3,opt,name=default_repeat_interval_seconds,json=defaultRepeatIntervalSeconds,proto3" json:"default_repeat_interval_seconds,omitempty"` // Default seconds if task doesn't specify
DefaultCheckIntervalSeconds int32 `protobuf:"varint,4,opt,name=default_check_interval_seconds,json=defaultCheckIntervalSeconds,proto3" json:"default_check_interval_seconds,omitempty"` // Default seconds for periodic checks
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *MaintenancePolicy) Reset() {
*x = MaintenancePolicy{}
mi := &file_worker_proto_msgTypes[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MaintenancePolicy) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MaintenancePolicy) ProtoMessage() {}
func (x *MaintenancePolicy) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[28]
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 MaintenancePolicy.ProtoReflect.Descriptor instead.
func (*MaintenancePolicy) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{28}
}
func (x *MaintenancePolicy) GetTaskPolicies() map[string]*TaskPolicy {
if x != nil {
return x.TaskPolicies
}
return nil
}
func (x *MaintenancePolicy) GetGlobalMaxConcurrent() int32 {
if x != nil {
return x.GlobalMaxConcurrent
}
return 0
}
func (x *MaintenancePolicy) GetDefaultRepeatIntervalSeconds() int32 {
if x != nil {
return x.DefaultRepeatIntervalSeconds
}
return 0
}
func (x *MaintenancePolicy) GetDefaultCheckIntervalSeconds() int32 {
if x != nil {
return x.DefaultCheckIntervalSeconds
}
return 0
}
// TaskPolicy represents configuration for a specific task type
type TaskPolicy struct {
state protoimpl.MessageState `protogen:"open.v1"`
Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
MaxConcurrent int32 `protobuf:"varint,2,opt,name=max_concurrent,json=maxConcurrent,proto3" json:"max_concurrent,omitempty"`
RepeatIntervalSeconds int32 `protobuf:"varint,3,opt,name=repeat_interval_seconds,json=repeatIntervalSeconds,proto3" json:"repeat_interval_seconds,omitempty"` // Seconds to wait before repeating
CheckIntervalSeconds int32 `protobuf:"varint,4,opt,name=check_interval_seconds,json=checkIntervalSeconds,proto3" json:"check_interval_seconds,omitempty"` // Seconds between checks
// Typed task-specific configuration (replaces generic map)
//
// Types that are valid to be assigned to TaskConfig:
//
// *TaskPolicy_VacuumConfig
// *TaskPolicy_ErasureCodingConfig
// *TaskPolicy_BalanceConfig
// *TaskPolicy_ReplicationConfig
// *TaskPolicy_EcBalanceConfig
TaskConfig isTaskPolicy_TaskConfig `protobuf_oneof:"task_config"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskPolicy) Reset() {
*x = TaskPolicy{}
mi := &file_worker_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskPolicy) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskPolicy) ProtoMessage() {}
func (x *TaskPolicy) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[29]
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 TaskPolicy.ProtoReflect.Descriptor instead.
func (*TaskPolicy) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{29}
}
func (x *TaskPolicy) GetEnabled() bool {
if x != nil {
return x.Enabled
}
return false
}
func (x *TaskPolicy) GetMaxConcurrent() int32 {
if x != nil {
return x.MaxConcurrent
}
return 0
}
func (x *TaskPolicy) GetRepeatIntervalSeconds() int32 {
if x != nil {
return x.RepeatIntervalSeconds
}
return 0
}
func (x *TaskPolicy) GetCheckIntervalSeconds() int32 {
if x != nil {
return x.CheckIntervalSeconds
}
return 0
}
func (x *TaskPolicy) GetTaskConfig() isTaskPolicy_TaskConfig {
if x != nil {
return x.TaskConfig
}
return nil
}
func (x *TaskPolicy) GetVacuumConfig() *VacuumTaskConfig {
if x != nil {
if x, ok := x.TaskConfig.(*TaskPolicy_VacuumConfig); ok {
return x.VacuumConfig
}
}
return nil
}
func (x *TaskPolicy) GetErasureCodingConfig() *ErasureCodingTaskConfig {
if x != nil {
if x, ok := x.TaskConfig.(*TaskPolicy_ErasureCodingConfig); ok {
return x.ErasureCodingConfig
}
}
return nil
}
func (x *TaskPolicy) GetBalanceConfig() *BalanceTaskConfig {
if x != nil {
if x, ok := x.TaskConfig.(*TaskPolicy_BalanceConfig); ok {
return x.BalanceConfig
}
}
return nil
}
func (x *TaskPolicy) GetReplicationConfig() *ReplicationTaskConfig {
if x != nil {
if x, ok := x.TaskConfig.(*TaskPolicy_ReplicationConfig); ok {
return x.ReplicationConfig
}
}
return nil
}
func (x *TaskPolicy) GetEcBalanceConfig() *EcBalanceTaskConfig {
if x != nil {
if x, ok := x.TaskConfig.(*TaskPolicy_EcBalanceConfig); ok {
return x.EcBalanceConfig
}
}
return nil
}
type isTaskPolicy_TaskConfig interface {
isTaskPolicy_TaskConfig()
}
type TaskPolicy_VacuumConfig struct {
VacuumConfig *VacuumTaskConfig `protobuf:"bytes,5,opt,name=vacuum_config,json=vacuumConfig,proto3,oneof"`
}
type TaskPolicy_ErasureCodingConfig struct {
ErasureCodingConfig *ErasureCodingTaskConfig `protobuf:"bytes,6,opt,name=erasure_coding_config,json=erasureCodingConfig,proto3,oneof"`
}
type TaskPolicy_BalanceConfig struct {
BalanceConfig *BalanceTaskConfig `protobuf:"bytes,7,opt,name=balance_config,json=balanceConfig,proto3,oneof"`
}
type TaskPolicy_ReplicationConfig struct {
ReplicationConfig *ReplicationTaskConfig `protobuf:"bytes,8,opt,name=replication_config,json=replicationConfig,proto3,oneof"`
}
type TaskPolicy_EcBalanceConfig struct {
EcBalanceConfig *EcBalanceTaskConfig `protobuf:"bytes,9,opt,name=ec_balance_config,json=ecBalanceConfig,proto3,oneof"`
}
func (*TaskPolicy_VacuumConfig) isTaskPolicy_TaskConfig() {}
func (*TaskPolicy_ErasureCodingConfig) isTaskPolicy_TaskConfig() {}
func (*TaskPolicy_BalanceConfig) isTaskPolicy_TaskConfig() {}
func (*TaskPolicy_ReplicationConfig) isTaskPolicy_TaskConfig() {}
func (*TaskPolicy_EcBalanceConfig) isTaskPolicy_TaskConfig() {}
// VacuumTaskConfig contains vacuum-specific configuration
type VacuumTaskConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
GarbageThreshold float64 `protobuf:"fixed64,1,opt,name=garbage_threshold,json=garbageThreshold,proto3" json:"garbage_threshold,omitempty"` // Minimum garbage ratio to trigger vacuum (0.0-1.0)
MinVolumeAgeHours int32 `protobuf:"varint,2,opt,name=min_volume_age_hours,json=minVolumeAgeHours,proto3" json:"min_volume_age_hours,omitempty"` // Minimum age before vacuum is considered
MinIntervalSeconds int32 `protobuf:"varint,3,opt,name=min_interval_seconds,json=minIntervalSeconds,proto3" json:"min_interval_seconds,omitempty"` // Minimum time between vacuum operations on the same volume
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *VacuumTaskConfig) Reset() {
*x = VacuumTaskConfig{}
mi := &file_worker_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *VacuumTaskConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VacuumTaskConfig) ProtoMessage() {}
func (x *VacuumTaskConfig) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[30]
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 VacuumTaskConfig.ProtoReflect.Descriptor instead.
func (*VacuumTaskConfig) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{30}
}
func (x *VacuumTaskConfig) GetGarbageThreshold() float64 {
if x != nil {
return x.GarbageThreshold
}
return 0
}
func (x *VacuumTaskConfig) GetMinVolumeAgeHours() int32 {
if x != nil {
return x.MinVolumeAgeHours
}
return 0
}
func (x *VacuumTaskConfig) GetMinIntervalSeconds() int32 {
if x != nil {
return x.MinIntervalSeconds
}
return 0
}
// ErasureCodingTaskConfig contains EC-specific configuration
type ErasureCodingTaskConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
FullnessRatio float64 `protobuf:"fixed64,1,opt,name=fullness_ratio,json=fullnessRatio,proto3" json:"fullness_ratio,omitempty"` // Minimum fullness ratio to trigger EC (0.0-1.0)
QuietForSeconds int32 `protobuf:"varint,2,opt,name=quiet_for_seconds,json=quietForSeconds,proto3" json:"quiet_for_seconds,omitempty"` // Minimum quiet time before EC
MinVolumeSizeMb int32 `protobuf:"varint,3,opt,name=min_volume_size_mb,json=minVolumeSizeMb,proto3" json:"min_volume_size_mb,omitempty"` // Minimum volume size for EC
CollectionFilter string `protobuf:"bytes,4,opt,name=collection_filter,json=collectionFilter,proto3" json:"collection_filter,omitempty"` // Only process volumes from specific collections
PreferredTags []string `protobuf:"bytes,5,rep,name=preferred_tags,json=preferredTags,proto3" json:"preferred_tags,omitempty"` // Disk tags to prioritize for EC shard placement
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ErasureCodingTaskConfig) Reset() {
*x = ErasureCodingTaskConfig{}
mi := &file_worker_proto_msgTypes[31]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ErasureCodingTaskConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ErasureCodingTaskConfig) ProtoMessage() {}
func (x *ErasureCodingTaskConfig) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[31]
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 ErasureCodingTaskConfig.ProtoReflect.Descriptor instead.
func (*ErasureCodingTaskConfig) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{31}
}
func (x *ErasureCodingTaskConfig) GetFullnessRatio() float64 {
if x != nil {
return x.FullnessRatio
}
return 0
}
func (x *ErasureCodingTaskConfig) GetQuietForSeconds() int32 {
if x != nil {
return x.QuietForSeconds
}
return 0
}
func (x *ErasureCodingTaskConfig) GetMinVolumeSizeMb() int32 {
if x != nil {
return x.MinVolumeSizeMb
}
return 0
}
func (x *ErasureCodingTaskConfig) GetCollectionFilter() string {
if x != nil {
return x.CollectionFilter
}
return ""
}
func (x *ErasureCodingTaskConfig) GetPreferredTags() []string {
if x != nil {
return x.PreferredTags
}
return nil
}
// BalanceTaskConfig contains balance-specific configuration
type BalanceTaskConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
ImbalanceThreshold float64 `protobuf:"fixed64,1,opt,name=imbalance_threshold,json=imbalanceThreshold,proto3" json:"imbalance_threshold,omitempty"` // Threshold for triggering rebalancing (0.0-1.0)
MinServerCount int32 `protobuf:"varint,2,opt,name=min_server_count,json=minServerCount,proto3" json:"min_server_count,omitempty"` // Minimum number of servers required for balancing
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *BalanceTaskConfig) Reset() {
*x = BalanceTaskConfig{}
mi := &file_worker_proto_msgTypes[32]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *BalanceTaskConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BalanceTaskConfig) ProtoMessage() {}
func (x *BalanceTaskConfig) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[32]
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 BalanceTaskConfig.ProtoReflect.Descriptor instead.
func (*BalanceTaskConfig) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{32}
}
func (x *BalanceTaskConfig) GetImbalanceThreshold() float64 {
if x != nil {
return x.ImbalanceThreshold
}
return 0
}
func (x *BalanceTaskConfig) GetMinServerCount() int32 {
if x != nil {
return x.MinServerCount
}
return 0
}
// ReplicationTaskConfig contains replication-specific configuration
type ReplicationTaskConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
TargetReplicaCount int32 `protobuf:"varint,1,opt,name=target_replica_count,json=targetReplicaCount,proto3" json:"target_replica_count,omitempty"` // Target number of replicas
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ReplicationTaskConfig) Reset() {
*x = ReplicationTaskConfig{}
mi := &file_worker_proto_msgTypes[33]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ReplicationTaskConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReplicationTaskConfig) ProtoMessage() {}
func (x *ReplicationTaskConfig) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[33]
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 ReplicationTaskConfig.ProtoReflect.Descriptor instead.
func (*ReplicationTaskConfig) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{33}
}
func (x *ReplicationTaskConfig) GetTargetReplicaCount() int32 {
if x != nil {
return x.TargetReplicaCount
}
return 0
}
// EcBalanceTaskParams for EC shard balancing operations
type EcBalanceTaskParams struct {
state protoimpl.MessageState `protogen:"open.v1"`
DiskType string `protobuf:"bytes,1,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"` // Disk type filter (hdd, ssd, "")
MaxParallelization int32 `protobuf:"varint,2,opt,name=max_parallelization,json=maxParallelization,proto3" json:"max_parallelization,omitempty"` // Max parallel shard moves within a batch
TimeoutSeconds int32 `protobuf:"varint,3,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"` // Operation timeout per move
Moves []*EcShardMoveSpec `protobuf:"bytes,4,rep,name=moves,proto3" json:"moves,omitempty"` // Batch: multiple shard moves in one job
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EcBalanceTaskParams) Reset() {
*x = EcBalanceTaskParams{}
mi := &file_worker_proto_msgTypes[34]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EcBalanceTaskParams) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EcBalanceTaskParams) ProtoMessage() {}
func (x *EcBalanceTaskParams) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[34]
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 EcBalanceTaskParams.ProtoReflect.Descriptor instead.
func (*EcBalanceTaskParams) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{34}
}
func (x *EcBalanceTaskParams) GetDiskType() string {
if x != nil {
return x.DiskType
}
return ""
}
func (x *EcBalanceTaskParams) GetMaxParallelization() int32 {
if x != nil {
return x.MaxParallelization
}
return 0
}
func (x *EcBalanceTaskParams) GetTimeoutSeconds() int32 {
if x != nil {
return x.TimeoutSeconds
}
return 0
}
func (x *EcBalanceTaskParams) GetMoves() []*EcShardMoveSpec {
if x != nil {
return x.Moves
}
return nil
}
// EcShardMoveSpec describes a single EC shard move within a batch
type EcShardMoveSpec struct {
state protoimpl.MessageState `protogen:"open.v1"`
VolumeId uint32 `protobuf:"varint,1,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"` // EC volume ID
ShardId uint32 `protobuf:"varint,2,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"` // Shard ID (0-13)
Collection string `protobuf:"bytes,3,opt,name=collection,proto3" json:"collection,omitempty"` // Collection name
SourceNode string `protobuf:"bytes,4,opt,name=source_node,json=sourceNode,proto3" json:"source_node,omitempty"` // Source server address
SourceDiskId uint32 `protobuf:"varint,5,opt,name=source_disk_id,json=sourceDiskId,proto3" json:"source_disk_id,omitempty"` // Source disk ID
TargetNode string `protobuf:"bytes,6,opt,name=target_node,json=targetNode,proto3" json:"target_node,omitempty"` // Target server address
TargetDiskId uint32 `protobuf:"varint,7,opt,name=target_disk_id,json=targetDiskId,proto3" json:"target_disk_id,omitempty"` // Target disk ID
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EcShardMoveSpec) Reset() {
*x = EcShardMoveSpec{}
mi := &file_worker_proto_msgTypes[35]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EcShardMoveSpec) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EcShardMoveSpec) ProtoMessage() {}
func (x *EcShardMoveSpec) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[35]
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 EcShardMoveSpec.ProtoReflect.Descriptor instead.
func (*EcShardMoveSpec) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{35}
}
func (x *EcShardMoveSpec) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *EcShardMoveSpec) GetShardId() uint32 {
if x != nil {
return x.ShardId
}
return 0
}
func (x *EcShardMoveSpec) GetCollection() string {
if x != nil {
return x.Collection
}
return ""
}
func (x *EcShardMoveSpec) GetSourceNode() string {
if x != nil {
return x.SourceNode
}
return ""
}
func (x *EcShardMoveSpec) GetSourceDiskId() uint32 {
if x != nil {
return x.SourceDiskId
}
return 0
}
func (x *EcShardMoveSpec) GetTargetNode() string {
if x != nil {
return x.TargetNode
}
return ""
}
func (x *EcShardMoveSpec) GetTargetDiskId() uint32 {
if x != nil {
return x.TargetDiskId
}
return 0
}
// EcBalanceTaskConfig contains EC balance-specific configuration
type EcBalanceTaskConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
ImbalanceThreshold float64 `protobuf:"fixed64,1,opt,name=imbalance_threshold,json=imbalanceThreshold,proto3" json:"imbalance_threshold,omitempty"` // Threshold for triggering EC shard rebalancing
MinServerCount int32 `protobuf:"varint,2,opt,name=min_server_count,json=minServerCount,proto3" json:"min_server_count,omitempty"` // Minimum number of servers required
CollectionFilter string `protobuf:"bytes,3,opt,name=collection_filter,json=collectionFilter,proto3" json:"collection_filter,omitempty"` // Collection filter
DiskType string `protobuf:"bytes,4,opt,name=disk_type,json=diskType,proto3" json:"disk_type,omitempty"` // Disk type filter
PreferredTags []string `protobuf:"bytes,5,rep,name=preferred_tags,json=preferredTags,proto3" json:"preferred_tags,omitempty"` // Preferred disk tags for placement
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EcBalanceTaskConfig) Reset() {
*x = EcBalanceTaskConfig{}
mi := &file_worker_proto_msgTypes[36]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EcBalanceTaskConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EcBalanceTaskConfig) ProtoMessage() {}
func (x *EcBalanceTaskConfig) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[36]
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 EcBalanceTaskConfig.ProtoReflect.Descriptor instead.
func (*EcBalanceTaskConfig) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{36}
}
func (x *EcBalanceTaskConfig) GetImbalanceThreshold() float64 {
if x != nil {
return x.ImbalanceThreshold
}
return 0
}
func (x *EcBalanceTaskConfig) GetMinServerCount() int32 {
if x != nil {
return x.MinServerCount
}
return 0
}
func (x *EcBalanceTaskConfig) GetCollectionFilter() string {
if x != nil {
return x.CollectionFilter
}
return ""
}
func (x *EcBalanceTaskConfig) GetDiskType() string {
if x != nil {
return x.DiskType
}
return ""
}
func (x *EcBalanceTaskConfig) GetPreferredTags() []string {
if x != nil {
return x.PreferredTags
}
return nil
}
// MaintenanceTaskData represents complete task state for persistence
type MaintenanceTaskData struct {
state protoimpl.MessageState `protogen:"open.v1"`
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
Priority string `protobuf:"bytes,3,opt,name=priority,proto3" json:"priority,omitempty"`
Status string `protobuf:"bytes,4,opt,name=status,proto3" json:"status,omitempty"`
VolumeId uint32 `protobuf:"varint,5,opt,name=volume_id,json=volumeId,proto3" json:"volume_id,omitempty"`
Server string `protobuf:"bytes,6,opt,name=server,proto3" json:"server,omitempty"`
Collection string `protobuf:"bytes,7,opt,name=collection,proto3" json:"collection,omitempty"`
TypedParams *TaskParams `protobuf:"bytes,8,opt,name=typed_params,json=typedParams,proto3" json:"typed_params,omitempty"`
Reason string `protobuf:"bytes,9,opt,name=reason,proto3" json:"reason,omitempty"`
CreatedAt int64 `protobuf:"varint,10,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
ScheduledAt int64 `protobuf:"varint,11,opt,name=scheduled_at,json=scheduledAt,proto3" json:"scheduled_at,omitempty"`
StartedAt int64 `protobuf:"varint,12,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
CompletedAt int64 `protobuf:"varint,13,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"`
WorkerId string `protobuf:"bytes,14,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
Error string `protobuf:"bytes,15,opt,name=error,proto3" json:"error,omitempty"`
Progress float64 `protobuf:"fixed64,16,opt,name=progress,proto3" json:"progress,omitempty"`
RetryCount int32 `protobuf:"varint,17,opt,name=retry_count,json=retryCount,proto3" json:"retry_count,omitempty"`
MaxRetries int32 `protobuf:"varint,18,opt,name=max_retries,json=maxRetries,proto3" json:"max_retries,omitempty"`
// Enhanced fields for detailed task tracking
CreatedBy string `protobuf:"bytes,19,opt,name=created_by,json=createdBy,proto3" json:"created_by,omitempty"`
CreationContext string `protobuf:"bytes,20,opt,name=creation_context,json=creationContext,proto3" json:"creation_context,omitempty"`
AssignmentHistory []*TaskAssignmentRecord `protobuf:"bytes,21,rep,name=assignment_history,json=assignmentHistory,proto3" json:"assignment_history,omitempty"`
DetailedReason string `protobuf:"bytes,22,opt,name=detailed_reason,json=detailedReason,proto3" json:"detailed_reason,omitempty"`
Tags map[string]string `protobuf:"bytes,23,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
CreationMetrics *TaskCreationMetrics `protobuf:"bytes,24,opt,name=creation_metrics,json=creationMetrics,proto3" json:"creation_metrics,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *MaintenanceTaskData) Reset() {
*x = MaintenanceTaskData{}
mi := &file_worker_proto_msgTypes[37]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *MaintenanceTaskData) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MaintenanceTaskData) ProtoMessage() {}
func (x *MaintenanceTaskData) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[37]
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 MaintenanceTaskData.ProtoReflect.Descriptor instead.
func (*MaintenanceTaskData) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{37}
}
func (x *MaintenanceTaskData) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *MaintenanceTaskData) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *MaintenanceTaskData) GetPriority() string {
if x != nil {
return x.Priority
}
return ""
}
func (x *MaintenanceTaskData) GetStatus() string {
if x != nil {
return x.Status
}
return ""
}
func (x *MaintenanceTaskData) GetVolumeId() uint32 {
if x != nil {
return x.VolumeId
}
return 0
}
func (x *MaintenanceTaskData) GetServer() string {
if x != nil {
return x.Server
}
return ""
}
func (x *MaintenanceTaskData) GetCollection() string {
if x != nil {
return x.Collection
}
return ""
}
func (x *MaintenanceTaskData) GetTypedParams() *TaskParams {
if x != nil {
return x.TypedParams
}
return nil
}
func (x *MaintenanceTaskData) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
func (x *MaintenanceTaskData) GetCreatedAt() int64 {
if x != nil {
return x.CreatedAt
}
return 0
}
func (x *MaintenanceTaskData) GetScheduledAt() int64 {
if x != nil {
return x.ScheduledAt
}
return 0
}
func (x *MaintenanceTaskData) GetStartedAt() int64 {
if x != nil {
return x.StartedAt
}
return 0
}
func (x *MaintenanceTaskData) GetCompletedAt() int64 {
if x != nil {
return x.CompletedAt
}
return 0
}
func (x *MaintenanceTaskData) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *MaintenanceTaskData) GetError() string {
if x != nil {
return x.Error
}
return ""
}
func (x *MaintenanceTaskData) GetProgress() float64 {
if x != nil {
return x.Progress
}
return 0
}
func (x *MaintenanceTaskData) GetRetryCount() int32 {
if x != nil {
return x.RetryCount
}
return 0
}
func (x *MaintenanceTaskData) GetMaxRetries() int32 {
if x != nil {
return x.MaxRetries
}
return 0
}
func (x *MaintenanceTaskData) GetCreatedBy() string {
if x != nil {
return x.CreatedBy
}
return ""
}
func (x *MaintenanceTaskData) GetCreationContext() string {
if x != nil {
return x.CreationContext
}
return ""
}
func (x *MaintenanceTaskData) GetAssignmentHistory() []*TaskAssignmentRecord {
if x != nil {
return x.AssignmentHistory
}
return nil
}
func (x *MaintenanceTaskData) GetDetailedReason() string {
if x != nil {
return x.DetailedReason
}
return ""
}
func (x *MaintenanceTaskData) GetTags() map[string]string {
if x != nil {
return x.Tags
}
return nil
}
func (x *MaintenanceTaskData) GetCreationMetrics() *TaskCreationMetrics {
if x != nil {
return x.CreationMetrics
}
return nil
}
// TaskAssignmentRecord tracks worker assignments for a task
type TaskAssignmentRecord struct {
state protoimpl.MessageState `protogen:"open.v1"`
WorkerId string `protobuf:"bytes,1,opt,name=worker_id,json=workerId,proto3" json:"worker_id,omitempty"`
WorkerAddress string `protobuf:"bytes,2,opt,name=worker_address,json=workerAddress,proto3" json:"worker_address,omitempty"`
AssignedAt int64 `protobuf:"varint,3,opt,name=assigned_at,json=assignedAt,proto3" json:"assigned_at,omitempty"`
UnassignedAt int64 `protobuf:"varint,4,opt,name=unassigned_at,json=unassignedAt,proto3" json:"unassigned_at,omitempty"` // Optional: when worker was unassigned
Reason string `protobuf:"bytes,5,opt,name=reason,proto3" json:"reason,omitempty"` // Reason for assignment/unassignment
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskAssignmentRecord) Reset() {
*x = TaskAssignmentRecord{}
mi := &file_worker_proto_msgTypes[38]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskAssignmentRecord) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskAssignmentRecord) ProtoMessage() {}
func (x *TaskAssignmentRecord) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[38]
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 TaskAssignmentRecord.ProtoReflect.Descriptor instead.
func (*TaskAssignmentRecord) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{38}
}
func (x *TaskAssignmentRecord) GetWorkerId() string {
if x != nil {
return x.WorkerId
}
return ""
}
func (x *TaskAssignmentRecord) GetWorkerAddress() string {
if x != nil {
return x.WorkerAddress
}
return ""
}
func (x *TaskAssignmentRecord) GetAssignedAt() int64 {
if x != nil {
return x.AssignedAt
}
return 0
}
func (x *TaskAssignmentRecord) GetUnassignedAt() int64 {
if x != nil {
return x.UnassignedAt
}
return 0
}
func (x *TaskAssignmentRecord) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
// TaskCreationMetrics tracks why and how a task was created
type TaskCreationMetrics struct {
state protoimpl.MessageState `protogen:"open.v1"`
TriggerMetric string `protobuf:"bytes,1,opt,name=trigger_metric,json=triggerMetric,proto3" json:"trigger_metric,omitempty"` // Name of metric that triggered creation
MetricValue float64 `protobuf:"fixed64,2,opt,name=metric_value,json=metricValue,proto3" json:"metric_value,omitempty"` // Value that triggered creation
Threshold float64 `protobuf:"fixed64,3,opt,name=threshold,proto3" json:"threshold,omitempty"` // Threshold that was exceeded
VolumeMetrics *VolumeHealthMetrics `protobuf:"bytes,4,opt,name=volume_metrics,json=volumeMetrics,proto3" json:"volume_metrics,omitempty"` // Volume health at creation time
AdditionalData map[string]string `protobuf:"bytes,5,rep,name=additional_data,json=additionalData,proto3" json:"additional_data,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // Additional context data
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskCreationMetrics) Reset() {
*x = TaskCreationMetrics{}
mi := &file_worker_proto_msgTypes[39]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskCreationMetrics) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskCreationMetrics) ProtoMessage() {}
func (x *TaskCreationMetrics) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[39]
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 TaskCreationMetrics.ProtoReflect.Descriptor instead.
func (*TaskCreationMetrics) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{39}
}
func (x *TaskCreationMetrics) GetTriggerMetric() string {
if x != nil {
return x.TriggerMetric
}
return ""
}
func (x *TaskCreationMetrics) GetMetricValue() float64 {
if x != nil {
return x.MetricValue
}
return 0
}
func (x *TaskCreationMetrics) GetThreshold() float64 {
if x != nil {
return x.Threshold
}
return 0
}
func (x *TaskCreationMetrics) GetVolumeMetrics() *VolumeHealthMetrics {
if x != nil {
return x.VolumeMetrics
}
return nil
}
func (x *TaskCreationMetrics) GetAdditionalData() map[string]string {
if x != nil {
return x.AdditionalData
}
return nil
}
// VolumeHealthMetrics captures volume state at task creation
type VolumeHealthMetrics struct {
state protoimpl.MessageState `protogen:"open.v1"`
TotalSize uint64 `protobuf:"varint,1,opt,name=total_size,json=totalSize,proto3" json:"total_size,omitempty"`
UsedSize uint64 `protobuf:"varint,2,opt,name=used_size,json=usedSize,proto3" json:"used_size,omitempty"`
GarbageSize uint64 `protobuf:"varint,3,opt,name=garbage_size,json=garbageSize,proto3" json:"garbage_size,omitempty"`
GarbageRatio float64 `protobuf:"fixed64,4,opt,name=garbage_ratio,json=garbageRatio,proto3" json:"garbage_ratio,omitempty"`
FileCount int32 `protobuf:"varint,5,opt,name=file_count,json=fileCount,proto3" json:"file_count,omitempty"`
DeletedFileCount int32 `protobuf:"varint,6,opt,name=deleted_file_count,json=deletedFileCount,proto3" json:"deleted_file_count,omitempty"`
LastModified int64 `protobuf:"varint,7,opt,name=last_modified,json=lastModified,proto3" json:"last_modified,omitempty"`
ReplicaCount int32 `protobuf:"varint,8,opt,name=replica_count,json=replicaCount,proto3" json:"replica_count,omitempty"`
IsEcVolume bool `protobuf:"varint,9,opt,name=is_ec_volume,json=isEcVolume,proto3" json:"is_ec_volume,omitempty"`
Collection string `protobuf:"bytes,10,opt,name=collection,proto3" json:"collection,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *VolumeHealthMetrics) Reset() {
*x = VolumeHealthMetrics{}
mi := &file_worker_proto_msgTypes[40]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *VolumeHealthMetrics) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VolumeHealthMetrics) ProtoMessage() {}
func (x *VolumeHealthMetrics) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[40]
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 VolumeHealthMetrics.ProtoReflect.Descriptor instead.
func (*VolumeHealthMetrics) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{40}
}
func (x *VolumeHealthMetrics) GetTotalSize() uint64 {
if x != nil {
return x.TotalSize
}
return 0
}
func (x *VolumeHealthMetrics) GetUsedSize() uint64 {
if x != nil {
return x.UsedSize
}
return 0
}
func (x *VolumeHealthMetrics) GetGarbageSize() uint64 {
if x != nil {
return x.GarbageSize
}
return 0
}
func (x *VolumeHealthMetrics) GetGarbageRatio() float64 {
if x != nil {
return x.GarbageRatio
}
return 0
}
func (x *VolumeHealthMetrics) GetFileCount() int32 {
if x != nil {
return x.FileCount
}
return 0
}
func (x *VolumeHealthMetrics) GetDeletedFileCount() int32 {
if x != nil {
return x.DeletedFileCount
}
return 0
}
func (x *VolumeHealthMetrics) GetLastModified() int64 {
if x != nil {
return x.LastModified
}
return 0
}
func (x *VolumeHealthMetrics) GetReplicaCount() int32 {
if x != nil {
return x.ReplicaCount
}
return 0
}
func (x *VolumeHealthMetrics) GetIsEcVolume() bool {
if x != nil {
return x.IsEcVolume
}
return false
}
func (x *VolumeHealthMetrics) GetCollection() string {
if x != nil {
return x.Collection
}
return ""
}
// TaskStateFile wraps task data with metadata for persistence
type TaskStateFile struct {
state protoimpl.MessageState `protogen:"open.v1"`
Task *MaintenanceTaskData `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
LastUpdated int64 `protobuf:"varint,2,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty"`
AdminVersion string `protobuf:"bytes,3,opt,name=admin_version,json=adminVersion,proto3" json:"admin_version,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TaskStateFile) Reset() {
*x = TaskStateFile{}
mi := &file_worker_proto_msgTypes[41]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TaskStateFile) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TaskStateFile) ProtoMessage() {}
func (x *TaskStateFile) ProtoReflect() protoreflect.Message {
mi := &file_worker_proto_msgTypes[41]
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 TaskStateFile.ProtoReflect.Descriptor instead.
func (*TaskStateFile) Descriptor() ([]byte, []int) {
return file_worker_proto_rawDescGZIP(), []int{41}
}
func (x *TaskStateFile) GetTask() *MaintenanceTaskData {
if x != nil {
return x.Task
}
return nil
}
func (x *TaskStateFile) GetLastUpdated() int64 {
if x != nil {
return x.LastUpdated
}
return 0
}
func (x *TaskStateFile) GetAdminVersion() string {
if x != nil {
return x.AdminVersion
}
return ""
}
var File_worker_proto protoreflect.FileDescriptor
const file_worker_proto_rawDesc = "" +
"\n" +
"\fworker.proto\x12\tworker_pb\"\x90\x04\n" +
"\rWorkerMessage\x12\x1b\n" +
"\tworker_id\x18\x01 \x01(\tR\bworkerId\x12\x1c\n" +
"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12C\n" +
"\fregistration\x18\x03 \x01(\v2\x1d.worker_pb.WorkerRegistrationH\x00R\fregistration\x12:\n" +
"\theartbeat\x18\x04 \x01(\v2\x1a.worker_pb.WorkerHeartbeatH\x00R\theartbeat\x12;\n" +
"\ftask_request\x18\x05 \x01(\v2\x16.worker_pb.TaskRequestH\x00R\vtaskRequest\x128\n" +
"\vtask_update\x18\x06 \x01(\v2\x15.worker_pb.TaskUpdateH\x00R\n" +
"taskUpdate\x12>\n" +
"\rtask_complete\x18\a \x01(\v2\x17.worker_pb.TaskCompleteH\x00R\ftaskComplete\x127\n" +
"\bshutdown\x18\b \x01(\v2\x19.worker_pb.WorkerShutdownH\x00R\bshutdown\x12H\n" +
"\x11task_log_response\x18\t \x01(\v2\x1a.worker_pb.TaskLogResponseH\x00R\x0ftaskLogResponseB\t\n" +
"\amessage\"\x95\x04\n" +
"\fAdminMessage\x12\x19\n" +
"\badmin_id\x18\x01 \x01(\tR\aadminId\x12\x1c\n" +
"\ttimestamp\x18\x02 \x01(\x03R\ttimestamp\x12V\n" +
"\x15registration_response\x18\x03 \x01(\v2\x1f.worker_pb.RegistrationResponseH\x00R\x14registrationResponse\x12M\n" +
"\x12heartbeat_response\x18\x04 \x01(\v2\x1c.worker_pb.HeartbeatResponseH\x00R\x11heartbeatResponse\x12D\n" +
"\x0ftask_assignment\x18\x05 \x01(\v2\x19.worker_pb.TaskAssignmentH\x00R\x0etaskAssignment\x12J\n" +
"\x11task_cancellation\x18\x06 \x01(\v2\x1b.worker_pb.TaskCancellationH\x00R\x10taskCancellation\x12A\n" +
"\x0eadmin_shutdown\x18\a \x01(\v2\x18.worker_pb.AdminShutdownH\x00R\radminShutdown\x12E\n" +
"\x10task_log_request\x18\b \x01(\v2\x19.worker_pb.TaskLogRequestH\x00R\x0etaskLogRequestB\t\n" +
"\amessage\"\x9c\x02\n" +
"\x12WorkerRegistration\x12\x1b\n" +
"\tworker_id\x18\x01 \x01(\tR\bworkerId\x12\x18\n" +
"\aaddress\x18\x02 \x01(\tR\aaddress\x12\"\n" +
"\fcapabilities\x18\x03 \x03(\tR\fcapabilities\x12%\n" +
"\x0emax_concurrent\x18\x04 \x01(\x05R\rmaxConcurrent\x12G\n" +
"\bmetadata\x18\x05 \x03(\v2+.worker_pb.WorkerRegistration.MetadataEntryR\bmetadata\x1a;\n" +
"\rMetadataEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"x\n" +
"\x14RegistrationResponse\x12\x18\n" +
"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x18\n" +
"\amessage\x18\x02 \x01(\tR\amessage\x12,\n" +
"\x12assigned_worker_id\x18\x03 \x01(\tR\x10assignedWorkerId\"\xad\x02\n" +
"\x0fWorkerHeartbeat\x12\x1b\n" +
"\tworker_id\x18\x01 \x01(\tR\bworkerId\x12\x16\n" +
"\x06status\x18\x02 \x01(\tR\x06status\x12!\n" +
"\fcurrent_load\x18\x03 \x01(\x05R\vcurrentLoad\x12%\n" +
"\x0emax_concurrent\x18\x04 \x01(\x05R\rmaxConcurrent\x12(\n" +
"\x10current_task_ids\x18\x05 \x03(\tR\x0ecurrentTaskIds\x12'\n" +
"\x0ftasks_completed\x18\x06 \x01(\x05R\x0etasksCompleted\x12!\n" +
"\ftasks_failed\x18\a \x01(\x05R\vtasksFailed\x12%\n" +
"\x0euptime_seconds\x18\b \x01(\x03R\ruptimeSeconds\"G\n" +
"\x11HeartbeatResponse\x12\x18\n" +
"\asuccess\x18\x01 \x01(\bR\asuccess\x12\x18\n" +
"\amessage\x18\x02 \x01(\tR\amessage\"w\n" +
"\vTaskRequest\x12\x1b\n" +
"\tworker_id\x18\x01 \x01(\tR\bworkerId\x12\"\n" +
"\fcapabilities\x18\x02 \x03(\tR\fcapabilities\x12'\n" +
"\x0favailable_slots\x18\x03 \x01(\x05R\x0eavailableSlots\"\xb6\x02\n" +
"\x0eTaskAssignment\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\ttask_type\x18\x02 \x01(\tR\btaskType\x12-\n" +
"\x06params\x18\x03 \x01(\v2\x15.worker_pb.TaskParamsR\x06params\x12\x1a\n" +
"\bpriority\x18\x04 \x01(\x05R\bpriority\x12!\n" +
"\fcreated_time\x18\x05 \x01(\x03R\vcreatedTime\x12C\n" +
"\bmetadata\x18\x06 \x03(\v2'.worker_pb.TaskAssignment.MetadataEntryR\bmetadata\x1a;\n" +
"\rMetadataEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xff\x05\n" +
"\n" +
"TaskParams\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\tvolume_id\x18\x02 \x01(\rR\bvolumeId\x12\x1e\n" +
"\n" +
"collection\x18\x03 \x01(\tR\n" +
"collection\x12\x1f\n" +
"\vdata_center\x18\x04 \x01(\tR\n" +
"dataCenter\x12\x12\n" +
"\x04rack\x18\x05 \x01(\tR\x04rack\x12\x1f\n" +
"\vvolume_size\x18\x06 \x01(\x04R\n" +
"volumeSize\x12/\n" +
"\asources\x18\a \x03(\v2\x15.worker_pb.TaskSourceR\asources\x12/\n" +
"\atargets\x18\b \x03(\v2\x15.worker_pb.TaskTargetR\atargets\x12B\n" +
"\rvacuum_params\x18\t \x01(\v2\x1b.worker_pb.VacuumTaskParamsH\x00R\fvacuumParams\x12X\n" +
"\x15erasure_coding_params\x18\n" +
" \x01(\v2\".worker_pb.ErasureCodingTaskParamsH\x00R\x13erasureCodingParams\x12E\n" +
"\x0ebalance_params\x18\v \x01(\v2\x1c.worker_pb.BalanceTaskParamsH\x00R\rbalanceParams\x12Q\n" +
"\x12replication_params\x18\f \x01(\v2 .worker_pb.ReplicationTaskParamsH\x00R\x11replicationParams\x12L\n" +
"\x11ec_balance_params\x18\r \x01(\v2\x1e.worker_pb.EcBalanceTaskParamsH\x00R\x0fecBalanceParams\x12N\n" +
"\x13s3_lifecycle_params\x18\x0e \x01(\v2\x1c.worker_pb.S3LifecycleParamsH\x00R\x11s3LifecycleParamsB\r\n" +
"\vtask_params\"\xa1\x03\n" +
"\x11S3LifecycleParams\x12>\n" +
"\asubtype\x18\x01 \x01(\x0e2$.worker_pb.S3LifecycleParams.SubtypeR\asubtype\x12\x16\n" +
"\x06bucket\x18\x02 \x01(\tR\x06bucket\x12\x1b\n" +
"\trule_hash\x18\x03 \x01(\fR\bruleHash\x12\x14\n" +
"\x05force\x18\x04 \x01(\bR\x05force\x12/\n" +
"\x14batch_time_budget_ns\x18\x05 \x01(\x03R\x11batchTimeBudgetNs\x12,\n" +
"\x12batch_event_budget\x18\x06 \x01(\x05R\x10batchEventBudget\x12?\n" +
"\fcontinuation\x18\a \x01(\v2\x1b.worker_pb.ContinuationHintR\fcontinuation\x12\x19\n" +
"\bshard_id\x18\b \x01(\x05R\ashardId\"F\n" +
"\aSubtype\x12\x17\n" +
"\x13SUBTYPE_UNSPECIFIED\x10\x00\x12\b\n" +
"\x04READ\x10\x01\x12\r\n" +
"\tBOOTSTRAP\x10\x02\x12\t\n" +
"\x05DRAIN\x10\x03\"h\n" +
"\x10ContinuationHint\x12*\n" +
"\x11last_scanned_path\x18\x01 \x01(\tR\x0flastScannedPath\x12(\n" +
"\x10last_position_ns\x18\x02 \x01(\x03R\x0elastPositionNs\"\xcb\x01\n" +
"\x10VacuumTaskParams\x12+\n" +
"\x11garbage_threshold\x18\x01 \x01(\x01R\x10garbageThreshold\x12!\n" +
"\fforce_vacuum\x18\x02 \x01(\bR\vforceVacuum\x12\x1d\n" +
"\n" +
"batch_size\x18\x03 \x01(\x05R\tbatchSize\x12\x1f\n" +
"\vworking_dir\x18\x04 \x01(\tR\n" +
"workingDir\x12'\n" +
"\x0fverify_checksum\x18\x05 \x01(\bR\x0everifyChecksum\"\xae\x02\n" +
"\x17ErasureCodingTaskParams\x120\n" +
"\x14estimated_shard_size\x18\x01 \x01(\x04R\x12estimatedShardSize\x12\x1f\n" +
"\vdata_shards\x18\x02 \x01(\x05R\n" +
"dataShards\x12#\n" +
"\rparity_shards\x18\x03 \x01(\x05R\fparityShards\x12\x1f\n" +
"\vworking_dir\x18\x04 \x01(\tR\n" +
"workingDir\x12#\n" +
"\rmaster_client\x18\x05 \x01(\tR\fmasterClient\x12%\n" +
"\x0ecleanup_source\x18\x06 \x01(\bR\rcleanupSource\x12(\n" +
"\x10source_disk_type\x18\b \x01(\tR\x0esourceDiskTypeJ\x04\b\a\x10\b\"\xcf\x01\n" +
"\n" +
"TaskSource\x12\x12\n" +
"\x04node\x18\x01 \x01(\tR\x04node\x12\x17\n" +
"\adisk_id\x18\x02 \x01(\rR\x06diskId\x12\x12\n" +
"\x04rack\x18\x03 \x01(\tR\x04rack\x12\x1f\n" +
"\vdata_center\x18\x04 \x01(\tR\n" +
"dataCenter\x12\x1b\n" +
"\tvolume_id\x18\x05 \x01(\rR\bvolumeId\x12\x1b\n" +
"\tshard_ids\x18\x06 \x03(\rR\bshardIds\x12%\n" +
"\x0eestimated_size\x18\a \x01(\x04R\restimatedSize\"\xcf\x01\n" +
"\n" +
"TaskTarget\x12\x12\n" +
"\x04node\x18\x01 \x01(\tR\x04node\x12\x17\n" +
"\adisk_id\x18\x02 \x01(\rR\x06diskId\x12\x12\n" +
"\x04rack\x18\x03 \x01(\tR\x04rack\x12\x1f\n" +
"\vdata_center\x18\x04 \x01(\tR\n" +
"dataCenter\x12\x1b\n" +
"\tvolume_id\x18\x05 \x01(\rR\bvolumeId\x12\x1b\n" +
"\tshard_ids\x18\x06 \x03(\rR\bshardIds\x12%\n" +
"\x0eestimated_size\x18\a \x01(\x04R\restimatedSize\"\xb1\x01\n" +
"\x0fBalanceMoveSpec\x12\x1b\n" +
"\tvolume_id\x18\x01 \x01(\rR\bvolumeId\x12\x1f\n" +
"\vsource_node\x18\x02 \x01(\tR\n" +
"sourceNode\x12\x1f\n" +
"\vtarget_node\x18\x03 \x01(\tR\n" +
"targetNode\x12\x1e\n" +
"\n" +
"collection\x18\x04 \x01(\tR\n" +
"collection\x12\x1f\n" +
"\vvolume_size\x18\x05 \x01(\x04R\n" +
"volumeSize\"\xbf\x01\n" +
"\x11BalanceTaskParams\x12\x1d\n" +
"\n" +
"force_move\x18\x01 \x01(\bR\tforceMove\x12'\n" +
"\x0ftimeout_seconds\x18\x02 \x01(\x05R\x0etimeoutSeconds\x120\n" +
"\x14max_concurrent_moves\x18\x03 \x01(\x05R\x12maxConcurrentMoves\x120\n" +
"\x05moves\x18\x04 \x03(\v2\x1a.worker_pb.BalanceMoveSpecR\x05moves\"k\n" +
"\x15ReplicationTaskParams\x12#\n" +
"\rreplica_count\x18\x01 \x01(\x05R\freplicaCount\x12-\n" +
"\x12verify_consistency\x18\x02 \x01(\bR\x11verifyConsistency\"\x8e\x02\n" +
"\n" +
"TaskUpdate\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\tworker_id\x18\x02 \x01(\tR\bworkerId\x12\x16\n" +
"\x06status\x18\x03 \x01(\tR\x06status\x12\x1a\n" +
"\bprogress\x18\x04 \x01(\x02R\bprogress\x12\x18\n" +
"\amessage\x18\x05 \x01(\tR\amessage\x12?\n" +
"\bmetadata\x18\x06 \x03(\v2#.worker_pb.TaskUpdate.MetadataEntryR\bmetadata\x1a;\n" +
"\rMetadataEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc5\x02\n" +
"\fTaskComplete\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\tworker_id\x18\x02 \x01(\tR\bworkerId\x12\x18\n" +
"\asuccess\x18\x03 \x01(\bR\asuccess\x12#\n" +
"\rerror_message\x18\x04 \x01(\tR\ferrorMessage\x12'\n" +
"\x0fcompletion_time\x18\x05 \x01(\x03R\x0ecompletionTime\x12T\n" +
"\x0fresult_metadata\x18\x06 \x03(\v2+.worker_pb.TaskComplete.ResultMetadataEntryR\x0eresultMetadata\x1aA\n" +
"\x13ResultMetadataEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"Y\n" +
"\x10TaskCancellation\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x16\n" +
"\x06reason\x18\x02 \x01(\tR\x06reason\x12\x14\n" +
"\x05force\x18\x03 \x01(\bR\x05force\"o\n" +
"\x0eWorkerShutdown\x12\x1b\n" +
"\tworker_id\x18\x01 \x01(\tR\bworkerId\x12\x16\n" +
"\x06reason\x18\x02 \x01(\tR\x06reason\x12(\n" +
"\x10pending_task_ids\x18\x03 \x03(\tR\x0ependingTaskIds\"c\n" +
"\rAdminShutdown\x12\x16\n" +
"\x06reason\x18\x01 \x01(\tR\x06reason\x12:\n" +
"\x19graceful_shutdown_seconds\x18\x02 \x01(\x05R\x17gracefulShutdownSeconds\"\xe9\x01\n" +
"\x0eTaskLogRequest\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\tworker_id\x18\x02 \x01(\tR\bworkerId\x12)\n" +
"\x10include_metadata\x18\x03 \x01(\bR\x0fincludeMetadata\x12\x1f\n" +
"\vmax_entries\x18\x04 \x01(\x05R\n" +
"maxEntries\x12\x1b\n" +
"\tlog_level\x18\x05 \x01(\tR\blogLevel\x12\x1d\n" +
"\n" +
"start_time\x18\x06 \x01(\x03R\tstartTime\x12\x19\n" +
"\bend_time\x18\a \x01(\x03R\aendTime\"\xf8\x01\n" +
"\x0fTaskLogResponse\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\tworker_id\x18\x02 \x01(\tR\bworkerId\x12\x18\n" +
"\asuccess\x18\x03 \x01(\bR\asuccess\x12#\n" +
"\rerror_message\x18\x04 \x01(\tR\ferrorMessage\x126\n" +
"\bmetadata\x18\x05 \x01(\v2\x1a.worker_pb.TaskLogMetadataR\bmetadata\x128\n" +
"\vlog_entries\x18\x06 \x03(\v2\x17.worker_pb.TaskLogEntryR\n" +
"logEntries\"\x97\x04\n" +
"\x0fTaskLogMetadata\x12\x17\n" +
"\atask_id\x18\x01 \x01(\tR\x06taskId\x12\x1b\n" +
"\ttask_type\x18\x02 \x01(\tR\btaskType\x12\x1b\n" +
"\tworker_id\x18\x03 \x01(\tR\bworkerId\x12\x1d\n" +
"\n" +
"start_time\x18\x04 \x01(\x03R\tstartTime\x12\x19\n" +
"\bend_time\x18\x05 \x01(\x03R\aendTime\x12\x1f\n" +
"\vduration_ms\x18\x06 \x01(\x03R\n" +
"durationMs\x12\x16\n" +
"\x06status\x18\a \x01(\tR\x06status\x12\x1a\n" +
"\bprogress\x18\b \x01(\x02R\bprogress\x12\x1b\n" +
"\tvolume_id\x18\t \x01(\rR\bvolumeId\x12\x16\n" +
"\x06server\x18\n" +
" \x01(\tR\x06server\x12\x1e\n" +
"\n" +
"collection\x18\v \x01(\tR\n" +
"collection\x12\"\n" +
"\rlog_file_path\x18\f \x01(\tR\vlogFilePath\x12\x1d\n" +
"\n" +
"created_at\x18\r \x01(\x03R\tcreatedAt\x12K\n" +
"\vcustom_data\x18\x0e \x03(\v2*.worker_pb.TaskLogMetadata.CustomDataEntryR\n" +
"customData\x1a=\n" +
"\x0fCustomDataEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x88\x02\n" +
"\fTaskLogEntry\x12\x1c\n" +
"\ttimestamp\x18\x01 \x01(\x03R\ttimestamp\x12\x14\n" +
"\x05level\x18\x02 \x01(\tR\x05level\x12\x18\n" +
"\amessage\x18\x03 \x01(\tR\amessage\x12;\n" +
"\x06fields\x18\x04 \x03(\v2#.worker_pb.TaskLogEntry.FieldsEntryR\x06fields\x12\x1a\n" +
"\bprogress\x18\x05 \x01(\x02R\bprogress\x12\x16\n" +
"\x06status\x18\x06 \x01(\tR\x06status\x1a9\n" +
"\vFieldsEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc0\x03\n" +
"\x11MaintenanceConfig\x12\x18\n" +
"\aenabled\x18\x01 \x01(\bR\aenabled\x122\n" +
"\x15scan_interval_seconds\x18\x02 \x01(\x05R\x13scanIntervalSeconds\x124\n" +
"\x16worker_timeout_seconds\x18\x03 \x01(\x05R\x14workerTimeoutSeconds\x120\n" +
"\x14task_timeout_seconds\x18\x04 \x01(\x05R\x12taskTimeoutSeconds\x12.\n" +
"\x13retry_delay_seconds\x18\x05 \x01(\x05R\x11retryDelaySeconds\x12\x1f\n" +
"\vmax_retries\x18\x06 \x01(\x05R\n" +
"maxRetries\x128\n" +
"\x18cleanup_interval_seconds\x18\a \x01(\x05R\x16cleanupIntervalSeconds\x124\n" +
"\x16task_retention_seconds\x18\b \x01(\x05R\x14taskRetentionSeconds\x124\n" +
"\x06policy\x18\t \x01(\v2\x1c.worker_pb.MaintenancePolicyR\x06policy\"\x80\x03\n" +
"\x11MaintenancePolicy\x12S\n" +
"\rtask_policies\x18\x01 \x03(\v2..worker_pb.MaintenancePolicy.TaskPoliciesEntryR\ftaskPolicies\x122\n" +
"\x15global_max_concurrent\x18\x02 \x01(\x05R\x13globalMaxConcurrent\x12E\n" +
"\x1fdefault_repeat_interval_seconds\x18\x03 \x01(\x05R\x1cdefaultRepeatIntervalSeconds\x12C\n" +
"\x1edefault_check_interval_seconds\x18\x04 \x01(\x05R\x1bdefaultCheckIntervalSeconds\x1aV\n" +
"\x11TaskPoliciesEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12+\n" +
"\x05value\x18\x02 \x01(\v2\x15.worker_pb.TaskPolicyR\x05value:\x028\x01\"\xd0\x04\n" +
"\n" +
"TaskPolicy\x12\x18\n" +
"\aenabled\x18\x01 \x01(\bR\aenabled\x12%\n" +
"\x0emax_concurrent\x18\x02 \x01(\x05R\rmaxConcurrent\x126\n" +
"\x17repeat_interval_seconds\x18\x03 \x01(\x05R\x15repeatIntervalSeconds\x124\n" +
"\x16check_interval_seconds\x18\x04 \x01(\x05R\x14checkIntervalSeconds\x12B\n" +
"\rvacuum_config\x18\x05 \x01(\v2\x1b.worker_pb.VacuumTaskConfigH\x00R\fvacuumConfig\x12X\n" +
"\x15erasure_coding_config\x18\x06 \x01(\v2\".worker_pb.ErasureCodingTaskConfigH\x00R\x13erasureCodingConfig\x12E\n" +
"\x0ebalance_config\x18\a \x01(\v2\x1c.worker_pb.BalanceTaskConfigH\x00R\rbalanceConfig\x12Q\n" +
"\x12replication_config\x18\b \x01(\v2 .worker_pb.ReplicationTaskConfigH\x00R\x11replicationConfig\x12L\n" +
"\x11ec_balance_config\x18\t \x01(\v2\x1e.worker_pb.EcBalanceTaskConfigH\x00R\x0fecBalanceConfigB\r\n" +
"\vtask_config\"\xa2\x01\n" +
"\x10VacuumTaskConfig\x12+\n" +
"\x11garbage_threshold\x18\x01 \x01(\x01R\x10garbageThreshold\x12/\n" +
"\x14min_volume_age_hours\x18\x02 \x01(\x05R\x11minVolumeAgeHours\x120\n" +
"\x14min_interval_seconds\x18\x03 \x01(\x05R\x12minIntervalSeconds\"\xed\x01\n" +
"\x17ErasureCodingTaskConfig\x12%\n" +
"\x0efullness_ratio\x18\x01 \x01(\x01R\rfullnessRatio\x12*\n" +
"\x11quiet_for_seconds\x18\x02 \x01(\x05R\x0fquietForSeconds\x12+\n" +
"\x12min_volume_size_mb\x18\x03 \x01(\x05R\x0fminVolumeSizeMb\x12+\n" +
"\x11collection_filter\x18\x04 \x01(\tR\x10collectionFilter\x12%\n" +
"\x0epreferred_tags\x18\x05 \x03(\tR\rpreferredTags\"n\n" +
"\x11BalanceTaskConfig\x12/\n" +
"\x13imbalance_threshold\x18\x01 \x01(\x01R\x12imbalanceThreshold\x12(\n" +
"\x10min_server_count\x18\x02 \x01(\x05R\x0eminServerCount\"I\n" +
"\x15ReplicationTaskConfig\x120\n" +
"\x14target_replica_count\x18\x01 \x01(\x05R\x12targetReplicaCount\"\xbe\x01\n" +
"\x13EcBalanceTaskParams\x12\x1b\n" +
"\tdisk_type\x18\x01 \x01(\tR\bdiskType\x12/\n" +
"\x13max_parallelization\x18\x02 \x01(\x05R\x12maxParallelization\x12'\n" +
"\x0ftimeout_seconds\x18\x03 \x01(\x05R\x0etimeoutSeconds\x120\n" +
"\x05moves\x18\x04 \x03(\v2\x1a.worker_pb.EcShardMoveSpecR\x05moves\"\xf7\x01\n" +
"\x0fEcShardMoveSpec\x12\x1b\n" +
"\tvolume_id\x18\x01 \x01(\rR\bvolumeId\x12\x19\n" +
"\bshard_id\x18\x02 \x01(\rR\ashardId\x12\x1e\n" +
"\n" +
"collection\x18\x03 \x01(\tR\n" +
"collection\x12\x1f\n" +
"\vsource_node\x18\x04 \x01(\tR\n" +
"sourceNode\x12$\n" +
"\x0esource_disk_id\x18\x05 \x01(\rR\fsourceDiskId\x12\x1f\n" +
"\vtarget_node\x18\x06 \x01(\tR\n" +
"targetNode\x12$\n" +
"\x0etarget_disk_id\x18\a \x01(\rR\ftargetDiskId\"\xe1\x01\n" +
"\x13EcBalanceTaskConfig\x12/\n" +
"\x13imbalance_threshold\x18\x01 \x01(\x01R\x12imbalanceThreshold\x12(\n" +
"\x10min_server_count\x18\x02 \x01(\x05R\x0eminServerCount\x12+\n" +
"\x11collection_filter\x18\x03 \x01(\tR\x10collectionFilter\x12\x1b\n" +
"\tdisk_type\x18\x04 \x01(\tR\bdiskType\x12%\n" +
"\x0epreferred_tags\x18\x05 \x03(\tR\rpreferredTags\"\xae\a\n" +
"\x13MaintenanceTaskData\x12\x0e\n" +
"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
"\x04type\x18\x02 \x01(\tR\x04type\x12\x1a\n" +
"\bpriority\x18\x03 \x01(\tR\bpriority\x12\x16\n" +
"\x06status\x18\x04 \x01(\tR\x06status\x12\x1b\n" +
"\tvolume_id\x18\x05 \x01(\rR\bvolumeId\x12\x16\n" +
"\x06server\x18\x06 \x01(\tR\x06server\x12\x1e\n" +
"\n" +
"collection\x18\a \x01(\tR\n" +
"collection\x128\n" +
"\ftyped_params\x18\b \x01(\v2\x15.worker_pb.TaskParamsR\vtypedParams\x12\x16\n" +
"\x06reason\x18\t \x01(\tR\x06reason\x12\x1d\n" +
"\n" +
"created_at\x18\n" +
" \x01(\x03R\tcreatedAt\x12!\n" +
"\fscheduled_at\x18\v \x01(\x03R\vscheduledAt\x12\x1d\n" +
"\n" +
"started_at\x18\f \x01(\x03R\tstartedAt\x12!\n" +
"\fcompleted_at\x18\r \x01(\x03R\vcompletedAt\x12\x1b\n" +
"\tworker_id\x18\x0e \x01(\tR\bworkerId\x12\x14\n" +
"\x05error\x18\x0f \x01(\tR\x05error\x12\x1a\n" +
"\bprogress\x18\x10 \x01(\x01R\bprogress\x12\x1f\n" +
"\vretry_count\x18\x11 \x01(\x05R\n" +
"retryCount\x12\x1f\n" +
"\vmax_retries\x18\x12 \x01(\x05R\n" +
"maxRetries\x12\x1d\n" +
"\n" +
"created_by\x18\x13 \x01(\tR\tcreatedBy\x12)\n" +
"\x10creation_context\x18\x14 \x01(\tR\x0fcreationContext\x12N\n" +
"\x12assignment_history\x18\x15 \x03(\v2\x1f.worker_pb.TaskAssignmentRecordR\x11assignmentHistory\x12'\n" +
"\x0fdetailed_reason\x18\x16 \x01(\tR\x0edetailedReason\x12<\n" +
"\x04tags\x18\x17 \x03(\v2(.worker_pb.MaintenanceTaskData.TagsEntryR\x04tags\x12I\n" +
"\x10creation_metrics\x18\x18 \x01(\v2\x1e.worker_pb.TaskCreationMetricsR\x0fcreationMetrics\x1a7\n" +
"\tTagsEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xb8\x01\n" +
"\x14TaskAssignmentRecord\x12\x1b\n" +
"\tworker_id\x18\x01 \x01(\tR\bworkerId\x12%\n" +
"\x0eworker_address\x18\x02 \x01(\tR\rworkerAddress\x12\x1f\n" +
"\vassigned_at\x18\x03 \x01(\x03R\n" +
"assignedAt\x12#\n" +
"\runassigned_at\x18\x04 \x01(\x03R\funassignedAt\x12\x16\n" +
"\x06reason\x18\x05 \x01(\tR\x06reason\"\xe4\x02\n" +
"\x13TaskCreationMetrics\x12%\n" +
"\x0etrigger_metric\x18\x01 \x01(\tR\rtriggerMetric\x12!\n" +
"\fmetric_value\x18\x02 \x01(\x01R\vmetricValue\x12\x1c\n" +
"\tthreshold\x18\x03 \x01(\x01R\tthreshold\x12E\n" +
"\x0evolume_metrics\x18\x04 \x01(\v2\x1e.worker_pb.VolumeHealthMetricsR\rvolumeMetrics\x12[\n" +
"\x0fadditional_data\x18\x05 \x03(\v22.worker_pb.TaskCreationMetrics.AdditionalDataEntryR\x0eadditionalData\x1aA\n" +
"\x13AdditionalDataEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xf2\x02\n" +
"\x13VolumeHealthMetrics\x12\x1d\n" +
"\n" +
"total_size\x18\x01 \x01(\x04R\ttotalSize\x12\x1b\n" +
"\tused_size\x18\x02 \x01(\x04R\busedSize\x12!\n" +
"\fgarbage_size\x18\x03 \x01(\x04R\vgarbageSize\x12#\n" +
"\rgarbage_ratio\x18\x04 \x01(\x01R\fgarbageRatio\x12\x1d\n" +
"\n" +
"file_count\x18\x05 \x01(\x05R\tfileCount\x12,\n" +
"\x12deleted_file_count\x18\x06 \x01(\x05R\x10deletedFileCount\x12#\n" +
"\rlast_modified\x18\a \x01(\x03R\flastModified\x12#\n" +
"\rreplica_count\x18\b \x01(\x05R\freplicaCount\x12 \n" +
"\fis_ec_volume\x18\t \x01(\bR\n" +
"isEcVolume\x12\x1e\n" +
"\n" +
"collection\x18\n" +
" \x01(\tR\n" +
"collection\"\x8b\x01\n" +
"\rTaskStateFile\x122\n" +
"\x04task\x18\x01 \x01(\v2\x1e.worker_pb.MaintenanceTaskDataR\x04task\x12!\n" +
"\flast_updated\x18\x02 \x01(\x03R\vlastUpdated\x12#\n" +
"\radmin_version\x18\x03 \x01(\tR\fadminVersion2V\n" +
"\rWorkerService\x12E\n" +
"\fWorkerStream\x12\x18.worker_pb.WorkerMessage\x1a\x17.worker_pb.AdminMessage(\x010\x01B2Z0github.com/seaweedfs/seaweedfs/weed/pb/worker_pbb\x06proto3"
var (
file_worker_proto_rawDescOnce sync.Once
file_worker_proto_rawDescData []byte
)
func file_worker_proto_rawDescGZIP() []byte {
file_worker_proto_rawDescOnce.Do(func() {
file_worker_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_worker_proto_rawDesc), len(file_worker_proto_rawDesc)))
})
return file_worker_proto_rawDescData
}
var file_worker_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_worker_proto_msgTypes = make([]protoimpl.MessageInfo, 51)
var file_worker_proto_goTypes = []any{
(S3LifecycleParams_Subtype)(0), // 0: worker_pb.S3LifecycleParams.Subtype
(*WorkerMessage)(nil), // 1: worker_pb.WorkerMessage
(*AdminMessage)(nil), // 2: worker_pb.AdminMessage
(*WorkerRegistration)(nil), // 3: worker_pb.WorkerRegistration
(*RegistrationResponse)(nil), // 4: worker_pb.RegistrationResponse
(*WorkerHeartbeat)(nil), // 5: worker_pb.WorkerHeartbeat
(*HeartbeatResponse)(nil), // 6: worker_pb.HeartbeatResponse
(*TaskRequest)(nil), // 7: worker_pb.TaskRequest
(*TaskAssignment)(nil), // 8: worker_pb.TaskAssignment
(*TaskParams)(nil), // 9: worker_pb.TaskParams
(*S3LifecycleParams)(nil), // 10: worker_pb.S3LifecycleParams
(*ContinuationHint)(nil), // 11: worker_pb.ContinuationHint
(*VacuumTaskParams)(nil), // 12: worker_pb.VacuumTaskParams
(*ErasureCodingTaskParams)(nil), // 13: worker_pb.ErasureCodingTaskParams
(*TaskSource)(nil), // 14: worker_pb.TaskSource
(*TaskTarget)(nil), // 15: worker_pb.TaskTarget
(*BalanceMoveSpec)(nil), // 16: worker_pb.BalanceMoveSpec
(*BalanceTaskParams)(nil), // 17: worker_pb.BalanceTaskParams
(*ReplicationTaskParams)(nil), // 18: worker_pb.ReplicationTaskParams
(*TaskUpdate)(nil), // 19: worker_pb.TaskUpdate
(*TaskComplete)(nil), // 20: worker_pb.TaskComplete
(*TaskCancellation)(nil), // 21: worker_pb.TaskCancellation
(*WorkerShutdown)(nil), // 22: worker_pb.WorkerShutdown
(*AdminShutdown)(nil), // 23: worker_pb.AdminShutdown
(*TaskLogRequest)(nil), // 24: worker_pb.TaskLogRequest
(*TaskLogResponse)(nil), // 25: worker_pb.TaskLogResponse
(*TaskLogMetadata)(nil), // 26: worker_pb.TaskLogMetadata
(*TaskLogEntry)(nil), // 27: worker_pb.TaskLogEntry
(*MaintenanceConfig)(nil), // 28: worker_pb.MaintenanceConfig
(*MaintenancePolicy)(nil), // 29: worker_pb.MaintenancePolicy
(*TaskPolicy)(nil), // 30: worker_pb.TaskPolicy
(*VacuumTaskConfig)(nil), // 31: worker_pb.VacuumTaskConfig
(*ErasureCodingTaskConfig)(nil), // 32: worker_pb.ErasureCodingTaskConfig
(*BalanceTaskConfig)(nil), // 33: worker_pb.BalanceTaskConfig
(*ReplicationTaskConfig)(nil), // 34: worker_pb.ReplicationTaskConfig
(*EcBalanceTaskParams)(nil), // 35: worker_pb.EcBalanceTaskParams
(*EcShardMoveSpec)(nil), // 36: worker_pb.EcShardMoveSpec
(*EcBalanceTaskConfig)(nil), // 37: worker_pb.EcBalanceTaskConfig
(*MaintenanceTaskData)(nil), // 38: worker_pb.MaintenanceTaskData
(*TaskAssignmentRecord)(nil), // 39: worker_pb.TaskAssignmentRecord
(*TaskCreationMetrics)(nil), // 40: worker_pb.TaskCreationMetrics
(*VolumeHealthMetrics)(nil), // 41: worker_pb.VolumeHealthMetrics
(*TaskStateFile)(nil), // 42: worker_pb.TaskStateFile
nil, // 43: worker_pb.WorkerRegistration.MetadataEntry
nil, // 44: worker_pb.TaskAssignment.MetadataEntry
nil, // 45: worker_pb.TaskUpdate.MetadataEntry
nil, // 46: worker_pb.TaskComplete.ResultMetadataEntry
nil, // 47: worker_pb.TaskLogMetadata.CustomDataEntry
nil, // 48: worker_pb.TaskLogEntry.FieldsEntry
nil, // 49: worker_pb.MaintenancePolicy.TaskPoliciesEntry
nil, // 50: worker_pb.MaintenanceTaskData.TagsEntry
nil, // 51: worker_pb.TaskCreationMetrics.AdditionalDataEntry
}
var file_worker_proto_depIdxs = []int32{
3, // 0: worker_pb.WorkerMessage.registration:type_name -> worker_pb.WorkerRegistration
5, // 1: worker_pb.WorkerMessage.heartbeat:type_name -> worker_pb.WorkerHeartbeat
7, // 2: worker_pb.WorkerMessage.task_request:type_name -> worker_pb.TaskRequest
19, // 3: worker_pb.WorkerMessage.task_update:type_name -> worker_pb.TaskUpdate
20, // 4: worker_pb.WorkerMessage.task_complete:type_name -> worker_pb.TaskComplete
22, // 5: worker_pb.WorkerMessage.shutdown:type_name -> worker_pb.WorkerShutdown
25, // 6: worker_pb.WorkerMessage.task_log_response:type_name -> worker_pb.TaskLogResponse
4, // 7: worker_pb.AdminMessage.registration_response:type_name -> worker_pb.RegistrationResponse
6, // 8: worker_pb.AdminMessage.heartbeat_response:type_name -> worker_pb.HeartbeatResponse
8, // 9: worker_pb.AdminMessage.task_assignment:type_name -> worker_pb.TaskAssignment
21, // 10: worker_pb.AdminMessage.task_cancellation:type_name -> worker_pb.TaskCancellation
23, // 11: worker_pb.AdminMessage.admin_shutdown:type_name -> worker_pb.AdminShutdown
24, // 12: worker_pb.AdminMessage.task_log_request:type_name -> worker_pb.TaskLogRequest
43, // 13: worker_pb.WorkerRegistration.metadata:type_name -> worker_pb.WorkerRegistration.MetadataEntry
9, // 14: worker_pb.TaskAssignment.params:type_name -> worker_pb.TaskParams
44, // 15: worker_pb.TaskAssignment.metadata:type_name -> worker_pb.TaskAssignment.MetadataEntry
14, // 16: worker_pb.TaskParams.sources:type_name -> worker_pb.TaskSource
15, // 17: worker_pb.TaskParams.targets:type_name -> worker_pb.TaskTarget
12, // 18: worker_pb.TaskParams.vacuum_params:type_name -> worker_pb.VacuumTaskParams
13, // 19: worker_pb.TaskParams.erasure_coding_params:type_name -> worker_pb.ErasureCodingTaskParams
17, // 20: worker_pb.TaskParams.balance_params:type_name -> worker_pb.BalanceTaskParams
18, // 21: worker_pb.TaskParams.replication_params:type_name -> worker_pb.ReplicationTaskParams
35, // 22: worker_pb.TaskParams.ec_balance_params:type_name -> worker_pb.EcBalanceTaskParams
10, // 23: worker_pb.TaskParams.s3_lifecycle_params:type_name -> worker_pb.S3LifecycleParams
0, // 24: worker_pb.S3LifecycleParams.subtype:type_name -> worker_pb.S3LifecycleParams.Subtype
11, // 25: worker_pb.S3LifecycleParams.continuation:type_name -> worker_pb.ContinuationHint
16, // 26: worker_pb.BalanceTaskParams.moves:type_name -> worker_pb.BalanceMoveSpec
45, // 27: worker_pb.TaskUpdate.metadata:type_name -> worker_pb.TaskUpdate.MetadataEntry
46, // 28: worker_pb.TaskComplete.result_metadata:type_name -> worker_pb.TaskComplete.ResultMetadataEntry
26, // 29: worker_pb.TaskLogResponse.metadata:type_name -> worker_pb.TaskLogMetadata
27, // 30: worker_pb.TaskLogResponse.log_entries:type_name -> worker_pb.TaskLogEntry
47, // 31: worker_pb.TaskLogMetadata.custom_data:type_name -> worker_pb.TaskLogMetadata.CustomDataEntry
48, // 32: worker_pb.TaskLogEntry.fields:type_name -> worker_pb.TaskLogEntry.FieldsEntry
29, // 33: worker_pb.MaintenanceConfig.policy:type_name -> worker_pb.MaintenancePolicy
49, // 34: worker_pb.MaintenancePolicy.task_policies:type_name -> worker_pb.MaintenancePolicy.TaskPoliciesEntry
31, // 35: worker_pb.TaskPolicy.vacuum_config:type_name -> worker_pb.VacuumTaskConfig
32, // 36: worker_pb.TaskPolicy.erasure_coding_config:type_name -> worker_pb.ErasureCodingTaskConfig
33, // 37: worker_pb.TaskPolicy.balance_config:type_name -> worker_pb.BalanceTaskConfig
34, // 38: worker_pb.TaskPolicy.replication_config:type_name -> worker_pb.ReplicationTaskConfig
37, // 39: worker_pb.TaskPolicy.ec_balance_config:type_name -> worker_pb.EcBalanceTaskConfig
36, // 40: worker_pb.EcBalanceTaskParams.moves:type_name -> worker_pb.EcShardMoveSpec
9, // 41: worker_pb.MaintenanceTaskData.typed_params:type_name -> worker_pb.TaskParams
39, // 42: worker_pb.MaintenanceTaskData.assignment_history:type_name -> worker_pb.TaskAssignmentRecord
50, // 43: worker_pb.MaintenanceTaskData.tags:type_name -> worker_pb.MaintenanceTaskData.TagsEntry
40, // 44: worker_pb.MaintenanceTaskData.creation_metrics:type_name -> worker_pb.TaskCreationMetrics
41, // 45: worker_pb.TaskCreationMetrics.volume_metrics:type_name -> worker_pb.VolumeHealthMetrics
51, // 46: worker_pb.TaskCreationMetrics.additional_data:type_name -> worker_pb.TaskCreationMetrics.AdditionalDataEntry
38, // 47: worker_pb.TaskStateFile.task:type_name -> worker_pb.MaintenanceTaskData
30, // 48: worker_pb.MaintenancePolicy.TaskPoliciesEntry.value:type_name -> worker_pb.TaskPolicy
1, // 49: worker_pb.WorkerService.WorkerStream:input_type -> worker_pb.WorkerMessage
2, // 50: worker_pb.WorkerService.WorkerStream:output_type -> worker_pb.AdminMessage
50, // [50:51] is the sub-list for method output_type
49, // [49:50] is the sub-list for method input_type
49, // [49:49] is the sub-list for extension type_name
49, // [49:49] is the sub-list for extension extendee
0, // [0:49] is the sub-list for field type_name
}
func init() { file_worker_proto_init() }
func file_worker_proto_init() {
if File_worker_proto != nil {
return
}
file_worker_proto_msgTypes[0].OneofWrappers = []any{
(*WorkerMessage_Registration)(nil),
(*WorkerMessage_Heartbeat)(nil),
(*WorkerMessage_TaskRequest)(nil),
(*WorkerMessage_TaskUpdate)(nil),
(*WorkerMessage_TaskComplete)(nil),
(*WorkerMessage_Shutdown)(nil),
(*WorkerMessage_TaskLogResponse)(nil),
}
file_worker_proto_msgTypes[1].OneofWrappers = []any{
(*AdminMessage_RegistrationResponse)(nil),
(*AdminMessage_HeartbeatResponse)(nil),
(*AdminMessage_TaskAssignment)(nil),
(*AdminMessage_TaskCancellation)(nil),
(*AdminMessage_AdminShutdown)(nil),
(*AdminMessage_TaskLogRequest)(nil),
}
file_worker_proto_msgTypes[8].OneofWrappers = []any{
(*TaskParams_VacuumParams)(nil),
(*TaskParams_ErasureCodingParams)(nil),
(*TaskParams_BalanceParams)(nil),
(*TaskParams_ReplicationParams)(nil),
(*TaskParams_EcBalanceParams)(nil),
(*TaskParams_S3LifecycleParams)(nil),
}
file_worker_proto_msgTypes[29].OneofWrappers = []any{
(*TaskPolicy_VacuumConfig)(nil),
(*TaskPolicy_ErasureCodingConfig)(nil),
(*TaskPolicy_BalanceConfig)(nil),
(*TaskPolicy_ReplicationConfig)(nil),
(*TaskPolicy_EcBalanceConfig)(nil),
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_worker_proto_rawDesc), len(file_worker_proto_rawDesc)),
NumEnums: 1,
NumMessages: 51,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_worker_proto_goTypes,
DependencyIndexes: file_worker_proto_depIdxs,
EnumInfos: file_worker_proto_enumTypes,
MessageInfos: file_worker_proto_msgTypes,
}.Build()
File_worker_proto = out.File
file_worker_proto_goTypes = nil
file_worker_proto_depIdxs = nil
}
Reference in New Issue View Git Blame Copy Permalink