backend

type ApplyEnvironmenter interface {
	ApplyEnvironment(prefix string)
}

type Backend interface {
	// Properties returns information about the backend
	Properties() Properties

	// Hasher may return a hash function for calculating a content hash for the backend
	Hasher() hash.Hash

	// Remove removes a File described by h.
	Remove(ctx context.Context, h Handle) error

	// Close the backend
	Close() error

	// Save stores the data from rd under the given handle.
	Save(ctx context.Context, h Handle, rd RewindReader) error

	// Load runs fn with a reader that yields the contents of the file at h at the
	// given offset. If length is larger than zero, only a portion of the file
	// is read. If the length is larger than zero and the file is too short to return
	// the requested length bytes, then an error MUST be returned that is recognized
	// by IsPermanentError().
	//
	// The function fn may be called multiple times during the same Load invocation
	// and therefore must be idempotent.
	//
	// Implementations are encouraged to use util.DefaultLoad
	Load(ctx context.Context, h Handle, length int, offset int64, fn func(rd io.Reader) error) error

	// Stat returns information about the File identified by h.
	Stat(ctx context.Context, h Handle) (FileInfo, error)

	// List runs fn for each file in the backend which has the type t. When an
	// error occurs (or fn returns an error), List stops and returns it.
	//
	// The function fn is called exactly once for each file during successful
	// execution and at most once in case of an error.
	//
	// The function fn is called in the same Goroutine that List() is called
	// from.
	List(ctx context.Context, t FileType, fn func(FileInfo) error) error

	// IsNotExist returns true if the error was caused by a non-existing file
	// in the backend.
	//
	// The argument may be a wrapped error. The implementation is responsible
	// for unwrapping it.
	IsNotExist(err error) bool

	// IsPermanentError returns true if the error can very likely not be resolved
	// by retrying the operation. Backends should return true if the file is missing,
	// the requested range does not (completely) exist in the file or the user is
	// not authorized to perform the requested operation.
	IsPermanentError(err error) bool

	// Delete removes all data in the backend.
	Delete(ctx context.Context) error

	// Warmup ensures that the specified handles are ready for upcoming reads.
	// This is particularly useful for transitioning files from cold to hot
	// storage.
	//
	// The method is non-blocking. WarmupWait can be used to wait for
	// completion.
	//
	// Returns:
	// - Handles currently warming up.
	// - An error if warmup fails.
	Warmup(ctx context.Context, h []Handle) ([]Handle, error)

	// WarmupWait waits until all given handles are warm.
	WarmupWait(ctx context.Context, h []Handle) error
}

type ByteReader struct {
	*bytes.Reader
	Len int64
	// contains filtered or unexported fields
}

type FileInfo struct {
	Size int64
	Name string
}

type FileReader struct {
	io.ReadSeeker
	Len int64
	// contains filtered or unexported fields
}

type FileType uint8

type FreezeBackend interface {
	Backend
	// Freeze blocks all backend operations except those on lock files
	Freeze()
	// Unfreeze allows all backend operations to continue
	Unfreeze()
}

type Handle struct {
	Type       FileType
	IsMetadata bool
	Name       string
}

type Properties struct {
	// Connections states the maximum number of concurrent backend operations.
	Connections uint

	// HasAtomicReplace states whether Save() can atomically replace files
	HasAtomicReplace bool

	// HasFlakyErrors states whether the backend may temporarily return errors
	// that are considered as permanent for existing files.
	HasFlakyErrors bool
}

type RewindReader interface {
	io.Reader

	// Rewind rewinds the reader so the same data can be read again from the
	// start.
	Rewind() error

	// Length returns the number of bytes that can be read from the Reader
	// after calling Rewind.
	Length() int64

	// Hash return a hash of the data if requested by the backed.
	Hash() []byte
}

type TransportOptions struct {
	// contains filenames of PEM encoded root certificates to trust
	RootCertFilenames []string

	// contains the name of a file containing the TLS client certificate and private key in PEM format
	TLSClientCertKeyFilename string

	// Skip TLS certificate verification
	InsecureTLS bool

	// Specify Custom User-Agent for the http Client
	HTTPUserAgent string

	// Timeout after which to retry stuck requests
	StuckRequestTimeout time.Duration
}

type Unwrapper interface {
	// Unwrap returns the underlying backend or nil if there is none.
	Unwrap() Backend
}