Add file-based registry provider to thv-registry-api (#1909)

* Add file-based registry provider to thv-registry-api

Extends the registry API server to support reading registry data from
local files in addition to Kubernetes ConfigMaps. This enables
deployment scenarios where ConfigMaps are mounted as volumes rather
than accessed via the Kubernetes API.

The server now accepts either:
- `--configmap` flag: Reads from Kubernetes ConfigMap via API
- `--file` flag: Reads from mounted file (for volume-mounted ConfigMaps)

* Pass the registry name explicitly as a command line flag

* Rename parameters to --from-configmap and --from-file

* fix lint

Author: jhrozek

cmd/thv-registry-api/api/v1/routes_test.go

@@ -257,6 +257,11 @@ func (*realisticRegistryProvider) GetSource() string {
 	return "test:realistic-registry-data"
 }
 
+// GetRegistryName implements RegistryDataProvider.GetRegistryName
+func (*realisticRegistryProvider) GetRegistryName() string {
+	return "test-registry"
+}
+
 func TestHealthRouter(t *testing.T) {
 	t.Parallel()
 	ctrl := gomock.NewController(t)
@@ -607,6 +612,11 @@ func (*fileBasedRegistryProvider) GetSource() string {
 	return "embedded:pkg/registry/data/registry.json"
 }
 
+// GetRegistryName implements RegistryDataProvider.GetRegistryName
+func (*fileBasedRegistryProvider) GetRegistryName() string {
+	return "embedded-registry"
+}
+
 // TestRoutesWithRealData tests all routes using the embedded registry.json data
 // This provides integration-style testing with realistic MCP server configurations
 func TestRoutesWithRealData(t *testing.T) {

cmd/thv-registry-api/app/serve.go

@@ -27,7 +27,12 @@ var serveCmd = &cobra.Command{
 	Use:   "serve",
 	Short: "Start the registry API server",
 	Long: `Start the registry API server to serve MCP registry data.
-The server reads registry data from ConfigMaps and provides REST endpoints for clients.`,
+The server can read registry data from either:
+- ConfigMaps using --from-configmap flag (requires Kubernetes API access)
+- Local files using --from-file flag (for mounted ConfigMaps)
+
+Both options require --registry-name to specify the registry identifier.
+One of --from-configmap or --from-file must be specified.`,
 	RunE: runServe,
 }
 
@@ -41,15 +46,25 @@ const (
 
 func init() {
 	serveCmd.Flags().String("address", ":8080", "Address to listen on")
-	serveCmd.Flags().String("configmap", "", "ConfigMap name containing registry data")
+	serveCmd.Flags().String("from-configmap", "", "ConfigMap name containing registry data (mutually exclusive with --from-file)")
+	serveCmd.Flags().String("from-file", "", "File path to registry.json (mutually exclusive with --from-configmap)")
+	serveCmd.Flags().String("registry-name", "", "Registry name identifier (required)")
 
 	err := viper.BindPFlag("address", serveCmd.Flags().Lookup("address"))
 	if err != nil {
 		logger.Fatalf("Failed to bind address flag: %v", err)
 	}
-	err = viper.BindPFlag("configmap", serveCmd.Flags().Lookup("configmap"))
+	err = viper.BindPFlag("from-configmap", serveCmd.Flags().Lookup("from-configmap"))
+	if err != nil {
+		logger.Fatalf("Failed to bind from-configmap flag: %v", err)
+	}
+	err = viper.BindPFlag("from-file", serveCmd.Flags().Lookup("from-file"))
+	if err != nil {
+		logger.Fatalf("Failed to bind from-file flag: %v", err)
+	}
+	err = viper.BindPFlag("registry-name", serveCmd.Flags().Lookup("registry-name"))
 	if err != nil {
-		logger.Fatalf("Failed to bind configmap flag: %v", err)
+		logger.Fatalf("Failed to bind registry-name flag: %v", err)
 	}
 }
 
@@ -68,48 +83,95 @@ func getKubernetesConfig() (*rest.Config, error) {
 	return kubeConfig.ClientConfig()
 }
 
-func runServe(_ *cobra.Command, _ []string) error {
-	ctx := context.Background()
+// buildProviderConfig creates provider configuration based on command-line flags
+func buildProviderConfig() (*service.RegistryProviderConfig, error) {
+	configMapName := viper.GetString("from-configmap")
+	filePath := viper.GetString("from-file")
+	registryName := viper.GetString("registry-name")
 
-	// Get configuration
-	address := viper.GetString("address")
-	configMapName := viper.GetString("configmap")
+	// Validate mutual exclusivity
+	if configMapName != "" && filePath != "" {
+		return nil, fmt.Errorf("--from-configmap and --from-file flags are mutually exclusive")
+	}
+
+	// Require one of the flags
+	if configMapName == "" && filePath == "" {
+		return nil, fmt.Errorf("either --from-configmap or --from-file flag is required")
+	}
 
-	if configMapName == "" {
-		return fmt.Errorf("configmap flag is required")
+	// Require registry name
+	if registryName == "" {
+		return nil, fmt.Errorf("--registry-name flag is required")
 	}
 
-	namespace := thvk8scli.GetCurrentNamespace()
+	if configMapName != "" {
+		config, err := getKubernetesConfig()
+		if err != nil {
+			return nil, fmt.Errorf("failed to create kubernetes config: %w", err)
+		}
+
+		clientset, err := kubernetes.NewForConfig(config)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create kubernetes client: %w", err)
+		}
+
+		return &service.RegistryProviderConfig{
+			Type: service.RegistryProviderTypeConfigMap,
+			ConfigMap: &service.ConfigMapProviderConfig{
+				Name:         configMapName,
+				Namespace:    thvk8scli.GetCurrentNamespace(),
+				Clientset:    clientset,
+				RegistryName: registryName,
+			},
+		}, nil
+	}
+
+	return &service.RegistryProviderConfig{
+		Type: service.RegistryProviderTypeFile,
+		File: &service.FileProviderConfig{
+			FilePath:     filePath,
+			RegistryName: registryName,
+		},
+	}, nil
+}
+
+func runServe(_ *cobra.Command, _ []string) error {
+	ctx := context.Background()
+	address := viper.GetString("address")
 
 	logger.Infof("Starting registry API server on %s", address)
-	logger.Infof("ConfigMap: %s, Namespace: %s", configMapName, namespace)
 
-	// Create Kubernetes client and providers
-	var registryProvider service.RegistryDataProvider
-	var deploymentProvider service.DeploymentProvider
+	providerConfig, err := buildProviderConfig()
+	if err != nil {
+		return fmt.Errorf("failed to build provider configuration: %w", err)
+	}
 
-	// Get Kubernetes config
-	config, err := getKubernetesConfig()
+	if err := providerConfig.Validate(); err != nil {
+		return fmt.Errorf("invalid provider configuration: %w", err)
+	}
+
+	factory := service.NewRegistryProviderFactory()
+	registryProvider, err := factory.CreateProvider(providerConfig)
 	if err != nil {
-		return fmt.Errorf("failed to create kubernetes config: %w", err)
+		return fmt.Errorf("failed to create registry provider: %w", err)
 	}
 
-	// Create Kubernetes client
-	clientset, err := kubernetes.NewForConfig(config)
+	logger.Infof("Created registry data provider: %s", registryProvider.GetSource())
+
+	var deploymentProvider service.DeploymentProvider
+	config, err := getKubernetesConfig()
 	if err != nil {
-		return fmt.Errorf("failed to create kubernetes client: %w", err)
+		return fmt.Errorf("failed to create kubernetes config for deployment provider: %w", err)
 	}
 
-	// Create the Kubernetes-based registry data provider
-	registryProvider = service.NewK8sRegistryDataProvider(clientset, configMapName, namespace)
-	logger.Infof("Created Kubernetes registry data provider for ConfigMap %s/%s", namespace, configMapName)
+	// Use registry name from provider
+	registryName := registryProvider.GetRegistryName()
 
-	// Create the Kubernetes-based deployment provider
-	deploymentProvider, err = service.NewK8sDeploymentProvider(config, configMapName)
+	deploymentProvider, err = service.NewK8sDeploymentProvider(config, registryName)
 	if err != nil {
 		return fmt.Errorf("failed to create kubernetes deployment provider: %w", err)
 	}
-	logger.Infof("Created Kubernetes deployment provider for registry: %s", configMapName)
+	logger.Infof("Created Kubernetes deployment provider for registry: %s", registryName)
 
 	// Create the registry service
 	svc, err := service.NewService(ctx, registryProvider, deploymentProvider)

cmd/thv-registry-api/internal/service/file_provider.go

@@ -0,0 +1,78 @@
+// Package service provides the business logic for the MCP registry API
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/stacklok/toolhive/pkg/registry"
+)
+
+// FileRegistryDataProvider implements RegistryDataProvider using local file system.
+// This implementation reads registry data from a mounted file instead of calling the Kubernetes API.
+// It is designed to work with ConfigMaps mounted as volumes in Kubernetes deployments.
+type FileRegistryDataProvider struct {
+	filePath     string
+	registryName string
+}
+
+// NewFileRegistryDataProvider creates a new file-based registry data provider.
+// The filePath parameter should point to the registry.json file, typically mounted from a ConfigMap.
+// The registryName parameter specifies the registry identifier for business logic purposes.
+func NewFileRegistryDataProvider(filePath, registryName string) *FileRegistryDataProvider {
+	return &FileRegistryDataProvider{
+		filePath:     filePath,
+		registryName: registryName,
+	}
+}
+
+// GetRegistryData implements RegistryDataProvider.GetRegistryData.
+// It reads the registry.json file from the local filesystem and parses it into a Registry struct.
+func (p *FileRegistryDataProvider) GetRegistryData(_ context.Context) (*registry.Registry, error) {
+	if p.filePath == "" {
+		return nil, fmt.Errorf("file path not configured")
+	}
+
+	// Check if the file exists and is readable
+	if _, err := os.Stat(p.filePath); err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("registry file not found at %s: %w", p.filePath, err)
+		}
+		return nil, fmt.Errorf("cannot access registry file at %s: %w", p.filePath, err)
+	}
+
+	// Read the file contents
+	data, err := os.ReadFile(p.filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read registry file at %s: %w", p.filePath, err)
+	}
+
+	// Parse the JSON data
+	var reg registry.Registry
+	if err := json.Unmarshal(data, &reg); err != nil {
+		return nil, fmt.Errorf("failed to parse registry data from file %s: %w", p.filePath, err)
+	}
+
+	return &reg, nil
+}
+
+// GetSource implements RegistryDataProvider.GetSource.
+// It returns a descriptive string indicating the file source.
+func (p *FileRegistryDataProvider) GetSource() string {
+	if p.filePath == "" {
+		return "file:<not-configured>"
+	}
+
+	// Clean the path for consistent display
+	cleanPath := filepath.Clean(p.filePath)
+	return fmt.Sprintf("file:%s", cleanPath)
+}
+
+// GetRegistryName implements RegistryDataProvider.GetRegistryName.
+// It returns the injected registry name identifier.
+func (p *FileRegistryDataProvider) GetRegistryName() string {
+	return p.registryName
+}