Restyle the web UI with Cozy and Console themes

.gitignore

@@ -13,6 +13,7 @@ vmlinuz
 bin
 public/tftp/*
 public/node_modules
+scripts/node_modules
 public/http/css/tailwind.css
 public/tftp/pxelinux.cfg/*
 public/provision/configs/cloud-init/*

Dockerfile.release

@@ -21,21 +21,26 @@ WORKDIR /app
 
 # Download the pre-built binary from GitHub release
 # Use curl with follow redirects for better GitHub releases handling
-RUN curl -L -o ./ignite https://github.com/chadleeshaw/ignite/releases/download/v2.0.0/ignite-linux-amd64 && \
+RUN curl -L -o ./ignite https://github.com/chadleeshaw/ignite/releases/download/v3.0.0/ignite-linux-amd64 && \
     chmod +x ./ignite
 
 # Copy public files
 COPY --chown=ignite:ignite ./public ./public
 
-# Create data directory for database
+# Create the data directory before the volume so a new named volume is
+# owned by ignite (uid 1001). The database and Syslinux cache live here.
 RUN mkdir -p /app/data && chown ignite:ignite /app/data
+VOLUME /app/data
+
+# Declared after COPY so a new named volume is seeded from ./public/tftp.
+VOLUME /app/public/tftp
 
 # Switch to non-root user
 USER ignite
 
 EXPOSE 8080
 
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8080/status || exit 1
+    CMD curl -f http://localhost:${HTTP_PORT}/ || exit 1
 
 CMD ["./ignite"]

app/application.go

@@ -8,9 +8,12 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
+	"strconv"
 	"syscall"
 	"time"
 
+	"ignite/config"
+	"ignite/dhcp"
 	"ignite/handlers"
 	"ignite/routes"
 	"ignite/tftp"
@@ -25,6 +28,11 @@ type Application struct {
 	tftpServer       *tftp.Server
 	staticFS         embed.FS
 	staticHandler    *handlers.StaticHandlers
+
+	// rootCancel cancels the process-wide context passed to background work.
+	// Stop calls it so the lease maintainer observes cancellation.
+	rootCancel context.CancelFunc
+	maintainer *dhcp.LeaseMaintainer
 }
 
 // NewApplicationWithStatic creates a new application instance with embedded static files
@@ -45,7 +53,12 @@ func NewApplicationWithStatic(staticFS embed.FS) (*Application, error) {
 		SyslinuxService: container.SyslinuxService,
 		IPXEService:     container.IPXEService,
 		Config:          container.Config,
+		Prefs:           container.Prefs,
 	}
+	handlers.SetPreferenceStore(container.Prefs)
+	handlers.SetPageHealth(func(r *http.Request) string {
+		return handlers.NewStatusHandlers(handlerContainer).CurrentOverallStatus(r)
+	})
 
 	return &Application{
 		container:        container,
@@ -58,12 +71,61 @@ func NewApplicationWithStatic(staticFS embed.FS) (*Application, error) {
 
 // Start starts all application services including static file serving
 func (a *Application) Start() error {
-	// Start TFTP server
-	a.tftpServer = tftp.NewServer(a.container.Config.TFTP.Dir)
+	rootCtx, rootCancel := context.WithCancel(context.Background())
+	a.rootCancel = rootCancel
+	a.maintainer = dhcp.NewLeaseMaintainer(
+		a.container.LeaseService,
+		dhcp.DefaultMaintenanceInterval,
+		dhcp.DefaultOfflineThreshold,
+	)
+	a.maintainer.Start(rootCtx)
+
+	// Start TFTP server. Record the outcome so status never stays "unknown"
+	// after a start attempt, including a failed bind.
+	tftpRoot, err := config.ResolveTFTPRoot(a.container.Config.TFTP.Dir)
+	if err != nil {
+		handlers.SetTFTPRunning(false)
+		a.stopMaintenance()
+		return fmt.Errorf("failed to resolve TFTP root: %w", err)
+	}
+	for _, line := range tftpRoot.StartupLines() {
+		log.Print(line)
+	}
+	a.container.Config.TFTP.Dir = tftpRoot.Path
+	handlers.SetTFTPRoot(tftpRoot.Path)
+	handlers.SetTFTPDisplayRoot(tftpRoot.Display)
+	if a.container.SyslinuxService != nil {
+		slCfg := a.container.SyslinuxService.GetConfig()
+		slCfg.TFTPDir = tftpRoot.Path
+		_ = a.container.SyslinuxService.UpdateConfig(rootCtx, slCfg)
+		log.Printf("Syslinux cache: %s", slCfg.TempDir)
+	}
+	tftpPort, err := strconv.Atoi(a.container.Config.TFTP.Port)
+	if err != nil {
+		handlers.SetTFTPRunning(false)
+		a.stopMaintenance()
+		return fmt.Errorf("invalid TFTP port %q: %w", a.container.Config.TFTP.Port, err)
+	}
+	a.tftpServer = tftp.NewServerWithPort(tftpRoot.Path, tftpPort)
 	if err := a.tftpServer.Start(); err != nil {
+		handlers.SetTFTPRunning(false)
+		a.stopMaintenance()
 		return fmt.Errorf("failed to start TFTP server: %w", err)
 	}
-	log.Printf("TFTP server started on port 69, serving from %s", a.container.Config.TFTP.Dir)
+	handlers.SetTFTPRunning(true)
+	log.Printf("TFTP server started on port %d, serving from %s", tftpPort, a.container.Config.TFTP.Dir)
+	if a.container.Config.DHCP.Enabled {
+		dhcp.SetListenersEnabled(true)
+	} else {
+		dhcp.SetListenersEnabled(false)
+		log.Print("DHCP is disabled")
+	}
+	log.Print(config.BMCTLSModeLog(a.container.Config.BMC.TLSVerify))
+
+	// Every page gets the same overall service word as the Overview pill.
+	handlers.SetPageHealth(func(r *http.Request) string {
+		return handlers.NewStatusHandlers(a.handlerContainer).CurrentOverallStatus(r)
+	})
 
 	// Create HTTP router with injected dependencies and static file handling
 	router := routes.SetupWithContainerAndStatic(a.handlerContainer, a.staticHandler)
@@ -90,8 +152,24 @@ func (a *Application) Start() error {
 	return nil
 }
 
-// Rest of the Application methods remain the same...
+// stopMaintenance cancels the application context and waits for the lease
+// maintainer to finish. It is safe to call more than once.
+func (a *Application) stopMaintenance() {
+	if a.rootCancel != nil {
+		a.rootCancel()
+		a.rootCancel = nil
+	}
+	if a.maintainer != nil {
+		a.maintainer.Stop()
+		a.maintainer = nil
+	}
+}
+
 func (a *Application) Stop() error {
+	// Cancel background work first and wait for the lease maintainer to
+	// leave the database alone before the rest of shutdown closes it.
+	a.stopMaintenance()
+
 	// Stop any running DHCP servers first
 	if a.container.ServerService != nil {
 		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
@@ -121,6 +199,7 @@ func (a *Application) Stop() error {
 
 	if a.tftpServer != nil {
 		a.tftpServer.Stop()
+		handlers.SetTFTPRunning(false)
 	}
 
 	if err := a.container.Close(); err != nil {

app/application_test.go

@@ -2,19 +2,53 @@ package app
 
 import (
 	"embed"
+	"net"
+	"path/filepath"
+	"strconv"
 	"testing"
 
+	"ignite/handlers"
+
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewApplicationWithStatic(t *testing.T) {
+	t.Setenv("DB_PATH", t.TempDir())
 	// Create a simple empty embedded filesystem for testing
 	testFS := embed.FS{}
 	app, err := NewApplicationWithStatic(testFS)
-	assert.NoError(t, err)
-	assert.NotNil(t, app)
+	require.NoError(t, err)
+	require.NotNil(t, app)
+	t.Cleanup(func() { _ = app.Stop() })
 	assert.NotNil(t, app.GetContainer())
 	assert.NotNil(t, app.GetContainer().ServerService)
 	assert.NotNil(t, app.GetContainer().LeaseService)
 	assert.NotNil(t, app.GetContainer().Config)
 }
+
+func TestStartAndStopRecordTFTPStatus(t *testing.T) {
+	t.Setenv("DB_PATH", t.TempDir())
+	t.Setenv("DB_FILE", "tftp-status.db")
+	t.Setenv("HTTP_PORT", "18081")
+	t.Setenv("TFTP_DIR", filepath.Join(t.TempDir(), "tftp"))
+	probe, err := net.ListenUDP("udp4", &net.UDPAddr{Port: 0})
+	require.NoError(t, err)
+	tftpPort := probe.LocalAddr().(*net.UDPAddr).Port
+	require.NoError(t, probe.Close())
+	t.Setenv("TFTP_PORT", strconv.Itoa(tftpPort))
+
+	app, err := NewApplicationWithStatic(embed.FS{})
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = app.Stop() })
+
+	err = app.Start()
+	if err != nil {
+		require.Equal(t, "stopped", handlers.TFTPStatus())
+		return
+	}
+	require.Equal(t, ":18081", app.httpServer.Addr)
+	require.Equal(t, "running", handlers.TFTPStatus())
+	require.NoError(t, app.Stop())
+	require.Equal(t, "stopped", handlers.TFTPStatus())
+}

app/container.go

@@ -5,6 +5,7 @@ import (
 	"ignite/config"
 	"ignite/db"
 	"ignite/dhcp"
+	"ignite/handlers"
 	"ignite/ipxe"
 	"ignite/osimage"
 	"ignite/syslinux"
@@ -24,6 +25,7 @@ type Container struct {
 	SyslinuxRepo       syslinux.Repository
 	SyslinuxService    syslinux.Service
 	IPXEService        *ipxe.Service
+	Prefs              handlers.PreferenceStore
 }
 
 // NewContainer creates and wires up all dependencies
@@ -49,8 +51,14 @@ func NewContainer() (c *Container, err error) {
 	// Create repositories
 	serverRepo := dhcp.NewBoltServerRepository(database, cfg.DB.Bucket+"_servers")
 	leaseRepo := dhcp.NewBoltLeaseRepository(database, cfg.DB.Bucket+"_leases")
-	osImageRepo := osimage.NewOSImageRepository(database)
-	downloadStatusRepo := osimage.NewDownloadStatusRepository(database)
+	osImageRepo, err := osimage.NewOSImageRepository(database)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create os image repository: %w", err)
+	}
+	downloadStatusRepo, err := osimage.NewDownloadStatusRepository(database)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create download status repository: %w", err)
+	}
 	syslinuxRepo, err := syslinux.NewBoltRepository(database)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create syslinux repository: %w", err)
@@ -60,8 +68,20 @@ func NewContainer() (c *Container, err error) {
 	serverService := dhcp.NewDHCPServerService(serverRepo, leaseRepo)
 	leaseService := dhcp.NewDHCPLeaseService(leaseRepo, serverRepo)
 	osImageService := osimage.NewOSImageService(osImageRepo, downloadStatusRepo, cfg)
-	syslinuxService := syslinux.NewService(syslinuxRepo, syslinux.GetDefaultConfig())
+	cacheDir, err := config.ResolveSyslinuxCacheDir(cfg.DB.DBPath, cfg.Syslinux.CacheDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve syslinux cache: %w", err)
+	}
+	cfg.Syslinux.CacheDir = cacheDir
+	slCfg := syslinux.GetDefaultConfig()
+	slCfg.TFTPDir = cfg.TFTP.Dir
+	slCfg.TempDir = cacheDir
+	syslinuxService := syslinux.NewService(syslinuxRepo, slCfg)
 	ipxeService := ipxe.NewService(cfg, osImageService)
+	prefs, err := handlers.NewBoltPreferenceStore(database, cfg.DB.Bucket+"_prefs")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create preference store: %w", err)
+	}
 
 	c = &Container{
 		Config:             cfg,
@@ -76,6 +96,7 @@ func NewContainer() (c *Container, err error) {
 		SyslinuxRepo:       syslinuxRepo,
 		SyslinuxService:    syslinuxService,
 		IPXEService:        ipxeService,
+		Prefs:              prefs,
 	}
 	return c, nil
 }

app/container_test.go

@@ -2,9 +2,11 @@ package app
 
 import (
 	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewContainer(t *testing.T) {
@@ -30,6 +32,12 @@ func TestNewContainer(t *testing.T) {
 	assert.NotNil(t, container.ServerService)
 	assert.NotNil(t, container.LeaseService)
 	assert.NotNil(t, container.Config)
+	wantCache, err := filepath.Abs(filepath.Join(tempDir, "syslinux"))
+	require.NoError(t, err)
+	assert.Equal(t, wantCache, container.SyslinuxService.GetConfig().TempDir)
+	info, err := os.Stat(wantCache)
+	require.NoError(t, err)
+	assert.True(t, info.IsDir())
 
 	// Clean up
 	container.Close()