Initialize project

Author: hiraq

.gitignore

@@ -12,3 +12,4 @@
 
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
+vendor/

glide.lock

@@ -0,0 +1,6 @@
+package: base-golang-api
+import:
+- package: github.com/gorilla/mux
+  version: v1.6.1
+- package: github.com/gorilla/handlers
+  version: v1.3.0

glide.yaml

@@ -0,0 +1,7 @@
+package handler
+
+import "net/http"
+
+func HelloPanic(w http.ResponseWriter, r *http.Request) {
+	panic("hello panic!")
+}

handler/hello-panic.go

@@ -0,0 +1,11 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func HelloPost(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintf(w, "hello world via post")
+}

handler/hello-post.go

@@ -0,0 +1,11 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func HelloWorld(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintf(w, "hello world")
+}

handler/hello.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+)
+
+// Logger used to construct logger proccess
+type Logger struct {
+	IsDebug bool
+}
+
+// Info used to log all INFO's messages
+func (l *Logger) Info(msg ...interface{}) {
+	logger, buf := createNew()
+
+	msglog := fmt.Sprintf("INFO: %s", msg)
+	logger.Print(msglog)
+	fmt.Println(buf)
+}
+
+// Error used to catch any error messages
+func (l *Logger) Error(msg ...interface{}) {
+	logger, buf := createNew()
+
+	msglog := fmt.Sprintf("Error: %s", msg)
+	logger.Print(msglog)
+	fmt.Println(buf)
+}
+
+// Debug used to log all DEBUG's message.
+// This method should be active only if current process
+// started with -debug (true).
+func (l *Logger) Debug(msg ...interface{}) {
+	if l.IsDebug {
+		logger, buf := createNew()
+
+		msglog := fmt.Sprintf("DEBUG: %s", msg)
+		logger.Print(msglog)
+		fmt.Println(buf)
+	}
+}
+
+func logBuilder(isDebug bool) *Logger {
+	builder := new(Logger)
+	builder.IsDebug = isDebug
+	return builder
+}
+
+func createNew() (*log.Logger, *bytes.Buffer) {
+	var buf bytes.Buffer
+	logger := log.New(&buf, "Log: ", log.Ldate|log.Ltime|log.LUTC)
+	return logger, &buf
+}

logger.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/gorilla/handlers"
+	"github.com/gorilla/mux"
+)
+
+var (
+	logger              *Logger
+	isDebug             bool
+	enablePrintRecovery bool
+	address             string
+	timeout             int
+)
+
+const (
+	isDebugDefault                  = false
+	isDebugUsage                    = "Enable debug mode"
+	enablePrintRecoveryStackDefault = false
+	enablePrintRecoveryUsage        = "Used to print all stack traces when panic happened"
+	addressDefault                  = "127.0.0.1:8080"
+	addressUsage                    = "Setup your running ip & port"
+	timeoutDefault                  = 15
+	timeoutUsage                    = "Set your write and timeout limit"
+)
+
+func init() {
+	flag.StringVar(&address, "address", addressDefault, addressUsage)
+	flag.BoolVar(&isDebug, "debug", isDebugDefault, isDebugUsage)
+	flag.BoolVar(&enablePrintRecovery, "enablePrintStack", enablePrintRecoveryStackDefault, enablePrintRecoveryUsage)
+	flag.IntVar(&timeout, "timeout", timeoutDefault, timeoutUsage)
+	flag.Parse()
+
+	logger = logBuilder(isDebug)
+	logger.Debug(fmt.Sprintf("Enable Print Recovery? %t", enablePrintRecovery))
+	logger.Debug(fmt.Sprintf("Timeout: %v", timeout))
+	logger.Info(fmt.Sprintf("Address: %v", address))
+}
+
+func main() {
+	r := mux.NewRouter()
+
+	// register routes and their controllers
+	routers := RegisterRoutes(r)
+
+	// register middlewares
+	routers.Use(AccessLogMiddleware)
+	routers.Use(ContentNegotiatorMiddleware)
+	routers.Use(handlers.RecoveryHandler(handlers.PrintRecoveryStack(enablePrintRecovery)))
+
+	srv := &http.Server{
+		Handler:      routers,
+		Addr:         address,
+		WriteTimeout: time.Duration(timeout) * time.Second,
+		ReadTimeout:  time.Duration(timeout) * time.Second,
+	}
+
+	log.Fatal(srv.ListenAndServe())
+}

main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"net/http"
+	"os"
+
+	"github.com/gorilla/handlers"
+)
+
+var (
+	contentTypes = []string{
+		"application/json",
+		"application/vnd.api+json",
+	}
+)
+
+func AccessLogMiddleware(next http.Handler) http.Handler {
+	loggedMiddleware := handlers.LoggingHandler(os.Stdout, next)
+	return loggedMiddleware
+}
+
+func ContentNegotiatorMiddleware(next http.Handler) http.Handler {
+	contentTypeNegotiatorMiddleware := handlers.ContentTypeHandler(next, contentTypes...)
+	return contentTypeNegotiatorMiddleware
+}

middlewares.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	controller "base-golang-api/handler"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+// AppHandler used as http endpoint controller
+type AppHandler func(w http.ResponseWriter, r *http.Request)
+
+// Route used as a dictionary provide an information about
+// endpoint path and endpoint handler (AppHandler)
+type Route struct {
+	Method  string
+	Path    string
+	Handler AppHandler
+}
+
+var routes []Route
+
+func init() {
+	routes = append(routes, Route{"GET", "/hello", controller.HelloWorld})
+	routes = append(routes, Route{"GET", "/hello-panic", controller.HelloPanic})
+	routes = append(routes, Route{"POST", "/hello-post", controller.HelloPost})
+}
+
+// RegisterRoutes used to activate all configured routes register them to
+// gorilla/mux routers.
+func RegisterRoutes(r *mux.Router) *mux.Router {
+	if len(routes) >= 1 {
+		for _, route := range routes {
+			r.HandleFunc(route.Path, route.Handler).Methods(route.Method)
+		}
+	}
+
+	return r
+}