Merge branch 'master' into not-required-to-increment-version

cmd/completion/tenant.go

@@ -0,0 +1,18 @@
+package completion
+
+import (
+	"github.com/metal-stack/metal-go/api/client/tenant"
+	"github.com/spf13/cobra"
+)
+
+func (c *Completion) TenantListCompletion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	resp, err := c.client.Tenant().ListTenants(tenant.NewListTenantsParams(), nil)
+	if err != nil {
+		return nil, cobra.ShellCompDirectiveError
+	}
+	var names []string
+	for _, p := range resp.Payload {
+		names = append(names, p.Meta.ID+"\t/"+p.Name)
+	}
+	return names, cobra.ShellCompDirectiveNoFileComp
+}

cmd/root.go

@@ -119,6 +119,7 @@ metalctl machine list -o template --template "{{ .id }}:{{ .size.id  }}"
 	rootCmd.AddCommand(newMachineCmd(c))
 	rootCmd.AddCommand(newFirewallCmd(c))
 	rootCmd.AddCommand(newProjectCmd(c))
+	rootCmd.AddCommand(newTenantCmd(c))
 	rootCmd.AddCommand(newSizeCmd(c))
 	rootCmd.AddCommand(newFilesystemLayoutCmd(c))
 	rootCmd.AddCommand(newImageCmd(c))

cmd/sorters/tenant.go

@@ -0,0 +1,21 @@
+package sorters
+
+import (
+	"github.com/metal-stack/metal-go/api/models"
+	"github.com/metal-stack/metal-lib/pkg/multisort"
+	p "github.com/metal-stack/metal-lib/pkg/pointer"
+)
+
+func TenantSorter() *multisort.Sorter[*models.V1TenantResponse] {
+	return multisort.New(multisort.FieldMap[*models.V1TenantResponse]{
+		"id": func(a, b *models.V1TenantResponse, descending bool) multisort.CompareResult {
+			return multisort.Compare(p.SafeDeref(a.Meta).ID, p.SafeDeref(b.Meta).ID, descending)
+		},
+		"name": func(a, b *models.V1TenantResponse, descending bool) multisort.CompareResult {
+			return multisort.Compare(a.Name, b.Name, descending)
+		},
+		"description": func(a, b *models.V1TenantResponse, descending bool) multisort.CompareResult {
+			return multisort.Compare(a.Description, b.Description, descending)
+		},
+	}, multisort.Keys{{ID: "id"}})
+}

cmd/switch.go

@@ -105,13 +105,15 @@ r01leaf01,swp2,44e3a522-5f48-4f3c-9188-41025f9e401e,<b-serial>
 	switchMachinesCmd.Flags().String("os-version", "", "OS version of this switch.")
 	switchMachinesCmd.Flags().String("partition", "", "Partition of this switch.")
 	switchMachinesCmd.Flags().String("rack", "", "Rack of this switch.")
-	switchMachinesCmd.Flags().String("size", "", "Size of the connectedmachines.")
+	switchMachinesCmd.Flags().String("size", "", "Size of the connected machines.")
+	switchMachinesCmd.Flags().String("machine-id", "", "The id of the connected machine, ignores size flag if set.")
 
 	must(switchMachinesCmd.RegisterFlagCompletionFunc("id", c.comp.SwitchListCompletion))
 	must(switchMachinesCmd.RegisterFlagCompletionFunc("name", c.comp.SwitchNameListCompletion))
 	must(switchMachinesCmd.RegisterFlagCompletionFunc("partition", c.comp.PartitionListCompletion))
 	must(switchMachinesCmd.RegisterFlagCompletionFunc("rack", c.comp.SwitchRackListCompletion))
 	must(switchMachinesCmd.RegisterFlagCompletionFunc("size", c.comp.SizeListCompletion))
