store

type Blob interface {
	bitset.Blob
}

type Database interface {
	MetaStore
	//GetState checks if we have a file or not, or in progress
	GetState(key HLKey) FileState
	//GetAt reads len(b) bytes of file key from offset off.
	//returns error if b can't be read completely
	GetAt(key HLKey, b []byte, off int64) error
	//PutAt writes b to file from offset off.
	//
	//has returns the number of leaf nodes completed. This can report the progress.
	//Iff has is full, complete is true
	//
	//If hash checking fails, an err is reported. The server can us this information
	//to demote the source.
	PutAt(key HLKey, b []byte, off int64) (has ht.Nodes, complete bool, err error)

	//Import a file from reader
	ImportFromReader(r io.Reader) HLKey
}

type FileState int

type HLKey interface {
	//Hash returns the hash of refereced. Do not modify the returned contests
	GetHash() []byte
	//Length returns the length of refereced file in bytes
	GetLength() int64
	//FullBytes is used when a key need to include length, as an attacker might
	//claim the existence of a file of the same hash but different size.
	//Do not modify the returned contests
	FullBytes() []byte
}

type KV interface {
	//Get gets the value for the given key. It returns nil if KV does not contain the key.
	//
	//Warning: Get might not see what was Set or Deleted until after sync().
	//This is a temperary work around to easly warp some apis.
	Get(key []byte) []byte
	//Set sets the value for the given key. It overwrites any previous value for that key.
	//Do not set with len(v) == 0, use Delete instead.
	Set(key []byte, v []byte)
	//Delete deletes the value for the given key, it is a no-op if KV does not contain the key.
	Delete(key []byte)
	//Sync commits all the changes to stable storage. It blocks until done.
	Sync()
	//Close closes KV.
	Close() error
	GC(startAfterKey []byte, f func(key []byte, v []byte) (delete bool, stop bool))
}

type LV interface {
	//New creates a new block in LV, or nil if the key already exist.
	//size > 0
	New(key []byte, size int64) Blob
	//Get returns the Block referenced by key, or nil if key is not found.
	Get(key []byte, size int64) Blob
	//Move changes the key from from to to, and resizes to newSize.
	//If from does not exist, or to already exist, then an error is reported.
	//The Blob keyed by from should not be open.
	Move(oldKey []byte, oldSize int64, newKey []byte, newSize int64) error

	//Delete removes the Block repersented by key from LV.
	//Returns true if blob is not in LV after Delete.
	Delete(key []byte, size int64) (bool, error)

	Close() error
}

type MetaStore interface {
	//InnerHashMinLevel reports the amount of inner hash saved, everything at or
	//above the Level can be retrieved
	InnerHashMinLevel() ht.Level
	//GetInnerHashes reads inner hashes at level and offset, len(hs) should be a
	//multiple of hash length (32).
	//
	//An error is reported if parts of hs is unknown, parts known is still filled
	//with unknown parts as all zeros.
	//
	//If parts of hs are impossible by index range, it panics
	GetInnerHashes(key HLKey, hs []byte, level ht.Level, off ht.Nodes) error

	PutInnerHashes(key HLKey, hs []byte, level ht.Level, off ht.Nodes) (has ht.Nodes, complete bool, err error)

	//TTLGet gets the TTL of a file
	//TTLGet does not imply having a file. Only that the file is desired to be keeped.
	TTLGet(key HLKey) TTL

	//TTLSetAtleast updates the TTL to be at least coved to until, the total
	//increase is multiplied by key.Length() to return costs in storage time by
	//byteMonth.
	//Savings in deduplication can be reflected in byteMonth.
	//
	//The time increased form freeFrom is unaccounted, put in now to not charge before now.
	//byteMonth = 0 if freeFrom >= until
	TTLSetAtleast(key HLKey, freeFrom, until TTL) (byteMonth int64)

	//Close closes MetaStore
	Close() error
}

type TTL int16 //January, 2000 is 0.