cockroach: github.com/objectundefined/cockroach/server Index | Files | Directories

package server

import "github.com/objectundefined/cockroach/server"

Package server implements the Cockroach storage node. A node corresponds to a single instance of the cockroach binary, running on a single physical machine, which exports the "Node" Go RPC service. Each node multiplexes RPC requests to one or more stores, associated with physical storage devices.

Package server also provides access to administrative tools via the command line and also through a REST API.

Index

Package Files

admin.go context.go debug.go doc.go node.go server.go status.go store_spec.go testserver.go ui_fs_release.go updates.go

Constants

const (
    // TestUser is a fixed user used in unittests.
    // It has valid embedded client certs.
    TestUser = "testuser"
)

Variables

var (

    // GracefulDrainModes is the standard succession of drain modes entered
    // for a graceful shutdown.
    GracefulDrainModes = []serverpb.DrainMode{serverpb.DrainMode_CLIENT, serverpb.DrainMode_LEADERSHIP}
)
var TestServerFactory testingshim.TestServerFactory = testServerFactoryImpl{}

TestServerFactory can be passed to testingshim.InitTestServerFactory

func AddEventLogToMetadataSchema Uses

func AddEventLogToMetadataSchema(schema *sqlbase.MetadataSchema)

AddEventLogToMetadataSchema adds the range event log table to the supplied MetadataSchema.

func ExpectedInitialRangeCount Uses

func ExpectedInitialRangeCount() int

ExpectedInitialRangeCount returns the expected number of ranges that should be on the server after initial (asynchronous) splits have been completed, assuming no additional information is added outside of the normal bootstrap process.

func GetBootstrapSchema Uses

func GetBootstrapSchema() sqlbase.MetadataSchema

GetBootstrapSchema returns the schema which will be used to bootstrap a new server.

func GetTotalMemory Uses

func GetTotalMemory() (int64, error)

GetTotalMemory returns either the total system memory or if possible the cgroups available memory.

func PathForNodeStatus Uses

func PathForNodeStatus(nodeID string) string

PathForNodeStatus returns the path needed to issue a GET request for node status. If passed an empty nodeID, this returns the path to GET status for all nodes.

func WaitForInitialSplits Uses

func WaitForInitialSplits(db *client.DB) error

WaitForInitialSplits waits for the expected number of initial ranges to be populated in the meta2 table. If the expected range count is not reached within a configured timeout, an error is returned.

type Context Uses

type Context struct {
    // Embed the base context.
    *base.Context

    // Unix socket: for postgres only.
    SocketFile string

    // Stores is specified to enable durable key-value storage.
    Stores StoreSpecList

    // Attrs specifies a colon-separated list of node topography or machine
    // capabilities, used to match capabilities or location preferences specified
    // in zone configs.
    Attrs string

    // JoinUsing is a comma-separated list of node addresses that
    // act as bootstrap hosts for connecting to the gossip network.
    JoinUsing string

    // CacheSize is the amount of memory in bytes to use for caching data.
    // The value is split evenly between the stores if there are more than one.
    CacheSize int64

    // MemtableBudget is the amount of memory, per store, in bytes to use for
    // the memory table.
    // This value is no longer settable by the end user.
    MemtableBudget int64

    // Engines is the storage instances specified by Stores.
    Engines []engine.Engine

    // NodeAttributes is the parsed representation of Attrs.
    NodeAttributes roachpb.Attributes

    // GossipBootstrapResolvers is a list of gossip resolvers used
    // to find bootstrap nodes for connecting to the gossip network.
    GossipBootstrapResolvers []resolver.Resolver

    // Enables linearizable behaviour of operations on this node by making sure
    // that no commit timestamp is reported back to the client until all other
    // node clocks have necessarily passed it.
    // Environment Variable: COCKROACH_LINEARIZABLE
    Linearizable bool

    // Maximum clock offset for the cluster.
    // Environment Variable: COCKROACH_MAX_OFFSET
    MaxOffset time.Duration

    // RaftTickInterval is the resolution of the Raft timer.
    RaftTickInterval time.Duration

    // MetricsSamplePeriod determines the time between records of
    // server internal metrics.
    // Environment Variable: COCKROACH_METRICS_SAMPLE_INTERVAL
    MetricsSampleInterval time.Duration

    // ScanInterval determines a duration during which each range should be
    // visited approximately once by the range scanner.
    // Environment Variable: COCKROACH_SCAN_INTERVAL
    ScanInterval time.Duration

    // ScanMaxIdleTime is the maximum time the scanner will be idle between ranges.
    // If enabled (> 0), the scanner may complete in less than ScanInterval for small
    // stores.
    // Environment Variable: COCKROACH_SCAN_MAX_IDLE_TIME
    ScanMaxIdleTime time.Duration

    // ConsistencyCheckInterval determines the time between range consistency checks.
    // Environment Variable: COCKROACH_CONSISTENCY_CHECK_INTERVAL
    ConsistencyCheckInterval time.Duration

    // ConsistencyCheckPanicOnFailure causes the node to panic when it detects a
    // replication consistency check failure.
    ConsistencyCheckPanicOnFailure bool

    // TimeUntilStoreDead is the time after which if there is no new gossiped
    // information about a store, it is considered dead.
    // Environment Variable: COCKROACH_TIME_UNTIL_STORE_DEAD
    TimeUntilStoreDead time.Duration

    // ReservationsEnabled is a switch used to enable the add replica
    // reservation system.
    ReservationsEnabled bool

    // TestingKnobs is used for internal test controls only.
    TestingKnobs base.TestingKnobs
}

