pack

type ArchiveBatchObserver interface {
	ArchiveObserver
	// ArchivesDeleted is told the archives' files are gone from the storage.
	ArchivesDeleted(names []string)
}

type ArchiveIndex interface {
	SessionIndex

	LocateObject(ref *proto.Ref, scope Scope, exclude ...string) (IndexLocation, error)
	// LocateCopies returns every copy the archives visible to scope hold
	// of each ref, keyed by its hash; a ref none holds is absent.
	LocateCopies(refs []*proto.Ref, scope Scope) (map[string][]IndexLocation, error)
	// LocateTombstones is LocateCopies for refs of tombstones and
	// un-tombstones: it finds tombstone records only.
	LocateTombstones(refs []*proto.Ref, scope Scope) (map[string][]IndexLocation, error)
	LookupArchive(archive string) (ArchiveInfo, bool, error)
	// IndexArchive registers an archive; a pending one needs a live session.
	// Of an archive it already knows, it only records a creation time the
	// index lacks.
	IndexArchive(archive ArchiveInfo, index IndexFile) error
	// DeleteArchives forgets the archives and their objects, all or none.
	DeleteArchives(names []string) error
	Close() error
	CountObjects() (uint64, uint64, error)
}

type ArchiveInfo struct {
	Name    string
	Session string
	State   ArchiveState
	// Created is when the bucket created the archive's index file, which
	// versions every record the archive holds; zero while it has none.
	Created time.Time
}

type ArchiveObserver interface {
	// ArchiveStored is told an archive and its index are in the storage,
	// the bytes both take up and the session that wrote them; the session
	// is empty for an archive the store rewrote itself.
	ArchiveStored(name string, bytes int64, session string)
	// ArchiveDeleted is told an archive's files are gone from the storage.
	ArchiveDeleted(name string)
}

type ArchiveState uint8

type ArchiveStorage interface {
	Create(name string) (File, error)
	// CreateNew stores data under name unless a file has it already, which
	// it answers with ErrFileExists; of several callers racing for a name,
	// exactly one succeeds.
	CreateNew(name string, data []byte) error
	Open(name string) (File, error)
	List(extension string) ([]string, error)
	Delete(name string) error
	DeleteAll() error
}

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

type Attribution struct {
	Group int64
	Set   int64
}

type Checksummer interface {
	Checksum(name string) ([]byte, error)
}

type Claim struct {
	Archive string
	Age     time.Duration
}

type ClaimIndex interface {
	// OpenArchive claims a new archive for a live session.
	OpenArchive(name, session string) error
	// AddObjects indexes objects written to an open archive, or answers
	// ErrClaimLapsed when the archive is no longer open.
	AddObjects(archive string, records []IndexRecord) error
	// FinalizeArchive turns an open archive pending, created at created,
	// when it was claimed less than within ago, and answers ErrClaimLapsed
	// otherwise.
	FinalizeArchive(name string, within time.Duration, created time.Time) error
	// Holds reports whether a pending or open archive of the session holds
	// the object.
	Holds(ref *proto.Ref, session string) (bool, error)
	// Claims lists the open archives of the session.
	Claims(session string) ([]Claim, error)
	// Abandon turns an open archive lost when it was claimed at least
	// within ago, and reports whether it did.
	Abandon(name string, within time.Duration) (bool, error)
	// Lost lists the objects the session's lost archives held that none of
	// its pending archives and no committed archive holds, leaving out
	// commits and the un-tombstones of the commits its lost and pending
	// archives hold, which belong to the commit that was refused.
	Lost(session string) ([]*proto.Ref, error)
}

