Move into api routers instead of main

services/entry/pkg/api/api.go

@@ -0,0 +1,58 @@
+package api
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"log"
+	"net/http"
+	"serverctl/pkg/api/routers"
+	"serverctl/pkg/infrastructure/dependencies"
+)
+
+// Used for profiling
+import _ "net/http/pprof"
+
+type ServerctlApi struct {
+	logger       *zap.Logger
+	router       *gin.Engine
+	routingTable *routers.RoutingTable
+	dependencies *dependencies.Dependencies
+}
+
+func NewServerctlApi(dependencies *dependencies.Dependencies) *ServerctlApi {
+	return &ServerctlApi{dependencies: dependencies}
+}
+
+func (a *ServerctlApi) SetupApi() *ServerctlApi {
+	a.dependencies.Logger.Info("Setting up serverctl setupApi (using gin)")
+	a.router = gin.Default()
+
+	a.setupCommonMiddleware().setupRoutingTable()
+
+	return a
+}
+
+func (a *ServerctlApi) RunApi() {
+	runProfilerHttpServer()
+
+	err := a.router.Run(":8080")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (a *ServerctlApi) setupCommonMiddleware() *ServerctlApi {
+	return a
+}
+
+func (a *ServerctlApi) setupRoutingTable() {
+	a.routingTable = routers.
+		NewRoutingTable(a.router, a.dependencies).
+		Setup()
+}
+
+func runProfilerHttpServer() {
+	go func() {
+		log.Println(http.ListenAndServe(":6060", nil))
+	}()
+}

services/entry/pkg/api/middleware/auth.go

@@ -0,0 +1,38 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+	"net/http"
+	"serverctl/pkg/application/users"
+)
+
+func BasicAuthMiddleware(l *zap.Logger, us *users.Service) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		username, password, hasAuth := c.Request.BasicAuth()
+		if !hasAuth {
+			l.Info("user could not be authenticated",
+				zap.String("username", username))
+			c.Header("WWW-Authenticate", "Basic realm=serverctl")
+			c.Abort()
+			c.JSON(http.StatusUnauthorized, gin.H{"message": "credentials were invalid (authorization header missing)"})
+			return
+		}
+
+		user, err := us.Authenticate(c.Request.Context(), username, password)
+		if err != nil {
+			l.Info("user could not be authenticated",
+				zap.String("username", username))
+			c.Abort()
+			c.Header("WWW-Authenticate", "Basic realm=serverctl")
+			c.JSON(http.StatusUnauthorized, gin.H{"message": "credentials were invalid (credentials didn't match)"})
+			return
+		}
+
+		l.Debug("user has been authenticated",
+			zap.Int("userId", user.Id),
+			zap.String("email", user.Email))
+		c.Set("userId", user.Id)
+		c.Next()
+	}
+}

services/entry/pkg/api/routers/applications.go

@@ -0,0 +1,32 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"serverctl/pkg/api/middleware"
+	"serverctl/pkg/infrastructure/dependencies"
+)
+
+func applicationsRouter(router *gin.Engine, d *dependencies.Dependencies) {
+	applications := router.Group("/applications", middleware.BasicAuthMiddleware(d.Logger, d.UsersService))
+	applications.POST("/", func(c *gin.Context) {
+		type CreateApplicationRequest struct {
+			ProjectId int    `json:"projectId" binding:"required"`
+			Name      string `json:"name" binding:"required"`
+		}
+
+		var createApplicationRequest CreateApplicationRequest
+		if err := c.BindJSON(&createApplicationRequest); err != nil {
+			return
+		}
+
+		userId, _ := c.Get("userId")
+		applicationId, err := d.ApplicationsService.CreateApplication(c.Request.Context(), createApplicationRequest.Name, userId.(int), createApplicationRequest.ProjectId)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"message": "you have provided invalid input"})
+			return
+		}
+
+		c.JSON(http.StatusCreated, gin.H{"message": "application has been created", "applicationId": applicationId})
+	})
+}

services/entry/pkg/api/routers/auth.go

@@ -0,0 +1,28 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"serverctl/pkg/infrastructure/dependencies"
+)
+
+func authRouter(router *gin.Engine, d *dependencies.Dependencies) {
+	router.POST("/auth/register", func(c *gin.Context) {
+		type RegisterUser struct {
+			Email    string `json:"email" binding:"required"`
+			Password string `json:"password" binding:"required"`
+		}
+		var registerUser RegisterUser
+		if err := c.BindJSON(&registerUser); err != nil {
+			return
+		}
+
+		createUser, err := d.UsersService.Create(registerUser.Email, registerUser.Password)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"message": "you have provided invalid input"})
+			return
+		}
+
+		c.JSON(http.StatusCreated, gin.H{"message": "user has been registered", "userId": createUser})
+	})
+}

