Non-kube network observer installation

internal/cmd/skupper/common/flags.go

@@ -92,6 +92,12 @@ for other Kubernetes flavors, loadbalancer is the default.`
 
 	FlagNameReloadType = "reload-type"
 	FlagDescReloadType = "Specify the type of reload to perform. Choices: manual, auto"
+
+	FlagNameNetworkObserverUninstall = "uninstall"
+	FlagDescNetworkObserverUninstall = "Uninstall Network Observer"
+
+	FlagNamePrometheusUninstall = "uninstall"
+	FlagDescPrometheusUninstall = "Uninstall Prometheus"
 )
 
 type CommandSiteCreateFlags struct {
@@ -245,6 +251,14 @@ type CommandListenerGenerateFlags struct {
 	Output         string
 }
 
+type CommandNetworkObserverFlags struct {
+	Uninstall bool
+}
+
+type CommandPrometheusFlags struct {
+	Uninstall bool
+}
+
 type CommandVersionFlags struct {
 	Output string
 }

internal/cmd/skupper/system/kube/system_network-observer.go

@@ -0,0 +1,39 @@
+package kube
+
+import (
+	"fmt"
+
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
+	"github.com/spf13/cobra"
+)
+
+type CmdSystemNetworkObserver struct {
+	CobraCmd  *cobra.Command
+	Flags     *common.CommandNetworkObserverFlags
+	namespace string
+	user      string
+	password  string
+}
+
+func NewCmdSystemNetworkObserver() *CmdSystemNetworkObserver {
+	return &CmdSystemNetworkObserver{}
+}
+
+func (cmd *CmdSystemNetworkObserver) NewClient(cobraCommand *cobra.Command, args []string) {}
+
+func (cmd *CmdSystemNetworkObserver) ValidateInput(args []string) error {
+	return nil
+}
+
+func (cmd *CmdSystemNetworkObserver) InputToOptions() {
+
+}
+
+func (cmd *CmdSystemNetworkObserver) Run() error {
+	fmt.Println("This command does not support kubernetes platforms.")
+	return nil
+}
+
+func (cmd *CmdSystemNetworkObserver) WaitUntil() error {
+	return nil
+}

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

@@ -0,0 +1,34 @@
+package kube
+
+import (
+	"fmt"
+
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
+	"github.com/spf13/cobra"
+)
+
+type CmdSystemPrometheus struct {
+	CobraCmd *cobra.Command
+	Flags    *common.CommandPrometheusFlags
+}
+
+func NewCmdSystemPrometheus() *CmdSystemPrometheus {
+	return &CmdSystemPrometheus{}
+}
+
+func (cmd *CmdSystemPrometheus) NewClient(cobraCommand *cobra.Command, args []string) {}
+
+func (cmd *CmdSystemPrometheus) ValidateInput(args []string) error {
+	return nil
+}
+
+func (cmd *CmdSystemPrometheus) InputToOptions() {}
+
+func (cmd *CmdSystemPrometheus) Run() error {
+	fmt.Println("This command does not support kubernetes platforms.")
+	return nil
+}
+
+func (cmd *CmdSystemPrometheus) WaitUntil() error {
+	return nil
+}

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

@@ -0,0 +1,46 @@
+package kube
+
+import (
+	"testing"
+
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
+)
+
+func TestCmdSystemPrometheus_ValidateInput(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+	}{
+		{name: "no arguments"},
+		{name: "arguments are accepted", args: []string{"something"}},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cmd := &CmdSystemPrometheus{Flags: &common.CommandPrometheusFlags{}}
+			if err := cmd.ValidateInput(test.args); err != nil {
+				t.Fatalf("expected no error, got %q", err)
+			}
+		})
+	}
+}
+
+func TestCmdSystemPrometheus_Run(t *testing.T) {
+	// The kube Run prints a not-supported message and always returns nil.
+	cmd := &CmdSystemPrometheus{Flags: &common.CommandPrometheusFlags{}}
+	if err := cmd.Run(); err != nil {
+		t.Fatalf("expected no error, got %q", err)
+	}
+}
+
+func TestCmdSystemPrometheus_WaitUntil(t *testing.T) {
+	cmd := &CmdSystemPrometheus{}
+	if err := cmd.WaitUntil(); err != nil {
+		t.Fatalf("expected no error, got %q", err)
+	}
+}
+
+func TestCmdSystemPrometheus_InputToOptions(t *testing.T) {
+	cmd := &CmdSystemPrometheus{Flags: &common.CommandPrometheusFlags{}}
+	cmd.InputToOptions()
+}

internal/cmd/skupper/system/nonkube/system_network-observer.go

@@ -0,0 +1,79 @@
+package nonkube
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
+	networkobserver "github.com/skupperproject/skupper/internal/nonkube/network-observer"
+	"github.com/spf13/cobra"
+)
+
+type CmdSystemNetworkObserver struct {
+	CobraCmd  *cobra.Command
+	Flags     *common.CommandNetworkObserverFlags
+	namespace string
+}
+
+func NewCmdSystemNetworkObserver() *CmdSystemNetworkObserver {
+	return &CmdSystemNetworkObserver{}
+}
+
+func (cmd *CmdSystemNetworkObserver) NewClient(cobraCommand *cobra.Command, args []string) {
+	if cmd.CobraCmd != nil && cmd.CobraCmd.Flag(common.FlagNameNamespace) != nil {
+		cmd.namespace = cmd.CobraCmd.Flag(common.FlagNameNamespace).Value.String()
+	}
+	if cmd.namespace == "" {
+		cmd.namespace = "default"
+	}
+}
+
+func (cmd *CmdSystemNetworkObserver) ValidateInput(args []string) error {
+	var validationErrors []error
+
+	if len(args) > 0 {
+		validationErrors = append(validationErrors, fmt.Errorf("this command does not accept arguments"))
+	}
+
+	return errors.Join(validationErrors...)
+}
+
+func (cmd *CmdSystemNetworkObserver) InputToOptions() {}
+
+func (cmd *CmdSystemNetworkObserver) Run() error {
+	installer, err := networkobserver.NewInstaller(cmd.namespace)
+	if err != nil {
+		return fmt.Errorf("failed to create installer: %w", err)
+	}
+
+	if cmd.Flags.Uninstall {
+
+		if err := installer.ValidatePrerequisitesForUninstall(); err != nil {
+			return err
+		}
+
+		if err := installer.Uninstall(); err != nil {
+			return fmt.Errorf("uninstallation failed: %w", err)
+		}
+
+		return nil
+	}
+
+	if err := installer.ValidatePrerequisitesForInstall(); err != nil {
+		return fmt.Errorf("prerequisite validation failed: %w", err)
+	}
+
+	result, err := installer.Install()
+	if err != nil {
+		return fmt.Errorf("installation failed: %w", err)
+	}
+
+	fmt.Println("Network observer installed successfully!")
+	fmt.Printf("\nAccess URL: %s\n", result.URL)
+
+	return nil
+}
+
+func (cmd *CmdSystemNetworkObserver) WaitUntil() error {
+	return nil
+}

internal/cmd/skupper/system/nonkube/system_network-observer_test.go

@@ -0,0 +1,102 @@
+package nonkube
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/skupperproject/skupper/internal/cmd/skupper/common"
+	"github.com/spf13/cobra"
+)
+
+func TestCmdSystemNetworkObserverValidateInput(t *testing.T) {
+	tests := []struct {
+		name          string
+		args          []string
+		flags         *common.CommandNetworkObserverFlags
+		expectedError []string
+	}{
+		{
+			name:          "rejects arguments",
+			args:          []string{"extra"},
+			expectedError: []string{"this command does not accept arguments"},
+		},
+		{
+			name:  "accepts no arguments",
+			flags: &common.CommandNetworkObserverFlags{},
+		},
+		{
+			name:  "accepts uninstall flag",
+			flags: &common.CommandNetworkObserverFlags{Uninstall: true},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cmd := &CmdSystemNetworkObserver{Flags: test.flags}
+
+			err := cmd.ValidateInput(test.args)
+			if len(test.expectedError) == 0 {
+				if err != nil {
+					t.Fatalf("expected no error, got %q", err.Error())
+				}
+				return
+			}
+
+			if err == nil {
+				t.Fatal("expected error")
+			}
+			for _, expected := range test.expectedError {
+				if !strings.Contains(err.Error(), expected) {
+					t.Fatalf("expected validation error %q, got %q", expected, err.Error())
+				}
+			}
+		})
+	}
+}
+
+func TestCmdSystemNetworkObserverNewClient(t *testing.T) {
+	tests := []struct {
+		name              string
+		flagNamespace     string
+		initialNamespace  string
+		expectedNamespace string
+	}{
+		{
+			name:              "uses namespace flag",
+			flagNamespace:     "west",
+			expectedNamespace: "west",
+		},
+		{
+			name:              "defaults namespace",
+			expectedNamespace: "default",
+		},
+		{
+			name:              "defaults even when namespace was preset without flag",
+			initialNamespace:  "east",
+			expectedNamespace: "default",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cobraCmd := &cobra.Command{}
+			cobraCmd.Flags().String(common.FlagNameNamespace, "", "")
+			if test.flagNamespace != "" {
+				if err := cobraCmd.Flags().Set(common.FlagNameNamespace, test.flagNamespace); err != nil {
+					t.Fatalf("failed to set namespace flag: %v", err)
+				}
+			}
+
+			cmd := &CmdSystemNetworkObserver{
+				CobraCmd:  cobraCmd,
+				namespace: test.initialNamespace,
+			}
+
+			cmd.NewClient(cobraCmd, nil)
+
+			if cmd.namespace != test.expectedNamespace {
+				t.Fatalf("expected namespace %q, got %q", test.expectedNamespace, cmd.namespace)
+			}
+		})
+	}
+}