storage

type APIServer struct {
	Registrar StoreActionerRegistrar
	DB        *bolt.DB

	HTTPDService interface {
		AddRoutes([]httpd.Route) error
		DelRoutes([]httpd.Route)
	}
	// contains filtered or unexported fields
}

type BinaryObject interface {
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
	ObjectID() string
}

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

type Config struct {
	// Path to a boltdb database file.
	BoltDBPath string `toml:"boltdb"`
}

type Diagnostic interface {
	Error(msg string, err error)
}

type Index struct {
	Name      string
	ValueFunc ValueFunc
	Unique    bool
}

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

type IndexedStoreConfig struct {
	Prefix        string
	DataPrefix    string
	IndexesPrefix string
	NewObject     NewObjectF
	Indexes       []Index
}

type Interface interface {

	// View creates a new read only transaction and always rolls it back.
	View(func(ReadOnlyTx) error) error

	// Update creates a new read-write transaction and always rolls it back.
	// If the function returns a nil error the transaction is committed, otherwise the error is returned.
	Update(func(Tx) error) error
}

type KeyValue struct {
	Key   string
	Value []byte
}

type MemStore struct {
	Name string
	// contains filtered or unexported fields
}

type NewObjectF func() BinaryObject

type ReadOnlyTx interface {
	ReadOperator

	// Rollback signals that the transaction is complete.
	// If the transaction was not committed, then all changes are reverted.
	// Rollback must always be called for every transaction.
	Rollback() error
}

type ReadOperator interface {
	// Retrieve a value.
	Get(key string) (*KeyValue, error)
	// Check if a key exists>
	Exists(key string) (bool, error)
	// List all values with given prefix.
	List(prefix string) ([]*KeyValue, error)
}

type Service struct {
	HTTPDService interface {
		AddRoutes([]httpd.Route) error
		DelRoutes([]httpd.Route)
	}
	// contains filtered or unexported fields
}

type StoreActioner interface {
	// Rebuild the entire store, this should be considered to be an expensive action.
	Rebuild() error
}

type StoreActionerRegistrar interface {
	List() []string
	Register(name string, store StoreActioner)
	Get(name string) (StoreActioner, bool)
}

type Tx interface {
	ReadOnlyTx
	WriteOperator

	// Commit finalizes the transaction.
	// Once a transaction is committed, rolling back the transaction has no effect.
	Commit() error
}

type TxOperator interface {
	// BeginReadOnlyTx starts a new read only transaction. The transaction must be rolledback.
	// Leaving a transaction open can block other operations and otherwise
	// significantly degrade the performance of the storage backend.
	// A single go routine should only have one transaction open at a time.
	BeginReadOnlyTx() (ReadOnlyTx, error)
	// BeginTx starts a new transaction for reads and writes. The transaction must be committed or rolledback.
	// Leaving a transaction open can block other operations and otherwise
	// significantly degrade the performance of the storage backend.
	// A single go routine should only have one transaction open at a time.
	BeginTx() (Tx, error)
}

type ValueFunc func(BinaryObject) (string, error)

type VersionWrapper struct {
	Version int              `json:"version"`
	Value   *json.RawMessage `json:"value"`
}

type Versions interface {
	Get(id string) (string, error)
	Set(id, version string) error
}

type WriteOperator interface {
	// Store a value.
	Put(key string, value []byte) error
	// Delete a key.
	// Deleting a non-existent key is not an error.
	Delete(key string) error
}