Minimal service functionality

Author: skillcoder

.gitignore

@@ -10,3 +10,7 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+/homer
+
+/glide.lock
+/vendor

.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+-   repo: git://github.com/dnephin/pre-commit-golang
+    sha: 471a7c123ea7a3b776ff018edf00066947873a94
+    hooks:
+    -   id: go-fmt
+    -   id: go-vet
+    -   id: go-lint

glide.yaml

@@ -0,0 +1,8 @@
+package: github.com/skillcoder/homer
+import:
+- package: github.com/sirupsen/logrus
+  version: ^1.0.6
+- package: github.com/eclipse/paho.mqtt.golang
+  version: ^1.1.1
+- package: github.com/kshvakov/clickhouse
+  version: ^1.3.4

handlers.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+
+    "github.com/skillcoder/homer/version"
+	"github.com/takama/router"
+)
+
+// home returns the path of current request
+func home(c *router.Control) {
+	fmt.Fprintf(c.Writer, "Repo: %s, Commit: %s, Version: %s", version.REPO, version.COMMIT, version.RELEASE)
+}
+
+// logger provides a log of requests
+func logger(c *router.Control) {
+	remoteAddr := c.Request.Header.Get("X-Forwarded-For")
+	if remoteAddr == "" {
+		remoteAddr = c.Request.RemoteAddr
+	}
+	log.Infof("%s %s %s", remoteAddr, c.Request.Method, c.Request.URL.Path)
+}

main.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+	"net/http"
+	"fmt"
+//	"log"
+	"os"
+//	"time"
+	"github.com/sirupsen/logrus"
+	"github.com/takama/router"
+	MQTT "github.com/eclipse/paho.mqtt.golang"
+//	"github.com/skillcoder/homer/version"
+	"github.com/skillcoder/homer/shutdown"
+)
+
+var log = logrus.New()
+
+//define a function for the default message handler
+var mqttMessageHandler MQTT.MessageHandler = func(client MQTT.Client, msg MQTT.Message) {
+  fmt.Printf("TOPIC: %s\n", msg.Topic())
+  fmt.Printf("MSG: %s\n", msg.Payload())
+}
+
+// Run server: go build; env SERVICE_PORT=8000 step-by-step
+// Try requests: curl http://127.0.0.1:8000/test
+func main() {
+  http_listen := os.Getenv("SERVICE_LISTEN")
+  if len(http_listen) == 0 {
+	  log.Fatal("Required env parameter SERVICE_LISTEN [ip:port] is not set")
+  }
+
+  mqtt_server := os.Getenv("MQTT_SERVER")
+  if len(mqtt_server) == 0 {
+	  log.Fatal("Required env parameter MQTT_SERVER [ip:port] is not set")
+  }
+
+  //create a ClientOptions struct setting the broker address, clientid, turn
+  //off trace output and set the default message handler
+  opts := MQTT.NewClientOptions().AddBroker("tcp://"+mqtt_server)
+  opts.SetClientID("go-homer-server")
+  opts.SetDefaultPublishHandler(mqttMessageHandler)
+
+  //create and start a client using the above ClientOptions
+  mqttClient := MQTT.NewClient(opts)
+  if token := mqttClient.Connect(); token.Wait() && token.Error() != nil {
+    panic(token.Error())
+  }
+
+  //subscribe to the topic /go-mqtt/sample and request messages to be delivered
+  //at a maximum qos of zero, wait for the receipt to confirm the subscription
+  if token := mqttClient.Subscribe("/esp/init", 0, nil); token.Wait() && token.Error() != nil {
+    fmt.Println(token.Error())
+    os.Exit(1)
+  }
+
+  //Publish 5 messages to /go-mqtt/sample at qos 1 and wait for the receipt
+  //from the server after sending each message
+  /*
+  for i := 0; i < 5; i++ {
+    text := fmt.Sprintf("this is msg #%d!", i)
+    token := mqttClient.Publish("go-mqtt/sample", 0, false, text)
+    token.Wait()
+  }
+
+  time.Sleep(3 * time.Second)
+  */
+
+  //unsubscribe from /go-mqtt/sample
+  /*
+  if token := mqttClient.Unsubscribe("go-mqtt/sample"); token.Wait() && token.Error() != nil {
+    fmt.Println(token.Error())
+    os.Exit(1)
+  }
+  */
+  //mqttClient.Disconnect(250)
+
+  r := router.New()
+  r.Logger = logger
+  r.GET("/", home)
+
+  // Readiness and liveness probes for Kubernetes
+  r.GET("/info", func(c *router.Control) {
+	  //common_handlers.Info(c, version.RELEASE, version.REPO, version.COMMIT)
+  })
+  r.GET("/healthz", func(c *router.Control) {
+	  c.Code(http.StatusOK).Body(http.StatusText(http.StatusOK))
+  })
+
+  go r.Listen(http_listen)
+
+  logger := log.WithField("event", "shutdown")
+  sdHandler := shutdown.NewHandler(logger)
+  sdHandler.RegisterShutdown(sd)
+}
+
+// sd does graceful dhutdown of the service
+func sd() (string, error) {
+	// if service has to finish some tasks before shutting down, these tasks must be finished her
+	return "Ok", nil
+}

shutdown/shutdown.go

@@ -0,0 +1,60 @@
+package shutdown
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/sirupsen/logrus"
+)
+
+// Callback is a function to provide service shutdown.
+// This function should return status of shutdown and error in case of problems.
+type Callback func() (status string, err error)
+
+// Handler handles shutting process
+type Handler struct {
+	logger          logrus.FieldLogger
+	shutdownSignals []os.Signal
+}
+
+// NewHandler creates an instance of Handler
+func NewHandler(logger logrus.FieldLogger) *Handler {
+	return &Handler{
+		logger:          logger,
+		shutdownSignals: []os.Signal{os.Interrupt, os.Kill, syscall.SIGTERM},
+	}
+}
+
+// RegisterShutdown set up a channel where we can send signal notifications and listen for the signal.
+// We must use a buffered channel, or risk missing the signal
+// if we're not ready to receive it when the signal is sent.
+// We strongly recommend to use this function once.
+// ToDo: how do we want to process case if user register few different shutdowns?
+func (h *Handler) RegisterShutdown(shutdown Callback) {
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, h.shutdownSignals...)
+
+	killSignal := <-interrupt
+	h.logger.Infof("Got signal: %+v", killSignal)
+
+	// ToDo: interrupt shutdown function if it takes too much time
+	status, err := shutdown()
+	if err != nil {
+		h.logger.Fatalf("Error during shutdown: %s Status: %s\n", err.Error(), status)
+		os.Exit(-1)
+	}
+
+	if killSignal == os.Kill {
+		h.logger.Infof("Service was killed with status: %s", status)
+	} else {
+		h.logger.Infof("Service was terminated by system signal with status: %s", status)
+	}
+	os.Exit(0)
+}
+
+// AddShutdownSignal adds a user-defined signals to shutdown.
+// It might be helpful for testing.
+func (h *Handler) AddShutdownSignal(sig os.Signal) {
+	h.shutdownSignals = append(h.shutdownSignals, sig)
+}

version/version.go

@@ -0,0 +1,10 @@
+package version
+
+var (
+	// RELEASE returns the release version
+	RELEASE = "UNKNOWN"
+	// REPO returns the git repository URL
+	REPO = "UNKNOWN"
+	// COMMIT returns the short sha from git
+	COMMIT = "UNKNOWN"
+)