def start(transport='zmq', address='0.0.0.0', port=49017):
'''
Listen to napalm-logs and publish events into the Salt event bus.
transport: ``zmq``
Choose the desired transport.
.. note::
Currently ``zmq`` is the only valid option.
address: ``0.0.0.0``
The address of the publisher.
port: ``49017``
The port of the publisher.
'''
transport_recv_fun = _get_transport_recv(name=transport,
address=address,
port=port)
if not transport_recv_fun:
log.critical('Unable to start the engine', exc_info=True)
return
master = False
if __opts__['__role'] == 'master':
master = True
while True:
raw_object = transport_recv_fun()
log.debug('Received from napalm-logs:')
log.debug(raw_object)
try:
dict_object = json.loads(raw_object)
except ValueError:
log.error(
'Unable to deserialise JSON object: {0}'.format(raw_object),
exc_info=True)
continue # and go the the next item
if not isinstance(dict_object, dict):
log.error('Invalid object read from napalm-logs:')
log.error(dict_object)
continue # ignore
tag = 'napalm/syslog/{os}/{error}/{device}'.format(
os=dict_object['os'],
error=dict_object['error'],
device=dict_object.get('host', dict_object.get('ip')))
log.debug('Sending event {0}'.format(tag))
log.debug(raw_object)
if master:
event.get_master_event(__opts__, __opts__['sock_dir']).fire_event(
dict_object, tag)
else:
__salt__['event.send'](tag, dict_object)
def send_event_to_salt(self, result):
'''
This function identifies whether the engine is running on the master
or the minion and sends the data to the master event bus accordingly.
:param result: It's a dictionary which has the final data and topic.
'''
if result['send']:
data = result['data']
topic = result['topic']
# If the engine is run on master, get the event bus and send the
# parsed event.
if __opts__['__role'] == 'master':
event.get_master_event(__opts__,
__opts__['sock_dir']).fire_event(
data, topic)
# If the engine is run on minion, use the fire_master execution
# module to send event on the master bus.
else:
__salt__['event.fire_master'](data=data, tag=topic)
def send_event_to_salt(self, result):
"""
This function identifies whether the engine is running on the master
or the minion and sends the data to the master event bus accordingly.
:param result: It's a dictionary which has the final data and topic.
"""
if result["send"]:
data = result["data"]
topic = result["topic"]
# If the engine is run on master, get the event bus and send the
# parsed event.
if __opts__["__role"] == "master":
event.get_master_event(__opts__,
__opts__["sock_dir"]).fire_event(
data, topic)
# If the engine is run on minion, use the fire_master execution
# module to send event on the master bus.
else:
__salt__["event.fire_master"](data=data, tag=topic)
def start(
transport="zmq",
address="0.0.0.0",
port=49017,
auth_address="0.0.0.0",
auth_port=49018,
disable_security=False,
certificate=None,
os_whitelist=None,
os_blacklist=None,
error_whitelist=None,
error_blacklist=None,
host_whitelist=None,
host_blacklist=None,
):
"""
Listen to napalm-logs and publish events into the Salt event bus.
transport: ``zmq``
Choose the desired transport.
.. note::
Currently ``zmq`` is the only valid option.
address: ``0.0.0.0``
The address of the publisher, as configured on napalm-logs.
port: ``49017``
The port of the publisher, as configured on napalm-logs.
auth_address: ``0.0.0.0``
The address used for authentication
when security is not disabled.
auth_port: ``49018``
Port used for authentication.
disable_security: ``False``
Trust unencrypted messages.
Strongly discouraged in production.
certificate: ``None``
Absolute path to the SSL certificate.
os_whitelist: ``None``
List of operating systems allowed. By default everything is allowed.
os_blacklist: ``None``
List of operating system to be ignored. Nothing ignored by default.
error_whitelist: ``None``
List of errors allowed.
error_blacklist: ``None``
List of errors ignored.
host_whitelist: ``None``
List of hosts or IPs to be allowed.
host_blacklist: ``None``
List of hosts of IPs to be ignored.
"""
if not disable_security:
if not certificate:
log.critical("Please use a certificate, or disable the security.")
return
auth = napalm_logs.utils.ClientAuth(
certificate, address=auth_address, port=auth_port
)
transport_recv_fun = _get_transport_recv(name=transport, address=address, port=port)
if not transport_recv_fun:
log.critical("Unable to start the engine", exc_info=True)
return
master = False
if __opts__["__role"] == "master":
master = True
while True:
log.debug("Waiting for napalm-logs to send anything...")
raw_object = transport_recv_fun()
log.debug("Received from napalm-logs:")
log.debug(raw_object)
if not disable_security:
dict_object = auth.decrypt(raw_object)
else:
dict_object = napalm_logs.utils.unserialize(raw_object)
try:
event_os = dict_object["os"]
if os_blacklist or os_whitelist:
valid_os = salt.utils.stringutils.check_whitelist_blacklist(
event_os, whitelist=os_whitelist, blacklist=os_blacklist
)
if not valid_os:
log.info("Ignoring NOS %s as per whitelist/blacklist", event_os)
continue
event_error = dict_object["error"]
if error_blacklist or error_whitelist:
valid_error = salt.utils.stringutils.check_whitelist_blacklist(
event_error, whitelist=error_whitelist, blacklist=error_blacklist
)
if not valid_error:
log.info(
"Ignoring error %s as per whitelist/blacklist", event_error
)
continue
event_host = dict_object.get("host") or dict_object.get("ip")
if host_blacklist or host_whitelist:
valid_host = salt.utils.stringutils.check_whitelist_blacklist(
event_host, whitelist=host_whitelist, blacklist=host_blacklist
)
if not valid_host:
log.info(
"Ignoring messages from %s as per whitelist/blacklist",
event_host,
)
continue
tag = "napalm/syslog/{os}/{error}/{host}".format(
os=event_os, error=event_error, host=event_host
)
except KeyError as kerr:
log.warning("Missing keys from the napalm-logs object:", exc_info=True)
log.warning(dict_object)
continue # jump to the next object in the queue
log.debug("Sending event %s", tag)
log.debug(raw_object)
if master:
event.get_master_event(__opts__, __opts__["sock_dir"]).fire_event(
dict_object, tag
)
else:
__salt__["event.send"](tag, dict_object)
def start(transport='zmq',
address='0.0.0.0',
port=49017,
auth_address='0.0.0.0',
auth_port=49018,
disable_security=False,
certificate=None,
os_whitelist=None,
os_blacklist=None,
error_whitelist=None,
error_blacklist=None,
host_whitelist=None,
host_blacklist=None):
'''
Listen to napalm-logs and publish events into the Salt event bus.
transport: ``zmq``
Choose the desired transport.
.. note::
Currently ``zmq`` is the only valid option.
address: ``0.0.0.0``
The address of the publisher, as configured on napalm-logs.
port: ``49017``
The port of the publisher, as configured on napalm-logs.
auth_address: ``0.0.0.0``
The address used for authentication
when security is not disabled.
auth_port: ``49018``
Port used for authentication.
disable_security: ``False``
Trust unencrypted messages.
Strongly discouraged in production.
certificate: ``None``
Absolute path to the SSL certificate.
os_whitelist: ``None``
List of operating systems allowed. By default everything is allowed.
os_blacklist: ``None``
List of operating system to be ignored. Nothing ignored by default.
error_whitelist: ``None``
List of errors allowed.
error_blacklist: ``None``
List of errors ignored.
host_whitelist: ``None``
List of hosts or IPs to be allowed.
host_blacklist: ``None``
List of hosts of IPs to be ignored.
'''
if not disable_security:
if not certificate:
log.critical('Please use a certificate, or disable the security.')
return
priv_key, verify_key = napalm_logs.utils.authenticate(
certificate, address=auth_address, port=auth_port)
transport_recv_fun = _get_transport_recv(name=transport,
address=address,
port=port)
if not transport_recv_fun:
log.critical('Unable to start the engine', exc_info=True)
return
master = False
if __opts__['__role'] == 'master':
master = True
while True:
log.debug('Waiting for napalm-logs to send anything...')
raw_object = transport_recv_fun()
log.debug('Received from napalm-logs:')
log.debug(raw_object)
if not disable_security:
dict_object = napalm_logs.utils.decrypt(raw_object, verify_key,
priv_key)
else:
dict_object = napalm_logs.utils.unserialize(raw_object)
try:
event_os = dict_object['os']
if os_blacklist or os_whitelist:
valid_os = salt.utils.check_whitelist_blacklist(
event_os, whitelist=os_whitelist, blacklist=os_blacklist)
if not valid_os:
log.info(
'Ignoring NOS {} as per whitelist/blacklist'.format(
event_os))
continue
event_error = dict_object['error']
if error_blacklist or error_whitelist:
valid_error = salt.utils.check_whitelist_blacklist(
event_error,
whitelist=error_whitelist,
blacklist=error_blacklist)
if not valid_error:
log.info(
'Ignoring error {} as per whitelist/blacklist'.format(
event_error))
continue
event_host = dict_object.get('host') or dict_object.get('ip')
if host_blacklist or host_whitelist:
valid_host = salt.utils.check_whitelist_blacklist(
event_host,
whitelist=host_whitelist,
blacklist=host_blacklist)
if not valid_host:
log.info(
'Ignoring messages from {} as per whitelist/blacklist'.
format(event_host))
continue
tag = 'napalm/syslog/{os}/{error}/{host}'.format(os=event_os,
error=event_error,
host=event_host)
except KeyError as kerr:
log.warning('Missing keys from the napalm-logs object:',
exc_info=True)
log.warning(dict_object)
continue # jump to the next object in the queue
log.debug('Sending event {0}'.format(tag))
log.debug(raw_object)
if master:
event.get_master_event(__opts__, __opts__['sock_dir']).fire_event(
dict_object, tag)
else:
__salt__['event.send'](tag, dict_object)
def start(transport='zmq',
address='0.0.0.0',
port=49017,
auth_address='0.0.0.0',
auth_port=49018,
disable_security=False,
certificate=None):
'''
Listen to napalm-logs and publish events into the Salt event bus.
transport: ``zmq``
Choose the desired transport.
.. note::
Currently ``zmq`` is the only valid option.
address: ``0.0.0.0``
The address of the publisher.
port: ``49017``
The port of the publisher.
auth_address: ``0.0.0.0``
The address used for authentication
when security is not disabled.
auth_port: ``49018``
Port used for authentication.
disable_security: ``False``
Trust unencrypted messages.
Strongly discouraged in production.
certificate
Absolute path to the SSL certificate.
'''
if not disable_security:
priv_key, verify_key = napalm_logs.utils.authenticate(certificate,
address=auth_address,
port=auth_port)
transport_recv_fun = _get_transport_recv(name=transport,
address=address,
port=port)
if not transport_recv_fun:
log.critical('Unable to start the engine', exc_info=True)
return
master = False
if __opts__['__role'] == 'master':
master = True
while True:
log.debug('Waiting for napalm-logs to send anything...')
raw_object = transport_recv_fun()
log.debug('Received from napalm-logs:')
log.debug(raw_object)
if not disable_security:
dict_object = napalm_logs.utils.decrypt(raw_object, verify_key, priv_key)
else:
dict_object = napalm_logs.utils.unserialize(raw_object)
try:
tag = 'napalm/syslog/{os}/{error}/{host}'.format(
os=dict_object['os'],
error=dict_object['error'],
host=(dict_object.get('host') or dict_object.get('ip'))
)
except KeyError as kerr:
log.warning('Missing keys from the napalm-logs object:', exc_info=True)
log.warning(dict_object)
log.debug('Sending event {0}'.format(tag))
log.debug(raw_object)
if master:
event.get_master_event(__opts__,
__opts__['sock_dir']
).fire_event(dict_object, tag)
else:
__salt__['event.send'](tag, dict_object)
