j4Vdc@s+dZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z m Z ddlmZmZmZmZmZddlmZmZddlmZmZmZdd lmZdd lm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/d Z0de1fdYZ2de3fdYZ4dZ5ddddZ7edde8e8de9ddZ:ede8ddZ;dZ<ddZ=e9ddZ>dZ?e8dZ@e9de8dddddZAeddZBe dZCe9e9e9e8de8e8ddddddd ZDee9e9de8e8dddddd ZEee9e9dde8e8ddddddd! ZFe8dd"ZGed#d$e9d%ZHdS(&sR Functions to be used in fabfiles and other non-core code, such as run()/sudo(). i(twith_statementN(tglob(tclosingtcontextmanager(tsettingst char_bufferedthidetquiett warn_only(t output_loopt input_loop(t needs_hosttssht ssh_config(tSFTP(tenvt connectionstoutputtwin32tdefault_channel(t ThreadHandler(tabortterrorthandle_prompt_aborttindentt _pty_sizetwarnt apply_lcwdt RingBuffercCs+x$dD]}|j|d|}qW|S(s Escape double quotes, backticks and dollar signs in given ``string``. For example:: >>> _shell_escape('abc$') 'abc\\$' >>> _shell_escape('"') '\\"' t"t$t`s\%s(RRR(treplace(tstringtchar((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt _shell_escapes t_AttributeStringcBseZdZedZRS(sE Simple string subclass to allow arbitrary attribute access. cCs t|S(N(tstr(tself((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pytstdout3s(t__name__t __module__t__doc__tpropertyR'(((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyR$/st_AttributeListcBseZdZRS(s/ Like _AttributeString, but for lists. (R(R)R*(((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyR,8sc OsPtd|}|sdSt|dkr=d}d}n d}d}dtkred tj}nd }d ||t|f}d |kr|d ||d f7}nd|krB|d}t|ds|g}nt|dkrd}nd}d} g|D]} | | ^q } |d|t| f7}nt|dS(s Check for given keys in the shared environment dict and abort if not found. Positional arguments should be strings signifying what env vars should be checked for. If any of the given arguments do not exist, Fabric will abort execution and print the names of the missing keys. The optional keyword argument ``used_for`` may be a string, which will be printed in the error output to inform users why this requirement is in place. ``used_for`` is printed as part of a string similar to:: "Th(is|ese) variable(s) (are|is) used for %s" so format it appropriately. The optional keyword argument ``provided_by`` may be a list of functions or function names or a single function or function name which the user should be able to execute in order to set the key or keys; it will be included in the error output if requirements are not met. Note: it is assumed that the keyword arguments apply to all given keys as a group. If you feel the need to specify more than one ``used_for``, for example, you should break your logic into multiple calls to ``require()``. .. versionchanged:: 1.1 Allow iterable ``provided_by`` values instead of just single values. cSs@|tkp?|tko?tt|ttttfo?t| S(N(Rt isinstancetdicttlistttupletset(tx((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt^sNisvariables weresThese variables ares variable wassThis variable istcommands$The command '%s' failed because the sThe s3%sfollowing required environment %s not defined: %stused_fors %s used for %st provided_byt__iter__sone of the following commandssthe following commandcSst|dt|S(NR((tgetattrR%(tobj((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyR3ts: Try running %s prior to this one, to fix the problem: %s(tfiltertlenRR4RthasattrR( tkeystkwargst missing_keystvariabletusedtprefixtmsgtfuncsR4tto_sR9R6((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pytrequireAs8          R:c Cstd|r"tj|}nd}|dkrMdt|j}nd}|j|}d }x|d krPt|p|}|rlt|ry||}WqJtk r}d }dGHt |j dGHqJXqM|j dsd|}n|j ds|d7}nt j||} | sMd ||fGHd }qMqlqlW|rd|t|`` in addition to being returned by `prompt`. If the key already existed in ``env``, its value will be overwritten and a warning printed to the user. If ``default`` is given, it is displayed in square brackets and used if the user enters nothing (i.e. presses Enter without entering any text). ``default`` defaults to the empty string. If non-empty, a space will be appended, so that a call such as ``prompt("What hostname?", default="foo")`` would result in a prompt of ``What hostname? [foo]`` (with a trailing space after the ``[foo]``.) The optional keyword argument ``validate`` may be a callable or a string: * If a callable, it is called with the user's input, and should return the value to be stored on success. On failure, it should raise an exception with an exception message, which will be printed to the user. * If a string, the value passed to ``validate`` is used as a regular expression. It is thus recommended to use raw strings in this case. Note that the regular expression, if it is not fully matching (bounded by ``^`` and ``$``) it will be made so. In other words, the input must fully match the regex. Either way, `prompt` will re-prompt until validation passes (or the user hits ``Ctrl-C``). .. note:: `~fabric.operations.prompt` honors :ref:`env.abort_on_prompts ` and will call `~fabric.utils.abort` instead of prompting if that flag is set to ``True``. If you want to block on user input regardless, try wrapping with `~fabric.context_managers.settings`. Examples:: # Simplest form: environment = prompt('Please specify target environment: ') # With default, and storing as env.dish: prompt('Specify favorite dish: ', 'dish', default='spam & eggs') # With validation, i.e. requiring integer input: prompt('Please specify process nice level: ', key='nice', validate=int) # With validation against a regular expression: release = prompt('Please supply a release name', validate=r'^\w+-\d+(\.\d+)?$') # Prompt regardless of the global abort-on-prompts setting: with settings(abort_on_prompts=False): prompt('I seriously need an answer on this! ') sa user-specified prompt() callR:s [%s] t s+Validation failed for the following reason:s t^Rs?Regular expression validation failed: '%s' does not match '%s' sCoverwrote previous env variable '%s'; used to be '%s', is now '%s'.N(RRtgetR%tstriptNonet raw_inputtcallablet ExceptionRtmessaget startswithtendswithtretfindallR( ttexttkeytdefaulttvalidatetprevious_valuet default_strt prompt_strtvaluetetresult((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pytpromptsB<      c Cs|ptj}t|do-t|j }ttj}t|t}|j d} |pg| }|j dr|j d| d}ntj j | rtjdrtjjdd|}n|r3tj j|}t|t}|r t|} q<tj j|r*|g} q<g} n |g} |rb| rbd|} t| n|j|r|rt| dkr|j| rtd|qng} g} x| D]}yx|rtj j|r|j||||||}| j|n.|j|||||||}| j|Wqtk r}d }|rd|nd }| j|td ||d |qXqWt| }| |_|j |_ |SWd QXd S(s  Upload one or more files to a remote host. As with the OpenSSH ``sftp`` program, `.put` will overwrite pre-existing remote files without requesting confirmation. `~fabric.operations.put` returns an iterable containing the absolute file paths of all remote files uploaded. This iterable also exhibits a ``.failed`` attribute containing any local file paths which failed to upload (and may thus be used as a boolean test.) You may also check ``.succeeded`` which is equivalent to ``not .failed``. ``local_path`` may be a relative or absolute local file or directory path, and may contain shell-style wildcards, as understood by the Python ``glob`` module (give ``use_glob=False`` to disable this behavior). Tilde expansion (as implemented by ``os.path.expanduser``) is also performed. ``local_path`` may alternately be a file-like object, such as the result of ``open('path')`` or a ``StringIO`` instance. .. note:: In this case, `~fabric.operations.put` will attempt to read the entire contents of the file-like object by rewinding it using ``seek`` (and will use ``tell`` afterwards to preserve the previous file position). ``remote_path`` may also be a relative or absolute location, but applied to the remote host. Relative paths are relative to the remote user's home directory, but tilde expansion (e.g. ``~/.ssh/``) will also be performed if necessary. An empty string, in either path argument, will be replaced by the appropriate end's current working directory. While the SFTP protocol (which `put` uses) has no direct ability to upload files to locations not owned by the connecting user, you may specify ``use_sudo=True`` to work around this. When set, this setting causes `put` to upload the local files to a temporary location on the remote end (defaults to remote user's ``$HOME``; this may be overridden via ``temp_dir``), and then use `sudo` to move them to ``remote_path``. In some use cases, it is desirable to force a newly uploaded file to match the mode of its local counterpart (such as when uploading executable scripts). To do this, specify ``mirror_local_mode=True``. Alternately, you may use the ``mode`` kwarg to specify an exact mode, in the same vein as ``os.chmod``, such as an exact octal number (``0755``) or a string representing one (``"0755"``). `~fabric.operations.put` will honor `~fabric.context_managers.cd`, so relative values in ``remote_path`` will be prepended by the current remote working directory, if applicable. Thus, for example, the below snippet would attempt to upload to ``/tmp/files/test.txt`` instead of ``~/files/test.txt``:: with cd('/tmp'): put('/path/to/local/test.txt', 'files') Use of `~fabric.context_managers.lcd` will affect ``local_path`` in the same manner. Examples:: put('bin/project.zip', '/tmp/project.zip') put('*.py', 'cgi-bin/') put('index.html', 'index.html', mode=0755) .. note:: If a file-like object such as StringIO has a ``name`` attribute, that will be used in Fabric's printed output instead of the default ```` .. versionchanged:: 1.0 Now honors the remote working directory as manipulated by `~fabric.context_managers.cd`, and the local working directory as manipulated by `~fabric.context_managers.lcd`. .. versionchanged:: 1.0 Now allows file-like objects in the ``local_path`` argument. .. versionchanged:: 1.0 Directories may be specified in the ``local_path`` argument and will trigger recursive uploads. .. versionchanged:: 1.0 Return value is now an iterable of uploaded remote file paths which also exhibits the ``.failed`` and ``.succeeded`` attributes. .. versionchanged:: 1.5 Allow a ``name`` attribute on file-like objects for log output .. versionchanged:: 1.7 Added ``use_glob`` option to allow disabling of globbing. treadt.t~itcwdt/s''%s' is not a valid local path or glob.s'%s' is not a directorys3put() encountered an exception while uploading '%s's RPt exceptionN(!tostgetcwdR=RNR`RRt host_stringRt normalizeRQR tpathtisabsRJRctrstript expanduserRRtexistst ValueErrorR<tisdirtput_dirtextendtputtappendRORR,tfailedt succeeded(t local_patht remote_pathtuse_sudotmirror_local_modetmodetuse_globttemp_dirt local_is_pathtftpthometnamesterrt remote_pathstfailed_local_pathstlpathtpR]RDtfailuretret((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyRss\[ "     (     c Cs|p d}t|do't|j }|rCt|t}nttj}t|W}|jd}|j dr|j d|d}n|rt j j |}nt j j|stjdrtjjd}|j dd }|d|}qtj||}ng}g} y|j|sSd |ksSd |kre|j|} n |g} |st| dks|j| d rtd tj|fqnx| D]}}|j|r|j||||} |j| q|j||||t j j||} |r|j| qqWWn=tk r~} | j|d} td| |d| nXt|r|ng}| |_|j |_|SWdQXdS(s Download one or more files from a remote host. `~fabric.operations.get` returns an iterable containing the absolute paths to all local files downloaded, which will be empty if ``local_path`` was a StringIO object (see below for more on using StringIO). This object will also exhibit a ``.failed`` attribute containing any remote file paths which failed to download, and a ``.succeeded`` attribute equivalent to ``not .failed``. ``remote_path`` is the remote file or directory path to download, which may contain shell glob syntax, e.g. ``"/var/log/apache2/*.log"``, and will have tildes replaced by the remote home directory. Relative paths will be considered relative to the remote user's home directory, or the current remote working directory as manipulated by `~fabric.context_managers.cd`. If the remote path points to a directory, that directory will be downloaded recursively. ``local_path`` is the local file path where the downloaded file or files will be stored. If relative, it will honor the local current working directory as manipulated by `~fabric.context_managers.lcd`. It may be interpolated, using standard Python dict-based interpolation, with the following variables: * ``host``: The value of ``env.host_string``, eg ``myhostname`` or ``user@myhostname-222`` (the colon between hostname and port is turned into a dash to maximize filesystem compatibility) * ``dirname``: The directory part of the remote file path, e.g. the ``src/projectname`` in ``src/projectname/utils.py``. * ``basename``: The filename part of the remote file path, e.g. the ``utils.py`` in ``src/projectname/utils.py`` * ``path``: The full remote path, e.g. ``src/projectname/utils.py``. While the SFTP protocol (which `get` uses) has no direct ability to download files from locations not owned by the connecting user, you may specify ``use_sudo=True`` to work around this. When set, this setting allows `get` to copy (using sudo) the remote files to a temporary location on the remote end (defaults to remote user's ``$HOME``; this may be overridden via ``temp_dir``), and then download them to ``local_path``. .. note:: When ``remote_path`` is an absolute directory path, only the inner directories will be recreated locally and passed into the above variables. So for example, ``get('/var/log', '%(path)s')`` would start writing out files like ``apache2/access.log``, ``postgresql/8.4/postgresql.log``, etc, in the local working directory. It would **not** write out e.g. ``var/log/apache2/access.log``. Additionally, when downloading a single file, ``%(dirname)s`` and ``%(path)s`` do not make as much sense and will be empty and equivalent to ``%(basename)s``, respectively. Thus a call like ``get('/var/log/apache2/access.log', '%(path)s')`` will save a local file named ``access.log``, not ``var/log/apache2/access.log``. This behavior is intended to be consistent with the command-line ``scp`` program. If left blank, ``local_path`` defaults to ``"%(host)s/%(path)s"`` in order to be safe for multi-host invocations. .. warning:: If your ``local_path`` argument does not contain ``%(host)s`` and your `~fabric.operations.get` call runs against multiple hosts, your local files will be overwritten on each successive run! If ``local_path`` does not make use of the above variables (i.e. if it is a simple, explicit file path) it will act similar to ``scp`` or ``cp``, overwriting pre-existing files if necessary, downloading into a directory if given (e.g. ``get('/path/to/remote_file.txt', 'local_directory')`` will create ``local_directory/remote_file.txt``) and so forth. ``local_path`` may alternately be a file-like object, such as the result of ``open('path', 'w')`` or a ``StringIO`` instance. .. note:: Attempting to `get` a directory into a file-like object is not valid and will result in an error. .. note:: This function will use ``seek`` and ``tell`` to overwrite the entire contents of the file-like object, in order to be consistent with the behavior of `~fabric.operations.put` (which also considers the entire file). However, unlike `~fabric.operations.put`, the file pointer will not be restored to its previous location, as that doesn't make as much sense here and/or may not even be possible. .. note:: If a file-like object such as StringIO has a ``name`` attribute, that will be used in Fabric's printed output instead of the default ```` .. versionchanged:: 1.0 Now honors the remote working directory as manipulated by `~fabric.context_managers.cd`, and the local working directory as manipulated by `~fabric.context_managers.lcd`. .. versionchanged:: 1.0 Now allows file-like objects in the ``local_path`` argument. .. versionchanged:: 1.0 ``local_path`` may now contain interpolated path- and host-related variables. .. versionchanged:: 1.0 Directories may be specified in the ``remote_path`` argument and will trigger recursive downloads. .. versionchanged:: 1.0 Return value is now an iterable of downloaded local file paths, which also exhibits the ``.failed`` and ``.succeeded`` attributes. .. versionchanged:: 1.5 Allow a ``name`` attribute on file-like objects for log output s%(host)s/%(path)stwriteRaRbiRcRds\ RHt*t?is@[%s] %s is a glob or directory, but local_path is a file object!s5get() encountered an exception while downloading '%s'RPReN( R=RNRRRRRhRRiRQR RfRjRmRkRJRcRlt posixpathtjoinRpRR<Rtget_dirRrtbasenameRtROR,RuRv(RxRwRyR}R~RRtremote_path_escapedt local_filestfailed_remote_filesRR^R]RDR((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyRJsVp  % *   cCs=|dkrdSt|jr/d|}nd||fS(NR:s#%ss %s "%s"(RLR%tisdigit(targumentR\((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt_sudo_prefix_argumentVs   cCsLtjt}|dk s%|dk rHd|td|td|fS|S(sS Return ``env.sudo_prefix`` with ``user``/``group`` inserted if necessary. s%s%s%s s-us-gN(Rt sudo_prefixRLR(tusertgroupRC((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt _sudo_prefix^s   cCs|rtj rt}n|dkr.d}n |d7}|rmtjd}|r`t|}nd|}nd}|||S(sN Conditionally wrap given command in env.shell (while honoring sudo.) R:RHs"%s"N(Rt use_shelltFalseRLtshellR#(R4t shell_escapeRR((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt _shell_wrapks      cCsttj}|dkr$tjntj}ts9dnd}|rb|jdd||fnd}|r|j||nd}||S(s Prefixes ``command`` with all prefixes found in ``env.command_prefixes``. ``env.command_prefixes`` is a list of strings which is modified by the `~fabric.context_managers.prefix` context manager. This function also handles a special-case prefix, ``cwd``, used by `~fabric.context_managers.cd`. The ``which`` kwarg should be a string, ``"local"`` or ``"remote"``, which will determine whether ``cwd`` or ``lcwd`` is used. tremotes >/dev/nullR:iscd %s%ss && (R/Rtcommand_prefixesRctlcwdRtinsertR(R4twhichtprefixesRctredirecttglueRC((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt_prefix_commandss csi}tj}|rvtjdkr1d|}n8tjdkrMd|}ntjdkrid|}n||dss%s%s && (R:R:(RRjt path_behaviortupdatet shell_envRRt iteritems(R4tlocaltenv_varsRjtexp_cmdtexportst shell_env_str((Rs_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt_prefix_env_varss,          c Cs|p tj}|ptj}|dkr3tjn|}tj} ttj.|dkrjtj }n|j |t } | r| stj rt } n| rt\} } |jd| d| ntjddjdk} d}tjs| rtjj|}n|rD|j|rT|j|dqTn|jd|tdgd |}tdgd |}|rd}}ntd t|d d |d |d|tdt|dd |d |d|tdt|| f}| dkr|} n| r| rt } nxvt r|jr5Pnx|D]}|jq<Wyt j!tj"Wqt#k r| sn|j$dqXqW|j%}x%|D]}|j&j'|jqW|j(|dk r|j(n|sdj'|j)}dj'|j)}nt*j+rGt*jrG|rG|j,d sft*jrn|rn|j,d rndGHn|||fSWdQXdS(s Execute ``command`` over ``channel``. ``pty`` controls whether a pseudo-terminal is created. ``combine_stderr`` controls whether we call ``channel.set_combine_stderr``. By default, the global setting for this behavior (:ref:`env.combine_stderr `) is consulted, but you may specify ``True`` or ``False`` here to override it. ``invoke_shell`` controls whether we use ``exec_command`` or ``invoke_shell`` (plus a handful of other things, such as always forcing a pty.) ``capture_buffer_size`` controls the length of the ring-buffers used to capture stdout/stderr. (This is ignored if ``invoke_shell=True``, since that completely disables capturing overall.) Returns a three-tuple of (``stdout``, ``stderr``, ``status``), where ``stdout``/``stderr`` are captured output strings and ``status`` is the program's return code, if applicable. twidththeightt forwardagenttnotyess R4R\tmaxlentouttrecvtcapturetstreamttimeoutRt recv_stderrtinsR:N(-tsysR'tstderrRLRtcommand_timeouttremote_interruptRtstdintcombine_stderrtset_combine_stderrtTruetalways_use_ptyRRtget_ptyR RJtlowert forward_agentR tagenttAgentRequestHandlert invoke_shelltsendallt exec_commandRRR R texit_status_readytraise_if_neededttimetsleeptio_sleeptKeyboardInterrupttsendtrecv_exit_statustthreadRtcloseRKRtrunningRR(tchannelR4tptyRRR'RRtcapture_buffer_sizeRt using_ptytrowstcolst config_agenttforwardt stdout_buft stderr_buftworkerstworkertstatus((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt_executes|     !                 c Cs,tdtd|dtdtdtdS(s9 Invoke a fully interactive shell on the remote end. If ``command`` is given, it will be sent down the pipe before handing control over to the invoking user. This function is most useful for when you need to interact with a heavily shell-based command or series of commands, such as when debugging or when fully interactive recovery is required upon remote program failure. It should be considered an easy way to work an interactive shell session into the middle of a Fabric script and is *not* a drop-in replacement for `~fabric.operations.run`, which is also capable of interacting with the remote end (albeit only while its given command is executing) and has much stronger programmatic abilities such as error handling and stdout/stderr capture. Specifically, `~fabric.operations.open_shell` provides a better interactive experience than `~fabric.operations.run`, but use of a full remote shell prevents Fabric from determining whether programs run within the shell have failed, and pollutes the stdout/stderr stream with shell output such as login banners, prompts and echoed stdin. Thus, this function does not have a return value and will not trigger Fabric's failure handling if any remote programs result in errors. .. versionadded:: 1.0 RR4RRRN(RRR(R4((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt open_shellTsccs dVdS(N((((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt_noopvscCst}|rt}n|r$t}n||}| dkrUtjdt} nttt |d| ||rt || nd}|rdnd}t j rdtj ||fGHn!t jrdtj ||fGHntdtd|d|d |d td |d | d | d| \}}}t|}t|}t|_||_||_|tjkrt|_d||f}tjr|d|7}n|d||f7}td|d |d |n||_|j |_||_|SWdQXdS(sP Underpinnings of `run` and `sudo`. See their docstrings for more info. RRtsudotruns [%s] %s: %sRR4RRRR'RRRs4%s() received nonzero return code %s while executings '%s'!s! Requested: %s Executed: %sRPN(Rtwarn_only_managert quiet_managerRLRRJRRRRRRtdebugRhRRRRR$RuR4t real_commandt ok_ret_codesRRt return_codeRvR(R4RRRRRRRR'RRRRRtmanagert given_commandtwrapped_commandRt result_stdoutt result_stderrRRRRD((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyt _run_command{sT                  c Cs=t||||d|d|d|d|d|d| d| S(s Run a shell command on a remote host. If ``shell`` is True (the default), `run` will execute the given command string via a shell interpreter, the value of which may be controlled by setting ``env.shell`` (defaulting to something similar to ``/bin/bash -l -c ""``.) Any double-quote (``"``) or dollar-sign (``$``) characters in ``command`` will be automatically escaped when ``shell`` is True (unless disabled by setting ``shell_escape=False``). When ``shell=False``, no shell wrapping or escaping will occur. (It's possible to specify ``shell=False, shell_escape=True`` if desired, which will still trigger escaping of dollar signs, etc but will not wrap with a shell program invocation). `run` will return the result of the remote program's stdout as a single (likely multiline) string. This string will exhibit ``failed`` and ``succeeded`` boolean attributes specifying whether the command failed or succeeded, and will also include the return code as the ``return_code`` attribute. Furthermore, it includes a copy of the requested & actual command strings executed, as ``.command`` and ``.real_command``, respectively. To lessen memory use when running extremely verbose programs (and, naturally, when having access to their full output afterwards is not necessary!) you may limit how much of the program's stdout/err is stored by setting ``capture_buffer_size`` to an integer value. .. warning:: Do not set ``capture_buffer_size`` to any value smaller than the length of ``env.sudo_prompt`` or you will likely break the functionality of `sudo`! Ditto any user prompts stored in ``env.prompts``. .. note:: This value is used for each buffer independently, so e.g. ``1024`` may result in storing a total of ``2048`` bytes if there's data in both streams.) Any text entered in your local terminal will be forwarded to the remote program as it runs, thus allowing you to interact with password or other prompts naturally. For more on how this works, see :doc:`/usage/interactivity`. You may pass ``pty=False`` to forego creation of a pseudo-terminal on the remote end in case the presence of one causes problems for the command in question. However, this will force Fabric itself to echo any and all input you type while the command is running, including sensitive passwords. (With ``pty=True``, the remote pseudo-terminal will echo for you, and will intelligently handle password-style prompts.) See :ref:`pseudottys` for details. Similarly, if you need to programmatically examine the stderr stream of the remote program (exhibited as the ``stderr`` attribute on this function's return value), you may set ``combine_stderr=False``. Doing so has a high chance of causing garbled output to appear on your terminal (though the resulting strings returned by `~fabric.operations.run` will be properly separated). For more info, please read :ref:`combine_streams`. To ignore non-zero return codes, specify ``warn_only=True``. To both ignore non-zero return codes *and* force a command to run silently, specify ``quiet=True``. To override which local streams are used to display remote stdout and/or stderr, specify ``stdout`` or ``stderr``. (By default, the regular ``sys.stdout`` and ``sys.stderr`` Python stream objects are used.) For example, ``run("command", stderr=sys.stdout)`` would print the remote standard error to the local standard out, while preserving it as its own distinct attribute on the return value (as per above.) Alternately, you could even provide your own stream objects or loggers, e.g. ``myout = StringIO(); run("command", stdout=myout)``. If you want an exception raised when the remote program takes too long to run, specify ``timeout=N`` where ``N`` is an integer number of seconds, after which to time out. This will cause ``run`` to raise a `~fabric.exceptions.CommandTimeout` exception. If you want to disable Fabric's automatic attempts at escaping quotes, dollar signs etc., specify ``shell_escape=False``. Examples:: run("ls /var/www/") run("ls /home/myuser", shell=False) output = run('ls /var/www/site1') run("take_a_long_time", timeout=5) .. versionadded:: 1.0 The ``succeeded`` and ``stderr`` return value attributes, the ``combine_stderr`` kwarg, and interactive behavior. .. versionchanged:: 1.0 The default value of ``pty`` is now ``True``. .. versionchanged:: 1.0.2 The default value of ``combine_stderr`` is now ``None`` instead of ``True``. However, the default *behavior* is unchanged, as the global setting is still ``True``. .. versionadded:: 1.5 The ``quiet``, ``warn_only``, ``stdout`` and ``stderr`` kwargs. .. versionadded:: 1.5 The return value attributes ``.command`` and ``.real_command``. .. versionadded:: 1.6 The ``timeout`` argument. .. versionadded:: 1.7 The ``shell_escape`` argument. .. versionadded:: 1.11 The ``capture_buffer_size`` argument. RRR'RRRR(R( R4RRRRRR'RRRR((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyRsvc Cs^t||||dtd|r$|ntjd| d|d|d|d|d| d | d |  S( sy Run a shell command on a remote host, with superuser privileges. `sudo` is identical in every way to `run`, except that it will always wrap the given ``command`` in a call to the ``sudo`` program to provide superuser privileges. `sudo` accepts additional ``user`` and ``group`` arguments, which are passed to ``sudo`` and allow you to run as some user and/or group other than root. On most systems, the ``sudo`` program can take a string username/group or an integer userid/groupid (uid/gid); ``user`` and ``group`` may likewise be strings or integers. You may set :ref:`env.sudo_user ` at module level or via `~fabric.context_managers.settings` if you want multiple ``sudo`` calls to have the same ``user`` value. An explicit ``user`` argument will, of course, override this global setting. Examples:: sudo("~/install_script.py") sudo("mkdir /var/www/new_docroot", user="www-data") sudo("ls /home/jdoe", user=1001) result = sudo("ls /tmp/") with settings(sudo_user='mysql'): sudo("whoami") # prints 'mysql' .. versionchanged:: 1.0 See the changed and added notes for `~fabric.operations.run`. .. versionchanged:: 1.5 Now honors :ref:`env.sudo_user `. .. versionadded:: 1.5 The ``quiet``, ``warn_only``, ``stdout`` and ``stderr`` kwargs. .. versionadded:: 1.5 The return value attributes ``.command`` and ``.real_command``. .. versionadded:: 1.7 The ``shell_escape`` argument. .. versionadded:: 1.11 The ``capture_buffer_size`` argument. RRRRRR'RRRR(RRRt sudo_user( R4RRRRRRR'RRRRR((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyRDs 1c Cs|}t|dt}t|d}tjr<d|GHntjrQd|GHnd }|rrtj}tj}n<t t j d}tj rd n|}tj rd n|}zYtr|n|g} tj| dtd|d|d|d t } | j\} } Wd |d k r#|jnXt| r9| jnd } t| rW| jnd }|| _|| _t| _| j| _|| _ | jtjkrt| _d | j|f}td |d| d|n| j | _| S(s Run a command on the local system. `local` is simply a convenience wrapper around the use of the builtin Python ``subprocess`` module with ``shell=True`` activated. If you need to do anything special, consider using the ``subprocess`` module directly. ``shell`` is passed directly to `subprocess.Popen `_'s ``execute`` argument (which determines the local shell to use.) As per the linked documentation, on Unix the default behavior is to use ``/bin/sh``, so this option is useful for setting that value to e.g. ``/bin/bash``. `local` is not currently capable of simultaneously printing and capturing output, as `~fabric.operations.run`/`~fabric.operations.sudo` do. The ``capture`` kwarg allows you to switch between printing and capturing as necessary, and defaults to ``False``. When ``capture=False``, the local subprocess' stdout and stderr streams are hooked up directly to your terminal, though you may use the global :doc:`output controls ` ``output.stdout`` and ``output.stderr`` to hide one or both if desired. In this mode, the return value's stdout/stderr values are always empty. When ``capture=True``, you will not see any output from the subprocess in your terminal, but the return value will contain the captured stdout/stderr. In either case, as with `~fabric.operations.run` and `~fabric.operations.sudo`, this return value exhibits the ``return_code``, ``stderr``, ``failed``, ``succeeded``, ``command`` and ``real_command`` attributes. See `run` for details. `~fabric.operations.local` will honor the `~fabric.context_managers.lcd` context manager, allowing you to control its current working directory independently of the remote end (which honors `~fabric.context_managers.cd`). .. versionchanged:: 1.0 Added the ``succeeded`` and ``stderr`` attributes. .. versionchanged:: 1.0 Now honors the `~fabric.context_managers.lcd` context manager. .. versionchanged:: 1.0 Changed the default value of ``capture`` from ``True`` to ``False``. .. versionadded:: 1.9 The return value attributes ``.command`` and ``.real_command``. Rs[localhost] local: %ss[localhost] local: sw+RR'Rt executablet close_fdsNR:sBlocal() encountered an error (return code %s) while executing '%s'RP(RRRRRRRLt subprocesstPIPEtopenRftdevnullR'RRtPopent communicateRR$RKR4RRRut returncodeRRRRRv(R4RRRtwith_envRtdev_nullt out_streamt err_streamtcmd_argRR'RRRRD((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyR~sF0                ixtrebootcCsd}ttt|t|}ttdd|d|8|rStnt|tjdt j t j WdQXdS(sq Reboot the remote system. Will temporarily tweak Fabric's reconnection settings (:ref:`timeout` and :ref:`connection-attempts`) to ensure that reconnection does not give up for at least ``wait`` seconds. .. note:: As of Fabric 1.4, the ability to reconnect partway through a session no longer requires use of internal APIs. While we are not officially deprecating this function, adding more features to it will not be a priority. Users who want greater control are encouraged to check out this function's (6 lines long, well commented) source code and write their own adaptation using different timeout/attempt values or additional logic. .. versionadded:: 0.9.2 .. versionchanged:: 1.4 Changed the ``wait`` kwarg to be optional, and refactored to leverage the new reconnection functionality; it may not actually have to wait for ``wait`` seconds before reconnecting. .. versionchanged:: 1.11 Added ``use_sudo`` as a kwarg. Maintained old functionality by setting the default value to True. iRRtconnection_attemptsN( tinttroundtfloatRRRRRRRtconnectRRh(twaitR4RyRtattempts((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pyRs"   (IR*t __future__RRftos.pathRRSRRRRt contextlibRRtfabric.context_managersRRRRRRRt fabric.ioR R tfabric.networkR R R t fabric.sftpRt fabric.stateRRRRRtfabric.thread_handlingRt fabric.utilsRRRRRRRRR#R%R$R/R,RGRLR_RRRsRJRRRRRRRRRRRRR(((s_/var/www/html/phendo-backend/phendo_python/env/lib/python2.7/site-packages/fabric/operations.pytsj       ((:   Er     .  !   I z 7]