update

Author: hhftechnology

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

api/handlers/datasource.go

@@ -1,7 +1,11 @@
 package handlers
 
 import (
+    "context"
+    "fmt"
+    "log"
     "net/http"
+    "time"
 
     "github.com/gin-gonic/gin"
     "github.com/hhftechnology/middleware-manager/models"
@@ -25,6 +29,12 @@ func (h *DataSourceHandler) GetDataSources(c *gin.Context) {
     sources := h.ConfigManager.GetDataSources()
     activeSource := h.ConfigManager.GetActiveSourceName()
 
+    // Format sources to mask passwords
+    for key, source := range sources {
+        source.FormatBasicAuth()
+        sources[key] = source
+    }
+    
     c.JSON(http.StatusOK, gin.H{
         "active_source": activeSource,
         "sources":       sources,
@@ -91,4 +101,78 @@ func (h *DataSourceHandler) UpdateDataSource(c *gin.Context) {
         "name":    name,
         "config":  config,
     })
+}
+
+// TestDataSourceConnection tests the connection to a data source
+func (h *DataSourceHandler) TestDataSourceConnection(c *gin.Context) {
+    name := c.Param("name")
+    if name == "" {
+        ResponseWithError(c, http.StatusBadRequest, "Data source name is required")
+        return
+    }
+    
+    var config models.DataSourceConfig
+    if err := c.ShouldBindJSON(&config); err != nil {
+        ResponseWithError(c, http.StatusBadRequest, fmt.Sprintf("Invalid request: %v", err))
+        return
+    }
+    
+    // Create a context with timeout
+    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+    defer cancel()
+    
+    // Test the connection with endpoints that work
+    err := testDataSourceConnection(ctx, config)
+    if err != nil {
+        log.Printf("Connection test failed for %s: %v", name, err)
+        ResponseWithError(c, http.StatusBadRequest, fmt.Sprintf("Connection test failed: %v", err))
+        return
+    }
+    
+    c.JSON(http.StatusOK, gin.H{
+        "message": "Connection test successful",
+        "name":    name,
+    })
+}
+
+// testDataSourceConnection tests the connection to a data source using different endpoints
+// based on the data source type
+func testDataSourceConnection(ctx context.Context, config models.DataSourceConfig) error {
+    client := &http.Client{
+        Timeout: 5 * time.Second,
+    }
+    
+    var url string
+    switch config.Type {
+    case models.PangolinAPI:
+        // Use traefik-config endpoint instead of status to test Pangolin
+        url = config.URL + "/traefik-config"
+    case models.TraefikAPI:
+        // Use http/routers endpoint to test Traefik
+        url = config.URL + "/api/http/routers"
+    default:
+        return fmt.Errorf("unsupported data source type: %s", config.Type)
+    }
+    
+    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+    if err != nil {
+        return fmt.Errorf("failed to create request: %w", err)
+    }
+    
+    // Add basic auth if configured
+    if config.BasicAuth.Username != "" {
+        req.SetBasicAuth(config.BasicAuth.Username, config.BasicAuth.Password)
+    }
+    
+    resp, err := client.Do(req)
+    if err != nil {
+        return fmt.Errorf("connection failed: %w", err)
+    }
+    defer resp.Body.Close()
+    
+    if resp.StatusCode >= 400 {
+        return fmt.Errorf("API returned status code: %d", resp.StatusCode)
+    }
+    
+    return nil
 }

api/server.go

@@ -14,6 +14,7 @@ import (
 	"github.com/gin-contrib/static"
 	"github.com/gin-gonic/gin"
 	"github.com/hhftechnology/middleware-manager/api/handlers"
+	"github.com/hhftechnology/middleware-manager/services"
 )
 
 // Server represents the API server
@@ -24,6 +25,8 @@ type Server struct {
 	middlewareHandler *handlers.MiddlewareHandler
 	resourceHandler   *handlers.ResourceHandler
 	configHandler     *handlers.ConfigHandler
+	dataSourceHandler *handlers.DataSourceHandler
+	configManager     *services.ConfigManager
 }
 
 // ServerConfig contains configuration options for the server
@@ -36,7 +39,7 @@ type ServerConfig struct {
 }
 
 // NewServer creates a new API server
-func NewServer(db *sql.DB, config ServerConfig) *Server {
+func NewServer(db *sql.DB, config ServerConfig, configManager *services.ConfigManager) *Server {
 	// Set gin mode based on debug flag
 	if !config.Debug {
 		gin.SetMode(gin.ReleaseMode)
@@ -77,6 +80,7 @@ func NewServer(db *sql.DB, config ServerConfig) *Server {
 	middlewareHandler := handlers.NewMiddlewareHandler(db)
 	resourceHandler := handlers.NewResourceHandler(db)
 	configHandler := handlers.NewConfigHandler(db)
+	dataSourceHandler := handlers.NewDataSourceHandler(configManager)
 
 	// Setup server
 	server := &Server{
@@ -85,6 +89,8 @@ func NewServer(db *sql.DB, config ServerConfig) *Server {
 		middlewareHandler: middlewareHandler,
 		resourceHandler:   resourceHandler,
 		configHandler:     configHandler,
+		dataSourceHandler: dataSourceHandler,
+		configManager:     configManager,
 		srv: &http.Server{
 			Addr:              ":" + config.Port,
 			Handler:           router,
@@ -132,20 +138,22 @@ func (s *Server) setupRoutes(uiPath string) {
 			resources.DELETE("/:id/middlewares/:middlewareId", s.resourceHandler.RemoveMiddleware)
 
 			// Router configuration routes
-			resources.PUT("/:id/config/http", s.configHandler.UpdateHTTPConfig)       // HTTP entrypoints
-			resources.PUT("/:id/config/tls", s.configHandler.UpdateTLSConfig)         // TLS certificate domains
-			resources.PUT("/:id/config/tcp", s.configHandler.UpdateTCPConfig)         // TCP SNI routing
-			resources.PUT("/:id/config/headers", s.configHandler.UpdateHeadersConfig) // Custom Host headers
-			resources.PUT("/:id/config/priority", s.configHandler.UpdateRouterPriority) // Router priority
+			resources.PUT("/:id/config/http", s.configHandler.UpdateHTTPConfig)
+			resources.PUT("/:id/config/tls", s.configHandler.UpdateTLSConfig)
+			resources.PUT("/:id/config/tcp", s.configHandler.UpdateTCPConfig)
+			resources.PUT("/:id/config/headers", s.configHandler.UpdateHeadersConfig)
+			resources.PUT("/:id/config/priority", s.configHandler.UpdateRouterPriority)
+		}
+
+		// Data source routes
+		datasource := api.Group("/datasource")
+		{
+			datasource.GET("", s.dataSourceHandler.GetDataSources)
+			datasource.GET("/active", s.dataSourceHandler.GetActiveDataSource)
+			datasource.PUT("/active", s.dataSourceHandler.SetActiveDataSource)
+			datasource.PUT("/:name", s.dataSourceHandler.UpdateDataSource)
+			datasource.POST("/:name/test", s.dataSourceHandler.TestDataSourceConnection)
 		}
-        // Data source routes
-        datasource := api.Group("/datasource")
-        {
-            datasource.GET("", s.dataSourceHandler.GetDataSources)
-            datasource.GET("/active", s.dataSourceHandler.GetActiveDataSource)
-            datasource.PUT("/active", s.dataSourceHandler.SetActiveDataSource)
-            datasource.PUT("/:name", s.dataSourceHandler.UpdateDataSource)
-        }		
 	}
 
 	// Serve the React app

database/db.go

@@ -158,6 +158,29 @@ func runPostMigrationUpdates(db *sql.DB) error {
 	if err != nil {
 		return fmt.Errorf("failed to check if entrypoints column exists: %w", err)
 	}
+
+	// Check for source_type column
+	var hasSourceTypeColumn bool
+	err = db.QueryRow(`
+    SELECT COUNT(*) > 0 
+    FROM pragma_table_info('resources') 
+    WHERE name = 'source_type'
+`).Scan(&hasSourceTypeColumn)
+
+	if err != nil {
+    return fmt.Errorf("failed to check if source_type column exists: %w", err)
+	}
+
+   // If the column doesn't exist, add it
+	if !hasSourceTypeColumn {
+    log.Println("Adding source_type column to resources table")
+    
+    if _, err := db.Exec("ALTER TABLE resources ADD COLUMN source_type TEXT DEFAULT ''"); err != nil {
+        return fmt.Errorf("failed to add source_type column: %w", err)
+    }
+    
+    log.Println("Successfully added source_type column")
+	}
 
 	// If the column doesn't exist, add the routing columns too
 	if !hasEntrypointsColumn {

database/migrations.sql

@@ -35,6 +35,9 @@ CREATE TABLE IF NOT EXISTS resources (
     -- Router priority configuration
     router_priority INTEGER DEFAULT 100,
 
+    -- Source type for tracking data origin
+    source_type TEXT DEFAULT '',
+    
     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );

database/transaction.go

@@ -95,4 +95,5 @@ func GetLastInsertID(result sql.Result) (int64, error) {
     return 0, fmt.Errorf("failed to get last insert ID: %w", err)
   }
   return id, nil
-}
+}
+

main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"flag"
 	"log"
+	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -20,6 +21,7 @@ import (
 // Configuration represents the application configuration
 type Configuration struct {
 	PangolinAPIURL   string
+	TraefikAPIURL    string
 	TraefikConfDir   string
 	DBPath           string
 	Port             string
@@ -30,6 +32,37 @@ type Configuration struct {
 	Debug            bool
 	AllowCORS        bool
 	CORSOrigin       string
+	ActiveDataSource string
+}
+
+// DiscoverTraefikAPI attempts to discover the Traefik API by trying common URLs
+func DiscoverTraefikAPI() (string, error) {
+	client := &http.Client{
+		Timeout: 2 * time.Second, // Short timeout for discovery
+	}
+
+	// Common URLs to try
+	urls := []string{
+		"http://host.docker.internal:8080",
+		"http://localhost:8080",
+		"http://127.0.0.1:8080",
+		"http://traefik:8080",
+	}
+
+	for _, url := range urls {
+		testURL := url + "/api/version"
+		resp, err := client.Get(testURL)
+		if err == nil && resp.StatusCode == http.StatusOK {
+			resp.Body.Close()
+			log.Printf("Discovered Traefik API at %s", url)
+			return url, nil
+		}
+		if resp != nil {
+			resp.Body.Close()
+		}
+	}
+
+	return "", nil // Return empty string without error to allow fallbacks
 }
 
 func main() {
@@ -43,6 +76,14 @@ func main() {
 	// Load configuration
 	cfg := loadConfiguration(debug)
 
+	// Try to discover Traefik API URL if not set in environment
+	if os.Getenv("TRAEFIK_API_URL") == "" {
+		if discoveredURL, err := DiscoverTraefikAPI(); err == nil && discoveredURL != "" {
+			log.Printf("Auto-discovered Traefik API URL: %s", discoveredURL)
+			cfg.TraefikAPIURL = discoveredURL
+		}
+	}
+
 	// Initialize database
 	db, err := database.InitDB(cfg.DBPath)
 	if err != nil {
@@ -72,6 +113,9 @@ func main() {
 		log.Fatalf("Failed to initialize config manager: %v", err)
 	}
 
+	// Ensure default data sources are configured with potentially discovered URL
+	configManager.EnsureDefaultDataSources(cfg.PangolinAPIURL, cfg.TraefikAPIURL)
+
 	// Create stop channel for graceful shutdown
 	stopChan := make(chan struct{})
 
@@ -153,11 +197,14 @@ func loadConfiguration(debug bool) Configuration {
 
 	return Configuration{
 		PangolinAPIURL:   getEnv("PANGOLIN_API_URL", "http://pangolin:3001/api/v1"),
+		// Changed to use host.docker.internal as first default to better support Docker environments
+		TraefikAPIURL:    getEnv("TRAEFIK_API_URL", "http://host.docker.internal:8080"),
 		TraefikConfDir:   getEnv("TRAEFIK_CONF_DIR", "/conf"),
 		DBPath:           getEnv("DB_PATH", "/data/middleware.db"),
 		Port:             getEnv("PORT", "3456"),
 		UIPath:           getEnv("UI_PATH", "/app/ui/build"),
 		ConfigDir:        getEnv("CONFIG_DIR", "/app/config"),
+		ActiveDataSource: getEnv("ACTIVE_DATA_SOURCE", "pangolin"),
 		CheckInterval:    checkInterval,
 		GenerateInterval: generateInterval,
 		Debug:            debug,