Current File : //lib/python2.7/site-packages/salt/states/module.pyo
�
���^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
m Z d d l m
Z
d d l m Z d d l m Z d d l m Z d � Z e j j j e d
� Z e e � d d e j �d
� � Z d d � Z d � Z d � Z d � Z e j j j e d � Z d S( u_
Execution of Salt modules from within states
============================================
With `module.run` these states allow individual execution module calls to be
made via states. To call a single module function use a :mod:`module.run <salt.states.module.run>`
state:
.. code-block:: yaml
mine.send:
module.run:
- network.interfaces
Note that this example is probably unnecessary to use in practice, since the
``mine_functions`` and ``mine_interval`` config parameters can be used to
schedule updates for the mine (see :ref:`here <salt-mine>` for more info).
It is sometimes desirable to trigger a function call after a state is executed,
for this the :mod:`module.wait <salt.states.module.wait>` state can be used:
.. code-block:: yaml
fetch_out_of_band:
module.run:
- git.fetch:
- cwd: /path/to/my/repo
- user: myuser
- opts: '--all'
Another example:
.. code-block:: yaml
mine.send:
module.run:
- network.ip_addrs:
- interface: eth0
And more complex example:
.. code-block:: yaml
eventsviewer:
module.run:
- task.create_task:
- name: events-viewer
- user_name: System
- action_type: Execute
- cmd: 'c:\netops\scripts\events_viewer.bat'
- trigger_type: 'Daily'
- start_date: '2017-1-20'
- start_time: '11:59PM'
Please note, this is a new behaviour of `module.run` function.
With the previous `module.run` there are several differences:
- The need of `name` keyword
- The need of `m_` prefix
- No way to call more than one function at once
For example:
.. code-block:: yaml
mine.send:
module.wait:
- name: network.interfaces
- watch:
- file: /etc/network/interfaces
All arguments that the ``module`` state does not consume are passed through to
the execution module function being executed:
.. code-block:: yaml
fetch_out_of_band:
module.run:
- name: git.fetch
- cwd: /path/to/my/repo
- user: myuser
- opts: '--all'
Due to how the state system works, if a module function accepts an
argument called, ``name``, then ``m_name`` must be used to specify that
argument, to avoid a collision with the ``name`` argument.
Here is a list of keywords hidden by the state system, which must be prefixed
with ``m_``:
* fun
* name
* names
* state
* saltenv
For example:
.. code-block:: yaml
disable_nfs:
module.run:
- name: service.disable
- m_name: nfs
Note that some modules read all or some of the arguments from a list of keyword
arguments. For example:
.. code-block:: yaml
mine.send:
module.run:
- func: network.ip_addrs
- kwargs:
interface: eth0
.. code-block:: yaml
cloud.create:
module.run:
- func: cloud.create
- provider: test-provider
- m_names:
- test-vlad
- kwargs: {
ssh_username: 'ubuntu',
image: 'ami-8d6d9daa',
securitygroup: 'default',
size: 'c3.large',
location: 'ap-northeast-1',
delvol_on_destroy: 'True'
}
Another example that creates a recurring task that runs a batch file on a
Windows system:
.. code-block:: yaml
eventsviewer:
module.run:
- name: task.create_task
- m_name: 'events-viewer'
- user_name: System
- kwargs: {
action_type: 'Execute',
cmd: 'c:\netops\scripts\events_viewer.bat',
trigger_type: 'Daily',
start_date: '2017-1-20',
start_time: '11:59PM'
}
Another option is to use the new version of `module.run`. With which you can call one (or more!)
functions at once the following way:
.. code-block:: yaml
call_something:
module.run:
- git.fetch:
- cwd: /path/to/my/repo
- user: myuser
- opts: '--all'
By default this behaviour is not turned on. In order to do so, please add the following
configuration to the minion:
.. code-block:: yaml
use_superseded:
- module.run
i ( t absolute_importt print_functiont unicode_literalsN( t six( t range( t zip( t SaltInvocationError( t with_deprecatedc K@ s i | d 6i d 6t d 6d d 6S( u�
Run a single module function only if the watch statement calls it
``name``
The module function to execute
``**kwargs``
Pass any arguments needed to execute the function
.. note::
Like the :mod:`cmd.run <salt.states.cmd.run>` state, this state will
return ``True`` but not actually execute, unless one of the following
two things happens:
1. The state has a :ref:`watch requisite <requisites-watch>`, and
the state which it is watching changes.
2. Another state has a :ref:`watch_in requisite
<requisites-watch-in>` which references this state, and the state
wth the ``watch_in`` changes.
u nameu changesu resultu u comment( t True( t namet kwargs( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyt wait� s
u watchu Sodiumt policyc K@ s d | k r | j d � n i t | � d 6i d 6d d 6d d 6} g | j � D] } d | k rQ | ^ qQ } g } g } xW | D]O } | j d � d } | t k r� | j | � q� t d r� | j | � q� q� W| s� | r�d
j | r&d j d t
| � d
k p d d d j | � p d � p)d | rhd j d t
| � d
k pMd d d j | � pbd � pkd g � j � | d <| p�| | d <n | d d k r t | d <g } g } x%| D] } | j d � d } y� t
| d | j d � d | j | � �} t | | d j d i � � s_t | t � r�| j d j | | j d d � � � q�nH | j d j | t | t � r�| j d d � n | � � | | d | <Wq�t t f k
r�}
| j d j | |
� � q�Xq�Wd j | | � | d <t | � | d <n | S( u:
Run a single module function or a range of module functions in a batch.
Supersedes ``module.run`` function, which requires ``m_`` prefix to
function-specific parameters.
:param returner:
Specify a common returner for the whole batch to send the return data
:param kwargs:
Pass any arguments needed to execute the function(s)
.. code-block:: yaml
some_id_of_state:
module.run:
- network.ip_addrs:
- interface: eth0
- cloud.create:
- names:
- test-isbm-1
- test-isbm-2
- ssh_username: sles
- image: sles12sp2
- securitygroup: default
- size: 'c3.large'
- location: ap-northeast-1
- delvol_on_destroy: True
:return:
u nameu changesu u commentu resultu .u :i u testu u" Unavailable function{plr}: {func}.t plri t funcu , u$ Function{plr} {func} to be executed.t returneru returnert func_argsu retu '{0}' failed: {1}u (error message N/A)u {0}: {1}u SuccessN( t popt listt Nonet keyst splitt __salt__t appendt __opts__t joint formatt lent stripR t _call_functiont gett _get_resultt
isinstancet dictR t TypeErrort bool( R
t retR t functionst missingt testst failurest successt _funct func_rett ex( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyt run� s\ "
+
.
.!c K@ s~ t j j j t | � } t t | j t | j p4 g � | j pE g � � } | j t | j pc g � t | j pu g � } g i t } } } x� t
| j d � p� g � D]o } t | t � s� | j
| � q� xG t j | � D]6 }
|
| k r | j
| |
� q� q� | j | � q� Wq� W| j � t | j p9g � t | j pKg � } t | � } g }
| r�| | k r�x0 | j D]" } | | k r�|
j
| � q�q�Wn |
r�t d j d j |
� � � � n' | | k r�t d j | | � � � n t | | | � } | d k rzt j j t t � } | | k rz| | i t d d 6| d 6| d 6t j j j t � d 6� qzn | S(
ug
Calls a function from the specified module.
:param name:
:param kwargs:
:return:
u func_argsu Missing arguments: {0}u , u- Function expects {0} parameters, got only {1}u idu retu funu jidN( t saltt utilst argst get_function_argspecR R! R R t defaultst Falset reversedR R R R t iterkeyst updatet reverseR R R R t loadert returnersR t jidt gen_jid( R R R
t argspect func_kwR t arg_typet na_typet kw_typet funcsett kwarg_keyt _exp_prmt _passed_prmR& t argt mretR9 ( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyR 7 sB /"
( ! 'c K@ s i | d 6i d 6d d 6d d 6} | t k rO d j | � | d <t | d <| St d rp d j | � | d <| St j j j t | � } g } i } d } d } t | j t
� r� t | j � } n t | j t
� r� t | j � } n xT t | d
d d � D]< } | | } | | d k r | j | | | j | <q q Wx� | D]� }
|
d k r~d | k r| j d � | |
<qn� |
d
k r�d | k r| j d � | |
<qnb |
d k r�d | k r| j d � | |
<qn1 |
d k rd | k r| j d � | |
<qn |
| k rG| j |
� | |
<qGqGWt � } x� | j D]� }
|
d k red } nZ |
d
k rzd } nE |
d k r�d } n0 |
d k r�d } n |
d k r�d } n |
} | | k r�|
| k r�| j | � qJn |
| k r
| j | |
� qJ| j | j | � � qJW| rld }
x! | D] }
|
d j |
� 7}
q7W|
| d <t | d <| S| j r]| j d k r�d } ni | j d
k r�d } nQ | j d k r�d } n9 | j d k r�d } n! | j d k r�d } n | j } | | k r]| j | � } t | t
� sJd } | j | j � | d <t | d <| S| j | � q]n i } | j r�| j | k r�| j | j � } t | t � s�d } | j | j � | d <t | d <| Sn y3 | j r�t | | | � } n t | | � } Wn4 t k
r2} d j | | � | d <t | d <| SX| d k sK| i k r\| | d d <n d | k r�i t d d 6| d 6| d
6t j j j t � d 6} t j j t t � } | d | k r�| | d | � q�n d j | � | d <t | | d � | d <| S( u\
.. deprecated:: 2017.7.0
Function name stays the same, behaviour will change.
Run a single module function
``name``
The module function to execute
``returner``
Specify the returner to send the return of the module execution to
``kwargs``
Pass any arguments needed to execute the function
u nameu changesu u commentu resultu$ Module function {0} is not availableu testu% Module function {0} is set to executei i i����u m_nameu funu m_funu stateu m_stateu saltenvu m_saltenvu namesu m_namesu$ The following arguments are missing:u {0}u '{0}' must be a list.u '{0}' must be a dict.u6 Module function {0} threw an exception. Exception: {1}u retu returneru idu jidu Module function {0} executedN( R R R R3 R R. R/ R0 R1 R R R R2 t tupleR R t sett addR t varargst extendt keywordsR! t ExceptionR: R; R8 R9 R ( R R
R$ t aspecR0 R2 t arglent deflent indt minusRE R& t rargt commentRJ t msgt nkwargsRF t et ret_retR9 ( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyt _runp s�
c C@ s� t } t | t � r6 | j d d � d k r6 t } n� t | t � rN | } n� | j d i � } t | t � r� t | j d i � t � r� | j d i � } q� | j d d � d k r� t } q� t | � } n | S( Nu retcodei u retu result( R R R! R R3 R# t _get_dict_result( R+ t changest rest changes_ret( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyR s ' c C@ sz t } xm t j | � D]\ \ } } | d k rD | t k rD t } Pq t | t � r t | � } | t k rr Pqr q q W| S( Nu result( R R t iteritemsR3 R R! RZ ( t nodeR$ t keyt val( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyRZ s u mod_watch(! t __doc__t
__future__R R R t salt.loaderR. t salt.utils.argst salt.utils.functoolst salt.utils.jidt salt.extR t salt.ext.six.movesR R t salt.exceptionsR t salt.utils.decoratorsR R R/ t functoolst alias_functiont watcht globalst OPT_INR- R R RY R RZ t mod_watch( ( ( s6 /usr/lib/python2.7/site-packages/salt/states/module.pyt <module>� s$ $Z 9 �
Mini Shell