feat: add namespace support for runtime resources

- Introduced a new `namespace` field in the OpenAPI specification for runtime resources, applicable to Kubernetes backends.
- Updated the runtime supervisor and related services to handle the new namespace parameter during scroll creation and management.
- Enhanced error handling and logging in the runtime daemon for better observability.
- Refactored related tests to accommodate the namespace changes and ensure proper functionality.

Author: MarcStdt

api/openapi.yaml

@@ -89,6 +89,9 @@ components:
         owner_id:
           type: string
           description: Runtime owner id used for customer-facing route authorization.
+        namespace:
+          type: string
+          description: Kubernetes namespace for runtime resources. Ignored by non-Kubernetes backends.
         registry_credentials:
           type: array
           items:
@@ -110,6 +113,9 @@ components:
         owner_id:
           type: string
           description: Runtime owner id used for customer-facing route authorization.
+        namespace:
+          type: string
+          description: Kubernetes namespace for runtime resources. Ignored by non-Kubernetes backends.
         registry_credentials:
           type: array
           items:

apps/druid-coldstarter/adapters/cli/root.go

@@ -7,14 +7,12 @@ import (
 	"os/signal"
 	"syscall"
 
-	"github.com/highcard-dev/daemon/apps/druid-coldstarter/adapters/filesystem"
 	"github.com/highcard-dev/daemon/apps/druid-coldstarter/core/services"
 	"github.com/spf13/cobra"
 )
 
 const (
-	rootEnv       = "DRUID_ROOT"
-	statusFileEnv = "DRUID_COLDSTARTER_STATUS_FILE"
+	rootEnv = "DRUID_ROOT"
 )
 
 func NewRootCommand() *cobra.Command {
@@ -28,7 +26,7 @@ func NewRootCommand() *cobra.Command {
 			}
 			ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
 			defer stop()
-			return services.NewColdstarterService(filesystem.NewStatusWriter()).Run(ctx, root, os.Getenv(statusFileEnv))
+			return services.NewColdstarterService().Run(ctx, root)
 		},
 	}
 	cmd.SilenceUsage = true

apps/druid-coldstarter/adapters/cli/root_test.go

