o

�N�g7W�@s�
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlmZ
d
dlm	Z	
d
dl
Zd
dlZd
dl
Zd
dlZd
dlZd
dlZd
dlmZ
d
dlmZ
dg
ZiZdddd	�Zd
d�ZdZe�e�
Zd
d�Zdd�Zdd�Zdd�Z ee eeeeed�Z!dedfdd�
Z"dd�Z#d9dd�
Z$dd �Z%d:d!d"�
Z&d:d#d$�
Z'defd%d&�
Z(ef
d'd(�
Z)d9d)d*�
Z*d;d+d,�
Z+d-d.�Z,d<d1d2�
Z-ef
d3d4�
Z.dddefd5d6�
Z/d7d8�Z0e"Z1dS)=a

Return/control aspects of the grains data

Grains set or altered with this module are stored in the 'grains'
file on the minions. By default, this file is located at: ``/etc/salt/grains``

.. Note::

   This does **NOT** override any grains set in the minion config file.
�N)
�Mapping)
�reduce)
�DEFAULT_TARGET_DELIM)
�
SaltException�
*�nested)�items�item�setvalcCs
t�
t�
S)
N)�collections�defaultdict�
_infinitedict�rr�G/opt/saltstack/salt/lib/python3.10/site-packages/salt/modules/grains.pyr
+s

r
Z/NonExistentValueMagicNumberSpK3hnufdHfeBUXCfqVKc
Cs6t|�
}
t
t�|
d
�
�
}d�|d|�d|
|�S)z*Replaces the last 1/4 of a string with X'sg�?z{}{}N�
X)�len�int�math�floor�format)Zinstr�length�indexrrr�_serial_sanitizer4s

rc


C�d
S)NzMINION.DOMAINNAMEr�
�
xrrr�_fqdn_sanitizer;�
rc


Cr)NZMINIONrrrrr�_hostname_sanitizer?rrc


Cr)NZ
DOMAINNAMErrrrr�_domainname_sanitizerCrr)Zserialnumber�domainZfqdn�id�hostZ	localhost�nodename�TcCs:|d
urt}nt
jj�t
jj�t�
�
}t
jj�|||
|�S)a�
    Attempt to retrieve the named value from grains, if the named value is not
    available return the passed default. The default return is an empty string.

    The value can also represent a value in a nested dict using a ":" delimiter
    for the dict. This means that if a dict in grains looks like this::

        {'pkg': {'apache': 'httpd'}}

    To retrieve the value associated with the apache key in the pkg dict this
    key can be passed::

        pkg:apache


    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict.
        This is useful for when the desired key contains a colon. See CLI
        example below for usage.

        .. versionadded:: 2014.7.0

    :param ordered:
        Outputs an ordered dict if applicable (default: True)

        .. versionadded:: 2016.11.0

    CLI Example:

    .. code-block:: bash

        salt '*' grains.get pkg:apache
        salt '*' grains.get abc::def|ghi delimiter='|'
    T)�
__grains__�salt�utils�json�loads�dumps�data�traverse_dict_and_list)�key�default�	delimiterZordered�grainsrrr�getTs#

r1c

Cstj
j�t|t�tu
S)
ad

    Determine whether a key exists in the grains dictionary.

    Given a grains dictionary that contains the following structure::

        {'pkg': {'apache': 'httpd'}}

    One would determine if the apache key in the pkg dict exists by::

        pkg:apache

    CLI Example:

    .. code-block:: bash

        salt '*' grains.has_value pkg:apache
    )r&r'r+r,r%�KeyError)
r-rrr�	has_value~s
��r3Fc
CsLtj
j�|�
r"tt�
}
t��D]\}}||
vr||
|�
|
|<q|
Stt�
S)
z�
    Return all of the minion's grains

    CLI Example:

    .. code-block:: bash

        salt '*' grains.items

    Sanitized CLI Example:

    .. code-block:: bash

        salt '*' grains.items sanitize=True
    )r&r'r+�is_true�dictr%�_SANITIZERSr)�sanitize�outr-�funcrrrr�s



�
rcOs�i}|
�d
d�}|
�dt
�}z|D]}tjj�t|||�||<qWn	ty*


Yn
wtjj�|
�d�
�
rJt	�
�D]\}}||vrI|||�
||<q9|S)a

    Return one or more grains

    CLI Example:

    .. code-block:: bash

        salt '*' grains.item os
        salt '*' grains.item os osrelease oscodename

    Sanitized CLI Example:

    .. code-block:: bash

        salt '*' grains.item host sanitize=True
    r.r$r/r7)r1rr&r'r+r,r%r2r4r6r)�args�kwargs�retr.r/�argr9rrrr	�s$





