server

package
v1.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 7, 2017 License: Apache-2.0 Imports: 88 Imported by: 0

Documentation

Overview

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

Constants

View Source 
const (

	// FirstNodeID is the node ID of the first node in a new cluster.
	FirstNodeID = 1
)
View Source 
const (
	// TestUser is a fixed user used in unittests.
	// It has valid embedded client certs.
	TestUser = "testuser"
)

Variables

View Source 
var (

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

TestServerFactory can be passed to serverutils.InitTestServerFactory

Functions

func ExpectedInitialRangeCount 

func ExpectedInitialRangeCount(db *client.DB) (int, error)

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 

func GetBootstrapSchema() sqlbase.MetadataSchema

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

func GetTotalMemory 

func GetTotalMemory(ctx context.Context) (int64, error)

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

func SetOpenFileLimitForOneStore 

func SetOpenFileLimitForOneStore() (int, error)

SetOpenFileLimitForOneStore sets the soft limit for open file descriptors when there is only one store.

func WaitForInitialSplits 

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.

Types

type Config 

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

	// Unix socket: for postgres only.
	SocketFile string

	// Stores is specified to enable durable key-value storage.
	Stores base.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

	// JoinList is a list of node addresses that act as bootstrap hosts for
	// connecting to the gossip network. Each item in the list can actually be
	// multiple comma-separated addresses, kept for backward-compatibility.
	JoinList base.JoinListType

	// RetryOptions controls the retry behavior of the server.
	RetryOptions retry.Options

	// 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

	// TimeSeriesServerConfig contains configuration specific to the time series
	// server.
	TimeSeriesServerConfig ts.ServerConfig

	// SQLMemoryPoolSize is the amount of memory in bytes that can be
	// used by SQL clients to store row data in server RAM.
	SQLMemoryPoolSize int64

	// 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 allowed clock offset for the cluster. If observed clock
	// offsets exceed this limit, inconsistency may result, and servers
	// will panic to minimize the likelihood of inconsistent data.
	// Increasing this value will increase time to recovery after
	// failures, and increase the frequency and impact of
	// ReadWithinUncertaintyIntervalError.
	MaxOffset time.Duration

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

	// RaftElectionTimeoutTicks is the number of raft ticks before the
	// previous election expires. This value is inherited by individual
	// stores unless overridden.
	RaftElectionTimeoutTicks int

	// 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. Set to 0 to disable.
	// 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.
	// Set to 0 to disable.
	// 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 *settings.DurationSetting

	// SendNextTimeout is the time after which an alternate replica will
	// be used to attempt sending a KV batch.
	// Environment Variable: COCKROACH_SEND_NEXT_TIMEOUT
	SendNextTimeout time.Duration

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

	// AmbientCtx is used to annotate contexts used inside the server.
	AmbientCtx log.AmbientContext

	// Locality is a description of the topography of the server.
	Locality roachpb.Locality

	// EventLogEnabled is a switch which enables recording into cockroach's SQL
	// event log tables. These tables record transactional events about changes
	// to cluster metadata, such as DDL statements and range rebalancing
	// actions.
	EventLogEnabled bool

	// ListeningURLFile indicates the file to which the server writes
	// its listening URL when it is ready.
	ListeningURLFile string

	// PIDFile indicates the file to which the server writes its PID when
	// it is ready.
	PIDFile string
	// contains filtered or unexported fields
}

Config holds parameters needed to setup a server.

func MakeConfig 

func MakeConfig() Config

MakeConfig returns a Context with default values.

func (*Config) CreateEngines 

func (cfg *Config) CreateEngines(ctx context.Context) (Engines, error)

CreateEngines creates Engines based on the specs in cfg.Stores.

func (*Config) FilterGossipBootstrapResolvers 

func (cfg *Config) FilterGossipBootstrapResolvers(
	ctx context.Context, listen, advert net.Addr,
) []resolver.Resolver

FilterGossipBootstrapResolvers removes any gossip bootstrap resolvers which match either this node's listen address or its advertised host address.

func (Config) HistogramWindowInterval 

func (cfg Config) HistogramWindowInterval() time.Duration

HistogramWindowInterval is used to determine the approximate length of time that individual samples are retained in in-memory histograms. Currently, it is set to the arbitrary length of six times the Metrics sample interval.