type CollectOptions struct {
	// Readers is the number of parallel object reads during the mark (32).
	Readers int
	// DeadRatio selects an archive for sweeping once this share of its bytes
	// is dead (0.3).
	DeadRatio float64
	// ErasureBound selects an archive that has held dead objects this long
	// regardless of ratio (14 days).
	ErasureBound time.Duration
	// MinAge keeps every object younger than this, whatever the mark says (24h).
	MinAge time.Duration
	// NoSweep stops after the mark.
	NoSweep bool
	// Handoff publishes the sweep as a plan for RewritePlan instead of
	// running it.
	Handoff bool
	// Quarantine is how long the files of an archive a rewrite retired
	// are kept before a collection deletes them (DefaultQuarantine).
	Quarantine time.Duration
	// TempDir holds the live-set runs and the checkpoints a crashed run
	// resumes from (os.TempDir()).
	TempDir string
	// Now is the snapshot time (time.Now()).
	Now time.Time
	// Owner names what a root belongs to, so the mark can attribute the
	// objects it reaches; nil, or a zero Attribution, attributes nothing.
	Owner func(root []byte) Attribution
}

type CollectReport struct {
	Generation  uint64
	Archives    int
	Objects     uint64
	Roots       int
	Marked      uint64
	DeadObjects uint64
	DeadBytes   uint64
	// Resumed counts the root batches taken from a previous, interrupted run.
	Resumed int
	// ErasedArchives counts the archives flagged for holding the objects of
	// an erased commit.
	ErasedArchives int
	// SetBytes is what each set's live objects take up in the archives,
	// keyed by the set ids Owner returned. Within a group an object counts
	// once, for the first set the mark reached it from; across groups it
	// counts in each.
	SetBytes map[int64]uint64
	// SetDeduplicated is the uncompressed size of the distinct file content
	// each set's live objects carry, attributed as SetBytes is.
	SetDeduplicated map[int64]uint64
	// SetAlone is what each set's live objects would take up were it the
	// only set of its group, and SetExclusive what of that no other set of
	// the group reaches: what deleting the set would free.
	SetAlone, SetExclusive map[int64]uint64
	// SetDeduplicatedAlone is the uncompressed size of the distinct file
	// content each set's live objects carry were it the only set of its group.
	SetDeduplicatedAlone map[int64]uint64
	// Unattributed is what the live objects no set reaches take up, such
	// as those only a commit without an owner reaches; zero without Owner.
	Unattributed uint64
	// Condemned counts the unreachable objects the run stored tombstones for.
	Condemned int
	// Waiting is the generation whose published plan has not been
	// rewritten yet; a run that waits does nothing else.
	Waiting uint64
	// SweepSkipped names the reason when the run marked but did not sweep.
	SweepSkipped string
	// Published counts the archives of the plan the run published.
	Published        int
	Swept            int
	ReclaimedObjects uint64
	ReclaimedBytes   uint64
	// CopiedBytes is what the sweep wrote again to reclaim that.
	CopiedBytes uint64
	// Purged counts the quarantined files the run deleted.
	Purged int
	// ArchiveBytes is what the archives the run marked take up in storage,
	// dead objects included, and RetiredBytes what the archives rewrites
	// retired still take up until they are purged.
	ArchiveBytes, RetiredBytes uint64
	// OldestDead is when the archive that has held dead objects longest
	// without being rewritten first held them; zero when none holds any.
	OldestDead time.Time
	Duration   time.Duration
}

type Collector interface {
	Collect(ctx context.Context, opts CollectOptions) (*CollectReport, error)
}

type CompactReport struct {
	// Candidates counts the small committed archives Compact found, and
	// CandidateBytes what they take up; it merges them only once they add
	// up to a batch or are more than MinimumCandidates.
	Candidates     int
	CandidateBytes uint64
	// Rewritten counts the candidates rewritten and retired, and ReadBytes
	// what they took up.
	Rewritten int
	ReadBytes uint64
	// Written counts the archives written, and WrittenBytes what they take
	// up.
	Written      int
	WrittenBytes uint64
	// Moved counts the objects copied into the written archives, and
	// CopiedBytes their bytes.
	Moved       uint64
	CopiedBytes uint64
	// Superseded counts the objects not copied because another copy,
	// outside the candidates or written by the same run, stands in for them.
	Superseded uint64
	// ReclaimedBytes is ReadBytes less WrittenBytes, or zero.
	ReclaimedBytes uint64
	Duration       time.Duration
}

