Skip to content

Modern Docker Management, Designed for Everyone

11.2 KB
Raw Blame
package volumes

import (
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/getarcaneapp/arcane/types/v2/volume"
	"github.com/spf13/cobra"
	"go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
	"github.com/getarcaneapp/arcane/cli/v2/internal/output"
	"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)

func Command() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "volumes",
		Aliases: []string{"volume", "vol", "v"},
		Short:   "Manage volumes",
	}
	cmd.AddCommand(
		newWorkspaceCmd(),
		newRenameCmd(),
		newBackupsCmd(),
		newListCmd(),
		newGetCmd(),
		newDeleteCmd(),
		newCountsCmd(),
		newPruneCmd(),
		newSizesCmd(),
		newUsageCmd(),
		newCreateCmd(),
	)
	cmdutil.SetScope(cmdutil.ScopeResource, cmd)
	return cmd
}

func newListCmd() *cobra.Command {
	var opts struct {
		limitFlag      int
		startFlag      int
		allFlag        bool
		inUseOnlyFlag  bool
		unusedOnlyFlag bool
		includeFlag    bool
	}
	cmd := &cobra.Command{
		Use:          "list",
		Aliases:      []string{"ls"},
		Short:        "List volumes",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			// Filter server-side so that pagination and the reported totals apply to
			// the matching set rather than to whichever page happened to be fetched.
			query := url.Values{}
			if opts.inUseOnlyFlag {
				query.Set("inUse", "true")
			}
			if opts.unusedOnlyFlag {
				query.Set("inUse", "false")
			}
			if opts.includeFlag {
				query.Set("include", "true")
			}

			return cmdutil.RunList(cmd, c, cmdutil.ListSpec[volume.Volume]{
				Resource: "volumes",
				Endpoint: types.Volumes(c.EnvID()),
				Params: cmdutil.ListParams{
					Resource:        "volumes",
					Limit:           opts.limitFlag,
					FallbackDefault: 20,
					Start:           opts.startFlag,
					All:             opts.allFlag,
				},
				Query:   query,
				Headers: []string{"NAME", "DRIVER", "MOUNTPOINT", "CREATED", "IN USE"},
				Row: func(vol volume.Volume) []string {
					return []string{
						vol.Name,
						vol.Driver,
						vol.Mountpoint,
						vol.CreatedAt,
						kit.Ternary(vol.InUse, "Yes", "No"),
					}
				},
			})
		},
	}
	cmd.Flags().IntVarP(&opts.limitFlag, "limit", "n", 20, "Number of volumes to show")
	cmd.Flags().IntVar(&opts.startFlag, "start", 0, cmdutil.StartFlagUsage)
	cmd.Flags().BoolVarP(&opts.allFlag, "all", "a", false, cmdutil.AllFlagUsage)
	cmd.Flags().BoolVar(&opts.inUseOnlyFlag, "inuse", false, "Only show volumes currently in use")
	cmd.Flags().BoolVar(&opts.unusedOnlyFlag, "unused", false, "Only show volumes not in use")
	cmd.Flags().BoolVar(&opts.includeFlag, "include-internal", false, "Include Arcane-internal volumes")
	cmdutil.SetScope(cmdutil.ScopeMerged, cmd)
	cmd.PreRunE = func(cmd *cobra.Command, _ []string) error { return cmdutil.ExclusiveFlags(cmd, "inuse", "unused") }
	return cmd
}

func newGetCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "get <volume-name>",
		Short:        "Get volume details",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			allowPrompt := cmdutil.AllowPrompt(cmd)
			resolved, err := volumeRef.Fetch(cmd.Context(), c, args[0], allowPrompt)
			if err != nil {
				return err
			}

			if cmdutil.JSONOutputEnabled(cmd) {
				return cmdutil.PrintJSON(resolved)
			}

			output.Header("Volume Details")
			output.KeyValue("Name", resolved.Name)
			output.KeyValue("Driver", resolved.Driver)
			output.KeyValue("Mountpoint", resolved.Mountpoint)
			output.KeyValue("Scope", resolved.Scope)
			output.KeyValue("Created", resolved.CreatedAt)
			output.KeyValue("In Use", resolved.InUse)
			if resolved.Size > 0 {
				output.KeyValue("Size", output.Bytes(resolved.Size))
			}
			return nil
		},
	}
}

