func newServer() (*server, error) {
// Determine hostname in case it hasn't been specified in -rpc or -http.
host, err := os.Hostname()
if err != nil {
host = "127.0.0.1"
}
// Resolve
if strings.HasPrefix(*rpcAddr, ":") {
*rpcAddr = host + *rpcAddr
}
addr, err := net.ResolveTCPAddr("tcp", *rpcAddr)
if err != nil {
return nil, util.Errorf("unable to resolve RPC address %q: %v", *rpcAddr, err)
}
s := &server{
host: host,
mux: http.NewServeMux(),
rpc: rpc.NewServer(addr),
}
s.gossip = gossip.New()
s.kvDB = kv.NewDB(s.gossip)
s.kvREST = rest.NewRESTServer(s.kvDB)
s.node = NewNode(s.kvDB, s.gossip)
s.admin = newAdminServer(s.kvDB)
s.status = newStatusServer(s.kvDB)
s.structuredDB = structured.NewDB(s.kvDB)
s.structuredREST = structured.NewRESTServer(s.structuredDB)
return s, nil
}
// createTestNode creates an rpc server using the specified address,
// gossip instance, KV database and a node using the specified slice
// of engines. The server and node are returned. If gossipBS is not
// nil, the gossip bootstrap address is set to gossipBS.
func createTestNode(addr net.Addr, engines []engine.Engine, gossipBS net.Addr, t *testing.T) (
*rpc.Server, *Node) {
tlsConfig, err := rpc.LoadTestTLSConfig("..")
if err != nil {
t.Fatal(err)
}
rpcServer := rpc.NewServer(addr, tlsConfig)
if err := rpcServer.Start(); err != nil {
t.Fatal(err)
}
g := gossip.New(tlsConfig)
if gossipBS != nil {
// Handle possibility of a :0 port specification.
if gossipBS == addr {
gossipBS = rpcServer.Addr()
}
g.SetBootstrap([]net.Addr{gossipBS})
g.Start(rpcServer)
}
clock := hlc.NewClock(hlc.UnixNano)
db := kv.NewDB(kv.NewDistKV(g), clock)
node := NewNode(db, g)
if err := node.start(rpcServer, clock, engines, proto.Attributes{}); err != nil {
t.Fatal(err)
}
return rpcServer, node
}
// BootstrapCluster bootstraps a store using the provided engine and
// cluster ID. The bootstrapped store contains a single range spanning
// all keys. Initial range lookup metadata is populated for the range.
//
// Returns a kv.DB for unittest purposes only.
func BootstrapCluster(clusterID string, eng engine.Engine) (*kv.DB, error) {
sIdent := proto.StoreIdent{
ClusterID: clusterID,
NodeID: 1,
StoreID: 1,
}
clock := hlc.NewClock(hlc.UnixNano)
now := clock.Now()
s := storage.NewStore(clock, eng, nil, nil)
// Verify the store isn't already part of a cluster.
if len(s.Ident.ClusterID) > 0 {
return nil, util.Errorf("storage engine already belongs to a cluster (%s)", s.Ident.ClusterID)
}
// Bootstrap store to persist the store ident.
if err := s.Bootstrap(sIdent); err != nil {
return nil, err
}
// Create first range.
rng, err := s.CreateRange(s.BootstrapRangeMetadata())
if err != nil {
return nil, err
}
// Create a KV DB with a local KV to directly modify the new range.
localKV := kv.NewLocalKV()
localKV.AddStore(s)
localDB := kv.NewDB(localKV, clock)
// Initialize range addressing records and default administrative configs.
desc := &rng.Meta.RangeDescriptor
if err := storage.BootstrapRangeDescriptor(localDB, desc, now); err != nil {
return nil, err
}
// Write default configs to local DB.
if err := storage.BootstrapConfigs(localDB, now); err != nil {
return nil, err
}
// Initialize node and store ids after the fact to account
// for use of node ID = 1 and store ID = 1.
if nodeID, err := allocateNodeID(localDB); nodeID != sIdent.NodeID || err != nil {
return nil, util.Errorf("expected to intialize node id allocator to %d, got %d: %v",
sIdent.NodeID, nodeID, err)
}
if storeID, err := allocateStoreIDs(sIdent.NodeID, 1, localDB); storeID != sIdent.StoreID || err != nil {
return nil, util.Errorf("expected to intialize store id allocator to %d, got %d: %v",
sIdent.StoreID, storeID, err)
}
return localDB, nil
}
func newServer() (*server, error) {
// Determine hostname in case it hasn't been specified in -rpc or -http.
host, err := os.Hostname()
if err != nil {
host = "127.0.0.1"
}
// Resolve
if strings.HasPrefix(*rpcAddr, ":") {
*rpcAddr = host + *rpcAddr
}
_, err = net.ResolveTCPAddr("tcp", *rpcAddr)
if err != nil {
return nil, util.Errorf("unable to resolve RPC address %q: %v", *rpcAddr, err)
}
var tlsConfig *rpc.TLSConfig
if *certDir == "" {
tlsConfig = rpc.LoadInsecureTLSConfig()
} else {
var err error
if tlsConfig, err = rpc.LoadTLSConfig(*certDir); err != nil {
return nil, util.Errorf("unable to load TLS config: %v", err)
}
}
s := &server{
host: host,
mux: http.NewServeMux(),
clock: hlc.NewClock(hlc.UnixNano),
rpc: rpc.NewServer(util.MakeRawAddr("tcp", *rpcAddr), tlsConfig),
}
s.clock.SetMaxDrift(*maxDrift)
s.gossip = gossip.New(tlsConfig)
s.kvDB = kv.NewDB(kv.NewDistKV(s.gossip), s.clock)
s.kvREST = rest.NewRESTServer(s.kvDB)
s.node = NewNode(s.kvDB, s.gossip)
s.admin = newAdminServer(s.kvDB)
s.status = newStatusServer(s.kvDB)
s.structuredDB = structured.NewDB(s.kvDB)
s.structuredREST = structured.NewRESTServer(s.structuredDB)
return s, nil
}
func newServer() (*server, error) {
addr, err := net.ResolveTCPAddr("tcp", *rpcAddr)
if err != nil {
return nil, err
}
s := &server{
mux: http.NewServeMux(),
rpc: rpc.NewServer(addr),
}
s.gossip = gossip.New(s.rpc)
s.kvDB = kv.NewDB(s.gossip)
s.kvREST = kv.NewRESTServer(s.kvDB)
s.node = NewNode(s.rpc, s.kvDB, s.gossip)
s.admin = newAdminServer(s.kvDB)
s.structuredDB = structured.NewDB(s.kvDB)
s.structuredREST = structured.NewRESTServer(s.structuredDB)
return s, nil
}
// createTestNode creates an rpc server using the specified address,
// gossip instance, KV database and a node using the specified slice
// of engines. The server and node are returned. If gossipBS is not
// nil, the gossip bootstrap address is set to gossipBS.
func createTestNode(addr net.Addr, engines []storage.Engine, gossipBS net.Addr, t *testing.T) (
*rpc.Server, *Node) {
rpcServer := rpc.NewServer(addr)
if err := rpcServer.Start(); err != nil {
t.Fatal(err)
}
g := gossip.New()
if gossipBS != nil {
// Handle possibility of a :0 port specification.
if gossipBS == addr {
gossipBS = rpcServer.Addr()
}
g.SetBootstrap([]net.Addr{gossipBS})
g.Start(rpcServer)
}
db := kv.NewDB(g)
node := NewNode(db, g)
if err := node.start(rpcServer, engines, nil); err != nil {
t.Fatal(err)
}
return rpcServer, node
}
