Current File : //usr/lib/python2.7/site-packages/salt/client/__init__.pyc
�
���^c @@ sF d Z d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l
Z d d l Z d d l
Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l j Z d d l m Z m Z m Z m! Z! m" Z" m# Z# m$ Z$ d d l% m& Z& e' Z( y d d l) Z* e+ Z( Wn e, k
r�n Xd d l- Z. e j/ e0 � Z1 e j2 j3 e j4 d � e5 e' e5 e' d � Z6 d e7 f d
� � YZ8 d e9 f d � � YZ: d
e7 f d � � YZ; d e7 f d � � YZ< d S( u'
The client module is used to create a client connection to the publisher
The data structure needs to be:
{'enc': 'clear',
'load': {'fun': '<mod.callable>',
'arg':, ('arg1', 'arg2', ...),
'tgt': '<glob or id>',
'key': '<read in the key file>'}
i ( t absolute_importt print_functiont unicode_literalsN( t datetime( t AuthenticationErrort AuthorizationErrort EauthAuthenticationErrort PublishErrort SaltInvocationErrort SaltReqTimeoutErrort SaltClientError( t sixu masterc C@ s� | r | } n d d l } | j j | � } | d d k r_ d d l } | j j j d | � S| d d k r� t d | d | d | d
| � Sd S( u�
.. versionadded:: 2014.7.0
Read in the config and return the correct LocalClient object based on
the configured transport
:param IOLoop io_loop: io_loop used for events.
Pass in an io_loop if you want asynchronous
operation for obtaining events. Eg use of
set_event_handler() API. Otherwise, operation
will be synchronous.
i Nu transportu raett moptsu zeromqu tcpt skip_perm_errorst io_loopt auto_reconnect( u zeromqu tcp( t salt.configt configt
client_configt salt.client.raett clientt raett LocalClient( t c_pathR R
R R t optst salt( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt get_local_clientL s R c
B@ s� e Z d Z e j j e j d � d' e d' e e d � Z
d � Z d � Z d � Z
e d � Z e d � Z d( d d d' d d' e d
� Z d � Z e j j d) d d d' d d' e d' d � � Z d* d d d d' d
� Z d+ d d d' d e e e d � Z d, d d d' d d � Z d- d' d d d e d' d � Z d. d' d d e d' e d � Z d/ d' d d d' d � Z d0 d' d d d' e e d � Z d1 d' d d e d' d � Z d' d d e e d � Z d' d � Z d' d d e e d � Z! d' d � Z" d' d � Z# d � Z$ d' d d e e e d � Z% d' d d e e e e d � Z& d' d � Z' d! � Z( d2 d d d d" e d# � Z) e j j d3 d d d d" d' e d$ � � Z* d% � Z+ d& � Z, RS(4 u=
The interface used by the :command:`salt` CLI tool on the Salt Master
``LocalClient`` is used to send a command to Salt minions to execute
:ref:`execution modules <all-salt.modules>` and return the results to the
Salt Master.
Importing and using ``LocalClient`` must be done on the same machine as the
Salt Master and it must be done using the same user that the Salt Master is
running as. (Unless :conf_master:`external_auth` is configured and
authentication credentials are included in the execution).
.. note::
The LocalClient uses a Tornado IOLoop, this can create issues when
using the LocalClient inside an existing IOLoop. If creating the
LocalClient in partnership with another IOLoop either create the
IOLoop before creating the LocalClient, or when creating the IOLoop
use ioloop.current() which will return the ioloop created by
LocalClient.
.. code-block:: python
import salt.client
local = salt.client.LocalClient()
local.cmd('*', 'test.fib', [10])
u masterc C@ sE | r | | _ nC t j j | � r@ t j d | j j | � n t j j
| � | _ t j j | j � | _
t j j j � | _ | | _ | j � | _ | | _ t j j j d | j d | j d d | j d t d | d | �| _ t j j | j � | _ t j j | j d | j �| _ t j j | j | j � | _ d
S( uV
:param IOLoop io_loop: io_loop used for events.
Pass in an io_loop if you want asynchronous
operation for obtaining events. Eg use of
set_event_handler() API. Otherwise,
operation will be synchronous.
uP %s expects a file path not a directory path(%s) to its 'c_path' keyword argumentu masteru sock_diru transportR t listenR t keep_loopt utilsN( R t ost patht isdirt logt warningt __class__t __name__R R R t payloadt Serialt serialR t usert get_specific_usert salt_userR
t _LocalClient__read_master_keyt keyR t eventt get_eventt Falset loadert minion_modst functionst returners( t selfR R R
R R R ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt __init__� s.
!c C@ sA | j } | d k rK | j j d d � d k rK | j j d d � } qK n | j d � rr | j j d d � } n t j j j � r� | j d d � } n t j
j | j d d j | � � } ya t j j
j | j d | | j � t j j j | d � � } t j j j | j � � SWd QXWn t t t f k
r<d
SXd S( u@
Read in the rotating master authentication key
u rootu useru sudo_u \u _u cachediru .{0}_keyu rNu ( R* R t gett
startswithR R t platformt
is_windowst replaceR R t joint formatt verifyt check_path_traversalR
t filest fopent stringutilst
to_unicodet readt OSErrort IOErrorR
( R4 t key_usert keyfileR, ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt __read_master_key� s$
#c C@ s^ t j j | j d � } y | j | � SWn- t j j k
rY } t d j | � � g SXd S( u?
convert a seco.range range into a list target
u range_serveru Range server exception: {0}N( t secot ranget RangeR t expandt RangeExceptiont printR< ( R4 t tgtt range_t err( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt _convert_range_to_list� s c C@ st | d k r | j d St | t � r* | St | t j � ri y t | � SWqi t k
re | j d SXn | j d S( u+
Return the timeout to use
u timeoutN( t NoneR t
isinstancet intR t string_typest
ValueError( R4 t timeout( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt _get_timeout� s
c K@ s� t j d | � t | j d | j d � � } | j | d d | g d | d | d | | �} d | k r� | j j | d � n | S( u:
Return the information about a given job
u( Checking whether jid %s is still runningu gather_job_timeoutu saltutil.find_jobt argt tgt_typeRX R u jid( R! t debugRU R6 R t run_jobR- t subscribe( R4 t jidRO R[ R t kwargsRX t pub_data( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt gather_job_info� s c C@ s | d k r t d � � n d | k rM t | d � t j d | d � i Sd | k r] i S| d d k r{ t d � i S| j j d � s� | d s� t d
� i Sn | s� | S| j j d � r� | j j d j | d � d � n | j j d
j | d � � | S( uX
Common checks on the pub_data data structure returned from running pub
u u� Failed to authenticate! This is most likely because this user is not permitted to execute commands, but there is a small possibility that a disk error occurred (check disk/inode usage).u erroru _check_pub_data() error: %su jidu 0u< Failed to connect to the Master, is the Salt Master running?u
order_mastersu minionsuH No minions matched the target. No command was sent, no jid was assigned.u
syndic/.*/{0}u regexu salt/job/{0}( R RN R! R\ R R6 R- R^ R< ( R4 Ra R ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt _check_pub_data� s,
# u globu c
K@ s� t j j j | | � } y= | j | | | | | d | d | j | � d | |
�} Wnw t k
rt t d � � n[ t k
r� } t | � � n= t k
r� } t | � � n t k
r� }
t |
� � n X| j
| d | �S( u
Asynchronously send a command to connected minions
Prep the job directory and publish a command to any targeted minions.
:return: A dictionary of (validated) ``pub_data`` or an empty
dictionary on failure. The ``pub_data`` contains the job ID and a
list of all minions that are expected to return data.
.. code-block:: python
>>> local.run_job('*', 'test.sleep', [300])
{'jid': '20131219215650131543', 'minions': ['jerry']}
R_ RX R u: The salt master could not be contacted. Is master running?( R R t argst condition_inputt pubRY R
R R t ExceptionRc ( R4 RO t funRZ R[ t retRX R_ t kwargR R` Ra RQ t general_exception( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR] + s,
c C@ s/ t j j j | j � j | d | �} | d S( NR[ u minions( R R t minionst CkMinionsR t
check_minions( R4 RO t expr_formt _res( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt gather_minionsa s 'c k@ s� t j j j | | � } yD | j | | | | | d | d | j | � d |
d | | �V} Wnw t k
r{ t d � � n[ t k
r� }
t |
� � n= t k
r� }
t |
� � n t k
r� } t | � � n Xt
j j | j
| d | �� � d S( u
Asynchronously send a command to connected minions
Prep the job directory and publish a command to any targeted minions.
:return: A dictionary of (validated) ``pub_data`` or an empty
dictionary on failure. The ``pub_data`` contains the job ID and a
list of all minions that are expected to return data.
.. code-block:: python
>>> local.run_job_async('*', 'test.sleep', [300])
{'jid': '20131219215650131543', 'minions': ['jerry']}
R_ RX R R u: The salt master could not be contacted. Is master running?N( R R Rd Re t pub_asyncRY R
R R Rg t tornadot gent ReturnRc ( R4 RO Rh RZ R[ Ri RX R_ Rj R R R` Ra RQ Rk ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt
run_job_asynce s.
c
K@ sg t j j j | | � } | j | | | | | d | d t | �} y | d SWn t k
rb d SXd S( uT
Asynchronously send a command to connected minions
The function signature is the same as :py:meth:`cmd` with the
following exceptions.
:returns: A job ID or 0 on failure.
.. code-block:: python
>>> local.cmd_async('*', 'test.sleep', [300])
'20131219215921857715'
R_ R u jidi N( R R Rd Re R] R/ t KeyError(
R4 RO Rh RZ R[ Ri R_ Rj R` Ra ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt cmd_async� s
i c K@ s� | j | d d | | �} t | � }
t j |
� g } xD |
D]< } | | | k rg | j | � n t | � | k rA PqA qA W| j } | r� | j } n | | | | d d d | d | d | d |
| �S( u�
Execute a command on a random subset of the targeted systems
The function signature is the same as :py:meth:`cmd` with the
following exceptions.
:param sub: The number of systems to execute on
:param cli: When this is set to True, a generator is returned,
otherwise a dictionary of the minion returns is returned
.. code-block:: python
>>> SLC.cmd_subset('*', 'test.ping', sub=1)
{'jerry': True}
u sys.list_functionsR[ u listRi Rj t progresst full_return( t cmdt listt randomt shufflet appendt lent cmd_cli( R4 RO Rh RZ R[ Ri Rj t subt cliRy Rz R` t
minion_retRl t f_tgtt miniont func( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt
cmd_subset� s2
u 10%c k@ s� d d l } d d l } | j j j | | � } i | d 6| d 6| d 6| d 6| d 6| d 6| j d | j j d t � � d 6| j d
t � d
6}
d | k r� | d |
d <n d | k r� | d |
d <n d
| k r� t | d
� |
d
<n i } d | k r| j d � | d <n d | k r<| j d � | d <n d | k r^| j d � | d <n d | k r�| j d � | d <n x9 t
j | j � D]% \ } }
| |
k r�|
|
| <q�q�W| j j
j |
d | d t �} x | j � D] } | Vq�Wd S( u5
Iteratively execute a command on subsets of minions at a time
The function signature is the same as :py:meth:`cmd` with the
following exceptions.
:param batch: The batch identifier of systems to execute on
:returns: A generator of minion returns
.. code-block:: python
>>> returns = local.cmd_batch('*', 'state.highstate', batch='10%')
>>> for ret in returns:
... print(ret)
{'jerry': {...}}
{'dave': {...}}
{'stewart': {...}}
i Nu tgtu funu argu tgt_typeu retu batchu failhardu rawu timeoutu gather_job_timeoutu
batch_waitu eauthu usernameu passwordu tokent eautht quiet( t salt.utils.argst salt.cli.batchR Rd Re R6 R R/ RU t popR t iteritemsR� t batcht Batcht Truet run( R4 RO Rh RZ R[ Ri Rj R� R` R R R� R, t val( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt cmd_batch� s@ !
" !c
K@ s> t j j j | | � } | j j } z� | j | | | | | | | d t |
�} | s[ | Si } x� | j | d | d | j | � | | |
� D]Q }
|
r� xB t
j |
� D]. \ } } | r� | n | j d i � | | <q� Wq� q� Wx2 t
t | d � t | � � D] } t | | <qW| SWd | s9| j j � n Xd S( u�
Synchronously execute a command on targeted minions
The cmd method will execute and wait for the timeout period for all
minions to reply, then it will return all minion data at once.
.. code-block:: python
>>> import salt.client
>>> local = salt.client.LocalClient()
>>> local.cmd('*', 'cmd.run', ['whoami'])
{'jerry': 'root'}
With extra keyword arguments for the command function to be run:
.. code-block:: python
local.cmd('*', 'test.arg', ['arg1', 'arg2'], kwarg={'foo': 'bar'})
Compound commands can be used for multiple executions in a single
publish. Function names and function arguments are provided in separate
lists but the index values must correlate and an empty list must be
used if no arguments are required.
.. code-block:: python
>>> local.cmd('*', [
'grains.items',
'sys.doc',
'cmd.run',
],
[
[],
[],
['uptime'],
])
:param tgt: Which minions to target for the execution. Default is shell
glob. Modified by the ``tgt_type`` option.
:type tgt: string or list
:param fun: The module and function to call on the specified minions of
the form ``module.function``. For example ``test.ping`` or
``grains.items``.
Compound commands
Multiple functions may be called in a single publish by
passing a list of commands. This can dramatically lower
overhead and speed up the application communicating with Salt.
This requires that the ``arg`` param is a list of lists. The
``fun`` list and the ``arg`` list must correlate by index
meaning a function that does not take arguments must still have
a corresponding empty list at the expected index.
:type fun: string or list of strings
:param arg: A list of arguments to pass to the remote function. If the
function takes no arguments ``arg`` may be omitted except when
executing a compound command.
:type arg: list or list-of-lists
:param timeout: Seconds to wait after the last minion returns but
before all minions return.
:param tgt_type: The type of ``tgt``. Allowed values:
* ``glob`` - Bash glob completion - Default
* ``pcre`` - Perl style regular expression
* ``list`` - Python list of hosts
* ``grain`` - Match based on a grain comparison
* ``grain_pcre`` - Grain comparison with a regex
* ``pillar`` - Pillar data comparison
* ``pillar_pcre`` - Pillar data comparison with a regex
* ``nodegroup`` - Match on nodegroup
* ``range`` - Use a Range server for matching
* ``compound`` - Pass a compound match string
* ``ipcidr`` - Match based on Subnet (CIDR notation) or IPv4 address.
.. versionchanged:: 2017.7.0
Renamed from ``expr_form`` to ``tgt_type``
:param ret: The returner to use. The value passed can be single
returner, or a comma delimited list of returners to call in order
on the minions
:param kwarg: A dictionary with keyword arguments for the function.
:param full_return: Output the job return only (default) or the full
return including exit code and other job metadata.
:param kwargs: Optional keyword arguments.
Authentication credentials may be passed when using
:conf_master:`external_auth`.
For example: ``local.cmd('*', 'test.ping', username='saltdev',
password='saltdev', eauth='pam')``.
Or: ``local.cmd('*', 'test.ping',
token='5871821ea51754fdcea8153c1c745433')``
:returns: A dictionary with the result of the execution, keyed by
minion ID. A compound command will return a sub-dictionary keyed by
function name.
R u jidu minionsu retN( R R Rd Re R- t cpubR] R� t get_cli_event_returnsRY R R� R6 R| t setR/ t close_pub( R4 RO Rh RZ RX R[ Ri R_ Rz Rj R` t
was_listeningRa t fn_rett midt datat failed( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR{ A s> r
!'c
k@ s t j j j | | � } | j j } z� | j | | | | | | d t |
�| _ | j se | j Vn� y[ xT | j | j d | j d | j
| � | | | | |
� D] } | s� q� n | Vq� WWn- t k
r� t d j
| j d � � � n XWd | s
| j j � n Xd S( um
Used by the :command:`salt` CLI. This method returns minion returns as
they come back and attempts to block until all minions return.
The function signature is the same as :py:meth:`cmd` with the
following exceptions.
:param verbose: Print extra information about the running command
:returns: A generator
R u jidu minionsu
This job's jid is: {0}
Exiting gracefully on Ctrl-c
The minions may not have all finished running and any remaining minions will return upon completion. To look up the return data for this job later, run the following command:
salt-run jobs.lookup_jid {0}N( R R Rd Re R- R� R] R� Ra R� RY t KeyboardInterruptt
SystemExitR< R� (
R4 RO Rh RZ RX R[ Ri t verboseRj Ry R` R� R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� � sB
c
k@ s� t j j j | | � } | j j } z� | j | | | | | | d t | �}
|
s\ |
Vn| | j d � rs |
Vn xQ | j |
d |
d d | j
| � d | d | | �D] } | s� q� n | Vq� W| j |
d � Wd | s� | j j � n Xd S( u�
Yields the individual minion returns as they come in
The function signature is the same as :py:meth:`cmd` with the
following exceptions.
Normally :py:meth:`cmd_iter` does not yield results for minions that
are not connected. If you want it to return results for disconnected
minions set `expect_minions=True` in `kwargs`.
:return: A generator yielding the individual minion returns
.. code-block:: python
>>> ret = local.cmd_iter('*', 'test.ping')
>>> for i in ret:
... print(i)
{'jerry': {'ret': True}}
{'dave': {'ret': True}}
{'stewart': {'ret': True}}
R u yield_pub_datau jidu minionsRX RO R[ N(
R R Rd Re R- R� R] R� R6 t get_iter_returnsRY t _clean_up_subscriptionsR� ( R4 RO Rh RZ RX R[ Ri Rj R` R� Ra R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt cmd_iter s8
c
k@ s t j j j | | � } | j j } z� | j | | | | | | d t |
�} | s\ | Vn� x� | j | d | d d | d | d | d t |
�D]I }
|
r� t
| | g � r� x# |
D] } | d |
| d <q� Wn |
Vq� W| j | d � Wd | s
| j j � n Xd S( u�
Yields the individual minion returns as they come in, or None
when no returns are available.
The function signature is the same as :py:meth:`cmd` with the
following exceptions.
:returns: A generator yielding the individual minion returns, or None
when no returns are available. This allows for actions to be
injected in between minion returns.
.. code-block:: python
>>> ret = local.cmd_iter_no_block('*', 'test.ping')
>>> for i in ret:
... print(i)
None
{'jerry': {'ret': True}}
{'dave': {'ret': True}}
None
{'stewart': {'ret': True}}
R u jidu minionsRX RO R[ t blockN(
R R Rd Re R- R� R] R� R� R/ t anyR� R� ( R4 RO Rh RZ RX R[ Ri Rj t show_jidR� R` R� Ra R� R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt cmd_iter_no_block^ s8 "
c
K@ s� t j j j | | � } | j j }
zY | j | | | | | | d t | �} | sX | S| j | d | d | | | | � SWd |
s� | j j � n Xd S( u3
Execute a salt command and return
R u jidu minionsN(
R R Rd Re R- R� R] R� t get_cli_static_event_returnsR� ( R4 RO Rh RZ RX R[ Ri R� Rj R` R� Ra ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt cmd_full_return� s,
u *c k@ s~ | r: d j | � } t | � t d t | � d � n | rV t d j | � � n | d k rr | j d } n i }
t | � } t � } | j | | d | �} | j | � }
|
i k r� | j t |
� � |
Vn t | j | � � t | � k rt
� � n xo | D]g } | i k r<| j t | � � | Vn t | j | � � t | � k r| j | � t
� � qqWd S( u�
Starts a watcher looking at the return data for a specified JID
:returns: all of the information for the JID
u Executing job with jid {0}u -u
u jid: {0}u timeoutRX N( R< RN R� RS R R� t get_event_iter_returnst get_cache_returnst updatet intersectiont
StopIterationR� ( R4 R_ Rl RX RO R[ R� R� R` t msgt frett foundt
event_iterRi R- ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt get_cli_returns� s2
!
!
c
c@ sL xE t rG | j j d d d | d | d t d t d | j � } | Vq Wd S( u4
Raw function to just return events of jid excluding timeout logic
Yield either the raw event data or None
Pass a list of additional regular expressions as `tags_regex` to search
the event bus for non-return data, such as minion lists returned from
syndics.
t waitg{�G�z�?t tagt
match_typet fullt no_blockR N( R� R- R. R ( R4 R� R� t raw( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt get_returns_no_block� s $c k@ s� t | t � s` t | t j � r3 t | g � } q` t | t t f � r` t t | � � } q` n | d% k r| | j d } n t | j d | j d � � } t t
j
� � }
i } t � } t � }
yK | j d j | j d � | � i k rt
j d � i Vt � � n Wn, t k
r>} t
j d | d t j �n Xt } | j d rp| j d j | � d
� } n | j d j | � � } g } t � } t
j
� | } t
j
� | j d } t } t
j d
| | t j | � j
� � x%t rx�| D]�} | d% k rPn d | j d i � k rr| j | d d � d | j d i � k r�|
j | d d � q�q�n d | d k r�q�n | j d t � r�| j | d d � | Vq�| j | d d � i i | d d d 6| d d 6} d | d k r!| d d | | d d d <n d | d k rR| d d | | d d d <n d | d k r�| d d | | d d d <n | j d t � r�| | d d j | d � n t
j d | | d d � | Vq�Wt | j | � � t | � k r | j d r t
j d | | � Pnq t | j | � � t | � k r�| j d r�t | � t | � k r�t | � d k r�t
j
� | k r�Pq�n x5 | | D]) } | | k r�t
j
� | | | <q�q�Wt
j
� | k ru| ru| j | t | | � d | � } t } d | k r g } n | j d j | d � � } t
j
� | } | j d ru| | j j d d � 7} qun x| D]} | d% k r�Pn yI | d d d k r�t
j d | d d � | j | d d � Pn WnT t k
r1} | j! � j" d � } | d k r t
j d � q2t
j d! | � n X| j | d � d | j d i � k rv| j | d d � q|n d" | j d i � k r�| j | d" � q|n d | j d i � k r�q|n | d d i k r�q|n t | d d t j � r
t
j d# | � q|n d | d d k r?| d d d i k r?q|n | d d | k rk| j | d d � n t
j
� | | | d d <t } q|Wt
j
� } | | k o�| } | r�x/ | | D] } | | | k r�t } Pq�q�Wn | r�Pn | rt
j# d$ � q�d% Vq�W| r;x! | D] } | j$ j% | � q Wn | rrx. t | | � D] } i i t d& 6| 6VqRWn |
| 8}
|
r�x$ |
D] } i i t d& 6| 6Vq�Wn d% S(' u�
Watch the event system and return job data as it comes in
:returns: all of the information for the JID
u timeoutu gather_job_timeoutu {0}.get_loadu master_job_cacheu jid does not existu Returner unavailable: %st exc_info_on_loglevelu
order_mastersu (salt/job|syndic/.*)/{0}u regexu salt/job/{0}u syndic_waitu9 get_iter_returns for jid %s sent to %s will timeout at %su minionsu datau missingu returnu rawu idu retu outu retcodeu jidu _cmd_metau jid %s return from %su jid %s found all minions %si u listi u& saltutil returning errors on minion %su '"u" retcode missing from client returnuc Passing on saltutil error. Key '%s' missing from client return. This may be an error in the client.u syndicu! unexpected return from minion: %sg{�G�z�?Nu failed(& RT R� R RV R| t tupleRS R RU R6 t timeR3 R< R! R" R� Rg t loggingt DEBUGR/ R� R� R\ R t
fromtimestampR� t addR� R� Rb t errort removeRw t __str__t stript sleepR- t unsubscribe( R4 R_ Rl RX RO R[ t expect_minionsR� R` t gather_job_timeoutt startt minion_timeoutsR� t missingt exct last_timet ret_itert
jinfo_itert open_jidst
timeout_att gather_syndic_waitt minions_runningR� Ri t id_t jinfot missing_keyt nowt doneR� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� s
)
$!!! /.< "
c C@ s* t | � } | d k r( | j d } n t t j � � } | | } t j d | | t j | � j � � t � } i } y> | j d j
| j d � | � i k r� t j d � | SWn2 t k
r� } t
d j
| j d | � � � n Xx8t r%| t t j � � } t d | � }
| j j |
| d | j �} | d k r�d | k r�| j | d
� | d | | d
<t | j | � � t | � k r� t j d | � Pq� q� n t | j | � � t | � k r�t j d | � Pn t t j � � | k rt j d | | | � Pn t j d
� q� W| S( uU
Get the returns for the command line interface via the event system
u timeoutu4 get_returns for jid %s sent to %s will timeout at %su {0}.get_loadu master_job_cacheu jid does not existuL Master job cache returner [{0}] failed to verify jid. Exception details: {1}i R u returnu idu jid %s found all minionsu( jid %s minions %s did not return in timeg{�G�z�?N( R� RS R RU R� R! R\ R R� R3 R< R" Rg R
R� t maxR- R. R R� R� R� t infoR� ( R4 R_ Rl RX R� R� R� Ri R� t time_leftR� R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt get_returns� sL
)
!!c C@ s� i } | j | | d | �} y' | j d j | j d � | � } Wn2 t k
ry } t d j | j d | � � � n Xx� | D]� } i } d | | k r� | | j d � | d <n | | j d � | d <d | | k r� | | d | d <n | | k r| | j | � q� | | | <q� Wt t | � j
| � � t | � k rL| Sx� | D]� }
|
i k rxt j d � qSn xG t
j |
� D]6 \ } } | | k r�| | j | � q�| | | <q�Wt t | � j
| � � t | � k rS| SqSW| S( u�
This method starts off a watcher looking at the return data for
a specified jid, it returns all of the information for the jid
RX u {0}.get_jidu master_job_cacheu= Returner {0} could not fetch jid data. Exception details: {1}u returnu retu outg{�G�z�?( R� R3 R< R Rg R
R6 R� R� R� R� R� R� R R� ( R4 R_ Rl RX Ri R� R� R� R� t m_datat event_ret( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt get_full_returns. s> '
'
'c C@ s
i } y' | j d j | j d � | � } Wn2 t k
ra } t d j | j d | � � � n Xx� | D]� } i } d | | k r� | | j d � | d <n | | j d � | d <d | | k r� | | d | d <n | | k r� | | j | � qi | | | <qi W| S( uO
Execute a single pass to gather the contents of the job cache
u {0}.get_jidu master_job_cacheuZ Could not examine master job cache. Error occurred in {0} returner. Exception details: {1}u returnu retu out( R3 R< R Rg R
R6 R� ( R4 R_ Ri R� R� R� R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� e s$ '
c C@ s\ t j d � t | � } | rS d j | � } t | � t d t | � d � n | ro t d j | � � n | d k r� | j d } n t t j � � }
|
| } t � } i }
y> | j
d j | j d � | � i k r� t j d � |
SWn2 t k
r(} t
d
j | j d | � � � n Xx t rJ| t t j � � } t d | � } d j | � } | j j | | d
| j �} | d k rgd | k rgd | j d i � k r�| j | d d � q,n | j | d � i | d d 6|
| d <| j d t � |
| d d <d | k r<| d |
| d d <n t | j | � � t | � k r,Pq,q,n t | j | � � t | � k r�Pn t t j � � | k r:| s�| r6| j j d t � s�| d k r6t | � t | � k r3t t | j | � � � } x) | D] } i d d 6d d 6|
| <q Wq3q6n Pn t j d � q,W| j | � |
S( uU
Get the returns for the command line interface via the event system
u1 entered - function get_cli_static_event_returns()u Executing job with jid {0}u -u
u jid: {0}u timeoutu {0}.get_loadu master_job_cacheu jid does not existuE Load could not be retrieved from returner {0}. Exception details: {1}i u salt/job/{0}R u returnu minionsu datau idu retu successu outu minion_data_cacheu globu pcreu listu no_returnu Minion did not returng{�G�z�?N( u globu pcreu list( R! t traceR� R< RN R� RS R RU R� R3 R" Rg R
R� R� R- R. R R6 R� R� R/ R� t sortedR| t
differenceR� R� ( R4 R_ Rl RX RO R[ R� t show_timeoutR� R� R� R� R� Ri R� R� R� t jid_tagR� t failR� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� � sn
)
!!
c
k@ s� t j d � | rG d j | � } t | � t d t | � d � n | rc t d j | � � n d } d }
x�| j | | d | d | d | d
|
j d t � p� | p� | |
�D]�} t j d | � |
d
}
| r/xQ t
j | � D]= \ } } | j d � t
k r� i t | � d 6|
d 6Vq� q� Wn x9t
j | � D](\ } } | j d � t
k r[| d k r�t j j j | j � j � } n | j d rt j j | j � j d j | � d � r| r| | k ri i d d 6d d 6t j j j d 6| 6Vqgt j j t j j | j d | � � sgi i d d 6d d 6t j j j d 6| 6Vqgq?i | | 6Vq?Wq� W| j | � d S( uU
Get the returns for the command line interface via the event system
u func get_cli_event_returns()u Executing job with jid {0}u -u
u jid: {0}i RX RO R[ R� u expect_minionsu return event: %si u failedu minion_countu return_countu minion_data_cacheu minions/{0}u datau no_returnu outu& Minion did not return. [Not connected]u retu retcodeu
syndic_diru$ Minion did not return. [No response]N( R! R� R< RN R� RS R� R� R/ R\ R R� R6 R� R R Rl Rm R t
connected_idst cachet factoryt containst defaultst exitcodest
EX_GENERICR R t existsR; R� ( R4 R_ Rl RX RO R[ R� Ry R� R� R` R� t connected_minionst return_countRi R� t min_ret( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� � sV
# !
* ( c c@ st t j d � | d k r) | j d } n t j � | } t � } | j d j | j d � | � i k r� t j d � i Vt � � n x� t
ro| j j | d | j
�} | d k s� t j � | k r� Pn d | j d i � k r� q� n y1 | j | d � i i | d
d 6| d 6} Wn t k
r4q� n Xd | k rZ| d | | d d <n | Vt j d
� q� Wd S( uk
Gather the return data from the event system, break hard when timeout
is reached.
u+ entered - function get_event_iter_returns()u timeoutu {0}.get_loadu master_job_cacheu jid does not existR u minionsu datau idu returnu retu outg{�G�z�?N( R! R� RS R R� R� R3 R< R" R� R� R- R. R R6 R� Rw R� ( R4 R_ Rl RX R� R� R� Ri ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� s0
)
c K@ s� | d k rw | | j d k rO | j j d d � } t d j | | � � � n t j j j | | j d � } d } n | d k r� t r� | j | � } d } n | j j d � r� | r� | d
j | j d � 7} q� | j d } n i d d 6| d
6| d 6| d 6| j
d 6| d 6| d 6| d 6}
| r:| |
d <n | j d rdd | k rd| d |
d <n | j r}| j |
d <n | j d r�| |
d <n |
S( uI
Set up the payload_kwargs to be sent down to the master
u nodegroupu
nodegroupsu conf_fileu the master config fileu! Node group {0} unavailable in {1}u compoundu rangeu listu
ext_job_cacheu ,{0}u publishu cmdu tgtu funu argu keyu tgt_typeu retu jidu kwargsu
syndic_masteru useru
order_mastersu to( R R6 R R< R R Rl t nodegroup_compt HAS_RANGERR R, R* ( R4 RO Rh RZ R[ Ri R_ RX R` t conf_filet payload_kwargs( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt _prep_pubD sD
i c
K@ sd | j j d d � d k rd t j j t j j | j d d � � rd t j d | j d � t � n | j | | | | | | | | � }
d t
j j j
| j d � d t j | j d
� } t
j j j j | j d d d
| �} yA | r| j j d | � rt � � n | j |
d | �}
Wn t k
rGt d � � n X|
s�| j � } | | j k rm|
S| | _ | j |
d <| j |
� }
n |
j d d � } | d k r.t | t � r | j d d � } | j d d � } | d k rt | � � q | d k r t | � � q n t | � � n |
s8|
S| j! � i |
d d d 6|
d d d 6S( u�
Take the required arguments and publish the given command.
Arguments:
tgt:
The tgt is a regex or a glob used to match up the ids on
the minions. Salt works by always publishing every command
to all of the minions and then the minions determine if
the command is for them based on the tgt value.
fun:
The function name to be called on the remote host(s), this
must be a string in the format "<modulename>.<function name>"
arg:
The arg option needs to be a tuple of arguments to pass
to the calling function, if left blank
Returns:
jid:
A string, as returned by the publisher, which is the job
id, this will inform the client where to get the job results
minions:
A set, the targets that the tgt passed should match.
u ipc_modeu u tcpu sock_diru publish_pull.ipcu4 Unable to connect to the salt master publisher at %su tcp://u interfaceu :u ret_portt cryptu cleart
master_uriRX uf Salt request timed out. The master is not responding. You may need to run your command with `--async` in order to bypass the congested event bus. With `--async`, the CLI tool will print the job id (jid) and exit immediately without listening for responses. You can then use `salt-run jobs.lookup_jid` to look up the results of the job in the job cache later.u keyu erroru nameu messageu AuthenticationErroru AuthorizationErroru loadu jidu minionsN(" R R6 R R R� R; R! R� R
R� R R t zeromqt
ip_bracketR t text_typet transportR t
ReqChannelR� R- t connect_pubR t sendR+ R, R� RS RT t dictR R R t close( R4 RO Rh RZ R[ Ri R_ RX R R` R� R� t channelR% R, R� t err_namet err_msg( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyRf � sb
8
c
k@ s� | j j d d � d k rd t j j t j j | j d d � � rd t j d | j d � t � n | j | | | | | | | |
� } d t
j j j
| j d � d t j | j d
� } t
j j j j | j d | d d
d | �}
yB | r| j j d | � rt � � n |
j | d | �V} Wn t k
rNt d � � n X| s�| j � } | | j k r�t j j | � � n | | _ | j | d <|
j | � V} n | j d d � } | d k rGt | t � r8| j d d � } | j d d � } | d k rt! | � � q8| d k r8t" | � � q8n t# | � � n | sbt j j | � � n |
j$ � t j j i | d d d 6| d d d 6� � d S( u�
Take the required arguments and publish the given command.
Arguments:
tgt:
The tgt is a regex or a glob used to match up the ids on
the minions. Salt works by always publishing every command
to all of the minions and then the minions determine if
the command is for them based on the tgt value.
fun:
The function name to be called on the remote host(s), this
must be a string in the format "<modulename>.<function name>"
arg:
The arg option needs to be a tuple of arguments to pass
to the calling function, if left blank
Returns:
jid:
A string, as returned by the publisher, which is the job
id, this will inform the client where to get the job results
minions:
A set, the targets that the tgt passed should match.
u ipc_modeu u tcpu sock_diru publish_pull.ipcu4 Unable to connect to the salt master publisher at %su tcp://u interfaceu :u ret_portR R� u clearR� RX uf Salt request timed out. The master is not responding. You may need to run your command with `--async` in order to bypass the congested event bus. With `--async`, the CLI tool will print the job id (jid) and exit immediately without listening for responses. You can then use `salt-run jobs.lookup_jid` to look up the results of the job in the job cache later.u keyu erroru nameu messageu AuthenticationErroru AuthorizationErroru loadu jidu minionsN(% R R6 R R R� R; R! R� R
R� R R R� R� R R� R� R t AsyncReqChannelR� R- R� R R� R+ R, Rs Rt Ru R� RS RT R R R R R ( R4 RO Rh RZ R[ Ri R_ RX R R R` R� R� R R% R, R� R R ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyRr � sd "
8
c C@ s t | d � r | ` n d S( Nu event( t hasattrR- ( R4 ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt __del__] s c C@ sN | j j d � r1 | j j d j | � d � n | j j d j | � � d S( Nu
order_mastersu
syndic/.*/{0}u regexu salt/job/{0}( R R6 R- R� R< ( R4 t job_id( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� e s N( ( ( ( ( ( ( ( ( ( ( ( (- R$ t
__module__t __doc__R R R; t syspathst
CONFIG_DIRRS R/ R5 R+ RR RY R� Rb Rc R] Rq Rs Rt t coroutineRv Rx R� R� R{ R� R� R� R� R� R� R� R� R� R� R� R� R� R� Rf Rr R R� ( ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR p s� # 2 , 1 ! / C � ? < > $ . � 4 7 L C % G a b t FunctionWrapperc B@ s2 e Z d Z d � Z d � Z d � Z d � Z RS( u
Create a function wrapper that looks like the functions dict on the minion
but invoked commands on the minion via a LocalClient.
This allows SLS files to be loaded with an object that calls down to the
minion when the salt functions dict is referenced.
c C@ sN t t | � j � | | _ | | _ t | j d � | _ | j � | _ d S( Nu conf_file( t superR R5 R R� R t localt _FunctionWrapper__load_functionsR2 ( R4 R R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR5 s s
c C@ s% | | j k r t � n | j | � S( u�
Since the function key is missing, wrap this call to a command to the
minion of said key if it is available in the self.functions set
( R2 Rw t run_key( R4 R, ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt __missing__z s c C@ s+ t | j j | j d � j | j g � � S( uE
Find out what functions are available on the minion
u sys.list_functions( R� R R{ R� R6 ( R4 ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt __load_functions� s c @ s � � f d � } | S( uc
Return a function that executes the arguments passed via the local
client
c @ sU t | � } x- | D]% \ } } | j d j | | � � q W� j j � j � | � S( u+
Run a remote call
u {0}={1}( R| R R< R R{ R� ( Rd R` t _keyt _val( R, R4 ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR� � s ( ( R4 R, R� ( ( R, R4 s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR � s ( R$ R R
R5 R R R ( ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR k s
t Callerc B@ sA e Z d Z e j j e j d � d d � Z d � Z
d � Z RS( u�
``Caller`` is the same interface used by the :command:`salt-call`
command-line tool on the Salt Minion.
.. versionchanged:: 2015.8.0
Added the ``cmd`` method for consistency with the other Salt clients.
The existing ``function`` and ``sminion.functions`` interfaces still
exist but have been removed from the docs.
Importing and using ``Caller`` must be done on the same machine as a
Salt Minion and it must be done using the same user that the Salt Minion is
running as.
Usage:
.. code-block:: python
import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')
Note, a running master or minion daemon is not required to use this class.
Running ``salt-call --local`` simply sets :conf_minion:`file_client` to
``'local'``. The same can be achieved at the Python level by including that
setting in a minion config file.
.. versionadded:: 2014.7.0
Pass the minion config as the ``mopts`` dictionary.
.. code-block:: python
import salt.client
import salt.config
__opts__ = salt.config.minion_config('/etc/salt/minion')
__opts__['file_client'] = 'local'
caller = salt.client.Caller(mopts=__opts__)
u minionc C@ sO d d l } | r | | _ n | j j | � | _ | j j | j � | _ d S( Ni ( t salt.minionR R t
minion_configR� t SMiniont sminion( R4 R R R ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR5 � s
c O@ s | j j | | | � S( uF
Call an execution module with the given arguments and keyword arguments
.. versionchanged:: 2015.8.0
Added the ``cmd`` method for consistency with the other Salt clients.
The existing ``function`` and ``sminion.functions`` interfaces still
exist but have been removed from the docs.
.. code-block:: python
caller.cmd('test.arg', 'Foo', 'Bar', baz='Baz')
caller.cmd('event.send', 'myco/myevent/something',
data={'foo': 'Foo'}, with_env=['GIT_COMMIT'], with_grains=True)
( R R2 ( R4 Rh Rd R` ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR{ � s c O@ sJ | j j | } t j j | t j j j | � | � \ } } | | | � S( u-
Call a single salt function
( R R2 R R� t load_args_and_kwargsR Rd t parse_input( R4 Rh Rd R` R� ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt function� s N( R$ R R
R R R; R R RS R5 R{ R ( ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR � s
% t ProxyCallerc B@ s8 e Z d Z e j j e j d � d d � Z d � Z
RS( u/
``ProxyCaller`` is the same interface used by the :command:`salt-call`
with the args ``--proxyid <proxyid>`` command-line tool on the Salt Proxy
Minion.
Importing and using ``ProxyCaller`` must be done on the same machine as a
Salt Minion and it must be done using the same user that the Salt Minion is
running as.
Usage:
.. code-block:: python
import salt.client
caller = salt.client.Caller()
caller.cmd('test.ping')
Note, a running master or minion daemon is not required to use this class.
Running ``salt-call --local`` simply sets :conf_minion:`file_client` to
``'local'``. The same can be achieved at the Python level by including that
setting in a minion config file.
.. code-block:: python
import salt.client
import salt.config
__opts__ = salt.config.proxy_config('/etc/salt/proxy', minion_id='quirky_edison')
__opts__['file_client'] = 'local'
caller = salt.client.ProxyCaller(mopts=__opts__)
.. note::
To use this for calling proxies, the :py:func:`is_proxy functions
<salt.utils.platform.is_proxy>` requires that ``--proxyid`` be an
argument on the commandline for the script this is used in, or that the
string ``proxy`` is in the name of the script.
u proxyc C@ sC d d l } | p! | j j | � | _ | j j | j � | _ d S( Ni ( R R t proxy_configR R� t SProxyMinionR ( R4 R R R ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR5 s c
O@ s� | j j | } i | d 6| d 6} | j | � t | j d g � p[ | j j d d g � } t | t j � r| | g } n x| | D]t } d j | � } | | j j
k r� t d j | � � � n | j j
| | j | | | | � } | d k r� Pq� q� W| S( uF
Call an execution module with the given arguments and keyword arguments
.. code-block:: python
caller.cmd('test.arg', 'Foo', 'Bar', baz='Baz')
caller.cmd('event.send', 'myco/myevent/something',
data={'foo': 'Foo'}, with_env=['GIT_COMMIT'], with_grains=True)
u argu funu module_executorsu direct_callu {0}.executeu Executor '{0}' is not availableN(
R R2 R� t getattrR R6 RT R RV R< t executorsR RS (
R4 Rh Rd R` R� R� R# t namet fnamet return_data( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR{ s"
% N( R$ R R
R R R; R R RS R5 R{ ( ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyR � s %!(= R
t
__future__R R R R R� R} R� R R R t
salt.cachet salt.defaults.exitcodest salt.payloadt salt.transport.clientt salt.loaderR� t salt.utils.eventt salt.utils.filest salt.utils.jidt salt.utils.minionst salt.utils.platformt salt.utils.stringutilst salt.utils.usert salt.utils.verifyt salt.utils.zeromqt
salt.syspathsR t salt.exceptionsR R R R R R R
t salt.extR R/ R� t
seco.rangeRI R� t ImportErrort tornado.genRs t getLoggerR$ R! R R; R RS R t objectR R R R R ( ( ( s8 /usr/lib/python2.7/site-packages/salt/client/__init__.pyt <module>
sb 4
� � � � � � � /N
Mini Shell