cybertron/internal/transport/server.go

package transport

import (
	"cybertron/internal/transport/middleware"
	"cybertron/internal/transport/router"
	"cybertron/pkg/metrics"
	"fmt"
	"github.com/gin-contrib/cors"
	"os"
	"os/signal"
	"syscall"
	"time"

	"cybertron/configs"
	"cybertron/internal/dependencies"

	ginzap "github.com/gin-contrib/zap"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
)

type Server struct {
	gin          *gin.Engine
	dependencies *dependencies.Dependencies
}

func NewServer(dep *dependencies.Dependencies) *Server {
	return &Server{
		gin:          gin.New(),
		dependencies: dep,
	}
}

func (s *Server) router() {
	router.ReadinessRouter(s.gin)
	router.ProjectRouter(s.gin, s.dependencies)
	router.SourceMapRouter(s.gin, s.dependencies)
	router.ReleasesRouter(s.gin, s.dependencies)
	router.ExceptionRouter(s.gin, s.dependencies)
	router.SearchRouter(s.gin, s.dependencies)
}

func (s *Server) Start() {
	s.gin.Use(ginzap.Ginzap(s.dependencies.Logger, time.RFC3339, false))
	s.gin.Use(cors.New(cors.Config{
		AllowOrigins:     []string{"*"},
		AllowMethods:     []string{"PUT", "PATCH", "GET", "POST", "OPTIONS"},
		AllowHeaders:     []string{"*", "x-session-token"},
		ExposeHeaders:    []string{"Content-Length"},
		AllowCredentials: true,
		MaxAge:           24 * time.Hour,
	}))
	s.gin.Use(middleware.MetricMiddleware())
	//s.gin.Use(middleware.PermissionMiddleware(s.dependencies.Service.AuthService))
	s.router()
	metrics.AdminHandler()

	port := configs.GetPort()
	s.dependencies.Logger.Info("Starting server", zap.Int("port", port))

	err := s.gin.Run(fmt.Sprintf(":%v", port))
	if err != nil {
		s.dependencies.Logger.Fatal("error while starting the server", zap.Error(err))
	}
}

func (s *Server) Close() {
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	s.dependencies.Logger.Info("Shutdown server ...")
}