github.com/wulonghui/docker@v1.8.0-rc2/contrib/completion/bash/docker (about)

     1  #!/bin/bash
     2  #
     3  # bash completion file for core docker commands
     4  #
     5  # This script provides completion of:
     6  #  - commands and their options
     7  #  - container ids and names
     8  #  - image repos and tags
     9  #  - filepaths
    10  #
    11  # To enable the completions either:
    12  #  - place this file in /etc/bash_completion.d
    13  #  or
    14  #  - copy this file to e.g. ~/.docker-completion.sh and add the line
    15  #    below to your .bashrc after bash completion features are loaded
    16  #    . ~/.docker-completion.sh
    17  #
    18  # Note:
    19  # Currently, the completions will not work if the docker daemon is not
    20  # bound to the default communication port/socket
    21  # If the docker daemon is using a unix socket for communication your user
    22  # must have access to the socket for the completions to function correctly
    23  #
    24  # Note for developers:
    25  # Please arrange options sorted alphabetically by long name with the short
    26  # options immediately following their corresponding long form.
    27  # This order should be applied to lists, alternatives and code blocks.
    28  
    29  __docker_q() {
    30  	docker ${host:+-H "$host"} 2>/dev/null "$@"
    31  }
    32  
    33  __docker_containers_all() {
    34  	local IFS=$'\n'
    35  	local containers=( $(__docker_q ps -aq --no-trunc) )
    36  	if [ "$1" ]; then
    37  		containers=( $(__docker_q inspect --format "{{if $1}}{{.Id}}{{end}}" "${containers[@]}") )
    38  	fi
    39  	local names=( $(__docker_q inspect --format '{{.Name}}' "${containers[@]}") )
    40  	names=( "${names[@]#/}" ) # trim off the leading "/" from the container names
    41  	unset IFS
    42  	COMPREPLY=( $(compgen -W "${names[*]} ${containers[*]}" -- "$cur") )
    43  }
    44  
    45  __docker_containers_running() {
    46  	__docker_containers_all '.State.Running'
    47  }
    48  
    49  __docker_containers_stopped() {
    50  	__docker_containers_all 'not .State.Running'
    51  }
    52  
    53  __docker_containers_pauseable() {
    54  	__docker_containers_all 'and .State.Running (not .State.Paused)'
    55  }
    56  
    57  __docker_containers_unpauseable() {
    58  	__docker_containers_all '.State.Paused'
    59  }
    60  
    61  __docker_container_names() {
    62  	local containers=( $(__docker_q ps -aq --no-trunc) )
    63  	local names=( $(__docker_q inspect --format '{{.Name}}' "${containers[@]}") )
    64  	names=( "${names[@]#/}" ) # trim off the leading "/" from the container names
    65  	COMPREPLY=( $(compgen -W "${names[*]}" -- "$cur") )
    66  }
    67  
    68  __docker_container_ids() {
    69  	local containers=( $(__docker_q ps -aq) )
    70  	COMPREPLY=( $(compgen -W "${containers[*]}" -- "$cur") )
    71  }
    72  
    73  __docker_image_repos() {
    74  	local repos="$(__docker_q images | awk 'NR>1 && $1 != "<none>" { print $1 }')"
    75  	COMPREPLY=( $(compgen -W "$repos" -- "$cur") )
    76  }
    77  
    78  __docker_image_repos_and_tags() {
    79  	local reposAndTags="$(__docker_q images | awk 'NR>1 && $1 != "<none>" { print $1; print $1":"$2 }')"
    80  	COMPREPLY=( $(compgen -W "$reposAndTags" -- "$cur") )
    81  	__ltrim_colon_completions "$cur"
    82  }
    83  
    84  __docker_image_repos_and_tags_and_ids() {
    85  	local images="$(__docker_q images -a --no-trunc | awk 'NR>1 { print $3; if ($1 != "<none>") { print $1; print $1":"$2 } }')"
    86  	COMPREPLY=( $(compgen -W "$images" -- "$cur") )
    87  	__ltrim_colon_completions "$cur"
    88  }
    89  
    90  __docker_containers_and_images() {
    91  	__docker_containers_all
    92  	local containers=( "${COMPREPLY[@]}" )
    93  	__docker_image_repos_and_tags_and_ids
    94  	COMPREPLY+=( "${containers[@]}" )
    95  }
    96  
    97  # Finds the position of the first word that is neither option nor an option's argument.
    98  # If there are options that require arguments, you should pass a glob describing those
    99  # options, e.g. "--option1|-o|--option2"
   100  # Use this function to restrict completions to exact positions after the argument list.
   101  __docker_pos_first_nonflag() {
   102  	local argument_flags=$1
   103  
   104  	local counter=$((command_pos + 1))
   105  	while [ $counter -le $cword ]; do
   106  		if [ -n "$argument_flags" ] && eval "case '${words[$counter]}' in $argument_flags) true ;; *) false ;; esac"; then
   107  			(( counter++ ))
   108  			# eat "=" in case of --option=arg syntax
   109  			[ "${words[$counter]}" = "=" ] && (( counter++ ))
   110  		else
   111  			case "${words[$counter]}" in
   112  				-*)
   113  					;;
   114  				*)
   115  					break
   116  					;;
   117  			esac
   118  		fi
   119  
   120  		# Bash splits words at "=", retaining "=" as a word, examples:
   121  		# "--debug=false" => 3 words, "--log-opt syslog-facility=daemon" => 4 words
   122  		while [ "${words[$counter + 1]}" = "=" ] ; do
   123  			counter=$(( counter + 2))
   124  		done
   125  
   126  		(( counter++ ))
   127  	done
   128  
   129  	echo $counter
   130  }
   131  
   132  # Returns the value of the first option matching option_glob.
   133  # Valid values for option_glob are option names like '--log-level' and
   134  # globs like '--log-level|-l'
   135  # Only positions between the command and the current word are considered.
   136  __docker_value_of_option() {
   137  	local option_glob=$1
   138  
   139  	local counter=$((command_pos + 1))
   140  	while [ $counter -lt $cword ]; do
   141  		case ${words[$counter]} in
   142  			$option_glob )
   143  				echo ${words[$counter + 1]}
   144  				break
   145  				;;
   146  		esac
   147  		(( counter++ ))
   148  	done
   149  }
   150  
   151  # Transforms a multiline list of strings into a single line string
   152  # with the words separated by "|".
   153  # This is used to prepare arguments to __docker_pos_first_nonflag().
   154  __docker_to_alternatives() {
   155  	local parts=( $1 )
   156  	local IFS='|'
   157  	echo "${parts[*]}"
   158  }
   159  
   160  # Transforms a multiline list of options into an extglob pattern
   161  # suitable for use in case statements.
   162  __docker_to_extglob() {
   163  	local extglob=$( __docker_to_alternatives "$1" )
   164  	echo "@($extglob)"
   165  }
   166  
   167  __docker_resolve_hostname() {
   168  	command -v host >/dev/null 2>&1 || return
   169  	COMPREPLY=( $(host 2>/dev/null "${cur%:}" | awk '/has address/ {print $4}') )
   170  }
   171  
   172  __docker_capabilities() {
   173  	# The list of capabilities is defined in types.go, ALL was added manually.
   174  	COMPREPLY=( $( compgen -W "
   175  		ALL
   176  		AUDIT_CONTROL
   177  		AUDIT_WRITE
   178  		AUDIT_READ
   179  		BLOCK_SUSPEND
   180  		CHOWN
   181  		DAC_OVERRIDE
   182  		DAC_READ_SEARCH
   183  		FOWNER
   184  		FSETID
   185  		IPC_LOCK
   186  		IPC_OWNER
   187  		KILL
   188  		LEASE
   189  		LINUX_IMMUTABLE
   190  		MAC_ADMIN
   191  		MAC_OVERRIDE
   192  		MKNOD
   193  		NET_ADMIN
   194  		NET_BIND_SERVICE
   195  		NET_BROADCAST
   196  		NET_RAW
   197  		SETFCAP
   198  		SETGID
   199  		SETPCAP
   200  		SETUID
   201  		SYS_ADMIN
   202  		SYS_BOOT
   203  		SYS_CHROOT
   204  		SYSLOG
   205  		SYS_MODULE
   206  		SYS_NICE
   207  		SYS_PACCT
   208  		SYS_PTRACE
   209  		SYS_RAWIO
   210  		SYS_RESOURCE
   211  		SYS_TIME
   212  		SYS_TTY_CONFIG
   213  		WAKE_ALARM
   214  	" -- "$cur" ) )
   215  }
   216  
   217  __docker_log_drivers() {
   218  	COMPREPLY=( $( compgen -W "
   219  		fluentd
   220  		gelf
   221  		journald
   222  		json-file
   223  		none
   224  		syslog
   225  	" -- "$cur" ) )
   226  }
   227  
   228  __docker_log_driver_options() {
   229  	# see docs/reference/logging/index.md
   230  	local fluentd_options="fluentd-address fluentd-tag"
   231  	local gelf_options="gelf-address gelf-tag"
   232  	local syslog_options="syslog-address syslog-facility syslog-tag"
   233  
   234  	case $(__docker_value_of_option --log-driver) in
   235  		'')
   236  			COMPREPLY=( $( compgen -W "$fluentd_options $gelf_options $syslog_options" -S = -- "$cur" ) )
   237  			;;
   238  		fluentd)
   239  			COMPREPLY=( $( compgen -W "$fluentd_options" -S = -- "$cur" ) )
   240  			;;
   241  		gelf)
   242  			COMPREPLY=( $( compgen -W "$gelf_options" -S = -- "$cur" ) )
   243  			;;
   244  		syslog)
   245  			COMPREPLY=( $( compgen -W "$syslog_options" -S = -- "$cur" ) )
   246  			;;
   247  		*)
   248  			return
   249  			;;
   250  	esac
   251  
   252  	compopt -o nospace
   253  }
   254  
   255  __docker_complete_log_driver_options() {
   256  	# "=" gets parsed to a word and assigned to either $cur or $prev depending on whether
   257  	# it is the last character or not. So we search for "xxx=" in the the last two words.
   258  	case "${words[$cword-2]}$prev=" in
   259  		*gelf-address=*)
   260  			COMPREPLY=( $( compgen -W "udp" -S "://" -- "${cur#=}" ) )
   261  			compopt -o nospace
   262  			return
   263  			;;
   264  		*syslog-address=*)
   265  			COMPREPLY=( $( compgen -W "tcp udp unix" -S "://" -- "${cur#=}" ) )
   266  			compopt -o nospace
   267  			return
   268  			;;
   269  		*syslog-facility=*)
   270  			COMPREPLY=( $( compgen -W "
   271  				auth
   272  				authpriv
   273  				cron
   274  				daemon
   275  				ftp
   276  				kern
   277  				local0
   278  				local1
   279  				local2
   280  				local3
   281  				local4
   282  				local5
   283  				local6
   284  				local7
   285  				lpr
   286  				mail
   287  				news
   288  				syslog
   289  				user
   290  				uucp
   291  			" -- "${cur#=}" ) )
   292  			return
   293  			;;
   294  	esac
   295  	return 1
   296  }
   297  
   298  __docker_log_levels() {
   299  	COMPREPLY=( $( compgen -W "debug info warn error fatal" -- "$cur" ) )
   300  }
   301  
   302  # a selection of the available signals that is most likely of interest in the
   303  # context of docker containers.
   304  __docker_signals() {
   305  	local signals=(
   306  		SIGCONT
   307  		SIGHUP
   308  		SIGINT
   309  		SIGKILL
   310  		SIGQUIT
   311  		SIGSTOP
   312  		SIGTERM
   313  		SIGUSR1
   314  		SIGUSR2
   315  	)
   316  	COMPREPLY=( $( compgen -W "${signals[*]} ${signals[*]#SIG}" -- "$( echo $cur | tr '[:lower:]' '[:upper:]')" ) )
   317  }
   318  
   319  # global options that may appear after the docker command
   320  _docker_docker() {
   321  	local boolean_options="
   322  		$global_boolean_options
   323  		--help -h
   324  		--version -v
   325  	"
   326  
   327  	case "$prev" in
   328  		--log-level|-l)
   329  			__docker_log_levels
   330  			return
   331  			;;
   332  		$(__docker_to_extglob "$global_options_with_args") )
   333  			return
   334  			;;
   335  	esac
   336  
   337  	__docker_complete_log_driver_options && return
   338  
   339  	case "$cur" in
   340  		-*)
   341  			COMPREPLY=( $( compgen -W "$boolean_options $global_options_with_args" -- "$cur" ) )
   342  			;;
   343  		*)
   344  			local counter=$( __docker_pos_first_nonflag $(__docker_to_extglob "$global_options_with_args") )
   345  			if [ $cword -eq $counter ]; then
   346  				COMPREPLY=( $( compgen -W "${commands[*]} help" -- "$cur" ) )
   347  			fi
   348  			;;
   349  	esac
   350  }
   351  
   352  _docker_attach() {
   353  	case "$cur" in
   354  		-*)
   355  			COMPREPLY=( $( compgen -W "--help --no-stdin --sig-proxy" -- "$cur" ) )
   356  			;;
   357  		*)
   358  			local counter="$(__docker_pos_first_nonflag)"
   359  			if [ $cword -eq $counter ]; then
   360  				__docker_containers_running
   361  			fi
   362  			;;
   363  	esac
   364  }
   365  
   366  _docker_build() {
   367  	case "$prev" in
   368  		--cgroup-parent|--cpuset-cpus|--cpuset-mems|--cpu-shares|-c|--cpu-period|--cpu-quota|--memory|-m|--memory-swap)
   369  			return
   370  			;;
   371  		--file|-f)
   372  			_filedir
   373  			return
   374  			;;
   375  		--tag|-t)
   376  			__docker_image_repos_and_tags
   377  			return
   378  			;;
   379  	esac
   380  
   381  	case "$cur" in
   382  		-*)
   383  			COMPREPLY=( $( compgen -W "--cgroup-parent --cpuset-cpus --cpuset-mems --cpu-shares -c --cpu-period --cpu-quota --file -f --force-rm --help --memory -m --memory-swap --no-cache --pull --quiet -q --rm --tag -t --ulimit" -- "$cur" ) )
   384  			;;
   385  		*)
   386  			local counter="$(__docker_pos_first_nonflag '--cgroup-parent|--cpuset-cpus|--cpuset-mems|--cpu-shares|-c|--cpu-period|--cpu-quota|--file|-f|--memory|-m|--memory-swap|--tag|-t')"
   387  			if [ $cword -eq $counter ]; then
   388  				_filedir -d
   389  			fi
   390  			;;
   391  	esac
   392  }
   393  
   394  _docker_commit() {
   395  	case "$prev" in
   396  		--author|-a|--change|-c|--message|-m)
   397  			return
   398  			;;
   399  	esac
   400  
   401  	case "$cur" in
   402  		-*)
   403  			COMPREPLY=( $( compgen -W "--author -a --change -c --help --message -m --pause -p" -- "$cur" ) )
   404  			;;
   405  		*)
   406  			local counter=$(__docker_pos_first_nonflag '--author|-a|--change|-c|--message|-m')
   407  
   408  			if [ $cword -eq $counter ]; then
   409  				__docker_containers_all
   410  				return
   411  			fi
   412  			(( counter++ ))
   413  
   414  			if [ $cword -eq $counter ]; then
   415  				__docker_image_repos_and_tags
   416  				return
   417  			fi
   418  			;;
   419  	esac
   420  }
   421  
   422  _docker_cp() {
   423  	case "$cur" in
   424  		-*)
   425  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   426  			;;
   427  		*)
   428  			local counter=$(__docker_pos_first_nonflag)
   429  			if [ $cword -eq $counter ]; then
   430  				case "$cur" in
   431  					*:)
   432  						return
   433  						;;
   434  					*)
   435  						__docker_containers_all
   436  						COMPREPLY=( $( compgen -W "${COMPREPLY[*]}" -S ':' ) )
   437  						compopt -o nospace
   438  						return
   439  						;;
   440  				esac
   441  			fi
   442  			(( counter++ ))
   443  
   444  			if [ $cword -eq $counter ]; then
   445  				_filedir -d
   446  				return
   447  			fi
   448  			;;
   449  	esac
   450  }
   451  
   452  _docker_create() {
   453  	_docker_run
   454  }
   455  
   456  _docker_daemon() {
   457  	local boolean_options="
   458  		$global_boolean_options
   459  		--help -h
   460  		--icc=false
   461  		--ip-forward=false
   462  		--ip-masq=false
   463  		--iptables=false
   464  		--ipv6
   465  		--selinux-enabled
   466  		--userland-proxy=false
   467  	"
   468  	local options_with_args="
   469  		$global_options_with_args
   470  		--api-cors-header
   471  		--bip
   472  		--bridge -b
   473  		--default-gateway
   474  		--default-gateway-v6
   475  		--default-ulimit
   476  		--dns
   477  		--dns-search
   478  		--exec-driver -e
   479  		--exec-opt
   480  		--exec-root
   481  		--fixed-cidr
   482  		--fixed-cidr-v6
   483  		--graph -g
   484  		--group -G
   485  		--insecure-registry
   486  		--ip
   487  		--label
   488  		--log-driver
   489  		--log-opt
   490  		--mtu
   491  		--pidfile -p
   492  		--registry-mirror
   493  		--storage-driver -s
   494  		--storage-opt
   495  	"
   496  
   497  	case "$prev" in
   498  		--exec-root|--graph|-g)
   499  			_filedir -d
   500  			return
   501  			;;
   502  		--log-driver)
   503  			__docker_log_drivers
   504  			return
   505  			;;
   506  		--pidfile|-p|--tlscacert|--tlscert|--tlskey)
   507  			_filedir
   508  			return
   509  			;;
   510  		--storage-driver|-s)
   511  			COMPREPLY=( $( compgen -W "aufs devicemapper btrfs overlay" -- "$(echo $cur | tr '[:upper:]' '[:lower:]')" ) )
   512  			return
   513  			;;
   514  		--log-level|-l)
   515  			__docker_log_levels
   516  			return
   517  			;;
   518  		--log-opt)
   519  			__docker_log_driver_options
   520  			return
   521  			;;
   522  		$(__docker_to_extglob "$options_with_args") )
   523  			return
   524  			;;
   525  	esac
   526  
   527  	case "$cur" in
   528  		-*)
   529  			COMPREPLY=( $( compgen -W "$boolean_options $options_with_args" -- "$cur" ) )
   530  			;;
   531  	esac
   532  }
   533  
   534  _docker_diff() {
   535  	case "$cur" in
   536  		-*)
   537  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   538  			;;
   539  		*)
   540  			local counter=$(__docker_pos_first_nonflag)
   541  			if [ $cword -eq $counter ]; then
   542  				__docker_containers_all
   543  			fi
   544  			;;
   545  	esac
   546  }
   547  
   548  _docker_events() {
   549  	case "$prev" in
   550  		--filter|-f)
   551  			COMPREPLY=( $( compgen -S = -W "container event image" -- "$cur" ) )
   552  			compopt -o nospace
   553  			return
   554  			;;
   555  		--since|--until)
   556  			return
   557  			;;
   558  	esac
   559  
   560  	case "${words[$cword-2]}$prev=" in
   561  		*container=*)
   562  			cur="${cur#=}"
   563  			__docker_containers_all
   564  			return
   565  			;;
   566  		*event=*)
   567  			COMPREPLY=( $( compgen -W "
   568  				attach
   569  				commit
   570  				copy
   571  				create
   572  				delete
   573  				destroy
   574  				die
   575  				exec_create
   576  				exec_start
   577  				export
   578  				import
   579  				kill
   580  				oom
   581  				pause
   582  				pull
   583  				push
   584  				rename
   585  				resize
   586  				restart
   587  				start
   588  				stop
   589  				tag
   590  				top
   591  				unpause
   592  				untag
   593  			" -- "${cur#=}" ) )
   594  			return
   595  			;;
   596  		*image=*)
   597  			cur="${cur#=}"
   598  			__docker_image_repos_and_tags_and_ids
   599  			return
   600  			;;
   601  	esac
   602  
   603  	case "$cur" in
   604  		-*)
   605  			COMPREPLY=( $( compgen -W "--filter -f --help --since --until" -- "$cur" ) )
   606  			;;
   607  	esac
   608  }
   609  
   610  _docker_exec() {
   611  	case "$prev" in
   612  		--user|-u)
   613  			return
   614  			;;
   615  	esac
   616  
   617  	case "$cur" in
   618  		-*)
   619  			COMPREPLY=( $( compgen -W "--detach -d --help --interactive -i -t --tty -u --user" -- "$cur" ) )
   620  			;;
   621  		*)
   622  			__docker_containers_running
   623  			;;
   624  	esac
   625  }
   626  
   627  _docker_export() {
   628  	case "$cur" in
   629  		-*)
   630  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   631  			;;
   632  		*)
   633  			local counter=$(__docker_pos_first_nonflag)
   634  			if [ $cword -eq $counter ]; then
   635  				__docker_containers_all
   636  			fi
   637  			;;
   638  	esac
   639  }
   640  
   641  _docker_help() {
   642  	local counter=$(__docker_pos_first_nonflag)
   643  	if [ $cword -eq $counter ]; then
   644  		COMPREPLY=( $( compgen -W "${commands[*]}" -- "$cur" ) )
   645  	fi
   646  }
   647  
   648  _docker_history() {
   649  	case "$cur" in
   650  		-*)
   651  			COMPREPLY=( $( compgen -W "--help --no-trunc --quiet -q" -- "$cur" ) )
   652  			;;
   653  		*)
   654  			local counter=$(__docker_pos_first_nonflag)
   655  			if [ $cword -eq $counter ]; then
   656  				__docker_image_repos_and_tags_and_ids
   657  			fi
   658  			;;
   659  	esac
   660  }
   661  
   662  _docker_images() {
   663  	case "$prev" in
   664  		--filter|-f)
   665  			COMPREPLY=( $( compgen -W "dangling=true label=" -- "$cur" ) )
   666  			if [ "$COMPREPLY" = "label=" ]; then
   667  				compopt -o nospace
   668  			fi
   669  			return
   670  			;;
   671  	esac
   672  
   673  	case "${words[$cword-2]}$prev=" in
   674  		*dangling=*)
   675  			COMPREPLY=( $( compgen -W "true false" -- "${cur#=}" ) )
   676  			return
   677  			;;
   678  		*label=*)
   679  			return
   680  			;;
   681  	esac
   682  
   683  	case "$cur" in
   684  		-*)
   685  			COMPREPLY=( $( compgen -W "--all -a --digests --filter -f --help --no-trunc --quiet -q" -- "$cur" ) )
   686  			;;
   687  		=)
   688  			return
   689  			;;
   690  		*)
   691  			__docker_image_repos
   692  			;;
   693  	esac
   694  }
   695  
   696  _docker_import() {
   697  	case "$cur" in
   698  		-*)
   699  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   700  			;;
   701  		*)
   702  			local counter=$(__docker_pos_first_nonflag)
   703  			if [ $cword -eq $counter ]; then
   704  				return
   705  			fi
   706  			(( counter++ ))
   707  
   708  			if [ $cword -eq $counter ]; then
   709  				__docker_image_repos_and_tags
   710  				return
   711  			fi
   712  			;;
   713  	esac
   714  }
   715  
   716  _docker_info() {
   717  	case "$cur" in
   718  		-*)
   719  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   720  			;;
   721  	esac
   722  }
   723  
   724  _docker_inspect() {
   725  	case "$prev" in
   726  		--format|-f)
   727  			return
   728  			;;
   729  		--type)
   730                       COMPREPLY=( $( compgen -W "image container" -- "$cur" ) )
   731                       return
   732                          ;;
   733  
   734  	esac
   735  
   736  	case "$cur" in
   737  		-*)
   738  			COMPREPLY=( $( compgen -W "--format -f --type --help" -- "$cur" ) )
   739  			;;
   740  		*)
   741  			case $(__docker_value_of_option --type) in
   742  				'')
   743  					__docker_containers_and_images
   744  					;;
   745  				container)
   746  					__docker_containers_all
   747  					;;
   748  				image)
   749  					__docker_image_repos_and_tags_and_ids
   750  					;;
   751  			esac
   752  	esac
   753  }
   754  
   755  _docker_kill() {
   756  	case "$prev" in
   757  		--signal|-s)
   758  			__docker_signals
   759  			return
   760  			;;
   761  	esac
   762  
   763  	case "$cur" in
   764  		-*)
   765  			COMPREPLY=( $( compgen -W "--help --signal -s" -- "$cur" ) )
   766  			;;
   767  		*)
   768  			__docker_containers_running
   769  			;;
   770  	esac
   771  }
   772  
   773  _docker_load() {
   774  	case "$prev" in
   775  		--input|-i)
   776  			_filedir
   777  			return
   778  			;;
   779  	esac
   780  
   781  	case "$cur" in
   782  		-*)
   783  			COMPREPLY=( $( compgen -W "--help --input -i" -- "$cur" ) )
   784  			;;
   785  	esac
   786  }
   787  
   788  _docker_login() {
   789  	case "$prev" in
   790  		--email|-e|--password|-p|--username|-u)
   791  			return
   792  			;;
   793  	esac
   794  
   795  	case "$cur" in
   796  		-*)
   797  			COMPREPLY=( $( compgen -W "--email -e --help --password -p --username -u" -- "$cur" ) )
   798  			;;
   799  	esac
   800  }
   801  
   802  _docker_logout() {
   803  	case "$cur" in
   804  		-*)
   805  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   806  			;;
   807  	esac
   808  }
   809  
   810  _docker_logs() {
   811  	case "$prev" in
   812  		--since|--tail)
   813  			return
   814  			;;
   815  	esac
   816  
   817  	case "$cur" in
   818  		-*)
   819  			COMPREPLY=( $( compgen -W "--follow -f --help --since --tail --timestamps -t" -- "$cur" ) )
   820  			;;
   821  		*)
   822  			local counter=$(__docker_pos_first_nonflag '--tail')
   823  			if [ $cword -eq $counter ]; then
   824  				__docker_containers_all
   825  			fi
   826  			;;
   827  	esac
   828  }
   829  
   830  _docker_pause() {
   831  	case "$cur" in
   832  		-*)
   833  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   834  			;;
   835  		*)
   836  			local counter=$(__docker_pos_first_nonflag)
   837  			if [ $cword -eq $counter ]; then
   838  				__docker_containers_pauseable
   839  			fi
   840  			;;
   841  	esac
   842  }
   843  
   844  _docker_port() {
   845  	case "$cur" in
   846  		-*)
   847  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   848  			;;
   849  		*)
   850  			local counter=$(__docker_pos_first_nonflag)
   851  			if [ $cword -eq $counter ]; then
   852  				__docker_containers_all
   853  			fi
   854  			;;
   855  	esac
   856  }
   857  
   858  _docker_ps() {
   859  	case "$prev" in
   860  		--before|--since)
   861  			__docker_containers_all
   862  			;;
   863  		--filter|-f)
   864  			COMPREPLY=( $( compgen -S = -W "exited id label name status" -- "$cur" ) )
   865  			compopt -o nospace
   866  			return
   867  			;;
   868  		-n)
   869  			return
   870  			;;
   871  	esac
   872  
   873  	case "${words[$cword-2]}$prev=" in
   874  		*id=*)
   875  			cur="${cur#=}"
   876  			__docker_container_ids
   877  			return
   878  			;;
   879  		*name=*)
   880  			cur="${cur#=}"
   881  			__docker_container_names
   882  			return
   883  			;;
   884  		*status=*)
   885  			COMPREPLY=( $( compgen -W "exited paused restarting running" -- "${cur#=}" ) )
   886  			return
   887  			;;
   888  	esac
   889  
   890  	case "$cur" in
   891  		-*)
   892  			COMPREPLY=( $( compgen -W "--all -a --before --filter -f --help --latest -l -n --no-trunc --quiet -q --size -s --since" -- "$cur" ) )
   893  			;;
   894  	esac
   895  }
   896  
   897  _docker_pull() {
   898  	case "$cur" in
   899  		-*)
   900  			COMPREPLY=( $( compgen -W "--all-tags -a --help" -- "$cur" ) )
   901  			;;
   902  		*)
   903  			local counter=$(__docker_pos_first_nonflag)
   904  			if [ $cword -eq $counter ]; then
   905  				for arg in "${COMP_WORDS[@]}"; do
   906  					case "$arg" in
   907  						--all-tags|-a)
   908  							__docker_image_repos
   909  							return
   910  							;;
   911  					esac
   912  				done
   913  				__docker_image_repos_and_tags
   914  			fi
   915  			;;
   916  	esac
   917  }
   918  
   919  _docker_push() {
   920  	case "$cur" in
   921  		-*)
   922  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   923  			;;
   924  		*)
   925  			local counter=$(__docker_pos_first_nonflag)
   926  			if [ $cword -eq $counter ]; then
   927  				__docker_image_repos_and_tags
   928  			fi
   929  			;;
   930  	esac
   931  }
   932  
   933  _docker_rename() {
   934  	case "$cur" in
   935  		-*)
   936  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
   937  			;;
   938  		*)
   939  			local counter=$(__docker_pos_first_nonflag)
   940  			if [ $cword -eq $counter ]; then
   941  				__docker_containers_all
   942  			fi
   943  			;;
   944  	esac
   945  }
   946  
   947  _docker_restart() {
   948  	case "$prev" in
   949  		--time|-t)
   950  			return
   951  			;;
   952  	esac
   953  
   954  	case "$cur" in
   955  		-*)
   956  			COMPREPLY=( $( compgen -W "--help --time -t" -- "$cur" ) )
   957  			;;
   958  		*)
   959  			__docker_containers_all
   960  			;;
   961  	esac
   962  }
   963  
   964  _docker_rm() {
   965  	case "$cur" in
   966  		-*)
   967  			COMPREPLY=( $( compgen -W "--force -f --help --link -l --volumes -v" -- "$cur" ) )
   968  			;;
   969  		*)
   970  			for arg in "${COMP_WORDS[@]}"; do
   971  				case "$arg" in
   972  					--force|-f)
   973  						__docker_containers_all
   974  						return
   975  						;;
   976  				esac
   977  			done
   978  			__docker_containers_stopped
   979  			;;
   980  	esac
   981  }
   982  
   983  _docker_rmi() {
   984  	case "$cur" in
   985  		-*)
   986  			COMPREPLY=( $( compgen -W "--force -f --help --no-prune" -- "$cur" ) )
   987  			;;
   988  		*)
   989  			__docker_image_repos_and_tags_and_ids
   990  			;;
   991  	esac
   992  }
   993  
   994  _docker_run() {
   995  	local options_with_args="
   996  		--add-host
   997  		--blkio-weight
   998  		--attach -a
   999  		--cap-add
  1000  		--cap-drop
  1001  		--cgroup-parent
  1002  		--cidfile
  1003  		--cpuset
  1004  		--cpu-period
  1005  		--cpu-quota
  1006  		--cpu-shares -c
  1007  		--device
  1008  		--dns
  1009  		--dns-search
  1010  		--entrypoint
  1011  		--env -e
  1012  		--env-file
  1013  		--expose
  1014  		--group-add
  1015  		--hostname -h
  1016  		--ipc
  1017  		--label -l
  1018  		--label-file
  1019  		--link
  1020  		--log-driver
  1021  		--log-opt
  1022  		--lxc-conf
  1023  		--mac-address
  1024  		--memory -m
  1025  		--memory-swap
  1026  		--name
  1027  		--net
  1028  		--pid
  1029  		--publish -p
  1030  		--restart
  1031  		--security-opt
  1032  		--user -u
  1033  		--ulimit
  1034  		--uts
  1035  		--volumes-from
  1036  		--volume -v
  1037  		--workdir -w
  1038  	"
  1039  
  1040  	local all_options="$options_with_args
  1041  		--help
  1042  		--interactive -i
  1043  		--privileged
  1044  		--publish-all -P
  1045  		--read-only
  1046  		--tty -t
  1047  	"
  1048  
  1049  	[ "$command" = "run" ] && all_options="$all_options
  1050  		--detach -d
  1051  		--rm
  1052  		--sig-proxy
  1053  	"
  1054  
  1055  	local options_with_args_glob=$(__docker_to_extglob "$options_with_args")
  1056  
  1057  	case "$prev" in
  1058  		--add-host)
  1059  			case "$cur" in
  1060  				*:)
  1061  					__docker_resolve_hostname
  1062  					return
  1063  					;;
  1064  			esac
  1065  			;;
  1066  		--attach|-a)
  1067  			COMPREPLY=( $( compgen -W 'stdin stdout stderr' -- "$cur" ) )
  1068  			return
  1069  			;;
  1070  		--cap-add|--cap-drop)
  1071  			__docker_capabilities
  1072  			return
  1073  			;;
  1074  		--cidfile|--env-file|--label-file)
  1075  			_filedir
  1076  			return
  1077  			;;
  1078  		--device|--volume|-v)
  1079  			case "$cur" in
  1080  				*:*)
  1081  					# TODO somehow do _filedir for stuff inside the image, if it's already specified (which is also somewhat difficult to determine)
  1082  					;;
  1083  				'')
  1084  					COMPREPLY=( $( compgen -W '/' -- "$cur" ) )
  1085  					compopt -o nospace
  1086  					;;
  1087  				/*)
  1088  					_filedir
  1089  					compopt -o nospace
  1090  					;;
  1091  			esac
  1092  			return
  1093  			;;
  1094  		--env|-e)
  1095  			COMPREPLY=( $( compgen -e -- "$cur" ) )
  1096  			compopt -o nospace
  1097  			return
  1098  			;;
  1099  		--ipc)
  1100  			case "$cur" in
  1101  				*:*)
  1102  					cur="${cur#*:}"
  1103  					__docker_containers_running
  1104  					;;
  1105  				*)
  1106  					COMPREPLY=( $( compgen -W 'host container:' -- "$cur" ) )
  1107  					if [ "$COMPREPLY" = "container:" ]; then
  1108  						compopt -o nospace
  1109  					fi
  1110  					;;
  1111  			esac
  1112  			return
  1113  			;;
  1114  		--link)
  1115  			case "$cur" in
  1116  				*:*)
  1117  					;;
  1118  				*)
  1119  					__docker_containers_running
  1120  					COMPREPLY=( $( compgen -W "${COMPREPLY[*]}" -S ':' ) )
  1121  					compopt -o nospace
  1122  					;;
  1123  			esac
  1124  			return
  1125  			;;
  1126  		--log-driver)
  1127  			__docker_log_drivers
  1128  			return
  1129  			;;
  1130  		--log-opt)
  1131  			__docker_log_driver_options
  1132  			return
  1133  			;;
  1134  		--net)
  1135  			case "$cur" in
  1136  				container:*)
  1137  					local cur=${cur#*:}
  1138  					__docker_containers_all
  1139  					;;
  1140  				*)
  1141  					COMPREPLY=( $( compgen -W "bridge none container: host" -- "$cur") )
  1142  					if [ "${COMPREPLY[*]}" = "container:" ] ; then
  1143  						compopt -o nospace
  1144  					fi
  1145  					;;
  1146  			esac
  1147  			return
  1148  			;;
  1149  		--restart)
  1150  			case "$cur" in
  1151  				on-failure:*)
  1152  					;;
  1153  				*)
  1154  					COMPREPLY=( $( compgen -W "no on-failure on-failure: always" -- "$cur") )
  1155  					;;
  1156  			esac
  1157  			return
  1158  			;;
  1159  		--security-opt)
  1160  			case "$cur" in
  1161  				label:*:*)
  1162  					;;
  1163  				label:*)
  1164  					local cur=${cur##*:}
  1165  					COMPREPLY=( $( compgen -W "user: role: type: level: disable" -- "$cur") )
  1166  					if [ "${COMPREPLY[*]}" != "disable" ] ; then
  1167  						compopt -o nospace
  1168  					fi
  1169  					;;
  1170  				*)
  1171  					COMPREPLY=( $( compgen -W "label apparmor" -S ":" -- "$cur") )
  1172  					compopt -o nospace
  1173  					;;
  1174  			esac
  1175  			return
  1176  			;;
  1177  		--volumes-from)
  1178  			__docker_containers_all
  1179  			return
  1180  			;;
  1181  		$options_with_args_glob )
  1182  			return
  1183  			;;
  1184  	esac
  1185  
  1186  	__docker_complete_log_driver_options && return
  1187  
  1188  	case "$cur" in
  1189  		-*)
  1190  			COMPREPLY=( $( compgen -W "$all_options" -- "$cur" ) )
  1191  			;;
  1192  		*)
  1193  			local counter=$( __docker_pos_first_nonflag $( __docker_to_alternatives "$options_with_args" ) )
  1194  
  1195  			if [ $cword -eq $counter ]; then
  1196  				__docker_image_repos_and_tags_and_ids
  1197  			fi
  1198  			;;
  1199  	esac
  1200  }
  1201  
  1202  _docker_save() {
  1203  	case "$prev" in
  1204  		--output|-o)
  1205  			_filedir
  1206  			return
  1207  			;;
  1208  	esac
  1209  
  1210  	case "$cur" in
  1211  		-*)
  1212  			COMPREPLY=( $( compgen -W "--help --output -o" -- "$cur" ) )
  1213  			;;
  1214  		*)
  1215  			__docker_image_repos_and_tags_and_ids
  1216  			;;
  1217  	esac
  1218  }
  1219  
  1220  _docker_search() {
  1221  	case "$prev" in
  1222  		--stars|-s)
  1223  			return
  1224  			;;
  1225  	esac
  1226  
  1227  	case "$cur" in
  1228  		-*)
  1229  			COMPREPLY=( $( compgen -W "--automated --help --no-trunc --stars -s" -- "$cur" ) )
  1230  			;;
  1231  	esac
  1232  }
  1233  
  1234  _docker_start() {
  1235  	case "$cur" in
  1236  		-*)
  1237  			COMPREPLY=( $( compgen -W "--attach -a --help --interactive -i" -- "$cur" ) )
  1238  			;;
  1239  		*)
  1240  			__docker_containers_stopped
  1241  			;;
  1242  	esac
  1243  }
  1244  
  1245  _docker_stats() {
  1246  	case "$cur" in
  1247  		-*)
  1248  			COMPREPLY=( $( compgen -W "--no-stream --help" -- "$cur" ) )
  1249  			;;
  1250  		*)
  1251  			__docker_containers_running
  1252  			;;
  1253  	esac
  1254  }
  1255  
  1256  _docker_stop() {
  1257  	case "$prev" in
  1258  		--time|-t)
  1259  			return
  1260  			;;
  1261  	esac
  1262  
  1263  	case "$cur" in
  1264  		-*)
  1265  			COMPREPLY=( $( compgen -W "--help --time -t" -- "$cur" ) )
  1266  			;;
  1267  		*)
  1268  			__docker_containers_running
  1269  			;;
  1270  	esac
  1271  }
  1272  
  1273  _docker_tag() {
  1274  	case "$cur" in
  1275  		-*)
  1276  			COMPREPLY=( $( compgen -W "--force -f --help" -- "$cur" ) )
  1277  			;;
  1278  		*)
  1279  			local counter=$(__docker_pos_first_nonflag)
  1280  
  1281  			if [ $cword -eq $counter ]; then
  1282  				__docker_image_repos_and_tags
  1283  				return
  1284  			fi
  1285  			(( counter++ ))
  1286  
  1287  			if [ $cword -eq $counter ]; then
  1288  				__docker_image_repos_and_tags
  1289  				return
  1290  			fi
  1291  			;;
  1292  	esac
  1293  }
  1294  
  1295  _docker_unpause() {
  1296  	case "$cur" in
  1297  		-*)
  1298  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  1299  			;;
  1300  		*)
  1301  			local counter=$(__docker_pos_first_nonflag)
  1302  			if [ $cword -eq $counter ]; then
  1303  				__docker_containers_unpauseable
  1304  			fi
  1305  			;;
  1306  	esac
  1307  }
  1308  
  1309  _docker_top() {
  1310  	case "$cur" in
  1311  		-*)
  1312  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  1313  			;;
  1314  		*)
  1315  			local counter=$(__docker_pos_first_nonflag)
  1316  			if [ $cword -eq $counter ]; then
  1317  				__docker_containers_running
  1318  			fi
  1319  			;;
  1320  	esac
  1321  }
  1322  
  1323  _docker_version() {
  1324  	case "$cur" in
  1325  		-*)
  1326  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  1327  			;;
  1328  	esac
  1329  }
  1330  
  1331  _docker_wait() {
  1332  	case "$cur" in
  1333  		-*)
  1334  			COMPREPLY=( $( compgen -W "--help" -- "$cur" ) )
  1335  			;;
  1336  		*)
  1337  			__docker_containers_all
  1338  			;;
  1339  	esac
  1340  }
  1341  
  1342  _docker() {
  1343  	local previous_extglob_setting=$(shopt -p extglob)
  1344  	shopt -s extglob
  1345  
  1346  	local commands=(
  1347  		attach
  1348  		build
  1349  		commit
  1350  		cp
  1351  		create
  1352  		daemon
  1353  		diff
  1354  		events
  1355  		exec
  1356  		export
  1357  		history
  1358  		images
  1359  		import
  1360  		info
  1361  		inspect
  1362  		kill
  1363  		load
  1364  		login
  1365  		logout
  1366  		logs
  1367  		pause
  1368  		port
  1369  		ps
  1370  		pull
  1371  		push
  1372  		rename
  1373  		restart
  1374  		rm
  1375  		rmi
  1376  		run
  1377  		save
  1378  		search
  1379  		start
  1380  		stats
  1381  		stop
  1382  		tag
  1383  		top
  1384  		unpause
  1385  		version
  1386  		wait
  1387  	)
  1388  
  1389  	# These options are valid as global options for all client commands
  1390  	# and valid as command options for `docker daemon`
  1391  	local global_boolean_options="
  1392  		--debug -D
  1393  		--tls
  1394  		--tlsverify
  1395  	"
  1396  	local global_options_with_args="
  1397  		--host -H
  1398  		--log-level -l
  1399  		--tlscacert
  1400  		--tlscert
  1401  		--tlskey
  1402  	"
  1403  
  1404  	local host
  1405  
  1406  	COMPREPLY=()
  1407  	local cur prev words cword
  1408  	_get_comp_words_by_ref -n : cur prev words cword
  1409  
  1410  	local command='docker' command_pos=0
  1411  	local counter=1
  1412  	while [ $counter -lt $cword ]; do
  1413  		case "${words[$counter]}" in
  1414  			# save host so that completion can use custom daemon
  1415  			--host|-H)
  1416  				(( counter++ ))
  1417  				host="${words[$counter]}"
  1418  				;;
  1419  			$(__docker_to_extglob "$global_options_with_args") )
  1420  				(( counter++ ))
  1421  				;;
  1422  			-*)
  1423  				;;
  1424  			=)
  1425  				(( counter++ ))
  1426  				;;
  1427  			*)
  1428  				command="${words[$counter]}"
  1429  				command_pos=$counter
  1430  				break
  1431  				;;
  1432  		esac
  1433  		(( counter++ ))
  1434  	done
  1435  
  1436  	local completions_func=_docker_${command}
  1437  	declare -F $completions_func >/dev/null && $completions_func
  1438  
  1439  	eval "$previous_extglob_setting"
  1440  	return 0
  1441  }
  1442  
  1443  complete -F _docker docker