liveness

type Actor struct {
	Kind       audit.PrincipalKind
	ID         string
	OnBehalfOf string
	RequestID  string
}

type Apps interface {
	ByID(ctx context.Context, appID string) (state.App, bool, error)
}

type Auditor interface {
	Write(ctx context.Context, e audit.Event) error
}

type Config struct {
	// Period is T: how long a host must have reached fewer than half the
	// cluster before it stops its apps. DefaultPeriod when zero.
	Period time.Duration

	// Interval is how often a host probes every other. Period/6 when zero,
	// and never more than that.
	Interval time.Duration

	// Timeout bounds one probe. Interval/2 when zero, and never more than
	// Interval.
	Timeout time.Duration

	// PeerWait is how long a round waits for the list of peers before it
	// probes the last one known. The list is read beside the round, never
	// in it, so a database that hangs never keeps a host from probing, or
	// from fencing. The smaller of Timeout and 2 s when zero.
	PeerWait time.Duration
}

type Failover interface {
	PromoteStandby(ctx context.Context, appID string) error
}

type Fencer interface {
	Fence(ctx context.Context) (int, error)
}

type HomedApp struct {
	AppID      string
	HasStandby bool
	// Queue is which apps start one after another: those sharing a queue
	// start in the order listed, each once the one before has ended, and
	// different queues start side by side (R-422: standbys sharing one
	// host past the reservation take its room in priority order).
	Queue string
}

type Homes interface {
	AppsHomedOn(ctx context.Context, hostID string) ([]HomedApp, error)
}

type HostLoss struct {
	HostID      string       `json:"host_id"`
	Name        string       `json:"name"`
	AlreadyLost bool         `json:"already_lost"`
	Started     []string     `json:"started"`
	Skipped     []SkippedApp `json:"skipped"`
}

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

type Monitor struct {
	Self string

	// Peers lists the cluster's hosts. An error keeps the last list.
	Peers func(ctx context.Context) ([]Peer, error)

	// Probe pings a peer and returns the View it answered with, as JSON. An
	// error wrapping ErrContactOnly is contact without a view; any other
	// error is silence.
	Probe func(ctx context.Context, p Peer) ([]byte, error)

	Fencer Fencer
	Config Config
	Clock  clock.Clock
	Logger *zap.Logger
	// contains filtered or unexported fields
}

type Peer struct {
	ID      string
	Name    string
	Address string

	// Lost is that the host is marked lost (R-421). A lost host is left out
	// of the cluster's size on every side — the leader's and each host's
	// alike, so they agree on it — and is not probed by the hosts; the
	// leader still probes it, to see it come back (R-419).
	Lost bool
}

type Returns interface {
	AppsLeftOn(ctx context.Context, hostID string) ([]string, error)
	RemoveStale(ctx context.Context, appID string) error
}

type Service struct {
	Store    Store
	Apps     Apps
	Audit    Auditor
	Logger   *zap.Logger
	Homes    Homes
	Failover Failover
	// Returns removes a returned host's copies before its lost mark is
	// cleared. Nil leaves a lost host marked: without it nothing would
	// remove the copies, and a host still marked lost starts nothing.
	Returns Returns

	// Witness says whether a host has been heard from lately. A host that
	// has is not gone, and is not marked lost by hand: its apps may be
	// running, and a standby started beside them would be a second copy
	// (R-153). Nil skips the check.
	Witness interface {
		Silent(ctx context.Context, h state.Host) error
	}

	// FailoverConcurrency is how many queues of a lost host's apps start
	// at once; zero is DefaultFailoverConcurrency.
	FailoverConcurrency int
	// contains filtered or unexported fields
}

type SkippedApp struct {
	AppID  string `json:"app_id"`
	Reason string `json:"reason"`
	Detail string `json:"detail,omitempty"`
}

type Store interface {
	Host(ctx context.Context, hostID string) (state.Host, error)
	MarkHostLost(ctx context.Context, hostID, by string) (bool, error)
	ClearHostLost(ctx context.Context, hostID string) error
	LostHosts(ctx context.Context) (map[string]bool, error)
	RecordHostFence(ctx context.Context, hostID, fenceID string) (bool, error)
}

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

type View struct {
	Host string `json:"host"`

	// UnreachedMS is, for each peer, how many milliseconds this host has
	// watched it without contact (Tracker.UnreachedFor). A duration on this
	// host's own clock, never a time.
	UnreachedMS map[string]int64 `json:"unreached_ms"`

	// SilentForMS is how long this host had watched the host that sent the
	// probe without contact, until the probe arrived: what the majority
	// would say of the sender. A host that was suspended learns from it, at
	// its first round after it wakes, that it was taken for lost while its
	// own clock stood still (Monitor.Round). Zero for the leader's collector.
	SilentForMS int64 `json:"silent_for_ms,omitempty"`

	// Fenced is whether this host is cut off and has stopped its apps.
	Fenced bool `json:"fenced"`

	// FenceID names this host's latest fence, so the leader audits each one
	// once (cluster.host.fence) however often it hears of it. Kept after the
	// host is reached again, until it fences next.
	FenceID string `json:"fence_id,omitempty"`

	// Stopped is how many app containers the latest fence stopped.
	Stopped int `json:"stopped,omitempty"`
}

type Watch struct {
	// Hosts lists every host of the cluster, lost ones included: a lost
	// host is still probed, to see it come back, but no longer counts
	// toward the cluster's size.
	Hosts func(ctx context.Context) ([]Peer, error)

	// Probe asks a host's agent for its View, as JSON; as Monitor.Probe.
	Probe func(ctx context.Context, p Peer) ([]byte, error)

	Service *Service
	Config  Config
	Clock   clock.Clock
	Logger  *zap.Logger
	// contains filtered or unexported fields
}

type Witness struct {
	// Hosts lists the cluster's hosts, as Watch.Hosts.
	Hosts func(ctx context.Context) ([]Peer, error)

	// Probe is Watch.Probe.
	Probe func(ctx context.Context, p Peer) ([]byte, error)

	// Local is this control host's Monitor's UnreachedFor; nil when it has
	// none yet.
	Local func(hostID string) (time.Duration, bool)

	Config Config
}