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()