Context holds parameters needed to setup a server.

func MakeContext Uses

func MakeContext() Context

MakeContext returns a Context with default values.

func MakeTestContext Uses

func MakeTestContext() Context

MakeTestContext returns a context for testing. It overrides the Certs with the test certs directory. We need to override the certs loader.

func (*Context) InitNode Uses

func (ctx *Context) InitNode() error

InitNode parses node attributes and initializes the gossip bootstrap resolvers.

func (*Context) InitStores Uses

func (ctx *Context) InitStores(stopper *stop.Stopper) error

InitStores initializes ctx.Engines based on ctx.Stores.

type Node Uses

type Node struct {
    ClusterID  uuid.UUID              // UUID for Cockroach cluster
    Descriptor roachpb.NodeDescriptor // Node ID, network/physical topology
    // contains filtered or unexported fields
}

A Node manages a map of stores (by store ID) for which it serves traffic. A node is the top-level data structure. There is one node instance per process. A node accepts incoming RPCs and services them by directing the commands contained within RPCs to local stores, which in turn direct the commands to specific ranges. Each node has access to the global, monolithic Key-Value abstraction via its kv.DB reference. Nodes use this to allocate node and store IDs for bootstrapping the node itself or new stores as they're added on subsequent instantiations.

func NewNode Uses

func NewNode(
    ctx storage.StoreContext,
    recorder *status.MetricsRecorder,
    stopper *stop.Stopper,
    txnMetrics *kv.TxnMetrics,
    eventLogger sql.EventLogger,
) *Node

NewNode returns a new instance of Node.

func (*Node) Batch Uses

func (n *Node) Batch(
    ctx context.Context, args *roachpb.BatchRequest,
) (br *roachpb.BatchResponse, err error)

Batch implements the roachpb.InternalServer interface.

func (*Node) IsDraining Uses

func (n *Node) IsDraining() bool

IsDraining returns true if at least one Store housed on this Node is not currently allowing leader leases to be procured or extended.

func (*Node) PollFrozen Uses

func (n *Node) PollFrozen(
    ctx context.Context, args *roachpb.PollFrozenRequest,
) (*roachpb.PollFrozenResponse, error)

PollFrozen implements the roachpb.InternalServer interface.

func (*Node) Reserve Uses

func (n *Node) Reserve(
    ctx context.Context, req *roachpb.ReservationRequest,
) (*roachpb.ReservationResponse, error)

Reserve implements the roachpb.InternalServer interface.

func (*Node) SetDraining Uses

func (n *Node) SetDraining(drain bool) error

