Current File : //lib/python2.7/site-packages/salt/states/cmd.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
Z d d l Z d d l m
Z
m Z d d l m Z e j e � Z d � Z d � Z d � Z d � Z d d d d d d d e d d
e e d d �
Z e j j j e d � Z d d d d d d d d e d e d
e d
�
Z d d d d d d d d e d d
e d e e d d � Z d d d d d d d d d e d d e d
e d d d d � Z! d d d d d d
e e d � Z" d d d d d e e d
e d � Z# d � Z$ d S( u�
Execution of arbitrary commands
===============================
The cmd state module manages the enforcement of executed commands, this
state can tell a command to run under certain circumstances.
A simple example to execute a command:
.. code-block:: yaml
# Store the current date in a file
'date > /tmp/salt-run':
cmd.run
Only run if another execution failed, in this case truncate syslog if there is
no disk space:
.. code-block:: yaml
'> /var/log/messages/:
cmd.run:
- unless: echo 'foo' > /tmp/.test && rm -f /tmp/.test
Only run if the file specified by ``creates`` does not exist, in this case
touch /tmp/foo if it does not exist:
.. code-block:: yaml
touch /tmp/foo:
cmd.run:
- creates: /tmp/foo
``creates`` also accepts a list of files:
.. code-block:: yaml
"echo 'foo' | tee /tmp/bar > /tmp/baz":
cmd.run:
- creates:
- /tmp/bar
- /tmp/baz
.. note::
The ``creates`` option was added to version 2014.7.0
Sometimes when running a command that starts up a daemon, the init script
doesn't return properly which causes Salt to wait indefinitely for a response.
In situations like this try the following:
.. code-block:: yaml
run_installer:
cmd.run:
- name: /tmp/installer.bin > /dev/null 2>&1
Salt determines whether the ``cmd`` state is successfully enforced based on the exit
code returned by the command. If the command returns a zero exit code, then salt
determines that the state was successfully enforced. If the script returns a non-zero
exit code, then salt determines that it failed to successfully enforce the state.
If a command returns a non-zero exit code but you wish to treat this as a success,
then you must place the command in a script and explicitly set the exit code of
the script to zero.
Please note that the success or failure of the state is not affected by whether a state
change occurred nor the stateful argument.
When executing a command or script, the state (i.e., changed or not)
of the command is unknown to Salt's state system. Therefore, by default, the
``cmd`` state assumes that any command execution results in a changed state.
This means that if a ``cmd`` state is watched by another state then the
state that's watching will always be executed due to the `changed` state in
the ``cmd`` state.
.. _stateful-argument:
Using the "Stateful" Argument
-----------------------------
Many state functions in this module now also accept a ``stateful`` argument.
If ``stateful`` is specified to be true then it is assumed that the command
or script will determine its own state and communicate it back by following
a simple protocol described below:
1. :strong:`If there's nothing in the stdout of the command, then assume no
changes.` Otherwise, the stdout must be either in JSON or its `last`
non-empty line must be a string of key=value pairs delimited by spaces (no
spaces on either side of ``=``).
2. :strong:`If it's JSON then it must be a JSON object (e.g., {}).` If it's
key=value pairs then quoting may be used to include spaces. (Python's shlex
module is used to parse the key=value string)
Two special keys or attributes are recognized in the output::
changed: bool (i.e., 'yes', 'no', 'true', 'false', case-insensitive)
comment: str (i.e., any string)
So, only if ``changed`` is ``True`` then assume the command execution has
changed the state, and any other key values or attributes in the output will
be set as part of the changes.
3. :strong:`If there's a comment then it will be used as the comment of the
state.`
Here's an example of how one might write a shell script for use with a
stateful command:
.. code-block:: bash
#!/bin/bash
#
echo "Working hard..."
# writing the state line
echo # an empty line here so the next line will be the last.
echo "changed=yes comment='something has changed' whatever=123"
And an example SLS file using this module:
.. code-block:: yaml
Run myscript:
cmd.run:
- name: /path/to/myscript
- cwd: /
- stateful: True
Run only if myscript changed something:
cmd.run:
- name: echo hello
- cwd: /
- onchanges:
- cmd: Run myscript
Note that if the second ``cmd.run`` state also specifies ``stateful: True`` it can
then be watched by some other states as well.
4. :strong:`The stateful argument can optionally include a test_name parameter.`
This is used to specify a command to run in test mode. This command should
return stateful data for changes that would be made by the command in the
name parameter.
.. versionadded:: 2015.2.0
.. code-block:: yaml
Run myscript:
cmd.run:
- name: /path/to/myscript
- cwd: /
- stateful:
- test_name: /path/to/myscript test
Run masterscript:
cmd.script:
- name: masterscript
- source: salt://path/to/masterscript
- cwd: /
- stateful:
- test_name: masterscript test
Should I use :mod:`cmd.run <salt.states.cmd.run>` or :mod:`cmd.wait <salt.states.cmd.wait>`?
--------------------------------------------------------------------------------------------
.. note::
Use :mod:`cmd.run <salt.states.cmd.run>` together with :ref:`onchanges <requisites-onchanges>`
instead of :mod:`cmd.wait <salt.states.cmd.wait>`.
These two states are often confused. The important thing to remember about them
is that :mod:`cmd.run <salt.states.cmd.run>` states are run each time the SLS
file that contains them is applied. If it is more desirable to have a command
that only runs after some other state changes, then :mod:`cmd.wait
<salt.states.cmd.wait>` does just that. :mod:`cmd.wait <salt.states.cmd.wait>`
is designed to :ref:`watch <requisites-watch>` other states, and is
executed when the state it is watching changes. Example:
.. code-block:: yaml
/usr/local/bin/postinstall.sh:
cmd.wait:
- watch:
- pkg: mycustompkg
file.managed:
- source: salt://utils/scripts/postinstall.sh
mycustompkg:
pkg.installed:
- require:
- file: /usr/local/bin/postinstall.sh
``cmd.wait`` itself does not do anything; all functionality is inside its ``mod_watch``
function, which is called by ``watch`` on changes.
The preferred format is using the :ref:`onchanges Requisite <requisites-onchanges>`, which
works on ``cmd.run`` as well as on any other state. The example would then look as follows:
.. code-block:: yaml
/usr/local/bin/postinstall.sh:
cmd.run:
- onchanges:
- pkg: mycustompkg
file.managed:
- source: salt://utils/scripts/postinstall.sh
mycustompkg:
pkg.installed:
- require:
- file: /usr/local/bin/postinstall.sh
How do I create an environment from a pillar map?
-------------------------------------------------
The map that comes from a pillar can be directly consumed by the env option!
To use it, one may pass it like this. Example:
.. code-block:: yaml
printenv:
cmd.run:
- env: {{ salt['pillar.get']('example:key', {}) }}
i ( t absolute_importt print_functiont unicode_literalsN( t CommandExecutionErrort SaltRenderError( t sixc
C@ s� | d } i | d <d | d <| j d � } | sW | j d � rS | d | d <n | St } y; t j j j | � } t | t � s� t | d � St } Wn� t
k
r[| j � j d � } | d k r� | | d } n i } yC x< t j j
j | � D]% } | j d
� \ } } | | | <q� WWq\t
k
rWt | d � } | d j | � | SXn Xt | j d d
� � } d | k r�| d | d <| d =n | r�x" | D] } | j | | | � q�W| r�d n | j d d � | | d <| | d <n | S( uO
Re-interpret the state returned by salt.state.run using our protocol.
u changesu u commentu stdoutu stderru4 script JSON output must be a JSON object (e.g., {})!u
i����i u =uP Failed parsing script output! Stdout must be JSON or a line of name=value pairs.u changedu no( t gett Falset saltt utilst jsont loadst
isinstancet dictt _failoutt Truet
ValueErrort rstript rfindt argst shlex_splitt splitt updatet _is_truet
setdefault(
t statet rett outt is_jsont datat idxt itemt keyt valt changed( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt _reinterpreted_state� sR
&
c C@ s | | d <t | d <| S( Nu commentu result( R ( R t msg( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyR 8 s
c C@ s] | r% t j | � j � d k r% t St j | � j � d k rD t St d j | � � � d S(
Nu trueu yesu 1u falseu nou 0u! Failed parsing boolean value: {0}( u trueu yesu 1( u falseu nou 0( R t text_typet lowerR R R t format( R! ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyR > s
!c C@ s\ t j | � } t | d <t | d <| d k rkt | t j � r� t d | d t d t | �} t j
d j | � � | d k rhi d d 6t d
6t d 6Sqkt | t � r'x� | D]l } t d | d t d t | �} t j
d j | | � � | d k r� i d
j | � d 6t d
6t d 6Sq� Wqkt | t j � sk| sht j
d � i d d 6t d
6t d 6Sqkn | d k r�t | t j � r�t d | d t d t | �} t j
d j | � � | d k r�i d d 6t d
6t d 6Sq�t | t � r�g } xJ | D]B } | j
t d | d t d t | �� t j
d j | � � qWt g | D] } | d k ^ qR� r�i d d 6t d
6t d 6Sq�t | t j � s�| r�t j
d � i d d 6t d
6t d 6Sq�n t | t j � r t j j | � r i d j | � d 6t d 6St | t � rXt g | D] } t j j | � ^ q%� rXi d d 6t d 6St S( u�
Execute the onlyif and unless logic.
Return a result dict if:
* onlyif failed (onlyif != 0)
* unless succeeded (unless == 0)
else return True
u use_vtu bgu cmd.retcodet ignore_retcodet python_shellu Last command return code: {0}i u onlyif condition is falseu commentu
skip_watchu resultu# Last command '{0}' return code: {1}u onlyif condition is false: {0}u7 Command not run: onlyif did not evaluate to string_typeu unless condition is trueu7 Command not run: unless did not evaluate to string_typeu
{0} existsu All files in creates existN( t copyt deepcopyR t NoneR R t string_typest __salt__R t logt debugR' t listt appendt allt ost patht exists( t
cmd_kwargst onlyift unlesst createst cmdt entryt cR5 ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt
mod_run_checkF sp
&%
$(
u debugc K@ s i | d 6i d 6t d 6d d 6S( u�
Run the given command only if the watch statement calls it.
.. note::
Use :mod:`cmd.run <salt.states.cmd.run>` together with :mod:`onchanges </ref/states/requisites#onchanges>`
instead of :mod:`cmd.wait <salt.states.cmd.wait>`.
name
The command to execute, remember that the command will execute with the
path and permissions of the salt-minion.
onlyif
A command to run as a check, run the named command only if the command
passed to the ``onlyif`` option returns true
unless
A command to run as a check, only run the named command if the command
passed to the ``unless`` option returns false
cwd
The current working directory to execute the command in, defaults to
/root
runas
The user name to run the command as
shell
The shell to use for execution, defaults to /bin/sh
env
A list of environment variables to be set prior to execution.
Example:
.. code-block:: yaml
script-foo:
cmd.wait:
- env:
- BATCH: 'yes'
.. warning::
The above illustrates a common PyYAML pitfall, that **yes**,
**no**, **on**, **off**, **true**, and **false** are all loaded as
boolean ``True`` and ``False`` values, and must be enclosed in
quotes to be used as strings. More info on this (and other) PyYAML
idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`.
Variables as values are not evaluated. So $PATH in the following
example is a literal '$PATH':
.. code-block:: yaml
script-bar:
cmd.wait:
- env: "PATH=/some/path:$PATH"
One can still use the existing $PATH by using a bit of Jinja:
.. code-block:: jinja
{% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
mycommand:
cmd.run:
- name: ls -l /
- env:
- PATH: {{ [current_path, '/my/special/bin']|join(':') }}
umask
The umask (in octal) to use when running the command.
stateful
The command being executed is expected to return data about executing
a state. For more information, see the :ref:`stateful-argument` section.
creates
Only run if the file or files specified by ``creates`` do not exist.
.. versionadded:: 2014.7.0
output_loglevel : debug
Control the loglevel at which the output from the command is logged to
the minion log.
.. note::
The command being run will still be logged at the ``debug``
loglevel regardless, unless ``quiet`` is used for this value.
hide_output : False
Suppress stdout and stderr in the state's results.
.. note::
This is separate from ``output_loglevel``, which only handles how
Salt logs to the minion log.
.. versionadded:: 2018.3.0
use_vt
Use VT utils (saltstack) to stream the command output more
interactively to the console and the logs.
This is experimental.
success_retcodes: This parameter will be allow a list of
non-zero return codes that should be considered a success. If the
return code returned from the run matches any in the provided list,
the return code will be overridden with zero.
.. versionadded:: 2019.2.0
u nameu changesu resultu u comment( R ( t nameR8 R9 R: t cwdt runast shellt envt statefult umaskt output_loglevelt hide_outputt use_vtt success_retcodest kwargs( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt wait� s
u watchc K@ s i | d 6i d 6t d 6d d 6S( u�
Download a script from a remote source and execute it only if a watch
statement calls it.
source
The source script being downloaded to the minion, this source script is
hosted on the salt master server. If the file is located on the master
in the directory named spam, and is called eggs, the source string is
salt://spam/eggs
template
If this setting is applied then the named templating engine will be
used to render the downloaded file, currently jinja, mako, and wempy
are supported
name
The command to execute, remember that the command will execute with the
path and permissions of the salt-minion.
onlyif
A command to run as a check, run the named command only if the command
passed to the ``onlyif`` option returns true
unless
A command to run as a check, only run the named command if the command
passed to the ``unless`` option returns false
cwd
The current working directory to execute the command in, defaults to
/root
runas
The user name to run the command as
shell
The shell to use for execution, defaults to the shell grain
env
A list of environment variables to be set prior to execution.
Example:
.. code-block:: yaml
salt://scripts/foo.sh:
cmd.wait_script:
- env:
- BATCH: 'yes'
.. warning::
The above illustrates a common PyYAML pitfall, that **yes**,
**no**, **on**, **off**, **true**, and **false** are all loaded as
boolean ``True`` and ``False`` values, and must be enclosed in
quotes to be used as strings. More info on this (and other) PyYAML
idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`.
Variables as values are not evaluated. So $PATH in the following
example is a literal '$PATH':
.. code-block:: yaml
salt://scripts/bar.sh:
cmd.wait_script:
- env: "PATH=/some/path:$PATH"
One can still use the existing $PATH by using a bit of Jinja:
.. code-block:: jinja
{% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
mycommand:
cmd.run:
- name: ls -l /
- env:
- PATH: {{ [current_path, '/my/special/bin']|join(':') }}
umask
The umask (in octal) to use when running the command.
stateful
The command being executed is expected to return data about executing
a state. For more information, see the :ref:`stateful-argument` section.
use_vt
Use VT utils (saltstack) to stream the command output more
interactively to the console and the logs.
This is experimental.
output_loglevel : debug
Control the loglevel at which the output from the command is logged to
the minion log.
.. note::
The command being run will still be logged at the ``debug``
loglevel regardless, unless ``quiet`` is used for this value.
hide_output : False
Suppress stdout and stderr in the state's results.
.. note::
This is separate from ``output_loglevel``, which only handles how
Salt logs to the minion log.
.. versionadded:: 2018.3.0
success_retcodes: This parameter will be allow a list of
non-zero return codes that should be considered a success. If the
return code returned from the run matches any in the provided list,
the return code will be overridden with zero.
.. versionadded:: 2019.2.0
u nameu changesu resultu u comment( R ( R? t sourcet templateR8 R9 R@ RA RB RC RD RE RH RF RG RJ ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt wait_script s �
c
K@ sW i | d 6i d 6t d 6d d 6} d | k ru | j d � } d } t j j j d | � | j d g � j | � n t } d" } t | t
� s� | t k } n0 t | t
� r� d
| d k r� | d d
} n t d r� | r� | } n | d" k rt | t
t
f � rd
| d <| St j | � } | j i | d 6| d 6| d 6| pRt d d 6| d 6| d 6|
d 6| d 6| d 6| d 6| d 6� t | | | | � } t | t
� r�| j | � | St d r| rd" | d <d j | � | d <| r�t | � S| S| r2t j j | � r2d j | � | d <| Sy# t d | d |
d t | �} Wn' t k
r~} t j | � | d <| SX| | d <t | d � | d <d j | � | d <| r
d } | d j d � d k r
| | d j d! � k r
d | d d <t | d <q
n | r"t | � } n t d rS| d d k rS| d rSd" | d <n | S(# u�
Run a command if certain circumstances are met. Use ``cmd.wait`` if you
want to use the ``watch`` requisite.
name
The command to execute, remember that the command will execute with the
path and permissions of the salt-minion.
onlyif
A command to run as a check, run the named command only if the command
passed to the ``onlyif`` option returns a zero exit status
unless
A command to run as a check, only run the named command if the command
passed to the ``unless`` option returns a non-zero exit status
cwd
The current working directory to execute the command in, defaults to
/root
runas
The user name to run the command as
shell
The shell to use for execution, defaults to the shell grain
env
A list of environment variables to be set prior to execution.
Example:
.. code-block:: yaml
script-foo:
cmd.run:
- env:
- BATCH: 'yes'
.. warning::
The above illustrates a common PyYAML pitfall, that **yes**,
**no**, **on**, **off**, **true**, and **false** are all loaded as
boolean ``True`` and ``False`` values, and must be enclosed in
quotes to be used as strings. More info on this (and other) PyYAML
idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`.
Variables as values are not evaluated. So $PATH in the following
example is a literal '$PATH':
.. code-block:: yaml
script-bar:
cmd.run:
- env: "PATH=/some/path:$PATH"
One can still use the existing $PATH by using a bit of Jinja:
.. code-block:: jinja
{% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
mycommand:
cmd.run:
- name: ls -l /
- env:
- PATH: {{ [current_path, '/my/special/bin']|join(':') }}
prepend_path
$PATH segment to prepend (trailing ':' not necessary) to $PATH. This is
an easier alternative to the Jinja workaround.
.. versionadded:: 2018.3.0
stateful
The command being executed is expected to return data about executing
a state. For more information, see the :ref:`stateful-argument` section.
umask
The umask (in octal) to use when running the command.
output_loglevel : debug
Control the loglevel at which the output from the command is logged to
the minion log.
.. note::
The command being run will still be logged at the ``debug``
loglevel regardless, unless ``quiet`` is used for this value.
hide_output : False
Suppress stdout and stderr in the state's results.
.. note::
This is separate from ``output_loglevel``, which only handles how
Salt logs to the minion log.
.. versionadded:: 2018.3.0
quiet
This option no longer has any functionality and will be removed, please
set ``output_loglevel`` to ``quiet`` to suppress logging of the
command.
.. deprecated:: 2014.1.0
timeout
If the command has not terminated after timeout seconds, send the
subprocess sigterm, and if sigterm is ignored, follow up with sigkill
ignore_timeout
Ignore the timeout of commands, which is useful for running nohup
processes.
.. versionadded:: 2015.8.0
creates
Only run if the file or files specified by ``creates`` do not exist.
.. versionadded:: 2014.7.0
use_vt : False
Use VT utils (saltstack) to stream the command output more
interactively to the console and the logs.
This is experimental.
bg : False
If ``True``, run command in background and do not await or deliver its
results.
.. versionadded:: 2016.3.6
success_retcodes: This parameter will be allow a list of
non-zero return codes that should be considered a success. If the
return code returned from the run matches any in the provided list,
the return code will be overridden with zero.
.. versionadded:: 2019.2.0
.. note::
cmd.run supports the usage of ``reload_modules``. This functionality
allows you to force Salt to reload all modules. You should only use
``reload_modules`` if your cmd.run does some sort of installation
(such as ``pip``), if you do not reload the modules future items in
your state which rely on the software being installed will fail.
.. code-block:: yaml
getpip:
cmd.run:
- name: /usr/bin/python /usr/local/sbin/get-pip.py
- unless: which pip
- require:
- pkg: python
- file: /usr/local/sbin/get-pip.py
- reload_modules: True
u nameu changesu resultu u commentu quietu� The 'quiet' argument for cmd.run has been deprecated since 2014.1.0 and will be removed as of the Neon release. Please set 'output_loglevel' to 'quiet' instead.u Neonu warningsu test_namei u testu7 Invalidly-formatted 'env' parameter. See documentation.u cwdu runasu use_vtu shellu envu prepend_pathu umasku output_loglevelu hide_outputu success_retcodesu& Command "{0}" would have been executedu0 Desired working directory "{0}" is not availableu cmd.run_allt timeoutR) u retcodeu Command "{0}" runu Timed out afteri u stdoutN( R t popR R t versionst
warn_untilR R2 R, R R1 R t __opts__R
R* R+ R t
__grains__R> R' R# R4 R5 t isdirR. R R R% t boolR ( R? R8 R9 R: R@ RA RB RC t prepend_pathRD RE RF RG RO t ignore_timeoutRH RI RJ R t quietR$ t test_nameR7 t crett cmd_allt errt trigger( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt run� s~ �
"
2$
c K@ s d& } t |
t � s$ |
t k }
n0 t |
t � rT d |
d k rT |
d d } n t d rm | rm | } n i | d 6i d 6t d 6d d 6} | d& k r� t | t t f � r� d | d <| S| r� t | t � r� d
| d <| S| rt | t � rd | d <| S| r| n i } | r/| j | � n t j | � } | j i | d 6| p[t
d
d
6| d 6| d 6| d 6| d 6| d 6| d 6| d 6| d 6| d 6|
d 6| d 6t d 6| d 6� i | d 6| d 6| p�t
d
d
6} | d& k r�| } n | j d d& � rJt
| j � � d k rJ| j i | j d d � d d 6� n t | | | | � } t | t � r| j | � | St d r�| r�d& | d <d j | � | d <|
r�t | � S| S| r�t j j | � r�d j | � | d <| Sy t d | d! t | �} Wn0 t t t f k
r@} t j | � | d <| SX| | d <| j d" t � rqt | � | d <n t | d" � | d <| j d i � j d# � r�d$ j | t � | d <n d% j | � | d <|
r�t | � } n t d r| d" d k r| d rd& | d <n | S(' u*
Download a script and execute it with specified arguments.
source
The location of the script to download. If the file is located on the
master in the directory named spam, and is called eggs, the source
string is salt://spam/eggs
template
If this setting is applied then the named templating engine will be
used to render the downloaded file. Currently jinja, mako, and wempy
are supported
name
Either "cmd arg1 arg2 arg3..." (cmd is not used) or a source
"salt://...".
onlyif
Run the named command only if the command passed to the ``onlyif``
option returns true
unless
Run the named command only if the command passed to the ``unless``
option returns false
cwd
The current working directory to execute the command in, defaults to
/root
runas
The name of the user to run the command as
shell
The shell to use for execution. The default is set in grains['shell']
env
A list of environment variables to be set prior to execution.
Example:
.. code-block:: yaml
salt://scripts/foo.sh:
cmd.script:
- env:
- BATCH: 'yes'
.. warning::
The above illustrates a common PyYAML pitfall, that **yes**,
**no**, **on**, **off**, **true**, and **false** are all loaded as
boolean ``True`` and ``False`` values, and must be enclosed in
quotes to be used as strings. More info on this (and other) PyYAML
idiosyncrasies can be found :ref:`here <yaml-idiosyncrasies>`.
Variables as values are not evaluated. So $PATH in the following
example is a literal '$PATH':
.. code-block:: yaml
salt://scripts/bar.sh:
cmd.script:
- env: "PATH=/some/path:$PATH"
One can still use the existing $PATH by using a bit of Jinja:
.. code-block:: jinja
{% set current_path = salt['environ.get']('PATH', '/bin:/usr/bin') %}
mycommand:
cmd.run:
- name: ls -l /
- env:
- PATH: {{ [current_path, '/my/special/bin']|join(':') }}
saltenv : ``base``
The Salt environment to use
umask
The umask (in octal) to use when running the command.
stateful
The command being executed is expected to return data about executing
a state. For more information, see the :ref:`stateful-argument` section.
timeout
If the command has not terminated after timeout seconds, send the
subprocess sigterm, and if sigterm is ignored, follow up with sigkill
args
String of command line args to pass to the script. Only used if no
args are specified as part of the `name` argument. To pass a string
containing spaces in YAML, you will need to doubly-quote it: "arg1
'arg two' arg3"
creates
Only run if the file or files specified by ``creates`` do not exist.
.. versionadded:: 2014.7.0
use_vt
Use VT utils (saltstack) to stream the command output more
interactively to the console and the logs.
This is experimental.
context
.. versionadded:: 2016.3.0
Overrides default context variables passed to the template.
defaults
.. versionadded:: 2016.3.0
Default context passed to the template.
output_loglevel : debug
Control the loglevel at which the output from the command is logged to
the minion log.
.. note::
The command being run will still be logged at the ``debug``
loglevel regardless, unless ``quiet`` is used for this value.
hide_output : False
Suppress stdout and stderr in the state's results.
.. note::
This is separate from ``output_loglevel``, which only handles how
Salt logs to the minion log.
.. versionadded:: 2018.3.0
success_retcodes: This parameter will be allow a list of
non-zero return codes that should be considered a success. If the
return code returned from the run matches any in the provided list,
the return code will be overridden with zero.
.. versionadded:: 2019.2.0
u test_namei u testu nameu changesu resultu u commentu7 Invalidly-formatted 'env' parameter. See documentation.uB Invalidly-formatted 'context' parameter. Must be formed as a dict.uC Invalidly-formatted 'defaults' parameter. Must be formed as a dict.u runasu shellu envu onlyifu unlessu cwdu templateu umasku timeoutu output_loglevelu hide_outputu use_vtu contextu saltenvu success_retcodesu argsi u u& Command '{0}' would have been executedu0 Desired working directory "{0}" is not availableu
cmd.scriptR) u retcodeu cache_erroru- Unable to cache script {0} from saltenv '{1}'u Command '{0}' runN( R, R R1 R RS R R
R R* R+ RT t __env__R t lenR R> R' R# R4 R5 RU R. R R t IOErrorR R% RV ( R? RL RM R8 R9 R: R@ RA RB RC RD RE RO RH RF RG t defaultst contextRI RJ RZ R t tmpctxR7 t run_check_cmd_kwargsR[ R\ R] ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt script� s� �
"
+'
$
c
K@ sd i | d 6i d 6t d 6d d 6} i |
j d � d 6|
j d � d 6|
j d � p[ t d d 6|
j d
� d
6| d 6| d 6| d
6|
j d � d 6} t | | | | � }
t |
t � r� | j |
� | S| s� i } n | | | � } t | t � r
| j | � | Si | d 6| d <| d k r-t n t | � | d <t | t
j � r\| | d <n | Sd S( u
Invoke a pre-defined Python function with arguments specified in the state
declaration. This function is mainly used by the
:mod:`salt.renderers.pydsl` renderer.
The interpretation of ``onlyif`` and ``unless`` arguments are identical to
those of :mod:`cmd.run <salt.states.cmd.run>`, and all other
arguments(``cwd``, ``runas``, ...) allowed by :mod:`cmd.run
<salt.states.cmd.run>` are allowed here, except that their effects apply
only to the commands specified in `onlyif` and `unless` rather than to the
function to be invoked.
In addition, the ``stateful`` argument has no effects here.
The return value of the invoked function will be interpreted as follows.
If it's a dictionary then it will be passed through to the state system,
which expects it to have the usual structure returned by any salt state
function.
Otherwise, the return value (denoted as ``result`` in the code below) is
expected to be a JSON serializable object, and this dictionary is returned:
.. code-block:: python
{
'name': name
'changes': {'retval': result},
'result': True if result is None else bool(result),
'comment': result if isinstance(result, six.string_types) else ''
}
u nameu changesu resultu u commentu cwdu useru runasu shellu envu use_vtu output_loglevelu hide_outputu umasku retvalN( R R RT R> R R
R R, R RV R R- ( R? t funcR t kwsR8 R9 R: RF RG RH RJ R R7 R[ t result( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt call� s6 +
"
c K@ s i | d 6i d 6t d 6d d 6S( Nu nameu changesu resultu u comment( R ( R? Rh R Ri R8 R9 R: RD RH RF RG RJ ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt wait_call s
c K@ sK | d d k rL | j d � r? | j d � t t | | � � St | | � S| d d k sl | d d k r� | j d � r� | j d � t t | | � � St | | � S| d d k s� | d d k r"| j d
� r� | j d
� } t | | | � Si | d 6i d 6d
j | � d 6t d 6Sn i | d 6i d 6d j | � d 6t d 6S( u'
Execute a cmd function based on a watch call
.. note::
This state exists to support special handling of the ``watch``
:ref:`requisite <requisites>`. It should not be called directly.
Parameters for this function should be set by the state being triggered.
u sfunu waitu runu watchu statefulu wait_scriptu scriptu wait_callu callu funcu nameu changesu* cmd.{0[sfun]} needs a named parameter funcu commentu resultu\ cmd.{0[sfun]} does not work with the watch requisite, please use cmd.wait or cmd.wait_script( u waitu runu watch( R RP R# R_ Rg Rk R' R ( R? RJ Rh ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt mod_watch s0
( ( ( (% t __doc__t
__future__R R R R4 R* t loggingt salt.utils.argsR t salt.utils.functoolst salt.utils.jsont salt.exceptionsR R t salt.extR t getLoggert __name__R/ R# R R R> R, R RK R t functoolst alias_functiont watchRN R_ Rg Rk Rl Rm ( ( ( s3 /usr/lib/python2.7/site-packages/salt/states/cmd.pyt <module>� s� > K y { � � F
Mini Shell