def run(self): self._run = True logmod.set_current_application(self) log.info('Starting eventful application') for s in self._services: s.bind_and_listen() event.event(eventbase.event_read_bound_socket, handle=s.sock, evtype=event.EV_READ | event.EV_PERSIST, arg=s).add() self.setup_wake_pipe() def checkpoint(): if not self._run: raise SystemExit timers.call_every(1.0, checkpoint) self.setup() while self._run: try: event.dispatch() except SystemExit: log.warn("-- SystemExit raised.. exiting main loop --") break except KeyboardInterrupt: log.warn("-- KeyboardInterrupt raised.. exiting main loop --") break except Exception, e: log.error("-- Unhandled Exception in main loop --") log.error(traceback.format_exc())
def test_abort(self): print 'test_abort' def __time_cb(): raise NotImplementedError, 'abort failed!' event.timeout(5, __time_cb) event.timeout(1, event.abort) event.dispatch()
def main(): if len(sys.argv) > 1: url = sys.argv[1] else: url = 'http://localhost:8888/msgbus/chatdemo' scheme, netloc, path, query, fragment = urlparse.urlsplit(url) if not path.startswith('/msgbus/'): raise ValueError, 'invalid msgbus URL: %s' % url channel = path[8:] username, password, hostname, port = parse_netloc(scheme, netloc) # XXX - stdin b0rkage! os.putenv('EVENT_NOKQUEUE', '1') os.putenv('EVENT_NOPOLL', '1') event.init() event.read(0, recv_stdin, channel) evmsg.open(hostname, port, scheme == 'https') if username and password: evmsg.set_auth(username, password) sub = evmsg.subscribe(channel, '*', '*', recv_chat) event.signal(2, event.abort) print 'pub/sub to', url event.dispatch()
def main(self, argv=sys.argv[1:], subclasses=None): """Run any Handler subclass in __main__ scope. """ # XXX - even with only select enabled, BPF immediate doesn't # work on OSX, and we only get read events on full buffers. if sys.platform in ('darwin', 'win32'): os.putenv('EVENT_NOKQUEUE', '1') os.putenv('EVENT_NOPOLL', '1') if not subclasses: subclasses = find_subclasses(Handler, __import__('__main__')) if not subclasses: raise RuntimeError, 'no Handler subclasses found' event.init() self.setup() self.getopt(argv) # XXX - configure pcap filter global config config['pcap']['prefilter'] = ' '.join(self.args) for cls in subclasses: handlers[cls.name] = cls() for sig in (signal.SIGINT, signal.SIGTERM): event.signal(sig, event.abort) event.dispatch() for h in handlers.itervalues(): h.teardown() self.teardown()
def unload_all(): '''Unload all loaded modules.''' for i in var.modules_loaded: unload(i) event.dispatch('OnModuleUnloadAll')
def run(): '''Execute all timers that need to be executed.''' global timer_min for timer in var.timers: if timer['when'] <= time.time(): timer['func'](timer['args']) timer_min = -1 event.dispatch('OnTimerCallFunction', timer['func'], timer['args']) # If it's scheduled more than once updated its `when`. if timer['freq']: timer['when'] = (time.time() + timer['freq']) if timer['when'] < timer_min or timer_min == -1: timer_min = timer['when'] # Otherwise mark it as inactive. else: timer['active'] = False # Delete any timers that aren't useful anymore. var.timers = [timer for timer in var.timers if timer['active']]
def test_timeout2(self): def __timeout2_cb(start, secs): dur = int(time.time() - start) assert dur == secs, 'timeout2 failed' print 'test_timeout2' event.timeout(5, __timeout2_cb, time.time(), 5) event.dispatch()
def run(self): global GLOBAL_TERMINATE if 'event' in globals(): event.signal(2,self._lib_out).add() if select_enabled: while GLOBAL_TERMINATE == False: self.select_handle() elif 'event' in globals(): event.dispatch()
def main(local_ip, mca): my_sock = UdpSocket((local_ip, 0)) my_sock.receive_buffer_size = 8000 my_sock.send_buffer_size = 100000 mc_sock = UdpSocket((mca, 8000)) mc_sock.join_mcast_group(mca) mc_sock.receive_buffer_size = 8000 mc_sock.send_buffer_size = 100000 receiver = Receiver() handler = RmcProtocolHandler(my_sock, mc_sock) handler.MAX_BACKLOG = 1000 handler.MAX_BURST = 10 ## handler.add_action('__received_packet__', receiver.on_incomming_packet) ## handler.add_action('__sent_packet__', receiver.on_outgoing_packet) handler.add_action('missing_heartbeat', receiver.on_missing_sender) handler.add_action('new_sender', receiver.on_new_sender) handler.add_action('new_packet', receiver.on_new_packet) handler.add_action('got_heartbeat', receiver.on_heartbeat) handler.add_action('got_reset', receiver.on_reset) handler.add_action('got_lost', receiver.on_lost) handler.add_action('got_nack', receiver.on_nack) handler.add_action('sent_heartbeat', receiver.sent_heartbeat) handler.add_action('sent_lost', receiver.sent_lost) handler.add_action('sent_nack', receiver.sent_nack) print 'RECEIVER STARTED', repr(handler.local_addr) try: event.dispatch() except KeyboardInterrupt: pass handler.finish() now = time.time() print '%.6f: DONE' % now return
def connect_to_all(): '''Connect to all servers in the configuration.''' for i in var.conf.get('network'): serv = { 'id': i.get('id'), 'address': i.get('address'), 'port': int(i.get('port')), 'nick': i.get('nick'), 'ident': i.get('ident'), 'gecos': i.get('gecos'), 'vhost': i.get('vhost'), 'chans': [], 'connected': False, 'pass': i.get('pass'), 'recontime': 0, 'trigger': i.get('trigger') } serv['chans'].append(i.get('chans')) if i.get('recontime'): serv['recontime'] = int(i.get('recontime')) var.servers.append(serv) event.dispatch('OnNewServer', serv) try: connect(serv) except socket.error, e: logger.error('%s: Unable to connect - (%s)' % (serv['id'], serv['address'], serv['port'], os.strerror(e.args[0])))
def run(self): ''' Engine.run() - launch pygame and run the mainloop ''' pygame.init() if self.fullscreen: pygame.display.set_mode(self.size,pygame.FULLSCREEN) else: pygame.display.set_mode(self.size) self.state = self.DEFAULT() self.state.start() #mainloop while 1: event.handlePygame() #for event in pygame.event.get(): # eventnet.driver.post(pygame.event.event_name(event.type), # **event.dict) if self.state.done and self.state.next: self.state = self.state.next self.state.start() elif self.state.done and not self.state.next: self.state = self.DEFAULT() self.state.start() else: self.clock.tick(self.fps) event.dispatch('Tick')
def delete_first(eventname, func, cmd_type): '''Remove a function as an event's first function.''' eventname = eventname.upper() cmd_type[eventname]['first'] = None logger.debug('Deleted command %s assigned to %s (high-priority)' % (eventname, func)) event.dispatch('OnCommandDeleteFirst', eventname, func, cmd_type)
def rehash(self, on_sighup): '''Rehash configuration and change synarere to fit the new conditions.''' logger.info('Rehashing configuration %s' % ('due to SIGHUP.' if on_sighup else '')) self.parse() event.dispatch('OnRehash', self.file, on_sighup)
def delete(func, args=None): '''Delete all timers with matching `func` and `args`.''' var.timers = [ timer for timer in var.timers if timer['func'] != func and timer['args'] != args ] event.dispatch('OnTimerDelete', func, args)
def unload_all(): '''Unload all loaded modules.''' logger.info('Unloading all modules.') for i in var.modules_loaded: unload(i) event.dispatch('OnUnloadAllModules')
def report(self): '''Report new data.''' while len(self.recvq): line = self.recvq.popleft() protocol.parse_data(self, line) event.dispatch('OnRawSocketRead', self, line) logger.debug('%s -> %s' % (self.server['address'], line))
def test_timeout(self): def __timeout_cb(ev, handle, evtype, ts): now = time.time() assert int(now - ts['start']) == ts['secs'], 'timeout failed' print 'test_timeout' ts = { 'start':time.time(), 'secs':5 } ev = event.event(__timeout_cb, arg=ts) ev.add(ts['secs']) event.dispatch()
def test_exception(self): print 'test_exception' def __bad_cb(foo): raise NotImplementedError, foo event.timeout(0, __bad_cb, 'bad callback') try: event.dispatch() except NotImplementedError: pass
def test_read2(self): def __read2_cb(fd, msg): assert os.read(fd, 1024) == msg, 'read2 event failed' print 'test_read2' msg = 'hello world' pipe = os.pipe() event.read(pipe[0], __read2_cb, pipe[0], msg) os.write(pipe[1], msg) event.dispatch()
def test_timeout(self): def __timeout_cb(ev, handle, evtype, ts): now = time.time() assert int(now - ts['start']) == ts['secs'], 'timeout failed' print 'test_timeout' ts = {'start': time.time(), 'secs': 5} ev = event.event(__timeout_cb, arg=ts) ev.add(ts['secs']) event.dispatch()
def test_read(self): def __read_cb(ev, fd, evtype, pipe): buf = os.read(fd, 1024) assert buf == 'hi niels', 'read event failed' print 'test_read' pipe = os.pipe() event.event(__read_cb, handle=pipe[0], evtype=event.EV_READ).add() os.write(pipe[1], 'hi niels') event.dispatch()
def load_all(): '''Load all modules listed in the configuration.''' for i in var.conf.get('module'): name = i.get('name') if name != None: load(name) event.dispatch('OnLoadAllModules', name)
def part(self, channel, reason=None): '''Part 'channel' with 'reason' if present.''' if not reason: event.dispatch('OnPartChannel', self.server, channel) self.sendq.appendleft('PART %s' % channel) return event.dispatch('OnPartChannelWithReason', self.server, channel, reason) self.sendq.appendleft('PART %s :%s' % (channel, reason)) return
def test_signal(self): def __signal_cb(ev, sig, evtype, arg): if evtype == event.EV_SIGNAL: ev.delete() elif evtype == event.EV_TIMEOUT: os.kill(os.getpid(), signal.SIGUSR1) print 'test_signal' event.event(__signal_cb, handle=signal.SIGUSR1, evtype=event.EV_SIGNAL).add() event.event(__signal_cb).add(2) event.dispatch()
def quit(self, reason=None): '''QUIT the server with 'reason'. This offers no reconnection.''' if not reason: self.sendq.appendleft('QUIT') event.dispatch('OnQuit', self.server) return self.sendq.appendleft('QUIT :%s' % reason) event.dispatch('OnQuitWithReason', self.server, reason) return
def join(self, channel, key=None): '''Join 'channel' with 'key' if present.''' if not key: event.dispatch('OnJoinChannel', self.server, channel) self.sendq.appendleft('JOIN %s' % channel) return self.sendq.appendleft('JOIN %s :%s' % (channel, key)) event.dispatch('OnJoinChannelWithKey', self.server, channel, key) return
def unload(module): '''Unload a module.''' if module not in var.modules_loaded: logger.warning('attempted to unload module %s, but that is not in the loaded modules list' % module) return module.module_fini() # Remove the module from the loaded modules list. var.modules_loaded.remove(module) event.dispatch('OnModuleUnload', module)
def test_thread(self): print 'test_thread' def __time_cb(d): assert d['count'] == 3 def __time_thread(count, d): for i in range(count): time.sleep(1) d['count'] += 1 d = { 'count': 0 } thread.start_new_thread(__time_thread, (3, d)) event.timeout(4, __time_cb, d) event.dispatch()
def load_all_from_conf(): '''Load all modules listed in configuration.''' try: for i in var.conf.get('module'): name = i.get('name') if name: load(name) except: pass # Means they dont want modules loaded. event.dispatch('OnModuleLoadAllFromConf')
def unload(module): '''Unload a module.''' # Make sure it is in the modules loaded list. if module not in var.modules_loaded: logger.warning('%s is not in the loaded modules list.' % module) return module.module_fini() # Remove the module from the loaded modules list. var.modules_loaded.remove(module) event.dispatch('OnModuleUnload', module)
def delete(eventname, func, cmd_type): '''Remove a function from an event's list of functions.''' eventname = eventname.upper() if func not in cmd_type[eventname]['funcs']: return False cmd_type[eventname]['funcs'].remove(func) return True logger.debug('Deleted command %s assigned to %s (low-priority)' % (eventname, func)) event.dispatch('OnCommandDelete', eventname, func, cmd_type)
def handle_connect(self): '''Log into the IRC server.''' logger.info('%s: Connection established.' % (self.server['id'])) self.server['connected'] = True event.dispatch('OnConnect', self.server) if self.server['pass']: self.sendq.appendleft('PASS %s' % self.server['pass']) self.sendq.appendleft('NICK %s' % self.server['nick']) self.sendq.appendleft('USER %s 2 3 :%s' % (self.server['ident'], self.server['gecos']))
def main(): global CONN # setup the connection myconn = beanstalk.serverconn.LibeventConn(SERVER, PORT) #setup callbacks myconn.result_callback_args = (myconn,) myconn.result_callback = got_response myconn.error_callback = got_error #setup the callchain start(myconn) CONN = myconn print 'dispatching' event.dispatch()
def main(): op = optparse.OptionParser(usage='%prog [OPTIONS] [URL|channel]') op.add_option('-q', dest='quiet', help='enable quiet output', action='store_true') op.add_option('-s', dest='sender', default='*', help='subscribe to messages from this sender') op.add_option('-t', dest='type', default='*', help='subscribe to messages of this type') opts, args = op.parse_args(sys.argv[1:]) if not args: url = 'http://localhost:8888/msgbus/' channel = '' elif args[0].startswith('http'): url = args[0] channel = url.split('/')[-1] else: url = 'http://localhost:8888/msgbus/%s' % args[0] channel = args[0] scheme, netloc, path, query, fragment = urlparse.urlsplit(url) if not path.startswith('/msgbus/'): raise ValueError, 'invalid msgbus URL: %s' % url channel = path[8:] username, password, hostname, port = parse_netloc(scheme, netloc) d = {'quiet': opts.quiet, 'cnt': 0} start = time.time() event.init() evmsg.open(hostname, port, scheme == 'https') if username and password: evmsg.set_auth(username, password) sub = evmsg.subscribe(channel, opts.type, opts.sender, recv_msg, d) event.signal(2, event.abort) print >> sys.stderr, 'subscribed to', url event.dispatch() secs = time.time() - start print >>sys.stderr, 'received %d msgs over %d secs (%.1f mps)' % \ (d['cnt'], secs, float(d['cnt']) / secs)
def main(local_ip, mca): my_sock = UdpSocket((local_ip, 0)) my_sock.send_buffer_size = 100000 mc_sock = UdpSocket(mca) mc_sock.join_mcast_group(mca[0]) mc_sock.receive_buffer_size = 10000 mc_sock.send_buffer_size = 100000 sender = Sender() handler = RmcProtocolHandler(my_sock, mc_sock) handler.MAX_BACKLOG = 5000 handler.MAX_BURST = 5 handler.no_sync = True ## handler.add_action('__received_packet__', sender.on_incomming_packet) ## handler.add_action('__sent_packet__', sender.on_outgoing_packet) handler.add_action('missing_heartbeat', sender.on_missing_sender) handler.add_action('new_sender', sender.on_new_sender) handler.add_action('new_packet', sender.on_new_packet) handler.add_action('got_heartbeat', sender.on_heartbeat) handler.add_action('got_nack', sender.on_nack) handler.add_action('got_reset', sender.on_reset) handler.add_action('got_lost', sender.on_lost) handler.add_action('sent_heartbeat', sender.sent_heartbeat) handler.add_action('sent_lost', sender.sent_lost) handler.add_action('sent_nack', sender.sent_nack) print 'SENDER STARTED', repr(handler.local_addr) # spool first batch of packets for n in range(3): p = packet.Packet() p.payload = 's: %d' % n handler.send(p) # delayed reset p = packet.Packet(seq=200) p.flags |= packet.RESET p.payload = '' event.timeout(2.0, send_p, [p], handler) # more packets, fast! pl = [ packet.Packet(payload=('%06d: ' % n + 'Z' * 80)) for n in xrange(50) ] event.timeout(3.0, send_p, pl, handler) # more packets, fast! pl = [ packet.Packet(payload=('%06d: ' % n + 'Z' * 80)) for n in xrange(50, 550) ] event.timeout(4.0, send_p, pl, handler) try: event.dispatch() except KeyboardInterrupt: pass handler.finish() now = time.time() print '%.6f: DONE' % now return
def run(self): while True: try: event.dispatch() break except api.GreenletExit: break except self.SYSTEM_EXCEPTIONS: raise except: if self.exc_info is not None: self.schedule_call_global(0, api.getcurrent().parent.throw, *self.exc_info) self.exc_info = None else: traceback.print_exc()
def test_ev_chat(): import event ep = udplib.UdpSocket(('', 9000)) chat = TestEventChat(ep) del ep chat.set_terminator(6) addr = ('127.0.0.1', 9000) count = 3 t = threading.Thread(target=_send_to, args=(addr, count)) t.start() chat.add_read() event.dispatch() t.join() chat.close() return
def test_thread(self): print 'test_thread' def __time_cb(d): assert d['count'] == 3 def __time_thread(count, d): for i in range(count): time.sleep(1) d['count'] += 1 d = {'count': 0} thread.start_new_thread(__time_thread, (3, d)) event.timeout(4, __time_cb, d) event.dispatch()
def handle_close(self): '''Handle connection closings.''' asyncore.dispatcher.close(self) logger.info('connection to %s lost' % self.server['id']) self.server['connected'] = False if self.server['recontime']: logger.info('reconnecting to %s in %d second%s' % (self.server['id'], self.server['recontime'], 's' if self.server['recontime'] != 1 else '')) timer.add('uplink.reconnect', True, reinit, self.server['recontime'], self.server) event.dispatch('OnReconnect', self.server) else: # Exit. shutdown(os.EX_SOFTWARE, 'no reconnection to %s, therefore we dont need to hang around' % self.server['id'])
def handle_write(self): '''Write the first line in the sendq to the socket.''' # Grab the first line from the sendq. line = self.sendq[-1] + '\r\n' # Try to send it. num_sent = self.send(line) # If it didn't all send we have to work this out. if num_sent == len(line): event.dispatch('OnRawSocketWrite', self, line) logger.debug('%s <- %s' % (self.server['address'], self.sendq.pop())) else: logger.warning('incomplete write to %s (%d byte%s written instead of %d)' % (self.server['id'], num_sent, 's' if num_sent != 1 else '', len(line))) self.sendq[-1] = self.sendq[-1][num_sent:]
def init(): '''Connect to the uplink.''' serv = { 'id' : None, 'address' : None, 'password' : None, 'vhost' : None, 'actual' : None, 'services_name' : None, 'services_desc' : None, 'port' : 0, 'recontime' : 0, 'connected' : False } try: serv['id'] = var.conf.get('uplink', 'id')[0] serv['address'] = var.conf.get('uplink', 'address')[0] serv['password'] = var.conf.get('uplink', 'password')[0] serv['vhost'] = var.conf.get('uplink', 'vhost')[0] serv['actual'] = var.conf.get('uplink', 'actual')[0] serv['port'] = int(var.conf.get('uplink', 'port')[0]) if var.conf.get('uplink', 'recontime')[0]: serv['recontime'] = int(var.conf.get('uplink', 'recontime')[0]) serv['services_name'] = var.conf.get('server', 'name')[0] serv['services_desc'] = var.conf.get('server', 'desc')[0] except (conf.BlockNotFound, conf.VariableNotFound): shutdown(os.EX_CONFIG, 'uplink directives missing') event.dispatch('OnUplinkRecognization', serv) logger.info('connecting to %s (%s:%d)' % (serv['id'], serv['address'], serv['port'])) var.conn = UplinkConnection(serv) event.dispatch('OnPreConnect', serv) # This step is low-level to permit IPv6. af, type, proto, canon, sa = socket.getaddrinfo(serv['address'], serv['port'], 0, 1)[0] var.conn.create_socket(af, type) # If there's a vhost, bind to it. if serv['vhost']: var.conn.bind((serv['vhost'], 0)) # Now connect to the uplink. var.conn.connect(sa)
def delete_user(channel, user): '''Remove a user from a channel.''' try: var.channels[channel] except KeyError: logger.debug('attempted to remove user %s from channel %s, but that channel does not exist' % (user['nick'], channel)) return event.dispatch('OnUserPart', channel, user) var.channels[name]['ucount'] -= 1 if var.channels[name]['ucount'] == 0: logger.debug('channel %s became empty after %s parted, removing' % (channel['name'], user['nick'])) delete_channel(channel) logger,debug('user %s from %s removed' % (user['nick'], channel['name']))
def main(argv): # initialize libevent event.init() # set the SIGINT handler event.signal(signal.SIGINT, _sigint) # create an incoming (listen) socket, and bind listen_sock = socket.socket() listen_sock.setblocking(0) listen_sock.bind(("localhost", listen_port)) # start listening, set event listen_sock.listen(20) event.event(listen_read, None, event.EV_READ | event.EV_PERSIST, listen_sock).add() # start event loop event.dispatch()
def main(): op = optparse.OptionParser(usage='%prog [OPTIONS] [URL|channel]') op.add_option('-q', dest='quiet', help='enable quiet output', action='store_true') op.add_option('-s', dest='sender', default='*', help='subscribe to messages from this sender') op.add_option('-t', dest='type', default='*', help='subscribe to messages of this type') opts, args = op.parse_args(sys.argv[1:]) if not args: url = 'http://localhost:8888/msgbus/' channel = '' elif args[0].startswith('http'): url = args[0] channel = url.split('/')[-1] else: url = 'http://localhost:8888/msgbus/%s' % args[0] channel = args[0] scheme, netloc, path, query, fragment = urlparse.urlsplit(url) if not path.startswith('/msgbus/'): raise ValueError, 'invalid msgbus URL: %s' % url channel = path[8:] username, password, hostname, port = parse_netloc(scheme, netloc) d = { 'quiet':opts.quiet, 'cnt':0 } start = time.time() event.init() evmsg.open(hostname, port, scheme == 'https') if username and password: evmsg.set_auth(username, password) sub = evmsg.subscribe(channel, opts.type, opts.sender, recv_msg, d) event.signal(2, event.abort) print >>sys.stderr, 'subscribed to', url event.dispatch() secs = time.time() - start print >>sys.stderr, 'received %d msgs over %d secs (%.1f mps)' % \ (d['cnt'], secs, float(d['cnt']) / secs)
def add(name, only_once, func, freq, args=None): '''Add a new timer to be executed every `freq` seconds.''' global timer_min timer = new() timer['name'] = name timer['func'] = func timer['args'] = args timer['freq'] = freq if not only_once else 0 timer['when'] = (time.time() + freq) timer['active'] = True if timer['when'] < timer_min or timer_min == -1: timer_min = timer['when'] var.timers.append(timer) event.dispatch('OnAddTimer', timer)
def add(name, only_once, func, freq, args=None): '''Add a new timer to be executed every `freq` seconds.''' global timer_min timer = { 'name': name, 'func': func, 'args': args, 'freq': freq if not only_once else 0, 'when': (time.time() + freq), 'active': True } if timer['when'] < timer_min or timer_min == -1: timer_min = timer['when'] var.timers.append(timer) event.dispatch('OnAddTimer', timer)
def delete_channel(channel): '''Remove a channel, it's users, everything.''' try: var.channels[channel] except KeyError: logger.debug('attempted to delete non-existant channel %s' % channel) return event.dispatch('OnDeleteChannel', channel) var.channels[channel]['ts'] = 0 var.channels[channel]['ucount'] = 0 var.channels[channel]['users'] = [] var.channels[channel]['topic'] = None var.channels[channel]['topic_setter'] = None var.channels[channel]['metadata'] = [] logger.debug('deleted channel %s' % channel['name'])
def add_first(eventname, func, cmd_type): '''Add a function as an event's first function.''' eventname = eventname.upper() try: test = cmd_type[eventname] except KeyError: cmd_type[eventname] = { 'first' : None, 'funcs' : [], 'last' : None } if cmd_type[eventname]['first']: return False cmd_type[eventname]['first'] = func return True logger.debug('Created new command %s assigned to %s (high-priority)' % (eventname, func)) event.dispatch('OnCommandAddFirst', eventname, func, cmd_type)
def add(eventname, func, cmd_type): '''Add a function to an event's list of functions.''' eventname = eventname.upper() try: test = cmd_type[eventname] except KeyError: cmd_type[eventname] = { 'first' : None, 'funcs' : [], 'last' : None } if func in cmd_type[eventname]['funcs']: return True cmd_type[eventname]['funcs'].append(func) return True logger.debug('Created new command %s assigned to function %s (low-priority)' % (eventname, func)) event.dispatch('OnCommandAdd', eventname, func, cmd_type)
def run(self): event.dispatch()