639 lines
26 KiB
Go
639 lines
26 KiB
Go
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
|
|
}
|