Merge pull request #8 from chadleeshaw/feature/architecture-refactor

Feature/architecture refactor

Author: chadleeshaw

.gitignore

@@ -2,7 +2,10 @@
 .DS_Store
 .idea
 .codegpt
+.claude
+.grok
 ignite.db
+ignite
 bin
 public/node_modules
 public/http/css/tailwind.css

app/application.go

@@ -0,0 +1,131 @@
+package app
+
+import (
+	"context"
+	"embed"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"ignite/handlers"
+	"ignite/routes"
+	"ignite/tftp"
+)
+
+// Application represents the main application with embedded static files
+type Application struct {
+	container     *Container
+	httpServer    *http.Server
+	tftpServer    *tftp.Server
+	staticFS      embed.FS
+	staticHandler *handlers.StaticHandlers
+}
+
+// NewApplicationWithStatic creates a new application instance with embedded static files
+func NewApplicationWithStatic(staticFS embed.FS) (*Application, error) {
+	container, err := NewContainer()
+	if err != nil {
+		return nil, fmt.Errorf("failed to create container: %w", err)
+	}
+
+	// Create static file handler
+	staticHandler := handlers.NewStaticHandlers(staticFS, container.Config.HTTP.Dir)
+
+	return &Application{
+		container:     container,
+		staticFS:      staticFS,
+		staticHandler: staticHandler,
+	}, nil
+}
+
+// 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)
+	if err := a.tftpServer.Start(); err != nil {
+		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)
+
+	// Setup HTTP handlers with dependency injection
+	handlerContainer := &handlers.Container{
+		ServerService: a.container.ServerService,
+		LeaseService:  a.container.LeaseService,
+		Config:        a.container.Config,
+	}
+
+	// Create HTTP router with injected dependencies and static file handling
+	router := routes.SetupWithContainerAndStatic(handlerContainer, a.staticHandler)
+	log.Printf("Embedded HTTP server configured")
+
+	// Create HTTP server
+	a.httpServer = &http.Server{
+		Addr:    ":" + a.container.Config.HTTP.Port,
+		Handler: router,
+	}
+
+	// Start HTTP server
+	go func() {
+		log.Printf("HTTP API server started on port %s", a.container.Config.HTTP.Port)
+		if err := a.httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("HTTP server failed: %v", err)
+		}
+	}()
+
+	return nil
+}
+
+// Rest of the Application methods remain the same...
+func (a *Application) Stop() error {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	if a.httpServer != nil {
+		if err := a.httpServer.Shutdown(ctx); err != nil {
+			log.Printf("Error shutting down HTTP server: %v", err)
+		}
+	}
+
+	if a.tftpServer != nil {
+		a.tftpServer.Stop()
+	}
+
+	if err := a.container.Close(); err != nil {
+		log.Printf("Error closing container: %v", err)
+	}
+
+	return nil
+}
+
+func (a *Application) Run() error {
+	if err := a.Start(); err != nil {
+		return fmt.Errorf("failed to start application: %w", err)
+	}
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	log.Println("Application started. Press Ctrl+C to stop.")
+	<-quit
+	log.Println("Shutting down application...")
+
+	if err := a.Stop(); err != nil {
+		return fmt.Errorf("failed to stop application: %w", err)
+	}
+
+	log.Println("Application stopped")
+	return nil
+}
+
+// GetContainer returns the application's container for access to services
+func (a *Application) GetContainer() *handlers.Container {
+	return &handlers.Container{
+		ServerService: a.container.ServerService,
+		LeaseService:  a.container.LeaseService,
+		Config:        a.container.Config,
+	}
+}

app/application_test.go

@@ -0,0 +1,20 @@
+package app
+
+import (
+	"embed"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewApplicationWithStatic(t *testing.T) {
+	// Create a simple empty embedded filesystem for testing
+	testFS := embed.FS{}
+	app, err := NewApplicationWithStatic(testFS)
+	assert.NoError(t, err)
+	assert.NotNil(t, app)
+	assert.NotNil(t, app.GetContainer())
+	assert.NotNil(t, app.GetContainer().ServerService)
+	assert.NotNil(t, app.GetContainer().LeaseService)
+	assert.NotNil(t, app.GetContainer().Config)
+}

app/container.go

@@ -0,0 +1,58 @@
+package app
+
+import (
+	"fmt"
+	"ignite/config"
+	"ignite/db"
+	"ignite/dhcp"
+)
+
+// Container holds all application dependencies
+type Container struct {
+	Config        *config.Config
+	Database      db.Database
+	ServerRepo    dhcp.ServerRepository
+	LeaseRepo     dhcp.LeaseRepository
+	ServerService dhcp.ServerService
+	LeaseService  dhcp.LeaseService
+}
+
+// NewContainer creates and wires up all dependencies
+func NewContainer() (*Container, error) {
+	// Load configuration
+	cfg, err := config.LoadDefault()
+	if err != nil {
+		return nil, fmt.Errorf("failed to load configuration: %w", err)
+	}
+
+	// Initialize database
+	database, err := db.NewBoltDB(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize database: %w", err)
+	}
+
+	// Create repositories
+	serverRepo := dhcp.NewBoltServerRepository(database, cfg.DB.Bucket+"_servers")
+	leaseRepo := dhcp.NewBoltLeaseRepository(database, cfg.DB.Bucket+"_leases")
+
+	// Create services
+	serverService := dhcp.NewDHCPServerService(serverRepo, leaseRepo)
+	leaseService := dhcp.NewDHCPLeaseService(leaseRepo, serverRepo)
+
+	return &Container{
+		Config:        cfg,
+		Database:      database,
+		ServerRepo:    serverRepo,
+		LeaseRepo:     leaseRepo,
+		ServerService: serverService,
+		LeaseService:  leaseService,
+	}, nil
+}
+
+// Close closes all resources held by the container
+func (c *Container) Close() error {
+	if c.Database != nil {
+		return c.Database.Close()
+	}
+	return nil
+}

app/container_test.go

@@ -0,0 +1,17 @@
+package app
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewContainer(t *testing.T) {
+	container, err := NewContainer()
+	assert.NoError(t, err)
+	assert.NotNil(t, container)
+	assert.NotNil(t, container.Database)
+	assert.NotNil(t, container.ServerService)
+	assert.NotNil(t, container.LeaseService)
+	assert.NotNil(t, container.Config)
+}

app/static.go

@@ -0,0 +1,36 @@
+package app
+
+import (
+	"embed"
+	"io/fs"
+	"net/http"
+)
+
+// StaticFileSystem wraps embed.FS for serving static files
+type StaticFileSystem struct {
+	embedFS embed.FS
+	prefix  string
+}
+
+// NewStaticFileSystem creates a new static file system
+func NewStaticFileSystem(embedFS embed.FS, prefix string) *StaticFileSystem {
+	return &StaticFileSystem{
+		embedFS: embedFS,
+		prefix:  prefix,
+	}
+}
+
+// Open implements fs.FS interface
+func (sfs *StaticFileSystem) Open(name string) (fs.File, error) {
+	return sfs.embedFS.Open(sfs.prefix + "/" + name)
+}
+
+// HTTPHandler returns an http.Handler for serving static files
+func (sfs *StaticFileSystem) HTTPHandler() http.Handler {
+	return http.FileServer(http.FS(sfs))
+}
+
+// StripPrefix returns a handler that strips the prefix from the URL path
+func (sfs *StaticFileSystem) StripPrefixHandler(prefix string) http.Handler {
+	return http.StripPrefix(prefix, sfs.HTTPHandler())
+}