fleet

type Capability string

type Compatibility struct {
	// State is version compatibility, not authenticated worker identity or
	// liveness.
	State CompatibilityState `json:"state"`
	// Enabled is a newly owned sorted intersection, empty unless versions are
	// compatible.
	Enabled []Capability `json:"enabled"`
	// WorkerOnly is a newly owned sorted set absent from control-plane
	// capabilities.
	WorkerOnly []Capability `json:"worker_only"`
	// ControlPlaneOnly is a newly owned sorted set absent from worker
	// capabilities.
	ControlPlaneOnly []Capability `json:"control_plane_only"`
}

type CompatibilityState string

type DrainState string

type Heartbeat struct {
	// TenantID is required bounded tenant scope; the reporting/authentication
	// boundary must bind it.
	TenantID string
	// WorkerID is required bounded worker identity, paired with TenantID in
	// Registry.
	WorkerID string
	// Version is required bounded implementation version text, not the
	// management Protocol.
	Version string
	// StartedAt is required worker start time and must not follow ObservedAt.
	StartedAt time.Time
	// ObservedAt is required observation time used for ordering and staleness;
	// source adapters choose its clock authority.
	ObservedAt time.Time
	// Queues contains at most MaxQueuesPerWorker bounded names; Registry copies
	// the slice.
	Queues []string
	// Concurrency must be positive and at most MaxWorkerConcurrency.
	Concurrency uint32
	// State must be a reported running/paused/draining/stopped state; derived
	// stale/unknown values are rejected.
	State State
	// CurrentJobs must not exceed Concurrency.
	CurrentJobs uint32
	// DrainStatus must be one supported reported drain state.
	DrainStatus DrainState
	// Backend is required bounded backend attribution.
	Backend string
	// Protocol must be a nonzero version pair; this is a report, not
	// conformance proof.
	Protocol ProtocolVersion
	// Capabilities contains at most MaxCapabilitiesPerWorker bounded capability
	// names; Registry copies the slice.
	Capabilities []Capability
}

type HeartbeatDisposition string

type HeartbeatValidationError struct {
	// Field names the invalid boundary and is printed by Error.
	Field string
	// Problem is printed by Error; producers should supply rule text, not
	// sensitive rejected values.
	Problem string
}

type Projection struct {
	// contains filtered or unexported fields
}

type ProjectionSnapshot struct {
	// Queues is a newly owned backend/queue-sorted slice; caller mutation does
	// not alter Projection.
	Queues []QueueSnapshot
	// Overflow aggregates events for identities refused at the configured
	// cardinality limit.
	Overflow QueueMetrics
}

type ProtocolRange struct {
	// Minimum is the inclusive lower version; an inverted range yields
	// CompatibilityUnknown.
	Minimum ProtocolVersion
	// Maximum is the inclusive upper version.
	Maximum ProtocolVersion
}

type ProtocolVersion struct {
	// Major is the reported major version; this model compares the complete
	// nonzero pair rather than validating a universal protocol edition.
	Major uint16 `json:"major"`
	// Minor is the reported minor version used in lexicographic range
	// comparison.
	Minor uint16 `json:"minor"`
}

type QueueMetrics struct {
	// Enqueued counts observed EventEnqueued events since construction.
	Enqueued uint64
	// Succeeded counts observed successful handler events, not durable
	// settlement.
	Succeeded uint64
	// Failed counts observed failed handler events.
	Failed uint64
	// Runtime accumulates handler success/failure durations; it is not a per-job average.
	Runtime time.Duration
}

type QueueSnapshot struct {
	// Backend identifies the event source backend, not a connection handle.
	Backend string
	// Queue identifies the event-reported queue.
	Queue string
	// Metrics contains copied cumulative counters for this identity.
	Metrics QueueMetrics
}

type Registry struct {
	// contains filtered or unexported fields
}

type RegistrySnapshot struct {
	// Workers is a newly owned tenant/worker-sorted slice with copied
	// queue/capability slices.
	Workers []WorkerSnapshot
	// Rejected counts capacity refusals when RejectedKnown is true.
	Rejected uint64
	// RejectedKnown distinguishes exact counts from unavailable tenant detail.
	// Whole-registry counts are always known; tenant counts are known only for
	// tenants with a successfully registered worker.
	RejectedKnown bool
}

type State string

type WorkerSnapshot struct {
	Heartbeat
	// State is derived liveness/conflict state, shadowing the embedded reported
	// State.
	State State
}