func initMesh(addr, hwaddr, nickname string) *mesh.Router {
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
log.Fatalf("mesh address: %s: %v", addr, err)
}
port, err := strconv.Atoi(portStr)
if err != nil {
log.Fatalf("mesh address: %s: %v", addr, err)
}
name, err := mesh.PeerNameFromString(hwaddr)
if err != nil {
log.Fatalf("invalid hardware address %q: %v", hwaddr, err)
}
return mesh.NewRouter(mesh.Config{
Host: host,
Port: port,
ProtocolMinVersion: mesh.ProtocolMinVersion,
Password: []byte(""),
ConnLimit: 64,
PeerDiscovery: true,
TrustedSubnets: []*net.IPNet{},
}, name, nickname, mesh.NullOverlay{}, stdlog.New(ioutil.Discard, "", 0))
}
func initMesh(addr, hwaddr, nickname, pw string) *mesh.Router {
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
log.Fatalf("mesh address: %s: %v", addr, err)
}
port, err := strconv.Atoi(portStr)
if err != nil {
log.Fatalf("mesh address: %s: %v", addr, err)
}
name, err := mesh.PeerNameFromString(hwaddr)
if err != nil {
log.Fatalf("invalid hardware address %q: %v", hwaddr, err)
}
password := []byte(pw)
if len(password) == 0 {
// Emtpy password is used to disable secure communication. Using a nil
// password disables encryption in mesh.
password = nil
}
return mesh.NewRouter(mesh.Config{
Host: host,
Port: port,
ProtocolMinVersion: mesh.ProtocolMinVersion,
Password: password,
ConnLimit: 64,
PeerDiscovery: true,
TrustedSubnets: []*net.IPNet{},
}, name, nickname, mesh.NullOverlay{}, stdlog.New(ioutil.Discard, "", 0))
}
func NewNetworkRouter(config mesh.Config, networkConfig NetworkConfig, name mesh.PeerName, nickName string, overlay NetworkOverlay) *NetworkRouter {
if overlay == nil {
overlay = NullNetworkOverlay{}
}
if networkConfig.Bridge == nil {
networkConfig.Bridge = NullBridge{}
}
router := &NetworkRouter{Router: mesh.NewRouter(config, name, nickName, overlay), NetworkConfig: networkConfig}
router.Peers.OnInvalidateShortIDs(overlay.InvalidateShortIDs)
router.Routes.OnChange(overlay.InvalidateRoutes)
router.Macs = NewMacCache(macMaxAge,
func(mac net.HardwareAddr, peer *mesh.Peer) {
log.Println("Expired MAC", mac, "at", peer)
})
router.Peers.OnGC(func(peer *mesh.Peer) { router.Macs.Delete(peer) })
return router
}
// 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 (
httpListen = flag.String("http", ":8080", "HTTP 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 ID")
nickname = flag.String("nickname", mustHostname(), "peer nickname")
password = flag.String("password", "", "password (optional)")
channel = flag.String("channel", "default", "gossip channel name")
)
flag.Var(peers, "peer", "initial peer (may be repeated)")
flag.Parse()
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)
}
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{}, log.New(ioutil.Discard, "", 0))
peer := newPeer(name, logger)
gossip := router.NewGossip(*channel, peer)
peer.register(gossip)
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)
errs := make(chan error)
go func() {
c := make(chan os.Signal)
signal.Notify(c, syscall.SIGINT)
errs <- fmt.Errorf("%s", <-c)
}()
go func() {
logger.Printf("HTTP server starting (%s)", *httpListen)
http.HandleFunc("/", handle(peer))
errs <- http.ListenAndServe(*httpListen, nil)
}()
logger.Print(<-errs)
}
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
}