feat: changed controllers

procima/internal/integration/http/v1/router/const.go → procima/internal/app/http/v1/const.go

@@ -1,7 +1,7 @@
-package router
+package v1
 
 const (
- MetricsURL = "/api/metrics"
+ MetricsURL = "/metrics"
  BaseURL = "/api/v1"
  ImageURL = "/images"
  ImageUploadURL = ImageURL + UPLOAD

procima/internal/integration/http/v1/controller/image.go → procima/internal/app/http/v1/images/controller.go

@@ -1,27 +1,26 @@
-package controller
+package images
 
 import (
  "context"
  errorsPkg "errors"
  "github.com/SShlykov/procima/procima/internal/domain/services"
- "github.com/SShlykov/procima/procima/internal/integration/http/v1/errors"
  "github.com/SShlykov/procima/procima/internal/models"
  loggerPkg "github.com/SShlykov/procima/procima/pkg/logger"
  "github.com/gin-gonic/gin"
  "net/http"
- "regexp"
 )
 
 // ImageController контроллер для обработки изображений
 //
-//go:generate mockgen -destination=./mocks/mock_image_controller.go -package=mocks github.com/SShlykov/procima/procima/internal/integration/http/v1/controller ImageController
+//go:generate mockgen -destination=./mocks/mock_image_controller.go -package=mocks github.com/SShlykov/procima/procima/internal/app/http/v1/controller ImageController
 type ImageController interface {
+ RegisterRoutes(router *gin.RouterGroup)
  ProcessImage(c *gin.Context)
 }
 
 // ImageService сервис для обработки изображений
 //
-//go:generate mockgen -destination=./mocks/mock_image_service.go -package=mocks github.com/SShlykov/procima/procima/internal/integration/http/v1/controller ImageService
+//go:generate mockgen -destination=./mocks/mock_image_service.go -package=mocks github.com/SShlykov/procima/procima/internal/app/http/v1/controller ImageService
 type ImageService interface {
  ProcessImage(ctx context.Context, request models.RequestImage) (*[]byte, error)
 }
@@ -42,21 +41,21 @@ func (ic *imageController) ProcessImage(c *gin.Context) {
 
  var request models.RequestImage
  if err := c.BindJSON(&request); err != nil {
- ic.logger.Error(errors.ErrorBadRequest, loggerPkg.Err(err))
- c.JSON(http.StatusBadRequest, gin.H{"error": errors.ErrorBadRequest})
+ ic.logger.Error(ErrorBadRequest, loggerPkg.Err(err))
+ c.JSON(http.StatusBadRequest, gin.H{"error": ErrorBadRequest})
  return
  }
 
  if len(request.Image) > ic.fileSizeLimit {
- ic.logger.Error(errors.ErrorBadRequest, loggerPkg.String("error", errors.ErrorExcededFileSize))
- c.JSON(http.StatusBadRequest, gin.H{"error": errors.ErrorExcededFileSize, "limit": ic.fileSizeLimit, "actual": len(request.Image)})
+ ic.logger.Error(ErrorBadRequest, loggerPkg.String("error", ErrorExcededFileSize))
+ c.JSON(http.StatusBadRequest, gin.H{"error": ErrorExcededFileSize, "limit": ic.fileSizeLimit, "actual": len(request.Image)})
  return
  }
 
  imageType, found := getImageType(request.Image)
  if !found || !ic.isAvailable(imageType) {
- ic.logger.Error(errors.ErrorBadRequest, loggerPkg.String("error", errors.ErrorInvalidImageType))
- c.JSON(http.StatusBadRequest, gin.H{"error": errors.ErrorInvalidImageType, "available": ic.availableImageTypes, "actual": imageType})
+ ic.logger.Error(ErrorBadRequest, loggerPkg.String("error", ErrorInvalidImageType))
+ c.JSON(http.StatusBadRequest, gin.H{"error": ErrorInvalidImageType, "available": ic.availableImageTypes, "actual": imageType})
  return
  }
 
@@ -68,7 +67,7 @@ func (ic *imageController) ProcessImage(c *gin.Context) {
  return
  }
 
- c.JSON(http.StatusInternalServerError, gin.H{"error": errors.ErrorInternal})
+ c.JSON(http.StatusInternalServerError, gin.H{"error": ErrorInternal})
  return
  }
 
@@ -85,15 +84,3 @@ func (ic *imageController) isAvailable(imageType string) bool {
  }
  return false
 }