func newDeleteCmd() *cobra.Command {
	var opts struct {
		forceFlag bool
	}
	cmd := &cobra.Command{
		Use:          "delete <volume-name>",
		Aliases:      []string{"rm", "remove"},
		Short:        "Delete a volume",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			allowPrompt := !opts.forceFlag && cmdutil.AllowPrompt(cmd)
			resolved, _, err := volumeRef.Resolve(cmd.Context(), c, args[0], allowPrompt)
			if err != nil {
				return err
			}

			return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
				Force:          opts.forceFlag,
				Prompt:         fmt.Sprintf("Are you sure you want to delete volume %s?", resolved.Name),
				Path:           cmdutil.AppendQuery(types.Volume(c.EnvID(), resolved.Name), url.Values{"force": []string{strconv.FormatBool(opts.forceFlag)}}),
				FailureMessage: "failed to delete volume",
				SuccessMessage: fmt.Sprintf("Volume %s deleted successfully", resolved.Name),
			})
		},
	}
	cmd.Flags().BoolVarP(&opts.forceFlag, "force", "f", false, "Force removal of a volume that is in use and skip the confirmation prompt")
	return cmd
}

func newCountsCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:          "counts",
		Short:        "Get volume usage counts",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}
			return cmdutil.Run(cmd, c, cmdutil.Spec[any]{
				Method:         http.MethodGet,
				Path:           types.VolumesCounts(c.EnvID()),
				FailureMessage: "failed to get volume counts",
				Render: func(data any) error {
					output.Header("Volume Usage Counts")
					return cmdutil.PrintJSON(data)
				},
			})
		},
	}
	cmdutil.SetScope(cmdutil.ScopeRead, cmd)
	return cmd
}

func newPruneCmd() *cobra.Command {
	var opts struct {
		forceFlag bool
	}
	cmd := &cobra.Command{
		Use:          "prune",
		Short:        "Remove unused volumes",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			confirmed, confirmationErr := cmdutil.ConfirmOrCancel(cmd, opts.forceFlag, "Are you sure you want to prune unused volumes?")
			if confirmationErr != nil || !confirmed {
				return confirmationErr
			}

			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[any]{
				Method:         http.MethodPost,
				Path:           types.VolumesPrune(c.EnvID()),
				FailureMessage: "failed to prune volumes",
				Render:         func(any) error { output.Success("%s", "Volumes pruned successfully"); return nil },
			})
		},
	}
	cmd.Flags().BoolVarP(&opts.forceFlag, "force", "f", false, "Force prune without confirmation")
	cmdutil.SetScope(cmdutil.ScopeFleet, cmd)
	return cmd
}

func newSizesCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:          "sizes",
		Short:        "Get volume sizes",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}
			return cmdutil.Run(cmd, c, cmdutil.Spec[any]{
				Method:         http.MethodGet,
				Path:           types.VolumesSizes(c.EnvID()),
				FailureMessage: "failed to get volume sizes",
				Render: func(data any) error {
					output.Header("Volume Sizes")
					return cmdutil.PrintJSON(data)
				},
			})
		},
	}
	cmdutil.SetScope(cmdutil.ScopeMerged, cmd)
	return cmd
}

