treasurer/internal/app/app.go

package app

import (
	"context"
	"errors"
	"fmt"
	"os/signal"
	"syscall"
	"time"

	"go.uber.org/zap"
	"gitea.pena/PenaSide/treasurer/internal/initialize"
	"gitea.pena/PenaSide/treasurer/internal/interface/swagger"
	"gitea.pena/PenaSide/treasurer/internal/models"
	"gitea.pena/PenaSide/treasurer/internal/server"
	"gitea.pena/PenaSide/treasurer/internal/worker"
	"gitea.pena/PenaSide/treasurer/pkg/closer"
	"gitea.pena/PenaSide/treasurer/pkg/mongo"
)

const (
	shutdownTimeout = 5 * time.Second
)

func Run(config *models.Config, logger *zap.Logger) (appErr error) {
	defer func() {
		if recovered := recover(); recovered != nil {
			appErr = errors.New("recovered panic on application run")
			logger.Error("recovered panic on application run", zap.Any("recovered", recovered))
		}
	}()

	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer cancel()

	mongoDB, connectionErr := mongo.Connect(ctx, &mongo.ConnectDeps{
		Configuration: &config.Database,
		Timeout:       10 * time.Second,
	})
	if connectionErr != nil {
		return fmt.Errorf("failed connection to db: %w", connectionErr)
	}

	closer := closer.New()

	openapi, swaggerErr := swagger.GetSwagger()
	if swaggerErr != nil {
		return fmt.Errorf("failed to loading openapi spec: %w", swaggerErr)
	}

	repositories, err := initialize.NewRepositories(initialize.RepositoriesDeps{
		Logger:   logger,
		Database: mongoDB,
	})
	if err != nil {
		return err.Wrap("failed to initialize repositories")
	}

	clients, err := initialize.NewClients(initialize.ClientsDeps{
		Logger:                logger,
		YoomoneyConfiguration: &config.Service.YoomomeyConfiguration,
	})
	if err != nil {
		return err.Wrap("failed to initialize clients")
	}

	services, err := initialize.NewServices(initialize.ServicesDeps{
		Logger:            logger,
		Repositories:      *repositories,
		Clients:           *clients,
		ConfigurationHTTP: &config.HTTP,
		Configuration:     &config.Service,
	})
	if err != nil {
		return err.Wrap("failed to initialize services")
	}

	workers, err := initialize.NewWorkers(initialize.WorkersDeps{
		Logger:   logger,
		Services: *services,
	})

	if err != nil {
		return err.Wrap("failed to initialize workers")
	}

	controllers, err := initialize.NewControllers(initialize.ControllersDeps{
		Logger:   logger,
		Services: *services,
	})
	if err != nil {
		return err.Wrap("failed to initialize controllers")
	}

	api, err := initialize.NewAPI(controllers)
	if err != nil {
		return err.Wrap("failed to initialize api")
	}

	httpServer, err := server.NewHTTP(server.DepsHTTP{
		Logger:  logger,
		Swagger: openapi,
	})
	if err != nil {
		return err.Wrap("failed to initialize http server")
	}

	httpServer.Register(api)

	grpcServer, err := server.NewGRPC(server.DepsGRPC{Logger: logger})
	if err != nil {
		return err.Wrap("failed to initialize grpc server")
	}

	grpcServer.Register(controllers.PaymentGRPC)

	go httpServer.Run(&config.HTTP)
	go grpcServer.Run(&config.GRPC)
	go worker.Run(ctx, workers)

	closer.Add(mongoDB.Client().Disconnect)
	closer.Add(httpServer.Stop)
	closer.Add(grpcServer.Stop)

	<-ctx.Done()

	logger.Info("shutting down app gracefully")

	shutdownCtx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)

	defer cancel()

	if err := closer.Close(shutdownCtx); err != nil {
		return fmt.Errorf("closer: %w", err)
	}

	return nil
}