2011-01-07 09:54:51 -06:00
|
|
|
"""
|
|
|
|
DrBotIRC - customizations of irclib, for dr.botzo
|
|
|
|
Copyright (C) 2011 Brian S. Stephan
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
"""
|
|
|
|
|
2011-01-08 00:32:46 -06:00
|
|
|
import bisect
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
import copy
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
from ConfigParser import NoOptionError, NoSectionError
|
2012-07-15 21:32:12 -05:00
|
|
|
import logging
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
import re
|
|
|
|
import signal
|
2012-03-30 09:43:30 -05:00
|
|
|
from SimpleXMLRPCServer import SimpleXMLRPCServer
|
2011-01-07 09:54:51 -06:00
|
|
|
import socket
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
import sys
|
2012-03-30 09:43:30 -05:00
|
|
|
import thread
|
2012-07-14 09:16:59 -05:00
|
|
|
import traceback
|
2011-01-07 09:54:51 -06:00
|
|
|
|
|
|
|
from extlib import irclib
|
|
|
|
|
2012-03-30 09:43:30 -05:00
|
|
|
class DrBotzoMethods:
|
|
|
|
|
|
|
|
"""Methods to expose to the XML-RPC server."""
|
|
|
|
|
|
|
|
def __init__(self, irc):
|
|
|
|
"""Store the same stuff the core module would, since we'll probably need it."""
|
|
|
|
|
|
|
|
self.irc = irc
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log = logging.getLogger('dr.botzo')
|
2012-03-30 09:43:30 -05:00
|
|
|
|
|
|
|
def echo(self, message):
|
|
|
|
"""
|
|
|
|
Just reply to the client, for testing purposes.
|
2012-03-30 11:14:31 -05:00
|
|
|
|
|
|
|
Keyword arguments:
|
|
|
|
message - the message to echo
|
2012-03-30 09:43:30 -05:00
|
|
|
"""
|
|
|
|
|
|
|
|
return message
|
|
|
|
|
|
|
|
def say(self, target, message):
|
|
|
|
"""
|
|
|
|
Say a message in a channel/to a nick.
|
2012-03-30 11:14:31 -05:00
|
|
|
|
|
|
|
Keyword arguments:
|
|
|
|
target - the nick/channel to privmsg
|
|
|
|
message - the message to send
|
2012-03-30 09:43:30 -05:00
|
|
|
"""
|
|
|
|
|
|
|
|
self.irc.server.privmsg(target, message)
|
|
|
|
return "OK"
|
|
|
|
|
|
|
|
def execute_module_method(self, modname, method, args):
|
|
|
|
"""
|
|
|
|
Execute the method (with arguments) of the specified module.
|
2012-03-30 11:14:31 -05:00
|
|
|
|
|
|
|
Keyword arguments:
|
|
|
|
modname - the loaded module to retrieve
|
|
|
|
method - the method to call from that module
|
|
|
|
args - the arguments to provide to the method as a pythonic tuple
|
2012-03-30 09:43:30 -05:00
|
|
|
"""
|
|
|
|
|
|
|
|
for module in self.irc.modlist:
|
|
|
|
if modname == module.__class__.__name__:
|
|
|
|
try:
|
|
|
|
func = getattr(module, method)
|
|
|
|
except AttributeError:
|
|
|
|
return "couldn't find " + method + " in found module " + modname
|
|
|
|
|
|
|
|
if hasattr(func, '__call__'):
|
|
|
|
return func(*args)
|
|
|
|
else:
|
|
|
|
return method + " in found module " + modname + " is not callable"
|
|
|
|
|
|
|
|
return "couldn't find " + modname
|
|
|
|
|
2011-01-07 09:54:51 -06:00
|
|
|
class DrBotServerConnection(irclib.ServerConnection):
|
|
|
|
|
|
|
|
"""Subclass irclib's ServerConnection, in order to expand privmsg."""
|
|
|
|
|
2011-01-08 00:05:00 -06:00
|
|
|
nickmask = None
|
2011-01-07 23:56:51 -06:00
|
|
|
|
|
|
|
def __init__(self, irclibobj):
|
|
|
|
irclib.ServerConnection.__init__(self, irclibobj)
|
|
|
|
|
|
|
|
# temporary. hopefully on_welcome() will set this
|
2011-01-08 00:05:00 -06:00
|
|
|
self.nickmask = socket.getfqdn()
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log = logging.getLogger('dr.botzo')
|
2011-01-07 23:56:51 -06:00
|
|
|
|
|
|
|
self.add_global_handler('welcome', self.on_welcome, 1)
|
|
|
|
|
|
|
|
def on_welcome(self, connection, event):
|
2011-01-08 00:05:00 -06:00
|
|
|
"""Set the nickmask that the ircd tells us is us."""
|
2011-01-07 23:56:51 -06:00
|
|
|
what = event.arguments()[0]
|
|
|
|
|
|
|
|
match = re.search('(\S+!\S+@\S+)', what)
|
|
|
|
if match:
|
2011-01-08 00:05:00 -06:00
|
|
|
self.nickmask = match.group(1)
|
2011-01-07 23:56:51 -06:00
|
|
|
|
2011-01-07 09:54:51 -06:00
|
|
|
def privmsg(self, target, text):
|
|
|
|
"""Send a PRIVMSG command."""
|
|
|
|
|
|
|
|
splitter = "..."
|
|
|
|
|
|
|
|
# split messages that are too long. Max length is 512.
|
2011-01-08 00:05:00 -06:00
|
|
|
# TODO: this does not properly handle when the nickmask has been
|
2011-01-07 09:54:51 -06:00
|
|
|
# masked by the ircd
|
2011-01-07 23:56:51 -06:00
|
|
|
# is the above still the case?
|
2011-01-08 00:05:00 -06:00
|
|
|
space = 512 - len('\r\n') - len(' PRIVMSG ') - len(target) - len(' :') - len(self.nickmask) - len(' :')
|
2011-01-07 09:54:51 -06:00
|
|
|
splitspace = space - (len(splitter) + 1)
|
|
|
|
|
|
|
|
if len(text) > space:
|
|
|
|
times = 1
|
|
|
|
|
|
|
|
while len(text) > splitspace:
|
|
|
|
splitpos = text.rfind(' ', 0, splitspace)
|
|
|
|
splittext = text[0:splitpos] + ' ' + splitter
|
|
|
|
text = splitter + ' ' + text[splitpos+1:]
|
|
|
|
self.send_raw("PRIVMSG %s :%s" % (target, splittext))
|
|
|
|
|
|
|
|
times = times + 1
|
|
|
|
if times >= 4:
|
|
|
|
return
|
|
|
|
|
|
|
|
# done splitting
|
|
|
|
self.send_raw("PRIVMSG %s :%s" % (target, text))
|
|
|
|
else:
|
|
|
|
self.send_raw("PRIVMSG %s :%s" % (target, text))
|
|
|
|
|
|
|
|
class DrBotIRC(irclib.IRC):
|
|
|
|
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
"""Implement a customized irclib IRC."""
|
|
|
|
|
|
|
|
modlist = []
|
|
|
|
config = None
|
|
|
|
server = None
|
|
|
|
|
|
|
|
def __init__(self, config):
|
|
|
|
irclib.IRC.__init__(self)
|
|
|
|
|
|
|
|
self.config = config
|
2012-03-30 09:43:30 -05:00
|
|
|
self.xmlrpc = None
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log = logging.getLogger('dr.botzo')
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
|
|
|
# handle SIGINT
|
|
|
|
signal.signal(signal.SIGINT, self.sigint_handler)
|
2011-01-07 09:54:51 -06:00
|
|
|
|
2012-03-30 09:43:30 -05:00
|
|
|
# load XML-RPC server
|
|
|
|
try:
|
|
|
|
if self.config.has_section('XMLRPC'):
|
|
|
|
host = self.config.get('XMLRPC', 'host')
|
|
|
|
port = self.config.getint('XMLRPC', 'port')
|
|
|
|
if host and port:
|
|
|
|
self.funcs = DrBotzoMethods(self)
|
|
|
|
|
|
|
|
self.xmlrpc = SimpleXMLRPCServer((host, port))
|
|
|
|
self.xmlrpc.register_introspection_functions()
|
|
|
|
self.xmlrpc.register_instance(self.funcs)
|
|
|
|
|
|
|
|
thread.start_new_thread(self._xmlrpc_listen, ())
|
|
|
|
except NoOptionError: pass
|
|
|
|
|
2011-01-07 09:54:51 -06:00
|
|
|
def server(self):
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
"""Create a DrBotServerConnection."""
|
|
|
|
self.server = DrBotServerConnection(self)
|
|
|
|
self.connections.append(self.server)
|
|
|
|
|
|
|
|
return self.server
|
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
def _handle_event(self, connection, event):
|
|
|
|
"""Override event handler to do recursion."""
|
|
|
|
|
2012-03-01 22:00:42 -06:00
|
|
|
try:
|
|
|
|
nick = irclib.nm_to_n(event.source())
|
|
|
|
except (IndexError, AttributeError):
|
|
|
|
nick = ''
|
|
|
|
|
|
|
|
try:
|
|
|
|
if self.config.has_section('Ignore'):
|
2012-03-07 22:48:30 -06:00
|
|
|
alias = self.config.get('Ignore', nick.lower())
|
2012-03-01 22:00:42 -06:00
|
|
|
if alias:
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log.debug("ignoring " + nick + " as per config file")
|
2012-03-01 22:00:42 -06:00
|
|
|
return
|
|
|
|
except NoOptionError: pass
|
|
|
|
|
2011-04-27 22:11:37 -05:00
|
|
|
self.try_alias_cmds(connection, event)
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
self.try_recursion(connection, event)
|
|
|
|
self.try_alias(connection, event)
|
|
|
|
|
|
|
|
h = self.handlers
|
|
|
|
for handler in h.get("all_events", []) + h.get(event.eventtype(), []):
|
2011-10-18 00:48:11 -05:00
|
|
|
try:
|
|
|
|
if handler[1](connection, event) == "NO MORE":
|
|
|
|
return
|
|
|
|
except Exception as e:
|
2012-07-14 09:16:59 -05:00
|
|
|
exc_type, exc_value, exc_traceback = sys.exc_info()
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log.error("exception floated up to DrBotIrc!")
|
|
|
|
self.log.error(exc_type + ": " + exc_value)
|
|
|
|
self.log.error(exc_traceback)
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
|
2012-03-30 10:17:13 -05:00
|
|
|
def xmlrpc_register_function(self, func, name):
|
|
|
|
"""Add a method to the XML-RPC interface."""
|
|
|
|
|
2012-03-30 17:25:46 -05:00
|
|
|
if func and self.xmlrpc:
|
2012-03-30 10:17:13 -05:00
|
|
|
if hasattr(func, '__call__'):
|
|
|
|
self.xmlrpc.register_function(func, name)
|
|
|
|
|
2012-03-30 09:43:30 -05:00
|
|
|
def _xmlrpc_listen(self):
|
|
|
|
"""Begin listening. Hopefully this was called in a new thread."""
|
|
|
|
|
|
|
|
self.xmlrpc.serve_forever()
|
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
def try_to_replace_event_text_with_module_text(self, connection, event):
|
|
|
|
"""Do something very similar to _handle_event, but for recursion.
|
|
|
|
|
|
|
|
The intent here is that we replace [text] with whatever a module
|
|
|
|
provides to us.
|
|
|
|
"""
|
|
|
|
|
|
|
|
h = self.handlers
|
2011-02-17 12:01:32 -06:00
|
|
|
replies = []
|
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
for handler in h.get("all_events", []) + h.get(event.eventtype(), []):
|
|
|
|
ret = handler[1](connection, event)
|
|
|
|
if ret:
|
2011-02-17 12:01:32 -06:00
|
|
|
replies.append(ret)
|
|
|
|
if len(replies):
|
|
|
|
event.arguments()[0] = '\n'.join(replies)
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
|
2011-04-27 22:11:37 -05:00
|
|
|
def try_alias_cmds(self, connection, event):
|
|
|
|
"""See if there is an alias ("!command") in the text, and if so
|
|
|
|
do alias manipulation before any other recursion or aliasing.
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
"""
|
|
|
|
|
2011-04-27 22:11:37 -05:00
|
|
|
try:
|
|
|
|
nick = irclib.nm_to_n(event.source())
|
|
|
|
except (IndexError, AttributeError):
|
|
|
|
nick = ''
|
|
|
|
try:
|
|
|
|
userhost = irclib.nm_to_uh(event.source())
|
|
|
|
except (IndexError, AttributeError):
|
|
|
|
userhost = ''
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
replypath = event.target()
|
2011-04-27 22:11:37 -05:00
|
|
|
try:
|
|
|
|
what = event.arguments()[0]
|
|
|
|
except (IndexError, AttributeError):
|
|
|
|
what = ''
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
admin_unlocked = False
|
|
|
|
|
2011-01-07 21:14:14 -06:00
|
|
|
# privmsg
|
|
|
|
if replypath == connection.get_nickname():
|
|
|
|
replypath = nick
|
|
|
|
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
try:
|
|
|
|
if userhost == self.config.get('dr.botzo', 'admin_userhost'):
|
|
|
|
admin_unlocked = True
|
|
|
|
except NoOptionError: pass
|
|
|
|
|
|
|
|
# first see if the aliases are being directly manipulated via add/remove
|
|
|
|
whats = what.split(' ')
|
2011-06-14 22:40:45 -05:00
|
|
|
|
|
|
|
if len(whats) <= 1:
|
|
|
|
return
|
|
|
|
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
try:
|
|
|
|
if whats[0] == '!alias' and whats[1] == 'add' and len(whats) >= 4:
|
|
|
|
if not self.config.has_section('Alias'):
|
|
|
|
self.config.add_section('Alias')
|
|
|
|
|
|
|
|
self.config.set('Alias', whats[2], ' '.join(whats[3:]))
|
|
|
|
replystr = 'Added alias ' + whats[2] + '.'
|
2011-02-17 10:07:29 -06:00
|
|
|
return self.reply(connection, event, replystr)
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
if whats[0] == '!alias' and whats[1] == 'remove' and len(whats) >= 3:
|
|
|
|
if not self.config.has_section('Alias'):
|
|
|
|
self.config.add_section('Alias')
|
|
|
|
|
|
|
|
if self.config.remove_option('Alias', whats[2]):
|
|
|
|
replystr = 'Removed alias ' + whats[2] + '.'
|
2011-02-17 10:07:29 -06:00
|
|
|
return self.reply(connection, event, replystr)
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
elif whats[0] == '!alias' and whats[1] == 'list':
|
|
|
|
try:
|
|
|
|
if len(whats) > 2:
|
|
|
|
alias = self.config.get('Alias', whats[2])
|
2011-02-17 10:07:29 -06:00
|
|
|
return self.reply(connection, event, alias)
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
else:
|
|
|
|
alist = self.config.options('Alias')
|
2011-01-07 20:36:42 -06:00
|
|
|
alist.remove('debug')
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
alist.sort()
|
|
|
|
liststr = ', '.join(alist)
|
2011-02-17 10:07:29 -06:00
|
|
|
return self.reply(connection, event, liststr)
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
except NoSectionError: pass
|
|
|
|
except NoOptionError: pass
|
|
|
|
except NoSectionError: pass
|
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
def try_alias(self, connection, event):
|
2011-01-07 22:34:27 -06:00
|
|
|
# try doing alias work
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
try:
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
what = event.arguments()[0]
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
alias_list = self.config.options('Alias')
|
|
|
|
|
|
|
|
for alias in alias_list:
|
2011-02-17 09:38:41 -06:00
|
|
|
alias_re = re.compile(alias, re.IGNORECASE)
|
2011-06-20 20:05:03 -05:00
|
|
|
if alias_re.search(what) and alias != 'debug':
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
# we found an alias for our given string, doing a replace
|
2011-02-17 09:38:41 -06:00
|
|
|
command = re.sub(alias, self.config.get('Alias', alias), what, flags=re.IGNORECASE)
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
event.arguments()[0] = command
|
|
|
|
|
|
|
|
# now we have to check it for recursions again
|
|
|
|
self.try_recursion(connection, event)
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
2011-01-07 22:31:30 -06:00
|
|
|
# i guess someone could have an alias of an alias... try again
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
return self.try_alias(connection, event)
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
except NoOptionError: pass
|
|
|
|
except NoSectionError: pass
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
except IndexError: pass
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
|
|
|
# if we got here, there are no matching aliases, so return what we got
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
return event
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
def try_recursion(self, connection, event):
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
"""Scan message for subcommands to execute and use as part of this command.
|
|
|
|
|
|
|
|
Upon seeing a line intended for this module, see if there are subcommands
|
|
|
|
that we should do what is basically a text replacement on. The intent is to
|
|
|
|
allow things like the following:
|
|
|
|
|
|
|
|
command arg1 [anothercommand arg1 arg2]
|
|
|
|
|
|
|
|
where the output of anothercommand is command's arg2..n.
|
|
|
|
"""
|
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
try:
|
|
|
|
# begin recursion search
|
|
|
|
attempt = event.arguments()[0]
|
|
|
|
|
|
|
|
start_idx = attempt.find('[')
|
|
|
|
subcmd = attempt[start_idx+1:]
|
|
|
|
end_idx = subcmd.rfind(']')
|
|
|
|
subcmd = subcmd[:end_idx]
|
|
|
|
|
|
|
|
if start_idx != -1 and end_idx != -1 and len(subcmd) > 0:
|
|
|
|
# found recursion candidate
|
|
|
|
# copy the event and see if IT has recursion to do
|
|
|
|
newevent = copy.deepcopy(event)
|
|
|
|
newevent.arguments()[0] = subcmd
|
2012-03-29 20:07:32 -05:00
|
|
|
newevent._recursing = True
|
|
|
|
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
self.try_recursion(connection, newevent)
|
|
|
|
|
|
|
|
# recursion over, check for aliases
|
|
|
|
self.try_alias(connection, newevent)
|
|
|
|
|
|
|
|
# now that we have a string that has been de-aliased and
|
|
|
|
# recursed all the way deeper into its text, see if any
|
|
|
|
# modules can do something with it. this calls the same
|
|
|
|
# event handlers in the same way as if this were a native
|
|
|
|
# event.
|
|
|
|
self.try_to_replace_event_text_with_module_text(connection, newevent)
|
|
|
|
|
|
|
|
# we have done all we can do with the sub-event. whatever
|
|
|
|
# the text of that event now is, we should replace the parent
|
|
|
|
# event's [] section with it.
|
|
|
|
oldtext = event.arguments()[0]
|
|
|
|
newtext = oldtext.replace('['+subcmd+']', newevent.arguments()[0])
|
|
|
|
event.arguments()[0] = newtext
|
|
|
|
|
|
|
|
# we have now resolved the []. recursion will unfold, replacing
|
|
|
|
# it further and further, until we eventually get back to the
|
|
|
|
# original irc event in _handle_event, which will do one
|
|
|
|
# last search on the text.
|
|
|
|
except IndexError: pass
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
|
|
|
def quit_irc(self, connection, msg):
|
|
|
|
for module in self.modlist:
|
2011-01-08 00:44:37 -06:00
|
|
|
module.save()
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
module.shutdown()
|
|
|
|
|
|
|
|
connection.quit(msg)
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log.info(self.save_config())
|
2012-03-30 09:43:30 -05:00
|
|
|
self._xmlrpc_shutdown()
|
2012-07-15 21:48:33 -05:00
|
|
|
self.log.info("Bot shutting down.")
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
sys.exit()
|
|
|
|
|
2012-07-10 17:18:35 -05:00
|
|
|
def reply(self, connection, event, replystr, stop_responding=False):
|
|
|
|
"""Reply over IRC to replypath or return a string with the reply."""
|
|
|
|
|
|
|
|
replypath = event.target()
|
|
|
|
|
|
|
|
# check for privmsg
|
|
|
|
if replypath == connection.get_nickname():
|
|
|
|
replypath = irclib.nm_to_n(event.source())
|
|
|
|
|
|
|
|
if replystr is not None:
|
|
|
|
if event._recursing:
|
|
|
|
return replystr
|
|
|
|
else:
|
|
|
|
replies = replystr.split('\n')
|
|
|
|
for reply in replies:
|
|
|
|
connection.privmsg(replypath, reply)
|
|
|
|
if stop_responding:
|
|
|
|
return "NO MORE"
|
|
|
|
|
2011-01-08 00:49:10 -06:00
|
|
|
def save_modules(self):
|
|
|
|
for module in self.modlist:
|
|
|
|
module.save()
|
|
|
|
|
2012-03-30 09:43:30 -05:00
|
|
|
def _xmlrpc_shutdown(self):
|
|
|
|
"""Shut down the XML-RPC server."""
|
|
|
|
|
|
|
|
if self.xmlrpc is not None:
|
|
|
|
self.xmlrpc.shutdown()
|
|
|
|
self.xmlrpc.server_close()
|
|
|
|
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
def save_config(self):
|
|
|
|
with open('dr.botzo.cfg', 'w') as cfg:
|
|
|
|
self.config.write(cfg)
|
|
|
|
|
2011-01-08 00:44:37 -06:00
|
|
|
return 'Saved config.'
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
|
|
|
def load_module(self, modname):
|
|
|
|
"""Load a module (in both the python and dr.botzo sense) if not
|
|
|
|
already loaded.
|
|
|
|
"""
|
|
|
|
|
|
|
|
for module in self.modlist:
|
|
|
|
if modname == module.__class__.__name__:
|
|
|
|
return 'Module ' + modname + ' is already loaded.'
|
|
|
|
|
|
|
|
# not loaded, let's get to work
|
|
|
|
try:
|
|
|
|
modstr = 'modules.'+modname
|
|
|
|
__import__(modstr)
|
|
|
|
module = sys.modules[modstr]
|
|
|
|
botmod = eval('module.' + modname + '(self, self.config, self.server)')
|
|
|
|
self.modlist.append(botmod)
|
rewrite recursion/alias code for the 500th time.
more of a moving of the code, actually, it now exists in (an overridden)
_handle_event, so that recursions happen against irc events directly,
rather than an already partially interpreted object.
with this change, modules don't need to implement do() nor do we have a
need for the internal_bus, which was doing an additional walk of the
modules after the irc event was already handled and turned into text. now
the core event handler does the recursion scans.
to support this, we bring back the old replypath trick and use it again,
so we know when to send a privmsg reply and when to return text so that
it may be chained in recursion. this feels old hat by now, but if you
haven't been following along, you should really look at the diff.
that's the meat of the change. the rest is updating modules to use
self.reply() and reimplementing (un)register_handlers where appropriate
2011-02-17 01:08:45 -06:00
|
|
|
botmod.register_handlers()
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
|
|
|
|
# might as well add it to the list
|
|
|
|
modset = set(self.config.get('dr.botzo', 'module_list').split(','))
|
|
|
|
modset.add(modname)
|
|
|
|
self.config.set('dr.botzo', 'module_list', ','.join(modset))
|
|
|
|
|
|
|
|
return 'Module ' + modname + ' loaded.'
|
|
|
|
except ImportError:
|
|
|
|
return 'Module ' + modname + ' not found.'
|
|
|
|
|
|
|
|
def unload_module(self, modname):
|
|
|
|
"""Attempt to unload and del a module if it's loaded."""
|
|
|
|
|
|
|
|
modstr = 'modules.'+modname
|
|
|
|
for module in self.modlist:
|
|
|
|
if modname == module.__class__.__name__:
|
|
|
|
# do anything the module needs to do to clean up
|
2011-01-08 00:44:37 -06:00
|
|
|
module.save()
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
module.shutdown()
|
|
|
|
|
|
|
|
# remove module references
|
|
|
|
self.modlist.remove(module)
|
|
|
|
module.unregister_handlers()
|
|
|
|
|
|
|
|
# del it
|
|
|
|
del(sys.modules[modstr])
|
|
|
|
del(module)
|
|
|
|
|
|
|
|
# might as well remove it from the list
|
|
|
|
modset = set(self.config.get('dr.botzo', 'module_list').split(','))
|
|
|
|
modset.remove(modname)
|
|
|
|
self.config.set('dr.botzo', 'module_list', ','.join(modset))
|
|
|
|
|
|
|
|
return 'Module ' + modname + ' unloaded.'
|
|
|
|
|
|
|
|
# guess it was never loaded
|
|
|
|
return 'Module ' + modname + ' is not loaded.'
|
|
|
|
|
2011-01-08 01:22:31 -06:00
|
|
|
def list_modules(self):
|
|
|
|
"""List loaded modules."""
|
|
|
|
|
|
|
|
modnames = []
|
|
|
|
for module in self.modlist:
|
|
|
|
modnames.append(module.__class__.__name__)
|
|
|
|
|
|
|
|
return modnames
|
|
|
|
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
# SIGINT signal handler
|
|
|
|
def sigint_handler(self, signal, frame):
|
2011-01-08 00:44:37 -06:00
|
|
|
for module in self.modlist:
|
|
|
|
module.save()
|
|
|
|
module.shutdown()
|
|
|
|
|
2012-07-15 21:32:12 -05:00
|
|
|
self.log.info(self.save_config())
|
2012-03-30 09:43:30 -05:00
|
|
|
self._xmlrpc_shutdown()
|
migrate some code that became pivotal to the bot into DrBotIRC.
this is a big change. DrBotIrc is now in charge of module loading
and unloading, aliases, and recursion. the Alias module is no more,
and a bunch of functionality was moved out of IrcAdmin, including
also config file saving, the sigint handler, and quitting the bot.
additionally, a lot of stuff got caught in the wake. dr.botzo.py
is simpler now, and lets DrBotIRC do the dynamic loading stuff.
Module.__init__ changed, modules no longer get modlist and instead
get a reference to the DrBotIRC object. IrcAdmin still has the same
exposed methods, but now calls out to DrBotIRC to achieve some of
them.
naturally, a recursion/alias rewrite was included with this change.
it is clearer now (i think), but probably brittle somewhere.
additionally, currently any module that has registered a pubmsg
handler can potentially fire more than once on one input (without
recursion). this may be the next thing to fix. do() may need to
be split, or maybe it's time to stop having modules deal with
pubmsg/privmsg entirely. need to decide.
WEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
2011-01-07 17:38:26 -06:00
|
|
|
sys.exit()
|
2011-01-07 09:54:51 -06:00
|
|
|
|
|
|
|
# vi:tabstop=4:expandtab:autoindent
|
|
|
|
# kate: indent-mode python;indent-width 4;replace-tabs on;
|