-
-const PartsWhenImage = 2
-
-func getImageType(dataURL string) (string, bool) {
- re := regexp.MustCompile(`^data:image/([^;]+);base64,`)
- matches := re.FindStringSubmatch(dataURL[:50])
-
- if len(matches) == PartsWhenImage {
- return matches[1], true
- }
- return "", false
-}

procima/internal/integration/http/v1/errors/errors.go → procima/internal/app/http/v1/images/errors.go

@@ -1,4 +1,4 @@
-package errors
+package images
 
 const (
  ErrorBadRequest = "bad request"

procima/internal/app/http/v1/images/routes.go

@@ -0,0 +1,10 @@
+package images
+
+import (
+ v1 "github.com/SShlykov/procima/procima/internal/app/http/v1"
+ "github.com/gin-gonic/gin"
+)
+
+func (ic *imageController) RegisterRoutes(router *gin.RouterGroup) {
+ router.POST(v1.ImageUploadURL, ic.ProcessImage)
+}

procima/internal/app/http/v1/images/utils.go

@@ -0,0 +1,15 @@
+package images
+
+import "regexp"
+
+const PartsWhenImage = 2
+
+func getImageType(dataURL string) (string, bool) {
+ re := regexp.MustCompile(`^data:image/([^;]+);base64,`)
+ matches := re.FindStringSubmatch(dataURL[:50])
+
+ if len(matches) == PartsWhenImage {
+ return matches[1], true
+ }
+ return "", false
+}

procima/internal/app/http/v1/metrics/controller.go

@@ -0,0 +1,31 @@
+package metrics
+
+import (
+ "github.com/SShlykov/procima/procima/pkg/metrics"
+ "github.com/gin-gonic/gin"
+ "github.com/prometheus/client_golang/prometheus"
+ "github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+type Controller interface {
+ PrometheusHandler(c *gin.Context)
+ RegisterRoutes(router *gin.RouterGroup)
+}
+
+type metricsController struct {
+ metr metrics.Metrics
+}
+
+func NewMetricsController(metr metrics.Metrics) Controller {
+ return &metricsController{metr: metr}
+}
+
+func (mc *metricsController) PrometheusHandler(c *gin.Context) {
+ reg := prometheus.NewRegistry()
+
+ mc.metr.Register(reg)
+
+ h := promhttp.HandlerFor(reg, promhttp.HandlerOpts{Registry: reg})
+
+ h.ServeHTTP(c.Writer, c.Request)
+}

procima/internal/app/http/v1/metrics/routes.go

@@ -0,0 +1,10 @@
+package metrics
+
+import (
+ v1 "github.com/SShlykov/procima/procima/internal/app/http/v1"
+ "github.com/gin-gonic/gin"
+)
+
+func (mc *metricsController) RegisterRoutes(router *gin.RouterGroup) {
+ router.POST(v1.ImageUploadURL, mc.PrometheusHandler)
+}

procima/internal/bootstrap/app/app.go

@@ -5,6 +5,7 @@ import (
  "github.com/SShlykov/procima/procima/internal/bootstrap/registry"
  configPkg "github.com/SShlykov/procima/procima/internal/config"
  "github.com/SShlykov/procima/procima/internal/domain/processor"
+ "github.com/SShlykov/procima/procima/internal/domain/services"
  loggerPkg "github.com/SShlykov/procima/procima/pkg/logger"
  "github.com/SShlykov/procima/procima/pkg/metrics"
  "os/signal"
@@ -52,14 +53,16 @@ func (app *App) Run() error {
 
  app.logger.Info("запуск приложения", loggerPkg.Any("cfg", app.config))
  app.logger.Debug("включены отладочные сообщения")
+
  imageProcessorChan := make(chan processor.ImageProcessorItem)
+ service := services.NewImageService(app.logger, imageProcessorChan)
 
  wg.Add(1)
  go func() {
  defer wg.Done()
  defer app.cancel()
  defer app.logger.Info(app.config.AppName + " остановлен")
- server, err := registry.InitWebServer(app.logger, app.configPath, app.metric, imageProcessorChan)
+ server, err := registry.InitWebServer(app.logger, app.configPath, app.metric, service)
  if err != nil {
  app.logger.Error("failed to init web server", loggerPkg.Err(err))
  return

procima/internal/bootstrap/registry/web_server.go

@@ -2,20 +2,20 @@ package registry
 
 import (
  "errors"
+ "github.com/SShlykov/procima/procima/internal/app/http/endpoint"
+ "github.com/SShlykov/procima/procima/internal/app/http/middleware"
+ v1 "github.com/SShlykov/procima/procima/internal/app/http/v1"
+ cntr "github.com/SShlykov/procima/procima/internal/app/http/v1/images"
+ metrics2 "github.com/SShlykov/procima/procima/internal/app/http/v1/metrics"
  "github.com/SShlykov/procima/procima/internal/config"
- "github.com/SShlykov/procima/procima/internal/domain/processor"
  "github.com/SShlykov/procima/procima/internal/domain/services"
- "github.com/SShlykov/procima/procima/internal/integration/http/endpoint"
- cntr "github.com/SShlykov/procima/procima/internal/integration/http/v1/controller"
- "github.com/SShlykov/procima/procima/internal/integration/http/v1/router"
  loggerPkg "github.com/SShlykov/procima/procima/pkg/logger"
  "github.com/SShlykov/procima/procima/pkg/metrics"
  "github.com/gin-gonic/gin"
  "net/http"
 )
 
-func InitWebServer(logger loggerPkg.Logger, configPath string, metr metrics.Metrics,
- processorChan chan<- processor.ImageProcessorItem) (*endpoint.WebServer, error) {
+func InitWebServer(logger loggerPkg.Logger, configPath string, metr metrics.Metrics, imgService services.ImageService) (*endpoint.WebServer, error) {
  cfg, err := config.LoadServerConfig(configPath)
  if err != nil {
  return nil, errors.New("failed to load server config: " + err.Error())
@@ -24,40 +24,30 @@ func InitWebServer(logger loggerPkg.Logger, configPath string, metr metrics.Metr
  gin.SetMode(gin.ReleaseMode)
  engine := gin.New()
  engine.Use(gin.Recovery())
+ engine.Use(middleware.Metrics(logger, metr))
+ group := engine.Group(v1.BaseURL)
 
- SetRouter(engine, logger, cfg, metr, processorChan)
+ metrContr := metrics2.NewMetricsController(metr)
+ metrContr.RegisterRoutes(group)
 
+ imgCntr := cntr.NewImageController(imgService, logger, cfg.AvailableTypes, cfg.MaxFileSize)
+ imgCntr.RegisterRoutes(group)
+
+ webSever := configToWebServer(cfg)
+ webSever.Server.Handler = engine
+
+ return webSever, nil
+}
+
+func configToWebServer(cfg *config.ServerConfig) *endpoint.WebServer {
  srv := &http.Server{
  ReadHeaderTimeout: cfg.ReadHeaderTimeout,
  ReadTimeout: cfg.ReadTimeout,
  WriteTimeout: cfg.WriteTimeout,
  IdleTimeout: cfg.IddleTimeout,
 
- Addr: cfg.Addr,
- Handler: engine,
+ Addr: cfg.Addr,
  }
 
- return &endpoint.WebServer{Server: srv, Config: cfg}, nil
-}
-
-func SetRouter(engine *gin.Engine, logger loggerPkg.Logger, serverConfig *config.ServerConfig, metr metrics.Metrics,
- processorChan chan<- processor.ImageProcessorItem) {
- imageController := initImageController(logger, serverConfig, processorChan)
-
- routers :=
- []func(engine *gin.Engine, logger loggerPkg.Logger){
- router.ImageRouter(imageController, metr),
- router.MetricsRouter(metr),
- }
-
- for _, routes := range routers {
- routes(engine, logger)
- }
-}
-
-func initImageController(logger loggerPkg.Logger, serverConfig *config.ServerConfig,
- processorChan chan<- processor.ImageProcessorItem) cntr.ImageController {
- service := services.NewImageService(logger, processorChan)
- controller := cntr.NewImageController(service, logger, serverConfig.AvailableTypes, serverConfig.MaxFileSize)
- return controller
+ return &endpoint.WebServer{Server: srv, Config: cfg}
 }