add namespace scanning

Author: jsbroks

cmd/ctrlc/root/sync/kubernetes/kubernetes.go

@@ -2,17 +2,49 @@ package kubernetes
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/MakeNowJust/heredoc/v2"
 	"github.com/charmbracelet/log"
+	"github.com/ctrlplanedev/cli/internal/api"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 )
 
+func processNamespace(_ context.Context, namespace corev1.Namespace) api.CreateResource {
+	metadata := map[string]string{}
+	for key, value := range namespace.Labels {
+		metadata[fmt.Sprintf("tags/%s", key)] = value
+	}
+
+	metadata["kubernetes/namespace"] = namespace.Name
+	metadata["namespace/id"] = string(namespace.UID)
+	metadata["namespace/api-version"] = namespace.APIVersion
+	metadata["namespace/status"] = string(namespace.Status.Phase)
+
+	return api.CreateResource{
+		Version: "ctrlplane.dev/kubernetes/namespace/v1",
+		Kind: "KubernetesNamespace",
+		Name: namespace.Name,
+		Identifier: string(namespace.UID),
+		Config: map[string]any{
+			"id": string(namespace.UID),
+			"name": namespace.Name,
+			"status": namespace.Status.Phase,
+		},
+		Metadata: metadata,
+	}
+}
+
 func NewSyncKubernetesCmd() *cobra.Command {
+	var clusterIdentifier string
+	var providerName string
+	var clusterName string
+
 	cmd := &cobra.Command{
 		Use:   "kubernetes",
 		Short: "Sync Kubernetes resources on a cluster",
@@ -21,45 +53,93 @@ func NewSyncKubernetesCmd() *cobra.Command {
 		`),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			log.Info("Syncing Kubernetes resources on a cluster")
-			config, clusterName, err := getKubeConfig()
+			if clusterIdentifier == "" {
+				clusterIdentifier = viper.GetString("cluster-identifier")
+			}
+
+			config, configClusterName, err := getKubeConfig()
 			if err != nil {
 				return err
 			}
 
+			if clusterName == "" {
+				clusterName = configClusterName
+			}
+
 			log.Info("Connected to cluster", "name", clusterName)
 
 			clientset, err := kubernetes.NewForConfig(config)
 			if err != nil {
 				return err
 			}
 
-			pods, err := clientset.CoreV1().Pods("default").List(
-				context.Background(), metav1.ListOptions{})
+			namespaces, err := clientset.CoreV1().Namespaces().List(context.Background(), metav1.ListOptions{})
 			if err != nil {
 				return err
 			}
 
-			if len(pods.Items) > 0 {
-				log.Info("First two pods:")
-				for i := 0; i < min(2, len(pods.Items)); i++ {
-					pod := pods.Items[i]
-					podJson, err := json.Marshal(pod)
-					if err != nil {
-						log.Error("Failed to marshal pod to JSON", "error", err)
-						continue
-					}
-					fmt.Println(string(podJson))
-					// log.Info("Pod", "json", string(podJson))
-				}
-			} else {
-				log.Info("No pods found in default namespace")
+			resources := []api.CreateResource{}
+			for _, namespace := range namespaces.Items {
+				resource := processNamespace(context.Background(), namespace)
+				resources = append(resources, resource)
 			}
 
-			return nil
+			return upsertToCtrlplane(context.Background(), resources, clusterIdentifier, clusterName, providerName)
 		},
 	}
-
-	cmd.Flags().String("cluster", "", "The cluster to sync")
+	cmd.Flags().StringVarP(&providerName, "provider", "p", "", "Name of the resource provider")
+	cmd.Flags().StringVarP(&clusterIdentifier, "cluster-identifier", "c", "", "The identifier of the parent cluster in ctrlplane (if not provided, will use the CLUSTER_IDENTIFIER environment variable)")
+	cmd.Flags().StringVarP(&clusterName, "cluster-name", "n", "", "The name of the cluster")
 
 	return cmd
 }
+
+// upsertToCtrlplane handles upserting resources to Ctrlplane
+func upsertToCtrlplane(ctx context.Context, resources []api.CreateResource, clusterIdentifier string, clusterName string, providerName string) error {
+	apiURL := viper.GetString("url")
+	apiKey := viper.GetString("api-key")
+	workspaceId := viper.GetString("workspace")
+
+	ctrlplaneClient, err := api.NewAPIKeyClientWithResponses(apiURL, apiKey)
+	if err != nil {
+		return fmt.Errorf("failed to create API client: %w", err)
+	}
+
+	clusterResource, _ := ctrlplaneClient.GetResourceByIdentifierWithResponse(ctx, workspaceId, clusterIdentifier)
+	if clusterResource.JSON200 != nil {
+		for _, resource := range resources {
+			for key, value := range clusterResource.JSON200.Metadata {
+				if strings.HasPrefix(key, "tags/") {
+					continue
+				}
+				if _, exists := resource.Metadata[key]; !exists {
+					resource.Metadata[key] = value
+				}
+			}
+			resource.Metadata["kubernetes/name"] = clusterResource.JSON200.Name
+		}
+		if clusterName == "" {
+			clusterName = clusterResource.JSON200.Name
+		}
+		
+	}
+
+	if providerName == "" {
+		providerName = fmt.Sprintf("kubernetes-cluster-%s", clusterName)
+	}
+
+	log.Info("Using provider name", "provider", providerName)
+
+	rp, err := api.NewResourceProvider(ctrlplaneClient, workspaceId, providerName)
+	if err != nil {
+		return fmt.Errorf("failed to create resource provider: %w", err)
+	}
+
+	upsertResp, err := rp.UpsertResource(ctx, resources)
+	if err != nil {
+		return fmt.Errorf("failed to upsert resources: %w", err)
+	}
+
+	log.Info("Response from upserting resources", "status", upsertResp.Status)
+	return nil
+}

cmd/ctrlc/root/sync/kubernetes/vcluster.go

@@ -102,8 +102,8 @@ func generateVclusterMetadata(vcluster find.VCluster, clusterMetadata api.Metada
 	return metadata, nil
 }
 
-func generateVclusterConfig(vcluster find.VCluster, clusterName string, clusterConfig map[string]interface{}) map[string]interface{} {
-	vclusterConfig := make(map[string]interface{})
+func generateVclusterConfig(vcluster find.VCluster, clusterConfig map[string]any) map[string]any {
+	vclusterConfig := make(map[string]any)
 	vclusterConfig["name"] = vcluster.Name
 	vclusterConfig["namespace"] = vcluster.Namespace
 	vclusterConfig["status"] = getNormalizedVclusterStatus(vcluster.Status)
@@ -142,7 +142,7 @@ func getCreateResourceFromVcluster(vcluster find.VCluster, clusterResource Clust
 		Kind:       generateVclusterKind(clusterResource),
 		Version:    "ctrlplane.dev/kubernetes/cluster/v1",
 		Metadata:   metadata,
-		Config:     generateVclusterConfig(vcluster, clusterResource.Name, clonedParentConfig),
+		Config:     generateVclusterConfig(vcluster, clonedParentConfig),
 	}
 
 	return resource, nil
@@ -249,9 +249,8 @@ func NewSyncVclusterCmd() *cobra.Command {
 			}
 			log.Infof("Upserted %d resources", len(resourcesToUpsert))
 
-			if err := createResourceRelationshipRule(cmd.Context(), rp, clusterResource); err != nil {
-				return fmt.Errorf("failed to create resource relationship rule: %w", err)
-			}
+			createResourceRelationshipRule(cmd.Context(), rp, clusterResource)
+			
 			return nil
 		},
 	}