strata

type BackupCommand struct {
	ReplicaID string `short:"r" long:"replica-id" description:"An arbitrary string representing this node in the metadata. Defaults to hostname."`
	// contains filtered or unexported fields
}

type ByTime []LazySnapshotMetadata

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

type DeleteCommand struct {
	ReplicaID string `short:"r" long:"replica-id" description:"An arbitrary string representing this node in the metadata" required:"true"`
	BackupID  string `short:"d" long:"delete-backup-id" description:"Optional. If set, delete this backup id." optional:"true" default:""`
	Age       string `` /* 182-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Driver struct {
	Manager *SnapshotManager
}

type DriverFactory interface {
	// GetOptions should return a pointer suitable for use as the first
	// argument of flags.NewParser()
	GetOptions() interface{}
	// Driver returns an initialized Driver
	Driver() (*Driver, error)
}

type ErrNoSnapshotMetadata string

type ErrNotFound string

type File struct {
	// The original name of the file
	Name     string `json:"name"`
	Size     int64  `json:"size"`
	Checksum string `json:"checksum"` // This is a partial checksum
}

type FileMetadata struct {
	CompleteChecksum []byte `json:"completechecksum"`
}

type GCCommand struct {
	ReplicaID string `short:"r" long:"replica-id" description:"An arbitrary string representing this node in the metadata" required:"true"`
	// contains filtered or unexported fields
}

type GCStats struct {
	// NumNeeded and NumGarbage include only DB files
	NumNeeded  int
	NumGarbage int
	// FM means "file metadata"
	NumFMNeeded     int
	NumFMGarbage    int
	NumStatsNeeded  int
	NumStatsGarbage int
	NumErrsDeleting int
	// Sizes exclude file metadata and stats files, since those do not include
	// their sizes in their names
	SizeNeeded            int64
	SizeGarbage           int64
	SizeGarbageNotDeleted int64
	Duration              time.Duration
}

type LazySnapshotMetadata struct {
	// The path of the persistent-storage file for the SnapshotMetadata
	// Snapshot ID and time should be embedded in path name
	MetadataPath string

	// Indicate that the SnapshotMetadata should be removed from persistent storage
	DeleteMark bool

	// Indicate that the SnapshotMetadata should be saved to persistent storage
	// Overridden by DeleteMark
	SaveMark bool
	// contains filtered or unexported fields
}

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

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

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

type ReaderFunc func() (io.ReadCloser, error)

type ReaderReaderAt interface {
	io.Reader
	io.ReaderAt
}

type Replica interface {
	// CreateSnapshot is called to trigger Snapshot creation on the target source
	CreateSnapshot(replicaID, snapshotID string) (*Snapshot, error)

	// DeleteSnapshot is used to clean up the snapshot files on the target host
	DeleteSnapshot(lz LazySnapshotMetadata) error

	// PrepareToRestoreSnapshot() is called by a SnapshotManager when the
	// SnapshotManager is about to restore a snapshot on the replica.
	// If targetPath is the empty string, then the database is restored to the directory in Snapshot s.
	// The first return value is the path/prefix on replica for SST files. For example, /data/mongodb/db.
	// Note that this is slightly different from MongoDB's --dbpath argument, which would be /data/mongodb.
	PrepareToRestoreSnapshot(replicaID, targetPath string, s *Snapshot) (dbpath string, err error)

	// PutReader lays down a file.
	PutReader(path string, reader io.Reader) error

	// PutSoftlink creates a softlink
	PutSoftlink(pointingTo, path string) error

	// Delete the contents stored at the specified string
	Delete(string) error

	// List returns up to |n| files that have path/prefix |prefix| on replica
	// This list does not include any directories
	List(prefix string, n int) ([]string, error)

	// Same returns true if the replica object at |path| has the same fingerprint as |file|.
	// This fingerprint might be a partial checksum. It should be computed quickly.
	Same(path string, file File) (bool, error)

	// GetSnapshot returns a Snapshot given the specified SnapshotMetadata
	GetSnapshot(s SnapshotMetadata) (*Snapshot, error)

	// MaxBackgroundCopies returns the maximum number of copies that CreateSnapshot
	// and RestoreSnapshot may perform in parallel
	MaxBackgroundCopies() int
}

type RestoreCommand struct {
	ReplicaID  string `short:"r" long:"replica-id" description:"An arbitrary string representing this node in the metadata" required:"true"`
	BackupID   string `short:"i" long:"backup-id" description:"The backup id to restore from" required:"true"`
	TargetPath string `short:"t" long:"target-path" description:"If not specified, restore to the path in snapshot metadata."`
	// contains filtered or unexported fields
}

type ShowBackupsCommand struct {
	ReplicaID string `short:"r" long:"replica-id" description:"The replica ID to show backups for" required:"true"`
	ShowSize  bool   `short:"s" long:"show-size" description:"Print backup size with backup ids"`
	// contains filtered or unexported fields
}

type ShowCommand struct{}

type ShowLastBackupTimeCommand struct {
	ReplicaID string `short:"r" long:"replica-id" description:"The replica ID to show backups for" required:"true"`
	// contains filtered or unexported fields
}

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

type Snapshot struct {
	Metadata *SnapshotMetadata
	// contains filtered or unexported fields
}

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

type SnapshotMetadata struct {
	Files []File `json:"files"`
	// ReplicaID should uniquely identify the replica in the environment
	// An example would be combination of replica set and hostname
	ReplicaID string `json:"source_id"`
	// ID should uniquely identify this snapshot within the context
	// of a ReplicaID. It can be as simple as an incrementing counter
	ID string `json:"id"`
	// Path is where the snapshot originated from on disk
	Path string    `json:"path"`
	Tags []string  `json:"tags"`
	Time time.Time `json:"time"`
}

type SnapshotStats struct {
	NumFiles             int           `json:"num_files"`
	NumIncrementalFiles  int           `json:"num_ifiles"`
	SizeFiles            int64         `json:"size_files"`
	SizeIncrementalFiles int64         `json:"size_ifiles"`
	Duration             time.Duration `json:"duration"`
}

type Storage interface {
	// Get returns a Reader at the specified string
	Get(string) (reader io.ReadCloser, err error)

	// Put stores the bytes at the specified location.
	// Implementations should see comments on PutReader.
	Put(path string, data []byte) error

	// PutReader stores the contents of Reader at the specified location
	// Put and PutReader should not leave any incomplete files in the event of
	// a failure, unless those files end in ".tmp". Garbage collection will
	// eventually remove .tmp files.
	// Suggestion: If the storage system does not support atomic Puts, consider
	// implementing Put and PutReader by first writing to a .tmp file, and then
	// atomically renaming the file to remove the .tmp suffix.
	PutReader(path string, reader io.Reader) error

	// Delete the contents stored at the specified string.
	// Should return nil if there is no object at the specified string.
	Delete(string) error

	// List up to n items satisfying the specified prefix
	List(prefix string, n int) ([]string, error)

	// Lock is optional. If implemented, provide exclusive access to the specified item
	// Lock is not currently used by SnapshotManager anyway
	Lock(string) error

	// Unlock
	Unlock(string) error
}