Current File : //proc/self/root/proc/3522530/root/lib/python2.7/site-packages/salt/modules/slsutil.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 e e d � Z
d d e d � Z d d e d � Z d d d d
� Z d � Z d � Z d
� Z d S( u0
Utility functions for use with or in SLS files
i ( t absolute_importt unicode_literalst print_functionNc C@ s t j j j | | | | � S( u3
Merge ``upd`` recursively into ``dest``
If ``merge_lists=True``, will aggregate list object types instead of
replacing. This behavior is only activated when ``recursive_update=True``.
CLI Example:
.. code-block:: shell
salt '*' slsutil.update '{foo: Foo}' '{bar: Bar}'
( t saltt utilst
dictupdatet update( t destt updt recursive_updatet merge_lists( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyR s u smartu yamlc C@ s t j j j | | | | | � S( u
Merge a data structure into another by choosing a merge strategy
Strategies:
* aggregate
* list
* overwrite
* recurse
* smart
CLI Example:
.. code-block:: shell
salt '*' slsutil.merge '{foo: Foo}' '{bar: Bar}'
( R R R t merge( t obj_at obj_bt strategyt rendererR
( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyR # s c C@ s< i } x/ | D]' } t j j j | | | | | � } q
W| S( uv
.. versionadded:: 2019.2.0
Merge a list of objects into each other in order
:type lst: Iterable
:param lst: List of objects to be merged.
:type strategy: String
:param strategy: Merge strategy. See utils.dictupdate.
:type renderer: String
:param renderer:
Renderer type. Used to determine strategy when strategy is 'smart'.
:type merge_lists: Bool
:param merge_lists: Defines whether to merge embedded object lists.
CLI Example:
.. code-block:: shell
$ salt-call --output=txt slsutil.merge_all '[{foo: Foo}, {foo: Bar}]'
local: {u'foo': u'Bar'}
( R R R R ( t lstR R R
t rett obj( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyt merge_all9 s
u
jinja|yamlc K@ s� | r# | r# t j j d � � n t j j t t � } | rQ t d | � } n | rj d } | | d <n t j j | | | t d t d | � } t d | � r� | j
� S| S( u8
Parse a string or file through Salt's renderer system
.. versionchanged:: 2018.3.0
Add support for Salt fileserver URIs.
This is an open-ended function and can be used for a variety of tasks. It
makes use of Salt's "renderer pipes" system to run a string or file through
a pipe of any of the loaded renderer modules.
:param path: The path to a file on Salt's fileserver (any URIs supported by
:py:func:`cp.get_url <salt.modules.cp.get_url>`) or on the local file
system.
:param string: An inline string to be used as the file to send through the
renderer system. Note, not all renderer modules can work with strings;
the 'py' renderer requires a file, for example.
:param default_renderer: The renderer pipe to send the file through; this
is overridden by a "she-bang" at the top of the file.
:param kwargs: Keyword args to pass to Salt's compile_template() function.
Keep in mind the goal of each renderer when choosing a render-pipe; for
example, the Jinja renderer processes a text file and produces a string,
however the YAML renderer processes a text file and produces a data
structure.
One possible use is to allow writing "map files", as are commonly seen in
Salt formulas, but without tying the renderer of the map file to the
renderer used in the other sls files. In other words, a map file could use
the Python renderer and still be included and used by an sls file that uses
the default 'jinja|yaml' renderer.
For example, the two following map files produce identical results but one
is written using the normal 'jinja|yaml' and the other is using 'py':
.. code-block:: jinja
#!jinja|yaml
{% set apache = salt.grains.filter_by({
...normal jinja map file here...
}, merge=salt.pillar.get('apache:lookup')) %}
{{ apache | yaml() }}
.. code-block:: python
#!py
def run():
apache = __salt__.grains.filter_by({
...normal map here but as a python dict...
}, merge=__salt__.pillar.get('apache:lookup'))
return apache
Regardless of which of the above map files is used, it can be accessed from
any other sls file by calling this function. The following is a usage
example in Jinja:
.. code-block:: jinja
{% set apache = salt.slsutil.renderer('map.sls') %}
CLI Example:
.. code-block:: bash
salt '*' slsutil.renderer salt://path/to/file
salt '*' slsutil.renderer /path/to/file
salt '*' slsutil.renderer /path/to/file.jinja 'jinja'
salt '*' slsutil.renderer /path/to/file.sls 'jinja|yaml'
salt '*' slsutil.renderer string='Inline template! {{ saltenv }}'
salt '*' slsutil.renderer string='Hello, {{ name }}.' name='world'
u Must pass either path or stringu
cp.get_urlu :string:u
input_datau renderer_blacklistu renderer_whitelistu stringio.is_readable( R t
exceptionst SaltInvocationErrort loadert rendert __opts__t __salt__t templatet compile_templatet __utils__t read( t patht stringt default_renderert kwargst rendererst path_or_stringR ( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyR ] s" G
c C@ s� t j j t � } t | | d � } t | | d � } | sZ t j j d j | � � � n | s� t j j d j | | � � � n | S( Nu Serializer '{0}' not found.u( Serializer '{0}' does not implement {1}.( R R t serializersR t getattrt NoneR t CommandExecutionErrort format( t
serializert fn_nameR$ t fnst fn( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyt _get_serialize_fn� s c K@ s+ t j j j | � } t | d � | | � S( ue
Serialize a Python object using a :py:mod:`serializer module
<salt.serializers>`
CLI Example:
.. code-block:: bash
salt '*' --no-parse=obj slsutil.serialize 'json' obj="{'foo': 'Foo!'}
Jinja Example:
.. code-block:: jinja
{% set json_string = salt.slsutil.serialize('json',
{'foo': 'Foo!'}) %}
u serialize( R R t argst clean_kwargsR- ( R) R t
mod_kwargsR! ( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyt serialize� s c K@ s+ t j j j | � } t | d � | | � S( u�
Deserialize a Python object using a :py:mod:`serializer module
<salt.serializers>`
CLI Example:
.. code-block:: bash
salt '*' slsutil.deserialize 'json' '{"foo": "Foo!"}'
salt '*' --no-parse=stream_or_string slsutil.deserialize 'json' \
stream_or_string='{"foo": "Foo!"}'
Jinja Example:
.. code-block:: jinja
{% set python_object = salt.slsutil.deserialize('json',
'{"foo": "Foo!"}') %}
u deserialize( R R R. R/ R- ( R) t stream_or_stringR0 R! ( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyt deserialize� s ( t __doc__t
__future__R R R t salt.exceptionsR t salt.loadert
salt.templatet salt.utils.argst salt.utils.dictupdatet Truet FalseR R R R& R R- R1 R3 ( ( ( s8 /usr/lib/python2.7/site-packages/salt/modules/slsutil.pyt <module> s $^
Mini Shell