controller

type Config struct {
	// Interval is how long between passes.
	Interval time.Duration
	// PolicyRetry is how soon a pass that met a console answering under
	// another policy is tried again; each further retry waits twice as
	// long. Zero is five seconds.
	PolicyRetry time.Duration
	// Enabled are the workspaces the controller acts in. Every other
	// declared workspace is derived and reported, and nothing is changed: a
	// workspace is born disabled.
	Enabled map[string]bool
	// CredentialsDir is where the workspaces' credentials are mounted, one
	// file per workspace.
	CredentialsDir string
	// RecordsDir is where the console's records are mounted: each
	// workspace's record, the shared channels' definitions and the
	// operators' confirmations. Empty, or absent, is no records.
	RecordsDir string
	// CredentialPoll is how often the mounted credentials are looked at for
	// a change, which runs a pass at once instead of at the next interval:
	// an install lands as a new bot token, and its result should not wait
	// for the full interval. Zero is thirty seconds; negative turns it off.
	CredentialPoll time.Duration
}

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

type Deps struct {
	Log    *slog.Logger
	Access directoryrosterv1connect.AccessServiceClient
	// Audit is where the controller records what it did: the audit
	// installation, with this workload's own identity. Nil records nothing.
	Audit  audit.Recorder
	Status StatusWriter
	// Policy is the declared policy the controller decides with, and Digest
	// the digest of it. The console's answers carry the digest of the policy
	// it computed them under, and a pass acts only on answers from the same
	// one: in a rollout the controller and the console restart at different
	// moments, and a group the new policy binds has, under the old one,
	// nobody in it.
	Policy policy.Policy
	Digest string
	// Slack makes the client that acts with a bot token. Nil is Slack's own
	// API.
	Slack func(token string) *slackapp.Client
	// Leases takes a lease on each workspace before its tick, from the State
	// port. Nil runs every tick without one: a single runner, which is what
	// a deployment with no shared State has (see docs/concepts/sluis/ports.md).
	Leases *rails.Leases
	// Trigger says that a workspace has work: a notification runs that
	// workspace's tick. Nil is an in-process trigger.
	Trigger port.Trigger
	// Records is where the workspaces' records and credentials are read from
	// when they are kept on the State port. Nil reads the mounted
	// directories of [Config].
	Records RecordSource
	// Handoff carries a Slack Connect share from the host's tick to the guest's
	// (see [Handoff]). Nil keeps the hint alone: the host asks the guest to
	// tick, and a lost hint is answered at the guest's next sweep.
	Handoff Handoff
	// Members remembers who a channel's member is across passes (see
	// [apply.MemberCache]). Nil asks Slack every pass.
	Members apply.MemberCache
	Now     func() time.Time
}

type Handoff interface {
	// Offer records that host invited guest to the channel, and asks the
	// guest to tick.
	Offer(ctx context.Context, host, channel, channelID, guest, inviteID string, at time.Time) error
	// Accepted records that guest accepted the host's share.
	Accepted(ctx context.Context, host, channel, channelID, guest string, at time.Time) error
	// Waiting are the shares offered to guest that it has not accepted.
	Waiting(ctx context.Context, guest string) ([]connection.PendingShare, error)
}

type RecordSource interface {
	// Records are the connected workspaces' records.
	Records(ctx context.Context) ([]connection.Record, error)
	// Credential is one workspace's credential; found is false when it has none.
	Credential(ctx context.Context, workspace string) (credential connection.Credential, found bool, err error)
	// Shared and Channels are the console's Slack Connect and channel records.
	Shared(ctx context.Context) ([]connection.SharedRecord, error)
	Channels(ctx context.Context) ([]connection.ChannelRecord, error)
	// Confirmations are the operators' confirmations that still stand.
	Confirmations(ctx context.Context) (map[string]connection.Confirmation, error)
	// PassRequests are the operators' last requests for a pass now.
	PassRequests(ctx context.Context) (map[string]connection.PassRequest, error)
	// Digest summarises what a change to wakes a pass: the records and the
	// credentials, not the confirmations and the pass requests.
	Digest(ctx context.Context) ([sha256.Size]byte, error)
}

type StatusReader = rails.Reader

type StatusWriter = rails.Store