Inital Commit

src/cmd/main.go

@@ -0,0 +1,91 @@
+
+package main
+
+import (
+	"fmt"
+	"strings"
+	log "github.com/inconshreveable/log15"
+	"github.com/pborman/getopt/v2"
+	"github.com/onrik/ethrpc"
+	"internal/haproxy"
+	"internal/tcp_server"
+)
+
+var logger log.Logger
+
+func onConnect(c *tcp_server.Client) {
+	logger.Info("Client connected", "addr", c.Addr.String())
+}
+
+func onTcpMessage(c *tcp_server.Client, message string) {
+
+	status := haproxy.HealthCheckDown
+	client := ethrpc.New(strings.TrimSpace(message))
+
+	resp, err := client.EthSyncing()
+	if err == nil {
+		if resp.IsSyncing == false {
+			status = haproxy.HealthCheckUp
+		}
+	} else {
+		logger.Warn(err.Error())
+	}
+
+	logger.Info("Node status", "status", status)
+
+	// Report status to HAproxy
+	c.WriteString(fmt.Sprintln(status))
+	c.Close()
+}
+
+func onDisconnect(c *tcp_server.Client, err error) {
+	if err == nil {
+		logger.Info("Client disconnected", "addr", c.Addr.String())
+	} else {
+		logger.Warn("Client disconnected", "addr", c.Addr.String(), "err", err)
+	}
+}
+
+func argv_listen_addr() string {
+
+	var addr string
+
+	argv := getopt.Args()
+	if len(argv) > 0 {
+		addr = argv[0]
+	} else {
+		addr = "127.0.0.1"
+	}
+
+	addr += ":"
+	if len(argv) > 1 {
+		addr += argv[1]
+	} else {
+		addr += "1301"
+	}
+
+	return addr
+}
+
+func main() {
+
+	logger = log.New()
+
+	getopt.Parse()
+
+	addr := argv_listen_addr()
+	server := tcp_server.New(argv_listen_addr())
+
+	logger.Info(fmt.Sprintf("Listening on: %s", addr))
+
+	// TCP Client sends message.
+	server.OnConnect(onConnect)
+	server.OnMessage(onTcpMessage)
+	server.OnDisconnect(onDisconnect)
+
+	err := server.Listen()
+
+	if err != nil {
+		logger.Error(err.Error())
+	}
+}

src/haproxy/go.mod

@@ -0,0 +1,3 @@
+module internal/haproxy
+
+go 1.14

src/haproxy/types.go

@@ -0,0 +1,15 @@
+
+package haproxy
+
+// All supported health check values for HAproxy.
+// See https://cbonte.github.io/haproxy-dconv/1.7/configuration.html#5.2-agent-check
+type HealthCheckStatus string
+const (
+	HealthCheckUp 		= "up"
+	HealthCheckDown 	= "down"
+	HealthCheckMaint 	= "maint"
+	HealthCheckReady	= "ready"
+	HealthCheckDrain	= "drain"
+	HealthCheckFailed 	= "failed"
+	HealthCheckStopped 	= "Stopped"
+)

src/tcp_server/client.go

@@ -0,0 +1,44 @@
+
+package tcp_server
+
+import (
+	"bufio"
+	"net"
+)
+
+// Read client messages.
+func (c *Client) read() {
+	reader := bufio.NewReader(c.conn)
+	for {
+		message, err := reader.ReadString('\n')
+		if err != nil {
+			c.conn.Close()
+			c.Server.onDisconnect(c, err)
+			return
+		}
+		c.Server.onMessage(c, message)
+	}
+}
+
+// Write string to client.
+func (c *Client) WriteString(message string) error {
+	return c.Write([]byte(message))
+}
+
+// Write bytes to client
+func (c *Client) Write(b []byte) error {
+	_, err := c.conn.Write(b)
+	if err != nil {
+		c.conn.Close()
+		c.Server.onDisconnect(c, err)
+	}
+	return err
+}
+
+func (c *Client) Conn() net.Conn {
+	return c.conn
+}
+
+func (c *Client) Close() error {
+	return c.conn.Close()
+}

src/tcp_server/go.mod

@@ -0,0 +1,3 @@
+module internal/tcp_server
+
+go 1.14

src/tcp_server/server.go

@@ -0,0 +1,56 @@
+
+package tcp_server
+
+import (
+	"net"
+)
+
+func New(address string) *server {
+
+	server := &server{
+		address: address,
+	}
+
+	server.OnConnect(func(c *Client) {})
+	server.OnMessage(func(c *Client, message string) {})
+	server.OnDisconnect(func(c *Client, err error) {})
+
+	return server
+}
+
+// Called when a client connects
+func (s *server) OnConnect(callback func(c *Client)) {
+	s.onConnect = callback
+}
+
+// Called the server gets a message from a client.
+func (s *server) OnMessage(callback func(c *Client, message string)) {
+	s.onMessage = callback
+}
+
+// Called when a connection is closed.
+func (s *server) OnDisconnect(callback func(c *Client, err error)) {
+	s.onDisconnect = callback
+}
+
+func (s *server) Listen() error {
+
+	sock, err := net.Listen("tcp", s.address)
+	if err != nil {
+		return err
+	}
+	defer sock.Close()
+
+	for {
+		conn, _ := sock.Accept()
+		c := &Client{
+			conn:   conn,
+			Server: s,
+			Addr: conn.RemoteAddr(),
+		}
+		s.onConnect(c)
+		go c.read()
+	}
+
+	return nil
+}

src/tcp_server/types.go

@@ -0,0 +1,19 @@
+
+package tcp_server
+
+import (
+	"net"
+)
+
+type Client struct {
+	conn   net.Conn
+	Addr   net.Addr
+	Server *server
+}
+
+type server struct {
+	address 		string
+	onConnect		func(c *Client)
+	onDisconnect	func(c *Client, err error)
+	onMessage		func(c *Client, message string)
+}