Current File : //usr/lib/python2.7/site-packages/salt/modules/state.pyo
�
���^c @@ sx 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 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 m Z m Z d d l! m" a# d d l$ m% Z% d d l& m' Z' d d l( Z( d g Z) i d d
6d d 6d d 6d d
6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6Z* i d d 6Z+ e j, e- � Z. d Z/ d � Z0 d � Z1 e2 d � Z3 e2 d � Z4 d � Z5 d � Z6 d � Z7 e2 d � Z8 e2 d � Z9 e2 d � Z: e2 e2 d! � Z; e2 d" � Z< d# e2 e2 e2 e2 d$ � Z" e= d% � Z> d& � Z? d' � Z@ d( � ZA e= d) � ZB e2 d* � ZC e2 e= d+ � ZD e= d, � ZE e= d- � ZF e2 d. � ZG e2 d/ � ZH e2 d0 � ZI e2 d1 � ZJ d2 d3 � ZK e2 e= d4 � ZL e2 e2 e= e2 d5 � ZM e2 e= d6 � ZN e= d7 � ZO e= d8 � ZP e= d9 � ZQ e= d: � ZR e2 e= d; � ZS e2 e= d< � ZT e2 e= d= � ZU e2 e= d> � ZV e2 e= d? � ZW e= d@ � ZX e2 e= dA � ZY dB � ZZ e2 dC � Z[ dD � Z\ dE � Z] dF � Z^ dG � Z_ d dH e= e2 e= dI dJ � Z` d S(K uB
Control the state system on the minion.
State Caching
-------------
When a highstate is called, the minion automatically caches a copy of the last
high data. If you then run a highstate with cache=True it will use that cached
highdata and won't hit the fileserver except for ``salt://`` links in the
states themselves.
i ( t absolute_importt print_functiont unicode_literalsN( t CommandExecutionErrort SaltInvocationError( t orchestrate( t OrderedDict( t sixu *u highstateu slsu sls_idu pkgu topu singleu templateu template_stru apply_u requestu
check_requestu run_requestu applyu statec C@ s t j j j t t � � a t S( u
Set the virtualname
( t saltt utilst functoolst namespaced_functiont _orchestratet globalst __virtualname__( ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt __virtual__L s c C@ s# t d � t j | � D� � } | S( u7
Filter out the result: True + no changes data
c s@ s6 | ], \ } } | d s$ | d r | | f Vq d S( u resultu changesN( ( t .0t tagt value( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pys <genexpr>[ s ( t dictR t iteritems( t runningst ret( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _filter_runningW s c C@ si t j j j t d <t | t � r9 t j j j t d <d St d | d | �se t j j j t d <n d S( uJ
Set the return code based on the data back from the state system
u retcodeNu state.check_resultt highstate(
R t defaultst exitcodest EX_OKt __context__t
isinstancet listt EX_STATE_COMPILER_ERRORt __utils__t EX_STATE_FAILURE( R R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _set_retcode` s c C@ s8 | j d � r d S| p i j d t j d � � p7 d S( u�
Checks all pillars (external and internal) for errors.
Return an error message, if anywhere or None.
:param kwargs: dictionary of options
:param pillar: external pillar
:return: None or an error message
u forceu _errorsN( t gett Nonet
__pillar__( t kwargst pillar( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _get_pillar_errorso s c C@ sZ | d k r$ t j j j t � } n t | � } x# | rU t j d � t | � } q3 Wd S( uF
Wait for all previously started state jobs to finish running
i N( R$ R R t jidt gen_jidt __opts__t _prior_running_statest timet sleep( R) t states( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _wait{ s
c
C@ s� d
} y[ | d r` t j d � r` t d d t j d d � d d d d
j | � d | � } n Wn! t k
r� t j d | � n X| S( u'
Create a snapper pre snapshot
u testu snapper_statesu snapper.create_snapshott configu snapper_states_configu roott
snapshot_typeu pret descriptionu Salt State run for jid {0}t __pub_jidu1 Failed to create snapper pre snapshot for jid: %sN( R$ R+ R# t __salt__t formatt Exceptiont logt error( t optsR) t snapper_pre( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _snapper_pre� s
c
C@ s� ye | d rd t j d � rd | rd t d d t j d d � d d d | d
d j | � d | � n Wn! t k
r� t j d
| � n Xd S( u)
Create the post states snapshot
u testu snapper_statesu snapper.create_snapshotR1 u snapper_states_configu rootR2 u postt
pre_numberR3 u Salt State run for jid {0}R4 u1 Failed to create snapper pre snapshot for jid: %sN( R+ R# R5 R6 R7 R8 R9 ( R: R) t pre_num( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
_snapper_post� s
c C@ s� t j j t d d � } t j j | | � } t j j | � sh y t j | � Wqh t k
rd qh Xn i } | d k r� | | k r� i | | <q� n t j j | � r� t j j
j | d � � } t j
| j � � } Wd QXn | | f S( u6
Return the pause information for a given jid
u cachediru state_pauseu rbN( t ost patht joinR+ t existst makedirst OSErrorR$ R R t filest fopent msgpackt loadst read( R) t state_idt pause_dirt
pause_patht datat fp_( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
_get_pause� s
c
C@ sC i } t d d � } t j j t d d � } t j j | � sE | S| d k rc t j | � } n9 t | t � r� t
j j j
| � } n t j | � g } x� | D]� } t } x' | D] } | d | k r� t } q� q� W| s y& t j j | | � } t j | � Wq� t k
rq� Xq� n t | � \ } } | | | <q� W| S( u�
Get a report on all of the currently paused state runs and pause
run settings.
Optionally send in a jid if you only desire to see a single pause
data set.
u saltutil.is_runningu state.*u cachediru state_pauseu jidN( R5 R@ RA RB R+ RC R$ t listdirR R R R RN t stringifyR t text_typet Falset Truet removeRE RP (
R) R t activeRL t jidst scan_jidt is_activet active_dataRM RN ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
get_pauses� s2
c C@ s� t j | � } | d k r$ d } n t | | � \ } } t | | d <t j j j | d � � } | j t
j | � � Wd QXd S( u�
Set up a state run to die before executing the given state id,
this instructs a running state to safely exit at a given
state id. This needs to pass in the jid of the running state.
If a state_id is not passed then the jid referenced will be safely exited
at the beginning of the next state run.
The given state id is the id got a given state execution, so given a state
that looks like this:
.. code-block:: yaml
vim:
pkg.installed: []
The state_id to pass to `soft_kill` is `vim`
CLI Examples:
.. code-block:: bash
salt '*' state.soft_kill 20171130110407769519
salt '*' state.soft_kill 20171130110407769519 vim
u __all__u killu wbN( R RS R$ RP RU R R RF RG t writeRH t dumps( R) RK RN RM RO ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt soft_kill� s c C@ s� t j | � } | d k r$ d } n t | | � \ } } | rV t | � | | d <n t j j j | d � � } | j t
j | � � Wd QXd S( u�
Set up a state id pause, this instructs a running state to pause at a given
state id. This needs to pass in the jid of the running state and can
optionally pass in a duration in seconds. If a state_id is not passed then
the jid referenced will be paused at the beginning of the next state run.
The given state id is the id got a given state execution, so given a state
that looks like this:
.. code-block:: yaml
vim:
pkg.installed: []
The state_id to pass to `pause` is `vim`
CLI Examples:
.. code-block:: bash
salt '*' state.pause 20171130110407769519
salt '*' state.pause 20171130110407769519 vim
salt '*' state.pause 20171130110407769519 vim 20
u __all__u durationu wbN( R RS R$ RP t intR R RF RG R] RH R^ ( R) RK t durationRN RM RO ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt pause s c C@ s� t j | � } | d k r$ d } n t | | � \ } } | | k rU | j | � n | d k rj i } n t j j j | d � � } | j t
j | � � Wd QXd S( u
Remove a pause from a jid, allowing it to continue. If the state_id is
not specified then the a general pause will be resumed.
The given state_id is the id got a given state execution, so given a state
that looks like this:
.. code-block:: yaml
vim:
pkg.installed: []
The state_id to pass to `rm_pause` is `vim`
CLI Examples:
.. code-block:: bash
salt '*' state.resume 20171130110407769519
salt '*' state.resume 20171130110407769519 vim
u __all__u wbN( R RS R$ RP t popR R RF RG R] RH R^ ( R) RK RN RM RO ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt resume) s u basec
C@ s+ t d | d | d | d | d | d | � S( u"
.. versionadded:: 2016.11.0
Execute the orchestrate runner from a masterless minion.
.. seealso:: More Orchestrate documentation
* :ref:`Full Orchestrate Tutorial <orchestrate-runner>`
* :py:mod:`Docs for the ``salt`` state module <salt.states.saltmod>`
CLI Examples:
.. code-block:: bash
salt-call --local state.orchestrate webserver
salt-call --local state.orchestrate webserver saltenv=dev test=True
salt-call --local state.orchestrate webserver saltenv=dev pillarenv=aws
t modst saltenvt testt excludeR' t pillarenv( R ( Re Rf Rg Rh R' Ri ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR K s c C@ sy g } | r | St d d � } xR | D]J } d j | d | d t j j j | d � | d � } | j | � q' W| S( u
Return a list of strings that contain state return data if a state function
is already running. This function is used to prevent multiple state calls
from being run at the same time.
CLI Example:
.. code-block:: bash
salt '*' state.running
u saltutil.is_runningu state.*uL The function "{0}" is running as PID {1} and was started at {2} with jid {3}u funu pidu jid( R5 R6 R R R) t jid_to_timet append( t
concurrentR RW RN t err( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt runningk s
c C@ sx g } t d d � } x[ | D]S } y t | d � } Wn t k
rM q n X| t | � k r | j | � q q W| S( u�
Return a list of dicts of prior calls to state functions. This function is
used to queue state calls so only one is run at a time.
u saltutil.is_runningu state.*u jid( R5 R` t
ValueErrorRk ( R) R RW RN t data_jid( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR, � s
c C@ sX | r t | j d � � n8 t d | j d t � � } | rT t j j j t d <| Sd S( uy
Utility function to queue the state run if requested
and to check for conflicts in currently running states
u __pub_jidRl u
concurrentu retcodeN( R0 R# Rn RT R R R R R ( t queueR& t conflict( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _check_queue� s c C@ s4 t j d d � d k r0 | d t d k r0 t Sd S( Nu __cliu salt-callu pillarenv( R+ R# R$ R% ( R: ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _get_initial_pillar� s c K@ s� t | | � } | d k r | Sy t j j t d t �} Wn# t k
r` t j j t � } n X| j | � } | r� t j j
j t d <| S| j
| � } t | t � r� t j j
j t d <n t d | � r� t j j
j t d <n | S( u
Execute a single low data call
This function is mostly intended for testing the state system and is not
likely to be needed in everyday usage.
CLI Example:
.. code-block:: bash
salt '*' state.low '{"state": "pkg", "fun": "installed", "name": "vi"}'
t proxyu retcodeu state.check_resultN( Rs R$ R t statet StateR+ t __proxy__t NameErrort verify_dataR R R R t callR R R R! ( RN Rq R& Rr t st_Rm R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt low� s"
c K@ sz t } | d k rp t j j j d | | � r6 t } qv t d d d t �t k r[ t } qv t j d d � } n | } | S( u8
Determine the correct value for the test flag.
Rg u
config.getu testt omit_optsN( RU R$ R R t argst test_modeR5 R+ R# ( Rg R& R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt _get_test_value� s c
K@ s4 t | | � } | d
k r | St j j j t | � } t | | � | d <| j d � } | j d � } | d
k r� | d
k r� t | t
� r� t d � � n y7 t j j | | d | d t
d t d t | � �} Wn8 t k
rt j j | | d | d t | � �} n X| j | � } t | d | �| S( u,
Execute the compound calls stored in a single set of high data
This function is mostly intended for testing the state system and is not
likely to be needed in everyday usage.
CLI Example:
.. code-block:: bash
salt '*' state.high '{"vim": {"pkg": ["installed"]}}'
u testu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.t
pillar_encRu t contextt initial_pillarR N( Rs R$ R R Rv t get_sls_optsR+ R� R# R R R Rw Rx R Rt Ry t call_highR" (
RN Rg Rq R& Rr R: t pillar_overrideR� R| R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt high� s6
c K@ s� d | k r | j d � n t | | � } | d k r; | St j j j t | � } y. t j j | d t d t
d t | � �} Wn5 t k
r� t j j | d t d t | � �} n Xt
| d | j d �} | r t j j j t d <t d d | �� n | j d
� s$d j d | � } n | j | | j d
d � d d d t �\ } } | rqt j j j t d <| S| j j | � } t | d | �| S( uL
Execute the information stored in a template file on the minion.
This function does not ask a master for a SLS file to render but
instead directly processes the file at the provided path on the minion.
CLI Example:
.. code-block:: bash
salt '*' state.template '<Path to template on the minion>'
u envR� Ru R� R' u pillaru retcodeu Pillar failed to rendert infou .slsu {sls}.slst slsu saltenvu t localR N( Rc Rs R$ R R Rv R� R+ t HighStateR Rx Rt Ry R( R: R R t EX_PILLAR_FAILURER t endswithR6 t render_stateR# RU R R� R" ( t temRq R& Rr R: R| t errorst
high_stateR ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt template s@
c K@ s� t | | � } | d k r | St j j j t | � } y( t j j | d t d t | � �} Wn/ t
k
r� t j j | d t | � �} n X| j | � } t | � | S( u�
Execute the information stored in a string from an sls template
CLI Example:
.. code-block:: bash
salt '*' state.template_str '<Template String>'
Ru R� N(
Rs R$ R R Rv R� R+ Rw Rx Rt Ry t call_template_strR" ( R� Rq R& Rr R: R| R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt template_strC s
"
c K@ s | r t | | � St | � S( u�
.. versionadded:: 2015.5.0
This function will call :mod:`state.highstate
<salt.modules.state.highstate>` or :mod:`state.sls
<salt.modules.state.sls>` based on the arguments passed to this function.
It exists as a more intuitive way of applying states.
.. rubric:: APPLYING ALL STATES CONFIGURED IN TOP.SLS (A.K.A. :ref:`HIGHSTATE <running-highstate>`)
To apply all configured states, simply run ``state.apply``:
.. code-block:: bash
salt '*' state.apply
The following additional arguments are also accepted when applying all
states configured in top.sls:
test
Run states in test-only (dry-run) mode
mock
The mock option allows for the state run to execute without actually
calling any states. This then returns a mocked return which will show
the requisite ordering as well as fully validate the state run.
.. versionadded:: 2015.8.4
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. code-block:: bash
salt '*' state.apply stuff pillar='{"foo": "bar"}'
.. note::
Values passed this way will override Pillar values set via
``pillar_roots`` or an external Pillar source.
exclude
Exclude specific states from execution. Accepts a list of sls names, a
comma-separated string of sls names, or a list of dictionaries
containing ``sls`` or ``id`` keys. Glob-patterns may be used to match
multiple states.
.. code-block:: bash
salt '*' state.apply exclude=bar,baz
salt '*' state.apply exclude=foo*
salt '*' state.apply exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
queue : False
Instead of failing immediately when another state run is in progress,
queue the new state run to begin running once the other has finished.
This option starts a new thread for each queued state run, so use this
option sparingly.
localconfig
Optionally, instead of using the minion config, load minion opts from
the file specified by this argument, and then merge them with the
options from the minion config. This functionality allows for specific
states to be run with their own custom minion configuration, including
different pillars, file_roots, etc.
.. code-block:: bash
salt '*' state.apply localconfig=/path/to/minion.yml
.. rubric:: APPLYING INDIVIDUAL SLS FILES (A.K.A. :py:func:`STATE.SLS <salt.modules.state.sls>`)
To apply individual SLS files, pass them as a comma-separated list:
.. code-block:: bash
# Run the states configured in salt://stuff.sls (or salt://stuff/init.sls)
salt '*' state.apply stuff
# Run the states configured in salt://stuff.sls (or salt://stuff/init.sls)
# and salt://pkgs.sls (or salt://pkgs/init.sls).
salt '*' state.apply stuff,pkgs
The following additional arguments are also accepted when applying
individual SLS files:
test
Run states in test-only (dry-run) mode
mock
The mock option allows for the state run to execute without actually
calling any states. This then returns a mocked return which will show
the requisite ordering as well as fully validate the state run.
.. versionadded:: 2015.8.4
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. code-block:: bash
salt '*' state.apply stuff pillar='{"foo": "bar"}'
.. note::
Values passed this way will override Pillar values set via
``pillar_roots`` or an external Pillar source.
queue : False
Instead of failing immediately when another state run is in progress,
queue the new state run to begin running once the other has finished.
This option starts a new thread for each queued state run, so use this
option sparingly.
concurrent : False
Execute state runs concurrently instead of serially
.. warning::
This flag is potentially dangerous. It is designed for use when
multiple state runs can safely be run at the same time. Do *not*
use this flag for performance optimization.
saltenv
Specify a salt fileserver environment to be used when applying states
.. versionchanged:: 0.17.0
Argument name changed from ``env`` to ``saltenv``
.. versionchanged:: 2014.7.0
If no saltenv is specified, the minion config will be checked for an
``environment`` parameter and if found, it will be used. If none is
found, ``base`` will be used. In prior releases, the minion config
was not checked and ``base`` would always be assumed when the
saltenv was not explicitly set.
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
localconfig
Optionally, instead of using the minion config, load minion opts from
the file specified by this argument, and then merge them with the
options from the minion config. This functionality allows for specific
states to be run with their own custom minion configuration, including
different pillars, file_roots, etc.
.. code-block:: bash
salt '*' state.apply stuff localconfig=/path/to/minion.yml
sync_mods
If specified, the desired custom module types will be synced prior to
running the SLS files:
.. code-block:: bash
salt '*' state.apply stuff sync_mods=states,modules
salt '*' state.apply stuff sync_mods=all
.. note::
This option is ignored when no SLS files are specified, as a
:ref:`highstate <running-highstate>` automatically syncs all custom
module types.
.. versionadded:: 2017.7.8,2018.3.3,2019.2.0
( R� R ( Re R& ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt apply_^ s �
c K@ s- t | d <t | | � } t j j t d d � } t j j t � } t � } | j
i i | d 6| d 6| d 6| j d d � 6� t j j
j d � �� ya t j j j � r� t d
d j | � � n t j j
j | d � � } | j | | � Wd
QXWn' t t f k
r"t j d | � n XWd
QX| S( uJ
.. versionadded:: 2015.5.0
Request that the local admin execute a state run via
`salt-call state.run_request`.
All arguments match those of state.apply.
CLI Example:
.. code-block:: bash
salt '*' state.request
salt '*' state.request stuff
salt '*' state.request stuff,pkgs
u testu cachediru req_state.pu test_runu modsu kwargsu nameu defaulti? u cmd.runu attrib -R "{0}"u w+bNu8 Unable to write state request file %s. Check permission.( RU R� R@ RA RB R+ R t payloadt Serialt
check_requestt updateR# R RF t set_umaskt platformt
is_windowsR5 R6 RG t dumpt IOErrorRE R8 R9 ( Re R& R t notify_patht serialt reqRO ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt request s(
c C@ s� t j j t d d � } t j j t � } t j j | � r t j j j
| d � � } | j | � } Wd QX| r{ | | S| Si S( u�
.. versionadded:: 2015.5.0
Return the state request information, if any
CLI Example:
.. code-block:: bash
salt '*' state.check_request
u cachediru req_state.pu rbN( R@ RA RB R+ R R� R� t isfileR RF RG t load( t nameR� R� RO R� ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR� 9 s c C@ sI t j j t d d � } t j j t � } t j j | � sA t S| su y t j | � WqEt
t f k
rq qEXn� t � } | | k r� | j
| � n t St j j j d � �� ya t j j j � r� t d d j | � � n t j j j | d � � } | j | | � Wd QXWn' t
t f k
r>t j d | � n XWd QXt S( u�
.. versionadded:: 2015.5.0
Clear out the state execution request without executing it
CLI Example:
.. code-block:: bash
salt '*' state.clear_request
u cachediru req_state.pi? u cmd.runu attrib -R "{0}"u w+bNu8 Unable to write state request file %s. Check permission.( R@ RA RB R+ R R� R� R� RU RV R� RE R� Rc RT R RF R� R� R� R5 R6 RG R� R8 R9 ( R� R� R� R� RO ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
clear_requestP s0 u defaultc K@ s� t � } | | k r i S| | } d | k s; d | k r? i S| | d j | � d | d k rx | d j d � n | r� t | d | d � } y$ t j t j j t d d � � Wn t t
f k
r� n X| Si S( u�
.. versionadded:: 2015.5.0
Execute the pending state request
CLI Example:
.. code-block:: bash
salt '*' state.run_request
u modsu kwargsu testu cachediru req_state.p( R� R� Rc R� R@ RV RA RB R+ R� RE ( R� R& R� t n_reqR ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt run_requestz s"
$c
K@ s\ t d g � r; t j d � i d d 6d d 6d d 6} | St | | � } | d% k rZ | St j d d% � } t j j j
t | � } t | | � | d <d | k r� | j d � n d
| k r� | d
| d
<n d | k r� | d | d <n | j d � } | j d
� } | d% k rB| d% k rBt
| t � rBt d � � n yU t j j | | | j d � d | d t d t d | j d t � d t | � �} WnV t k
r�t j j | | | j d � d | d | j d t � d t | � �} n Xt | | j d � }
|
r*t j j j t d <d g |
S| j � | j d � } t | | j d d � � } zm | j d | j d g � d | j d d% � d | j d d � d | j d! t � d" | j d# � d$ | � } Wd% | j � Xt
| t � r t d& d' d( � d) k s| j d) � r t | � } n t! | d* | j" �t# | | j d d � | � | t d <| S(+ u
Retrieve the state data from the salt master for this minion and execute it
test
Run states in test-only (dry-run) mode
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. code-block:: bash
salt '*' state.highstate stuff pillar='{"foo": "bar"}'
.. note::
Values passed this way will override Pillar values set via
``pillar_roots`` or an external Pillar source.
.. versionchanged:: 2016.3.0
GPG-encrypted CLI Pillar data is now supported via the GPG
renderer. See :ref:`here <encrypted-cli-pillar-data>` for details.
pillar_enc
Specify which renderer to use to decrypt encrypted data located within
the ``pillar`` value. Currently, only ``gpg`` is supported.
.. versionadded:: 2016.3.0
exclude
Exclude specific states from execution. Accepts a list of sls names, a
comma-separated string of sls names, or a list of dictionaries
containing ``sls`` or ``id`` keys. Glob-patterns may be used to match
multiple states.
.. code-block:: bash
salt '*' state.highstate exclude=bar,baz
salt '*' state.highstate exclude=foo*
salt '*' state.highstate exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
saltenv
Specify a salt fileserver environment to be used when applying states
.. versionchanged:: 0.17.0
Argument name changed from ``env`` to ``saltenv``.
.. versionchanged:: 2014.7.0
If no saltenv is specified, the minion config will be checked for a
``saltenv`` parameter and if found, it will be used. If none is
found, ``base`` will be used. In prior releases, the minion config
was not checked and ``base`` would always be assumed when the
saltenv was not explicitly set.
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
queue : False
Instead of failing immediately when another state run is in progress,
queue the new state run to begin running once the other has finished.
This option starts a new thread for each queued state run, so use this
option sparingly.
localconfig
Optionally, instead of using the minion config, load minion opts from
the file specified by this argument, and then merge them with the
options from the minion config. This functionality allows for specific
states to be run with their own custom minion configuration, including
different pillars, file_roots, etc.
mock
The mock option allows for the state run to execute without actually
calling any states. This then returns a mocked return which will show
the requisite ordering as well as fully validate the state run.
.. versionadded:: 2015.8.4
CLI Examples:
.. code-block:: bash
salt '*' state.highstate
salt '*' state.highstate whitelist=sls1_to_run,sls2_to_run
salt '*' state.highstate exclude=sls_to_exclude
salt '*' state.highstate exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
salt '*' state.highstate pillar="{foo: 'Foo!', bar: 'Bar!'}"
u highstateuH Salt highstate run is disabled. To re-enable, run state.enable highstateu nameu Falseu resultu Disabledu commentu testu envu saltenvu pillarenvu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.u __pub_jidR� Ru R� t mockedu mockR� u retcodeu4 Pillar failed to render with the following messages:u orchestration_jidu
called localyRh u excludet cacheu cachet
cache_nameu
cache_namet forceu forcet whitelistu whitelistt orchestration_jidNu
config.optionu
state_datau u terseR ($ t _disabledR8 t debugRs R$ R+ R# R R Rv R� R� Rc R R R R� Rx R RT Rt Ry R( R: R R R� t push_activeR< t call_highstatet
pop_activeR5 R R" t building_highstateR? (
Rg Rq R& R Rr t orig_testR: R� R� R| R� R� R; ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR � s� ]
(
c K@ s� | j d t � } d | k r. | j d � n | rJ t | j d � � n) t | � } | rs t j j j t d <| St
| t � r� t | � } n t | g � } | r� x! | D] } t
j d | | � q� Wt j j j t d <| St j d d � }
t j j j t | � } t | | � | d <| d d k r;d | d <n | j d � } | j d
� }
|
d k r�| d k r�t
| t � r�t d � � n t j j t � } t j j t d d
j | j d d � � � } | t k r�d g } n | d k r t j j j | � } n g } d | k r9| d g k r9d g } n xT | D]L } y" t d j | � d | d � Wq@t! k
r�t
j" d | � q@Xq@WyU t j j# | | | j d � d |
d t$ d t d | j d t � d t% | � �} WnV t& k
r=t j j# | | | j d � d |
d | j d t � d t% | � �} n Xt' | d | j( d �} | r{t j j j) t d <d g | S| j d � } t j j* j+ d � �o | j d � r
t j j, | � r
t j j* j- | d � �) } | j. | � } | j j/ | | � SWd QXq
n Wd QXt
| t0 j1 � r@t j j2 j3 t4 | � � } n t j j j | � } | j5 � z� | j6 i | | d 6� \ } } | r�t j j j t d <| S| r�t j j j | � } d! | k r�| d! j7 | � q�| | d! <n t8 | | j d d" � � } | j j/ | | � } Wd | j9 � Xt d# d$ d% � d& k sN| j d& � r]t: | � } n t j j t d d' � } t j j* j+ d � �$yg t j j; j< � r�t d( d) d* | g d+ t �n t j j* j- | d, � � } | j= | | � Wd QXWn' t> t? f k
r t
j@ d- | � n XtA | | � |
t d <yM t j j* j- | d, � �/ } y | j= | | � Wn tB k
ryn XWd QXWn' t> t? f k
r�t
j@ d. | � n XWd QXtC | | j d d" � | � | S(/ uc
Execute the states in one or more SLS files
test
Run states in test-only (dry-run) mode
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. code-block:: bash
salt '*' state.sls stuff pillar='{"foo": "bar"}'
.. note::
Values passed this way will override existing Pillar values set via
``pillar_roots`` or an external Pillar source. Pillar values that
are not included in the kwarg will not be overwritten.
.. versionchanged:: 2016.3.0
GPG-encrypted CLI Pillar data is now supported via the GPG
renderer. See :ref:`here <encrypted-cli-pillar-data>` for details.
pillar_enc
Specify which renderer to use to decrypt encrypted data located within
the ``pillar`` value. Currently, only ``gpg`` is supported.
.. versionadded:: 2016.3.0
exclude
Exclude specific states from execution. Accepts a list of sls names, a
comma-separated string of sls names, or a list of dictionaries
containing ``sls`` or ``id`` keys. Glob-patterns may be used to match
multiple states.
.. code-block:: bash
salt '*' state.sls foo,bar,baz exclude=bar,baz
salt '*' state.sls foo,bar,baz exclude=ba*
salt '*' state.sls foo,bar,baz exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
queue : False
Instead of failing immediately when another state run is in progress,
queue the new state run to begin running once the other has finished.
This option starts a new thread for each queued state run, so use this
option sparingly.
concurrent : False
Execute state runs concurrently instead of serially
.. warning::
This flag is potentially dangerous. It is designed for use when
multiple state runs can safely be run at the same time. Do *not*
use this flag for performance optimization.
saltenv
Specify a salt fileserver environment to be used when applying states
.. versionchanged:: 0.17.0
Argument name changed from ``env`` to ``saltenv``.
.. versionchanged:: 2014.7.0
If no saltenv is specified, the minion config will be checked for an
``environment`` parameter and if found, it will be used. If none is
found, ``base`` will be used. In prior releases, the minion config
was not checked and ``base`` would always be assumed when the
saltenv was not explicitly set.
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
localconfig
Optionally, instead of using the minion config, load minion opts from
the file specified by this argument, and then merge them with the
options from the minion config. This functionality allows for specific
states to be run with their own custom minion configuration, including
different pillars, file_roots, etc.
mock:
The mock option allows for the state run to execute without actually
calling any states. This then returns a mocked return which will show
the requisite ordering as well as fully validate the state run.
.. versionadded:: 2015.8.4
sync_mods
If specified, the desired custom module types will be synced prior to
running the SLS files:
.. code-block:: bash
salt '*' state.sls stuff sync_mods=states,modules
salt '*' state.sls stuff sync_mods=all
.. versionadded:: 2017.7.8,2018.3.3,2019.2.0
CLI Example:
.. code-block:: bash
salt '*' state.sls core,edit.vim dev
salt '*' state.sls core exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
salt '*' state.sls myslsfile pillar="{foo: 'Foo!', bar: 'Bar!'}"
u
concurrentu envu __pub_jidu retcodeu< Salt state %s is disabled. To re-enable, run state.enable %su testu saltenvu baseu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.u cachediru {0}.cache.pu
cache_nameu highstateu allu saltutil.sync_{0}Rf u) Invalid custom module type '%s', ignoringR� Ru R� R� u mockR� R' u4 Pillar failed to render with the following messages:u orchestration_jidi? u cacheu rbNu __exclude__u
called localyu
config.optionu
state_datau u terseu sls.pu cmd.runu attribu -Rt python_shellu w+bu7 Unable to write to SLS cache file %s. Check permission.uD Unable to write to highstate cache file %s. Do you have permissions?(D R# RT Rc R0 Rn R R R R R R R R� R8 R� R+ R$ R Rv R� R� R R R� R� R@ RA RB R6 RU R t split_inputR5 t KeyErrort warningR� Rx Rt Ry R( R: R� RF R� R� RG R� R� R t
integer_typest stringutilst
to_unicodet strR� t render_highstatet extendR< R� R R� R� R� R� RE R9 R" t TypeErrorR? ( Re Rg Rh Rq t sync_modsR& Rl Rr t disabledRv R� R: R� R� R� t cfnt module_typeR| R� R� RO t high_R; R t
cache_file( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR� M s� p
%
(
c K@ ss t | | � } | d k r | St j d d � } t j j j t | � } t | | � | d <| j d � } | j d � } | d k r� | d k r� t | t
� r� t d � � n y7 t j j | | d | d t
d t d t | � �} Wn> t k
r(t j j | | d | d t
d t | � �} n Xt | d | j d �}
|
rft j j j t
d
<d g |
S| j � t j j j | � | j d <i } | j d
� } d | k r�| d | j d <n zg t | | j d d � � }
| j d | j d g � d | j d d � d | j d d � d | � } Wd | j � Xt | d | j �t | | j d d � |
� | t d <| S( u�
Execute a specific top file instead of the default. This is useful to apply
configurations from a different environment (for example, dev or prod), without
modifying the default top file.
queue : False
Instead of failing immediately when another state run is in progress,
queue the new state run to begin running once the other has finished.
This option starts a new thread for each queued state run, so use this
option sparingly.
saltenv
Specify a salt fileserver environment to be used when applying states
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
.. versionadded:: 2017.7.0
CLI Example:
.. code-block:: bash
salt '*' state.top reverse_top.sls
salt '*' state.top prod_top.sls exclude=sls_to_exclude
salt '*' state.top dev_top.sls exclude="[{'id': 'id_to_exclude'}, {'sls': 'sls_to_exclude'}]"
u testu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.R� R� Ru R� R' u retcodeu4 Pillar failed to render with the following messages:u state_topu orchestration_jidu saltenvu state_top_saltenvu __pub_jidu
called localyRh u excludeR� u cacheR� u
cache_nameu highstateR� NR ( Rs R$ R+ R# R R Rv R� R� R R R R� R Rx Rt Ry R( R: R R R� R� t urlt createR< R� R� R" R� R? ( t topfnRg Rq R& Rr R� R: R� R� R| R� R R� R; ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt topd s` !
c K@ su t | | � } | d k r | S| j d � } | j d � } | d k rt | d k rt t | t � rt t d � � n t j j j t
| � } y1 t j j | | d | d t d t
| � �} Wn8 t k
r� t j j | | d | d t
| � �} n Xt | d | j d �} | r?t j j j t d <t d d
| �� n | j � z | j � } Wd | j � Xt | � | S( u�
Retrieve the highstate data from the salt master and display it
Custom Pillar data can be passed with the ``pillar`` kwarg.
CLI Example:
.. code-block:: bash
salt '*' state.show_highstate
u pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.R� Ru R� R' u retcodeu Pillar failed to renderR� N( Rs R$ R# R R R R R Rv R� R+ R� Rx Rt Ry R( R: R R R� R R R� t compile_highstateR� R" ( Rq R& Rr R� R� R: R| R� R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt show_highstate� s@
c K@ s t | | � } | d k r | St j j j t | � } y( t j j | d t d t | � �} Wn/ t
k
r� t j j | d t | � �} n Xt | d | j d �} | r� t j
j j t d <t d d | �� n | j � z | j � } Wd | j � X| S( u�
List out the low data that will be applied to this minion
CLI Example:
.. code-block:: bash
salt '*' state.show_lowstate
Ru R� R' u pillaru retcodeu Pillar failed to renderR� N( Rs R$ R R Rv R� R+ R� Rx Rt Ry R( R: R R R� R R R� t compile_low_chunksR� ( Rq R& Rr R: R| R� R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
show_lowstate� s(
c K@ s� t | | � } | d k r | S| j d � } | j d � } | d k rt | d k rt t | t � rt t d � � n t j j t | d | �} | j
� z | j � } Wd | j � Xt
| � | S( u�
Retrieve the highstate data from the salt master to analyse used and unused states
Custom Pillar data can be passed with the ``pillar`` kwarg.
CLI Example:
.. code-block:: bash
salt '*' state.show_state_usage
u pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.R� N( Rs R$ R# R R R R Rv R� R+ R� t compile_state_usageR� R" ( Rq R& Rr R' R� R| R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt show_state_usage s"
c K@ ss t | | � } | d k r | St j j j t | � } y( t j j | d t d t | � �} Wn/ t
k
r� t j j | d t | � �} n Xt | d | j d �} | r� t j
j j t d <t d d | �� n | j � t � } zj | j � } t | t � st | � � n x9 | D]1 } t | t � sBt | � | St | | d <q WWd | j � Xt | j � � S(
u�
Returns the list of states that will be applied on highstate.
CLI Example:
.. code-block:: bash
salt '*' state.show_states
.. versionadded:: 2019.2.0
Ru R� R' u pillaru retcodeu Pillar failed to renderR� u __sls__N( Rs R$ R R Rv R� R+ R� Rx Rt Ry R( R: R R R� R R R� R R� R R R7 R R" RU R� t keys( Rq R& Rr R: R| R� R/ t resultt s( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt show_states< s8
c K@ s� t | | � } | d
k r | St j d d
� } t j j j t | � } t | | � | d <| d d
k ry d | d <n | j d � } | j d � } | d
k r� | d
k r� t | t
� r� t d � � n y1 t j j | | d | d t
d t | � �}
Wn8 t k
r9t j j | | d | d t | � �}
n Xt | d
|
j d �} | rwt j j j t d <d g | St j j j | � } |
j � z$ |
j i | | d 6� \ }
} Wd
|
j � X| |
j j |
� 7} |
j j |
� \ }
} | r | j | � n | r)t j j j t d <| S|
j j |
� } i } xH | D]@ } | j d d � | k rH| j |
j j! | i | � � qHqHWt" | d t# �| t d <| s�t d j$ | | | d � � � n | S( ud
Call a single ID from the named module(s) and handle all requisites
The state ID comes *before* the module ID(s) on the command line.
id
ID to call
mods
Comma-delimited list of modules to search for given id and its requisites
.. versionadded:: 2014.7.0
saltenv : base
Specify a salt fileserver environment to be used when applying states
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. code-block:: bash
salt '*' state.sls_id my_state my_module pillar='{"foo": "bar"}'
.. note::
Values passed this way will override existing Pillar values set via
``pillar_roots`` or an external Pillar source. Pillar values that
are not included in the kwarg will not be overwritten.
.. versionadded:: 2018.3.0
CLI Example:
.. code-block:: bash
salt '*' state.sls_id my_state my_module
salt '*' state.sls_id my_state my_module,a_common_module
u testu saltenvu baseu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.R� Ru R� R' u retcodeu4 Pillar failed to render with the following messages:Nu __id__u R u? No matches for ID '{0}' found in SLS '{1}' within saltenv '{2}'(% Rs R$ R+ R# R R Rv R� R� R R R R� Rx Rt Ry R( R: R R R� R R R� R� R� R� t verify_hight requisite_inR� R t compile_high_dataR� t
call_chunkR" R R6 ( t id_Re Rg Rq R& Rr R� R: R� R� R| R� t
split_modsR� t
req_in_errorst chunksR t chunk( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt sls_ido sl .
$
&
c
K@ s5 d | k r | j d � n t | | � } | d k r; | St j d d � } t j j j t | � } t | | � | d <| d d k r� d | d <n | j d � } | j d � } | d k r� | d k r� t
| t � r� t d � � n y+ t j j
| | d t d t | � �} Wn2 t k
rIt j j
| | d t | � �} n Xt | d
| j d �}
|
r�t j j j t d <t d d
|
�� n t j j j | � } | j � z$ | j i | | d 6� \ } }
Wd | j � X|
| j j | � 7}
|
rt j j j t d <|
S| j j | � } | t d <| S( u
Display the low data from a specific sls. The default environment is
``base``, use ``saltenv`` to specify a different environment.
saltenv
Specify a salt fileserver environment to be used when applying states
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. code-block:: bash
salt '*' state.show_low_sls stuff pillar='{"foo": "bar"}'
.. note::
Values passed this way will override Pillar values set via
``pillar_roots`` or an external Pillar source.
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
CLI Example:
.. code-block:: bash
salt '*' state.show_low_sls foo
salt '*' state.show_low_sls foo saltenv=dev
u envu testu saltenvu baseu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.Ru R� R' u retcodeu Pillar failed to renderR� N( Rc Rs R$ R+ R# R R Rv R� R� R R R R� Rx Rt Ry R( R: R R R� R R R R� R� R� R� R� R R� (
Re Rg Rq R& Rr R� R: R� R� R| R� R� R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt show_low_sls� sT !
$
c K@ s/ d | k r | j d � n t | | � } | d k r; | St j d d � } t j j j t | � } t | | � | d <| d d k r� d | d <n | j d � } | j d � } | d k r� | d k r� t
| t � r� t d � � n y1 t j j
| | d | d t d
t | � �} Wn8 t k
rUt j j
| | d | d
t | � �} n Xt | d | j d �}
|
r�t j j j t d <t d
d |
�� n t j j j | � } | j � z$ | j i | | d 6� \ } }
Wd | j � X|
| j j | � 7}
| t d <|
r+t j j j t d <|
S| S( u~
Display the state data from a specific sls or list of sls files on the
master. The default environment is ``base``, use ``saltenv`` to specify a
different environment.
This function does not support topfiles. For ``top.sls`` please use
``show_top`` instead.
Custom Pillar data can be passed with the ``pillar`` kwarg.
saltenv
Specify a salt fileserver environment to be used when applying states
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
CLI Example:
.. code-block:: bash
salt '*' state.show_sls core,edit.vim saltenv=dev
u envu testu saltenvu baseu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.R� Ru R� R' u retcodeu Pillar failed to renderR� N( Rc Rs R$ R+ R# R R Rv R� R� R R R R� Rx Rt Ry R( R: R R R� R R R R� R� R� R� R� R ( Re Rg Rq R& Rr R� R: R� R� R| R� R� ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt show_slsA sV
$
c K@ s" t t | d | d | | �t � S( uT
Tests for the existance the of a specific SLS or list of SLS files on the
master. Similar to :py:func:`state.show_sls <salt.modules.state.show_sls>`,
rather than returning state details, returns True or False. The default
environment is ``base``, use ``saltenv`` to specify a different environment.
.. versionadded:: 2019.2.0
saltenv
Specify a salt fileserver environment from which to look for the SLS files
specified in the ``mods`` argument
CLI Example:
.. code-block:: bash
salt '*' state.sls_exists core,edit.vim saltenv=dev
Rg Rq ( R R� R ( Re Rg Rq R& ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
sls_exists� s c K@ sY t j j j | � } t | � } t d � t | d | d | | �D� � } | j | � S( uR
Tests for the existence of a specific ID or list of IDs within the
specified SLS file(s). Similar to :py:func:`state.sls_exists
<salt.modules.state.sls_exists>`, returns True or False. The default
environment is base``, use ``saltenv`` to specify a different environment.
.. versionadded:: 2019.2.0
saltenv
Specify a salt fileserver environment from which to look for the SLS files
specified in the ``mods`` argument
CLI Example:
.. code-block:: bash
salt '*' state.id_exists create_myfile,update_template filestate saltenv=dev
c s@ s | ] } | d Vq d S( u __id__N( ( R t x( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pys <genexpr>� s Rg Rq ( R R R R� t setR� t issubset( t idsRe Rg Rq R& t sls_ids( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt id_exists� s +c K@ sI d | k r | j d � n t | | � } | d k r; | St j j j t | � } y( t j j | d t d t
| � �} Wn/ t k
r� t j j | d t
| � �} n Xt | d | j
d �} | r� t j j j t d <t d d | �� n g } | j � } | | j | � 7} | r6t j j j t d <| S| j | � } | S(
u�
Return the top data that the minion will use for a highstate
CLI Example:
.. code-block:: bash
salt '*' state.show_top
u envRu R� R' u pillaru retcodeu Pillar failed to renderR� N( Rc Rs R$ R R Rv R� R+ R� Rx Rt Ry R( R: R R R� R R t get_topt verify_topsR t top_matches( Rq R& Rr R: R| R� t top_t matches( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt show_top� s0
" c K@ s- t | | � } | d k r | S| j d � } t | � d k rW t j j j t d <d S| j i | d d 6| d d 6| d 6| d
6� t
j d d � } t j j
j t
| � } t | | � | d <| j d � } | j d
� }
|
d k r| d k rt | t � rt d � � n y1 t j
j | | d |
d t d t | � �} Wn8 t k
r�t j
j | | d |
d t | � �} n X| j | � } | r�t j j j t d <| S| j | � t | | j d d � � }
i | j | � d j | � 6} t | � t | | j d d � |
� | t
d <| S( u�
Execute a single state function with the named kwargs, returns False if
insufficient data is sent to the command
By default, the values of the kwargs will be parsed as YAML. So, you can
specify lists values, or lists of single entry key-value maps, as you
would in a YAML salt file. Alternatively, JSON format of keyword values
is also supported.
CLI Example:
.. code-block:: bash
salt '*' state.single pkg.installed name=vim
u .i u retcodeu Invalid function passedi u statei u funu __id__u nameu testu pillaru
pillar_encuN Pillar data must be formatted as a dictionary, unless pillar_enc is specified.R� Ru R� u __pub_jidu
called localyu/ {0[state]}_|-{0[__id__]}_|-{0[name]}_|-{0[fun]}N( Rs R$ t splitt lenR R R R R R� R+ R# R Rv R� R� R R R Rw Rx Rt Ry Rz t _mod_initR< R{ R6 R" R? ( t funR� Rg Rq R& Rr t compsR� R: R� R� R| Rm R; R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt single� sX
c C@ s� g } xx t j t d � D]c } | j d � r t j j t d | � } t j j | � s` q n t j | � | j | � q q W| S( uK
Clear out cached state files, forcing even cache runs to refresh the cache
on the next state execution.
Remember that the state cache is completely disabled by default, this
execution only applies if cache=True is used in states
CLI Example:
.. code-block:: bash
salt '*' state.clear_cache
u cachediru .cache.p( R@ RQ R+ R� RA RB R� RV Rk ( R t fn_RA ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt clear_cache9 s
c K@ s� t j j j t | � } t j j | � s. i St j j j | | � | k sP i St
j � } t j
| d � } | j � } xv | D]n } t j j j | j � j t j d j t j � f � r� i Sd j t j � t j j j | j � k r� i Sq� W| j | � | j � t j j | d � }
t j j j |
d � � } t j j j | � } Wd QXx! | D] }
t |
t � s\| Sq\Wt j j | d � } t j j | � r�t j j j | d � � } t j j j | � } Wd QXn d } t j j | d � } t j j | � r?t j j j | d � � } t j j j | � } Wd QXn t j j | � r^| | d <n d | d
<i | d <t | | � | d <t j | � } xL | D]D } t j j | | � } t j j | � s�q�n | g | d | <q�Wt j j! | d
| �} t" | | j# d d � � } | j$ | � } | j% | | � } y t& j' | � Wn t( t) f k
ran Xt* | � t+ | | j# d d � | � | S( u'
Execute a packaged state run, the packaged state run will exist in a
tarball available locally. This packaged state
can be generated using salt-ssh.
CLI Example:
.. code-block:: bash
salt '*' state.pkg /tmp/salt_state.tgz 760a9353810e36f6d81416366fc426dc md5
u r:gzu ..{0}u
lowstate.jsonu rNu pillar.jsonu roster_grains.jsonu grainsu localu
fileclientu
file_rootsu testR� u __pub_jidu
called localy(, R R Rv R� R+ R@ RA R� t hashutilst get_hasht tempfilet mkdtempt tarfilet opent
getmembersR� R� t
startswitht sepR6 t
extractallt closeRB RF RG t jsonR� R R R$ R� RQ t isdirRw R< R# t call_chunkst call_listent shutilt rmtreeR� RE R" R? ( t pkg_patht pkg_sumt hash_typeRg R& t poptst roott s_pkgt memberst membert
lowstate_jsonRO t lowstateR� t pillar_jsonR� t roster_grains_jsont
roster_grainst envsR� t fullR| R; R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt pkgR sh
6*
c C@ s� i t d 6d d 6} t j j j | � } g } t d d � } t | t � sW g } n t } x\ | D]T } | | k r� | j d j
| � � qd | j d j
| � � | j | � t } qd W| r� t d d | � n d j | � | d <t d
� | S( uk
Disable state runs.
CLI Example:
.. code-block:: bash
salt '*' state.disable highstate
salt '*' state.disable highstate,test.succeed_without_changes
.. note::
To disable a state file from running provide the same name that would
be passed in a state.sls call.
salt '*' state.disable bind.config
u resu u msgu
grains.getu state_runs_disabledu! Info: {0} state already disabled.u Info: {0} state disabled.u
grains.setvalu
u saltutil.refresh_modules( RU R R R R� R5 R R RT Rk R6 RB ( R/ R t msgR� t _changedt _state( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt disable� s(
c C@ s i t d 6d d 6} t j j j | � } t j d | � g } t d d � } t | t � sg g } n t
} xl | D]d } t j d | � | | k r� | j d j | � � qt | j d j | � � | j
| � t } qt W| r� t d
d | � n d j | � | d <t d � | S(
uk
Enable state function or sls run
CLI Example:
.. code-block:: bash
salt '*' state.enable highstate
salt '*' state.enable test.succeed_without_changes
.. note::
To enable a state file from running provide the same name that would
be passed in a state.sls call.
salt '*' state.disable bind.config
u resu u msgu states %su
grains.getu state_runs_disabledu _state %su Info: {0} state already enabled.u Info: {0} state enabled.u
grains.setvalu
u saltutil.refresh_modules( RU R R R R� R8 R� R5 R R RT Rk R6 RV RB ( R/ R R R� R R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt enable� s,
c C@ s t d d � S( u�
List the states which are currently disabled
CLI Example:
.. code-block:: bash
salt '*' state.list_disabled
u
grains.getu state_runs_disabled( R5 ( ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt
list_disabled s
c C@ s� g } t d d � } x� | D]� } x� | D]� } d | k r� | j d � d } | j d � sh | d n | } | j | � r� d j | | � } | j | � q* q� q* | | k r* d j | � } | j | � q* q* q* Wq W| S( uU
Return messages for disabled states
that match state functions in funs.
u
grains.getu state_runs_disabledu .*u .i uX The state file "{0}" is currently disabled by "{1}", to re-enable, run state.enable {1}.uO The state file "{0}" is currently disabled, to re-enable, run state.enable {0}.( R5 R� R� R� R6 Rk ( t funsR R� Rv R t target_stateRm ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR� s&
i����u minionc
C@ sX t j j j | | p t d t d d t d t �} x t rS| j d t d t � } | d k rh q8 n t j j j | d | � r9| s� t j j j t
d � j t j j j | d � t j j
j | d d
| d | s� d n d �� � t j j � n | d
k r&| d 8} t j d | � n | d
k rPPqPq8 t j d | d � q8 q8 Wd S( u*
Watch Salt's event bus and block until the given tag is matched
.. versionadded:: 2016.3.0
.. versionchanged:: 2019.2.0
``tagmatch`` can now be either a glob or regular expression.
This is useful for utilizing Salt's event bus from shell scripts or for
taking simple actions directly from the CLI.
Enable debug logging to see ignored events.
:param tagmatch: the event is written to stdout for each tag that matches
this glob or regular expression.
:param count: this number is decremented for each event that matches the
``tagmatch`` parameter; pass ``-1`` to listen forever.
:param quiet: do not print to stdout; just block
:param sock_dir: path to the Salt master's event socket file.
:param pretty: Output the JSON all on a single line if ``False`` (useful
for shell tools); pretty-print the JSON output if ``True``.
:param node: Watch the minion-side or master-side event bus.
CLI Example:
.. code-block:: bash
salt-call --local state.event pretty=True
u sock_diru transportR: t listenR t auto_reconnectu tagu {0} {1}u datat sort_keyst indenti i i u Remaining event matches: %su Skipping event tag: %sN( R R t eventt get_eventR+ RU R$ R� t
expr_matcht print_cliR� R6 t to_strR R^ t syst stdoutt flushR8 R� ( t tagmatcht countt quiett sock_dirt prettyt nodet seventR ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyR$ 6 s6 "
(a t __doc__t
__future__R R R t loggingR@ R R) R� R� R- t salt.configR t salt.payloadt
salt.statet salt.utils.argst salt.utils.datat salt.utils.eventt salt.utils.filest salt.utils.functoolst salt.utils.hashutilst salt.utils.jidt salt.utils.jsont salt.utils.platformt salt.utils.statet salt.utils.stringutilst salt.utils.urlt salt.utils.versionst salt.defaults.exitcodest salt.exceptionsR R t salt.runners.stateR R t salt.utils.odictR t salt.extR RH t __proxyenabled__t
__outputter__t __func_alias__t getLoggert __name__R8 R R R R$ R" R( R0 R< R? RP R\ R_ Rb Rd RT Rn R, Rs Rt R} R� R� R� R� R� R� R� R� R� R R� R� R� R� R� R� R� R� R� R� R� R� R� R� R R R R R� R$ ( ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/state.pyt <module> s�
$ "# # / 4 � + * �� [ 4 % $ 3w[W )F I 3 5
#
Mini Shell