File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/salt/states/__pycache__/cmd.cpython-310.pyc
Back
o ;j� � @ sP d Z ddlZddlZddlZddlZddlZddlZddlZddl m Z m Z e� e �Zdd� Zdd� Zdd � Z d d d�Zejj�ed�Z d dd�Z d dd�Z d dd�Z d dd�Z d!dd�Zdd� Z dS )"a$ 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, in which case this state will run if **any** of the files do not exist: .. code-block:: yaml "echo 'foo' | tee /tmp/bar > /tmp/baz": cmd.run: - creates: - /tmp/bar - /tmp/baz .. note:: The ``creates`` option was added to the cmd state in version 2014.7.0, and made a global requisite in 3001. 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 do 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', {}) }} � N)�CommandExecutionError�SaltRenderErrorc C s� | d }i | d< d| d< |� d�}|s |� d�r |d | d< | S d}ztjj�|�}t|t�s5t| d�W S d}W nO ty� |� � � d �}|d krR||d d � }i }ztjj � |�D ] }|� d �\}}|||< q\W n ty� t| d�} | d �|� | Y Y S w Y nw t|� dd��} d|v r�|d | d< |d= | r�|D ] }|�||| � q�|r�dn |� dd�d |� |d< || d< | S )zO Re-interpret the state returned by salt.state.run using our protocol. �changes� �comment�stdout�stderrFz4script JSON output must be a JSON object (e.g., {})!T� ���� N�=zPFailed parsing script output! Stdout must be JSON or a line of name=value pairs.�changed�no)�get�salt�utils�json�loads� isinstance�dict�_failout� ValueError�rstrip�rfind�argsZ shlex_split�split�update�_is_true� setdefault) �state�ret�outZis_json�data�idx�item�key�valr � r' �C/opt/saltstack/salt/lib/python3.10/site-packages/salt/states/cmd.py�_reinterpreted_state� s\ � � � ��� r) c C s || d< d| d< | S )Nr F�resultr' )r �msgr' r' r( r 4 s r c C s: | r t | ��� dv r dS t | ��� dv rdS td| � ���)N)�trueZyes�1T)�falser �0Fz Failed parsing boolean value: )�str�lowerr )r& r' r' r( r : s r r' F�debugc K � | i ddd�S )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. cwd The current working directory to execute the command in, defaults to /root root Path to the root of the jail to use. If this parameter is set, the command will run inside a chroot runas The user name to run the command as. On Windows, a password may be required — see :mod:`cmd.run <salt.states.cmd.run>` for details. 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(':') }} .. note:: When using environment variables on Windows, case-sensitivity matters, i.e. Windows uses `Path` as opposed to `PATH` for other systems. 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 specified by ``creates`` do not exist. If you specify a list of files then this state will only run if **any** of the files 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 allows you to specify a list of non-zero return codes that should be considered as successful. If the return code from the command matches any in the list, the state will have a ``True`` result instead of ``False``. .. versionadded:: 2019.2.0 success_stdout: This parameter will allow a list of strings that when found in standard out should be considered a success. If stdout returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 success_stderr: This parameter will allow a list of strings that when found in standard error should be considered a success. If stderr returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 Tr ��namer r* r r' )r5 �cwd�root�runas�shell�env�stateful�output_loglevel� hide_output�use_vt�success_retcodes�success_stdout�success_stderr�kwargsr' r' r( �waitB s rC �watchc K r3 )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. cwd The current working directory to execute the command in, defaults to /root runas The user name to run the command as. On Windows, a password may be required — see :mod:`cmd.script <salt.states.cmd.script>` for details. 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(':') }} .. note:: When using environment variables on Windows, case-sensitivity matters, i.e. Windows uses `Path` as opposed to `PATH` for other systems. 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 allows you to specify a list of non-zero return codes that should be considered as successful. If the return code from the command matches any in the list, the state will have a ``True`` result instead of ``False``. .. versionadded:: 2019.2.0 success_stdout: This parameter will allow a list of strings that when found in standard out should be considered a success. If stdout returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 success_stderr: This parameter will allow a list of strings that when found in standard error should be considered a success. If stderr returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 Tr r4 r' )r5 �source�templater6 r8 r9 r: r; r> r< r= r? r@ rA rB r' r' r( � wait_script� s rG c K s | i ddd�}d}t |t�s|du }nt |t�r$d|d v r$|d d }td r,|r,|} |dur=t |ttf�s=d |d < |S t�|�}|�||||| |pNtd ||| | |||d � � td ry|syd|d < d| � d�|d < d| i|d< |rwt|�S |S |r�t j � |�s�d|� d�|d < |S z|s�dnd}t | d | | dd�|��}W n t y� } zt|�|d < |W Y d}~S d}~ww ||d< t|d � |d < d| � d�|d < | r�d}|d �d�dkr�||d �d�v r�d|d d< d|d < |r�t|�}td �r |d dk�r |d �r d|d < |S ) aV Run a command if certain circumstances are met. Use ``cmd.wait`` if you want to use the ``watch`` requisite. .. note:: The ``**kwargs`` of ``cmd.run`` are passed down to one of the following exec modules: * ``cmdmod.run_all``: If used with default ``runas`` * ``cmdmod.run_chroot``: If used with non-``root`` value for ``runas`` For more information on what args are available for either of these, refer to the :ref:`cmdmod documentation <cmdmod-module>`. name The command to execute, remember that the command will execute with the path and permissions of the salt-minion. cwd The current working directory to execute the command in, defaults to /root root Path to the root of the jail to use. If this parameter is set, the command will run inside a chroot runas The user name (or uid) to run the command as. The default behavior is to run as the user under which Salt is running. .. note:: On Windows, a ``password`` may be required depending on the privileges of the salt-minion process. See the ``password`` parameter for details. To specify a domain account, use the UPN format (``user@domain``) or down-level logon name (``DOMAIN\user``). password Windows only. The password for the account specified by ``runas``. Required only when the salt-minion is **not** running as SYSTEM or as an elevated Administrator. When Salt has sufficient privileges it can obtain a logon token for the target user through Windows impersonation APIs without needing their credentials. This parameter is ignored on non-Windows platforms. .. versionadded:: 3000 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(':') }} .. note:: When using environment variables on Windows, case-sensitivity matters, i.e. Windows uses `Path` as opposed to `PATH` for other systems. 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. 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 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 specified by ``creates`` do not exist. If you specify a list of files then this state will only run if **any** of the files 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 allows you to specify a list of non-zero return codes that should be considered as successful. If the return code from the command matches any in the list, the state will have a ``True`` result instead of ``False``. .. versionadded:: 2019.2.0 success_stdout: This parameter will allow a list of strings that when found in standard out should be considered a success. If stdout returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 success_stderr: This parameter will allow a list of strings that when found in standard error should be considered a success. If stderr returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 .. 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 Fr r4 NT� test_namer �test�7Invalidly-formatted 'env' parameter. See documentation.r r9 ) r6 r7 r8 �passwordr> r9 r: � prepend_pathr< r= r? r@ rA r* z Command "z" would have been executed�cmdr �Desired working directory "�" is not availablez cmd.run_allzcmd.run_chroot)rM �timeout� python_shell�retcodez" runzTimed out afterr r r' )r �list�__opts__r �copy�deepcopyr � __grains__r) �os�path�isdir�__salt__� Exceptionr0 �boolr )r5 r6 r7 r8 rK r9 r: rL r; r< r= rP Zignore_timeoutr> r? r@ rA rB r rH � cmd_kwargsZrun_cmd�cmd_all�errZtriggerr' r' r( �runi s� \ �� � � �� � "ra c K s� d}t |t�s |du }nt |t�r d|d v r |d d }td r%|r%|} | i ddd�}|dur=t |ttf�s=d |d < |S |rJt |t�sJd |d < |S | rWt | t�sWd |d < |S |rftjj�� rf|sft� d � | rj| ni }|rs|� |� t � |�}|� |||p�t d |||| | | | |t|||d�� |||p�t d d�}|du r�| }|�dd�s�t| �� �dkr�|� d| �dd�d i� td r�|s�d|d< d| � d�|d < |r�t|�S |S |r�tj�|�s�d|� d�|d < |S ztd |fddi|��}W n tttf�y } zt|�|d < |W Y d}~S d}~ww ||d< |�d d��r(t|� |d< n t|d � |d< |�di ��d ��rDd � |t�|d < nd| � d �|d < |�rSt|�}td �rh|d dk�rh|d �rhd|d< |S ) a� 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://...". cwd The current working directory to execute the command in, defaults to /root runas Specify an alternate user to run the command. The default behavior is to run as the user under which Salt is running. .. note:: On Windows, a ``password`` may be required depending on the privileges of the salt-minion process. See the ``password`` parameter for details. To specify a domain account, use the UPN format (``user@domain``) or down-level logon name (``DOMAIN\user``). password Windows only. The password for the account specified by ``runas``. Required only when the salt-minion is **not** running as SYSTEM or as an elevated Administrator. When Salt has sufficient privileges it can obtain a logon token for the target user through Windows impersonation APIs without needing their credentials. This parameter is ignored on non-Windows platforms. .. versionadded:: 3000 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(':') }} .. note:: When using environment variables on Windows, case-sensitivity matters, i.e. Windows uses `Path` as opposed to `PATH` for other systems. saltenv : ``base`` The Salt environment to use 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 specified by ``creates`` do not exist. If you specify a list of files then this state will only run if **any** of the files 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 allows you to specify a list of non-zero return codes that should be considered as successful. If the return code from the command matches any in the list, the state will have a ``True`` result instead of ``False``. .. versionadded:: 2019.2.0 success_stdout: This parameter will allow a list of strings that when found in standard out should be considered a success. If stdout returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 success_stderr: This parameter will allow a list of strings that when found in standard error should be considered a success. If stderr returned from the run matches any in the provided list, the return code will be overridden with zero. .. versionadded:: 3004 NTrH r rI Fr r4 rJ r zBInvalidly-formatted 'context' parameter. Must be formed as a dict.zCInvalidly-formatted 'defaults' parameter. Must be formed as a dict.z�runas is set without a password on Windows. This will succeed only if the salt-minion is running as SYSTEM or as an elevated Administrator.r9 )r8 rK r9 r: r6 rF rP r< r= r> �contextZsaltenvr? r@ rA )r6 r8 r9 r r � r* z Command 'z' would have been executedrN rO z cmd.scriptrQ r rR Z cache_errorz+Unable to cache script {} from saltenv '{}'z' run) r rS rT r r r �platformZ is_windows�log�warningr rU rV rW Z__env__r �lenr r) rX rY rZ r[ r r �OSErrorr0 r] �format)r5 rE rF r6 r8 rK r9 r: r; rP r> r< r= �defaultsrb r? r@ rA rB rH r Ztmpctxr^ Zrun_check_cmd_kwargsr_ r` r' r' r( �script� s� ? ��� �� � �� �"rk c K s� | i ddd�}|� d�|� d�|� d�ptd |� d�|||d�} |s%i }||i |��} t| t�r8|�| � |S d | i|d < | d u rDd nt| �|d < t| t�rS| |d< |S )a~ 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. 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, str) else '' } Fr r4 r6 �userr9 r: )r6 r8 r9 r: r> r< r= �retvalr NTr* r )r rW r r r r] r0 ) r5 �funcr �kwsr< r= r> rB r r^ r* r' r' r( �call� s( #� rp c K r3 )NTr r4 r' ) r5 rn r ro r; r> r< r= rB r' r' r( � wait_call� s rq c K s� |d dv r"|� d�r|�d� tt| fi |���S t| fi |��S |d dks.|d dkrJ|� d�rB|�d� tt| fi |���S t| fi |��S |d dksV|d dkrs|� d�ri|�d�}t| |fi |��S | i d �|�d d �S | i d �|�d d �S ) a' 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. Zsfun)rC ra rD r; rG rk rq rp rn z*cmd.{0[sfun]} needs a named parameter funcF)r5 r r r* z\cmd.{0[sfun]} does not work with the watch requisite, please use cmd.wait or cmd.wait_script)r �popr) ra rk rp ri )r5 rB rn r' r' r( � mod_watch s2 ��rs ) NNNNr' Fr2 FFNNN) NNNNNNFFr2 FNNN)NNNNNNNFr2 FNFFNNN)NNNNNNNFNFr2 FNNNNN)r' Nr2 FF)r' NFFr2 F) �__doc__rU �loggingrX Zsalt.utils.argsr Zsalt.utils.functoolsZsalt.utils.jsonZsalt.utils.platformZsalt.exceptionsr r � getLogger�__name__re r) r r rC r � functoolsZalias_functionrD rG ra rk rp rq rs r' r' r' r( �<module> s� j = � � � * � . �A �
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings