Add shell completion with cobra

Allow automatic generation for shell completion scripts
with the internal cobra functions (requires v1.0.0+).

This should replace the handwritten completion scripts
and even adds support for fish. With this approach it is
less likley that completions and code are out of sync.

We can now create the scripts with
- podman completion bash
- podman completion zsh
- podman completion fish

To test the completion run:
source <(podman completion bash)

The same works for podman-remote and podman --remote and
it will complete your remote containers/images with
the correct endpoints values from --url/--connection.

The completion logic is written in go and provided by the
cobra library. The completion functions lives in
`cmd/podman/completion/completion.go`.

The unit test at cmd/podman/shell_completion_test.go checks
if each command and flag has an autocompletion function set.
This prevents that commands and flags have no shell completion set.

This commit does not replace the current autocompletion scripts.

Closes #6440

Signed-off-by: Paul Holzinger <paul.holzinger@web.de>

cmd/podman/auto-update.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/errorhandling"
@@ -20,10 +21,11 @@ var (
   or similar units that create new containers in order to run the updated images.
   Please refer to the podman-auto-update(1) man page for details.`
 	autoUpdateCommand = &cobra.Command{
-		Use:   "auto-update [options]",
-		Short: "Auto update containers according to their auto-update policy",
-		Long:  autoUpdateDescription,
-		RunE:  autoUpdate,
+		Use:               "auto-update [options]",
+		Short:             "Auto update containers according to their auto-update policy",
+		Long:              autoUpdateDescription,
+		RunE:              autoUpdate,
+		ValidArgsFunction: completion.AutocompleteNone,
 		Example: `podman auto-update
   podman auto-update --authfile ~/authfile.json`,
 	}
@@ -36,7 +38,10 @@ func init() {
 	})
 
 	flags := autoUpdateCommand.Flags()
-	flags.StringVar(&autoUpdateOptions.Authfile, "authfile", auth.GetDefaultAuthFile(), "Path to the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&autoUpdateOptions.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "Path to the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = autoUpdateCommand.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
 }
 
 func autoUpdate(cmd *cobra.Command, args []string) error {

cmd/podman/common/completion.go

@@ -0,0 +1,638 @@
+package common
+
+import (
+	"bufio"
+	"os"
+	"strings"
+
+	"github.com/containers/common/pkg/config"
+	"github.com/containers/podman/v2/cmd/podman/registry"
+	"github.com/containers/podman/v2/libpod"
+	"github.com/containers/podman/v2/libpod/define"
+	"github.com/containers/podman/v2/pkg/domain/entities"
+	"github.com/containers/podman/v2/pkg/registries"
+	systemdGen "github.com/containers/podman/v2/pkg/systemd/generate"
+	"github.com/spf13/cobra"
+)
+
+var (
+	// ChangeCmds is the list of valid Change commands to passed to the Commit call
+	ChangeCmds = []string{"CMD", "ENTRYPOINT", "ENV", "EXPOSE", "LABEL", "ONBUILD", "STOPSIGNAL", "USER", "VOLUME", "WORKDIR"}
+	// LogLevels supported by podman
+	LogLevels = []string{"debug", "info", "warn", "error", "fatal", "panic"}
+)
+
+func getContainers(status string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	suggestions := []string{}
+	listOpts := entities.ContainerListOptions{
+		Filters: make(map[string][]string),
+	}
+	listOpts.All = true
+
+	if status != "all" {
+		listOpts.Filters = map[string][]string{"status": {status}}
+	}
+
+	containers, err := registry.ContainerEngine().ContainerList(registry.GetContext(), listOpts)
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	for _, container := range containers {
+		// include ids in suggestions if more then 2 chars are typed
+		if len(toComplete) > 1 {
+			suggestions = append(suggestions, container.ID[0:12])
+		}
+		// include name in suggestions
+		suggestions = append(suggestions, container.Names...)
+	}
+	return suggestions, cobra.ShellCompDirectiveNoFileComp
+}
+
+func getPods(status string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	suggestions := []string{}
+	listOpts := entities.PodPSOptions{
+		Filters: make(map[string][]string),
+	}
+
+	if status != "all" {
+		listOpts.Filters = map[string][]string{"status": {status}}
+	}
+
+	pods, err := registry.ContainerEngine().PodPs(registry.GetContext(), listOpts)
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	for _, pod := range pods {
+		// include ids in suggestions if more then 2 chars are typed
+		if len(toComplete) > 1 {
+			suggestions = append(suggestions, pod.Id[0:12])
+		}
+		// include name in suggestions
+		suggestions = append(suggestions, pod.Name)
+	}
+	return suggestions, cobra.ShellCompDirectiveNoFileComp
+}
+
+func getVolumes() ([]string, cobra.ShellCompDirective) {
+	suggestions := []string{}
+	lsOpts := entities.VolumeListOptions{}
+
+	volumes, err := registry.ContainerEngine().VolumeList(registry.GetContext(), lsOpts)
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	for _, volume := range volumes {
+		suggestions = append(suggestions, volume.Name)
+	}
+	return suggestions, cobra.ShellCompDirectiveNoFileComp
+}
+
+func getImages(toComplete string) ([]string, cobra.ShellCompDirective) {
+	suggestions := []string{}
+	listOptions := entities.ImageListOptions{}
+
+	images, err := registry.ImageEngine().List(registry.GetContext(), listOptions)
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	for _, image := range images {
+		// FIXME: need ux testing
+		// discuss when image ids should be completed
+		// include ids in suggestions if more then 2 chars are typed
+		if len(toComplete) > 1 {
+			suggestions = append(suggestions, image.ID[0:12])
+		}
+		for _, repo := range image.RepoTags {
+			if toComplete == "" {
+				// suggest only full repo path if no input is given
+				suggestions = append(suggestions, repo)
+			} else {
+				// suggested "registry.fedoraproject.org/f29/httpd:latest" as
+				// - "registry.fedoraproject.org/f29/httpd:latest"
+				// - "registry.fedoraproject.org/f29/httpd"
+				// - "f29/httpd:latest"
+				// - "f29/httpd"
+				// - "httpd:latest"
+				// - "httpd"
+				paths := strings.Split(repo, "/")
+				for i := range paths {
+					suggestionWithTag := strings.Join(paths[i:], "/")
+					suggestionWithoutTag := strings.SplitN(strings.SplitN(suggestionWithTag, ":", 2)[0], "@", 2)[0]
+					suggestions = append(suggestions, suggestionWithTag, suggestionWithoutTag)
+				}
+			}
+		}
+	}
+	return suggestions, cobra.ShellCompDirectiveNoFileComp
+}
+
+func getRegistries() ([]string, cobra.ShellCompDirective) {
+	regs, err := registries.GetRegistries()
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+	return regs, cobra.ShellCompDirectiveNoFileComp
+}
+
+func getNetworks() ([]string, cobra.ShellCompDirective) {
+	suggestions := []string{}
+	networkListOptions := entities.NetworkListOptions{}
+
+	networks, err := registry.ContainerEngine().NetworkList(registry.Context(), networkListOptions)
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	for _, network := range networks {
+		suggestions = append(suggestions, network.Name)
+	}
+	return suggestions, cobra.ShellCompDirectiveNoFileComp
+}
+
+/* Autocomplete Functions for cobra ValidArgsFunction */
+
+// AutocompleteContainers - Autocomplete all container names.
+func AutocompleteContainers(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getContainers("all", toComplete)
+}
+
+// AutocompleteContainersCreated - Autocomplete only created container names.
+func AutocompleteContainersCreated(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getContainers("created", toComplete)
+}
+
+// AutocompleteContainersExited - Autocomplete only exited container names.
+func AutocompleteContainersExited(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getContainers("exited", toComplete)
+}
+
+// AutocompleteContainersPaused - Autocomplete only paused container names.
+func AutocompleteContainersPaused(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getContainers("paused", toComplete)
+}
+
+// AutocompleteContainersRunning - Autocomplete only running container names.
+func AutocompleteContainersRunning(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getContainers("running", toComplete)
+}
+
+// AutocompleteContainersStartable - Autocomplete only created and exited container names.
+func AutocompleteContainersStartable(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	containersCreated, _ := getContainers("created", toComplete)
+	containersExited, _ := getContainers("exited", toComplete)
+	return append(containersCreated, containersExited...), cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompletePods - Autocomplete all pod names.
+func AutocompletePods(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getPods("all", toComplete)
+}
+
+// AutocompletePodsRunning - Autocomplete only running pod names.
+func AutocompletePodsRunning(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getPods("running", toComplete)
+}
+
+// AutocompleteContainersAndPods - Autocomplete container names and pod names.
+func AutocompleteContainersAndPods(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	containers, _ := getContainers("all", toComplete)
+	pods, _ := getPods("all", toComplete)
+	return append(containers, pods...), cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteContainersAndImages - Autocomplete container names and pod names.
+func AutocompleteContainersAndImages(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	containers, _ := getContainers("all", toComplete)
+	images, _ := getImages(toComplete)
+	return append(containers, images...), cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteVolumes - Autocomplete volumes.
+func AutocompleteVolumes(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getVolumes()
+}
+
+// AutocompleteImages - Autocomplete images.
+func AutocompleteImages(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getImages(toComplete)
+}
+
+// AutocompleteCreateRun - Autocomplete only the fist argument as image and then do file completion.
+func AutocompleteCreateRun(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if len(args) < 1 {
+		return getImages(toComplete)
+	}
+	// TODO: add path completion for files in the image
+	return nil, cobra.ShellCompDirectiveDefault
+}
+
+// AutocompleteRegistries - Autocomplete registries.
+func AutocompleteRegistries(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getRegistries()
+}
+
+// AutocompleteNetworks - Autocomplete networks.
+func AutocompleteNetworks(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return getNetworks()
+}
+
+// AutocompleteCpCommand - Autocomplete podman cp command args.
+func AutocompleteCpCommand(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if len(args) < 2 {
+		containers, _ := getContainers("all", toComplete)
+		for _, container := range containers {
+			// TODO: Add path completion for inside the container if possible
+			if strings.HasPrefix(container, toComplete) {
+				return containers, cobra.ShellCompDirectiveNoSpace
+			}
+		}
+		// else complete paths
+		return nil, cobra.ShellCompDirectiveDefault
+	}
+	// don't complete more than 2 args
+	return nil, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteSystemConnections - Autocomplete system connections.
+func AutocompleteSystemConnections(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	suggestions := []string{}
+	cfg, err := config.ReadCustomConfig()
+	if err != nil {
+		cobra.CompErrorln(err.Error())
+		return nil, cobra.ShellCompDirectiveError
+	}
+
+	for k, v := range cfg.Engine.ServiceDestinations {
+		// the URI will be show as description in shells like zsh
+		suggestions = append(suggestions, k+"\t"+v.URI)
+	}
+
+	return suggestions, cobra.ShellCompDirectiveNoFileComp
+}
+
+/* -------------- Flags ----------------- */
+
+// AutocompleteDetachKeys - Autocomplete detach-keys options.
+// -> "ctrl-"
+func AutocompleteDetachKeys(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if strings.HasSuffix(toComplete, ",") {
+		return []string{toComplete + "ctrl-"}, cobra.ShellCompDirectiveNoSpace
+	}
+	return []string{"ctrl-"}, cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompleteChangeInstructions - Autocomplete change instructions options for commit and import.
+// -> "CMD", "ENTRYPOINT", "ENV", "EXPOSE", "LABEL", "ONBUILD", "STOPSIGNAL", "USER", "VOLUME", "WORKDIR"
+func AutocompleteChangeInstructions(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return ChangeCmds, cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompleteImageFormat - Autocomplete image format options.
+// -> "oci", "docker"
+func AutocompleteImageFormat(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	ImageFormat := []string{"oci", "docker"}
+	return ImageFormat, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteCreateAttach - Autocomplete create --attach options.
+// -> "stdin", "stdout", "stderr"
+func AutocompleteCreateAttach(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return []string{"stdin", "stdout", "stderr"}, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteNamespace - Autocomplete namespace options.
+// -> host,container:[name],ns:[path],private
+func AutocompleteNamespace(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	namespacesOptions := []string{"host", "container:", "ns:", "private"}
+
+	switch {
+	case strings.HasPrefix(toComplete, "container:"):
+		// Complete containers after colon
+		containers, _ := getContainers("all", toComplete[10:]) //trim "container:"
+
+		// add "container:" in front of the suggestions
+		var suggestions []string
+		for _, container := range containers {
+			suggestions = append(suggestions, "container:"+container)
+		}
+
+		return suggestions, cobra.ShellCompDirectiveNoFileComp
+
+	case strings.HasPrefix(toComplete, "ns:"):
+		// Complete path after colon
+		return nil, cobra.ShellCompDirectiveDefault
+
+	case strings.HasPrefix(toComplete, "c") || strings.HasPrefix(toComplete, "n"):
+		// don't insert space for container: and ns:
+		return []string{"container:", "ns:"}, cobra.ShellCompDirectiveNoSpace
+	}
+	return namespacesOptions, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteUserNamespace - Autocomplete namespace options.
+// -> same as AutocompleteNamespace with "auto", "keep-id" added
+func AutocompleteUserNamespace(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	results, directive := AutocompleteNamespace(cmd, args, toComplete)
+	if directive == cobra.ShellCompDirectiveNoFileComp {
+		// add the auto and keep-id options
+		results = append(results, "auto", "keep-id")
+	}
+	return results, directive
+}
+
+// AutocompleteCgroupMode - Autocomplete cgroup mode options.
+// -> "enabled", "disabled", "no-conmon", "split"
+func AutocompleteCgroupMode(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	cgroupModes := []string{"enabled", "disabled", "no-conmon", "split"}
+	return cgroupModes, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteImageVolume - Autocomplete image volume options.
+// -> "bind", "tmpfs", "ignore"
+func AutocompleteImageVolume(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	imageVolumes := []string{"bind", "tmpfs", "ignore"}
+	return imageVolumes, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteLogDriver - Autocomplete log-driver options.
+// -> "journald", "none", "k8s-file"
+func AutocompleteLogDriver(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	// don't show json-file
+	logDrivers := []string{define.JournaldLogging, define.NoLogging, define.KubernetesLogging}
+	return logDrivers, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteLogOpt - Autocomplete log-opt options.
+// -> "path=", "tag="
+func AutocompleteLogOpt(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	// FIXME: are these the only one? the man page states these but in the current shell completion they are more options
+	logOptions := []string{"path=", "tag="}
+	if strings.HasPrefix(toComplete, "path=") {
+		return nil, cobra.ShellCompDirectiveDefault
+	}
+	return logOptions, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompletePullOption - Autocomplete pull options for create and run command.
+// -> "always", "missing", "never"
+func AutocompletePullOption(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	pullOptions := []string{"always", "missing", "never"}
+	return pullOptions, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteRestartOption - Autocomplete restart options for create and run command.
+// -> "always", "no", "on-failure", "unless-stopped"
+func AutocompleteRestartOption(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	restartOptions := []string{libpod.RestartPolicyAlways, libpod.RestartPolicyNo,
+		libpod.RestartPolicyOnFailure, libpod.RestartPolicyUnlessStopped}
+	return restartOptions, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteSecurityOption - Autocomplete security options options.
+func AutocompleteSecurityOption(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	SecurityOptions := []string{"apparmor=", "no-new-privileges", "seccomp=", "label="}
+	switch {
+	case strings.HasPrefix(toComplete, "apparmor=u"):
+		// add space after unconfined
+		return []string{"apparmor=unconfined"}, cobra.ShellCompDirectiveNoFileComp
+
+	case strings.HasPrefix(toComplete, "label=d"):
+		// add space after disable
+		return []string{"label=disable"}, cobra.ShellCompDirectiveNoFileComp
+
+	case strings.HasPrefix(toComplete, "label="):
+		return []string{"label=user:", "label=role:", "label=type:", "label=level:", "label=filetype:", "label=disable"},
+			cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveNoSpace
+
+	case strings.HasPrefix(toComplete, "seccomp="):
+		// complete files
+		return nil, cobra.ShellCompDirectiveDefault
+
+	case strings.HasPrefix(toComplete, "n"):
+		// add space if no-new-privileges
+		return []string{"no-new-privileges"}, cobra.ShellCompDirectiveNoFileComp
+	}
+	return SecurityOptions, cobra.ShellCompDirectiveNoFileComp | cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompleteStopSignal - Autocomplete stop signal options.
+// -> "SIGHUP", "SIGINT", "SIGKILL", "SIGTERM"
+func AutocompleteStopSignal(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	// FIXME: add more/different signals?
+	stopSignals := []string{"SIGHUP", "SIGINT", "SIGKILL", "SIGTERM"}
+	return stopSignals, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteSystemdFlag - Autocomplete systemd flag options.
+// -> "true", "false", "always"
+func AutocompleteSystemdFlag(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	systemd := []string{"true", "false", "always"}
+	return systemd, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteUserFlag - Autocomplete user flag based on the names and groups (includes ids after first char) in /etc/passwd and /etc/group files.
+// -> user:group
+func AutocompleteUserFlag(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	if strings.Contains(toComplete, ":") {
+		// It would be nice to read the file in the image
+		// but at this point we don't know the image.
+		file, err := os.Open("/etc/group")
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveError
+		}
+		defer file.Close()
+
+		var groups []string
+		scanner := bufio.NewScanner(file)
+		user := strings.SplitN(toComplete, ":", 2)[0]
+		for scanner.Scan() {
+			entries := strings.SplitN(scanner.Text(), ":", 4)
+			groups = append(groups, user+":"+entries[0])
+			// complete ids after at least one char is given
+			if len(user)+1 < len(toComplete) {
+				groups = append(groups, user+":"+entries[2])
+			}
+		}
+		if err = scanner.Err(); err != nil {
+			return nil, cobra.ShellCompDirectiveError
+		}
+		return groups, cobra.ShellCompDirectiveNoFileComp
+	}
+
+	// It would be nice to read the file in the image
+	// but at this point we don't know the image.
+	file, err := os.Open("/etc/passwd")
+	if err != nil {
+		return nil, cobra.ShellCompDirectiveError
+	}
+	defer file.Close()
+
+	var users []string
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		entries := strings.SplitN(scanner.Text(), ":", 7)
+		users = append(users, entries[0]+":")
+		// complete ids after at least one char is given
+		if len(toComplete) > 0 {
+			users = append(users, entries[2]+":")
+		}
+	}
+	if err = scanner.Err(); err != nil {
+		return nil, cobra.ShellCompDirectiveError
+	}
+	return users, cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompleteMountFlag - Autocomplete mount flag options.
+// -> "type=bind,", "type=volume,", "type=tmpfs,"
+func AutocompleteMountFlag(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"type=bind,", "type=volume,", "type=tmpfs,"}
+	// TODO: Add support for all different options
+	return types, cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompleteVolumeFlag - Autocomplete volume flag options.
+// -> volumes and paths
+func AutocompleteVolumeFlag(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	result := []string{}
+	volumes, _ := getVolumes()
+	for _, volume := range volumes {
+		// If we don't filter on "toComplete", zsh and fish will not do file completion
+		// even if the prefix typed by the user does not match the returned completions
+		if strings.HasPrefix(volume, toComplete) {
+			result = append(result, volume)
+		}
+	}
+	directive := cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveDefault
+	if strings.Contains(toComplete, ":") {
+		// add space after second path
+		directive = cobra.ShellCompDirectiveDefault
+	}
+	return result, directive
+}
+
+// AutocompleteJSONFormat - Autocomplete format flag option.
+// -> "json"
+func AutocompleteJSONFormat(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return []string{"json"}, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteEventFilter - Autocomplete event filter flag options.
+// -> "container=", "event=", "image=", "pod=", "volume=", "type="
+func AutocompleteEventFilter(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	filters := []string{"container=", "event=", "image=", "pod=", "volume=", "type="}
+	return filters, cobra.ShellCompDirectiveNoSpace
+}
+
+// AutocompleteSystemdRestartOptions - Autocomplete systemd restart options.
+// -> "no", "on-success", "on-failure", "on-abnormal", "on-watchdog", "on-abort", "always"
+func AutocompleteSystemdRestartOptions(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return systemdGen.RestartPolicies, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteTrustType - Autocomplete trust type options.
+// -> "signedBy", "accept", "reject"
+func AutocompleteTrustType(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"signedBy", "accept", "reject"}
+	return types, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteImageSort - Autocomplete images sort options.
+// -> "created", "id", "repository", "size", "tag"
+func AutocompleteImageSort(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	sortBy := []string{"created", "id", "repository", "size", "tag"}
+	return sortBy, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteInspectType - Autocomplete inspect type options.
+// -> "container", "image", "all"
+func AutocompleteInspectType(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"container", "image", "all"}
+	return types, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteManifestFormat - Autocomplete manifest format options.
+// -> "oci", "v2s2"
+func AutocompleteManifestFormat(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"oci", "v2s2"}
+	return types, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteNetworkDriver - Autocomplete network driver option.
+// -> "bridge"
+func AutocompleteNetworkDriver(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	drivers := []string{"bridge"}
+	return drivers, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompletePodShareNamespace - Autocomplete pod create --share flag option.
+// -> "ipc", "net", "pid", "user", "uts", "cgroup", "none"
+func AutocompletePodShareNamespace(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	namespaces := []string{"ipc", "net", "pid", "user", "uts", "cgroup", "none"}
+	return namespaces, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompletePodPsSort - Autocomplete images sort options.
+// -> "created", "id", "name", "status", "number"
+func AutocompletePodPsSort(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	sortBy := []string{"created", "id", "name", "status", "number"}
+	return sortBy, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompletePsSort - Autocomplete images sort options.
+// -> "command", "created", "id", "image", "names", "runningfor", "size", "status"
+func AutocompletePsSort(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	sortBy := []string{"command", "created", "id", "image", "names", "runningfor", "size", "status"}
+	return sortBy, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteImageSaveFormat - Autocomplete image save format options.
+// -> "oci-archive", "oci-dir", "docker-dir"
+func AutocompleteImageSaveFormat(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	formats := []string{"oci-archive", "oci-dir", "docker-dir"}
+	return formats, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteWaitCondition - Autocomplete wait condition options.
+// -> "unknown", "configured", "created", "running", "stopped", "paused", "exited", "removing"
+func AutocompleteWaitCondition(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	states := []string{"unknown", "configured", "created", "running", "stopped", "paused", "exited", "removing"}
+	return states, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteCgroupManager - Autocomplete cgroup manager options.
+// -> "cgroupfs", "systemd"
+func AutocompleteCgroupManager(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"cgroupfs", "systemd"}
+	return types, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteEventBackend - Autocomplete event backend options.
+// -> "file", "journald", "none"
+func AutocompleteEventBackend(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"file", "journald", "none"}
+	return types, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteLogLevel - Autocomplete log level options.
+// -> "debug", "info", "warn", "error", "fatal", "panic"
+func AutocompleteLogLevel(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	return LogLevels, cobra.ShellCompDirectiveNoFileComp
+}
+
+// AutocompleteSDNotify - Autocomplete sdnotify options.
+// -> "container", "conmon", "ignore"
+func AutocompleteSDNotify(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	types := []string{"container", "conmon", "ignore"}
+	return types, cobra.ShellCompDirectiveNoFileComp
+}

cmd/podman/common/create.go

@@ -5,296 +5,457 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/libpod/define"
-	"github.com/spf13/pflag"
+	"github.com/spf13/cobra"
 )
 
 const sizeWithUnitFormat = "(format: `<number>[<unit>]`, where unit = b (bytes), k (kilobytes), m (megabytes), or g (gigabytes))"
 
 var containerConfig = registry.PodmanConfig()
 
-func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
-	createFlags := pflag.FlagSet{}
+func DefineCreateFlags(cmd *cobra.Command, cf *ContainerCLIOpts) {
+	createFlags := cmd.Flags()
+
+	annotationFlagName := "annotation"
 	createFlags.StringSliceVar(
 		&cf.Annotation,
-		"annotation", []string{},
+		annotationFlagName, []string{},
 		"Add annotations to container (key:value)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(annotationFlagName, completion.AutocompleteNone)
+
+	attachFlagName := "attach"
 	createFlags.StringSliceVarP(
 		&cf.Attach,
-		"attach", "a", []string{},
+		attachFlagName, "a", []string{},
 		"Attach to STDIN, STDOUT or STDERR",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(attachFlagName, AutocompleteCreateAttach)
+
+	authfileFlagName := "authfile"
 	createFlags.StringVar(
 		&cf.Authfile,
-		"authfile", auth.GetDefaultAuthFile(),
+		authfileFlagName, auth.GetDefaultAuthFile(),
 		"Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
+
+	blkioWeightFlagName := "blkio-weight"
 	createFlags.StringVar(
 		&cf.BlkIOWeight,
-		"blkio-weight", "",
+		blkioWeightFlagName, "",
 		"Block IO weight (relative weight) accepts a weight value between 10 and 1000.",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(blkioWeightFlagName, completion.AutocompleteNone)
+
+	blkioWeightDeviceFlagName := "blkio-weight-device"
 	createFlags.StringSliceVar(
 		&cf.BlkIOWeightDevice,
-		"blkio-weight-device", []string{},
+		blkioWeightDeviceFlagName, []string{},
 		"Block IO weight (relative device weight, format: `DEVICE_NAME:WEIGHT`)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(blkioWeightDeviceFlagName, completion.AutocompleteDefault)
+
+	capAddFlagName := "cap-add"
 	createFlags.StringSliceVar(
 		&cf.CapAdd,
-		"cap-add", []string{},
+		capAddFlagName, []string{},
 		"Add capabilities to the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(capAddFlagName, completion.AutocompleteCapabilities)
+
+	capDropFlagName := "cap-drop"
 	createFlags.StringSliceVar(
 		&cf.CapDrop,
-		"cap-drop", []string{},
+		capDropFlagName, []string{},
 		"Drop capabilities from the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(capDropFlagName, completion.AutocompleteCapabilities)
+
+	cgroupnsFlagName := "cgroupns"
 	createFlags.String(
-		"cgroupns", "",
+		cgroupnsFlagName, "",
 		"cgroup namespace to use",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cgroupnsFlagName, AutocompleteNamespace)
+
+	cgroupsFlagName := "cgroups"
 	createFlags.StringVar(
 		&cf.CGroupsMode,
-		"cgroups", containerConfig.Cgroups(),
+		cgroupsFlagName, containerConfig.Cgroups(),
 		`control container cgroup configuration ("enabled"|"disabled"|"no-conmon"|"split")`,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cgroupsFlagName, AutocompleteCgroupMode)
+
+	cgroupParentFlagName := "cgroup-parent"
 	createFlags.StringVar(
 		&cf.CGroupParent,
-		"cgroup-parent", "",
+		cgroupParentFlagName, "",
 		"Optional parent cgroup for the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cgroupParentFlagName, completion.AutocompleteDefault)
+
+	cidfileFlagName := "cidfile"
 	createFlags.StringVar(
 		&cf.CIDFile,
-		"cidfile", "",
+		cidfileFlagName, "",
 		"Write the container ID to the file",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cidfileFlagName, completion.AutocompleteDefault)
+
+	conmonPidfileFlagName := "conmon-pidfile"
 	createFlags.StringVar(
 		&cf.ConmonPIDFile,
-		"conmon-pidfile", "",
+		conmonPidfileFlagName, "",
 		"Path to the file that will receive the PID of conmon",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(conmonPidfileFlagName, completion.AutocompleteDefault)
+
+	cpuPeriodFlagName := "cpu-period"
 	createFlags.Uint64Var(
 		&cf.CPUPeriod,
-		"cpu-period", 0,
+		cpuPeriodFlagName, 0,
 		"Limit the CPU CFS (Completely Fair Scheduler) period",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpuPeriodFlagName, completion.AutocompleteNone)
+
+	cpuQuotaFlagName := "cpu-quota"
 	createFlags.Int64Var(
 		&cf.CPUQuota,
-		"cpu-quota", 0,
+		cpuQuotaFlagName, 0,
 		"Limit the CPU CFS (Completely Fair Scheduler) quota",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpuQuotaFlagName, completion.AutocompleteNone)
+
+	cpuRtPeriodFlagName := "cpu-rt-period"
 	createFlags.Uint64Var(
 		&cf.CPURTPeriod,
-		"cpu-rt-period", 0,
+		cpuRtPeriodFlagName, 0,
 		"Limit the CPU real-time period in microseconds",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpuRtPeriodFlagName, completion.AutocompleteNone)
+
+	cpuRtRuntimeFlagName := "cpu-rt-runtime"
 	createFlags.Int64Var(
 		&cf.CPURTRuntime,
-		"cpu-rt-runtime", 0,
+		cpuRtRuntimeFlagName, 0,
 		"Limit the CPU real-time runtime in microseconds",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpuRtRuntimeFlagName, completion.AutocompleteNone)
+
+	cpuSharesFlagName := "cpu-shares"
 	createFlags.Uint64Var(
 		&cf.CPUShares,
-		"cpu-shares", 0,
+		cpuSharesFlagName, 0,
 		"CPU shares (relative weight)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpuSharesFlagName, completion.AutocompleteNone)
+
+	cpusFlagName := "cpus"
 	createFlags.Float64Var(
 		&cf.CPUS,
-		"cpus", 0,
+		cpusFlagName, 0,
 		"Number of CPUs. The default is 0.000 which means no limit",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpusFlagName, completion.AutocompleteNone)
+
+	cpusetCpusFlagName := "cpuset-cpus"
 	createFlags.StringVar(
 		&cf.CPUSetCPUs,
-		"cpuset-cpus", "",
+		cpusetCpusFlagName, "",
 		"CPUs in which to allow execution (0-3, 0,1)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpusetCpusFlagName, completion.AutocompleteNone)
+
+	cpusetMemsFlagName := "cpuset-mems"
 	createFlags.StringVar(
 		&cf.CPUSetMems,
-		"cpuset-mems", "",
+		cpusetMemsFlagName, "",
 		"Memory nodes (MEMs) in which to allow execution (0-3, 0,1). Only effective on NUMA systems.",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(cpusetMemsFlagName, completion.AutocompleteNone)
+
+	deviceFlagName := "device"
 	createFlags.StringSliceVar(
 		&cf.Devices,
-		"device", containerConfig.Devices(),
+		deviceFlagName, containerConfig.Devices(),
 		fmt.Sprintf("Add a host device to the container"),
 	)
+	_ = cmd.RegisterFlagCompletionFunc(deviceFlagName, completion.AutocompleteDefault)
+
+	deviceCgroupRuleFlagName := "device-cgroup-rule"
 	createFlags.StringSliceVar(
 		&cf.DeviceCGroupRule,
-		"device-cgroup-rule", []string{},
+		deviceCgroupRuleFlagName, []string{},
 		"Add a rule to the cgroup allowed devices list",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(deviceCgroupRuleFlagName, completion.AutocompleteNone)
+
+	deviceReadBpsFlagName := "device-read-bps"
 	createFlags.StringSliceVar(
 		&cf.DeviceReadBPs,
-		"device-read-bps", []string{},
+		deviceReadBpsFlagName, []string{},
 		"Limit read rate (bytes per second) from a device (e.g. --device-read-bps=/dev/sda:1mb)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(deviceReadBpsFlagName, completion.AutocompleteDefault)
+
+	deviceReadIopsFlagName := "device-read-iops"
 	createFlags.StringSliceVar(
 		&cf.DeviceReadIOPs,
-		"device-read-iops", []string{},
+		deviceReadIopsFlagName, []string{},
 		"Limit read rate (IO per second) from a device (e.g. --device-read-iops=/dev/sda:1000)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(deviceReadIopsFlagName, completion.AutocompleteDefault)
+
+	deviceWriteBpsFlagName := "device-write-bps"
 	createFlags.StringSliceVar(
 		&cf.DeviceWriteBPs,
-		"device-write-bps", []string{},
+		deviceWriteBpsFlagName, []string{},
 		"Limit write rate (bytes per second) to a device (e.g. --device-write-bps=/dev/sda:1mb)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(deviceWriteBpsFlagName, completion.AutocompleteDefault)
+
+	deviceWriteIopsFlagName := "device-write-iops"
 	createFlags.StringSliceVar(
 		&cf.DeviceWriteIOPs,
-		"device-write-iops", []string{},
+		deviceWriteIopsFlagName, []string{},
 		"Limit write rate (IO per second) to a device (e.g. --device-write-iops=/dev/sda:1000)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(deviceWriteIopsFlagName, completion.AutocompleteDefault)
+
 	createFlags.Bool(
 		"disable-content-trust", false,
 		"This is a Docker specific option and is a NOOP",
 	)
-	createFlags.String("entrypoint", "",
+
+	entrypointFlagName := "entrypoint"
+	createFlags.String(entrypointFlagName, "",
 		"Overwrite the default ENTRYPOINT of the image",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(entrypointFlagName, completion.AutocompleteNone)
+
+	envFlagName := "env"
 	createFlags.StringArrayP(
-		"env", "e", containerConfig.Env(),
+		envFlagName, "e", containerConfig.Env(),
 		"Set environment variables in container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(envFlagName, completion.AutocompleteNone)
+
 	if !registry.IsRemote() {
 		createFlags.BoolVar(
 			&cf.EnvHost,
 			"env-host", false, "Use all current host environment variables in container",
 		)
 	}
+
+	envFileFlagName := "env-file"
 	createFlags.StringSliceVar(
 		&cf.EnvFile,
-		"env-file", []string{},
+		envFileFlagName, []string{},
 		"Read in a file of environment variables",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(envFileFlagName, completion.AutocompleteDefault)
+
+	exposeFlagName := "expose"
 	createFlags.StringSliceVar(
 		&cf.Expose,
-		"expose", []string{},
+		exposeFlagName, []string{},
 		"Expose a port or a range of ports",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(exposeFlagName, completion.AutocompleteNone)
+
+	gidmapFlagName := "gidmap"
 	createFlags.StringSliceVar(
 		&cf.GIDMap,
-		"gidmap", []string{},
+		gidmapFlagName, []string{},
 		"GID map to use for the user namespace",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(gidmapFlagName, completion.AutocompleteNone)
+
+	groupAddFlagName := "group-add"
 	createFlags.StringSliceVar(
 		&cf.GroupAdd,
-		"group-add", []string{},
+		groupAddFlagName, []string{},
 		"Add additional groups to join",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(groupAddFlagName, completion.AutocompleteNone)
+
 	createFlags.Bool(
 		"help", false, "",
 	)
+
+	healthCmdFlagName := "health-cmd"
 	createFlags.StringVar(
 		&cf.HealthCmd,
-		"health-cmd", "",
+		healthCmdFlagName, "",
 		"set a healthcheck command for the container ('none' disables the existing healthcheck)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(healthCmdFlagName, completion.AutocompleteNone)
+
+	healthIntervalFlagName := "health-interval"
 	createFlags.StringVar(
 		&cf.HealthInterval,
-		"health-interval", DefaultHealthCheckInterval,
+		healthIntervalFlagName, DefaultHealthCheckInterval,
 		"set an interval for the healthchecks (a value of disable results in no automatic timer setup)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(healthIntervalFlagName, completion.AutocompleteNone)
+
+	healthRetriesFlagName := "health-retries"
 	createFlags.UintVar(
 		&cf.HealthRetries,
-		"health-retries", DefaultHealthCheckRetries,
+		healthRetriesFlagName, DefaultHealthCheckRetries,
 		"the number of retries allowed before a healthcheck is considered to be unhealthy",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(healthRetriesFlagName, completion.AutocompleteNone)
+
+	healthStartPeriodFlagName := "health-start-period"
 	createFlags.StringVar(
 		&cf.HealthStartPeriod,
-		"health-start-period", DefaultHealthCheckStartPeriod,
+		healthStartPeriodFlagName, DefaultHealthCheckStartPeriod,
 		"the initialization time needed for a container to bootstrap",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(healthStartPeriodFlagName, completion.AutocompleteNone)
+
+	healthTimeoutFlagName := "health-timeout"
 	createFlags.StringVar(
 		&cf.HealthTimeout,
-		"health-timeout", DefaultHealthCheckTimeout,
+		healthTimeoutFlagName, DefaultHealthCheckTimeout,
 		"the maximum time allowed to complete the healthcheck before an interval is considered failed",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(healthTimeoutFlagName, completion.AutocompleteNone)
+
+	hostnameFlagName := "hostname"
 	createFlags.StringVarP(
 		&cf.Hostname,
-		"hostname", "h", "",
+		hostnameFlagName, "h", "",
 		"Set container hostname",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(hostnameFlagName, completion.AutocompleteNone)
+
 	createFlags.BoolVar(
 		&cf.HTTPProxy,
 		"http-proxy", true,
 		"Set proxy environment variables in the container based on the host proxy vars",
 	)
+
+	imageVolumeFlagName := "image-volume"
 	createFlags.StringVar(
 		&cf.ImageVolume,
-		"image-volume", DefaultImageVolume,
+		imageVolumeFlagName, DefaultImageVolume,
 		`Tells podman how to handle the builtin image volumes ("bind"|"tmpfs"|"ignore")`,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(imageVolumeFlagName, AutocompleteImageVolume)
+
 	createFlags.BoolVar(
 		&cf.Init,
 		"init", false,
 		"Run an init binary inside the container that forwards signals and reaps processes",
 	)
+
+	initPathFlagName := "init-path"
 	createFlags.StringVar(
 		&cf.InitPath,
-		"init-path", containerConfig.InitPath(),
+		initPathFlagName, containerConfig.InitPath(),
 		// Do not use  the Value field for setting the default value to determine user input (i.e., non-empty string)
 		fmt.Sprintf("Path to the container-init binary"),
 	)
+	_ = cmd.RegisterFlagCompletionFunc(initPathFlagName, completion.AutocompleteDefault)
+
 	createFlags.BoolVarP(
 		&cf.Interactive,
 		"interactive", "i", false,
 		"Keep STDIN open even if not attached",
 	)
+
+	ipcFlagName := "ipc"
 	createFlags.String(
-		"ipc", "",
+		ipcFlagName, "",
 		"IPC namespace to use",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(ipcFlagName, AutocompleteNamespace)
+
+	kernelMemoryFlagName := "kernel-memory"
 	createFlags.StringVar(
 		&cf.KernelMemory,
-		"kernel-memory", "",
+		kernelMemoryFlagName, "",
 		"Kernel memory limit "+sizeWithUnitFormat,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(kernelMemoryFlagName, completion.AutocompleteNone)
+
+	labelFlagName := "label"
 	createFlags.StringArrayVarP(
 		&cf.Label,
-		"label", "l", []string{},
+		labelFlagName, "l", []string{},
 		"Set metadata on container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(labelFlagName, completion.AutocompleteNone)
+
+	labelFileFlagName := "label-file"
 	createFlags.StringSliceVar(
 		&cf.LabelFile,
-		"label-file", []string{},
+		labelFileFlagName, []string{},
 		"Read in a line delimited file of labels",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(labelFileFlagName, completion.AutocompleteDefault)
+
+	logDriverFlagName := "log-driver"
 	createFlags.StringVar(
 		&cf.LogDriver,
-		"log-driver", "",
+		logDriverFlagName, "",
 		"Logging driver for the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(logDriverFlagName, AutocompleteLogDriver)
+
+	logOptFlagName := "log-opt"
 	createFlags.StringSliceVar(
 		&cf.LogOptions,
-		"log-opt", []string{},
+		logOptFlagName, []string{},
 		"Logging driver options",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(logOptFlagName, AutocompleteLogOpt)
+
+	memoryFlagName := "memory"
 	createFlags.StringVarP(
 		&cf.Memory,
-		"memory", "m", "",
+		memoryFlagName, "m", "",
 		"Memory limit "+sizeWithUnitFormat,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(memoryFlagName, completion.AutocompleteNone)
+
+	memoryReservationFlagName := "memory-reservation"
 	createFlags.StringVar(
 		&cf.MemoryReservation,
-		"memory-reservation", "",
+		memoryReservationFlagName, "",
 		"Memory soft limit "+sizeWithUnitFormat,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(memoryReservationFlagName, completion.AutocompleteNone)
+
+	memorySwapFlagName := "memory-swap"
 	createFlags.StringVar(
 		&cf.MemorySwap,
-		"memory-swap", "",
+		memorySwapFlagName, "",
 		"Swap limit equal to memory plus swap: '-1' to enable unlimited swap",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(memorySwapFlagName, completion.AutocompleteNone)
+
+	memorySwappinessFlagName := "memory-swappiness"
 	createFlags.Int64Var(
 		&cf.MemorySwappiness,
-		"memory-swappiness", -1,
+		memorySwappinessFlagName, -1,
 		"Tune container memory swappiness (0 to 100, or -1 for system default)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(memorySwappinessFlagName, completion.AutocompleteNone)
+
+	nameFlagName := "name"
 	createFlags.StringVar(
 		&cf.Name,
-		"name", "",
+		nameFlagName, "",
 		"Assign a name to the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(nameFlagName, completion.AutocompleteNone)
+
 	createFlags.BoolVar(
 		&cf.NoHealthCheck,
 		"no-healthcheck", false,
@@ -305,44 +466,69 @@ func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
 		"oom-kill-disable", false,
 		"Disable OOM Killer",
 	)
+
+	oomScoreAdjFlagName := "oom-score-adj"
 	createFlags.IntVar(
 		&cf.OOMScoreAdj,
-		"oom-score-adj", 0,
+		oomScoreAdjFlagName, 0,
 		"Tune the host's OOM preferences (-1000 to 1000)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(oomScoreAdjFlagName, completion.AutocompleteNone)
+
+	overrideArchFlagName := "override-arch"
 	createFlags.StringVar(
 		&cf.OverrideArch,
-		"override-arch", "",
+		overrideArchFlagName, "",
 		"use `ARCH` instead of the architecture of the machine for choosing images",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(overrideArchFlagName, completion.AutocompleteNone)
+
+	overrideOSFlagName := "override-os"
 	createFlags.StringVar(
 		&cf.OverrideOS,
-		"override-os", "",
+		overrideOSFlagName, "",
 		"use `OS` instead of the running OS for choosing images",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(overrideOSFlagName, completion.AutocompleteNone)
+
+	overrideVariantFlagName := "override-variant"
 	createFlags.StringVar(
 		&cf.OverrideVariant,
-		"override-variant", "",
+		overrideVariantFlagName, "",
 		"Use _VARIANT_ instead of the running architecture variant for choosing images",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(overrideVariantFlagName, completion.AutocompleteNone)
+
+	pidFlagName := "pid"
 	createFlags.String(
-		"pid", "",
+		pidFlagName, "",
 		"PID namespace to use",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(pidFlagName, AutocompleteNamespace)
+
+	pidsLimitFlagName := "pids-limit"
 	createFlags.Int64(
-		"pids-limit", containerConfig.PidsLimit(),
+		pidsLimitFlagName, containerConfig.PidsLimit(),
 		"Tune container pids limit (set 0 for unlimited, -1 for server defaults)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(pidsLimitFlagName, completion.AutocompleteNone)
+
+	podFlagName := "pod"
 	createFlags.StringVar(
 		&cf.Pod,
-		"pod", "",
+		podFlagName, "",
 		"Run container in an existing pod",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(podFlagName, AutocompletePods)
+
+	podIDFileFlagName := "pod-id-file"
 	createFlags.StringVar(
 		&cf.PodIDFile,
-		"pod-id-file", "",
+		podIDFileFlagName, "",
 		"Read the pod ID from the file",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(podIDFileFlagName, completion.AutocompleteDefault)
+
 	createFlags.BoolVar(
 		&cf.Privileged,
 		"privileged", false,
@@ -353,11 +539,15 @@ func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
 		"publish-all", "P", false,
 		"Publish all exposed ports to random ports on the host interface",
 	)
+
+	pullFlagName := "pull"
 	createFlags.StringVar(
 		&cf.Pull,
-		"pull", containerConfig.Engine.PullPolicy,
+		pullFlagName, containerConfig.Engine.PullPolicy,
 		`Pull image before creating ("always"|"missing"|"never")`,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(pullFlagName, AutocompletePullOption)
+
 	createFlags.BoolVarP(
 		&cf.Quiet,
 		"quiet", "q", false,
@@ -378,11 +568,15 @@ func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
 		"replace", false,
 		`If a container with the same name exists, replace it`,
 	)
+
+	restartFlagName := "restart"
 	createFlags.StringVar(
 		&cf.Restart,
-		"restart", "",
+		restartFlagName, "",
 		`Restart policy to apply when a container exits ("always"|"no"|"on-failure"|"unless-stopped")`,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(restartFlagName, AutocompleteRestartOption)
+
 	createFlags.BoolVar(
 		&cf.Rm,
 		"rm", false,
@@ -393,20 +587,31 @@ func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
 		"rootfs", false,
 		"The first argument is not an image but the rootfs to the exploded container",
 	)
+
+	sdnotifyFlagName := "sdnotify"
 	createFlags.StringVar(
 		&cf.SdNotifyMode,
-		"sdnotify", define.SdNotifyModeContainer,
+		sdnotifyFlagName, define.SdNotifyModeContainer,
 		`control sd-notify behavior ("container"|"conmon"|"ignore")`,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(sdnotifyFlagName, AutocompleteSDNotify)
+
+	securityOptFlagName := "security-opt"
 	createFlags.StringArrayVar(
 		&cf.SecurityOpt,
-		"security-opt", []string{},
+		securityOptFlagName, []string{},
 		"Security Options",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(securityOptFlagName, AutocompleteSecurityOption)
+
+	shmSizeFlagName := "shm-size"
 	createFlags.String(
-		"shm-size", containerConfig.ShmSize(),
+		shmSizeFlagName, containerConfig.ShmSize(),
 		"Size of /dev/shm "+sizeWithUnitFormat,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(shmSizeFlagName, completion.AutocompleteNone)
+
+	stopSignalFlagName := "stop-signal"
 	createFlags.StringVar(
 		&cf.SignaturePolicy,
 		"signature-policy", "",
@@ -414,112 +619,175 @@ func GetCreateFlags(cf *ContainerCLIOpts) *pflag.FlagSet {
 	)
 	createFlags.StringVar(
 		&cf.StopSignal,
-		"stop-signal", "",
+		stopSignalFlagName, "",
 		"Signal to stop a container. Default is SIGTERM",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(stopSignalFlagName, AutocompleteStopSignal)
+
+	stopTimeoutFlagName := "stop-timeout"
 	createFlags.UintVar(
 		&cf.StopTimeout,
-		"stop-timeout", containerConfig.Engine.StopTimeout,
+		stopTimeoutFlagName, containerConfig.Engine.StopTimeout,
 		"Timeout (in seconds) to stop a container. Default is 10",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(stopTimeoutFlagName, completion.AutocompleteNone)
+
+	storageOptFlagName := "storage-opt"
 	createFlags.StringSliceVar(
 		&cf.StoreageOpt,
-		"storage-opt", []string{},
+		storageOptFlagName, []string{},
 		"Storage driver options per container",
 	)
+	//FIXME: What should we suggest here? The flag is not in the man page.
+	_ = cmd.RegisterFlagCompletionFunc(storageOptFlagName, completion.AutocompleteNone)
+
+	subgidnameFlagName := "subgidname"
 	createFlags.StringVar(
 		&cf.SubUIDName,
-		"subgidname", "",
+		subgidnameFlagName, "",
 		"Name of range listed in /etc/subgid for use in user namespace",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(subgidnameFlagName, completion.AutocompleteSubgidName)
+
+	subuidnameFlagName := "subuidname"
 	createFlags.StringVar(
 		&cf.SubGIDName,
-		"subuidname", "",
+		subuidnameFlagName, "",
 		"Name of range listed in /etc/subuid for use in user namespace",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(subuidnameFlagName, completion.AutocompleteSubuidName)
 
+	sysctlFlagName := "sysctl"
 	createFlags.StringSliceVar(
 		&cf.Sysctl,
-		"sysctl", []string{},
+		sysctlFlagName, []string{},
 		"Sysctl options",
 	)
+	//TODO: Add function for systctl completion.
+	_ = cmd.RegisterFlagCompletionFunc(sysctlFlagName, completion.AutocompleteNone)
+
+	systemdFlagName := "systemd"
 	createFlags.StringVar(
 		&cf.Systemd,
-		"systemd", "true",
+		systemdFlagName, "true",
 		`Run container in systemd mode ("true"|"false"|"always")`,
 	)
+	_ = cmd.RegisterFlagCompletionFunc(systemdFlagName, AutocompleteSystemdFlag)
+
+	tmpfsFlagName := "tmpfs"
 	createFlags.StringArrayVar(
 		&cf.TmpFS,
-		"tmpfs", []string{},
+		tmpfsFlagName, []string{},
 		"Mount a temporary filesystem (`tmpfs`) into a container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(tmpfsFlagName, completion.AutocompleteDefault)
+
 	createFlags.BoolVarP(
 		&cf.TTY,
 		"tty", "t", false,
 		"Allocate a pseudo-TTY for container",
 	)
+
+	timezonezFlagName := "tz"
 	createFlags.StringVar(
 		&cf.Timezone,
-		"tz", containerConfig.TZ(),
+		timezonezFlagName, containerConfig.TZ(),
 		"Set timezone in container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(timezonezFlagName, completion.AutocompleteNone) //TODO: add timezone completion
+
+	umaskFlagName := "umask"
 	createFlags.StringVar(
 		&cf.Umask,
-		"umask", containerConfig.Umask(),
+		umaskFlagName, containerConfig.Umask(),
 		"Set umask in container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(umaskFlagName, completion.AutocompleteNone)
+
+	uidmapFlagName := "uidmap"
 	createFlags.StringSliceVar(
 		&cf.UIDMap,
-		"uidmap", []string{},
+		uidmapFlagName, []string{},
 		"UID map to use for the user namespace",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(uidmapFlagName, completion.AutocompleteNone)
+
+	ulimitFlagName := "ulimit"
 	createFlags.StringSliceVar(
 		&cf.Ulimit,
-		"ulimit", containerConfig.Ulimits(),
+		ulimitFlagName, containerConfig.Ulimits(),
 		"Ulimit options",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(ulimitFlagName, completion.AutocompleteNone)
+
+	userFlagName := "user"
 	createFlags.StringVarP(
 		&cf.User,
-		"user", "u", "",
+		userFlagName, "u", "",
 		"Username or UID (format: <name|uid>[:<group|gid>])",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(userFlagName, AutocompleteUserFlag)
+
+	usernsFlagName := "userns"
 	createFlags.String(
-		"userns", os.Getenv("PODMAN_USERNS"),
+		usernsFlagName, os.Getenv("PODMAN_USERNS"),
 		"User namespace to use",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(usernsFlagName, AutocompleteUserNamespace)
+
+	utsFlagName := "uts"
 	createFlags.String(
-		"uts", "",
+		utsFlagName, "",
 		"UTS namespace to use",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(utsFlagName, AutocompleteNamespace)
+
+	mountFlagName := "mount"
 	createFlags.StringArrayVar(
 		&cf.Mount,
-		"mount", []string{},
+		mountFlagName, []string{},
 		"Attach a filesystem mount to the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(mountFlagName, AutocompleteMountFlag)
+
+	volumeFlagName := "volume"
 	createFlags.StringArrayVarP(
 		&cf.Volume,
-		"volume", "v", containerConfig.Volumes(),
+		volumeFlagName, "v", containerConfig.Volumes(),
 		"Bind mount a volume into the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(volumeFlagName, AutocompleteVolumeFlag)
+
+	volumesFromFlagName := "volumes-from"
 	createFlags.StringArrayVar(
 		&cf.VolumesFrom,
-		"volumes-from", []string{},
+		volumesFromFlagName, []string{},
 		"Mount volumes from the specified container(s)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(volumesFromFlagName, AutocompleteContainers)
+
+	workdirFlagName := "workdir"
 	createFlags.StringVarP(
 		&cf.Workdir,
-		"workdir", "w", "",
+		workdirFlagName, "w", "",
 		"Working directory inside the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(workdirFlagName, completion.AutocompleteDefault)
+
+	seccompPolicyFlagName := "seccomp-policy"
 	createFlags.StringVar(
 		&cf.SeccompPolicy,
-		"seccomp-policy", "default",
+		seccompPolicyFlagName, "default",
 		"Policy for selecting a seccomp profile (experimental)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(seccompPolicyFlagName, completion.AutocompleteDefault)
+
+	cgroupConfFlagName := "cgroup-conf"
 	createFlags.StringSliceVar(
 		&cf.CgroupConf,
-		"cgroup-conf", []string{},
+		cgroupConfFlagName, []string{},
 		"Configure cgroup v2 (key=value)",
 	)
-	return &createFlags
+	_ = cmd.RegisterFlagCompletionFunc(cgroupConfFlagName, completion.AutocompleteNone)
+
 }

cmd/podman/common/netflags.go

@@ -4,58 +4,85 @@ import (
 	"net"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/libpod/define"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/specgen"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
-func GetNetFlags() *pflag.FlagSet {
-	netFlags := pflag.FlagSet{}
+func DefineNetFlags(cmd *cobra.Command) {
+	netFlags := cmd.Flags()
+
+	addHostFlagName := "add-host"
 	netFlags.StringSlice(
-		"add-host", []string{},
+		addHostFlagName, []string{},
 		"Add a custom host-to-IP mapping (host:ip) (default [])",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(addHostFlagName, completion.AutocompleteNone)
+
+	dnsFlagName := "dns"
 	netFlags.StringSlice(
-		"dns", containerConfig.DNSServers(),
+		dnsFlagName, containerConfig.DNSServers(),
 		"Set custom DNS servers",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(dnsFlagName, completion.AutocompleteNone)
+
+	dnsOptFlagName := "dns-opt"
 	netFlags.StringSlice(
-		"dns-opt", containerConfig.DNSOptions(),
+		dnsOptFlagName, containerConfig.DNSOptions(),
 		"Set custom DNS options",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(dnsOptFlagName, completion.AutocompleteNone)
+
+	dnsSearchFlagName := "dns-search"
 	netFlags.StringSlice(
-		"dns-search", containerConfig.DNSSearches(),
+		dnsSearchFlagName, containerConfig.DNSSearches(),
 		"Set custom DNS search domains",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(dnsSearchFlagName, completion.AutocompleteNone)
+
+	ipFlagName := "ip"
 	netFlags.String(
-		"ip", "",
+		ipFlagName, "",
 		"Specify a static IPv4 address for the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(ipFlagName, completion.AutocompleteNone)
+
+	macAddressFlagName := "mac-address"
 	netFlags.String(
-		"mac-address", "",
+		macAddressFlagName, "",
 		"Container MAC address (e.g. 92:d0:c6:0a:29:33)",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(macAddressFlagName, completion.AutocompleteNone)
+
+	networkFlagName := "network"
 	netFlags.String(
-		"network", containerConfig.NetNS(),
+		networkFlagName, containerConfig.NetNS(),
 		"Connect a container to a network",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(networkFlagName, AutocompleteNetworks)
+
+	networkAliasFlagName := "network-alias"
 	netFlags.StringSlice(
-		"network-alias", []string{},
+		networkAliasFlagName, []string{},
 		"Add network-scoped alias for the container",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(networkAliasFlagName, completion.AutocompleteNone)
+
+	publishFlagName := "publish"
 	netFlags.StringSliceP(
-		"publish", "p", []string{},
+		publishFlagName, "p", []string{},
 		"Publish a container's port, or a range of ports, to the host (default [])",
 	)
+	_ = cmd.RegisterFlagCompletionFunc(publishFlagName, completion.AutocompleteNone)
+
 	netFlags.Bool(
 		"no-hosts", false,
 		"Do not create /etc/hosts within the container, instead use the version from the image",
 	)
-	return &netFlags
 }
 
 func NetFlagsToNetOptions(cmd *cobra.Command) (*entities.NetOptions, error) {

cmd/podman/completion/completion.go

@@ -0,0 +1,93 @@
+package completion
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	commonComp "github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/registry"
+	"github.com/containers/podman/v2/pkg/domain/entities"
+	"github.com/spf13/cobra"
+)
+
+const (
+	completionDescription = `Generate shell autocompletions.
+  Valid arguments are bash, zsh, and fish.
+  Please refer to the man page to see how you can load these completions.`
+)
+
+var (
+	file          string
+	noDesc        bool
+	shells        = []string{"bash", "zsh", "fish"}
+	completionCmd = &cobra.Command{
+		Use:       fmt.Sprintf("completion [options] {%s}", strings.Join(shells, "|")),
+		Short:     "Generate shell autocompletions",
+		Long:      completionDescription,
+		ValidArgs: shells,
+		Args:      cobra.ExactValidArgs(1),
+		RunE:      completion,
+		Example: `podman completion bash
+  podman completion zsh -f _podman
+  podman completion fish --no-desc`,
+		//dont show this command to users
+		Hidden: true,
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
+		Command: completionCmd,
+	})
+	flags := completionCmd.Flags()
+	fileFlagName := "file"
+	flags.StringVarP(&file, fileFlagName, "f", "", "Output the completion to file rather than stdout.")
+	_ = completionCmd.RegisterFlagCompletionFunc(fileFlagName, commonComp.AutocompleteDefault)
+
+	flags.BoolVar(&noDesc, "no-desc", false, "Don't include descriptions in the completion output.")
+}
+
+func completion(cmd *cobra.Command, args []string) error {
+	var w io.Writer
+
+	if file != "" {
+		file, err := os.Create(file)
+		if err != nil {
+			return err
+		}
+		defer file.Close()
+		w = file
+	} else {
+		w = os.Stdout
+	}
+
+	var err error
+	switch args[0] {
+	case "bash":
+		if noDesc {
+			err = cmd.Root().GenBashCompletion(w)
+		} else {
+			err = cmd.Root().GenBashCompletionWithDesc(w)
+		}
+	case "zsh":
+		if noDesc {
+			err = cmd.Root().GenZshCompletionNoDesc(w)
+		} else {
+			err = cmd.Root().GenZshCompletion(w)
+		}
+	case "fish":
+		err = cmd.Root().GenFishCompletion(w, !noDesc)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	_, err = io.WriteString(w, fmt.Sprintf(
+		"\n# This file is generated with %q; see: podman-completion(1)\n", cmd.CommandPath(),
+	))
+	return err
+}

cmd/podman/containers/attach.go

@@ -3,33 +3,35 @@ package containers
 import (
 	"os"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	attachDescription = "The podman attach command allows you to attach to a running container using the container's ID or name, either to view its ongoing output or to control it interactively."
 	attachCommand     = &cobra.Command{
-		Use:   "attach [options] CONTAINER",
-		Short: "Attach to a running container",
-		Long:  attachDescription,
-		RunE:  attach,
-		Args:  validate.IDOrLatestArgs,
+		Use:               "attach [options] CONTAINER",
+		Short:             "Attach to a running container",
+		Long:              attachDescription,
+		RunE:              attach,
+		Args:              validate.IDOrLatestArgs,
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman attach ctrID
   podman attach 1234
   podman attach --no-stdin foobar`,
 	}
 
 	containerAttachCommand = &cobra.Command{
-		Use:   attachCommand.Use,
-		Short: attachCommand.Short,
-		Long:  attachCommand.Long,
-		RunE:  attachCommand.RunE,
-		Args:  validate.IDOrLatestArgs,
+		Use:               attachCommand.Use,
+		Short:             attachCommand.Short,
+		Long:              attachCommand.Long,
+		RunE:              attachCommand.RunE,
+		Args:              validate.IDOrLatestArgs,
+		ValidArgsFunction: attachCommand.ValidArgsFunction,
 		Example: `podman container attach ctrID
 	podman container attach 1234
 	podman container attach --no-stdin foobar`,
@@ -40,8 +42,13 @@ var (
 	attachOpts entities.AttachOptions
 )
 
-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 `_`")
+func attachFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	detachKeysFlagName := "detach-keys"
+	flags.StringVar(&attachOpts.DetachKeys, detachKeysFlagName, 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 `_`")
+	_ = cmd.RegisterFlagCompletionFunc(detachKeysFlagName, common.AutocompleteDetachKeys)
+
 	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")
 }
@@ -51,7 +58,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: attachCommand,
 	})
-	attachFlags(attachCommand.Flags())
+	attachFlags(attachCommand)
 	validate.AddLatestFlag(attachCommand, &attachOpts.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -59,7 +66,7 @@ func init() {
 		Command: containerAttachCommand,
 		Parent:  containerCmd,
 	})
-	attachFlags(containerAttachCommand.Flags())
+	attachFlags(containerAttachCommand)
 	validate.AddLatestFlag(containerAttachCommand, &attachOpts.Latest)
 
 }

cmd/podman/containers/checkpoint.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -27,6 +29,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman container checkpoint --keep ctrID
   podman container checkpoint --all
   podman container checkpoint --leave-running --latest`,
@@ -48,7 +51,11 @@ func init() {
 	flags.BoolVarP(&checkpointOptions.LeaveRunning, "leave-running", "R", false, "Leave the container running after writing checkpoint to disk")
 	flags.BoolVar(&checkpointOptions.TCPEstablished, "tcp-established", false, "Checkpoint a container with established TCP connections")
 	flags.BoolVarP(&checkpointOptions.All, "all", "a", false, "Checkpoint all running containers")
-	flags.StringVarP(&checkpointOptions.Export, "export", "e", "", "Export the checkpoint image to a tar.gz")
+
+	exportFlagName := "export"
+	flags.StringVarP(&checkpointOptions.Export, exportFlagName, "e", "", "Export the checkpoint image to a tar.gz")
+	_ = checkpointCommand.RegisterFlagCompletionFunc(exportFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVar(&checkpointOptions.IgnoreRootFS, "ignore-rootfs", false, "Do not include root file-system changes when exporting")
 	validate.AddLatestFlag(checkpointCommand, &checkpointOptions.Latest)
 }

cmd/podman/containers/cleanup.go

@@ -3,6 +3,8 @@ package containers
 import (
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -26,6 +28,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainersExited,
 		Example: `podman container cleanup --latest
   podman container cleanup ctrID1 ctrID2 ctrID3
   podman container cleanup --all`,
@@ -44,7 +47,11 @@ func init() {
 	})
 	flags := cleanupCommand.Flags()
 	flags.BoolVarP(&cleanupOptions.All, "all", "a", false, "Cleans up all containers")
-	flags.StringVar(&cleanupOptions.Exec, "exec", "", "Clean up the given exec session instead of the container")
+
+	execFlagName := "exec"
+	flags.StringVar(&cleanupOptions.Exec, execFlagName, "", "Clean up the given exec session instead of the container")
+	_ = cleanupCommand.RegisterFlagCompletionFunc(execFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&cleanupOptions.Remove, "rm", false, "After cleanup, remove the container entirely")
 	flags.BoolVar(&cleanupOptions.RemoveImage, "rmi", false, "After cleanup, remove the image entirely")
 	validate.AddLatestFlag(cleanupCommand, &cleanupOptions.Latest)

cmd/podman/containers/commit.go

@@ -7,22 +7,24 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	commitDescription = `Create an image from a container's changes. Optionally tag the image created, set the author with the --author flag, set the commit message with the --message flag, and make changes to the instructions with the --change flag.`
 
 	commitCommand = &cobra.Command{
-		Use:   "commit [options] CONTAINER [IMAGE]",
-		Short: "Create new image based on the changed container",
-		Long:  commitDescription,
-		RunE:  commit,
-		Args:  cobra.RangeArgs(1, 2),
+		Use:               "commit [options] CONTAINER [IMAGE]",
+		Short:             "Create new image based on the changed container",
+		Long:              commitDescription,
+		RunE:              commit,
+		Args:              cobra.RangeArgs(1, 2),
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman commit -q --message "committing container to image" reverent_golick image-committed
   podman commit -q --author "firstName lastName" reverent_golick image-committed
   podman commit -q --pause=false containerID image-committed
@@ -30,19 +32,17 @@ var (
 	}
 
 	containerCommitCommand = &cobra.Command{
-		Args:  commitCommand.Args,
-		Use:   commitCommand.Use,
-		Short: commitCommand.Short,
-		Long:  commitCommand.Long,
-		RunE:  commitCommand.RunE,
+		Args:              commitCommand.Args,
+		Use:               commitCommand.Use,
+		Short:             commitCommand.Short,
+		Long:              commitCommand.Long,
+		RunE:              commitCommand.RunE,
+		ValidArgsFunction: commitCommand.ValidArgsFunction,
 		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"}
 )
 
 var (
@@ -52,12 +52,29 @@ var (
 	iidFile string
 )
 
-func commitFlags(flags *pflag.FlagSet) {
-	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")
-	flags.StringVarP(&commitOptions.Message, "message", "m", "", "Set commit message for imported image")
-	flags.StringVarP(&commitOptions.Author, "author", "a", "", "Set the author for the image committed")
+func commitFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	changeFlagName := "change"
+	flags.StringArrayVarP(&commitOptions.Changes, changeFlagName, "c", []string{}, "Apply the following possible instructions to the created image (default []): "+strings.Join(common.ChangeCmds, " | "))
+	_ = cmd.RegisterFlagCompletionFunc(changeFlagName, common.AutocompleteChangeInstructions)
+
+	formatFlagName := "format"
+	flags.StringVarP(&commitOptions.Format, formatFlagName, "f", "oci", "`Format` of the image manifest and metadata")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteImageFormat)
+
+	iidFileFlagName := "iidfile"
+	flags.StringVarP(&iidFile, iidFileFlagName, "", "", "`file` to write the image ID to")
+	_ = cmd.RegisterFlagCompletionFunc(iidFileFlagName, completion.AutocompleteDefault)
+
+	messageFlagName := "message"
+	flags.StringVarP(&commitOptions.Message, messageFlagName, "m", "", "Set commit message for imported image")
+	_ = cmd.RegisterFlagCompletionFunc(messageFlagName, completion.AutocompleteNone)
+
+	authorFlagName := "author"
+	flags.StringVarP(&commitOptions.Author, authorFlagName, "a", "", "Set the author for the image committed")
+	_ = cmd.RegisterFlagCompletionFunc(authorFlagName, completion.AutocompleteNone)
+
 	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")
@@ -68,16 +85,14 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: commitCommand,
 	})
