feat(iaas): add client-side vcpu and ram filter for machine-types

h3adex · h3adex · commit 7e1a210a8f11 · 2026-03-03T13:40:17.000+01:00
diff --git a/docs/stackit_server_machine-type_list.md b/docs/stackit_server_machine-type_list.md
@@ -4,7 +4,7 @@ Get list of all machine types available in a project
 
 ### Synopsis
 
-Get list of all machine types available in a project.
+Get list of all machine types available in a project. Supports filtering by minimum vCPU and RAM (GB).
 
 ```
 stackit server machine-type list [flags]
@@ -21,13 +21,18 @@ stackit server machine-type list [flags]
 
   List the first 10 machine types
   $ stackit server machine-type list --limit=10
+
+  Filter for machines with at least 8 vCPUs and 16GB RAM
+  $ stackit server machine-type list --min-vcpu 8 --min-ram 16
 ```
 
 ### Options
 
 ```
-  -h, --help        Help for "stackit server machine-type list"
-      --limit int   Limit the output to the first n elements
+  -h, --help           Help for "stackit server machine-type list"
+      --limit int      Limit the output to the first n elements
+      --min-ram int    Filter by minimum RAM amount in GB
+      --min-vcpu int   Filter by minimum number of vCPUs
 ```
 
 ### Options inherited from parent commands