��
�


�
r	c
Cs�|}t|t
�std
�
�
i}tj�td�
r;tjj	�
�r-tj�tj�td�
dtdd�}nYtj�tj�td�
d�}nKtj�
td�
ratjj	�
�rWtj�tddtdd�}n/tj�tdd�}n%tjj	�
�rytj�tj�td�
dtdd�}n
tj�tj�td�
d�}tj�|�
r�tjj�|d��3}z	tjj�|�
}Wn!tjjjy�
}
zd|��WYd}~Wd�
Sd}~w
wWd�
n1s�w



Y
t|t�s�i}|��D]#\}}|dur�|
d	ur�||vr�||=|tvr�t|=q�|||<|t|<q�z'tjjj|d
dd��}tjjj||d
d�
Wd�
n	1�
sw



Y
Wnt�
y5


t�d|�
Yn
wtj�tdd�}	ztjj�|	d
��
Wd�
n	1�
sTw



Y
Wnt�
yj


t�d|	�
Yn
wt�dd
��
sytd|d�

|S)az

    Set new grains values in the grains config file

    destructive
        If an operation results in a key being removed, delete the key, too.
        Defaults to False.

    refresh_pillar
        Whether pillar will be refreshed.
        Defaults to True.

    CLI Example:

    .. code-block:: bash

        salt '*' grains.setvals "{'key1': 'val1', 'key2': 'val2'}"
    z$setvals grains must be a dictionary.Z	conf_filezproxy.dr!r0�rbz%Unable to read existing grains file: NTzw+zutf-8)
�encodingF)
Zdefault_flow_stylez8Unable to write to grains file at %s. Check permissions.ZcachedirZmodule_refreshz4Unable to write to cache file %s. Check permissions.�localzsaltutil.refresh_grains�
�refresh_pillar)�
isinstancerr�os�path�isfileZ__opts__r&r'�platformZis_proxy�join�dirname�isdir�filesZfopenZyamlZ	safe_loadZ	YAMLErrorr5rr%Z	safe_dump�OSError�log�errorZflopenr1Z__salt__)
r0�destructiverBZ
new_grainsZgfnZfp_�excr-�valZfn_rrr�setvals�s�










�



�




�




����







�




��
�


��
�rRcCst||
i
||d
�S)a
    Set a grains value in the grains config file

    key
        The grain key to be set.

    val
        The value to set the grain key to.

    destructive
        If an operation results in a key being removed, delete the key, too.
        Defaults to False.

    refresh_pillar
        Whether pillar will be refreshed.
        Defaults to True.

    CLI Example:

    .. code-block:: bash

        salt '*' grains.setval key val
        salt '*' grains.setval key "{'sub-key': 'val', 'sub-key2': 'val2'}"
    rA)
rR)r-rQrOrBrrrr
)
sr
cCs�t|g|�}|rt
|t�s|d
urgn|g
}t
|t�s!d|�d�S|
|vr-d|
�d|��St
|
t�r=|
D]}|�|�

q4n|�|
�

||vrg|�|d�\}}t|t�|�}t
|t�ra|�||i
�

|}||vsFt||�S)a�
    .. versionadded:: 0.17.0

    Append a value to a list in the grains config file. If the grain doesn't
    exist, the grain key is added and the value is appended to the new grain
    as a list item.

    key
        The grain key to be appended to

    val
        The value to append to the grain key

    convert
        If convert is True, convert non-list contents into a list.
        If convert is False and the grain contains non-list contents, an error
        is given. Defaults to False.

    delimiter
        The key can be a nested dict key. Use this parameter to
        specify the delimiter you use, instead of the default ``:``.
        You can now append values to a list in nested dictionary grains. If the
        list doesn't exist at this level, it will be created.

        .. versionadded:: 2014.7.6

    CLI Example:

    .. code-block:: bash

        salt '*' grains.append key val
    N�The key � is not a valid list�The val z was already in the list �
)	r1rC�list�append�rsplitr
r5�updater
)r-rQ�convertr/r0r	�rest�_grainrrrrXE
s*!












�






�
rXcCs�t|g|�}t
|t�sd
|�d�S|
|v
rd|
�d|��S|�|
�

||vrF|�|d�\}}t|d|�}t
|t�r@|�||i
�

