Current File : //lib/python2.7/site-packages/salt/modules/grains.pyc
�
���^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 d d l
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 d d l m Z d d l m Z d g Z i Z i d
d 6d
d 6d
d
6Z d � Z d Z e j! e" � Z# d � Z$ d � Z% d � Z& d � Z' i e$ d 6e' d 6e% d 6e% d 6e& d 6e& d 6e& d 6Z( d e e) d � Z* d � Z+ e, d � Z- d � Z. e, d � Z/ e, d! � Z0 e, e d" � Z1 e d# � Z2 d$ � Z3 e, d% � Z4 d& � Z5 d' d d( d d) � Z7 e d* � Z8 d+ d, d- � Z9 d e, e, e d. � Z: d/ � Z; e* Z< d S(0 u
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.
i ( t absolute_importt print_functiont unicode_literalsN( t reduce( t six( t DEFAULT_TARGET_DELIM( t
SaltException( t rangeu *u nestedu itemsu itemu setvalc C@ s
t j t � S( N( t collectionst defaultdictt
_infinitedict( ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt <lambda>0 s u/ NonExistentValueMagicNumberSpK3hnufdHfeBUXCfqVKc C@ sA t | � } t t j | d � � } d j | | d | | � S( u* Replaces the last 1/4 of a string with X'sg �?u {0}{1}u X( t lent intt matht floort format( t instrt lengtht index( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt _serial_sanitizer7 s c C@ s d S( Nu MINION.DOMAINNAME( ( t x( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyR > s c C@ s d S( Nu MINION( ( R ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyR ? s c C@ s d S( Nu
DOMAINNAME( ( R ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyR @ s u serialnumberu domainu fqdnu idu hostu localhostu nodenameu c C@ sU | t k r t } n$ t j j j t j j j t � � } t j j j | | | | � S( u�
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 Truet
__grains__t saltt utilst jsont loadst dumpst datat traverse_dict_and_list( t keyt defaultt delimitert orderedt grains( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt getP s # $ c C@ s t j j j t | t � t k S( ud
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 t KeyError( R ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt has_value~ s c C@ sp t j j j | � rh t t � } x@ t j t � D]/ \ } } | | k r1 | | | � | | <q1 q1 W| St Sd S( u�
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
N( R R R t is_truet dictR R t iteritemst _SANITIZERS( t sanitizet outR t func( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt items� s c O@ s� i } | j d d � } | j d t � } y7 x0 | D]( } t j j j t | | | � | | <q4 WWn t k
rt n Xt j j j | j d � � r� xC t j
t � D]/ \ } } | | k r� | | | � | | <q� q� Wn | S( u
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
u defaultu u delimiteru sanitize( R$ R R R R R R R% R' R R) R* ( t argst kwargst retR R! t argR- ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt item� s"
c
C@ s� | } t | t j � s' t d � � n i } t j j t d � r� t j j
j � r� t j j t j j
t d � d t d d � } q�t j j t j j
t d � d � } n� t j j t d � rt j j
j � r� t j j t d d t d d � } q�t j j t d d � } ni t j j
j � r]t j j t j j
t d � d t d d � } n% t j j t j j
t d � d � } t j j | � rt j j j | d � �I } y t j j j | � } Wn& t j j j k
r�} d j | � SXWd QXt | t � si } qn xx t j | � D]g \ } } | d k ru| t k ru| | k r\| | =n | t k r�t | =q�q"| | | <| t | <q"WyA t j j j | d � �# } t j j j | | d
t �Wd QXWn' t t f k
r�t j d | � n Xt j j t d d
� } y# t j j j! | d � � Wd QXWn' t t f k
r]t j d | � n Xt j" d t � s~t# d � n | S( u"
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.
CLI Example:
.. code-block:: bash
salt '*' grains.setvals "{'key1': 'val1', 'key2': 'val2'}"
u$ setvals grains must be a dictionary.u conf_fileu proxy.du idu grainsu rbu( Unable to read existing grains file: {0}Nu w+t default_flow_styleu8 Unable to write to grains file at %s. Check permissions.u cachediru module_refreshu4 Unable to write to cache file %s. Check permissions.u localu saltutil.refresh_grains($ t
isinstanceR t MappingR t ost patht isfilet __opts__R R t platformt is_proxyt joint dirnamet isdirt filest fopent yamlt safe_loadt YAMLErrorR R( R R) t NoneR R t safe_dumpt Falset IOErrort OSErrort logt errort flopenR$ t __salt__( R# t destructivet
new_grainst gfnt fp_t excR t valt fn_( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt setvals� s�
&
c C@ s t i | | 6| � S( u�
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.
CLI Example:
.. code-block:: bash
salt '*' grains.setval key val
salt '*' grains.setval key "{'sub-key': 'val', 'sub-key2': 'val2'}"
( RU ( R RS RN ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt setval9 s c C@ s6 t | g | � } | rH t | t � sH | d k r9 g n | g } qH n t | t � sd d j | � S| | k r� d j | | � St | t � r� x+ | D] } | j | � q� Wn
| j | � xi | | k r(| j | d � \ } } t | t � | � } t | t � r | j i | | 6� n | } q� Wt
| | � S( u�
.. 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
u The key {0} is not a valid listu' The val {0} was already in the list {1}i N( R$ R5 t listRE R t appendt rsplitR
R( t updateRV ( R RS t convertR! R# R3 t restt _grain( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyRX Q s& !!
c C@ s� t | g | � } t | t � s. d j | � S| | k rJ d j | | � S| j | � xf | | k r� | j | d � \ } } t | d | � } t | t � r� | j i | | 6� n | } qZ Wt | | � S( uF
.. 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
u The key {0} is not a valid listu# The val {0} was not in the list {1}i N(
R$ R5 RW R t removeRY RE R( RZ RV ( R RS R! R# R\ R] ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyR^ � s
c C@ s t | d d t �d S( u
.. 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.
CLI Example:
.. code-block:: bash
salt '*' grains.delkey key
RN N( RV RE R ( R ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt delkey� s c C@ s t | d d | �d S( u�
.. 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.
CLI Example:
.. code-block:: bash
salt '*' grains.delval key
RN N( RV RE ( R RN ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt delval� s c C@ s
t t � S( uw
Return a list of all available grains
CLI Example:
.. code-block:: bash
salt '*' grains.ls
( t sortedR ( ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt ls� s
u os_familyu defaultc
C@ s4 t j j j d | d | d t d | d | d | � S( u�
.. 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}
t lookup_dictt lookupt traverset mergeR t base( R R R t filter_byR ( Rc t grainRf R Rg ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyRh � s gc C@ sC t � } | j | � } t t j | d | � } | | | d <| S( u�
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"}}
i����( R
RY R t operatort getitem( R8 RS R! t nested_dictt keyst lastplace( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt _dict_from_path[ s
i u2 abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)c C@ s� t | d � } | d k r� d j g t | � D] } t j � j | � ^ q. � } t | k r� | j t d � \ } } t | t � � } t
| | � } | j | � t | | � q� t | | � n t | � S( u�
Perform a one-time generation of a hash and write it to the local grains.
If that grain has already been set return the value instead.
This is useful for generating passwords or keys that are specific to a
single minion that don't need to be stored somewhere centrally.
State Example:
.. code-block:: yaml
some_mysql_user:
mysql_user:
- present
- host: localhost
- password: {{ salt['grains.get_or_set_hash']('mysql:some_mysql_user') }}
CLI Example:
.. code-block:: bash
salt '*' grains.get_or_set_hash 'django:SECRET_KEY' 50
.. warning::
This function could return strings which may contain characters which are reserved
as directives by the YAML parser, such as strings beginning with ``%``. To avoid
issues when using the output of this function in an SLS file containing YAML+Jinja,
surround the call with single quotes.
u i N(
R$ RE R= R t randomt SystemRandomt choiceR t splitR
Ro RZ RV ( t nameR t charsR1 t _RS t rootR\ t curr( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt get_or_set_hashk s ! 7
c C@ se i d d 6i d 6t d 6} d } t | t � r9 d } n t | t � rQ d } n t � } t | | | � } | } d }
| | k r� d
}
n0 t | t � r� d }
n t | t � r� d }
n |
d
k r� | | k r� | d
k s� | t k r� d | d <| S| d
k r}| r}|
d k r;d j | � | d <t | d <| S| d k rt|
d
k rtd j | � | d <t | d <| S| } n | } x�| | k r| j | d
� \ } } t | i | � } t | t � r| d
k r| r| | j
� k r| j | � qq| j i | | 6� n� t | t � r�t } xx t
| � D]j \ }
} | | k rmi | | 6| |
<t } q;t | t � r;| | k r;| j i | | 6� t } q;q;W| s| j i | | 6� qnI | | k s�| r�i | | 6} n' d j | | | � | d <t | d <| S| } q�Wt | | d | �} t | t � rM| | d <n | | d <t | d <| S( un
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}'
u u commentu changesu resultu simpleu complexu Grain is already setuL The key '{0}' exists but is a dict or a list. Use 'force=True' to overwrite.u\ The key '{0}' exists and the given value is a dict or a list. Use 'force=True' to overwrite.i ul The key '{0}' value is '{1}', which is different from the provided key '{2}'. Use 'force=True' to overwrite.RN N( R R5 R( RW t objectR$ RE R RG RY Rm t popRZ t enumerateRX RV ( R RS t forceRN R! R1 t _new_value_typet
_non_existentt _existing_valuet _valuet _existing_value_typeR\ t
_list_updatedt _indext _itemt _setval_ret( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt set� s�
c C@ s" t j | � t j t | � � k S( u+
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
( R t text_typeR$ ( R t value( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt equals s (= t __doc__t
__future__R R R R7 Rp t loggingRj R R t functoolsR t salt.extR t salt.utils.compatR t salt.utils.datat salt.utils.filest salt.utils.jsont salt.utils.platformt salt.utils.yamlt
salt.defaultsR t salt.exceptionsR t salt.ext.six.movesR t __proxyenabled__R t
__outputter__R
t _non_existent_keyt getLoggert __name__RJ R t _FQDN_SANITIZERt _HOSTNAME_SANITIZERt _DOMAINNAME_SANITIZERR* R R$ R& RG R. R3 RU RV RX R^ R_ R` Rb RE Rh Ro Ry R� R� t fetch( ( ( s7 /usr/lib/python2.7/site-packages/salt/modules/grains.pyt <module> sx
. & c 9 +
o 1 u
Mini Shell