diff --git a/internal/cmd/server/machine-type/list/list.go b/internal/cmd/server/machine-type/list/list.go
@@ -23,18 +23,22 @@ import (
 
 type inputModel struct {
 	*globalflags.GlobalFlagModel
-	Limit *int64
+	Limit    *int64
+	MinVCPUs *int64
+	MinRAM   *int64
 }
 
 const (
-	limitFlag = "limit"
+	limitFlag   = "limit"
+	minVcpuFlag = "min-vcpu"
+	minRamFlag  = "min-ram"
 )
 
 func NewCmd(params *types.CmdParams) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "list",
 		Short: "Get list of all machine types available in a project",
-		Long:  "Get list of all machine types available in a project.",
+		Long:  "Get list of all machine types available in a project. Supports filtering by minimum vCPU and RAM (GB).",
 		Args:  args.NoArgs,
 		Example: examples.Build(
 			examples.NewExample(
@@ -49,6 +53,10 @@ func NewCmd(params *types.CmdParams) *cobra.Command {
 				`List the first 10 machine types`,
 				`$ stackit server machine-type list --limit=10`,
 			),
+			examples.NewExample(
+				`Filter for machines with at least 8 vCPUs and 16GB RAM`,
+				"$ stackit server machine-type list --min-vcpu 8 --min-ram 16",
+			),
 		),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := context.Background()
@@ -73,18 +81,26 @@ func NewCmd(params *types.CmdParams) *cobra.Command {
 			if resp.Items == nil || len(*resp.Items) == 0 {
 				projectLabel, err := projectname.GetProjectName(ctx, params.Printer, params.CliVersion, cmd)
 				if err != nil {
-					params.Printer.Debug(print.ErrorLevel, "get project name: %v", err)
 					projectLabel = model.ProjectId
 				}
 				params.Printer.Info("No machine-types found for project %q\n", projectLabel)
 				return nil
 			}
 
-			// limit output
-			if model.Limit != nil && len(*resp.Items) > int(*model.Limit) {
-				*resp.Items = (*resp.Items)[:*model.Limit]
+			// Filter the items client-side
+			filteredItems := filterMachineTypes(resp.Items, model)
+
+			if len(filteredItems) == 0 {
+				params.Printer.Info("No machine-types found matching the criteria\n")
+				return nil
 			}
 
+			// Apply limit to results
+			if model.Limit != nil && len(filteredItems) > int(*model.Limit) {
+				filteredItems = filteredItems[:*model.Limit]
+			}
+
+			resp.Items = &filteredItems
 			return outputResult(params.Printer, model.OutputFormat, *resp)
 		},
 	}
@@ -95,6 +111,8 @@ func NewCmd(params *types.CmdParams) *cobra.Command {
 
 func configureFlags(cmd *cobra.Command) {
 	cmd.Flags().Int64(limitFlag, 0, "Limit the output to the first n elements")
+	cmd.Flags().Int64(minVcpuFlag, 0, "Filter by minimum number of vCPUs")
+	cmd.Flags().Int64(minRamFlag, 0, "Filter by minimum RAM amount in GB")
 }
 
 func parseInput(p *print.Printer, cmd *cobra.Command, _ []string) (*inputModel, error) {
@@ -105,21 +123,48 @@ func parseInput(p *print.Printer, cmd *cobra.Command, _ []string) (*inputModel,
 
 	limit := flags.FlagToInt64Pointer(p, cmd, limitFlag)
 	if limit != nil && *limit < 1 {
-		return nil, &errors.FlagValidationError{
-			Flag:    limitFlag,
-			Details: "must be greater than 0",
-		}
+		return nil, &errors.FlagValidationError{Flag: limitFlag, Details: "must be greater than 0"}
 	}
 
 	model := inputModel{
 		GlobalFlagModel: globalFlags,
-		Limit:           flags.FlagToInt64Pointer(p, cmd, limitFlag),
+		Limit:           limit,
+		MinVCPUs:        flags.FlagToInt64Pointer(p, cmd, minVcpuFlag),
+		MinRAM:          flags.FlagToInt64Pointer(p, cmd, minRamFlag),
 	}
 
 	p.DebugInputModel(model)
 	return &model, nil
 }
 
+// filterMachineTypes applies logic to filter by resource minimums.
+// Discuss: hide deprecated machine-types?
+func filterMachineTypes(items *[]iaas.MachineType, model *inputModel) []iaas.MachineType {
+	if items == nil {
+		return []iaas.MachineType{}
+	}
+
+	var filtered []iaas.MachineType
+	for _, item := range *items {
+		// Minimum vCPU check
+		if model.MinVCPUs != nil && *model.MinVCPUs > 0 {
+			if item.Vcpus == nil || *item.Vcpus < *model.MinVCPUs {
+				continue
+			}
+		}
+
+		// Minimum RAM check (converting API MB to GB)
+		if model.MinRAM != nil && *model.MinRAM > 0 {
+			if item.Ram == nil || (*item.Ram/1024) < *model.MinRAM {
+				continue
+			}
+		}
+
+		filtered = append(filtered, item)
+	}
+	return filtered
+}
+
 func buildRequest(ctx context.Context, model *inputModel, apiClient *iaas.APIClient) iaas.ApiListMachineTypesRequest {
 	return apiClient.ListMachineTypes(ctx, model.ProjectId, model.Region)
 }
@@ -128,19 +173,32 @@ func outputResult(p *print.Printer, outputFormat string, machineTypes iaas.Machi
 	return p.OutputResult(outputFormat, machineTypes, func() error {
 		table := tables.NewTable()
 		table.SetTitle("Machine-Types")
+		table.SetHeader("NAME", "VCPUS", "RAM (GB)", "DESCRIPTION", "EXTRA SPECS")
 
-		table.SetHeader("NAME", "DESCRIPTION")
 		if items := machineTypes.GetItems(); len(items) > 0 {
-			for _, machineType := range items {
-				table.AddRow(*machineType.Name, utils.PtrString(machineType.Description))
-			}
-		}
+			for _, mt := range items {
+				extraSpecMap := make(map[string]string)
+				if mt.ExtraSpecs != nil && len(*mt.ExtraSpecs) > 0 {
+					for key, value := range *mt.ExtraSpecs {
+						extraSpecMap[key] = fmt.Sprintf("%v", value)
+					}
+				}
 
-		err := table.Display(p)
-		if err != nil {
-			return fmt.Errorf("render table: %w", err)
-		}
+				ramGB := int64(0)
+				if mt.Ram != nil {
+					ramGB = *mt.Ram / 1024
+				}
 
-		return nil
+				table.AddRow(
+					utils.PtrString(mt.Name),
+					utils.PtrValue(mt.Vcpus),
+					ramGB,
+					utils.PtrString(mt.Description),
+					utils.JoinStringMap(extraSpecMap, ": ", "\n"),
+				)
+				table.AddSeparator()
+			}
+		}
+		return table.Display(p)
 	})
 }
diff --git a/internal/cmd/server/machine-type/list/list_test.go b/internal/cmd/server/machine-type/list/list_test.go
@@ -31,8 +31,7 @@ func fixtureFlagValues(mods ...func(flagValues map[string]string)) map[string]st
 	flagValues := map[string]string{
 		globalflags.ProjectIdFlag: testProjectId,
 		globalflags.RegionFlag:    testRegion,
-
-		limitFlag: "10",
+		limitFlag:                 "10",
 	}
 	for _, mod := range mods {
 		mod(flagValues)
@@ -47,7 +46,9 @@ func fixtureInputModel(mods ...func(model *inputModel)) *inputModel {
 			ProjectId: testProjectId,
 			Region:    testRegion,
 		},
-		Limit: utils.Ptr(int64(10)),
+		Limit:    utils.Ptr(int64(10)),
+		MinVCPUs: nil,
+		MinRAM:   nil,
 	}
 	for _, mod := range mods {
 		mod(model)
@@ -83,50 +84,90 @@ func TestParseInput(t *testing.T) {
 			isValid:     false,
 		},
 		{
-			description: "no flag values",
-			flagValues:  map[string]string{},
-			isValid:     false,
-		},
-		{
-			description: "project id missing",
+			description: "filter by resources valid",
 			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				delete(flagValues, globalflags.ProjectIdFlag)
+				flagValues[minVcpuFlag] = "16"
+				flagValues[minRamFlag] = "32"
+			}),
+			isValid: true,
+			expectedModel: fixtureInputModel(func(model *inputModel) {
+				model.MinVCPUs = utils.Ptr(int64(16))
+				model.MinRAM = utils.Ptr(int64(32))
 			}),
-			isValid: false,
 		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			testutils.TestParseInput(t, NewCmd, parseInput, tt.expectedModel, tt.argValues, tt.flagValues, tt.isValid)
+		})
+	}
+}
+
+func TestFilterMachineTypes(t *testing.T) {
+	items := []iaas.MachineType{
 		{
-			description: "project id invalid 1",
-			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[globalflags.ProjectIdFlag] = ""
-			}),
-			isValid: false,
+			Name:        utils.Ptr("c3i.16"),
+			Vcpus:       utils.Ptr(int64(16)),
+			Ram:         utils.Ptr(int64(32768)),
+			Description: utils.Ptr("Intel Emerald Rapids 8580 CPU instance"),
+			ExtraSpecs: &map[string]interface{}{
+				"hw:cpu_sockets":   "1",
+				"hw:mem_page_size": "large",
+				"aggregate":        "intel-gen3-oc-cpu-optimized",
+			},
 		},
 		{
-			description: "project id invalid 2",
-			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[globalflags.ProjectIdFlag] = "invalid-uuid"
-			}),
-			isValid: false,
+			Name:        utils.Ptr("c3i.28"),
+			Vcpus:       utils.Ptr(int64(28)),
+			Ram:         utils.Ptr(int64(60416)),
+			Description: utils.Ptr("Intel Emerald Rapids 8580 CPU instance"),
+			ExtraSpecs: &map[string]interface{}{
+				"cpu":              "intel-emerald-rapids-8580-dual-socket",
+				"overcommit":       "4",
+				"hw:mem_page_size": "large",
+			},
 		},
 		{
-			description: "limit invalid",
-			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[limitFlag] = "invalid"
-			}),
-			isValid: false,
+			Name:        utils.Ptr("g2i.1"),
+			Vcpus:       utils.Ptr(int64(1)),
+			Ram:         utils.Ptr(int64(4096)),
+			Description: utils.Ptr("Intel Ice Lake 4316 CPU instance"),
 		},
