postgres

type BaseBackup struct {
	// Walker stores the commit; its Set is the base set. Run sets its
	// Stream and Metadata.
	Walker *backup.Walker
}

type BaseInfo struct {
	SystemID     uint64
	Timeline     uint32
	StartLSN     uint64
	StopLSN      uint64
	StartWALFile string
}

type BaseStream struct {
	// Tar is the backup as pg_basebackup -D - -Ft -X fetch writes it: the
	// data directory with the WAL it needs, then backup_manifest.
	Tar io.Reader
	// Wait reports how the backup ended, once Tar is read to its end.
	Wait func() error
	// contains filtered or unexported fields
}

type OpenSegment struct {
	// Name is the segment's name.
	Name string
	// Path is where it is on disk.
	Path string
	// Size is how much of it holds whole records.
	Size int64
}

type Receiver struct {
	// ConnString is the libpq connection string of the replication
	// connection and of the monitoring one, which goes to the database it
	// names, postgres by default; empty leaves both to the PG* variables.
	ConnString string
	// Slot is the physical replication slot; SlotName of the WAL set when
	// empty. The receiver creates it when missing.
	Slot string
	// AllowUncappedSlot streams even when max_slot_wal_keep_size doesn't
	// bound what the slot keeps.
	AllowUncappedSlot bool
	// Spool is where WAL waits for its commit; one receiver per spool.
	Spool Spool
	// Walker returns the walker of one commit: its Set is the WAL set and
	// its Root the spool's directory.
	Walker func() *backup.Walker
	// BaseSet is the set the cluster's base backups go to.
	BaseSet string
	// Window is how far back point-in-time recovery reaches.
	Window time.Duration
	// CommitEvery is how often new WAL is committed; DefaultCommitEvery
	// when zero, and at least MinCommitEvery.
	CommitEvery time.Duration
	// CommitBytes of new WAL commit early; DefaultCommitBytes when zero.
	CommitBytes int64
	// Logger is where the receiver reports; nil means slog.Default.
	Logger *slog.Logger
	// Committed, when set, hears of each commit once it is stored.
	Committed func(*backup.WalkResult)
	// Report, when set, hears how the receiver stands every ten seconds.
	Report func(ReceiverStatus)
	// contains filtered or unexported fields
}

type ReceiverStatus struct {
	Timeline uint32 `json:"timeline"`
	// Received is where the WAL written to the spool ends.
	Received string `json:"received"`
	// Committed is where the WAL the newest stored commit holds ends.
	Committed string `json:"committed,omitempty"`
	// LagBytes is how much WAL the server has written that no commit
	// holds; LagSeconds how long the oldest of it has waited.
	LagBytes   int64   `json:"lag_bytes"`
	LagSeconds float64 `json:"lag_seconds"`
	SpoolBytes int64   `json:"spool_bytes"`
	// WALStatus and SafeWALSize are the slot's, as pg_replication_slots
	// shows them; SafeWALSize is -1 when nothing bounds it.
	WALStatus   string `json:"wal_status,omitempty"`
	SafeWALSize int64  `json:"safe_wal_size"`
	// RetainedBytes is how much WAL the slot keeps on the server.
	RetainedBytes int64 `json:"retained_bytes"`
	// Healthy is false while WAL has waited for a commit longer than
	// three commit intervals.
	Healthy bool `json:"-"`
}

type Restore struct {
	Objects backup.ObjectStore
	Key     *storekey.Key
	// Latest finds a set's newest complete commit; it returns
	// backup.ErrNotFound for a set without one.
	Latest  func(ctx context.Context, set string) (*proto.Ref, error)
	BaseSet string
	// WALSet, when empty, restores the base alone: Postgres recovers to the
	// end of the base backup.
	WALSet string
	// At, when set, is the moment recovery stops at; zero recovers to the
	// end of the WAL set.
	At time.Time
	// FS is the tree the data directory is written onto; nil is the local
	// disk.
	FS backup.WriteFS
	// RestoreCommand, when set, is the restore_command that fetches the WAL
	// commit's files, with %f and %p for Postgres to fill in. When nil, the
	// WAL recovery reads is copied into the data directory's pg_wal.
	RestoreCommand func(walCommit *proto.Ref) string
}

type RestoreResult struct {
	Base    *proto.Commit
	BaseRef *proto.Ref
	// WAL is the WAL commit recovery reads from; nil when the WAL set has
	// none, and then the cluster recovers only to the end of its base.
	WAL *proto.Ref
	// Copied names the WAL files copied into pg_wal, as they are named
	// there; empty with a RestoreCommand.
	Copied []string
	// ModeUnset is true when FS could not give the data directory mode
	// 0700, which Postgres needs before it starts on it.
	ModeUnset bool
}

type Spool struct {
	Dir string
}

type WALBackup struct {
	// Walker stores the commit; its Root is the spool's directory and its
	// Set the WAL set. Run sets its Include, Carry, Growing and Metadata.
	Walker *backup.Walker
	Spool  Spool
	// BaseSet is the set the cluster's base backups go to.
	BaseSet string
	Window  time.Duration
	Now     func() time.Time
	// Files are the spool's whole files to commit.
	Files []string
	// Open, when set, is the segment still being received; the commit
	// holds it up to its length as <name>.partial, in place of the previous
	// commit's partial segment of its timeline.
	Open *OpenSegment
}