-	flags := commitCommand.Flags()
-	commitFlags(flags)
+	commitFlags(commitCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: containerCommitCommand,
 		Parent:  containerCmd,
 	})
-	containerCommitFlags := containerCommitCommand.Flags()
-	commitFlags(containerCommitFlags)
+	commitFlags(containerCommitCommand)
 }
 
 func commit(cmd *cobra.Command, args []string) error {

cmd/podman/containers/cp.go

@@ -1,13 +1,13 @@
 package containers
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/cgroups"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/rootless"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -16,21 +16,23 @@ var (
   You can copy from the container's file system to the local machine or the reverse, from the local filesystem to the container. If "-" is specified for either the SRC_PATH or DEST_PATH, you can also stream a tar archive from STDIN or to STDOUT. The CONTAINER can be a running or stopped container.  The SRC_PATH or DEST_PATH can be a file or directory.
 `
 	cpCommand = &cobra.Command{
-		Use:     "cp [options] SRC_PATH DEST_PATH",
-		Short:   "Copy files/folders between a container and the local filesystem",
-		Long:    cpDescription,
-		Args:    cobra.ExactArgs(2),
-		RunE:    cp,
-		Example: "podman cp [CONTAINER:]SRC_PATH [CONTAINER:]DEST_PATH",
+		Use:               "cp [options] SRC_PATH DEST_PATH",
+		Short:             "Copy files/folders between a container and the local filesystem",
+		Long:              cpDescription,
+		Args:              cobra.ExactArgs(2),
+		RunE:              cp,
+		ValidArgsFunction: common.AutocompleteCpCommand,
+		Example:           "podman cp [CONTAINER:]SRC_PATH [CONTAINER:]DEST_PATH",
 	}
 
 	containerCpCommand = &cobra.Command{
-		Use:     cpCommand.Use,
-		Short:   cpCommand.Short,
-		Long:    cpCommand.Long,
-		Args:    cpCommand.Args,
-		RunE:    cpCommand.RunE,
-		Example: "podman container cp [CONTAINER:]SRC_PATH [CONTAINER:]DEST_PATH",
+		Use:               cpCommand.Use,
+		Short:             cpCommand.Short,
+		Long:              cpCommand.Long,
+		Args:              cpCommand.Args,
+		RunE:              cpCommand.RunE,
+		ValidArgsFunction: cpCommand.ValidArgsFunction,
+		Example:           "podman container cp [CONTAINER:]SRC_PATH [CONTAINER:]DEST_PATH",
 	}
 )
 
@@ -38,7 +40,8 @@ var (
 	cpOpts entities.ContainerCpOptions
 )
 
-func cpFlags(flags *pflag.FlagSet) {
+func cpFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
 	flags.BoolVar(&cpOpts.Extract, "extract", false, "Extract the tar file into the destination directory.")
 	flags.BoolVar(&cpOpts.Pause, "pause", copyPause(), "Pause the container while copying")
 }
@@ -48,16 +51,14 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode},
 		Command: cpCommand,
 	})
-	flags := cpCommand.Flags()
-	cpFlags(flags)
+	cpFlags(cpCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode},
 		Command: containerCpCommand,
 		Parent:  containerCmd,
 	})
-	containerCpFlags := containerCpCommand.Flags()
-	cpFlags(containerCpFlags)
+	cpFlags(containerCpCommand)
 }
 
 func cp(cmd *cobra.Command, args []string) error {

cmd/podman/containers/create.go

@@ -19,7 +19,6 @@ import (
 	"github.com/containers/podman/v2/pkg/util"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -27,22 +26,24 @@ var (
 
   The container ID is then printed to stdout. You can then start it at any time with the podman start <container_id> command. The container will be created with the initial state 'created'.`
 	createCommand = &cobra.Command{
-		Use:   "create [options] IMAGE [COMMAND [ARG...]]",
-		Short: "Create but do not start a container",
-		Long:  createDescription,
-		RunE:  create,
-		Args:  cobra.MinimumNArgs(1),
+		Use:               "create [options] IMAGE [COMMAND [ARG...]]",
+		Short:             "Create but do not start a container",
+		Long:              createDescription,
+		RunE:              create,
+		Args:              cobra.MinimumNArgs(1),
+		ValidArgsFunction: common.AutocompleteCreateRun,
 		Example: `podman create alpine ls
   podman create --annotation HELLO=WORLD alpine ls
   podman create -t -i --name myctr alpine ls`,
 	}
 
 	containerCreateCommand = &cobra.Command{
-		Args:  cobra.MinimumNArgs(1),
-		Use:   createCommand.Use,
-		Short: createCommand.Short,
-		Long:  createCommand.Long,
-		RunE:  createCommand.RunE,
+		Args:              cobra.MinimumNArgs(1),
+		Use:               createCommand.Use,
+		Short:             createCommand.Short,
+		Long:              createCommand.Long,
+		RunE:              createCommand.RunE,
+		ValidArgsFunction: createCommand.ValidArgsFunction,
 		Example: `podman container create alpine ls
   podman container create --annotation HELLO=WORLD alpine ls
   podman container create -t -i --name myctr alpine ls`,
@@ -53,10 +54,13 @@ var (
 	cliVals common.ContainerCLIOpts
 )
 
-func createFlags(flags *pflag.FlagSet) {
+func createFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.SetInterspersed(false)
-	flags.AddFlagSet(common.GetCreateFlags(&cliVals))
-	flags.AddFlagSet(common.GetNetFlags())
+	common.DefineCreateFlags(cmd, &cliVals)
+	common.DefineNetFlags(cmd)
+
 	flags.SetNormalizeFunc(utils.AliasFlags)
 
 	_ = flags.MarkHidden("signature-policy")
@@ -70,18 +74,14 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: createCommand,
 	})
-	// common.GetCreateFlags(createCommand)
-	flags := createCommand.Flags()
-	createFlags(flags)
+	createFlags(createCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: containerCreateCommand,
 		Parent:  containerCmd,
 	})
-
-	containerCreateFlags := containerCreateCommand.Flags()
-	createFlags(containerCreateFlags)
+	createFlags(containerCreateCommand)
 }
 
 func create(cmd *cobra.Command, args []string) error {

cmd/podman/containers/diff.go

@@ -13,11 +13,12 @@ import (
 var (
 	// podman container _diff_
 	diffCmd = &cobra.Command{
-		Use:   "diff [options] CONTAINER",
-		Args:  validate.IDOrLatestArgs,
-		Short: "Inspect changes to the container's file systems",
-		Long:  `Displays changes to the container filesystem's'.  The container will be compared to its parent layer.`,
-		RunE:  diff,
+		Use:               "diff [options] CONTAINER",
+		Args:              validate.IDOrLatestArgs,
+		Short:             "Inspect changes to the container's file systems",
+		Long:              `Displays changes to the container filesystem's'.  The container will be compared to its parent layer.`,
+		RunE:              diff,
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman container diff myCtr
   podman container diff -l --format json myCtr`,
 	}
@@ -35,7 +36,11 @@ func init() {
 	flags := diffCmd.Flags()
 	flags.BoolVar(&diffOpts.Archive, "archive", true, "Save the diff as a tar archive")
 	_ = flags.MarkHidden("archive")
-	flags.StringVar(&diffOpts.Format, "format", "", "Change the output format")
+
+	formatFlagName := "format"
+	flags.StringVar(&diffOpts.Format, formatFlagName, "", "Change the output format")
+	_ = diffCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	validate.AddLatestFlag(diffCmd, &diffOpts.Latest)
 }
 

cmd/podman/containers/exec.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/libpod/define"
@@ -13,7 +15,6 @@ import (
 	"github.com/containers/podman/v2/pkg/rootless"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -25,6 +26,7 @@ var (
 		Long:                  execDescription,
 		RunE:                  exec,
 		DisableFlagsInUseLine: true,
+		ValidArgsFunction:     common.AutocompleteContainersRunning,
 		Example: `podman exec -it ctrID ls
   podman exec -it -w /tmp myCtr pwd
   podman exec --user root ctrID ls`,
@@ -36,6 +38,7 @@ var (
 		Long:                  execCommand.Long,
 		RunE:                  execCommand.RunE,
 		DisableFlagsInUseLine: true,
+		ValidArgsFunction:     execCommand.ValidArgsFunction,
 		Example: `podman container exec -it ctrID ls
   podman container exec -it -w /tmp myCtr pwd
   podman container exec --user root ctrID ls`,
@@ -48,18 +51,39 @@ var (
 	execDetach        bool
 )
 
-func execFlags(flags *pflag.FlagSet) {
+func execFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.SetInterspersed(false)
 	flags.BoolVarP(&execDetach, "detach", "d", false, "Run the exec session in detached mode (backgrounded)")
-	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")
-	flags.StringSliceVar(&envFile, "env-file", []string{}, "Read in a file of environment variables")
+
+	detachKeysFlagName := "detach-keys"
+	flags.StringVar(&execOpts.DetachKeys, detachKeysFlagName, 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 _")
+	_ = cmd.RegisterFlagCompletionFunc(detachKeysFlagName, common.AutocompleteDetachKeys)
+
+	envFlagName := "env"
+	flags.StringArrayVarP(&envInput, envFlagName, "e", []string{}, "Set environment variables")
+	_ = cmd.RegisterFlagCompletionFunc(envFlagName, completion.AutocompleteNone)
+
+	envFileFlagName := "env-file"
+	flags.StringSliceVar(&envFile, envFileFlagName, []string{}, "Read in a file of environment variables")
+	_ = cmd.RegisterFlagCompletionFunc(envFileFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVarP(&execOpts.Interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
 	flags.BoolVar(&execOpts.Privileged, "privileged", false, "Give the process extended Linux capabilities inside the container.  The default is false")
 	flags.BoolVarP(&execOpts.Tty, "tty", "t", false, "Allocate a pseudo-TTY. The default is false")
-	flags.StringVarP(&execOpts.User, "user", "u", "", "Sets the username or UID used and optionally the groupname or GID for the specified command")
-	flags.UintVar(&execOpts.PreserveFDs, "preserve-fds", 0, "Pass N additional file descriptors to the container")
-	flags.StringVarP(&execOpts.WorkDir, "workdir", "w", "", "Working directory inside the container")
+
+	userFlagName := "user"
+	flags.StringVarP(&execOpts.User, userFlagName, "u", "", "Sets the username or UID used and optionally the groupname or GID for the specified command")
+	_ = cmd.RegisterFlagCompletionFunc(userFlagName, common.AutocompleteUserFlag)
+
+	preserveFdsFlagName := "preserve-fds"
+	flags.UintVar(&execOpts.PreserveFDs, preserveFdsFlagName, 0, "Pass N additional file descriptors to the container")
+	_ = cmd.RegisterFlagCompletionFunc(preserveFdsFlagName, completion.AutocompleteNone)
+
+	workdirFlagName := "workdir"
+	flags.StringVarP(&execOpts.WorkDir, workdirFlagName, "w", "", "Working directory inside the container")
+	_ = cmd.RegisterFlagCompletionFunc(workdirFlagName, completion.AutocompleteDefault)
 
 	if registry.IsRemote() {
 		_ = flags.MarkHidden("preserve-fds")
@@ -71,7 +95,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: execCommand,
 	})
-	execFlags(execCommand.Flags())
+	execFlags(execCommand)
 	validate.AddLatestFlag(execCommand, &execOpts.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -79,7 +103,7 @@ func init() {
 		Command: containerExecCommand,
 		Parent:  containerCmd,
 	})
-	execFlags(containerExecCommand.Flags())
+	execFlags(containerExecCommand)
 	validate.AddLatestFlag(containerExecCommand, &execOpts.Latest)
 }
 

cmd/podman/containers/exists.go

@@ -3,6 +3,7 @@ package containers
 import (
 	"context"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -20,6 +21,7 @@ var (
 		RunE:                  exists,
 		Args:                  cobra.ExactArgs(1),
 		DisableFlagsInUseLine: true,
+		ValidArgsFunction:     common.AutocompleteContainers,
 	}
 )
 

cmd/podman/containers/export.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"os"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 	"golang.org/x/crypto/ssh/terminal"
 )
 
@@ -18,21 +19,23 @@ var (
 		" and saves it on the local machine."
 
 	exportCommand = &cobra.Command{
-		Use:   "export [options] CONTAINER",
-		Short: "Export container's filesystem contents as a tar archive",
-		Long:  exportDescription,
-		RunE:  export,
-		Args:  cobra.ExactArgs(1),
+		Use:               "export [options] CONTAINER",
+		Short:             "Export container's filesystem contents as a tar archive",
+		Long:              exportDescription,
+		RunE:              export,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman export ctrID > myCtr.tar
   podman export --output="myCtr.tar" ctrID`,
 	}
 
 	containerExportCommand = &cobra.Command{
-		Args:  cobra.ExactArgs(1),
-		Use:   exportCommand.Use,
-		Short: exportCommand.Short,
-		Long:  exportCommand.Long,
-		RunE:  exportCommand.RunE,
+		Args:              cobra.ExactArgs(1),
+		Use:               exportCommand.Use,
+		Short:             exportCommand.Short,
+		Long:              exportCommand.Long,
+		RunE:              exportCommand.RunE,
+		ValidArgsFunction: exportCommand.ValidArgsFunction,
 		Example: `podman container export ctrID > myCtr.tar
   podman container export --output="myCtr.tar" ctrID`,
 	}
@@ -42,8 +45,12 @@ 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 exportFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	outputFlagName := "output"
+	flags.StringVarP(&exportOpts.Output, outputFlagName, "o", "", "Write to a specified file (default: stdout, which must be redirected)")
+	_ = cmd.RegisterFlagCompletionFunc(outputFlagName, completion.AutocompleteDefault)
 }
 
 func init() {
@@ -51,17 +58,14 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: exportCommand,
 	})
-	flags := exportCommand.Flags()
-	exportFlags(flags)
+	exportFlags(exportCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: containerExportCommand,
 		Parent:  containerCmd,
 	})
