chore: plugin system for custom middlewares

Author: mirkobrombin

README.md

@@ -121,7 +121,7 @@ Each site configuration is represented by a JSON file and meets the following st
   "port": 8080,
   "root_directory": "/path/to/root",
   "custom_headers": {
-    "X-Custom-Header": "Value"
+      "X-Domain-Name": "example.com"
   },
   "proxy_pass": "http://localhost:3000",
   "ssl": {

cmd/goup/main.go

@@ -2,8 +2,15 @@ package main
 
 import (
 	"github.com/mirkobrombin/goup/internal/cli"
+	"github.com/mirkobrombin/goup/internal/plugin"
+	"github.com/mirkobrombin/goup/plugins"
 )
 
 func main() {
+	pluginManager := plugin.GetPluginManagerInstance()
+
+	// Register your plugins here:
+	pluginManager.Register(&plugins.CustomHeaderPlugin{})
+
 	cli.Execute()
 }

internal/cli/cli.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/mirkobrombin/goup/internal/config"
+	"github.com/mirkobrombin/goup/internal/plugin"
 	"github.com/mirkobrombin/goup/internal/server"
 	"github.com/spf13/cobra"
 )
@@ -33,8 +34,8 @@ func init() {
 	rootCmd.AddCommand(startCmd)
 	rootCmd.AddCommand(validateCmd)
 	rootCmd.AddCommand(listCmd)
+	rootCmd.AddCommand(pluginsCmd)
 
-	// Add the --tui flag to the start command
 	startCmd.Flags().BoolVarP(&tuiMode, "tui", "t", false, "Enable TUI mode")
 }
 
@@ -203,3 +204,22 @@ func list(cmd *cobra.Command, args []string) {
 		fmt.Printf("- %s (port %d)\n", conf.Domain, conf.Port)
 	}
 }
+
+var pluginsCmd = &cobra.Command{
+	Use:   "plugins",
+	Short: "List all registered plugins",
+	Run: func(cmd *cobra.Command, args []string) {
+		pluginManager := plugin.GetPluginManagerInstance()
+		plugins := pluginManager.GetRegisteredPlugins()
+
+		if len(plugins) == 0 {
+			fmt.Println("No plugins registered.")
+			return
+		}
+
+		fmt.Println("Registered plugins:")
+		for _, name := range plugins {
+			fmt.Printf("- %s\n", name)
+		}
+	},
+}

internal/plugin/plugin.go

