storage

type CheckStatus uint8

type ChunkConfig struct {
	Size    int64
	Objects []metatypes.Object
}

type ChunkStorage interface {
	// WriteChunk writes a data chunk as one or multiple objects to a storage,
	// returning the generated chunk's config used to store it.
	//
	// Remember to store the returned config,
	// as you'll need it in order to read the chunk back back.
	WriteChunk(data []byte) (*ChunkConfig, error)

	// ReadChunk reads the chunk's objects from a storage,
	// using the chunk config generated while writing the object, previously.
	ReadChunk(cfg ChunkConfig) ([]byte, error)

	// CheckChunk checks if a chunk is in a valid condition.
	//
	// The fast parameter can be given in case you want to do a fast check only,
	// which means it will return as soon as all the needed objects
	// are found to be in a valid condition,
	// ignoring the possibility that it could even be in excellent condition.
	//
	// An error can be returned in case the given chunk config
	// is not compatible with the used storage.
	// Meaning the chunk cannot be read, written or repaired.
	CheckChunk(cfg ChunkConfig, fast bool) (CheckStatus, error)

	// RepairChunk will try to repair a chunk, already stored within the Storage.
	// If the chunk could be repaired, the updated chunk config will be returned and
	// indicate the current objects are stored/used for this chunk.
	RepairChunk(cfg ChunkConfig) (*ChunkConfig, error)

	// DeleteChunk will delete a chunk, previously stored within the Storage.
	// If the chunk was written using a different type of ChunkStorage,
	// it might not be possible to delete that chunk.
	// When an error is returned it should be assumed the chunk wasn't deleted,
	// if no error is returned, however, it can be assumed that the chunk was deleted.
	DeleteChunk(cfg ChunkConfig) error

	// Close any open resources.
	Close() error
}

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

type DistributedEncoderDecoder interface {
	// Encode object data into multiple (distributed) parts,
	// such that those parts can be reconstructed when the data has to be read again.
	Encode(data []byte) (parts [][]byte, err error)
	// Decode the different parts back into the original data slice,
	// as it was given in the original Encode call.
	Decode(parts [][]byte, dataSize int64) (data []byte, err error)

	// MinimumValidShardCount returns the minimum valid shard count required,
	// in order to decode a distributed object.
	MinimumValidShardCount() int

	// RequiredShardCount returns the shard count which is expected.
	// Meaning that the parts given to the Decode method will have to be exactly the number
	// returned by ths method, or else that method will fail.
	RequiredShardCount() int
}

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

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

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