hubca

type ActivateRequest struct {
	// Force activates although runs dispatched before the stage are still
	// running: they stop verifying the monitors, and are named.
	Force bool
	// contains filtered or unexported fields
}

type ActivateResult struct {
	Rotation statedb.HubCARotationRow `json:"rotation"`
	// Broken are the runs a forced activation broke.
	Broken []Run `json:"broken,omitempty"`
}

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

type CAInfo struct {
	Slot        Slot      `json:"slot"`
	Serial      string    `json:"serial"`
	Fingerprint string    `json:"fingerprint"`
	NotBefore   time.Time `json:"not_before"`
	NotAfter    time.Time `json:"not_after"`
	// Names are the names the CA's X.509 name constraints permit; empty for a
	// CA without constraints, which may vouch for any name.
	Names    []string          `json:"names,omitempty"`
	IssuedAt time.Time         `json:"issued_at,omitzero"`
	IssuedBy string            `json:"issued_by,omitempty"`
	Cert     *x509.Certificate `json:"-"`
	PEM      []byte            `json:"-"`
}

type EmergencyResult struct {
	Rotation statedb.HubCARotationRow `json:"rotation"`
	// Replaced are the CAs it took out of every bundle.
	Replaced []string `json:"replaced"`
	CA       *CAInfo  `json:"ca"`
	// Cut are the runs whose proxy sessions the hub members end.
	Cut []Run `json:"cut,omitempty"`
	// Leaves are the monitors' certificates it reissued from the new CA.
	Leaves []Issued `json:"leaves,omitempty"`
}

type Env struct {
	Store  *Store
	Sealer Sealer
	// Options carries the clock, who is acting (Actor) and where the step's
	// record goes (Rotation, Audit).
	Options Options
	// Runs lists the dispatches still running; nil reads the control plane's
	// executor sessions.
	Runs func() ([]Run, error)
	// Alive judges a hub member row; nil counts every member that has not
	// left. The CLI passes hubcluster.RowAlive, a member its own view.
	Alive func(statedb.HubMemberRow) bool
}

type Issued struct {
	// CA is true for the CA itself, false for a monitor's leaf.
	CA bool
	// Monitor is the leaf's monitor; empty for the CA.
	Monitor Monitor
	Serial  string
	// Fingerprint is the SHA-256 of the certificate's DER, in hex: what an
	// operator compares against the PEM a sandbox was given.
	Fingerprint string
	Names       []string
	NotAfter    time.Time
	// Replaced is the serial of the leaf this one replaced, if any.
	Replaced string
	// Issuer is the serial of the CA that signed a leaf.
	Issuer string
	// Reason says why a leaf was issued: Reason*.
	Reason string
}

type Leaf struct {
	Monitor  Monitor
	Serial   string
	Cert     *x509.Certificate
	CertPEM  []byte
	IssuedBy string
	// contains filtered or unexported fields
}

type LeafInfo struct {
	Monitor  Monitor
	Cert     *x509.Certificate
	SANs     []string
	Issuer   string
	IssuedBy string
	IssuedAt time.Time
}

type LeafStatus struct {
	Monitor  Monitor   `json:"monitor"`
	Serial   string    `json:"serial"`
	Issuer   string    `json:"issuer"`
	Slot     Slot      `json:"slot,omitempty"`
	Names    []string  `json:"names"`
	NotAfter time.Time `json:"not_after"`
}

type Member struct {
	ID       string `json:"id"`
	Hostname string `json:"hostname,omitempty"`
	PID      int    `json:"pid,omitempty"`
	Version  string `json:"version,omitempty"`
	// Rotates reports that the member's build takes part in a rotation
	// (EndpointRotation).
	Rotates bool `json:"rotates"`
	// Report is what the member last said it serves; nil when it has said
	// nothing — it runs no credential monitor under tls: auto.
	Report *statedb.HubCAMemberRow `json:"-"`
}

type MemberStatus struct {
	Member
	Trusts    []string                        `json:"trusts,omitempty"`
	Active    string                          `json:"active,omitempty"`
	Leaves    map[string]statedb.HubCALeafAck `json:"leaves,omitempty"`
	AdoptedAt time.Time                       `json:"adopted_at,omitzero"`
	SeenAt    time.Time                       `json:"seen_at,omitzero"`
	// Serves reports that the member runs a credential monitor under tls:
	// auto: it reported, recently.
	Serves bool `json:"serves"`
	// CaughtUp is false while the member trusts, signs with or serves
	// something the rotation's current step has moved past; Behind says what.
	CaughtUp bool   `json:"caught_up"`
	Behind   string `json:"behind,omitempty"`
}

