Add JSON output option to all hcloud list commands (#225)

.goreleaser.yml

@@ -52,8 +52,10 @@ signs:
       - gon.hcl
     artifacts: all
     signature: "hcloud-macos-amd64.zip"
+    id: hcloud-macos-sign
   - artifacts: all
     signature: "${artifact}.sig"
+    id: hcloud-sign
     ids:
       - hcloud-build
     args: ["--batch", "-u", "[email protected]", "--pinentry-mode", "loopback", "--output", "${signature}", "--detach-sign", "${artifact}"]

cli/datacenter_list.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"github.com/hetznercloud/hcloud-go/hcloud"
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
 	"github.com/spf13/cobra"
 )
 
@@ -29,14 +30,23 @@ func newDatacenterListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runDatacenterList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(datacenterListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(datacenterListTableOutput.Columns()), outputOptionJSON())
 	return cmd
 }
 
 func runDatacenterList(cli *CLI, cmd *cobra.Command, args []string) error {
 	outOpts := outputFlagsForCommand(cmd)
 
 	datacenters, err := cli.Client().Datacenter.All(cli.Context)
+
+	if outOpts.IsSet("json") {
+		var datacenterSchemas []schema.Datacenter
+		for _, datacenter := range datacenters {
+			datacenterSchemas = append(datacenterSchemas, datacenterToSchema(*datacenter))
+		}
+		return describeJSON(datacenterSchemas)
+	}
+
 	if err != nil {
 		return err
 	}

cli/floatingip_list.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
+
 	"github.com/hetznercloud/hcloud-go/hcloud"
 	"github.com/spf13/cobra"
 )
@@ -27,7 +29,7 @@ func newFloatingIPListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runFloatingIPList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(floatingIPListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(floatingIPListTableOutput.Columns()), outputOptionJSON())
 	cmd.Flags().StringP("selector", "l", "", "Selector to filter by labels")
 	return cmd
 }
@@ -47,6 +49,35 @@ func runFloatingIPList(cli *CLI, cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	if outOpts.IsSet("json") {
+		var floatingIPSchemas []schema.FloatingIP
+		for _, floatingIP := range floatingIPs {
+			floatingIPSchema := schema.FloatingIP{
+				ID:           floatingIP.ID,
+				Name:         floatingIP.Name,
+				Description:  hcloud.String(floatingIP.Description),
+				IP:           floatingIP.IP.String(),
+				Created:      floatingIP.Created,
+				Type:         string(floatingIP.Type),
+				HomeLocation: locationToSchema(*floatingIP.HomeLocation),
+				Blocked:      floatingIP.Blocked,
+				Protection:   schema.FloatingIPProtection{Delete: floatingIP.Protection.Delete},
+				Labels:       floatingIP.Labels,
+			}
+			for ip, dnsPtr := range floatingIP.DNSPtr {
+				floatingIPSchema.DNSPtr = append(floatingIPSchema.DNSPtr, schema.FloatingIPDNSPtr{
+					IP:     ip,
+					DNSPtr: dnsPtr,
+				})
+			}
+			if floatingIP.Server != nil {
+				floatingIPSchema.Server = hcloud.Int(floatingIP.Server.ID)
+			}
+			floatingIPSchemas = append(floatingIPSchemas, floatingIPSchema)
+		}
+		return describeJSON(floatingIPSchemas)
+	}
+
 	cols := []string{"id", "type", "name", "description", "ip", "home", "server", "dns"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]

cli/image_list.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
+
 	humanize "github.com/dustin/go-humanize"
 	"github.com/hetznercloud/hcloud-go/hcloud"
 	"github.com/spf13/cobra"
@@ -29,7 +31,7 @@ func newImageListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runImageList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(imageListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(imageListTableOutput.Columns()), outputOptionJSON())
 	cmd.Flags().StringVarP(&typeFilter, "type", "t", "", "Only show images of given type")
 	cmd.Flags().StringP("selector", "l", "", "Selector to filter by labels")
 	return cmd
@@ -58,6 +60,15 @@ func runImageList(cli *CLI, cmd *cobra.Command, args []string) error {
 		}
 		images = _images
 	}
+
+	if outOpts.IsSet("json") {
+		var imageSchemas []schema.Image
+		for _, image := range images {
+			imageSchemas = append(imageSchemas, imageToSchema(*image))
+		}
+		return describeJSON(imageSchemas)
+	}
+
 	cols := []string{"id", "type", "name", "description", "image_size", "disk_size", "created"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]

cli/iso_list.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"github.com/hetznercloud/hcloud-go/hcloud"
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
 	"github.com/spf13/cobra"
 )
 
@@ -25,7 +26,7 @@ func newISOListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runISOList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(isoListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(isoListTableOutput.Columns()), outputOptionJSON())
 	return cmd
 }
 
@@ -37,6 +38,14 @@ func runISOList(cli *CLI, cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	if outOpts.IsSet("json") {
+		var isoSchemas []schema.ISO
+		for _, iso := range isos {
+			isoSchemas = append(isoSchemas, isoToSchema(*iso))
+		}
+		return describeJSON(isoSchemas)
+	}
+
 	cols := []string{"id", "name", "description", "type"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]

cli/location_list.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"github.com/hetznercloud/hcloud-go/hcloud"
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
 	"github.com/spf13/cobra"
 )
 
@@ -25,7 +26,7 @@ func newLocationListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runLocationList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(locationListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(locationListTableOutput.Columns()), outputOptionJSON())
 	return cmd
 }
 
@@ -37,6 +38,14 @@ func runLocationList(cli *CLI, cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	if outOpts.IsSet("json") {
+		var locationSchemas []schema.Location
+		for _, location := range locations {
+			locationSchemas = append(locationSchemas, locationToSchema(*location))
+		}
+		return describeJSON(locationSchemas)
+	}
+
 	cols := []string{"id", "name", "description", "network_zone", "country", "city"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]

cli/network_list.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/hetznercloud/hcloud-go/hcloud"
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
 	"github.com/spf13/cobra"
 )
 
@@ -27,7 +28,7 @@ func newNetworkListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runNetworkList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(networkListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(networkListTableOutput.Columns()), outputOptionJSON())
 	cmd.Flags().StringP("selector", "l", "", "Selector to filter by labels")
 	return cmd
 }
@@ -47,6 +48,39 @@ func runNetworkList(cli *CLI, cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	if outOpts.IsSet("json") {
+		var networkSchemas []schema.Network
+		for _, network := range networks {
+			networkSchema := schema.Network{
+				ID:         network.ID,
+				Name:       network.Name,
+				IPRange:    network.IPRange.String(),
+				Protection: schema.NetworkProtection{Delete: network.Protection.Delete},
+				Created:    network.Created,
+				Labels:     network.Labels,
+			}
+			for _, subnet := range network.Subnets {
+				networkSchema.Subnets = append(networkSchema.Subnets, schema.NetworkSubnet{
+					Type:        string(subnet.Type),
+					IPRange:     subnet.IPRange.String(),
+					NetworkZone: string(subnet.NetworkZone),
+					Gateway:     subnet.Gateway.String(),
+				})
+			}
+			for _, route := range network.Routes {
+				networkSchema.Routes = append(networkSchema.Routes, schema.NetworkRoute{
+					Destination: route.Destination.String(),
+					Gateway:     route.Gateway.String(),
+				})
+			}
+			for _, server := range network.Servers {
+				networkSchema.Servers = append(networkSchema.Servers, server.ID)
+			}
+			networkSchemas = append(networkSchemas, networkSchema)
+		}
+		return describeJSON(networkSchemas)
+	}
+
 	cols := []string{"id", "name", "ip_range", "servers"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]

cli/server_list.go

@@ -4,6 +4,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
+
 	"github.com/hetznercloud/hcloud-go/hcloud"
 	"github.com/spf13/cobra"
 )
@@ -27,7 +29,7 @@ func newServerListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runServerList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(serverListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(serverListTableOutput.Columns()), outputOptionJSON())
 	cmd.Flags().StringP("selector", "l", "", "Selector to filter by labels")
 	return cmd
 }