@@ -7,17 +7,10 @@ import (
 
 func TestRootCommandHasNoRuntimeFlags(t *testing.T) {
 	cmd := NewRootCommand()
-	if cmd.Flags().Lookup("root") != nil {
-		t.Fatal("did not expect root flag")
-	}
-	if cmd.Flags().Lookup("status-file") != nil {
-		t.Fatal("did not expect status-file flag")
-	}
-	if cmd.Flags().Lookup("scroll-root") != nil {
-		t.Fatal("did not expect scroll-root flag")
-	}
-	if cmd.Flags().Lookup("runtime-config") != nil {
-		t.Fatal("did not expect runtime-config flag")
+	for _, flag := range []string{"root", "scroll-root", "runtime-config", "status" + "-" + "file"} {
+		if cmd.Flags().Lookup(flag) != nil {
+			t.Fatalf("did not expect %s flag", flag)
+		}
 	}
 }
 

apps/druid-coldstarter/adapters/filesystem/status_writer.go

@@ -3,50 +3,111 @@ package services
 import (
 	"context"
 	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 
-	"github.com/highcard-dev/daemon/apps/druid-coldstarter/core/ports"
+	"github.com/highcard-dev/daemon/internal/core/domain"
 	"github.com/highcard-dev/daemon/internal/core/services"
 	"github.com/highcard-dev/daemon/internal/utils/logger"
 	"go.uber.org/zap"
 )
 
-type ColdstarterService struct {
-	statusWriter ports.StatusWriter
+type ColdstarterService struct{}
+
+type envPortService struct {
+	ports []*domain.AugmentedPort
 }
 
-func NewColdstarterService(statusWriter ports.StatusWriter) *ColdstarterService {
-	return &ColdstarterService{statusWriter: statusWriter}
+func NewColdstarterService() *ColdstarterService {
+	return &ColdstarterService{}
 }
 
-func (s *ColdstarterService) Run(ctx context.Context, root string, statusFile string) error {
-	scrollService, err := services.NewScrollService(root)
+func (s *ColdstarterService) Run(ctx context.Context, root string) error {
+	portService, err := portServiceFromEnv(root)
 	if err != nil {
-		return fmt.Errorf("failed to load scroll: %w", err)
-	}
-
-	currentScroll := scrollService.GetCurrent()
-	if len(currentScroll.Ports) == 0 {
-		return fmt.Errorf("no ports found in scroll")
+		return err
 	}
 
-	logger.Log().Info("Coldstart scroll loaded", zap.String("name", currentScroll.Name), zap.Any("version", currentScroll.Version), zap.Any("ports", currentScroll.Ports))
+	logger.Log().Info("Coldstart ports loaded", zap.Any("ports", portService.GetPorts()))
 
-	portService := services.NewPortServiceWithScrollFile(&currentScroll.File)
-	coldStarter := services.NewColdStarter(portService, nil, scrollService.GetDir())
+	coldStarter := services.NewColdStarter(portService, nil, root)
 
 	finish := coldStarter.Start(ctx)
 	select {
 	case <-ctx.Done():
 		coldStarter.Stop()
 		return ctx.Err()
-	case port := <-finish:
+	case <-finish:
 		coldStarter.Stop()
-		if statusFile != "" && s.statusWriter != nil {
-			if err := s.statusWriter.Write(root, statusFile, port); err != nil {
-				return err
-			}
-		}
 		logger.Log().Info("Coldstarter finished")
 		return nil
 	}
 }
+
+func (s *envPortService) GetPorts() []*domain.AugmentedPort {
+	return s.ports
+}
+
+func portServiceFromEnv(root string) (*envPortService, error) {
+	ports := []*domain.AugmentedPort{}
+	vars := map[string]string{}
+	for _, entry := range os.Environ() {
+		key, value, ok := strings.Cut(entry, "=")
+		if !ok {
+			continue
+		}
+		if name, ok := strings.CutPrefix(key, "DRUID_COLDSTARTER_VAR_"); ok {
+			if name != strings.ToUpper(name) {
+				return nil, fmt.Errorf("%s must be uppercase", key)
+			}
+			vars[name] = value
+			continue
+		}
+		if !strings.HasPrefix(key, "DRUID_PORT_") || !strings.HasSuffix(key, "_COLDSTARTER") {
+			continue
+		}
+		if key != strings.ToUpper(key) {
+			return nil, fmt.Errorf("%s must be uppercase", key)
+		}
+		handler := value
+		suffix := strings.TrimSuffix(strings.TrimPrefix(key, "DRUID_PORT_"), "_COLDSTARTER")
+		portValue := os.Getenv("DRUID_PORT_" + suffix)
+		if portValue == "" {
+			return nil, fmt.Errorf("DRUID_PORT_%s is required when %s is set", suffix, key)
+		}
+		if handler == "" {
+			return nil, fmt.Errorf("%s must not be empty", key)
+		}
+		if handler != "generic" {
+			path := filepath.Join(root, filepath.Clean(handler))
+			if rel, err := filepath.Rel(root, path); err != nil || rel == ".." || filepath.IsAbs(rel) || strings.HasPrefix(rel, "../") {
+				return nil, fmt.Errorf("%s must be generic or a path below DRUID_ROOT", key)
+			}
+		}
+		port, err := strconv.Atoi(portValue)
+		if err != nil {
+			return nil, fmt.Errorf("DRUID_PORT_%s must be a port number: %w", suffix, err)
+		}
+		protocol := strings.ToLower(os.Getenv("DRUID_PORT_" + suffix + "_PROTOCOL"))
+		if protocol == "" {
+			protocol = "tcp"
+		}
+		ports = append(ports, &domain.AugmentedPort{
+			Port: domain.Port{
+				Name:     strings.ToLower(suffix),
+				Port:     port,
+				Protocol: protocol,
+			},
+			ColdstarterHandler: handler,
+			ColdstarterVars:    vars,
+			InactiveSince:      time.Now(),
+		})
+	}
+	if len(ports) == 0 {
+		return nil, fmt.Errorf("no coldstarter ports configured")
+	}
+	return &envPortService{ports: ports}, nil
+}

apps/druid-coldstarter/core/ports/status_writer.go

@@ -6,33 +6,23 @@ import (
 	"os"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
-
-	"github.com/highcard-dev/daemon/apps/druid-coldstarter/adapters/filesystem"
 )
 
-func TestColdstarterRunServesGenericPortAndWritesStatus(t *testing.T) {
+func TestColdstarterRunServesGenericPortFromEnv(t *testing.T) {
 	root := t.TempDir()
 	port := freeTCPPort(t)
-	scroll := []byte(`name: test/coldstarter
-version: 0.1.0
-ports:
-  - name: main
-    protocol: tcp
-    port: ` + port + `
-    sleep_handler: generic
-commands: {}
-`)
-	if err := os.WriteFile(filepath.Join(root, "scroll.yaml"), scroll, 0644); err != nil {
-		t.Fatal(err)
-	}
+	t.Setenv("DRUID_PORT_MAIN", port)
+	t.Setenv("DRUID_PORT_MAIN_PROTOCOL", "tcp")
+	t.Setenv("DRUID_PORT_MAIN_COLDSTARTER", "generic")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	errCh := make(chan error, 1)
 	go func() {
-		errCh <- NewColdstarterService(filesystem.NewStatusWriter()).Run(ctx, root, ".coldstarter.json")
+		errCh <- NewColdstarterService().Run(ctx, root)
 	}()
 
 	conn := dialTCP(t, "127.0.0.1:"+port)
@@ -47,8 +37,96 @@ commands: {}
 	case <-time.After(3 * time.Second):
 		t.Fatal("coldstarter did not finish")
 	}
-	if _, err := os.Stat(filepath.Join(root, ".coldstarter.json")); err != nil {
-		t.Fatalf("status file missing: %v", err)
+	if _, err := os.Stat(filepath.Join(root, ".coldstarter.json")); !os.IsNotExist(err) {
+		t.Fatalf("status file exists or stat failed: %v", err)
+	}
+}
+
+func TestColdstarterRunExitsFromSecondaryGenericPort(t *testing.T) {
+	root := t.TempDir()
+	mainPort := freeTCPPort(t)
+	rconPort := freeTCPPort(t)
+	t.Setenv("DRUID_PORT_MAIN", mainPort)
+	t.Setenv("DRUID_PORT_MAIN_PROTOCOL", "tcp")
+	t.Setenv("DRUID_PORT_MAIN_COLDSTARTER", "generic")
+	t.Setenv("DRUID_PORT_RCON", rconPort)
+	t.Setenv("DRUID_PORT_RCON_PROTOCOL", "tcp")
+	t.Setenv("DRUID_PORT_RCON_COLDSTARTER", "generic")
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- NewColdstarterService().Run(context.Background(), root)
+	}()
+
+	conn := dialTCP(t, "127.0.0.1:"+rconPort)
+	_, _ = conn.Write([]byte("wake"))
+	_ = conn.Close()
+
+	select {
+	case err := <-errCh:
+		if err != nil {
+			t.Fatal(err)
+		}
+	case <-time.After(3 * time.Second):
+		t.Fatal("coldstarter did not finish")
+	}
+}
+
+func TestColdstarterRejectsMissingPortEnv(t *testing.T) {
+	t.Setenv("DRUID_PORT_MAIN_COLDSTARTER", "generic")
+
+	err := NewColdstarterService().Run(context.Background(), t.TempDir())
+	if err == nil || !strings.Contains(err.Error(), "DRUID_PORT_MAIN is required") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestColdstarterRejectsPathTraversalHandler(t *testing.T) {
+	t.Setenv("DRUID_PORT_MAIN", freeTCPPort(t))
+	t.Setenv("DRUID_PORT_MAIN_COLDSTARTER", "../minecraft.lua")
+
+	err := NewColdstarterService().Run(context.Background(), t.TempDir())
+	if err == nil || !strings.Contains(err.Error(), "path below DRUID_ROOT") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestColdstarterRequiresConfiguredPorts(t *testing.T) {
+	err := NewColdstarterService().Run(context.Background(), t.TempDir())
+	if err == nil || !strings.Contains(err.Error(), "no coldstarter ports configured") {
+		t.Fatalf("err = %v", err)
+	}
+}
+
+func TestColdstarterAcceptsRelativeLuaHandler(t *testing.T) {
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "packet_handler"), 0755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("DRUID_PORT_MAIN", freeTCPPort(t))
+	t.Setenv("DRUID_PORT_MAIN_COLDSTARTER", "packet_handler/minecraft.lua")
+	t.Setenv("DRUID_COLDSTARTER_VAR_SERVER_LIST_NAME", "Druid idle")
+
+	service, err := portServiceFromEnv(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := service.GetPorts()[0].ColdstarterHandler; got != "packet_handler/minecraft.lua" {
+		t.Fatalf("handler = %q", got)
+	}
+	if got := service.GetPorts()[0].ColdstarterVars["SERVER_LIST_NAME"]; got != "Druid idle" {
+		t.Fatalf("lua var = %q", got)
+	}
+}
+
+func TestColdstarterRejectsMixedCaseEnvNames(t *testing.T) {
+	t.Setenv("DRUID_PORT_MAIN", freeTCPPort(t))
+	t.Setenv("DRUID_PORT_MAIN_COLDSTARTER", "generic")
+	t.Setenv("DRUID_COLDSTARTER_VAR_"+"ServerListName", "Druid idle")
+
+	err := NewColdstarterService().Run(context.Background(), t.TempDir())
+	if err == nil || !strings.Contains(err.Error(), "must be uppercase") {
+		t.Fatalf("err = %v", err)
 	}
 }