Limnoria/src/irclib.py

958 lines
35 KiB
Python
Raw Normal View History

2003-03-12 07:26:59 +01:00
###
2004-08-23 15:03:46 +02:00
# Copyright (c) 2002-2004 Jeremiah Fincher
2003-03-12 07:26:59 +01:00
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions, and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions, and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the author of this software nor the name of
# contributors to this software may be used to endorse or promote products
# derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###
2003-11-25 09:38:19 +01:00
__revision__ = "$Id$"
2004-07-24 07:18:26 +02:00
import supybot.fix as fix
2003-03-12 07:26:59 +01:00
import copy
2003-07-31 08:20:58 +02:00
import sets
2003-03-12 07:26:59 +01:00
import time
2004-08-17 10:07:47 +02:00
import random
import operator
2004-01-01 21:12:01 +01:00
from itertools import imap, chain, cycle
2003-03-12 07:26:59 +01:00
2004-07-24 07:18:26 +02:00
import supybot.log as log
import supybot.conf as conf
import supybot.utils as utils
import supybot.world as world
import supybot.ircdb as ircdb
import supybot.ircmsgs as ircmsgs
import supybot.ircutils as ircutils
from supybot.structures import queue, smallqueue, RingBuffer
2003-03-12 07:26:59 +01:00
###
# The base class for a callback to be registered with an Irc object. Shows
# the required interface for callbacks -- name(),
# inFilter(irc, msg), outFilter(irc, msg), and __call__(irc, msg) [used so
# functions can be used as callbacks conceivable, and so if refactoring ever
# changes the nature of the callbacks from classes to functions, syntactical
# changes elsewhere won't be required.
###
class IrcCommandDispatcher(object):
"""Base class for classes that must dispatch on a command."""
def dispatchCommand(self, command):
2003-10-04 14:17:31 +02:00
"""Given a string 'command', dispatches to doCommand."""
return getattr(self, 'do' + command.capitalize(), None)
class IrcCallback(IrcCommandDispatcher):
2003-03-12 07:26:59 +01:00
"""Base class for standard callbacks.
Callbacks derived from this class should have methods of the form
"doCommand" -- doPrivmsg, doNick, do433, etc. These will be called
on matching messages.
"""
callAfter = ()
callBefore = ()
__metaclass__ = log.MetaFirewall
__firewalled__ = {'die': None,
'reset': None,
'__call__': None,
'__lt__': lambda self: 0,
'inFilter': lambda self, irc, msg: msg,
'outFilter': lambda self, irc, msg: msg,
'name': lambda self: self.__class__.__name__,}
2004-09-10 08:30:21 +02:00
def __repr__(self):
return '<%s %s>' % (self.__class__.__name__, self.name())
2003-03-12 07:26:59 +01:00
def name(self):
2003-10-04 14:17:31 +02:00
"""Returns the name of the callback."""
2003-03-12 07:26:59 +01:00
return self.__class__.__name__
def callPrecedence(self, irc):
"""Returns a pair of (callbacks to call before me,
callbacks to call after me)"""
after = []
before = []
2004-09-16 16:37:08 +02:00
for name in self.callBefore:
cb = irc.getCallback(name)
if cb is not None:
after.append(cb)
2004-09-16 16:37:08 +02:00
for name in self.callAfter:
cb = irc.getCallback(name)
if cb is not None:
before.append(cb)
assert self not in after, '%s was in its own after.' % self.name()
assert self not in before, '%s was in its own before.' % self.name()
return (before, after)
2003-03-12 07:26:59 +01:00
def inFilter(self, irc, msg):
2003-10-04 14:17:31 +02:00
"""Used for filtering/modifying messages as they're entering.
ircmsgs.IrcMsg objects are immutable, so this method is expected to
return another ircmsgs.IrcMsg object. Obviously the same IrcMsg
can be returned.
"""
2003-03-12 07:26:59 +01:00
return msg
def outFilter(self, irc, msg):
2003-10-04 14:17:31 +02:00
"""Used for filtering/modifying messages as they're leaving.
As with inFilter, an IrcMsg is returned.
"""
2003-03-12 07:26:59 +01:00
return msg
def __call__(self, irc, msg):
2003-10-04 14:17:31 +02:00
"""Used for handling each message."""
method = self.dispatchCommand(msg.command)
if method is not None:
method(irc, msg)
2003-03-12 07:26:59 +01:00
def reset(self):
2004-01-01 21:12:01 +01:00
"""Resets the callback. Called when reconnecting to the server."""
2003-03-12 07:26:59 +01:00
pass
def die(self):
2003-10-04 14:17:31 +02:00
"""Makes the callback die. Called when the parent Irc object dies."""
2003-03-12 07:26:59 +01:00
pass
###
# Basic queue for IRC messages. It doesn't presently (but should at some
# later point) reorder messages based on priority or penalty calculations.
###
_high = sets.ImmutableSet(['MODE', 'KICK', 'PONG', 'NICK', 'PASS', 'CAPAB'])
_low = sets.ImmutableSet(['PRIVMSG', 'PING', 'WHO', 'NOTICE'])
2003-03-12 07:26:59 +01:00
class IrcMsgQueue(object):
"""Class for a queue of IrcMsgs. Eventually, it should be smart.
Probably smarter than it is now, though it's gotten quite a bit smarter
than it originally was. A method to "score" methods, and a heapq to
maintain a priority queue of the messages would be the ideal way to do
2004-08-19 01:15:27 +02:00
intelligent queuing.
2003-10-04 14:17:31 +02:00
As it stands, however, we simple keep track of 'high priority' messages,
'low priority' messages, and normal messages, and just make sure to return
the 'high priority' ones before the normal ones before the 'low priority'
ones.
2003-03-12 07:26:59 +01:00
"""
__slots__ = ('msgs', 'highpriority', 'normal', 'lowpriority')
def __init__(self, iterable=()):
2003-03-12 07:26:59 +01:00
self.reset()
for msg in iterable:
self.enqueue(msg)
2003-03-12 07:26:59 +01:00
def reset(self):
2003-10-04 14:17:31 +02:00
"""Clears the queue."""
self.highpriority = smallqueue()
self.normal = smallqueue()
self.lowpriority = smallqueue()
2003-07-31 08:20:58 +02:00
self.msgs = sets.Set()
2003-03-12 07:26:59 +01:00
def enqueue(self, msg):
2003-10-04 14:17:31 +02:00
"""Enqueues a given message."""
if msg in self.msgs and \
not conf.supybot.protocols.irc.queueDuplicateMessages():
s = str(msg).strip()
log.warning('Not adding message %r to queue, already added.', s)
return False
2003-03-12 07:26:59 +01:00
else:
self.msgs.add(msg)
if msg.command in _high:
self.highpriority.enqueue(msg)
elif msg.command in _low:
2003-04-02 11:07:52 +02:00
self.lowpriority.enqueue(msg)
else:
self.normal.enqueue(msg)
return True
2003-03-12 07:26:59 +01:00
def dequeue(self):
2003-10-04 14:17:31 +02:00
"""Dequeues a given message."""
msg = None
if self.highpriority:
msg = self.highpriority.dequeue()
elif self.normal:
msg = self.normal.dequeue()
2003-04-02 11:07:52 +02:00
elif self.lowpriority:
msg = self.lowpriority.dequeue()
if msg:
try:
self.msgs.remove(msg)
except KeyError:
s = 'Odd, dequeuing a message that\'s not in self.msgs.'
log.warning(s)
2003-04-02 11:07:52 +02:00
return msg
2003-03-12 07:26:59 +01:00
def __nonzero__(self):
2003-07-31 08:20:58 +02:00
return bool(self.highpriority or self.normal or self.lowpriority)
2003-03-12 07:26:59 +01:00
def __len__(self):
return sum(imap(len,[self.highpriority,self.lowpriority,self.normal]))
def __repr__(self):
name = self.__class__.__name__
return '%s(%r)' % (name, list(chain(self.highpriority,
self.normal,
self.lowpriority)))
__str__ = __repr__
2003-03-12 07:26:59 +01:00
###
# Maintains the state of IRC connection -- the most recent messages, the
# status of various modes (especially ops/halfops/voices) in channels, etc.
###
class ChannelState(object):
__slots__ = ('users', 'ops', 'halfops', 'bans',
'voices', 'topic', 'modes', 'created')
2003-03-12 07:26:59 +01:00
def __init__(self):
self.topic = ''
self.created = 0
self.ops = ircutils.IrcSet()
self.bans = ircutils.IrcSet()
self.users = ircutils.IrcSet()
self.voices = ircutils.IrcSet()
self.halfops = ircutils.IrcSet()
2004-01-30 20:53:34 +01:00
self.modes = ircutils.IrcDict()
2003-03-12 07:26:59 +01:00
def addUser(self, user):
2003-10-04 14:17:31 +02:00
"Adds a given user to the ChannelState. Power prefixes are handled."
2003-06-18 09:19:27 +02:00
nick = user.lstrip('@%+')
2003-12-02 12:40:46 +01:00
if not nick:
return
2003-06-02 09:21:08 +02:00
while user and user[0] in '@%+':
(marker, user) = (user[0], user[1:])
2004-08-26 01:19:07 +02:00
assert user, 'Looks like my caller is passing chars, not nicks.'
if marker == '@':
self.ops.add(nick)
elif marker == '%':
self.halfops.add(nick)
elif marker == '+':
self.voices.add(nick)
self.users.add(nick)
def replaceUser(self, oldNick, newNick):
2003-10-04 14:17:31 +02:00
"""Changes the user oldNick to newNick; used for NICK changes."""
# Note that this doesn't have to have the sigil (@%+) that users
# have to have for addUser; it just changes the name of the user
# without changing any of his categories.
for s in (self.users, self.ops, self.halfops, self.voices):
if oldNick in s:
s.remove(oldNick)
s.add(newNick)
2003-03-12 07:26:59 +01:00
def removeUser(self, user):
2003-10-04 14:17:31 +02:00
"""Removes a given user from the channel."""
self.users.discard(user)
self.ops.discard(user)
self.halfops.discard(user)
self.voices.discard(user)
2003-03-12 07:26:59 +01:00
2004-01-30 20:53:34 +01:00
def setMode(self, mode, value=None):
assert mode not in 'ovhbeq'
2004-01-30 20:53:34 +01:00
self.modes[mode] = value
def unsetMode(self, mode):
assert mode not in 'ovhbeq'
2004-01-30 20:53:34 +01:00
if mode in self.modes:
del self.modes[mode]
def doMode(self, msg):
def getSet(c):
if c == 'o':
set = self.ops
elif c == 'v':
set = self.voices
elif c == 'h':
set = self.halfops
elif c == 'b':
set = self.bans
else: # We don't care yet, so we'll just return an empty set.
set = sets.Set()
return set
for (mode, value) in ircutils.separateModes(msg.args[1:]):
(action, modeChar) = mode
if modeChar in 'ovhbeq': # We don't handle e or q yet.
set = getSet(modeChar)
if action == '-':
set.discard(value)
elif action == '+':
set.add(value)
else:
if action == '+':
self.setMode(modeChar, value)
else:
assert action == '-'
self.unsetMode(modeChar)
def __getstate__(self):
return [getattr(self, name) for name in self.__slots__]
def __setstate__(self, t):
for (name, value) in zip(self.__slots__, t):
setattr(self, name, value)
def __eq__(self, other):
ret = True
for name in self.__slots__:
ret = ret and getattr(self, name) == getattr(other, name)
return ret
def __ne__(self, other):
# This shouldn't even be necessary, grr...
return not self == other
class IrcState(IrcCommandDispatcher):
2003-03-12 07:26:59 +01:00
"""Maintains state of the Irc connection. Should also become smarter.
"""
__metaclass__ = log.MetaFirewall
__firewalled__ = {'addMsg': None}
def __init__(self, history=None, supported=None,
nicksToHostmasks=None, channels=None):
if history is None:
history = RingBuffer(conf.supybot.protocols.irc.maxHistoryLength())
if supported is None:
supported = utils.InsensitivePreservingDict()
if nicksToHostmasks is None:
nicksToHostmasks = ircutils.IrcDict()
if channels is None:
channels = ircutils.IrcDict()
self.supported = supported
self.history = history
self.channels = channels
self.nicksToHostmasks = nicksToHostmasks
2003-03-12 07:26:59 +01:00
def reset(self):
2003-10-04 14:17:31 +02:00
"""Resets the state to normal, unconnected state."""
self.history.reset()
self.channels.clear()
2004-08-25 00:15:56 +02:00
self.supported.clear()
self.nicksToHostmasks.clear()
self.history.resize(conf.supybot.protocols.irc.maxHistoryLength())
def __reduce__(self):
return (self.__class__, (self.history, self.supported,
self.nicksToHostmasks, self.channels))
def __eq__(self, other):
return self.history == other.history and \
self.channels == other.channels and \
self.supported == other.supported and \
self.nicksToHostmasks == other.nicksToHostmasks
def __ne__(self, other):
return not self == other
2003-08-20 18:26:23 +02:00
2003-03-12 07:26:59 +01:00
def copy(self):
ret = self.__class__()
ret.history = copy.deepcopy(self.history)
ret.nicksToHostmasks = copy.deepcopy(self.nicksToHostmasks)
ret.channels = copy.deepcopy(self.channels)
2003-03-12 07:26:59 +01:00
return ret
def addMsg(self, irc, msg):
2003-10-04 14:17:31 +02:00
"""Updates the state based on the irc object and the message."""
self.history.append(msg)
if ircutils.isUserHostmask(msg.prefix) and not msg.command == 'NICK':
2003-03-12 07:26:59 +01:00
self.nicksToHostmasks[msg.nick] = msg.prefix
method = self.dispatchCommand(msg.command)
if method is not None:
method(irc, msg)
2003-03-12 07:26:59 +01:00
def getTopic(self, channel):
2003-10-04 14:17:31 +02:00
"""Returns the topic for a given channel."""
return self.channels[channel].topic
2003-03-12 07:26:59 +01:00
def nickToHostmask(self, nick):
2003-10-04 14:17:31 +02:00
"""Returns the hostmask for a given nick."""
2003-03-12 07:26:59 +01:00
return self.nicksToHostmasks[nick]
2004-08-25 00:15:56 +02:00
_005converters = utils.InsensitivePreservingDict({
'modes': int,
2004-09-09 00:48:32 +02:00
'keylen': int,
2004-08-25 00:15:56 +02:00
'maxbans': int,
'nicklen': int,
2004-09-09 00:48:32 +02:00
'userlen': int,
'hostlen': int,
2004-08-25 00:15:56 +02:00
'kicklen': int,
'awaylen': int,
'silence': int,
2004-09-09 00:48:32 +02:00
'topiclen': int,
'channellen': int,
'maxtargets': int,
'maxnicklen': int,
'maxchannels': int,
'watch': int, # DynastyNet, EnterTheGame
2004-08-25 00:15:56 +02:00
})
def _prefixParser(s):
2004-08-26 06:43:19 +02:00
if ')' in s:
(left, right) = s.split(')')
assert left[0] == '(', 'Odd PREFIX in 005: %s' % s
left = left[1:]
assert len(left) == len(right), 'Odd PREFIX in 005: %s' % s
return dict(zip(left, right))
else:
return dict(zip('ovh', s))
2004-08-25 00:15:56 +02:00
_005converters['prefix'] = _prefixParser
del _prefixParser
def do005(self, irc, msg):
for arg in msg.args[1:-1]: # 0 is nick, -1 is "are supported"
if '=' in arg:
(name, value) = arg.split('=', 1)
converter = self._005converters.get(name, lambda x: x)
try:
self.supported[name] = converter(value)
except Exception, e:
log.exception('Uncaught exception in 005 converter:')
log.error('Name: %s, Converter: %s', name, converter)
2004-08-25 00:15:56 +02:00
else:
self.supported[arg] = None
def do352(self, irc, msg):
2004-08-26 01:04:18 +02:00
# WHO reply.
2004-04-30 01:33:31 +02:00
(nick, user, host) = (msg.args[5], msg.args[2], msg.args[3])
hostmask = '%s!%s@%s' % (nick, user, host)
self.nicksToHostmasks[nick] = hostmask
2004-08-26 01:04:18 +02:00
def do353(self, irc, msg):
# NAMES reply.
(_, type, channel, names) = msg.args
2004-08-26 01:04:18 +02:00
if channel not in self.channels:
2004-08-26 01:23:51 +02:00
self.channels[channel] = ChannelState()
2004-08-26 01:04:18 +02:00
c = self.channels[channel]
2004-08-26 01:19:07 +02:00
for name in names.split():
2004-08-26 01:04:18 +02:00
c.addUser(name)
if type == '@':
2004-08-26 01:04:18 +02:00
c.modes['s'] = None
def doJoin(self, irc, msg):
for channel in msg.args[0].split(','):
if channel in self.channels:
self.channels[channel].addUser(msg.nick)
2004-03-25 13:09:39 +01:00
elif msg.nick: # It must be us.
chan = ChannelState()
chan.addUser(msg.nick)
self.channels[channel] = chan
# I don't know why this assert was here.
#assert msg.nick == irc.nick, msg
def doMode(self, irc, msg):
channel = msg.args[0]
if ircutils.isChannel(channel): # There can be user modes, as well.
chan = self.channels[channel] # ??? Do we need to catch KeyError?
chan.doMode(msg)
def do324(self, irc, msg):
channel = msg.args[1]
chan = self.channels[channel]
for (mode, value) in ircutils.separateModes(msg.args[2:]):
modeChar = mode[1]
2004-07-31 10:26:04 +02:00
if mode[0] == '+' and mode[1] not in 'ovh':
chan.setMode(modeChar, value)
2004-07-31 10:26:04 +02:00
elif mode[0] == '-' and mode[1] not in 'ovh':
chan.unsetMode(modeChar)
def do329(self, irc, msg):
# This is the last part of an empty mode.
channel = msg.args[1]
chan = self.channels[channel]
chan.created = int(msg.args[2])
def doPart(self, irc, msg):
for channel in msg.args[0].split(','):
chan = self.channels[channel]
if msg.nick == irc.nick:
del self.channels[channel]
else:
chan.removeUser(msg.nick)
def doKick(self, irc, msg):
(channel, users) = msg.args[:2]
chan = self.channels[channel]
for user in users.split(','):
chan.removeUser(user)
def doQuit(self, irc, msg):
for channel in self.channels.itervalues():
channel.removeUser(msg.nick)
2004-08-19 22:32:07 +02:00
if msg.nick in self.nicksToHostmasks:
# If we're quitting, it may not be.
del self.nicksToHostmasks[msg.nick]
def doTopic(self, irc, msg):
if len(msg.args) == 1:
return # Empty TOPIC for information. Does not affect state.
try:
chan = self.channels[msg.args[0]]
chan.topic = msg.args[1]
except KeyError:
pass # We don't have to be in a channel to send a TOPIC.
def do332(self, irc, msg):
chan = self.channels[msg.args[1]]
chan.topic = msg.args[2]
def doNick(self, irc, msg):
2003-08-12 21:12:12 +02:00
newNick = msg.args[0]
oldNick = msg.nick
try:
if msg.user and msg.host:
# Nick messages being handed out from the bot itself won't
# have the necessary prefix to make a hostmask.
newHostmask = ircutils.joinHostmask(newNick,msg.user,msg.host)
self.nicksToHostmasks[newNick] = newHostmask
del self.nicksToHostmasks[oldNick]
except KeyError:
pass
for channel in self.channels.itervalues():
channel.replaceUser(oldNick, newNick)
2003-03-12 07:26:59 +01:00
###
# The basic class for handling a connection to an IRC server. Accepts
# callbacks of the IrcCallback interface. Public attributes include 'driver',
# 'queue', and 'state', in addition to the standard nick/user/ident attributes.
###
_callbacks = []
class Irc(IrcCommandDispatcher):
2003-03-12 07:26:59 +01:00
"""The base class for an IRC connection.
Handles PING commands already.
"""
__metaclass__ = log.MetaFirewall
__firewalled__ = {'die': None,
'feedMsg': None,
'takeMsg': None,}
2003-07-31 08:20:58 +02:00
_nickSetters = sets.Set(['001', '002', '003', '004', '250', '251', '252',
'254', '255', '265', '266', '372', '375', '376',
2003-11-25 12:53:09 +01:00
'333', '353', '332', '366', '005'])
# We specifically want these callbacks to be common between all Ircs,
# that's why we don't do the normal None default with a check.
def __init__(self, network, callbacks=_callbacks):
2004-08-19 22:32:07 +02:00
self.zombie = False
2003-03-12 07:26:59 +01:00
world.ircs.append(self)
self.network = network
self.callbacks = callbacks
2003-03-12 07:26:59 +01:00
self.state = IrcState()
self.queue = IrcMsgQueue()
self.fastqueue = smallqueue()
2003-03-12 07:26:59 +01:00
self.driver = None # The driver should set this later.
self._setNonResettingVariables()
self._queueConnectMessages()
self.startedSync = ircutils.IrcDict()
2003-03-12 07:26:59 +01:00
def isChannel(self, s):
"""Helper function to check whether a given string is a channel on
the network this Irc object is connected to."""
kw = {}
if 'chantypes' in self.state.supported:
kw['chantypes'] = self.state.supported['chantypes']
if 'channellen' in self.state.supported:
kw['channellen'] = self.state.supported['channellen']
return ircutils.isChannel(s, **kw)
def isNick(self, s):
kw = {}
if 'nicklen' in self.state.supported:
kw['nicklen'] = self.state.supported['nicklen']
return ircutils.isNick(s, **kw)
2004-04-18 02:38:54 +02:00
# This *isn't* threadsafe!
2003-03-12 07:26:59 +01:00
def addCallback(self, callback):
2003-10-04 14:17:31 +02:00
"""Adds a callback to the callbacks list."""
2003-03-12 07:26:59 +01:00
self.callbacks.append(callback)
# This is the new list we're building, which will be tsorted.
cbs = []
# The vertices are self.callbacks itself. Now we make the edges.
edges = sets.Set()
for cb in self.callbacks:
(before, after) = cb.callPrecedence(self)
assert cb not in after, 'cb was in its own after.'
assert cb not in before, 'cb was in its own before.'
for otherCb in before:
edges.add((otherCb, cb))
for otherCb in after:
edges.add((cb, otherCb))
def getFirsts():
firsts = sets.Set(self.callbacks) - sets.Set(cbs)
for (before, after) in edges:
firsts.discard(after)
return firsts
firsts = getFirsts()
while firsts:
# Then we add these to our list of cbs, and remove all edges that
# originate with these cbs.
for cb in firsts:
cbs.append(cb)
edgesToRemove = []
for edge in edges:
if edge[0] is cb:
edgesToRemove.append(edge)
for edge in edgesToRemove:
edges.remove(edge)
firsts = getFirsts()
assert len(cbs) == len(self.callbacks), \
'cbs: %s, self.callbacks: %s' % (cbs, self.callbacks)
self.callbacks[:] = cbs
2003-03-12 07:26:59 +01:00
2003-06-06 06:47:18 +02:00
def getCallback(self, name):
2003-10-04 14:17:31 +02:00
"""Gets a given callback by name."""
2003-07-30 13:04:29 +02:00
name = name.lower()
2003-06-06 06:47:18 +02:00
for callback in self.callbacks:
2003-07-30 13:04:29 +02:00
if callback.name().lower() == name:
2003-06-06 06:47:18 +02:00
return callback
else:
return None
2003-03-12 07:26:59 +01:00
def removeCallback(self, name):
2003-10-04 14:17:31 +02:00
"""Removes a callback from the callback list."""
name = name.lower()
def nameMatches(cb):
return cb.name().lower() == name
(bad, good) = partition(nameMatches, self.callbacks)
2003-04-20 19:18:34 +02:00
self.callbacks[:] = good
return bad
2003-03-12 07:26:59 +01:00
def queueMsg(self, msg):
2003-10-04 14:17:31 +02:00
"""Queues a message to be sent to the server."""
2004-08-19 22:32:07 +02:00
if not self.zombie:
return self.queue.enqueue(msg)
2004-08-19 22:32:07 +02:00
else:
log.warning('Refusing to queue %r; %s is a zombie.', msg, self)
return False
2003-03-12 07:26:59 +01:00
def sendMsg(self, msg):
2003-10-04 14:17:31 +02:00
"""Queues a message to be sent to the server *immediately*"""
2004-08-19 22:32:07 +02:00
if not self.zombie:
self.fastqueue.enqueue(msg)
else:
2004-08-29 07:45:28 +02:00
log.warning('Refusing to send %r; %s is a zombie.', self, msg)
2003-03-12 07:26:59 +01:00
def takeMsg(self):
2003-10-04 14:17:31 +02:00
"""Called by the IrcDriver; takes a message to be sent."""
if not self.callbacks:
log.critical('No callbacks in %s.', self)
2003-03-12 07:26:59 +01:00
now = time.time()
msg = None
if self.fastqueue:
2003-04-02 11:26:16 +02:00
msg = self.fastqueue.dequeue()
elif self.queue:
if now-self.lastTake <= conf.supybot.protocols.irc.throttleTime():
log.debug('Irc.takeMsg throttling.')
2003-03-12 07:26:59 +01:00
else:
self.lastTake = now
msg = self.queue.dequeue()
2004-04-30 01:33:31 +02:00
elif self.afterConnect and \
conf.supybot.protocols.irc.ping() and \
now > self.lastping + conf.supybot.protocols.irc.ping.interval():
if self.outstandingPing:
log.warning('Ping sent at %s not replied to.',
log.timestamp(self.lastping))
self.driver.reconnect()
2003-03-12 07:26:59 +01:00
else:
self.lastping = now
now = str(int(now))
self.outstandingPing = True
self.queueMsg(ircmsgs.ping(now))
2003-03-12 07:26:59 +01:00
if msg:
2004-04-20 11:51:20 +02:00
for callback in reversed(self.callbacks):
msg = callback.outFilter(self, msg)
if msg is None:
log.debug('%s.outFilter returned None.' % callback.name())
return self.takeMsg()
2004-04-30 01:33:31 +02:00
world.debugFlush()
if len(str(msg)) > 512:
# Yes, this violates the contract, but at this point it doesn't
# matter. That's why we gotta go munging in private attributes
2004-10-12 13:40:56 +02:00
log.warning('Truncating %r, message is too long.', msg)
msg._str = msg._str[:500] + '\r\n'
msg._len = len(str(msg))
# I don't think we should do this. Why should it matter? If it's
# something important, then the server will send it back to us,
# and if it's just a privmsg/notice/etc., we don't care.
# self.state.addMsg(self, msg)
log.debug('Outgoing message: ' + str(msg).rstrip('\r\n'))
if msg.command == 'JOIN':
channels = msg.args[0].split(',')
for channel in channels:
# Let's make this more accurate.
self.startedSync[channel] = time.time()
2003-03-12 07:26:59 +01:00
return msg
elif self.zombie:
# We kill the driver here so it doesn't continue to try to
# take messages from us.
self.driver.die()
self._reallyDie()
2003-03-12 07:26:59 +01:00
else:
return None
2003-03-12 07:26:59 +01:00
def feedMsg(self, msg):
"""Called by the IrcDriver; feeds a message received."""
msg.tag('receivedBy', self)
msg.tag('receivedOn', self.network)
log.debug('Incoming message: ' + str(msg).rstrip('\r\n'))
# Yeah, so this is odd. Some networks (oftc) seem to give us certain
# messages with our nick instead of our prefix. We'll fix that here.
if msg.prefix == self.nick:
log.debug('Got one of those odd nick-instead-of-prefix msgs.')
msg = ircmsgs.IrcMsg(prefix=self.prefix, msg=msg)
# This catches cases where we know our own nick (from sending it to the
# server) but we don't yet know our prefix.
if msg.nick == self.nick and self.prefix != msg.prefix:
self.prefix = msg.prefix
# This keeps our nick and server attributes updated.
if msg.command in self._nickSetters:
if msg.args[0] != self.nick:
self.nick = msg.args[0]
log.debug('Updating nick attribute to %s.', self.nick)
if msg.prefix != self.server:
self.server = msg.prefix
log.debug('Updating server attribute to %s.')
# Dispatch to specific handlers for commands.
method = self.dispatchCommand(msg.command)
if method is not None:
method(msg)
# Now update the IrcState object.
try:
self.state.addMsg(self, msg)
except:
log.exception('Exception in update of IrcState object:')
# Now call the callbacks.
world.debugFlush()
for callback in self.callbacks:
try:
m = callback.inFilter(self, msg)
if not m:
log.debug('%s.inFilter returned None' % callback.name())
return
msg = m
except:
log.exception('Uncaught exception in inFilter:')
world.debugFlush()
for callback in self.callbacks:
try:
if callback is not None:
callback(self, msg)
except:
log.exception('Uncaught exception in callback:')
world.debugFlush()
def die(self):
"""Makes the Irc object *promise* to die -- but it won't die (of its
own volition) until all its queues are clear. Isn't that cool?"""
self.zombie = True
if not self.afterConnect:
self._reallyDie()
# This is useless because it's in world.ircs, so it won't be deleted until
# the program exits. Just figured you might want to know.
#def __del__(self):
# self._reallyDie()
def reset(self):
"""Resets the Irc object. Called when the driver reconnects."""
self._setNonResettingVariables()
self.state.reset()
self.queue.reset()
self.fastqueue.reset()
self.startedSync.clear()
for callback in self.callbacks:
callback.reset()
self._queueConnectMessages()
def _setNonResettingVariables(self):
# Configuration stuff.
self.nick = conf.supybot.nick()
self.user = conf.supybot.user()
self.ident = conf.supybot.ident()
self.alternateNicks = conf.supybot.nick.alternates()[:]
self.password = conf.supybot.networks.get(self.network).password()
self.prefix = '%s!%s@%s' % (self.nick, self.ident, 'unset.domain')
# The rest.
self.lastTake = 0
self.server = 'unset'
self.afterConnect = False
self.lastping = time.time()
self.outstandingPing = False
def _queueConnectMessages(self):
if self.zombie:
self.driver.die()
self._reallyDie()
else:
if self.password:
log.info('Sending PASS command, not logging the password.')
self.queueMsg(ircmsgs.password(self.password))
log.debug('Queuing NICK command, nick is %s.', self.nick)
self.queueMsg(ircmsgs.nick(self.nick))
log.debug('Queuing USER command, ident is %s, user is %s.',
self.ident, self.user)
self.queueMsg(ircmsgs.user(self.ident, self.user))
def _getNextNick(self):
if self.alternateNicks:
nick = self.alternateNicks.pop(0)
if '%s' in nick:
nick %= conf.supybot.nick()
return nick
else:
nick = conf.supybot.nick()
ret = nick
L = list(nick)
while len(L) <= 3:
L.append('`')
while ret == nick:
L[random.randrange(len(L))] = random.choice('0123456789')
ret = ''.join(L)
return ret
2004-01-01 21:12:01 +01:00
def do002(self, msg):
"""Logs the ircd version."""
(beginning, version) = rsplit(msg.args[-1], maxsplit=1)
2004-01-01 21:12:01 +01:00
log.info('Server %s has version %s', self.server, version)
2003-12-02 12:40:46 +01:00
def doPing(self, msg):
"""Handles PING messages."""
self.sendMsg(ircmsgs.pong(msg.args[0]))
def doPong(self, msg):
"""Handles PONG messages."""
self.outstandingPing = False
def do376(self, msg):
log.info('Got end of MOTD from %s', self.server)
2003-12-12 13:47:23 +01:00
self.afterConnect = True
# Let's reset nicks in case we had to use a weird one.
self.alternateNicks = conf.supybot.nick.alternates()[:]
umodes = conf.supybot.protocols.irc.umodes()
if umodes:
2004-08-30 08:58:47 +02:00
if umodes[0] not in '+-':
umodes = '+' + umodes
log.info('Sending user modes to %s: %s', self.network, umodes)
self.sendMsg(ircmsgs.mode(self.nick, umodes))
2003-12-12 13:47:23 +01:00
do377 = do422 = do376
def do433(self, msg):
"""Handles 'nickname already in use' messages."""
if not self.afterConnect:
newNick = self._getNextNick()
assert newNick != self.nick
log.info('Got 433: %s is in use. Trying %s.', self.nick, newNick)
self.sendMsg(ircmsgs.nick(newNick))
do432 = do433 # 432: Erroneous nickname.
def doJoin(self, msg):
if msg.nick == self.nick:
channel = msg.args[0]
self.queueMsg(ircmsgs.who(channel)) # Ends with 315.
self.queueMsg(ircmsgs.mode(channel)) # Ends with 329.
self.startedSync[channel] = time.time()
def do315(self, msg):
channel = msg.args[1]
popped = False
if channel in self.startedSync:
now = time.time()
started = self.startedSync.pop(channel)
elapsed = now - started
2004-09-16 18:20:58 +02:00
log.info('Join to %s on %s synced in %.2f seconds.',
channel, self.network, elapsed)
popped = True
if popped and not self.startedSync:
2004-09-24 16:37:24 +02:00
log.info('All channels synced on %s.', self.network)
def doError(self, msg):
"""Handles ERROR messages."""
2004-09-09 20:58:56 +02:00
log.info('Error message from %s: %s', self.network, msg.args[0])
2004-08-20 06:37:18 +02:00
if not self.zombie:
if msg.args[0].startswith('Closing Link'):
self.driver.reconnect()
elif 'too fast' in msg.args[0]:
self.driver.reconnect(wait=True)
def doNick(self, msg):
"""Handles NICK messages."""
if msg.nick == self.nick:
2004-07-31 00:35:51 +02:00
newNick = msg.args[0]
self.nick = newNick
(nick, user, domain) = ircutils.splitHostmask(msg.prefix)
self.prefix = ircutils.joinHostmask(self.nick, user, domain)
2004-01-18 08:58:26 +01:00
elif conf.supybot.followIdentificationThroughNickChanges():
2004-01-01 21:12:01 +01:00
# We use elif here because this means it's someone else's nick
# change, not our own.
try:
id = ircdb.users.getUserId(msg.prefix)
u = ircdb.users.getUser(id)
except KeyError:
return
if u.auth:
(_, user, host) = ircutils.splitHostmask(msg.prefix)
newhostmask = ircutils.joinHostmask(msg.args[0], user, host)
for (i, (when, authmask)) in enumerate(u.auth[:]):
if ircutils.strEqual(msg.prefix, authmask):
log.info('Following identification for %s: %s -> %s',
u.name, authmask, newhostmask)
u.auth[i] = (u.auth[i][0], newhostmask)
ircdb.users.setUser(id, u)
2004-08-19 22:32:07 +02:00
def _reallyDie(self):
2003-10-04 14:17:31 +02:00
"""Makes the Irc object die. Dead."""
2004-08-29 07:45:28 +02:00
log.info('Irc object for %s dying.' % self.network)
2003-08-23 12:59:28 +02:00
if self in world.ircs:
world.ircs.remove(self)
# Only kill the callbacks if we're the last Irc.
if not world.ircs:
for cb in self.callbacks:
cb.die()
# If we shared our list of callbacks, this ensures that
# cb.die() is only called once for each callback. It's
# not really necessary since we already check to make sure
# we're the only Irc object, but a little robustitude never
# hurt anybody.
log.debug('Last Irc, clearing callbacks.')
self.callbacks[:] = []
2004-01-27 12:15:56 +01:00
else:
log.warning('Irc object killed twice: %s', utils.stackTrace())
def __hash__(self):
return id(self)
def __eq__(self, other):
return id(self) == id(other)
def __ne__(self, other):
return not (self == other)
2004-01-08 01:47:48 +01:00
def __str__(self):
2004-07-29 09:05:46 +02:00
return 'Irc object for %s' % self.network
2004-01-08 01:47:48 +01:00
2004-07-29 20:28:43 +02:00
def __repr__(self):
return '<irclib.Irc object for %s>' % self.network
# vim:set shiftwidth=4 tabstop=8 expandtab textwidth=78: