workload

type AggregatedSample struct {
	At                    time.Time `json:"at"`
	ReplicaCount          int       `json:"replica_count"`
	CPUPercent            float64   `json:"cpu_percent"`
	MemoryUsedMB          int       `json:"memory_used_mb"`
	MemoryLimitMB         int       `json:"memory_limit_mb"`
	NetworkInBytesPerSec  float64   `json:"network_in_bytes_per_sec"`
	NetworkOutBytesPerSec float64   `json:"network_out_bytes_per_sec"`
	RequestsPerSec        float64   `json:"requests_per_sec,omitempty"`
	LatencyP95Ms          float64   `json:"latency_p95_ms,omitempty"`
}

type CreateRequest struct {
	Name           string                 `json:"name"                      validate:"required"`
	DatacenterID   id.ID                  `json:"datacenter_id,omitzero"`
	Region         string                 `json:"region,omitempty"`
	ProviderName   string                 `json:"provider_name,omitempty"`
	FromTemplateID id.ID                  `json:"from_template_id,omitzero"`
	Kind           provider.WorkloadKind  `json:"kind,omitempty"`
	Services       []provider.ServiceSpec `json:"services,omitempty"`
	Labels         map[string]string      `json:"labels,omitempty"`

	// Replicas is the desired replica count. Defaults to 1 when zero
	// or negative.
	Replicas int `json:"replicas,omitempty"`
}

type DeployRequest struct {
	Services []provider.ServiceDeploySpec `json:"services"           validate:"required,min=1"`
	Strategy string                       `json:"strategy,omitempty"` // "rolling" (default), "recreate", "blue_green", "canary"
	Notes    string                       `json:"notes,omitempty"`
}

type HealthEvent struct {
	WorkloadID   id.ID `json:"workload_id"`
	InstanceID   id.ID `json:"instance_id"`
	ReplicaIndex int   `json:"replica_index"`
	Result       any   `json:"result"` // *health.HealthResult — kept opaque to avoid an import cycle
}

type ListOptions struct {
	State        State  `json:"state,omitempty"`
	ProviderName string `json:"provider_name,omitempty"`
	Region       string `json:"region,omitempty"`
	Limit        int    `json:"limit,omitempty"`
}

type ListResult struct {
	Items []*Workload `json:"items"`
	Total int         `json:"total"`
}

type LogEvent struct {
	WorkloadID   id.ID  `json:"workload_id"`
	InstanceID   id.ID  `json:"instance_id"`
	ReplicaIndex int    `json:"replica_index"`
	Line         []byte `json:"line"`
}

type LogsOptions struct {
	Follow bool      `json:"follow"`
	Since  time.Time `json:"since,omitzero"`
	Tail   int       `json:"tail,omitempty"`
}

type MetricsEvent struct {
	WorkloadID   id.ID `json:"workload_id"`
	InstanceID   id.ID `json:"instance_id"`
	ReplicaIndex int   `json:"replica_index"`
	Sample       any   `json:"sample"` // metrics.Sample
}

type MetricsRange struct {
	Since      time.Time     `json:"since"`
	Until      time.Time     `json:"until"`
	Resolution time.Duration `json:"resolution,omitempty"`
}

type MetricsSeries []AggregatedSample

