Add Golang version + minor fixes to Java version

Author: mateuszdyminski

.gitignore

@@ -2,3 +2,7 @@ target
 .idea
 *.iml
 main
+~$*
+.classpath
+.project
+.settings

README.md

@@ -24,14 +24,16 @@ minikube start
 
 Install MySQL(with Helm):
 ```
-helm install stable/mysql
+helm install --set mysqlRootPassword=password --name mysql stable/mysql
+kubectl get service mysql-mysql -o yaml | sed 's/type: ClusterIP/type: NodePort/g' | kubectl replace -f -
 ```
 
 Create db:
 ```
-mysql/mysql.sh create
+cd mysql && ./mysql.sh create
 ```
 
+#### Users Service - Java
 Run Users Service in Kubernetes:
 ```
 kubectl apply -f kube/java/01_users_srv.yaml
@@ -42,6 +44,17 @@ Run Users Deployment in Kubernetes:
 kubectl apply -f kube/java/02_deployment.yaml
 ```
 
+#### Users Service - Golang
+Run Users Service in Kubernetes:
+```
+kubectl apply -f kube/golang/01_users_srv.yaml
+```
+
+Run Users Deployment in Kubernetes:
+```
+kubectl apply -f kube/golang/02_deployment.yaml
+```
+
 Verification:
 
 Open:

golang/Dockerfile

@@ -8,4 +8,4 @@ ADD $TYPE/main /usr/share/zero/main
 
 EXPOSE 8080
 
-ENTRYPOINT /usr/share/zero/main
+ENTRYPOINT [ "/usr/share/zero/main", "-port=8080", "-db-user=root", "-db-pass=password", "-db-host=mysql-mysql:3306", "-db-name=users" ]

golang/all.sh

@@ -2,5 +2,7 @@
 
 ./dev.sh build simple v1
 ./dev.sh docker simple v1
-./dev.sh build simple v2
-./dev.sh docker simple v2
+./dev.sh build graceful v2
+./dev.sh docker graceful v2
+./dev.sh build simple v3
+./dev.sh docker simple v3

golang/dev.sh

@@ -34,7 +34,7 @@ case "$CMD" in
 		cd $TYPE; CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$LDFLAGS" -o main -a -tags netgo .
 	;;
 	docker)
-		docker build --build-arg TYPE=$TYPE -t "mateuszdyminski/zero-$TYPE:$VERSION" . && docker push "mateuszdyminski/zero-$TYPE:$VERSION"
+		docker build --build-arg TYPE=$TYPE -t "mateuszdyminski/zero-golang:$VERSION" . && docker push "mateuszdyminski/zero-golang:$VERSION"
 	;;
 	*)
 		usage

golang/graceful/main.go

@@ -7,8 +7,10 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"syscall"
 	"time"
 
+	_ "github.com/go-sql-driver/mysql"
 	"github.com/gorilla/mux"
 	"github.com/mateuszdyminski/zero/golang"
 	"github.com/prometheus/client_golang/prometheus"
