init

internal/ginserver/logger.go

@@ -0,0 +1,71 @@
+package ginserver
+
+import (
+	"github.com/kratisto/mam-contract/internal/utils"
+	"math/rand"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	letterBytes   = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	letterIdxBits = 6                    // 6 bits to represent a letter index
+	letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
+	letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
+)
+
+var src = rand.NewSource(time.Now().UnixNano())
+
+func randStringBytesMaskImprSrc(n int) string {
+	b := make([]byte, n)
+	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
+	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
+		if remain == 0 {
+			cache, remain = src.Int63(), letterIdxMax
+		}
+		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
+			b[i] = letterBytes[idx]
+			i--
+		}
+		cache >>= letterIdxBits
+		remain--
+	}
+
+	return string(b)
+}
+
+func GetLoggerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		correlationID := c.Request.Header.Get(utils.HeaderNameCorrelationID)
+		if correlationID == "" {
+			correlationID = randStringBytesMaskImprSrc(30)
+			c.Writer.Header().Set(utils.HeaderNameCorrelationID, correlationID)
+		}
+
+		logger := utils.GetLogger()
+		logEntry := logger.WithField(utils.HeaderNameCorrelationID, correlationID)
+
+		c.Set(utils.ContextKeyLogger, logEntry)
+	}
+}
+
+func GetHTTPLoggerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+
+		utils.GetLoggerFromCtx(c).
+			WithField("method", c.Request.Method).
+			WithField("url", c.Request.RequestURI).
+			WithField("from", c.ClientIP()).
+			Info("start handling HTTP request")
+
+		c.Next()
+		d := time.Since(start)
+
+		utils.GetLoggerFromCtx(c).
+			WithField("status", c.Writer.Status()).
+			WithField("duration", d.String()).
+			Info("end handling HTTP request")
+	}
+}

internal/ginserver/oauth_token.go

@@ -0,0 +1,40 @@
+package ginserver
+
+import (
+	"fmt"
+	"github.com/kratisto/mam-contract/internal/storage/model"
+	"github.com/kratisto/mam-contract/internal/utils"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"google.golang.org/api/oauth2/v1"
+)
+
+func ValidateOAuthToken(c *gin.Context) {
+	authorizationHeader := c.GetHeader("Authorization")
+	authorizationHeaderSplitted := strings.Split(authorizationHeader, " ")
+	if len(authorizationHeaderSplitted) != 2 {
+		utils.JSONError(c.Writer, model.ErrBadRequestFormat)
+		c.Abort()
+		return
+	}
+
+	oauth2Service, err := oauth2.New(&http.Client{})
+	if oauth2Service == nil {
+		fmt.Println(err)
+		utils.JSONError(c.Writer, model.ErrInternalServer)
+		c.Abort()
+		return
+	}
+	tokenInfoCall := oauth2Service.Tokeninfo()
+	tokenInfoCall.IdToken(authorizationHeaderSplitted[1])
+	token, err := tokenInfoCall.Do()
+	if err != nil {
+		utils.GetLogger().WithError(err).Error(err)
+		utils.JSONError(c.Writer, model.ErrBadRequestFormat)
+		c.Abort()
+		return
+	}
+	c.Set("googleUserId", token.UserId)
+}

internal/ginserver/setup.go

@@ -0,0 +1,45 @@
+package ginserver
+
+import (
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"github.com/kratisto/mam-contract/configuration"
+	"github.com/kratisto/mam-contract/internal/utils"
+	"time"
+)
+
+var (
+	routerInjectorKey = "ROUTER"
+
+	SecuredRouterInjectorKey   = "SECURED_ROUTER"
+	UnsecuredRouterInjectorKey = "UNSECURED_ROUTER"
+)
+
+func Setup(injector *utils.Injector, config *configuration.Config) {
+
+	gin.SetMode(gin.ReleaseMode)
+
+	router := gin.New()
+	router.HandleMethodNotAllowed = true
+
+	router.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"http://localhost:8080/", "http://localhost:8080", "http://localhost:19006"},
+		AllowMethods:     []string{"*"},
+		AllowHeaders:     []string{"*"},
+		ExposeHeaders:    []string{"*"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+	router.Use(gin.Recovery())
+	router.Use(GetLoggerMiddleware())
+	router.Use(GetHTTPLoggerMiddleware())
+	public := router.Group("/")
+	injector.Set(UnsecuredRouterInjectorKey, public)
+
+	securedUserRoute := public.Group("/users")
+	securedUserRoute.Use(ValidateOAuthToken)
+
+	injector.Set(SecuredRouterInjectorKey, securedUserRoute)
+	injector.Set(routerInjectorKey, router)
+
+}

internal/ginserver/start.go

@@ -0,0 +1,38 @@
+package ginserver
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/kratisto/mam-contract/internal/utils"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func Start(injector *utils.Injector) {
+	router := utils.Get[*gin.Engine](injector, routerInjectorKey)
+
+	srv := &http.Server{
+		Addr:    ":8080",
+		Handler: router,
+	}
+
+	go func() {
+		// service connections
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("listen: %s\n", err)
+		}
+	}()
+
+	// Wait for interrupt signal to gracefully shutdown the server with
+	// a timeout of 5 seconds.
+	quit := make(chan os.Signal)
+	// kill (no param) default send syscanll.SIGTERM
+	// kill -2 is syscall.SIGINT
+	// kill -9 is syscall. SIGKILL but can"t be catch, so don't need add it
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+	log.Println("Shutdown Server ...")
+
+}