SetDraining called with 'true' waits until all Replicas' leader leases have expired or a reasonable amount of time has passed (in which case an error is returned but draining mode is still active). When called with 'false', returns to the normal mode of allowing leader lease acquisition and extensions.

type Server Uses

type Server struct {
    Tracer opentracing.Tracer
    // contains filtered or unexported fields
}

Server is the cockroach server node.

func NewServer Uses

func NewServer(ctx Context, stopper *stop.Stopper) (*Server, error)

NewServer creates a Server from a server.Context.

func (*Server) Drain Uses

func (s *Server) Drain(on []serverpb.DrainMode) ([]serverpb.DrainMode, error)

Drain idempotently activates the given DrainModes on the Server in the order in which they are supplied. For example, Drain is typically called with [CLIENT,LEADERSHIP] before terminating the process for graceful shutdown. On success, returns all active drain modes after carrying out the request. On failure, the system may be in a partially drained state and should be recovered by calling Undrain() with the same (or a larger) slice of modes.

func (*Server) ServeHTTP Uses

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

ServeHTTP is necessary to implement the http.Handler interface.

func (*Server) SetupReportingURLs Uses

func (s *Server) SetupReportingURLs() error

SetupReportingURLs parses the phone-home for version updates URL and should be called before a server starts. Where update checks are not useful (eg in tests), skipping this call, or setting env var COCKROACH_SKIP_UPDATE_CHECK=1, skips the acutal network calls (note though the check is treated as having succeeded, meaning the cluster will wait until the next scheduled check to try again).

func (*Server) Start Uses

func (s *Server) Start() error

Start starts the server on the specified port, starts gossip and initializes the node using the engines from the server's context.

func (*Server) Stop Uses

func (s *Server) Stop()

Stop stops the server.

func (*Server) Undrain Uses

func (s *Server) Undrain(off []serverpb.DrainMode) []serverpb.DrainMode

Undrain idempotently deactivates the given DrainModes on the Server in the order in which they are supplied. On success, returns any remaining active drain modes.

type StoreSpec Uses

type StoreSpec struct {
    Path        string
    SizeInBytes int64
    SizePercent float64
    InMemory    bool
    Attributes  roachpb.Attributes
}

StoreSpec contains the details that can be specified in the cli pertaining to the --store flag.

func (StoreSpec) String Uses

func (ss StoreSpec) String() string

String returns a fully parsable version of the store spec.

type StoreSpecList Uses

type StoreSpecList struct {
    Specs []StoreSpec
    // contains filtered or unexported fields
}

StoreSpecList contains a slice of StoreSpecs that implements pflag's value interface.

func (*StoreSpecList) Set Uses

func (ssl *StoreSpecList) Set(value string) error

Set adds a new value to the StoreSpecValue. It is the important part of pflag's value interface.

func (StoreSpecList) String Uses

func (ssl StoreSpecList) String() string

String returns a string representation of all the StoreSpecs. This is part of pflag's value interface.

func (*StoreSpecList) Type Uses

func (ssl *StoreSpecList) Type() string

Type returns the underlying type in string form. This is part of pflag's value interface.

type TestServer Uses

type TestServer struct {
    // Ctx is the context used by this server.
    Ctx *Context
    // server is the embedded Cockroach server struct.
    *Server
    StoresPerNode int
}

A TestServer encapsulates an in-memory instantiation of a cockroach node with a single store. Example usage of a TestServer follows:

s := server.StartTestServer(t)
defer s.Stop()

func StartInsecureTestServer Uses

func StartInsecureTestServer(t util.Tester) TestServer

StartInsecureTestServer starts an insecure in-memory test server.

func StartTestServer Uses

func StartTestServer(t util.Tester) TestServer

StartTestServer starts an in-memory test server.

func StartTestServerJoining Uses

func StartTestServerJoining(t util.Tester, other TestServer) TestServer

StartTestServerJoining starts an in-memory test server that attempts to join `other`.

func StartTestServerWithContext Uses

func StartTestServerWithContext(t util.Tester, ctx *Context) TestServer

