Enable dynamic changes in the router for non-kube environments

api/types/client.go

@@ -18,7 +18,11 @@ import (
 )
 
 const (
-	ENV_PLATFORM = "SKUPPER_PLATFORM"
+	ENV_PLATFORM           = "SKUPPER_PLATFORM"
+	ENV_SYSTEM_AUTO_RELOAD = "SKUPPER_SYSTEM_RELOAD_TYPE"
+
+	SystemReloadTypeAuto   string = "auto"
+	SystemReloadTypeManual string = "manual"
 )
 
 type ConnectorCreateOptions struct {

cmd/system-controller/main.go

@@ -10,7 +10,9 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/skupperproject/skupper/api/types"
 	"github.com/skupperproject/skupper/internal/nonkube/controller"
+	"github.com/skupperproject/skupper/internal/utils"
 	"github.com/skupperproject/skupper/internal/version"
 	"github.com/skupperproject/skupper/pkg/nonkube/api"
 )
@@ -23,6 +25,9 @@ func main() {
 	if api.IsRunningInContainer() {
 		slog.Info("Host path info:", slog.String("path", api.GetHostNamespacesPath()))
 	}
+	systemReloadType := utils.DefaultStr(os.Getenv(types.ENV_SYSTEM_AUTO_RELOAD),
+		types.SystemReloadTypeManual)
+	slog.Info("System Reload:", slog.String("type", systemReloadType))
 	if err := os.MkdirAll(namespacesPath, 0755); err != nil {
 		slog.Error("Error creating skupper namespaces directory", slog.String("path", namespacesPath), slog.Any("error", err))
 		os.Exit(1)

internal/cmd/skupper/common/constants.go

@@ -8,6 +8,7 @@ var (
 	WorkloadTypes   = []string{"deployment", "service", "daemonset", "statefulset"}
 	WaitStatusTypes = []string{"ready", "configured", "none"}
 	BundleTypes     = []string{"tarball", "shell-script"}
+	ReloadTypes     = []string{"manual", "auto"}
 )
 
 const (

internal/cmd/skupper/common/flags.go

@@ -89,6 +89,9 @@ for other Kubernetes flavors, loadbalancer is the default.`
 
 	FlagNameFileName = "filename"
 	FlagDescFileName = "The name of the file with custom resources"
+
+	FlagNameReloadType = "reload-type"
+	FlagDescReloadType = "Specify the type of reload to perform. Choices: manual, auto"
 )
 
 type CommandSiteCreateFlags struct {
@@ -265,3 +268,7 @@ type CommandSystemApplyFlags struct {
 type CommandSystemDeleteFlags struct {
 	Filename string
 }
+
+type CommandSystemInstallFlags struct {
+	ReloadType string
+}

internal/cmd/skupper/system/kube/system_install.go

@@ -2,6 +2,8 @@ package kube
 
 import (
 	"fmt"
+
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
 	skupperv2alpha1 "github.com/skupperproject/skupper/pkg/generated/client/clientset/versioned/typed/skupper/v2alpha1"
 	"github.com/spf13/cobra"
 	"k8s.io/client-go/kubernetes"
@@ -12,6 +14,7 @@ type CmdSystemInstall struct {
 	KubeClient kubernetes.Interface
 	CobraCmd   *cobra.Command
 	Namespace  string
+	Flags      *common.CommandSystemInstallFlags
 }
 
 func NewCmdSystemInstall() *CmdSystemInstall {

internal/cmd/skupper/system/nonkube/system_apply.go

@@ -224,7 +224,7 @@ func (cmd *CmdSystemApply) Run() error {
 	}
 
 	if crApplied {
-		fmt.Println("Custom resources are applied. If a site is already running, run `skupper system reload` to make effective the changes.")
+		fmt.Println("Custom resources are applied.")
 	}
 
 	return nil

internal/cmd/skupper/system/nonkube/system_install.go

@@ -3,8 +3,11 @@ package nonkube
 import (
 	"errors"
 	"fmt"
+
 	"github.com/skupperproject/skupper/api/types"
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
 	"github.com/skupperproject/skupper/internal/config"
+	"github.com/skupperproject/skupper/internal/utils/validator"
 
 	"github.com/skupperproject/skupper/internal/nonkube/bootstrap"
 	"github.com/spf13/cobra"
@@ -13,7 +16,9 @@ import (
 type CmdSystemInstall struct {
 	CobraCmd      *cobra.Command
 	Namespace     string
-	SystemInstall func(string) error
+	SystemInstall func(string, string) error
+	Flags         *common.CommandSystemInstallFlags
+	reloadType    string
 }
 
 func NewCmdSystemInstall() *CmdSystemInstall {
@@ -30,6 +35,7 @@ func (cmd *CmdSystemInstall) NewClient(cobraCommand *cobra.Command, args []strin
 func (cmd *CmdSystemInstall) ValidateInput(args []string) error {
 
 	var validationErrors []error
+	reloadTypeValidator := validator.NewOptionValidator(common.ReloadTypes)
 
 	if len(args) > 0 {
 		validationErrors = append(validationErrors, fmt.Errorf("this command does not accept arguments"))
@@ -38,13 +44,25 @@ func (cmd *CmdSystemInstall) ValidateInput(args []string) error {
 	if config.GetPlatform() != types.PlatformPodman && config.GetPlatform() != types.PlatformDocker {
 		validationErrors = append(validationErrors, fmt.Errorf("the selected platform is not supported by this command. There is nothing to install"))
 	}
+
+	if cmd.Flags != nil && cmd.Flags.ReloadType != "" {
+		ok, err := reloadTypeValidator.Evaluate(cmd.Flags.ReloadType)
+		if !ok {
+			validationErrors = append(validationErrors, fmt.Errorf("reload type is not valid: %s", err))
+		}
+	}
+
 	return errors.Join(validationErrors...)
 }
 
-func (cmd *CmdSystemInstall) InputToOptions() {}
+func (cmd *CmdSystemInstall) InputToOptions() {
+	if cmd.Flags != nil && cmd.Flags.ReloadType != "" {
+		cmd.reloadType = cmd.Flags.ReloadType
+	}
+}
 
 func (cmd *CmdSystemInstall) Run() error {
-	err := cmd.SystemInstall(string(config.GetPlatform()))
+	err := cmd.SystemInstall(string(config.GetPlatform()), cmd.reloadType)
 
 	if err != nil {
 		return fmt.Errorf("failed to configure the environment : %s", err)

internal/cmd/skupper/system/nonkube/system_install_test.go

@@ -2,10 +2,12 @@ package nonkube
 
 import (
 	"fmt"
-	"github.com/skupperproject/skupper/internal/config"
 	"os"
 	"testing"
 
+	cmd "github.com/skupperproject/skupper/internal/cmd/skupper/common"
+	"github.com/skupperproject/skupper/internal/config"
+
 	"github.com/skupperproject/skupper/internal/cmd/skupper/common/testutils"
 	"gotest.tools/v3/assert"
 )
@@ -15,6 +17,7 @@ func TestCmdSystemInstall_ValidateInput(t *testing.T) {
 		name          string
 		args          []string
 		platform      string
+		reloadType    string
 		expectedError string
 	}
 
@@ -30,6 +33,12 @@ func TestCmdSystemInstall_ValidateInput(t *testing.T) {
 			platform:      "linux",
 			expectedError: "the selected platform is not supported by this command. There is nothing to install",
 		},
+		{
+			name:          "reload type not supported",
+			reloadType:    "both",
+			platform:      "podman",
+			expectedError: "reload type is not valid: value both not allowed. It should be one of this options: [manual auto]",
+		},
 	}
 
 	for _, test := range testTable {
@@ -39,7 +48,8 @@ func TestCmdSystemInstall_ValidateInput(t *testing.T) {
 			err := os.Setenv("SKUPPER_PLATFORM", test.platform)
 			assert.Check(t, err == nil)
 
-			command := &CmdSystemInstall{}
+			command := &CmdSystemInstall{Flags: &cmd.CommandSystemInstallFlags{}}
+			command.Flags.ReloadType = test.reloadType
 
 			testutils.CheckValidateInput(t, command, test.expectedError, test.args)
 		})
@@ -96,7 +106,7 @@ func newCmdSystemInstallWithMocks(podmanSocketEnablementFails bool) *CmdSystemIn
 	return cmdMock
 }
 
-func mockCmdSystemInstall(platform string) error { return nil }
-func mockCmdSystemInstallSocketEnablementFails(platform string) error {
+func mockCmdSystemInstall(platform string, reloadType string) error { return nil }
+func mockCmdSystemInstallSocketEnablementFails(platform string, reloadType string) error {
 	return fmt.Errorf("systemd failed to enable podman socket")
 }

internal/cmd/skupper/system/nonkube/system_reload_test.go

@@ -36,7 +36,6 @@ func TestCmdSystemReload_ValidateInput(t *testing.T) {
 
 	for _, test := range testTable {
 		t.Run(test.name, func(t *testing.T) {
-
 			command := &CmdSystemReload{}
 			command.Namespace = test.namespace
 			command.CobraCmd = common.ConfigureCobraCommand(common.PlatformLinux, common.SkupperCmdDescription{}, command, nil)

internal/cmd/skupper/system/nonkube/system_start_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/skupperproject/skupper/api/types"
 	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
 	"github.com/skupperproject/skupper/internal/cmd/skupper/common/testutils"
 	"github.com/skupperproject/skupper/internal/config"
@@ -38,7 +39,7 @@ func TestCmdSystemSetup_ValidateInput(t *testing.T) {
 
 	for _, test := range testTable {
 		t.Run(test.name, func(t *testing.T) {
-
+			t.Setenv(types.ENV_SYSTEM_AUTO_RELOAD, types.SystemReloadTypeManual)
 			command := &CmdSystemStart{}
 			command.CobraCmd = common.ConfigureCobraCommand(common.PlatformLinux, common.SkupperCmdDescription{}, command, nil)
 			command.Namespace = test.namespace

internal/cmd/skupper/system/nonkube/system_stop.go

@@ -4,8 +4,10 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/skupperproject/skupper/api/types"
 	"github.com/skupperproject/skupper/internal/config"
 	"github.com/skupperproject/skupper/internal/nonkube/bootstrap"
+	"github.com/skupperproject/skupper/internal/nonkube/common"
 	"github.com/skupperproject/skupper/internal/utils/validator"
 	"github.com/spf13/cobra"
 )
@@ -45,6 +47,20 @@ func (cmd *CmdSystemStop) ValidateInput(args []string) error {
 		}
 	}
 
+	platformLoader := &common.NamespacePlatformLoader{}
+	configuredPlatform, err := platformLoader.Load(cmd.Namespace)
+	if err != nil {
+		return err
+	}
+
+	currentPlatform := config.GetPlatform()
+	if currentPlatform.IsKubernetes() {
+		currentPlatform = types.PlatformPodman
+	}
+	if string(currentPlatform) != configuredPlatform {
+		validationErrors = append(validationErrors, fmt.Errorf("existing namespace uses %q platform and it cannot change to %q", configuredPlatform, string(currentPlatform)))
+	}
+
 	return errors.Join(validationErrors...)
 }
 

internal/cmd/skupper/system/nonkube/system_stop_test.go

@@ -2,37 +2,82 @@ package nonkube
 
 import (
 	"fmt"
+	"os"
+	"path"
 	"testing"
 
+	"github.com/skupperproject/skupper/api/types"
 	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
 	"github.com/skupperproject/skupper/internal/cmd/skupper/common/testutils"
+	"github.com/skupperproject/skupper/internal/config"
+	"github.com/skupperproject/skupper/pkg/nonkube/api"
 	"gotest.tools/v3/assert"
 )
 
 func TestCmdSystemTearDown_ValidateInput(t *testing.T) {
 	type test struct {
-		name          string
-		namespace     string
-		args          []string
-		expectedError string
+		name            string
+		namespace       string
+		args            []string
+		envSystemReload string
+		expectedError   string
+		configPlatform  string // platform.yaml content
+		currentPlatform string // SKUPPER_PLATFORM env var value
 	}
 
 	testTable := []test{
 		{
-			name:          "arg-not-accepted",
-			args:          []string{"namespace"},
-			expectedError: "this command does not accept arguments",
+			name:            "arg-not-accepted",
+			args:            []string{"namespace"},
+			configPlatform:  "podman",
+			currentPlatform: "podman",
+			expectedError:   "this command does not accept arguments",
+		},
+		{
+			name:            "invalid-namespace",
+			namespace:       "Invalid",
+			configPlatform:  "docker",
+			currentPlatform: "docker",
+			expectedError:   "namespace is not valid: value does not match this regular expression: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
 		},
 		{
-			name:          "invalid-namespace",
-			namespace:     "Invalid",
-			expectedError: "namespace is not valid: value does not match this regular expression: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$",
+			name:            "platform-mismatch-podman-vs-docker",
+			namespace:       "test-ns",
+			configPlatform:  "podman",
+			currentPlatform: "docker",
+			expectedError:   `existing namespace uses "podman" platform and it cannot change to "docker"`,
 		},
 	}
 
 	for _, test := range testTable {
 		t.Run(test.name, func(t *testing.T) {
 
+			// Create a temporary directory to simulate the namespace output path
+			tmpDir := t.TempDir()
+
+			namespace := test.namespace
+			if namespace == "" {
+				namespace = "default"
+			}
+
+			internalDir := path.Join(tmpDir, "skupper", "namespaces", namespace, string(api.InternalBasePath))
+			err := os.MkdirAll(internalDir, 0755)
+			assert.NilError(t, err)
+
+			//create platform config file
+			platformYaml := fmt.Sprintf("platform: %s\n", test.configPlatform)
+			err = os.WriteFile(path.Join(internalDir, "platform.yaml"), []byte(platformYaml), 0644)
+			assert.NilError(t, err)
+
+			t.Setenv("XDG_DATA_HOME", tmpDir)
+
+			//set the current platform
+			config.ClearPlatform()
+			t.Setenv(types.ENV_PLATFORM, test.currentPlatform)
+			t.Cleanup(func() {
+				config.ClearPlatform()
+			})
+
 			command := &CmdSystemStop{}
 			command.Namespace = test.namespace
 			command.CobraCmd = common.ConfigureCobraCommand(common.PlatformLinux, common.SkupperCmdDescription{}, command, nil)

internal/cmd/skupper/system/system.go

@@ -112,8 +112,14 @@ func CmdSystemInstallFactory(configuredPlatform common.Platform) *cobra.Command
 
 	cmd := common.ConfigureCobraCommand(configuredPlatform, cmdSystemInstallDesc, kubeCommand, nonKubeCommand)
 
+	cmdFlags := common.CommandSystemInstallFlags{}
+
+	cmd.Flags().StringVar(&cmdFlags.ReloadType, common.FlagNameReloadType, "manual", common.FlagDescReloadType)
+
 	kubeCommand.CobraCmd = cmd
+	kubeCommand.Flags = &cmdFlags
 	nonKubeCommand.CobraCmd = cmd
+	nonKubeCommand.Flags = &cmdFlags
 
 	return cmd
 }

internal/cmd/skupper/system/system_test.go

@@ -42,9 +42,11 @@ func TestCmdSystemFactory(t *testing.T) {
 			command: CmdSystemGenerateBundleFactory(common.PlatformPodman),
 		},
 		{
-			name:                          "CmdSystemInstallFactory",
-			expectedFlagsWithDefaultValue: map[string]interface{}{},
-			command:                       CmdSystemInstallFactory(common.PlatformKubernetes),
+			name: "CmdSystemInstallFactory",
+			expectedFlagsWithDefaultValue: map[string]interface{}{
+				common.FlagNameReloadType: "manual",
+			},
+			command: CmdSystemInstallFactory(common.PlatformKubernetes),
 		},
 		{
 			name: "CmdSystemUninstallFactory",

internal/kube/adaptor/config_sync.go

@@ -181,7 +181,7 @@ func syncConnectors(agent *qdr.Agent, desired *qdr.RouterConfig) error {
 
 	ignorePrefix := "auto-mesh"
 	if differences := qdr.ConnectorsDifference(actual, desired, &ignorePrefix); !differences.Empty() {
-		if err = agent.UpdateConnectorConfig(differences); err != nil {
+		if err = agent.UpdateConnectorConfig(differences, true); err != nil {
 			return fmt.Errorf("Error syncing connectors: %s", err)
 		}
 	}

internal/nonkube/bootstrap/bootstrap.go

@@ -109,7 +109,7 @@ func Bootstrap(config *Config) (*api.SiteState, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to load site state: %v", err)
 	}
-	// if sources are being consume from namespace sources, they must be properly set
+	// if sources are being consumed from namespace sources, they must be properly set
 	crNamespace := siteState.GetNamespace()
 	targetNamespace := utils.DefaultStr(config.Namespace, "default")
 	if config.InputPath == sourcesPath {