podmanv2 container subcommands

add container subcommands with example text that has proper context.

Signed-off-by: Brent Baude <bbaude@redhat.com>

cmd/podman/containers/attach.go

@@ -7,6 +7,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -26,6 +27,16 @@ var (
   podman attach 1234
   podman attach --no-stdin foobar`,
 	}
+
+	containerAttachCommand = &cobra.Command{
+		Use:   attachCommand.Use,
+		Short: attachCommand.Short,
+		Long:  attachCommand.Long,
+		RunE:  attachCommand.RunE,
+		Example: `podman container attach ctrID
+	podman container attach 1234
+	podman container attach --no-stdin foobar`,
+	}
 )
 
 var (
@@ -38,6 +49,18 @@ func init() {
 		Command: attachCommand,
 	})
 	flags := attachCommand.Flags()
+	attachFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerAttachCommand,
+		Parent:  containerCmd,
+	})
+	containerAttachFlags := containerAttachCommand.Flags()
+	attachFlags(containerAttachFlags)
+}
+
+func attachFlags(flags *pflag.FlagSet) {
 	flags.StringVar(&attachOpts.DetachKeys, "detach-keys", containerConfig.DetachKeys(), "Select the key sequence for detaching a container. Format is a single character `[a-Z]` or a comma separated sequence of `ctrl-<value>`, where `<value>` is one of: `a-z`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`")
 	flags.BoolVar(&attachOpts.NoStdin, "no-stdin", false, "Do not attach STDIN. The default is false")
 	flags.BoolVar(&attachOpts.SigProxy, "sig-proxy", true, "Proxy received signals to the process")
@@ -47,6 +70,23 @@ func init() {
 	}
 }
 
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: attachCommand,
+	})
+	flags := attachCommand.Flags()
+	attachFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerAttachCommand,
+		Parent:  containerCmd,
+	})
+	containerAttachFlags := containerAttachCommand.Flags()
+	attachFlags(containerAttachFlags)
+}
+
 func attach(cmd *cobra.Command, args []string) error {
 	attachOpts.Stdin = os.Stdin
 	if attachOpts.NoStdin {

cmd/podman/containers/commit.go

@@ -11,6 +11,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -28,6 +29,17 @@ var (
   podman commit containerID`,
 	}
 
+	containerCommitCommand = &cobra.Command{
+		Use:   commitCommand.Use,
+		Short: commitCommand.Short,
+		Long:  commitCommand.Long,
+		RunE:  commitCommand.RunE,
+		Example: `podman container commit -q --message "committing container to image" reverent_golick image-committed
+  podman container commit -q --author "firstName lastName" reverent_golick image-committed
+  podman container commit -q --pause=false containerID image-committed
+  podman container commit containerID`,
+	}
+
 	// ChangeCmds is the list of valid Changes commands to passed to the Commit call
 	ChangeCmds = []string{"CMD", "ENTRYPOINT", "ENV", "EXPOSE", "LABEL", "ONBUILD", "STOPSIGNAL", "USER", "VOLUME", "WORKDIR"}
 )
@@ -39,12 +51,7 @@ var (
 	iidFile string
 )
 
-func init() {
+func commitFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		Command: commitCommand,
-	})
-	flags := commitCommand.Flags()
 	flags.StringArrayVarP(&commitOptions.Changes, "change", "c", []string{}, "Apply the following possible instructions to the created image (default []): "+strings.Join(ChangeCmds, " | "))
 	flags.StringVarP(&commitOptions.Format, "format", "f", "oci", "`Format` of the image manifest and metadata")
 	flags.StringVarP(&iidFile, "iidfile", "", "", "`file` to write the image ID to")
@@ -53,8 +60,25 @@ func init() {
 	flags.BoolVarP(&commitOptions.Pause, "pause", "p", false, "Pause container during commit")
 	flags.BoolVarP(&commitOptions.Quiet, "quiet", "q", false, "Suppress output")
 	flags.BoolVar(&commitOptions.IncludeVolumes, "include-volumes", false, "Include container volumes as image volumes")
-
 }
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: commitCommand,
+	})
+	flags := commitCommand.Flags()
+	commitFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerAttachCommand,
+		Parent:  containerCmd,
+	})
+	containerCommitFlags := containerCommitCommand.Flags()
+	commitFlags(containerCommitFlags)
+}
+
 func commit(cmd *cobra.Command, args []string) error {
 	container := args[0]
 	if len(args) > 1 {

cmd/podman/containers/create.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -27,12 +28,29 @@ var (
   podman create --annotation HELLO=WORLD alpine ls
   podman create -t -i --name myctr alpine ls`,
 	}
+
+	containerCreateCommand = &cobra.Command{
+		Use:   createCommand.Use,
+		Short: createCommand.Short,
+		Long:  createCommand.Long,
+		RunE:  createCommand.RunE,
+		Example: `podman container create alpine ls
+  podman container create --annotation HELLO=WORLD alpine ls
+  podman container create -t -i --name myctr alpine ls`,
+	}
 )
 
 var (
 	cliVals common.ContainerCLIOpts
 )
 
+func createFlags(flags *pflag.FlagSet) {
+	flags.SetInterspersed(false)
+	flags.AddFlagSet(common.GetCreateFlags(&cliVals))
+	flags.AddFlagSet(common.GetNetFlags())
+	flags.SetNormalizeFunc(common.AliasFlags)
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
@@ -40,10 +58,16 @@ func init() {
 	})
 	//common.GetCreateFlags(createCommand)
 	flags := createCommand.Flags()
-	flags.SetInterspersed(false)
+	createFlags(flags)
-	flags.AddFlagSet(common.GetCreateFlags(&cliVals))
+
-	flags.AddFlagSet(common.GetNetFlags())
+	registry.Commands = append(registry.Commands, registry.CliCommand{
-	flags.SetNormalizeFunc(common.AliasFlags)
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerCreateCommand,
+		Parent:  containerCmd,
+	})
+
+	containerCreateFlags := containerCreateCommand.Flags()
+	createFlags(containerCreateFlags)
 }
 
 func create(cmd *cobra.Command, args []string) error {

cmd/podman/containers/exec.go

@@ -9,6 +9,7 @@ import (
 	envLib "github.com/containers/libpod/pkg/env"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -23,6 +24,16 @@ var (
   podman exec -it -w /tmp myCtr pwd
   podman exec --user root ctrID ls`,
 	}
+
+	containerExecCommand = &cobra.Command{
+		Use:   execCommand.Use,
+		Short: execCommand.Short,
+		Long:  execCommand.Long,
+		RunE:  execCommand.RunE,
+		Example: `podman container exec -it ctrID ls
+  podman container exec -it -w /tmp myCtr pwd
+  podman container exec --user root ctrID ls`,
+	}
 )
 
 var (
@@ -30,12 +41,7 @@ var (
 	execOpts          entities.ExecOptions
 )
 
-func init() {
+func execFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode},
-		Command: execCommand,
-	})
-	flags := execCommand.Flags()
 	flags.SetInterspersed(false)
 	flags.StringVar(&execOpts.DetachKeys, "detach-keys", containerConfig.DetachKeys(), "Select the key sequence for detaching a container. Format is a single character [a-Z] or ctrl-<value> where <value> is one of: a-z, @, ^, [, , or _")
 	flags.StringArrayVarP(&envInput, "env", "e", []string{}, "Set environment variables")
@@ -51,8 +57,26 @@ func init() {
 		_ = flags.MarkHidden("latest")
 		_ = flags.MarkHidden("preserve-fds")
 	}
-
 }
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: execCommand,
+	})
+	flags := execCommand.Flags()
+	execFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerExecCommand,
+		Parent:  containerCommitCommand,
+	})
+
+	containerExecFlags := containerExecCommand.Flags()
+	execFlags(containerExecFlags)
+}
+
 func exec(cmd *cobra.Command, args []string) error {
 	var nameOrId string
 	execOpts.Cmd = args

cmd/podman/containers/export.go

@@ -9,6 +9,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"golang.org/x/crypto/ssh/terminal"
 )
 
@@ -25,19 +26,41 @@ var (
 		Example: `podman export ctrID > myCtr.tar
   podman export --output="myCtr.tar" ctrID`,
 	}
+
+	containerExportCommand = &cobra.Command{
+		Use:   exportCommand.Use,
+		Short: exportCommand.Short,
+		Long:  exportCommand.Long,
+		RunE:  exportCommand.RunE,
+		Example: `podman container export ctrID > myCtr.tar
+  podman container export --output="myCtr.tar" ctrID`,
+	}
 )
 
 var (
 	exportOpts entities.ContainerExportOptions
 )
 
+func exportFlags(flags *pflag.FlagSet) {
+	flags.StringVarP(&exportOpts.Output, "output", "o", "", "Write to a specified file (default: stdout, which must be redirected)")
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: exportCommand,
 	})
 	flags := exportCommand.Flags()
-	flags.StringVarP(&exportOpts.Output, "output", "o", "", "Write to a specified file (default: stdout, which must be redirected)")
+	exportFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerExportCommand,
+		Parent:  containerCmd,
+	})
+
+	containerExportFlags := containerExportCommand.Flags()
+	exportFlags(containerExportFlags)
 }
 
 func export(cmd *cobra.Command, args []string) error {

cmd/podman/containers/kill.go

@@ -11,6 +11,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/containers/libpod/pkg/signal"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -27,24 +28,47 @@ var (
   podman kill 860a4b23
   podman kill --signal TERM ctrID`,
 	}
+
+	containerKillCommand = &cobra.Command{
+		Use:   killCommand.Use,
+		Short: killCommand.Short,
+		Long:  killCommand.Long,
+		RunE:  killCommand.RunE,
+		Example: `podman container kill mywebserver
+  podman container kill 860a4b23
+  podman container kill --signal TERM ctrID`,
+	}
 )
 
 var (
 	killOptions = entities.KillOptions{}
 )
 
+func killFlags(flags *pflag.FlagSet) {
+	flags.BoolVarP(&killOptions.All, "all", "a", false, "Signal all running containers")
+	flags.StringVarP(&killOptions.Signal, "signal", "s", "KILL", "Signal to send to the container")
+	flags.BoolVarP(&killOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+	}
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: killCommand,
 	})
 	flags := killCommand.Flags()