type Service interface {
	// Create allocates a Workload and provisions Replicas Instances
	// in one shot. Returns the Workload; List the Workload's
	// instances separately if you need them.
	Create(ctx context.Context, req CreateRequest) (*Workload, error)

	Get(ctx context.Context, workloadID id.ID) (*Workload, error)
	GetBySlug(ctx context.Context, slug string) (*Workload, error)
	List(ctx context.Context, opts ListOptions) (*ListResult, error)

	// Update mutates the Workload spec (image, env, resources,
	// labels). For changes that need a deploy (image swap),
	// callers should use Deploy instead — Update sets the spec but
	// doesn't push it to running replicas.
	Update(ctx context.Context, workloadID id.ID, req UpdateRequest) (*Workload, error)

	// Scale adjusts the replica count. Adds new Instances when
	// growing, deprovisions trailing Instances when shrinking. Does
	// not touch existing replicas' images or env.
	Scale(ctx context.Context, workloadID id.ID, replicas int) (*Workload, error)

	// Pause scales to zero while retaining the spec. Resume scales
	// back to the previously-set replica count.
	Pause(ctx context.Context, workloadID id.ID) error
	Resume(ctx context.Context, workloadID id.ID) error

	// Restart performs an in-place restart of every replica. Each
	// replica's container is stopped and started again by the
	// underlying provider (docker ContainerRestart, k8s Pod
	// restart, etc.) — no deprovision, no replica-count change,
	// no new container IDs. The Workload state stays Active
	// throughout.
	Restart(ctx context.Context, workloadID id.ID) error

	// Deploy creates a new Release from the Workload's current spec
	// (or from req overrides) and rolls it out to all replicas via
	// the chosen strategy. Returns the Deployment record so callers
	// can poll its state.
	Deploy(ctx context.Context, workloadID id.ID, req DeployRequest) (*deploy.Deployment, error)

	// Delete tears down the Workload and all its replicas.
	Delete(ctx context.Context, workloadID id.ID) error

	// ListInstances returns every Instance owned by the Workload,
	// ordered by ReplicaIndex.
	ListInstances(ctx context.Context, workloadID id.ID) ([]*instance.Instance, error)

	// ListDeployments returns every Deployment whose target instance
	// is one of the workload's replicas. Each rollout is represented
	// once (deployments are inherently per-replica today; if a
	// future Deploy strategy emits a single workload-level record,
	// this aggregator collapses to a passthrough).
	ListDeployments(ctx context.Context, workloadID id.ID, opts deploy.ListOptions) (*deploy.DeployListResult, error)

	// ListReleases returns the union of releases across the
	// workload's replicas, deduplicated by Release.ID. Sorted by
	// CreatedAt descending so the most recent release is first.
	ListReleases(ctx context.Context, workloadID id.ID, opts deploy.ListOptions) (*deploy.ReleaseListResult, error)

	// ListDomains returns every Domain currently bound to any of
	// the workload's replicas, deduplicated by Domain.ID.
	ListDomains(ctx context.Context, workloadID id.ID) ([]network.Domain, error)

	// ListRoutes returns every Route currently bound to any of the
	// workload's replicas, deduplicated by Route.ID.
	ListRoutes(ctx context.Context, workloadID id.ID) ([]network.Route, error)

	// WatchHealth returns a channel that fans in HealthResults from
	// every replica in the workload. Each event carries the source
	// instance ID + replica index. The fan-in re-lists replicas
	// every 30s so a Scale that adds new replicas mid-stream picks
	// them up automatically. Channel is closed when ctx is cancelled.
	WatchHealth(ctx context.Context, workloadID id.ID) (<-chan *HealthEvent, error)

	// StreamLogs returns a channel of log events fanned in across
	// every replica's stdout/stderr. Each event carries the source
	// instance ID + replica index alongside the original log line.
	// Closed when ctx is cancelled or every replica's underlying
	// log stream has terminated.
	StreamLogs(ctx context.Context, workloadID id.ID, opts LogsOptions) (<-chan *LogEvent, error)

	// GetHealth returns the worst-of-replicas health status. Useful
	// for the workspace dashboard badge — aggregates per-replica
	// InstanceHealth and takes the most severe state. Replica counts
	// (healthy/degraded/unhealthy/unknown) are returned alongside so
	// the badge can show "2/3 healthy" detail.
	GetHealth(ctx context.Context, workloadID id.ID) (*WorkloadHealth, error)

	// RangeMetrics returns aggregated resource metrics summed across
	// the workload's replicas at each bucket. CPU/Memory/Network are
	// summed; LatencyP95 and RequestsPerSec are averaged (a per-
	// replica P95 isn't meaningfully summable). Empty when no
	// replicas have any samples in the window.
	RangeMetrics(ctx context.Context, workloadID id.ID, q MetricsRange) (MetricsSeries, error)

	// WatchMetrics emits one MetricsEvent per replica per sample.
	// Aggregating into a workload total is the consumer's job — the
	// dashboard wants per-replica spark lines next to the aggregate.
	WatchMetrics(ctx context.Context, workloadID id.ID) (<-chan *MetricsEvent, error)
}

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

