Current File : //lib/python2.7/site-packages/salt/modules/napalm_formula.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
j j Z d d l
Z d d l m Z y d d l m Z Wn! e k
r� d d l m Z n Xd g Z d Z e j e � Z d � Z d d e d � Z d d e d
� Z d e d � Z d e d � Z e e! d
� Z" d e! d � Z# d d e! d � Z$ d � Z% d S( u4
NAPALM Formula helpers
======================
.. versionadded:: 2019.2.0
This is an Execution Module providing helpers for various NAPALM formulas,
e.g., napalm-interfaces-formula, napalm-bgp-formula, napalm-ntp-formula etc.,
meant to provide various helper functions to make the templates more readable.
i ( t absolute_importt unicode_literalst print_functionN( t DEFAULT_TARGET_DELIM( t traverse_dict_and_listu *u napalm_formulac C@ s t j j j t t t � S( u+
Available only on NAPALM Minions.
( t saltt utilst napalmt virtualt __opts__t __virtualname__t __file__( ( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt __virtual__# s c c@ s� | s d } n | s d } n x� t j | � D]{ \ } } | ra d j d | d | d | � } n | } | | k r{ | Vq. x+ t | d | d | d | �D] } | Vq� Wq. Wd S(
ur
Generate all the possible paths within an OpenConfig-like object.
This function returns a generator.
u u configu {prev_key}{delim}{cur_key}t prev_keyt delimt cur_keyt keyt containerN( t sixt iteritemst formatt _container_path( t modelR R R t model_keyt model_valuet key_deptht value( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyR * s"
c C@ s t t | � � S( u^
Return the list of all the possible paths in a container, down to the
``config`` container.
This function can be used to verify that the ``model`` is a Python object
correctly structured and respecting the OpenConfig hierarchy.
model
The OpenConfig-structured object to inspect.
delim: ``:``
The key delimiter. In particular cases, it is indicated to use ``//``
as ``:`` might be already used in various cases, e.g., IPv6 addresses,
interface name (e.g., Juniper QFX series), etc.
CLI Example:
.. code-block:: bash
salt '*' napalm_formula.container_path "{'interfaces': {'interface': {'Ethernet1': {'config': {'name': 'Ethernet1'}}}}}"
The example above would return a list with the following element:
``interfaces:interface:Ethernet1:config`` which is the only possible path
in that hierarchy.
Other output examples:
.. code-block:: text
- interfaces:interface:Ethernet1:config
- interfaces:interface:Ethernet1:subinterfaces:subinterface:0:config
- interfaces:interface:Ethernet2:config
( t listR ( R R R R ( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt container_pathG s !c C@ sw | s i } n | } | j | � } x5 | d D]) } | | k rN i | | <n | | } q/ Wt j | � | | d <| S( u}
Set a value under the dictionary hierarchy identified
under the key. The target 'foo/bar/baz' returns the
dictionary hierarchy {'foo': {'bar': {'baz': {}}}}.
.. note::
Currently this doesn't work with integers, i.e.
cannot build lists dynamically.
CLI Example:
.. code-block:: bash
salt '*' formula.setval foo:baz:bar True
i����( t splitt copyt deepcopy( R t valt dict_R t prev_hiert dict_hiert each( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt setvalk s
c C@ s t | | d | d | �S( u�
Traverse a dict or list using a colon-delimited (or otherwise delimited,
using the ``delimiter`` param) target string. The target ``foo:bar:0`` will
return ``data['foo']['bar'][0]`` if this value exists, and will otherwise
return the dict in the default argument.
Function will automatically determine the target type.
The target ``foo:bar:0`` will return data['foo']['bar'][0] if data like
``{'foo':{'bar':['baz']}}`` , if data like ``{'foo':{'bar':{'0':'baz'}}}``
then ``return data['foo']['bar']['0']``
CLI Example:
.. code-block:: bash
salt '*' napalm_formula.traverse "{'foo': {'bar': {'baz': True}}}" foo:baz:bar
t defaultt delimiter( t _traverse_dict_and_list( t dataR R& R' ( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt traverse� s c C@ s" t j j j | | d | d | �S( u#
Recursive version of the default dict.update
Merges upd recursively into dest
If recursive_update=False, will use the classic dict.update, or fall back
on a manual merge (helpful for non-dict types like ``FunctionWrapper``).
If ``merge_lists=True``, will aggregate list object types instead of replace.
The list in ``upd`` is added to the list in ``dest``, so the resulting list
is ``dest[key] + upd[key]``. This behaviour is only activated when
``recursive_update=True``. By default ``merge_lists=False``.
t recursive_updatet merge_lists( R R t
dictupdatet update( t destt updR+ R, ( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyR- � s u //c
C@ st i } t j d � t j | � t j d � t j | � x� t | d | �D]� } x� t | d | �D]� } t j d | | � t j | | � sf t | j | � � t | j | � � k r� qf n t j d | | � t | | d | �} t | | d | d | �} qf WqM Wt j d � t j | � t j d � t j | � | r^t j j
j | | � St j j
j | | � S(
uC
Apply the defaults to a Python dictionary having the structure as described
in the OpenConfig standards.
model
The OpenConfig model to apply the defaults to.
defaults
The dictionary of defaults. This argument must equally be structured
with respect to the OpenConfig standards.
For ease of use, the keys of these support glob matching, therefore
we don't have to provide the defaults for each entity but only for
the entity type. See an example below.
delim: ``//``
The key delimiter to use. Generally, ``//`` should cover all the possible
cases, and you don't need to override this value.
flipped_merge: ``False``
Whether should merge the model into the defaults, or the defaults
into the model. Default: ``False`` (merge the model into the defaults,
i.e., any defaults would be overridden by the values from the ``model``).
CLI Example:
.. code-block:: bash
salt '*' napalm_formula.defaults "{'interfaces': {'interface': {'Ethernet1': {'config': {'name': 'Ethernet1'}}}}}" "{'interfaces': {'interface': {'*': {'config': {'enabled': True}}}}}"
As one can notice in the example above, the ``*`` corresponds to the
interface name, therefore, the defaults will be applied on all the
interfaces.
u Applying the defaults:u openconfig like dictionary:R u Comparing %s to %su
%s matches %sR' R! u Complete default dictionaryu Merging with the model( t logt debugR t fnmatcht lenR R( R% R R R- R. ( R t defaults_R t
flipped_merget mergedt
model_patht default_patht devault_val( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt defaults� s. &
+ #
c K@ s� t | | � } | d k r d S| d k r@ | j d d � } n | d k rn t d d
k re d } qn d } n | r� d j d | � } n d j d
| d | d | � S( uZ
Render a field found under the ``field`` level of the hierarchy in the
``dictionary`` object.
This is useful to render a field in a Jinja template without worrying that
the hierarchy might not exist. For example if we do the following in Jinja:
``{{ interfaces.interface.Ethernet5.config.description }}`` for the
following object:
``{'interfaces': {'interface': {'Ethernet1': {'config': {'enabled': True}}}}}``
it would error, as the ``Ethernet5`` key does not exist.
With this helper, we can skip this and avoid existence checks. This must be
however used with care.
dictionary
The dictionary to traverse.
field
The key name or part to traverse in the ``dictionary``.
prepend: ``None``
The text to prepend in front of the text. Usually, we need to have the
name of the field too when generating the configuration.
append: ``None``
Text to append at the end.
quotes: ``False``
Whether should wrap the text around quotes.
CLI Example:
.. code-block:: bash
salt '*' napalm_formula.render_field "{'enabled': True}" enabled
# This would return the value of the ``enabled`` leaf key
salt '*' napalm_formula.render_field "{'enabled': True}" description
# This would not error
Jinja usage example:
.. code-block:: jinja
{%- set config = {'enabled': True, 'description': 'Interface description'} %}
{{ salt.napalm_formula.render_field(config, 'description', quotes=True) }}
The example above would be rendered on Arista / Cisco as:
.. code-block:: text
description "Interface description"
While on Junos (the semicolon is important to be added, otherwise the
configuration won't be accepted by Junos):
.. code-block:: text
description "Interface description";
u u _u -u osu junosu ;u "{value}"R u {prepend} {value}{append}t prependt appendN( u junos( R* t Nonet replacet
__grains__R ( t
dictionaryt fieldR< R= t quotest optsR ( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt render_field� s ? c O@ s� g } x6 | D]. } t | | | � } | r
| j | � q
q
Wd | k rX d | d <n d | k r� d j d d | d � | d <n | d j | � S( u
This function works similarly to
:mod:`render_field <salt.modules.napalm_formula.render_field>` but for a
list of fields from the same dictionary, rendering, indenting and
distributing them on separate lines.
dictionary
The dictionary to traverse.
fields
A list of field names or paths in the dictionary.
indent: ``0``
The indentation to use, prepended to the rendered field.
separator: ``\n``
The separator to use between fields.
CLI Example:
.. code-block:: bash
salt '*' napalm_formula.render_fields "{'mtu': 68, 'description': 'Interface description'}" mtu description
Jinja usage example:
.. code-block:: jinja
{%- set config={'mtu': 68, 'description': 'Interface description'} %}
{{ salt.napalm_formula.render_fields(config, 'mtu', 'description', quotes=True) }}
The Jinja example above would generate the following configuration:
.. code-block:: text
mtu "68"
description "Interface description"
u indenti u separatoru
{ind}t indu ( RE R= R t join( RA t fieldsRD t resultsRB t res( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt
render_fields= s )
!(& t __doc__t
__future__R R R R t loggingR3 t salt.utils.napalmR t salt.ext.sixt extR t salt.utils.dictupdatet
salt.defaultsR t salt.utils.dataR R( t ImportErrort
salt.utilst __proxyenabled__R
t getLoggert __name__R1 R R> R R R% R* t Truet FalseR- R; RE RK ( ( ( s? /usr/lib/python2.7/site-packages/salt/modules/napalm_formula.pyt <module> s:
$ ? L
Mini Shell