pkg: fix listing resources in cluster mode

Author: weizhouapache

cmd/cli/get.go

@@ -1,11 +1,14 @@
 package cli
 
 import (
+	v1 "cloudstackctl/apis/v1"
 	"cloudstackctl/pkg/handlers"
 	"encoding/json"
 	"log"
 	"net/url"
 
+	cs "github.com/apache/cloudstack-go/v2/cloudstack"
+
 	"github.com/spf13/cobra"
 )
 
@@ -36,8 +39,10 @@ var getCmd = &cobra.Command{
 				payload["name"] = name
 			}
 			raw, _ := json.Marshal(payload)
-			if err := handlers.GetCloudStackResource(raw); err != nil {
+			if resp, err := handlers.GetCloudStackResource(raw); err != nil {
 				log.Fatalf("Local get failed: %v", err)
+			} else {
+				handlers.PrintCloudStackResource(resourceType, resp)
 			}
 			return
 		}
@@ -54,10 +59,82 @@ var getCmd = &cobra.Command{
 		if err != nil {
 			log.Fatalf("Failed to query controller: %v", err)
 		}
-		println(string(body))
+
+		// If controller returned VM objects from DB, pretty-print them
+		if resourceType == "VirtualMachine" {
+			var vms []v1.VirtualMachine
+			if err := json.Unmarshal(body, &vms); err == nil {
+				handlers.PrintVMsFromDB(vms)
+				return
+			}
+		}
+
+		tryDecodeAndPrint(resourceType, body)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(getCmd)
 }
+
+// tryDecodeAndPrint attempts to decode controller JSON into known typed
+// responses and prints them using the shared handlers. Returns true if
+// printing was performed.
+func tryDecodeAndPrint(resourceType string, body []byte) bool {
+	// VMs are returned from the controller DB as []v1.VirtualMachine
+	if resourceType == "VirtualMachine" {
+		var vms []v1.VirtualMachine
+		if err := json.Unmarshal(body, &vms); err == nil {
+			handlers.PrintVMsFromDB(vms)
+			return true
+		}
+	}
+
+	// Try CloudStack SDK response types for unmanaged resources so we can
+	// preserve typed slices (e.g., []*cs.Network) when printing.
+	switch resourceType {
+	case "Network":
+		var resp cs.ListNetworksResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	case "Volume":
+		var resp cs.ListVolumesResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	case "Template":
+		var resp cs.ListTemplatesResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	case "SSHKey":
+		var resp cs.ListSSHKeyPairsResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	case "SecurityGroup":
+		var resp cs.ListSecurityGroupsResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	case "AffinityGroup":
+		var resp cs.ListAffinityGroupsResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	case "UserData":
+		var resp cs.ListUserDataResponse
+		if err := json.Unmarshal(body, &resp); err == nil {
+			handlers.PrintCloudStackResource(resourceType, &resp)
+			return true
+		}
+	}
+	return false
+}

controller/controller.go

@@ -239,6 +239,7 @@ func (c *Controller) Start() {
 				return
 			}
 			kind := r.URL.Query().Get("kind")
