Current File : //lib/python2.7/site-packages/salt/beacons/napalm_beacon.pyc
�
���^c @@ s� d Z d d l m Z m Z d d l Z d d l Z d d l m Z d d l Z e j
e � Z e j
d � Z i d d 6d d 6d
d 6d d
6d d 6d d 6Z d Z d � Z d � Z d � Z d � Z d S( u~
Watch NAPALM functions and fire events on specific triggers
===========================================================
.. versionadded:: 2018.3.0
.. note::
The ``NAPALM`` beacon only works only when running under
a regular Minion or a Proxy Minion, managed via NAPALM_.
Check the documentation for the
:mod:`NAPALM proxy module <salt.proxy.napalm>`.
.. _NAPALM: http://napalm.readthedocs.io/en/latest/index.html
The configuration accepts a list of Salt functions to be
invoked, and the corresponding output hierarchy that should
be matched against. To invoke a function with certain
arguments, they can be specified using the ``_args`` key, or
``_kwargs`` for more specific key-value arguments.
The match structure follows the output hierarchy of the NAPALM
functions, under the ``out`` key.
For example, the following is normal structure returned by the
:mod:`ntp.stats <salt.modules.napalm_ntp.stats>` execution function:
.. code-block:: json
{
"comment": "",
"result": true,
"out": [
{
"referenceid": ".GPSs.",
"remote": "172.17.17.1",
"synchronized": true,
"reachability": 377,
"offset": 0.461,
"when": "860",
"delay": 143.606,
"hostpoll": 1024,
"stratum": 1,
"jitter": 0.027,
"type": "-"
},
{
"referenceid": ".INIT.",
"remote": "172.17.17.2",
"synchronized": false,
"reachability": 0,
"offset": 0.0,
"when": "-",
"delay": 0.0,
"hostpoll": 1024,
"stratum": 16,
"jitter": 4000.0,
"type": "-"
}
]
}
In order to fire events when the synchronization is lost with
one of the NTP peers, e.g., ``172.17.17.2``, we can match it explicitly as:
.. code-block:: yaml
ntp.stats:
remote: 172.17.17.2
synchronized: false
There is one single nesting level, as the output of ``ntp.stats`` is
just a list of dictionaries, and this beacon will compare each dictionary
from the list with the structure examplified above.
.. note::
When we want to match on any element at a certain level, we can
configure ``*`` to match anything.
Considering a more complex structure consisting on multiple nested levels,
e.g., the output of the :mod:`bgp.neighbors <salt.modules.napalm_bgp.neighbors>`
execution function, to check when any neighbor from the ``global``
routing table is down, the match structure would have the format:
.. code-block:: yaml
bgp.neighbors:
global:
'*':
up: false
The match structure above will match any BGP neighbor, with
any network (``*`` matches any AS number), under the ``global`` VRF.
In other words, this beacon will push an event on the Salt bus
when there's a BGP neighbor down.
The right operand can also accept mathematical operations
(i.e., ``<``, ``<=``, ``!=``, ``>``, ``>=`` etc.) when comparing
numerical values.
Configuration Example:
.. code-block:: yaml
beacons:
napalm:
- net.interfaces:
# fire events when any interfaces is down
'*':
is_up: false
- net.interfaces:
# fire events only when the xe-0/0/0 interface is down
'xe-0/0/0':
is_up: false
- ntp.stats:
# fire when there's any NTP peer unsynchornized
synchronized: false
- ntp.stats:
# fire only when the synchronization
# with with the 172.17.17.2 NTP server is lost
_args:
- 172.17.17.2
synchronized: false
- ntp.stats:
# fire only when there's a NTP peer with
# synchronization stratum > 5
stratum: '> 5'
Event structure example:
.. code-block:: json
{
"_stamp": "2017-09-05T09:51:09.377202",
"args": [],
"data": {
"comment": "",
"out": [
{
"delay": 0.0,
"hostpoll": 1024,
"jitter": 4000.0,
"offset": 0.0,
"reachability": 0,
"referenceid": ".INIT.",
"remote": "172.17.17.1",
"stratum": 16,
"synchronized": false,
"type": "-",
"when": "-"
}
],
"result": true
},
"fun": "ntp.stats",
"id": "edge01.bjm01",
"kwargs": {},
"match": {
"stratum": "> 5"
}
}
The event examplified above has been fired when the device
identified by the Minion id ``edge01.bjm01`` has been synchronized
with a NTP server at a stratum level greater than 5.
i ( t absolute_importt unicode_literalsN( t sixu' ^(<|>|<=|>=|==|!=)\s*(\d+(\.\d+){0,1})$u __lt__u <u __gt__u >u __ge__u >=u __le__u <=u __eq__u ==u __ne__u !=u napalmc C@ s t j j j t t t � S( uk
This beacon can only work when running under a regular or a proxy minion, managed through napalm.
( t saltt utilst napalmt virtualt __opts__t __virtualname__t __file__( ( ( s> /usr/lib/python2.7/site-packages/salt/beacons/napalm_beacon.pyt __virtual__� s c
C@ s+ t | t � r�t | t � r�t j d � x�t j | � D]\ } } | d k r-t | t � r� t } x0 t j | � D] \ } } | t | | � O} qx W| St } t | t t f � r� xi | D] } | t | | � O} q� WnE t | t � r&x3 t j | � D] \ } } | t | | � O} q Wn | Sq; t | t � r]| | k rLt St | | | � St | t � r�t } x0 t j | � D] \ } } | t | | � O} q�W| St | | | � Sq; Wnft | t t f � r7t | t t f � r7t j d � t } x2 | D]* } x! | D] } | t | | � O} qWqW| St | t � r�t | t t f � r�t j d � t } x! | D] } | t | | � O} quW| St | t
� r�t | t
� r�t j d | | � | | k St | t j t j f � r@t | t j t j f � r@t j d | | � t
j | | t
j � }
|
r<t St St | t j t f � r�t | t j t f � r�t j d | | � | | k St | t j t f � r't | t j t j f � r't j d | | � t j | � } | r#| j d � } t t | � t | j d
� � t | � � St St S( uS
Compares two objects and return a boolean value
when there's a match.
u Comparing dict to dictu *u Comparing list to listu" Comparing dict to list (of dicts?)u Comparing booleans: %s ? %su' Comparing strings (and regex?): %s ? %su! Comparing numeric values: %d ? %du1 Comparing a numeric value (%d) with a string (%s)i i ( t
isinstancet dictt logt debugR t iteritemst Falset _comparet listt tuplet boolt string_typest text_typet ret matcht It Truet
integer_typest floatt _numeric_regext groupt getattrt _numeric_operand(
t cur_cmpt
cur_structt cmp_keyt cmp_valuet foundt _t cur_struct_valt cur_elet cur_cmp_elet cur_struct_elet matchedt numeric_comparet
compare_value( ( s> /usr/lib/python2.7/site-packages/salt/beacons/napalm_beacon.pyR � s~
*
$
,c C@ s� t | t � s t d f Sxo | D]g } | j � d } | j � d } t | t � sh t d j | � f S| t k r t d j | � f Sq Wt d f S( u,
Validate the beacon configuration.
u/ Configuration for napalm beacon must be a list.i uM The match structure for the {} execution function output must be a dictionaryu& Execution function {} is not availabe!u) Valid configuration for the napal beacon!( R R R t keyst valuesR t formatt __salt__R ( t configt modt funt fun_cfg( ( s> /usr/lib/python2.7/site-packages/salt/beacons/napalm_beacon.pyt validate s
c C@ sO t j d � t j | � g } x| D]} | s9 q' n i } | j � d } | j � d } | j d g � } | j d i � } t j d j d | d | d | � � t | | | � } t j d � t j | � | j d
t � st j d j | � � t j | � q' n | d } t j d
� t j | � y t
| | � }
Wn) t k
rr} t j | d t �q' n Xt j d j d |
� � |
r' t j
d j d | d | � � d j d t d d | � | d <| | d <| | d <| | d <| | d <| | d <t j d � t j | � | j | � q' q' Wt j d � t j | � | S( u0
Watch napalm function and fire events.
u$ Executing napalm beacon with config:i u _argsu _kwargsu( Executing {fun} with {args} and {kwargs}R4 t argst kwargsu Got the reply from the minion:u resultu Error whilst executing {}u outu
Comparing to:t exc_infou Result of comparison: {res}t resu Matched {fun} with {cfg}t cfgu
{os}/{fun}t osu osu tagu funu argsu kwargsu datau matchu Queueing event:u# NAPALM beacon generated the events:( R
R R. R/ t popR0 R1 t getR t errorR t ExceptionR t infot
__grains__t append( R2 t retR3 t eventR4 R5 R7 R8 t fun_rett fun_ret_outt fun_cmp_resultt err( ( s> /usr/lib/python2.7/site-packages/salt/beacons/napalm_beacon.pyt beacon* s^
( t __doc__t
__future__R R R t loggingt salt.extR t salt.utils.napalmR t getLoggert __name__R
t compileR R R R
R R6 RJ ( ( ( s> /usr/lib/python2.7/site-packages/salt/beacons/napalm_beacon.pyt <module>� s&
N
Mini Shell