backup

type Manifest struct {
	Version int               `json:"version"`
	Created time.Time         `json:"created"`
	SHA256  map[string]string `json:"sha256"`
	// Dialect is "postgres" for a logical dump; empty means SQLite.
	Dialect string `json:"dialect,omitempty"`
}

type Node struct {
	ID, Name string
}

type Pending struct {
	// Staged is the staging folder, relative to the data directory.
	Staged string `json:"staged"`
	// Kind is "snapshot" (a bundle kept on this server), "upload" (a
	// downloaded bundle) or "undo" (a previous restore's rollback).
	Kind string `json:"kind"`
	// Source names what is restored: a bundle or file name.
	Source        string    `json:"source"`
	BackupCreated time.Time `json:"backupCreated,omitzero"`
	Requested     time.Time `json:"requested"`
	// Rollback is set once the swap has started: the folder (under
	// rollbacks/) the current files move to.
	Rollback string `json:"rollback,omitempty"`
	// Moved are the original files now in the rollback folder, Installed
	// the staged files now in the data directory, and Step the move in
	// flight ("aside:", "install:", "return:" or "restore:" and a file
	// name), all written before and after each move.
	Moved     []string `json:"moved,omitempty"`
	Installed []string `json:"installed,omitempty"`
	Step      string   `json:"step,omitempty"`
	// Applied is set once every file is in place: the restored server is
	// starting and the restore is confirmed when it is ready.
	Applied bool `json:"applied,omitempty"`
	// RollingBack replaces Applied once an applied restore's undo has
	// swept the restored server's files into Installed: from then on only
	// the journal says what to move, so a retried undo never mistakes an
	// original already put back for a file the restored server made.
	RollingBack bool `json:"rollingBack,omitempty"`
	// Failure is why an applied restore is being rolled back.
	Failure string `json:"failure,omitempty"`
}

type Report struct {
	// Status is "restored", or "failed" when the original files are back
	// (the restore could not be applied, or the restored server could not
	// start: RolledBack).
	Status        string    `json:"status"`
	Kind          string    `json:"kind"`
	Source        string    `json:"source"`
	BackupCreated time.Time `json:"backupCreated,omitzero"`
	RestoredAt    time.Time `json:"restoredAt"`
	// RolledBack is set when the backup was in place but the server could
	// not start on it, so the original data was put back automatically.
	RolledBack bool `json:"rolledBack,omitempty"`
	// Rollback is the folder (under rollbacks/) holding the files this
	// restore replaced; Undo puts them back.
	Rollback     string `json:"rollback,omitempty"`
	RollbackPath string `json:"rollbackPath,omitempty"`
	// Files are the data-directory files that were replaced.
	Files []string `json:"files,omitempty"`
	// Logical is set for a PostgreSQL-style dump imported at start;
	// Imported once the import finished.
	Logical  bool `json:"logical,omitempty"`
	Imported bool `json:"imported,omitempty"`
	// Integrity is the restored database's check.
	Integrity *store.Integrity `json:"integrity,omitempty"`
	Error     string           `json:"error,omitempty"`
}

type Rollback struct {
	Name       string    `json:"name"`
	Created    time.Time `json:"created"`
	ReplacedBy string    `json:"replacedBy,omitempty"`
	Files      []string  `json:"files,omitempty"`
}

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

type Settings struct {
	IntervalHours int   `json:"intervalHours"`
	Retain        int   `json:"retain"`
	LastRun       int64 `json:"lastRun"`
	// SharedDir (clustered servers) is a directory every node can reach,
	// at the same path, where scheduled and manual backups are written
	// instead of the writing node's data directory. Empty keeps them on
	// the node that made them.
	SharedDir string `json:"sharedDir,omitempty"`
}

type Snapshot struct {
	Name    string    `json:"name"`
	Size    int64     `json:"size"`
	Created time.Time `json:"created"`
	// Clustered servers only: the node that wrote the bundle and holds it
	// (unless Shared), whether it is in the shared backup directory, and
	// Remote when it is on another node's disk (download it there).
	Node   string `json:"node,omitempty"`
	NodeID string `json:"nodeId,omitempty"`
	Shared bool   `json:"shared,omitempty"`
	Remote bool   `json:"remote,omitempty"`
}

type Staged struct {
	// ID is the staging folder's name in the data directory.
	ID     string `json:"id"`
	Kind   string `json:"kind"`
	Source string `json:"source"`
	// Created is when the backup was taken.
	Created time.Time `json:"created"`
	// Logical is set for a PostgreSQL-style dump: it is imported into
	// this server's own database when it starts.
	Logical bool  `json:"logical,omitempty"`
	Size    int64 `json:"size"`
	// Path is the staging folder, for the guided restore on a cluster.
	Path string `json:"path"`
}