HEX

File: //opt/saltstack/salt/lib/python3.10/site-packages/salt/states/__pycache__/saltmod.cpython-310.pyc
o

�N�g���@sdZddlZddlZddlZddlZddlZddlZddlZddl	Zddl
ZddlZddlZe�
e�ZdZdd�Zdd�Zdd	�Z	
												
				
			
			ddd�Z	
					
								ddd�Zddd�Zdd�Zdd�Zdd�ZdS) a�
Control the Salt command interface
==================================

This state is intended for use from the Salt Master. It provides access to
sending commands down to minions as well as access to executing master-side
modules. These state functions wrap Salt's :ref:`Python API <python-api>`.

    .. versionadded:: 2016.11.0

    Support for masterless minions was added to the ``salt.state`` function,
    so they can run orchestration sls files. This is particularly useful when
    the rendering of a state is dependent on the execution of another state.
    Orchestration will render and execute each orchestration block
    independently, while honoring requisites to ensure the states are applied
    in the correct order.

.. seealso:: More Orchestrate documentation

    * :ref:`Full Orchestrate Tutorial <orchestrate-runner>`
    * :py:func:`The Orchestrate runner <salt.runners.state.orchestrate>`
�N�saltcCstS)z
    Named salt
    )�__virtualname__�rr�G/opt/saltstack/salt/lib/python3.10/site-packages/salt/states/saltmod.py�__virtual__+srcCs:z
tjj�tt|d�WdStyt�d�YdSw)N�run�>Unable to fire args event due to missing __orchestration_jid__)	r�utils�eventZ	fire_args�__opts__�__orchestration_jid__�	NameError�log�debug)Ztag_datarrr�
_fire_args2s
�rc	s�t��dg�t��dg�����fdd�}tt|tt�����}|D]}|��q$�D]}|dur=|\}}}|�|��q-�S)a
    Applies a function to each element of a list, returning the resulting list.

    A separate thread is created for each element in the input list and the
    passed function is called for each of the elements. When all threads have
    finished execution a list with the results corresponding to the inputs is
    returned.

    If one of the threads fails (because the function throws an exception),
    that exception is reraised. If more than one thread fails, the exception
    from the first thread (according to the index of the input element) is
    reraised.

    func:
        function that is applied on each input element.
    inputs:
        list of elements that shall be processed. The length of this list also
        defines the number of threads created.
    Ncs,�����fdd�}tj|d�}|��|S)Ncs0z������<WdSt����<YdS)N)�sys�exc_infor)�errors�func�index�inputs�outputsrr�
run_threadQsz8_parallel_map.<locals>.create_thread.<locals>.run_thread)�target)�	threading�Thread�start)rr�thread�rrrr)rr�
create_threadPsz$_parallel_map.<locals>.create_thread)�len�list�map�range�join�with_traceback)	rrr�threadsr�error�exc_type�	exc_value�
exc_tracebackrrr�
_parallel_map9s


�r+F�glob�Tc(	Kszgi||d�}|r
||d<|r||d<|iddd�}zt|�}Wnty3d|d<d	|d
<|YSw||d<||d<d
|vrF|d
|d
<||d<|rOd}n,|	r[d}|d�|	�n |rqd}t|t�rid�|�}|d�|�n
d|d
<d|d<|S|dus�t�d�r�|dur�|nt�d�|dd<|r�||dd<|
dur�|
|dd<|
dur�|
|dd<|dur�||dd<||dd<t|t�r�||dd<n
d|d
<d|d<|S|dur�t	|�|d<|dur�||d <|dus�t�d!�r�d|d!<td"d#ko�td$d%k}|�st
d&|||d'��td(||fi|��}nA|	�r&d�|�d��|d)<n
|�r3d�|�d��|d*<|�
|�d��t|d1i|��}td+|t|t��rT|�d,d-�nd-d.�i}z|tt|��d/|d0<Wnttf�ysYnwi} t�}!t�}"|du�r�d1}n"t|t	��r�d2d3�|�d�D�}nt|t��s�|�d4g��d5�d1}|�s�|�r�d|d<d6|d
<|S|��D]�\}#}$|$�d,d�d-k�r�t�d7�d}%d8|$v�r�d9|$v�r�|$�d8�|$d9<d}&|$�d:d��r�d}&nz|$d9}%Wnt�y�d}&Ynw|&�r	td;|%dd<�}&|&�s|#|v�r|!�|#�|%| |#<�q�z&|%��D]}'t|'t��r9d=|'v�r9|'d=�r9|%| |#<n�q!|"�|#�W�q�t�y[t�d>t|%�|%�|"�|#�Y�q�w| �rfd-| d?�|d=<t|!�|k�r|d|d<d@� dA�|!��|d
<n&dB|d
<| �r�|d
dC� dA�| ��7<|"�r�|d
dD� dA�|"��7<|�s�t�d��r�|d=�r�|ddu�r�d|d<|S)Ea�
    Invoke a state run on a given target

    name
        An arbitrary name used to track the state execution

    tgt
        The target specification for the state run.

        .. versionadded:: 2016.11.0

        Masterless support: When running on a masterless minion, the ``tgt``
        is ignored and will always be the local minion.

    tgt_type
        The target type to resolve, defaults to ``glob``

    ret
        Optionally set a single or a list of returners to use

    ret_config
        Use an alternative returner configuration

    ret_kwargs
        Override individual returner configuration items

    highstate
        Defaults to None, if set to True the target systems will ignore any
        sls references specified in the sls option and call state.highstate
        on the targeted minions

    top
        Should be the name of a top file. If set state.top is called with this
        top file instead of state.sls.

    sls
        A group of sls files to execute. This can be defined as a single string
        containing a single sls file, or a list of sls files

    test
        Pass ``test=true`` or ``test=false`` through to the state function. This
        can be used to override a test mode set in the minion's config file. If
        left as the default of None and the 'test' mode is supplied on the
        command line, that value is passed instead.

    pillar
        Pass the ``pillar`` kwarg through to the state function

    pillarenv
        The pillar environment to grab pillars from

        .. versionadded:: 2017.7.0

    saltenv
        The default salt environment to pull sls files from

    ssh
        Set to `True` to use the ssh client instead of the standard salt client

    roster
        In the event of using salt-ssh, a roster system can be set

    expect_minions
        An optional boolean for failing if some minions do not respond

    fail_minions
        An optional list of targeted minions where failure is an option

    allow_fail
        Pass in the number of minions to allow for failure before setting
        the result of the execution to False

    exclude
        Pass exclude kwarg to state

    concurrent
        Allow multiple state runs to occur at once.

        WARNING: This flag is potentially dangerous. It is designed
        for use when multiple state runs can safely be run at the same
        Do not use this flag for performance optimization.

    queue
        Pass ``queue=true`` through to the state function

    batch
        Execute the command :ref:`in batches <targeting-batch>`. E.g.: ``10%``.

        .. versionadded:: 2016.3.0

    subset
        Number of minions from the targeted set to randomly use

        .. versionadded:: 2017.7.0

    failhard
        pass failhard down to the executing state

        .. versionadded:: 2019.2.2

    Examples:

    Run a list of sls files via :py:func:`state.sls <salt.state.sls>` on target
    minions:

    .. code-block:: yaml

        webservers:
          salt.state:
            - tgt: 'web*'
            - sls:
              - apache
              - django
              - core
            - saltenv: prod

    Run sls file via :py:func:`state.sls <salt.state.sls>` on target
    minions with exclude:

    .. code-block:: yaml

        docker:
          salt.state:
            - tgt: 'docker*'
            - sls: docker
            - exclude: docker.swarm
            - saltenv: prod

    Run a full :py:func:`state.highstate <salt.state.highstate>` on target
    mininons.

    .. code-block:: yaml

        databases:
          salt.state:
            - tgt: role:database
            - tgt_type: grain
            - highstate: True
    ��arg�kwarg�ret�timeout�
ret_config�
ret_kwargsr-T��name�changes�comment�resultFr9z5Passed invalid value for 'allow_fail', must be an intr8�tgt_type�ssh�roster�expect_minionszstate.highstatez	state.topr/z	state.sls�,z0No highstate or sls specified, no execution madeN�testr0�pillar�	pillarenv�saltenv�exclude�queue�
concurrentz.Must pass in boolean for value of 'concurrent'�batch�subset�failhardZ__role�minionZfile_client�local�state��type�tgtr6�args�saltutil.cmdZtopfn�mods�id�out�	highstate)r1rS�jid�__jid__rcS�g|]}|���qSr��strip��.0rIrrr�
<listcomp>t�zstate.<locals>.<listcomp>�warnings�G'fail_minions' needs to be a list or a comma separated string. Ignored.zNo minions returnedz$Output from salt state not highstate�returnr1�failedzstate.check_result)Zrecurser7z m_ret did not have changes %s %s)rSr1zRun failed on minions: {}�, zStates ran successfully.z
 Updating {}.z No changes made to {}.)!�int�
ValueError�append�
isinstancer!r$r�get�bool�strr�__salt__�pop�update�dict�next�iter�
StopIteration�KeyError�set�split�
setdefault�itemsr�warningZ	__utils__�add�values�AttributeErrorr'rMr �format)(r6rNr;r:r1r3r4rTZsls�toprBr?r@rAr=rC�fail_minionsZ
allow_failrEr2rFrDrGZorchestration_jidrH�kwargs�cmd_kwZ	state_ret�funZ
masterless�cmd_retZtmp_retr7�failZ	no_changerI�mdata�m_retZm_stateZ
state_itemrrrrKes(�


����
�
�

�
���rKc
Ks2|iddd�}|dur
i}t|
t�rdg|d<|
��}
|
pg|||d�}|
dur.t|
�|d<|dur6||d	<||d
<||d<d|vrH|d|d<||d
<d|d<|dusYt�d�r]d|d<|rc||d<|ri||d<|}tddurd�||�|d<d|d<|Sztd|||d��td||fi|��}Wnty�}zd|d<t|�|d<|WYd}~Sd}~wwz|t	t
|��d|d<Wnttfy�Ynwi}t
�}|dur�d}n t|t�r�dd�|�d�D�}nt|t�s�|�dg��d �d}|��D]Y\}}d}|�d!��rd|d<|�|�|�d"d��rd}n)d#|v�r.d$|v�r.|�d#�|d$<|d$}|	�r9d�p>t|	|�}|du�rFd}|�sS||v�rS|�|�|||<q�|�sed|d<d%|d<|S|�rnd$|i|d&<|�r�d|d<d'�|d(�|��|d<nd)|d<|�r�|dd*�|d(�|��7<|S)+a�
    Execute a single module function on a remote minion via salt or salt-ssh

    name
        The name of the function to run, aka cmd.run or pkg.install

    tgt
        The target specification, aka '*' for all minions

    tgt_type
        The target type, defaults to ``glob``

    arg
        The list of arguments to pass into the function

    kwarg
        The dict (not a list) of keyword arguments to pass into the function

    ret
        Optionally set a single or a list of returners to use

    ret_config
        Use an alternative returner configuration

    ret_kwargs
        Override individual returner configuration items

    expect_minions
        An optional boolean for failing if some minions do not respond

    fail_minions
        An optional list of targeted minions where failure is an option

    fail_function
        An optional string that points to a salt module that returns True or False
        based on the returned data dict for individual minions

    ssh
        Set to `True` to use the ssh client instead of the standard salt client

    roster
        In the event of using salt-ssh, a roster system can be set

        .. versionadded:: 3005

    batch
        Execute the command :ref:`in batches <targeting-batch>`. E.g.: ``10%``.

    subset
        Number of minions from the targeted set to randomly use

        .. versionadded:: 2017.7.0

    failhard
        pass failhard down to the executing state

        .. versionadded:: 2019.2.2

    r-Tr5Nz,Please specify 'arg' as a list of arguments.r^r.rFrGr:r;r<r=Z	_cmd_metarHr3r4r?z*Function {} would be executed on target {}r8r9�functionrLrPFrUrVrcSrWrrXrZrrrr\?r]zfunction.<locals>.<listcomp>r>r_�retcoderar`r1zNo minions respondedr7z)Running function {} failed on minions: {}rbzFunction ran successfully.z Function {} ran on {}.)rfrirsrrgrzrrj�	Exceptionrnrorprqrrr!rtrerurwrkr$)r6rNr;r:r1r3r4r=r|Z
fail_functionr/r0r2rFrGrHr}Zfunc_retr~rr��excr7r�rIr�r�Zm_funcrrrr��s�N

����

�




�

�
�r�rR�,�masterc	s�|iddd�}t�d�rd|�d�|d<d|d	<|Stjjj|td
tdd���}d
}t��}||}		|jdd�}
t��|	k}|
durL|sLt�d�q3|
dur_|r_d|d<|Wd�St	�	|
d|��r|
d�|���dur�d|
dvr�|
dd�|���dur�t
�t�rćfdd�|D�}|s�t�d|�nn|r�|d�dg�}
|D]}|�
|�|d7}|
�|�t�d|t|��q�nGz|���}Wnty�t�d|�Yn1w||=|d7}|d�dg�}
|
���t�d�t|��nt�d||
d�nt�d|
d�t|�d
k�r*d|d	<d�t��|�|d<|Wd�S|�r:d|d<|Wd�Sq41�s?wYdS)a
    Watch Salt's event bus and block until a condition is met

    .. versionadded:: 2014.7.0

    name
        An event tag to watch for; supports Reactor-style globbing.
    id_list
        A list of event identifiers to watch for -- usually the minion ID. Each
        time an event tag is matched the event data is inspected for
        ``event_id``, if found it is removed from ``id_list``. When ``id_list``
        is empty this function returns success.
    event_id : id
        The name of a key in the event data. Default is ``id`` for the minion
        ID, another common value is ``name`` for use with orchestrating
        salt-cloud events.
    timeout : 300
        The maximum time in seconds to wait before failing.

    The following example blocks until all the listed minions complete a
    restart and reconnect to the Salt master:

    .. code-block:: yaml

        reboot_all_minions:
          salt.function:
            - name: system.reboot
            - tgt: '*'

        wait_for_reboots:
          salt.wait_for_event:
            - name: salt/minion/*/start
            - id_list:
              - jerry
              - stuart
              - dave
              - phil
              - kevin
              - mike
            - require:
              - salt: reboot_all_minions
    r-Fr5r?z$Orchestration would wait for event '�'r8Nr9Zsock_dirT)�opts�listenr)�fullz'wait_for_event: No event data; waiting.zTimeout value reached.�tag�datacsg|]}|�vr|�qSrr)r[rR��valrrr\�sz"wait_for_event.<locals>.<listcomp>z>wait_for_event: Event identifier '%s' not in id_list; skippingr7�minions_seen�zOwait_for_event: Event identifier '%s' removed from id_list; %s items remaining.z?wait_for_event: Event identifier '%s' not in id_list; skipping.zBwait_for_event: Event identifier '%s' not in event '%s'; skipping.z-wait_for_event: Skipping unmatched event '%s'zAll events seen in {} seconds.)rrgrr	r
Z	get_event�timerZtrace�fnmatchrfr!rt�removererr rrdrz)r6Zid_listZevent_idr2�noder1ZseventZdel_counterZ	starttimeZ	timelimitr
Zis_timedoutZval_listr�Z	found_valZval_idxrr�r�wait_for_eventms�+
�
�
�

����
��
��U��r�cKs<zt}Wntyt�d�d}Ynwz
t|d<t�dt|�Wnty0t�d�Ynwt�dd�rD|did|�d	�d
�}|Std|f|t	dd
�|��}|�d�}t
|t�rdd|vrdd|d<|�dd�}|d|i|d�}d�||rydnd�|d<td�dd�r�d|d<t
jj�dd�d|vr�|d|d<|S)a1
    Execute a runner module on the master

    .. versionadded:: 2014.7.0

    name
        The name of the function to run
    kwargs
        Any keyword arguments to pass to the runner function

    .. code-block:: yaml

         run-manage-up:
          salt.runner:
            - name: manage.up
    rNZ
__pub_userz>added __pub_user to kwargs using dunder user '%s', kwargs '%s'z?unable to find user for fire args event due to missing __user__r?FzRunner function '�' would be executed.�r6r9r7r8�saltutil.runnerT�r�__env__Zfull_returnr`�Error�success�r6r7r9zRunner function '{}' {}.�executedrar8�features�$enable_deprecated_orchestration_flag�__orchestration__i�z�The __orchestration__ return flag will be removed in {version}. For more information see https://github.com/saltstack/salt/pull/59917.rUrV)rr
rrZ__user__rvrrgrjr�rfrmrzrr	�versions�
warn_until)r6r}rUr1rSZ
runner_returnr�rrr�runner�s`
���
����

��r�c
s&t|t�r|||igi}t|t�s|didd�S|��D]\}}|dur'i}ntjj�|�}d|vr6||d<|||<qzt�Wnt	yOt
�d�d�Ynw�fdd�}zt|t
|�����Wntjjy�}z|ddid	|��d
�WYd}~Sd}~wwdd�t|����D��td
d����D��}�fdd��|r�dd����D�}|}	|	r�d}
n�fdd�|D�}d�|�}
i}���D]\}}
�|
d�}|r�|||<q�n3dd����D�}|}	|	r�d}
nt|�dkr�d|d�d�}
nd�d�|��}
ddd����D�i}||	||
d�}|S)a_
    Executes multiple runner modules on the master in parallel.

    .. versionadded:: 2018.3.0

    A separate thread is spawned for each runner. This state is intended to be
    used with the orchestrate runner in place of the ``saltmod.runner`` state
    when different tasks should be run in parallel. In general, Salt states are
    not safe when used concurrently, so ensure that they are used in a safe way
    (e.g. by only targeting separate minions in parallel tasks).

    name:
        name identifying this state. The name is provided as part of the
        output, but not used for anything else.

    runners:
        list of runners that should be run in parallel. Each element of the
        list has to be a dictionary. This dictionary's name entry stores the
        name of the runner function that shall be invoked. The optional kwarg
        entry stores a dictionary of named arguments that are passed to the
        runner function.

    .. code-block:: yaml

        parallel-state:
           salt.parallel_runners:
             - runners:
                 my_runner_1:
                   - name: state.orchestrate
                   - kwarg:
                       mods: orchestrate_state_1
                 my_runner_2:
                   - name: state.orchestrate
                   - kwarg:
                       mods: orchestrate_state_2
    Fz/The runners parameter must be a string or dict.r�Nr6rcs(td|df�tdd�|�di���S)Nr�r6Tr�r0)rjr�rg)�
runner_config)rUrr�call_runner�s��
�z%parallel_runners.<locals>.call_runnerz(One of the runners raised an exception: )r6r9r�r7r8cSsi|]	\}}||d�qS)r`r�r[�	runner_idrSrrr�
<dictcomp>�s�z$parallel_runners.<locals>.<dictcomp>cSs$g|]}|�dd�dkod|v�qS)Z	outputterr-rTr��rg)r[rSrrrr\�s��z$parallel_runners.<locals>.<listcomp>cs�t|t�siSd|vr,t|dt�r(|d�dd�dkr(d|dvr(|ddS|dSi}|��D]\}}�|�}|r@|||<q2|S)Nr7rSr-rTr1)rfrmrgru)�objZ
found_changes�key�valueZchange)�extract_changesrrr��s 
��z)parallel_runners.<locals>.extract_changescSs(g|]\}}|d�dd�dkr|�qS)r�r�rr�r�rrrr\�s
�z+All runner functions executed successfully.cs,g|]}d�|tjj�|dtdd���qS)z&Runner {} failed with return value:
{}�nested�)Z
nested_indent)rzr�outputZ
out_formatr)r[r�)rrrr\�s�����
r�cSs$g|]\}}|�dd�dkr|�qS)Z	exit_coderr�r�rrrr\�s
�r�zRunner rz failed.zRunners {} failed.rbr1cSsi|]\}}||�qSrrr�rrrr��s)rfrirmrurr	r�Zrepack_dictlistrr
rrr+r!rx�
exceptionsZ
SaltException�zip�keys�allr$r rz)r6Zrunnersr}r�r�r�r�Zhighstate_outputZfailed_runnersZall_successfulr8Zrunner_commentsr7rSZrunner_changesr1r)r�rUrr�parallel_runners@s�
,
�

�	������
�
�
	����r�cKs|didd�}zt}Wntyt�d�d}Ynwt�dd�r4d|d<i|d<d	|�d
�|d<|Std|f|td
�|��}|�d�}t|t	�rSd|vrSd|d<|�dd�}|d|i|d�}d�
||rhdnd�|d<td�dd�r�d|d<tjj
�dd�d|vr�|d|d<|S)aM
    Execute a wheel module on the master

    .. versionadded:: 2014.7.0

    name
        The name of the function to run
    kwargs
        Any keyword arguments to pass to the wheel function

    .. code-block:: yaml

        accept_minion_key:
          salt.wheel:
            - name: key.accept
            - match: frank
    Fr-r�rNr?r9r7zWheel function 'r�r8zsaltutil.wheel)rr�r`r�r�Tr�zWheel function '{}' {}.r�rar�r�r�ZArgonz�The __orchestration__ return flag will be removed in Salt Argon. For more information see https://github.com/saltstack/salt/pull/59917.rUrV)rr
rrrrgrjr�rfrmrzrr	r�r�)r6r}r1rUrSZwheel_returnr�rrr�wheel�sJ
����

��r�)Fr,r-NNNNNNNNNTNNrFNNFNNN)Fr,r-NNFNNNNNNNN)rRr�r�)�__doc__r��loggingrrr�Zsalt.exceptionsrZsalt.outputZ
salt.syspathsZsalt.utils.dataZsalt.utils.eventZsalt.utils.versions�	getLogger�__name__rrrrr+rKr�r�r�r�r�rrrr�<module>s�
/
�Y
�
5
G>