@@ -0,0 +1,65 @@
+package plugin
+
+import (
+	"sync"
+
+	"github.com/mirkobrombin/goup/internal/server/middleware"
+)
+
+// Plugin defines the interface for GoUP plugins.
+type Plugin interface {
+	Name() string
+	Init(mwManager *middleware.MiddlewareManager) error
+}
+
+// PluginManager manages loading and initialization of plugins.
+type PluginManager struct {
+	plugins []Plugin
+	mu      sync.Mutex
+}
+
+// Singleton PluginManagerInstance.
+var pluginManagerInstance *PluginManager
+var once sync.Once
+
+// GetPluginManagerInstance returns the singleton instance of PluginManager.
+func GetPluginManagerInstance() *PluginManager {
+	once.Do(func() {
+		pluginManagerInstance = &PluginManager{
+			plugins: []Plugin{},
+		}
+	})
+	return pluginManagerInstance
+}
+
+// Register registers a new plugin.
+func (pm *PluginManager) Register(plugin Plugin) {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+	pm.plugins = append(pm.plugins, plugin)
+}
+
+// InitPlugins initializes all registered plugins.
+func (pm *PluginManager) InitPlugins(mwManager *middleware.MiddlewareManager) error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	for _, plugin := range pm.plugins {
+		if err := plugin.Init(mwManager); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetRegisteredPlugins returns the registered plugins.
+func (pm *PluginManager) GetRegisteredPlugins() []string {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	names := make([]string, len(pm.plugins))
+	for i, plugin := range pm.plugins {
+		names[i] = plugin.Name()
+	}
+	return names
+}

internal/plugin/plugin_test.go

@@ -0,0 +1,35 @@
+package plugin
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/mirkobrombin/goup/internal/server/middleware"
+	"github.com/mirkobrombin/goup/plugins"
+)
+
+func TestPluginManager(t *testing.T) {
+	pluginManager := GetPluginManagerInstance()
+
+	pluginManager.Register(&plugins.CustomHeaderPlugin{})
+
+	mwManager := middleware.NewMiddlewareManager()
+	err := pluginManager.InitPlugins(mwManager)
+	if err != nil {
+		t.Fatalf("Failed to initialize plugin: %v", err)
+	}
+
+	handler := mwManager.Apply(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+
+	req := httptest.NewRequest("GET", "http://example.com", nil)
+	rec := httptest.NewRecorder()
+
+	handler.ServeHTTP(rec, req)
+
+	if rec.Header().Get("X-GoUP-Header") != "GoUP" {
+		t.Errorf("Expected X-GoUP-Header to be 'GoUP', got '%s'", rec.Header().Get("X-GoUP-Header"))
+	}
+}

internal/server/handler.go

@@ -18,7 +18,7 @@ func createHandler(conf config.SiteConfig, logger *log.Logger, identifier string
 	var handler http.Handler
 
 	if conf.ProxyPass != "" {
-		// Set up reverse proxy handler if ProxyPass is set
+		// Set up reverse proxy handler if ProxyPass is set.
 		proxyURL, err := url.Parse(conf.ProxyPass)
 		if err != nil {
 			return nil, fmt.Errorf("invalid proxy URL: %v", err)
@@ -29,17 +29,21 @@ func createHandler(conf config.SiteConfig, logger *log.Logger, identifier string
 			proxy.ServeHTTP(w, r)
 		})
 	} else {
-		// Serve static files
+		// Serve static files from the root directory.
 		fs := http.FileServer(http.Dir(conf.RootDirectory))
 		handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			addCustomHeaders(w, conf.CustomHeaders)
 			fs.ServeHTTP(w, r)
 		})
 	}
 
-	// Wrap with logging and timeout middleware
+	// Set up site-specific middleware.
+	mwManager := middleware.NewMiddlewareManager()
 	timeout := time.Duration(conf.RequestTimeout) * time.Second
-	handler = middleware.TimeoutMiddleware(timeout, middleware.LoggingMiddleware(logger, conf.Domain, identifier, handler))
+	mwManager.Use(middleware.TimeoutMiddleware(timeout))
+	mwManager.Use(middleware.LoggingMiddleware(logger, conf.Domain, identifier))
+
+	handler = mwManager.Apply(handler)
 
 	return handler, nil
 }
@@ -50,7 +54,7 @@ func addCustomHeaders(w http.ResponseWriter, headers map[string]string) {
 		w.Header().Set(key, value)
 	}
 