@@ -17,6 +19,10 @@ import (
 
 // Flags
 var port = flag.String("port", "8080", "HTTP port number")
+var dbHost = flag.String("db-host", "mysql-mysql:3306", "Mysql database host with port")
+var dbUser = flag.String("db-user", "root", "Mysql database user")
+var dbPass = flag.String("db-pass", "password", "Mysql database password")
+var dbName = flag.String("db-name", "users", "Mysql database name")
 
 // Variables injected by -X flag
 var appVersion = "unknown"
@@ -27,35 +33,30 @@ var lastCommitUser = "unknown"
 var buildTime = "unknown"
 
 // Timeout is the duration to allow outstanding requests to survive before forcefully terminating them.
-const Timeout = 10
+const Timeout = 20
 
 func main() {
 	flag.Parse()
 
-	// subscribe to SIGINT signals
-	quit := make(chan os.Signal)
-	signal.Notify(quit, os.Interrupt, os.Kill)
-
-	// configure http handlers
-	flag.Parse()
-
 	router := mux.NewRouter()
 
-	rest, err := golang.NewUserRest(buildInfo())
+	rest, err := golang.NewUserRest(buildInfo(), dbInfo())
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	router.HandleFunc("/api/users", rest.Users).Methods("GET")
 	router.HandleFunc("/api/users", rest.AddUser).Methods("POST")
 	router.HandleFunc("/api/users/{id}", rest.GetUser).Methods("GET")
-	router.HandleFunc("/api/health", rest.Health).Methods("GET")
+	router.HandleFunc("/health", rest.Health).Methods("GET")
 	router.HandleFunc("/api/error", rest.Err).Methods("POST")
 	router.Handle("/metrics", promhttp.HandlerFor(
 		prometheus.DefaultGatherer,
 		promhttp.HandlerOpts{},
 	))
 
+	log.Println("starting http server with graceful shutdown mode!")
+
 	// create and start http server in new goroutine
 	srv := &http.Server{Addr: ":" + *port, Handler: golang.NewLogginHandler(router)}
 	go func() {
@@ -65,18 +66,25 @@ func main() {
 		}
 	}()
 
-	// blocks the execution until os.Interrupt or os.Kill signal appears
-	<-quit
+	// subscribe to SIGTERM signals
+	quit := make(chan os.Signal)
+	signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
 
+	// blocks the execution until os.Interrupt or syscall.SIGTERM signal appears
+	<-quit
 	log.Println("shutting down server. waiting to drain the ongoing requests...")
+	rest.Unhealthy()
+
+	// add extra time to prevent new requests be routed to our service
+	time.Sleep(5 * time.Second)
 
 	// shut down gracefully, but wait no longer than the Timeout value.
 	ctx, cancelF := context.WithTimeout(context.Background(), Timeout*time.Second)
 	defer cancelF()
 
 	// shutdown the http server
 	if err := srv.Shutdown(ctx); err != nil {
-		log.Fatalf("error while shutdown http server: %v\n", err)
+		log.Printf("error while shutdown http server: %v\n", err)
 	}
 
 	log.Println("server gracefully stopped")
@@ -89,8 +97,17 @@ func buildInfo() golang.BuildInfo {
 		BuildTime:  buildTime,
 		LastCommit: golang.Commit{
 			Author: lastCommitUser,
-			Id:     lastCommitHash,
+			ID:     lastCommitHash,
 			Time:   lastCommitTime,
 		},
 	}
 }
+
+func dbInfo() golang.DBInfo {
+	return golang.DBInfo{
+		Name:     *dbName,
+		Host:     *dbHost,
+		User:     *dbUser,
+		Password: *dbPass,
+	}
+}

golang/http.go

@@ -11,6 +11,7 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+// WriteJSON writes JSON response struct to ResponseWriter.
 func WriteJSON(w http.ResponseWriter, response interface{}) error {
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	json, err := json.Marshal(response)
@@ -25,6 +26,7 @@ func WriteJSON(w http.ResponseWriter, response interface{}) error {
 	return nil
 }
 
+// WriteErr writes error to ResponseWriter.
 func WriteErr(w http.ResponseWriter, err error, httpCode int) {
 	logrus.Error(err.Error())
 
@@ -36,10 +38,14 @@ func WriteErr(w http.ResponseWriter, err error, httpCode int) {
 		"error":      err.Error(),
 	}
 
-	errJson, _ := json.Marshal(errMap)
-	logrus.Error(string(errJson))
+	errJSON, err := json.Marshal(errMap)
+	if err != nil {
+		logrus.Errorf("can't marshal error response. err: %s", err)
+	}
+
+	logrus.Error(string(errJSON))
 	w.WriteHeader(httpCode)
-	w.Write(errJson)
+	w.Write(errJSON)
 }
 
 // callStats holds various stats associated with HTTP request-response pair.
@@ -156,13 +162,13 @@ func getRemoteAddr(r *http.Request) string {
 }
 
 // Describe implements prometheus.Collector interface.
-func (d LoggingHandler) Describe(in chan<- *prometheus.Desc) {
-	d.duration.Describe(in)
-	d.requests.Describe(in)
+func (h LoggingHandler) Describe(in chan<- *prometheus.Desc) {
+	h.duration.Describe(in)
+	h.requests.Describe(in)
 }
 
 // Collect implements prometheus.Collector interface.
-func (d LoggingHandler) Collect(in chan<- prometheus.Metric) {
-	d.duration.Collect(in)
-	d.requests.Collect(in)
+func (h LoggingHandler) Collect(in chan<- prometheus.Metric) {
+	h.duration.Collect(in)
+	h.requests.Collect(in)
 }

golang/rest.go

@@ -4,26 +4,30 @@ import (
 	"database/sql"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 	"os"
 	"sync"
 	"time"
 
-	_ "github.com/go-sql-driver/mysql"
 	"github.com/gorilla/mux"
 )
 
+// UserRest is REST controller used to handler request about the user entities.
 type UserRest struct {
 	wg        sync.WaitGroup
 	buildInfo BuildInfo
 	hostname  string
 	startedAt time.Time
 	db        *sql.DB
+	mu        sync.Mutex
+	healthy   bool
 }
 
-func NewUserRest(buildInfo BuildInfo) (*UserRest, error) {
-	db, err := sql.Open("mysql", "root:7J52xZ0B9V@tcp(mysql-mysql:3306)/users?charset=utf8&parseTime=true")
+// NewUserRest constructs new UserRest controller used to handler request about the user entities.
+func NewUserRest(buildInfo BuildInfo, dbInfo DBInfo) (*UserRest, error) {
+	db, err := sql.Open("mysql", dbInfo.ConnectionString())
 	if err != nil {
 		return nil, err
 	}
@@ -38,9 +42,18 @@ func NewUserRest(buildInfo BuildInfo) (*UserRest, error) {
 		buildInfo: buildInfo,
 		hostname:  host,
 		startedAt: time.Now().UTC(),
+		healthy:   true,
 	}, nil
 }
 
+// Unhealthy sets server health to false - used in gracefull shutdown mode
+func (r *UserRest) Unhealthy() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.healthy = false
+}
+
+// Users handler responds with list of all users in system.
 func (r *UserRest) Users(w http.ResponseWriter, req *http.Request) {
 	rows, err := r.db.Query("SELECT * FROM users")
 	if err != nil {
@@ -71,6 +84,7 @@ func (r *UserRest) Users(w http.ResponseWriter, req *http.Request) {
 	WriteJSON(w, users)
 }
 
+// GetUser handler responds with particular user based on the id of the user.
 func (r *UserRest) GetUser(w http.ResponseWriter, req *http.Request) {
 	id := mux.Vars(req)["id"]
 	if id == "" {
@@ -99,6 +113,7 @@ func (r *UserRest) GetUser(w http.ResponseWriter, req *http.Request) {
 	WriteJSON(w, user)
 }
 
+// AddUser handler is responsible for adding new user to system.
 func (r *UserRest) AddUser(w http.ResponseWriter, req *http.Request) {
 	var user User
 	err := json.NewDecoder(req.Body).Decode(&user)
@@ -114,17 +129,26 @@ func (r *UserRest) AddUser(w http.ResponseWriter, req *http.Request) {
 	}
 }
 
+// Health handler is responsible for serving resonse with current health status of service. Healthz concept is used to leverage the regular health status pattern.
 func (r *UserRest) Health(w http.ResponseWriter, req *http.Request) {
-	resp := HealthStatus{
-		Hostname:  r.hostname,
-		StartedAt: r.startedAt.Format("2006-01-02_15:04:05"),
-		Uptime:    time.Now().UTC().Sub(r.startedAt).String(),
-		Build:     r.buildInfo,
-	}
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if r.healthy {
+		resp := HealthStatus{
+			Hostname:  r.hostname,
+			StartedAt: r.startedAt.Format("2006-01-02_15:04:05"),
+			Uptime:    time.Now().UTC().Sub(r.startedAt).String(),
+			Build:     r.buildInfo,
+		}
 
-	WriteJSON(w, resp)
+		WriteJSON(w, resp)
+	} else {
+		WriteErr(w, fmt.Errorf("Server in graceful  shutdown mode"), http.StatusInternalServerError)
+	}
 }
 
+// Err handler is dummy simulator of error which occurs in out service.
 func (r *UserRest) Err(w http.ResponseWriter, req *http.Request) {
 	bytes, err := ioutil.ReadAll(req.Body)
 	if err != nil {
@@ -135,29 +159,46 @@ func (r *UserRest) Err(w http.ResponseWriter, req *http.Request) {
 	WriteErr(w, errors.New(string(bytes)), http.StatusInternalServerError)
 }
 
+// User holds basic info about the User entity.
 type User struct {
 	ID         int       `json:"id"`
 	FirstName  string    `json:"firstName"`
 	SecondName string    `json:"secondName"`
 	BirthDate  time.Time `json:"birthDate"`
 }
 
+// HealthStatus holds basic info about the Health status of the application.
 type HealthStatus struct {
 	Build     BuildInfo `json:"buildInfo"`
 	Hostname  string    `json:"hostname"`
 	Uptime    string    `json:"uptime"`
 	StartedAt string    `json:"startedAt"`
 }
 
+// BuildInfo holds basic info about the build based on the git statistics.
 type BuildInfo struct {
 	Version    string `json:"version"`
 	GitVersion string `json:"gitVersion"`
 	BuildTime  string `json:"buildTime"`
 	LastCommit Commit `json:"lastCommit"`
 }
 
+// Commit holds info about the git commit.
 type Commit struct {
-	Id     string `json:"id"`
+	ID     string `json:"id"`
 	Time   string `json:"time"`
 	Author string `json:"author"`
 }
+
+// DBInfo holds configuration how to access to database.
+type DBInfo struct {
+	User     string `json:"user"`
+	Password string `json:"password"`
+	Host     string `json:"host"`
+	Name     string `json:"name"`
+}
+
+// ConnectionString returns connection string based on the DBInfo configuration.
+func (db *DBInfo) ConnectionString() string {
+	return fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=true", db.User, db.Password, db.Host, db.Name)
+}