volume

type FileStat struct {
	Size     int64
	ETag     string
	ModTime  time.Time
	VolumeID string
}

type Local interface {
	Volume

	// Close will try to make a clean shutdown
	io.Closer

	// ID returns the ID of the Volume
	ID() string

	// NextReplica returns the next replica
	// inline. A "not found" error means
	// no replica is needed
	NextReplica(ctx context.Context) (*replica.Replica, error)

	// UpdateReplica updates the rp of the index and the File to include
	// the vID as a volume with the Replica
	UpdateReplica(ctx context.Context, rp *replica.Replica, vID string) error

	// DeleteReplica removes a pending replication job from the queue.
	// Used to clean up stale jobs when the source file no longer exists.
	DeleteReplica(ctx context.Context, rp *replica.Replica) error

	// NextDeletion returns the next pending remote-deletion job.
	// A "not found" error means the queue is empty.
	NextDeletion(ctx context.Context) (*deletion.Deletion, error)

	// DeleteDeletion removes a processed deletion job from the queue.
	DeleteDeletion(ctx context.Context, d *deletion.Deletion) error

	// NextScrub returns the next pending scrub-repair job.
	// A "not found" error means the queue is empty.
	NextScrub(ctx context.Context) (*scrub.Scrub, error)

	// DeleteScrub removes a processed scrub-repair job from the queue.
	DeleteScrub(ctx context.Context, s *scrub.Scrub) error

	// OverwriteFileContent replaces the on-disk content for sig by streaming
	// from r, verifying the SHA1 matches sig after writing.
	OverwriteFileContent(ctx context.Context, sig string, r io.Reader) error

	// SynchronizeReplicas checks the replicas related with vID and
	// if this volume is the responsible (next after the removed ID on the files)
	// will start replication of those files which have to
	SynchronizeReplicas(ctx context.Context, vID string) error

	// GetState returns the current State of the volume
	GetState(ctx context.Context) (*state.State, error)

	// Reset will clean all the data of the volume and even change the ID
	Reset(ctx context.Context) error

	// PrepareForDrain creates Replica jobs for all local files that don't have
	// enough external replicas to cover the configured replica count.
	PrepareForDrain(ctx context.Context) error

	// HasPendingReplicas reports whether there are any pending replica jobs queued.
	HasPendingReplicas(ctx context.Context) (bool, error)

	// PurgeAllFiles removes all local files and their keys from this volume
	// without creating deletion jobs for remote nodes (remote copies are preserved).
	PurgeAllFiles(ctx context.Context) error

	// ReconcileReplicas clears the stale replica queue and rebuilds it from
	// the current file state. It enqueues a replica job for every locally-owned
	// file (VolumeIDs[0] == l.ID()) that has fewer copies than required.
	// Call this once at startup after a crash (non-reset path).
	ReconcileReplicas(ctx context.Context) error

	// AllFiles returns all file records stored on this volume.
	AllFiles(ctx context.Context) ([]*file.File, error)

	// FileVolumeIDs returns the VolumeIDs and replica count for the file with the given key.
	FileVolumeIDs(ctx context.Context, key string) ([]string, int, error)

	// PurgeFile removes the local file and index entries for key without
	// creating deletion jobs for remote nodes (unlike DeleteFile).
	PurgeFile(ctx context.Context, key string) error
}

type Volume interface {
	// CreateFile creates a new file from the reader with the key, ttl and time of creation (if empty will be set to now)
	// There are 4 different use cases to consider:
	// * New key and reader
	// * New key with already known reader
	// * Already known key with new reader
	// * Already known key and reader
	CreateFile(ctx context.Context, key string, reader io.ReadCloser, replica int, ttl time.Duration, ca time.Time) error

	// GetFile search for the file with the key
	GetFile(ctx context.Context, key string) (io.ReadCloser, int64, error)

	// StatFile returns metadata about the file without reading its content.
	StatFile(ctx context.Context, key string) (*FileStat, error)

	// HasFile checks if a file with the key exists and returns the volumeID
	// of where is it.
	// It's possible to return a vid but false that means we know which volume
	// has it but it's not this one
	HasFile(ctx context.Context, key string) (string, bool, error)

	// DeleteFile deletes the key, if the key points to a
	// file with 2 keys, then just the key will be deleted
	// and not the content
	DeleteFile(ctx context.Context, key string) error

	// UpdateFileReplica updates the Replica information of the file
	// with the given one basically replacing it
	UpdateFileReplica(ctx context.Context, key string, volumeIDs []string, replica int) error
}