kv

Documentation

Overview

Package kv provides a key-value API to an underlying cockroach datastore. Cockroach itself provides a single, monolithic, sorted key value map, distributed over multiple nodes. Each node holds a set of key ranges. Package kv translates between the monolithic, logical map which Cockroach clients experience to the physically distributed key ranges which comprise the whole.

Package kv implements the logic necessary to locate appropriate nodes based on keys being read or written. In some cases, requests may span a range of keys, in which case multiple RPCs may be sent out.

Index

• Constants
• type DBServer
  • func NewDBServer(sender client.KVSender) *DBServer
  • func (s *DBServer) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type DistSender
  • func NewDistSender(gossip *gossip.Gossip) *DistSender
  • func (ds *DistSender) Close()
  • func (ds *DistSender) Send(call *client.Call)
• type LocalSender
  • func NewLocalSender() *LocalSender
  • func (ls *LocalSender) AddStore(s *storage.Store)
  • func (ls *LocalSender) Close()
  • func (ls *LocalSender) GetStore(storeID proto.StoreID) (*storage.Store, error)
  • func (ls *LocalSender) GetStoreCount() int
  • func (ls *LocalSender) HasStore(storeID proto.StoreID) bool
  • func (ls *LocalSender) Send(call *client.Call)
  • func (ls *LocalSender) VisitStores(visitor func(s *storage.Store) error) error
• type RESTServer
  • func NewRESTServer(db *client.KV) *RESTServer
  • func (s *RESTServer) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type RangeDescriptorCache
  • func NewRangeDescriptorCache(db rangeDescriptorDB) *RangeDescriptorCache
  • func (rmc *RangeDescriptorCache) EvictCachedRangeDescriptor(key proto.Key)
  • func (rmc *RangeDescriptorCache) LookupRangeDescriptor(key proto.Key) (*proto.RangeDescriptor, error)
• type TxnCoordSender
  • func NewTxnCoordSender(wrapped client.KVSender, clock *hlc.Clock, linearizable bool) *TxnCoordSender
  • func (tc *TxnCoordSender) Close()
  • func (tc *TxnCoordSender) Send(call *client.Call)

Constants

const (
	// RESTPrefix is the prefix for RESTful endpoints used to
	// interact directly with the key-value datastore.
	RESTPrefix = "/kv/rest/"
	// EntryPrefix is the prefix for endpoints that interact with individual key-value pairs directly.
	EntryPrefix = RESTPrefix + "entry/"
	// RangePrefix is the prefix for endpoints that interact with a range of key-value pairs.
	RangePrefix = RESTPrefix + "range"
	// CounterPrefix is the prefix for the endpoint that increments a key by a given amount.
	CounterPrefix = RESTPrefix + "counter/"
)

const (
	// DBPrefix is the prefix for the key-value database endpoint used
	// to interact with the key-value datastore via HTTP RPC.
	DBPrefix = client.KVDBEndpoint
)

Types

type DBServer

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

A DBServer provides an HTTP server endpoint serving the key-value API. It accepts either JSON or serialized protobuf content types.

func NewDBServer

func NewDBServer(sender client.KVSender) *DBServer

NewDBServer allocates and returns a new DBServer.

func (*DBServer) ServeHTTP

func (s *DBServer) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP serves the key-value API by treating the request URL path as the method, the request body as the arguments, and sets the response body as the method reply. The request body is unmarshalled into arguments based on the Content-Type request header. Protobuf and JSON-encoded requests are supported. The response body is encoded according the the request's Accept header, or if not present, in the same format as the request's incoming Content-Type header.

type DistSender

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

A DistSender provides methods to access Cockroach's monolithic, distributed key value store. Each method invocation triggers a lookup or lookups to find replica metadata for implicated key ranges. RPCs are sent to one or more of the replicas to satisfy the method invocation.

func NewDistSender

func NewDistSender(gossip *gossip.Gossip) *DistSender

NewDistSender returns a client.KVSender instance which connects to the Cockroach cluster via the supplied gossip instance.

func (*DistSender) Close

func (ds *DistSender) Close()

Close implements the client.KVSender interface. It's a noop for the distributed sender.

func (*DistSender) Send

func (ds *DistSender) Send(call *client.Call)

Send implements the clent.KVSender interface. It verifies permissions and looks up the appropriate range based on the supplied key and sends the RPC according to the specified options. If the request spans multiple ranges (which is possible for Scan or DeleteRange requests), Send sends requests to the individual ranges sequentially and combines the results transparently.

type LocalSender

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

A LocalSender provides methods to access a collection of local stores.

func NewLocalSender

func NewLocalSender() *LocalSender

NewLocalSender returns a local-only sender which directly accesses a collection of stores.

