196 lines
6.3 KiB
Python
196 lines
6.3 KiB
Python
#!/bin/bash /usr/scripts/python.sh
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# Trigger library, designed to send events messages.
|
|
#
|
|
# Author : Pierre-Elliott Bécue <becue@crans.org>
|
|
# License : GPLv3
|
|
# Date : 18/05/2014
|
|
|
|
"""
|
|
This service (event) is designed to receive any modification done on LDAP
|
|
database, and to make a correct diff between former and later object in order
|
|
to guess which services has to be updated.
|
|
"""
|
|
|
|
import cmb
|
|
import cPickle
|
|
import pika
|
|
import importlib
|
|
import itertools
|
|
import traceback
|
|
|
|
# Trigger features
|
|
import gestion.config.trigger as trigger_config
|
|
from gestion.trigger.host import record, TriggerFactory
|
|
from gestion.trigger.services.service import BasicService
|
|
|
|
# Clogger
|
|
import cranslib.clogger as clogger
|
|
|
|
# lc_ldap
|
|
import lc_ldap.attributs
|
|
|
|
logger = clogger.CLogger("trigger", "event", "debug", trigger_config.debug)
|
|
|
|
services = []
|
|
for config_service in trigger_config.all_services:
|
|
try:
|
|
services.append(importlib.import_module("gestion.trigger.services.%s" % (config_service,)))
|
|
except Exception as e:
|
|
logger.critical("Fatal : import of %r failed, see following traceback. %r", config_service, traceback.format_exc())
|
|
|
|
class EventProducer(cmb.BasicProducer):
|
|
"""
|
|
EventProducer tracker
|
|
"""
|
|
def __init__(self, app_id):
|
|
"""Extended
|
|
|
|
"""
|
|
logger.info("Starting trigger EventProducer program…")
|
|
super(EventProducer, self).__init__(trigger_config.master, 'trigger', app_id)
|
|
self._connection = self.connect()
|
|
self.get_chan()
|
|
|
|
def send_message(self, routing_key, body):
|
|
"""Sends basic message with app_id and body
|
|
|
|
"""
|
|
try:
|
|
logger.info("Sending message %s with routing_key %s.", body, routing_key)
|
|
body = cPickle.dumps(body)
|
|
self._channel.basic_publish(exchange=self._exchange_name,
|
|
routing_key=routing_key,
|
|
body=body,
|
|
properties=pika.BasicProperties(
|
|
delivery_mode=2,
|
|
app_id=self._app_id,
|
|
))
|
|
except:
|
|
print "Failure in trigger.event"
|
|
raise
|
|
|
|
def announce(self, body):
|
|
"""Feature to send message without giving routing_key
|
|
|
|
"""
|
|
self.send_message("trigger.event", body)
|
|
|
|
def diff_o_matic(body=()):
|
|
"""Fait un diff exhaustif des deux dicos"""
|
|
|
|
if not body:
|
|
raise ValueError("diff_o_matic received %r as an argument, which is unusable." % (body,))
|
|
|
|
before = dict(body[1]) or {}
|
|
after = dict(body[2]) or {}
|
|
|
|
# set(dico) retourne un set de dico.keys()
|
|
keys_pool = set(before).union(set(after))
|
|
diff = {}
|
|
|
|
for key in keys_pool:
|
|
if before.has_key(key):
|
|
if not isinstance(before[key], list):
|
|
blist = [before[key]]
|
|
else:
|
|
blist = list(before[key])
|
|
else:
|
|
blist = []
|
|
if after.has_key(key):
|
|
if not isinstance(after[key], list):
|
|
alist = [after[key]]
|
|
else:
|
|
alist = list(after[key])
|
|
else:
|
|
alist = []
|
|
moins, plus = compare_lists(blist, alist)
|
|
if moins != [] or plus != []:
|
|
diff[key] = (moins, plus)
|
|
|
|
return diff
|
|
|
|
def compare_lists(list1, list2):
|
|
"""Compare deux listes, retourne deux listes, une
|
|
avec les données perdues, et une avec les données
|
|
apparues
|
|
|
|
Insensible à la casse.
|
|
|
|
"""
|
|
moins, plus = [], []
|
|
|
|
for elem in [] + list1:
|
|
try:
|
|
ind = list2.index(elem.lower())
|
|
except ValueError:
|
|
moins.append(elem)
|
|
continue
|
|
list1.remove(elem)
|
|
list2.pop(ind)
|
|
plus = plus + list2
|
|
|
|
return moins, plus
|
|
|
|
class Event(BasicService):
|
|
"""Event service class. It extends BasicService, but should not implement
|
|
any change trigger, since it's this service which is designed to call
|
|
change triggers of other services.
|
|
|
|
"""
|
|
|
|
@classmethod
|
|
def get_changes(cls, body, diff):
|
|
"""Compute changes from diff"""
|
|
|
|
return [None]
|
|
|
|
@classmethod
|
|
def regen(cls, body=()):
|
|
"""When any event arrives on trigger-civet-event, this method is called
|
|
and designed to transcript the body (ldap data) in something usable for
|
|
the services. Afterwards, it sends these transcripts on the good way
|
|
using routing_key.
|
|
|
|
body is a 3-tuple, containing LDAP dn, the former state of the object
|
|
(a simple dict), and the later state. The data are non-binding-dependant.
|
|
|
|
A new object has body[1] to None, a deleted one has body[2] to None.
|
|
|
|
"""
|
|
|
|
logger.info("Received message %r…", body)
|
|
|
|
diff = diff_o_matic(body)
|
|
|
|
# Now, diff is a dict containing attributes which has been modified.
|
|
# diff['macAddress'] could look like (['aa:bb:cc:dd:ee:fg'], ['aa:bb:cc:dd:ee:ff']),
|
|
# where the list on the left is the former value of attributes, and the list on the
|
|
# right the latter values.
|
|
|
|
# -*- Explain -*-
|
|
#In [11]: import itertools
|
|
#
|
|
#In [12]: a = [[(3, 'lol'), ('7', 3)], [(5, 6), None], [None], [('lol', 'lal')]]
|
|
#
|
|
#In [13]: a
|
|
#Out[13]: [[(3, 'lol'), ('7', 3)], [(5, 6), None], [None], [('lol', 'lal')]]
|
|
#
|
|
#In [14]: list(set([message for message in itertools.chain(*a)]))
|
|
#Out[14]: [('7', 3), (5, 6), None, ('lol', 'lal'), (3, 'lol')] # Only one None from a, since [None, x, y, None] is equivalent for itertools to [x, y]
|
|
#
|
|
#In [15]: b = list(set([message for message in itertools.chain(*a) if message is not None]))
|
|
#
|
|
#In [16]: b
|
|
#Out[16]: [('7', 3), (5, 6), ('lol', 'lal'), (3, 'lol')]
|
|
msg_to_send = [message for message in itertools.chain(*[service.get_changes(body, diff) for service in TriggerFactory.get_services()]) if message is not None]
|
|
|
|
for msg in msg_to_send:
|
|
logger.info("Sending %r on the road \\o/", msg)
|
|
# XXX - uncomment this when in production
|
|
# trigger_send(*msg)
|
|
|
|
def trigger_send(routing_key, body):
|
|
sender = EventProducer("civet")
|
|
sender.send_message("trigger.%s" % (routing_key,), body)
|