-	// Expose the custom headers to the client. Should be safe (?)
+	// Expose custom headers to the client.
 	exposeHeaders := []string{}
 	for key := range headers {
 		exposeHeaders = append(exposeHeaders, key)

internal/server/middleware/manager.go

@@ -0,0 +1,31 @@
+package middleware
+
+import "net/http"
+
+// MiddlewareFunc represents the type for middleware functions.
+type MiddlewareFunc func(http.Handler) http.Handler
+
+// MiddlewareManager manages a chain of middleware.
+type MiddlewareManager struct {
+	middleware []MiddlewareFunc
+}
+
+// NewMiddlewareManager creates a new instance of MiddlewareManager.
+func NewMiddlewareManager() *MiddlewareManager {
+	return &MiddlewareManager{
+		middleware: []MiddlewareFunc{},
+	}
+}
+
+// Use adds a middleware function to the chain.
+func (m *MiddlewareManager) Use(mw MiddlewareFunc) {
+	m.middleware = append(m.middleware, mw)
+}
+
+// Apply applies all registered middleware to a handler.
+func (m *MiddlewareManager) Apply(handler http.Handler) http.Handler {
+	for i := len(m.middleware) - 1; i >= 0; i-- {
+		handler = m.middleware[i](handler)
+	}
+	return handler
+}

internal/server/middleware/middleware.go

@@ -9,44 +9,49 @@ import (
 )
 
 // LoggingMiddleware logs HTTP requests.
-func LoggingMiddleware(logger *log.Logger, domain string, identifier string, next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		start := time.Now()
-
-		rw := &responseWriter{ResponseWriter: w, statusCode: 200}
-
-		next.ServeHTTP(rw, r)
-
-		duration := time.Since(start)
-
-		entry := logger.WithFields(log.Fields{
-			"domain":      domain,
-			"identifier":  identifier,
-			"method":      r.Method,
-			"url":         r.URL.String(),
-			"remote_addr": r.RemoteAddr,
-			"status_code": rw.statusCode,
-			"duration":    duration.Seconds(),
+func LoggingMiddleware(logger *log.Logger, domain string, identifier string) MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
+
+			rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
+
+			next.ServeHTTP(rw, r)
+
+			duration := time.Since(start)
+
+			entry := logger.WithFields(log.Fields{
+				"domain":      domain,
+				"identifier":  identifier,
+				"method":      r.Method,
+				"url":         r.URL.String(),
+				"remote_addr": r.RemoteAddr,
+				"status_code": rw.statusCode,
+				"duration":    duration.Seconds(),
+			})
+			entry.Info("Handled request")
+
+			if tui.IsEnabled() {
+				tui.UpdateLog(identifier, entry)
+			}
 		})
-		entry.Info("Handled request")
-
-		if tui.IsEnabled() {
-			tui.UpdateLog(identifier, entry)
-		}
-	})
+	}
 }
 
 // TimeoutMiddleware applies a timeout to HTTP requests.
-func TimeoutMiddleware(timeout time.Duration, next http.Handler) http.Handler {
-	return http.TimeoutHandler(next, timeout, "Request timed out")
+func TimeoutMiddleware(timeout time.Duration) MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.TimeoutHandler(next, timeout, "Request timed out")
+	}
 }
 
-// responseWriter is a wrapper for http.ResponseWriter that captures the status code.
+// responseWriter wraps http.ResponseWriter to capture the status code.
 type responseWriter struct {
 	http.ResponseWriter
 	statusCode int
 }
 
+// WriteHeader sets the HTTP status code.
 func (rw *responseWriter) WriteHeader(code int) {
 	rw.statusCode = code
 	rw.ResponseWriter.WriteHeader(code)

internal/server/middleware/middleware_test.go

@@ -11,25 +11,29 @@ import (
 
 func TestLoggingMiddleware(t *testing.T) {
 	logger := log.New()
-	logger.Out = httptest.NewRecorder() // Discard output on purpose
+	logger.Out = httptest.NewRecorder() // Discard output for testing
 
 	domain := "example.com"
 	identifier := "test"
 
 	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(200)
+		w.WriteHeader(http.StatusOK)
 		w.Write([]byte("OK"))
 	})
 
-	middlewareHandler := LoggingMiddleware(logger, domain, identifier, handler)
+	// Get the middleware function
+	loggingMiddleware := LoggingMiddleware(logger, domain, identifier)
+
+	// Apply middleware to the handler
+	middlewareHandler := loggingMiddleware(handler)
 
 	req := httptest.NewRequest("GET", "http://example.com/test", nil)
 	w := httptest.NewRecorder()
 
 	middlewareHandler.ServeHTTP(w, req)
 
-	if w.Code != 200 {
-		t.Errorf("Expected status code 200, got %d", w.Code)
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status code %d, got %d", http.StatusOK, w.Code)
 	}
 }
 
@@ -41,7 +45,11 @@ func TestTimeoutMiddleware(t *testing.T) {
 		w.Write([]byte("This should timeout"))
 	})
 
-	middlewareHandler := TimeoutMiddleware(timeout, handler)
+	// Get the middleware function
+	timeoutMiddleware := TimeoutMiddleware(timeout)
+
+	// Apply middleware to the handler
+	middlewareHandler := timeoutMiddleware(handler)
 
 	req := httptest.NewRequest("GET", "http://example.com/test", nil)
 	w := httptest.NewRecorder()