|}||vs&t||�S)aF
    .. versionadded:: 0.17.0

    Remove a value from a list in the grains config file

    key
        The grain key to remove.

    val
        The value to remove.

    delimiter
        The key can be a nested dict key. Use this parameter to
        specify the delimiter you use, instead of the default ``:``.
        You can now append values to a list in nested dictionary grains. If the
        list doesn't exist at this level, it will be created.

        .. versionadded:: 2015.8.2

    CLI Example:

    .. code-block:: bash

        salt '*' grains.remove key val
    rSrTrUz was not in the list rVN)r1rCrW�removerYr5rZr
)r-rQr/r0r\r]rrrr^~
s












�
r^cCst|d
|
d�S)az

    .. versionadded:: 2017.7.0

    Remove a grain completely from the grain system, this will remove the
    grain key and value

    key
        The grain key from which to delete the value.

    force
        Force remove the grain even when it is a mapped value.
        Defaults to False

    CLI Example:

    .. code-block:: bash

        salt '*' grains.delkey key
    T�rO�force)
�delval)r-r`rrr�delkey�
srbcCst|d
|
|d�S)a.
    .. versionadded:: 0.17.0

    Delete a grain value from the grains config file. This will just set the
    grain value to ``None``. To completely remove the grain, run ``grains.delkey``
    or pass ``destructive=True`` to ``grains.delval``.

    key
        The grain key from which to delete the value.

    destructive
        Delete the key, too. Defaults to False.

    force
        Force remove the grain even when it is a mapped value.
        Defaults to False

    CLI Example:

    .. code-block:: bash

        salt '*' grains.delval key
    Nr_)
�set)r-rOr`rrrra�
sracCstt
�
S)
zw
    Return a list of all available grains

    CLI Example:

    .. code-block:: bash

        salt '*' grains.ls
    )�sortedr%rrrr�ls�
s
re�	os_familyr.cCstj
jj||
t|||d
�S)a�
    .. versionadded:: 0.17.0

    Look up the given grain in a given dictionary for the current OS and return
    the result

    Although this may occasionally be useful at the CLI, the primary intent of
    this function is for use in Jinja to make short work of creating lookup
    tables for OS-specific data. For example:

    .. code-block:: jinja

        {% set apache = salt['grains.filter_by']({
            'Debian': {'pkg': 'apache2', 'srv': 'apache2'},
            'RedHat': {'pkg': 'httpd', 'srv': 'httpd'},
        }, default='Debian') %}

        myapache:
          pkg.installed:
            - name: {{ apache.pkg }}
          service.running:
            - name: {{ apache.srv }}

    Values in the lookup table may be overridden by values in Pillar. An
    example Pillar to override values in the example above could be as follows:

    .. code-block:: yaml

        apache:
          lookup:
            pkg: apache_13
            srv: apache

    The call to ``filter_by()`` would be modified as follows to reference those
    Pillar values:

    .. code-block:: jinja

        {% set apache = salt['grains.filter_by']({
            ...
        }, merge=salt['pillar.get']('apache:lookup')) %}


    :param lookup_dict: A dictionary, keyed by a grain, containing a value or
        values relevant to systems matching that grain. For example, a key
        could be the grain for an OS and the value could the name of a package
        on that particular OS.

        .. versionchanged:: 2016.11.0

            The dictionary key could be a globbing pattern. The function will
            return the corresponding ``lookup_dict`` value where grain value
            matches the pattern. For example:

            .. code-block:: bash

                # this will render 'got some salt' if Minion ID begins from 'salt'
                salt '*' grains.filter_by '{salt*: got some salt, default: salt is not here}' id

    :param grain: The name of a grain to match with the current system's
        grains. For example, the value of the "os_family" grain for the current
        system could be used to pull values from the ``lookup_dict``
        dictionary.

        .. versionchanged:: 2016.11.0

            The grain value could be a list. The function will return the
            ``lookup_dict`` value for a first found item in the list matching
            one of the ``lookup_dict`` keys.

    :param merge: A dictionary to merge with the results of the grain selection
        from ``lookup_dict``. This allows Pillar to override the values in the
        ``lookup_dict``. This could be useful, for example, to override the
        values for non-standard package names such as when using a different
        Python version from the default Python version provided by the OS
        (e.g., ``python26-mysql`` instead of ``python-mysql``).

    :param default: default lookup_dict's key used if the grain does not exists
        or if the grain value has no match on lookup_dict.  If unspecified
        the value is "default".

        .. versionadded:: 2014.1.0

    :param base: A lookup_dict key to use for a base dictionary.  The
        grain-selected ``lookup_dict`` is merged over this and then finally
        the ``merge`` dictionary is merged.  This allows common values for
        each case to be collected in the base and overridden by the grain
        selection dictionary and the merge dictionary.  Default is unset.

        .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' grains.filter_by '{Debian: Debheads rule, RedHat: I love my hat}'
        # this one will render {D: {E: I, G: H}, J: K}
        salt '*' grains.filter_by '{A: B, C: {D: {E: F, G: H}}}' 'xxx' '{D: {E: I}, J: K}' 'C'
        # next one renders {A: {B: G}, D: J}
        salt '*' grains.filter_by '{default: {A: {B: C}, D: E}, F: {A: {B: G}}, H: {D: I}}' 'xxx' '{D: J}' 'F' 'default'
        # next same as above when default='H' instead of 'F' renders {A: {B: C}, D: J}
    )�lookup_dict�lookupZtraverse�merger.�base)r&r'r+�	filter_byr%)rgZgrainrir.rjrrrrk�
