Add kyma dashboard command (#2800)

Author: FilipRudy

docs/user/gen-docs/kyma_dashboard.md

@@ -20,6 +20,9 @@ kyma dashboard <command> [flags]
 ## Flags
 
 ```text
+      --container-name string   Specifies the name of the local container. (default "kyma-dashboard")
+  -p, --port string             Specifies the port on which the local dashboard will be exposed. (default "3001")
+  -v, --verbose                 Enables verbose output with detailed logs.
       --context string          The name of the kubeconfig context to use
   -h, --help                    Help for the command
       --kubeconfig string       Path to the Kyma kubeconfig file

internal/busola/container.go

@@ -52,8 +52,8 @@ func (c *Container) Start() error {
 }
 
 // Opens the kyma dashboard in a browser.
-func (c *Container) Open(path string) error {
-	url := fmt.Sprintf("http://localhost:%s%s/clusters", c.port, path)
+func (c *Container) Open() error {
+	url := fmt.Sprintf("http://localhost:%s/clusters", c.port)
 
 	err := browser.OpenURL(url)
 	if err != nil {
@@ -62,9 +62,9 @@ func (c *Container) Open(path string) error {
 	return nil
 }
 
-// Watch attaches to the running docker container and forwards its output.
-func (c *Container) Watch(ctx context.Context) error {
-	return c.docker.ContainerFollowRun(ctx, c.id, c.verbose)
+// Watch attaches to the running docker container, streams its output, and handles graceful shutdown on user interrupt.
+func (c *Container) Watch() error {
+	return c.docker.ContainerFollowRun(c.id, c.verbose)
 }
 
 func (c *Container) containerOpts(envs []string) docker.ContainerRunOpts {

internal/cmd/dashboard/dashboard.go

@@ -1,19 +1,64 @@
 package dashboard
 
 import (
+	"github.com/kyma-project/cli.v3/internal/busola"
+	"github.com/kyma-project/cli.v3/internal/clierror"
 	"github.com/kyma-project/cli.v3/internal/cmdcommon"
 	"github.com/spf13/cobra"
 )
 
+type dashboardConfig struct {
+	*cmdcommon.KymaConfig
+	port          string
+	containerName string
+	verbose       bool
+}
+
 func NewDashboardCMD(kymaConfig *cmdcommon.KymaConfig) *cobra.Command {
+	cfg := dashboardConfig{
+		KymaConfig: kymaConfig,
+	}
+
 	cmd := &cobra.Command{
 		Use:   "dashboard <command> [flags]",
 		Short: "Manages Kyma dashboard locally.",
 		Long:  `Use this command to manage Kyma dashboard locally in a Docker container.`,
-	}
+		Run: func(_ *cobra.Command, _ []string) {
+			clierror.Check(runDashboard(&cfg))
+		}}
+
+	cmd.Flags().StringVarP(&cfg.port, "port", "p", "3001", `Specifies the port on which the local dashboard will be exposed.`)
+	cmd.Flags().StringVar(&cfg.containerName, "container-name", "kyma-dashboard", `Specifies the name of the local container.`)
+	cmd.Flags().BoolVarP(&cfg.verbose, "verbose", "v", true, `Enables verbose output with detailed logs.`)
 
 	cmd.AddCommand(NewDashboardStartCMD(kymaConfig))
 	cmd.AddCommand(NewDashboardStopCMD(kymaConfig))
 
 	return cmd
 }
+
+func runDashboard(cfg *dashboardConfig) clierror.Error {
+	dash, err := busola.New(
+		cfg.containerName,
+		cfg.port,
+		cfg.verbose,
+	)
+
+	if err != nil {
+		return clierror.Wrap(err, clierror.New("failed to initialize docker client"))
+	}
+
+	if err = dash.Start(); err != nil {
+		return clierror.Wrap(err, clierror.New("failed to start kyma dashboard"))
+	}
+
+	if err = dash.Open(); err != nil {
+		return clierror.Wrap(err, clierror.New("failed to open kyma dashboard"))
+	}
+
+	if err = dash.Watch(); err != nil {
+		return clierror.Wrap(err, clierror.New("failed to watch kyma dashboard"))
+	}
+
+	return nil
+}

internal/cmd/dashboard/start.go

@@ -52,7 +52,7 @@ func runDashboardStart(cfg *dashboardStartConfig) clierror.Error {
 	}
 
 	if cfg.open {
-		err = dash.Open("")
+		err = dash.Open()
 	}
 	if err != nil {
 		return clierror.Wrap(err, clierror.New("failed to open kyma dashboard"))

internal/docker/containerfollowrun.go

@@ -5,12 +5,11 @@ import (
 	"io"
 
 	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/pkg/stdcopy"
 	"github.com/kyma-project/cli.v3/internal/out"
 )
 
-func (c *Client) ContainerFollowRun(ctx context.Context, containerID string, forwardOutput bool) error {
-	buf, err := c.ContainerAttach(ctx, containerID, container.AttachOptions{
+func (c *Client) ContainerFollowRun(containerID string, forwardOutput bool) error {
+	buf, err := c.ContainerAttach(context.Background(), containerID, container.AttachOptions{
 		Stdout: true,
 		Stderr: true,
 		Stream: true,
@@ -26,7 +25,12 @@ func (c *Client) ContainerFollowRun(ctx context.Context, containerID string, for
 		dsterr = out.Default.ErrWriter()
 	}
 
-	_, err = stdcopy.StdCopy(dstout, dsterr, buf.Reader)
+	c.stopContainerOnSigInt(
+		containerID,
+		dstout,
+		dsterr,
+		buf.Reader,
+	)
 
-	return err
+	return nil
 }

internal/docker/stopcontainer.go

@@ -0,0 +1,48 @@
+package docker
+
+import (
+	"context"
+	"io"
+	"os"
+	"os/signal"
+	"time"
+
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/pkg/stdcopy"
+	"github.com/kyma-project/cli.v3/internal/out"
+)
+
+func (c *Client) stopContainerOnSigInt(
+	containerID string,
+	dstout io.Writer,
+	dsterr io.Writer,
+	reader io.Reader,
+) {
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, os.Interrupt)
+	defer signal.Stop(sigCh)
+
+	done := make(chan struct{})
+
+	go func() {
+		_, _ = stdcopy.StdCopy(dstout, dsterr, reader)
+		close(done)
+	}()
+
+	select {
+	case <-sigCh:
+		stopCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		if err := c.ContainerStop(stopCtx, containerID, container.StopOptions{}); err != nil {
+			out.Default.Errfln(
+				"Failed to stop the running container. The container may still be running.\n"+
+					"You can try stopping it again using Kyma Dashboard.\n"+
+					"Error: %v",
+				err,
+			)
+		}
+		<-done
+	case <-done:
+	}
+}