Fully implement local and container MRVA

cmd/server/main.go

@@ -4,20 +4,25 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"log"
 	"log/slog"
 	"os"
+	"os/signal"
+	"path/filepath"
+	"sync"
+	"syscall"
 
 	"mrvacommander/config/mcc"
 
 	"mrvacommander/pkg/agent"
-	"mrvacommander/pkg/logger"
+	"mrvacommander/pkg/artifactstore"
+	"mrvacommander/pkg/deploy"
 	"mrvacommander/pkg/qldbstore"
-	"mrvacommander/pkg/qpstore"
 	"mrvacommander/pkg/queue"
 	"mrvacommander/pkg/server"
-	"mrvacommander/pkg/storage"
+	"mrvacommander/pkg/state"
 )
 
 func main() {
@@ -25,13 +30,14 @@ func main() {
 	helpFlag := flag.Bool("help", false, "Display help message")
 	logLevel := flag.String("loglevel", "info", "Set log level: debug, info, warn, error")
 	mode := flag.String("mode", "standalone", "Set mode: standalone, container, cluster")
+	dbPathRoot := flag.String("dbpath", "", "Set the root path for the database store if using standalone mode.")
 
 	// Custom usage function for the help flag
 	flag.Usage = func() {
 		log.Printf("Usage of %s:\n", os.Args[0])
 		flag.PrintDefaults()
 		log.Println("\nExamples:")
-		log.Println("  go run main.go --loglevel=debug --mode=container")
+		log.Println("go run main.go --loglevel=debug --mode=container --dbpath=/path/to/db_dir")
 	}
 
 	// Parse the flags
@@ -58,6 +64,20 @@ func main() {
 		os.Exit(1)
 	}
 
+	// Process database root if standalone and not provided
+	if *mode == "standalone" && *dbPathRoot == "" {
+		slog.Warn("No database root path provided.")
+		// Current directory of the Executable has a codeql directory. There.
+		// Resolve the absolute directory based on os.Executable()
+		execPath, err := os.Executable()
+		if err != nil {
+			slog.Error("Failed to get executable path", slog.Any("error", err))
+			os.Exit(1)
+		}
+		*dbPathRoot = filepath.Dir(execPath) + "/codeql/dbs/"
+		slog.Info("Using default database root path", "dbPathRoot", *dbPathRoot)
+	}
+
 	// Read configuration
 	config := mcc.LoadConfig("mcconfig.toml")
 
@@ -66,91 +86,73 @@ func main() {
 	log.Printf("Log Level: %s\n", *logLevel)
 	log.Printf("Mode: %s\n", *mode)
 
+	// Handle signals
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
 	// Apply 'mode' flag
 	switch *mode {
 	case "standalone":
 		// Assemble single-process version
-
-		sl := logger.NewLoggerSingle(&logger.Visibles{})
-
-		// FIXME take value from configuration
-		sq := queue.NewQueueSingle(2, &queue.Visibles{
-			Logger: sl,
-		})
-
-		ss := storage.NewStorageSingle(config.Storage.StartingID, &storage.Visibles{})
-
-		qp, err := qpstore.NewStore(&qpstore.Visibles{})
-		if err != nil {
-			slog.Error("Unable to initialize query pack storage")
-			os.Exit(1)
-		}
-
-		ql, err := qldbstore.NewStore(&qldbstore.Visibles{})
-		if err != nil {
-			slog.Error("Unable to initialize ql database storage")
-			os.Exit(1)
-		}
+		sq := queue.NewQueueSingle(2)
+		ss := state.NewLocalState(config.Storage.StartingID)
+		as := artifactstore.NewInMemoryArtifactStore()
+		ql := qldbstore.NewLocalFilesystemCodeQLDatabaseStore(*dbPathRoot)
 
 		server.NewCommanderSingle(&server.Visibles{
-			Logger:         sl,
-			Queue:          sq,
-			ServerStore:    ss,
-			QueryPackStore: qp,
-			QLDBStore:      ql,
+			Queue:         sq,
+			State:         ss,
+			Artifacts:     as,
+			CodeQLDBStore: ql,
 		})
 
-		// FIXME take value from configuration
-		agent.NewAgentSingle(2, &agent.Visibles{
-			Logger:         sl,
-			Queue:          sq,
-			QueryPackStore: qp,
-			QLDBStore:      ql,
-		})
+		var wg sync.WaitGroup
+		ctx, cancel := context.WithCancel(context.Background())
+
+		go agent.StartAndMonitorWorkers(ctx, as, ql, sq, 2, &wg)
+
+		slog.Info("Started server and standalone agent")
+		<-sigChan
+		slog.Info("Shutting down...")
+		cancel()
+		wg.Wait()
+		slog.Info("Agent shutdown complete")
 
 	case "container":
-		// Assemble container version
-		sl := logger.NewLoggerSingle(&logger.Visibles{})
+		isAgent := false
 
-		// FIXME take value from configuration
-		sq := queue.NewQueueSingle(2, &queue.Visibles{
-			Logger: sl,
-		})
-
-		ss := storage.NewStorageSingle(config.Storage.StartingID, &storage.Visibles{})
-
-		qp, err := qpstore.NewStore(&qpstore.Visibles{})
+		rabbitMQQueue, err := deploy.InitRabbitMQ(isAgent)
 		if err != nil {
-			slog.Error("Unable to initialize query pack storage")
+			slog.Error("Failed to initialize RabbitMQ", slog.Any("error", err))
+			os.Exit(1)
+		}
+		defer rabbitMQQueue.Close()
+
+		artifacts, err := deploy.InitMinIOArtifactStore()
+		if err != nil {
+			slog.Error("Failed to initialize artifact store", slog.Any("error", err))
 			os.Exit(1)
 		}
 
-		ql, err := qldbstore.NewStore(&qldbstore.Visibles{})
+		databases, err := deploy.InitMinIOCodeQLDatabaseStore()
 		if err != nil {
-			slog.Error("Unable to initialize ql database storage")
+			slog.Error("Failed to initialize database store", slog.Any("error", err))
 			os.Exit(1)
 		}
 
-		agent.NewAgentSingle(2, &agent.Visibles{
-			Logger:         sl,
-			Queue:          sq,
-			QueryPackStore: qp,
-			QLDBStore:      ql,
-		})
-
 		server.NewCommanderSingle(&server.Visibles{
-			Logger:         sl,
-			Queue:          sq,
-			ServerStore:    ss,
-			QueryPackStore: qp,
-			QLDBStore:      ql,
+			Queue:         rabbitMQQueue,
+			State:         state.NewLocalState(config.Storage.StartingID),
+			Artifacts:     artifacts,
+			CodeQLDBStore: databases,
 		})
 
-	case "cluster":
-		// Assemble cluster version
+		slog.Info("Started server in container mode.")
+		<-sigChan
 	default:
-		slog.Error("Invalid value for --mode. Allowed values are: standalone, container, cluster\n")
+		slog.Error("Invalid value for --mode. Allowed values are: standalone, container, cluster")
 		os.Exit(1)
 	}
 
+	slog.Info("Server shutdown complete")
 }