fleet

type AgentOfflineError struct {
	LastSeenAt *time.Time
}

type Directives interface {
	// DirectReconnect asks for a Reconnect directive on the stream of id.
	// It returns once the request is published; whether any replica
	// holds the stream is not known to it.
	DirectReconnect(ctx context.Context, id identity.WorkloadID) error
}

type DryRunRequest struct {
	Rulesets     []policy.Ruleset
	StateVersion string
}

type DryRunResult struct {
	StateVersion string
	Stale        bool
	Workloads    []compiler.WorkloadDiff
}

type MatchCountError struct {
	Expected int
	Matched  int
}

type ModeChangeRecord struct {
	ID                 uuid.UUID
	CreatedAt          time.Time
	TargetMode         innerwallv1.EnforcementMode
	Selector           policy.Selector
	ExpectedMatchCount int
	Workloads          []ModeChangeWorkload
	DesiredUpdated     int
}

type ModeChangeRequest struct {
	Selector           policy.Selector
	WorkloadIDs        []identity.WorkloadID
	TargetMode         innerwallv1.EnforcementMode
	ExpectedMatchCount int
}

type ModeChangeResult struct {
	ID             uuid.UUID
	Matched        int
	DesiredUpdated int
	Rendered       *compiler.Report
}

type ModeChangeTx interface {
	compiler.Tx
	// RecordModeChange persists the intent and the set it resolved to.
	RecordModeChange(ctx context.Context, rec *ModeChangeRecord) error
	// SetWorkloadModes sets the desired mode of exactly the given
	// workloads and reports how many were not already in it.
	SetWorkloadModes(ctx context.Context, ids []identity.WorkloadID, mode innerwallv1.EnforcementMode) (int, error)
}

type ModeChangeWorkload struct {
	ID           identity.WorkloadID
	PreviousMode innerwallv1.EnforcementMode
}

type Preview struct {
	Matched []WorkloadRef
}

type ReconnectRequest struct {
	LastSnapshotSentAt *time.Time
}

type RetireSubject struct {
	RetiredAt        *time.Time
	LastFlowReportAt *time.Time
	Process          *registry.AgentProcess
}

type RetireTx interface {
	compiler.Tx
	// LockWorkload locks the workload's row for the rest of the
	// transaction and reads it, or returns registry.ErrWorkloadUnknown.
	// Flow ingest's receipt and label writes take the same lock.
	LockWorkload(ctx context.Context, id identity.WorkloadID) (*RetireSubject, error)
	// StampRetired records the retirement instant.
	StampRetired(ctx context.Context, id identity.WorkloadID, at time.Time) error
	// WriteGaps stores derived gaps through the flow store, inside this
	// transaction.
	WriteGaps(ctx context.Context, id identity.WorkloadID, gaps []flowstore.Gap) error
	// DirectEnd asks every replica, once the transaction commits, to end
	// the workload's live stream if it holds it. Delivery is best-effort
	// by design, as for every directive (ADR-0018 as amended).
	DirectEnd(ctx context.Context, id identity.WorkloadID) error
}

type Retirement struct {
	ID        identity.WorkloadID
	RetiredAt time.Time
	Rendered  *compiler.Report
	Closed    *flowstore.Gap
}

type Service struct {
	Store  Store
	Engine *compiler.Engine
	// Reads is the read model a directed reconnect judges the workload
	// by, and Directives is where it sends one; RequestReconnect needs
	// both, nothing else here uses them.
	Reads      *readmodel.Reader
	Directives Directives
	// Streams ends the live streams this process holds when a workload
	// is retired; nil in a process that holds none.
	Streams Streams
	// FlowWindow is the flow window agents are handed, which judges the
	// silence a retirement closes (ADR-0019 as amended); with none, no
	// silence is closed.
	FlowWindow time.Duration
	Log        *slog.Logger
	// Now is the clock; time.Now if nil.
	Now func() time.Time
}

type Store interface {
	// ListWorkloads returns every workload with its labels.
	ListWorkloads(ctx context.Context) ([]registry.Workload, error)
	// ReplaceWorkloadLabels replaces a workload's labels when they still
	// hold the version the caller read (registry.LabelsVersion), refusing
	// with a *registry.LabelsVersionError otherwise; an empty expect
	// replaces unconditionally. It returns registry.ErrWorkloadUnknown
	// for an unregistered id.
	ReplaceWorkloadLabels(ctx context.Context, id identity.WorkloadID, labels []registry.Label, expect string) error
	// ModeChangeTx runs fn in one transaction holding the render lock and
	// commits when fn returns nil.
	ModeChangeTx(ctx context.Context, fn func(ctx context.Context, tx ModeChangeTx) error) error
	// LoadRenderState reads the render inputs and every persisted policy
	// as one consistent snapshot, without a lock and without writing.
	LoadRenderState(ctx context.Context) (*compiler.Inputs, map[identity.WorkloadID]*innerwallv1.WorkloadPolicy, error)
	// RetireTx runs fn in one transaction holding the render lock and
	// commits when fn returns nil.
	RetireTx(ctx context.Context, fn func(ctx context.Context, tx RetireTx) error) error
}

type Streams interface {
	// EndRetired ends the live stream of a retired workload, if this
	// process holds it, with the refusal every door gives a retired
	// identity, and reports whether it held one.
	EndRetired(id identity.WorkloadID) bool
}

type WorkloadRef struct {
	ID       identity.WorkloadID
	Hostname string
	Labels   map[string]string
}