@@ -47,6 +49,62 @@ func runServerList(cli *CLI, cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	if outOpts.IsSet("json") {
+		var serversSchema []schema.Server
+		for _, server := range servers {
+			serverSchema := schema.Server{
+				ID:         server.ID,
+				Name:       server.Name,
+				Status:     string(server.Status),
+				Created:    server.Created,
+				Datacenter: datacenterToSchema(*server.Datacenter),
+				ServerType: serverTypeToSchema(*server.ServerType),
+				PublicNet: schema.ServerPublicNet{
+					IPv4: schema.ServerPublicNetIPv4{
+						IP:      server.PublicNet.IPv4.IP.String(),
+						Blocked: server.PublicNet.IPv4.Blocked,
+						DNSPtr:  server.PublicNet.IPv4.DNSPtr,
+					},
+					IPv6: schema.ServerPublicNetIPv6{
+						IP:      server.PublicNet.IPv6.IP.String(),
+						Blocked: server.PublicNet.IPv6.Blocked,
+					},
+				},
+				RescueEnabled:   server.RescueEnabled,
+				BackupWindow:    hcloud.String(server.BackupWindow),
+				OutgoingTraffic: &server.OutgoingTraffic,
+				IngoingTraffic:  &server.IngoingTraffic,
+				IncludedTraffic: server.IncludedTraffic,
+				Protection: schema.ServerProtection{
+					Delete:  server.Protection.Delete,
+					Rebuild: server.Protection.Rebuild,
+				},
+			}
+			if server.Image != nil {
+				serverImage := imageToSchema(*server.Image)
+				serverSchema.Image = &serverImage
+			}
+			if server.ISO != nil {
+				serverISO := isoToSchema(*server.ISO)
+				serverSchema.ISO = &serverISO
+			}
+			for ip, dnsPTR := range server.PublicNet.IPv6.DNSPtr {
+				serverSchema.PublicNet.IPv6.DNSPtr = append(serverSchema.PublicNet.IPv6.DNSPtr, schema.ServerPublicNetIPv6DNSPtr{
+					IP:     ip,
+					DNSPtr: dnsPTR,
+				})
+			}
+			for _, floatingIP := range server.PublicNet.FloatingIPs {
+				serverSchema.PublicNet.FloatingIPs = append(serverSchema.PublicNet.FloatingIPs, floatingIP.ID)
+			}
+			for _, volume := range server.Volumes {
+				serverSchema.Volumes = append(serverSchema.Volumes, volume.ID)
+			}
+			serversSchema = append(serversSchema, serverSchema)
+		}
+		return describeJSON(serversSchema)
+	}
+
 	cols := []string{"id", "name", "status", "ipv4", "ipv6", "datacenter"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]

cli/servertypes_list.go

@@ -3,6 +3,8 @@ package cli
 import (
 	"fmt"
 
+	"github.com/hetznercloud/hcloud-go/hcloud/schema"
+
 	"github.com/hetznercloud/hcloud-go/hcloud"
 	"github.com/spf13/cobra"
 )
@@ -36,7 +38,7 @@ func newServerTypeListCommand(cli *CLI) *cobra.Command {
 		PreRunE:               cli.ensureToken,
 		RunE:                  cli.wrap(runServerTypeList),
 	}
-	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(serverTypeListTableOutput.Columns()))
+	addOutputFlag(cmd, outputOptionNoHeader(), outputOptionColumns(serverTypeListTableOutput.Columns()), outputOptionJSON())
 	return cmd
 }
 
@@ -48,6 +50,14 @@ func runServerTypeList(cli *CLI, cmd *cobra.Command, args []string) error {
 		return err
 	}
 
+	if outOpts.IsSet("json") {
+		var serverTypeSchemas []schema.ServerType
+		for _, serverType := range serverTypes {
+			serverTypeSchemas = append(serverTypeSchemas, serverTypeToSchema(*serverType))
+		}
+		return describeJSON(serverTypeSchemas)
+	}
+
 	cols := []string{"id", "name", "cores", "memory", "disk", "storage_type"}
 	if outOpts.IsSet("columns") {
 		cols = outOpts["columns"]