140 lines
3.5 KiB
Go
140 lines
3.5 KiB
Go
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
|
|
"github.com/spf13/viper"
|
|
|
|
"otpm/config"
|
|
"otpm/database"
|
|
"otpm/handlers"
|
|
"otpm/models"
|
|
"otpm/server"
|
|
"otpm/services"
|
|
)
|
|
|
|
func init() {
|
|
// Set config file with multi-environment support
|
|
viper.SetConfigName("config")
|
|
viper.SetConfigType("yaml")
|
|
viper.AddConfigPath(".")
|
|
|
|
// Set environment specific config (e.g. config.production.yaml)
|
|
env := os.Getenv("OTPM_ENV")
|
|
if env != "" {
|
|
viper.SetConfigName(fmt.Sprintf("config.%s", env))
|
|
}
|
|
|
|
// Set default values
|
|
viper.SetDefault("server.port", "8080")
|
|
viper.SetDefault("server.timeout.read", "15s")
|
|
viper.SetDefault("server.timeout.write", "15s")
|
|
viper.SetDefault("server.timeout.idle", "60s")
|
|
viper.SetDefault("database.max_open_conns", 25)
|
|
viper.SetDefault("database.max_idle_conns", 5)
|
|
viper.SetDefault("database.conn_max_lifetime", "5m")
|
|
|
|
// Set environment variable prefix
|
|
viper.SetEnvPrefix("OTPM")
|
|
viper.AutomaticEnv()
|
|
|
|
// Bind environment variables
|
|
viper.BindEnv("database.url", "OTPM_DB_URL")
|
|
viper.BindEnv("database.password", "OTPM_DB_PASSWORD")
|
|
}
|
|
|
|
// Execute is the entry point for the application
|
|
func Execute() error {
|
|
// Load configuration
|
|
cfg, err := config.LoadConfig()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to load config: %w", err)
|
|
}
|
|
|
|
// Create context with cancellation
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
// Setup signal handling
|
|
sigChan := make(chan os.Signal, 1)
|
|
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
|
|
go func() {
|
|
sig := <-sigChan
|
|
log.Printf("Received signal: %v", sig)
|
|
cancel()
|
|
}()
|
|
|
|
// Initialize database
|
|
db, err := database.New(&cfg.Database)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to initialize database: %w", err)
|
|
}
|
|
defer db.Close()
|
|
|
|
// Run database migrations
|
|
if err := database.MigrateWithContext(ctx, db.DB, cfg.Database.SkipMigration); err != nil {
|
|
return fmt.Errorf("failed to run migrations: %w", err)
|
|
}
|
|
|
|
// Initialize repositories
|
|
userRepo := models.NewUserRepository(db.DB)
|
|
otpRepo := models.NewOTPRepository(db.DB)
|
|
|
|
// Initialize services
|
|
authService := services.NewAuthService(cfg, userRepo)
|
|
otpService := services.NewOTPService(otpRepo)
|
|
|
|
// Initialize handlers
|
|
authHandler := handlers.NewAuthHandler(authService)
|
|
otpHandler := handlers.NewOTPHandler(otpService)
|
|
|
|
// Create and configure server
|
|
srv := server.New(cfg)
|
|
|
|
// Register health check endpoint
|
|
srv.RegisterHealthCheck()
|
|
|
|
// Register public routes with type conversion
|
|
authRoutes := make(map[string]http.Handler)
|
|
for path, handler := range authHandler.Routes() {
|
|
authRoutes[path] = http.HandlerFunc(handler)
|
|
}
|
|
srv.RegisterRoutes(authRoutes)
|
|
|
|
// Register authenticated routes with type conversion
|
|
otpRoutes := make(map[string]http.Handler)
|
|
for path, handler := range otpHandler.Routes() {
|
|
otpRoutes[path] = http.HandlerFunc(handler)
|
|
}
|
|
srv.RegisterAuthRoutes(otpRoutes)
|
|
|
|
// Start server in goroutine
|
|
serverErr := make(chan error, 1)
|
|
go func() {
|
|
log.Printf("Starting server on %s:%d", cfg.Server.Host, cfg.Server.Port)
|
|
if err := srv.Start(); err != nil {
|
|
serverErr <- fmt.Errorf("server error: %w", err)
|
|
}
|
|
}()
|
|
|
|
// Wait for shutdown signal or server error
|
|
select {
|
|
case err := <-serverErr:
|
|
return err
|
|
case <-ctx.Done():
|
|
// Graceful shutdown with timeout
|
|
log.Println("Shutting down server...")
|
|
if err := srv.Shutdown(); err != nil {
|
|
return fmt.Errorf("server shutdown error: %w", err)
|
|
}
|
|
log.Println("Server stopped gracefully")
|
|
}
|
|
|
|
return nil
|
|
}
|