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