mysql

type Binlog struct {
	Name string
	Size int64
}

type Client interface {
	Querier
	// DumpVersion is the output of mysqldump --version.
	DumpVersion(ctx context.Context) (string, error)
	// Dump starts mysqldump with args. Close on the returned reader waits
	// for mysqldump, stopping it first unless its output was read to the
	// end, and reports how it ended.
	Dump(ctx context.Context, args []string) (io.ReadCloser, error)
	// Load runs the SQL r holds through mysql.
	Load(ctx context.Context, r io.Reader) error
	// BinlogVersion is the output of mysqlbinlog --version; it fails when
	// there is no mysqlbinlog.
	BinlogVersion(ctx context.Context) (string, error)
	// Replay runs mysqlbinlog with args, under TZ=UTC, into mysql.
	Replay(ctx context.Context, args []string) error
}

type Dump struct {
	// Walker stores the commit; its Set is the dump set. Run sets its
	// Stream and Metadata.
	Walker *backup.Walker
	Client Client
	// NoPosition leaves the binary log position out even when log_bin is
	// on, which spares the dump the global read lock and the RELOAD and
	// REPLICATION CLIENT privileges.
	NoPosition bool
	// BinlogSet, when set, is the set the server's binlogs go to; a dump
	// joins the newest chain it has seen, which catches a reset the
	// numbering since the previous dump does not show.
	BinlogSet string
	// Logger is where the dump reports; nil means slog.Default.
	Logger *slog.Logger
}

type Exec struct {
	Mysql       string
	Mysqldump   string
	Mysqlbinlog string
	// DefaultsFile, when set, goes to every program as
	// --defaults-extra-file.
	DefaultsFile string
	// Stderr receives the programs' errors; nil means os.Stderr.
	Stderr io.Writer
}

type Identity struct {
	ServerID   uint32
	ServerUUID string
	Base       string
}

type OpenBinlog struct {
	Name string
	Path string
	// Size is how much of it holds whole events.
	Size int64
	// ModTime is its last event's time.
	ModTime time.Time
	// Created is its format description event's time.
	Created time.Time
}

type Options struct {
	Host     string
	Port     int
	Socket   string
	User     string
	Password string
	// Protocol is tcp or socket, as --protocol takes it; empty picks by
	// Host.
	Protocol string
	// SSLMode, SSLCA, SSLCert and SSLKey are the --ssl-* options.
	SSLMode string
	SSLCA   string
	SSLCert string
	SSLKey  string
}

type Querier interface {
	// Query runs sql and returns its rows as mysql --batch
	// --skip-column-names prints them, NULL as "NULL".
	Query(ctx context.Context, sql string) ([][]string, error)
}

type Receiver struct {
	// DefaultsExtraFile is the option file read before ~/.my.cnf for the
	// connection and its password.
	DefaultsExtraFile string
	// ServerID is the replica server id the receiver connects with;
	// ReplicaServerID of the set when zero.
	ServerID uint32
	// Spool is where binlogs wait for their commit; one receiver per spool.
	Spool Spool
	// Walker returns the walker of one commit: its Set is the binlog set
	// and its Root the spool's directory.
	Walker func() *backup.Walker
	// DumpSet is the set the server's dumps go to.
	DumpSet string
	// Window is how far back point-in-time recovery reaches.
	Window time.Duration
	// CommitEvery is how often new binlog is committed; DefaultCommitEvery
	// when zero, and at least MinCommitEvery.
	CommitEvery time.Duration
	// CommitBytes of new binlog 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 {
	Chain     int  `json:"chain"`
	Connected bool `json:"connected"`
	// Received is the binlog and position the spool's binlogs end at.
	Received string `json:"received,omitempty"`
	// Committed is where the binlogs the newest stored commit holds end.
	Committed string `json:"committed,omitempty"`
	// LagBytes is how much binlog the server holds that no commit holds,
	// as of the last minute; LagSeconds how long the oldest received byte
	// no commit holds has waited.
	LagBytes   int64   `json:"lag_bytes"`
	LagSeconds float64 `json:"lag_seconds"`
	SpoolBytes int64   `json:"spool_bytes"`
	ServerID   uint32  `json:"server_id"`
	// Healthy is false while a received byte has waited for a commit, or
	// the receiver for a connection, longer than three commit intervals.
	Healthy bool `json:"-"`
}

type Restore struct {
	Objects backup.ObjectStore
	Key     *storekey.Key
	// Latest finds a set's newest commit; it returns backup.ErrNotFound for
	// a set without one.
	Latest  func(ctx context.Context, set string) (*proto.Ref, error)
	DumpSet string
	// BinlogSet, when empty, restores the dump alone.
	BinlogSet string
	// At, when set, is the moment the restore stops at; zero replays to the
	// end of the binlog set.
	At     time.Time
	Client Client
	// WorkDir is where the binlogs are fetched to before the replay.
	WorkDir string
	// To, when set, only writes the dump and the binlogs into this empty
	// directory, for the caller to apply.
	To string
	// FS is the tree To names a directory of; nil is the local disk.
	FS backup.WriteFS
	// Force loads into a server that holds databases already.
	Force bool
}

type RestoreResult struct {
	Dump    *proto.Commit
	DumpRef *proto.Ref
	// Binlog is the binlog commit the binlogs come from; nil without a
	// binlog set or when it has no commits.
	Binlog       *proto.Ref
	BinlogFormat string
	// Binlogs names the binlogs replayed, in order.
	Binlogs []string
	// ReplayArgs are mysqlbinlog's arguments; empty when nothing is
	// replayed. With To, they name the binlogs as FS names them.
	ReplayArgs []string
	// DumpPath is where a restore with To wrote the dump, as FS names it.
	DumpPath string
}

type Server struct {
	Version        string
	Major, Minor   int
	Patch          int
	LogBin         bool
	ServerID       uint32
	ServerUUID     string
	BinlogBasename string
	BinlogFormat   string
	GTIDMode       bool
}

type Spool struct {
	Dir string
}