+	must(switchMachinesCmd.RegisterFlagCompletionFunc("machine-id", c.comp.MachineListCompletion))
 
 	switchReplaceCmd := &cobra.Command{
 		Use:   "replace <switchID>",
@@ -256,29 +258,43 @@ func (c *switchCmd) switchMachines() error {
 		return err
 	}
 
-	resp, err := c.client.Machine().FindIPMIMachines(machine.NewFindIPMIMachinesParams().WithBody(&models.V1MachineFindRequest{
-		PartitionID: viper.GetString("partition"),
-		Rackid:      viper.GetString("rack"),
-		Sizeid:      viper.GetString("size"),
-	}), nil)
-	if err != nil {
-		return err
+	var machines []*models.V1MachineIPMIResponse
+
+	if viper.IsSet("machine-id") {
+		resp, err := c.client.Machine().FindIPMIMachine(machine.NewFindIPMIMachineParams().WithID(viper.GetString("machine-id")), nil)
+		if err != nil {
+			return err
+		}
+
+		machines = append(machines, resp.Payload)
+	} else {
+		resp, err := c.client.Machine().FindIPMIMachines(machine.NewFindIPMIMachinesParams().WithBody(&models.V1MachineFindRequest{
+			ID:          viper.GetString("machine-id"),
+			PartitionID: viper.GetString("partition"),
+			Rackid:      viper.GetString("rack"),
+			Sizeid:      viper.GetString("size"),
+		}), nil)
+		if err != nil {
+			return err
+		}
+
+		machines = append(machines, resp.Payload...)
 	}
 
-	machines := map[string]*models.V1MachineIPMIResponse{}
-	for _, m := range resp.Payload {
+	ms := map[string]*models.V1MachineIPMIResponse{}
+	for _, m := range machines {
 		m := m
 
 		if m.ID == nil {
 			continue
 		}
 
-		machines[*m.ID] = m
+		ms[*m.ID] = m
 	}
 
 	return c.listPrinter.Print(&tableprinters.SwitchesWithMachines{
 		SS: switches,
-		MS: machines,
+		MS: ms,
 	})
 }
 

cmd/tableprinters/printer.go

@@ -73,6 +73,10 @@ func (t *TablePrinter) ToHeaderAndRows(data any, wide bool) ([]string, [][]strin
 		return t.ProjectTable(pointer.WrapInSlice(d), wide)
 	case []*models.V1ProjectResponse:
 		return t.ProjectTable(d, wide)
+	case *models.V1TenantResponse:
+		return t.TenantTable(pointer.WrapInSlice(d), wide)
+	case []*models.V1TenantResponse:
+		return t.TenantTable(d, wide)
 	case []*models.V1MachineIPMIResponse:
 		return t.MachineIPMITable(d, wide)
 	case *models.V1MachineIPMIResponse:

cmd/tableprinters/switch.go

@@ -127,8 +127,9 @@ func (t *TablePrinter) SwitchWithConnectedMachinesTable(data *SwitchesWithMachin
 		rows = append(rows, []string{id, "", "", partition, rack})
 
 		conns := s.Connections
-		if viper.IsSet("size") {
-			conns = []*models.V1SwitchConnection{}
+		if viper.IsSet("size") || viper.IsSet("machine-id") {
+			filteredConns := []*models.V1SwitchConnection{}
+
 			for _, conn := range s.Connections {
 				conn := conn
 
@@ -137,10 +138,16 @@ func (t *TablePrinter) SwitchWithConnectedMachinesTable(data *SwitchesWithMachin
 					continue
 				}
 
-				if pointer.SafeDeref(m.Size.ID) == viper.GetString("size") {
-					conns = append(conns, conn)
+				if viper.IsSet("machine-id") && pointer.SafeDeref(m.ID) == viper.GetString("machine-id") {
+					filteredConns = append(filteredConns, conn)
+				}
+
+				if viper.IsSet("size") && pointer.SafeDeref(m.Size.ID) == viper.GetString("size") {
+					filteredConns = append(filteredConns, conn)
 				}
 			}
+
+			conns = filteredConns
 		}
 
 		sort.Slice(conns, switchInterfaceNameLessFunc(conns))

cmd/tableprinters/tenant.go

@@ -0,0 +1,66 @@
+package tableprinters
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/metal-stack/metal-go/api/models"
+	"github.com/metal-stack/metal-lib/pkg/genericcli"
+)
+
+func (t *TablePrinter) TenantTable(data []*models.V1TenantResponse, wide bool) ([]string, [][]string, error) {
+	var (
+		rows [][]string
+	)
+
+	header := []string{"ID", "Name", "Description", "Labels", "Annotations"}
+	if wide {
+		header = []string{"ID", "Name", "Description", "Labels", "Annotations", "Quotas"}
+	}
+
+	for _, pr := range data {
+		var (
+			clusterQuota = "∞"
+			machineQuota = "∞"
+			ipQuota      = "∞"
+		)
+
+		if pr.Quotas != nil {
+			qs := pr.Quotas
+			if qs.Cluster != nil {
+				if qs.Cluster.Quota != 0 {
+					clusterQuota = strconv.FormatInt(int64(qs.Cluster.Quota), 10)
+				}
+			}
+			if qs.Machine != nil {
+				if qs.Machine.Quota != 0 {
+					machineQuota = strconv.FormatInt(int64(qs.Machine.Quota), 10)
+				}
+			}
+			if qs.IP != nil {
+				if qs.IP.Quota != 0 {
+					ipQuota = strconv.FormatInt(int64(qs.IP.Quota), 10)
+				}
+			}
+		}
+
+		quotas := []string{
+			clusterQuota + " Cluster(s)",
+			machineQuota + " Machine(s)",
+			ipQuota + " IP(s)",
+		}
+
+		labels := strings.Join(pr.Meta.Labels, "\n")
+
+		as := genericcli.MapToLabels(pr.Meta.Annotations)
+		annotations := strings.Join(as, "\n")
+
+		if wide {
+			rows = append(rows, []string{pr.Meta.ID, pr.Name, pr.Description, labels, annotations, strings.Join(quotas, "\n")})
+		} else {
+			rows = append(rows, []string{pr.Meta.ID, pr.Name, pr.Description, labels, annotations})
+		}
+	}
+
+	return header, rows, nil
+}