Add "podman volume" command

Add support for podman volume and its subcommands.
The commands supported are:
	podman volume create
	podman volume inspect
	podman volume ls
	podman volume rm
	podman volume prune

This is a tool to manage volumes used by podman. For now it only handle
named volumes, but eventually it will handle all volumes used by podman.

Signed-off-by: umohnani8 <umohnani@redhat.com>

10 files changed, 697 insertions, 8 deletions

diff --git a/cmd/podman/create_cli.go b/cmd/podman/create_cli.go
index 218e9b806..b3a30d185 100644
--- a/cmd/podman/create_cli.go
+++ b/cmd/podman/create_cli.go
@@ -201,12 +201,13 @@ func parseVolumesFrom(volumesFrom []string) error {
 }
 
 func validateVolumeHostDir(hostDir string) error {
-	if !filepath.IsAbs(hostDir) {
-		return errors.Errorf("invalid host path, must be an absolute path %q", hostDir)
-	}
-	if _, err := os.Stat(hostDir); err != nil {
-		return errors.Wrapf(err, "error checking path %q", hostDir)
+	if filepath.IsAbs(hostDir) {
+		if _, err := os.Stat(hostDir); err != nil {
+			return errors.Wrapf(err, "error checking path %q", hostDir)
+		}
 	}
+	// If hostDir is not an absolute path, that means the user wants to create a
+	// named volume. This will be done later on in the code.
 	return nil
 }
 
diff --git a/cmd/podman/libpodruntime/runtime.go b/cmd/podman/libpodruntime/runtime.go
index 0dc6bcf18..d7a0dd931 100644
--- a/cmd/podman/libpodruntime/runtime.go
+++ b/cmd/podman/libpodruntime/runtime.go
@@ -14,6 +14,11 @@ func GetRuntime(c *cli.Context) (*libpod.Runtime, error) {
 	storageOpts := new(storage.StoreOptions)
 	options := []libpod.RuntimeOption{}
 
+	_, volumePath, err := util.GetDefaultStoreOptions()
+	if err != nil {
+		return nil, err
+	}
+
 	if c.IsSet("uidmap") || c.IsSet("gidmap") || c.IsSet("subuidmap") || c.IsSet("subgidmap") {
 		mappings, err := util.ParseIDMapping(c.StringSlice("uidmap"), c.StringSlice("gidmap"), c.String("subuidmap"), c.String("subgidmap"))
 		if err != nil {
@@ -90,6 +95,7 @@ func GetRuntime(c *cli.Context) (*libpod.Runtime, error) {
 	if c.IsSet("infra-command") {
 		options = append(options, libpod.WithDefaultInfraCommand(c.String("infra-command")))
 	}
+	options = append(options, libpod.WithVolumePath(volumePath))
 	if c.IsSet("config") {
 		return libpod.NewRuntimeFromConfig(c.String("config"), options...)
 	}
diff --git a/cmd/podman/main.go b/cmd/podman/main.go
index bcae04575..280448dc8 100644
--- a/cmd/podman/main.go
+++ b/cmd/podman/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"log/syslog"
 	"os"
 	"os/exec"
 	"runtime/pprof"
@@ -16,7 +17,6 @@ import (
 	"github.com/sirupsen/logrus"
 	lsyslog "github.com/sirupsen/logrus/hooks/syslog"
 	"github.com/urfave/cli"
-	"log/syslog"
 )
 
 // This is populated by the Makefile from the VERSION file
@@ -102,6 +102,7 @@ func main() {
 		umountCommand,
 		unpauseCommand,
 		versionCommand,
+		volumeCommand,
 		waitCommand,
 	}
 
diff --git a/cmd/podman/utils.go b/cmd/podman/utils.go
index 5735156c2..a59535b43 100644
--- a/cmd/podman/utils.go
+++ b/cmd/podman/utils.go
@@ -3,6 +3,9 @@ package main
 import (
 	"context"
 	"fmt"
+	"os"
+	gosignal "os/signal"
+
 	"github.com/containers/libpod/libpod"
 	"github.com/docker/docker/pkg/signal"
 	"github.com/docker/docker/pkg/term"
@@ -11,8 +14,6 @@ import (
 	"github.com/urfave/cli"
 	"golang.org/x/crypto/ssh/terminal"
 	"k8s.io/client-go/tools/remotecommand"
-	"os"
-	gosignal "os/signal"
 )
 
 type RawTtyFormatter struct {
@@ -208,6 +209,35 @@ func getPodsFromContext(c *cli.Context, r *libpod.Runtime) ([]*libpod.Pod, error
 	return pods, lastError
 }
 
+func getVolumesFromContext(c *cli.Context, r *libpod.Runtime) ([]*libpod.Volume, error) {
+	args := c.Args()
+	var (
+		vols      []*libpod.Volume
+		lastError error
+		err       error
+	)
+
+	if c.Bool("all") {
+		vols, err = r.Volumes()
+		if err != nil {
+			return nil, errors.Wrapf(err, "unable to get all volumes")
+		}
+	}
+
+	for _, i := range args {
+		vol, err := r.GetVolume(i)
+		if err != nil {
+			if lastError != nil {
+				logrus.Errorf("%q", lastError)
+			}
+			lastError = errors.Wrapf(err, "unable to find volume %s", i)
+			continue
+		}
+		vols = append(vols, vol)
+	}
+	return vols, lastError
+}
+
 //printParallelOutput takes the map of parallel worker results and outputs them
 // to stdout
 func printParallelOutput(m map[string]error, errCount int) error {
diff --git a/cmd/podman/volume.go b/cmd/podman/volume.go
new file mode 100644
index 000000000..913592e74
--- /dev/null
+++ b/cmd/podman/volume.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+	"github.com/urfave/cli"
+)
+
+var (
+	volumeDescription = `Manage volumes.
+
+Volumes are created in and can be shared between containers.`
+
+	volumeSubCommands = []cli.Command{
+		volumeCreateCommand,
+		volumeLsCommand,
+		volumeRmCommand,
+		volumeInspectCommand,
+		volumePruneCommand,
+	}
+	volumeCommand = cli.Command{
+		Name:                   "volume",
+		Usage:                  "Manage volumes",
+		Description:            volumeDescription,
+		UseShortOptionHandling: true,
+		Subcommands:            volumeSubCommands,
+	}
+)
diff --git a/cmd/podman/volume_create.go b/cmd/podman/volume_create.go
new file mode 100644
index 000000000..0b5f8d1e3
--- /dev/null
+++ b/cmd/podman/volume_create.go
@@ -0,0 +1,97 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/containers/libpod/cmd/podman/libpodruntime"
+	"github.com/containers/libpod/libpod"
+	"github.com/pkg/errors"
+	"github.com/urfave/cli"
+)
+
+var volumeCreateDescription = `
+podman volume create
+
+Creates a new volume. If using the default driver, "local", the volume will
+be created at.`
+
+var volumeCreateFlags = []cli.Flag{
+	cli.StringFlag{
+		Name:  "driver",
+		Usage: "Specify volume driver name (default local)",
+	},
+	cli.StringSliceFlag{
+		Name:  "label, l",
+		Usage: "Set metadata for a volume (default [])",
+	},
+	cli.StringSliceFlag{
+		Name:  "opt, o",
+		Usage: "Set driver specific options (default [])",
+	},
+}
+
+var volumeCreateCommand = cli.Command{
+	Name:                   "create",
+	Usage:                  "Create a new volume",
+	Description:            volumeCreateDescription,
+	Flags:                  volumeCreateFlags,
+	Action:                 volumeCreateCmd,
+	SkipArgReorder:         true,
+	ArgsUsage:              "[VOLUME-NAME]",
+	UseShortOptionHandling: true,
+}
+
+func volumeCreateCmd(c *cli.Context) error {
+	var (
+		options []libpod.VolumeCreateOption
+		err     error
+		volName string
+	)
+
+	if err = validateFlags(c, volumeCreateFlags); err != nil {
+		return err
+	}
+
+	runtime, err := libpodruntime.GetRuntime(c)
+	if err != nil {
+		return errors.Wrapf(err, "error creating libpod runtime")
+	}
+	defer runtime.Shutdown(false)
+
+	if len(c.Args()) > 1 {
+		return errors.Errorf("too many arguments, create takes at most 1 argument")
+	}
+
+	if len(c.Args()) > 0 {
+		volName = c.Args()[0]
+		options = append(options, libpod.WithVolumeName(volName))
+	}
+
+	if c.IsSet("driver") {
+		options = append(options, libpod.WithVolumeDriver(c.String("driver")))
+	}
+
+	labels, err := getAllLabels([]string{}, c.StringSlice("label"))
+	if err != nil {
+		return errors.Wrapf(err, "unable to process labels")
+	}
+	if len(labels) != 0 {
+		options = append(options, libpod.WithVolumeLabels(labels))
+	}
+
+	opts, err := getAllLabels([]string{}, c.StringSlice("opt"))
+	if err != nil {
+		return errors.Wrapf(err, "unable to process options")
+	}
+	if len(options) != 0 {
+		options = append(options, libpod.WithVolumeOptions(opts))
+	}
+
+	vol, err := runtime.NewVolume(getContext(), options...)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("%s\n", vol.Name())
+
+	return nil
+}
diff --git a/cmd/podman/volume_inspect.go b/cmd/podman/volume_inspect.go
new file mode 100644
index 000000000..152f1d098
--- /dev/null
+++ b/cmd/podman/volume_inspect.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"github.com/containers/libpod/cmd/podman/libpodruntime"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli"
+)
+
+var volumeInspectDescription = `
+podman volume inspect
+
+Display detailed information on one or more volumes. Can change the format
+from JSON to a Go template.
+`
+
+var volumeInspectFlags = []cli.Flag{
+	cli.BoolFlag{
+		Name:  "all, a",
+		Usage: "Inspect all volumes",
+	},
+	cli.StringFlag{
+		Name:  "format, f",
+		Usage: "Format volume output using Go template",
+		Value: "json",
+	},
+}
+
+var volumeInspectCommand = cli.Command{
+	Name:                   "inspect",
+	Usage:                  "Display detailed information on one or more volumes",
+	Description:            volumeInspectDescription,
+	Flags:                  volumeInspectFlags,
+	Action:                 volumeInspectCmd,
+	SkipArgReorder:         true,
+	ArgsUsage:              "[VOLUME-NAME ...]",
+	UseShortOptionHandling: true,
+}
+
+func volumeInspectCmd(c *cli.Context) error {
+	var err error
+
+	if err = validateFlags(c, volumeInspectFlags); err != nil {
+		return err
+	}
+
+	runtime, err := libpodruntime.GetRuntime(c)
+	if err != nil {
+		return errors.Wrapf(err, "error creating libpod runtime")
+	}
+	defer runtime.Shutdown(false)
+
+	opts := volumeLsOptions{
+		Format: c.String("format"),
+	}
+
+	vols, lastError := getVolumesFromContext(c, runtime)
+	if lastError != nil {
+		logrus.Errorf("%q", lastError)
+	}
+
+	return generateVolLsOutput(vols, opts, runtime)
+}
diff --git a/cmd/podman/volume_ls.go b/cmd/podman/volume_ls.go
new file mode 100644
index 000000000..0f94549ee
--- /dev/null
+++ b/cmd/podman/volume_ls.go
@@ -0,0 +1,308 @@
+package main
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/containers/libpod/cmd/podman/formats"
+	"github.com/containers/libpod/cmd/podman/libpodruntime"
+	"github.com/containers/libpod/libpod"
+	"github.com/pkg/errors"
+	"github.com/urfave/cli"
+)
+
+// volumeOptions is the "ls" command options
+type volumeLsOptions struct {
+	Format string
+	Quiet  bool
+}
+
+// volumeLsTemplateParams is the template parameters to list the volumes
+type volumeLsTemplateParams struct {
+	Name       string
+	Labels     string
+	MountPoint string
+	Driver     string
+	Options    string
+	Scope      string
+}
+
+// volumeLsJSONParams is the JSON parameters to list the volumes
+type volumeLsJSONParams struct {
+	Name       string            `json:"name"`
+	Labels     map[string]string `json:"labels"`
+	MountPoint string            `json:"mountPoint"`
+	Driver     string            `json:"driver"`
+	Options    map[string]string `json:"options"`
+	Scope      string            `json:"scope"`
+}
+
+var volumeLsDescription = `
+podman volume ls
+
+List all available volumes. The output of the volumes can be filtered
+and the output format can be changed to JSON or a user specified Go template.
+`
+
+var volumeLsFlags = []cli.Flag{
+	cli.StringFlag{
+		Name:  "filter, f",
+		Usage: "Filter volume output",
+	},
+	cli.StringFlag{
+		Name:  "format",
+		Usage: "Format volume output using Go template",
+		Value: "table {{.Driver}}\t{{.Name}}",
+	},
+	cli.BoolFlag{
+		Name:  "quiet, q",
+		Usage: "Print volume output in quiet mode",
+	},
+}
+
+var volumeLsCommand = cli.Command{
+	Name:                   "ls",
+	Aliases:                []string{"list"},
+	Usage:                  "List volumes",
+	Description:            volumeLsDescription,
+	Flags:                  volumeLsFlags,
+	Action:                 volumeLsCmd,
+	SkipArgReorder:         true,
+	UseShortOptionHandling: true,
+}
+
+func volumeLsCmd(c *cli.Context) error {
+	if err := validateFlags(c, volumeLsFlags); err != nil {
+		return err
+	}
+
+	runtime, err := libpodruntime.GetRuntime(c)
+	if err != nil {
+		return errors.Wrapf(err, "error creating libpod runtime")
+	}
+	defer runtime.Shutdown(false)
+
+	if len(c.Args()) > 0 {
+		return errors.Errorf("too many arguments, ls takes no arguments")
+	}
+
+	opts := volumeLsOptions{
+		Quiet: c.Bool("quiet"),
+	}
+	opts.Format = genVolLsFormat(c)
+
+	// Get the filter functions based on any filters set
+	var filterFuncs []libpod.VolumeFilter
+	if c.String("filter") != "" {
+		filters := strings.Split(c.String("filter"), ",")
+		for _, f := range filters {
+			filterSplit := strings.Split(f, "=")
+			if len(filterSplit) < 2 {
+				return errors.Errorf("filter input must be in the form of filter=value: %s is invalid", f)
+			}
+			generatedFunc, err := generateVolumeFilterFuncs(filterSplit[0], filterSplit[1], runtime)
+			if err != nil {
+				return errors.Wrapf(err, "invalid filter")
+			}
+			filterFuncs = append(filterFuncs, generatedFunc)
+		}
+	}
+
+	volumes, err := runtime.GetAllVolumes()
+	if err != nil {
+		return err
+	}
+
+	// Get the volumes that match the filter
+	volsFiltered := make([]*libpod.Volume, 0, len(volumes))
+	for _, vol := range volumes {
+		include := true
+		for _, filter := range filterFuncs {
+			include = include && filter(vol)
+		}
+
+		if include {
+			volsFiltered = append(volsFiltered, vol)
+		}
+	}
+	return generateVolLsOutput(volsFiltered, opts, runtime)
+}
+
+// generate the template based on conditions given
+func genVolLsFormat(c *cli.Context) string {
+	var format string
+	if c.String("format") != "" {
+		// "\t" from the command line is not being recognized as a tab
+		// replacing the string "\t" to a tab character if the user passes in "\t"
+		format = strings.Replace(c.String("format"), `\t`, "\t", -1)
+	}
+	if c.Bool("quiet") {
+		format = "{{.Name}}"
+	}
+	return format
+}
+
+// Convert output to genericParams for printing
+func volLsToGeneric(templParams []volumeLsTemplateParams, JSONParams []volumeLsJSONParams) (genericParams []interface{}) {
+	if len(templParams) > 0 {
+		for _, v := range templParams {
+			genericParams = append(genericParams, interface{}(v))
+		}
+		return
+	}
+	for _, v := range JSONParams {
+		genericParams = append(genericParams, interface{}(v))
+	}
+	return
+}
+
+// generate the accurate header based on template given
+func (vol *volumeLsTemplateParams) volHeaderMap() map[string]string {
+	v := reflect.Indirect(reflect.ValueOf(vol))
+	values := make(map[string]string)
+
+	for i := 0; i < v.NumField(); i++ {
+		key := v.Type().Field(i).Name
+		value := key
+		if value == "Name" {
+			value = "Volume" + value
+		}
+		values[key] = strings.ToUpper(splitCamelCase(value))
+	}
+	return values
+}
+
+// getVolTemplateOutput returns all the volumes in the volumeLsTemplateParams format
+func getVolTemplateOutput(lsParams []volumeLsJSONParams, opts volumeLsOptions) ([]volumeLsTemplateParams, error) {
+	var lsOutput []volumeLsTemplateParams
+
+	for _, lsParam := range lsParams {
+		var (
+			labels  string
+			options string
+		)
+
+		for k, v := range lsParam.Labels {
+			label := k
+			if v != "" {
+				label += "=" + v
+			}
+			labels += label
+		}
+		for k, v := range lsParam.Options {
+			option := k
+			if v != "" {
+				option += "=" + v
+			}
+			options += option
+		}
+		params := volumeLsTemplateParams{
+			Name:       lsParam.Name,
+			Driver:     lsParam.Driver,
+			MountPoint: lsParam.MountPoint,
+			Scope:      lsParam.Scope,
+			Labels:     labels,
+			Options:    options,
+		}
+
+		lsOutput = append(lsOutput, params)
+	}
+	return lsOutput, nil
+}
+
+// getVolJSONParams returns the volumes in JSON format
+func getVolJSONParams(volumes []*libpod.Volume, opts volumeLsOptions, runtime *libpod.Runtime) ([]volumeLsJSONParams, error) {
+	var lsOutput []volumeLsJSONParams
+
+	for _, volume := range volumes {
+		params := volumeLsJSONParams{
+			Name:       volume.Name(),
+			Labels:     volume.Labels(),
+			MountPoint: volume.MountPoint(),
+			Driver:     volume.Driver(),
+			Options:    volume.Options(),
+			Scope:      volume.Scope(),
+		}
+
+		lsOutput = append(lsOutput, params)
+	}
+	return lsOutput, nil
+}
+
+// generateVolLsOutput generates the output based on the format, JSON or Go Template, and prints it out
+func generateVolLsOutput(volumes []*libpod.Volume, opts volumeLsOptions, runtime *libpod.Runtime) error {
+	if len(volumes) == 0 && opts.Format != formats.JSONString {
+		return nil
+	}
+	lsOutput, err := getVolJSONParams(volumes, opts, runtime)
+	if err != nil {
+		return err
+	}
+	var out formats.Writer
+
+	switch opts.Format {
+	case formats.JSONString:
+		if err != nil {
+			return errors.Wrapf(err, "unable to create JSON for volume output")
+		}
+		out = formats.JSONStructArray{Output: volLsToGeneric([]volumeLsTemplateParams{}, lsOutput)}
+	default:
+		lsOutput, err := getVolTemplateOutput(lsOutput, opts)
+		if err != nil {
+			return errors.Wrapf(err, "unable to create volume output")
+		}
+		out = formats.StdoutTemplateArray{Output: volLsToGeneric(lsOutput, []volumeLsJSONParams{}), Template: opts.Format, Fields: lsOutput[0].volHeaderMap()}
+	}
+	return formats.Writer(out).Out()
+}
+
+// generateVolumeFilterFuncs returns the true if the volume matches the filter set, otherwise it returns false.
+func generateVolumeFilterFuncs(filter, filterValue string, runtime *libpod.Runtime) (func(volume *libpod.Volume) bool, error) {
+	switch filter {
+	case "name":
+		return func(v *libpod.Volume) bool {
+			return strings.Contains(v.Name(), filterValue)
+		}, nil
+	case "driver":
+		return func(v *libpod.Volume) bool {
+			return v.Driver() == filterValue
+		}, nil
+	case "scope":
+		return func(v *libpod.Volume) bool {
+			return v.Scope() == filterValue
+		}, nil
+	case "label":
+		filterArray := strings.SplitN(filterValue, "=", 2)
+		filterKey := filterArray[0]
+		if len(filterArray) > 1 {
+			filterValue = filterArray[1]
+		} else {
+			filterValue = ""
+		}
+		return func(v *libpod.Volume) bool {
+			for labelKey, labelValue := range v.Labels() {
+				if labelKey == filterKey && ("" == filterValue || labelValue == filterValue) {
+					return true
+				}
+			}
+			return false
+		}, nil
+	case "opt":
+		filterArray := strings.SplitN(filterValue, "=", 2)
+		filterKey := filterArray[0]
+		if len(filterArray) > 1 {
+			filterValue = filterArray[1]
+		} else {
+			filterValue = ""
+		}
+		return func(v *libpod.Volume) bool {
+			for labelKey, labelValue := range v.Options() {
+				if labelKey == filterKey && ("" == filterValue || labelValue == filterValue) {
+					return true
+				}
+			}
+			return false
+		}, nil
+	}
+	return nil, errors.Errorf("%s is an invalid filter", filter)
+}
diff --git a/cmd/podman/volume_prune.go b/cmd/podman/volume_prune.go
new file mode 100644
index 000000000..652c50f42
--- /dev/null
+++ b/cmd/podman/volume_prune.go
@@ -0,0 +1,86 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/containers/libpod/cmd/podman/libpodruntime"
+	"github.com/containers/libpod/libpod"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli"
+)
+
+var volumePruneDescription = `
+podman volume prune
+
+Remove all unused volumes. Will prompt for confirmation if not
+using force.
+`
+
+var volumePruneFlags = []cli.Flag{
+	cli.BoolFlag{
+		Name:  "force, f",
+		Usage: "Do not prompt for confirmation",
+	},
+}
+
+var volumePruneCommand = cli.Command{
+	Name:                   "prune",
+	Usage:                  "Remove all unused volumes",
+	Description:            volumePruneDescription,
+	Flags:                  volumePruneFlags,
+	Action:                 volumePruneCmd,
+	SkipArgReorder:         true,
+	UseShortOptionHandling: true,
+}
+
+func volumePruneCmd(c *cli.Context) error {
+	var lastError error
+
+	if err := validateFlags(c, volumePruneFlags); err != nil {
+		return err
+	}
+
+	runtime, err := libpodruntime.GetRuntime(c)
+	if err != nil {
+		return errors.Wrapf(err, "error creating libpod runtime")
+	}
+	defer runtime.Shutdown(false)
+
+	ctx := getContext()
+
+	// Prompt for confirmation if --force is not set
+	if !c.Bool("force") {
+		reader := bufio.NewReader(os.Stdin)
+		fmt.Println("WARNING! This will remove all volumes not used by at least one container.")
+		fmt.Print("Are you sure you want to continue? [y/N] ")
+		ans, err := reader.ReadString('\n')
+		if err != nil {
+			return errors.Wrapf(err, "error reading input")
+		}
+		if strings.ToLower(ans)[0] != 'y' {
+			return nil
+		}
+	}
+
+	volumes, err := runtime.GetAllVolumes()
+	if err != nil {
+		return err
+	}
+
+	for _, vol := range volumes {
+		err = runtime.RemoveVolume(ctx, vol, false, true)
+		if err == nil {
+			fmt.Println(vol.Name())
+		} else if err != libpod.ErrVolumeBeingUsed {
+			if lastError != nil {
+				logrus.Errorf("%q", lastError)
+			}
+			lastError = errors.Wrapf(err, "failed to remove volume %q", vol.Name())
+		}
+	}
+	return lastError
+}
diff --git a/cmd/podman/volume_rm.go b/cmd/podman/volume_rm.go
new file mode 100644
index 000000000..3fb623624
--- /dev/null
+++ b/cmd/podman/volume_rm.go
@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/containers/libpod/cmd/podman/libpodruntime"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli"
+)
+
+var volumeRmDescription = `
+podman volume rm
+
+Remove one or more existing volumes. Will only remove volumes that are
+not being used by any containers. To remove the volumes anyways, use the
+--force flag.
+`
+
+var volumeRmFlags = []cli.Flag{
+	cli.BoolFlag{
+		Name:  "all, a",
+		Usage: "Remove all volumes",
+	},
+	cli.BoolFlag{
+		Name:  "force, f",
+		Usage: "Remove a volume by force, even if it is being used by a container",
+	},
+}
+
+var volumeRmCommand = cli.Command{
+	Name:                   "rm",
+	Aliases:                []string{"remove"},
+	Usage:                  "Remove one or more volumes",
+	Description:            volumeRmDescription,
+	Flags:                  volumeRmFlags,
+	Action:                 volumeRmCmd,
+	ArgsUsage:              "[VOLUME-NAME ...]",
+	SkipArgReorder:         true,
+	UseShortOptionHandling: true,
+}
+
+func volumeRmCmd(c *cli.Context) error {
+	var err error
+
+	if err = validateFlags(c, volumeRmFlags); err != nil {
+		return err
+	}
+
+	runtime, err := libpodruntime.GetRuntime(c)
+	if err != nil {
+		return errors.Wrapf(err, "error creating libpod runtime")
+	}
+	defer runtime.Shutdown(false)
+
+	ctx := getContext()
+
+	vols, lastError := getVolumesFromContext(c, runtime)
+	for _, vol := range vols {
+		err = runtime.RemoveVolume(ctx, vol, c.Bool("force"), false)
+		if err != nil {
+			if lastError != nil {
+				logrus.Errorf("%q", lastError)
+			}
+			lastError = errors.Wrapf(err, "failed to remove volume %q", vol.Name())
+		} else {
+			fmt.Println(vol.Name())
+		}
+	}
+	return lastError
+}