-	flags.BoolVarP(&killOptions.All, "all", "a", false, "Signal all running containers")
+	killFlags(flags)
-	flags.StringVarP(&killOptions.Signal, "signal", "s", "KILL", "Signal to send to the container")
+
-	flags.BoolVarP(&killOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	registry.Commands = append(registry.Commands, registry.CliCommand{
-	if registry.IsRemote() {
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		_ = flags.MarkHidden("latest")
+		Command: containerKillCommand,
-	}
+		Parent:  containerCmd,
+	})
+
+	containerKillFlags := containerKillCommand.Flags()
+	killFlags(containerKillFlags)
 }
 
 func kill(cmd *cobra.Command, args []string) error {

cmd/podman/containers/mount.go

@@ -12,6 +12,7 @@ import (
 	"github.com/containers/libpod/cmd/podman/utils"
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -34,22 +35,41 @@ var (
 			registry.ParentNSRequired: "",
 		},
 	}
+
+	containerMountCommmand = &cobra.Command{
+		Use:   mountCommand.Use,
+		Short: mountCommand.Short,
+		Long:  mountCommand.Long,
+		RunE:  mountCommand.RunE,
+	}
 )
 
 var (
 	mountOpts entities.ContainerMountOptions
 )
 
+func mountFlags(flags *pflag.FlagSet) {
+	flags.BoolVarP(&mountOpts.All, "all", "a", false, "Mount all containers")
+	flags.StringVar(&mountOpts.Format, "format", "", "Change the output format to Go template")
+	flags.BoolVarP(&mountOpts.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	flags.BoolVar(&mountOpts.NoTruncate, "notruncate", false, "Do not truncate output")
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode},
 		Command: mountCommand,
 	})
 	flags := mountCommand.Flags()