-
-	containerExportFlags := containerExportCommand.Flags()
-	exportFlags(containerExportFlags)
+	exportFlags(containerExportCommand)
 }
 
 func export(cmd *cobra.Command, args []string) error {

cmd/podman/containers/init.go

@@ -3,6 +3,7 @@ package containers
 import (
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -22,17 +23,19 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainersCreated,
 		Example: `podman init --latest
   podman init 3c45ef19d893
   podman init test1`,
 	}
 
 	containerInitCommand = &cobra.Command{
-		Use:   initCommand.Use,
-		Short: initCommand.Short,
-		Long:  initCommand.Long,
-		RunE:  initCommand.RunE,
-		Args:  initCommand.Args,
+		Use:               initCommand.Use,
+		Short:             initCommand.Short,
+		Long:              initCommand.Long,
+		RunE:              initCommand.RunE,
+		Args:              initCommand.Args,
+		ValidArgsFunction: initCommand.ValidArgsFunction,
 		Example: `podman container init --latest
   podman container init 3c45ef19d893
   podman container init test1`,

cmd/podman/containers/inspect.go

@@ -1,6 +1,7 @@
 package containers
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/inspect"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -11,10 +12,11 @@ import (
 var (
 	// podman container _inspect_
 	inspectCmd = &cobra.Command{
-		Use:   "inspect [options] CONTAINER [CONTAINER...]",
-		Short: "Display the configuration of a container",
-		Long:  `Displays the low-level information on a container identified by name or ID.`,
-		RunE:  inspectExec,
+		Use:               "inspect [options] CONTAINER [CONTAINER...]",
+		Short:             "Display the configuration of a container",
+		Long:              `Displays the low-level information on a container identified by name or ID.`,
+		RunE:              inspectExec,
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman container inspect myCtr
   podman container inspect -l --format '{{.Id}} {{.Config.Labels}}'`,
 	}
@@ -30,7 +32,11 @@ func init() {
 	inspectOpts = new(entities.InspectOptions)
 	flags := inspectCmd.Flags()
 	flags.BoolVarP(&inspectOpts.Size, "size", "s", false, "Display total file size")
-	flags.StringVarP(&inspectOpts.Format, "format", "f", "json", "Format the output to a Go template or json")
+
+	formatFlagName := "format"
+	flags.StringVarP(&inspectOpts.Format, formatFlagName, "f", "json", "Format the output to a Go template or json")
+	_ = inspectCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	validate.AddLatestFlag(inspectCmd, &inspectOpts.Latest)
 }
 

cmd/podman/containers/kill.go

@@ -5,13 +5,13 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/signal"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -24,6 +24,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman kill mywebserver
   podman kill 860a4b23
   podman kill --signal TERM ctrID`,
@@ -33,10 +34,11 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
-		Use:   killCommand.Use,
-		Short: killCommand.Short,
-		Long:  killCommand.Long,
-		RunE:  killCommand.RunE,
+		Use:               killCommand.Use,
+		Short:             killCommand.Short,
+		Long:              killCommand.Long,
+		RunE:              killCommand.RunE,
+		ValidArgsFunction: killCommand.ValidArgsFunction,
 		Example: `podman container kill mywebserver
   podman container kill 860a4b23
   podman container kill --signal TERM ctrID`,
@@ -47,9 +49,14 @@ var (
 	killOptions = entities.KillOptions{}
 )
 
-func killFlags(flags *pflag.FlagSet) {
+func killFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&killOptions.All, "all", "a", false, "Signal all running containers")
-	flags.StringVarP(&killOptions.Signal, "signal", "s", "KILL", "Signal to send to the container")
+
+	signalFlagName := "signal"
+	flags.StringVarP(&killOptions.Signal, signalFlagName, "s", "KILL", "Signal to send to the container")
+	_ = cmd.RegisterFlagCompletionFunc(signalFlagName, common.AutocompleteStopSignal)
 }
 
 func init() {
@@ -57,7 +64,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: killCommand,
 	})
-	killFlags(killCommand.Flags())
+	killFlags(killCommand)
 	validate.AddLatestFlag(killCommand, &killOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -65,7 +72,7 @@ func init() {
 		Command: containerKillCommand,
 		Parent:  containerCmd,
 	})
-	killFlags(containerKillCommand.Flags())
+	killFlags(containerKillCommand)
 	validate.AddLatestFlag(containerKillCommand, &killOptions.Latest)
 }
 

cmd/podman/containers/list.go

@@ -1,6 +1,7 @@
 package containers
 
 import (
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -10,12 +11,13 @@ import (
 var (
 	// podman container _list_
 	listCmd = &cobra.Command{
-		Use:     "list [options]",
-		Aliases: []string{"ls"},
-		Args:    validate.NoArgs,
-		Short:   "List containers",
-		Long:    "Prints out information about the containers",
-		RunE:    ps,
+		Use:               "list [options]",
+		Aliases:           []string{"ls"},
+		Args:              validate.NoArgs,
+		Short:             "List containers",
+		Long:              "Prints out information about the containers",
+		RunE:              ps,
+		ValidArgsFunction: completion.AutocompleteNone,
 		Example: `podman container list -a
   podman container list -a --format "{{.ID}}  {{.Image}}  {{.Labels}}  {{.Mounts}}"
   podman container list --size --sort names`,
@@ -28,6 +30,6 @@ func init() {
 		Command: listCmd,
 		Parent:  containerCmd,
 	})
-	listFlagSet(listCmd.Flags())
+	listFlagSet(listCmd)
 	validate.AddLatestFlag(listCmd, &listOpts.Latest)
 }

cmd/podman/containers/logs.go

@@ -3,13 +3,14 @@ package containers
 import (
 	"os"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/util"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // logsOptionsWrapper wraps entities.LogsOptions and prevents leaking
@@ -43,7 +44,8 @@ var (
 			}
 			return nil
 		},
-		RunE: logs,
+		RunE:              logs,
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman logs ctrID
   podman logs --names ctrID1 ctrID2
   podman logs --tail 2 mywebserver
@@ -52,11 +54,12 @@ var (
 	}
 
 	containerLogsCommand = &cobra.Command{
-		Use:   logsCommand.Use,
-		Short: logsCommand.Short,
-		Long:  logsCommand.Long,
-		Args:  logsCommand.Args,
-		RunE:  logsCommand.RunE,
+		Use:               logsCommand.Use,
+		Short:             logsCommand.Short,
+		Long:              logsCommand.Long,
+		Args:              logsCommand.Args,
+		RunE:              logsCommand.RunE,
+		ValidArgsFunction: logsCommand.ValidArgsFunction,
 		Example: `podman container logs ctrID
 		podman container logs --names ctrID1 ctrID2
 		podman container logs --tail 2 mywebserver
@@ -71,7 +74,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: logsCommand,
 	})
-	logsFlags(logsCommand.Flags())
+	logsFlags(logsCommand)
 	validate.AddLatestFlag(logsCommand, &logsOptions.Latest)
 
 	// container logs
@@ -80,15 +83,24 @@ func init() {
 		Command: containerLogsCommand,
 		Parent:  containerCmd,
 	})
-	logsFlags(containerLogsCommand.Flags())
+	logsFlags(containerLogsCommand)
 	validate.AddLatestFlag(containerLogsCommand, &logsOptions.Latest)
 }
 
-func logsFlags(flags *pflag.FlagSet) {
+func logsFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVar(&logsOptions.Details, "details", false, "Show extra details provided to the logs")
 	flags.BoolVarP(&logsOptions.Follow, "follow", "f", false, "Follow log output.  The default is false")
-	flags.StringVar(&logsOptions.SinceRaw, "since", "", "Show logs since TIMESTAMP")
-	flags.Int64Var(&logsOptions.Tail, "tail", -1, "Output the specified number of LINES at the end of the logs.  Defaults to -1, which prints all lines")
+
+	sinceFlagName := "since"
+	flags.StringVar(&logsOptions.SinceRaw, sinceFlagName, "", "Show logs since TIMESTAMP")
+	_ = cmd.RegisterFlagCompletionFunc(sinceFlagName, completion.AutocompleteNone)
+
+	tailFlagName := "tail"
+	flags.Int64Var(&logsOptions.Tail, tailFlagName, -1, "Output the specified number of LINES at the end of the logs.  Defaults to -1, which prints all lines")
+	_ = cmd.RegisterFlagCompletionFunc(tailFlagName, completion.AutocompleteNone)
+
 	flags.BoolVarP(&logsOptions.Timestamps, "timestamps", "t", false, "Output the timestamps in the log")
 	flags.BoolVarP(&logsOptions.Names, "names", "n", false, "Output the container name in the log")
 	flags.SetInterspersed(false)

cmd/podman/containers/mount.go

@@ -7,13 +7,13 @@ import (
 	"text/template"
 
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -36,15 +36,17 @@ var (
 			registry.UnshareNSRequired: "",
 			registry.ParentNSRequired:  "",
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 	}
 
 	containerMountCommmand = &cobra.Command{
-		Use:         mountCommand.Use,
-		Short:       mountCommand.Short,
-		Long:        mountCommand.Long,
-		RunE:        mountCommand.RunE,
-		Args:        mountCommand.Args,
-		Annotations: mountCommand.Annotations,
+		Use:               mountCommand.Use,
+		Short:             mountCommand.Short,
+		Long:              mountCommand.Long,
+		RunE:              mountCommand.RunE,
+		Args:              mountCommand.Args,
+		Annotations:       mountCommand.Annotations,
+		ValidArgsFunction: mountCommand.ValidArgsFunction,
 	}
 )
 
@@ -52,9 +54,15 @@ var (
 	mountOpts entities.ContainerMountOptions
 )
 
-func mountFlags(flags *pflag.FlagSet) {
+func mountFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&mountOpts.All, "all", "a", false, "Mount all containers")
-	flags.StringVar(&mountOpts.Format, "format", "", "Print the mounted containers in specified format (json)")
+
+	formatFlagName := "format"
+	flags.StringVar(&mountOpts.Format, formatFlagName, "", "Print the mounted containers in specified format (json)")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVar(&mountOpts.NoTruncate, "notruncate", false, "Do not truncate output")
 }
 
@@ -63,7 +71,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode},
 		Command: mountCommand,
 	})
-	mountFlags(mountCommand.Flags())
+	mountFlags(mountCommand)
 	validate.AddLatestFlag(mountCommand, &mountOpts.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -71,7 +79,7 @@ func init() {
 		Command: containerMountCommmand,
 		Parent:  containerCmd,
 	})
-	mountFlags(containerMountCommmand.Flags())
+	mountFlags(containerMountCommmand)
 	validate.AddLatestFlag(containerMountCommmand, &mountOpts.Latest)
 }
 

cmd/podman/containers/pause.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/cgroups"
@@ -17,20 +18,22 @@ import (
 var (
 	pauseDescription = `Pauses one or more running containers.  The container name or ID can be used.`
 	pauseCommand     = &cobra.Command{
-		Use:   "pause [options] CONTAINER [CONTAINER...]",
-		Short: "Pause all the processes in one or more containers",
-		Long:  pauseDescription,
-		RunE:  pause,
+		Use:               "pause [options] CONTAINER [CONTAINER...]",
+		Short:             "Pause all the processes in one or more containers",
+		Long:              pauseDescription,
+		RunE:              pause,
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman pause mywebserver
   podman pause 860a4b23
   podman pause -a`,
 	}
 
 	containerPauseCommand = &cobra.Command{
-		Use:   pauseCommand.Use,
-		Short: pauseCommand.Short,
-		Long:  pauseCommand.Long,
-		RunE:  pauseCommand.RunE,
+		Use:               pauseCommand.Use,
+		Short:             pauseCommand.Short,
+		Long:              pauseCommand.Long,
+		RunE:              pauseCommand.RunE,
+		ValidArgsFunction: pauseCommand.ValidArgsFunction,
 		Example: `podman container pause mywebserver
   podman container pause 860a4b23
   podman container pause -a`,

cmd/podman/containers/port.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -25,6 +26,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, true, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman port --all
   podman port ctrID 80/tcp
   podman port --latest 80`,
@@ -38,6 +40,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, true, false)
 		},
+		ValidArgsFunction: portCommand.ValidArgsFunction,
 		Example: `podman container port --all
   podman container port --latest 80`,
 	}

cmd/podman/containers/prune.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -21,12 +22,13 @@ var (
 
 	Removes all non running containers`)
 	pruneCommand = &cobra.Command{
-		Use:     "prune [options]",
-		Short:   "Remove all non running containers",
-		Long:    pruneDescription,
-		RunE:    prune,
-		Example: `podman container prune`,
-		Args:    validate.NoArgs,
+		Use:               "prune [options]",
+		Short:             "Remove all non running containers",
+		Long:              pruneDescription,
+		RunE:              prune,
+		ValidArgsFunction: completion.AutocompleteNone,
+		Example:           `podman container prune`,
+		Args:              validate.NoArgs,
 	}
 	force  bool
 	filter = []string{}
@@ -40,7 +42,9 @@ func init() {
 	})
 	flags := pruneCommand.Flags()
 	flags.BoolVarP(&force, "force", "f", false, "Do not prompt for confirmation.  The default is false")
-	flags.StringArrayVar(&filter, "filter", []string{}, "Provide filter values (e.g. 'label=<key>=<value>')")
+	filterFlagName := "filter"
+	flags.StringArrayVar(&filter, filterFlagName, []string{}, "Provide filter values (e.g. 'label=<key>=<value>')")
+	_ = pruneCommand.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
 }
 
 func prune(cmd *cobra.Command, args []string) error {

cmd/podman/containers/ps.go

@@ -11,7 +11,9 @@ import (
 	"time"
 
 	tm "github.com/buger/goterm"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
@@ -21,17 +23,17 @@ import (
 	"github.com/docker/go-units"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	psDescription = "Prints out information about the containers"
 	psCommand     = &cobra.Command{
-		Use:   "ps [options]",
-		Args:  validate.NoArgs,
-		Short: "List containers",
-		Long:  psDescription,
-		RunE:  ps,
+		Use:               "ps [options]",
+		Args:              validate.NoArgs,
+		Short:             "List containers",
+		Long:              psDescription,
+		RunE:              ps,
+		ValidArgsFunction: completion.AutocompleteNone,
 		Example: `podman ps -a
   podman ps -a --format "{{.ID}}  {{.Image}}  {{.Labels}}  {{.Mounts}}"
   podman ps --size --sort names`,
@@ -50,26 +52,45 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: psCommand,
 	})
-	listFlagSet(psCommand.Flags())
+	listFlagSet(psCommand)
 	validate.AddLatestFlag(psCommand, &listOpts.Latest)
 }
 
-func listFlagSet(flags *pflag.FlagSet) {
+func listFlagSet(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&listOpts.All, "all", "a", false, "Show all the containers, default is only running containers")
-	flags.StringSliceVarP(&filters, "filter", "f", []string{}, "Filter output based on conditions given")
 	flags.BoolVar(&listOpts.Storage, "external", false, "Show containers in storage not controlled by Podman")
-	flags.StringVar(&listOpts.Format, "format", "", "Pretty-print containers to JSON or using a Go template")
-	flags.IntVarP(&listOpts.Last, "last", "n", -1, "Print the n last created containers (all states)")
+
+	filterFlagName := "filter"
+	flags.StringSliceVarP(&filters, filterFlagName, "f", []string{}, "Filter output based on conditions given")
+	//TODO add custom filter function
+	_ = cmd.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
+
+	formatFlagName := "format"
+	flags.StringVar(&listOpts.Format, formatFlagName, "", "Pretty-print containers to JSON or using a Go template")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
+	lastFlagName := "last"
+	flags.IntVarP(&listOpts.Last, lastFlagName, "n", -1, "Print the n last created containers (all states)")
+	_ = cmd.RegisterFlagCompletionFunc(lastFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&listOpts.Namespace, "ns", false, "Display namespace information")
 	flags.BoolVar(&noTrunc, "no-trunc", false, "Display the extended information")
 	flags.BoolVarP(&listOpts.Pod, "pod", "p", false, "Print the ID and name of the pod the containers are associated with")
 	flags.BoolVarP(&listOpts.Quiet, "quiet", "q", false, "Print the numeric IDs of the containers only")
 	flags.BoolVarP(&listOpts.Size, "size", "s", false, "Display the total file sizes")
 	flags.BoolVar(&listOpts.Sync, "sync", false, "Sync container state with OCI runtime")
-	flags.UintVarP(&listOpts.Watch, "watch", "w", 0, "Watch the ps output on an interval in seconds")
+
+	watchFlagName := "watch"
+	flags.UintVarP(&listOpts.Watch, watchFlagName, "w", 0, "Watch the ps output on an interval in seconds")
+	_ = cmd.RegisterFlagCompletionFunc(watchFlagName, completion.AutocompleteNone)
 
 	sort := validate.Value(&listOpts.Sort, "command", "created", "id", "image", "names", "runningfor", "size", "status")
-	flags.Var(sort, "sort", "Sort output by: "+sort.Choices())
+	sortFlagName := "sort"
+	flags.Var(sort, sortFlagName, "Sort output by: "+sort.Choices())
+	_ = cmd.RegisterFlagCompletionFunc(sortFlagName, common.AutocompletePsSort)
+
 	flags.SetNormalizeFunc(utils.AliasFlags)
 }
 func checkFlags(c *cobra.Command) error {

cmd/podman/containers/restart.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -11,7 +13,6 @@ import (
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -27,16 +28,18 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman restart ctrID
   podman restart --latest
   podman restart ctrID1 ctrID2`,
 	}
 
 	containerRestartCommand = &cobra.Command{
-		Use:   restartCommand.Use,
-		Short: restartCommand.Short,
-		Long:  restartCommand.Long,
-		RunE:  restartCommand.RunE,
+		Use:               restartCommand.Use,
+		Short:             restartCommand.Short,
+		Long:              restartCommand.Long,
+		RunE:              restartCommand.RunE,
+		ValidArgsFunction: restartCommand.ValidArgsFunction,
 		Example: `podman container restart ctrID
   podman container restart --latest
   podman container restart ctrID1 ctrID2`,
@@ -48,10 +51,15 @@ var (
 	restartTimeout uint
 )
 
-func restartFlags(flags *pflag.FlagSet) {
+func restartFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&restartOptions.All, "all", "a", false, "Restart all non-running containers")
 	flags.BoolVar(&restartOptions.Running, "running", false, "Restart only running containers when --all is used")
-	flags.UintVarP(&restartTimeout, "time", "t", containerConfig.Engine.StopTimeout, "Seconds to wait for stop before killing the container")
+
+	timeFlagName := "time"
+	flags.UintVarP(&restartTimeout, timeFlagName, "t", containerConfig.Engine.StopTimeout, "Seconds to wait for stop before killing the container")
+	_ = cmd.RegisterFlagCompletionFunc(timeFlagName, completion.AutocompleteNone)
 
 	flags.SetNormalizeFunc(utils.AliasFlags)
 }
@@ -61,7 +69,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: restartCommand,
 	})
-	restartFlags(restartCommand.Flags())
+	restartFlags(restartCommand)
 	validate.AddLatestFlag(restartCommand, &restartOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -69,7 +77,7 @@ func init() {
 		Command: containerRestartCommand,
 		Parent:  containerCmd,
 	})
-	restartFlags(containerRestartCommand.Flags())
+	restartFlags(containerRestartCommand)
 	validate.AddLatestFlag(containerRestartCommand, &restartOptions.Latest)
 }
 

cmd/podman/containers/restore.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -27,6 +29,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, true, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman container restore ctrID
   podman container restore --latest
   podman container restore --all`,
@@ -47,8 +50,15 @@ func init() {
 	flags.BoolVarP(&restoreOptions.All, "all", "a", false, "Restore all checkpointed containers")
 	flags.BoolVarP(&restoreOptions.Keep, "keep", "k", false, "Keep all temporary checkpoint files")
 	flags.BoolVar(&restoreOptions.TCPEstablished, "tcp-established", false, "Restore a container with established TCP connections")
-	flags.StringVarP(&restoreOptions.Import, "import", "i", "", "Restore from exported checkpoint archive (tar.gz)")
-	flags.StringVarP(&restoreOptions.Name, "name", "n", "", "Specify new name for container restored from exported checkpoint (only works with --import)")
+
+	importFlagName := "import"
+	flags.StringVarP(&restoreOptions.Import, importFlagName, "i", "", "Restore from exported checkpoint archive (tar.gz)")
+	_ = restoreCommand.RegisterFlagCompletionFunc(importFlagName, completion.AutocompleteDefault)
+
+	nameFlagName := "name"
+	flags.StringVarP(&restoreOptions.Name, nameFlagName, "n", "", "Specify new name for container restored from exported checkpoint (only works with --import)")
+	_ = restoreCommand.RegisterFlagCompletionFunc(nameFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&restoreOptions.IgnoreRootFS, "ignore-rootfs", false, "Do not apply root file-system changes when importing from exported checkpoint")
 	flags.BoolVar(&restoreOptions.IgnoreStaticIP, "ignore-static-ip", false, "Ignore IP address set via --static-ip")
 	flags.BoolVar(&restoreOptions.IgnoreStaticMAC, "ignore-static-mac", false, "Ignore MAC address set via --mac-address")

cmd/podman/containers/rm.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -13,7 +15,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -28,6 +29,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman rm imageID
   podman rm mywebserver myflaskserver 860a4b23
   podman rm --force --all
@@ -42,6 +44,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: rmCommand.ValidArgsFunction,
 		Example: `podman container rm imageID
   podman container rm mywebserver myflaskserver 860a4b23
   podman container rm --force --all
@@ -53,12 +56,17 @@ var (
 	rmOptions = entities.RmOptions{}
 )
 
-func rmFlags(flags *pflag.FlagSet) {
+func rmFlags(cmd *cobra.Command) {
+	flags := cmd.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")
 	flags.BoolVarP(&rmOptions.Volumes, "volumes", "v", false, "Remove anonymous volumes associated with the container")
-	flags.StringArrayVarP(&rmOptions.CIDFiles, "cidfile", "", nil, "Read the container ID from the file")
+
+	cidfileFlagName := "cidfile"
+	flags.StringArrayVarP(&rmOptions.CIDFiles, cidfileFlagName, "", nil, "Read the container ID from the file")
+	_ = cmd.RegisterFlagCompletionFunc(cidfileFlagName, completion.AutocompleteDefault)
 
 	if !registry.IsRemote() {
 		// This option is deprecated, but needs to still exists for backwards compatibility
@@ -72,7 +80,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: rmCommand,
 	})
-	rmFlags(rmCommand.Flags())
+	rmFlags(rmCommand)
 	validate.AddLatestFlag(rmCommand, &rmOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -80,7 +88,7 @@ func init() {
 		Command: containerRmCommand,
 		Parent:  containerCmd,
 	})
-	rmFlags(containerRmCommand.Flags())
+	rmFlags(containerRmCommand)
 	validate.AddLatestFlag(containerRmCommand, &rmOptions.Latest)
 }
 

cmd/podman/containers/run.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
@@ -18,28 +19,29 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	runDescription = "Runs a command in a new container from the given image"
 	runCommand     = &cobra.Command{
-		Args:  cobra.MinimumNArgs(1),
-		Use:   "run [options] IMAGE [COMMAND [ARG...]]",
-		Short: "Run a command in a new container",
-		Long:  runDescription,
-		RunE:  run,
+		Args:              cobra.MinimumNArgs(1),
+		Use:               "run [options] IMAGE [COMMAND [ARG...]]",
+		Short:             "Run a command in a new container",
+		Long:              runDescription,
+		RunE:              run,
+		ValidArgsFunction: common.AutocompleteCreateRun,
 		Example: `podman run imageID ls -alF /etc
   podman run --network=host imageID dnf -y install java
   podman run --volume /var/hostdir:/var/ctrdir -i -t fedora /bin/bash`,
 	}
 
 	containerRunCommand = &cobra.Command{
-		Args:  cobra.MinimumNArgs(1),
-		Use:   runCommand.Use,
-		Short: runCommand.Short,
-		Long:  runCommand.Long,
-		RunE:  runCommand.RunE,
+		Args:              cobra.MinimumNArgs(1),
+		Use:               runCommand.Use,
+		Short:             runCommand.Short,
+		Long:              runCommand.Long,
+		RunE:              runCommand.RunE,
+		ValidArgsFunction: runCommand.ValidArgsFunction,
 		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`,
@@ -55,16 +57,26 @@ var (
 	runRmi bool
 )
 
-func runFlags(flags *pflag.FlagSet) {
+func runFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.SetInterspersed(false)
-	flags.AddFlagSet(common.GetCreateFlags(&cliVals))
-	flags.AddFlagSet(common.GetNetFlags())
+	common.DefineCreateFlags(cmd, &cliVals)
+	common.DefineNetFlags(cmd)
+
 	flags.SetNormalizeFunc(utils.AliasFlags)
 	flags.BoolVar(&runOpts.SigProxy, "sig-proxy", true, "Proxy received signals to the process")
 	flags.BoolVar(&runRmi, "rmi", false, "Remove container image unless used by other containers")
+
+	preserveFdsFlagName := "preserve-fds"
 	flags.UintVar(&runOpts.PreserveFDs, "preserve-fds", 0, "Pass a number of additional file descriptors into the container")
+	_ = cmd.RegisterFlagCompletionFunc(preserveFdsFlagName, completion.AutocompleteNone)
+
 	flags.BoolVarP(&runOpts.Detach, "detach", "d", false, "Run container in background and print container ID")
-	flags.StringVar(&runOpts.DetachKeys, "detach-keys", containerConfig.DetachKeys(), "Override 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-cf`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`")
+
+	detachKeysFlagName := "detach-keys"
+	flags.StringVar(&runOpts.DetachKeys, detachKeysFlagName, containerConfig.DetachKeys(), "Override 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-cf`, `@`, `^`, `[`, `\\`, `]`, `^` or `_`")
+	_ = cmd.RegisterFlagCompletionFunc(detachKeysFlagName, common.AutocompleteDetachKeys)
 
 	_ = flags.MarkHidden("signature-policy")
 	if registry.IsRemote() {
@@ -77,8 +89,8 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: runCommand,
 	})
-	flags := runCommand.Flags()
-	runFlags(flags)
+
+	runFlags(runCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
@@ -86,8 +98,7 @@ func init() {
 		Parent:  containerCmd,
 	})
 
-	containerRunFlags := containerRunCommand.Flags()
-	runFlags(containerRunFlags)
+	runFlags(containerRunCommand)
 }
 
 func run(cmd *cobra.Command, args []string) error {

cmd/podman/containers/runlabel.go

@@ -5,7 +5,9 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/sirupsen/logrus"
@@ -23,11 +25,12 @@ var (
 	runlabelOptions     = runlabelOptionsWrapper{}
 	runlabelDescription = "Executes a command as described by a container image label."
 	runlabelCommand     = &cobra.Command{
-		Use:   "runlabel [options] LABEL IMAGE [ARG...]",
-		Short: "Execute the command described by an image label",
-		Long:  runlabelDescription,
-		RunE:  runlabel,
-		Args:  cobra.MinimumNArgs(2),
+		Use:               "runlabel [options] LABEL IMAGE [ARG...]",
+		Short:             "Execute the command described by an image label",
+		Long:              runlabelDescription,
+		RunE:              runlabel,
+		Args:              cobra.MinimumNArgs(2),
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman container runlabel run imageID
   podman container runlabel install imageID arg1 arg2
   podman container runlabel --display run myImage`,
@@ -42,11 +45,25 @@ func init() {
 	})
 
 	flags := runlabelCommand.Flags()
-	flags.StringVar(&runlabelOptions.Authfile, "authfile", auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
-	flags.StringVar(&runlabelOptions.CertDir, "cert-dir", "", "`Pathname` of a directory containing TLS certificates and keys")
-	flags.StringVar(&runlabelOptions.Credentials, "creds", "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
+
+	authfileflagName := "authfile"
+	flags.StringVar(&runlabelOptions.Authfile, authfileflagName, auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = runlabelCommand.RegisterFlagCompletionFunc(authfileflagName, completion.AutocompleteDefault)
+
+	certDirFlagName := "cert-dir"
+	flags.StringVar(&runlabelOptions.CertDir, certDirFlagName, "", "`Pathname` of a directory containing TLS certificates and keys")
+	_ = runlabelCommand.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
+
+	credsFlagName := "creds"
+	flags.StringVar(&runlabelOptions.Credentials, credsFlagName, "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
+	_ = runlabelCommand.RegisterFlagCompletionFunc(credsFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&runlabelOptions.Display, "display", false, "Preview the command that the label would run")
-	flags.StringVarP(&runlabelOptions.Name, "name", "n", "", "Assign a name to the container")
+
+	nameFlagName := "name"
+	flags.StringVarP(&runlabelOptions.Name, nameFlagName, "n", "", "Assign a name to the container")
+	_ = runlabelCommand.RegisterFlagCompletionFunc(nameFlagName, completion.AutocompleteNone)
+
 	flags.StringVar(&runlabelOptions.Optional1, "opt1", "", "Optional parameter to pass for install")
 	flags.StringVar(&runlabelOptions.Optional2, "opt2", "", "Optional parameter to pass for install")
 	flags.StringVar(&runlabelOptions.Optional3, "opt3", "", "Optional parameter to pass for install")

cmd/podman/containers/start.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -11,26 +12,27 @@ import (
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	startDescription = `Starts one or more containers.  The container name or ID can be used.`
 	startCommand     = &cobra.Command{
-		Use:   "start [options] CONTAINER [CONTAINER...]",
-		Short: "Start one or more containers",
-		Long:  startDescription,
-		RunE:  start,
+		Use:               "start [options] CONTAINER [CONTAINER...]",
+		Short:             "Start one or more containers",
+		Long:              startDescription,
+		RunE:              start,
+		ValidArgsFunction: common.AutocompleteContainersStartable,
 		Example: `podman start --latest
   podman start 860a4b231279 5421ab43b45
   podman start --interactive --attach imageID`,
 	}
 
 	containerStartCommand = &cobra.Command{
-		Use:   startCommand.Use,
-		Short: startCommand.Short,
-		Long:  startCommand.Long,
-		RunE:  startCommand.RunE,
+		Use:               startCommand.Use,
+		Short:             startCommand.Short,
+		Long:              startCommand.Long,
+		RunE:              startCommand.RunE,
+		ValidArgsFunction: startCommand.ValidArgsFunction,
 		Example: `podman container start --latest
   podman container start 860a4b231279 5421ab43b45
   podman container start --interactive --attach imageID`,
@@ -41,9 +43,15 @@ var (
 	startOptions entities.ContainerStartOptions
 )
 
-func startFlags(flags *pflag.FlagSet) {
+func startFlags(cmd *cobra.Command) {
+	flags := cmd.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 `_`")
+
+	detachKeysFlagName := "detach-keys"
+	flags.StringVar(&startOptions.DetachKeys, detachKeysFlagName, 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 `_`")
+	_ = cmd.RegisterFlagCompletionFunc(detachKeysFlagName, common.AutocompleteDetachKeys)
+
 	flags.BoolVarP(&startOptions.Interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
 	flags.BoolVar(&startOptions.SigProxy, "sig-proxy", false, "Proxy received signals to the process (default true if attaching, false otherwise)")
 
@@ -56,7 +64,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: startCommand,
 	})
-	startFlags(startCommand.Flags())
+	startFlags(startCommand)
 	validate.AddLatestFlag(startCommand, &startOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -64,9 +72,8 @@ func init() {
 		Command: containerStartCommand,
 		Parent:  containerCmd,
 	})
-	startFlags(containerStartCommand.Flags())
+	startFlags(containerStartCommand)
 	validate.AddLatestFlag(containerStartCommand, &startOptions.Latest)
-
 }
 
 func start(cmd *cobra.Command, args []string) error {

cmd/podman/containers/stats.go

@@ -8,6 +8,7 @@ import (
 
 	tm "github.com/buger/goterm"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -20,28 +21,29 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	statsDescription = "Display percentage of CPU, memory, network I/O, block I/O and PIDs for one or more containers."
 	statsCommand     = &cobra.Command{
-		Use:   "stats [options] [CONTAINER...]",
-		Short: "Display a live stream of container resource usage statistics",
-		Long:  statsDescription,
-		RunE:  stats,
-		Args:  checkStatOptions,
+		Use:               "stats [options] [CONTAINER...]",
+		Short:             "Display a live stream of container resource usage statistics",
+		Long:              statsDescription,
+		RunE:              stats,
+		Args:              checkStatOptions,
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman stats --all --no-stream
   podman stats ctrID
   podman stats --no-stream --format "table {{.ID}} {{.Name}} {{.MemUsage}}" ctrID`,
 	}
 
 	containerStatsCommand = &cobra.Command{
-		Use:   statsCommand.Use,
-		Short: statsCommand.Short,
-		Long:  statsCommand.Long,
-		RunE:  statsCommand.RunE,
-		Args:  checkStatOptions,
+		Use:               statsCommand.Use,
+		Short:             statsCommand.Short,
+		Long:              statsCommand.Long,
+		RunE:              statsCommand.RunE,
+		Args:              checkStatOptions,
+		ValidArgsFunction: statsCommand.ValidArgsFunction,
 		Example: `podman container stats --all --no-stream
   podman container stats ctrID
   podman container stats --no-stream --format "table {{.ID}} {{.Name}} {{.MemUsage}}" ctrID`,
@@ -62,9 +64,15 @@ var (
 	statsOptions statsOptionsCLI
 )
 
-func statFlags(flags *pflag.FlagSet) {
+func statFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&statsOptions.All, "all", "a", false, "Show all containers. Only running containers are shown by default. The default is false")
-	flags.StringVar(&statsOptions.Format, "format", "", "Pretty-print container statistics to JSON or using a Go template")
+
+	formatFlagName := "format"
+	flags.StringVar(&statsOptions.Format, formatFlagName, "", "Pretty-print container statistics to JSON or using a Go template")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVar(&statsOptions.NoReset, "no-reset", false, "Disable resetting the screen between intervals")
 	flags.BoolVar(&statsOptions.NoStream, "no-stream", false, "Disable streaming stats and only pull the first result, default setting is false")
 }
@@ -74,7 +82,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: statsCommand,
 	})
-	statFlags(statsCommand.Flags())
+	statFlags(statsCommand)
 	validate.AddLatestFlag(statsCommand, &statsOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -82,7 +90,7 @@ func init() {
 		Command: containerStatsCommand,
 		Parent:  containerCmd,
 	})
-	statFlags(containerStatsCommand.Flags())
+	statFlags(containerStatsCommand)
 	validate.AddLatestFlag(containerStatsCommand, &statsOptions.Latest)
 }
 

cmd/podman/containers/stop.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -24,6 +25,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman stop ctrID
   podman stop --latest
   podman stop --time 2 mywebserver 6e534f14da9d`,
@@ -37,6 +39,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: stopCommand.ValidArgsFunction,
 		Example: `podman container stop ctrID
   podman container stop --latest
   podman container stop --time 2 mywebserver 6e534f14da9d`,
@@ -48,11 +51,19 @@ var (
 	stopTimeout uint
 )
 
-func stopFlags(flags *pflag.FlagSet) {
+func stopFlags(cmd *cobra.Command) {
+	flags := cmd.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")
-	flags.UintVarP(&stopTimeout, "time", "t", containerConfig.Engine.StopTimeout, "Seconds to wait for stop before killing the container")
+
+	cidfileFlagName := "cidfile"
+	flags.StringArrayVarP(&stopOptions.CIDFiles, cidfileFlagName, "", nil, "Read the container ID from the file")
+	_ = cmd.RegisterFlagCompletionFunc(cidfileFlagName, completion.AutocompleteDefault)
+
+	timeFlagName := "time"
+	flags.UintVarP(&stopTimeout, timeFlagName, "t", containerConfig.Engine.StopTimeout, "Seconds to wait for stop before killing the container")
+	_ = cmd.RegisterFlagCompletionFunc(timeFlagName, completion.AutocompleteNone)
 
 	if registry.IsRemote() {
 		_ = flags.MarkHidden("cidfile")
@@ -66,7 +77,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: stopCommand,
 	})
-	stopFlags(stopCommand.Flags())
+	stopFlags(stopCommand)
 	validate.AddLatestFlag(stopCommand, &stopOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -74,8 +85,7 @@ func init() {
 		Command: containerStopCommand,
 		Parent:  containerCmd,
 	})
-
-	stopFlags(containerStopCommand.Flags())
+	stopFlags(containerStopCommand)
 	validate.AddLatestFlag(containerStopCommand, &stopOptions.Latest)
 }
 

cmd/podman/containers/top.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -26,11 +27,12 @@ var (
 	topOptions = entities.TopOptions{}
 
 	topCommand = &cobra.Command{
-		Use:   "top [options] CONTAINER [FORMAT-DESCRIPTORS|ARGS...]",
-		Short: "Display the running processes of a container",
-		Long:  topDescription,
-		RunE:  top,
-		Args:  cobra.ArbitraryArgs,
+		Use:               "top [options] CONTAINER [FORMAT-DESCRIPTORS|ARGS...]",
+		Short:             "Display the running processes of a container",
+		Long:              topDescription,
+		RunE:              top,
+		Args:              cobra.ArbitraryArgs,
+		ValidArgsFunction: common.AutocompleteContainersRunning,
 		Example: `podman top ctrID
 podman top --latest
 podman top ctrID pid seccomp args %C
@@ -38,10 +40,11 @@ podman top ctrID -eo user,pid,comm`,
 	}
 
 	containerTopCommand = &cobra.Command{
-		Use:   topCommand.Use,
-		Short: topCommand.Short,
-		Long:  topCommand.Long,
-		RunE:  topCommand.RunE,
+		Use:               topCommand.Use,
+		Short:             topCommand.Short,
+		Long:              topCommand.Long,
+		RunE:              topCommand.RunE,
+		ValidArgsFunction: topCommand.ValidArgsFunction,
 		Example: `podman container top ctrID
 podman container top --latest
 podman container top ctrID pid seccomp args %C

cmd/podman/containers/unmount.go

@@ -3,6 +3,7 @@ package containers
 import (
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -27,6 +28,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman unmount ctrID
   podman unmount ctrID1 ctrID2 ctrID3
   podman unmount --all`,
@@ -41,6 +43,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman container unmount ctrID
   podman container unmount ctrID1 ctrID2 ctrID3
   podman container unmount --all`,

cmd/podman/containers/unpause.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/cgroups"
@@ -17,20 +18,22 @@ import (
 var (
 	unpauseDescription = `Unpauses one or more previously paused containers.  The container name or ID can be used.`
 	unpauseCommand     = &cobra.Command{
-		Use:   "unpause [options] CONTAINER [CONTAINER...]",
-		Short: "Unpause the processes in one or more containers",
-		Long:  unpauseDescription,
-		RunE:  unpause,
+		Use:               "unpause [options] CONTAINER [CONTAINER...]",
+		Short:             "Unpause the processes in one or more containers",
+		Long:              unpauseDescription,
+		RunE:              unpause,
+		ValidArgsFunction: common.AutocompleteContainersPaused,
 		Example: `podman unpause ctrID
   podman unpause --all`,
 	}
 	unPauseOptions = entities.PauseUnPauseOptions{}
 
 	containerUnpauseCommand = &cobra.Command{
-		Use:   unpauseCommand.Use,
-		Short: unpauseCommand.Short,
-		Long:  unpauseCommand.Long,
-		RunE:  unpauseCommand.RunE,
+		Use:               unpauseCommand.Use,
+		Short:             unpauseCommand.Short,
+		Long:              unpauseCommand.Long,
+		RunE:              unpauseCommand.RunE,
+		ValidArgsFunction: unpauseCommand.ValidArgsFunction,
 		Example: `podman container unpause ctrID
   podman container unpause --all`,
 	}

cmd/podman/containers/wait.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -12,26 +14,27 @@ import (
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	waitDescription = `Block until one or more containers stop and then print their exit codes.
 `
 	waitCommand = &cobra.Command{
-		Use:   "wait [options] CONTAINER [CONTAINER...]",
-		Short: "Block on one or more containers",
-		Long:  waitDescription,
-		RunE:  wait,
+		Use:               "wait [options] CONTAINER [CONTAINER...]",
+		Short:             "Block on one or more containers",
+		Long:              waitDescription,
+		RunE:              wait,
+		ValidArgsFunction: common.AutocompleteContainers,
 		Example: `podman wait --interval 5s ctrID
   podman wait ctrID1 ctrID2`,
 	}
 
 	containerWaitCommand = &cobra.Command{
-		Use:   waitCommand.Use,
-		Short: waitCommand.Short,
-		Long:  waitCommand.Long,
-		RunE:  waitCommand.RunE,
+		Use:               waitCommand.Use,
+		Short:             waitCommand.Short,
+		Long:              waitCommand.Long,
+		RunE:              waitCommand.RunE,
+		ValidArgsFunction: waitCommand.ValidArgsFunction,
 		Example: `podman container wait --interval 5s ctrID
   podman container wait ctrID1 ctrID2`,
 	}
@@ -43,9 +46,17 @@ var (
 	waitInterval  string
 )
 
-func waitFlags(flags *pflag.FlagSet) {
-	flags.StringVarP(&waitInterval, "interval", "i", "250ns", "Time Interval to wait before polling for completion")
-	flags.StringVar(&waitCondition, "condition", "stopped", "Condition to wait on")
+func waitFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	intervalFlagName := "interval"
+	flags.StringVarP(&waitInterval, intervalFlagName, "i", "250ns", "Time Interval to wait before polling for completion")
+	_ = cmd.RegisterFlagCompletionFunc(intervalFlagName, completion.AutocompleteNone)
+
+	conditionFlagName := "condition"
+	flags.StringVar(&waitCondition, conditionFlagName, "stopped", "Condition to wait on")
+	_ = cmd.RegisterFlagCompletionFunc(conditionFlagName, common.AutocompleteWaitCondition)
+
 }
 
 func init() {
@@ -53,7 +64,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: waitCommand,
 	})
-	waitFlags(waitCommand.Flags())
+	waitFlags(waitCommand)
 	validate.AddLatestFlag(waitCommand, &waitOptions.Latest)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -61,9 +72,8 @@ func init() {
 		Command: containerWaitCommand,
 		Parent:  containerCmd,
 	})
-	waitFlags(containerWaitCommand.Flags())
+	waitFlags(containerWaitCommand)
 	validate.AddLatestFlag(containerWaitCommand, &waitOptions.Latest)
-
 }
 
 func wait(cmd *cobra.Command, args []string) error {

cmd/podman/diff.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/containers"
 	"github.com/containers/podman/v2/cmd/podman/images"
 	"github.com/containers/podman/v2/cmd/podman/registry"
@@ -17,11 +18,12 @@ var (
 	// Command: podman _diff_ Object_ID
 	diffDescription = `Displays changes on a container or image's filesystem.  The container or image will be compared to its parent layer.`
 	diffCmd         = &cobra.Command{
-		Use:   "diff [options] {CONTAINER_ID | IMAGE_ID}",
-		Args:  validate.IDOrLatestArgs,
-		Short: "Display the changes to the object's file system",
-		Long:  diffDescription,
-		RunE:  diff,
+		Use:               "diff [options] {CONTAINER_ID | IMAGE_ID}",
+		Args:              validate.IDOrLatestArgs,
+		Short:             "Display the changes to the object's file system",
+		Long:              diffDescription,
+		RunE:              diff,
+		ValidArgsFunction: common.AutocompleteContainersAndImages,
 		Example: `podman diff imageID
   podman diff ctrID
   podman diff --format json redis:alpine`,
@@ -38,7 +40,11 @@ func init() {
 	flags := diffCmd.Flags()
 	flags.BoolVar(&diffOpts.Archive, "archive", true, "Save the diff as a tar archive")
 	_ = flags.MarkHidden("archive")
-	flags.StringVar(&diffOpts.Format, "format", "", "Change the output format")
+
+	formatFlagName := "format"
+	flags.StringVar(&diffOpts.Format, formatFlagName, "", "Change the output format")
+	_ = diffCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	validate.AddLatestFlag(diffCmd, &diffOpts.Latest)
 }
 

cmd/podman/generate/kube.go

@@ -5,6 +5,8 @@ import (
 	"io/ioutil"
 	"os"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -20,11 +22,12 @@ var (
 Whether the input is for a container or pod, Podman will always generate the specification as a pod.`
 
 	kubeCmd = &cobra.Command{
-		Use:   "kube [options] CONTAINER | POD",
-		Short: "Generate Kubernetes YAML from a container or pod.",
-		Long:  kubeDescription,
-		RunE:  kube,
-		Args:  cobra.ExactArgs(1),
+		Use:               "kube [options] CONTAINER | POD",
+		Short:             "Generate Kubernetes YAML from a container or pod.",
+		Long:              kubeDescription,
+		RunE:              kube,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: common.AutocompleteContainersAndPods,
 		Example: `podman generate kube ctrID
   podman generate kube podID
   podman generate kube --service podID`,
@@ -39,7 +42,11 @@ func init() {
 	})
 	flags := kubeCmd.Flags()
 	flags.BoolVarP(&kubeOptions.Service, "service", "s", false, "Generate YAML for a Kubernetes service object")
-	flags.StringVarP(&kubeFile, "filename", "f", "", "Write output to the specified path")
+
+	filenameFlagName := "filename"
+	flags.StringVarP(&kubeFile, filenameFlagName, "f", "", "Write output to the specified path")
+	_ = kubeCmd.RegisterFlagCompletionFunc(filenameFlagName, completion.AutocompleteDefault)
+
 	flags.SetNormalizeFunc(utils.AliasFlags)
 }
 

cmd/podman/generate/systemd.go

@@ -6,7 +6,9 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -24,11 +26,12 @@ var (
   The generated units can later be controlled via systemctl(1).`
 
 	systemdCmd = &cobra.Command{
-		Use:   "systemd [options] CTR|POD",
-		Short: "Generate systemd units.",
-		Long:  systemdDescription,
-		RunE:  systemd,
-		Args:  cobra.ExactArgs(1),
+		Use:               "systemd [options] CTR|POD",
+		Short:             "Generate systemd units.",
+		Long:              systemdDescription,
+		RunE:              systemd,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: common.AutocompleteContainersAndPods,
 		Example: `podman generate systemd CTR
   podman generate systemd --new --time 10 CTR
   podman generate systemd --files --name POD`,
@@ -44,13 +47,32 @@ func init() {
 	flags := systemdCmd.Flags()
 	flags.BoolVarP(&systemdOptions.Name, "name", "n", false, "Use container/pod names instead of IDs")
 	flags.BoolVarP(&files, "files", "f", false, "Generate .service files instead of printing to stdout")
-	flags.UintVarP(&systemdTimeout, "time", "t", containerConfig.Engine.StopTimeout, "Stop timeout override")
-	flags.StringVar(&systemdOptions.RestartPolicy, "restart-policy", "on-failure", "Systemd restart-policy")
+
+	timeFlagName := "time"
+	flags.UintVarP(&systemdTimeout, timeFlagName, "t", containerConfig.Engine.StopTimeout, "Stop timeout override")
+	_ = systemdCmd.RegisterFlagCompletionFunc(timeFlagName, completion.AutocompleteNone)
 	flags.BoolVarP(&systemdOptions.New, "new", "", false, "Create a new container instead of starting an existing one")
-	flags.StringVar(&systemdOptions.ContainerPrefix, "container-prefix", "container", "Systemd unit name prefix for containers")
-	flags.StringVar(&systemdOptions.PodPrefix, "pod-prefix", "pod", "Systemd unit name prefix for pods")
-	flags.StringVar(&systemdOptions.Separator, "separator", "-", "Systemd unit name separator between name/id and prefix")
-	flags.StringVar(&format, "format", "", "Print the created units in specified format (json)")
+
+	containerPrefixFlagName := "container-prefix"
+	flags.StringVar(&systemdOptions.ContainerPrefix, containerPrefixFlagName, "container", "Systemd unit name prefix for containers")
+	_ = systemdCmd.RegisterFlagCompletionFunc(containerPrefixFlagName, completion.AutocompleteNone)
+
+	podPrefixFlagName := "pod-prefix"
+	flags.StringVar(&systemdOptions.PodPrefix, podPrefixFlagName, "pod", "Systemd unit name prefix for pods")
+	_ = systemdCmd.RegisterFlagCompletionFunc(podPrefixFlagName, completion.AutocompleteNone)
+
+	separatorFlagName := "separator"
+	flags.StringVar(&systemdOptions.Separator, separatorFlagName, "-", "Systemd unit name separator between name/id and prefix")
+	_ = systemdCmd.RegisterFlagCompletionFunc(separatorFlagName, completion.AutocompleteNone)
+
+	restartPolicyFlagName := "restart-policy"
+	flags.StringVar(&systemdOptions.RestartPolicy, restartPolicyFlagName, "on-failure", "Systemd restart-policy")
+	_ = systemdCmd.RegisterFlagCompletionFunc(restartPolicyFlagName, common.AutocompleteSystemdRestartOptions)
+
+	formatFlagName := "format"
+	flags.StringVar(&format, formatFlagName, "", "Print the created units in specified format (json)")
+	_ = systemdCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.SetNormalizeFunc(utils.AliasFlags)
 }
 

cmd/podman/healthcheck/run.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -18,6 +19,7 @@ var (
 		Example:               `podman healthcheck run mywebapp`,
 		RunE:                  run,
 		Args:                  cobra.ExactArgs(1),
+		ValidArgsFunction:     common.AutocompleteContainersRunning,
 		DisableFlagsInUseLine: true,
 	}
 )

cmd/podman/images/build.go

@@ -9,6 +9,7 @@ import (
 	"github.com/containers/buildah/imagebuildah"
 	buildahCLI "github.com/containers/buildah/pkg/cli"
 	"github.com/containers/buildah/pkg/parse"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/config"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
@@ -18,7 +19,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // buildFlagsWrapper are local to cmd/ as the build code is using Buildah-internal
@@ -40,22 +40,24 @@ var (
 	// Command: podman _diff_ Object_ID
 	buildDescription = "Builds an OCI or Docker image using instructions from one or more Containerfiles and a specified build context directory."
 	buildCmd         = &cobra.Command{
-		Use:   "build [options] [CONTEXT]",
-		Short: "Build an image using instructions from Containerfiles",
-		Long:  buildDescription,
-		Args:  cobra.MaximumNArgs(1),
-		RunE:  build,
+		Use:               "build [options] [CONTEXT]",
+		Short:             "Build an image using instructions from Containerfiles",
+		Long:              buildDescription,
+		Args:              cobra.MaximumNArgs(1),
+		RunE:              build,
+		ValidArgsFunction: completion.AutocompleteDefault,
 		Example: `podman build .
   podman build --creds=username:password -t imageName -f Containerfile.simple .
   podman build --layers --force-rm --tag imageName .`,
 	}
 
 	imageBuildCmd = &cobra.Command{
-		Args:  buildCmd.Args,
-		Use:   buildCmd.Use,
-		Short: buildCmd.Short,
-		Long:  buildCmd.Long,
-		RunE:  buildCmd.RunE,
+		Args:              buildCmd.Args,
+		Use:               buildCmd.Use,
+		Short:             buildCmd.Short,
+		Long:              buildCmd.Long,
+		RunE:              buildCmd.RunE,
+		ValidArgsFunction: buildCmd.ValidArgsFunction,
 		Example: `podman image build .
   podman image build --creds=username:password -t imageName -f Containerfile.simple .
   podman image build --layers --force-rm --tag imageName .`,
@@ -79,22 +81,25 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: buildCmd,
 	})
-	buildFlags(buildCmd.Flags())
+	buildFlags(buildCmd)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: imageBuildCmd,
 		Parent:  imageCmd,
 	})
-	buildFlags(imageBuildCmd.Flags())
+	buildFlags(imageBuildCmd)
 }
 
-func buildFlags(flags *pflag.FlagSet) {
+func buildFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	// Podman flags
 	flags.BoolVarP(&buildOpts.SquashAll, "squash-all", "", false, "Squash all layers into a single layer")
 
 	// Bud flags
 	budFlags := buildahCLI.GetBudFlags(&buildOpts.BudResults)
+
 	// --pull flag
 	flag := budFlags.Lookup("pull")
 	if err := flag.Value.Set("true"); err != nil {
@@ -102,6 +107,9 @@ func buildFlags(flags *pflag.FlagSet) {
 	}
 	flag.DefValue = "true"
 	flags.AddFlagSet(&budFlags)
+	// Add the completion functions
+	budCompletions := buildahCLI.GetBudFlagsCompletions()
+	completion.CompleteCommandFlags(cmd, budCompletions)
 
 	// Layer flags
 	layerFlags := buildahCLI.GetLayerFlags(&buildOpts.LayerResults)
@@ -127,6 +135,9 @@ func buildFlags(flags *pflag.FlagSet) {
 		os.Exit(1)
 	}
 	flags.AddFlagSet(&fromAndBudFlags)
+	// Add the completion functions
+	fromAndBudFlagsCompletions := buildahCLI.GetFromAndBudFlagsCompletions()
+	completion.CompleteCommandFlags(cmd, fromAndBudFlagsCompletions)
 	_ = flags.MarkHidden("signature-policy")
 }
 

cmd/podman/images/diff.go

@@ -13,11 +13,12 @@ import (
 var (
 	// podman container _inspect_
 	diffCmd = &cobra.Command{
-		Use:   "diff [options] IMAGE",
-		Args:  cobra.ExactArgs(1),
-		Short: "Inspect changes to the image's file systems",
-		Long:  `Displays changes to the image's filesystem.  The image will be compared to its parent layer.`,
-		RunE:  diff,
+		Use:               "diff [options] IMAGE",
+		Args:              cobra.ExactArgs(1),
+		Short:             "Inspect changes to the image's file systems",
+		Long:              `Displays changes to the image's filesystem.  The image will be compared to its parent layer.`,
+		RunE:              diff,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman image diff myImage
   podman image diff --format json redis:alpine`,
 	}
@@ -37,7 +38,10 @@ func diffFlags(flags *pflag.FlagSet) {
 	diffOpts = &entities.DiffOptions{}
 	flags.BoolVar(&diffOpts.Archive, "archive", true, "Save the diff as a tar archive")
 	_ = flags.MarkDeprecated("archive", "Provided for backwards compatibility, has no impact on output.")
-	flags.StringVar(&diffOpts.Format, "format", "", "Change the output format")
+
+	formatFlagName := "format"
+	flags.StringVar(&diffOpts.Format, formatFlagName, "", "Change the output format")
+	_ = diffCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
 }
 
 func diff(cmd *cobra.Command, args []string) error {

cmd/podman/images/exists.go

@@ -1,6 +1,7 @@
 package images
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -8,11 +9,12 @@ import (
 
 var (
 	existsCmd = &cobra.Command{
-		Use:   "exists IMAGE",
-		Short: "Check if an image exists in local storage",
-		Long:  `If the named image exists in local storage, podman image exists exits with 0, otherwise the exit code will be 1.`,
-		Args:  cobra.ExactArgs(1),
-		RunE:  exists,
+		Use:               "exists IMAGE",
+		Short:             "Check if an image exists in local storage",
+		Long:              `If the named image exists in local storage, podman image exists exits with 0, otherwise the exit code will be 1.`,
+		Args:              cobra.ExactArgs(1),
+		RunE:              exists,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman image exists ID
   podman image exists IMAGE && podman pull IMAGE`,
 		DisableFlagsInUseLine: true,

cmd/podman/images/history.go

@@ -11,13 +11,13 @@ import (
 	"unicode"
 
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/docker/go-units"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -27,21 +27,23 @@ var (
 
 	// podman _history_
 	historyCmd = &cobra.Command{
-		Use:     "history [options] IMAGE",
-		Short:   "Show history of a specified image",
-		Long:    long,
-		Args:    cobra.ExactArgs(1),
-		RunE:    history,
-		Example: "podman history quay.io/fedora/fedora",
+		Use:               "history [options] IMAGE",
+		Short:             "Show history of a specified image",
+		Long:              long,
+		Args:              cobra.ExactArgs(1),
+		RunE:              history,
+		ValidArgsFunction: common.AutocompleteImages,
+		Example:           "podman history quay.io/fedora/fedora",
 	}
 
 	imageHistoryCmd = &cobra.Command{
-		Args:    historyCmd.Args,
-		Use:     historyCmd.Use,
-		Short:   historyCmd.Short,
-		Long:    historyCmd.Long,
-		RunE:    historyCmd.RunE,
-		Example: `podman image history quay.io/fedora/fedora`,
+		Args:              historyCmd.Args,
+		Use:               historyCmd.Use,
+		Short:             historyCmd.Short,
+		Long:              historyCmd.Long,
+		ValidArgsFunction: historyCmd.ValidArgsFunction,
+		RunE:              historyCmd.RunE,
+		Example:           `podman image history quay.io/fedora/fedora`,
 	}
 
 	opts = struct {
@@ -57,18 +59,23 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: historyCmd,
 	})
-	historyFlags(historyCmd.Flags())
+	historyFlags(historyCmd)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: imageHistoryCmd,
 		Parent:  imageCmd,
 	})
-	historyFlags(imageHistoryCmd.Flags())
+	historyFlags(imageHistoryCmd)
 }
 
-func historyFlags(flags *pflag.FlagSet) {
-	flags.StringVar(&opts.format, "format", "", "Change the output to JSON or a Go template")
+func historyFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	formatFlagName := "format"
+	flags.StringVar(&opts.format, formatFlagName, "", "Change the output to JSON or a Go template")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVarP(&opts.human, "human", "H", true, "Display sizes and dates in human readable format")
 	flags.BoolVar(&opts.noTrunc, "no-trunc", false, "Do not truncate the output")
 	flags.BoolVar(&opts.noTrunc, "notruncate", false, "Do not truncate the output")

cmd/podman/images/images.go

@@ -16,6 +16,7 @@ var (
 		Short:                 listCmd.Short,
 		Long:                  listCmd.Long,
 		RunE:                  listCmd.RunE,
+		ValidArgsFunction:     listCmd.ValidArgsFunction,
 		Example:               strings.Replace(listCmd.Example, "podman image list", "podman images", -1),
 		DisableFlagsInUseLine: true,
 	}
@@ -27,5 +28,5 @@ func init() {
 		Command: imagesCmd,
 	})
 
-	imageListFlagSet(imagesCmd.Flags())
+	imageListFlagSet(imagesCmd)
 }

cmd/podman/images/import.go

@@ -3,14 +3,16 @@ package images
 import (
 	"context"
 	"fmt"
+	"strings"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/hashicorp/go-multierror"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -19,21 +21,23 @@ var (
   Note remote tar balls can be specified, via web address.
   Optionally tag the image. You can specify the instructions using the --change option.`
 	importCommand = &cobra.Command{
-		Use:   "import [options] PATH [REFERENCE]",
-		Short: "Import a tarball to create a filesystem image",
-		Long:  importDescription,
-		RunE:  importCon,
+		Use:               "import [options] PATH [REFERENCE]",
+		Short:             "Import a tarball to create a filesystem image",
+		Long:              importDescription,
+		RunE:              importCon,
+		ValidArgsFunction: completion.AutocompleteDefault,
 		Example: `podman import http://example.com/ctr.tar url-image
   cat ctr.tar | podman -q import --message "importing the ctr.tar tarball" - image-imported
   cat ctr.tar | podman import -`,
 	}
 
 	imageImportCommand = &cobra.Command{
-		Args:  cobra.MinimumNArgs(1),
-		Use:   importCommand.Use,
-		Short: importCommand.Short,
-		Long:  importCommand.Long,
-		RunE:  importCommand.RunE,
+		Args:              cobra.MinimumNArgs(1),
+		Use:               importCommand.Use,
+		Short:             importCommand.Short,
+		Long:              importCommand.Long,
+		RunE:              importCommand.RunE,
+		ValidArgsFunction: importCommand.ValidArgsFunction,
 		Example: `podman image import http://example.com/ctr.tar url-image
   cat ctr.tar | podman -q image import --message "importing the ctr.tar tarball" - image-imported
   cat ctr.tar | podman image import -`,
@@ -49,19 +53,27 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: importCommand,
 	})
-	importFlags(importCommand.Flags())
+	importFlags(importCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: imageImportCommand,
 		Parent:  imageCmd,
 	})
-	importFlags(imageImportCommand.Flags())
+	importFlags(imageImportCommand)
 }
 
-func importFlags(flags *pflag.FlagSet) {
-	flags.StringArrayVarP(&importOpts.Changes, "change", "c", []string{}, "Apply the following possible instructions to the created image (default []): CMD | ENTRYPOINT | ENV | EXPOSE | LABEL | STOPSIGNAL | USER | VOLUME | WORKDIR")
-	flags.StringVarP(&importOpts.Message, "message", "m", "", "Set commit message for imported image")
+func importFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	changeFlagName := "change"
+	flags.StringArrayVarP(&importOpts.Changes, changeFlagName, "c", []string{}, "Apply the following possible instructions to the created image (default []): "+strings.Join(common.ChangeCmds, " | "))
+	_ = cmd.RegisterFlagCompletionFunc(changeFlagName, common.AutocompleteChangeInstructions)
+
+	messageFlagName := "message"
+	flags.StringVarP(&importOpts.Message, messageFlagName, "m", "", "Set commit message for imported image")
+	_ = cmd.RegisterFlagCompletionFunc(messageFlagName, completion.AutocompleteNone)
+
 	flags.BoolVarP(&importOpts.Quiet, "quiet", "q", false, "Suppress output")
 	flags.StringVar(&importOpts.SignaturePolicy, "signature-policy", "", "Path to a signature-policy file")
 	_ = flags.MarkHidden("signature-policy")

cmd/podman/images/inspect.go

@@ -1,6 +1,7 @@
 package images
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/inspect"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -10,10 +11,11 @@ import (
 var (
 	// Command: podman image _inspect_
 	inspectCmd = &cobra.Command{
-		Use:   "inspect [options] IMAGE [IMAGE...]",
-		Short: "Display the configuration of an image",
-		Long:  `Displays the low-level information of an image identified by name or ID.`,
-		RunE:  inspectExec,
+		Use:               "inspect [options] IMAGE [IMAGE...]",
+		Short:             "Display the configuration of an image",
+		Long:              `Displays the low-level information of an image identified by name or ID.`,
+		RunE:              inspectExec,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman inspect alpine
   podman inspect --format "imageId: {{.Id}} size: {{.Size}}" alpine
   podman inspect --format "image: {{.ImageName}} driver: {{.Driver}}" myctr`,
@@ -29,7 +31,10 @@ func init() {
 	})
 	inspectOpts = new(entities.InspectOptions)
 	flags := inspectCmd.Flags()
-	flags.StringVarP(&inspectOpts.Format, "format", "f", "json", "Format the output to a Go template or json")
+
+	formatFlagName := "format"
+	flags.StringVarP(&inspectOpts.Format, formatFlagName, "f", "json", "Format the output to a Go template or json")
+	_ = inspectCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
 }
 
 func inspectExec(cmd *cobra.Command, args []string) error {

cmd/podman/images/list.go

@@ -10,15 +10,16 @@ import (
 	"time"
 	"unicode"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
 	"github.com/containers/image/v5/docker/reference"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/docker/go-units"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 type listFlagType struct {
@@ -35,12 +36,13 @@ type listFlagType struct {
 var (
 	// Command: podman image _list_
 	listCmd = &cobra.Command{
-		Use:     "list [options] [IMAGE]",
-		Aliases: []string{"ls"},
-		Args:    cobra.MaximumNArgs(1),
-		Short:   "List images in local storage",
-		Long:    "Lists images previously pulled to the system or created on the system.",
-		RunE:    images,
+		Use:               "list [options] [IMAGE]",
+		Aliases:           []string{"ls"},
+		Args:              cobra.MaximumNArgs(1),
+		Short:             "List images in local storage",
+		Long:              "Lists images previously pulled to the system or created on the system.",
+		RunE:              images,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman image list --format json
   podman image list --sort repository --format "table {{.ID}} {{.Repository}} {{.Tag}}"
   podman image list --filter dangling=true`,
@@ -67,18 +69,32 @@ func init() {
 		Command: listCmd,
 		Parent:  imageCmd,
 	})
-	imageListFlagSet(listCmd.Flags())
+	imageListFlagSet(listCmd)
 }
 
-func imageListFlagSet(flags *pflag.FlagSet) {
+func imageListFlagSet(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&listOptions.All, "all", "a", false, "Show all images (default hides intermediate images)")
-	flags.StringSliceVarP(&listOptions.Filter, "filter", "f", []string{}, "Filter output based on conditions provided (default [])")
-	flags.StringVar(&listFlag.format, "format", "", "Change the output format to JSON or a Go template")
+
+	filterFlagName := "filter"
+	flags.StringSliceVarP(&listOptions.Filter, filterFlagName, "f", []string{}, "Filter output based on conditions provided (default [])")
+	// TODO: add completion function for filters
+	_ = cmd.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
+
+	formatFlagName := "format"
+	flags.StringVar(&listFlag.format, formatFlagName, "", "Change the output format to JSON or a Go template")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVar(&listFlag.digests, "digests", false, "Show digests")
 	flags.BoolVarP(&listFlag.noHeading, "noheading", "n", false, "Do not print column headings")
 	flags.BoolVar(&listFlag.noTrunc, "no-trunc", false, "Do not truncate output")
 	flags.BoolVarP(&listFlag.quiet, "quiet", "q", false, "Display only image IDs")
-	flags.StringVar(&listFlag.sort, "sort", "created", "Sort by "+sortFields.String())
+
+	sortFlagName := "sort"
+	flags.StringVar(&listFlag.sort, sortFlagName, "created", "Sort by "+sortFields.String())
+	_ = cmd.RegisterFlagCompletionFunc(sortFlagName, completion.AutocompleteNone)
+
 	flags.BoolVarP(&listFlag.history, "history", "", false, "Display the image name history")
 }
 

cmd/podman/images/load.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/docker/reference"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
@@ -15,26 +16,27 @@ import (
 	"github.com/containers/podman/v2/pkg/util"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 	"golang.org/x/crypto/ssh/terminal"
 )
 
 var (
 	loadDescription = "Loads an image from a locally stored archive (tar file) into container storage."
 	loadCommand     = &cobra.Command{
-		Use:   "load [options] [NAME[:TAG]]",
-		Short: "Load an image from container archive",
-		Long:  loadDescription,
-		RunE:  load,
-		Args:  cobra.MaximumNArgs(1),
+		Use:               "load [options] [NAME[:TAG]]",
+		Short:             "Load an image from container archive",
+		Long:              loadDescription,
+		RunE:              load,
+		Args:              cobra.MaximumNArgs(1),
+		ValidArgsFunction: completion.AutocompleteNone,
 	}
 
 	imageLoadCommand = &cobra.Command{
-		Args:  loadCommand.Args,
-		Use:   loadCommand.Use,
-		Short: loadCommand.Short,
-		Long:  loadCommand.Long,
-		RunE:  loadCommand.RunE,
+		Args:              loadCommand.Args,
+		Use:               loadCommand.Use,
+		Short:             loadCommand.Short,
+		Long:              loadCommand.Long,
+		ValidArgsFunction: loadCommand.ValidArgsFunction,
+		RunE:              loadCommand.RunE,
 	}
 )
 
@@ -47,17 +49,22 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: loadCommand,
 	})
-	loadFlags(loadCommand.Flags())
+	loadFlags(loadCommand)
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: imageLoadCommand,
 		Parent:  imageCmd,
 	})
-	loadFlags(imageLoadCommand.Flags())
+	loadFlags(imageLoadCommand)
 }
 
-func loadFlags(flags *pflag.FlagSet) {
-	flags.StringVarP(&loadOpts.Input, "input", "i", "", "Read from specified archive file (default: stdin)")
+func loadFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	inputFlagName := "input"
+	flags.StringVarP(&loadOpts.Input, inputFlagName, "i", "", "Read from specified archive file (default: stdin)")
+	_ = cmd.RegisterFlagCompletionFunc(inputFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVarP(&loadOpts.Quiet, "quiet", "q", false, "Suppress the output")
 	flags.StringVar(&loadOpts.SignaturePolicy, "signature-policy", "", "Pathname of signature policy file")
 	_ = flags.MarkHidden("signature-policy")

cmd/podman/images/mount.go

@@ -7,12 +7,12 @@ import (
 	"text/template"
 
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
@@ -24,10 +24,11 @@ var (
 `
 
 	mountCommand = &cobra.Command{
-		Use:   "mount [options] [IMAGE...]",
-		Short: "Mount an image's root filesystem",
-		Long:  mountDescription,
-		RunE:  mount,
+		Use:               "mount [options] [IMAGE...]",
+		Short:             "Mount an image's root filesystem",
+		Long:              mountDescription,
+		RunE:              mount,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman image mount imgID
   podman image mount imgID1 imgID2 imgID3
   podman image mount
@@ -43,9 +44,14 @@ var (
 	mountOpts entities.ImageMountOptions
 )
 
-func mountFlags(flags *pflag.FlagSet) {
+func mountFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVarP(&mountOpts.All, "all", "a", false, "Mount all images")
-	flags.StringVar(&mountOpts.Format, "format", "", "Print the mounted images in specified format (json)")
+
+	formatFlagName := "format"
+	flags.StringVar(&mountOpts.Format, formatFlagName, "", "Print the mounted images in specified format (json)")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
 }
 
 func init() {
@@ -54,7 +60,7 @@ func init() {
 		Command: mountCommand,
 		Parent:  imageCmd,
 	})
-	mountFlags(mountCommand.Flags())
+	mountFlags(mountCommand)
 }
 
 func mount(cmd *cobra.Command, args []string) error {

cmd/podman/images/prune.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -19,12 +20,13 @@ var (
 
   If an image is not being used by a container, it will be removed from the system.`
 	pruneCmd = &cobra.Command{
-		Use:     "prune [options]",
-		Args:    validate.NoArgs,
-		Short:   "Remove unused images",
-		Long:    pruneDescription,
-		RunE:    prune,
-		Example: `podman image prune`,
+		Use:               "prune [options]",
+		Args:              validate.NoArgs,
+		Short:             "Remove unused images",
+		Long:              pruneDescription,
+		RunE:              prune,
+		ValidArgsFunction: completion.AutocompleteNone,
+		Example:           `podman image prune`,
 	}
 
 	pruneOpts = entities.ImagePruneOptions{}
@@ -42,7 +44,11 @@ func init() {
 	flags := pruneCmd.Flags()
 	flags.BoolVarP(&pruneOpts.All, "all", "a", false, "Remove all unused images, not just dangling ones")
 	flags.BoolVarP(&force, "force", "f", false, "Do not prompt for confirmation")
-	flags.StringArrayVar(&filter, "filter", []string{}, "Provide filter values (e.g. 'label=<key>=<value>')")
+
+	filterFlagName := "filter"
+	flags.StringArrayVar(&filter, filterFlagName, []string{}, "Provide filter values (e.g. 'label=<key>=<value>')")
+	//TODO: add completion for filters
+	_ = pruneCmd.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
 
 }
 

cmd/podman/images/pull.go

@@ -5,12 +5,13 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/util"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // pullOptionsWrapper wraps entities.ImagePullOptions and prevents leaking
@@ -29,11 +30,12 @@ var (
 
 	// Command: podman pull
 	pullCmd = &cobra.Command{
-		Use:   "pull [options] IMAGE",
-		Args:  cobra.ExactArgs(1),
-		Short: "Pull an image from a registry",
-		Long:  pullDescription,
-		RunE:  imagePull,
+		Use:               "pull [options] IMAGE",
+		Args:              cobra.ExactArgs(1),
+		Short:             "Pull an image from a registry",
+		Long:              pullDescription,
+		RunE:              imagePull,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman pull imageName
   podman pull fedora:latest`,
 	}
@@ -42,11 +44,12 @@ var (
 	// It's basically a clone of `pullCmd` with the exception of being a
 	// child of the images command.
 	imagesPullCmd = &cobra.Command{
-		Use:   pullCmd.Use,
-		Args:  pullCmd.Args,
-		Short: pullCmd.Short,
-		Long:  pullCmd.Long,
-		RunE:  pullCmd.RunE,
+		Use:               pullCmd.Use,
+		Args:              pullCmd.Args,
+		Short:             pullCmd.Short,
+		Long:              pullCmd.Long,
+		RunE:              pullCmd.RunE,
+		ValidArgsFunction: pullCmd.ValidArgsFunction,
 		Example: `podman image pull imageName
   podman image pull fedora:latest`,
 	}
@@ -58,9 +61,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: pullCmd,
 	})
-
-	flags := pullCmd.Flags()
-	pullFlags(flags)
+	pullFlags(pullCmd)
 
 	// images pull
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -68,26 +69,46 @@ func init() {
 		Command: imagesPullCmd,
 		Parent:  imageCmd,
 	})
-
-	imagesPullFlags := imagesPullCmd.Flags()
-	pullFlags(imagesPullFlags)
+	pullFlags(imagesPullCmd)
 }
 
 // pullFlags set the flags for the pull command.
-func pullFlags(flags *pflag.FlagSet) {
+func pullFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVar(&pullOptions.AllTags, "all-tags", false, "All tagged images in the repository will be pulled")
-	flags.StringVar(&pullOptions.CredentialsCLI, "creds", "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
-	flags.StringVar(&pullOptions.OverrideArch, "override-arch", "", "Use `ARCH` instead of the architecture of the machine for choosing images")
-	flags.StringVar(&pullOptions.OverrideOS, "override-os", "", "Use `OS` instead of the running OS for choosing images")
-	flags.StringVar(&pullOptions.OverrideVariant, "override-variant", "", " use VARIANT instead of the running architecture variant for choosing images")
+
+	credsFlagName := "creds"
+	flags.StringVar(&pullOptions.CredentialsCLI, credsFlagName, "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
+	_ = cmd.RegisterFlagCompletionFunc(credsFlagName, completion.AutocompleteNone)
+
+	overrideArchFlagName := "override-arch"
+	flags.StringVar(&pullOptions.OverrideArch, overrideArchFlagName, "", "Use `ARCH` instead of the architecture of the machine for choosing images")
+	_ = cmd.RegisterFlagCompletionFunc(overrideArchFlagName, completion.AutocompleteNone)
+
+	overrideOsFlagName := "override-os"
+	flags.StringVar(&pullOptions.OverrideOS, overrideOsFlagName, "", "Use `OS` instead of the running OS for choosing images")
+	_ = cmd.RegisterFlagCompletionFunc(overrideOsFlagName, completion.AutocompleteNone)
+
+	overrideVariantFlagName := "override-variant"
+	flags.StringVar(&pullOptions.OverrideVariant, overrideVariantFlagName, "", " use VARIANT instead of the running architecture variant for choosing images")
+	_ = cmd.RegisterFlagCompletionFunc(overrideVariantFlagName, completion.AutocompleteNone)
+
 	flags.Bool("disable-content-trust", false, "This is a Docker specific option and is a NOOP")
 	flags.BoolVarP(&pullOptions.Quiet, "quiet", "q", false, "Suppress output information when pulling images")
 	flags.StringVar(&pullOptions.SignaturePolicy, "signature-policy", "", "`Pathname` of signature policy file (not usually used)")
 	flags.BoolVar(&pullOptions.TLSVerifyCLI, "tls-verify", true, "Require HTTPS and verify certificates when contacting registries")
-	flags.StringVar(&pullOptions.Authfile, "authfile", auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&pullOptions.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = cmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
 
 	if !registry.IsRemote() {
-		flags.StringVar(&pullOptions.CertDir, "cert-dir", "", "`Pathname` of a directory containing TLS certificates and keys")
+
+		certDirFlagName := "cert-dir"
+		flags.StringVar(&pullOptions.CertDir, certDirFlagName, "", "`Pathname` of a directory containing TLS certificates and keys")
+		_ = cmd.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
+
 	}
 	_ = flags.MarkHidden("signature-policy")
 }

cmd/podman/images/push.go

@@ -4,12 +4,13 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/util"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // pushOptionsWrapper wraps entities.ImagepushOptions and prevents leaking
@@ -28,11 +29,12 @@ var (
 
 	// Command: podman push
 	pushCmd = &cobra.Command{
-		Use:   "push [options] SOURCE [DESTINATION]",
-		Short: "Push an image to a specified destination",
-		Long:  pushDescription,
-		RunE:  imagePush,
-		Args:  cobra.RangeArgs(1, 2),
+		Use:               "push [options] SOURCE [DESTINATION]",
+		Short:             "Push an image to a specified destination",
+		Long:              pushDescription,
+		RunE:              imagePush,
+		Args:              cobra.RangeArgs(1, 2),
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman push imageID docker://registry.example.com/repository:tag
 		podman push imageID oci-archive:/path/to/layout:image:tag`,
 	}
@@ -41,11 +43,12 @@ var (
 	// It's basically a clone of `pushCmd` with the exception of being a
 	// child of the images command.
 	imagePushCmd = &cobra.Command{
-		Use:   pushCmd.Use,
-		Short: pushCmd.Short,
-		Long:  pushCmd.Long,
-		RunE:  pushCmd.RunE,
-		Args:  pushCmd.Args,
+		Use:               pushCmd.Use,
+		Short:             pushCmd.Short,
+		Long:              pushCmd.Long,
+		RunE:              pushCmd.RunE,
+		Args:              pushCmd.Args,
+		ValidArgsFunction: pushCmd.ValidArgsFunction,
 		Example: `podman image push imageID docker://registry.example.com/repository:tag
 		podman image push imageID oci-archive:/path/to/layout:image:tag`,
 	}
@@ -57,9 +60,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: pushCmd,
 	})
-
-	flags := pushCmd.Flags()
-	pushFlags(flags)
+	pushFlags(pushCmd)
 
 	// images push
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -67,23 +68,45 @@ func init() {
 		Command: imagePushCmd,
 		Parent:  imageCmd,
 	})
-
-	pushFlags(imagePushCmd.Flags())
+	pushFlags(imagePushCmd)
 }
 
 // pushFlags set the flags for the push command.
-func pushFlags(flags *pflag.FlagSet) {
-	flags.StringVar(&pushOptions.Authfile, "authfile", auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
-	flags.StringVar(&pushOptions.CertDir, "cert-dir", "", "Path to a directory containing TLS certificates and keys")
+func pushFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&pushOptions.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = cmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
+
+	certDirFlagName := "cert-dir"
+	flags.StringVar(&pushOptions.CertDir, certDirFlagName, "", "Path to a directory containing TLS certificates and keys")
+	_ = cmd.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVar(&pushOptions.Compress, "compress", false, "Compress tarball image layers when pushing to a directory using the 'dir' transport. (default is same compression type as source)")
-	flags.StringVar(&pushOptions.CredentialsCLI, "creds", "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
-	flags.StringVar(&pushOptions.DigestFile, "digestfile", "", "Write the digest of the pushed image to the specified file")
+
+	credsFlagName := "creds"
+	flags.StringVar(&pushOptions.CredentialsCLI, credsFlagName, "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
+	_ = cmd.RegisterFlagCompletionFunc(credsFlagName, completion.AutocompleteNone)
+
 	flags.Bool("disable-content-trust", false, "This is a Docker specific option and is a NOOP")
-	flags.StringVarP(&pushOptions.Format, "format", "f", "", "Manifest type (oci, v2s1, or v2s2) to use when pushing an image using the 'dir' transport (default is manifest type of source)")
+
+	digestfileFlagName := "digestfile"
+	flags.StringVar(&pushOptions.DigestFile, digestfileFlagName, "", "Write the digest of the pushed image to the specified file")
+	_ = cmd.RegisterFlagCompletionFunc(digestfileFlagName, completion.AutocompleteDefault)
+
+	formatFlagName := "format"
+	flags.StringVarP(&pushOptions.Format, formatFlagName, "f", "", "Manifest type (oci, v2s1, or v2s2) to use when pushing an image using the 'dir' transport (default is manifest type of source)")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteManifestFormat)
+
 	flags.BoolVarP(&pushOptions.Quiet, "quiet", "q", false, "Suppress output information when pushing images")
 	flags.BoolVar(&pushOptions.RemoveSignatures, "remove-signatures", false, "Discard any pre-existing signatures in the image")
 	flags.StringVar(&pushOptions.SignaturePolicy, "signature-policy", "", "Path to a signature-policy file")
-	flags.StringVar(&pushOptions.SignBy, "sign-by", "", "Add a signature at the destination using the specified key")
+
+	signByFlagName := "sign-by"
+	flags.StringVar(&pushOptions.SignBy, signByFlagName, "", "Add a signature at the destination using the specified key")
+	_ = cmd.RegisterFlagCompletionFunc(signByFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&pushOptions.TLSVerifyCLI, "tls-verify", true, "Require HTTPS and verify certificates when contacting registries")
 
 	if registry.IsRemote() {

cmd/podman/images/rm.go

@@ -3,6 +3,7 @@ package images
 import (
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/errorhandling"
@@ -14,10 +15,11 @@ import (
 var (
 	rmDescription = "Removes one or more previously pulled or locally created images."
 	rmCmd         = &cobra.Command{
-		Use:   "rm [options] IMAGE [IMAGE...]",
-		Short: "Removes one or more images from local storage",
-		Long:  rmDescription,
-		RunE:  rm,
+		Use:               "rm [options] IMAGE [IMAGE...]",
+		Short:             "Removes one or more images from local storage",
+		Long:              rmDescription,
+		RunE:              rm,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman image rm imageID
   podman image rm --force alpine
   podman image rm c4dfb1609ee2 93fd78260bd1 c0ed59d05ff7`,

cmd/podman/images/rmi.go

@@ -10,12 +10,13 @@ import (
 
 var (
 	rmiCmd = &cobra.Command{
-		Use:     strings.Replace(rmCmd.Use, "rm ", "rmi ", 1),
-		Args:    rmCmd.Args,
-		Short:   rmCmd.Short,
-		Long:    rmCmd.Long,
-		RunE:    rmCmd.RunE,
-		Example: strings.Replace(rmCmd.Example, "podman image rm", "podman rmi", -1),
+		Use:               strings.Replace(rmCmd.Use, "rm ", "rmi ", 1),
+		Args:              rmCmd.Args,
+		Short:             rmCmd.Short,
+		Long:              rmCmd.Long,
+		RunE:              rmCmd.RunE,
+		ValidArgsFunction: rmCmd.ValidArgsFunction,
+		Example:           strings.Replace(rmCmd.Example, "podman image rm", "podman rmi", -1),
 	}
 )
 

cmd/podman/images/save.go

@@ -5,6 +5,8 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/libpod/define"
@@ -12,7 +14,6 @@ import (
 	"github.com/containers/podman/v2/pkg/util"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 	"golang.org/x/crypto/ssh/terminal"
 )
 
@@ -42,16 +43,18 @@ var (
 			}
 			return nil
 		},
+		ValidArgsFunction: completion.AutocompleteNone,
 		Example: `podman save --quiet -o myimage.tar imageID
   podman save --format docker-dir -o ubuntu-dir ubuntu
   podman save > alpine-all.tar alpine:latest`,
 	}
 	imageSaveCommand = &cobra.Command{
-		Args:  saveCommand.Args,
-		Use:   saveCommand.Use,
-		Short: saveCommand.Short,
-		Long:  saveCommand.Long,
-		RunE:  saveCommand.RunE,
+		Args:              saveCommand.Args,
+		Use:               saveCommand.Use,
+		Short:             saveCommand.Short,
+		Long:              saveCommand.Long,
+		RunE:              saveCommand.RunE,
+		ValidArgsFunction: saveCommand.ValidArgsFunction,
 		Example: `podman image save --quiet -o myimage.tar imageID
   podman image save --format docker-dir -o ubuntu-dir ubuntu
   podman image save > alpine-all.tar alpine:latest`,
@@ -67,20 +70,29 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: saveCommand,
 	})
-	saveFlags(saveCommand.Flags())
+	saveFlags(saveCommand)
 
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: imageSaveCommand,
 		Parent:  imageCmd,
 	})
-	saveFlags(imageSaveCommand.Flags())
+	saveFlags(imageSaveCommand)
 }
 
-func saveFlags(flags *pflag.FlagSet) {
+func saveFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
 	flags.BoolVar(&saveOpts.Compress, "compress", false, "Compress tarball image layers when saving to a directory using the 'dir' transport. (default is same compression type as source)")
-	flags.StringVar(&saveOpts.Format, "format", define.V2s2Archive, "Save image to oci-archive, oci-dir (directory with oci manifest type), docker-archive, docker-dir (directory with v2s2 manifest type)")
-	flags.StringVarP(&saveOpts.Output, "output", "o", "", "Write to a specified file (default: stdout, which must be redirected)")
+
+	formatFlagName := "format"
+	flags.StringVar(&saveOpts.Format, formatFlagName, define.V2s2Archive, "Save image to oci-archive, oci-dir (directory with oci manifest type), docker-archive, docker-dir (directory with v2s2 manifest type)")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteImageSaveFormat)
+
+	outputFlagName := "output"
+	flags.StringVarP(&saveOpts.Output, outputFlagName, "o", "", "Write to a specified file (default: stdout, which must be redirected)")
+	_ = cmd.RegisterFlagCompletionFunc(outputFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVarP(&saveOpts.Quiet, "quiet", "q", false, "Suppress the output")
 	flags.BoolVarP(&saveOpts.MultiImageArchive, "multi-image-archive", "m", containerConfig.Engine.MultiImageArchive, "Interpret additional arguments as images not tags and create a multi-image-archive (only for docker-archive)")
 }

cmd/podman/images/search.go

@@ -7,6 +7,7 @@ import (
 	"text/template"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
 	"github.com/containers/image/v5/types"
 	"github.com/containers/podman/v2/cmd/podman/parse"
@@ -14,7 +15,6 @@ import (
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // searchOptionsWrapper wraps entities.ImagePullOptions and prevents leaking
@@ -34,11 +34,12 @@ var (
 
 	// Command: podman search
 	searchCmd = &cobra.Command{
-		Use:   "search [options] TERM",
-		Short: "Search registry for image",
-		Long:  searchDescription,
-		RunE:  imageSearch,
-		Args:  cobra.ExactArgs(1),
+		Use:               "search [options] TERM",
+		Short:             "Search registry for image",
+		Long:              searchDescription,
+		RunE:              imageSearch,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: completion.AutocompleteNone,
 		Example: `podman search --filter=is-official --limit 3 alpine
   podman search registry.fedoraproject.org/  # only works with v2 registries
   podman search --format "table {{.Index}} {{.Name}}" registry.fedoraproject.org/fedora`,
@@ -46,12 +47,13 @@ var (
 
 	// Command: podman image search
 	imageSearchCmd = &cobra.Command{
-		Use:         searchCmd.Use,
-		Short:       searchCmd.Short,
-		Long:        searchCmd.Long,
-		RunE:        searchCmd.RunE,
-		Args:        searchCmd.Args,
-		Annotations: searchCmd.Annotations,
+		Use:               searchCmd.Use,
+		Short:             searchCmd.Short,
+		Long:              searchCmd.Long,
+		RunE:              searchCmd.RunE,
+		Args:              searchCmd.Args,
+		Annotations:       searchCmd.Annotations,
+		ValidArgsFunction: searchCmd.ValidArgsFunction,
 		Example: `podman image search --filter=is-official --limit 3 alpine
   podman image search registry.fedoraproject.org/  # only works with v2 registries
   podman image search --format "table {{.Index}} {{.Name}}" registry.fedoraproject.org/fedora`,
@@ -64,9 +66,7 @@ func init() {
 		Mode:    []entities.EngineMode{entities.ABIMode, entities.TunnelMode},
 		Command: searchCmd,
 	})
-
-	flags := searchCmd.Flags()
-	searchFlags(flags)
+	searchFlags(searchCmd)
 
 	// images search
 	registry.Commands = append(registry.Commands, registry.CliCommand{
@@ -74,18 +74,32 @@ func init() {
 		Command: imageSearchCmd,
 		Parent:  imageCmd,
 	})
-
-	imageSearchFlags := imageSearchCmd.Flags()
-	searchFlags(imageSearchFlags)
+	searchFlags(imageSearchCmd)
 }
 
 // searchFlags set the flags for the pull command.
-func searchFlags(flags *pflag.FlagSet) {
-	flags.StringSliceVarP(&searchOptions.Filters, "filter", "f", []string{}, "Filter output based on conditions provided (default [])")
-	flags.StringVar(&searchOptions.Format, "format", "", "Change the output format to JSON or a Go template")
-	flags.IntVar(&searchOptions.Limit, "limit", 0, "Limit the number of results")
+func searchFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	filterFlagName := "filter"
+	flags.StringSliceVarP(&searchOptions.Filters, filterFlagName, "f", []string{}, "Filter output based on conditions provided (default [])")
+	//TODO add custom filter function
+	_ = cmd.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
+
+	formatFlagName := "format"
+	flags.StringVar(&searchOptions.Format, formatFlagName, "", "Change the output format to JSON or a Go template")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, completion.AutocompleteNone)
+
+	limitFlagName := "limit"
+	flags.IntVar(&searchOptions.Limit, limitFlagName, 0, "Limit the number of results")
+	_ = cmd.RegisterFlagCompletionFunc(limitFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&searchOptions.NoTrunc, "no-trunc", false, "Do not truncate the output")
-	flags.StringVar(&searchOptions.Authfile, "authfile", auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&searchOptions.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = cmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVar(&searchOptions.TLSVerifyCLI, "tls-verify", true, "Require HTTPS and verify certificates when contacting registries")
 	flags.BoolVar(&searchOptions.ListTags, "list-tags", false, "List the tags of the input registry")
 }

cmd/podman/images/sign.go

@@ -3,6 +3,8 @@ package images
 import (
 	"os"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
@@ -12,11 +14,12 @@ import (
 var (
 	signDescription = "Create a signature file that can be used later to verify the image."
 	signCommand     = &cobra.Command{
-		Use:   "sign [options] IMAGE [IMAGE...]",
-		Short: "Sign an image",
-		Long:  signDescription,
-		RunE:  sign,
-		Args:  cobra.MinimumNArgs(1),
+		Use:               "sign [options] IMAGE [IMAGE...]",
+		Short:             "Sign an image",
+		Long:              signDescription,
+		RunE:              sign,
+		Args:              cobra.MinimumNArgs(1),
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman image sign --sign-by mykey imageID
   podman image sign --sign-by mykey --directory ./mykeydir imageID`,
 	}
@@ -33,9 +36,17 @@ func init() {
 		Parent:  imageCmd,
 	})
 	flags := signCommand.Flags()
-	flags.StringVarP(&signOptions.Directory, "directory", "d", "", "Define an alternate directory to store signatures")
-	flags.StringVar(&signOptions.SignBy, "sign-by", "", "Name of the signing key")
-	flags.StringVar(&signOptions.CertDir, "cert-dir", "", "`Pathname` of a directory containing TLS certificates and keys")
+	directoryFlagName := "directory"
+	flags.StringVarP(&signOptions.Directory, directoryFlagName, "d", "", "Define an alternate directory to store signatures")
+	_ = signCommand.RegisterFlagCompletionFunc(directoryFlagName, completion.AutocompleteDefault)
+
+	signByFlagName := "sign-by"
+	flags.StringVar(&signOptions.SignBy, signByFlagName, "", "Name of the signing key")
+	_ = signCommand.RegisterFlagCompletionFunc(signByFlagName, completion.AutocompleteNone)
+
+	certDirFlagName := "cert-dir"
+	flags.StringVar(&signOptions.CertDir, certDirFlagName, "", "`Pathname` of a directory containing TLS certificates and keys")
+	_ = signCommand.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
 }
 
 func sign(cmd *cobra.Command, args []string) error {

cmd/podman/images/tag.go

@@ -1,6 +1,7 @@
 package images
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -15,6 +16,7 @@ var (
 		RunE:                  tag,
 		Args:                  cobra.MinimumNArgs(2),
 		DisableFlagsInUseLine: true,
+		ValidArgsFunction:     common.AutocompleteImages,
 		Example: `podman tag 0e3bbc2 fedora:latest
   podman tag imageID:latest myNewImage:newTag
   podman tag httpd myregistryhost:5000/fedora/httpd:v2`,
@@ -27,6 +29,7 @@ var (
 		Short:                 tagCommand.Short,
 		Long:                  tagCommand.Long,
 		RunE:                  tagCommand.RunE,
+		ValidArgsFunction:     tagCommand.ValidArgsFunction,
 		Example: `podman image tag 0e3bbc2 fedora:latest
   podman image tag imageID:latest myNewImage:newTag
   podman image tag httpd myregistryhost:5000/fedora/httpd:v2`,

cmd/podman/images/tree.go

@@ -3,6 +3,7 @@ package images
 import (
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -11,12 +12,13 @@ import (
 var (
 	treeDescription = "Prints layer hierarchy of an image in a tree format"
 	treeCmd         = &cobra.Command{
-		Use:     "tree [options] IMAGE",
-		Args:    cobra.ExactArgs(1),
-		Short:   treeDescription,
-		Long:    treeDescription,
-		RunE:    tree,
-		Example: "podman image tree alpine:latest",
+		Use:               "tree [options] IMAGE",
+		Args:              cobra.ExactArgs(1),
+		Short:             treeDescription,
+		Long:              treeDescription,
+		RunE:              tree,
+		ValidArgsFunction: common.AutocompleteImages,
+		Example:           "podman image tree alpine:latest",
 	}
 	treeOpts entities.ImageTreeOptions
 )

cmd/podman/images/trust_set.go

@@ -1,6 +1,8 @@
 package images
 
 import (
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/libpod/image"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -12,12 +14,13 @@ import (
 var (
 	setTrustDescription = "Set default trust policy or add a new trust policy for a registry"
 	setTrustCommand     = &cobra.Command{
-		Use:     "set [options] REGISTRY",
-		Short:   "Set default trust policy or a new trust policy for a registry",
-		Long:    setTrustDescription,
-		Example: "",
-		RunE:    setTrust,
-		Args:    cobra.ExactArgs(1),
+		Use:               "set [options] REGISTRY",
+		Short:             "Set default trust policy or a new trust policy for a registry",
+		Long:              setTrustDescription,
+		Example:           "",
+		RunE:              setTrust,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: common.AutocompleteRegistries,
 	}
 )
 
@@ -34,11 +37,17 @@ func init() {
 	setFlags := setTrustCommand.Flags()
 	setFlags.StringVar(&setOptions.PolicyPath, "policypath", "", "")
 	_ = setFlags.MarkHidden("policypath")
-	setFlags.StringSliceVarP(&setOptions.PubKeysFile, "pubkeysfile", "f", []string{}, `Path of installed public key(s) to trust for TARGET.
+
+	pubkeysfileFlagName := "pubkeysfile"
+	setFlags.StringSliceVarP(&setOptions.PubKeysFile, pubkeysfileFlagName, "f", []string{}, `Path of installed public key(s) to trust for TARGET.
 Absolute path to keys is added to policy.json. May
 used multiple times to define multiple public keys.
 File(s) must exist before using this command`)
-	setFlags.StringVarP(&setOptions.Type, "type", "t", "signedBy", "Trust type, accept values: signedBy(default), accept, reject")
+	_ = setTrustCommand.RegisterFlagCompletionFunc(pubkeysfileFlagName, completion.AutocompleteDefault)
+
+	typeFlagName := "type"
+	setFlags.StringVarP(&setOptions.Type, typeFlagName, "t", "signedBy", "Trust type, accept values: signedBy(default), accept, reject")
+	_ = setTrustCommand.RegisterFlagCompletionFunc(typeFlagName, common.AutocompleteTrustType)
 }
 
 func setTrust(cmd *cobra.Command, args []string) error {

cmd/podman/images/trust_show.go

@@ -6,6 +6,7 @@ import (
 	"text/tabwriter"
 	"text/template"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -14,12 +15,13 @@ import (
 var (
 	showTrustDescription = "Display trust policy for the system"
 	showTrustCommand     = &cobra.Command{
-		Use:     "show [options] [REGISTRY]",
-		Short:   "Display trust policy for the system",
-		Long:    showTrustDescription,
-		RunE:    showTrust,
-		Args:    cobra.MaximumNArgs(1),
-		Example: "",
+		Use:               "show [options] [REGISTRY]",
+		Short:             "Display trust policy for the system",
+		Long:              showTrustDescription,
+		RunE:              showTrust,
+		Args:              cobra.MaximumNArgs(1),
+		ValidArgsFunction: common.AutocompleteRegistries,
+		Example:           "",
 	}
 )
 

cmd/podman/images/unmount.go

@@ -3,6 +3,7 @@ package images
 import (
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -19,11 +20,12 @@ var (
   An unmount can be forced with the --force flag.
 `
 	unmountCommand = &cobra.Command{
-		Use:     "unmount [options] IMAGE [IMAGE...]",
-		Aliases: []string{"umount"},
-		Short:   "Unmount an image's root filesystem",
-		Long:    description,
-		RunE:    unmount,
+		Use:               "unmount [options] IMAGE [IMAGE...]",
+		Aliases:           []string{"umount"},
+		Short:             "Unmount an image's root filesystem",
+		Long:              description,
+		RunE:              unmount,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman unmount imgID
   podman unmount imgID1 imgID2 imgID3
   podman unmount --all`,

cmd/podman/images/untag.go

@@ -1,6 +1,7 @@
 package images
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -14,6 +15,7 @@ var (
 		RunE:                  untag,
 		Args:                  cobra.MinimumNArgs(1),
 		DisableFlagsInUseLine: true,
+		ValidArgsFunction:     common.AutocompleteImages,
 		Example: `podman untag 0e3bbc2
   podman untag imageID:latest otherImageName:latest
   podman untag httpd myregistryhost:5000/fedora/httpd:v2`,
@@ -26,6 +28,7 @@ var (
 		Short:                 untagCommand.Short,
 		Long:                  untagCommand.Long,
 		RunE:                  untagCommand.RunE,
+		ValidArgsFunction:     untagCommand.ValidArgsFunction,
 		Example: `podman image untag 0e3bbc2
   podman image untag imageID:latest otherImageName:latest
   podman image untag httpd myregistryhost:5000/fedora/httpd:v2`,

cmd/podman/inspect.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/inspect"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -19,11 +20,12 @@ var (
 
 	// Command: podman _inspect_ Object_ID
 	inspectCmd = &cobra.Command{
-		Use:              "inspect [options] {CONTAINER_ID | IMAGE_ID} [...]",
-		Short:            "Display the configuration of object denoted by ID",
-		RunE:             inspectExec,
-		Long:             inspectDescription,
-		TraverseChildren: true,
+		Use:               "inspect [options] {CONTAINER_ID | IMAGE_ID} [...]",
+		Short:             "Display the configuration of object denoted by ID",
+		RunE:              inspectExec,
+		Long:              inspectDescription,
+		TraverseChildren:  true,
+		ValidArgsFunction: common.AutocompleteContainersAndImages,
 		Example: `podman inspect fedora
   podman inspect --type image fedora
   podman inspect CtrID ImgID

cmd/podman/inspect/inspect.go

@@ -9,7 +9,9 @@ import (
 	"text/tabwriter"
 	"text/template"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/libpod/define"
@@ -44,8 +46,14 @@ func AddInspectFlagSet(cmd *cobra.Command) *entities.InspectOptions {
 
 	flags := cmd.Flags()
 	flags.BoolVarP(&opts.Size, "size", "s", false, "Display total file size")
-	flags.StringVarP(&opts.Format, "format", "f", "json", "Format the output to a Go template or json")
-	flags.StringVarP(&opts.Type, "type", "t", AllType, fmt.Sprintf("Specify inspect-oject type (%q, %q or %q)", ImageType, ContainerType, AllType))
+
+	formatFlagName := "format"
+	flags.StringVarP(&opts.Format, formatFlagName, "f", "json", "Format the output to a Go template or json")
+	_ = cmd.RegisterFlagCompletionFunc(formatFlagName, completion.AutocompleteNone)
+
+	typeFlagName := "type"
+	flags.StringVarP(&opts.Type, typeFlagName, "t", AllType, fmt.Sprintf("Specify inspect-oject type (%q, %q or %q)", ImageType, ContainerType, AllType))
+	_ = cmd.RegisterFlagCompletionFunc(typeFlagName, common.AutocompleteInspectType)
 
 	validate.AddLatestFlag(cmd, &opts.Latest)
 	return &opts

cmd/podman/login.go

@@ -5,7 +5,9 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/registries"
@@ -20,11 +22,12 @@ type loginOptionsWrapper struct {
 var (
 	loginOptions = loginOptionsWrapper{}
 	loginCommand = &cobra.Command{
-		Use:   "login [options] [REGISTRY]",
-		Short: "Login to a container registry",
-		Long:  "Login to a container registry on a specified server.",
-		RunE:  login,
-		Args:  cobra.MaximumNArgs(1),
+		Use:               "login [options] [REGISTRY]",
+		Short:             "Login to a container registry",
+		Long:              "Login to a container registry on a specified server.",
+		RunE:              login,
+		Args:              cobra.MaximumNArgs(1),
+		ValidArgsFunction: common.AutocompleteRegistries,
 		Example: `podman login quay.io
   podman login --username ... --password ... quay.io
   podman login --authfile dir/auth.json quay.io`,
@@ -44,6 +47,9 @@ func init() {
 	// Flags from the auth package.
 	flags.AddFlagSet(auth.GetLoginFlags(&loginOptions.LoginOptions))
 
+	// Add flag completion
+	completion.CompleteCommandFlags(loginCommand, auth.GetLoginFlagsCompletions())
+
 	// Podman flags.
 	flags.BoolVarP(&loginOptions.tlsVerify, "tls-verify", "", false, "Require HTTPS and verify certificates when contacting registries")
 	loginOptions.Stdin = os.Stdin

cmd/podman/logout.go

@@ -4,7 +4,9 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/registries"
@@ -14,11 +16,12 @@ import (
 var (
 	logoutOptions = auth.LogoutOptions{}
 	logoutCommand = &cobra.Command{
-		Use:   "logout [options] [REGISTRY]",
-		Short: "Logout of a container registry",
-		Long:  "Remove the cached username and password for the registry.",
-		RunE:  logout,
-		Args:  cobra.MaximumNArgs(1),
+		Use:               "logout [options] [REGISTRY]",
+		Short:             "Logout of a container registry",
+		Long:              "Remove the cached username and password for the registry.",
+		RunE:              logout,
+		Args:              cobra.MaximumNArgs(1),
+		ValidArgsFunction: common.AutocompleteRegistries,
 		Example: `podman logout quay.io
   podman logout --authfile dir/auth.json quay.io
   podman logout --all`,
@@ -37,6 +40,10 @@ func init() {
 
 	// Flags from the auth package.
 	flags.AddFlagSet(auth.GetLogoutFlags(&logoutOptions))
+
+	// Add flag completion
+	completion.CompleteCommandFlags(logoutCommand, auth.GetLogoutFlagsCompletions())
+
 	logoutOptions.Stdout = os.Stdout
 	logoutOptions.AcceptUnspecifiedRegistry = true
 }

cmd/podman/main.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 
+	_ "github.com/containers/podman/v2/cmd/podman/completion"
 	_ "github.com/containers/podman/v2/cmd/podman/containers"
 	_ "github.com/containers/podman/v2/cmd/podman/generate"
 	_ "github.com/containers/podman/v2/cmd/podman/healthcheck"
@@ -35,6 +36,13 @@ func main() {
 		os.Setenv("TMPDIR", "/var/tmp")
 	}
 
+	rootCmd = parseCommands()
+
+	Execute()
+	os.Exit(0)
+}
+
+func parseCommands() *cobra.Command {
 	cfg := registry.PodmanConfig()
 	for _, c := range registry.Commands {
 		for _, m := range c.Mode {
@@ -75,6 +83,5 @@ func main() {
 		os.Exit(1)
 	}
 
-	Execute()
-	os.Exit(0)
+	return rootCmd
 }

cmd/podman/manifest/add.go

@@ -5,7 +5,9 @@ import (
 	"fmt"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/util"
@@ -25,10 +27,11 @@ type manifestAddOptsWrapper struct {
 var (
 	manifestAddOpts = manifestAddOptsWrapper{}
 	addCmd          = &cobra.Command{
-		Use:   "add [options] LIST LIST",
-		Short: "Add images to a manifest list or image index",
-		Long:  "Adds an image to a manifest list or image index.",
-		RunE:  add,
+		Use:               "add [options] LIST LIST",
+		Short:             "Add images to a manifest list or image index",
+		Long:              "Adds an image to a manifest list or image index.",
+		RunE:              add,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman manifest add mylist:v1.11 image:v1.11-amd64
 		podman manifest add mylist:v1.11 transport:imageName`,
 		Args: cobra.ExactArgs(2),
@@ -43,17 +46,44 @@ func init() {
 	})
 	flags := addCmd.Flags()
 	flags.BoolVar(&manifestAddOpts.All, "all", false, "add all of the list's images if the image is a list")
-	flags.StringSliceVar(&manifestAddOpts.Annotation, "annotation", nil, "set an `annotation` for the specified image")
-	flags.StringVar(&manifestAddOpts.Arch, "arch", "", "override the `architecture` of the specified image")
-	flags.StringVar(&manifestAddOpts.Authfile, "authfile", auth.GetDefaultAuthFile(), "path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
-	flags.StringVar(&manifestAddOpts.CertDir, "cert-dir", "", "use certificates at the specified path to access the registry")
-	flags.StringVar(&manifestAddOpts.CredentialsCLI, "creds", "", "use `[username[:password]]` for accessing the registry")
 
-	flags.StringSliceVar(&manifestAddOpts.Features, "features", nil, "override the `features` of the specified image")
-	flags.StringVar(&manifestAddOpts.OS, "os", "", "override the `OS` of the specified image")
-	flags.StringVar(&manifestAddOpts.OSVersion, "os-version", "", "override the OS `version` of the specified image")
+	annotationFlagName := "annotation"
+	flags.StringSliceVar(&manifestAddOpts.Annotation, annotationFlagName, nil, "set an `annotation` for the specified image")
+	_ = addCmd.RegisterFlagCompletionFunc(annotationFlagName, completion.AutocompleteNone)
+
+	archFlagName := "arch"
+	flags.StringVar(&manifestAddOpts.Arch, archFlagName, "", "override the `architecture` of the specified image")
+	_ = addCmd.RegisterFlagCompletionFunc(archFlagName, completion.AutocompleteNone)
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&manifestAddOpts.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = addCmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
+
+	certDirFlagName := "cert-dir"
+	flags.StringVar(&manifestAddOpts.CertDir, certDirFlagName, "", "use certificates at the specified path to access the registry")
+	_ = addCmd.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
+
+	credsFlagName := "creds"
+	flags.StringVar(&manifestAddOpts.CredentialsCLI, credsFlagName, "", "use `[username[:password]]` for accessing the registry")
+	_ = addCmd.RegisterFlagCompletionFunc(credsFlagName, completion.AutocompleteNone)
+
+	featuresFlagName := "features"
+	flags.StringSliceVar(&manifestAddOpts.Features, featuresFlagName, nil, "override the `features` of the specified image")
+	_ = addCmd.RegisterFlagCompletionFunc(featuresFlagName, completion.AutocompleteNone)
+
+	osFlagName := "os"
+	flags.StringVar(&manifestAddOpts.OS, osFlagName, "", "override the `OS` of the specified image")
+	_ = addCmd.RegisterFlagCompletionFunc(osFlagName, completion.AutocompleteNone)
+
+	osVersionFlagName := "os-version"
+	flags.StringVar(&manifestAddOpts.OSVersion, osVersionFlagName, "", "override the OS `version` of the specified image")
+	_ = addCmd.RegisterFlagCompletionFunc(osVersionFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&manifestAddOpts.TLSVerifyCLI, "tls-verify", true, "require HTTPS and verify certificates when accessing the registry")
-	flags.StringVar(&manifestAddOpts.Variant, "variant", "", "override the `Variant` of the specified image")
+
+	variantFlagName := "variant"
+	flags.StringVar(&manifestAddOpts.Variant, variantFlagName, "", "override the `Variant` of the specified image")
+	_ = addCmd.RegisterFlagCompletionFunc(variantFlagName, completion.AutocompleteNone)
 
 	if registry.IsRemote() {
 		_ = flags.MarkHidden("cert-dir")

cmd/podman/manifest/annotate.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
@@ -13,12 +15,13 @@ import (
 var (
 	manifestAnnotateOpts = entities.ManifestAnnotateOptions{}
 	annotateCmd          = &cobra.Command{
-		Use:     "annotate [options] LIST IMAGE",
-		Short:   "Add or update information about an entry in a manifest list or image index",
-		Long:    "Adds or updates information about an entry in a manifest list or image index.",
-		RunE:    annotate,
-		Example: `podman manifest annotate --annotation left=right mylist:v1.11 image:v1.11-amd64`,
-		Args:    cobra.ExactArgs(2),
+		Use:               "annotate [options] LIST IMAGE",
+		Short:             "Add or update information about an entry in a manifest list or image index",
+		Long:              "Adds or updates information about an entry in a manifest list or image index.",
+		RunE:              annotate,
+		Example:           `podman manifest annotate --annotation left=right mylist:v1.11 image:v1.11-amd64`,
+		Args:              cobra.ExactArgs(2),
+		ValidArgsFunction: common.AutocompleteImages,
 	}
 )
 
@@ -29,13 +32,34 @@ func init() {
 		Parent:  manifestCmd,
 	})
 	flags := annotateCmd.Flags()
-	flags.StringSliceVar(&manifestAnnotateOpts.Annotation, "annotation", nil, "set an `annotation` for the specified image")
-	flags.StringVar(&manifestAnnotateOpts.Arch, "arch", "", "override the `architecture` of the specified image")
-	flags.StringSliceVar(&manifestAnnotateOpts.Features, "features", nil, "override the `features` of the specified image")
-	flags.StringVar(&manifestAnnotateOpts.OS, "os", "", "override the `OS` of the specified image")
-	flags.StringSliceVar(&manifestAnnotateOpts.OSFeatures, "os-features", nil, "override the OS `features` of the specified image")
-	flags.StringVar(&manifestAnnotateOpts.OSVersion, "os-version", "", "override the OS `version` of the specified image")
-	flags.StringVar(&manifestAnnotateOpts.Variant, "variant", "", "override the `variant` of the specified image")
+
+	annotationFlagName := "annotation"
+	flags.StringSliceVar(&manifestAnnotateOpts.Annotation, annotationFlagName, nil, "set an `annotation` for the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(annotationFlagName, completion.AutocompleteNone)
+
+	archFlagName := "arch"
+	flags.StringVar(&manifestAnnotateOpts.Arch, archFlagName, "", "override the `architecture` of the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(archFlagName, completion.AutocompleteNone)
+
+	featuresFlagName := "features"
+	flags.StringSliceVar(&manifestAnnotateOpts.Features, featuresFlagName, nil, "override the `features` of the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(featuresFlagName, completion.AutocompleteNone)
+
+	osFlagName := "os"
+	flags.StringVar(&manifestAnnotateOpts.OS, osFlagName, "", "override the `OS` of the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(osFlagName, completion.AutocompleteNone)
+
+	osFeaturesFlagName := "os-features"
+	flags.StringSliceVar(&manifestAnnotateOpts.OSFeatures, osFeaturesFlagName, nil, "override the OS `features` of the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(osFeaturesFlagName, completion.AutocompleteNone)
+
+	osVersionFlagName := "os-version"
+	flags.StringVar(&manifestAnnotateOpts.OSVersion, osVersionFlagName, "", "override the OS `version` of the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(osVersionFlagName, completion.AutocompleteNone)
+
+	variantFlagName := "variant"
+	flags.StringVar(&manifestAnnotateOpts.Variant, variantFlagName, "", "override the `Variant` of the specified image")
+	_ = annotateCmd.RegisterFlagCompletionFunc(variantFlagName, completion.AutocompleteNone)
 }
 
 func annotate(cmd *cobra.Command, args []string) error {

cmd/podman/manifest/create.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
@@ -13,10 +14,11 @@ import (
 var (
 	manifestCreateOpts = entities.ManifestCreateOptions{}
 	createCmd          = &cobra.Command{
-		Use:   "create [options] LIST [IMAGE]",
-		Short: "Create manifest list or image index",
-		Long:  "Creates manifest lists or image indexes.",
-		RunE:  create,
+		Use:               "create [options] LIST [IMAGE]",
+		Short:             "Create manifest list or image index",
+		Long:              "Creates manifest lists or image indexes.",
+		RunE:              create,
+		ValidArgsFunction: common.AutocompleteImages,
 		Example: `podman manifest create mylist:v1.11
   podman manifest create mylist:v1.11 arch-specific-image-to-add
   podman manifest create --all mylist:v1.11 transport:tagged-image-to-add`,

cmd/podman/manifest/inspect.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
@@ -16,6 +17,7 @@ var (
 		Short:                 "Display the contents of a manifest list or image index",
 		Long:                  "Display the contents of a manifest list or image index.",
 		RunE:                  inspect,
+		ValidArgsFunction:     common.AutocompleteImages,
 		Example:               "podman manifest inspect localhost/list",
 		Args:                  cobra.ExactArgs(1),
 		DisableFlagsInUseLine: true,

cmd/podman/manifest/push.go

@@ -2,7 +2,9 @@ package manifest
 
 import (
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/containers/podman/v2/pkg/util"
@@ -22,12 +24,13 @@ type manifestPushOptsWrapper struct {
 var (
 	manifestPushOpts = manifestPushOptsWrapper{}
 	pushCmd          = &cobra.Command{
-		Use:     "push [options] SOURCE DESTINATION",
-		Short:   "Push a manifest list or image index to a registry",
-		Long:    "Pushes manifest lists and image indexes to registries.",
-		RunE:    push,
-		Example: `podman manifest push mylist:v1.11 quay.io/myimagelist`,
-		Args:    cobra.ExactArgs(2),
+		Use:               "push [options] SOURCE DESTINATION",
+		Short:             "Push a manifest list or image index to a registry",
+		Long:              "Pushes manifest lists and image indexes to registries.",
+		RunE:              push,
+		Example:           `podman manifest push mylist:v1.11 quay.io/myimagelist`,
+		Args:              cobra.ExactArgs(2),
+		ValidArgsFunction: common.AutocompleteImages,
 	}
 )
 
@@ -40,13 +43,33 @@ func init() {
 	flags := pushCmd.Flags()
 	flags.BoolVar(&manifestPushOpts.Purge, "purge", false, "remove the manifest list if push succeeds")
 	flags.BoolVar(&manifestPushOpts.All, "all", false, "also push the images in the list")
-	flags.StringVar(&manifestPushOpts.Authfile, "authfile", auth.GetDefaultAuthFile(), "path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
-	flags.StringVar(&manifestPushOpts.CertDir, "cert-dir", "", "use certificates at the specified path to access the registry")
-	flags.StringVar(&manifestPushOpts.CredentialsCLI, "creds", "", "use `[username[:password]]` for accessing the registry")
-	flags.StringVar(&manifestPushOpts.DigestFile, "digestfile", "", "after copying the image, write the digest of the resulting digest to the file")
-	flags.StringVarP(&manifestPushOpts.Format, "format", "f", "", "manifest type (oci or v2s2) to attempt to use when pushing the manifest list (default is manifest type of source)")
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&manifestPushOpts.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = pushCmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
+
+	certDirFlagName := "cert-dir"
+	flags.StringVar(&manifestPushOpts.CertDir, certDirFlagName, "", "use certificates at the specified path to access the registry")
+	_ = pushCmd.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
+
+	credsFlagName := "creds"
+	flags.StringVar(&manifestPushOpts.CredentialsCLI, credsFlagName, "", "use `[username[:password]]` for accessing the registry")
+	_ = pushCmd.RegisterFlagCompletionFunc(credsFlagName, completion.AutocompleteNone)
+
+	digestfileFlagName := "digestfile"
+	flags.StringVar(&manifestPushOpts.DigestFile, digestfileFlagName, "", "after copying the image, write the digest of the resulting digest to the file")
+	_ = pushCmd.RegisterFlagCompletionFunc(digestfileFlagName, completion.AutocompleteDefault)
+
+	formatFlagName := "format"
+	flags.StringVarP(&manifestPushOpts.Format, formatFlagName, "f", "", "manifest type (oci or v2s2) to attempt to use when pushing the manifest list (default is manifest type of source)")
+	_ = pushCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteManifestFormat)
+
 	flags.BoolVarP(&manifestPushOpts.RemoveSignatures, "remove-signatures", "", false, "don't copy signatures when pushing images")
-	flags.StringVar(&manifestPushOpts.SignBy, "sign-by", "", "sign the image using a GPG key with the specified `FINGERPRINT`")
+
+	signByFlagName := "sign-by"
+	flags.StringVar(&manifestPushOpts.SignBy, signByFlagName, "", "sign the image using a GPG key with the specified `FINGERPRINT`")
+	_ = pushCmd.RegisterFlagCompletionFunc(signByFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&manifestPushOpts.TLSVerifyCLI, "tls-verify", true, "require HTTPS and verify certificates when accessing the registry")
 	flags.BoolVarP(&manifestPushOpts.Quiet, "quiet", "q", false, "don't output progress information when pushing lists")
 

cmd/podman/manifest/remove.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/pkg/errors"
@@ -16,6 +17,7 @@ var (
 		Short:                 "Remove an entry from a manifest list or image index",
 		Long:                  "Removes an image from a manifest list or image index.",
 		RunE:                  remove,
+		ValidArgsFunction:     common.AutocompleteImages,
 		Example:               `podman manifest remove mylist:v1.11 sha256:15352d97781ffdf357bf3459c037be3efac4133dc9070c2dce7eca7c05c3e736`,
 		Args:                  cobra.ExactArgs(2),
 		DisableFlagsInUseLine: true,

cmd/podman/networks/create.go

@@ -4,22 +4,24 @@ import (
 	"fmt"
 	"net"
 
+	"github.com/containers/common/pkg/completion"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/libpod/define"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 var (
 	networkCreateDescription = `create CNI networks for containers and pods`
 	networkCreateCommand     = &cobra.Command{
-		Use:     "create [options] [NETWORK]",
-		Short:   "network create",
-		Long:    networkCreateDescription,
-		RunE:    networkCreate,
-		Args:    cobra.MaximumNArgs(1),
-		Example: `podman network create podman1`,
+		Use:               "create [options] [NETWORK]",
+		Short:             "network create",
+		Long:              networkCreateDescription,
+		RunE:              networkCreate,
+		Args:              cobra.MaximumNArgs(1),
+		ValidArgsFunction: completion.AutocompleteNone,
+		Example:           `podman network create podman1`,
 	}
 )
 
@@ -27,16 +29,36 @@ var (
 	networkCreateOptions entities.NetworkCreateOptions
 )
 
-func networkCreateFlags(flags *pflag.FlagSet) {
-	flags.StringVarP(&networkCreateOptions.Driver, "driver", "d", "bridge", "driver to manage the network")
-	flags.IPVar(&networkCreateOptions.Gateway, "gateway", nil, "IPv4 or IPv6 gateway for the subnet")
+func networkCreateFlags(cmd *cobra.Command) {
+	flags := cmd.Flags()
+
+	driverFlagName := "driver"
+	flags.StringVarP(&networkCreateOptions.Driver, driverFlagName, "d", "bridge", "driver to manage the network")
+	_ = cmd.RegisterFlagCompletionFunc(driverFlagName, common.AutocompleteNetworkDriver)
+
+	gatewayFlagName := "gateway"
+	flags.IPVar(&networkCreateOptions.Gateway, gatewayFlagName, nil, "IPv4 or IPv6 gateway for the subnet")
+	_ = cmd.RegisterFlagCompletionFunc(gatewayFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&networkCreateOptions.Internal, "internal", false, "restrict external access from this network")
-	flags.IPNetVar(&networkCreateOptions.Range, "ip-range", net.IPNet{}, "allocate container IP from range")
-	flags.StringVar(&networkCreateOptions.MacVLAN, "macvlan", "", "create a Macvlan connection based on this device")
+
+	ipRangeFlagName := "ip-range"
+	flags.IPNetVar(&networkCreateOptions.Range, ipRangeFlagName, net.IPNet{}, "allocate container IP from range")
+	_ = cmd.RegisterFlagCompletionFunc(ipRangeFlagName, completion.AutocompleteNone)
+
+	macvlanFlagName := "macvlan"
+	flags.StringVar(&networkCreateOptions.MacVLAN, macvlanFlagName, "", "create a Macvlan connection based on this device")
+	_ = cmd.RegisterFlagCompletionFunc(macvlanFlagName, completion.AutocompleteNone)
+
 	// TODO not supported yet
 	// flags.StringVar(&networkCreateOptions.IPamDriver, "ipam-driver", "",  "IP Address Management Driver")
+
 	flags.BoolVar(&networkCreateOptions.IPv6, "ipv6", false, "enable IPv6 networking")
-	flags.IPNetVar(&networkCreateOptions.Subnet, "subnet", net.IPNet{}, "subnet in CIDR format")
+
+	subnetFlagName := "subnet"
+	flags.IPNetVar(&networkCreateOptions.Subnet, subnetFlagName, net.IPNet{}, "subnet in CIDR format")
+	_ = cmd.RegisterFlagCompletionFunc(subnetFlagName, completion.AutocompleteNone)
+
 	flags.BoolVar(&networkCreateOptions.DisableDNS, "disable-dns", false, "disable dns plugin")
 }
 func init() {
@@ -45,8 +67,7 @@ func init() {
 		Command: networkCreateCommand,
 		Parent:  networkCmd,
 	})
-	flags := networkCreateCommand.Flags()
-	networkCreateFlags(flags)
+	networkCreateFlags(networkCreateCommand)
 
 }
 

cmd/podman/networks/inspect.go

@@ -1,6 +1,7 @@
 package network
 
 import (
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/inspect"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -10,12 +11,13 @@ import (
 var (
 	networkinspectDescription = `Inspect network`
 	networkinspectCommand     = &cobra.Command{
-		Use:     "inspect [options] NETWORK [NETWORK...]",
-		Short:   "network inspect",
-		Long:    networkinspectDescription,
-		RunE:    networkInspect,
-		Example: `podman network inspect podman`,
-		Args:    cobra.MinimumNArgs(1),
+		Use:               "inspect [options] NETWORK [NETWORK...]",
+		Short:             "network inspect",
+		Long:              networkinspectDescription,
+		RunE:              networkInspect,
+		Example:           `podman network inspect podman`,
+		Args:              cobra.MinimumNArgs(1),
+		ValidArgsFunction: common.AutocompleteNetworks,
 	}
 	inspectOpts *entities.InspectOptions
 )
@@ -28,7 +30,10 @@ func init() {
 	})
 	inspectOpts = new(entities.InspectOptions)
 	flags := networkinspectCommand.Flags()
-	flags.StringVarP(&inspectOpts.Format, "format", "f", "", "Pretty-print network to JSON or using a Go template")
+
+	formatFlagName := "format"
+	flags.StringVarP(&inspectOpts.Format, formatFlagName, "f", "", "Pretty-print network to JSON or using a Go template")
+	_ = networkinspectCommand.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
 }
 
 func networkInspect(_ *cobra.Command, args []string) error {

cmd/podman/networks/list.go

@@ -8,7 +8,9 @@ import (
 	"text/tabwriter"
 	"text/template"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -21,12 +23,13 @@ import (
 var (
 	networklistDescription = `List networks`
 	networklistCommand     = &cobra.Command{
-		Use:     "ls [options]",
-		Args:    validate.NoArgs,
-		Short:   "network list",
-		Long:    networklistDescription,
-		RunE:    networkList,
-		Example: `podman network list`,
+		Use:               "ls [options]",
+		Args:              validate.NoArgs,
+		Short:             "network list",
+		Long:              networklistDescription,
+		RunE:              networkList,
+		ValidArgsFunction: completion.AutocompleteNone,
+		Example:           `podman network list`,
 	}
 )
 
@@ -35,11 +38,16 @@ var (
 )
 
 func networkListFlags(flags *pflag.FlagSet) {
-	// TODO enable filters based on something
-	// flags.StringSliceVarP(&networklistCommand.Filter, "filter", "f",  []string{}, "Pause all running containers")
-	flags.StringVarP(&networkListOptions.Format, "format", "f", "", "Pretty-print networks to JSON or using a Go template")
+	formatFlagName := "format"
+	flags.StringVarP(&networkListOptions.Format, formatFlagName, "f", "", "Pretty-print networks to JSON or using a Go template")
+	_ = networklistCommand.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVarP(&networkListOptions.Quiet, "quiet", "q", false, "display only names")
-	flags.StringVarP(&networkListOptions.Filter, "filter", "", "", "Provide filter values (e.g. 'name=podman')")
+
+	filterFlagName := "filter"
+	flags.StringVarP(&networkListOptions.Filter, filterFlagName, "", "", "Provide filter values (e.g. 'name=podman')")
+	_ = networklistCommand.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
+
 }
 
 func init() {

cmd/podman/networks/rm.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/libpod/define"
@@ -16,12 +17,13 @@ import (
 var (
 	networkrmDescription = `Remove networks`
 	networkrmCommand     = &cobra.Command{
-		Use:     "rm [options] NETWORK [NETWORK...]",
-		Short:   "network rm",
-		Long:    networkrmDescription,
-		RunE:    networkRm,
-		Example: `podman network rm podman`,
-		Args:    cobra.MinimumNArgs(1),
+		Use:               "rm [options] NETWORK [NETWORK...]",
+		Short:             "network rm",
+		Long:              networkrmDescription,
+		RunE:              networkRm,
+		Example:           `podman network rm podman`,
+		Args:              cobra.MinimumNArgs(1),
+		ValidArgsFunction: common.AutocompleteNetworks,
 	}
 )
 

cmd/podman/play/kube.go

@@ -5,7 +5,9 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/image/v5/types"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -31,11 +33,12 @@ var (
   It creates the pod and containers described in the YAML.  The containers within the pod are then started and the ID of the new Pod is output.`
 
 	kubeCmd = &cobra.Command{
-		Use:   "kube [options] KUBEFILE",
-		Short: "Play a pod based on Kubernetes YAML.",
-		Long:  kubeDescription,
-		RunE:  kube,
-		Args:  cobra.ExactArgs(1),
+		Use:               "kube [options] KUBEFILE",
+		Short:             "Play a pod based on Kubernetes YAML.",
+		Long:              kubeDescription,
+		RunE:              kube,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: completion.AutocompleteDefault,
 		Example: `podman play kube nginx.yml
   podman play kube --creds user:password --seccomp-profile-root /custom/path apache.yml`,
 	}
@@ -50,17 +53,41 @@ func init() {
 
 	flags := kubeCmd.Flags()
 	flags.SetNormalizeFunc(utils.AliasFlags)
-	flags.StringVar(&kubeOptions.CredentialsCLI, "creds", "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
-	flags.StringVar(&kubeOptions.Network, "network", "", "Connect pod to CNI network(s)")
-	flags.StringVar(&kubeOptions.LogDriver, "log-driver", "", "Logging driver for the container")
+
+	credsFlagName := "creds"
+	flags.StringVar(&kubeOptions.CredentialsCLI, credsFlagName, "", "`Credentials` (USERNAME:PASSWORD) to use for authenticating to a registry")
+	_ = kubeCmd.RegisterFlagCompletionFunc(credsFlagName, completion.AutocompleteNone)
+
+	networkFlagName := "network"
+	flags.StringVar(&kubeOptions.Network, networkFlagName, "", "Connect pod to CNI network(s)")
+	_ = kubeCmd.RegisterFlagCompletionFunc(networkFlagName, common.AutocompleteNetworks)
+
+	logDriverFlagName := "log-driver"
+	flags.StringVar(&kubeOptions.LogDriver, logDriverFlagName, "", "Logging driver for the container")
+	_ = kubeCmd.RegisterFlagCompletionFunc(logDriverFlagName, common.AutocompleteLogDriver)
+
 	flags.BoolVarP(&kubeOptions.Quiet, "quiet", "q", false, "Suppress output information when pulling images")
 	flags.BoolVar(&kubeOptions.TLSVerifyCLI, "tls-verify", true, "Require HTTPS and verify certificates when contacting registries")
-	flags.StringVar(&kubeOptions.Authfile, "authfile", auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+
+	authfileFlagName := "authfile"
+	flags.StringVar(&kubeOptions.Authfile, authfileFlagName, auth.GetDefaultAuthFile(), "Path of the authentication file. Use REGISTRY_AUTH_FILE environment variable to override")
+	_ = kubeCmd.RegisterFlagCompletionFunc(authfileFlagName, completion.AutocompleteDefault)
+
 	if !registry.IsRemote() {
-		flags.StringVar(&kubeOptions.CertDir, "cert-dir", "", "`Pathname` of a directory containing TLS certificates and keys")
+
+		certDirFlagName := "cert-dir"
+		flags.StringVar(&kubeOptions.CertDir, certDirFlagName, "", "`Pathname` of a directory containing TLS certificates and keys")
+		_ = kubeCmd.RegisterFlagCompletionFunc(certDirFlagName, completion.AutocompleteDefault)
+
 		flags.StringVar(&kubeOptions.SignaturePolicy, "signature-policy", "", "`Pathname` of signature policy file (not usually used)")
-		flags.StringVar(&kubeOptions.SeccompProfileRoot, "seccomp-profile-root", defaultSeccompRoot, "Directory path for seccomp profiles")
-		flags.StringSliceVar(&kubeOptions.ConfigMaps, "configmap", []string{}, "`Pathname` of a YAML file containing a kubernetes configmap")
+
+		seccompProfileRootFlagName := "seccomp-profile-root"
+		flags.StringVar(&kubeOptions.SeccompProfileRoot, seccompProfileRootFlagName, defaultSeccompRoot, "Directory path for seccomp profiles")
+		_ = kubeCmd.RegisterFlagCompletionFunc(seccompProfileRootFlagName, completion.AutocompleteDefault)
+
+		configmapFlagName := "configmap"
+		flags.StringSliceVar(&kubeOptions.ConfigMaps, configmapFlagName, []string{}, "`Pathname` of a YAML file containing a kubernetes configmap")
+		_ = kubeCmd.RegisterFlagCompletionFunc(configmapFlagName, completion.AutocompleteDefault)
 	}
 	_ = flags.MarkHidden("signature-policy")
 }

cmd/podman/pods/create.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
@@ -27,11 +28,12 @@ var (
   You can then start it at any time with the  podman pod start <pod_id> command. The pod will be created with the initial state 'created'.`
 
 	createCommand = &cobra.Command{
-		Use:   "create [options]",
-		Args:  validate.NoArgs,
-		Short: "Create a new empty pod",
-		Long:  podCreateDescription,
-		RunE:  create,
+		Use:               "create [options]",
+		Args:              validate.NoArgs,
+		Short:             "Create a new empty pod",
+		Long:              podCreateDescription,
+		RunE:              create,
+		ValidArgsFunction: completion.AutocompleteNone,
 	}
 )
 
@@ -51,19 +53,53 @@ func init() {
 	})
 	flags := createCommand.Flags()
 	flags.SetInterspersed(false)
-	flags.AddFlagSet(common.GetNetFlags())
-	flags.StringVar(&createOptions.CGroupParent, "cgroup-parent", "", "Set parent cgroup for the pod")
+
+	common.DefineNetFlags(createCommand)
+
+	cgroupParentflagName := "cgroup-parent"
+	flags.StringVar(&createOptions.CGroupParent, cgroupParentflagName, "", "Set parent cgroup for the pod")
+	_ = createCommand.RegisterFlagCompletionFunc(cgroupParentflagName, completion.AutocompleteDefault)
+
 	flags.BoolVar(&createOptions.Infra, "infra", true, "Create an infra container associated with the pod to share namespaces with")
-	flags.StringVar(&createOptions.InfraConmonPidFile, "infra-conmon-pidfile", "", "Path to the file that will receive the POD of the infra container's conmon")
-	flags.String("infra-image", containerConfig.Engine.InfraImage, "The image of the infra container to associate with the pod")
-	flags.String("infra-command", containerConfig.Engine.InfraCommand, "The command to run on the infra container when the pod is started")
-	flags.StringSliceVar(&labelFile, "label-file", []string{}, "Read in a line delimited file of labels")
-	flags.StringSliceVarP(&labels, "label", "l", []string{}, "Set metadata on pod (default [])")
-	flags.StringVarP(&createOptions.Name, "name", "n", "", "Assign a name to the pod")
-	flags.StringVarP(&createOptions.Hostname, "hostname", "", "", "Set a hostname to the pod")
-	flags.StringVar(&podIDFile, "pod-id-file", "", "Write the pod ID to the file")
+
+	infraConmonPidfileFlagName := "infra-conmon-pidfile"
+	flags.StringVar(&createOptions.InfraConmonPidFile, infraConmonPidfileFlagName, "", "Path to the file that will receive the POD of the infra container's conmon")
+	_ = createCommand.RegisterFlagCompletionFunc(infraConmonPidfileFlagName, completion.AutocompleteDefault)
+
+	infraImageFlagName := "infra-image"
+	flags.String(infraImageFlagName, containerConfig.Engine.InfraImage, "The image of the infra container to associate with the pod")
+	_ = createCommand.RegisterFlagCompletionFunc(infraImageFlagName, common.AutocompleteImages)
+
+	infraCommandFlagName := "infra-command"
+	flags.String(infraCommandFlagName, containerConfig.Engine.InfraCommand, "The command to run on the infra container when the pod is started")
+	_ = createCommand.RegisterFlagCompletionFunc(infraCommandFlagName, completion.AutocompleteNone)
+
+	labelFileFlagName := "label-file"
+	flags.StringSliceVar(&labelFile, labelFileFlagName, []string{}, "Read in a line delimited file of labels")
+	_ = createCommand.RegisterFlagCompletionFunc(labelFileFlagName, completion.AutocompleteDefault)
+
+	labelFlagName := "label"
+	flags.StringSliceVarP(&labels, labelFlagName, "l", []string{}, "Set metadata on pod (default [])")
+	_ = createCommand.RegisterFlagCompletionFunc(labelFlagName, completion.AutocompleteNone)
+
+	nameFlagName := "name"
+	flags.StringVarP(&createOptions.Name, nameFlagName, "n", "", "Assign a name to the pod")
+	_ = createCommand.RegisterFlagCompletionFunc(nameFlagName, completion.AutocompleteNone)
+
+	hostnameFlagName := "hostname"
+	flags.StringVarP(&createOptions.Hostname, hostnameFlagName, "", "", "Set a hostname to the pod")
+	_ = createCommand.RegisterFlagCompletionFunc(hostnameFlagName, completion.AutocompleteNone)
+
+	podIDFileFlagName := "pod-id-file"
+	flags.StringVar(&podIDFile, podIDFileFlagName, "", "Write the pod ID to the file")
+	_ = createCommand.RegisterFlagCompletionFunc(podIDFileFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVar(&replace, "replace", false, "If a pod with the same exists, replace it")
-	flags.StringVar(&share, "share", specgen.DefaultKernelNamespaces, "A comma delimited list of kernel namespaces the pod will share")
+
+	shareFlagName := "share"
+	flags.StringVar(&share, shareFlagName, specgen.DefaultKernelNamespaces, "A comma delimited list of kernel namespaces the pod will share")
+	_ = createCommand.RegisterFlagCompletionFunc(shareFlagName, common.AutocompletePodShareNamespace)
+
 	flags.SetNormalizeFunc(aliasNetworkFlag)
 }
 

cmd/podman/pods/exists.go

@@ -3,6 +3,7 @@ package pods
 import (
 	"context"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/pkg/domain/entities"
 	"github.com/spf13/cobra"
@@ -12,11 +13,12 @@ var (
 	podExistsDescription = `If the named pod exists in local storage, podman pod exists exits with 0, otherwise the exit code will be 1.`
 
 	existsCommand = &cobra.Command{
-		Use:   "exists POD",
-		Short: "Check if a pod exists in local storage",
-		Long:  podExistsDescription,
-		RunE:  exists,
-		Args:  cobra.ExactArgs(1),
+		Use:               "exists POD",
+		Short:             "Check if a pod exists in local storage",
+		Long:              podExistsDescription,
+		RunE:              exists,
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: common.AutocompletePods,
 		Example: `podman pod exists podID
   podman pod exists mypod || podman pod create --name mypod`,
 		DisableFlagsInUseLine: true,

cmd/podman/pods/inspect.go

@@ -8,6 +8,7 @@ import (
 	"text/template"
 
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -25,11 +26,12 @@ var (
 	By default, this will render all results in a JSON array.`)
 
 	inspectCmd = &cobra.Command{
-		Use:     "inspect [options] POD [POD...]",
-		Short:   "Displays a pod configuration",
-		Long:    inspectDescription,
-		RunE:    inspect,
-		Example: `podman pod inspect podID`,
+		Use:               "inspect [options] POD [POD...]",
+		Short:             "Displays a pod configuration",
+		Long:              inspectDescription,
+		RunE:              inspect,
+		ValidArgsFunction: common.AutocompletePods,
+		Example:           `podman pod inspect podID`,
 	}
 )
 
@@ -40,7 +42,11 @@ func init() {
 		Parent:  podCmd,
 	})
 	flags := inspectCmd.Flags()
-	flags.StringVarP(&inspectOptions.Format, "format", "f", "json", "Format the output to a Go template or json")
+
+	formatFlagName := "format"
+	flags.StringVarP(&inspectOptions.Format, formatFlagName, "f", "json", "Format the output to a Go template or json")
+	_ = inspectCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	validate.AddLatestFlag(inspectCmd, &inspectOptions.Latest)
 }
 

cmd/podman/pods/kill.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -23,6 +24,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompletePodsRunning,
 		Example: `podman pod kill podID
   podman pod kill --signal TERM mywebserver
   podman pod kill --latest`,
@@ -41,7 +43,11 @@ func init() {
 	})
 	flags := killCommand.Flags()
 	flags.BoolVarP(&killOpts.All, "all", "a", false, "Kill all containers in all pods")
-	flags.StringVarP(&killOpts.Signal, "signal", "s", "KILL", "Signal to send to the containers in the pod")
+
+	signalFlagName := "signal"
+	flags.StringVarP(&killOpts.Signal, signalFlagName, "s", "KILL", "Signal to send to the containers in the pod")
+	_ = killCommand.RegisterFlagCompletionFunc(signalFlagName, common.AutocompleteStopSignal)
+
 	validate.AddLatestFlag(killCommand, &killOpts.Latest)
 }
 

cmd/podman/pods/pause.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -23,6 +24,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompletePodsRunning,
 		Example: `podman pod pause podID1 podID2
   podman pod pause --latest
   podman pod pause --all`,

cmd/podman/pods/prune.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -23,12 +24,13 @@ var (
 	pruneDescription = fmt.Sprintf(`podman pod prune Removes all exited pods`)
 
 	pruneCommand = &cobra.Command{
-		Use:     "prune [options]",
-		Args:    validate.NoArgs,
-		Short:   "Remove all stopped pods and their containers",
-		Long:    pruneDescription,
-		RunE:    prune,
-		Example: `podman pod prune`,
+		Use:               "prune [options]",
+		Args:              validate.NoArgs,
+		Short:             "Remove all stopped pods and their containers",
+		Long:              pruneDescription,
+		RunE:              prune,
+		ValidArgsFunction: common.AutocompletePods,
+		Example:           `podman pod prune`,
 	}
 )
 

cmd/podman/pods/ps.go

@@ -10,7 +10,9 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -25,12 +27,13 @@ var (
 
 	// Command: podman pod _ps_
 	psCmd = &cobra.Command{
-		Use:     "ps  [options]",
-		Aliases: []string{"ls", "list"},
-		Short:   "List pods",
-		Long:    psDescription,
-		RunE:    pods,
-		Args:    validate.NoArgs,
+		Use:               "ps  [options]",
+		Aliases:           []string{"ls", "list"},
+		Short:             "List pods",
+		Long:              psDescription,
+		RunE:              pods,
+		Args:              validate.NoArgs,
+		ValidArgsFunction: completion.AutocompleteNone,
 	}
 )
 
@@ -51,13 +54,25 @@ func init() {
 	flags.BoolVar(&psInput.CtrIds, "ctr-ids", false, "Display the container UUIDs. If no-trunc is not set they will be truncated")
 	flags.BoolVar(&psInput.CtrStatus, "ctr-status", false, "Display the container status")
 	// TODO should we make this a [] ?
-	flags.StringSliceVarP(&inputFilters, "filter", "f", []string{}, "Filter output based on conditions given")
-	flags.StringVar(&psInput.Format, "format", "", "Pretty-print pods to JSON or using a Go template")
+
+	filterFlagName := "filter"
+	flags.StringSliceVarP(&inputFilters, filterFlagName, "f", []string{}, "Filter output based on conditions given")
+	//TODO complete filters
+	_ = psCmd.RegisterFlagCompletionFunc(filterFlagName, completion.AutocompleteNone)
+
+	formatFlagName := "format"
+	flags.StringVar(&psInput.Format, formatFlagName, "", "Pretty-print pods to JSON or using a Go template")
+	_ = psCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVar(&psInput.Namespace, "namespace", false, "Display namespace information of the pod")
 	flags.BoolVar(&psInput.Namespace, "ns", false, "Display namespace information of the pod")
 	flags.BoolVar(&noTrunc, "no-trunc", false, "Do not truncate pod and container IDs")
 	flags.BoolVarP(&psInput.Quiet, "quiet", "q", false, "Print the numeric IDs of the pods only")
-	flags.StringVar(&psInput.Sort, "sort", "created", "Sort output by created, id, name, or number")
+
+	sortFlagName := "sort"
+	flags.StringVar(&psInput.Sort, sortFlagName, "created", "Sort output by created, id, name, or number")
+	_ = psCmd.RegisterFlagCompletionFunc(sortFlagName, common.AutocompletePodPsSort)
+
 	validate.AddLatestFlag(psCmd, &psInput.Latest)
 }
 

cmd/podman/pods/restart.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -23,6 +24,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		ValidArgsFunction: common.AutocompletePods,
 		Example: `podman pod restart podID1 podID2
   podman pod restart --latest
   podman pod restart --all`,

cmd/podman/pods/rm.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
@@ -35,6 +36,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndPodIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: common.AutocompletePods,
 		Example: `podman pod rm mywebserverpod
   podman pod rm -f 860a4b23
   podman pod rm -f -a`,
@@ -52,7 +54,11 @@ func init() {
 	flags.BoolVarP(&rmOptions.All, "all", "a", false, "Remove all running pods")
 	flags.BoolVarP(&rmOptions.Force, "force", "f", false, "Force removal of a running pod by first stopping all containers, then removing all containers in the pod.  The default is false")
 	flags.BoolVarP(&rmOptions.Ignore, "ignore", "i", false, "Ignore errors when a specified pod is missing")
-	flags.StringArrayVarP(&rmOptions.PodIDFiles, "pod-id-file", "", nil, "Read the pod ID from the file")
+
+	podIDFileFlagName := "pod-id-file"
+	flags.StringArrayVarP(&rmOptions.PodIDFiles, podIDFileFlagName, "", nil, "Read the pod ID from the file")
+	_ = rmCommand.RegisterFlagCompletionFunc(podIDFileFlagName, completion.AutocompleteDefault)
+
 	validate.AddLatestFlag(rmCommand, &rmOptions.Latest)
 
 	if registry.IsRemote() {

cmd/podman/pods/start.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
@@ -31,6 +32,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndPodIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: common.AutocompletePods,
 		Example: `podman pod start podID
   podman pod start --latest
   podman pod start --all`,
@@ -50,7 +52,11 @@ func init() {
 
 	flags := startCommand.Flags()
 	flags.BoolVarP(&startOptions.All, "all", "a", false, "Restart all running pods")
-	flags.StringArrayVarP(&startOptions.PodIDFiles, "pod-id-file", "", nil, "Read the pod ID from the file")
+
+	podIDFileFlagName := "pod-id-file"
+	flags.StringArrayVarP(&startOptions.PodIDFiles, podIDFileFlagName, "", nil, "Read the pod ID from the file")
+	_ = startCommand.RegisterFlagCompletionFunc(podIDFileFlagName, completion.AutocompleteDefault)
+
 	validate.AddLatestFlag(startCommand, &startOptions.Latest)
 }
 

cmd/podman/pods/stats.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/buger/goterm"
 	"github.com/containers/common/pkg/report"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/parse"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -33,10 +34,11 @@ var (
 	statsDescription = `Display the containers' resource-usage statistics of one or more running pod`
 	// Command: podman pod _pod_
 	statsCmd = &cobra.Command{
-		Use:   "stats [options] [POD...]",
-		Short: "Display a live stream of resource usage statistics for the containers in one or more pods",
-		Long:  statsDescription,
-		RunE:  stats,
+		Use:               "stats [options] [POD...]",
+		Short:             "Display a live stream of resource usage statistics for the containers in one or more pods",
+		Long:              statsDescription,
+		RunE:              stats,
+		ValidArgsFunction: common.AutocompletePodsRunning,
 		Example: `podman pod stats
   podman pod stats a69b23034235 named-pod
   podman pod stats --latest
@@ -53,7 +55,11 @@ func init() {
 
 	flags := statsCmd.Flags()
 	flags.BoolVarP(&statsOptions.All, "all", "a", false, "Provide stats for all pods")
-	flags.StringVar(&statsOptions.Format, "format", "", "Pretty-print container statistics to JSON or using a Go template")
+
+	formatFlagName := "format"
+	flags.StringVar(&statsOptions.Format, formatFlagName, "", "Pretty-print container statistics to JSON or using a Go template")
+	_ = statsCmd.RegisterFlagCompletionFunc(formatFlagName, common.AutocompleteJSONFormat)
+
 	flags.BoolVar(&statsOptions.NoReset, "no-reset", false, "Disable resetting the screen when streaming")
 	flags.BoolVar(&statsOptions.NoStream, "no-stream", false, "Disable streaming stats and only pull the first result")
 	validate.AddLatestFlag(statsCmd, &statsOptions.Latest)

cmd/podman/pods/stop.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
@@ -36,6 +37,7 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndPodIDFile(cmd, args, false, true)
 		},
+		ValidArgsFunction: common.AutocompletePodsRunning,
 		Example: `podman pod stop mywebserverpod
   podman pod stop --latest
   podman pod stop --time 0 490eb 3557fb`,
@@ -51,8 +53,15 @@ func init() {
 	flags := stopCommand.Flags()
 	flags.BoolVarP(&stopOptions.All, "all", "a", false, "Stop all running pods")
 	flags.BoolVarP(&stopOptions.Ignore, "ignore", "i", false, "Ignore errors when a specified pod is missing")
-	flags.UintVarP(&stopOptions.TimeoutCLI, "time", "t", containerConfig.Engine.StopTimeout, "Seconds to wait for pod stop before killing the container")
-	flags.StringArrayVarP(&stopOptions.PodIDFiles, "pod-id-file", "", nil, "Read the pod ID from the file")
+
+	timeFlagName := "time"
+	flags.UintVarP(&stopOptions.TimeoutCLI, timeFlagName, "t", containerConfig.Engine.StopTimeout, "Seconds to wait for pod stop before killing the container")
+	_ = stopCommand.RegisterFlagCompletionFunc(timeFlagName, completion.AutocompleteNone)
+
+	podIDFileFlagName := "pod-id-file"
+	flags.StringArrayVarP(&stopOptions.PodIDFiles, podIDFileFlagName, "", nil, "Write the pod ID to the file")
+	_ = stopCommand.RegisterFlagCompletionFunc(podIDFileFlagName, completion.AutocompleteDefault)
+
 	validate.AddLatestFlag(stopCommand, &stopOptions.Latest)
 
 	if registry.IsRemote() {

cmd/podman/pods/top.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -23,11 +24,12 @@ var (
 	topOptions = entities.PodTopOptions{}
 
 	topCommand = &cobra.Command{
-		Use:   "top [options] POD [FORMAT-DESCRIPTORS|ARGS...]",
-		Short: "Display the running processes of containers in a pod",
-		Long:  topDescription,
-		RunE:  top,
-		Args:  cobra.ArbitraryArgs,
+		Use:               "top [options] POD [FORMAT-DESCRIPTORS|ARGS...]",
+		Short:             "Display the running processes of containers in a pod",
+		Long:              topDescription,
+		RunE:              top,
+		Args:              cobra.ArbitraryArgs,
+		ValidArgsFunction: common.AutocompletePodsRunning,
 		Example: `podman pod top podID
 podman pod top --latest
 podman pod top podID pid seccomp args %C

cmd/podman/pods/unpause.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/utils"
 	"github.com/containers/podman/v2/cmd/podman/validate"
@@ -23,6 +24,9 @@ var (
 		Args: func(cmd *cobra.Command, args []string) error {
 			return validate.CheckAllLatestAndCIDFile(cmd, args, false, false)
 		},
+		// TODO have a function which shows only pods which could be unpaused
+		// for now show all
+		ValidArgsFunction: common.AutocompletePods,
 		Example: `podman pod unpause podID1 podID2
   podman pod unpause --all
   podman pod unpause --latest`,

cmd/podman/registry/remote.go

@@ -5,6 +5,7 @@ import (
 	"sync"
 
 	"github.com/containers/podman/v2/pkg/domain/entities"
+	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
 
@@ -23,7 +24,15 @@ func IsRemote() bool {
 		fs.Usage = func() {}
 		fs.SetInterspersed(false)
 		fs.BoolVarP(&remoteFromCLI.Value, "remote", "r", false, "")
-		_ = fs.Parse(os.Args[1:])
+
+		// The shell completion logic will call a command called "__complete" or "__completeNoDesc"
+		// This command will always be the second argument
+		// To still parse --remote correctly in this case we have to set args offset to two in this case
+		start := 1
+		if len(os.Args) > 1 && (os.Args[1] == cobra.ShellCompRequestCmd || os.Args[1] == cobra.ShellCompNoDescRequestCmd) {
+			start = 2
+		}
+		_ = fs.Parse(os.Args[start:])
 	})
 	return podmanOptions.EngineMode == entities.TunnelMode || remoteFromCLI.Value
 }

cmd/podman/root.go

@@ -8,7 +8,9 @@ import (
 	"runtime/pprof"
 	"strings"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/config"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/validate"
 	"github.com/containers/podman/v2/libpod/define"
@@ -21,6 +23,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 // HelpTemplate is the help template for podman commands
@@ -67,9 +70,10 @@ var (
 		Version:               version.Version.String(),
 		DisableFlagsInUseLine: true,
 	}
-	logLevels = []string{"debug", "info", "warn", "error", "fatal", "panic"}
-	logLevel  = "error"
-	useSyslog bool
+
+	logLevel       = "error"
+	useSyslog      bool
+	requireCleanup = true
 )
 
 func init() {
@@ -102,11 +106,36 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 	// TODO: Remove trace statement in podman V2.1
 	logrus.Debugf("Called %s.PersistentPreRunE(%s)", cmd.Name(), strings.Join(os.Args, " "))
 
-	// Help and commands with subcommands are special cases, no need for more setup
-	if cmd.Name() == "help" || cmd.HasSubCommands() {
+	// Help, completion and commands with subcommands are special cases, no need for more setup
+	// Completion cmd is used to generate the shell scripts
+	if cmd.Name() == "help" || cmd.Name() == "completion" || cmd.HasSubCommands() {
+		requireCleanup = false
 		return nil
 	}
 
+	// Special case if command is hidden completion command ("__complete","__completeNoDesc")
+	// Since __completeNoDesc is an alias the cm.Name is always __complete
+	if cmd.Name() == cobra.ShellCompRequestCmd {
+		// Parse the cli arguments after the the completion cmd (always called as second argument)
+		// This ensures that the --url, --identity and --connection flags are properly set
+		compCmd, _, err := cmd.Root().Traverse(os.Args[2:])
+		if err != nil {
+			return err
+		}
+		// If we don't complete the root cmd hide all root flags
+		// so they won't show up in the completions on subcommands.
+		if compCmd != compCmd.Root() {
+			compCmd.Root().Flags().VisitAll(func(flag *pflag.Flag) {
+				flag.Hidden = true
+			})
+		}
+		// No need for further setup when completing commands with subcommands.
+		if compCmd.HasSubCommands() {
+			requireCleanup = false
+			return nil
+		}
+	}
+
 	cfg := registry.PodmanConfig()
 
 	// --connection is not as "special" as --remote so we can wait and process it here
@@ -203,8 +232,7 @@ func persistentPostRunE(cmd *cobra.Command, args []string) error {
 	// TODO: Remove trace statement in podman V2.1
 	logrus.Debugf("Called %s.PersistentPostRunE(%s)", cmd.Name(), strings.Join(os.Args, " "))
 
-	// Help and commands with subcommands are special cases, no need for more cleanup
-	if cmd.Name() == "help" || cmd.HasSubCommands() {
+	if !requireCleanup {
 		return nil
 	}
 
@@ -226,14 +254,14 @@ func persistentPostRunE(cmd *cobra.Command, args []string) error {
 
 func loggingHook() {
 	var found bool
-	for _, l := range logLevels {
+	for _, l := range common.LogLevels {
 		if l == strings.ToLower(logLevel) {
 			found = true
 			break
 		}
 	}
 	if !found {
-		fmt.Fprintf(os.Stderr, "Log Level %q is not supported, choose from: %s\n", logLevel, strings.Join(logLevels, ", "))
+		fmt.Fprintf(os.Stderr, "Log Level %q is not supported, choose from: %s\n", logLevel, strings.Join(common.LogLevels, ", "))
 		os.Exit(1)
 	}
 
@@ -254,9 +282,18 @@ func rootFlags(cmd *cobra.Command, opts *entities.PodmanConfig) {
 	srv, uri, ident := resolveDestination()
 
 	lFlags := cmd.Flags()
-	lFlags.StringVarP(&opts.Engine.ActiveService, "connection", "c", srv, "Connection to use for remote Podman service")
-	lFlags.StringVar(&opts.URI, "url", uri, "URL to access Podman service (CONTAINER_HOST)")
-	lFlags.StringVar(&opts.Identity, "identity", ident, "path to SSH identity file, (CONTAINER_SSHKEY)")
+
+	connectionFlagName := "connection"
+	lFlags.StringVarP(&opts.Engine.ActiveService, connectionFlagName, "c", srv, "Connection to use for remote Podman service")
+	_ = cmd.RegisterFlagCompletionFunc(connectionFlagName, common.AutocompleteSystemConnections)
+
+	urlFlagName := "url"
+	lFlags.StringVar(&opts.URI, urlFlagName, uri, "URL to access Podman service (CONTAINER_HOST)")
+	_ = cmd.RegisterFlagCompletionFunc(urlFlagName, completion.AutocompleteDefault)
+
+	identityFlagName := "identity"
+	lFlags.StringVar(&opts.Identity, identityFlagName, ident, "path to SSH identity file, (CONTAINER_SSHKEY)")
+	_ = cmd.RegisterFlagCompletionFunc(identityFlagName, completion.AutocompleteDefault)
 
 	lFlags.BoolVarP(&opts.Remote, "remote", "r", false, "Access remote Podman service (default false)")
 	pFlags := cmd.PersistentFlags()
@@ -266,25 +303,67 @@ func rootFlags(cmd *cobra.Command, opts *entities.PodmanConfig) {
 		}
 		opts.Remote = true
 	} else {
-		pFlags.StringVar(&cfg.Engine.CgroupManager, "cgroup-manager", cfg.Engine.CgroupManager, "Cgroup manager to use (\"cgroupfs\"|\"systemd\")")
-		pFlags.StringVar(&opts.CPUProfile, "cpu-profile", "", "Path for the cpu profiling results")
-		pFlags.StringVar(&opts.ConmonPath, "conmon", "", "Path of the conmon binary")
-		pFlags.StringVar(&cfg.Engine.NetworkCmdPath, "network-cmd-path", cfg.Engine.NetworkCmdPath, "Path to the command for configuring the network")
-		pFlags.StringVar(&cfg.Network.NetworkConfigDir, "cni-config-dir", cfg.Network.NetworkConfigDir, "Path of the configuration directory for CNI networks")
-		pFlags.StringVar(&cfg.Containers.DefaultMountsFile, "default-mounts-file", cfg.Containers.DefaultMountsFile, "Path to default mounts file")
-		pFlags.StringVar(&cfg.Engine.EventsLogger, "events-backend", cfg.Engine.EventsLogger, `Events backend to use ("file"|"journald"|"none")`)
-		pFlags.StringSliceVar(&cfg.Engine.HooksDir, "hooks-dir", cfg.Engine.HooksDir, "Set the OCI hooks directory path (may be set multiple times)")
-		pFlags.IntVar(&opts.MaxWorks, "max-workers", (runtime.NumCPU()*3)+1, "The maximum number of workers for parallel operations")
-		pFlags.StringVar(&cfg.Engine.Namespace, "namespace", cfg.Engine.Namespace, "Set the libpod namespace, used to create separate views of the containers and pods on the system")
-		pFlags.StringVar(&cfg.Engine.StaticDir, "root", "", "Path to the root directory in which data, including images, is stored")
-		pFlags.StringVar(&opts.RegistriesConf, "registries-conf", "", "Path to a registries.conf to use for image processing")
-		pFlags.StringVar(&opts.Runroot, "runroot", "", "Path to the 'run directory' where all state information is stored")
-		pFlags.StringVar(&opts.RuntimePath, "runtime", "", "Path to the OCI-compatible binary used to run containers, default is /usr/bin/runc")
-		// -s is deprecated due to conflict with -s on subcommands
-		pFlags.StringVar(&opts.StorageDriver, "storage-driver", "", "Select which storage driver is used to manage storage of images and containers (default is overlay)")
-		pFlags.StringArrayVar(&opts.StorageOpts, "storage-opt", []string{}, "Used to pass an option to the storage driver")
+		cgroupManagerFlagName := "cgroup-manager"
+		pFlags.StringVar(&cfg.Engine.CgroupManager, cgroupManagerFlagName, cfg.Engine.CgroupManager, "Cgroup manager to use (\"cgroupfs\"|\"systemd\")")
+		_ = cmd.RegisterFlagCompletionFunc(cgroupManagerFlagName, common.AutocompleteCgroupManager)
+
+		pFlags.StringVar(&opts.CPUProfile, "cpu-profile", "", "Path for the cpu profiling results")
+
+		conmonFlagName := "conmon"
+		pFlags.StringVar(&opts.ConmonPath, conmonFlagName, "", "Path of the conmon binary")
+		_ = cmd.RegisterFlagCompletionFunc(conmonFlagName, completion.AutocompleteDefault)
+
+		networkCmdPathFlagName := "network-cmd-path"
+		pFlags.StringVar(&cfg.Engine.NetworkCmdPath, networkCmdPathFlagName, cfg.Engine.NetworkCmdPath, "Path to the command for configuring the network")
+		_ = cmd.RegisterFlagCompletionFunc(networkCmdPathFlagName, completion.AutocompleteDefault)
+
+		cniConfigDirFlagName := "cni-config-dir"
+		pFlags.StringVar(&cfg.Network.NetworkConfigDir, cniConfigDirFlagName, cfg.Network.NetworkConfigDir, "Path of the configuration directory for CNI networks")
+		_ = cmd.RegisterFlagCompletionFunc(cniConfigDirFlagName, completion.AutocompleteDefault)
+
+		pFlags.StringVar(&cfg.Containers.DefaultMountsFile, "default-mounts-file", cfg.Containers.DefaultMountsFile, "Path to default mounts file")
+
+		eventsBackendFlagName := "events-backend"
+		pFlags.StringVar(&cfg.Engine.EventsLogger, eventsBackendFlagName, cfg.Engine.EventsLogger, `Events backend to use ("file"|"journald"|"none")`)
+		_ = cmd.RegisterFlagCompletionFunc(eventsBackendFlagName, common.AutocompleteEventBackend)
+
+		hooksDirFlagName := "hooks-dir"
+		pFlags.StringSliceVar(&cfg.Engine.HooksDir, hooksDirFlagName, cfg.Engine.HooksDir, "Set the OCI hooks directory path (may be set multiple times)")
+		_ = cmd.RegisterFlagCompletionFunc(hooksDirFlagName, completion.AutocompleteDefault)
+
+		pFlags.IntVar(&opts.MaxWorks, "max-workers", (runtime.NumCPU()*3)+1, "The maximum number of workers for parallel operations")
+
+		namespaceFlagName := "namespace"
+		pFlags.StringVar(&cfg.Engine.Namespace, namespaceFlagName, cfg.Engine.Namespace, "Set the libpod namespace, used to create separate views of the containers and pods on the system")
+		_ = cmd.RegisterFlagCompletionFunc(namespaceFlagName, completion.AutocompleteNone)
+
+		rootFlagName := "root"
+		pFlags.StringVar(&cfg.Engine.StaticDir, rootFlagName, "", "Path to the root directory in which data, including images, is stored")
+		_ = cmd.RegisterFlagCompletionFunc(rootFlagName, completion.AutocompleteDefault)
+
+		pFlags.StringVar(&opts.RegistriesConf, "registries-conf", "", "Path to a registries.conf to use for image processing")
+
+		runrootFlagName := "runroot"
+		pFlags.StringVar(&opts.Runroot, runrootFlagName, "", "Path to the 'run directory' where all state information is stored")
+		_ = cmd.RegisterFlagCompletionFunc(runrootFlagName, completion.AutocompleteDefault)
+
+		runtimeFlagName := "runtime"
+		pFlags.StringVar(&opts.RuntimePath, runtimeFlagName, "", "Path to the OCI-compatible binary used to run containers, default is /usr/bin/runc")
+		_ = cmd.RegisterFlagCompletionFunc(runtimeFlagName, completion.AutocompleteDefault)
+
+		// -s is deprecated due to conflict with -s on subcommands
+		storageDriverFlagName := "storage-driver"
+		pFlags.StringVar(&opts.StorageDriver, storageDriverFlagName, "", "Select which storage driver is used to manage storage of images and containers (default is overlay)")
+		_ = cmd.RegisterFlagCompletionFunc(storageDriverFlagName, completion.AutocompleteNone) //TODO: what can we recommend here?
+
+		storageOptFlagName := "storage-opt"
+		pFlags.StringArrayVar(&opts.StorageOpts, storageOptFlagName, []string{}, "Used to pass an option to the storage driver")
+		_ = cmd.RegisterFlagCompletionFunc(storageOptFlagName, completion.AutocompleteNone)
+
+		tmpdirFlagName := "tmpdir"
+		pFlags.StringVar(&opts.Engine.TmpDir, tmpdirFlagName, "", "Path to the tmp directory for libpod state content.\n\nNote: use the environment variable 'TMPDIR' to change the temporary storage location for container images, '/var/tmp'.\n")
+		_ = cmd.RegisterFlagCompletionFunc(tmpdirFlagName, completion.AutocompleteDefault)
 
-		pFlags.StringVar(&opts.Engine.TmpDir, "tmpdir", "", "Path to the tmp directory for libpod state content.\n\nNote: use the environment variable 'TMPDIR' to change the temporary storage location for container images, '/var/tmp'.\n")
 		pFlags.BoolVar(&opts.Trace, "trace", false, "Enable opentracing output (default false)")
 
 		// Hide these flags for both ABI and Tunneling
@@ -303,11 +382,17 @@ func rootFlags(cmd *cobra.Command, opts *entities.PodmanConfig) {
 	// Override default --help information of `--help` global flag
 	var dummyHelp bool
 	pFlags.BoolVar(&dummyHelp, "help", false, "Help for podman")
-	pFlags.StringVar(&logLevel, "log-level", logLevel, fmt.Sprintf("Log messages above specified level (%s)", strings.Join(logLevels, ", ")))
+
+	logLevelFlagName := "log-level"
+	pFlags.StringVar(&logLevel, logLevelFlagName, logLevel, fmt.Sprintf("Log messages above specified level (%s)", strings.Join(common.LogLevels, ", ")))
+	_ = rootCmd.RegisterFlagCompletionFunc(logLevelFlagName, common.AutocompleteLogLevel)
 
 	// Only create these flags for ABI connections
 	if !registry.IsRemote() {
-		pFlags.StringArrayVar(&opts.RuntimeFlags, "runtime-flag", []string{}, "add global flags for the container runtime")
+		runtimeflagFlagName := "runtime-flag"
+		pFlags.StringArrayVar(&opts.RuntimeFlags, runtimeflagFlagName, []string{}, "add global flags for the container runtime")
+		_ = rootCmd.RegisterFlagCompletionFunc(runtimeflagFlagName, completion.AutocompleteNone)
+
 		pFlags.BoolVar(&useSyslog, "syslog", false, "Output logging information to syslog as well as the console (default false)")
 	}
 }

cmd/podman/shell_completion_test.go

@@ -0,0 +1,71 @@
+/*
+	The purpose of this test is to keep a consistent
+	and great shell autocompletion experience.
+
+	This test ensures that each command and flag has a shell completion
+	function set. (except boolean, hidden and deprecated flags)
+
+	Shell completion functions are defined in:
+	- "github.com/containers/podman/v2/cmd/podman/common/completion.go"
+	- "github.com/containers/common/pkg/completion"
+	and are called Autocomplete...
+
+	To apply such function to a command use the ValidArgsFunction field.
+	To apply such function to a flag use cmd.RegisterFlagCompletionFunc(name,func)
+
+	If there are any questions/problems please tag Luap99.
+*/
+
+package main
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+func TestShellCompletionFunctions(t *testing.T) {
+
+	rootCmd := parseCommands()
+	checkCommand(t, rootCmd)
+
+}
+
+func checkCommand(t *testing.T, cmd *cobra.Command) {
+
+	if cmd.HasSubCommands() {
+		for _, childCmd := range cmd.Commands() {
+			checkCommand(t, childCmd)
+		}
+
+		// if not check if completion for that command is provided
+	} else if cmd.ValidArgsFunction == nil && cmd.ValidArgs == nil {
+		t.Errorf("%s command has no shell completion function set", cmd.CommandPath())
+	}
+
+	// loop over all local flags
+	cmd.LocalFlags().VisitAll(func(flag *pflag.Flag) {
+
+		// an error means that there is a completion function for this flag
+		err := cmd.RegisterFlagCompletionFunc(flag.Name, func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return nil, cobra.ShellCompDirectiveDefault
+		})
+
+		switch {
+		case flag.Value.Type() == "bool" && err != nil:
+			// make sure bool flags don't have a completion function
+			t.Errorf(`%s --%s is a bool flag but has a shell completion function set.
+You have to remove this shell completion function.`, cmd.CommandPath(), flag.Name)
+			return
+
+		case flag.Value.Type() == "bool" || flag.Hidden || len(flag.Deprecated) > 0:
+			// skip bool, hidden and deprecated flags
+			return
+
+		case err == nil:
+			// there is no shell completion function
+			t.Errorf("%s --%s flag has no shell completion function set", cmd.CommandPath(), flag.Name)
+		}
+	})
+}

cmd/podman/system/connection/add.go

@@ -10,6 +10,7 @@ import (
 	"os/user"
 	"regexp"
 
+	"github.com/containers/common/pkg/completion"
 	"github.com/containers/common/pkg/config"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/system"
@@ -34,7 +35,8 @@ var (
   "destination" is of the form [user@]hostname or
   an URI of the form ssh://[user@]hostname[:port]
 `,
-		RunE: add,
+		RunE:              add,
+		ValidArgsFunction: completion.AutocompleteNone,
 		Example: `podman system connection add laptop server.fubar.com
   podman system connection add --identity ~/.ssh/dev_rsa testing ssh://root@server.fubar.com:2222
   podman system connection add --identity ~/.ssh/dev_rsa --port 22 production root@server.fubar.com
@@ -57,9 +59,19 @@ func init() {
 	})
 
 	flags := addCmd.Flags()
-	flags.IntVarP(&cOpts.Port, "port", "p", 22, "SSH port number for destination")
-	flags.StringVar(&cOpts.Identity, "identity", "", "path to SSH identity file")
-	flags.StringVar(&cOpts.UDSPath, "socket-path", "", "path to podman socket on remote host. (default '/run/podman/podman.sock' or '/run/user/{uid}/podman/podman.sock)")
+
+	portFlagName := "port"
+	flags.IntVarP(&cOpts.Port, portFlagName, "p", 22, "SSH port number for destination")
+	_ = addCmd.RegisterFlagCompletionFunc(portFlagName, completion.AutocompleteNone)
+
+	identityFlagName := "identity"
+	flags.StringVar(&cOpts.Identity, identityFlagName, "", "path to SSH identity file")
+	_ = addCmd.RegisterFlagCompletionFunc(identityFlagName, completion.AutocompleteDefault)
+
+	socketPathFlagName := "socket-path"
+	flags.StringVar(&cOpts.UDSPath, socketPathFlagName, "", "path to podman socket on remote host. (default '/run/podman/podman.sock' or '/run/user/{uid}/podman/podman.sock)")
+	_ = addCmd.RegisterFlagCompletionFunc(socketPathFlagName, completion.AutocompleteDefault)
+
 	flags.BoolVarP(&cOpts.Default, "default", "d", false, "Set connection to be default")
 }
 

cmd/podman/system/connection/default.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/containers/common/pkg/config"
+	"github.com/containers/podman/v2/cmd/podman/common"
 	"github.com/containers/podman/v2/cmd/podman/registry"
 	"github.com/containers/podman/v2/cmd/podman/system"
 	"github.com/containers/podman/v2/pkg/domain/entities"
@@ -18,6 +19,7 @@ var (
 		Short:                 "Set named destination as default",
 		Long:                  `Set named destination as default for the Podman service`,
 		DisableFlagsInUseLine: true,
+		ValidArgsFunction:     common.AutocompleteSystemConnections,
 		RunE:                  defaultRunE,
 		Example:               `podman system connection default testing`,
 	}