mirror of
https://github.com/Mikaela/Limnoria.git
synced 2024-12-26 04:32:51 +01:00
833af36b08
Starting with this commit, there should be no "original" text in READMEs. Instead, the entire text should be in docstrings, and READMEs should be automatically generated from these docstrings. Motivation: * The same help is available both via IRC and in the README (although the README can be more detailed, as only the first paragraph will be shown on IRC) * This will allow auto-generating plugin help on docs.limnoria.net using the same content as the README, as it's sourced from the docstrings Additionally, this converts all READMEs from Markdown to ReST, because the documentation already uses ReST, and other docstrings in the codebase are in ReST for this reason.
463 lines
18 KiB
Python
463 lines
18 KiB
Python
###
|
|
# Copyright (c) 2002-2004, Jeremiah Fincher
|
|
# Copyright (c) 2010,2015 James McCoy
|
|
# 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.
|
|
###
|
|
|
|
import time
|
|
|
|
import supybot.conf as conf
|
|
import supybot.utils as utils
|
|
import supybot.world as world
|
|
from supybot.commands import *
|
|
import supybot.irclib as irclib
|
|
import supybot.ircmsgs as ircmsgs
|
|
import supybot.ircutils as ircutils
|
|
import supybot.callbacks as callbacks
|
|
from supybot.utils.structures import MultiSet, TimeoutQueue
|
|
from supybot.i18n import PluginInternationalization, internationalizeDocstring
|
|
_ = PluginInternationalization('Relay')
|
|
|
|
class Relay(callbacks.Plugin):
|
|
"""
|
|
This plugin allows you to setup a relay between networks.
|
|
|
|
Note that you must tell the bot to join the channel you wish to relay on
|
|
all networks with the ``join`` command or
|
|
``network command <network> join <channel>``
|
|
or to join the channel on all networks ``network cmdall join <channel>``.
|
|
|
|
There are several advanced alternatives to this plugin, available as
|
|
third-party plugins. You can check them out at
|
|
https://limnoria.net/plugins.xhtml#messaging
|
|
"""
|
|
noIgnore = True
|
|
def __init__(self, irc):
|
|
self.__parent = super(Relay, self)
|
|
self.__parent.__init__(irc)
|
|
self._whois = {}
|
|
self.queuedTopics = MultiSet()
|
|
self.lastRelayMsgs = ircutils.IrcDict()
|
|
|
|
def do376(self, irc, msg):
|
|
networkGroup = conf.supybot.networks.get(irc.network)
|
|
for channel in self.registryValue('channels'):
|
|
if self.registryValue('channels.joinOnAllNetworks', channel):
|
|
if channel not in irc.state.channels:
|
|
irc.queueMsg(networkGroup.channels.join(channel))
|
|
do377 = do422 = do376
|
|
|
|
def _getRealIrc(self, irc):
|
|
if isinstance(irc, irclib.Irc):
|
|
return irc
|
|
else:
|
|
return irc.getRealIrc()
|
|
|
|
def _getIrcName(self, irc):
|
|
# We should allow abbreviations at some point.
|
|
return irc.network
|
|
|
|
@internationalizeDocstring
|
|
def join(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Starts relaying between the channel <channel> on all networks. If on a
|
|
network the bot isn't in <channel>, it'll join. This commands is
|
|
required even if the bot is in the channel on both networks; it won't
|
|
relay between those channels unless it's told to join both
|
|
channels. If <channel> is not given, starts relaying on the channel
|
|
the message was sent in.
|
|
"""
|
|
self.registryValue('channels').add(channel)
|
|
for otherIrc in world.ircs:
|
|
if channel not in otherIrc.state.channels:
|
|
networkGroup = conf.supybot.networks.get(otherIrc.network)
|
|
otherIrc.queueMsg(networkGroup.channels.join(channel))
|
|
irc.replySuccess()
|
|
join = wrap(join, ['channel', 'admin'])
|
|
|
|
@internationalizeDocstring
|
|
def part(self, irc, msg, args, channel):
|
|
"""<channel>
|
|
|
|
Ceases relaying between the channel <channel> on all networks. The bot
|
|
will part from the channel on all networks in which it is on the
|
|
channel.
|
|
"""
|
|
self.registryValue('channels').discard(channel)
|
|
for otherIrc in world.ircs:
|
|
if channel in otherIrc.state.channels:
|
|
otherIrc.queueMsg(ircmsgs.part(channel))
|
|
irc.replySuccess()
|
|
part = wrap(part, ['channel', 'admin'])
|
|
|
|
@internationalizeDocstring
|
|
def nicks(self, irc, msg, args, channel):
|
|
"""[<channel>]
|
|
|
|
Returns the nicks of the people in the channel on the various networks
|
|
the bot is connected to. <channel> is only necessary if the message
|
|
isn't sent on the channel itself.
|
|
"""
|
|
realIrc = self._getRealIrc(irc)
|
|
if channel not in self.registryValue('channels'):
|
|
irc.error(format('I\'m not relaying in %s.', channel))
|
|
return
|
|
users = []
|
|
for otherIrc in world.ircs:
|
|
network = self._getIrcName(otherIrc)
|
|
ops = []
|
|
halfops = []
|
|
voices = []
|
|
usersS = []
|
|
if network != self._getIrcName(realIrc):
|
|
try:
|
|
Channel = otherIrc.state.channels[channel]
|
|
except KeyError:
|
|
users.append(format('(not in %s on %s)',channel,network))
|
|
continue
|
|
numUsers = 0
|
|
for s in Channel.users:
|
|
s = s.strip()
|
|
if not s:
|
|
continue
|
|
numUsers += 1
|
|
if s in Channel.ops:
|
|
ops.append('@' + s)
|
|
elif s in Channel.halfops:
|
|
halfops.append('%' + s)
|
|
elif s in Channel.voices:
|
|
voices.append('+' + s)
|
|
else:
|
|
usersS.append(s)
|
|
utils.sortBy(ircutils.toLower, ops)
|
|
utils.sortBy(ircutils.toLower, voices)
|
|
utils.sortBy(ircutils.toLower, halfops)
|
|
utils.sortBy(ircutils.toLower, usersS)
|
|
usersS = ', '.join(filter(None, list(map(', '.join,
|
|
(ops,halfops,voices,usersS)))))
|
|
users.append(format('%s (%i): %s',
|
|
ircutils.bold(network), numUsers, usersS))
|
|
users.sort()
|
|
irc.reply('; '.join(users))
|
|
nicks = wrap(nicks, ['channel'])
|
|
|
|
def do311(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
nick = ircutils.toLower(msg.args[1])
|
|
if (irc, nick) not in self._whois:
|
|
return
|
|
else:
|
|
self._whois[(irc, nick)][-1][msg.command] = msg
|
|
|
|
# These are all sent by a WHOIS response.
|
|
do301 = do311
|
|
do312 = do311
|
|
do317 = do311
|
|
do319 = do311
|
|
do320 = do311
|
|
|
|
def do318(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
nick = msg.args[1]
|
|
loweredNick = ircutils.toLower(nick)
|
|
if (irc, loweredNick) not in self._whois:
|
|
return
|
|
(replyIrc, replyMsg, d) = self._whois[(irc, loweredNick)]
|
|
d['318'] = msg
|
|
s = ircutils.formatWhois(irc, d, caller=replyMsg.nick,
|
|
channel=replyMsg.args[0])
|
|
replyIrc.reply(s)
|
|
del self._whois[(irc, loweredNick)]
|
|
|
|
def do402(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
nick = msg.args[1]
|
|
loweredNick = ircutils.toLower(nick)
|
|
if (irc, loweredNick) not in self._whois:
|
|
return
|
|
(replyIrc, replyMsg, d) = self._whois[(irc, loweredNick)]
|
|
del self._whois[(irc, loweredNick)]
|
|
s = format(_('There is no %s on %s.'), nick, self._getIrcName(irc))
|
|
replyIrc.reply(s)
|
|
|
|
do401 = do402
|
|
|
|
def _formatPrivmsg(self, nick, network, msg):
|
|
channel = msg.channel
|
|
if self.registryValue('includeNetwork', channel):
|
|
network = '@' + network
|
|
else:
|
|
network = ''
|
|
# colorize nicks
|
|
color = self.registryValue('color', channel) # Also used further down.
|
|
if color:
|
|
nick = ircutils.IrcString(nick)
|
|
newnick = ircutils.mircColor(nick, *ircutils.canonicalColor(nick))
|
|
colors = ircutils.canonicalColor(nick, shift=4)
|
|
nick = newnick
|
|
if ircmsgs.isAction(msg):
|
|
if color:
|
|
t = ircutils.mircColor('*', *colors)
|
|
else:
|
|
t = '*'
|
|
s = format('%s %s%s %s', t, nick, network, ircmsgs.unAction(msg))
|
|
else:
|
|
if color:
|
|
lt = ircutils.mircColor('<', *colors)
|
|
gt = ircutils.mircColor('>', *colors)
|
|
else:
|
|
lt = '<'
|
|
gt = '>'
|
|
s = format('%s%s%s%s %s', lt, nick, network, gt, msg.args[1])
|
|
return s
|
|
|
|
def _sendToOthers(self, irc, msg):
|
|
assert msg.command in ('PRIVMSG', 'NOTICE', 'TOPIC')
|
|
for otherIrc in world.ircs:
|
|
if otherIrc != irc and not otherIrc.zombie:
|
|
if msg.channel in otherIrc.state.channels:
|
|
msg.tag('relayedMsg')
|
|
otherIrc.queueMsg(msg)
|
|
|
|
def _checkRelayMsg(self, msg):
|
|
channel = msg.channel
|
|
if channel in self.lastRelayMsgs:
|
|
q = self.lastRelayMsgs[channel]
|
|
unformatted = ircutils.stripFormatting(msg.args[1])
|
|
normalized = utils.str.normalizeWhitespace(unformatted)
|
|
for s in q:
|
|
if s in normalized:
|
|
return True
|
|
return False
|
|
|
|
def _punishRelayers(self, msg):
|
|
assert self._checkRelayMsg(msg), 'Punishing without checking.'
|
|
who = msg.prefix
|
|
channel = msg.channel
|
|
def notPunishing(irc, s, *args):
|
|
self.log.info('Not punishing %s in %s on %s: %s.',
|
|
msg.prefix, channel, irc.network, s, *args)
|
|
for irc in world.ircs:
|
|
if channel in irc.state.channels:
|
|
if irc.nick in irc.state.channels[channel].ops:
|
|
if who in irc.state.channels[channel].bans:
|
|
notPunishing(irc, 'already banned')
|
|
else:
|
|
self.log.info('Punishing %s in %s on %s for relaying.',
|
|
who, channel, irc.network)
|
|
irc.sendMsg(ircmsgs.ban(channel, who))
|
|
kmsg = _('You seem to be relaying, punk.')
|
|
irc.sendMsg(ircmsgs.kick(channel, msg.nick, kmsg))
|
|
else:
|
|
notPunishing(irc, 'not opped')
|
|
|
|
def doPrivmsg(self, irc, msg):
|
|
if ircmsgs.isCtcp(msg) and not ircmsgs.isAction(msg):
|
|
return
|
|
text = msg.args[1]
|
|
if msg.channel:
|
|
irc = self._getRealIrc(irc)
|
|
if msg.channel not in self.registryValue('channels'):
|
|
return
|
|
ignores = self.registryValue('ignores', msg.channel, irc.network)
|
|
for ignore in ignores:
|
|
if ircutils.hostmaskPatternEqual(ignore, msg.prefix):
|
|
self.log.debug('Refusing to relay %s, ignored by %s.',
|
|
msg.prefix, ignore)
|
|
return
|
|
# Let's try to detect other relay bots.
|
|
if self._checkRelayMsg(msg):
|
|
if self.registryValue('punishOtherRelayBots',
|
|
msg.channel, irc.network):
|
|
self._punishRelayers(msg)
|
|
# Either way, we don't relay the message.
|
|
else:
|
|
self.log.warning('Refusing to relay message from %s, '
|
|
'it appears to be a relay message.',
|
|
msg.prefix)
|
|
else:
|
|
network = self._getIrcName(irc)
|
|
s = self._formatPrivmsg(msg.nick, network, msg)
|
|
m = self._msgmaker(msg.channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def _msgmaker(self, target, network, s):
|
|
msg = dynamic.msg
|
|
if self.registryValue('noticeNonPrivmsgs', target, network) and \
|
|
msg.command != 'PRIVMSG':
|
|
m = ircmsgs.notice(target, s)
|
|
else:
|
|
m = ircmsgs.privmsg(target, s)
|
|
|
|
m.channel = target
|
|
|
|
return m
|
|
|
|
def doJoin(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
channel = msg.args[0]
|
|
if channel not in self.registryValue('channels'):
|
|
return
|
|
network = self._getIrcName(irc)
|
|
if self.registryValue('hostmasks', channel):
|
|
hostmask = format(' (%s)', msg.prefix.split('!')[1])
|
|
else:
|
|
hostmask = ''
|
|
s = format(_('%s%s has joined on %s'), msg.nick, hostmask, network)
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doPart(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
channel = msg.args[0]
|
|
if channel not in self.registryValue('channels'):
|
|
return
|
|
network = self._getIrcName(irc)
|
|
if self.registryValue('hostmasks', channel):
|
|
hostmask = format(' (%s)', msg.prefix.split('!')[1])
|
|
else:
|
|
hostmask = ''
|
|
if len(msg.args) > 1:
|
|
s = format(_('%s%s has left on %s (%s)'),
|
|
msg.nick, hostmask, network, msg.args[1])
|
|
else:
|
|
s = format(_('%s%s has left on %s'), msg.nick, hostmask, network)
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doMode(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
channel = msg.args[0]
|
|
if channel not in self.registryValue('channels'):
|
|
return
|
|
network = self._getIrcName(irc)
|
|
s = format(_('mode change by %s on %s: %s'),
|
|
msg.nick, network, ' '.join(msg.args[1:]))
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doKick(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
channel = msg.args[0]
|
|
if channel not in self.registryValue('channels'):
|
|
return
|
|
network = self._getIrcName(irc)
|
|
if len(msg.args) == 3:
|
|
s = format(_('%s was kicked by %s on %s (%s)'),
|
|
msg.args[1], msg.nick, network, msg.args[2])
|
|
else:
|
|
s = format(_('%s was kicked by %s on %s'),
|
|
msg.args[1], msg.nick, network)
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doNick(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
newNick = msg.args[0]
|
|
network = self._getIrcName(irc)
|
|
s = format(_('nick change by %s to %s on %s'), msg.nick,newNick,network)
|
|
for channel in self.registryValue('channels'):
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doTopic(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
(channel, newTopic) = msg.args
|
|
if channel not in self.registryValue('channels'):
|
|
return
|
|
network = self._getIrcName(irc)
|
|
if self.registryValue('topicSync', channel):
|
|
m = ircmsgs.topic(channel, newTopic)
|
|
for otherIrc in world.ircs:
|
|
if irc != otherIrc:
|
|
try:
|
|
if otherIrc.state.getTopic(channel) != newTopic:
|
|
if (otherIrc, newTopic) not in self.queuedTopics:
|
|
self.queuedTopics.add((otherIrc, newTopic))
|
|
otherIrc.queueMsg(m)
|
|
else:
|
|
self.queuedTopics.remove((otherIrc, newTopic))
|
|
|
|
except KeyError:
|
|
self.log.warning('Not on %s on %s, '
|
|
'can\'t sync topics.',
|
|
channel, otherIrc.network)
|
|
else:
|
|
s = format(_('topic change by %s on %s: %s'),
|
|
msg.nick, network, newTopic)
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doQuit(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
network = self._getIrcName(irc)
|
|
if msg.args:
|
|
s = format(_('%s has quit %s (%s)'), msg.nick, network, msg.args[0])
|
|
else:
|
|
s = format(_('%s has quit %s.'), msg.nick, network)
|
|
for channel in self.registryValue('channels'):
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def doError(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
network = self._getIrcName(irc)
|
|
s = format(_('disconnected from %s: %s'), network, msg.args[0])
|
|
for channel in self.registryValue('channels'):
|
|
m = self._msgmaker(channel, network, s)
|
|
self._sendToOthers(irc, m)
|
|
|
|
def outFilter(self, irc, msg):
|
|
irc = self._getRealIrc(irc)
|
|
if msg.command == 'PRIVMSG':
|
|
if msg.relayedMsg:
|
|
self._addRelayMsg(msg)
|
|
else:
|
|
if msg.channel in self.registryValue('channels'):
|
|
network = self._getIrcName(irc)
|
|
s = self._formatPrivmsg(irc.nick, network, msg)
|
|
relayMsg = self._msgmaker(msg.args[0], network, s)
|
|
self._sendToOthers(irc, relayMsg)
|
|
return msg
|
|
|
|
def _addRelayMsg(self, msg):
|
|
channel = msg.channel
|
|
if channel in self.lastRelayMsgs:
|
|
q = self.lastRelayMsgs[channel]
|
|
else:
|
|
q = TimeoutQueue(60) # XXX Make this configurable.
|
|
self.lastRelayMsgs[channel] = q
|
|
unformatted = ircutils.stripFormatting(msg.args[1])
|
|
normalized = utils.str.normalizeWhitespace(unformatted)
|
|
q.enqueue(normalized)
|
|
|
|
|
|
Class = Relay
|
|
|
|
# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
|