ó .„^c@s>dZddlZddlZddlZddlZddlZddlZddlmZejdZ d„Z d„Z de fd„ƒYZ d e fd „ƒYZe ƒZejZejZejZejZejZd efd „ƒYZd ejfd„ƒYZdefd„ƒYZdefd„ƒYZdS(s{ Wrappers around subprocess functionality that simulate an actual shell. .. testsetup:: * from wizard.shell import * iÿÿÿÿN(tutilicCs|ddkp|ddkS(sADetects whether or not an argument list invokes a Python program.itpythontwizard((targs((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyt is_pythonscCsátjƒrdStj|ƒ}|s)dSg}xRtjjƒD]A\}}|jdƒsf|dkr?|jd||fƒq?q?W|tj 7}t j dƒ|rºtj ||dƒntj dddd t|ƒ|ŒdS( sd Checks if we are running as root. If we are, attempt to drop priviledges to the user who owns ``dir``, by re-calling itself using sudo with exec, such that the new process subsumes our current one. If ``log_file`` is passed, the file is chown'ed to the user we are dropping priviledges to, so the subprocess can write to it. NtWIZARD_tSSH_GSSAPI_NAMEs%s=%ssDropping priviledgesiÿÿÿÿtsudos-ut#(tostgetuidRt get_dir_uidtenvirontitemst startswithtappendtsystargvtloggingtdebugtchowntexeclptstr(tdirtlog_filetuidRtktv((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pytdrop_priviledgess   tShellcBskeZdZed„Zd„Zd„Zd„Zd„Zd„Z d„Z d„Z d „Z d „Z RS( sm An advanced shell that performs logging. If ``dry`` is ``True``, no commands are actually run. cCs||_d|_dS(N(tdrytNonetcwd(tselfR((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyt__init__8s c Os4|jƒ|jdtƒ|jdtƒ|jddƒ|jddƒ|jdtjƒ|jdtjƒ|jdtjƒ|jddƒ|jd tƒd d j|ƒd }|drÔ|dtk sä|dtkrôtj |ƒn tj |ƒ|j r|drd SdS|ddkrEt |ƒrEt|d>> sh = Shell() >>> sh.call("echo", "Foobar") ('Foobar\n', '') >>> sh.call("cat", input='Foobar') ('Foobar', '') t interactivetstripRtlogtstdouttstdintstderrtaddenvt close_fdss Running `t t`tiRtinputR tenvs N(NN(!t_waitt setdefaulttFalseRt subprocesstPIPEtTruetjoinRRtinfoRRtlistt wizard_binRR&R'R(tdictR R R tPopenR t_asynct communicatet_logt returncodetPythonCallErrort CallErrorRtrstrip( R!RtkwargstmsgR&R'R(R/R*tprocteclass((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pytcall;sn! *              & 6         cCs8|rtjd|ƒn|r4tjd|ƒndS(s;Logs the standard output and standard input from a command.sSTDOUT: sSTDERR: N(RR(R!R&R(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR>£scCsdS(N((R!((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR0©scOstS(N(R2(R!RRC((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR<«scOsß|jdd ƒ}|jdd ƒ}|jdt|ƒƒ| rX| rX|j||ŽStjdƒr“t|ƒ}|jddtjdƒƒn|r¼|jddd t |ƒ||ŽS|rÛ|jdd|||ŽSd S( s Performs a system call as a different user. This is only possible if you are running as root. Keyword arguments are the same as :meth:`call` with the following additions: :param user: name of the user to run command as. :param uid: uid of the user to run command as. .. note:: The resulting system call internally uses :command:`sudo`, and as such environment variables will get scrubbed. We manually preserve :envvar:`SSH_GSSAPI_NAME`. tuserRRRisSSH_GSSAPI_NAME=Rs-uRN( tpopRR1RRGR tgetenvR8tinsertR(R!RRCRHR((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyt callAsUser­s  #cOsttjƒr|j||ŽStjtjƒƒj}|tjƒkr`||d<|j||ŽS|j||ŽSdS(sà Checks if the owner of the current working directory is the same as the current user, and if it isn't, attempts to sudo to be that user. The intended use case is for calling Git commands when running as root, but this method should be used when interfacing with any moderately complex program that depends on working directory context. Keyword arguments are the same as :meth:`call`. RN(R R RGtstattgetcwdtst_uidtgeteuidRL(R!RRCR((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pytsafeCallÆs  cOst|d<|j||ŽS(s, Evaluates a command and returns its output, with trailing newlines stripped (like backticks in Bash). This is a convenience method for calling :meth:`call` with ``strip``. >>> sh = Shell() >>> sh.eval("echo", "Foobar") 'Foobar' R$(R5RG(R!RRC((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pytevalÙs cCs ||_dS(s— Sets the directory processes are executed in. This sets a value to be passed as the ``cwd`` argument to ``subprocess.Popen``. N(R (R!R ((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pytsetcwdåscCs~tjdƒ}|sd}n|dkr3d}nytj|ddtƒWn*tjk ry}tjd|j ƒnXdS(NtSHELLs /bin/bashs/usr/local/bin/mbashs-iR#s$Shell returned non-zero exit code %d( R RJR!RGR5tshellRARtwarningtcode(t user_shellte((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR#ës  (t__name__t __module__t__doc__R2R"RGR>R0R<RLRQRRRSR#(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR3s  h      t ParallelShellcBsYeZdZedd„Zed„ƒZd„Zd„Zd„Z d„Z d„Z RS( sc Modifies the semantics of :class:`Shell` so that commands are queued here, and executed in parallel using waitpid with ``max`` subprocesses, and result in callback execution when they finish. .. method:: call(*args, **kwargs) Enqueues a system call for parallel processing. If there are no openings in the queue, this will block. Keyword arguments are the same as :meth:`Shell.call` with the following additions: :param on_success: Callback function for success (zero exit status). The callback function should accept two arguments, ``stdout`` and ``stderr``. :param on_error: Callback function for failure (nonzero exit status). The callback function should accept one argument, the exception that would have been thrown by the synchronous version. :return: The :class:`subprocess.Proc` object that was opened. .. method:: callAsUser(*args, **kwargs) Enqueues a system call under a different user for parallel processing. Keyword arguments are the same as :meth:`Shell.callAsUser` with the additions of keyword arguments from :meth:`call`. .. method:: safeCall(*args, **kwargs) Enqueues a "safe" call for parallel processing. Keyword arguments are the same as :meth:`Shell.safeCall` with the additions of keyword arguments from :meth:`call`. .. method:: eval(*args, **kwargs) No difference from :meth:`call`. Consider having a non-parallel shell if the program you are shelling out to is fast. i cCs/tt|ƒjd|ƒi|_||_dS(NR(tsuperR]R"trunningtmax(R!RR`((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR"#s cCs|r tƒStd|ƒSdS(s4Convenience method oriented towards command modules.R`N(tDummyParallelShellR](tno_parallelizeR`((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pytmake'scKs#|||||f|j|jR@RAR?( R!RdtstatusRERRReRfR&R(RF((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyRhLs! cCstdƒ‚dS(Ns*Cannot use interactive() on parallel shell(tError(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR#[s( RZR[R\R2R"t staticmethodRcR<R0R6RhR#(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR]ùs)    RacBseZdZed„ZRS(spSame API as :class:`ParallelShell`, but doesn't actually parallelize (i.e. all calls to :meth:`wait` block.)cCs#tt|ƒjd|ddƒdS(NRR`i(R^RaR"(R!R((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR"is(RZR[R\R2R"(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyRafsRocBseZdZRS(sBase exception for this module(RZR[R\(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyRolsRAcBs8eZdZdZdZdZdZd„Zd„Z RS(s@Indicates that a subprocess call returned a nonzero exit status.cCs(||_||_||_||_dS(N(RWRR&R((R!RWRR&R(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR"zs   cCs3|jjƒjdƒd}d||j|jfS(Ns iÿÿÿÿs%s (exited with %d) %s(R(RBtsplitRW(R!tcompact((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyt__str__sN( RZR[R\RRWRR&R(R"Rs(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyRAps R@cBs&eZdZdZd„Zd„ZRS(s“ Indicates that a Python subprocess call had an uncaught exception. This exception also contains the attributes of :class:`CallError`. cCs8|rtj|ƒ|_ntj|||||ƒdS(N(Rtget_exception_nametnameRAR"(R!RWRR&R(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR"ŠscCs,|jrd|j|jfSd|jSdS(NsPythonCallError [%s] %ssPythonCallError %s(RuR((R!((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyRss N(RZR[R\RRuR"Rs(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyR@ƒs (R\R3RRR RkRRRR9RRtobjectRR]RURGRLRQRRR#RaRoRAR@(((s:/afs/athena.mit.edu/contrib/scripts/wizard/wizard/shell.pyts,         Æf