The length of the window must be longer than the sampling interval due to issue #12998, which was causing histograms to return zero values when sampled because all samples had been evicted.

Note that this is only intended to be a temporary fix for the above issue, as our current handling of metric histograms have numerous additional problems. These are tracked in github issue #7896, which has been given a relatively high priority in light of recent confusion around histogram metrics. For more information on the issues underlying our histogram system and the proposed fixes, please see issue #7896.

func (*Config) InitNode 

func (cfg *Config) InitNode() error

InitNode parses node attributes and initializes the gossip bootstrap resolvers.

func (*Config) Report added in v1.0.2 

func (cfg *Config) Report(ctx context.Context)

Report logs an overview of the server configuration parameters via the given context.

func (*Config) String added in v1.0.2 

func (cfg *Config) String() string

String implements the fmt.Stringer interface.

type Engines 

type Engines []engine.Engine

Engines is a container of engines, allowing convenient closing.

func (*Engines) Close 

func (e *Engines) Close()

Close closes all the Engines. This method has a pointer receiver so that the following pattern works: 

func f() {
	engines := Engines(engineSlice)
	defer engines.Close()  // make sure the engines are Closed if this
	                       // function returns early.
	... do something with engines, pass ownership away...
	engines = nil  // neutralize the preceding defer
}

type Node 

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 

func NewNode(
	cfg storage.StoreConfig,
	recorder *status.MetricsRecorder,
	reg *metric.Registry,
	stopper *stop.Stopper,
	txnMetrics kv.TxnMetrics,
	eventLogger sql.EventLogger,
) *Node

NewNode returns a new instance of Node.

func (*Node) AnnotateCtx 

func (n *Node) AnnotateCtx(ctx context.Context) context.Context

AnnotateCtx is a convenience wrapper; see AmbientContext.

func (*Node) AnnotateCtxWithSpan 

func (n *Node) AnnotateCtxWithSpan(
	ctx context.Context, opName string,
) (context.Context, opentracing.Span)

AnnotateCtxWithSpan is a convenience wrapper; see AmbientContext.

func (*Node) Batch 

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

Batch implements the roachpb.InternalServer interface.

func (*Node) IsDraining 

func (n *Node) IsDraining() bool

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

func (*Node) SetDraining 

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

SetDraining sets the draining mode on all of the node's underlying stores.

func (*Node) String 

func (n *Node) String() string

String implements fmt.Stringer.

type Server 

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

Server is the cockroach server node.

func NewServer 

func NewServer(cfg Config, stopper *stop.Stopper) (*Server, error)

NewServer creates a Server from a server.Context.

func (*Server) AnnotateCtx 

func (s *Server) AnnotateCtx(ctx context.Context) context.Context

AnnotateCtx is a convenience wrapper; see AmbientContext.

func (*Server) AnnotateCtxWithSpan 

func (s *Server) AnnotateCtxWithSpan(
	ctx context.Context, opName string,
) (context.Context, opentracing.Span)

AnnotateCtxWithSpan is a convenience wrapper; see AmbientContext.

func (*Server) ClusterID 

func (s *Server) ClusterID() uuid.UUID

ClusterID returns the ID of the cluster this server is a part of.

func (*Server) ClusterStores 

func (s *Server) ClusterStores() []roachpb.ReplicationTarget

ClusterStores returns a list of known stores in the cluster.

func (*Server) Drain 

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) InitialBoot 

func (s *Server) InitialBoot() bool

InitialBoot returns whether this is the first time the node has booted. Only intended to help print debugging info during server startup.

func (*Server) NodeID 

func (s *Server) NodeID() roachpb.NodeID

NodeID returns the ID of this node within its cluster.

func (*Server) PeriodicallyCheckForUpdates 

func (s *Server) PeriodicallyCheckForUpdates()

PeriodicallyCheckForUpdates starts a background worker that periodically phones home to check for updates and report usage.

func (*Server) ServeHTTP 

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

ServeHTTP is necessary to implement the http.Handler interface.

func (*Server) SetDistSQLSpanResolver 

func (ts *Server) SetDistSQLSpanResolver(spanResolver interface{})

SetDistSQLSpanResolver is part of TestServerInterface.

