cluster

type Event struct {
	ID        int64
	Topic     string
	Origin    string // node ID of the publisher
	Payload   []byte
	CreatedAt time.Time
}

type Handler func(Event)

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

type LeadershipOptions struct {
	// TTL is how long the lease lasts without renewal (default 30 s);
	// Renew how often the holder renews it and others try to take it
	// (default TTL/3).
	TTL   time.Duration
	Renew time.Duration
	// PredecessorSilence is how long a holder that ran on this machine
	// under this hostname, but in another pid namespace (typically this
	// container's predecessor in its pod), must have been silent in the
	// node registry before this replica takes the lease from it (default
	// two HeartbeatIntervals). See predecessorGone.
	PredecessorSilence time.Duration
}

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

type LogOptions struct {
	// PollInterval is how often the log is read without a notification
	// (default 5 s). Notifications only make delivery faster: a lost one
	// (listener reconnecting, NOTIFY dropped) delays an event by at most
	// this long. Every notification wakes a read, and so does every
	// listener reconnect, so the poll only covers a listener whose
	// connection died unnoticed. Each poll is two queries on every
	// replica, idle or not.
	PollInterval time.Duration
	// Window is how far back every read looks again for rows it has not
	// seen (default 30 s). An id is allocated before its row commits, so a
	// row can become visible after a higher id was already read; the window
	// is how long such a straggler is still picked up.
	Window time.Duration
	// Retention is how long rows are kept (default 15 min); PruneInterval
	// how often they are pruned (default 1 min). Retention is at least
	// twice Window.
	Retention     time.Duration
	PruneInterval time.Duration
	// BatchSize bounds one read (default 500); a full batch is followed by
	// another read at once.
	BatchSize int
	// ListenerDSN is the connection string for LISTEN; empty means the one
	// the database was opened with. Tests give each replica its own.
	ListenerDSN string
}

type LogStats struct {
	Enabled bool
	// Listening reports whether notifications wake the reader; without
	// them (the listener cannot connect) it reads every PollInterval.
	Listening          bool
	Cursor             int64     // highest id handled
	Delivered          uint64    // events handed to handlers
	LastRead           time.Time // last successful read
	ListenerReconnects uint64
	ReadErrors         uint64
	LastError          string
}

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

type NodeOptions struct {
	// Label names the replica on the status page and the Edge Gateways
	// page ("studio", "dashboard", "mdcb-eu-1"): at most MaxLabelLength
	// characters, letters, digits, spaces and . _ - : / ( ) only. Empty
	// leaves it unlabelled.
	Label string
	// NeverLeads records that the replica never takes the leader lease (a
	// headless control plane). It is recorded for operators; the replica's
	// own code decides whether it contends for the lease.
	NeverLeads bool
}

type NodeStatus struct {
	NodeID    string    `json:"node_id"`
	Hostname  string    `json:"hostname"`
	Version   string    `json:"version"`
	StartedAt time.Time `json:"started_at"`
	LastSeen  time.Time `json:"last_seen"`
	// Label names the replica for operators (empty when it has none).
	Label string `json:"label"`
	// LeaderEligible is false for a replica that never takes the leader
	// lease (a headless control plane).
	LeaderEligible bool `json:"leader_eligible"`
	// Edges is how many connected edges hold a stream to this replica.
	Edges int64 `json:"edges"`
	// Leader: this replica holds the leader lease.
	Leader bool `json:"leader"`
	// Self: the replica answering the request.
	Self bool `json:"self"`
}

type Owner struct {
	Label string
	// Live: the replica's registration is fresh. An edge whose owner is not
	// live reconnects to another replica shortly.
	Live bool
}

type PushBacklog struct {
	Pending  int64 `json:"pending"`   // waiting for the edge's stream
	InFlight int64 `json:"in_flight"` // claimed or sent, waiting for the edge
	// OldestPending is when the oldest pending command was created.
	OldestPending *time.Time `json:"oldest_pending,omitempty"`
	// Unowned counts in-flight commands whose replica is no longer live;
	// a janitor returns them to pending within seconds, so a lasting
	// non-zero value means no replica's janitor runs.
	Unowned int64 `json:"unowned"`
}

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

type RelayOptions struct {
	// Filter picks the events to relay (default RelayedByDefault).
	Filter func(eventbridge.Event) bool
	// QueueSize bounds the events waiting to be written to the log
	// (default 4096). When it is full, events are dropped and counted.
	QueueSize int
	// PublishTimeout bounds one write to the log (default 5 s); a failed
	// write is retried with backoff up to MaxRetries times (default 5).
	PublishTimeout time.Duration
	MaxRetries     int
}

type RelayStats struct {
	Sent     uint64 // events written to the log
	Received uint64 // events from other replicas republished locally
	Dropped  uint64 // events lost: queue full, or the log write kept failing
}

type Status struct {
	Self     string       `json:"self"`
	Database string       `json:"database"` // postgres | sqlite
	Nodes    []NodeStatus `json:"nodes"`
	// EdgesWithoutReplica counts connected edges whose owning replica is
	// not live: they reconnect elsewhere shortly.
	EdgesWithoutReplica int64 `json:"edges_without_replica"`

	Leader          string     `json:"leader"`
	LeaderExpiresAt *time.Time `json:"leader_expires_at,omitempty"`

	// EventLog and Relay are this replica's own.
	EventLog LogStats   `json:"event_log"`
	Relay    RelayStats `json:"relay"`

	Pushes PushBacklog `json:"pushes"`

	// Warnings explain anything that needs attention.
	Warnings []string `json:"warnings"`
}