Added manage and unmanaged commands (kyma-project#2316)

Co-authored-by: Cortey <[email protected]>

internal/cmd/alpha/module/manage.go

@@ -0,0 +1,64 @@
+package module
+
+import (
+	"fmt"
+	"github.com/kyma-project/cli.v3/internal/clierror"
+	"github.com/kyma-project/cli.v3/internal/cmdcommon"
+	"github.com/spf13/cobra"
+)
+
+type manageConfig struct {
+	*cmdcommon.KymaConfig
+
+	module string
+	policy string
+}
+
+func newManageCMD(kymaConfig *cmdcommon.KymaConfig) *cobra.Command {
+	cfg := manageConfig{
+		KymaConfig: kymaConfig,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "manage <module>",
+		Short: "Manage module.",
+		Long:  "Use this command to manage an existing module.",
+
+		PreRun: func(_ *cobra.Command, args []string) {
+			clierror.Check(cfg.validate())
+		},
+		Run: func(cmd *cobra.Command, args []string) {
+			clierror.Check(runManage(&cfg))
+		},
+	}
+
+	cmd.Flags().StringVar(&cfg.module, "module", "", "Name of the module to manage")
+	cmd.Flags().StringVar(&cfg.policy, "policy", "CreateAndDelete", "Set custom resource policy. (Possible values: CreateAndDelete, Ignore)")
+	_ = cmd.MarkFlagRequired("module")
+	return cmd
+}
+
+func (mc *manageConfig) validate() clierror.Error {
+	if mc.policy != "CreateAndDelete" && mc.policy != "Ignore" {
+		return clierror.New(fmt.Sprintf("invalid policy %q, only CreateAndDelete and Ignore are allowed", mc.policy))
+	}
+
+	return nil
+}
+
+func runManage(cfg *manageConfig) clierror.Error {
+	client, clierr := cfg.GetKubeClientWithClierr()
+	if clierr != nil {
+		return clierr
+	}
+
+	err := client.Kyma().ManageModule(cfg.Ctx, cfg.module, cfg.policy)
+	if err != nil {
+		return clierror.Wrap(err, clierror.New("failed to set module as managed"))
+	}
+	err = client.Kyma().WaitForModuleState(cfg.Ctx, cfg.module, "Ready", "Warning")
+	if err != nil {
+		return clierror.Wrap(err, clierror.New("failed to check module state"))
+	}
+	return nil
+}

internal/cmd/alpha/module/module.go

@@ -16,6 +16,8 @@ func NewModuleCMD(kymaConfig *cmdcommon.KymaConfig) *cobra.Command {
 	cmd.AddCommand(newListCMD(kymaConfig))
 	cmd.AddCommand(newAddCMD(kymaConfig))
 	cmd.AddCommand(newDeleteCMD(kymaConfig))
+	cmd.AddCommand(newManageCMD(kymaConfig))
+	cmd.AddCommand(newUnmanageCMD(kymaConfig))
 
 	return cmd
 }

internal/cmd/alpha/module/unmanage.go

@@ -0,0 +1,50 @@
+package module
+
+import (
+	"github.com/kyma-project/cli.v3/internal/clierror"
+	"github.com/kyma-project/cli.v3/internal/cmdcommon"
+	"github.com/spf13/cobra"
+)
+
+type unmanageConfig struct {
+	*cmdcommon.KymaConfig
+
+	module string
+}
+
+func newUnmanageCMD(kymaConfig *cmdcommon.KymaConfig) *cobra.Command {
+	cfg := unmanageConfig{
+		KymaConfig: kymaConfig,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "unmanage <module>",
+		Short: "Unmanage module.",
+		Long:  "Use this command to unmanage an existing module.",
+		Run: func(cmd *cobra.Command, args []string) {
+			clierror.Check(runUnmanage(&cfg))
+		},
+	}
+
+	cmd.Flags().StringVar(&cfg.module, "module", "", "Name of the module to unmanage")
+	_ = cmd.MarkFlagRequired("module")
+	return cmd
+}
+
+func runUnmanage(cfg *unmanageConfig) clierror.Error {
+	client, clierr := cfg.GetKubeClientWithClierr()
+	if clierr != nil {
+		return clierr
+	}
+
+	err := client.Kyma().UnmanageModule(cfg.Ctx, cfg.module)
+	if err != nil {
+		return clierror.Wrap(err, clierror.New("failed to set module as unmanaged"))
+	}
+
+	err = client.Kyma().WaitForModuleState(cfg.Ctx, cfg.module, "Unmanaged")
+	if err != nil {
+		return clierror.Wrap(err, clierror.New("failed to check module state"))
+	}
+	return nil
+}

internal/kube/fake/kyma.go

@@ -78,3 +78,11 @@ func (c *KymaClient) DisableModule(_ context.Context, module string) error {
 	c.DisabledModules = append(c.DisabledModules, module)
 	return c.ReturnDisableModuleErr
 }
+
+func (c *KymaClient) ManageModule(_ context.Context, _, _ string) error {
+	return c.ReturnWaitForModuleErr
+}
+
+func (c *KymaClient) UnmanageModule(_ context.Context, _ string) error {
+	return c.ReturnWaitForModuleErr
+}

internal/kube/kyma/kyma.go

@@ -2,7 +2,9 @@ package kyma
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"k8s.io/utils/ptr"
 	"slices"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -30,6 +32,8 @@ type Interface interface {
 	WaitForModuleState(context.Context, string, ...string) error
 	EnableModule(context.Context, string, string, string) error
 	DisableModule(context.Context, string) error
+	ManageModule(context.Context, string, string) error
+	UnmanageModule(context.Context, string) error
 }
 
 type client struct {
@@ -179,6 +183,36 @@ func (c *client) DisableModule(ctx context.Context, moduleName string) error {
 	return c.UpdateDefaultKyma(ctx, kymaCR)
 }
 
+// ManageModule configures given module as managed and updates Kyma CR in the kyma-system namespace with it
+func (c *client) ManageModule(ctx context.Context, moduleName, policy string) error {
+	kymaCR, err := c.GetDefaultKyma(ctx)
+	if err != nil {
+		return err
+	}
+
+	kymaCR, err = manageModule(kymaCR, moduleName, policy)
+	if err != nil {
+		return err
+	}
+
+	return c.UpdateDefaultKyma(ctx, kymaCR)
+}
+
+// UnmanageModule configures given module as unmanaged and updates Kyma CR in the kyma-system namespace with it
+func (c *client) UnmanageModule(ctx context.Context, moduleName string) error {
+	kymaCR, err := c.GetDefaultKyma(ctx)
+	if err != nil {
+		return err
+	}
+
+	kymaCR, err = unmanageModule(kymaCR, moduleName)
+	if err != nil {
+		return err
+	}
+
+	return c.UpdateDefaultKyma(ctx, kymaCR)
+}
+
 func checkModuleState(kymaObj runtime.Object, moduleName string, expectedStates ...string) error {
 	kyma := &Kyma{}
 	err := runtime.DefaultUnstructuredConverter.FromUnstructured(kymaObj.(*unstructured.Unstructured).Object, kyma)
@@ -241,6 +275,33 @@ func disableModule(kymaCR *Kyma, moduleName string) *Kyma {
 	return kymaCR
 }
 
+func manageModule(kymaCR *Kyma, moduleName, policy string) (*Kyma, error) {
+	for i, m := range kymaCR.Spec.Modules {
+		if m.Name == moduleName {
+			// module exists, update managed
+			kymaCR.Spec.Modules[i].Managed = ptr.To(true)
+			kymaCR.Spec.Modules[i].CustomResourcePolicy = policy
+
+			return kymaCR, nil
+		}
+	}
+
+	return kymaCR, errors.New("module not found")
+}
+
+func unmanageModule(kymaCR *Kyma, moduleName string) (*Kyma, error) {
+	for i, m := range kymaCR.Spec.Modules {
+		if m.Name == moduleName {
+			// module exists, update managed
+			kymaCR.Spec.Modules[i].Managed = ptr.To(false)
+
+			return kymaCR, nil
+		}
+	}
+
+	return kymaCR, errors.New("module not found")
+}
+
 func list[T any](ctx context.Context, client dynamic.Interface, gvr schema.GroupVersionResource) (*T, error) {
 	list, err := client.Resource(gvr).
 		List(ctx, metav1.ListOptions{})