type State string

type Store interface {
	InsertWorkload(ctx context.Context, w *Workload) error
	GetWorkloadByID(ctx context.Context, tenantID string, workloadID id.ID) (*Workload, error)
	GetWorkloadBySlug(ctx context.Context, tenantID, slug string) (*Workload, error)

	// ListWorkloads returns workloads visible to tenantID. Empty
	// tenantID is the cross-tenant convention used by admin views
	// (matches the instance + deploy stores).
	ListWorkloads(ctx context.Context, tenantID string, opts ListOptions) (*ListResult, error)

	UpdateWorkload(ctx context.Context, w *Workload) error
	DeleteWorkload(ctx context.Context, tenantID string, workloadID id.ID) error
}

type UpdateRequest struct {
	Name     *string                `json:"name,omitempty"`
	Services []provider.ServiceSpec `json:"services,omitempty"`
	Labels   map[string]string      `json:"labels,omitempty"`
}

type Workload struct {
	ctrlplane.Entity

	TenantID     string `db:"tenant_id"     json:"tenant_id"`
	Name         string `db:"name"          json:"name"`
	Slug         string `db:"slug"          json:"slug"`
	DatacenterID id.ID  `db:"datacenter_id" json:"datacenter_id,omitzero"`
	ProviderName string `db:"provider_name" json:"provider_name"`
	Region       string `db:"region"        json:"region"`

	// Kind selects the runtime topology — KindDeployment for stateless
	// replicas (default), KindStatefulSet for stable per-replica
	// identity + storage. Cannot change after creation; mutating this
	// field through Update is rejected.
	Kind provider.WorkloadKind `db:"kind" json:"kind"`

	// Services is the per-service spec applied to every replica. One
	// Workload spawns N replicas; each replica spawns every service in
	// this slice as a co-scheduled container/task.
	Services []provider.ServiceSpec `db:"services" json:"services"`

	// Labels is workload-level metadata applied to every container in
	// every replica. ctrlplane reserves keys prefixed `ctrlplane.` for
	// internal discovery (e.g. `ctrlplane.workload=<id>`).
	Labels map[string]string `db:"labels" json:"labels,omitempty"`

	// CurrentReleaseID points at the Release whose snapshot is in effect.
	// Bumped by Deploy. Empty until the first Deploy succeeds.
	CurrentReleaseID id.ID `db:"current_release_id" json:"current_release_id,omitzero"`

	// ReplicaCount is the desired number of running replicas.
	ReplicaCount int `db:"replica_count" json:"replica_count"`

	// State is the lifecycle of the Workload as an aggregate.
	State State `db:"state" json:"state"`

	PausedAt *time.Time `db:"paused_at" json:"paused_at,omitempty"`

	// PreviousReplicas remembers the desired replica count just
	// before the most recent Pause. Resume reads this so a 3-replica
	// workload paused-and-resumed comes back as 3 replicas, not 1.
	PreviousReplicas int `db:"previous_replicas" json:"previous_replicas,omitempty"`

	// TemplateID records the template (if any) the Workload was forked
	// from. Empty for workloads created from raw fields.
	TemplateID id.ID `db:"template_id" json:"template_id,omitzero"`
}

type WorkloadHealth struct {
	WorkloadID    id.ID  `json:"workload_id"`
	Status        string `json:"status"` // healthy / degraded / unhealthy / unknown — uses health.Status string values
	ReplicaCount  int    `json:"replica_count"`
	HealthyCount  int    `json:"healthy_count"`
	DegradedCount int    `json:"degraded_count"`
	UnhealthyCnt  int    `json:"unhealthy_count"`
	UnknownCount  int    `json:"unknown_count"`
}