-	flags.BoolVarP(&mountOpts.All, "all", "a", false, "Mount all containers")
+	mountFlags(flags)
-	flags.StringVar(&mountOpts.Format, "format", "", "Change the output format to Go template")
+
-	flags.BoolVarP(&mountOpts.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	registry.Commands = append(registry.Commands, registry.CliCommand{
-	flags.BoolVar(&mountOpts.NoTruncate, "notruncate", false, "Do not truncate output")
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerMountCommmand,
+		Parent:  containerCmd,
+	})
+	containerMountFlags := containerMountCommmand.Flags()
+	mountFlags(containerMountFlags)
 }
 
 func mount(cmd *cobra.Command, args []string) error {

cmd/podman/containers/pause.go

@@ -10,6 +10,7 @@ import (
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -24,16 +25,38 @@ var (
   podman pause -a`,
 	}
 
+	containerPauseCommand = &cobra.Command{
+		Use:   pauseCommand.Use,
+		Short: pauseCommand.Short,
+		Long:  pauseCommand.Long,
+		RunE:  pauseCommand.RunE,
+		Example: `podman container pause mywebserver
+  podman container pause 860a4b23
+  podman container pause -a`,
+	}
+
 	pauseOpts = entities.PauseUnPauseOptions{}
 )
 
+func pauseFlags(flags *pflag.FlagSet) {
+	flags.BoolVarP(&pauseOpts.All, "all", "a", false, "Pause all running containers")
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: pauseCommand,
 	})
 	flags := pauseCommand.Flags()
-	flags.BoolVarP(&pauseOpts.All, "all", "a", false, "Pause all running containers")
+	pauseFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerPauseCommand,
+		Parent:  containerCmd,
+	})
+	containerPauseFlags := containerPauseCommand.Flags()
+	pauseFlags(containerPauseFlags)
 }
 
 func pause(cmd *cobra.Command, args []string) error {

cmd/podman/containers/restart.go

@@ -11,6 +11,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -30,6 +31,16 @@ var (
   podman restart --latest
   podman restart ctrID1 ctrID2`,
 	}
+
+	containerRestartCommand = &cobra.Command{
+		Use:   restartCommand.Use,
+		Short: restartCommand.Short,
+		Long:  restartCommand.Long,
+		RunE:  restartCommand.RunE,
+		Example: `podman container restart ctrID
+  podman container restart --latest
+  podman container restart ctrID1 ctrID2`,
+	}
 )
 
 var (
@@ -37,12 +48,7 @@ var (
 	restartTimeout uint
 )
 
-func init() {
+func restartFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		Command: restartCommand,
-	})
-	flags := restartCommand.Flags()
 	flags.BoolVarP(&restartOptions.All, "all", "a", false, "Restart all non-running containers")
 	flags.BoolVarP(&restartOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
 	flags.BoolVar(&restartOptions.Running, "running", false, "Restart only running containers when --all is used")
@@ -53,6 +59,24 @@ func init() {
 	flags.SetNormalizeFunc(utils.AliasFlags)
 }
 
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: restartCommand,
+	})
+	flags := restartCommand.Flags()
+	restartFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerRestartCommand,
+		Parent:  containerCmd,
+	})
+
+	containerRestartFlags := containerRestartCommand.Flags()
+	restartFlags(containerRestartFlags)
+}
+
 func restart(cmd *cobra.Command, args []string) error {
 	var (
 		errs utils.OutputErrors

cmd/podman/containers/rm.go

@@ -12,6 +12,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -31,18 +32,24 @@ var (
   podman rm --force --all
   podman rm -f c684f0d469f2`,
 	}
+
+	containerRmCommand = &cobra.Command{
+		Use:   rmCommand.Use,
+		Short: rmCommand.Use,
+		Long:  rmCommand.Long,
+		RunE:  rmCommand.RunE,
+		Example: `podman container rm imageID
+  podman container rm mywebserver myflaskserver 860a4b23
+  podman container rm --force --all
+  podman container rm -f c684f0d469f2`,
+	}
 )
 
 var (
 	rmOptions = entities.RmOptions{}
 )
 
-func init() {
+func rmFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		Command: rmCommand,
-	})
-	flags := rmCommand.Flags()
 	flags.BoolVarP(&rmOptions.All, "all", "a", false, "Remove all containers")
 	flags.BoolVarP(&rmOptions.Ignore, "ignore", "i", false, "Ignore errors when a specified container is missing")
 	flags.BoolVarP(&rmOptions.Force, "force", "f", false, "Force removal of a running or unusable container.  The default is false")
@@ -56,7 +63,24 @@ func init() {
 		_ = flags.MarkHidden("cidfile")
 		_ = flags.MarkHidden("storage")
 	}
+}
 
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: rmCommand,
+	})
+	flags := rmCommand.Flags()
+	rmFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerRmCommand,
+		Parent:  containerCmd,
+	})
+
+	containerRmFlags := containerRmCommand.Flags()
+	rmFlags(containerRmFlags)
 }
 
 func rm(cmd *cobra.Command, args []string) error {

cmd/podman/containers/run.go

@@ -13,6 +13,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -26,6 +27,16 @@ var (
   podman run --network=host imageID dnf -y install java
   podman run --volume /var/hostdir:/var/ctrdir -i -t fedora /bin/bash`,
 	}
+
+	containerRunCommand = &cobra.Command{
+		Use:   runCommand.Use,
+		Short: runCommand.Short,
+		Long:  runCommand.Long,
+		RunE:  runCommand.RunE,
+		Example: `podman container run imageID ls -alF /etc
+  podman container run --network=host imageID dnf -y install java
+  podman container run --volume /var/hostdir:/var/ctrdir -i -t fedora /bin/bash`,
+	}
 )
 
 var (
@@ -37,12 +48,7 @@ var (
 	runRmi bool
 )
 
-func init() {
+func runFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode},
-		Command: runCommand,
-	})
-	flags := runCommand.Flags()
 	flags.SetInterspersed(false)
 	flags.AddFlagSet(common.GetCreateFlags(&cliVals))
 	flags.AddFlagSet(common.GetNetFlags())