type CompactionConfig struct {
	// Small is the size under which a committed archive is merged; zero
	// means 16 MiB.
	Small uint64
	// Batch is how much the small archives must add up to before Compact
	// merges them; zero means 256 MiB.
	Batch uint64
	// MinimumCandidates is how many small archives make Compact merge them
	// whatever they add up to.
	MinimumCandidates int
	// Workers is how many archives a rewrite, by Compact or Collect, reads
	// at once; zero means four per GOMAXPROCS, at most 16. Compact gives
	// each its own output, Collect each set and age of what survives.
	Workers int
	// Chunk is how many archives a rewrite takes at a time, retiring each
	// chunk as it finishes; zero means 1000.
	Chunk int
}

type File interface {
	io.Reader
	io.Writer
	io.Seeker
	io.Closer

	Stat() (fs.FileInfo, error)
}

type Head struct {
	SetID        uint64 `json:"setId"`
	Set          string `json:"set"`
	Commit       []byte `json:"commit"`
	ReceivedAtNs int64  `json:"receivedAtNs"`
}

type InMemoryIndex struct {

	// Now is the clock claims are aged by; nil means time.Now.
	Now func() time.Time
	// contains filtered or unexported fields
}

type IndexFile []IndexRecord

type IndexLocation struct {
	Archive string
	Record  IndexRecord
}

type IndexRecord struct {
	Sum    [proto.HashSize]byte
	Offset uint32
	Length uint32
	Type   uint32
	// CarriedTime and CarriedOffset are the version a rewrite carried the
	// record over with; a zero CarriedTime means the record has its
	// archive's version.
	CarriedTime   int64
	CarriedOffset uint32
}

type InfoLister interface {
	ListInfo(extension string) ([]ListedFile, error)
}

type ListedFile struct {
	Name     string
	Size     int64
	Modified time.Time
}

type ListedOpener interface {
	OpenListed(file ListedFile) (File, error)
}

type PackOption func(p *packOptions)

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

type Placement struct {
	Session string
}

type RangeSigner interface {
	// SignRange returns a GET whose body is bytes [offset, offset+length)
	// of name, good for ttl, carrying whatever headers the request must
	// repeat. It returns ErrNoSignedURL when it cannot sign.
	SignRange(ctx context.Context, name string, offset, length int64, ttl time.Duration) (*proto.Location, error)
}

type RepairReport struct {
	// Scrub is the pass that found the damage.
	Scrub *ScrubReport
	// Archives is how many archives were rewritten.
	Archives uint64
	// Recovered names the objects the store still holds after the pass,
	// because another archive had an intact copy.
	Recovered []*proto.Ref
	// Lost names the objects no archive holds any more. A restore of one
	// leaves a hole until a backup of a source that still has it puts it
	// back.
	Lost []*proto.Ref
}

type RewriteReport struct {
	Plans            int
	Swept            int
	ReclaimedObjects uint64
	ReclaimedBytes   uint64
	CopiedBytes      uint64
}

type Scope struct {
	Session string
}

type ScrubFailure struct {
	Archive string
	Ref     *proto.Ref
	Err     error
}

type ScrubReport struct {
	Archives uint64
	Objects  uint64
	Bytes    uint64
	// Corrupt lists the objects whose stored bytes do not hash to their
	// header or whose header names the wrong predecessor.
	Corrupt []ScrubFailure
	// Sealed counts the objects per hex at-rest key id, the ones stored
	// in the clear under the empty string. A rotation is over once no
	// retired key id is left here.
	Sealed map[string]uint64
}

type SessionIndex interface {
	BeginSession(s *backup.Session) error
	TouchSession(id string, at time.Time) error
	GetSession(id string) (*backup.Session, error)
	ListSessions() ([]*backup.Session, error)
	// EndSession drops the session and its uncommitted archives, returning
	// the names of the archives dropped.
	EndSession(id string) ([]string, error)
	// PendingArchives names the session's archives that a commit would
	// make committed.
	PendingArchives(id string) ([]string, error)
	// CommitSession flips the session's pending archives to committed and
	// forgets its lost ones.
	CommitSession(id string) error
}

type SharedClock interface {
	SharedNow(ctx context.Context) (time.Time, error)
}

type Version struct {
	Time   time.Time
	Offset uint32
}