+	}
+
+	tests := []struct {
+		description string
+		items       *[]iaas.MachineType
+		model       *inputModel
+		expectedLen int
+	}{
 		{
-			description: "limit invalid 2",
-			flagValues: fixtureFlagValues(func(flagValues map[string]string) {
-				flagValues[limitFlag] = "0"
-			}),
-			isValid: false,
+			description: "base filters",
+			items:       &items,
+			model:       fixtureInputModel(),
+			expectedLen: 3,
+		},
+		{
+			description: "nil items slice",
+			items:       nil,
+			model:       fixtureInputModel(),
+			expectedLen: 0,
+		},
+		{
+			description: "filter min-vcpu 20",
+			items:       &items,
+			model:       fixtureInputModel(func(m *inputModel) { m.MinVCPUs = utils.Ptr(int64(20)) }),
+			expectedLen: 1, // c3i.28 only
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.description, func(t *testing.T) {
-			testutils.TestParseInput(t, NewCmd, parseInput, tt.expectedModel, tt.argValues, tt.flagValues, tt.isValid)
+			result := filterMachineTypes(tt.items, tt.model)
+			if len(result) != tt.expectedLen {
+				t.Errorf("expected %d items, got %d", tt.expectedLen, len(result))
+			}
 		})
 	}
 }
@@ -170,10 +211,31 @@ func TestOutputResult(t *testing.T) {
 		wantErr bool
 	}{
 		{
-			name:    "empty",
+			name:    "empty response",
 			args:    args{},
 			wantErr: false,
 		},
+		{
+			name: "response with extra specs",
+			args: args{
+				outputFormat: "table",
+				machineTypes: iaas.MachineTypeListResponse{
+					Items: &[]iaas.MachineType{
+						{
+							Name:  utils.Ptr("c3i.16"),
+							Vcpus: utils.Ptr(int64(16)),
+							Ram:   utils.Ptr(int64(32768)),
+							ExtraSpecs: &map[string]interface{}{
+								"aggregate":  "intel-gen3",
+								"overcommit": 4,
+							},
+							Description: utils.Ptr("Intel Emerald Rapids 8580 CPU instance"),
+						},
+					},
+				},
+			},
+			wantErr: false,
+		},
 	}
 	p := print.NewPrinter()
 	p.Cmd = NewCmd(&types.CmdParams{Printer: p})
