Adding Trident-Autogrow

Co-authored-by: kj-netapp <87856291+kj-netapp@users.noreply.github.com>
Co-authored-by: Albin Johns <Albin.Johns@netapp.com>
Co-authored-by: Aparna Singh <aparna.singh@netapp.com>
Co-authored-by: Alloyd Savio Mendonca <167860552+alloydsa@users.noreply.github.com>

Author: 5 people

cli/api/types.go

@@ -40,6 +40,10 @@ type MultipleStorageClassResponse struct {
 	Items []StorageClass `json:"items"`
 }
 
+type MultipleAutogrowPolicyResponse struct {
+	Items []storage.AutogrowPolicyExternal `json:"items"`
+}
+
 type MultipleVolumeResponse struct {
 	Items []storage.VolumeExternal `json:"items"`
 }

cli/api/types_test.go

@@ -245,6 +245,169 @@ func TestMultipleStorageClassResponse(t *testing.T) {
 	assert.Len(t, result.Items, 2)
 }
 
+func TestMultipleAutogrowPolicyResponse(t *testing.T) {
+	tests := []struct {
+		name     string
+		policies []storage.AutogrowPolicyExternal
+	}{
+		{
+			name: "multiple policies",
+			policies: []storage.AutogrowPolicyExternal{
+				{
+					Name:          "policy1",
+					UsedThreshold: "80",
+					GrowthAmount:  "20",
+					MaxSize:       "1000",
+					State:         storage.AutogrowPolicyStateSuccess,
+					Volumes:       []string{"vol1", "vol2"},
+					VolumeCount:   2,
+				},
+				{
+					Name:          "policy2",
+					UsedThreshold: "90",
+					GrowthAmount:  "10",
+					MaxSize:       "2000",
+					State:         storage.AutogrowPolicyStateSuccess,
+					Volumes:       []string{"vol3"},
+					VolumeCount:   1,
+				},
+			},
+		},
+		{
+			name: "single policy",
+			policies: []storage.AutogrowPolicyExternal{
+				{
+					Name:          "policy1",
+					UsedThreshold: "85",
+					GrowthAmount:  "15",
+					MaxSize:       "1500",
+					State:         storage.AutogrowPolicyStateFailed,
+					Volumes:       []string{},
+					VolumeCount:   0,
+				},
+			},
+		},
+		{
+			name:     "empty policies",
+			policies: []storage.AutogrowPolicyExternal{},
+		},
+		{
+			name: "policy with empty maxSize",
+			policies: []storage.AutogrowPolicyExternal{
+				{
+					Name:          "policy-no-max",
+					UsedThreshold: "80",
+					GrowthAmount:  "20",
+					MaxSize:       "",
+					State:         storage.AutogrowPolicyStateSuccess,
+					Volumes:       []string{"vol1"},
+					VolumeCount:   1,
+				},
+			},
+		},
+		{
+			name: "policy with deleting state",
+			policies: []storage.AutogrowPolicyExternal{
+				{
+					Name:          "policy-deleting",
+					UsedThreshold: "75",
+					GrowthAmount:  "25",
+					MaxSize:       "3000",
+					State:         storage.AutogrowPolicyStateDeleting,
+					Volumes:       []string{"vol1", "vol2", "vol3"},
+					VolumeCount:   3,
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			response := MultipleAutogrowPolicyResponse{Items: tt.policies}
+
+			// Test marshaling
+			jsonData, err := json.Marshal(response)
+			require.NoError(t, err)
+			assert.Contains(t, string(jsonData), "items")
+
+			// Verify JSON structure
+			var jsonMap map[string]interface{}
+			err = json.Unmarshal(jsonData, &jsonMap)
+			require.NoError(t, err)
+			assert.Contains(t, jsonMap, "items")
+
+			// Test unmarshaling
+			var result MultipleAutogrowPolicyResponse
+			err = json.Unmarshal(jsonData, &result)
+			require.NoError(t, err)
+			assert.Len(t, result.Items, len(tt.policies))
+
+			// Verify individual policy data
+			for i, policy := range tt.policies {
+				assert.Equal(t, policy.Name, result.Items[i].Name)
+				assert.Equal(t, policy.UsedThreshold, result.Items[i].UsedThreshold)
+				assert.Equal(t, policy.GrowthAmount, result.Items[i].GrowthAmount)
+				assert.Equal(t, policy.MaxSize, result.Items[i].MaxSize)
+				assert.Equal(t, policy.State, result.Items[i].State)
+				assert.Equal(t, policy.VolumeCount, result.Items[i].VolumeCount)
+				assert.ElementsMatch(t, policy.Volumes, result.Items[i].Volumes)
+			}
+		})
+	}
+}
+
+func TestMultipleAutogrowPolicyResponse_JSONRoundTrip(t *testing.T) {
+	// Test that data survives JSON encoding/decoding cycle
+	original := MultipleAutogrowPolicyResponse{
+		Items: []storage.AutogrowPolicyExternal{
+			{
+				Name:          "test-policy",
+				UsedThreshold: "80",
+				GrowthAmount:  "20",
+				MaxSize:       "1000",
+				State:         storage.AutogrowPolicyStateSuccess,
+				Volumes:       []string{"volume-1", "volume-2", "volume-3"},
+				VolumeCount:   3,
+			},
+		},
+	}
+
+	// Marshal to JSON
+	jsonData, err := json.Marshal(original)
+	require.NoError(t, err)
+
+	// Unmarshal back
+	var decoded MultipleAutogrowPolicyResponse
+	err = json.Unmarshal(jsonData, &decoded)
+	require.NoError(t, err)
+
+	// Verify data integrity
+	require.Len(t, decoded.Items, 1)
+	assert.Equal(t, original.Items[0].Name, decoded.Items[0].Name)
+	assert.Equal(t, original.Items[0].UsedThreshold, decoded.Items[0].UsedThreshold)
+	assert.Equal(t, original.Items[0].GrowthAmount, decoded.Items[0].GrowthAmount)
+	assert.Equal(t, original.Items[0].MaxSize, decoded.Items[0].MaxSize)
+	assert.Equal(t, original.Items[0].State, decoded.Items[0].State)
+	assert.Equal(t, original.Items[0].VolumeCount, decoded.Items[0].VolumeCount)
+	assert.ElementsMatch(t, original.Items[0].Volumes, decoded.Items[0].Volumes)
+}
+
+func TestMultipleAutogrowPolicyResponse_NilItems(t *testing.T) {
+	// Test with nil Items slice
+	response := MultipleAutogrowPolicyResponse{Items: nil}
+
+	// Test marshaling
+	jsonData, err := json.Marshal(response)
+	require.NoError(t, err)
+
+	// Test unmarshaling
+	var result MultipleAutogrowPolicyResponse
+	err = json.Unmarshal(jsonData, &result)
+	require.NoError(t, err)
+	// Note: nil slices become empty slices after JSON round-trip in Go
+	assert.Empty(t, result.Items)
+}
+
 func TestMultipleVolumeResponse(t *testing.T) {
 	volumes := []storage.VolumeExternal{
 		{

cli/cmd/get_autogrowpolicy.go

@@ -0,0 +1,175 @@
+// Copyright 2026 NetApp, Inc. All Rights Reserved.
+
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"sort"
+	"strconv"
+
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+
+	"github.com/netapp/trident/cli/api"
+	"github.com/netapp/trident/config"
+	"github.com/netapp/trident/frontend/rest"
+	"github.com/netapp/trident/storage"
+	"github.com/netapp/trident/utils/errors"
+)
+
+func init() {
+	getCmd.AddCommand(getAutogrowPolicyCmd)
+}
+
+var getAutogrowPolicyCmd = &cobra.Command{
+	Use:     "autogrowpolicy [<name>...]",
+	Short:   "Get one or more autogrow policies from Trident",
+	Aliases: []string{"agp", "autogrowpolicies"},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if OperatingMode == ModeTunnel {
+			command := []string{"get", "autogrowpolicy"}
+			out, err := TunnelCommand(append(command, args...))
+			printOutput(cmd, out, err)
+			return err
+		} else {
+			return autogrowPolicyList(args)
+		}
+	},
+}
+
+func autogrowPolicyList(autogrowPolicyNames []string) error {
+	var err error
+
+	// If no policies were specified, we'll get all of them
+	getAll := false
+	if len(autogrowPolicyNames) == 0 {
+		getAll = true
+		autogrowPolicyNames, err = GetAutogrowPolicies()
+		if err != nil {
+			return err
+		}
+	}
+
+	autogrowPolicies := make([]storage.AutogrowPolicyExternal, 0, config.DefaultAutogrowPoliciesForCLI)
+
+	// Get the actual policy objects
+	for _, autogrowPolicyName := range autogrowPolicyNames {
+		autogrowPolicy, err := GetAutogrowPolicy(autogrowPolicyName)
+		if err != nil {
+			if getAll && errors.IsAutogrowPolicyNotFoundError(err) {
+				continue
+			}
+			return err
+		}
+		autogrowPolicies = append(autogrowPolicies, autogrowPolicy)
+	}
+
+	WriteAutogrowPolicies(autogrowPolicies)
+
+	return nil
+}
+
+func GetAutogrowPolicies() ([]string, error) {
+	url := BaseURL() + "/autogrowpolicy"
+
+	response, responseBody, err := api.InvokeRESTAPI("GET", url, nil)
+	if err != nil {
+		return nil, err
+	} else if response.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("could not get Autogrow policies: %v",
+			GetErrorFromHTTPResponse(response, responseBody))
+	}
+
+	var listPoliciesResponse rest.ListAutogrowPoliciesResponse
+	err = json.Unmarshal(responseBody, &listPoliciesResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	return listPoliciesResponse.AutogrowPolicies, nil
+}
+
+func GetAutogrowPolicy(autogrowPolicyName string) (storage.AutogrowPolicyExternal, error) {
+	url := BaseURL() + "/autogrowpolicy/" + autogrowPolicyName
+
+	response, responseBody, err := api.InvokeRESTAPI("GET", url, nil)
+	if err != nil {
+		return storage.AutogrowPolicyExternal{}, err
+	} else if response.StatusCode != http.StatusOK {
+		errorMessage := fmt.Sprintf("could not get autogrow policy %s: %v", autogrowPolicyName,
+			GetErrorFromHTTPResponse(response, responseBody))
+		switch response.StatusCode {
+		case http.StatusNotFound:
+			return storage.AutogrowPolicyExternal{}, errors.AutogrowPolicyNotFoundError(errorMessage)
+		default:
+			return storage.AutogrowPolicyExternal{}, errors.New(errorMessage)
+		}
+	}
+
+	var getPolicyResponse rest.GetAutogrowPolicyResponse
+	err = json.Unmarshal(responseBody, &getPolicyResponse)
+	if err != nil {
+		return storage.AutogrowPolicyExternal{}, err
+	}
+
+	return getPolicyResponse.AutogrowPolicy, nil
+}
+
+func WriteAutogrowPolicies(autogrowPolicies []storage.AutogrowPolicyExternal) {
+	switch OutputFormat {
+	case FormatJSON:
+		WriteJSON(api.MultipleAutogrowPolicyResponse{Items: autogrowPolicies})
+	case FormatYAML:
+		WriteYAML(api.MultipleAutogrowPolicyResponse{Items: autogrowPolicies})
+	case FormatName:
+		writeAutogrowPolicyNames(autogrowPolicies)
+	default:
+		writeAutogrowPolicyTable(autogrowPolicies)
+	}
+}
+
+func writeAutogrowPolicyTable(autogrowPolicies []storage.AutogrowPolicyExternal) {
+	// Sort autogrowPolicies alphabetically by name
+	sort.Slice(autogrowPolicies, func(i, j int) bool {
+		return autogrowPolicies[i].Name < autogrowPolicies[j].Name
+	})
+
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetHeader([]string{"Name", "Used Threshold", "Growth Amount", "Max Size", "Volumes"})
+
+	for _, agp := range autogrowPolicies {
+		maxSize := agp.MaxSize
+		if maxSize == "" {
+			maxSize = "N/A"
+		}
+
+		growthAmount := agp.GrowthAmount
+		if growthAmount == "" {
+			growthAmount = config.DefaultAGPGrowthAmount // Default value
+		}
+
+		table.Append([]string{
+			agp.Name,
+			agp.UsedThreshold,
+			growthAmount,
+			maxSize,
+			strconv.Itoa(agp.VolumeCount),
+		})
+	}
+
+	table.Render()
+}
+
+func writeAutogrowPolicyNames(autogrowPolicies []storage.AutogrowPolicyExternal) {
+	// Sort autogrowPolicies alphabetically by name
+	sort.Slice(autogrowPolicies, func(i, j int) bool {
+		return autogrowPolicies[i].Name < autogrowPolicies[j].Name
+	})
+
+	for _, agp := range autogrowPolicies {
+		fmt.Println(agp.Name)
+	}
+}