StartTestServerWithContext starts an in-memory test server. ctx can be nil, in which case a default context will be created.

func (*TestServer) Clock Uses

func (ts *TestServer) Clock() *hlc.Clock

Clock returns the clock used by the TestServer.

func (*TestServer) DB Uses

func (ts *TestServer) DB() *client.DB

DB returns the client.DB instance used by the TestServer.

func (*TestServer) Gossip Uses

func (ts *TestServer) Gossip() *gossip.Gossip

Gossip returns the gossip instance used by the TestServer.

func (*TestServer) KVClient Uses

func (ts *TestServer) KVClient() interface{}

KVClient is part of TestServerInterface.

func (*TestServer) KVDB Uses

func (ts *TestServer) KVDB() interface{}

KVDB is part of TestServerInterface.

func (*TestServer) LeaseManager Uses

func (ts *TestServer) LeaseManager() interface{}

LeaseManager is part of TestServerInterface.

func (*TestServer) MustGetSQLCounter Uses

func (ts *TestServer) MustGetSQLCounter(name string) int64

MustGetSQLCounter returns the value of a counter metric from the server's SQL Executor. Runs in O(# of metrics) time, which is fine for test code.

func (*TestServer) MustGetSQLNetworkCounter Uses

func (ts *TestServer) MustGetSQLNetworkCounter(name string) int64

MustGetSQLNetworkCounter returns the value of a counter metric from the server's SQL server. Runs in O(# of metrics) time, which is fine for test code.

func (*TestServer) RPCContext Uses

func (ts *TestServer) RPCContext() *rpc.Context

RPCContext returns the rpc context used by the TestServer.

func (*TestServer) ServingAddr Uses

func (ts *TestServer) ServingAddr() string

ServingAddr returns the server's address. Should be used by clients.

func (*TestServer) ServingHost Uses

func (ts *TestServer) ServingHost() (string, error)

ServingHost returns the host portion of the rpc server's address.

func (*TestServer) ServingPort Uses

func (ts *TestServer) ServingPort() (string, error)

ServingPort returns the port portion of the rpc server's address.

func (*TestServer) SetRangeRetryOptions Uses

func (ts *TestServer) SetRangeRetryOptions(ro retry.Options)

SetRangeRetryOptions sets the retry options for stores in TestServer.

func (*TestServer) Start Uses

func (ts *TestServer) Start() error

Start starts the TestServer by bootstrapping an in-memory store (defaults to maximum of 100M). The server is started, launching the node RPC server and all HTTP endpoints. Use the value of TestServer.ServingAddr() after Start() for client connections. Use Stop() to shutdown the server after the test completes.

func (*TestServer) StartWithStopper Uses

func (ts *TestServer) StartWithStopper(stopper *stop.Stopper) error

StartWithStopper is the same as Start, but allows passing a stopper explicitly.

func (*TestServer) Stop Uses

func (ts *TestServer) Stop()

Stop stops the TestServer.

func (*TestServer) Stopper Uses

func (ts *TestServer) Stopper() *stop.Stopper

Stopper returns the embedded server's Stopper.

func (*TestServer) Stores Uses

func (ts *TestServer) Stores() *storage.Stores

Stores returns the collection of stores from this TestServer's node.

func (*TestServer) TsDB Uses

func (ts *TestServer) TsDB() *ts.DB

TsDB returns the ts.DB instance used by the TestServer.

func (*TestServer) WaitForInitialSplits Uses

func (ts *TestServer) WaitForInitialSplits() error

WaitForInitialSplits waits for the server to complete its expected initial splits at startup. If the expected range count is not reached within a configured timeout, an error is returned.

func (*TestServer) WriteSummaries Uses

func (ts *TestServer) WriteSummaries() error

WriteSummaries records summaries of time-series data, which is required for any tests that query server stats.

Directories

PathSynopsis
serverpbPackage serverpb is a generated protocol buffer package.
statusPackage status is a generated protocol buffer package.
testingshim

Package server imports 78 packages (graph). Updated 2017-07-06. Refresh now. Tools for package owners. This is a dead-end fork (no commits since the fork).