CSI Volume Group Snapshots ONTAP-SAN

Added support for v1beta1 CSI Volume Group Snapshots starting in Kubernetes 1.32.
Co-authored-by: joe webster <[email protected]>
Co-authored-by: emmahardison <[email protected]>

Author: 3 people

cli/api/types.go

@@ -56,6 +56,10 @@ type MultipleSnapshotResponse struct {
 	Items []storage.SnapshotExternal `json:"items"`
 }
 
+type MultipleGroupSnapshotResponse struct {
+	Items []storage.GroupSnapshotExternal `json:"items"`
+}
+
 type Version struct {
 	Version       string `json:"version"`
 	MajorVersion  uint   `json:"majorVersion"`

cli/cmd/delete_groupsnapshot.go

@@ -0,0 +1,88 @@
+package cmd
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/spf13/cobra"
+
+	"github.com/netapp/trident/cli/api"
+	"github.com/netapp/trident/storage"
+	"github.com/netapp/trident/utils/errors"
+)
+
+var allGroupSnapshots bool
+
+func init() {
+	deleteCmd.AddCommand(deleteGroupSnapshotCmd)
+	deleteGroupSnapshotCmd.Flags().BoolVarP(&allGroupSnapshots, "all", "a", false, "Delete all group snapshots")
+}
+
+var deleteGroupSnapshotCmd = &cobra.Command{
+	Use:     "groupsnapshot <group snapshot name>...",
+	Short:   "Delete one or more group snapshots from Trident",
+	Aliases: []string{"gs", "gsnap", "groupsnapshots"},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if OperatingMode == ModeTunnel {
+			command := []string{"delete", "groupsnapshot"}
+
+			if allGroupSnapshots {
+				command = append(command, "--all")
+			}
+
+			out, err := TunnelCommand(append(command, args...))
+			printOutput(cmd, out, err)
+			return err
+		}
+		return groupSnapshotDelete(args...)
+	},
+}
+
+func groupSnapshotDelete(groupSnapshotIDs ...string) error {
+	// The --all switch cannot be used with specific snapshot IDs.
+	if allGroupSnapshots && len(groupSnapshotIDs) > 0 {
+		return errors.InvalidInputError("cannot use --all switch with individual group snapshots")
+	} else if len(groupSnapshotIDs) == 0 && !allGroupSnapshots {
+		return errors.InvalidInputError("must specify at least one group snapshot name or use --all switch")
+	}
+
+	if allGroupSnapshots {
+		var err error
+		groupSnapshotIDs, err = GetGroupSnapshots()
+		if err != nil {
+			return err
+		}
+	}
+
+	for _, groupSnapshotID := range groupSnapshotIDs {
+		if err := DeleteGroupSnapshot(groupSnapshotID); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func DeleteGroupSnapshot(groupID string) error {
+	if _, err := storage.ConvertGroupSnapshotID(groupID); err != nil {
+		return errors.InvalidInputError(fmt.Sprintf("invalid group snapshot ID %s: %v", groupID, err))
+	}
+
+	url := BaseURL() + "/groupsnapshot/" + groupID
+	response, responseBody, err := api.InvokeRESTAPI("DELETE", url, nil)
+	if err != nil {
+		return err
+	}
+
+	if response.StatusCode != http.StatusOK {
+		errorMessage := fmt.Sprintf("could not delete group snapshot %s: %v", groupID,
+			GetErrorFromHTTPResponse(response, responseBody))
+		switch response.StatusCode {
+		case http.StatusNotFound:
+			return errors.NotFoundError(errorMessage)
+		default:
+			return errors.New(errorMessage)
+		}
+	}
+
+	return nil
+}

cli/cmd/delete_snapshot.go

@@ -8,94 +8,126 @@ import (
 	"strings"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 
 	"github.com/netapp/trident/cli/api"
+	"github.com/netapp/trident/pkg/convert"
 	"github.com/netapp/trident/utils/errors"
 )
 
 var (
 	allSnapshots         bool
 	allSnapshotsInVolume string
+	allSnapshotsInGroup  string
+
+	// deleteSnapshotFlagValues is used to store the REST API URL parameters for the 'delete snapshot' command.
+	deleteSnapshotFlagValues map[string]string
 )
 
 func init() {
 	deleteCmd.AddCommand(deleteSnapshotCmd)
-	deleteSnapshotCmd.Flags().BoolVar(&allSnapshots, "all", false, "Delete all snapshots")
+	deleteSnapshotCmd.Flags().BoolVarP(&allSnapshots, "all", "a", false, "Delete all snapshots")
 	deleteSnapshotCmd.Flags().StringVar(&allSnapshotsInVolume, "volume", "", "Delete all snapshots in volume")
+	deleteSnapshotCmd.Flags().StringVar(&allSnapshotsInGroup, "group", "", "Delete all snapshots in a group")
+
+	// Only one of these flags may be specified at a time.
+	deleteSnapshotCmd.MarkFlagsMutuallyExclusive("volume", "group", "all")
 }
 
 var deleteSnapshotCmd = &cobra.Command{
 	Use:     "snapshot <volume/snapshot> [<volume/snapshot>...]",
 	Short:   "Delete one or more volume snapshots from Trident",
 	Aliases: []string{"s", "snap", "snapshots"},
 	RunE: func(cmd *cobra.Command, args []string) error {
+		// Build a map of URL parameters for the 'delete snapshot' command.
+		deleteSnapshotFlagValues = make(map[string]string)
+		cmd.Flags().Visit(func(flag *pflag.Flag) {
+			// Store the flag name and value in deleteSnapshotURLVar for use in REST API calls.
+			deleteSnapshotFlagValues[flag.Name] = flag.Value.String()
+		})
+
 		if OperatingMode == ModeTunnel {
 			command := []string{"delete", "snapshot"}
-			if allSnapshotsInVolume != "" {
-				command = append(command, "--volume", allSnapshotsInVolume)
+
+			volume, ok := deleteSnapshotFlagValues["volume"]
+			if ok && volume != "" {
+				command = append(command, "--volume", volume)
 			}
-			if allSnapshots {
+
+			group, ok := deleteSnapshotFlagValues["group"]
+			if ok && group != "" {
+				// If a group is specified, we delete all snapshots in that group.
+				// This typically isn't recommended, but we'll allow it for exceptional cases where
+				// the group snapshot has been lost and the admin needs to clean up.
+				command = append(command, "--group", group)
+			}
+
+			all, ok := deleteSnapshotFlagValues["all"]
+			if ok && convert.ToBool(all) {
 				command = append(command, "--all")
 			}
+
+			// Fail if a mix of flags is used that doesn't make sense. This should be caught by the CLI framework,
+			// but in the case it's not, check here.
+			if volume != "" && group != "" {
+				return errors.InvalidInputError("cannot specify both --volume and --group flags")
+			} else if volume != "" && convert.ToBool(all) {
+				return errors.InvalidInputError("cannot specify --volume flag and --all flag")
+			} else if group != "" && convert.ToBool(all) {
+				return errors.InvalidInputError("cannot specify --group flag and --all flag")
+			}
+
 			out, err := TunnelCommand(append(command, args...))
 			printOutput(cmd, out, err)
 			return err
-		} else {
-			return snapshotDelete(args)
 		}
+
+		return snapshotDelete(args)
 	},
 }
 
 func snapshotDelete(snapshotIDs []string) error {
-	var err error
-
-	if allSnapshotsInVolume != "" {
-		// Make sure --volume isn't being used along with specific snapshots
-		if len(snapshotIDs) > 0 {
-			return errors.New("cannot use --volume switch and specify individual snapshots")
-		}
+	// The --all switch cannot be used with specific snapshot IDs.
+	if all, _ := deleteSnapshotFlagValues["all"]; convert.ToBool(all) && len(snapshotIDs) > 0 {
+		return errors.InvalidInputError("cannot use --all switch with individual snapshots")
+	}
 
-		// Get list of snapshot IDs in the specified volume so we can delete them all
-		snapshotIDs, err = GetSnapshots(allSnapshotsInVolume)
-		if err != nil {
-			return err
-		}
+	// The --volume switch cannot be used with specific snapshot IDs.
+	if volume, _ := deleteSnapshotFlagValues["volume"]; volume != "" && len(snapshotIDs) > 0 {
+		return errors.InvalidInputError("cannot use --volume switch with individual snapshots")
+	}
 
-	} else if allSnapshots {
-		// Make sure --all isn't being used along with specific snapshots
-		if len(snapshotIDs) > 0 {
-			return errors.New("cannot use --all switch and specify individual snapshots")
-		}
+	// The --group switch cannot be used with specific snapshot IDs.
+	if group, _ := deleteSnapshotFlagValues["group"]; group != "" && len(snapshotIDs) > 0 {
+		return errors.InvalidInputError("cannot use --group switch with individual snapshots")
+	}
 
-		// Get list of snapshot IDs so we can delete them all
-		snapshotIDs, err = GetSnapshots("")
+	// If some snapshots were specified, we'll delete those.
+	var err error
+	if len(snapshotIDs) == 0 {
+		snapshotIDs, err = GetSnapshots(buildSnapshotURL(deleteSnapshotFlagValues))
 		if err != nil {
 			return err
 		}
-	} else {
-		// Not using --all or --volume, each snapshot must have volume specified
-		if len(snapshotIDs) == 0 {
-			return errors.New("volume/snapshot not specified")
-		}
-		for _, snapshotID := range snapshotIDs {
-			if !strings.ContainsRune(snapshotID, '/') {
-				return errors.InvalidInputError(fmt.Sprintf("invalid snapshot ID: %s; Please use the format "+
-					"<volume name>/<snapshot name>", snapshotID))
-			}
-		}
 	}
 
+	var errs error
 	for _, snapshotID := range snapshotIDs {
+		// Each snapshot must have volume specified.
+		if !strings.ContainsRune(snapshotID, '/') {
+			return errors.InvalidInputError(fmt.Sprintf("invalid snapshot ID: %s; Please use the format "+
+				"<volume name>/<snapshot name>", snapshotID))
+		}
+
 		url := BaseURL() + "/snapshot/" + snapshotID
 
 		response, responseBody, err := api.InvokeRESTAPI("DELETE", url, nil)
 		if err != nil {
 			return err
 		} else if response.StatusCode != http.StatusOK {
-			return fmt.Errorf("could not delete snapshot %s: %v", snapshotID,
-				GetErrorFromHTTPResponse(response, responseBody))
+			errs = errors.Join(errs, GetErrorFromHTTPResponse(response, responseBody))
 		}
 	}
 
-	return nil
+	return errs
 }