@@ -53,6 +59,23 @@ func init() {
 		_ = flags.MarkHidden("authfile")
 	}
 }
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: runCommand,
+	})
+	flags := runCommand.Flags()
+	runFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerRunCommand,
+		Parent:  containerCmd,
+	})
+
+	containerRunFlags := containerRunCommand.Flags()
+	runFlags(containerRunFlags)
+}
 
 func run(cmd *cobra.Command, args []string) error {
 	var err error

cmd/podman/containers/start.go

@@ -10,6 +10,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -24,18 +25,23 @@ var (
   podman start 860a4b231279 5421ab43b45
   podman start --interactive --attach imageID`,
 	}
+
+	containerStartCommand = &cobra.Command{
+		Use:   startCommand.Use,
+		Short: startCommand.Short,
+		Long:  startCommand.Long,
+		RunE:  startCommand.RunE,
+		Example: `podman container start --latest
+  podman container start 860a4b231279 5421ab43b45
+  podman container start --interactive --attach imageID`,
+	}
 )
 
 var (
 	startOptions entities.ContainerStartOptions
 )
 
-func init() {
+func startFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode},
-		Command: startCommand,
-	})
-	flags := startCommand.Flags()
 	flags.BoolVarP(&startOptions.Attach, "attach", "a", false, "Attach container's STDOUT and STDERR")
 	flags.StringVar(&startOptions.DetachKeys, "detach-keys", containerConfig.DetachKeys(), "Select the key sequence for detaching a container. Format is a single character `[a-Z]` or a comma separated sequence of `ctrl-<value>`, where `<value>` is one of: `a-z`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`")
 	flags.BoolVarP(&startOptions.Interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
@@ -45,7 +51,23 @@ func init() {
 		_ = flags.MarkHidden("latest")
 		_ = flags.MarkHidden("sig-proxy")
 	}
+}
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: startCommand,
+	})
+	flags := startCommand.Flags()
+	startFlags(flags)
 
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerStartCommand,
+		Parent:  containerCmd,
+	})
+
+	containerStartFlags := containerRunCommand.Flags()
+	startFlags(containerStartFlags)
 }
 
 func start(cmd *cobra.Command, args []string) error {

cmd/podman/containers/stop.go

@@ -9,6 +9,7 @@ import (
 	"github.com/containers/libpod/cmd/podman/utils"
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -27,6 +28,16 @@ var (
   podman stop --latest
   podman stop --time 2 mywebserver 6e534f14da9d`,
 	}
+
+	containerStopCommand = &cobra.Command{
+		Use:   stopCommand.Use,
+		Short: stopCommand.Short,
+		Long:  stopCommand.Long,
+		RunE:  stopCommand.RunE,
+		Example: `podman container stop ctrID
+  podman container stop --latest
+  podman container stop --time 2 mywebserver 6e534f14da9d`,
+	}
 )
 
 var (
@@ -34,12 +45,7 @@ var (
 	stopTimeout uint
 )
 
-func init() {
+func stopFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		Command: stopCommand,
-	})
-	flags := stopCommand.Flags()
 	flags.BoolVarP(&stopOptions.All, "all", "a", false, "Stop all running containers")
 	flags.BoolVarP(&stopOptions.Ignore, "ignore", "i", false, "Ignore errors when a specified container is missing")
 	flags.StringArrayVarP(&stopOptions.CIDFiles, "cidfile", "", nil, "Read the container ID from the file")
@@ -54,6 +60,24 @@ func init() {
 	flags.SetNormalizeFunc(utils.AliasFlags)
 }
 
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: stopCommand,
+	})
+	flags := stopCommand.Flags()
+	stopFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerStopCommand,
+		Parent:  containerCmd,
+	})
+
+	containerStopFlags := containerStopCommand.Flags()
+	stopFlags(containerStopFlags)
+}
+
 func stop(cmd *cobra.Command, args []string) error {
 	var (
 		errs utils.OutputErrors

cmd/podman/containers/top.go

@@ -12,6 +12,7 @@ import (
 	"github.com/containers/psgo"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -36,23 +37,44 @@ podman top --latest
 podman top ctrID pid seccomp args %C
 podman top ctrID -eo user,pid,comm`,
 	}
+
+	containerTopCommand = &cobra.Command{
+		Use:   topCommand.Use,
+		Short: topCommand.Short,
+		Long:  topCommand.Long,
+		RunE:  topCommand.RunE,
+		Example: `podman container top ctrID
+podman container top --latest
+podman container top ctrID pid seccomp args %C
+podman container top ctrID -eo user,pid,comm`,
+	}
 )
 
+func topFlags(flags *pflag.FlagSet) {
+	flags.SetInterspersed(false)
+	flags.BoolVar(&topOptions.ListDescriptors, "list-descriptors", false, "")
+	flags.BoolVarP(&topOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	_ = flags.MarkHidden("list-descriptors") // meant only for bash completion
+	if registry.IsRemote() {
+		_ = flags.MarkHidden("latest")
+	}
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: topCommand,
 	})
-
 	flags := topCommand.Flags()
-	flags.SetInterspersed(false)
+	topFlags(flags)
-	flags.BoolVar(&topOptions.ListDescriptors, "list-descriptors", false, "")
-	flags.BoolVarP(&topOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
 
-	_ = flags.MarkHidden("list-descriptors") // meant only for bash completion
+	registry.Commands = append(registry.Commands, registry.CliCommand{
-	if registry.IsRemote() {
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		_ = flags.MarkHidden("latest")
+		Command: containerTopCommand,
-	}
+		Parent:  containerCmd,
+	})
+	containerTopFlags := containerTopCommand.Flags()
+	topFlags(containerTopFlags)
 }
 
 func top(cmd *cobra.Command, args []string) error {

cmd/podman/containers/unmount.go

@@ -8,6 +8,7 @@ import (
 	"github.com/containers/libpod/cmd/podman/utils"
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -30,21 +31,44 @@ var (
   podman umount ctrID1 ctrID2 ctrID3
   podman umount --all`,
 	}
+
+	containerUnmountCommand = &cobra.Command{
+		Use:   umountCommand.Use,
+		Short: umountCommand.Short,
+		Long:  umountCommand.Long,
+		RunE:  umountCommand.RunE,
+		Example: `podman container umount ctrID
+  podman container umount ctrID1 ctrID2 ctrID3
+  podman container umount --all`,
+	}
 )
 
 var (
 	unmountOpts entities.ContainerUnmountOptions
 )
 
+func umountFlags(flags *pflag.FlagSet) {
+	flags.BoolVarP(&unmountOpts.All, "all", "a", false, "Umount all of the currently mounted containers")
+	flags.BoolVarP(&unmountOpts.Force, "force", "f", false, "Force the complete umount all of the currently mounted containers")
+	flags.BoolVarP(&unmountOpts.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode},
 		Command: umountCommand,
 	})
 	flags := umountCommand.Flags()
-	flags.BoolVarP(&unmountOpts.All, "all", "a", false, "Umount all of the currently mounted containers")
+	umountFlags(flags)
-	flags.BoolVarP(&unmountOpts.Force, "force", "f", false, "Force the complete umount all of the currently mounted containers")
+
-	flags.BoolVarP(&unmountOpts.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: containerUnmountCommand,
+		Parent:  containerCmd,
+	})
+
+	containerUmountFlags := containerUnmountCommand.Flags()
+	umountFlags(containerUmountFlags)
 }
 
 func unmount(cmd *cobra.Command, args []string) error {

cmd/podman/containers/unpause.go

@@ -10,6 +10,7 @@ import (
 	"github.com/containers/libpod/pkg/rootless"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -23,16 +24,37 @@ var (
   podman unpause --all`,
 	}
 	unPauseOptions = entities.PauseUnPauseOptions{}
+
+	containerUnpauseCommand = &cobra.Command{
+		Use:   unpauseCommand.Use,
+		Short: unpauseCommand.Short,
+		Long:  unpauseCommand.Long,
+		RunE:  unpauseCommand.RunE,
+		Example: `podman container unpause ctrID
+  podman container unpause --all`,
+	}
 )
 
+func unpauseFlags(flags *pflag.FlagSet) {
+	flags.BoolVarP(&unPauseOptions.All, "all", "a", false, "Pause all running containers")
+}
+
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: unpauseCommand,
-		Parent:  containerCmd,
 	})
 	flags := unpauseCommand.Flags()
