dbupgrade

type Advice struct {
	Engine         string   `json:"engine"`
	Current        string   `json:"current"`
	Comparable     bool     `json:"comparable"`
	Floating       bool     `json:"floating"`
	Line           string   `json:"line,omitempty"`
	EOL            string   `json:"eol,omitempty"`
	Support        string   `json:"support"`
	Advisories     []string `json:"advisories,omitempty"`
	Targets        []Target `json:"targets"`
	AutoMax        string   `json:"auto_max"`
	ImageRevert    bool     `json:"image_revert"`
	ManualReason   string   `json:"manual_reason,omitempty"`
	Notes          string   `json:"notes,omitempty"`
	Note           string   `json:"note,omitempty"`
	CatalogUpdated string   `json:"catalog_updated"`
}

type Advisor struct {
	Catalog *Catalog
	// EOLWarn is how long before end of life a line counts as eol_soon.
	EOLWarn time.Duration
}

type Advisory struct {
	IDs   []string `json:"ids"`
	Fixed []string `json:"fixed"`
}

type BackupRunner interface {
	RunBackup(ctx context.Context, historyID, databaseName, engine, containerName, targetID string) error
}

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

type ChannelNotifier struct {
	Channels ChannelStore
	Sender   NoticeSender
}

type ChannelStore interface {
	GetNotificationChannel(ctx context.Context, id string) (*alerting.NotificationChannel, error)
}

type DockerHubLister struct {
	Client *http.Client
}

type DockerRuntime struct {
	Store    DockerStore
	Docker   VolumeRuntime
	Backups  BackupRunner
	Verifier VerifyRunner
	Restorer RestoreRunner
	// CopyVolume and WipeVolume are internal/backup's volume helpers.
	CopyVolume func(ctx context.Context, rt docker.Runtime, src, dst string) error
	WipeVolume func(ctx context.Context, rt docker.Runtime, name string) error
	Nudge      func()
	// StopWait bounds the wait for the reconciler to stop a database.
	StopWait time.Duration
}

type DockerStore interface {
	GetDesiredDatabase(ctx context.Context, name string) (*store.DesiredDatabase, error)
	SaveDesiredDatabase(ctx context.Context, d store.DesiredDatabase) error
	UpdateDatabaseSuspended(ctx context.Context, name string, suspended bool) error
	GetBackupHistory(ctx context.Context, id string) (store.BackupHistory, error)
	ListBackupVerifications(ctx context.Context, backupHistoryID string, limit int) ([]store.BackupVerification, error)
	ListRunningMajorUpgrades(ctx context.Context) ([]store.MajorUpgrade, error)
	ListRestoreHistory(ctx context.Context, databaseName string) ([]store.RestoreHistory, error)
}

type EngineCatalog struct {
	Levels       []string      `json:"levels"`
	AutoMax      string        `json:"auto_max"`
	ImageRevert  bool          `json:"image_revert"`
	ManualReason string        `json:"manual_reason"`
	Notes        string        `json:"notes"`
	Versions     []string      `json:"versions"`
	Lines        []SupportLine `json:"lines"`
	Advisories   []Advisory    `json:"advisories"`
}

type Manager struct {
	Store   Store
	Runner  *Runner
	Advisor Advisor
	Logger  *slog.Logger
	Now     func() time.Time
	// MinWindowRemaining stops a run starting too close to a window's end.
	MinWindowRemaining time.Duration
	// Unreachable returns why the runner cannot act on a database (for
	// example it runs on another node), or "". nil means always reachable.
	Unreachable func(db store.DesiredDatabase) string
	// contains filtered or unexported fields
}

type NoticeSender interface {
	SendNotice(ctx context.Context, kind alerting.NotifyKind, notifyURL, text string) error
}

type Notifier interface {
	Notify(ctx context.Context, channelIDs []string, text string) error
}

type Overview struct {
	Database        string
	Engine          string
	Version         string
	Advice          Advice
	Policy          Policy
	PolicyInherited bool
	WindowOpen      bool
	NextWindow      time.Time
	// NextTarget is what the next window would apply, when anything.
	NextTarget *Target
	Blockers   []string
	Active     *store.DBUpgradeRun
	History    []store.DBUpgradeRun
}

