feat: downloader

cmd/api/main.go

@@ -1,27 +1,104 @@
 package main
 
 import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"git.intra.yksa.space/gsn/predictor/internal/jobs/grib/updater"
+	"git.intra.yksa.space/gsn/predictor/internal/pkg/errcodes"
+	"git.intra.yksa.space/gsn/predictor/internal/pkg/grib"
 	"git.intra.yksa.space/gsn/predictor/internal/service"
 	"git.intra.yksa.space/gsn/predictor/internal/transport/rest"
 	"git.intra.yksa.space/gsn/predictor/internal/transport/rest/handler"
+	"git.intra.yksa.space/gsn/predictor/pkg/redis"
+	"git.intra.yksa.space/gsn/predictor/pkg/scheduler"
+	env "github.com/caarlos0/env/v11"
 	"go.uber.org/zap"
 )
 
-const (
-	servicePrefix = "PREDICTOR"
-)
+const servicePrefix = "GSN_PREDICTOR"
 
 func main() {
 	lg, err := zap.NewProduction()
 	if err != nil {
 		panic(err)
 	}
+	defer lg.Sync()
 
-	svc := service.New()
+	// Load configuration from environment with service prefix
+	cfg, err := loadConfig()
+	if err != nil {
+		lg.Fatal("failed to load configuration", zap.Error(err))
+	}
 
+	// Load scheduler configuration
+	schedulerConfig, err := loadSchedulerConfig()
+	if err != nil {
+		lg.Fatal("failed to load scheduler configuration", zap.Error(err))
+	}
+
+	// Load GRIB updater job configuration
+	gribUpdaterConfig, err := loadGribUpdaterConfig()
+	if err != nil {
+		lg.Fatal("failed to load GRIB updater configuration", zap.Error(err))
+	}
+
+	// Initialize Redis service
+	redisService, err := redis.New(cfg.Redis)
+	if err != nil {
+		lg.Fatal("failed to initialize Redis service", zap.Error(err))
+	}
+	defer redisService.Close()
+
+	// Initialize GRIB service
+	gribService, err := grib.New(grib.ServiceConfig{
+		Dir:      cfg.Grib.Dir,
+		TTL:      cfg.Grib.TTL,
+		CacheTTL: cfg.Grib.CacheTTL,
+		Redis:    redisService,
+		Parallel: cfg.Grib.Parallel,
+		Client:   cfg.CreateHTTPClient(),
+	})
+	if err != nil {
+		lg.Fatal("failed to initialize GRIB service", zap.Error(err))
+	}
+	defer gribService.Close()
+
+	// Initialize service with dependencies
+	svc, err := service.New(cfg, gribService, redisService, lg)
+	if err != nil {
+		lg.Fatal("failed to initialize service", zap.Error(err))
+	}
+	defer svc.Close()
+
+	// Initialize scheduler
+	var sched *scheduler.Scheduler
+	if schedulerConfig.Enabled {
+		sched = scheduler.New(lg)
+
+		// Add GRIB update job
+		gribJob := updater.New(gribService, gribUpdaterConfig, lg)
+		if err := sched.AddJob(gribJob); err != nil {
+			lg.Error("failed to add GRIB update job to scheduler", zap.Error(err))
+		}
+
+		// TODO: Add more jobs here as needed
+		// Example:
+		// cleanupConfig := cleanup.NewConfig()
+		// cleanupJob := cleanup.New(svc, cleanupConfig, lg)
+		// if err := sched.AddJob(cleanupJob); err != nil {
+		//     lg.Error("failed to add cleanup job to scheduler", zap.Error(err))
+		// }
+
+		lg.Info("scheduler initialized with jobs")
+	}
+
+	// Initialize handler
 	handler := handler.New(svc)
 
-	restConfig, err := rest.NewConfig(servicePrefix)
+	// Initialize transport
+	restConfig, err := loadRestConfig()
 	if err != nil {
 		lg.Fatal("failed to init transport config", zap.Error(err))
 	}
@@ -31,11 +108,92 @@ func main() {
 		lg.Fatal("failed to init transport", zap.Error(err))
 	}
 
-	for {
-		transport.Run()
+	// Start service
+	svc.Start()
 
-		if r := recover(); r != nil {
-			lg.Error("panic occured", zap.Any("recover", r))
-		}
+	// Start scheduler if enabled
+	if sched != nil {
+		sched.Start()
+		lg.Info("scheduler started")
+	}
+
+	lg.Info("service started successfully",
+		zap.String("grib_dir", cfg.Grib.Dir),
+		zap.Duration("grib_ttl", cfg.Grib.TTL),
+		zap.Duration("grib_cache_ttl", cfg.Grib.CacheTTL),
+		zap.Int("grib_parallel", cfg.Grib.Parallel),
+		zap.Bool("scheduler_enabled", schedulerConfig.Enabled),
+		zap.Duration("grib_update_interval", gribUpdaterConfig.Interval))
+
+	// Wait for shutdown signal
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	// Start server in goroutine
+	go func() {
+		lg.Info("starting HTTP server")
+		transport.Run()
+	}()
+
+	// Wait for shutdown signal
+	<-sigChan
+	lg.Info("received shutdown signal, stopping service")
+
+	// Stop scheduler first
+	if sched != nil {
+		sched.Stop()
+		lg.Info("scheduler stopped")
 	}
 }
+
+// loadConfig loads configuration from environment with service prefix
+func loadConfig() (*service.Config, error) {
+	cfg := &service.Config{}
+
+	if err := env.ParseWithOptions(cfg, env.Options{
+		PrefixTagName: servicePrefix + "_",
+	}); err != nil {
+		return nil, errcodes.Wrap(err, "failed to parse configuration")
+	}
+
+	return cfg, nil
+}
+
+// loadSchedulerConfig loads scheduler configuration from environment
+func loadSchedulerConfig() (*scheduler.Config, error) {
+	cfg := &scheduler.Config{}
+
+	if err := env.ParseWithOptions(cfg, env.Options{
+		PrefixTagName: servicePrefix + "_SCHEDULER_",
+	}); err != nil {
+		return nil, errcodes.Wrap(err, "failed to parse scheduler configuration")
+	}
+
+	return cfg, nil
+}
+
+// loadGribUpdaterConfig loads GRIB updater job configuration from environment
+func loadGribUpdaterConfig() (*updater.Config, error) {
+	cfg := &updater.Config{}
+
+	if err := env.ParseWithOptions(cfg, env.Options{
+		PrefixTagName: servicePrefix + "_GRIB_UPDATER_",
+	}); err != nil {
+		return nil, errcodes.Wrap(err, "failed to parse GRIB updater configuration")
+	}
+
+	return cfg, nil
+}
+
+// loadRestConfig loads REST transport configuration from environment with service prefix
+func loadRestConfig() (*rest.Config, error) {
+	cfg := &rest.Config{}
+
+	if err := env.ParseWithOptions(cfg, env.Options{
+		PrefixTagName: servicePrefix + "_REST_",
+	}); err != nil {
+		return nil, errcodes.Wrap(err, "failed to parse REST configuration")
+	}
+
+	return cfg, nil
+}