func (*Server) Start 

func (s *Server) Start(ctx context.Context) error

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

The passed context can be used to trace the server startup. The context should represent the general startup operation.

func (*Server) Stop 

func (s *Server) Stop()

Stop stops the server.

func (*Server) Undrain 

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 TestServer 

type TestServer struct {
	Cfg *Config
	// server is the embedded Cockroach server struct.
	*Server
}

A TestServer encapsulates an in-memory instantiation of a cockroach node with a single store. It provides tests with access to Server internals. Where possible, it should be used through the testingshim.TestServerInterface.

Example usage of a TestServer: 

s, db, kvDB := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
// If really needed, in tests that can depend on server, downcast to
// server.TestServer:
ts := s.(*server.TestServer)

func (*TestServer) AdminURL 

func (ts *TestServer) AdminURL() string

AdminURL implements TestServerInterface.

func (*TestServer) Clock 

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

Clock returns the clock used by the TestServer.

func (*TestServer) DB 

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

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

func (*TestServer) DistSQLServer 

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

DistSQLServer is part of TestServerInterface.

func (*TestServer) DistSender 

func (ts *TestServer) DistSender() *kv.DistSender

DistSender exposes the Server's DistSender.

func (*TestServer) Engines 

func (ts *TestServer) Engines() []engine.Engine

Engines returns the TestServer's engines.

func (*TestServer) ExpectedInitialRangeCount 

func (ts *TestServer) ExpectedInitialRangeCount() (int, error)

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 (*TestServer) GetFirstStoreID 

func (ts *TestServer) GetFirstStoreID() roachpb.StoreID

GetFirstStoreID is part of TestServerInterface.

func (*TestServer) GetHTTPClient 

func (ts *TestServer) GetHTTPClient() (http.Client, error)

GetHTTPClient implements TestServerInterface.

func (*TestServer) GetNode 

func (ts *TestServer) GetNode() *Node

GetNode exposes the Server's Node.

func (*TestServer) Gossip 

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

Gossip returns the gossip instance used by the TestServer.

func (*TestServer) KVClient 

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

KVClient is part of TestServerInterface.

func (*TestServer) KVDB 

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

KVDB is part of TestServerInterface.

func (*TestServer) LeaseManager 

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

LeaseManager is part of TestServerInterface.

func (*TestServer) LookupRange 

func (ts *TestServer) LookupRange(key roachpb.Key) (roachpb.RangeDescriptor, error)

LookupRange returns the descriptor of the range containing key.

func (*TestServer) MustGetSQLCounter 

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

MustGetSQLCounter implements TestServerInterface.

func (*TestServer) MustGetSQLNetworkCounter 

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

MustGetSQLNetworkCounter implements TestServerInterface.

func (*TestServer) PGServer 

func (ts *TestServer) PGServer() *pgwire.Server

PGServer returns the pgwire.Server used by the TestServer.

func (*TestServer) RPCContext 

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

RPCContext returns the rpc context used by the TestServer.

func (*TestServer) ServingAddr 

func (ts *TestServer) ServingAddr() string

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

func (*TestServer) SplitRange 

func (ts *TestServer) SplitRange(
	splitKey roachpb.Key,
) (roachpb.RangeDescriptor, roachpb.RangeDescriptor, error)

SplitRange splits the range containing splitKey. The right range created by the split starts at the split key and extends to the original range's end key. Returns the new descriptors of the left and right ranges.

splitKey must correspond to a SQL table key (it must end with a family ID / col ID).

func (*TestServer) Start 

func (ts *TestServer) Start(params base.TestServerArgs) 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 TestServer.Stopper().Stop() to shutdown the server after the test completes.

func (*TestServer) Stopper 

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

Stopper returns the embedded server's Stopper.

func (*TestServer) Stores 

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

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

func (*TestServer) TsDB 

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

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

func (*TestServer) WaitForInitialSplits 

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 

func (ts *TestServer) WriteSummaries() error

WriteSummaries implements TestServerInterface.

Source Files

View all Source files

Directories

Path Synopsis
Package serverpb is a generated protocol buffer package.
 Package serverpb is a generated protocol buffer package.
Package status is a generated protocol buffer package.
 Package status is a generated protocol buffer package.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.