main.go

package main

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

	"github.com/cmsgov/emmy-api/api"
	"github.com/cmsgov/emmy-api/api/routes"
	"github.com/cmsgov/emmy-api/pkg/core"
	"github.com/cmsgov/emmy-api/pkg/redis"
	"github.com/cmsgov/emmy-api/pkg/reporting"

	"github.com/gofiber/fiber/v2"
)

var ErrRunFailed = errors.New("application failed to run")

func main() {
	err := run()
	if err != nil {
		os.Exit(1)
	}
	os.Exit(0)
}

func run() error {
	logger := core.NewLogger(nil)

	err := core.LoadEnv()
	if err != nil {
		logger.Error(
			"Failed to load environment",
			"err", err,
		)
		return ErrRunFailed
	}

	cfg, err := core.NewConfigFromEnv()
	if err != nil {
		logger.Error(
			"Failed to get configuration",
			"err", err,
		)
		return ErrRunFailed
	}

	logger.Info("raw abc123 env", "SKIP_AUTH", os.Getenv("SKIP_AUTH"))

	logger.Info("config loaded",
		"env", cfg.Environment,
		"port", cfg.Port,
		"skip_auth", cfg.SkipAuth,
	)

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	initLogger := core.NewLogger(&cfg)

	rdb := redis.NewClient(redis.Config{
		Addr:               cfg.Redis.Addr,
		Password:           cfg.Redis.Password,
		DB:                 cfg.Redis.DB,
		UseTLS:             cfg.Redis.UseTLS,
		InsecureSkipVerify: cfg.Redis.InsecureSkipVerify,
	}, logger)

	err = redis.Ping(ctx, rdb)
	if err != nil {
		logger.ErrorContext(ctx, "redis ping failed", "err", err)
		_ = rdb.Close()
		return ErrRunFailed
	}

	defer func() {
		if err := rdb.Close(); err != nil {
			logger.Warn("redis close failed", "err", err)
		}
	}()

	reporter := reporting.NewReporter(ctx, cfg.Reporting, logger)

	app, err := api.New(&api.Config{
		Core:   cfg,
		Logger: initLogger,
		Redis:  rdb,
	})
	if err != nil {
		logger.ErrorContext(
			ctx,
			"Error building app",
			"err", err,
		)
		return ErrRunFailed
	}

	routes.RegisterRoutes(app, &cfg, rdb, reporter, logger)

	addr, err := listenAddr(cfg.Port)
	if err != nil {
		logger.ErrorContext(
			ctx,
			"Invalid server port",
			"port", cfg.Port,
			"err", err,
		)
		return ErrRunFailed
	}

	err = runServer(ctx, app, addr)
	if err != nil {
		logger.ErrorContext(
			ctx,
			"Server error",
			"err", err,
		)
		return ErrRunFailed
	}

	return nil
}

func listenAddr(port int) (string, error) {
	if port < 1 || port > 65535 {
		return "", fmt.Errorf("port out of range: %d", port)
	}

	return fmt.Sprintf(":%d", port), nil
}

func runServer(ctx context.Context, app *fiber.App, addr string) error {
	srvErr := make(chan error, 1)

	go func() {
		srvErr <- app.Listen(addr)
	}()

	select {
	case err := <-srvErr:
		return err
	case <-ctx.Done():
	}

	err := app.ShutdownWithTimeout(5 * time.Second)
	if err != nil {
		return fmt.Errorf("error during shutdown: %w", err)
	}

	return nil
}