// NewDefaultServer is like NewServer, but we take care of creating a
// mesh.Router and meshconn.Peer for you, with sane defaults. If you need more
// fine-grained control, create the components yourself and use NewServer.
func NewDefaultServer(
minPeerCount int,
terminatec <-chan struct{},
terminatedc chan<- error,
logger mesh.Logger,
) Server {
var (
peerName = mustPeerName()
nickName = mustHostname()
host = "0.0.0.0"
port = 6379
password = ""
channel = "metcd"
)
router := mesh.NewRouter(mesh.Config{
Host: host,
Port: port,
ProtocolMinVersion: mesh.ProtocolMinVersion,
Password: []byte(password),
ConnLimit: 64,
PeerDiscovery: true,
TrustedSubnets: []*net.IPNet{},
}, peerName, nickName, mesh.NullOverlay{}, logger)
// Create a meshconn.Peer and connect it to a channel.
peer := meshconn.NewPeer(router.Ourself.Peer.Name, router.Ourself.UID, logger)
gossip := router.NewGossip(channel, peer)
peer.Register(gossip)
// Start the router and join the mesh.
// Note that we don't ever stop the router.
// This may or may not be a problem.
// TODO(pb): determine if this is a super huge problem
router.Start()
return NewServer(router, peer, minPeerCount, terminatec, terminatedc, logger)
}
func main() {
peers := &stringset{}
var (
apiListen = flag.String("api", ":8080", "API listen address")
meshListen = flag.String("mesh", net.JoinHostPort("0.0.0.0", strconv.Itoa(mesh.Port)), "mesh listen address")
hwaddr = flag.String("hwaddr", mustHardwareAddr(), "MAC address, i.e. mesh peer name")
nickname = flag.String("nickname", mustHostname(), "peer nickname")
password = flag.String("password", "", "password (optional)")
channel = flag.String("channel", "default", "gossip channel name")
quicktest = flag.Int("quicktest", 0, "set to integer 1-9 to enable quick test setup of node")
n = flag.Int("n", 3, "number of peers expected (lower bound)")
)
flag.Var(peers, "peer", "initial peer (may be repeated)")
flag.Parse()
if *quicktest >= 1 && *quicktest <= 9 {
*hwaddr = fmt.Sprintf("00:00:00:00:00:0%d", *quicktest)
*meshListen = fmt.Sprintf("0.0.0.0:600%d", *quicktest)
*apiListen = fmt.Sprintf("0.0.0.0:800%d", *quicktest)
*nickname = fmt.Sprintf("%d", *quicktest)
for i := 1; i <= 9; i++ {
peers.Set(fmt.Sprintf("127.0.0.1:600%d", i))
}
}
logger := log.New(os.Stderr, *nickname+"> ", log.LstdFlags)
host, portStr, err := net.SplitHostPort(*meshListen)
if err != nil {
logger.Fatalf("mesh address: %s: %v", *meshListen, err)
}
port, err := strconv.Atoi(portStr)
if err != nil {
logger.Fatalf("mesh address: %s: %v", *meshListen, err)
}
name, err := mesh.PeerNameFromString(*hwaddr)
if err != nil {
logger.Fatalf("%s: %v", *hwaddr, err)
}
ln, err := net.Listen("tcp", *apiListen)
if err != nil {
logger.Fatal(err)
}
logger.Printf("hello!")
defer logger.Printf("goodbye!")
// Create, but do not start, a router.
meshLogger := log.New(ioutil.Discard, "", 0) // no log from mesh please
router := mesh.NewRouter(mesh.Config{
Host: host,
Port: port,
ProtocolMinVersion: mesh.ProtocolMinVersion,
Password: []byte(*password),
ConnLimit: 64,
PeerDiscovery: true,
TrustedSubnets: []*net.IPNet{},
}, name, *nickname, mesh.NullOverlay{}, meshLogger)
// Create a meshconn.Peer.
peer := meshconn.NewPeer(name, router.Ourself.UID, logger)
gossip := router.NewGossip(*channel, peer)
peer.Register(gossip)
// Start the router and join the mesh.
func() {
logger.Printf("mesh router starting (%s)", *meshListen)
router.Start()
}()
defer func() {
logger.Printf("mesh router stopping")
router.Stop()
}()
router.ConnectionMaker.InitiateConnections(peers.slice(), true)
terminatec := make(chan struct{})
terminatedc := make(chan error)
go func() {
c := make(chan os.Signal)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
sig := <-c // receive interrupt
close(terminatec) // terminate metcd.Server
<-terminatedc // wait for shutdown
terminatedc <- fmt.Errorf("%s", sig) // forward signal
}()
go func() {
metcdServer := metcd.NewServer(router, peer, *n, terminatec, terminatedc, logger)
grpcServer := metcd.GRPCServer(metcdServer)
defer grpcServer.Stop()
logger.Printf("gRPC listening at %s", *apiListen)
terminatedc <- grpcServer.Serve(ln)
}()
logger.Print(<-terminatedc)
time.Sleep(time.Second) // TODO(pb): there must be a better way
}