func newUsageCmd() *cobra.Command {
	return &cobra.Command{
		Use:          "usage <volume-name>",
		Short:        "Get specific volume usage",
		Args:         cobra.ExactArgs(1),
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			allowPrompt := cmdutil.AllowPrompt(cmd)
			resolved, _, err := volumeRef.Resolve(cmd.Context(), c, args[0], allowPrompt)
			if err != nil {
				return err
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[any]{
				Method:         http.MethodGet,
				Path:           types.VolumeUsage(c.EnvID(), resolved.Name),
				FailureMessage: "failed to get volume usage",
				Render: func(data any) error {
					output.Header("Volume Usage: %s", resolved.Name)
					return cmdutil.PrintJSON(data)
				},
			})
		},
	}
}

func newCreateCmd() *cobra.Command {
	var opts struct {
		volumeCreateName   string
		volumeCreateDriver string
		volumeCreateOpts   []string
		volumeCreateLabels []string
	}
	cmd := &cobra.Command{
		Use:          "create",
		Short:        "Create a volume",
		SilenceUsage: true,
		Args:         cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			c, err := cmdutil.ClientFromCommand(cmd)
			if err != nil {
				return err
			}

			var driverOpts, labels map[string]string

			if len(opts.volumeCreateOpts) > 0 {
				driverOpts = make(map[string]string)
				for _, opt := range opts.volumeCreateOpts {
					parts := strings.SplitN(opt, "=", 2)
					if len(parts) == 2 {
						driverOpts[parts[0]] = parts[1]
					}
				}
			}

			if len(opts.volumeCreateLabels) > 0 {
				labels = make(map[string]string)
				for _, lbl := range opts.volumeCreateLabels {
					parts := strings.SplitN(lbl, "=", 2)
					if len(parts) == 2 {
						labels[parts[0]] = parts[1]
					}
				}
			}

			return cmdutil.Run(cmd, c, cmdutil.Spec[volume.Volume]{
				Method: http.MethodPost,
				Path:   types.Volumes(c.EnvID()),
				Body: volume.Create{
					Name:       opts.volumeCreateName,
					Driver:     opts.volumeCreateDriver,
					DriverOpts: driverOpts,
					Labels:     labels,
				},
				FailureMessage: "failed to create volume",
				Render: func(data volume.Volume) error {
					output.Success("Volume %s created successfully", data.Name)
					output.KeyValue("Name", data.Name)
					output.KeyValue("Driver", data.Driver)
					output.KeyValue("Mountpoint", data.Mountpoint)
					return nil
				},
			})
		},
	}
	cmd.Flags().StringVar(&opts.volumeCreateName, "name", "", "Volume name")
	cmd.Flags().StringVar(&opts.volumeCreateDriver, "driver", "", "Volume driver")
	cmd.Flags().StringArrayVar(&opts.volumeCreateOpts, "opt", nil, "Driver option (KEY=VALUE)")
	cmd.Flags().StringArrayVar(&opts.volumeCreateLabels, "label", nil, "Label (KEY=VALUE)")
	_ = cmd.MarkFlagRequired("name")
	cmdutil.SetScope(cmdutil.ScopeDestination, cmd)
	return cmd
}

var volumeRef = cmdutil.ResourceRef[volume.Volume, volume.Volume]{
	EnvironmentScoped: true,
	Singular:          "volume",
	Plural:            "volumes",
	IDHint:            "the volume name",
	ListCmd:           "arcane volumes list",
	GetPath:           types.Volume,
	IdentifierOf:      func(data volume.Volume) string { return data.Name },
	ListPath:          types.Volumes,
	Matches: func(item volume.Volume, identifierLower, original string) bool {
		idLower := strings.ToLower(item.ID)
		return strings.EqualFold(item.Name, original) || strings.Contains(strings.ToLower(item.Name), identifierLower) ||
			idLower == identifierLower || (len(identifierLower) >= 4 && strings.HasPrefix(idLower, identifierLower))
	},
	Label: func(match volume.Volume) string {
		if match.Driver != "" {
			return fmt.Sprintf("%s (%s)", match.Name, match.Driver)
		}
		return match.Name
	},
	Promote: func(match volume.Volume) *volume.Volume { return &match },
}