+			name := r.URL.Query().Get("name")
 			switch kind {
 			case "Application":
 				var apps []v1.Application
@@ -285,36 +286,21 @@ func (c *Controller) Start() {
 				w.WriteHeader(http.StatusOK)
 				w.Write(b)
 				return
-			// Unmanaged kinds: delegate to handlers/CloudStack client for listing and return raw JSON
-			case "Network":
-				resp, err := c.csClient.Network.ListNetworks(c.csClient.Network.NewListNetworksParams())
-				if err != nil {
-					http.Error(w, "cloudstack list networks failed", http.StatusInternalServerError)
-					return
+			// Unmanaged kinds: delegate to handlers.GetCloudStackResource which
+			// centralizes CloudStack listing logic. Controller should not call
+			// CloudStack APIs directly.
+			case "Network", "Volume", "SSHKey", "SecurityGroup", "AffinityGroup", "UserData", "Template":
+				payload := map[string]string{"kind": kind}
+				if name != "" {
+					payload["name"] = name
 				}
-				b, _ := json.Marshal(resp.Networks)
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(b)
-				return
-			case "Volume":
-				resp, err := c.csClient.Volume.ListVolumes(c.csClient.Volume.NewListVolumesParams())
-				if err != nil {
-					http.Error(w, "cloudstack list volumes failed", http.StatusInternalServerError)
-					return
-				}
-				b, _ := json.Marshal(resp.Volumes)
-				w.Header().Set("Content-Type", "application/json")
-				w.WriteHeader(http.StatusOK)
-				w.Write(b)
-				return
-			case "Template":
-				resp, err := c.csClient.Template.ListTemplates(c.csClient.Template.NewListTemplatesParams(""))
+				raw, _ := json.Marshal(payload)
+				obj, err := handlers.GetCloudStackResource(raw)
 				if err != nil {
-					http.Error(w, "cloudstack list templates failed", http.StatusInternalServerError)
+					http.Error(w, fmt.Sprintf("failed to list %s: %v", kind, err), http.StatusInternalServerError)
 					return
 				}
-				b, _ := json.Marshal(resp.Templates)
+				b, _ := json.Marshal(obj)
 				w.Header().Set("Content-Type", "application/json")
 				w.WriteHeader(http.StatusOK)
 				w.Write(b)
@@ -354,6 +340,7 @@ func (c *Controller) Start() {
 			case "Template":
 				params := c.csClient.Template.NewListTemplatesParams("")
 				params.SetName(name)
+				params.SetTemplatefilter("all")
 				resp, err := c.csClient.Template.ListTemplates(params)
 				if err != nil || resp == nil || len(resp.Templates) == 0 {
 					http.Error(w, "template not found", http.StatusNotFound)

pkg/handlers/affinitygroup.go

@@ -4,8 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
-	"os"
-	"text/tabwriter"
 
 	v1 "cloudstackctl/apis/v1"
 	"cloudstackctl/pkg/cloudstack"
@@ -42,27 +40,20 @@ func ApplyAffinityGroup(ag *v1.AffinityGroup) error {
 }
 
 // ListAffinityGroups lists affinity groups in CloudStack.
-func ListAffinityGroups(name string) error {
+func ListAffinityGroups(name string) (any, error) {
 	client, err := cloudstack.NewClient()
 	if err != nil {
-		return fmt.Errorf("failed to create CloudStack client: %w", err)
+		return nil, fmt.Errorf("failed to create CloudStack client: %w", err)
 	}
 	params := client.AffinityGroup.NewListAffinityGroupsParams()
 	if name != "" {
 		params.SetName(name)
 	}
 	resp, err := client.AffinityGroup.ListAffinityGroups(params)
 	if err != nil {
-		return fmt.Errorf("cloudstack API error: %w", err)
+		return nil, fmt.Errorf("cloudstack API error: %w", err)
 	}
-	// Print header then rows using tabwriter
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "NAME\tID")
-	for _, a := range resp.AffinityGroups {
-		fmt.Fprintf(w, "%s\t%s\n", a.Name, a.Id)
-	}
-	w.Flush()
-	return nil
+	return resp, err
 }
 
 // DescribeAffinityGroup prints details for an affinity group by name.

pkg/handlers/network.go

@@ -4,10 +4,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
-	"os"
 	"strconv"
 	"strings"
-	"text/tabwriter"
 
 	v1 "cloudstackctl/apis/v1"
 	"cloudstackctl/pkg/cloudstack"
@@ -37,57 +35,25 @@ func ResolveNetwork(name string) (string, error) {
 }
 
 // ListNetworks queries CloudStack and prints a table of networks.
-func ListNetworks(name string) error {
+func ListNetworks(name string) (any, error) {
 	client, err := cloudstack.NewClient()
 	if err != nil {
-		return fmt.Errorf("failed to create CloudStack client: %w", err)
+		return nil, fmt.Errorf("failed to create CloudStack client: %w", err)
 	}
 	params := client.Network.NewListNetworksParams()
 	if name != "" {
 		params.SetName(name)
 	}
 	resp, err := client.Network.ListNetworks(params)
 	if err != nil {
-		return fmt.Errorf("cloudstack API error: %w", err)
-	}
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "NAME\tID\tZONE\tVLAN\tDISPLAY TEXT\tTYPE\tSTATE")
-	for _, n := range resp.Networks {
-		display := n.Displaytext
-		if display == "" {
-			display = n.Name
-		}
-
-		zoneName := n.Zoneid
-		if n.Zoneid != "" {
-			zp := client.Zone.NewListZonesParams()
-			zp.SetId(n.Zoneid)
-			zr, zerr := client.Zone.ListZones(zp)
-			if zerr == nil && zr != nil && len(zr.Zones) > 0 {
-				zoneName = zr.Zones[0].Name
-			}
-		}
-
-		// Attempt to extract VLAN information from the returned network object
-		// via JSON to avoid SDK field name differences across versions.
-		vlan := ""
-		if b, merr := json.Marshal(n); merr == nil {
-			var m map[string]interface{}
-			if uerr := json.Unmarshal(b, &m); uerr == nil {
-				if v, ok := m["vlan"].(string); ok {
-					vlan = v
-				} else if v, ok := m["vlanid"].(string); ok {
-					vlan = v
-				}
-			}
-		}
-
-		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", n.Name, n.Id, zoneName, vlan, display, n.Type, n.State)
+		return nil, fmt.Errorf("cloudstack API error: %w", err)
 	}
-	w.Flush()
-	return nil
+	return resp, err
 }
 
+// PrintNetworks prints a table of networks from the SDK slice.
+// PrintNetworks moved to print.go
+
 // DescribeNetwork prints JSON for a single network identified by name.
 func DescribeNetwork(name string) error {
 	client, err := cloudstack.NewClient()