Merge pull request #2 from danielsobrado/copilot/stabilize-startup-error-handling

Startup/config/error handling stability

Author: danielsobrado

.gitignore

@@ -2,7 +2,7 @@
 node_modules/
 data/postgres/
 frontend/node_modules/
-dist/
+/dist/
 .cache/
 build/bin/
 data/keys/

app.go

@@ -64,62 +64,56 @@ type ActiveTransfer struct {
 	Speed       float64 `json:"speed"`
 }
 
-// NewApp creates a new application instance
-func NewApp() *App {
-	logger, _ := zap.NewProduction()
+// NewApp creates a new application instance using the provided configuration.
+// cfg must not be nil; callers should load it via config.Load or config.LoadDefaults.
+// Returns an error if logger creation or directory setup fails.
+func NewApp(cfg *config.Config) (*App, error) {
+	if cfg == nil {
+		return nil, errors.New("config must not be nil")
+	}
+
+	// Build logger from configuration.
+	var zapLogger *zap.Logger
+	var err error
+	if cfg.IsDevelopment() {
+		zapLogger, err = zap.NewDevelopment()
+	} else {
+		zapLogger, err = zap.NewProduction()
+	}
+	if err != nil {
+		return nil, fmt.Errorf("creating logger: %w", err)
+	}
+
 	ctx, cancel := context.WithCancel(context.Background())
 
-	// Create data directories
+	// Create data directories needed by the embedded Postgres runtime and scripts.
 	dirs := []string{
 		"./data",
 		"./data/postgres",
 		"./data/scripts",
 		"./data/keys",
 	}
-
 	for _, dir := range dirs {
 		if err := os.MkdirAll(dir, 0755); err != nil {
-			logger.Fatal("Failed to create directory",
-				zap.String("dir", dir),
-				zap.Error(err))
+			cancel()
+			_ = zapLogger.Sync()
+			return nil, fmt.Errorf("creating directory %q: %w", dir, err)
 		}
 	}
 
-	// Create default configuration
-	cfg := &config.Config{
-		Database: config.DatabaseConfig{
-			Type:           "postgres",
-			Port:           5433,
-			MaxConnections: 10,
-			MinConnections: 2,
-			SSLMode:        "disable",
-		},
-		P2P: config.P2PConfig{
-			Port:           4001,
-			MaxPeers:       50,
-			MinPeers:       5,
-			PeerTimeout:    30 * time.Second,
-			BootstrapPeers: []string{},
-		},
-		Scripts: config.ScriptConfig{
-			ScriptDir:   "./data/scripts",
-			PythonPath:  "python3",
-			MaxExecTime: 5 * time.Minute,
-			MaxMemoryMB: 512,
-			AllowedPkgs: []string{"pandas", "numpy", "requests"},
-		},
-		Security: config.SecurityConfig{
-			KeyFile: "./data/keys/host.key",
-		},
+	// Ensure the script directory points at the embedded data layout when the
+	// config is still using the generic default value.
+	if cfg.Scripts.ScriptDir == "scripts" {
+		cfg.Scripts.ScriptDir = "./data/scripts"
 	}
 
 	return &App{
 		ctx:     ctx,
 		cancel:  cancel,
-		logger:  logger,
+		logger:  zapLogger,
 		config:  cfg,
 		cleanup: make([]func() error, 0),
-	}
+	}, nil
 }
 
 func (a *App) startup(ctx context.Context) {
@@ -134,39 +128,62 @@ func (a *App) startup(ctx context.Context) {
 
 	// Initialize embedded database
 	if err := a.initEmbeddedDB(); err != nil {
-		a.logger.Fatal("Failed to initialize embedded database", zap.Error(err))
+		a.logger.Error("Failed to initialize embedded database", zap.Error(err))
 		return
 	}
 
 	// Initialize database connection
 	if err := a.initDatabase(ctx); err != nil {
-		a.logger.Fatal("Failed to initialize database", zap.Error(err))
+		a.logger.Error("Failed to initialize database", zap.Error(err))
+		a.cleanupEmbeddedDB()
 		return
 	}
 
 	// Initialize database schema for a fresh embedded database instance
 	if err := data.NewSchemaManager(a.conn).InitializeSchema(ctx); err != nil {
-		a.logger.Fatal("Failed to initialize database schema", zap.Error(err))
+		a.logger.Error("Failed to initialize database schema", zap.Error(err))
+		a.cleanupDBResources(ctx)
 		return
 	}
 
 	// Initialize repository
 	a.repo, err = data.NewPostgresRepository(ctx, a.conn, a.logger)
 	if err != nil {
-		a.logger.Fatal("Failed to create repository", zap.Error(err))
+		a.logger.Error("Failed to create repository", zap.Error(err))
+		a.cleanupDBResources(ctx)
 		return
 	}
 
 	// Initialize and start services
 	if err := a.initServices(ctx); err != nil {
-		a.logger.Fatal("Failed to initialize services", zap.Error(err))
+		a.logger.Error("Failed to initialize services", zap.Error(err))
+		a.cleanupDBResources(ctx)
 		return
 	}
 
 	a.running = true
 	a.logger.Info("Application started successfully")
 }
 
+// cleanupEmbeddedDB stops the embedded Postgres instance if it was started.
+func (a *App) cleanupEmbeddedDB() {
+	if a.embedded != nil {
+		if err := a.embedded.Stop(); err != nil {
+			a.logger.Error("Failed to stop embedded database during cleanup", zap.Error(err))
+		}
+	}
+}
+
+// cleanupDBResources closes the database connection and stops the embedded
+// Postgres instance. Called on partial startup failure.
+func (a *App) cleanupDBResources(ctx context.Context) {
+	if a.conn != nil {
+		a.conn.Close(ctx)
+		a.conn = nil
+	}
+	a.cleanupEmbeddedDB()
+}
+
 func (a *App) initEmbeddedDB() error {
 	pg := postgres.NewDatabase(
 		postgres.DefaultConfig().

cmd/app/main.go

@@ -86,15 +86,17 @@ func initializeApp(ctx context.Context, cfg *config.Config, logger *zap.Logger)
 		return nil, fmt.Errorf("initializing database service: %w", err)
 	}
 
-	// Initialize script manager
-	scriptConfig := &config.ScriptConfig{
-		ScriptDir: filepath.Join(*dataDir, "scripts"),
-		// Add other required config fields
+	// Override the script directory when --data-dir is set so the layout is
+	// consistent with the rest of the application.  Only override if the caller
+	// explicitly specified a non-default data directory.
+	scriptsCfg := cfg.Scripts
+	if *dataDir != "./data" {
+		scriptsCfg.ScriptDir = filepath.Join(*dataDir, "scripts")
 	}
 
-	scriptManager, err := scripts.NewScriptManager(scriptConfig, logger)
+	scriptManager, err := scripts.NewScriptManager(&scriptsCfg, logger)
 	if err != nil {
-		logger.Fatal("Failed to initialize script manager", zap.Error(err))
+		return nil, fmt.Errorf("initializing script manager: %w", err)
 	}
 
 	app := &App{
@@ -181,15 +183,6 @@ func loadConfig(path string) (*config.Config, error) {
 	if err != nil {
 		return nil, fmt.Errorf("loading config: %w", err)
 	}
-
-	// Set default values
-	if cfg.Database.Port == 0 {
-		cfg.Database.Port = 5433
-	}
-	if cfg.P2P.Port == 0 {
-		cfg.P2P.Port = 4001
-	}
-
 	return cfg, nil
 }
 

frontend/.gitignore

@@ -8,7 +8,8 @@ pnpm-debug.log*
 lerna-debug.log*
 
 node_modules
-dist
+dist/*
+!dist/.gitkeep
 dist-ssr
 *.local
 
@@ -22,3 +23,4 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
+!dist/index.html

frontend/dist/.gitkeep

@@ -0,0 +1 @@
+<!DOCTYPE html><html><body>P2P Market Data</body></html>

frontend/dist/index.html

@@ -4,13 +4,17 @@ package main
 import (
 	"embed"
 	"log"
+	"os"
+	"strings"
 
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/logger"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
 	"github.com/wailsapp/wails/v2/pkg/options/mac"
 	"github.com/wailsapp/wails/v2/pkg/options/windows"
+
+	"p2p_market_data/pkg/config"
 )
 
 //go:embed frontend/dist
@@ -20,14 +24,24 @@ var assets embed.FS
 var icon []byte
 
 func main() {
-	// Create configuration with defaults
-	// cfg := config.DefaultConfig()
+	// Load configuration; both Wails options and the App struct share this instance.
+	cfg, err := loadWailsConfig()
+	if err != nil {
+		log.Printf("Warning: could not load config (%v), falling back to defaults", err)
+		cfg, err = config.LoadDefaults()
+		if err != nil {
+			log.Fatalf("Failed to load default configuration: %v", err)
+		}
+	}
 
 	// Create an instance of the app structure
-	app := NewApp()
+	app, err := NewApp(cfg)
+	if err != nil {
+		log.Fatalf("Failed to create application: %v", err)
+	}
 
 	// Create application with options
-	err := wails.Run(&options.App{
+	err = wails.Run(&options.App{
 		Title:     "P2P Market Data",
 		Width:     1280,
 		Height:    930,
@@ -50,8 +64,8 @@ func main() {
 		OnBeforeClose: app.beforeClose,
 		OnShutdown:    app.shutdown,
 
-		// Enable dev tools in debug mode
-		LogLevel: determineLogLevel(),
+		// Log level driven by configuration, not hardcoded.
+		LogLevel: wailsLogLevel(cfg),
 
 		// Window configuration
 		Windows: &windows.Options{
@@ -85,7 +99,36 @@ func main() {
 	}
 }
 
-func determineLogLevel() logger.LogLevel {
-	// You could make this configurable via environment variables
-	return logger.DEBUG
+// loadWailsConfig tries to load configuration from well-known paths relative to
+// the working directory. If no config file is found it falls back to defaults.
+func loadWailsConfig() (*config.Config, error) {
+	candidates := []string{
+		"./config.yaml",
+		"./config/config.yaml",
+		"./config/db_config.yaml",
+	}
+	for _, path := range candidates {
+		if _, err := os.Stat(path); err == nil {
+			return config.Load(path)
+		}
+	}
+	return config.LoadDefaults()
+}
+
+// wailsLogLevel maps the config log-level string to the Wails logger.LogLevel
+// type.  Defaults to INFO when the level is unrecognised or the config is nil.
+func wailsLogLevel(cfg *config.Config) logger.LogLevel {
+	if cfg == nil {
+		return logger.INFO
+	}
+	switch strings.ToLower(cfg.LogLevel) {
+	case "debug":
+		return logger.DEBUG
+	case "warn", "warning":
+		return logger.WARNING
+	case "error":
+		return logger.ERROR
+	default:
+		return logger.INFO
+	}
 }

main.go

@@ -152,6 +152,7 @@ func setDefaults(v *viper.Viper) {
 	// Database defaults
 	v.SetDefault("database.type", "postgres")
 	v.SetDefault("database.url", "postgres://postgres:postgres@localhost:5433/market_data?sslmode=disable")
+	v.SetDefault("database.port", 5433)
 	v.SetDefault("database.max_conns", 10)
 	v.SetDefault("database.min_conns", 2)
 	v.SetDefault("database.timeout", "30s")
@@ -279,6 +280,26 @@ func (c *Config) validateSecurity() error {
 	return nil
 }
 
+// LoadDefaults returns a Config populated from defaults and environment variables
+// only, without reading any config file. Useful as a fallback when no config
+// file is available.
+func LoadDefaults() (*Config, error) {
+	v := viper.New()
+	setDefaults(v)
+	v.SetEnvPrefix("P2P")
+	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	v.AutomaticEnv()
+
+	cfg := &Config{}
+	if err := v.Unmarshal(cfg); err != nil {
+		return nil, fmt.Errorf("failed to parse default config: %w", err)
+	}
+	if err := cfg.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid default configuration: %w", err)
+	}
+	return cfg, nil
+}
+
 // GetLogLevel returns a zap log level based on the configured string
 func (c *Config) GetLogLevel() zap.AtomicLevel {
 	level := zap.NewAtomicLevel()