func checkOfficialize(t *testing.T, network, oldAddrString, newAddrString, expAddrString string) {
unresolvedAddr := util.NewUnresolvedAddr(network, oldAddrString)
resolvedAddr := util.NewUnresolvedAddr(network, newAddrString)
if err := officializeAddr(unresolvedAddr, resolvedAddr); err != nil {
t.Fatal(err)
}
if retAddrString := unresolvedAddr.String(); retAddrString != expAddrString {
t.Errorf("officializeAddr(%s, %s) was %s; expected %s", oldAddrString, newAddrString, retAddrString, expAddrString)
}
}
// Start starts the server on the specified port, starts gossip and
// initializes the node using the engines from the server's context.
func (s *Server) Start() error {
tlsConfig, err := s.ctx.GetServerTLSConfig()
if err != nil {
return err
}
unresolvedAddr := util.NewUnresolvedAddr("tcp", s.ctx.Addr)
ln, err := util.ListenAndServe(s.stopper, s, unresolvedAddr, tlsConfig)
if err != nil {
return err
}
s.listener = ln // Only used in tests.
if err := officializeAddr(unresolvedAddr, ln.Addr()); err != nil {
return err
}
s.rpcContext.SetLocalServer(s.rpc, unresolvedAddr.String())
s.grpc = grpc.NewServer()
s.gossip.Start(s.grpc, unresolvedAddr)
if err := s.node.start(s.rpc, unresolvedAddr, s.ctx.Engines, s.ctx.NodeAttributes); err != nil {
return err
}
// Begin recording runtime statistics.
runtime := status.NewRuntimeStatRecorder(s.node.Descriptor.NodeID, s.clock)
s.tsDB.PollSource(runtime, s.ctx.MetricsFrequency, ts.Resolution10s, s.stopper)
// Begin recording time series data collected by the status monitor.
s.recorder = status.NewNodeStatusRecorder(s.node.status, s.clock)
s.tsDB.PollSource(s.recorder, s.ctx.MetricsFrequency, ts.Resolution10s, s.stopper)
// Begin recording status summaries.
s.startWriteSummaries()
s.sqlServer.SetNodeID(s.node.Descriptor.NodeID)
// Create and start the schema change manager only after a NodeID
// has been assigned.
s.schemaChangeManager = sql.NewSchemaChangeManager(*s.db, s.gossip, s.leaseMgr)
s.schemaChangeManager.Start(s.stopper)
s.status = newStatusServer(s.db, s.gossip, s.registry, s.ctx)
log.Infof("starting %s server at %s", s.ctx.HTTPRequestScheme(), unresolvedAddr)
s.initHTTP()
return s.pgServer.Start(util.NewUnresolvedAddr("tcp", s.ctx.PGAddr))
}
func (tr *testResolver) GetAddress() (net.Addr, error) {
defer func() { tr.numTries++ }()
if tr.numTries < tr.numFails {
return nil, errors.New("bad address")
}
return util.NewUnresolvedAddr("tcp", tr.addr), nil
}
func officialAddr(unresolvedAddr string, resolvedAddr net.Addr) (*util.UnresolvedAddr, error) {
unresolvedHost, unresolvedPort, err := net.SplitHostPort(unresolvedAddr)
if err != nil {
return nil, err
}
resolvedHost, resolvedPort, err := net.SplitHostPort(resolvedAddr.String())
if err != nil {
return nil, err
}
var host string
if unresolvedHost != "" {
// A host was provided, use it.
host = unresolvedHost
} else {
// A host was not provided. Ask the system, and fall back to the listener.
if hostname, err := os.Hostname(); err == nil {
host = hostname
} else {
host = resolvedHost
}
}
var port string
if unresolvedPort != "0" {
// A port was provided, use it.
port = unresolvedPort
} else {
// A port was not provided, but the system assigned one.
port = resolvedPort
}
return util.NewUnresolvedAddr(resolvedAddr.Network(), net.JoinHostPort(host, port)), nil
}
func (tr *testResolver) GetAddress() (net.Addr, error) {
// Fail 3 times...
tr.tries++
if tr.tries < 3 {
return nil, errors.New("bad address")
}
return util.NewUnresolvedAddr("tcp", tr.addr), nil
}
func resolveAddress(network, address string) (net.Addr, error) {
if network == "tcp" {
_, err := net.ResolveTCPAddr("tcp", address)
if err != nil {
return nil, err
}
return util.NewUnresolvedAddr("tcp", address), nil
}
return nil, util.Errorf("unknown address type: %q", network)
}
// TestClientCloseBeforeConnect verifies that the client goroutine
// does not leak if the client is closed before connecting.
func TestClientCloseBeforeConnect(t *testing.T) {
defer leaktest.AfterTest(t)()
c := NewClient(
util.NewUnresolvedAddr("tcp", ":1337"),
&Context{Stopper: stop.NewStopper()},
)
c.Close()
}
// GetAddress returns a net.Addr or error.
func (sr *socketResolver) GetAddress() (net.Addr, error) {
switch sr.typ {
case "tcp":
_, err := net.ResolveTCPAddr("tcp", sr.addr)
if err != nil {
return nil, err
}
return util.NewUnresolvedAddr("tcp", sr.addr), nil
}
return nil, errors.Errorf("unknown address type: %q", sr.typ)
}
// GetAddress returns a net.Addr or error.
func (sr *socketResolver) GetAddress() (net.Addr, error) {
switch sr.typ {
case "unix":
addr, err := net.ResolveUnixAddr("unix", sr.addr)
if err != nil {
return nil, err
}
sr.exhausted = true
return addr, nil
case "tcp":
_, err := net.ResolveTCPAddr("tcp", sr.addr)
if err != nil {
return nil, err
}
sr.exhausted = true
return util.NewUnresolvedAddr("tcp", sr.addr), nil
}
return nil, util.Errorf("unknown address type: %q", sr.typ)
}
// GetAddress returns a net.Addr or error.
func (sr *socketResolver) GetAddress() (net.Addr, error) {
switch sr.typ {
case "unix":
addr, err := net.ResolveUnixAddr("unix", sr.addr)
if err != nil {
return nil, err
}
sr.exhausted = true
return addr, nil
case "tcp", "lb":
_, err := net.ResolveTCPAddr("tcp", sr.addr)
if err != nil {
return nil, err
}
if sr.typ == "tcp" {
// "tcp" resolvers point to a single host. "lb" have an unknown of number of backends.
sr.exhausted = true
}
return util.NewUnresolvedAddr("tcp", sr.addr), nil
}
return nil, util.Errorf("unknown address type: %q", sr.typ)
}
"github.com/cockroachdb/cockroach/util/leaktest"
)
var testRangeDescriptor = roachpb.RangeDescriptor{
RangeID: 1,
StartKey: roachpb.RKey("a"),
EndKey: roachpb.RKey("z"),
Replicas: []roachpb.ReplicaDescriptor{
{
NodeID: 1,
StoreID: 1,
},
},
}
var testAddress = util.NewUnresolvedAddr("tcp", "node1")
func makeTestGossip(t *testing.T) (*gossip.Gossip, func()) {
n := simulation.NewNetwork(1)
g := n.Nodes[0].Gossip
if err := g.AddInfo(gossip.KeySentinel, nil, time.Hour); err != nil {
t.Fatal(err)
}
if err := g.AddInfoProto(gossip.KeyFirstRangeDescriptor, &testRangeDescriptor, time.Hour); err != nil {
t.Fatal(err)
}
nodeIDKey := gossip.MakeNodeIDKey(1)
if err := g.AddInfoProto(nodeIDKey, &roachpb.NodeDescriptor{
NodeID: 1,
Address: *testAddress,
