rewrite

cmd/api/main.go

@@ -2,112 +2,97 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
-	"git.intra.yksa.space/gsn/predictor/internal/jobs/grib/updater"
-	"git.intra.yksa.space/gsn/predictor/internal/pkg/grib"
-	"git.intra.yksa.space/gsn/predictor/internal/pkg/log"
-	"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/scheduler"
+	"predictor-refactored/internal/downloader"
+	"predictor-refactored/internal/service"
+	"predictor-refactored/internal/transport/rest"
+	"predictor-refactored/internal/transport/rest/handler"
+
+	"github.com/go-co-op/gocron"
 	"go.uber.org/zap"
 )
 
-const servicePrefix = "GSN_PREDICTOR"
-
 func main() {
-	lg, err := zap.NewProduction()
+	log, err := zap.NewProduction()
 	if err != nil {
 		panic(err)
 	}
-	defer lg.Sync()
-	ctx := log.ToCtx(context.Background(), lg)
+	defer log.Sync()
 
-	schedulerConfig, err := scheduler.NewConfig()
-	if err != nil {
-		log.Ctx(ctx).Fatal("failed to load scheduler configuration", zap.Error(err))
+	cfg := downloader.LoadConfig()
+	log.Info("configuration loaded",
+		zap.String("data_dir", cfg.DataDir),
+		zap.Int("parallel", cfg.Parallel),
+		zap.Duration("update_interval", cfg.UpdateInterval),
+		zap.Duration("dataset_ttl", cfg.DatasetTTL))
+
+	if err := os.MkdirAll(cfg.DataDir, 0o755); err != nil {
+		log.Fatal("failed to create data directory", zap.Error(err))
 	}
 
-	gribUpdaterConfig, err := updater.NewConfig()
-	if err != nil {
-		log.Ctx(ctx).Fatal("failed to load GRIB updater configuration", zap.Error(err))
-	}
-
-	gribCfg, err := grib.NewConfig()
-	if err != nil {
-		log.Ctx(ctx).Fatal("failed to load GRIB configuration", zap.Error(err))
-	}
-
-	gribService, err := grib.New(gribCfg)
-	if err != nil {
-		log.Ctx(ctx).Fatal("failed to initialize GRIB service", zap.Error(err))
-	}
-	defer gribService.Close()
-
-	// Force GRIB update on startup in a goroutine
-	go func() {
-		log.Ctx(ctx).Info("Performing initial GRIB update (async)...")
-		if err := gribService.Update(ctx); err != nil {
-			log.Ctx(ctx).Error("initial GRIB update failed", zap.Error(err))
-		} else {
-			log.Ctx(ctx).Info("initial GRIB update complete")
-		}
-	}()
-
-	svc, err := service.New(gribService)
-	if err != nil {
-		log.Ctx(ctx).Fatal("failed to initialize service", zap.Error(err))
-	}
+	svc := service.New(cfg, log)
 	defer svc.Close()
 
-	var sched *scheduler.Scheduler
-	if schedulerConfig.Enabled {
-		sched = scheduler.New()
-
-		gribJob := updater.New(gribService, gribUpdaterConfig)
-		if err := sched.AddJob(gribJob); err != nil {
-			log.Ctx(ctx).Error("failed to add GRIB update job to scheduler", zap.Error(err))
-		}
-
-		log.Ctx(ctx).Info("scheduler initialized with jobs")
+	// Load elevation dataset (optional — falls back to sea-level termination)
+	elevPath := "/srv/ruaumoko-dataset"
+	if v := os.Getenv("PREDICTOR_ELEVATION_DATASET"); v != "" {
+		elevPath = v
 	}
+	svc.LoadElevation(elevPath)
 
-	handler := handler.New(svc)
-
-	restConfig, err := rest.NewConfig()
-	if err != nil {
-		lg.Fatal("failed to init transport config", zap.Error(err))
-	}
-
-	transport, err := rest.New(handler, restConfig)
-	if err != nil {
-		lg.Fatal("failed to init transport", zap.Error(err))
-	}
-
-	svc.Start()
-	if sched != nil {
-		sched.Start()
-		lg.Info("scheduler started")
-	}
-
-	lg.Info("service started successfully")
-
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
-
+	// Initial dataset load (async so the server starts immediately)
 	go func() {
-		lg.Info("starting HTTP server on port", zap.Int("port", restConfig.Port))
-		transport.Run()
+		log.Info("performing initial dataset update...")
+		if err := svc.Update(context.Background()); err != nil {
+			log.Error("initial dataset update failed", zap.Error(err))
+		} else {
+			log.Info("initial dataset update complete")
+		}
 	}()
 
-	<-sigChan
-	lg.Info("received shutdown signal, stopping service")
+	// Scheduler for periodic dataset updates
+	scheduler := gocron.NewScheduler(time.UTC)
+	scheduler.Every(cfg.UpdateInterval).Do(func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+		defer cancel()
+		log.Info("scheduled dataset update starting")
+		if err := svc.Update(ctx); err != nil {
+			log.Error("scheduled dataset update failed", zap.Error(err))
+		} else {
+			log.Info("scheduled dataset update complete")
+		}
+	})
+	scheduler.StartAsync()
+	defer scheduler.Stop()
 
-	if sched != nil {
-		sched.Stop()
-		lg.Info("scheduler stopped")
+	// HTTP transport (ogen)
+	port := 8080
+	if p := os.Getenv("PREDICTOR_PORT"); p != "" {
+		fmt.Sscanf(p, "%d", &port)
 	}
+
+	h := handler.New(svc, log)
+	transport, err := rest.New(h, port, log)
+	if err != nil {
+		log.Fatal("failed to create transport", zap.Error(err))
+	}
+
+	go func() {
+		if err := transport.Run(); err != nil {
+			log.Fatal("HTTP server error", zap.Error(err))
+		}
+	}()
+
+	log.Info("service started")
+
+	// Graceful shutdown
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	sig := <-sigChan
+	log.Info("received shutdown signal", zap.String("signal", sig.String()))
 }