index

type CommitDetail struct {
	Commit *proto.Commit
	// Ref is the commit object's own ref, which names it to a caller that
	// wants to pin or read it.
	Ref *proto.Ref
	// LogicalSize is what the set's files held at this commit, and Files
	// how many there were; nil when nothing measured it, which is every
	// commit written before the index started recording it.
	LogicalSize, Files *int64
	// RetainedBy names the retention rules keeping this commit, comma
	// separated: "last", "within", "pinned", "hourly", "daily", "weekly",
	// "monthly". It is empty for a commit retention has not evaluated yet
	// or has retired.
	RetainedBy string
	// Incomplete reports a commit indexed around objects the store no
	// longer holds, which cannot be restored whole.
	Incomplete bool
}

type CommitIndexer interface {
	IndexCommits(ctx context.Context, refs []*proto.Ref, dryRun bool) ([]IndexedSet, error)
}

type IndexedSet struct {
	// SetID is 0 for a set a dry run would create under a fresh id.
	SetID int64
	Set   string
	// Created is a set that did not exist before.
	Created bool
	// Placeholder is a set the commits went to because they name none.
	Placeholder bool
	Commits     int
	// Chained is whether each commit names the one received before it as
	// its parent.
	Chained bool
	// Oldest and Newest are the receipt times of the first and last commit.
	Oldest, Newest time.Time
	// Indexed counts the commits indexed, Tied those of them indexed a
	// microsecond after their set's newest, and Behind those received
	// before the set's newest and left out; all 0 on a dry run.
	Indexed, Tied, Behind int
}

type LostLister interface {
	// LostVersions lists the versions of set the store cannot read, with
	// the commits each one damages.
	LostVersions(ctx context.Context, set string) ([]LostVersion, error)
}

type LostVersion struct {
	Path    string
	Ref     *proto.Ref
	Commits []*proto.Ref
}

type OrphanCommit struct {
	Ref *proto.Ref
	// Copies is how many committed archives hold the commit, and Bytes
	// what those copies take up.
	Copies int
	Bytes  int64
}

type OrphanFinder interface {
	OrphanCommits(ctx context.Context) ([]OrphanCommit, error)
}

type RebuiltIndex struct {
	Name          string
	Before, After int64
}

type Reindexed struct {
	Table string
	// Churn is the rows inserted, updated and deleted since the table's
	// last reindex, and Live the rows it holds.
	Churn, Live int64
	Indexes     []RebuiltIndex
	Took        time.Duration
}

type Retired struct {
	Ref *proto.Ref
	// SetID and Set name the commit's set; a set's name is unique only
	// among the sets a caller sees.
	SetID int64
	Set   string
	// Timestamp is when the commit was taken and ReceivedAt when the store
	// received it.
	Timestamp, ReceivedAt time.Time
	// RetiredAt is when the policy retired the commit, zero for one deleted
	// by hand, and TombstonedAt when its tombstone became durable, zero
	// while none has.
	RetiredAt, TombstonedAt time.Time
	// Policy is the set's policy that retired the commit; nil when the
	// retirement predates its recording.
	Policy *retention.Policy
	// Deleted marks a commit deleted by hand, whose trash window let it go
	// unless retention did first.
	Deleted bool
	// Partial marks a checkpoint along the way of a backup.
	Partial bool
	// State is where the commit stands now.
	State RetiredState
}

type RetiredState int

type SetInfo struct {
	ID               int64
	Name             string
	State            string
	LogicalSize      int64
	KeptLogicalSize  int64
	PhysicalSize     int64
	DeduplicatedSize int64
	// UniqueSize is the size of every distinct file version a live commit
	// of the set holds, each counted once: what storing each version of
	// each file once would take.
	UniqueSize int64
	// AloneSize is what the set would take up were it the only set, and
	// ExclusiveSize what of that no other set holds, as of the last
	// garbage collection.
	AloneSize, ExclusiveSize int64
	// DeduplicatedAloneSize is DeduplicatedSize were the set the only set.
	DeduplicatedAloneSize int64
}

type SetQuery struct {
	// States keeps the sets in one of these states; none keeps all.
	States []string
	// Match keeps the sets whose name holds it, ignoring case, and those
	// Named lists; an empty Match keeps every set.
	Match string
	Named []string
	// BySize lists only the sets a garbage collection measured, largest
	// PhysicalSize first and by name within a size, instead of by name.
	BySize bool
	// After and AfterSize are the Name and PhysicalSize of the last set of
	// the previous page; AfterSize counts only with BySize. An empty After
	// starts at the first set.
	After     string
	AfterSize int64
	// Limit is the most sets a page holds; zero holds every one.
	Limit int
}

type SetRetention struct {
	Policy    *retention.Policy
	Effective retention.Policy
	Paused    bool
}

type SizeFiller interface {
	FillMissingSizes(ctx context.Context) (int, error)
}

type StorePolicy struct {
	Policy            storekey.Policy
	KeyAcknowledgedAt *time.Time
}

type Unretired struct {
	backup.Revival
	// Set names the commit's set.
	Set string
	// RetainedBy is why the set's policy keeps the commit once it is back,
	// as CommitDetail names it; empty when the policy retires it again or
	// the commit stays tombstoned.
	RetainedBy string
}

type Unretirer interface {
	TombstonedCommits(ctx context.Context, set string, since time.Time) ([]*proto.Ref, error)
	UnretireCommits(ctx context.Context, refs []*proto.Ref, dryRun bool) ([]Unretired, error)
}

type Version struct {
	Node *proto.TreeNode
	From time.Time
}

type Windows struct {
	TrashDays int
}