-	flags.BoolVarP(&unPauseOptions.All, "all", "a", false, "Pause all running containers")
+	unpauseFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: unpauseCommand,
+		Parent:  containerCmd,
+	})
+
+	unpauseCommandFlags := containerUnpauseCommand.Flags()
+	unpauseFlags(unpauseCommandFlags)
 }
 
 func unpause(cmd *cobra.Command, args []string) error {

cmd/podman/containers/wait.go

@@ -11,6 +11,7 @@ import (
 	"github.com/containers/libpod/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 var (
@@ -26,6 +27,16 @@ var (
   podman wait --interval 5000 ctrID
   podman wait ctrID1 ctrID2`,
 	}
+
+	containerWaitCommand = &cobra.Command{
+		Use:   waitCommand.Use,
+		Short: waitCommand.Short,
+		Long:  waitCommand.Long,
+		RunE:  waitCommand.RunE,
+		Example: `podman container wait --latest
+  podman container wait --interval 5000 ctrID
+  podman container wait ctrID1 ctrID2`,
+	}
 )
 
 var (
@@ -33,13 +44,7 @@ var (
 	waitCondition string
 )
 
-func init() {
+func waitFlags(flags *pflag.FlagSet) {
-	registry.Commands = append(registry.Commands, registry.CliCommand{
-		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
-		Command: waitCommand,
-	})
-
-	flags := waitCommand.Flags()
 	flags.DurationVarP(&waitOptions.Interval, "interval", "i", time.Duration(250), "Milliseconds to wait before polling for completion")
 	flags.BoolVarP(&waitOptions.Latest, "latest", "l", false, "Act on the latest container podman is aware of")
 	flags.StringVar(&waitCondition, "condition", "stopped", "Condition to wait on")
@@ -49,6 +54,24 @@ func init() {
 	}
 }
 
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: waitCommand,
+	})
+	flags := waitCommand.Flags()
+	waitFlags(flags)
+
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: containerWaitCommand,
+		Parent:  containerCmd,
+	})
+
+	containerWaitFlags := containerWaitCommand.Flags()
+	waitFlags(containerWaitFlags)
+}
+
 func wait(cmd *cobra.Command, args []string) error {
 	var (
 		err  error