From 931044be011e0bd910dcaa7ccbcceb2363195582 Mon Sep 17 00:00:00 2001 From: Eric Paris Date: Sun, 29 Mar 2015 00:01:00 -0400 Subject: [PATCH] update the actual bash completions using this code! --- contrib/completions/bash/kubectl | 1176 +++++++++++++++++++++++------- 1 file changed, 893 insertions(+), 283 deletions(-) diff --git a/contrib/completions/bash/kubectl b/contrib/completions/bash/kubectl index f9d8d95ce6..f534b0a8ad 100644 --- a/contrib/completions/bash/kubectl +++ b/contrib/completions/bash/kubectl @@ -1,19 +1,24 @@ -#!bash -# -# bash completion file for core kubectl commands -# -# This script provides completion of non replication controller options -# -# To enable the completions either: -# - place this file in /etc/bash_completion.d -# or -# - copy this file and add the line below to your .bashrc after -# bash completion features are loaded -# . kubectl -# -# Note: -# Currently, the completions will not work if the kube-apiserver daemon is not -# running on localhost on the standard port 8080 +#!/bin/bash + + +__debug() +{ + if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then + echo "$*" >> ${BASH_COMP_DEBUG_FILE} + fi +} + +__index_of_word() +{ + local w word=$1 + shift + index=0 + for w in "$@"; do + [[ $w = "$word" ]] && return + index=$((index+1)) + done + index=-1 +} __contains_word() { @@ -24,17 +29,120 @@ __contains_word() return 1 } -__has_resource() +__handle_reply() { - local all_resources=(pod pods service services minion minions replicationController replicationControllers) - local i - for ((i=command_word; i < cword; i++)); do - local word=${words[i]} - if __contains_word "${word}" "${all_resources[@]}"; then - return 0 + __debug "${FUNCNAME}" + case $cur in + -*) + compopt -o nospace + local allflags + if [ ${#must_have_one_flag[@]} -ne 0 ]; then + allflags=("${must_have_one_flag[@]}") + else + allflags=("${flags[*]} ${two_word_flags[*]}") + fi + COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") ) + [[ $COMPREPLY == *= ]] || compopt +o nospace + return 0; + ;; + esac + + # check if we are handling a flag with special work handling + local index + __index_of_word "${prev}" "${flags_with_completion[@]}" + if [[ ${index} -ge 0 ]]; then + ${flags_completion[${index}]} + return + fi + + # we are parsing a flag and don't have a special handler, no completion + if [[ ${cur} != "${words[cword]}" ]]; then + return + fi + + local completions + if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then + completions=("${must_have_one_flag[@]}") + elif [[ ${#must_have_one_noun[@]} -ne 0 ]]; then + completions=("${must_have_one_noun[@]}") + else + completions=("${commands[@]}") + fi + COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") ) + + if [[ ${#COMPREPLY[@]} -eq 0 ]]; then + declare -F __custom_func >/dev/null && __custom_func + fi +} + +__handle_flag() +{ + __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}" + + # if a command required a flag, and we found it, unset must_have_one_flag() + local flagname=${words[c]} + # if the word contained an = + if [[ ${words[c]} == *"="* ]]; then + flagname=${flagname%=*} # strip everything after the = + flagname="${flagname}=" # but put the = back + fi + __debug "${FUNCNAME}: looking for ${flagname}" + if __contains_word "${flagname}" "${must_have_one_flag[@]}"; then + must_have_one_flag=() + fi + + # skip the argument to a two word flag + if __contains_word "${words[c]}" "${two_word_flags[@]}"; then + c=$((c+1)) + # if we are looking for a flags value, don't show commands + if [[ $c -eq $cword ]]; then + commands=() fi - done - return 1 + fi + + # skip the flag itself + c=$((c+1)) + +} + +__handle_noun() +{ + __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}" + + if __contains_word "${words[c]}" "${must_have_one_noun[@]}"; then + must_have_one_noun=() + fi + + nouns+=("${words[c]}") + c=$((c+1)) +} + +__handle_command() +{ + __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}" + + local next_command + next_command="_${last_command}_${words[c]}" + c=$((c+1)) + __debug "${FUNCNAME}: looking for ${next_command}" + declare -F $next_command >/dev/null && $next_command +} + +__handle_word() +{ + if [[ $c -ge $cword ]]; then + __handle_reply + return + fi + __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}" + if [[ "${words[c]}" == -* ]]; then + __handle_flag + elif __contains_word "${words[c]}" "${commands[@]}"; then + __handle_command + else + __handle_noun + fi + __handle_word } # call kubectl get $1, @@ -49,293 +157,795 @@ __kubectl_parse_get() fi } +__kubectl_get_resource() +{ + if [[ ${#nouns[@]} -eq 0 ]]; then + return 1 + fi + __kubectl_parse_get ${nouns[${#nouns[@]} -1]} + if [[ $? -eq 0 ]]; then + return 0 + fi +} + # $1 is the name of the pod we want to get the list of containers inside __kubectl_get_containers() { local template template="{{ range .desiredState.manifest.containers }}{{ .name }} {{ end }}" + __debug ${FUNCNAME} "nouns are ${nouns[@]}" + local len="${#nouns[@]}" + if [[ ${len} -ne 1 ]]; then + return + fi + local last=${nouns[${len} -1]} local kubectl_out - if kubectl_out=$(kubectl get -o template --template="${template}" pods "$1" 2>/dev/null); then + if kubectl_out=$(kubectl get -o template --template="${template}" pods "${last}" 2>/dev/null); then COMPREPLY=( $( compgen -W "${kubectl_out[*]}" -- "$cur" ) ) fi } -__kubectl_pre_command() -{ - local flags=( - --api-version= - -a - --auth-path= - --certificate-authority= - --client-certificate= - --client-key= - --insecure-skip-tls-verify= - --match-server-version= - --namespace= - -s - --server= - ) - local api_versions=(v1beta1 v1beta2 v1beta3) - - case $prev in - --api-version) - COMPREPLY=( $(compgen -W "${api_versions[*]}" -- "$cur") ) - return 0 - ;; - -a | --auth-path | --certificate-authority | --client-certificate | --client-key) - _filedir - return 0 - ;; - --insecure-skip-tls-verify | --match-server-version) - COMPREPLY=( $(compgen -W "true false" -- "$cur") ) - return 0 - ;; - -n | --namespace | -s | --server) - return 0 - ;; - *) - ;; - esac - - if [[ "$cur" = -* ]]; then - compopt -o nospace - COMPREPLY=( $(compgen -W "${flags[*]}" -- "$cur") ) - [[ $COMPREPLY == *= ]] || compopt +o nospace - return 0 - fi - - COMPREPLY=( $( compgen -W "${commands[*]}" -- "$cur" ) ) - return 0 -} - -__kubectl_require_file() -{ - local i - local flags=(-f) - for ((i=command_word; i < cword; i++)); do - local word=${words[i]} - if [[ "${word}" == "-f" ]]; then - flags=() - fi - done - - case $prev in - -f) - _filedir '@(json|yml|yaml)' - return 0; - ;; - esac - COMPREPLY=( $( compgen -W "${flags[*]}" -- "$cur" ) ) -} - -__kubectl_handle_flags_resources() -{ - case $prev in - po | pod | pods) - __kubectl_parse_get pods - return 0 - ;; - rc | replicationController | replicationControllers) - __kubectl_parse_get replicationControllers - return 0 - ;; - se | service | services) - __kubectl_parse_get services - return 0 - ;; - me | minion | minions) - __kubectl_parse_get minions - return 0 - ;; - ev | event | events) - return 0 - ;; - esac - - case $cur in - -*) - compopt -o nospace - COMPREPLY=( $(compgen -W "${flags[*]}" -- "$cur") ) - [[ $COMPREPLY == *= ]] || compopt +o nospace - return 0; - ;; - esac - - COMPREPLY=( $(compgen -W "${resources[*]}" -- "$cur") ) -} - -__kubectl_get() -{ - local resources=() - local flags=(-o --output=) - - if __has_resource; then - resource=() - else - resources=(pods minions services replicationControllers) - fi - - for ((i=command_word; i < cword; i++)); do - local word=${words[i]} - local next=$(( $i + 1 )) - case $word in - -o | --output) - if [[ $next -lt $(( $cword )) ]] && - [[ ${words[$next]} == "template" ]]; then - resources+=(-t --template=) - flags=(-t --template=) - else - flags=() - fi - ;; - -t | --templtate) - resources=(${resources[@]/--template=}) - resources=(${resources[@]/-t}) - flags=() - ;; - esac - done - - case $prev in - -o | --output) - COMPREPLY=( $(compgen -W "json yaml template templatefile" -- "$cur") ) - return 0 - ;; - -t | --template) - _filedir - return 0 - ;; - esac - __kubectl_handle_flags_resources -} - # Require both a pod and a container to be specified __kubectl_require_pod_and_container() { - # check is cword-1 is $command - if [[ $prev == $command ]]; then + if [[ ${#nouns[@]} -eq 0 ]]; then __kubectl_parse_get pods return 0 fi; - - # this is safe, we know $command is back there somewhere and we know cword-1 - if [[ ${words[cword-2]} == $command ]]; then - __kubectl_get_containers $prev - return 0 - fi + __kubectl_get_containers + return 0 } -__kubectl_describe() -{ - local resources=() - local flags=() - - if __has_resource; then - resource=() - else - resources=(pods minions services replicationControllers) - fi - local resources=(pods minions services replicationControllers) - - __kubectl_handle_flags_resources -} - -__kubectl_delete() -{ - local resources=() - local flags=() - - if __has_resource; then - resource=() - flags=() - else - resources=(pods minions services replicationControllers -f) - flags=(-f) - fi - - for ((i=command_word; i < cword; i++)); do - local word=${words[i]} - if [[ "${word}" == "-f" ]]; then - resources=() - flags=() - fi - done - - case $prev in - -f) - _filedir '@(json|yml|yaml)' - return 0 - ;; - esac - __kubectl_handle_flags_resources -} - -__kubectl_post_command() -{ - case $command in - apply | create | update) - __kubectl_require_file - return 0 - ;; - get) - __kubectl_get - return 0 - ;; - describe) - __kubectl_describe - return 0 - ;; - delete) - __kubectl_delete - return 0 - ;; - log) - __kubectl_require_pod_and_container - return 0 +__custom_func() { + case ${last_command} in + kubectl_get | kubectl_describe | kubectl_delete | kubectl_stop) + __kubectl_get_resource + return ;; + kubectl_log) + __kubectl_require_pod_and_container + return + ;; *) ;; esac } -_kubectl() +_kubectl_get() { - local command command_word - local cur prev words cword split - _init_completion -s -n : || return 0 - _expand || return 0 - COMPREPLY=() + last_command="kubectl_get" + commands=() - local commands=(version proxy get describe create update delete namespace log apply help) - local two_word_flags=( - -a - -s - -n - ) + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() - # figure out which command they are running, remembering that arguments to - # options don't count as the command! So a hostname named 'create' won't - # trip things up - local i - for ((i=0; i < cword; i++)); do - if __contains_word "${words[i]}" "${commands[@]}" && - ! __contains_word "${words[i-1]}" "${two_word_flags[@]}"; then - command=${words[i]} - command_word=$i - break - fi - done + flags+=("--help") + flags+=("-h") + flags+=("--no-headers") + flags+=("--output=") + two_word_flags+=("-o") + flags+=("--output-version=") + flags+=("--selector=") + two_word_flags+=("-l") + flags+=("--template=") + two_word_flags+=("-t") + flags+=("--watch") + flags+=("-w") + flags+=("--watch-only") - if [[ -z $command ]]; then - __kubectl_pre_command - return 0 - fi - - __kubectl_post_command - - return 0 + must_have_one_flag=() + must_have_one_noun=() + must_have_one_noun+=("service") + must_have_one_noun+=("replicationcontroller") + must_have_one_noun+=("endpoints") + must_have_one_noun+=("node") + must_have_one_noun+=("secret") + must_have_one_noun+=("status") + must_have_one_noun+=("limitrange") + must_have_one_noun+=("persistentvolumeclaim") + must_have_one_noun+=("persistentvolume") + must_have_one_noun+=("pod") + must_have_one_noun+=("event") + must_have_one_noun+=("resourcequota") + must_have_one_noun+=("namespace") } -complete -F _kubectl kubectl +_kubectl_describe() +{ + last_command="kubectl_describe" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() + must_have_one_noun+=("pod") + must_have_one_noun+=("service") + must_have_one_noun+=("persistentvolume") + must_have_one_noun+=("persistentvolumeclaim") + must_have_one_noun+=("resourcequota") + must_have_one_noun+=("replicationcontroller") + must_have_one_noun+=("minion") + must_have_one_noun+=("node") + must_have_one_noun+=("limitrange") +} + +_kubectl_create() +{ + last_command="kubectl_create" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--filename=") + flags_with_completion+=("--filename") + flags_completion+=("_filedir '@(json|yaml|yml)'") + two_word_flags+=("-f") + flags_with_completion+=("-f") + flags_completion+=("_filedir '@(json|yaml|yml)'") + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_flag+=("--filename=") + must_have_one_flag+=("-f") + must_have_one_noun=() +} + +_kubectl_update() +{ + last_command="kubectl_update" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--filename=") + flags_with_completion+=("--filename") + flags_completion+=("_filedir '@(json|yaml|yml)'") + two_word_flags+=("-f") + flags_with_completion+=("-f") + flags_completion+=("_filedir '@(json|yaml|yml)'") + flags+=("--help") + flags+=("-h") + flags+=("--patch=") + + must_have_one_flag=() + must_have_one_flag+=("--filename=") + must_have_one_flag+=("-f") + must_have_one_flag+=("--patch=") + must_have_one_noun=() +} + +_kubectl_delete() +{ + last_command="kubectl_delete" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--all") + flags+=("--filename=") + flags_with_completion+=("--filename") + flags_completion+=("_filedir '@(json|yaml|yml)'") + two_word_flags+=("-f") + flags_with_completion+=("-f") + flags_completion+=("_filedir '@(json|yaml|yml)'") + flags+=("--help") + flags+=("-h") + flags+=("--selector=") + two_word_flags+=("-l") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_namespace() +{ + last_command="kubectl_namespace" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_log() +{ + last_command="kubectl_log" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--follow") + flags+=("-f") + flags+=("--help") + flags+=("-h") + flags+=("--interactive") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_rolling-update() +{ + last_command="kubectl_rolling-update" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--filename=") + flags_with_completion+=("--filename") + flags_completion+=("_filedir '@(json|yaml|yml)'") + two_word_flags+=("-f") + flags_with_completion+=("-f") + flags_completion+=("_filedir '@(json|yaml|yml)'") + flags+=("--help") + flags+=("-h") + flags+=("--poll-interval=") + flags+=("--timeout=") + flags+=("--update-period=") + + must_have_one_flag=() + must_have_one_flag+=("--filename=") + must_have_one_flag+=("-f") + must_have_one_noun=() +} + +_kubectl_resize() +{ + last_command="kubectl_resize" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--current-replicas=") + flags+=("--help") + flags+=("-h") + flags+=("--replicas=") + flags+=("--resource-version=") + + must_have_one_flag=() + must_have_one_flag+=("--replicas=") + must_have_one_noun=() +} + +_kubectl_exec() +{ + last_command="kubectl_exec" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--container=") + two_word_flags+=("-c") + flags+=("--help") + flags+=("-h") + flags+=("--pod=") + two_word_flags+=("-p") + flags+=("--stdin") + flags+=("-i") + flags+=("--tty") + flags+=("-t") + + must_have_one_flag=() + must_have_one_flag+=("--container=") + must_have_one_flag+=("-c") + must_have_one_flag+=("--pod=") + must_have_one_flag+=("-p") + must_have_one_noun=() +} + +_kubectl_port-forward() +{ + last_command="kubectl_port-forward" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + flags+=("--pod=") + two_word_flags+=("-p") + + must_have_one_flag=() + must_have_one_flag+=("--pod=") + must_have_one_flag+=("-p") + must_have_one_noun=() +} + +_kubectl_proxy() +{ + last_command="kubectl_proxy" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--api-prefix=") + flags+=("--help") + flags+=("-h") + flags+=("--port=") + two_word_flags+=("-p") + flags+=("--www=") + two_word_flags+=("-w") + flags+=("--www-prefix=") + two_word_flags+=("-P") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_run-container() +{ + last_command="kubectl_run-container" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--dry-run") + flags+=("--generator=") + flags+=("--help") + flags+=("-h") + flags+=("--image=") + flags+=("--labels=") + two_word_flags+=("-l") + flags+=("--no-headers") + flags+=("--output=") + two_word_flags+=("-o") + flags+=("--output-version=") + flags+=("--overrides=") + flags+=("--port=") + flags+=("--replicas=") + two_word_flags+=("-r") + flags+=("--template=") + two_word_flags+=("-t") + + must_have_one_flag=() + must_have_one_flag+=("--image=") + must_have_one_noun=() +} + +_kubectl_stop() +{ + last_command="kubectl_stop" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--all") + flags+=("--filename=") + flags_with_completion+=("--filename") + flags_completion+=("_filedir '@(json|yaml|yml)'") + two_word_flags+=("-f") + flags_with_completion+=("-f") + flags_completion+=("_filedir '@(json|yaml|yml)'") + flags+=("--help") + flags+=("-h") + flags+=("--selector=") + two_word_flags+=("-l") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_expose() +{ + last_command="kubectl_expose" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--container-port=") + flags+=("--create-external-load-balancer") + flags+=("--dry-run") + flags+=("--generator=") + flags+=("--help") + flags+=("-h") + flags+=("--labels=") + two_word_flags+=("-l") + flags+=("--no-headers") + flags+=("--output=") + two_word_flags+=("-o") + flags+=("--output-version=") + flags+=("--overrides=") + flags+=("--port=") + flags+=("--protocol=") + flags+=("--public-ip=") + flags+=("--selector=") + flags+=("--service-name=") + flags+=("--target-port=") + flags+=("--template=") + two_word_flags+=("-t") + + must_have_one_flag=() + must_have_one_flag+=("--port=") + must_have_one_noun=() +} + +_kubectl_label() +{ + last_command="kubectl_label" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--all") + flags+=("--help") + flags+=("-h") + flags+=("--no-headers") + flags+=("--output=") + two_word_flags+=("-o") + flags+=("--output-version=") + flags+=("--overwrite") + flags+=("--resource-version=") + flags+=("--selector=") + two_word_flags+=("-l") + flags+=("--template=") + two_word_flags+=("-t") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_view() +{ + last_command="kubectl_config_view" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + flags+=("--merge") + flags+=("--no-headers") + flags+=("--output=") + two_word_flags+=("-o") + flags+=("--output-version=") + flags+=("--template=") + two_word_flags+=("-t") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_set-cluster() +{ + last_command="kubectl_config_set-cluster" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--api-version=") + flags+=("--certificate-authority=") + flags+=("--embed-certs") + flags+=("--help") + flags+=("-h") + flags+=("--insecure-skip-tls-verify") + flags+=("--server=") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_set-credentials() +{ + last_command="kubectl_config_set-credentials" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--auth-path=") + flags+=("--client-certificate=") + flags+=("--client-key=") + flags+=("--embed-certs") + flags+=("--help") + flags+=("-h") + flags+=("--password=") + flags+=("--token=") + flags+=("--username=") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_set-context() +{ + last_command="kubectl_config_set-context" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--cluster=") + flags+=("--help") + flags+=("-h") + flags+=("--namespace=") + flags+=("--user=") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_set() +{ + last_command="kubectl_config_set" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_unset() +{ + last_command="kubectl_config_unset" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config_use-context() +{ + last_command="kubectl_config_use-context" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_config() +{ + last_command="kubectl_config" + commands=() + commands+=("view") + commands+=("set-cluster") + commands+=("set-credentials") + commands+=("set-context") + commands+=("set") + commands+=("unset") + commands+=("use-context") + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--envvar") + flags+=("--global") + flags+=("--help") + flags+=("-h") + flags+=("--kubeconfig=") + flags+=("--local") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_cluster-info() +{ + last_command="kubectl_cluster-info" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_api-versions() +{ + last_command="kubectl_api-versions" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl_version() +{ + last_command="kubectl_version" + commands=() + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--client") + flags+=("-c") + flags+=("--help") + flags+=("-h") + + must_have_one_flag=() + must_have_one_noun=() +} + +_kubectl() +{ + last_command="kubectl" + commands=() + commands+=("get") + commands+=("describe") + commands+=("create") + commands+=("update") + commands+=("delete") + commands+=("namespace") + commands+=("log") + commands+=("rolling-update") + commands+=("resize") + commands+=("exec") + commands+=("port-forward") + commands+=("proxy") + commands+=("run-container") + commands+=("stop") + commands+=("expose") + commands+=("label") + commands+=("config") + commands+=("cluster-info") + commands+=("api-versions") + commands+=("version") + + flags=() + two_word_flags=() + flags_with_completion=() + flags_completion=() + + flags+=("--alsologtostderr") + flags+=("--api-version=") + flags+=("--auth-path=") + two_word_flags+=("-a") + flags+=("--certificate-authority=") + flags+=("--client-certificate=") + flags+=("--client-key=") + flags+=("--cluster=") + flags+=("--context=") + flags+=("--help") + flags+=("-h") + flags+=("--insecure-skip-tls-verify") + flags+=("--kubeconfig=") + flags+=("--log_backtrace_at=") + flags+=("--log_dir=") + flags+=("--log_flush_frequency=") + flags+=("--logtostderr") + flags+=("--match-server-version") + flags+=("--namespace=") + flags+=("--password=") + flags+=("--server=") + two_word_flags+=("-s") + flags+=("--stderrthreshold=") + flags+=("--token=") + flags+=("--user=") + flags+=("--username=") + flags+=("--v=") + flags+=("--validate") + flags+=("--vmodule=") + + must_have_one_flag=() + must_have_one_noun=() +} + +__start_kubectl() +{ + local cur prev words cword split + _init_completion -s || return + + local completions_func + local c=0 + local flags=() + local two_word_flags=() + local flags_with_completion=() + local flags_completion=() + local commands=("kubectl") + local must_have_one_flag=() + local must_have_one_noun=() + local last_command + local nouns=() + + __handle_word +} + +complete -F __start_kubectl kubectl # ex: ts=4 sw=4 et filetype=sh