cmd/application/app.go - main - pyo/auth

cmd/application/app.go
184 строки4 KB
ilovepitsa
restore from another repo
16 июн 2025, 17:30
16 июн 2025, 17:30fb9346f
package application

import (
	"context"
	"errors"
	"fmt"
	"net"
	"net/http"
	"sync"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"
	"github.com/labstack/echo/v4"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promhttp"
	"github.com/redis/go-redis/v9"
	"gitverse.ru/pyo/auth/pkg/config"
	"gitverse.ru/pyo/auth/pkg/metrics"
	"gitverse.ru/pyo/auth/pkg/middleware"
	"gitverse.ru/pyo/auth/pkg/server"
	"gitverse.ru/pyo/auth/pkg/tokens"
	"gitverse.ru/pyo/auth/pkg/users"
	"gitverse.ru/pyo/auth/pkg/util"
	"go.uber.org/zap"
)

type Application struct {
	config         *config.ApplicationConfig
	redisClient    *redis.Client
	tokenRepo      *tokens.RedisClient
	tokenManager   *tokens.TokenManager
	tokenGenerator *tokens.JWTTokensGenerator
	Router         *echo.Echo
	UserServer     *users.UserServer
	UserRepo       *users.UserRepoPG
	Hasher         *util.StringHasher
	MetricHandler  http.Handler
	Logger         *zap.Logger
	MetricRegistry *prometheus.Registry
}

func (app *Application) Run(ctx context.Context) error {
	app.RegisterMetrics()
	wg := &sync.WaitGroup{}

	wg.Add(1)
	go func() {
		defer wg.Done()
		if err := app.Router.Start(app.config.Server.Address); err != nil {
			fmt.Println(err.Error())
			fmt.Println(err)
			return
		}
	}()

	<-ctx.Done()

	err := app.Router.Shutdown(ctx)
	if err != nil && !errors.Is(err, net.ErrClosed) && !errors.Is(err, http.ErrServerClosed) {
		fmt.Println(err.Error())
		return err
	}

	wg.Wait()
	return nil
}

func (app *Application) RegisterMetrics() {
	app.MetricRegistry.MustRegister(
		metrics.MetricProcessDuration,
		metrics.MetricCountInstanceActivate,
		metrics.MetricGaugeInstanceActivate,
		metrics.MetricUnauthorizeCounter,
		metrics.GaugeDBExecutorOperations,
		metrics.CounterDBExecutorOperations,
		metrics.MetricDBExecutorOperationDuration,
		metrics.MetricDBExecutorRowSelectErrors,
	)
}

type txCtxKey struct{}

var txCtxPoolKey = txCtxKey{}

func TxFromCtx(ctx context.Context) pgx.Tx {
	tx, ok := ctx.Value(txCtxPoolKey).(pgx.Tx)
	if ok {
		return tx
	}
	return nil
}

func ProvidePgxConnectionProvider(connPool *pgxpool.Pool) users.PgxConnProvider {
	return func(ctx context.Context) (ex users.PgxExecutor, err error) {
		ex = TxFromCtx(ctx)
		if ex == nil {
			ex = connPool
		}
		ex = users.NewPgExecutorMetricsWrapper(ex)
		_, err = ex.Exec(ctx, "SET TIME ZONE 'UTC';")
		return ex, err
	}
}

func LoggerFromConfig(cfg *zap.Config) (*zap.Logger, error) {
	logger, err := cfg.Build()
	if err != nil {
		return nil, err
	}
	return logger, nil
}

func InitializeApplication(ctx context.Context, configPath string) (*Application, error) {
	app := &Application{}
	cfg, err := config.ParseConfig(configPath)
	if err != nil {
		return nil, err
	}
	cfg.SetLoggerDefaults()
	logger, err := LoggerFromConfig(cfg.Logger)
	if err != nil {
		return nil, err
	}
	app.redisClient = redis.NewClient(&redis.Options{
		Addr:     cfg.RepoConfig.Address,
		Password: cfg.RepoConfig.Password,
		Protocol: 2,
	})

	app.MetricRegistry = prometheus.NewRegistry()
	handlerOpts := promhttp.HandlerOpts{
		ErrorLog:            nil,
		ErrorHandling:       0,
		Registry:            app.MetricRegistry,
		DisableCompression:  false,
		MaxRequestsInFlight: 0,
		Timeout:             time.Minute,
		EnableOpenMetrics:   true,
	}

	app.MetricHandler = promhttp.HandlerFor(app.MetricRegistry, handlerOpts)

	app.tokenRepo = tokens.NewRedisClient(app.redisClient, cfg.Tokens)
	app.tokenGenerator = &tokens.JWTTokensGenerator{
		Cfg: cfg.Tokens,
	}
	app.tokenManager = &tokens.TokenManager{
		Repo: app.tokenRepo,
		Gen:  app.tokenGenerator,
		Cfg:  cfg.TokenManager,
	}
	app.config = cfg
	e := echo.New()
	pool, err := pgxpool.New(ctx, cfg.Pg.ConnString)
	if err != nil {
		return nil, err
	}
	pgxConnProvider := ProvidePgxConnectionProvider(pool)
	app.UserRepo = users.NewUserRepoPG(pgxConnProvider)

	app.Router = e
	app.Hasher = util.NewStringHasher()
	app.Logger = logger

	app.UserServer = &users.UserServer{
		Repo:         app.UserRepo,
		TokenManager: app.tokenManager,
		Hasher:       app.Hasher,
		Logger:       logger.Named("user_server"),
	}

	app.Router.GET("/metrics", echo.WrapHandler(app.MetricHandler))

	server.RegisterHandlers(app.Router, app.UserServer)

	app.Router.Use(
		middleware.MiddlewareRouteInfo,
		middleware.MiddlewareBinds(),
	)
	app.Router.HideBanner = true

	return app, nil
}