type Policy struct {
	AutoUpgrade     string        `json:"auto_upgrade"`
	WindowCron      string        `json:"window_cron"`
	WindowDuration  time.Duration `json:"-"`
	WindowTimezone  string        `json:"window_timezone"`
	BackupBefore    bool          `json:"backup_before"`
	VerifyAfter     bool          `json:"verify_after"`
	RevertOnFailure bool          `json:"revert_on_failure"`
	Notify          []string      `json:"notify"`
}

type Refresher struct {
	Catalog *Catalog
	Lister  TagLister
	Logger  *slog.Logger
}

type RestoreRunner interface {
	RunRestore(ctx context.Context, historyID, databaseName, backupHistoryID, engine, containerName string) error
}

type Runner struct {
	Store    Store
	Runtime  Runtime
	Catalog  *Catalog
	Notifier Notifier
	Logger   *slog.Logger
	Now      func() time.Time
	// HealthTimeout bounds each wait for the database to come up healthy.
	HealthTimeout time.Duration
	Poll          time.Duration
}

type Runtime interface {
	// Busy returns a non-empty reason when another job owns the database.
	Busy(ctx context.Context, name string) (string, error)
	RunBackup(ctx context.Context, backupID string, db store.DesiredDatabase) error
	BackupStatus(ctx context.Context, backupID string) (string, error)
	RunVerify(ctx context.Context, verificationID, backupID, engine string) error
	VerifyStatus(ctx context.Context, backupID, verificationID string) (string, error)
	CheckImage(ctx context.Context, engine, version string) error
	ImageDigest(ctx context.Context, name string) (string, error)
	// SnapshotData stops the database and copies its data volume into volume; it stays stopped.
	SnapshotData(ctx context.Context, name, volume string) error
	// SetVersion saves the desired version and makes sure the database runs.
	SetVersion(ctx context.Context, name, version string) error
	Resume(ctx context.Context, name string) error
	// Health reports whether the database runs version and, when deep, answers
	// a query. It returns the server's reported version when it has one.
	Health(ctx context.Context, db store.DesiredDatabase, version string, deep bool) (ready bool, serverVersion string, err error)
	RestoreSnapshot(ctx context.Context, name, volume, version string) error
	// ResetData empties the data volume and starts version on it fresh.
	ResetData(ctx context.Context, name, version string) error
	RestoreBackup(ctx context.Context, restoreID, backupID string, db store.DesiredDatabase) error
	RemoveVolume(ctx context.Context, volume string) error
}

type Store interface {
	GetDesiredDatabase(ctx context.Context, name string) (*store.DesiredDatabase, error)
	ListDesiredDatabases(ctx context.Context) ([]store.DesiredDatabase, error)
	CreateDBUpgradeRun(ctx context.Context, r store.DBUpgradeRun) error
	UpdateDBUpgradeRun(ctx context.Context, r store.DBUpgradeRun) error
	GetDBUpgradeRun(ctx context.Context, id string) (store.DBUpgradeRun, error)
	ListDBUpgradeRuns(ctx context.Context, databaseName string, limit int) ([]store.DBUpgradeRun, error)
	ListActiveDBUpgradeRuns(ctx context.Context) ([]store.DBUpgradeRun, error)
	GetDBUpgradePolicy(ctx context.Context, name string) (store.DBUpgradePolicy, bool, error)
	SaveDBUpgradePolicy(ctx context.Context, p store.DBUpgradePolicy) error
	DeleteDBUpgradePolicy(ctx context.Context, name string) error
}

type SummaryItem struct {
	Database   string
	Engine     string
	Version    string
	Support    string
	EOL        string
	Security   bool
	Advisories []string
	Available  int
	Active     *store.DBUpgradeRun
	Last       *store.DBUpgradeRun
}

type SupportLine struct {
	Line string `json:"line"`
	EOL  string `json:"eol"`
}

type TagLister interface {
	ListTags(ctx context.Context, repository string) ([]string, error)
}

type Target struct {
	Version  string `json:"version"`
	Kind     string `json:"kind"`
	Security bool   `json:"security"`
	// Advisories are the CVE ids this target fixes for the current version.
	Advisories []string `json:"advisories,omitempty"`
	EOL        string   `json:"eol,omitempty"`
	// Automatic is true when the engine allows this kind without an operator.
	Automatic bool `json:"automatic"`
}

type VerifyRunner interface {
	VerifyBackup(ctx context.Context, verificationID, backupHistoryID, engine, checkedBy string) error
}

type VolumeRuntime interface {
	docker.Runtime
	EnsureVolume(ctx context.Context, name string) error
	RemoveVolume(ctx context.Context, name string) error
}