hub

type AgentInfo struct {
	ID            string
	Version       string
	System        *agentv1.SystemInfo
	ConnectedAt   time.Time
	LastHeartbeat time.Time // zero until the first heartbeat
	LastMetrics   *agentv1.MetricsReport
	// ProtocolVersion is the version negotiated for the connection.
	ProtocolVersion uint32
	// Compat tells how the agent's release relates to the hub's.
	Compat update.Compat
}

type AgentListener struct {
	// Enabled is true while remote agents can connect.
	Enabled bool `json:"enabled"`
	// Port is where they connect, when enabled.
	Port int `json:"port,omitempty"`
	// Source is ListenerFromConfig or ListenerFromDashboard, when enabled.
	Source string `json:"source,omitempty"`
	// CAFingerprint is what an agent pins to trust this hub.
	CAFingerprint string `json:"ca_fingerprint"`
	// Editable is true when the dashboard may turn the listener on.
	Editable bool `json:"editable"`
}

type AgentSource interface {
	Agents() []AgentInfo
	// StaleAfter is how long an agent may stay silent before it is reported as
	// stale.
	StaleAfter() time.Duration
	// Metrics returns the recent metrics of an agent, oldest first; known is
	// false for an agent the hub never saw.
	Metrics(agentID string) (samples []MetricsSample, known bool)
	// Subscribe returns a channel of JSON events (see events.go) and a function
	// that ends the subscription. The channel is closed if the subscriber falls
	// too far behind.
	Subscribe() (events <-chan []byte, cancel func())
}

type Deps struct {
	// UI holds the compiled dashboard.
	UI fs.FS
	// Agents, Layouts and Log may be nil in tests; the agent list is then empty
	// and the layout endpoints answer 404.
	Agents  AgentSource
	Layouts LayoutStore
	Log     *slog.Logger
	// Auth protects the API. A nil Auth leaves it open, which is only meant for
	// tests.
	Auth *auth.Service
	// Fleet enrolls and revokes remote agents. May be nil in tests; the
	// endpoints then answer 404.
	Fleet FleetControl
	// Updates reports and steers the updates of the hub. May be nil in tests;
	// the endpoints then answer 404.
	Updates UpdateControl
	// Rollout updates the managed servers to the version of the hub. May be nil
	// in tests; the endpoints then answer 404.
	Rollout RolloutControl
	// Version is the version the hub was built with. The enrollment answer
	// carries it when it is a release, so a new agent installs the same one.
	Version string
	// DatabaseProblem returns why the database is not answering, or "" when it
	// is. Nil means "no problem", as for SQLite and in tests. Only whether
	// there is a problem is ever sent to a client, never the text.
	DatabaseProblem func() string
}

type Enrollment struct {
	Token         string
	Name          string
	ExpiresAt     time.Time
	CAFingerprint string
	AgentPort     int
}

type FleetControl interface {
	CreateEnrollment(ctx context.Context, by, name string) (Enrollment, error)
	RevokeAgent(ctx context.Context, by, id string) error
	RenameAgent(ctx context.Context, by, id, name string) error
	AgentListener(ctx context.Context) (AgentListener, error)
	EnableAgents(ctx context.Context, by string, port int) (AgentListener, error)
}

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

type LayoutStore interface {
	// Layout returns the stored layout; found is false if the user has none.
	Layout(ctx context.Context, userID int64) (layout json.RawMessage, updatedAt time.Time, found bool, err error)
	SetLayout(ctx context.Context, userID int64, layout json.RawMessage) error
}

type MetricsSample struct {
	At     time.Time
	Report *agentv1.MetricsReport
}

type Option func(*Hub)

type Rejection struct {
	At      time.Time
	Version string
	Message string
}

type RolloutAgent struct {
	ID       string `json:"id"`
	Hostname string `json:"hostname,omitempty"`
	From     string `json:"from"`
	Status   string `json:"status"`
	Message  string `json:"message,omitempty"`
}

type RolloutControl interface {
	RolloutStatus(ctx context.Context) (RolloutStatus, error)
	StartRollout(ctx context.Context, by string, opts RolloutOptions) (RolloutStatus, error)
	StopRollout(ctx context.Context, by string) (RolloutStatus, error)
}

type RolloutOptions struct {
	// Agents limits the rollout to these servers; empty means every candidate.
	Agents []string `json:"agents"`
	// WaveSize is how many servers are updated at the same time (default 1).
	// The rollout stops at the first failure.
	WaveSize int `json:"wave_size"`
}

type RolloutStatus struct {
	// Target is the version the servers are updated to: the one this hub runs.
	Target string `json:"target"`
	State  string `json:"state"`
	// Candidates are the connected servers that run an older version and would
	// be updated by a new rollout.
	Candidates []RolloutAgent `json:"candidates"`
	// Agents is what the last rollout did.
	Agents     []RolloutAgent `json:"agents"`
	WaveSize   int            `json:"wave_size,omitempty"`
	StartedBy  string         `json:"started_by,omitempty"`
	StartedAt  *time.Time     `json:"started_at"`
	FinishedAt *time.Time     `json:"finished_at"`
}

type UpdateControl interface {
	Status(ctx context.Context) (update.Status, error)
	SetSettings(ctx context.Context, by string, s update.Settings) (update.Status, error)
	Check(ctx context.Context) (update.Status, error)
	Download(ctx context.Context, by string) (update.Status, error)
	Apply(ctx context.Context, by string) (update.Status, error)
}