services/entry/pkg/api/routers/containers.go

@@ -0,0 +1,36 @@
+package routers
+
+import (
+	"github.com/docker/docker/api/types"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"serverctl/pkg/api/middleware"
+	"serverctl/pkg/infrastructure/dependencies"
+)
+
+func containersRouter(router *gin.Engine, d *dependencies.Dependencies) {
+	containers := router.Group("/containers", middleware.BasicAuthMiddleware(d.Logger, d.UsersService))
+	containers.GET("/", func(c *gin.Context) {
+		type container struct {
+			Name string `json:"name"`
+		}
+		var msg struct {
+			Containers []container `json:"containers"`
+		}
+
+		get, err := d.Cache.Get("docker-containers")
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"message": "could not get containers from container runtime"})
+			return
+		}
+
+		msg.Containers = []container{}
+		for _, cont := range get.([]types.Container) {
+			msg.Containers = append(msg.Containers, container{
+				Name: cont.Names[0],
+			})
+		}
+
+		c.JSON(http.StatusOK, msg)
+	})
+}

services/entry/pkg/api/routers/lib.go

@@ -0,0 +1,25 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"serverctl/pkg/infrastructure/dependencies"
+)
+
+type RoutingTable struct {
+	router       *gin.Engine
+	dependencies *dependencies.Dependencies
+}
+
+func NewRoutingTable(router *gin.Engine, dependencies *dependencies.Dependencies) *RoutingTable {
+	return &RoutingTable{router: router, dependencies: dependencies}
+}
+
+func (t *RoutingTable) Setup() *RoutingTable {
+	metricsRouter(t.router)
+	authRouter(t.router, t.dependencies)
+	projectsRouter(t.router, t.dependencies)
+	applicationsRouter(t.router, t.dependencies)
+	containersRouter(t.router, t.dependencies)
+
+	return t
+}

services/entry/pkg/api/routers/metrics.go

@@ -0,0 +1,18 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+func metrics() gin.HandlerFunc {
+	h := promhttp.Handler()
+
+	return func(c *gin.Context) {
+		h.ServeHTTP(c.Writer, c.Request)
+	}
+}
+
+func metricsRouter(router *gin.Engine) {
+	router.GET("/metrics", metrics())
+}

services/entry/pkg/api/routers/projects.go

@@ -0,0 +1,73 @@
+package routers
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"serverctl/pkg/api/middleware"
+	"serverctl/pkg/application/projects"
+	"serverctl/pkg/infrastructure/dependencies"
+)
+
+func projectsRouter(router *gin.Engine, d *dependencies.Dependencies) {
+	projectsApi := router.Group("/projects", middleware.BasicAuthMiddleware(d.Logger, d.UsersService))
+	projectsApi.POST("/", func(c *gin.Context) {
+		type CreateProjectRequest struct {
+			Name string `json:"name" binding:"required"`
+		}
+		var createProjectRequest CreateProjectRequest
+		if err := c.BindJSON(&createProjectRequest); err != nil {
+			return
+		}
+
+		userId, _ := c.Get("userId")
+		createProjectId, err := d.ProjectsService.CreateProject(c.Request.Context(), userId.(int), createProjectRequest.Name)
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"message": "you have provided invalid input"})
+			return
+		}
+
+		c.JSON(http.StatusCreated, gin.H{"message": "project has been created", "projectId": createProjectId})
+	})
+	projectsApi.GET("/", func(c *gin.Context) {
+		userId, _ := c.Get("userId")
+
+		projectsArr, err := d.ProjectsService.Get(c.Request.Context(), userId.(int))
+		if err != nil {
+			d.Logger.Warn(err.Error())
+			return
+		}
+
+		type GetProjectMembers struct {
+			MemberId   int    `json:"memberId" binding:"required"`
+			MemberRole string `json:"memberRole" binding:"required"`
+		}
+		type GetProject struct {
+			Id      int                  `json:"id" binding:"required"`
+			Name    string               `json:"name" binding:"required"`
+			Members []*GetProjectMembers `json:"members" binding:"required"`
+		}
+
+		membersAsGetProjectMembers := func(projectMembers []projects.ProjectMember) []*GetProjectMembers {
+			gpm := make([]*GetProjectMembers, len(projectMembers))
+
+			for i, pm := range projectMembers {
+				gpm[i] = &GetProjectMembers{
+					MemberId:   pm.MemberId,
+					MemberRole: pm.Role,
+				}
+			}
+
+			return gpm
+		}
+
+		getProject := make([]GetProject, 0)
+		for _, p := range projectsArr {
+			getProject = append(getProject, GetProject{
+				Id:      p.Id,
+				Name:    p.Name,
+				Members: membersAsGetProjectMembers(p.Members),
+			})
+		}
+		c.JSON(http.StatusOK, getProject)
+	})
+}