From 5cbd0bef986124efcae95a148bacda8ddcab2535 Mon Sep 17 00:00:00 2001 From: guoxudong Date: Fri, 7 Aug 2020 17:03:36 +0800 Subject: [PATCH] add auto-completion command Signed-off-by: guoxudong --- README.md | 32 +++++- cmd/vela/main.go | 48 ++++++--- pkg/cmd/completion.go | 238 +++++++++++++++++++++++++++++++++++++++++ pkg/cmd/init.go | 2 +- pkg/plugins/cluster.go | 4 +- 5 files changed, 306 insertions(+), 18 deletions(-) create mode 100644 pkg/cmd/completion.go diff --git a/README.md b/README.md index c0c71ae43..4f547fb19 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ -# RudrX +# Vela -RudrX is a command-line tool to use OAM based micro-app engine. +Vela is a command-line tool to use OAM based micro-app engine. ## Develop Check out [DEVELOPMENT.md](./DEVELOPMENT.md) to see how to develop with RudrX @@ -11,7 +11,7 @@ $ go build -o /usr/local/bin/vela cmd/vela/main.go $ chmod +x /usr/local/bin/vela ``` -## RudrX commands +## Vela commands #### help ```shell script @@ -28,6 +28,7 @@ Available Commands: app:delete Delete OAM Applications app:ls List applications app:status get status of an application + completion Output shell completion code for the specified shell (bash or zsh) containerized:run Run containerized workloads deployment:run Run deployment workloads env List environments @@ -121,4 +122,29 @@ $ vela workloads NAME SHORT DEFINITION containerizedworkloads.core.oam.dev containerizedworkloads.core.oam.dev deployments.apps deployments.apps +``` + +#### Auto-Completion + +##### bash + +```shell script +To load completions in your current shell session: +$ source <(vela completion bash) + +To load completions for every new session, execute once: +Linux: + $ vela completion bash > /etc/bash_completion.d/vela +MacOS: + $ vela completion bash > /usr/local/etc/bash_completion.d/vela +``` + +##### zsh + +```shell script +To load completions in your current shell session: +$ source <(vela completion zsh) + +To load completions for every new session, execute once: +$ vela completion zsh > "${fpath[1]}/_vela" ``` \ No newline at end of file diff --git a/cmd/vela/main.go b/cmd/vela/main.go index 3e770f14c..fc142c0ee 100644 --- a/cmd/vela/main.go +++ b/cmd/vela/main.go @@ -1,7 +1,10 @@ package main import ( + "context" "fmt" + v1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "math/rand" "os" "runtime" @@ -64,6 +67,9 @@ func newCommand() *cobra.Command { Long: "✈️ A Micro App Plafrom for Kubernetes.", Run: runHelp, SilenceUsage: true, + ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { + return nil, cobra.ShellCompDirectiveNoFileComp + }, } restConf, err := config.GetConfig() @@ -71,7 +77,24 @@ func newCommand() *cobra.Command { fmt.Println("get kubeconfig err", err) os.Exit(1) } - client, err := client.New(restConf, client.Options{Scheme: scheme}) + newClient, err := client.New(restConf, client.Options{Scheme: scheme}) + err = cmds.RegisterFlagCompletionFunc("namespace", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { + // Choose a long enough timeout that the user notices somethings is not working + // but short enough that the user is not made to wait very long + to := int64(3) + listOpt := &client.ListOptions{ + Raw: &metav1.ListOptions{TimeoutSeconds: &to}, + } + nsNames := []string{} + namespaces := v1.NamespaceList{} + if err = newClient.List(context.Background(), &namespaces, listOpt); err == nil { + for _, ns := range namespaces.Items { + nsNames = append(nsNames, ns.Name) + } + return nsNames, cobra.ShellCompDirectiveNoFileComp + } + return nil, cobra.ShellCompDirectiveDefault + }) if err != nil { fmt.Println("create client from kubeconfig err", err) os.Exit(1) @@ -86,30 +109,31 @@ func newCommand() *cobra.Command { } cmds.AddCommand( - cmd.NewTraitsCommand(client, ioStream, []string{}), - cmd.NewWorkloadsCommand(client, ioStream, os.Args[1:]), - cmd.NewAdminInitCommand(client, ioStream), + cmd.NewTraitsCommand(newClient, ioStream, []string{}), + cmd.NewWorkloadsCommand(newClient, ioStream, os.Args[1:]), + cmd.NewAdminInitCommand(newClient, ioStream), cmd.NewAdminInfoCommand(VelaVersion, ioStream), - cmd.NewDeleteCommand(client, ioStream, os.Args[1:]), - cmd.NewAppsCommand(client, ioStream), - cmd.NewEnvInitCommand(client, ioStream), + cmd.NewDeleteCommand(newClient, ioStream, os.Args[1:]), + cmd.NewAppsCommand(newClient, ioStream), + cmd.NewEnvInitCommand(newClient, ioStream), cmd.NewEnvSwitchCommand(ioStream), cmd.NewEnvDeleteCommand(ioStream), cmd.NewEnvCommand(ioStream), NewVersionCommand(), - cmd.NewAppStatusCommand(client, ioStream), + cmd.NewAppStatusCommand(newClient, ioStream), cmd.NewAddonConfigCommand(ioStream), - cmd.NewAddonListCommand(client, ioStream), + cmd.NewAddonListCommand(newClient, ioStream), + cmd.NewCompletionCommand(), ) - if err = cmd.AddWorkloadPlugins(cmds, client, ioStream); err != nil { + if err = cmd.AddWorkloadPlugins(cmds, newClient, ioStream); err != nil { fmt.Println("Add plugins from workloadDefinition err", err) os.Exit(1) } - if err = cmd.AddTraitPlugins(cmds, client, ioStream); err != nil { + if err = cmd.AddTraitPlugins(cmds, newClient, ioStream); err != nil { fmt.Println("Add plugins from traitDefinition err", err) os.Exit(1) } - if err = cmd.DetachTraitPlugins(cmds, client, ioStream); err != nil { + if err = cmd.DetachTraitPlugins(cmds, newClient, ioStream); err != nil { fmt.Println("Add plugins from traitDefinition err", err) os.Exit(1) } diff --git a/pkg/cmd/completion.go b/pkg/cmd/completion.go new file mode 100644 index 000000000..c634d50bc --- /dev/null +++ b/pkg/cmd/completion.go @@ -0,0 +1,238 @@ +package cmd + +import ( + "fmt" + "github.com/spf13/cobra" + "io" + "os" + "path/filepath" +) + +const completionDesc = ` +Output shell completion code for the specified shell (bash or zsh). +The shell code must be evaluated to provide interactive completion +of vela commands. +` + +const bashCompDesc = ` +Generate the autocompletion script for Vela for the bash shell. + +To load completions in your current shell session: +$ source <(vela completion bash) + +To load completions for every new session, execute once: +Linux: + $ vela completion bash > /etc/bash_completion.d/vela +MacOS: + $ vela completion bash > /usr/local/etc/bash_completion.d/vela +` + +const zshCompDesc = ` +Generate the autocompletion script for Vela for the zsh shell. + +To load completions in your current shell session: +$ source <(vela completion zsh) + +To load completions for every new session, execute once: +$ vela completion zsh > "${fpath[1]}/_vela" +` + +func NewCompletionCommand() *cobra.Command { + cmd := &cobra.Command{ + Use: "completion [bash|zsh]", + Short: "Output shell completion code for the specified shell (bash or zsh)", + Long: completionDesc, + Args: cobra.NoArgs, + } + + bash := &cobra.Command{ + Use: "bash", + Short: "generate autocompletions script for bash", + Long: bashCompDesc, + Args: cobra.NoArgs, + DisableFlagsInUseLine: true, + RunE: func(cmd *cobra.Command, args []string) error { + return runCompletionBash(os.Stdout, cmd) + }, + } + + zsh := &cobra.Command{ + Use: "zsh", + Short: "generate autocompletions script for zsh", + Long: zshCompDesc, + Args: cobra.NoArgs, + DisableFlagsInUseLine: true, + RunE: func(cmd *cobra.Command, args []string) error { + return runCompletionZsh(os.Stdout, cmd) + }, + } + + cmd.AddCommand(bash, zsh) + + return cmd +} + +func runCompletionBash(out io.Writer, cmd *cobra.Command) error { + err := cmd.Root().GenBashCompletion(out) + + if binary := filepath.Base(os.Args[0]); binary != "vela" { + renamedBinaryHook := ` +# Hook the command used to generate the completion script +# to the vela completion function to handle the case where +# the user renamed the vela binary +if [[ $(type -t compopt) = "builtin" ]]; then + complete -o default -F __start_vela %[1]s +else + complete -o default -o nospace -F __start_vela %[1]s +fi +` + fmt.Fprintf(out, renamedBinaryHook, binary) + } + + return err +} + +func runCompletionZsh(out io.Writer, cmd *cobra.Command) error { + zshInitialization := `#compdef vela + +__vela_bash_source() { + alias shopt=':' + alias _expand=_bash_expand + alias _complete=_bash_comp + emulate -L sh + setopt kshglob noshglob braceexpand + source "$@" +} +__vela_type() { + # -t is not supported by zsh + if [ "$1" == "-t" ]; then + shift + # fake Bash 4 to disable "complete -o nospace". Instead + # "compopt +-o nospace" is used in the code to toggle trailing + # spaces. We don't support that, but leave trailing spaces on + # all the time + if [ "$1" = "__vela_compopt" ]; then + echo builtin + return 0 + fi + fi + type "$@" +} +__vela_compgen() { + local completions w + completions=( $(compgen "$@") ) || return $? + # filter by given word as prefix + while [[ "$1" = -* && "$1" != -- ]]; do + shift + shift + done + if [[ "$1" == -- ]]; then + shift + fi + for w in "${completions[@]}"; do + if [[ "${w}" = "$1"* ]]; then + # Use printf instead of echo beause it is possible that + # the value to print is -n, which would be interpreted + # as a flag to echo + printf "%s\n" "${w}" + fi + done +} +__vela_compopt() { + true # don't do anything. Not supported by bashcompinit in zsh +} +__vela_ltrim_colon_completions() +{ + if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then + # Remove colon-word prefix from COMPREPLY items + local colon_word=${1%${1##*:}} + local i=${#COMPREPLY[*]} + while [[ $((--i)) -ge 0 ]]; do + COMPREPLY[$i]=${COMPREPLY[$i]#"$colon_word"} + done + fi +} +__vela_get_comp_words_by_ref() { + cur="${COMP_WORDS[COMP_CWORD]}" + prev="${COMP_WORDS[${COMP_CWORD}-1]}" + words=("${COMP_WORDS[@]}") + cword=("${COMP_CWORD[@]}") +} +__vela_filedir() { + local RET OLD_IFS w qw + __debug "_filedir $@ cur=$cur" + if [[ "$1" = \~* ]]; then + # somehow does not work. Maybe, zsh does not call this at all + eval echo "$1" + return 0 + fi + OLD_IFS="$IFS" + IFS=$'\n' + if [ "$1" = "-d" ]; then + shift + RET=( $(compgen -d) ) + else + RET=( $(compgen -f) ) + fi + IFS="$OLD_IFS" + IFS="," __debug "RET=${RET[@]} len=${#RET[@]}" + for w in ${RET[@]}; do + if [[ ! "${w}" = "${cur}"* ]]; then + continue + fi + if eval "[[ \"\${w}\" = *.$1 || -d \"\${w}\" ]]"; then + qw="$(__vela_quote "${w}")" + if [ -d "${w}" ]; then + COMPREPLY+=("${qw}/") + else + COMPREPLY+=("${qw}") + fi + fi + done +} +__vela_quote() { + if [[ $1 == \'* || $1 == \"* ]]; then + # Leave out first character + printf %q "${1:1}" + else + printf %q "$1" + fi +} +autoload -U +X bashcompinit && bashcompinit +# use word boundary patterns for BSD or GNU sed +LWORD='[[:<:]]' +RWORD='[[:>:]]' +if sed --help 2>&1 | grep -q 'GNU\|BusyBox'; then + LWORD='\<' + RWORD='\>' +fi +__vela_convert_bash_to_zsh() { + sed \ + -e 's/declare -F/whence -w/' \ + -e 's/_get_comp_words_by_ref "\$@"/_get_comp_words_by_ref "\$*"/' \ + -e 's/local \([a-zA-Z0-9_]*\)=/local \1; \1=/' \ + -e 's/flags+=("\(--.*\)=")/flags+=("\1"); two_word_flags+=("\1")/' \ + -e 's/must_have_one_flag+=("\(--.*\)=")/must_have_one_flag+=("\1")/' \ + -e "s/${LWORD}_filedir${RWORD}/__vela_filedir/g" \ + -e "s/${LWORD}_get_comp_words_by_ref${RWORD}/__vela_get_comp_words_by_ref/g" \ + -e "s/${LWORD}__ltrim_colon_completions${RWORD}/__vela_ltrim_colon_completions/g" \ + -e "s/${LWORD}compgen${RWORD}/__vela_compgen/g" \ + -e "s/${LWORD}compopt${RWORD}/__vela_compopt/g" \ + -e "s/${LWORD}declare${RWORD}/builtin declare/g" \ + -e "s/\\\$(type${RWORD}/\$(__vela_type/g" \ + -e 's/aliashash\["\(.\{1,\}\)"\]/aliashash[\1]/g' \ + -e 's/FUNCNAME/funcstack/g' \ + <<'BASH_COMPLETION_EOF' +` + out.Write([]byte(zshInitialization)) + + runCompletionBash(out, cmd) + + zshTail := ` +BASH_COMPLETION_EOF +} +__vela_bash_source <(__vela_convert_bash_to_zsh) +` + out.Write([]byte(zshTail)) + return nil +} diff --git a/pkg/cmd/init.go b/pkg/cmd/init.go index 713cc7837..7e73aa0a4 100644 --- a/pkg/cmd/init.go +++ b/pkg/cmd/init.go @@ -87,7 +87,7 @@ func NewAdminInfoCommand(version string, ioStreams cmdutil.IOStreams) *cobra.Com cmd := &cobra.Command{ Use: "admin:info", - Short: "show RudrX client and cluster version", + Short: "show vela client and cluster version", RunE: func(cmd *cobra.Command, args []string) error { return i.run(version, ioStreams) }, diff --git a/pkg/plugins/cluster.go b/pkg/plugins/cluster.go index f6b1739df..4a5b733e6 100644 --- a/pkg/plugins/cluster.go +++ b/pkg/plugins/cluster.go @@ -44,7 +44,7 @@ func GetWorkloadsFromCluster(ctx context.Context, namespace string, c client.Cli var tmp types.Template tmp, err := HandleTemplate(wd.Spec.Extension, wd.Name, syncDir) if err != nil { - fmt.Printf("[WARN]handle template %s: %v\n", wd.Name, err) + //fmt.Printf("[WARN]handle template %s: %v\n", wd.Name, err) continue } tmp.Type = types.TypeWorkload @@ -65,7 +65,7 @@ func GetTraitsFromCluster(ctx context.Context, namespace string, c client.Client var tmp types.Template tmp, err := HandleTemplate(td.Spec.Extension, td.Name, syncDir) if err != nil { - fmt.Printf("[WARN]handle template %s: %v\n", td.Name, err) + //fmt.Printf("[WARN]handle template %s: %v\n", td.Name, err) continue } tmp.Type = types.TypeTrait