storage

Documentation

Index

• Variables
• func ReportEventReceived()
• type CancelFunc
• type ConsistentIndexGetter
• type ConsistentWatchableKV
  • func New(path string, ig ConsistentIndexGetter) ConsistentWatchableKV
• type KV
• type Snapshot
• type Watchable
• type WatchableKV
• type Watcher

Variables

var (
	ErrTxnIDMismatch = errors.New("storage: txn id mismatch")
	ErrCompacted     = errors.New("storage: required revision has been compacted")
	ErrFutureRev     = errors.New("storage: required revision is a future revision")
	ErrCanceled      = errors.New("storage: watcher is canceled")
)

var (
	ErrRevisionNotFound = errors.New("stroage: revision not found")
)

Functions

func ReportEventReceived

func ReportEventReceived()

ReportEventReceived reports that an event is received. This function should be called when the external systems received an event from storage.Watcher.

Types

type CancelFunc

type CancelFunc func()

CancelFunc tells an operation to abandon its work. A CancelFunc does not wait for the work to stop.

type ConsistentIndexGetter

type ConsistentIndexGetter interface {
	// ConsistentIndex returns the consistent index of current executing entry.
	ConsistentIndex() uint64
}

ConsistentIndexGetter is an interface that wraps the Get method. Consistent index is the offset of an entry in a consistent replicated log.

type ConsistentWatchableKV

type ConsistentWatchableKV interface {
	WatchableKV
}

ConsistentWatchableKV is a WatchableKV that understands the consistency algorithm and consistent index. If the consistent index of executing entry is not larger than the consistent index of ConsistentWatchableKV, all operations in this entry are skipped and return empty response.

func New

func New(path string, ig ConsistentIndexGetter) ConsistentWatchableKV

type KV

type KV interface {
	// Rev returns the current revision of the KV.
	Rev() int64

	// Range gets the keys in the range at rangeRev.
	// If rangeRev <=0, range gets the keys at currentRev.
	// If `end` is nil, the request returns the key.
	// If `end` is not nil, it gets the keys in range [key, range_end).
	// Limit limits the number of keys returned.
	// If the required rev is compacted, ErrCompacted will be returned.
	Range(key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, rev int64, err error)

	// Put puts the given key,value into the store.
	// A put also increases the rev of the store, and generates one event in the event history.
	Put(key, value []byte) (rev int64)

	// DeleteRange deletes the given range from the store.
	// A deleteRange increases the rev of the store if any key in the range exists.
	// The number of key deleted will be returned.
	// It also generates one event for each key delete in the event history.
	// if the `end` is nil, deleteRange deletes the key.
	// if the `end` is not nil, deleteRange deletes the keys in range [key, range_end).
	DeleteRange(key, end []byte) (n, rev int64)

	// TxnBegin begins a txn. Only Txn prefixed operation can be executed, others will be blocked
	// until txn ends. Only one on-going txn is allowed.
	// TxnBegin returns an int64 txn ID.
	// All txn prefixed operations with same txn ID will be done with the same rev.
	TxnBegin() int64
	// TxnEnd ends the on-going txn with txn ID. If the on-going txn ID is not matched, error is returned.
	TxnEnd(txnID int64) error
	TxnRange(txnID int64, key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, rev int64, err error)
	TxnPut(txnID int64, key, value []byte) (rev int64, err error)
	TxnDeleteRange(txnID int64, key, end []byte) (n, rev int64, err error)

	Compact(rev int64) error

	// Get the hash of KV state.
	// This method is designed for consistency checking purpose.
	Hash() (uint32, error)

	// Snapshot snapshots the full KV store.
	Snapshot() Snapshot

	// Commit commits txns into the underlying backend.
	Commit()

	Restore() error
	Close() error
}

type Snapshot

type Snapshot backend.Snapshot

type Watchable

type Watchable interface {
	// NewWatcher returns a Watcher that can be used to
	// watch events happened or happending on the KV.
	NewWatcher() Watcher
}

Watchable is the interface that wraps the NewWatcher function.

type WatchableKV

type WatchableKV interface {
	KV
	Watchable
}

WatchableKV is a KV that can be watched.

type Watcher

type Watcher interface {
	// Watch watches the events happening or happened on the given key
	// or key prefix from the given startRev.
	// The whole event history can be watched unless compacted.
	// If `prefix` is true, watch observes all events whose key prefix could be the given `key`.
	// If `startRev` <=0, watch observes events after currentRev.
	Watch(key []byte, prefix bool, startRev int64) CancelFunc

	// Chan returns a chan. All watched events will be sent to the returned chan.
	Chan() <-chan storagepb.Event

	// Close closes the WatchChan and release all related resources.
	Close()
}