Current File : //lib/python2.7/site-packages/salt/states/saltmod.pyc
�
���^c @@ s� 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 Z d d l
Z d d l Z d d l
Z d d l Z d d l Z d d l m Z e j e � Z d Z d � Z d � Z d � Z e d d
e e e e e e e e e e e d e e e e e e e d � Z e d d
e e e e e e e e e e e d � Z d
d d d � Z d � Z d � Z d � Z! d S( u�
Control the Salt command interface
==================================
This state is intended for use from the Salt Master. It provides access to
sending commands down to minions as well as access to executing master-side
modules. These state functions wrap Salt's :ref:`Python API <python-api>`.
.. versionadded: 2016.11.0
Support for masterless minions was added to the ``salt.state`` function,
so they can run orchestration sls files. This is particularly useful when
the rendering of a state is dependent on the execution of another state.
Orchestration will render and execute each orchestration block
independently, while honoring requisites to ensure the states are applied
in the correct order.
.. seealso:: More Orchestrate documentation
* :ref:`Full Orchestrate Tutorial <orchestrate-runner>`
* :py:func:`The Orchestrate runner <salt.runners.state.orchestrate>`
i ( t absolute_importt unicode_literalst print_functionN( t sixu saltc C@ s t S( u
Named salt
( t __virtualname__( ( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt __virtual__/ s c C@ sE y t j j j t t | d � Wn t k
r@ t j d � n Xd S( Nu runu> Unable to fire args event due to missing __orchestration_jid__( t saltt utilst eventt fire_argst __opts__t __orchestration_jid__t NameErrort logt debug( t tag_data( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt
_fire_args6 s
c @ s� t � � d g � t � � d g � � � � � f d � } t t j j | t j j t � � � � � } x | D] } | j � qr Wx? � D]7 } | d k r� | \ } } } t j | | | � q� q� W� S( u
Applies a function to each element of a list, returning the resulting list.
A separate thread is created for each element in the input list and the
passed function is called for each of the elements. When all threads have
finished execution a list with the results corresponding to the inputs is
returned.
If one of the threads fails (because the function throws an exception),
that exception is reraised. If more than one thread fails, the exception
from the first thread (according to the index of the input element) is
reraised.
func:
function that is applied on each input element.
inputs:
list of elements that shall be processed. The length of this list also
defines the number of threads created.
c @ s; � � � � � f d � } t j d | � } | j � | S( Nc @ s6 y � � � � � � <Wn t j � � � <n Xd S( N( t syst exc_info( ( t errorst funct indext inputst outputs( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt
run_threadZ s t target( t threadingt Threadt start( R R t thread( R R R R ( R s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt
create_threadY s
N( t lent Nonet listR t movest mapt ranget joint reraise( R R R t threadsR t errort exc_typet exc_valuet
exc_traceback( ( R R R R s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt
_parallel_mapB s -
u globu c ' K@ sh i g d 6i d 6| d 6| d 6} | r5 | | d <n | rH | | d <n i | d 6i d 6d d
6t d 6} y t | � } Wn& t k
r� t | d <d | d
<| SX| | d
<| | d <d | k r� | d | d <n | | d <| r� d } ny | r
d } | d j | � nY | rNd } t | t � r:d j | � } n | d j | � n d | d
<t | d <| S| d> k s�t j
d � r�| d> k r�| n t j
d � | d d <n | r�| | d d <n |
d> k r�|
| d d <n |
d> k r�|
| d d <n | | d d <t | t � r,| | d d <n d | d
<t | d <| S| d> k rft j
| � | d <n | d> k r| | d <n | t k s�t j
d � r�t | d <n t d d! k o�t d" d# k } | s t i d$ d% 6| d& 6| d 6| d' 6� t d( | | | � } n� | r1d j | j d � � | d) <n% | rVd j | j d � � | d* <n | j | j d � � t | | � } i i | d 6t | t � r�| j
d+ d, � n d, d+ 6t d- 6} y" | t t | � � d. | d/ <Wn t t f k
r�n Xi } t � } t � }! | d> k r%d? } nn t | t j � rbg | j d � D] }" |" j � ^ qG} n1 t | t � s�| j d0 g � j d1 � d@ } n | r�| r�t | d <d2 | d
<| Sx�t j | � D]�\ }" }# |# j
d+ d � d, k r�t j d3 � n t }$ d4 |# k r0d |# k r0|# j d4 � |# d <n t }% |# j
d5 t � rQt }% nG y |# d }$ Wn t k
rxt }% n X|% r�t d6 |$ d7 t �}% n |% s�|" | k r�| j |" � n |$ | |" <q�n ya xZ t j! |$ � D]< }& t |& t � r�d |& k r|& d r|$ | |" <Pqq�q�W|! j |" � Wq�t" k
rdt j# d8 t$ |$ � |$ � |! j |" � q�Xq�W| r�i d, d+ 6| d 6| d <n t% | � | k r�t | d <d9 j& d: j | � � | d
<n` d; | d
<| r�| d
c d< j& d: j | � � 7<n |! r%| d
c d= j& d: j |! � � 7<n | s:t j
d � rd| d rd| d t k rdd> | d <qdn | S(A u5
Invoke a state run on a given target
name
An arbitrary name used to track the state execution
tgt
The target specification for the state run.
.. versionadded: 2016.11.0
Masterless support: When running on a masterless minion, the ``tgt``
is ignored and will always be the local minion.
tgt_type
The target type to resolve, defaults to ``glob``
ret
Optionally set a single or a list of returners to use
ret_config
Use an alternative returner configuration
ret_kwargs
Override individual returner configuration items
highstate
Defaults to None, if set to True the target systems will ignore any
sls references specified in the sls option and call state.highstate
on the targeted minions
top
Should be the name of a top file. If set state.top is called with this
top file instead of state.sls.
sls
A group of sls files to execute. This can be defined as a single string
containing a single sls file, or a list of sls files
test
Pass ``test=true`` or ``test=false`` through to the state function. This
can be used to overide a test mode set in the minion's config file. If
left as the default of None and the 'test' mode is supplied on the
command line, that value is passed instead.
pillar
Pass the ``pillar`` kwarg through to the state function
pillarenv
The pillar environment to grab pillars from
.. versionadded:: 2017.7.0
saltenv
The default salt environment to pull sls files from
ssh
Set to `True` to use the ssh client instead of the standard salt client
roster
In the event of using salt-ssh, a roster system can be set
expect_minions
An optional boolean for failing if some minions do not respond
fail_minions
An optional list of targeted minions where failure is an option
allow_fail
Pass in the number of minions to allow for failure before setting
the result of the execution to False
concurrent
Allow multiple state runs to occur at once.
WARNING: This flag is potentially dangerous. It is designed
for use when multiple state runs can safely be run at the same
Do not use this flag for performance optimization.
queue
Pass ``queue=true`` through to the state function
batch
Execute the command :ref:`in batches <targeting-batch>`. E.g.: ``10%``.
.. versionadded:: 2016.3.0
subset
Number of minions from the targeted set to randomly use
.. versionadded:: 2017.7.0
failhard
pass failhard down to the executing state
.. versionadded:: 2019.2.2
Examples:
Run a list of sls files via :py:func:`state.sls <salt.state.sls>` on target
minions:
.. code-block:: yaml
webservers:
salt.state:
- tgt: 'web*'
- sls:
- apache
- django
- core
- saltenv: prod
Run a full :py:func:`state.highstate <salt.state.highstate>` on target
mininons.
.. code-block:: yaml
databases:
salt.state:
- tgt: role:database
- tgt_type: grain
- highstate: True
u argu kwargu retu timeoutu
ret_configu
ret_kwargsu nameu changesu u commentu resultu5 Passed invalid value for 'allow_fail', must be an intu tgt_typeu sshu rosteru expect_minionsu state.highstateu state.topu state.slsu ,u0 No highstate or sls specified, no execution madeu testu pillaru pillarenvu saltenvu queueu
concurrentu. Must pass in boolean for value of 'concurrent'u batchu subsetu failhardu __roleu minionu file_clientu localu stateu typeu tgtu argsu saltutil.cmdu topfnu modsu outu highstateu idu jidu __jid__u warningsuG 'fail_minions' needs to be a list or a comma separated string. Ignored.u No minions returnedu$ Output from salt state not highstateu returnu failedu state.check_resultt recurseu m_ret did not have changes %s %su Run failed on minions: {0}u , u States ran successfully.u Updating {0}.u No changes made to {0}.N( ( (' t Truet intt
ValueErrort Falset appendt
isinstanceR! R% R R
t gett boolR t text_typeR t __salt__t popt updatet dictt nextt itert
StopIterationt KeyErrort sett string_typest splitt stript
setdefaultt iteritemsR
t warningt __utils__t addt
itervaluest AttributeErrorR( t typeR t format(' t namet tgtt ssht tgt_typet rett
ret_configt
ret_kwargst highstatet slst topt saltenvt testt pillart pillarenvt expect_minionst fail_minionst
allow_failt
concurrentt timeoutt batcht queuet subsett orchestration_jidt failhardt kwargst cmd_kwt state_rett funt
masterlesst cmd_rett tmp_rett changest failt no_changet miniont mdatat m_rett m_statet
state_item( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt statel s �"
,
& 3" +
%%c K@ si i | d 6i d 6d d 6t d 6} | d+ k r7 i } n t |
t j � re d g | d <|
j � }
n i |
pq g d 6| d 6| d
6| d 6} |
d+ k r� t j |
� | d <n | d+ k r� | | d
<n | | d <| | d <| | d <t | d <| t k s t j d � rt | d <n | r+| | d <n | r>| | d <n | } t d t k rxd j | | � | d <d+ | d <| Sy@ t
i d d 6| d 6| d 6| d 6� t d | | | � } Wn1 t k
r�} t
| d <t j | � | d <| SXy" | t t | � � d | d <Wn t t f k
r'n Xi } t � } | d+ k rLd, } nn t | t j � r�g | j d � D] } | j � ^ qn} n1 t | t � s�| j d g � j d � d- } n x t j | � D]� \ } } t
} | j d � rt
| d <| j | � n | j d! t
� r t
} nj d" | k rNd
| k rN| j d" � | d
<n | d
} | ret prt | | � } | t
k r�t
} n | s�| | k r�| j | � q�n | | | <q�W| s�t
| d <d# | d$ <n� | r�i d% d& 6| d
6| d <n | r-t
| d <d' j | d( j | � � | d <n
d) | d <| re| d c d* j | d( j | � � 7<n | S(. um
Execute a single module function on a remote minion via salt or salt-ssh
name
The name of the function to run, aka cmd.run or pkg.install
tgt
The target specification, aka '*' for all minions
tgt_type
The target type, defaults to ``glob``
arg
The list of arguments to pass into the function
kwarg
The dict (not a list) of keyword arguments to pass into the function
ret
Optionally set a single or a list of returners to use
ret_config
Use an alternative returner configuration
ret_kwargs
Override individual returner configuration items
expect_minions
An optional boolean for failing if some minions do not respond
fail_minions
An optional list of targeted minions where failure is an option
fail_function
An optional string that points to a salt module that returns True or False
based on the returned data dict for individual minions
ssh
Set to `True` to use the ssh client instead of the standard salt client
batch
Execute the command :ref:`in batches <targeting-batch>`. E.g.: ``10%``.
subset
Number of minions from the targeted set to randomly use
.. versionadded:: 2017.7.0
failhard
pass failhard down to the executing state
.. versionadded:: 2019.2.2
u nameu changesu u commentu resultu, Please specify 'arg' as a list of arguments.u warningsu argu kwargu retu timeoutu batchu subsetu tgt_typeu sshu expect_minionsu _cmd_metau failhardu
ret_configu
ret_kwargsu testu, Function {0} would be executed on target {1}u functionu typeu tgtu argsu saltutil.cmdu jidu __jid__u ,uG 'fail_minions' needs to be a list or a comma separated string. Ignored.u retcodeu failedu returnu No minions respondedu commandu highstateu outu+ Running function {0} failed on minions: {1}u , u Function ran successfully.u Function {0} ran on {1}.N( ( ( R. R R3 R R@ RA R6 R
R4 RK R R7 t ExceptionR1 R; R< R= R> R? RB R! RC R2 RD RG R8 R% ( RL RM RN RO RP RQ RR RZ R[ t
fail_functiont argt kwargR^ R_ Ra Rc Rd t func_retRe Rg Ri t excRk Rl Rn Ro Rp t m_func( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt function� s� H
(
&
" +
"
(u idi, u masterc C@ s� i | d 6i d 6d d 6t d 6} t j d � rR d j | � | d <d | d <| St j j j | t d t d d
t d t �} d } t
j
� } | | } x�t r�| j d
t � }
t
j
� | k } |
d k r� | r� t j d � q� n |
d k r| rd | d <| St
j
|
d | � r |
d j | � } | d k rod |
d k ro|
d d j | � } n | d k ry | j | � }
Wn! t k
r�t j d | � qX| |
=| d 7} | d j d g � } | j | � t j d | t | � � q0t j d | |
d � n t j d |
d � t | � d k rmt | d <d j t
j
� | � | d <| S| r� d | d <| Sq� Wd S( u
Watch Salt's event bus and block until a condition is met
.. versionadded:: 2014.7.0
name
An event tag to watch for; supports Reactor-style globbing.
id_list
A list of event identifiers to watch for -- usually the minion ID. Each
time an event tag is matched the event data is inspected for
``event_id``, if found it is removed from ``id_list``. When ``id_list``
is empty this function returns success.
event_id : id
The name of a key in the event data. Default is ``id`` for the minion
ID, another common value is ``name`` for use with orchestrating
salt-cloud events.
timeout : 300
The maximum time in seconds to wait before failing.
The following example blocks until all the listed minions complete a
restart and reconnect to the Salt master:
.. code-block:: yaml
reboot_all_minions:
salt.function:
- name: system.reboot
- tgt: '*'
wait_for_reboots:
salt.wait_for_event:
- name: salt/minion/*/start
- id_list:
- jerry
- stuart
- dave
- phil
- kevin
- mike
- require:
- salt: reboot_all_minions
u nameu changesu u commentu resultu testu( Orchestration would wait for event '{0}'u sock_diru transportt optst listeni t fullu' wait_for_event: No event data; waiting.u Timeout value reached.u tagu datau? wait_for_event: Event identifier '%s' not in id_list; skipping.i u minions_seenuO wait_for_event: Event identifier '%s' removed from id_list; %s items remaining.uB wait_for_event: Event identifier '%s' not in event '%s'; skipping.u- wait_for_event: Skipping unmatched event '%s'u All events seen in {0} seconds.N( R1 R
R4 RK R R R R t get_eventR. t timeR
t tracet fnmatchR R0 RC R2 R R ( RL t id_listt event_idR^ t nodeRP t seventt del_countert starttimet timelimitR t is_timedoutt valt val_idxt minions_seen( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt wait_for_eventV sf 0"
c K@ sO y
t } Wn$ t k
r0 t j d � d } n Xt j d t � rr i | d 6d d 6i d 6d j | � d 6} | St d | d | d
t
d t | �} | j d � } t | t
� r� d
| k r� t | d <n | j d t � } i | d 6i | d 6d 6| d 6} d j | | rd n d � | d <t | d <d | k rK| d | d <n | S( u1
Execute a runner module on the master
.. versionadded:: 2014.7.0
name
The name of the function to run
kwargs
Any keyword arguments to pass to the runner function
.. code-block:: yaml
run-manage-up:
salt.runner:
- name: manage.up
u> Unable to fire args event due to missing __orchestration_jid__u testu nameu resultu changesu( Runner function '{0}' would be executed.u commentu saltutil.runnerR t __env__t full_returnu returnu Erroru successu Runner function '{0}' {1}.u executedu failedu __orchestration__u jidu __jid__N( R R R
R R R
R4 R1 RK R7 R� R. R3 R: ( RL Rd t jidRP t outt
runner_returnt success( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt runner� s@
c
@ s� t | t j � r, i i | | 6g | 6} n t | t � s[ i | d 6t d 6i d 6d d 6Sxj t j | � D]Y \ } } | d k r� i } n t j j j
| � } d | k r� | | d <n | | | <qk Wy
t � Wn$ t k
r� t
j d � d � n X� f d � } y" t | t t j | � � � } WnF t j j k
rr} i | d 6t d 6t d 6i d 6d j | � d 6SXd
� t j j t j | � | � D� } t g t j | � D]* } | j d d � d
k o�d | k ^ q�� } � f d � � | r�g t j | � D]. \ } } | d j d d � d k r| ^ q}
|
} | rPd } nP g |
D]4 } d j | t j j | | d t d d �� ^ qW}
d j |
� } i } x� t j | � D]/ \ } } � | d � } | r�| | | <q�q�Wn� g t j | � D]* \ } } | j d d � d k r�| ^ q�}
|
} | rBd } n@ t |
� d k rjd j |
d � } n d j d j |
� � } i d � t j | � D� d 6} i | d 6| d 6| d 6| d 6} | S( uj
Executes multiple runner modules on the master in parallel.
.. versionadded:: 2017.x.0 (Nitrogen)
A separate thread is spawned for each runner. This state is intended to be
used with the orchestrate runner in place of the ``saltmod.runner`` state
when different tasks should be run in parallel. In general, Salt states are
not safe when used concurrently, so ensure that they are used in a safe way
(e.g. by only targeting separate minions in parallel tasks).
name:
name identifying this state. The name is provided as part of the
output, but not used for anything else.
runners:
list of runners that should be run in parallel. Each element of the
list has to be a dictionary. This dictionary's name entry stores the
name of the runner function that shall be invoked. The optional kwarg
entry stores a dictionary of named arguments that are passed to the
runner function.
.. code-block:: yaml
parallel-state:
salt.parallel_runners:
- runners:
my_runner_1:
- name: state.orchestrate
- kwarg:
mods: orchestrate_state_1
my_runner_2:
- name: state.orchestrate
- kwarg:
mods: orchestrate_state_2
u nameu resultu changesu/ The runners parameter must be a string or dict.u commentu> Unable to fire args event due to missing __orchestration_jid__c @ s3 t d | d d � d t d t | j d i � �S( Nu saltutil.runneru nameR R� R� u kwarg( R7 R� R. R4 ( t
runner_config( R� ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt call_runnerQ s
u successu+ One of the runners raised an exception: {0}c S@ s# i | ] \ } } | d | � q S( u return( ( t .0t runner_idR� ( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pys
<dictcomp>h s u outputteru u highstateu datac @ s� t | t � s i Sd | k ru t | d t � rj | d j d d � d k rj d | d k rj | d d S| d SnI i } x< t j | � D]+ \ } } � | � } | r� | | | <q� q� W| Sd S( Nu changesu outu u highstateu ret( R3 R: R4 R RD ( t objt
found_changest keyt valuet change( t extract_changes( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyR� w s u retcodei u+ All runner functions executed successfully.u( Runner {0} failed with return value:
{1}u nestedt
nested_indenti u
u exit_codei u Runner {0} failed.u Runners {0} failed.u , c S@ s i | ] \ } } | | � q S( ( ( R� R� R� ( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pys
<dictcomp>� s u retN( R3 R R@ R: R1 RD R R R t datat repack_dictlistR R R
R R, R! RH t
exceptionst
SaltExceptionRK R" t zipt iterkeyst allR4 t outputt
out_formatR
R% R ( RL t runnersRd R� R� R� R Ry R� t highstate_outputt failed_runnerst all_successfult commentt runner_commentsRk t runner_changesRP ( ( R� R� s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt parallel_runners s� ,
" "@( > $
c K@ sg i | d 6t d 6i d 6d d 6} y
t } Wn$ t k
rR t j d � d } n Xt j d t � r� d | d <i | d <d j | � | d <| St d | d
| d t
| �} | j d � } t | t � r� d
| k r� t | d <n | j d t
� } i | d 6i | d 6d 6| d 6} d j | | r/d n d � | d <t
| d <d | k rc| d | d <n | S( uM
Execute a wheel module on the master
.. versionadded:: 2014.7.0
name
The name of the function to run
kwargs
Any keyword arguments to pass to the wheel function
.. code-block:: yaml
accept_minion_key:
salt.wheel:
- name: key.accept
- match: frank
u nameu resultu changesu u commentu> Unable to fire args event due to missing __orchestration_jid__u testu' Wheel function '{0}' would be executed.u saltutil.wheelR R� u returnu Erroru successu Wheel function '{0}' {1}.u executedu failedu __orchestration__u jidu __jid__N( N( R1 R R R
R R R
R4 RK R7 R� R3 R: R. ( RL Rd RP R� R� t wheel_returnR� ( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt wheel� s< "
(" t __doc__t
__future__R R R R� t loggingR R R� t
salt.syspathsR t salt.exceptionst salt.outputt salt.utils.datat salt.utils.eventt salt.extR t getLoggert __name__R
R R R R, R1 R R. Rs R{ R� R� R� R� ( ( ( s7 /usr/lib/python2.7/site-packages/salt/states/saltmod.pyt <module> sx , � * � n < �
Mini Shell