Permalink
4427 lines (4014 sloc) 86.4 KB
#!/usr/bin/env bash
#
# bash completion file for core docker commands
#
# This script provides completion of:
# - commands and their options
# - container ids and names
# - image repos and tags
# - filepaths
#
# To enable the completions either:
# - place this file in /etc/bash_completion.d
# or
# - copy this file to e.g. ~/.docker-completion.sh and add the line
# below to your .bashrc after bash completion features are loaded
# . ~/.docker-completion.sh
#
# Configuration:
#
# For several commands, the amount of completions can be configured by
# setting environment variables.
#
# DOCKER_COMPLETION_SHOW_CONTAINER_IDS
# DOCKER_COMPLETION_SHOW_NETWORK_IDS
# DOCKER_COMPLETION_SHOW_NODE_IDS
# DOCKER_COMPLETION_SHOW_PLUGIN_IDS
# DOCKER_COMPLETION_SHOW_SECRET_IDS
# DOCKER_COMPLETION_SHOW_SERVICE_IDS
# "no" - Show names only (default)
# "yes" - Show names and ids
#
# You can tailor completion for the "events", "history", "inspect", "run",
# "rmi" and "save" commands by settings the following environment
# variables:
#
# DOCKER_COMPLETION_SHOW_IMAGE_IDS
# "none" - Show names only (default)
# "non-intermediate" - Show names and ids, but omit intermediate image IDs
# "all" - Show names and ids, including intermediate image IDs
#
# DOCKER_COMPLETION_SHOW_TAGS
# "yes" - include tags in completion options (default)
# "no" - don't include tags in completion options
#
# Note:
# Currently, the completions will not work if the docker daemon is not
# bound to the default communication port/socket
# If the docker daemon is using a unix socket for communication your user
# must have access to the socket for the completions to function correctly
#
# Note for developers:
# Please arrange options sorted alphabetically by long name with the short
# options immediately following their corresponding long form.
# This order should be applied to lists, alternatives and code blocks.
__docker_previous_extglob_setting=$(shopt -p extglob)
shopt -s extglob
__docker_q() {
docker ${host:+-H "$host"} ${config:+--config "$config"} 2>/dev/null "$@"
}
# __docker_containers returns a list of containers. Additional options to
# `docker ps` may be specified in order to filter the list, e.g.
# `__docker_containers --filter status=running`
# By default, only names are returned.
# Set DOCKER_COMPLETION_SHOW_CONTAINER_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__docker_containers() {
local format
if [ "$1" = "--id" ] ; then
format='{{.ID}}'
shift
elif [ "$1" = "--name" ] ; then
format='{{.Names}}'
shift
elif [ "${DOCKER_COMPLETION_SHOW_CONTAINER_IDS}" = yes ] ; then
format='{{.ID}} {{.Names}}'
else
format='{{.Names}}'
fi
__docker_q ps --format "$format" "$@"
}
# __docker_complete_containers applies completion of containers based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__docker_containers`.
__docker_complete_containers() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_containers "$@")" -- "$current") )
}
__docker_complete_containers_all() {
__docker_complete_containers "$@" --all
}
__docker_complete_containers_running() {
__docker_complete_containers "$@" --filter status=running
}
__docker_complete_containers_stopped() {
__docker_complete_containers "$@" --filter status=exited
}
__docker_complete_containers_unpauseable() {
__docker_complete_containers "$@" --filter status=paused
}
__docker_complete_container_names() {
local containers=( $(__docker_q ps -aq --no-trunc) )
local names=( $(__docker_q inspect --format '{{.Name}}' "${containers[@]}") )
names=( "${names[@]#/}" ) # trim off the leading "/" from the container names
COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
}
__docker_complete_container_ids() {
local containers=( $(__docker_q ps -aq) )
COMPREPLY=( $(compgen -W "${containers[*]}" -- "$cur") )
}
__docker_images() {
local images_args=""
case "$DOCKER_COMPLETION_SHOW_IMAGE_IDS" in
all)
images_args="--no-trunc -a"
;;
non-intermediate)
images_args="--no-trunc"
;;
esac
local repo_print_command
if [ "${DOCKER_COMPLETION_SHOW_TAGS:-yes}" = "yes" ]; then
repo_print_command='print $1; print $1":"$2'
else
repo_print_command='print $1'
fi
local awk_script
case "$DOCKER_COMPLETION_SHOW_IMAGE_IDS" in
all|non-intermediate)
awk_script='NR>1 { print $3; if ($1 != "<none>") { '"$repo_print_command"' } }'
;;
none|*)
awk_script='NR>1 && $1 != "<none>" { '"$repo_print_command"' }'
;;
esac
__docker_q images $images_args | awk "$awk_script" | grep -v '<none>$'
}
__docker_complete_images() {
COMPREPLY=( $(compgen -W "$(__docker_images)" -- "$cur") )
__ltrim_colon_completions "$cur"
}
__docker_complete_image_repos() {
local repos="$(__docker_q images | awk 'NR>1 && $1 != "<none>" { print $1 }')"
COMPREPLY=( $(compgen -W "$repos" -- "$cur") )
}
__docker_complete_image_repos_and_tags() {
local reposAndTags="$(__docker_q images | awk 'NR>1 && $1 != "<none>" { print $1; print $1":"$2 }')"
COMPREPLY=( $(compgen -W "$reposAndTags" -- "$cur") )
__ltrim_colon_completions "$cur"
}
# __docker_networks returns a list of all networks. Additional options to
# `docker network ls` may be specified in order to filter the list, e.g.
# `__docker_networks --filter type=custom`
# By default, only names are returned.
# Set DOCKER_COMPLETION_SHOW_NETWORK_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__docker_networks() {
local format
if [ "$1" = "--id" ] ; then
format='{{.ID}}'
shift
elif [ "$1" = "--name" ] ; then
format='{{.Name}}'
shift
elif [ "${DOCKER_COMPLETION_SHOW_NETWORK_IDS}" = yes ] ; then
format='{{.ID}} {{.Name}}'
else
format='{{.Name}}'
fi
__docker_q network ls --format "$format" "$@"
}
# __docker_complete_networks applies completion of networks based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__docker_networks`.
__docker_complete_networks() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_networks "$@")" -- "$current") )
}
__docker_complete_containers_in_network() {
local containers=$(__docker_q network inspect -f '{{range $i, $c := .Containers}}{{$i}} {{$c.Name}} {{end}}' "$1")
COMPREPLY=( $(compgen -W "$containers" -- "$cur") )
}
# __docker_volumes returns a list of all volumes. Additional options to
# `docker volume ls` may be specified in order to filter the list, e.g.
# `__docker_volumes --filter dangling=true`
# Because volumes do not have IDs, this function does not distinguish between
# IDs and names.
__docker_volumes() {
__docker_q volume ls -q "$@"
}
# __docker_complete_volumes applies completion of volumes based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__docker_volumes`.
__docker_complete_volumes() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_volumes "$@")" -- "$current") )
}
# __docker_plugins_bundled returns a list of all plugins of a given type.
# The type has to be specified with the mandatory option `--type`.
# Valid types are: Network, Volume, Authorization.
# Completions may be added or removed with `--add` and `--remove`
# This function only deals with plugins that come bundled with Docker.
# For plugins managed by `docker plugin`, see `__docker_plugins_installed`.
__docker_plugins_bundled() {
local type add=() remove=()
while true ; do
case "$1" in
--type)
type="$2"
shift 2
;;
--add)
add+=("$2")
shift 2
;;
--remove)
remove+=("$2")
shift 2
;;
*)
break
;;
esac
done
local plugins=($(__docker_q info --format "{{range \$i, \$p := .Plugins.$type}}{{.}} {{end}}"))
for del in "${remove[@]}" ; do
plugins=(${plugins[@]/$del/})
done
echo "${plugins[@]} ${add[@]}"
}
# __docker_complete_plugins_bundled applies completion of plugins based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# The plugin type has to be specified with the next option `--type`.
# This function only deals with plugins that come bundled with Docker.
# For completion of plugins managed by `docker plugin`, see
# `__docker_complete_plugins_installed`.
__docker_complete_plugins_bundled() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_plugins_bundled "$@")" -- "$current") )
}
# __docker_plugins_installed returns a list of all plugins that were installed with
# the Docker plugin API.
# By default, only names are returned.
# Set DOCKER_COMPLETION_SHOW_PLUGIN_IDS=yes to also complete IDs.
# Additional options to `docker plugin ls` may be specified in order to filter the list,
# e.g. `__docker_plugins_installed --filter enabled=true`
# For built-in pugins, see `__docker_plugins_bundled`.
__docker_plugins_installed() {
local format
if [ "$DOCKER_COMPLETION_SHOW_PLUGIN_IDS" = yes ] ; then
format='{{.ID}} {{.Name}}'
else
format='{{.Name}}'
fi
__docker_q plugin ls --format "$format" "$@"
}
# __docker_complete_plugins_installed applies completion of plugins that were installed
# with the Docker plugin API, based on the current value of `$cur` or the value of
# the optional first option `--cur`, if given.
# Additional filters may be appended, see `__docker_plugins_installed`.
# For completion of built-in pugins, see `__docker_complete_plugins_bundled`.
__docker_complete_plugins_installed() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_plugins_installed "$@")" -- "$current") )
}
__docker_runtimes() {
__docker_q info | sed -n 's/^Runtimes: \(.*\)/\1/p'
}
__docker_complete_runtimes() {
COMPREPLY=( $(compgen -W "$(__docker_runtimes)" -- "$cur") )
}
# __docker_secrets returns a list of all secrets.
# By default, only names of secrets are returned.
# Set DOCKER_COMPLETION_SHOW_SECRET_IDS=yes to also complete IDs of secrets.
__docker_secrets() {
local fields='$2' # default: name only
[ "${DOCKER_COMPLETION_SHOW_SECRET_IDS}" = yes ] && fields='$1,$2' # ID and name
__docker_q secret ls | awk "NR>1 {print $fields}"
}
# __docker_complete_secrets applies completion of secrets based on the current value
# of `$cur`.
__docker_complete_secrets() {
COMPREPLY=( $(compgen -W "$(__docker_secrets)" -- "$cur") )
}
# __docker_stacks returns a list of all stacks.
__docker_stacks() {
__docker_q stack ls | awk 'NR>1 {print $1}'
}
# __docker_complete_stacks applies completion of stacks based on the current value
# of `$cur` or the value of the optional first option `--cur`, if given.
__docker_complete_stacks() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_stacks "$@")" -- "$current") )
}
# __docker_nodes returns a list of all nodes. Additional options to
# `docker node ls` may be specified in order to filter the list, e.g.
# `__docker_nodes --filter role=manager`
# By default, only node names are returned.
# Set DOCKER_COMPLETION_SHOW_NODE_IDS=yes to also complete node IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
# Completions may be added with `--add`, e.g. `--add self`.
__docker_nodes() {
local add=()
local fields='$2' # default: node name only
[ "${DOCKER_COMPLETION_SHOW_NODE_IDS}" = yes ] && fields='$1,$2' # ID and name
while true ; do
case "$1" in
--id)
fields='$1' # IDs only
shift
;;
--name)
fields='$2' # names only
shift
;;
--add)
add+=("$2")
shift 2
;;
*)
break
;;
esac
done
echo $(__docker_q node ls "$@" | tr -d '*' | awk "NR>1 {print $fields}") "${add[@]}"
}
# __docker_complete_nodes applies completion of nodes based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__docker_nodes`.
__docker_complete_nodes() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_nodes "$@")" -- "$current") )
}
__docker_complete_nodes_plus_self() {
__docker_complete_nodes --add self "$@"
}
# __docker_services returns a list of all services. Additional options to
# `docker service ls` may be specified in order to filter the list, e.g.
# `__docker_services --filter name=xxx`
# By default, only node names are returned.
# Set DOCKER_COMPLETION_SHOW_SERVICE_IDS=yes to also complete IDs.
# An optional first option `--id|--name` may be used to limit the
# output to the IDs or names of matching items. This setting takes
# precedence over the environment setting.
__docker_services() {
local fields='$2' # default: service name only
[ "${DOCKER_COMPLETION_SHOW_SERVICE_IDS}" = yes ] && fields='$1,$2' # ID & name
if [ "$1" = "--id" ] ; then
fields='$1' # IDs only
shift
elif [ "$1" = "--name" ] ; then
fields='$2' # names only
shift
fi
__docker_q service ls "$@" | awk "NR>1 {print $fields}"
}
# __docker_complete_services applies completion of services based on the current
# value of `$cur` or the value of the optional first option `--cur`, if given.
# Additional filters may be appended, see `__docker_services`.
__docker_complete_services() {
local current="$cur"
if [ "$1" = "--cur" ] ; then
current="$2"
shift 2
fi
COMPREPLY=( $(compgen -W "$(__docker_services "$@")" -- "$current") )
}
# __docker_append_to_completions appends the word passed as an argument to every
# word in `$COMPREPLY`.
# Normally you do this with `compgen -S` while generating the completions.
# This function allows you to append a suffix later. It allows you to use
# the __docker_complete_XXX functions in cases where you need a suffix.
__docker_append_to_completions() {
COMPREPLY=( ${COMPREPLY[@]/%/"$1"} )
}
# __docker_daemon_is_experimental tests whether the currently configured Docker
# daemon runs in experimental mode. If so, the function exits with 0 (true).
# Otherwise, or if the result cannot be determined, the exit value is 1 (false).
__docker_daemon_is_experimental() {
[ "$(__docker_q version -f '{{.Server.Experimental}}')" = "true" ]
}
# __docker_daemon_os_is tests whether the currently configured Docker daemon runs
# on the operating system passed in as the first argument.
# It does so by querying the daemon for its OS. The result is cached for the duration
# of one invocation of bash completion so that this function can be used to test for
# several different operating systems without additional costs.
# Known operating systems: linux, windows.
__docker_daemon_os_is() {
local expected_os="$1"
local actual_os=${daemon_os=$(__docker_q version -f '{{.Server.Os}}')}
[ "$actual_os" = "$expected_os" ]
}
# __docker_pos_first_nonflag finds the position of the first word that is neither
# option nor an option's argument. If there are options that require arguments,
# you should pass a glob describing those options, e.g. "--option1|-o|--option2"
# Use this function to restrict completions to exact positions after the argument list.
__docker_pos_first_nonflag() {
local argument_flags=$1
local counter=$((${subcommand_pos:-${command_pos}} + 1))
while [ $counter -le $cword ]; do
if [ -n "$argument_flags" ] && eval "case '${words[$counter]}' in $argument_flags) true ;; *) false ;; esac"; then
(( counter++ ))
# eat "=" in case of --option=arg syntax
[ "${words[$counter]}" = "=" ] && (( counter++ ))
else
case "${words[$counter]}" in
-*)
;;
*)
break
;;
esac
fi
# Bash splits words at "=", retaining "=" as a word, examples:
# "--debug=false" => 3 words, "--log-opt syslog-facility=daemon" => 4 words
while [ "${words[$counter + 1]}" = "=" ] ; do
counter=$(( counter + 2))
done
(( counter++ ))
done
echo $counter
}
# __docker_map_key_of_current_option returns `key` if we are currently completing the
# value of a map option (`key=value`) which matches the extglob given as an argument.
# This function is needed for key-specific completions.
__docker_map_key_of_current_option() {
local glob="$1"
local key glob_pos
if [ "$cur" = "=" ] ; then # key= case
key="$prev"
glob_pos=$((cword - 2))
elif [[ $cur == *=* ]] ; then # key=value case (OSX)
key=${cur%=*}
glob_pos=$((cword - 1))
elif [ "$prev" = "=" ] ; then
key=${words[$cword - 2]} # key=value case
glob_pos=$((cword - 3))
else
return
fi
[ "${words[$glob_pos]}" = "=" ] && ((glob_pos--)) # --option=key=value syntax
[[ ${words[$glob_pos]} == @($glob) ]] && echo "$key"
}
# __docker_value_of_option returns the value of the first option matching `option_glob`.
# Valid values for `option_glob` are option names like `--log-level` and globs like
# `--log-level|-l`
# Only positions between the command and the current word are considered.
__docker_value_of_option() {
local option_extglob=$(__docker_to_extglob "$1")
local counter=$((command_pos + 1))
while [ $counter -lt $cword ]; do
case ${words[$counter]} in
$option_extglob )
echo ${words[$counter + 1]}
break
;;
esac
(( counter++ ))
done
}
# __docker_to_alternatives transforms a multiline list of strings into a single line
# string with the words separated by `|`.
# This is used to prepare arguments to __docker_pos_first_nonflag().
__docker_to_alternatives() {
local parts=( $1 )
local IFS='|'
echo "${parts[*]}"
}
# __docker_to_extglob transforms a multiline list of options into an extglob pattern
# suitable for use in case statements.
__docker_to_extglob() {
local extglob=$( __docker_to_alternatives "$1" )
echo "@($extglob)"
}
# __docker_subcommands processes subcommands
# Locates the first occurrence of any of the subcommands contained in the
# first argument. In case of a match, calls the corresponding completion
# function and returns 0.
# If no match is found, 1 is returned. The calling function can then
# continue processing its completion.
#
# TODO if the preceding command has options that accept arguments and an
# argument is equal ot one of the subcommands, this is falsely detected as
# a match.
__docker_subcommands() {
local subcommands="$1"
local counter=$(($command_pos + 1))
while [ $counter -lt $cword ]; do
case "${words[$counter]}" in
$(__docker_to_extglob "$subcommands") )
subcommand_pos=$counter
local subcommand=${words[$counter]}
local completions_func=_docker_${command}_${subcommand}
declare -F $completions_func >/dev/null && $completions_func
return 0
;;
esac
(( counter++ ))
done
return 1
}
# __docker_nospace suppresses trailing whitespace
__docker_nospace() {
# compopt is not available in ancient bash versions
type compopt &>/dev/null && compopt -o nospace
}
__docker_complete_resolved_hostname() {
command -v host >/dev/null 2>&1 || return
COMPREPLY=( $(host 2>/dev/null "${cur%:}" | awk '/has address/ {print $4}') )
}
__docker_local_interfaces() {
command -v ip >/dev/null 2>&1 || return
ip addr show scope global 2>/dev/null | sed -n 's| \+inet \([0-9.]\+\).* \([^ ]\+\)|\1 \2|p'
}
__docker_complete_local_interfaces() {
local additional_interface
if [ "$1" = "--add" ] ; then
additional_interface="$2"
fi
COMPREPLY=( $( compgen -W "$(__docker_local_interfaces) $additional_interface" -- "$cur" ) )
}
# __docker_complete_capabilities_addable completes Linux capabilities which are
# not granted by default and may be added.
# see https://docs.docker.com/engine/reference/run/#/runtime-privilege-and-linux-capabilities
__docker_complete_capabilities_addable() {
COMPREPLY=( $( compgen -W "
ALL
AUDIT_CONTROL
BLOCK_SUSPEND
DAC_READ_SEARCH
IPC_LOCK
IPC_OWNER
LEASE
LINUX_IMMUTABLE
MAC_ADMIN
MAC_OVERRIDE
NET_ADMIN
NET_BROADCAST
SYS_ADMIN
SYS_BOOT
SYSLOG
SYS_MODULE
SYS_NICE
SYS_PACCT
SYS_PTRACE
SYS_RAWIO
SYS_RESOURCE
SYS_TIME
SYS_TTY_CONFIG
WAKE_ALARM
" -- "$cur" ) )
}
# __docker_complete_capabilities_droppable completes Linux capability options which are
# allowed by default and can be dropped.
# see https://docs.docker.com/engine/reference/run/#/runtime-privilege-and-linux-capabilities
__docker_complete_capabilities_droppable() {
COMPREPLY=( $( compgen -W "
ALL
AUDIT_WRITE
CHOWN
DAC_OVERRIDE
FOWNER
FSETID
KILL
MKNOD
NET_BIND_SERVICE
NET_RAW
SETFCAP
SETGID
SETPCAP
SETUID
SYS_CHROOT
" -- "$cur" ) )
}
__docker_complete_detach-keys() {
case "$prev" in
--detach-keys)
case "$cur" in
*,)
COMPREPLY=( $( compgen -W "${cur}ctrl-" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "ctrl-" -- "$cur" ) )
;;
esac
__docker_nospace
return
;;
esac
return 1
}
__docker_complete_isolation() {
COMPREPLY=( $( compgen -W "default hyperv process" -- "$cur" ) )
}
__docker_complete_log_drivers() {
COMPREPLY=( $( compgen -W "
awslogs
etwlogs
fluentd
gcplogs
gelf
journald
json-file
logentries
none
splunk
syslog
" -- "$cur" ) )
}
__docker_complete_log_options() {
# see repository docker/docker.github.io/engine/admin/logging/
local common_options="max-buffer-size mode"
local awslogs_options="$common_options awslogs-region awslogs-group awslogs-stream awslogs-create-group"
local fluentd_options="$common_options env fluentd-address fluentd-async-connect fluentd-buffer-limit fluentd-retry-wait fluentd-max-retries labels tag"
local gcplogs_options="$common_options env gcp-log-cmd gcp-project labels"
local gelf_options="$common_options env gelf-address gelf-compression-level gelf-compression-type labels tag"
local journald_options="$common_options env labels tag"
local json_file_options="$common_options env labels max-file max-size"
local logentries_options="$common_options logentries-token"
local syslog_options="$common_options env labels syslog-address syslog-facility syslog-format syslog-tls-ca-cert syslog-tls-cert syslog-tls-key syslog-tls-skip-verify tag"
local splunk_options="$common_options env labels splunk-caname splunk-capath splunk-format splunk-gzip splunk-gzip-level splunk-index splunk-insecureskipverify splunk-source splunk-sourcetype splunk-token splunk-url splunk-verify-connection tag"
local all_options="$fluentd_options $gcplogs_options $gelf_options $journald_options $logentries_options $json_file_options $syslog_options $splunk_options"
case $(__docker_value_of_option --log-driver) in
'')
COMPREPLY=( $( compgen -W "$all_options" -S = -- "$cur" ) )
;;
awslogs)
COMPREPLY=( $( compgen -W "$awslogs_options" -S = -- "$cur" ) )
;;
fluentd)
COMPREPLY=( $( compgen -W "$fluentd_options" -S = -- "$cur" ) )
;;
gcplogs)
COMPREPLY=( $( compgen -W "$gcplogs_options" -S = -- "$cur" ) )
;;
gelf)
COMPREPLY=( $( compgen -W "$gelf_options" -S = -- "$cur" ) )
;;
journald)
COMPREPLY=( $( compgen -W "$journald_options" -S = -- "$cur" ) )
;;
json-file)
COMPREPLY=( $( compgen -W "$json_file_options" -S = -- "$cur" ) )
;;
logentries)
COMPREPLY=( $( compgen -W "$logentries_options" -S = -- "$cur" ) )
;;
syslog)
COMPREPLY=( $( compgen -W "$syslog_options" -S = -- "$cur" ) )
;;
splunk)
COMPREPLY=( $( compgen -W "$splunk_options" -S = -- "$cur" ) )
;;
*)
return
;;
esac
__docker_nospace
}
__docker_complete_log_driver_options() {
local key=$(__docker_map_key_of_current_option '--log-opt')
case "$key" in
fluentd-async-connect)
COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
return
;;
gelf-address)
COMPREPLY=( $( compgen -W "udp" -S "://" -- "${cur##*=}" ) )
__docker_nospace
return
;;
gelf-compression-level)
COMPREPLY=( $( compgen -W "1 2 3 4 5 6 7 8 9" -- "${cur##*=}" ) )
return
;;
gelf-compression-type)
COMPREPLY=( $( compgen -W "gzip none zlib" -- "${cur##*=}" ) )
return
;;
mode)
COMPREPLY=( $( compgen -W "blocking non-blocking" -- "${cur##*=}" ) )
return
;;
syslog-address)
COMPREPLY=( $( compgen -W "tcp:// tcp+tls:// udp:// unix://" -- "${cur##*=}" ) )
__docker_nospace
__ltrim_colon_completions "${cur}"
return
;;
syslog-facility)
COMPREPLY=( $( compgen -W "
auth
authpriv
cron
daemon
ftp
kern
local0
local1
local2
local3
local4
local5
local6
local7
lpr
mail
news
syslog
user
uucp
" -- "${cur##*=}" ) )
return
;;
syslog-format)
COMPREPLY=( $( compgen -W "rfc3164 rfc5424 rfc5424micro" -- "${cur##*=}" ) )
return
;;
syslog-tls-ca-cert|syslog-tls-cert|syslog-tls-key)
_filedir
return
;;
syslog-tls-skip-verify)
COMPREPLY=( $( compgen -W "true" -- "${cur##*=}" ) )
return
;;
splunk-url)
COMPREPLY=( $( compgen -W "http:// https://" -- "${cur##*=}" ) )
__docker_nospace
__ltrim_colon_completions "${cur}"
return
;;
splunk-gzip|splunk-insecureskipverify|splunk-verify-connection)
COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
return
;;
splunk-format)
COMPREPLY=( $( compgen -W "inline json raw" -- "${cur##*=}" ) )
return
;;
esac
return 1
}
__docker_complete_log_levels() {
COMPREPLY=( $( compgen -W "debug info warn error fatal" -- "$cur" ) )
}
__docker_complete_restart() {
case "$prev" in
--restart)
case "$cur" in
on-failure:*)
;;
*)
COMPREPLY=( $( compgen -W "always no on-failure on-failure: unless-stopped" -- "$cur") )
;;
esac
return
;;
esac
return 1
}
# __docker_complete_signals returns a subset of the available signals that is most likely
# relevant in the context of docker containers
__docker_complete_signals() {
local signals=(
SIGCONT
SIGHUP
SIGINT
SIGKILL
SIGQUIT
SIGSTOP
SIGTERM
SIGUSR1
SIGUSR2
)
COMPREPLY=( $( compgen -W "${signals[*]} ${signals[*]#SIG}" -- "$( echo $cur | tr '[:lower:]' '[:upper:]')" ) )
}
__docker_complete_user_group() {
if [[ $cur == *:* ]] ; then
COMPREPLY=( $(compgen -g -- "${cur#*:}") )
else
COMPREPLY=( $(compgen -u -S : -- "$cur") )
__docker_nospace
fi
}
_docker_docker() {
# global options that may appear after the docker command
local boolean_options="
$global_boolean_options
--help
--version -v
"
case "$prev" in
--config)
_filedir -d
return
;;
--log-level|-l)
__docker_complete_log_levels
return
;;
$(__docker_to_extglob "$global_options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$boolean_options $global_options_with_args" -- "$cur" ) )
;;
*)
local counter=$( __docker_pos_first_nonflag "$(__docker_to_extglob "$global_options_with_args")" )
if [ $cword -eq $counter ]; then
__docker_daemon_is_experimental && commands+=(${experimental_commands[*]})
COMPREPLY=( $( compgen -W "${commands[*]} help" -- "$cur" ) )
fi
;;
esac
}
_docker_attach() {
_docker_container_attach
}
_docker_build() {
_docker_image_build
}
_docker_checkpoint() {
local subcommands="
create
ls
rm
"
local aliases="
list
remove
"
__docker_subcommands "$subcommands $aliases" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_checkpoint_create() {
case "$prev" in
--checkpoint-dir)
_filedir -d
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--checkpoint-dir --help --leave-running" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--checkpoint-dir')
if [ $cword -eq $counter ]; then
__docker_complete_containers_running
fi
;;
esac
}
_docker_checkpoint_ls() {
case "$prev" in
--checkpoint-dir)
_filedir -d
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--checkpoint-dir --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--checkpoint-dir')
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_checkpoint_rm() {
case "$prev" in
--checkpoint-dir)
_filedir -d
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--checkpoint-dir --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--checkpoint-dir')
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
elif [ $cword -eq $(($counter + 1)) ]; then
COMPREPLY=( $( compgen -W "$(__docker_q checkpoint ls "$prev" | sed 1d)" -- "$cur" ) )
fi
;;
esac
}
_docker_container() {
local subcommands="
attach
commit
cp
create
diff
exec
export
inspect
kill
logs
ls
pause
port
prune
rename
restart
rm
run
start
stats
stop
top
unpause
update
wait
"
local aliases="
list
ps
"
__docker_subcommands "$subcommands $aliases" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_container_attach() {
__docker_complete_detach-keys && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--detach-keys --help --no-stdin --sig-proxy=false" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--detach-keys')
if [ $cword -eq $counter ]; then
__docker_complete_containers_running
fi
;;
esac
}
_docker_container_commit() {
case "$prev" in
--author|-a|--change|-c|--message|-m)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--author -a --change -c --help --message -m --pause=false -p=false" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--author|-a|--change|-c|--message|-m')
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
return
fi
(( counter++ ))
if [ $cword -eq $counter ]; then
__docker_complete_image_repos_and_tags
return
fi
;;
esac
}
_docker_container_cp() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--follow-link -L --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
case "$cur" in
*:)
return
;;
*)
# combined container and filename completion
_filedir
local files=( ${COMPREPLY[@]} )
__docker_complete_containers_all
COMPREPLY=( $( compgen -W "${COMPREPLY[*]}" -S ':' ) )
local containers=( ${COMPREPLY[@]} )
COMPREPLY=( $( compgen -W "${files[*]} ${containers[*]}" -- "$cur" ) )
if [[ "$COMPREPLY" == *: ]]; then
__docker_nospace
fi
return
;;
esac
fi
(( counter++ ))
if [ $cword -eq $counter ]; then
if [ -e "$prev" ]; then
__docker_complete_containers_all
COMPREPLY=( $( compgen -W "${COMPREPLY[*]}" -S ':' ) )
__docker_nospace
else
_filedir
fi
return
fi
;;
esac
}
_docker_container_create() {
_docker_container_run_and_create
}
_docker_container_diff() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_container_exec() {
__docker_complete_detach-keys && return
case "$prev" in
--env|-e)
# we do not append a "=" here because "-e VARNAME" is legal systax, too
COMPREPLY=( $( compgen -e -- "$cur" ) )
__docker_nospace
return
;;
--user|-u)
__docker_complete_user_group
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--detach -d --detach-keys --env -e --help --interactive -i --privileged -t --tty -u --user" -- "$cur" ) )
;;
*)
__docker_complete_containers_running
;;
esac
}
_docker_container_export() {
case "$prev" in
--output|-o)
_filedir
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --output -o" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_container_inspect() {
_docker_inspect --type container
}
_docker_container_kill() {
case "$prev" in
--signal|-s)
__docker_complete_signals
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --signal -s" -- "$cur" ) )
;;
*)
__docker_complete_containers_running
;;
esac
}
_docker_container_logs() {
case "$prev" in
--since|--tail)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--details --follow -f --help --since --tail --timestamps -t" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--since|--tail')
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_container_list() {
_docker_container_ls
}
_docker_container_ls() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
ancestor)
cur="${cur##*=}"
__docker_complete_images
return
;;
before)
__docker_complete_containers_all --cur "${cur##*=}"
return
;;
expose|publish)
return
;;
id)
__docker_complete_containers_all --cur "${cur##*=}" --id
return
;;
health)
COMPREPLY=( $( compgen -W "healthy starting none unhealthy" -- "${cur##*=}" ) )
return
;;
is-task)
COMPREPLY=( $( compgen -W "true false" -- "${cur##*=}" ) )
return
;;
name)
__docker_complete_containers_all --cur "${cur##*=}" --name
return
;;
network)
__docker_complete_networks --cur "${cur##*=}"
return
;;
since)
__docker_complete_containers_all --cur "${cur##*=}"
return
;;
status)
COMPREPLY=( $( compgen -W "created dead exited paused restarting running removing" -- "${cur##*=}" ) )
return
;;
volume)
__docker_complete_volumes --cur "${cur##*=}"
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -S = -W "ancestor before exited expose health id is-task label name network publish since status volume" -- "$cur" ) )
__docker_nospace
return
;;
--format|--last|-n)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--all -a --filter -f --format --help --last -n --latest -l --no-trunc --quiet -q --size -s" -- "$cur" ) )
;;
esac
}
_docker_container_pause() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_containers_running
;;
esac
}
_docker_container_port() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_container_prune() {
case "$prev" in
--filter)
COMPREPLY=( $( compgen -W "until" -S = -- "$cur" ) )
__docker_nospace
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --filter --help" -- "$cur" ) )
;;
esac
}
_docker_container_ps() {
_docker_container_ls
}
_docker_container_rename() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_container_restart() {
case "$prev" in
--time|-t)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --time -t" -- "$cur" ) )
;;
*)
__docker_complete_containers_all
;;
esac
}
_docker_container_rm() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --help --link -l --volumes -v" -- "$cur" ) )
;;
*)
for arg in "${COMP_WORDS[@]}"; do
case "$arg" in
--force|-f)
__docker_complete_containers_all
return
;;
esac
done
__docker_complete_containers_stopped
;;
esac
}
_docker_container_run() {
_docker_container_run_and_create
}
# _docker_container_run_and_create is the combined completion for `_docker_container_run`
# and `_docker_container_create`
_docker_container_run_and_create() {
local options_with_args="
--add-host
--attach -a
--blkio-weight
--blkio-weight-device
--cap-add
--cap-drop
--cgroup-parent
--cidfile
--cpu-period
--cpu-quota
--cpu-rt-period
--cpu-rt-runtime
--cpuset-cpus
--cpus
--cpuset-mems
--cpu-shares -c
--device
--device-cgroup-rule
--device-read-bps
--device-read-iops
--device-write-bps
--device-write-iops
--dns
--dns-option
--dns-search
--entrypoint
--env -e
--env-file
--expose
--group-add
--hostname -h
--init-path
--ip
--ip6
--ipc
--kernel-memory
--label-file
--label -l
--link
--link-local-ip
--log-driver
--log-opt
--mac-address
--memory -m
--memory-swap
--memory-swappiness
--memory-reservation
--name
--network
--network-alias
--oom-score-adj
--pid
--pids-limit
--publish -p
--restart
--runtime
--security-opt
--shm-size
--stop-signal
--stop-timeout
--storage-opt
--tmpfs
--sysctl
--ulimit
--user -u
--userns
--uts
--volume-driver
--volumes-from
--volume -v
--workdir -w
"
__docker_daemon_os_is windows && options_with_args+="
--cpu-count
--cpu-percent
--credentialspec
--io-maxbandwidth
--io-maxiops
--isolation
"
local boolean_options="
--disable-content-trust=false
--help
--init
--interactive -i
--oom-kill-disable
--privileged
--publish-all -P
--read-only
--tty -t
"
if [ "$command" = "run" -o "$subcommand" = "run" ] ; then
options_with_args="$options_with_args
--detach-keys
--health-cmd
--health-interval
--health-retries
--health-timeout
"
boolean_options="$boolean_options
--detach -d
--no-healthcheck
--rm
--sig-proxy=false
"
__docker_complete_detach-keys && return
fi
local all_options="$options_with_args $boolean_options"
__docker_complete_log_driver_options && return
__docker_complete_restart && return
local key=$(__docker_map_key_of_current_option '--security-opt')
case "$key" in
label)
[[ $cur == *: ]] && return
COMPREPLY=( $( compgen -W "user: role: type: level: disable" -- "${cur##*=}") )
if [ "${COMPREPLY[*]}" != "disable" ] ; then
__docker_nospace
fi
return
;;
seccomp)
local cur=${cur##*=}
_filedir
COMPREPLY+=( $( compgen -W "unconfined" -- "$cur" ) )
return
;;
esac
case "$prev" in
--add-host)
case "$cur" in
*:)
__docker_complete_resolved_hostname
return
;;
esac
;;
--attach|-a)
COMPREPLY=( $( compgen -W 'stdin stdout stderr' -- "$cur" ) )
return
;;
--cap-add)
__docker_complete_capabilities_addable
return
;;
--cap-drop)
__docker_complete_capabilities_droppable
return
;;
--cidfile|--env-file|--init-path|--label-file)
_filedir
return
;;
--device|--tmpfs|--volume|-v)
case "$cur" in
*:*)
# TODO somehow do _filedir for stuff inside the image, if it's already specified (which is also somewhat difficult to determine)
;;
'')
COMPREPLY=( $( compgen -W '/' -- "$cur" ) )
__docker_nospace
;;
/*)
_filedir
__docker_nospace
;;
esac
return
;;
--env|-e)
# we do not append a "=" here because "-e VARNAME" is legal systax, too
COMPREPLY=( $( compgen -e -- "$cur" ) )
__docker_nospace
return
;;
--ipc)
case "$cur" in
*:*)
cur="${cur#*:}"
__docker_complete_containers_running
;;
*)
COMPREPLY=( $( compgen -W 'host container:' -- "$cur" ) )
if [ "$COMPREPLY" = "container:" ]; then
__docker_nospace
fi
;;
esac
return
;;
--isolation)
if __docker_daemon_os_is windows ; then
__docker_complete_isolation
return
fi
;;
--link)
case "$cur" in
*:*)
;;
*)
__docker_complete_containers_running
COMPREPLY=( $( compgen -W "${COMPREPLY[*]}" -S ':' ) )
__docker_nospace
;;
esac
return
;;
--log-driver)
__docker_complete_log_drivers
return
;;
--log-opt)
__docker_complete_log_options
return
;;
--network)
case "$cur" in
container:*)
__docker_complete_containers_all --cur "${cur#*:}"
;;
*)
COMPREPLY=( $( compgen -W "$(__docker_plugins_bundled --type Network) $(__docker_networks) container:" -- "$cur") )
if [ "${COMPREPLY[*]}" = "container:" ] ; then
__docker_nospace
fi
;;
esac
return
;;
--pid)
case "$cur" in
*:*)
__docker_complete_containers_running --cur "${cur#*:}"
;;
*)
COMPREPLY=( $( compgen -W 'host container:' -- "$cur" ) )
if [ "$COMPREPLY" = "container:" ]; then
__docker_nospace
fi
;;
esac
return
;;
--runtime)
__docker_complete_runtimes
return
;;
--security-opt)
COMPREPLY=( $( compgen -W "apparmor= label= no-new-privileges seccomp=" -- "$cur") )
if [ "${COMPREPLY[*]}" != "no-new-privileges" ] ; then
__docker_nospace
fi
return
;;
--storage-opt)
COMPREPLY=( $( compgen -W "size" -S = -- "$cur") )
__docker_nospace
return
;;
--user|-u)
__docker_complete_user_group
return
;;
--userns)
COMPREPLY=( $( compgen -W "host" -- "$cur" ) )
return
;;
--volume-driver)
__docker_complete_plugins_bundled --type Volume
return
;;
--volumes-from)
__docker_complete_containers_all
return
;;
$(__docker_to_extglob "$options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$all_options" -- "$cur" ) )
;;
*)
local counter=$( __docker_pos_first_nonflag $( __docker_to_alternatives "$options_with_args" ) )
if [ $cword -eq $counter ]; then
__docker_complete_images
fi
;;
esac
}
_docker_container_start() {
__docker_complete_detach-keys && return
case "$prev" in
--checkpoint)
if [ __docker_daemon_is_experimental ] ; then
return
fi
;;
--checkpoint-dir)
if [ __docker_daemon_is_experimental ] ; then
_filedir -d
return
fi
;;
esac
case "$cur" in
-*)
local options="--attach -a --detach-keys --help --interactive -i"
__docker_daemon_is_experimental && options+=" --checkpoint --checkpoint-dir"
COMPREPLY=( $( compgen -W "$options" -- "$cur" ) )
;;
*)
__docker_complete_containers_stopped
;;
esac
}
_docker_container_stats() {
case "$prev" in
--format)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--all -a --format --help --no-stream" -- "$cur" ) )
;;
*)
__docker_complete_containers_running
;;
esac
}
_docker_container_stop() {
case "$prev" in
--time|-t)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --time -t" -- "$cur" ) )
;;
*)
__docker_complete_containers_running
;;
esac
}
_docker_container_top() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_containers_running
fi
;;
esac
}
_docker_container_unpause() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_containers_unpauseable
fi
;;
esac
}
_docker_container_update() {
local options_with_args="
--blkio-weight
--cpu-period
--cpu-quota
--cpu-rt-period
--cpu-rt-runtime
--cpuset-cpus
--cpuset-mems
--cpu-shares -c
--kernel-memory
--memory -m
--memory-reservation
--memory-swap
--restart
"
local boolean_options="
--help
"
local all_options="$options_with_args $boolean_options"
__docker_complete_restart && return
case "$prev" in
$(__docker_to_extglob "$options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$all_options" -- "$cur" ) )
;;
*)
__docker_complete_containers_all
;;
esac
}
_docker_container_wait() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_containers_all
;;
esac
}
_docker_commit() {
_docker_container_commit
}
_docker_cp() {
_docker_container_cp
}
_docker_create() {
_docker_container_create
}
_docker_daemon() {
local boolean_options="
$global_boolean_options
--disable-legacy-registry
--experimental
--help
--icc=false
--init
--ip-forward=false
--ip-masq=false
--iptables=false
--ipv6
--live-restore
--raw-logs
--selinux-enabled
--userland-proxy=false
"
local options_with_args="
$global_options_with_args
--add-runtime
--api-cors-header
--authorization-plugin
--bip
--bridge -b
--cgroup-parent
--cluster-advertise
--cluster-store
--cluster-store-opt
--config-file
--containerd
--default-gateway
--default-gateway-v6
--default-shm-size
--default-ulimit
--dns
--dns-search
--dns-opt
--exec-opt
--exec-root
--fixed-cidr
--fixed-cidr-v6
--graph -g
--group -G
--init-path
--insecure-registry
--ip
--label
--log-driver
--log-opt
--max-concurrent-downloads
--max-concurrent-uploads
--mtu
--oom-score-adjust
--pidfile -p
--registry-mirror
--seccomp-profile
--shutdown-timeout
--storage-driver -s
--storage-opt
--userland-proxy-path
--userns-remap
"
__docker_complete_log_driver_options && return
key=$(__docker_map_key_of_current_option '--cluster-store-opt')
case "$key" in
kv.*file)
cur=${cur##*=}
_filedir
return
;;
esac
local key=$(__docker_map_key_of_current_option '--storage-opt')
case "$key" in
dm.blkdiscard|dm.override_udev_sync_check|dm.use_deferred_removal|dm.use_deferred_deletion)
COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
return
;;
dm.fs)
COMPREPLY=( $( compgen -W "ext4 xfs" -- "${cur##*=}" ) )
return
;;
dm.thinpooldev)
cur=${cur##*=}
_filedir
return
;;
esac
case "$prev" in
--authorization-plugin)
__docker_complete_plugins_bundled --type Authorization
return
;;
--cluster-store)
COMPREPLY=( $( compgen -W "consul etcd zk" -S "://" -- "$cur" ) )
__docker_nospace
return
;;
--cluster-store-opt)
COMPREPLY=( $( compgen -W "discovery.heartbeat discovery.ttl kv.cacertfile kv.certfile kv.keyfile kv.path" -S = -- "$cur" ) )
__docker_nospace
return
;;
--config-file|--containerd|--init-path|--pidfile|-p|--tlscacert|--tlscert|--tlskey|--userland-proxy-path)
_filedir
return
;;
--exec-root|--graph|-g)
_filedir -d
return
;;
--log-driver)
__docker_complete_log_drivers
return
;;
--storage-driver|-s)
COMPREPLY=( $( compgen -W "aufs btrfs devicemapper overlay overlay2 vfs zfs" -- "$(echo $cur | tr '[:upper:]' '[:lower:]')" ) )
return
;;
--storage-opt)
local btrfs_options="btrfs.min_space"
local devicemapper_options="
dm.basesize
dm.blkdiscard
dm.blocksize
dm.fs
dm.loopdatasize
dm.loopmetadatasize
dm.min_free_space
dm.mkfsarg
dm.mountopt
dm.override_udev_sync_check
dm.thinpooldev
dm.use_deferred_deletion
dm.use_deferred_removal
"
local zfs_options="zfs.fsname"
case $(__docker_value_of_option '--storage-driver|-s') in
'')
COMPREPLY=( $( compgen -W "$btrfs_options $devicemapper_options $zfs_options" -S = -- "$cur" ) )
;;
btrfs)
COMPREPLY=( $( compgen -W "$btrfs_options" -S = -- "$cur" ) )
;;
devicemapper)
COMPREPLY=( $( compgen -W "$devicemapper_options" -S = -- "$cur" ) )
;;
zfs)
COMPREPLY=( $( compgen -W "$zfs_options" -S = -- "$cur" ) )
;;
*)
return
;;
esac
__docker_nospace
return
;;
--log-level|-l)
__docker_complete_log_levels
return
;;
--log-opt)
__docker_complete_log_options
return
;;
--seccomp-profile)
_filedir json
return
;;
--userns-remap)
__docker_complete_user_group
return
;;
$(__docker_to_extglob "$options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
;;
esac
}
_docker_deploy() {
__docker_daemon_is_experimental && _docker_stack_deploy
}
_docker_diff() {
_docker_container_diff
}
_docker_events() {
_docker_system_events
}
_docker_exec() {
_docker_container_exec
}
_docker_export() {
_docker_container_export
}
_docker_help() {
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
COMPREPLY=( $( compgen -W "${commands[*]}" -- "$cur" ) )
fi
}
_docker_history() {
_docker_image_history
}
_docker_image() {
local subcommands="
build
history
import
inspect
load
ls
prune
pull
push
rm
save
tag
"
local aliases="
images
list
remove
rmi
"
__docker_subcommands "$subcommands $aliases" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_image_build() {
local options_with_args="
--build-arg
--cache-from
--cgroup-parent
--cpuset-cpus
--cpuset-mems
--cpu-shares -c
--cpu-period
--cpu-quota
--file -f
--label
--memory -m
--memory-swap
--network
--shm-size
--tag -t
--ulimit
"
__docker_daemon_os_is windows && options_with_args+="
--isolation
"
local boolean_options="
--compress
--disable-content-trust=false
--force-rm
--help
--no-cache
--pull
--quiet -q
--rm
"
__docker_daemon_is_experimental && boolean_options+="--squash"
local all_options="$options_with_args $boolean_options"
case "$prev" in
--build-arg)
COMPREPLY=( $( compgen -e -- "$cur" ) )
__docker_nospace
return
;;
--cache-from)
__docker_complete_image_repos_and_tags
return
;;
--file|-f)
_filedir
return
;;
--isolation)
if __docker_daemon_os_is windows ; then
__docker_complete_isolation
return
fi
;;
--network)
case "$cur" in
container:*)
__docker_complete_containers_all --cur "${cur#*:}"
;;
*)
COMPREPLY=( $( compgen -W "$(__docker_plugins --type Network) $(__docker_networks) container:" -- "$cur") )
if [ "${COMPREPLY[*]}" = "container:" ] ; then
__docker_nospace
fi
;;
esac
return
;;
--tag|-t)
__docker_complete_image_repos_and_tags
return
;;
$(__docker_to_extglob "$options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$all_options" -- "$cur" ) )
;;
*)
local counter=$( __docker_pos_first_nonflag $( __docker_to_alternatives "$options_with_args" ) )
if [ $cword -eq $counter ]; then
_filedir -d
fi
;;
esac
}
_docker_image_history() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --human=false -H=false --no-trunc --quiet -q" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_images
fi
;;
esac
}
_docker_image_images() {
_docker_image_ls
}
_docker_image_import() {
case "$prev" in
--change|-c|--message|-m)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--change -c --help --message -m" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--change|-c|--message|-m')
if [ $cword -eq $counter ]; then
return
fi
(( counter++ ))
if [ $cword -eq $counter ]; then
__docker_complete_image_repos_and_tags
return
fi
;;
esac
}
_docker_image_inspect() {
_docker_inspect --type image
}
_docker_image_load() {
case "$prev" in
--input|-i)
_filedir
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --input -i --quiet -q" -- "$cur" ) )
;;
esac
}
_docker_image_list() {
_docker_image_ls
}
_docker_image_ls() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
before|since|reference)
cur="${cur##*=}"
__docker_complete_images
return
;;
dangling)
COMPREPLY=( $( compgen -W "false true" -- "${cur##*=}" ) )
return
;;
label)
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -S = -W "before dangling label reference since" -- "$cur" ) )
__docker_nospace
return
;;
--format)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--all -a --digests --filter -f --format --help --no-trunc --quiet -q" -- "$cur" ) )
;;
=)
return
;;
*)
__docker_complete_image_repos
;;
esac
}
_docker_image_prune() {
case "$prev" in
--filter)
COMPREPLY=( $( compgen -W "until" -S = -- "$cur" ) )
__docker_nospace
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--all -a --force -f --filter --help" -- "$cur" ) )
;;
esac
}
_docker_image_pull() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--all-tags -a --disable-content-trust=false --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
for arg in "${COMP_WORDS[@]}"; do
case "$arg" in
--all-tags|-a)
__docker_complete_image_repos
return
;;
esac
done
__docker_complete_image_repos_and_tags
fi
;;
esac
}
_docker_image_push() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--disable-content-trust=false --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_image_repos_and_tags
fi
;;
esac
}
_docker_image_remove() {
_docker_image_rm
}
_docker_image_rm() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --help --no-prune" -- "$cur" ) )
;;
*)
__docker_complete_images
;;
esac
}
_docker_image_rmi() {
_docker_image_rm
}
_docker_image_save() {
case "$prev" in
--output|-o)
_filedir
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --output -o" -- "$cur" ) )
;;
*)
__docker_complete_images
;;
esac
}
_docker_image_tag() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_image_repos_and_tags
return
fi
(( counter++ ))
if [ $cword -eq $counter ]; then
__docker_complete_image_repos_and_tags
return
fi
;;
esac
}
_docker_images() {
_docker_image_ls
}
_docker_import() {
_docker_image_import
}
_docker_info() {
_docker_system_info
}
_docker_inspect() {
local preselected_type
local type
if [ "$1" = "--type" ] ; then
preselected_type=yes
type="$2"
else
type=$(__docker_value_of_option --type)
fi
case "$prev" in
--format|-f)
return
;;
--type)
if [ -z "$preselected_type" ] ; then
COMPREPLY=( $( compgen -W "container image network node plugin service volume" -- "$cur" ) )
return
fi
;;
esac
case "$cur" in
-*)
local options="--format -f --help --size -s"
if [ -z "$preselected_type" ] ; then
options+=" --type"
fi
COMPREPLY=( $( compgen -W "$options" -- "$cur" ) )
;;
*)
case "$type" in
'')
COMPREPLY=( $( compgen -W "
$(__docker_containers --all)
$(__docker_images)
$(__docker_networks)
$(__docker_nodes)
$(__docker_plugins_installed)
$(__docker_services)
$(__docker_volumes)
" -- "$cur" ) )
;;
container)
__docker_complete_containers_all
;;
image)
__docker_complete_images
;;
network)
__docker_complete_networks
;;
node)
__docker_complete_nodes
;;
plugin)
__docker_complete_plugins_installed
;;
service)
__docker_complete_services
;;
volume)
__docker_complete_volumes
;;
esac
esac
}
_docker_kill() {
_docker_container_kill
}
_docker_load() {
_docker_image_load
}
_docker_login() {
case "$prev" in
--password|-p|--username|-u)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --password -p --username -u" -- "$cur" ) )
;;
esac
}
_docker_logout() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
esac
}
_docker_logs() {
_docker_container_logs
}
_docker_network_connect() {
local options_with_args="
--alias
--ip
--ip6
--link
--link-local-ip
"
local boolean_options="
--help
"
case "$prev" in
--link)
case "$cur" in
*:*)
;;
*)
__docker_complete_containers_running
COMPREPLY=( $( compgen -W "${COMPREPLY[*]}" -S ':' ) )
__docker_nospace
;;
esac
return
;;
$(__docker_to_extglob "$options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
;;
*)
local counter=$( __docker_pos_first_nonflag $( __docker_to_alternatives "$options_with_args" ) )
if [ $cword -eq $counter ]; then
__docker_complete_networks
elif [ $cword -eq $(($counter + 1)) ]; then
__docker_complete_containers_all
fi
;;
esac
}
_docker_network_create() {
case "$prev" in
--aux-address|--gateway|--internal|--ip-range|--ipam-opt|--ipv6|--opt|-o|--subnet)
return
;;
--ipam-driver)
COMPREPLY=( $( compgen -W "default" -- "$cur" ) )
return
;;
--driver|-d)
# remove drivers that allow one instance only, add drivers missing in `docker info`
__docker_complete_plugins_bundled --type Network --remove host --remove null --add macvlan
return
;;
--label)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--attachable --aux-address --driver -d --gateway --help --internal --ip-range --ipam-driver --ipam-opt --ipv6 --label --opt -o --subnet" -- "$cur" ) )
;;
esac
}
_docker_network_disconnect() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_networks
elif [ $cword -eq $(($counter + 1)) ]; then
__docker_complete_containers_in_network "$prev"
fi
;;
esac
}
_docker_network_inspect() {
case "$prev" in
--format|-f)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--format -f --help" -- "$cur" ) )
;;
*)
__docker_complete_networks
esac
}
_docker_network_ls() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
driver)
__docker_complete_plugins_bundled --cur "${cur##*=}" --type Network --add macvlan
return
;;
id)
__docker_complete_networks --cur "${cur##*=}" --id
return
;;
name)
__docker_complete_networks --cur "${cur##*=}" --name
return
;;
type)
COMPREPLY=( $( compgen -W "builtin custom" -- "${cur##*=}" ) )
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -S = -W "driver id label name type" -- "$cur" ) )
__docker_nospace
return
;;
--format)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--filter -f --format --help --no-trunc --quiet -q" -- "$cur" ) )
;;
esac
}
_docker_network_prune() {
case "$prev" in
--filter)
COMPREPLY=( $( compgen -W "until" -S = -- "$cur" ) )
__docker_nospace
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --filter --help" -- "$cur" ) )
;;
esac
}
_docker_network_rm() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_networks --filter type=custom
esac
}
_docker_network() {
local subcommands="
connect
create
disconnect
inspect
ls
prune
rm
"
__docker_subcommands "$subcommands" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_service() {
local subcommands="
create
inspect
ls list
rm remove
scale
ps
update
"
__docker_daemon_is_experimental && subcommands+="logs"
__docker_subcommands "$subcommands" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_service_create() {
_docker_service_update_and_create
}
_docker_service_inspect() {
case "$prev" in
--format|-f)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--format -f --help --pretty" -- "$cur" ) )
;;
*)
__docker_complete_services
esac
}
_docker_service_logs() {
case "$prev" in
--since|--tail)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--details --follow -f --help --no-resolve --since --tail --timestamps -t" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--since|--tail')
if [ $cword -eq $counter ]; then
__docker_complete_services
fi
;;
esac
}
_docker_service_list() {
_docker_service_ls
}
_docker_service_ls() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
id)
__docker_complete_services --cur "${cur##*=}" --id
return
;;
name)
__docker_complete_services --cur "${cur##*=}" --name
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -W "id label name" -S = -- "$cur" ) )
__docker_nospace
return
;;
--format)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--filter -f --format --help --quiet -q" -- "$cur" ) )
;;
esac
}
_docker_service_remove() {
_docker_service_rm
}
_docker_service_rm() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_services
esac
}
_docker_service_scale() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_services
__docker_append_to_completions "="
__docker_nospace
;;
esac
}
_docker_service_ps() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
desired-state)
COMPREPLY=( $( compgen -W "accepted running" -- "${cur##*=}" ) )
return
;;
name)
__docker_complete_services --cur "${cur##*=}" --name
return
;;
node)
__docker_complete_nodes_plus_self --cur "${cur##*=}"
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -W "desired-state id name node" -S = -- "$cur" ) )
__docker_nospace
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--filter -f --help --no-resolve --no-trunc --quiet -q" -- "$cur" ) )
;;
*)
__docker_complete_services
;;
esac
}
_docker_service_update() {
_docker_service_update_and_create
}
# _docker_service_update_and_create is the combined completion for `docker service create`
# and `docker service update`
_docker_service_update_and_create() {
local $subcommand="${words[$subcommand_pos]}"
local options_with_args="
--constraint
--endpoint-mode
--env -e
--force
--health-cmd
--health-interval
--health-retries
--health-timeout
--hostname
--label -l
--limit-cpu
--limit-memory
--log-driver
--log-opt
--mount
--network
--no-healthcheck
--replicas
--reserve-cpu
--reserve-memory
--restart-condition
--restart-delay
--restart-max-attempts
--restart-window
--rollback
--stop-grace-period
--update-delay
--update-failure-action
--update-max-failure-ratio
--update-monitor
--update-parallelism
--user -u
--workdir -w
"
local boolean_options="
--help
--read-only
--tty -t
--with-registry-auth
"
__docker_complete_log_driver_options && return
if [ "$subcommand" = "create" ] ; then
options_with_args="$options_with_args
--container-label
--dns
--dns-option
--dns-search
--env-file
--group
--host
--mode
--name
--publish -p
--secret
"
case "$prev" in
--env-file)
_filedir
return
;;
--group)
COMPREPLY=( $(compgen -g -- "$cur") )
return
;;
--host)
case "$cur" in
*:)
__docker_complete_resolved_hostname
return
;;
esac
;;
--mode)
COMPREPLY=( $( compgen -W "global replicated" -- "$cur" ) )
return
;;
--secret)
__docker_complete_secrets
return
;;
esac
fi
if [ "$subcommand" = "update" ] ; then
options_with_args="$options_with_args
--arg
--container-label-add
--container-label-rm
--dns-add
--dns-option-add
--dns-option-rm
--dns-rm
--dns-search-add
--dns-search-rm
--group-add
--group-rm
--host-add
--host-rm
--image
--publish-add
--publish-rm
--secret-add
--secret-rm
"
case "$prev" in
--group-add|--group-rm)
COMPREPLY=( $(compgen -g -- "$cur") )
return
;;
--host-add|--host-rm)
case "$cur" in
*:)
__docker_complete_resolved_hostname
return
;;
esac
;;
--image)
__docker_complete_image_repos_and_tags
return
;;
--secret-add|--secret-rm)
__docker_complete_secrets
return
;;
esac
fi
case "$prev" in
--endpoint-mode)
COMPREPLY=( $( compgen -W "dnsrr vip" -- "$cur" ) )
return
;;
--env|-e)
# we do not append a "=" here because "-e VARNAME" is legal systax, too
COMPREPLY=( $( compgen -e -- "$cur" ) )
__docker_nospace
return
;;
--log-driver)
__docker_complete_log_drivers
return
;;
--log-opt)
__docker_complete_log_options
return
;;
--network)
__docker_complete_networks
return
;;
--restart-condition)
COMPREPLY=( $( compgen -W "any none on-failure" -- "$cur" ) )
return
;;
--user|-u)
__docker_complete_user_group
return
;;
$(__docker_to_extglob "$options_with_args") )
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
;;
*)
local counter=$( __docker_pos_first_nonflag $( __docker_to_alternatives "$options_with_args" ) )
if [ "$subcommand" = "update" ] ; then
if [ $cword -eq $counter ]; then
__docker_complete_services
fi
else
if [ $cword -eq $counter ]; then
__docker_complete_images
fi
fi
;;
esac
}
_docker_swarm() {
local subcommands="
init
join
join-token
leave
unlock
unlock-key
update
"
__docker_subcommands "$subcommands" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_swarm_init() {
case "$prev" in
--advertise-addr)
if [[ $cur == *: ]] ; then
COMPREPLY=( $( compgen -W "2377" -- "${cur##*:}" ) )
else
__docker_complete_local_interfaces
__docker_nospace
fi
return
;;
--availability)
COMPREPLY=( $( compgen -W "active drain pause" -- "$cur" ) )
return
;;
--cert-expiry|--dispatcher-heartbeat|--external-ca|--max-snapshots|--snapshot-interval|--task-history-limit)
return
;;
--listen-addr)
if [[ $cur == *: ]] ; then
COMPREPLY=( $( compgen -W "2377" -- "${cur##*:}" ) )
else
__docker_complete_local_interfaces --add 0.0.0.0
__docker_nospace
fi
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--advertise-addr --autolock --availability --cert-expiry --dispatcher-heartbeat --external-ca --force-new-cluster --help --listen-addr --max-snapshots --snapshot-interval --task-history-limit" -- "$cur" ) )
;;
esac
}
_docker_swarm_join() {
case "$prev" in
--advertise-addr)
if [[ $cur == *: ]] ; then
COMPREPLY=( $( compgen -W "2377" -- "${cur##*:}" ) )
else
__docker_complete_local_interfaces
__docker_nospace
fi
return
;;
--listen-addr)
if [[ $cur == *: ]] ; then
COMPREPLY=( $( compgen -W "2377" -- "${cur##*:}" ) )
else
__docker_complete_local_interfaces --add 0.0.0.0
__docker_nospace
fi
return
;;
--availability)
COMPREPLY=( $( compgen -W "active drain pause" -- "$cur" ) )
return
;;
--token)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--advertise-addr --availability --help --listen-addr --token" -- "$cur" ) )
;;
*:)
COMPREPLY=( $( compgen -W "2377" -- "${cur##*:}" ) )
;;
esac
}
_docker_swarm_join-token() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --quiet -q --rotate" -- "$cur" ) )
;;
*)
local counter=$( __docker_pos_first_nonflag )
if [ $cword -eq $counter ]; then
COMPREPLY=( $( compgen -W "manager worker" -- "$cur" ) )
fi
;;
esac
}
_docker_swarm_leave() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --help" -- "$cur" ) )
;;
esac
}
_docker_swarm_unlock() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
esac
}
_docker_swarm_unlock-key() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --quiet -q --rotate" -- "$cur" ) )
;;
esac
}
_docker_swarm_update() {
case "$prev" in
--cert-expiry|--dispatcher-heartbeat|--external-ca|--max-snapshots|--snapshot-interval|--task-history-limit)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--autolock --cert-expiry --dispatcher-heartbeat --external-ca --help --max-snapshots --snapshot-interval --task-history-limit" -- "$cur" ) )
;;
esac
}
_docker_node() {
local subcommands="
demote
inspect
ls list
promote
rm remove
ps
update
"
__docker_subcommands "$subcommands" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_node_demote() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_nodes --filter role=manager
esac
}
_docker_node_inspect() {
case "$prev" in
--format|-f)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--format -f --help --pretty" -- "$cur" ) )
;;
*)
__docker_complete_nodes_plus_self
esac
}
_docker_node_list() {
_docker_node_ls
}
_docker_node_ls() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
id)
__docker_complete_nodes --cur "${cur##*=}" --id
return
;;
name)
__docker_complete_nodes --cur "${cur##*=}" --name
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -W "id label name" -S = -- "$cur" ) )
__docker_nospace
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--filter -f --help --quiet -q" -- "$cur" ) )
;;
esac
}
_docker_node_promote() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
__docker_complete_nodes --filter role=worker
esac
}
_docker_node_remove() {
_docker_node_rm
}
_docker_node_rm() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --help" -- "$cur" ) )
;;
*)
__docker_complete_nodes
esac
}
_docker_node_ps() {
local key=$(__docker_map_key_of_current_option '--filter|-f')
case "$key" in
desired-state)
COMPREPLY=( $( compgen -W "accepted running" -- "${cur##*=}" ) )
return
;;
name)
__docker_complete_services --cur "${cur##*=}" --name
return
;;
esac
case "$prev" in
--filter|-f)
COMPREPLY=( $( compgen -W "desired-state id label name" -S = -- "$cur" ) )
__docker_nospace
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--filter -f --help --no-resolve --no-trunc" -- "$cur" ) )
;;
*)
__docker_complete_nodes_plus_self
;;
esac
}
_docker_node_update() {
case "$prev" in
--availability)
COMPREPLY=( $( compgen -W "active drain pause" -- "$cur" ) )
return
;;
--role)
COMPREPLY=( $( compgen -W "manager worker" -- "$cur" ) )
return
;;
--label-add|--label-rm)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--availability --help --label-add --label-rm --role" -- "$cur" ) )
;;
*)
__docker_complete_nodes
esac
}
_docker_pause() {
_docker_container_pause
}
_docker_plugin() {
local subcommands="
create
disable
enable
inspect
install
ls
push
rm
set
upgrade
"
local aliases="
list
remove
"
__docker_subcommands "$subcommands $aliases" && return
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
;;
*)
COMPREPLY=( $( compgen -W "$subcommands" -- "$cur" ) )
;;
esac
}
_docker_plugin_create() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--compress --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
# reponame
return
elif [ $cword -eq $((counter + 1)) ]; then
_filedir -d
fi
;;
esac
}
_docker_plugin_disable() {
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--force -f --help" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag)
if [ $cword -eq $counter ]; then
__docker_complete_plugins_installed --filter enabled=true
fi
;;
esac
}
_docker_plugin_enable() {
case "$prev" in
--timeout)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--help --timeout" -- "$cur" ) )
;;
*)
local counter=$(__docker_pos_first_nonflag '--timeout')
if [ $cword -eq $counter ]; then
__docker_complete_plugins_installed --filter enabled=false
fi
;;
esac
}
_docker_plugin_inspect() {
case "$prev" in
--format|f)
return
;;
esac
case "$cur" in
-*)
COMPREPLY=( $( compgen -W "--format -f --help" -- "$cur