type MembersError struct {
	Members []MemberStatus
	// Old reports that some predate rotation: no flag overrides that.
	Old bool
}

type Monitor string

type Options struct {
	// Now is the clock; nil uses time.Now.
	Now func() time.Time
	// Actor names the hub process issuing, for the row's issued_by.
	Actor string
	// Audit receives one record per certificate this process minted or
	// issued — never one it adopted from another process. Nil drops them.
	Audit func(Issued)
	// Rotation receives one record per rotation step this process took
	// (rotate.go). Nil drops them.
	Rotation func(RotationEvent)
}

type Phase string

type RetireResult struct {
	Rotation statedb.HubCARotationRow `json:"rotation"`
	Retired  string                   `json:"retired"`
}

type RotationEvent struct {
	Step       Step
	RotationID string
	FromSerial string
	ToSerial   string
	// Fingerprint and NotAfter describe the CA a stage minted.
	Fingerprint string
	NotAfter    time.Time
	Names       []string
	// Forced are the runs an activation was told to break.
	Forced []string
	// CutRuns are the runs whose proxy sessions an emergency ends.
	CutRuns   []string
	Emergency bool
	Detail    string
}

type Run struct {
	ID         string    `json:"run_id,omitempty"`
	SessionID  string    `json:"session_id"`
	Project    string    `json:"project,omitempty"`
	TaskID     int       `json:"task_id,omitempty"`
	ExecutorID string    `json:"executor_id,omitempty"`
	StartedAt  time.Time `json:"started_at,omitzero"`
	// Trusts are the hub CA serials the dispatch was told to trust, and Uses
	// the paths it was told them on (UseGitProxy, UseKubeGuard, UseNode).
	// Recorded is false for a dispatch made by a build from before rotation.
	Trusts   []string `json:"trusts,omitempty"`
	Uses     []string `json:"uses,omitempty"`
	Recorded bool     `json:"recorded"`
}

type RunsError struct{ Runs []Run }

type Sealer interface {
	SealFor(aad string, plaintext []byte) (secretbroker.Envelope, error)
	OpenEnvelope(aad string, env secretbroker.Envelope) ([]byte, error)
}

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

type ServerConfig struct {
	Monitor Monitor
	Store   *Store
	Sealer  Sealer
	// Trust is the process's view of the control plane's CAs, which a
	// rotation changes under a running server. Authority instead pins one CA
	// for the server's life: a caller without a store.
	Trust     *Trust
	Authority *Authority
	// Want are the names the monitor's sandboxes reach it at: SANsFor.
	Want    []string
	Options Options
	// Logf receives one line per certificate issued. Nil discards them.
	Logf func(format string, args ...any)
}

type Slot string

type Snapshot struct {
	Bundle  []byte
	Serials []string
}

type StageRequest struct {
	// Names are the names the new CA's constraints permit, beside the ones
	// every stored leaf already carries: what the monitors are reached at, and
	// any name an advertise URL is about to move to.
	Names []string
	// NoNameConstraints mints the new CA without constraints, as the first one
	// was: it can then vouch for any name.
	NoNameConstraints bool
	// Emergency marks the stage as Emergency's first step.
	Emergency bool
}

type StageResult struct {
	Rotation statedb.HubCARotationRow `json:"rotation"`
	CA       *CAInfo                  `json:"ca"`
}

type State struct {
	Active   *CAInfo `json:"active,omitempty"`
	Next     *CAInfo `json:"next,omitempty"`
	Previous *CAInfo `json:"previous,omitempty"`
	// Rotation is the rotation under way, nil when there is none.
	Rotation *statedb.HubCARotationRow `json:"-"`
}

type Status struct {
	Phase    Phase                     `json:"phase"`
	Active   *CAInfo                   `json:"active,omitempty"`
	Next     *CAInfo                   `json:"next,omitempty"`
	Previous *CAInfo                   `json:"previous,omitempty"`
	Rotation *statedb.HubCARotationRow `json:"rotation,omitempty"`
	Members  []MemberStatus            `json:"members"`
	Leaves   []LeafStatus              `json:"leaves"`
	// Blocking are the runs the next step would break: while staged, those
	// that do not trust the staged CA; once activated, those that trust only
	// the previous one.
	Blocking []Run `json:"blocking,omitempty"`
	// Running counts the runs on record as running.
	Running int `json:"running"`
	// NextStep says what an operator can do now.
	NextStep string `json:"next_step"`
	// Ready reports that the next step would not be refused.
	Ready bool `json:"ready"`
}

type Step string

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

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