KpSrSSKJr SSKJr SSKJr SSKrSSKrSSKrSSKrSSK r SSK r SSK J r SSK r SrSrS r"S S \5r"S S \ R&"\R(\55r"SS\ R&"\R(\55r"SS\5r"SS\5r"SS\5rSr"SS\5rg)aThe local coshell module. A coshell is an interactive non-login /bin/bash running as a coprocess. It has the same stdin, stdout and stderr as the caller and reads command lines from a pipe. Only one command runs at a time. ctrl-c interrupts and kills the currently running command but does not kill the coshell. The coshell process exits when the shell 'exit' command is executed. State is maintained by the coshell across commands, including the current working directory and local and environment variables. ~/.bashrc, if it exists, is sourced into the coshell at startup. This gives the caller the opportunity to set up aliases and default 'set -o ...' shell modes. Usage: cosh = coshell.Coshell() while True: command = try: command_exit_status = cosh.Run(command) except coshell.CoshellExitError: break coshell_exit_status = cosh.Close() This module contains three Coshell implementations: * _UnixCoshell using /bin/bash * _MinGWCoshell using MinGW bash or git bash * _WindowsCoshell using cmd.exe, does not support state across commands On the first instantiation Coshell.__init__() determines what implementation to use. All subsequent instantiations will use the same implementation. )absolute_import)division)unicode_literalsN)encodingCOSHELLz1.1a # Defines functions to support completion requests to the coshell. # # The only coshell specific shell globals are functions prefixed by __coshell_. # All other globals are part of the bash completion api. __coshell_get_completions__() { # Prints the completions for the (partial) command line "$@" terminated by # a blank line sentinel. The first arg is either 'prefix' for command # executable completeions or 'default' for default completions. local command completion_function last_word next_to_last_word local COMP_CWORD COMP_LINE COMP_POINT COMP_WORDS COMPREPLY=() (( $# )) || { printf '\n' return } command=$1 COMP_WORDS=( "$@" ) # Get the command specific completion function. set -- $(complete -p "$command" 2>/dev/null) if (( ! $# )); then # Load the completion function for the command. _completion_loader "$command" set -- $(complete -p "$command" 2>/dev/null) fi # Check if it was loaded. if (( $# )); then # There is an explicit completer. shift $(( $# - 2 )) completion_function=$1 else # Use the coshell default completer. __coshell_get_file_completions__ "${COMP_WORDS[${#COMP_WORDS[*]}-1]}" return fi # Set up the completion call stack -- really, this is the api? COMP_LINE=${COMP_WORDS[@]} COMP_POINT=${#COMP_LINE} # Index and value of the last word. COMP_CWORD=$(( ${#COMP_WORDS[@]} - 1 )) last_word=${COMP_WORDS[$COMP_CWORD]} # Value of the next to last word. if (( COMP_CWORD >= 2 )); then next_to_last_word=${COMP_WORDS[$((${COMP_CWORD}-1))]} else next_to_last_word='' fi # Execute the completion function. Some completers, like _python_argcomplete, # require $1, $2 and $3. if $completion_function "${command}" "${last_word}" "${next_to_last_word}" 2>/dev/null; then # Print the completions to stdout. printf '%s\n' "${COMPREPLY[@]}" '' else # Fall back to the coshell default completer on error. __coshell_get_file_completions__ "${COMP_WORDS[${#COMP_WORDS[@]}-1]}" fi } __coshell_get_executable_completions__() { # Prints the executable completions for $1 one per line, terminated by a # blank line sentinel. compgen -A command -- "$1" printf '\n' } __coshell_get_file_completions__() { # Prints the file completions for $1, with trailing / for dirs, one per line, # terminated by a blank line sentinel. We could almost use_filedir_xspec, but # * it's not installed/sourced by default on some systems (like macos) # * it's part of a ~2K line rc file with no clear way of slicing it out # * ~ and $... are expanded in the completions if __coshell_var_brace_expand "$1"; then # ...$AB compgen -A variable -P "${1%\$*}\${" -S "}" -- "${1##*\$\{}" elif __coshell_var_plain_expand "$1"; then # ...${AB compgen -A variable -P "${1%\$*}\$" -- "${1##*\$}" else local word_raw word_exp word words=() x IFS=$'\n' word_raw=$1 eval word_exp=\"$word_raw\" if [[ $word_exp == "$word_raw" ]]; then # No $... expansions, just add trailing / for dirs. words=( $(compgen -A file -- "$word_exp") ) for word in ${words[@]}; do if [[ $word != */ ]]; then if [[ $word == \~* ]]; then eval x="$word" else x=$word fi [[ -d $x ]] && word+=/ fi printf '%s\n' "$word" done else # $... expansions: expand for -d tests, return unexpanded completions with # trailing / for dirs. compgen -A file handles ~ but does not expand it, # too bad it doesn't do the same for $... expansions. local prefix_exp suffix_raw __coshell_suffix_raw "$word_raw" # Sets suffix_raw. prefix_raw=${word_raw%"$suffix_raw"} prefix_exp=${word_exp%"$suffix_raw"} words=( $(compgen -A file "$word_exp") ) for word in ${words[@]}; do [[ $word != */ && -d $word ]] && word+=/ printf '%s\n' "${prefix_raw}${word#"$prefix_exp"}" done fi fi printf '\n' } __coshell_get_directory_completions__() { # Prints the directory completions for $1, with trailing /, one per line, # terminated by a blank line sentinel. if __coshell_var_brace_expand "$1"; then # ...$AB compgen -A variable -P "${1%\$*}\${" -S "}" -- "${1##*\$\{}" elif __coshell_var_plain_expand "$1"; then # ...${AB compgen -A variable -P "${1%\$*}\$" -- "${1##*\$}" else local word_raw word_exp word words=() x IFS=$'\n' word_raw=$1 eval word_exp=\"$word_raw\" if [[ $word_exp == "$word_raw" ]]; then # No $... expansions, just add trailing / for dirs. words=( $(compgen -A directory -S/ -- "$word_exp") ) printf '%s\n' "${words[@]}" else # $... expansions: return unexpanded completions with trailing /. local prefix_exp suffix_raw __coshell_suffix_raw "$word_raw" # Sets suffix_raw. prefix_raw=${word_raw%"$suffix_raw"} prefix_exp=${word_exp%"$suffix_raw"} words=( $(compgen -A file -S/ -- "$word_exp") ) for word in ${words[@]}; do printf '%s\n' "${prefix_raw}${word#"$prefix_exp"}" done fi fi printf '\n' } __coshell_default_completer__() { # The default interactive completer. Handles ~ and embedded $... expansion. local IFS=$'\n' completer=__coshell_get_file_completions__ for o in "$@"; do case $o in -c) completer=__coshell_get_executable_completions__ ;; -d) completer=__coshell_get_directory_completions__ ;; esac done COMPREPLY=( $($completer "$cur") ) } __coshell_init_completions__() { # Loads bash-completion if necessary. declare -F _completion_loader &>/dev/null || { source /usr/share/bash-completion/bash_completion 2>/dev/null || { _completion_loader() { return 1 } } } # Defines bash version dependent functions. local x y x='${HOME}/tmp' y=${x##*\$?(\{)+([a-zA-Z0-90-9_])?(\})} if [[ $x != $y ]]; then # Modern bash. eval ' __coshell_suffix_raw() { coshell_suffix_raw=${1##*\$?(\{)+([a-zA-Z0-90-9_])?(\})} } ' else __coshell_suffix_raw() { suffix_raw=$(sed 's/.*\${*[a-zA-Z0-9_]*}*//' <<<"$1") } fi if eval '[[ x == *\$\{*([a-zA-Z0-90-9_]) ]]' 2>/dev/null; then # Modern bash. eval ' __coshell_var_brace_expand() { [[ $1 == *\$\{*([a-zA-Z0-90-9_]) ]] } __coshell_var_plain_expand() { [[ $1 == *\$+([a-zA-Z0-90-9_]) ]] } ' else __coshell_var_brace_expand() { __coshell_partial_expand=$(sed 's/.*\$\({*\)[a-zA-Z0-9_]*$/\1/' <<<"$1") [[ $1 && $__coshell_partial_expand == "{" ]] } __coshell_var_plain_expand() { __coshell_partial_expand=$(sed 's/.*\$\({*\)[a-zA-Z0-9_]*$/\1/' <<<"$1") [[ $1 && $__coshell_partial_expand == "" ]] } fi _filedir() { # Overrides the bash_completion function that completes internal $cur. __coshell_default_completer__ "$@" } _minimal() { # Overrides the bash_completion function that completes external COMP_WORDS. cur=${COMP_WORDS[$COMP_CWORD]} __coshell_default_completer__ "$@" } compopt() { # $completion_function is called by __coshell_get_file_completions__ # outside a completion context. Any of those functions calling compopt will # get an annoying error and completely break completions. This override # ignores the errors -- the other coshell completer overrides should wash # them out. command compopt "$@" 2>/dev/null return 0 } } __coshell_init_completions__ c0^\rSrSrSrSU4SjjrSrU=r$)CoshellExitErrori2zThe coshell exited.c8>[[U] U5 X lgN)superr __init__status)selfmessager __class__s 5lib/googlecloudsdk/command_lib/interactive/coshell.pyr CoshellExitError.__init__5s D*73Krr )__name__ __module__ __qualname____firstlineno____doc__r __static_attributes__ __classcell__rs@rr r 2srr c\rSrSrSrSSjr\S5r\S5r\S5r \ S5r Sr S r S rS r\R"SS j5r\R"S 5rSSjrSSjrSrg) _CoshellBasei:atThe local coshell base class. Attributes: _edit_mode: The coshell edit mode, one of {'emacs', 'vi'}. _ignore_eof: True if the coshell should ignore EOF on stdin and not exit. _set_modes_callback: Called when SetModesCallback() is called or when mutable shell modes may have changed. _state_is_preserved: True if shell process state is preserved across Run(). cnSUl[R"5UlXlSUlSUlg)NemacsF)_set_modes_callbacklocalegetpreferredencoding _encoding_state_is_preserved _edit_mode _ignore_eof)rstate_is_preserveds rr _CoshellBase.__init__Es/#D002DN1DODrcUR$r )r'rs r edit_mode_CoshellBase.edit_modeNs ??rcUR$r )r(r,s r ignore_eof_CoshellBase.ignore_eofRs   rcUR$r )r&r,s rr)_CoshellBase.state_is_preservedVs  # ##rc*UcSnU$US:aSU- nU$)z> **  ms  ,,cg)8Closes the coshell connection and release any resources.Nr6r,s rClose_CoshellBase.Closeqrc.XlU(aU"5 gg)zSets the callback function to be called when any mutable mode changed. If callback is not None then it is called immediately to initialize the caller. Args: callback: func() called when any mutable mode changed, None to disable. N)r")rcallbacks rSetModesCallback_CoshellBase.SetModesCallbackus (jrcg)aORuns command in the coshell and waits for it to complete. Args: command: The command line string to run. Must be a sytactically complete shell statement. Nothing is executed if there is a syntax error. check_modes: If True runs self._GetModes() after command has executed if command contains `set -o ...` or `set +o ...`. Nr6rcommand check_modess rRun_CoshellBase.Runs rcgz*Sends the interrupt signal to the coshell.Nr6)rsigs r Interrupt_CoshellBase.Interrupt rcAg)zReturns the list of completion choices for args. Args: args: The list of command line argument strings to complete. prefix: Complete the last arg as a command prefix. Nr6)rargsprefixs rGetCompletions_CoshellBase.GetCompletionss  rcA/$)Runs args and returns the list of output lines, up to first empty one. Args: args: The list of command line arguments. quote: Shell quote args if True. Returns: The list of output lines from command args up to the first empty line. r6)rr[quotes r Communicate_CoshellBase.Communicates  Ir)r'r%r(r"r&NTF)rrrrrr propertyr-r0r) staticmethodr7r>rCrGrLabcabstractmethodrRrWr]rbrr6rrrr:s     $ $         rrc^\rSrSrSrSrSrSrU4Sjr\ S5r Sr S r S r S rS rS rSrSrSr\R*SSj5rSSjrSSjrSrSrU=r$)_UnixCoshellBaseizYThe unix local coshell base class. Attributes: _shell: The coshell subprocess object. x cT>[[U] 5 SUlSUlSUlgr )r rkr r _status_fd_shellrrs rr _UnixCoshellBase.__init__s& D*,DKDODKrcDSRURSS55$)z?Quotes command in single quotes so it can be eval'd in coshell.z'{}''z'\'')formatreplace)rPs r_Quote_UnixCoshellBase._Quotes ==g6 77rcURS5 UR UR R 5n[SRU5US9e![[[4a NUf=f)z"Raises the coshell exit exception.:zThe coshell exited [status={}].r) _WriteLineIOErrorOSError ValueErrorr7rq returncoder rv)rrs r_Exited_UnixCoshellBase._Exitedsh  ooc  t{{55 6F )008  Wj )   sAA)(A)cURURRR55R 5$)z;Reads and returns a decoded stripped line from the coshell.)r>rqstdoutreadlinestripr,s r _ReadLine_UnixCoshellBase._ReadLines- << **335 6 < < >>rcD[R"URS5$)zCReads and returns one encoded character from the coshell status fd.)osreadrpr,s r_ReadStatusChar _UnixCoshellBase._ReadStatusChars 774??A &&rc^URRURUS-55 g)z&Writes an encoded line to the coshell. N)rq communicaterC)rlines rr|_UnixCoshellBase._WriteLines!KKDLL56rcURRRURUS-55 URRR 5 g![ [ [4a UR5 gf=f)z+Sends command to the coshell for execution.rN) rqstdinwriterCflushr}r~rr)rrPs r _SendCommand_UnixCoshellBase._SendCommandsa kkdll7T>:; kk Wj ) llnsAA%BBcB/nURRS5nUR5nUSSU4;aOURU5 M-UR SR U55nUR 5(aX2:XaUR5 [U5$)8Gets the status of the last command sent to the coshell.asciiN r) SHELL_STATUS_EXITrArappendr>joinisdigitrint)rrshell_status_exitc status_strings r _GetStatus_UnixCoshellBase._GetStatuss D..55g>     a tU-. .  kk!n  LL$0M  " "a&< lln } rcVSnURSSS9S:XaURS:wa SnSUlOURS:wa SnSUlURnURSSS9S:HUlURU:waSnU(a#UR(aUR5 g g g ) zSyncs the user settable modes of interest to the Coshell. Calls self._set_modes_callback if it was specified and any mode changed. Fzset -o | grep -q "^vi.*on"rQrviTr!z!set -o | grep -q "^ignoreeof.*on"N)rRr'r(r")rchangedr0s r _GetModes_UnixCoshellBase._GetModess G xx,%x@AE D  G #!!!Jxx+ @CDED :%g4++  ,wrcURS/SS9n[U5S:Xa[R"US5 US$g![a gf=f)zEGets the coshell pwd, sets local pwd, returns the pwd, None on error.zprintf "$PWD\n\n"F)rarrN)rblenrchdirr~)rpwds rGetPwd_UnixCoshellBase.GetPwd s`   01  ?C 3x1}  Q1v     sA A Ac URSR[URUR[ S95 URS5 URS5 UR 5 URS5 g)z,Consults the user shell config for defaults.zCOSHELL_VERSION={coshell_version};_status() {{ return $1; }};[[ -f $HOME/.bashrc ]] && source $HOME/.bashrc;trap 'echo $?{exit} >&{fdstatus}' 0;trap ":" 2;{get_completions_init})coshell_versionexitfdstatusget_completions_initzset -o monitor 2>/dev/nullz#shopt -s expand_aliases 2>/dev/nulltrueN)rrvCOSHELL_VERSIONrSHELL_STATUS_FD_GET_COMPLETIONS_INITrr,s r_GetUserConfigDefaults'_UnixCoshellBase._GetUserConfigDefaultss}  , ++--%:  <=$ 23 ;< NN frcg)9Runs command in the coshell and waits for it to complete.Nr6rOs r_Run_UnixCoshellBase._Run7rYrcNSn[R"[R[R5nURXS9n[R"[RU5 U$![a N3f=f![R"[RU5 f=f)rr)signalSIGINTSIG_IGNrKeyboardInterrupt)rrPrQrsigints rrR_UnixCoshellBase.Run<sv F ]]6==&.. 9F+yyy:f mmFMM6* M     mmFMM6*s#A-- A:7A=9A::A=='B$cU(aURSUS/5nOURS/U-5n[[U55$)zReturns the list of completion choices for args. Args: args: The list of command line argument strings to complete. prefix: Complete the last arg as a command prefix. Returns: The list of completions for args. &__coshell_get_executable_completions____coshell_get_completions__)rbsortedset)rr[r\ completionss rr]_UnixCoshellBase.GetCompletionsHsQ$$&N&*2h&01k$$&C%Dt%KLk #k" ##rcVURR[R5 grU)rq send_signalrrr,s rrW_UnixCoshellBase.InterruptZsKKFMM*r)r'r(rqrprrdre)rrrrrrrSHELL_STDIN_FDr rgrxrrrr|rrrrrrhrirrRr]rWrrrs@rrkrks /. 88 ?'7 !8 @   $$++rrkcN^\rSrSrSrSrS U4SjjrSrS SjrS Sjr Sr U=r $) _UnixCoshelli_aThe unix local coshell implementation. This implementation preserves coshell process state across Run(). Attributes: _status_fd: The read side of the pipe where the coshell write 1 char status lines. The status line is used to mark the exit of the currently running command. z /bin/bashc >[[U] 5 [R"UR 5n[R"SUR 5 [R"UR5n[R"SUR5 [R"5uUl n[R"XPR 5 [R"U5 [R"[R[5nU(aUR!S5nO UR"/n[$R&(a0OSS0n[(R*"U4[R[(R,UUSS.UD6UlUS:a7[R"X0R 5 [R"U5 O [R"UR 5 US:a7[R"X@R5 [R"U5 O [R"UR5 UR15 g![ a SnGN8f=f![ a SnGN f=f)Nrrr restore_signalsF)envrrstderr close_fds)r rr rduprr~dup2rpiperpcloserGetEncodedValueenviron COSHELL_ENVsplit SHELL_PATHsixPY2 subprocessPopenPIPErqr) rrrcaller_shell_status_fdcaller_shell_stdin_fdwcoshell_command_line shell_commandadditional_kwargsrs rr _UnixCoshell.__init__ls ,&("!vvd&:&:;GGAt##$! ffT%8%89GGAt""#DOQGGA##$HHQK$33BJJ L*005m'm"gg,=u+E"" JJoo  DK"gg$&:&:;hh%&hht##$!gg#%8%89hh$%hht""#!c "!" ! !s# I I1 I.-I.1 JJc URS:a'[R"UR5 SUlURS5 UR URR5$![[ 4a N7f=f)rFrrr) rprrr|r}rr7rqrr,s rrG_UnixCoshell.Closesl !hhtdo  oof   T[[33 44 Z    sA//BBcjURSRURU5URURS95 UR 5nU(aX[ R"SU5(aUR5 [ R"SU5(aUR5 U$)rzwcommand eval {command} <&{fdin} && echo 0 >&{fdstatus} || {{ status=$?; echo $status 1>&{fdstatus}; _status $status; }})rPrfdin\bset\s+[-+]o\s+\w\bcd\b) rrvrxrrrresearchrrrrPrQrs rr_UnixCoshell._Runs HHNKK())$$IOI&' __ F (' 2 2  9g & & Mrc6U(a1SRUVs/sHo0RU5PM sn5nOSRU5nURSRX@RS95 /n/nUR 5nWS;aJU(dU$URURSRU5R555 /nOURU5 Mts snf![ [[4a UR5 Nf=f)r`rz{command} >&{fdstatus} )rPr)Nrr) rrxrrvrrr}r~rrrr>rstrip)rr[raargrPlinesrrs rrb_UnixCoshell.Communicates d;ds++c*d;= 3 we are stuck with restricting fds 0,1,2 to be /dev/tty, via shell redirection, for Run(). For internal communication fds 0,1 are pipes. Luckily this works for the shell interactive prompt. Unfortunately this fails for the test environment. Nz/dev/ttyct>[[U] 5 UR5UlUR 5 gr )r rr _Popenrqrrrs rr _MinGWCoshell.__init__s) -')++-DK!rc[R"5n[RUl[R"UR /[R [R US9$)z2Mockable popen+startupinfo so we can test on Unix.)rr startupinfo)r STARTUPINFOCREATE_NEW_PROCESS_GROUPdWflagsrrr)rr s rr_MinGWCoshell._PopensK((*K$==K   T__-",//#-??(3 55rcURS5 URURR 5$![[4a N7f=f)rFr)r|r}rr7rqrr,s rrG_MinGWCoshell.ClosesI  oof   T[[33 44 Z    s8A  A cUR5nURUR5(aURnUSSnOSnUR5(aX R:XaUR 5 [ U5$)rNr)rendswithrrrr)rrrs rr_MinGWCoshell._GetStatussoNN$Md4455  a#CR(m a  " "a+A+A&A lln } rcjURSRURU5URURS95 UR 5nU(aX[ R"SU5(aUR5 [ R"SU5(aUR5 U$)rzdcommand eval {command} <'{stdin}' >>'{stdout}' && echo 0 || {{ status=$?; echo 1; (exit $status); }})rPrrrr) rrvrx STDIN_PATH STDOUT_PATHrrrrrrs rr_MinGWCoshell._Runs 3396KK(//##4:4  __ F (' 2 2  9g & & Mrc~U(a1SRUVs/sHo0RU5PM sn5nOSRU5nURUS-5 /nUR5nW(dU$URU5 M.s snf![[ [ 4a UR5 NIf=f)r`rr) rrxrrr}r~rrr)rr[rarrPrrs rrb_MinGWCoshell.Communicate0s d;ds++c*d;[[U] SS9 g)NF)r))r rr rrs rr _WindowsCoshell.__init__Vs /4)U)Crc.A[R"USS9$)rT)shell)rcallrOs rrR_WindowsCoshell.RunYs ??7$ //rcgrUr6r,s rrW_WindowsCoshell.Interrupt^rIrr6re) rrrrrr rRrWrrrs@rrrPs D0   rrcB[[5$![a gf=f)z#Lightweight mockable Windows check.F)bool WindowsError NameErrorr6rr_RunningOnWindowsr,cs$    s  c"\rSrSrSrSrSrSrg)CoshellikzThe local coshell implementation shim. This shim class delays os specific checks until the first instantiation. The checks are memoized in the shim class for subsequent instantiations. Nc|UR(dp[5(aV[UlSHDn[RR U5(dM)[ UlX0Rl O O [UlURR"UR/UQ70UD6nUR5 U$)N)zC:\MinGW\bin\sh.exezC:\Program Files\Git\bin\sh.exe) _IMPLEMENTATIONr,rrpathisfilerrr__new__r )clsr[kwargsr#objs rr3Coshell.__new__ts      - :E WW^^E " ""/C -2   *  :+   % %c&9&9 KD KF KCLLN Jrr6)rrrrrr0r3rr6rrr.r.ks /rr.)r __future__rrrrhr#rrrrgooglecloudsdk.core.utilrrrrr Exceptionr with_metaclassABCMetaobjectrrkrrrr,r.r6rrr>s <'' -  pfyn3%%ckk6:nbq+s))#++|Dq+hE#EPf1$f1R l &fr