def __dbm__(self):
# init the events map
event_map = {type(self._dbm_ready): [lambda t, x: x.set()]}
event_queue = self._event_queue
def default_handler(target, event):
if isinstance(event, Exception):
raise event
logging.warning('unsupported event ignored: %s' % type(event))
self.__initdb__()
self.db = dbschema.init(self._db, id(threading.current_thread()))
for (event, handler) in self.db.event_map.items():
if event not in event_map:
event_map[event] = []
event_map[event].append(handler)
while True:
target, events = event_queue.get()
for event in events:
handlers = event_map.get(event.__class__, [
default_handler,
])
for handler in handlers:
try:
handler(target, event)
except ShutdownException:
return
except:
import traceback
traceback.print_exc()
def __dbm__(self):
def default_handler(target, event):
if isinstance(event, Exception):
raise event
logging.warning('unsupported event ignored: %s' % type(event))
def check_sources_started(target, event):
if all([x.started.is_set() for x in self.sources.values()]):
self._event_queue.put(('localhost', (self._dbm_ready, )))
# init the events map
event_map = {type(self._dbm_ready): [lambda t, x: x.set()],
SchemaFlush: [lambda t, x: self.schema.flush(t)],
MarkFailed: [lambda t, x: self.schema.mark(t, 1)],
SyncStart: [check_sources_started]}
self._event_map = event_map
event_queue = self._event_queue
self.__initdb__()
self.schema = dbschema.init(self._db,
self._db_provider,
self._db_rtnl_log,
id(threading.current_thread()))
for target, source in self._nl.items():
try:
self.connect_source(target, source, SyncStart())
except Exception as e:
log.error('could not connect source %s: %s' % (target, e))
for (event, handlers) in self.schema.event_map.items():
for handler in handlers:
self.register_handler(event, handler)
while True:
target, events = event_queue.get()
for event in events:
handlers = event_map.get(event.__class__, [default_handler, ])
for handler in tuple(handlers):
try:
handler(target, event)
except InvalidateHandlerException:
try:
handlers.remove(handler)
except:
log.error('could not invalidate event handler:\n%s'
% traceback.format_exc())
except ShutdownException:
for target, source in self.sources.items():
source.shutdown.set()
return
except:
log.error('could not load event:\n%s\n%s'
% (event, traceback.format_exc()))
if time.time() - self.gctime > config.gc_timeout:
self.gctime = time.time()
for wr in tuple(self._rtnl_objects):
if wr() is None:
self._rtnl_objects.remove(wr)
def __dbm__(self):
# init the events map
self._event_map = event_map = {
type(self._dbm_ready): [lambda t, x: x.set()]
}
event_queue = self._event_queue
def default_handler(target, event):
if isinstance(event, Exception):
raise event
logging.warning('unsupported event ignored: %s' % type(event))
self.__initdb__()
self.schema = dbschema.init(self._db, self._db_provider,
self._db_rtnl_log,
id(threading.current_thread()))
for target, channel in self._nl.items():
self.connect_source(target, channel, None)
event_queue.put(('localhost', (self._dbm_ready, )))
for (event, handlers) in self.schema.event_map.items():
for handler in handlers:
self.register_handler(event, handler)
while True:
target, events = event_queue.get()
for event in events:
handlers = event_map.get(event.__class__, [
default_handler,
])
for handler in tuple(handlers):
try:
handler(target, event)
except InvalidateHandlerException:
try:
handlers.remove(handler)
except:
log.error(
'could not invalidate event handler:\n%s' %
traceback.format_exc())
except ShutdownException:
return
except:
log.error('could not load event:\n%s\n%s' %
(event, traceback.format_exc()))
if time.time() - self.gctime > config.gc_timeout:
self.gctime = time.time()
for wr in tuple(self._rtnl_objects):
if wr() is None:
self._rtnl_objects.remove(wr)
def __dbm__(self):
# init the events map
self._event_map = event_map = {
type(self._dbm_ready): [lambda t, x: x.set()]
}
event_queue = self._event_queue
def default_handler(target, event):
if isinstance(event, Exception):
raise event
logging.warning('unsupported event ignored: %s' % type(event))
self.__initdb__()
self.db = dbschema.init(self._db, id(threading.current_thread()))
for (event, handler) in self.db.event_map.items():
self.register_handler(event, handler)
while True:
target, events = event_queue.get()
for event in events:
handlers = event_map.get(event.__class__, [
default_handler,
])
for handler in tuple(handlers):
try:
handler(target, event)
except InvalidateHandlerException:
try:
handlers.remove(handler)
except:
traceback.print_exc()
except ShutdownException:
return
except:
traceback.print_exc()
def __dbm__(self):
def default_handler(target, event):
if isinstance(event, Exception):
raise event
log.warning('unsupported event ignored: %s' % type(event))
def check_sources_started(self, _locals, target, event):
_locals['countdown'] -= 1
if _locals['countdown'] == 0:
self._dbm_ready.set()
_locals = {'countdown': len(self._nl)}
# init the events map
event_map = {
type(self._dbm_ready): [lambda t, x: x.set()],
MarkFailed: [lambda t, x: (self.schema.mark(t, 1))],
SyncStart: [partial(check_sources_started, self, _locals)]
}
self._event_map = event_map
event_queue = self._event_queue
self.__initdb__()
self.schema = dbschema.init(self, self._db, self._db_provider,
self._db_rtnl_log,
id(threading.current_thread()))
for spec in self._nl:
spec['event'] = None
self.sources.add(**spec)
for (event, handlers) in self.schema.event_map.items():
for handler in handlers:
self.register_handler(event, handler)
while True:
target, events = event_queue.get()
try:
# if nlm_generator is True, an exception can come
# here while iterating events
for event in events:
handlers = event_map.get(event.__class__, [
default_handler,
])
for handler in tuple(handlers):
try:
handler(target, event)
except InvalidateHandlerException:
try:
handlers.remove(handler)
except:
log.error('could not invalidate '
'event handler:\n%s' %
traceback.format_exc())
except ShutdownException:
for target, source in self.sources.cache.items():
source.shutdown.set()
except DBMExitException:
return
except:
log.error('could not load event:\n%s\n%s' %
(event, traceback.format_exc()))
if time.time() - self.gctime > config.gc_timeout:
self.gctime = time.time()
except:
log.error('exception in source %s' % target)
# restart the target
self.sources[target].restart()
def __dbm__(self):
def default_handler(target, event):
if isinstance(event, Exception):
raise event
logging.warning('unsupported event ignored: %s' % type(event))
def check_sources_started(target, event):
if all([x.started.is_set() for x in self.sources.values()]):
self._event_queue.put(('localhost', (self._dbm_ready, )))
# init the events map
event_map = {
type(self._dbm_ready): [lambda t, x: x.set()],
SchemaFlush: [lambda t, x: self.schema.flush(t)],
MarkFailed: [lambda t, x: self.schema.mark(t, 1)],
SyncStart: [check_sources_started]
}
self._event_map = event_map
event_queue = self._event_queue
self.__initdb__()
self.schema = dbschema.init(self._db, self._db_provider,
self._db_rtnl_log,
id(threading.current_thread()))
for target, source in self._nl.items():
try:
self.connect_source(target, source, SyncStart())
except Exception as e:
log.error('could not connect source %s: %s' % (target, e))
for (event, handlers) in self.schema.event_map.items():
for handler in handlers:
self.register_handler(event, handler)
while True:
target, events = event_queue.get()
for event in events:
handlers = event_map.get(event.__class__, [
default_handler,
])
for handler in tuple(handlers):
try:
handler(target, event)
except InvalidateHandlerException:
try:
handlers.remove(handler)
except:
log.error(
'could not invalidate event handler:\n%s' %
traceback.format_exc())
except ShutdownException:
for target, source in self.sources.items():
source.shutdown.set()
except DBMExitException:
return
except:
log.error('could not load event:\n%s\n%s' %
(event, traceback.format_exc()))
if time.time() - self.gctime > config.gc_timeout:
self.gctime = time.time()
for wr in tuple(self._rtnl_objects):
if wr() is None:
self._rtnl_objects.remove(wr)
def __dbm__(self):
##
# Database management thread
##
event_map = {type(self._dbm_ready): [lambda t, x: x.set()]}
self._event_queue = event_queue = queue.Queue()
#
# ACHTUNG!
# check_same_thread=False
#
# Do NOT write into the DB from ANY other thread!
#
self.db = sqlite3.connect(self._db_uri, check_same_thread=False)
def default_handler(target, event):
if isinstance(event, Exception):
raise event
logging.warning('unsupported event ignored: %s' % type(event))
self.dbschema = dbschema.init(self.db, id(threading.current_thread()))
for (event, handler) in self.dbschema.event_map.items():
if event not in event_map:
event_map[event] = []
event_map[event].append(handler)
# initial load
for (target, channel) in tuple(self.nl.items()):
event_queue.put((target, channel.get_links()))
event_queue.put((target, channel.get_neighbours()))
event_queue.put((target, channel.get_routes(family=AF_INET)))
event_queue.put((target, channel.get_routes(family=AF_INET6)))
event_queue.put((target, channel.get_routes(family=AF_MPLS)))
event_queue.put((target, channel.get_addr()))
event_queue.put((
'localhost',
(self._dbm_ready, ),
))
#
for (target, channel) in tuple(self.nl.items()):
def t(event_queue, target, channel):
while True:
event_queue.put((target, channel.get()))
th = threading.Thread(target=t,
args=(event_queue, target, channel),
name='NDB event source: %s' % (target))
th.setDaemon(True)
th.start()
while True:
target, events = event_queue.get()
for event in events:
handlers = event_map.get(event.__class__, [
default_handler,
])
for handler in handlers:
try:
handler(target, event)
except ShutdownException:
return
except:
import traceback
traceback.print_exc()