storage

type Backend interface {
	// String returns the name of the Backend in the form of a string.
	String() string

	// LogStats reports any statistics that the Backend may have gathered
	// during the course of its operation.
	LogStats()

	// Fsck checks the consistency of the data in the Backend and reports
	// any problems found via the logger specified by SetLogger.
	Fsck()

	// Write saves the provided chunk of data to storage, returning a Hash
	// that uniquely identifies it. Any write errors are fatal and
	// terminate the program.
	Write(chunk []byte) Hash

	// SyncWrites ensures that all chunks of data provided to Write have
	// in fact reached permanent storage. Calls to Read may not find
	// data stored by Write if SyncWrites hasn't been called after the
	// call to Write.
	SyncWrites()

	// Read returns a io.ReadCloser that provides the chunk for the given
	// hash. If the given hash doesn't exist in the backend, an error is
	// returned.
	Read(hash Hash) (io.ReadCloser, error)

	// HashExists reports whether a blob of data with the given hash exists
	// in the storage backend.
	HashExists(hash Hash) bool

	// Hashes returns a map that has all of the hashes stored by the
	// storage backend.
	Hashes() map[Hash]struct{}

	// WriteMetadata saves the given data in the storage backend,
	// associating it with the given name. It's mostly used for storing
	// data that we don't want to run through the dedupe process and want
	// to be able to easily access directly by name.
	WriteMetadata(name string, data []byte)

	// ReadMetadata returns the metadata for a given name that was stored
	// with WriteMetadata.
	ReadMetadata(name string) []byte

	// MetadataExists indicates whether the given named metadata is
	// present in the storage backend.
	MetadataExists(name string) bool

	// ListMetadata returns a map from all of the existing metadata
	// to the time each one was created.
	ListMetadata() map[string]time.Time
}

type BlobLocation struct {
	PackName string
	Offset   int64
	Length   int64
}

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

type FileStorage interface {
	// CreateFile returns a RobustWriteCloser for a file with the given name;
	// a fatal error occurs if a file with that name already exists.
	CreateFile(name string) RobustWriteCloser

	// ReadFile returns the contents of the given file. If length is zero, the
	// whole file contents are returned; otherwise the segment starting at offset
	// with given length is returned.
	//
	// TODO: it might be more idiomatic to return e.g. an io.ReadCloser,
	// but between the GCS backend needing to be able to retry reads and
	// the fact that callers usually want a []byte in the end anyway, this
	// seems more straightforward overall.
	ReadFile(name string, offset int64, length int64) ([]byte, error)

	// ForFiles calls the given callback function for all files with the
	// given directory prefix, providing the file path and its creation
	// time.
	ForFiles(prefix string, f func(path string, created time.Time))

	String() string

	// Fsck checks the validity of the stored data.  The returned Boolean
	// value indicates whether or not the caller should continue and
	// perform its own checks on the contents of the data as well.
	Fsck() bool
}

type GCSOptions struct {
	BucketName string
	ProjectId  string
	// Optional. Will use "us-central1" if not specified.
	Location string

	// zero -> unlimited
	MaxUploadBytesPerSecond   int
	MaxDownloadBytesPerSecond int
}

type Hash [HashSize]byte

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

type MerkleHash struct {
	Hash  Hash
	Level uint8
}

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

type RobustWriteCloser interface {
	Write(b []byte)
	Close()
}