Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/fabric/__pycache__/context_managers.cpython-39.pyc
Ðазад
a {�h Q � @ sP d Z ddlmZ ddlZddlZddlZddlmZ ddlm Z m Z m Z m Z ddl mZ ddlmZ ejdu r|dd lmZ n dd lmZ G d d � d e�Ze s�ddlZddlZd d� Zdd� Zedd� �Zedd� �Zedd� �Zdd� Zdd� Z dd � Z d d � Z d2d d!�Z d"d#� Z ed$d%� �Z!d&d'� Z"d(d)� Z#ed3d,d-��Z$d.d/� Z%d0d1� Z&dS )4aJ Context managers for use with the ``with`` statement. .. note:: If you are using multiple directly nested ``with`` statements, it can be convenient to use multiple context expressions in one single with statement. Instead of writing:: with cd('/path/to/app'): with prefix('workon myvenv'): run('./manage.py syncdb') run('./manage.py loaddata myfixture') you can write:: with cd('/path/to/app'), prefix('workon myvenv'): run('./manage.py syncdb') run('./manage.py loaddata myfixture') � )�contextmanagerN)� ThreadHandler)�output�win32� connections�env)�state)�isattyT)�nested)� ExitStackc s e Zd Z� fdd�Z� ZS )r c s& t t| ��� |D ]}| �|� qd S �N)�superr �__init__� enter_context)�self�managers�manager�� __class__� ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/fabric/context_managers.pyr % s znested.__init__)�__name__� __module__� __qualname__r � __classcell__r r r r r $ s r c c sN i }z8t �| �D ]}t | ||< |t |< qdV W t �|� n t �|� 0 dS )z> Refactored subroutine used by ``hide`` and ``show``. N)r Zexpand_aliases�update)�groups�which�previous�groupr r r � _set_output0 s r c C s t | �}| |_|S r )r Z undecorated)�func�wrapperr r r �documented_contextmanagerA s r# c G s t | d�S )a� Context manager for setting the given output ``groups`` to True. ``groups`` must be one or more strings naming the output groups defined in `~fabric.state.output`. The given groups will be set to True for the duration of the enclosed block, and restored to their previous value afterwards. For example, to turn on debug output (which is typically off by default):: def my_task(): with show('debug'): run('ls /var/www') As almost all output groups are displayed by default, `show` is most useful for turning on the normally-hidden ``debug`` group, or when you know or suspect that code calling your own code is trying to hide output with `hide`. T�r �r r r r �showG s r& c G s t | d�S )aH Context manager for setting the given output ``groups`` to False. ``groups`` must be one or more strings naming the output groups defined in `~fabric.state.output`. The given groups will be set to False for the duration of the enclosed block, and restored to their previous value afterwards. For example, to hide the "[hostname] run:" status lines, as well as preventing printout of stdout and stderr, one might use `hide` as follows:: def my_task(): with hide('running', 'stdout', 'stderr'): run('ls /var/www') Fr$ r% r r r �hide_ s r' c c s\ t | �r| � } | �dd�}i }g }t�| �D ]6\}}|tjv rNtj| ||< n |�|� |tj|< q,zzdV W |r�t�| �D ]@\}}|tjv r||tj| kr|||v r�|| tj|< q|tj|= q|n tj�|� |D ] }tj|= q�nx|�r6t�| �D ]B\}}|tjv r�|tj| kr�||v �r*|| tj|< q�tj|= q�n tj�|� |D ]}tj|= �qF0 dS )a� Context manager temporarily overriding ``env`` with given key/value pairs. A callable that returns a dict can also be passed. This is necessary when new values are being calculated from current values, in order to ensure that the "current" value is current at the time that the context is entered, not when the context manager is initialized. (See Issue #736.) This context manager is used internally by `settings` and is not intended to be used directly. � clean_revertFN)�callable�pop�six� iteritemsr r �appendr )� variablesr( r �new�key�valuer r r �_setenvs s< � r2 c O s" t | �}|r|�t|�� t|� S )a� Nest context managers and/or override ``env`` variables. `settings` serves two purposes: * Most usefully, it allows temporary overriding/updating of ``env`` with any provided keyword arguments, e.g. ``with settings(user='foo'):``. Original values, if any, will be restored once the ``with`` block closes. * The keyword argument ``clean_revert`` has special meaning for ``settings`` itself (see below) and will be stripped out before execution. * In addition, it will use `contextlib.nested`_ to nest any given non-keyword arguments, which should be other context managers, e.g. ``with settings(hide('stderr'), show('stdout')):``. .. _contextlib.nested: http://docs.python.org/library/contextlib.html#contextlib.nested These behaviors may be specified at the same time if desired. An example will hopefully illustrate why this is considered useful:: def my_task(): with settings( hide('warnings', 'running', 'stdout', 'stderr'), warn_only=True ): if run('ls /etc/lsb-release'): return 'Ubuntu' elif run('ls /etc/redhat-release'): return 'RedHat' The above task executes a `run` statement, but will warn instead of aborting if the ``ls`` fails, and all output -- including the warning itself -- is prevented from printing to the user. The end result, in this scenario, is a completely silent task that allows the caller to figure out what type of system the remote host is, without incurring the handful of output that would normally occur. Thus, `settings` may be used to set any combination of environment variables in tandem with hiding (or showing) specific levels of output, or in tandem with any other piece of Fabric functionality implemented as a context manager. If ``clean_revert`` is set to ``True``, ``settings`` will **not** revert keys which are altered within the nested block, instead only reverting keys whose values remain the same as those given. More examples will make this clear; below is how ``settings`` operates normally:: # Before the block, env.parallel defaults to False, host_string to None with settings(parallel=True, host_string='myhost'): # env.parallel is True # env.host_string is 'myhost' env.host_string = 'otherhost' # env.host_string is now 'otherhost' # Outside the block: # * env.parallel is False again # * env.host_string is None again The internal modification of ``env.host_string`` is nullified -- not always desirable. That's where ``clean_revert`` comes in:: # Before the block, env.parallel defaults to False, host_string to None with settings(parallel=True, host_string='myhost', clean_revert=True): # env.parallel is True # env.host_string is 'myhost' env.host_string = 'otherhost' # env.host_string is now 'otherhost' # Outside the block: # * env.parallel is False again # * env.host_string remains 'otherhost' Brand new keys which did not exist in ``env`` prior to using ``settings`` are also preserved if ``clean_revert`` is active. When ``False``, such keys are removed when the block exits. .. versionadded:: 1.4.1 The ``clean_revert`` kwarg. )�listr- r2 r )�args�kwargsr r r r �settings� s Pr6 c C s t d| �S )aN Context manager that keeps directory state when calling remote operations. Any calls to `run`, `sudo`, `get`, or `put` within the wrapped block will implicitly have a string similar to ``"cd <path> && "`` prefixed in order to give the sense that there is actually statefulness involved. .. note:: `cd` only affects *remote* paths -- to modify *local* paths, use `~fabric.context_managers.lcd`. Because use of `cd` affects all such invocations, any code making use of those operations, such as much of the ``contrib`` section, will also be affected by use of `cd`. Like the actual 'cd' shell builtin, `cd` may be called with relative paths (keep in mind that your default starting directory is your remote user's ``$HOME``) and may be nested as well. Below is a "normal" attempt at using the shell 'cd', which doesn't work due to how shell-less SSH connections are implemented -- state is **not** kept between invocations of `run` or `sudo`:: run('cd /var/www') run('ls') The above snippet will list the contents of the remote user's ``$HOME`` instead of ``/var/www``. With `cd`, however, it will work as expected:: with cd('/var/www'): run('ls') # Turns into "cd /var/www && ls" Finally, a demonstration (see inline comments) of nesting:: with cd('/var/www'): run('ls') # cd /var/www && ls with cd('website1'): run('ls') # cd /var/www/website1 && ls .. note:: This context manager is currently implemented by appending to (and, as always, restoring afterwards) the current value of an environment variable, ``env.cwd``. However, this implementation may change in the future, so we do not recommend manually altering ``env.cwd`` -- only the *behavior* of `cd` will have any guarantee of backwards compatibility. .. note:: Space characters will be escaped automatically to make dealing with such directory names easier. .. seealso:: `~fabric.context_managers.lcd` �cwd�� _change_cwd��pathr r r �cd� s 8r< c C s t d| �S )a' Context manager for updating local current working directory. This context manager is identical to `~fabric.context_managers.cd`, except that it changes a different env var (`lcwd`, instead of `cwd`) and thus only affects the invocation of `~fabric.operations.local` and the local arguments to `~fabric.operations.get`/`~fabric.operations.put`. Relative path arguments are relative to the local user's current working directory, which will vary depending on where Fabric (or Fabric-using code) was invoked. You can check what this is with `os.getcwd <http://docs.python.org/release/2.6/library/os.html#os.getcwd>`_. It may be useful to pin things relative to the location of the fabfile in use, which may be found in :ref:`env.real_fabfile <real-fabfile>` Zlcwdr8 r: r r r �lcd/ s r= c C sR |� dd�}tj�| �rB|�d�sB|�d�sBtj�| �d | }n|}t| |i�S )N� z\ �/�~)�replacer r �get� startswithr2 )r r; Znew_cwdr r r r9 B s r9 r- c C s t | |d��S )a Append the given ``path`` to the PATH used to execute any wrapped commands. Any calls to `run` or `sudo` within the wrapped block will implicitly have a string similar to ``"PATH=$PATH:<path> "`` prepended before the given command. You may customize the behavior of `path` by specifying the optional ``behavior`` keyword argument, as follows: * ``'append'``: append given path to the current ``$PATH``, e.g. ``PATH=$PATH:<path>``. This is the default behavior. * ``'prepend'``: prepend given path to the current ``$PATH``, e.g. ``PATH=<path>:$PATH``. * ``'replace'``: ignore previous value of ``$PATH`` altogether, e.g. ``PATH=<path>``. .. note:: This context manager is currently implemented by modifying (and, as always, restoring afterwards) the current value of environment variables, ``env.path`` and ``env.path_behavior``. However, this implementation may change in the future, so we do not recommend manually altering them directly. )r; Z path_behavior�r2 )r; Zbehaviorr r r r; K s r; c s t � fdd��S )a� Prefix all wrapped `run`/`sudo` commands with given command plus ``&&``. This is nearly identical to `~fabric.operations.cd`, except that nested invocations append to a list of command strings instead of modifying a single string. Most of the time, you'll want to be using this alongside a shell script which alters shell state, such as ones which export or alter shell environment variables. For example, one of the most common uses of this tool is with the ``workon`` command from `virtualenvwrapper <http://www.doughellmann.com/projects/virtualenvwrapper/>`_:: with prefix('workon myvenv'): run('./manage.py syncdb') In the above snippet, the actual shell command run would be this:: $ workon myvenv && ./manage.py syncdb This context manager is compatible with `~fabric.context_managers.cd`, so if your virtualenv doesn't ``cd`` in its ``postactivate`` script, you could do the following:: with cd('/path/to/app'): with prefix('workon myvenv'): run('./manage.py syncdb') run('./manage.py loaddata myfixture') Which would result in executions like so:: $ cd /path/to/app && workon myvenv && ./manage.py syncdb $ cd /path/to/app && workon myvenv && ./manage.py loaddata myfixture Finally, as alluded to near the beginning, `~fabric.context_managers.prefix` may be nested if desired, e.g.:: with prefix('workon myenv'): run('ls') with prefix('source /some/script'): run('touch a_file') The result:: $ workon myenv && ls $ workon myenv && source /some/script && touch a_file Contrived, but hopefully illustrative. c s dt jj� g iS )N�command_prefixes)r r rE r ��commandr r �<lambda>� � zprefix.<locals>.<lambda>rD rF r rF r �prefixg s 4rJ c c sZ t s t| �sdV nBt�| �}t�| � zdV W t�| tj|� nt�| tj|� 0 dS )z� Force local terminal ``pipe`` be character, not line, buffered. Only applies on Unix-based systems; on Windows this is a no-op. N)r r �termios� tcgetattr�ttyZ setcbreak� tcsetattr� TCSADRAIN)�pipeZ old_settingsr r r � char_buffered� s rQ c K s t d| i�S )a� Set shell environment variables for wrapped commands. For example, the below shows how you might set a ZeroMQ related environment variable when installing a Python ZMQ library:: with shell_env(ZMQ_DIR='/home/user/local'): run('pip install pyzmq') As with `~fabric.context_managers.prefix`, this effectively turns the ``run`` command into:: $ export ZMQ_DIR='/home/user/local' && pip install pyzmq Multiple key-value pairs may be given simultaneously. .. note:: If used to affect the behavior of `~fabric.operations.local` when running from a Windows localhost, ``SET`` commands will be used to implement this feature. � shell_envrD )�kwr r r rR � s rR c C s� t � || gg g �\}}}||v rB|�d�}t|�dkr8qn| �|� | |v r | �d�}t|�dkrbqn|�|� q | �� |�� d S )Ni r )�select�recv�len�send�close)�chan�sock�r�w�x�datar r r � _forwarder� s r_ � localhost� 127.0.0.1c # s� �du r | �g �g � g �� ����fdd�}t tj �� }|j|| |d� zPdV W t�� ��D ],\}}}|�� |�� |j�� |� � q`|� || � nHt�� ��D ],\}}}|�� |�� |j�� |� � q�|� || � 0 dS )a� Create a tunnel forwarding a locally-visible port to the remote target. For example, you can let the remote host access a database that is installed on the client host:: # Map localhost:6379 on the server to localhost:6379 on the client, # so that the remote 'redis-cli' program ends up speaking to the local # redis-server. with remote_tunnel(6379): run("redis-cli -i") The database might be installed on a client only reachable from the client host (as opposed to *on* the client itself):: # Map localhost:6379 on the server to redis.internal:6379 on the client with remote_tunnel(6379, local_host="redis.internal") run("redis-cli -i") ``remote_tunnel`` accepts up to four arguments: * ``remote_port`` (mandatory) is the remote port to listen to. * ``local_port`` (optional) is the local port to connect to; the default is the same port as the remote one. * ``local_host`` (optional) is the locally-reachable computer (DNS name or IP address) to connect to; the default is ``localhost`` (that is, the same computer Fabric is running on). * ``remote_bind_address`` (optional) is the remote IP address to bind to for listening, on the current target. It should be an IP address assigned to an interface on the target (or a DNS name that resolves to such IP). You can use "0.0.0.0" to bind to all interfaces. .. note:: By default, most SSH servers only allow remote tunnels to listen to the localhost interface (127.0.0.1). In these cases, `remote_bind_address` is ignored by the server, and the tunnel will listen only to 127.0.0.1. .. versionadded: 1.6 Nc s� |\}}|\}}� � | � t�� }�� |� z|���f� W n0 tyn tdtj��f � | �� Y d S 0 tdtj| j| � � ��ff � t dt | |�}�� |� d S )Nz2[%s] rtunnel: cannot connect to %s:%d (from local)z3[%s] rtunnel: opened reverse tunnel: %r -> %r -> %rZfwd) r- �socket�connect� Exception�printr � host_stringrX Z origin_addr� getpeernamer r_ ) Zchannel�src�destZsrc_addrZsrc_portZ dest_addrZ dest_portrZ �th�Zchannels� local_host� local_portZsockets�threadsr r �accept s( � ��z remote_tunnel.<locals>.accept)�handler) r r rf Z get_transportZrequest_port_forward�ziprX �thread�joinZraise_if_neededZcancel_port_forward) Z remote_portrm rl Zremote_bind_addressro � transportrZ rY rj r rk r � remote_tunnel� s, * � ru c C s t td�dd�S )a� Alias to ``settings(hide('everything'), warn_only=True)``. Useful for wrapping remote interrogative commands which you expect to fail occasionally, and/or which you want to silence. Example:: with quiet(): have_build_dir = run("test -e /tmp/build").succeeded When used in a task, the above snippet will not produce any ``run: test -e /tmp/build`` line, nor will any stdout/stderr display, and command failure is ignored. .. seealso:: :ref:`env.warn_only <warn_only>`, `~fabric.context_managers.settings`, `~fabric.context_managers.hide` .. versionadded:: 1.5 Z everythingT�� warn_only)r6 r' r r r r �quiet0 s rx c C s t dd�S )z� Alias to ``settings(warn_only=True)``. .. seealso:: :ref:`env.warn_only <warn_only>`, `~fabric.context_managers.settings`, `~fabric.context_managers.quiet` Trv )r6 r r r r rw J s rw )r- )Nr` ra )'�__doc__� contextlibr r+ rb rT Zfabric.thread_handlingr Z fabric.stater r r r Zfabricr Z fabric.utilsr �PY2r r rK rM r r# r& r' r2 r6 r< r= r9 r; rJ rQ rR r_ ru rx rw r r r r �<module> sN *V; 7 � T
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0.32 |
proxy
|
phpinfo
|
ÐаÑтройка