kv

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

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

type Iterator interface {
	// Next advances the iterator to the next key
	// A fresh iterator must call Next once to
	// advance to the first key. Next returns false
	// if there is no next key or if it encounters an
	// error.
	Next() bool
	// Key returns the current key
	Key() []byte
	// Value returns the current value
	Value() []byte
	// Error returns the error, if any.
	Error() error
}

type KV [2][]byte

type Map interface {
	MapUpdater
	MapReader
}

type MapReader interface {
	// Get gets a key. It must observe updates to that key made
	// previously by this transation. Get must return an error
	// if the key is nil or empty. It must return nil if the
	// requested key does not exist.
	Get(key []byte) ([]byte, error)
	// Keys creates an iterator that iterates over the range
	// of keys
	Keys(keys keys.Range, order SortOrder) (Iterator, error)
}

type MapUpdater interface {
	// Put puts a key. Put must return an error
	// if either key is or empty or nil or if value is nil.
	Put(key, value []byte) error
	// Delete deletes a key. It must return an error if the key
	// is nil or empty. If the key doesn't exist it has no effect
	// and returns nil.
	Delete(key []byte) error
}

type Partition interface {
	// Name returns the name of this partition
	Name() []byte
	// Create creates this partition if it does not exist. It has no
	// effect if the partition already exists. It must return ErrClosed
	// if its invocation starts after Close() on the root store returns.
	// Otherwise it must return ErrNoSuchStore if the parent store does not exist.
	// metadata is set only if this call actually creates the partition.
	Create(metadata []byte) error
	// Delete deletes this partition if it exists. It has no effect if
	// the partition does not exist. It must return ErrClosed if its
	// invocation starts after Close() on the root store returns. Otherwise it
	// must return ErrNoSuchStore if the parent store does not exist.
	Delete() error
	// Begin starts a transaction for this partition. writable should be
	// true for read-write transactions and false for read-only transactions.
	// If Begin() is called after Close() on the root store returns it must
	// return ErrClosed. Otherwise if the parent store does not exist it must
	// return ErrNoSuchStore. Otherwise if this partition does not exist it must
	// return ErrNoSuchPartition.
	Begin(writable bool) (Transaction, error)
	// Snapshot takes a consistent snapshot of this partition. If Snapshot() is called
	// after Close() on the root store returns it must return ErrClosed. Otherwise if
	// the parent store does not exist it must return ErrNoSuchStore. Otherwise if this
	// partition does not exist it must return ErrNoSuchPartition. Snapshot is like a
	// self-contained read-only transaction. Until all calls to Snapshot() return
	// Close() on the root store must not return and must wait for all snapshots
	// to finish being read or closed. Calls to Snapshot() started after Close() is called
	// may return ErrClosed right away. Likewise, the snapshot should be consistent:
	// serializability must be maintained and its view must be consistent with the
	// most recently commited read-write transaction. Strict-serializability must
	// be enforced.
	snapshot.Source
	// ApplySnapshot applies a snapshot to this partition. If ApplySnapshot() is called
	// after Close() on the root store returns it must return ErrClosed. Otherwise if
	// the parent store does not exist it must return ErrNoSuchStore. If this partition
	// doesn't exist ApplySnapshot will create it. If the partition does exist ApplySnapshot
	// overwrites the state currently stored in the partition. ApplySnapshot
	// is like a self-contained read-write transaction. Until all calls to ApplySnapshot()
	// return Close() on the root store must not return. Calls to ApplySnapshot() started
	// after Close() is called may return ErrClosed right away. Strict-serializability must
	// be enforced.
	snapshot.Acceptor
}

type Plugin interface {
	// Name returns the name of the storage plugin
	Name() string
	// NewStore returns an instance of the plugin store
	NewRootStore(options PluginOptions) (RootStore, error)
	// NewTempStore returns an instance of the plugin store
	// initialized with some sane defaults. It is meant for
	// tests that need an initialized instance of the plugin's
	// store without knowing how to initialize it
	NewTempRootStore() (RootStore, error)
}

type PluginOptions map[string]interface{}

type RootStore interface {
	// Delete closes then deletes this store and all its contents.
	// If the root store doesn't exist it should return nil and have
	// no effect.
	Delete() error
	// Close closes the store. Function calls to any I/O objects
	// descended from this store occurring after Close returns
	// must have no effect and return ErrClosed. Close must not
	// return until all concurrent I/O operations have concluded
	// and all transactions have either rolled back or committed.
	// Operations started after the call to Close is started but
	// before it returns may proceed normally or may return ErrClosed.
	// If they return ErrClosed they must have no effect. Close may
	// return an error to indicate any problems that occurred during
	// shutdown. Simply put, when close returns it should ensure the caller
	// that the state of all the stores is fixed and will not change unless
	// this root store is reopened
	Close() error
	// Stores lists all the stores inside this root store by name. Results must
	// be in ascending lexicographical order. It must return
	// ErrClosed if its invocation starts after Close() returns.
	Stores() ([][]byte, error)
	// Store returns a handle for the store with this name. It does not
	// guarantee that this store exists yet and should not create the
	// store. It must not return nil.
	Store(name []byte) Store
}

type Snapshotter struct {
	// Partition should be the partition that is
	// to be snapshotted or to which a snapshot is
	// to be applied
	Begin func(writable bool, ensurePartitionExists bool) (Transaction, error)
	// Purge must be configured to a function which
	// completely erases all data in this partition using
	// the given transaction. Purge is used in the first
	// phase in applying a snapshot where the partition
	// is reverted to a blank slate on top of which the
	// snapshot is written.
	Purge func(transaction Transaction) error
}

type SortOrder int

type Store interface {
	// Name returns the name of this store.
	Name() []byte
	// Create creates this store if it does not exist. It has no
	// effect if the store already exists. It must return ErrClosed
	// if its invocation starts after Close() on the root store returns
	Create() error
	// Delete deletes this store if it exists. It has no effect
	// if the store does not exist. It must return ErrClosed if
	// its invocation starts after Close() on the root store returns.
	// Delete must not return until all concurrent I/O operations have
	// concluded and all transactions have either rolled back or committed.
	Delete() error
	// Partitions lists up to limit partitions in this store whose name
	// is in the range. List results must be in ascending lexocographical
	// order and contiguous. In other words, if partitions A, B, and C
	// exist and a consumer calls Partitions([]byte("A"), []byte("C"), 2)
	// the return value must be [][]byte{[]byte("A"), []byte("B")} rather
	// than [][]byte{[]byte("A"), []byte("C")}. There must be no gaps. A
	// caller making subsequent calls to Partitions() may observe inconsistencies
	// if Partitions() are created and deleted between calls to Partitions(). It
	// is up to the caller to control the ordering between creation, deletion,
	// and listing of partitions if their use case demands it. Partitions must
	// return ErrClosed if its invocation starts after Close() on the root store
	// returns. Otherwise it must return ErrNoSuchStore if this store does not exist.
	// min = nil indicates the lexocographically lowest partition name.
	// max = nil indicates the lexocographically highest partition name. limit < 0
	// indicates no limit.
	Partitions(names keys.Range, limit int) ([][]byte, error)
	// Partition returns a handle for the partition with this name inside this store.
	// It does not guarantee that this partition exists yet and should not create the partition.
	// It must not return nil.
	Partition(name []byte) Partition
}

type Transaction interface {
	Map
	// Metadata returns the metadata for this partition
	Metadata() ([]byte, error)
	// SetMetadata sets the metadata for this partition
	SetMetadata(metadata []byte) error
	// Commit commits the transaction
	Commit() error
	// Rollback rolls back the transaction
	Rollback() error
}