func (*LocalSender) AddStore

func (ls *LocalSender) AddStore(s *storage.Store)

AddStore adds the specified store to the store map.

func (*LocalSender) Close

func (ls *LocalSender) Close()

Close implements the client.KVSender interface. Close closes all stores.

func (*LocalSender) GetStore

func (ls *LocalSender) GetStore(storeID proto.StoreID) (*storage.Store, error)

GetStore looks up the store by store ID. Returns an error if not found.

func (*LocalSender) GetStoreCount

func (ls *LocalSender) GetStoreCount() int

GetStoreCount returns the number of stores this node is exporting.

func (*LocalSender) HasStore

func (ls *LocalSender) HasStore(storeID proto.StoreID) bool

HasStore returns true if the specified store is owned by this LocalSender.

func (*LocalSender) Send

func (ls *LocalSender) Send(call *client.Call)

Send implements the client.KVSender interface. The store is looked up from the store map if specified by header.Replica; otherwise, the command is being executed locally, and the replica is determined via lookup through each store's LookupRange method.

func (*LocalSender) VisitStores

func (ls *LocalSender) VisitStores(visitor func(s *storage.Store) error) error

VisitStores implements a visitor pattern over stores in the storeMap. The specified function is invoked with each store in turn. Stores are visited in a random order.

type RESTServer

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

A RESTServer provides a RESTful HTTP API to interact with an underlying key-value store.

func NewRESTServer

func NewRESTServer(db *client.KV) *RESTServer

NewRESTServer allocates and returns a new server.

func (*RESTServer) ServeHTTP

func (s *RESTServer) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP satisfies the http.Handler interface and arbitrates requests to the appropriate function based on the request’s HTTP method.

type RangeDescriptorCache

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

RangeDescriptorCache is used to retrieve range descriptors for arbitrary keys. Descriptors are initially queried from storage using a rangeDescriptorDB, but is cached for subsequent lookups.

func NewRangeDescriptorCache

func NewRangeDescriptorCache(db rangeDescriptorDB) *RangeDescriptorCache

NewRangeDescriptorCache returns a new RangeDescriptorCache which uses the given rangeDescriptorDB as the underlying source of range descriptors.

func (*RangeDescriptorCache) EvictCachedRangeDescriptor

func (rmc *RangeDescriptorCache) EvictCachedRangeDescriptor(key proto.Key)

EvictCachedRangeDescriptor will evict any cached range descriptors for the given key. It is intended that this method be called from a consumer of RangeDescriptorCache if the returned range descriptor is discovered to be stale.

func (*RangeDescriptorCache) LookupRangeDescriptor

func (rmc *RangeDescriptorCache) LookupRangeDescriptor(key proto.Key) (*proto.RangeDescriptor, error)

LookupRangeDescriptor attempts to locate a descriptor for the range containing the given Key. This is done by querying the two-level lookup table of range descriptors which cockroach maintains.

This method first looks up the specified key in the first level of range metadata, which returns the location of the key within the second level of range metadata. This second level location is then queried to retrieve a descriptor for the range where the key's value resides. Range descriptors retrieved during each search are cached for subsequent lookups.

This method returns the RangeDescriptor for the range containing the key's data, or an error if any occurred.

type TxnCoordSender

type TxnCoordSender struct {
	sync.Mutex // Protects the txns map.
	// contains filtered or unexported fields
}

A TxnCoordSender is an implementation of client.KVSender which wraps a lower-level KVSender (either a LocalSender or a DistSender) to which it sends commands. It acts as a man-in-the-middle, coordinating transaction state for clients. After a transaction is started, the TxnCoordSender starts asynchronously sending heartbeat messages to that transaction's txn record, to keep it live. It also keeps track of each written key or key range over the course of the transaction. When the transaction is committed or aborted, it clears accumulated write intents for the transaction.

func NewTxnCoordSender

func NewTxnCoordSender(wrapped client.KVSender, clock *hlc.Clock, linearizable bool) *TxnCoordSender

NewTxnCoordSender creates a new TxnCoordSender for use from a KV distributed DB instance. A TxnCoordSender should be closed when no longer in use via Close(), which also closes the wrapped sender supplied here.

func (*TxnCoordSender) Close

func (tc *TxnCoordSender) Close()

Close implements the client.KVSender interface by stopping ongoing heartbeats for extant transactions. Close does not attempt to resolve existing write intents for transactions which this TxnCoordSender has been managing.

func (*TxnCoordSender) Send

func (tc *TxnCoordSender) Send(call *client.Call)

Send implements the client.KVSender interface. If the call is part of a transaction, the coordinator will initialize the transaction if it's not nil but has an empty ID.