sg





�rkcCs6t�}|�
|�
}ttj|d
d�|�}|
||d<|S)z�
    Given a lookup string in the form of 'foo:bar:baz" return a nested
    dictionary of the appropriate depth with the final segment as a value.

    >>> _dict_from_path('foo:bar:baz', 'somevalue')
    {"foo": {"bar": {"baz": "somevalue"}}
    N���)r
rYr�operator�getitem)rErQr/Znested_dict�keysZ	lastplacerrr�_dict_from_pathYs




rpcCsRd
idd�}d}t|
t
�rd}nt|
t�rd}t�}t|||�}|}	d}
||ur+d}
nt|t
�r3d}
nt|t�r:d}
|
du
rP||
krP|
du
sJ|du
rPd|d<|S|du
r|s|
dkrgd	�|�
|d<d
|d<|S|dkr||
du
r|d�|�
|d<d
|d<|S|
}	n|
}	||v�
r|�|d
�\}}t|i|�}t|t
�r�|	dur�|r�||��vr�|�|�

n[|�	||	i
�

nSt|t�r�d
}t
|�
D]#\}
}||kr�||	i
||
<d}q�t|t
�r�||vr�|�	||	i
�

d}q�|s�|�||	i
�

n||ks�|r�||	i
}nd�|||�|d<d
|d<|S|}	||vs�t||	|d�}t|t
��
r||d<|S||d<d
|d<|S)an
    Set a key to an arbitrary value. It is used like setval but works
    with nested keys.

    This function is conservative. It will only overwrite an entry if
    its value and the given one are not a list or a dict. The ``force``
    parameter is used to allow overwriting in all cases.

    .. versionadded:: 2015.8.0

    :param force: Force writing over existing entry if given or existing
                  values are list or dict. Defaults to False.
    :param destructive: If an operation results in a key being removed,
                  delete the key, too. Defaults to False.
    :param delimiter:
        Specify an alternate delimiter to use when traversing a nested dict,
        the default being ``:``

    CLI Example:

    .. code-block:: bash

        salt '*' grains.set 'apps:myApp:port' 2209
        salt '*' grains.set 'apps:myApp' '{port: 2209}'
    r$T)�comment�changes�result�simple�complexNzGrain is already setrqzKThe key '{}' exists but is a dict or a list. Use 'force=True' to overwrite.Frsz[The key '{}' exists and the given value is a dict or a list. Use 'force=True' to overwrite.rVziThe key '{}' value is '{}', which is different from the provided key '{}'. Use 'force=True' to overwrite.)
rOrr)
rCr5rW�objectr1rrYro�poprZ�	enumeraterXr
)r-rQr`rOr/r<Z_new_value_typeZ
_non_existentZ_existing_value�_valueZ_existing_value_typer\Z
_list_updated�_indexZ_itemZ_setval_retrrrrcis�




















�


�









�









�

�




��

�!

�

rccCst|
�
tt
|�
�
kS)
a+

    Used to make sure the minion's grain key/value matches.

    Returns ``True`` if matches otherwise ``False``.

    .. versionadded:: 2017.7.0

    CLI Example:

    .. code-block:: bash

        salt '*' grains.equals fqdn <expected_fqdn>
        salt '*' grains.equals systemd:version 219
    )�strr1)r-�valuerrr�equals�sr})
F)FT)FF)rfNr.N)2�__doc__r�loggingrrmrD�collections.abcr�	functoolsrZsalt.utils.compatr&Zsalt.utils.dataZsalt.utils.filesZsalt.utils.jsonZsalt.utils.platformZsalt.utils.yamlZ
salt.defaultsrZsalt.exceptionsrZ__proxyenabled__r%Z
__outputter__r
Z_non_existent_key�	getLogger�__name__rMrrrrr6r1r3rr	rRr
rXr^rbrarerkrprcr}Zfetchrrrr�<module>
sj














�






�*

$
U9
+


qw