feat: api update include fileds, naming and methods & cmd updates

Author: poneding

cmd/krb-cli/cmd/get-recycle-items.go

@@ -25,21 +25,20 @@ import (
 	"github.com/ketches/kube-recycle-bin/internal/api"
 	krbclient "github.com/ketches/kube-recycle-bin/internal/client"
 	"github.com/ketches/kube-recycle-bin/internal/completion"
+	"github.com/ketches/kube-recycle-bin/pkg/kube"
 	"github.com/ketches/kube-recycle-bin/pkg/tlog"
 	"github.com/spf13/cobra"
+	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/duration"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 type GetRecycleItemFlags struct {
-	Group         string
-	Version       string
-	Kind          string
-	Namespace     string
-	AllNamespaces bool
+	ObjectResource  string
+	ObjectNamespace string
 }
 
-var getRecycylItemFlags GetRecycleItemFlags
+var getRecycleItemFlags GetRecycleItemFlags
 
 // getRecycleItemCmd represents the get recycle item command
 var getRecycleItemCmd = &cobra.Command{
@@ -48,11 +47,17 @@ var getRecycleItemCmd = &cobra.Command{
 	Short:   "Get recycle items",
 	Long:    `Get recycle items. This command retrieves the specified RecycleItem resources.`,
 	Example: `
+# Get all RecycleItems
+krb-cli get ri
+
 # Get RecycleItems with names foo and bar
-krb-cli get recycleitems foo bar
+krb-cli get ri foo bar
+
+# Get RecycleItems recycled from deployments resource
+krb-cli get ri --object-resource deployments
 
-# Get all RecyclePolicies
-krb-cli get recyclepolicies
+# Get RecycleItems recycled from dev namespace
+krb-cli get ri --object-namespace dev
 `,
 	Run: func(cmd *cobra.Command, args []string) {
 		runGetRecycleItems(args)
@@ -63,28 +68,42 @@ krb-cli get recyclepolicies
 func init() {
 	getCmd.AddCommand(getRecycleItemCmd)
 
-	getRecycleItemCmd.Flags().StringVarP(&getRecycylItemFlags.Group, "group", "g", "", "List resources of the specified group")
-	getRecycleItemCmd.Flags().StringVarP(&getRecycylItemFlags.Kind, "kind", "k", "", "List resources of the specified kind")
-	getRecycleItemCmd.Flags().StringVarP(&getRecycylItemFlags.Version, "version", "v", "", "List resources with the specified version")
-	getRecycleItemCmd.Flags().StringVarP(&getRecycylItemFlags.Namespace, "namespace", "n", "default", "List resources in the specified namespace")
-	getRecycleItemCmd.Flags().BoolVarP(&getRecycylItemFlags.AllNamespaces, "all-namespaces", "A", false, "List resources from all namespaces")
+	getRecycleItemCmd.Flags().StringVarP(&getRecycleItemFlags.ObjectResource, "object-resource", "", "", "List recycled resource objects filtered by the specified object resource")
+	getRecycleItemCmd.Flags().StringVarP(&getRecycleItemFlags.ObjectNamespace, "object-namespace", "", "", "List recycled resource objects filtered by the specified object namespace")
 
-	getRecycleItemCmd.MarkFlagsMutuallyExclusive("namespace", "all-namespaces")
+	getRecycleItemCmd.RegisterFlagCompletionFunc("object-resource", completion.RecycleItemGroupResource)
+	getRecycleItemCmd.RegisterFlagCompletionFunc("object-namespace", completion.RecycleItemNamespace)
 }
 
 func runGetRecycleItems(args []string) {
 	var result api.RecycleItemList
+
 	if len(args) > 0 {
-		for _, objName := range args {
-			obj, err := krbclient.RecycleItem().Get(context.Background(), objName, client.GetOptions{})
+		for _, name := range args {
+			obj, err := krbclient.RecycleItem().Get(context.Background(), name, client.GetOptions{})
 			if err != nil {
-				tlog.Errorf("✗ failed to get RecycleItem [%s]: %v, skipping.", objName, err)
+				tlog.Errorf("✗ failed to get RecycleItem [%s]: %v, skipping.", name, err)
 				continue
 			}
 			result.Items = append(result.Items, *obj)
 		}
 	} else {
-		list, err := krbclient.RecycleItem().List(context.Background(), client.ListOptions{})
+		labelSet := labels.Set{}
+		if getRecycleItemFlags.ObjectNamespace != "" {
+			labelSet["krb.ketches.cn/object-namespace"] = getRecycleItemFlags.ObjectNamespace
+		}
+		if getRecycleItemFlags.ObjectResource != "" {
+			tlog.Println(getRecycleItemFlags.ObjectResource)
+			if gvr, err := kube.GetPreferredGroupVersionResourceFor(getRecycleItemFlags.ObjectResource); err != nil {
+				tlog.Panicf("✗ failed to get preferred group version resource: %v", err)
+			} else {
+				labelSet["krb.ketches.cn/object-gr"] = gvr.GroupResource().String()
+			}
+		}
+
+		list, err := krbclient.RecycleItem().List(context.Background(), client.ListOptions{
+			LabelSelector: labels.SelectorFromSet(labelSet),
+		})
 		if err != nil {
 			tlog.Panicf("✗ failed to list RecycleItem: %v", err)
 			return
@@ -97,7 +116,7 @@ func runGetRecycleItems(args []string) {
 	t.AppendHeader(table.Row{"name", "group", "version", "kind", "namespace", "name", "age"})
 
 	for _, obj := range result.Items {
-		t.AppendRow(table.Row{obj.Name, obj.Object.Group, obj.Object.Version, obj.Object.Kind, obj.Object.Namespace, obj.Object.Name, duration.HumanDuration(time.Since(obj.CreationTimestamp.Time))}, table.RowConfig{
+		t.AppendRow(table.Row{obj.Name, obj.Object.Group, obj.Object.Version, obj.Object.Resource, obj.Object.Namespace, obj.Object.Name, duration.HumanDuration(time.Since(obj.CreationTimestamp.Time))}, table.RowConfig{
 			AutoMerge: true,
 		})
 	}

cmd/krb-cli/cmd/get-recycle-policies.go

@@ -25,21 +25,20 @@ import (
 	"github.com/ketches/kube-recycle-bin/internal/api"
 	krbclient "github.com/ketches/kube-recycle-bin/internal/client"
 	"github.com/ketches/kube-recycle-bin/internal/completion"
+	"github.com/ketches/kube-recycle-bin/pkg/kube"
 	"github.com/ketches/kube-recycle-bin/pkg/tlog"
 	"github.com/spf13/cobra"
+	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/util/duration"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 type GetRecyclePoliciesFlags struct {
-	Group         string
-	Version       string
-	Kind          string
-	Namespace     string
-	AllNamespaces bool
+	TargetResource  string
+	TargetNamespace string
 }
 
-var getRecycylPoliciesFlags GetRecyclePoliciesFlags
+var getRecyclePoliciesFlags GetRecyclePoliciesFlags
 
 // getRecyclePoliciesCmd represents the get recycle policies command
 var getRecyclePoliciesCmd = &cobra.Command{
@@ -48,11 +47,17 @@ var getRecyclePoliciesCmd = &cobra.Command{
 	Short:   "Get recycle policies",
 	Long:    `Get recycle policies. This command retrieves the specified RecyclePolicy resources.`,
 	Example: `
+# Get all RecyclePolicy
+krb-cli get recyclepolicies
+
 # Get RecyclePolicy with names foo and bar
 krb-cli get recyclepolicies foo bar
 
-# Get all RecyclePolicy
-krb-cli get recyclepolicies
+# Get RecyclePolicy for deployments resource
+krb-cli get recyclepolicies --target-resource deployments
+
+# Get RecyclePolicy for default namespace
+krb-cli get recyclepolicies --target-namespace default
 `,
 	Run: func(cmd *cobra.Command, args []string) {
 		runGetRecyclePolicies(args)
@@ -63,28 +68,37 @@ krb-cli get recyclepolicies
 func init() {
 	getCmd.AddCommand(getRecyclePoliciesCmd)
 
-	getRecyclePoliciesCmd.Flags().StringVarP(&getRecycylPoliciesFlags.Group, "group", "g", "", "List resources of the specified group")
-	getRecyclePoliciesCmd.Flags().StringVarP(&getRecycylPoliciesFlags.Kind, "kind", "k", "", "List resources of the specified kind")
-	getRecyclePoliciesCmd.Flags().StringVarP(&getRecycylPoliciesFlags.Version, "version", "v", "", "List resources with the specified version")
-	getRecyclePoliciesCmd.Flags().StringVarP(&getRecycylPoliciesFlags.Namespace, "namespace", "n", "default", "List resources in the specified namespace")
-	getRecyclePoliciesCmd.Flags().BoolVarP(&getRecycylPoliciesFlags.AllNamespaces, "all-namespaces", "A", false, "List resources from all namespaces")
+	getRecyclePoliciesCmd.Flags().StringVarP(&getRecyclePoliciesFlags.TargetResource, "target-resource", "", "", "List recycle policies filtered by the specified target resource")
+	getRecyclePoliciesCmd.Flags().StringVarP(&getRecyclePoliciesFlags.TargetNamespace, "target-namespace", "", "", "List recycle policies filtered by the specified target namespace")
 
-	getRecyclePoliciesCmd.MarkFlagsMutuallyExclusive("namespace", "all-namespaces")
+	getRecyclePoliciesCmd.RegisterFlagCompletionFunc("target-resource", completion.RecyclePolicyGroupResource)
+	getRecyclePoliciesCmd.RegisterFlagCompletionFunc("target-namespace", completion.RecyclePolicyNamespace)
 }
 
 func runGetRecyclePolicies(args []string) {
 	var result api.RecyclePolicyList
 	if len(args) > 0 {
-		for _, objName := range args {
-			obj, err := krbclient.RecyclePolicy().Get(context.Background(), objName, client.GetOptions{})
+		for _, name := range args {
+			obj, err := krbclient.RecyclePolicy().Get(context.Background(), name, client.GetOptions{})
 			if err != nil {
-				tlog.Errorf("✗ failed to get RecyclePolicy [%s]: %v, skipping.", objName, err)
+				tlog.Errorf("✗ failed to get RecyclePolicy [%s]: %v, ignored.", name, err)
 				continue
 			}
 			result.Items = append(result.Items, *obj)
 		}
 	} else {
-		list, err := krbclient.RecyclePolicy().List(context.Background(), client.ListOptions{})
+		labelSet := labels.Set{}
+		if getRecyclePoliciesFlags.TargetResource != "" {
+			if gvr, err := kube.GetPreferredGroupVersionResourceFor(getRecyclePoliciesFlags.TargetResource); err != nil {
+				tlog.Panicf("✗ failed to get preferred group version resource: %v", err)
+			} else {
+				labelSet["krb.ketches.cn/target-gr"] = gvr.GroupResource().String()
+			}
+		}
+		list, err := krbclient.RecyclePolicy().List(context.Background(), client.ListOptions{
+			LabelSelector: labels.SelectorFromSet(labelSet),
+			Namespace:     getRecyclePoliciesFlags.TargetNamespace,
+		})
 		if err != nil {
 			tlog.Panicf("✗ failed to list RecyclePolicy: %v", err)
 			return

cmd/krb-cli/cmd/recycle.go

@@ -63,14 +63,14 @@ func runRecycle(args []string) {
 		tlog.Panicf("✗ please specify a resource to recycle.")
 	}
 
-	for _, fuzzResource := range args {
-		gvr, err := kube.GetPreferredGroupVersionResource(fuzzResource)
+	for _, resource := range args {
+		gvr, err := kube.GetPreferredGroupVersionResourceFor(resource)
 		if err != nil {
 			tlog.Errorf("✗ failed to get gvr from resource name: %v, ignored.", err)
 			continue
 		}
 		if gvr == nil {
-			tlog.Errorf("✗ no resources found for %s, ignored.", fuzzResource)
+			tlog.Errorf("✗ no resources found for %s, ignored.", resource)
 			continue
 		}
 

cmd/krb-cli/cmd/restore.go

@@ -28,11 +28,29 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
+type RestoreFlags struct {
+	ObjectResource  string
+	ObjectNamespace string
+}
+
+var restoreFlags RestoreFlags
+
 // restoreCmd represents the restore command
 var restoreCmd = &cobra.Command{
 	Use:   "restore",
-	Short: "Restore resources from a RecycleItem",
+	Short: "Restore recycled resource objects from RecycleItem",
 	Args:  cobra.MinimumNArgs(1),
+	Example: `
+# Restore RecycleItem with names foo and bar
+krb-cli restore foo bar
+
+# Restore RecycleItem deployments foo and filter by object resource deployments
+krb-cli restore --object-resource deployments foo
+
+# Restore RecycleItem deployments foo-deploy, service foo-svc and filter by object namespace dev
+krb-cli restore --object-namespace dev foo-deploy foo-svc
+`,
+
 	Run: func(cmd *cobra.Command, args []string) {
 		runRestore(args)
 	},
@@ -41,6 +59,12 @@ var restoreCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(restoreCmd)
+
+	restoreCmd.Flags().StringVarP(&restoreFlags.ObjectResource, "object-resource", "", "", "Restore recycled resource objects filtered by the specified object resource")
+	restoreCmd.Flags().StringVarP(&restoreFlags.ObjectNamespace, "object-namespace", "", "", "Restore recycled resource objects filtered by the specified object namespace")
+
+	restoreCmd.RegisterFlagCompletionFunc("object-resource", completion.RecycleItemGroupResource)
+	restoreCmd.RegisterFlagCompletionFunc("object-namespace", completion.RecycleItemNamespace)
 }
 
 func runRestore(args []string) {
@@ -55,19 +79,19 @@ func runRestore(args []string) {
 			continue
 		}
 
-		unstructuredObj, err := recycleItem.ObjectUnstructured()
+		unstructuredObj, err := recycleItem.Object.Unstructured()
 		if err != nil {
 			tlog.Printf("✗ failed to get unstructured object from RecycleItem [%s]: %v, ignored.", recycleItemName, err)
 			continue
 		}
 
-		if _, err := kube.DynamicClient().Resource(recycleItem.ObjectGroupVersionResource()).Namespace(recycleItem.ObjectNamespace()).Create(context.Background(), unstructuredObj, metav1.CreateOptions{}); err != nil {
-			tlog.Printf("✗ failed to restore resource [%s]: %v", recycleItem.ObjectNamespacedName().String(), err)
+		if _, err := kube.DynamicClient().Resource(recycleItem.Object.GroupVersionResource()).Namespace(recycleItem.Object.Namespace).Create(context.Background(), unstructuredObj, metav1.CreateOptions{}); err != nil {
+			tlog.Printf("✗ failed to restore recycled resource object [%s]: %v", recycleItem.Object.Key().String(), err)
 		} else {
-			tlog.Printf("✓ restored %s [%s] done.", recycleItem.Kind, recycleItem.ObjectNamespacedName().String())
+			tlog.Printf("✓ restored recycled resource object [%s: %s] done.", recycleItem.Object.Resource, recycleItem.Object.Key().String())
 			// delete the recycle item after successful restore
 			if err := krbclient.RecycleItem().Delete(context.Background(), recycleItemName, client.DeleteOptions{}); err != nil {
-				tlog.Printf("✗ failed to automatically delete RecycleItem [%s]: %v", recycleItemName, err)
+				tlog.Printf("✗ failed to automatically delete RecycleItem [%s] after restore: %v", recycleItemName, err)
 			} else {
 				tlog.Printf("✓ automatically deleted RecycleItem [%s] after restore.", recycleItemName)
 			}