]*>\s*

(.*?)

.*?]*>(.*?)', + re.S) + +class BrainyQuote(CommandPlugin): + help = "Get the Quote of the Moment from brainyquote.com." + + @command(synonyms=("brainy quote", "brainyquote")) + def cmd_quote(self, msg, arg): + def extract_quote(data): + quote, author = map(str.strip, QURE.search(data).groups()) + hp = HTMLParser() + msg.reply("Quote of the moment: {} -- {}".format( + hp.unescape(quote), hp.unescape(author))) + + getPage("http://www.brainyquote.com/").addCallbacks(extract_quote, + msg.unhandled) diff -Nru endroid-1.1.2/src/endroid/plugins/broadcast.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/broadcast.py --- endroid-1.1.2/src/endroid/plugins/broadcast.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/broadcast.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,171 @@ +from endroid.plugins.command import CommandPlugin +from endroid.database import Database +import logging + + +DB_NAME = "BROADCAST" +DB_TABLE = "BROADCAST" + + +class Levels(object): + NONE = "none" + ALL = "all" + POSITIVE = "positive" + MAX = "max" + + @classmethod + def __contains__(cls, key): + return key in (cls.NONE, cls.ALL, cls.POSITIVE, cls.MAX) + + +class Broadcast(CommandPlugin): + """ + This plugin partially solves the problem with XMPP that if a user is logged + in on multiple devices (resources) then messages sent by EnDroid may not + arrive at all of them. + + When broadcasting is enabled by a user, any messages sent by EnDroid to them + will be intercepted and replaced by several identical messages sent + individually to a selection of their resources. + + Note: + - this plugin only applies to chat messages (room messages do not suffer + the same problem) + - the plugin may be configured to broadcast at levels: + - all: send to all the recipient's available resources + - positive: send to the recipient's available resources with priority >=0 + - max: send to the recipient's maximum priority resource + - none (default): disable broadcasting + + """ + help = "Plugin to enable the broadcasting of messages to all resources." + users = {} + + levels = Levels() + + ID = "broadcast_plugin" # this will be set as the source of sent messages + + def endroid_init(self): + self.register_chat_send_filter(self.do_broadcast) + self.db = Database(DB_NAME) + if not self.db.table_exists(DB_TABLE): + self.db.create_table(DB_TABLE, ('user', 'do_broadcast')) + + # make a local copy of the registration database + data = self.db.fetch(DB_TABLE, ['user', 'do_broadcast']) + for row in data: + self.users[row['user']] = row['do_broadcast'] + + def do_broadcast(self, msg): + sender = msg.sender + if sender == self.ID: # we sent this message + return True + + recipient = msg.recipient + recip_host = self.usermanagement.get_userhost(recipient) + + logging.debug("Broadcast got message {} -> {}".format(sender, recipient)) + # Check the broadcast level for recip_host (if they are not + # registered return levels.NONE). + level = self.users.get(recip_host, self.levels.NONE) + + if level == self.levels.NONE: + # we are not broadcasting to this user, let the original message + # through and do nothing + return True + else: + # we have some broadcasting to do + rs = self._get_resources(recip_host, level) + + sent_num = 0 + for resource in rs: + self.messagehandler.send_chat(resource, msg.body, self.ID) + sent_num += 1 + + fmt = "Broadcast '{}' sent {} messages to {}" + logging.debug(fmt.format(level, sent_num, recip_host)) + # drop the original message + return False + + + def cmd_set_broadcast(self, msg, arg): + """ + When this is called, messages EnDroid sends will be sent to _all_ + the user's available resources. + + """ + level = arg.split()[0] + level = level if level in self.levels else self.levels.ALL + # this will be broadcasted + msg.reply("Setting broadcast level '{}'.".format(level)) + if not msg.sender in self.users: + self._register_user(msg.sender, level=level) + else: + self._update_user(msg.sender, level=level) + # this may not be broadcasted, depending on what level has been set to + msg.reply("Set broadcast level '{}'.".format(level)) + + cmd_set_broadcast.helphint = ("{all|positive|max|none} (all, positive, max " + "process resource priorities.") + + + def cmd_disable_broadcast(self, msg, arg): + """Disable broadcasting.""" + self.cmd_set_broadcast(msg, self.levels.NONE) + # msg.reply("Disabling broadcast.") + # if self.users[msg.sender]: + # self._update_user(msg.sender, level=self.levels.NONE) + # msg.reply("Disabled broadcast.") + + cmd_disable_broadcast.helphint = ("Equivalent to 'set broadcast none'.") + + def cmd_get_broadcast(self, msg, arg): + """Get broadcast level.""" + level = self.users.get(msg.sender, self.levels.NONE) + message = "Broadcast level '{}'".format(level) + if arg and arg.split()[0] in ("ls", "list"): + rs = self._get_resources(msg.sender, level) + message += ':' + msg.reply('\n'.join([message] + (rs or ["none"]))) + else: + message += '.' + msg.reply(message) + + cmd_get_broadcast.helphint = ("{ls|list}?") + + def cmd_get_resources(self, msg, arg): + """Return msg.sender's available resources. + + If arg is "broadcast", return those we are broadcasting to. + + """ + message = ["Available resources:"] + rs = self._get_resources(msg.sender) + msg.reply('\n'.join(message + (rs or ["none"]))) + + cmd_get_resources.helphint = ("Report all available resources.") + + def _register_user(self, user, level=levels.NONE): + self.db.insert(DB_TABLE, {'user' : user, 'do_broadcast' : level}) + self.users[user] = level + + def _update_user(self, user, level=levels.NONE): + self.db.update(DB_TABLE, {'do_broadcast' : level}, {'user' : user}) + self.users[user] = level + + def _get_resources(self, user, level=levels.ALL): + resources = self.usermanagement.resources(user) + addresses = [] + + if level == self.levels.ALL: + addresses = resources.keys() + elif level == self.levels.POSITIVE: + addresses = [j for j, r in resources.items() if r.priority >= 0] + elif level == self.levels.MAX: + # resources.items is a list of tuples of form: (jid : Resource) + # sort on Resource.priority + # this returns the tuple (jid : max_priority_resource) + # get just the jid by indexing with [0] + addresses = [max(resources.items(), key=lambda (j,r): r.priority)[0]] + + return addresses diff -Nru endroid-1.1.2/src/endroid/plugins/command.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/command.py --- endroid-1.1.2/src/endroid/plugins/command.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/command.py 2013-09-16 14:30:23.000000000 +0000 @@ -4,13 +4,13 @@ # Created by Jonathan Millican # ----------------------------------------- -import logging - +import functools from collections import namedtuple from endroid.pluginmanager import Plugin, PluginMeta __all__ = ( 'CommandPlugin', + 'command', ) # A single registration @@ -18,22 +18,113 @@ # - command is the original registered command (a str, or a tuple of strs) # - helphint is any additional help hint provided at registration time # - if hidden is True, then the command is not included in help output +# - plugin is the plugin that made the registration Registration = namedtuple('Registration', ('callback', 'command', 'helphint', - 'hidden')) + 'hidden', 'plugin')) # A set of handlers # - handlers is a list of the Registration objects for this subcommand # - subcommands is a dict of subcommand (simple str) to Handlers object Handlers = namedtuple('Handlers', ('handlers', 'subcommands')) +def command(wrapped=None, synonyms=(), helphint="", hidden=False, + chat_only=False, muc_only=False): + """ + Decorator used to mark command functions in subclasses of CommandPlugin. + + In it's simplest form, can be used to mark a function as a command: + + >>> class Foo(CommandPlugin): + ... @command + ... def foo_bar(self, msg, args): + ... do_stuff_here() + + This will register the command string ("foo", "bar") with the Command plugin + when the Foo plugin is initialised. + + The decorator also takes a series of optional keyword arguments to control + the behaviour of the registration: + + synonyms: sequence of synonyms (either strings, or sequences of strings) + helphint: a helpful hint to display in help for the command + hidden: whether the command is hidden in the help + chat_only: set to True if the command should only be registered in chat + muc_only: set to True if the command should only be registered in muc + + """ + def decorator(fn): + fn.is_command = True + fn.synonyms = synonyms + fn.helphint = helphint + fn.hidden = hidden + fn.chat_only = chat_only + fn.muc_only = muc_only + return fn + if wrapped is None: + return decorator + else: + return decorator(wrapped) + + +class _Topics(object): + """ + Descriptor to handle auto-updating of the help_topics. + + This is required if a plugin doesn't just define its help_topics at the + class level, and instead sets it during its initialisation. This descriptor + will update the help_topics instead of replacing them when set. + """ + def __get__(self, obj, type=None): + """ + As well as fetching the help_topics (from the _help_topics field), this + also injects the 'commands' entry into topics. It is done here, as this + is the first point at which we have an instance of the plugin (needed + to do the filtering later when displaying the help). + + Moral of the story: injecting methods is awkward. + """ + def _commands_help(topic): + com = obj.get('endroid.plugins.command') + return com._help_main(topic, plugin=obj) + if not 'commands' in obj._help_topics: + # This will call the __set__, below + setattr(obj, 'help_topics', {'commands': _commands_help}) + return obj._help_topics + + def __set__(self, obj, value): + """ + Takes a copy of the existing topics, updates the dict with the given + value, then sets it on the instance. + + Note that if someone attempts to set them on the class after class + creation, this will raise an exception. Which seems the sanest thing to + do, as updating the class topics after the fact is an odd thing to do. + """ + # We need to take a copy in case these are the class topics + topics = obj._help_topics.copy() + topics.update(value) + obj._help_topics = topics + +# We only ever need one instance of this class +_Topics = _Topics() + + class CommandPluginMeta(PluginMeta): """ Metaclass to support simple command-driven plugins. This should not be used directly, but rather by subclassing from CommandPlugin rather than Plugin. """ def __new__(meta, name, bases, dct): - cmds = dict((c, f) for c, f in dct.items() if c.startswith("cmd_")) + # We can also always add a default name here, so command can always + # assume there is one. + if 'name' not in dct: + dct['name'] = name.lower() + + cmds = dict((c, f) for c, f in dct.items() + if c.startswith("cmd_") or getattr(f, "is_command", False)) init = dct.get('endroid_init', lambda _: None) + # Make sure the new init function looks like the old one + @functools.wraps(init) def endroid_init(self): com = self.get('endroid.plugins.command') for cmd, fn in cmds.items(): @@ -43,25 +134,42 @@ reg_fn = com.register_muc else: reg_fn = com.register_both - reg_fn(getattr(self, cmd), cmd.split("_")[1:], + words = cmd.split("_") + # Handle a leading underscore (may be necessary in some cases) + if not words[0]: + words = words[1:] + if not getattr(fn, "is_command", False): + words = words[1:] + reg_fn(getattr(self, cmd), words, helphint=getattr(fn, "helphint", ""), hidden=getattr(fn, "hidden", False), - synonyms=getattr(fn, "synonyms", ())) + synonyms=getattr(fn, "synonyms", ()), + plugin=self) init(self) dct['endroid_init'] = endroid_init + + # We replace any class topics with the Descriptor, and always set at + # least an empty dict in the private _help_topics field + topics = dct.get('help_topics', {}) + dct['_help_topics'] = topics + dct['help_topics'] = _Topics + dct['dependencies'] = tuple(dct.get('dependencies', ()) + ('endroid.plugins.command',)) - return PluginMeta.__new__(meta, name, bases, dct) + return super(CommandPluginMeta, meta).__new__(meta, name, bases, dct) class CommandPlugin(Plugin): """ Parent class for simple command-driven plugins. Such plugins don't need to explicitly register their commands. Instead, they can just define methods - prefixed with "cmd_" and they will automatically be registered. Any - additional underscores in the method name will be converted to spaces in - the registration (so cmd_foo_bar is registered as ('foo', 'bar')). + prefixed with "cmd_" or decorated with the 'command' decorator, and they + will automatically be registered. Any additional underscores in the method + name will be converted to spaces in the registration (so cmd_foo_bar is + registered as ('foo', 'bar')). + + In addition, certain options can be passed by adding fields to the methods, + or as keyword arguments to the decorator: - In addition, certain options can be passed by adding fields to the methods: - hidden: don't show the command in help if set to True. - synonyms: an iterable of alternative keyword sequences to register the method against. All synonyms are hidden. @@ -83,52 +191,53 @@ def endroid_init(self): self._muc_handlers = Handlers([], {}) self._chat_handlers = Handlers([], {}) - self.register_muc_callback(self.command_muc) - self.register_chat_callback(self.command_chat) + self.messages.register(self._command_muc, muc_only=True) + self.messages.register(self._command_chat, chat_only=True) self.help_topics = { - '': self.help_main, - 'chat': self.help_chat, - 'muc': self.help_muc, + '': self._help_main, + 'chat': self._help_chat, + 'muc': self._help_muc, } # ------------------------------------------------------------------------- # Help methods - def help_add_regs(self, output, handlers): + def _help_add_regs(self, output, handlers, plugin=None): """ Add lines of help strings to the output list for each handler in the given Handlers object. Then recurses down all subcommands to get their help strings too. """ for reg in handlers.handlers: - if not reg.hidden: + if not reg.hidden and (plugin is None or plugin is reg.plugin): output.append(" %s %s" % (reg.command, reg.helphint)) for _, hdlrs in sorted(handlers.subcommands.items()): - self.help_add_regs(output, hdlrs) + self._help_add_regs(output, hdlrs, plugin) - def help_main(self, topic): + def _help_main(self, topic, plugin=None): assert not topic - out = ["Commands known to me:"] - chat = self.help_chat(topic) + out = ["Commands known to {}:" + .format("me" if plugin is None else plugin.name)] + chat = self._help_chat(topic, plugin=plugin) if chat: out.extend(["", chat]) - muc = self.help_muc(topic) + muc = self._help_muc(topic, plugin=plugin) if muc: out.extend(["", muc]) return "\n".join(out) - def help_chat(self, topic): + def _help_chat(self, topic, plugin=None): parts = [] - self.help_add_regs(parts, self._chat_handlers) + self._help_add_regs(parts, self._chat_handlers, plugin=plugin) if parts: return "\n".join(["Commands in Chat:"] + parts) else: return "No command registered in chat." - def help_muc(self, topic): + def _help_muc(self, topic, plugin=None): parts = [] - self.help_add_regs(parts, self._muc_handlers) + self._help_add_regs(parts, self._muc_handlers, plugin=plugin) if parts: return "\n".join(["Commands in MUC:"] + parts) else: @@ -137,7 +246,7 @@ # ------------------------------------------------------------------------- # Command handling methods - def command(self, handlers, args, msg): + def _command(self, handlers, args, msg): """ Handle an incoming message using the given handlers; args is the current remaining message string; msg is the full Message object. @@ -145,22 +254,22 @@ All handlers for the current command are called after first recursing down to any subcommands that match. """ - com, arg = self.command_split(args) + com, arg = self._command_split(args) if com in handlers.subcommands: msg.inc_handlers() - self.command(handlers.subcommands[com], arg, msg) + self._command(handlers.subcommands[com], arg, msg) for handler in handlers.handlers: msg.inc_handlers() handler.callback(msg, args) msg.dec_handlers() - def command_muc(self, msg): - self.command(self._muc_handlers, msg.body, msg) + def _command_muc(self, msg): + self._command(self._muc_handlers, msg.body, msg) - def command_chat(self, msg): - self.command(self._chat_handlers, msg.body, msg) + def _command_chat(self, msg): + self._command(self._chat_handlers, msg.body, msg) - def command_split(self, text): + def _command_split(self, text): num = text.count(' ') if num == 0: return (text.lower(), '') @@ -171,19 +280,22 @@ # ------------------------------------------------------------------------- # Registration methods - def register_handler(self, callback, cmd, helphint, hidden, handlers, - synonyms=()): + def _register_handler(self, callback, cmd, helphint, hidden, handlers, + synonyms=(), plugin=None): """ Register a new handler. callback is the callback handle to call. command is either a single keyword, or a sequence of keywords to match. - helphint and hidden are argument to the Registration object. + helphint and hidden are arguments to the Registration object. handlers are the top-level handlers to add the registration to. + plugin is the plugin that made the registration, used to provide + automatic 'commands' help for the plugin. """ # Register any synonyms (done before we frig with the handlers) for entry in synonyms: - self.register_handler(callback, entry, helphint, True, handlers) + self._register_handler(callback, entry, helphint, True, handlers, + plugin=plugin) # Allow simple commands to be passed as strings cmd = cmd.split() if isinstance(cmd, (str, unicode)) else cmd @@ -191,22 +303,24 @@ for part in cmd: handlers = handlers.subcommands.setdefault(part, Handlers([], {})) handlers.handlers.append(Registration(callback, " ".join(cmd), - helphint, hidden)) + helphint, hidden, plugin)) def register_muc(self, callback, command, helphint="", hidden=False, - synonyms=()): + synonyms=(), plugin=None): """Register a new handler for MUC messages.""" - self.register_handler(callback, command, helphint, hidden, - self._muc_handlers, synonyms) + self._register_handler(callback, command, helphint, hidden, + self._muc_handlers, synonyms, plugin) def register_chat(self, callback, command, helphint="", hidden=False, - synonyms=()): + synonyms=(), plugin=None): """Register a new handler for chat messages.""" - self.register_handler(callback, command, helphint, hidden, - self._chat_handlers, synonyms) + self._register_handler(callback, command, helphint, hidden, + self._chat_handlers, synonyms, plugin) def register_both(self, callback, command, helphint="", hidden=False, - synonyms=()): + synonyms=(), plugin=None): """Register a handler for both MUC and chat messages.""" - self.register_muc(callback, command, helphint, hidden, synonyms) - self.register_chat(callback, command, helphint, hidden, synonyms) + self.register_muc(callback, command, helphint, hidden, synonyms, + plugin) + self.register_chat(callback, command, helphint, hidden, synonyms, + plugin) diff -Nru endroid-1.1.2/src/endroid/plugins/compute/__init__.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/compute/__init__.py --- endroid-1.1.2/src/endroid/plugins/compute/__init__.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/compute/__init__.py 2013-09-16 14:30:23.000000000 +0000 @@ -14,9 +14,10 @@ from twisted.web.client import getPage import logging import wap +import urllib # Constants for the DB values we use -WOLFRAM_API_SERVER_DEFAULT = "http://api.wolframalpha.com/v1/query.jsp" +WOLFRAM_API_SERVER_DEFAULT = "http://api.wolframalpha.com/v2/query" MESSAGES = { 'help' : """ @@ -44,7 +45,7 @@ self.waeo = wap.WolframAlphaEngine(self.api_key, self.server) except KeyError: logging.error("ERROR: Compute: There is no API key set in config! Set 'api_key' variable" - "in section '[Plugin:endroid.plugins.compute]'. Aborting plugin load.") + " in section '[Plugin:endroid.plugins.compute]'. Aborting plugin load.") raise PluginInitError("Aborted plugin initialization") def help(self): @@ -96,7 +97,7 @@ if not args: msg.reply(MESSAGES['help']) return - query = self.waeo.CreateQuery(' '.join(args)) + query = self.waeo.CreateQuery(urllib.quote_plus(' '.join(args))) # Set up Twisted to asyncronously download page d = getPage(self.waeo.server,method='POST',postdata=str(query), diff -Nru endroid-1.1.2/src/endroid/plugins/coolit.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/coolit.py --- endroid-1.1.2/src/endroid/plugins/coolit.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/coolit.py 2013-09-16 14:30:23.000000000 +0000 @@ -3,13 +3,12 @@ # Copyright 2012, Ensoft Ltd # ----------------------------------------------------------------------------- -from endroid.plugins.command import CommandPlugin +from endroid.plugins.command import CommandPlugin, command class CoolIt(CommandPlugin): help = "I'm a robot. I'm not a refrigerator." hidden = True - def cmd_coolit(self, msg, args): + @command(synonyms=('cool it', 'freeze'), hidden=True) + def coolit(self, msg, args): msg.reply(self.help) - cmd_coolit.hidden = True - cmd_coolit.synonyms = ('cool it',) diff -Nru endroid-1.1.2/src/endroid/plugins/correct.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/correct.py --- endroid-1.1.2/src/endroid/plugins/correct.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/correct.py 2013-09-16 14:30:23.000000000 +0000 @@ -8,9 +8,11 @@ from endroid.pluginmanager import Plugin -REGEX = "^s(?P[^a-zA-Z0-9])(.+?)(?P=sep)(.*?)(?P=sep)([gi]*)(?:\s.*)?$" +REGEX = r"^s(?P[^a-zA-Z0-9\\])((?:[^\\]|\\.)+)(?P=sep)((?:[^\\]|\\.)*)(?P=sep)(g?i?|ig)(?:\s.*)?$" REOBJ = re.compile(REGEX) +ERROR = "It looks like you tried to correct yourself, but I couldn't parse it! " + class Correct(Plugin): """ Correction plugin handles sed-style regular expressions, and corrects the @@ -21,8 +23,7 @@ def endroid_init(self): self.lastmsg = {} - self.register_chat_callback(self.heard) - self.register_muc_callback(self.heard) + self.messages.register(self.heard) def heard(self, msg): """ @@ -49,14 +50,23 @@ flags are supported: i for case-insensitive, and g for global replacements. """ + if r'\0' in match.group(3): + return msg.reply_to_sender(ERROR + r"'\0' not valid group reference." + + " Indices start at one.") + opts = match.group(4) if match.group(4) else "" count = 0 if "g" in opts else 1 flags = "(?i)" if "i" in opts else "" - newstr = re.sub(flags + match.group(2), match.group(3), body, count) + + try: + newstr = re.sub(flags + match.group(2), match.group(3), body, count) + except Exception as e: + return msg.reply_to_sender(ERROR + str(e)) if newstr == body: # This is unexpected. Probably a mistake on the user's part? msg.unhandled() else: - who = msg.sendernick if msg.sendernick else "You" + sendernick = self.rosters.nickname(msg.sender_full) + who = sendernick if self.place == "room" else "You" msg.reply("%s meant: %s" % (who, newstr)) diff -Nru endroid-1.1.2/src/endroid/plugins/echobot.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/echobot.py --- endroid-1.1.2/src/endroid/plugins/echobot.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/echobot.py 2013-09-16 14:30:23.000000000 +0000 @@ -7,7 +7,7 @@ from endroid.pluginmanager import Plugin class EchoBot(Plugin): - def endroid_plugin(self): + def endroid_init(self): self.register_chat_callback(self.do_echo) self.register_muc_callback(self.do_echo) diff -Nru endroid-1.1.2/src/endroid/plugins/exec.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/exec.py --- endroid-1.1.2/src/endroid/plugins/exec.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/exec.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,64 @@ +# ----------------------------------------------------------------------------- +# EnDroid - Exec process plugin +# Copyright 2013, Ensoft Ltd +# Created by Simon C +# ----------------------------------------------------------------------------- + +import re +from twisted.internet.utils import getProcessOutput +from endroid.pluginmanager import Plugin + +class Exec(Plugin): + name = "exec" + help = "Execute a command and display the output" + + def endroid_init(self): + """ + Go through each command, and compile a regexp for all the possible + ways to invoke it. We want any expensive string processing to be done + by the regexp engine, not Python. + """ + self.regexp_map = [] + for cmd_spec in self.vars.values(): + invocation = cmd_spec[0] + help_str = cmd_spec[1] + cmds = cmd_spec[2:] + regexp_bits = [] + self.help += '\n\n{}:'.format(help_str) + for cmd in cmds: + regexp_bits.append(r'(?:(?:(?:hey\s+)?endroid[,!:\s\?]*)?' + + '(?:' + cmd + ')' + + r'[,\s]*(?:please[,\s]*)?[\?!]*(?:endroid)?[\s\?!]*$)') + self.help += '\n - ' + cmd + regexp = re.compile('|'.join(regexp_bits), re.IGNORECASE) + self.regexp_map.append((regexp, invocation)) + self.messages.register(self.heard) + + def heard(self, msg): + """ + See if any of our commands match, and execute the process if so. + """ + for regexp, invocation in self.regexp_map: + if regexp.match(msg.body): + self.invoke(invocation, msg) + break + else: + msg.unhandled() + + def invoke(self, invocation, msg): + """ + Spawn a process and send the output + """ + def failure(result): + # twisted voodoo to try to guess at the interesting bit of a failure + try: + failure_summary = result.value[0].split('\\n')[-2] + assert len(failure_summary) > 0 + except Exception: + failure_summary = str(result.value) + msg.reply("I have this terrible pain in all the diodes down my " + "left hand side, trying to execute {}: {}". + format(invocation, failure_summary)) + d = getProcessOutput('/bin/sh', ('-c', invocation)) + d.addCallbacks(lambda result: msg.reply(result.rstrip()), failure) + diff -Nru endroid-1.1.2/src/endroid/plugins/help.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/help.py --- endroid-1.1.2/src/endroid/plugins/help.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/help.py 2013-09-16 14:30:23.000000000 +0000 @@ -3,9 +3,12 @@ # Copyright 2012, Ensoft Ltd # ----------------------------------------------------------------------------- -from endroid.plugins.command import CommandPlugin +import functools +from endroid.plugins.command import CommandPlugin, command class Help(CommandPlugin): + name = "help" + def endroid_init(self): self.help_topics = { '': self.show_help_main, @@ -18,13 +21,50 @@ self.load_plugin_list() def load_plugin_list(self): - self.plugins = {} - for fullname in self.list_plugins(): - plugin = self.get(fullname) + """ + Loads all plugins and stores a short name to plugin mapping. It also + updates the plugins to simplify later calls to get the help. + + Currently this means handling a help method or string, and updating + (or creating, as necessary) the help_topics with a '*' entry. This + means it's possible to just handle help_topics later when help is + requested. + """ + + def help_helper(self, name, topic): + out = [] + try: + out.append(self.help(topic)) + except TypeError: + if topic: + out.append("(Plugin {} doesn't support topic-based help)" + .format(name)) + if callable(self.help): + out.append(self.help()) + else: + out.append(str(self.help)) + return "\n".join(out) + + self._plugins = {} + for fullname in self.plugins.all(): + plugin = self.plugins.get(fullname) name = getattr(plugin, "name", fullname) - self.plugins[name] = (fullname, plugin) + self._plugins[name] = (fullname, plugin) - def cmd_help(self, msg, args): + # Do a little jiggery pokery to simplify any requests for help + # Put a "help" method or string in as a '*' topic handler (unless) + # there is already a '*' handler). If there's neither a help method + # nor help_topics dictionary, then it is just left alone. + topics = getattr(plugin, "help_topics", {}) + + if not '*' in topics and hasattr(plugin, "help"): + topics['*'] = functools.partial(help_helper, plugin, name) + + if topics: + plugin.help_topics = topics + + @command + def _help(self, msg, args): msg.reply_to_sender(self.show_help_plugin("help", args)) def show_help_main(self, topic): @@ -43,7 +83,7 @@ else: out = [] out.append("Currently loaded plugins:") - for name, (_, plug) in sorted(self.plugins.items()): + for name, (_, plug) in sorted(self._plugins.items()): if not getattr(plug, "hidden", False): out.append(" {0}".format(name)) return "\n".join(out) @@ -53,21 +93,10 @@ def show_help_plugin(self, name, topic=''): out = [] - fullname, plugin = self.plugins.get(name, (name, None)) - if self.pluginLoaded(fullname): - # First check if it has a simple "help" property or method - if plugin.hasattr("help"): - try: - out.append(plugin.help(topic)) - except TypeError: - if topic: - out.append("(Plugin doesn't support topic help)") - if callable(plugin.help): - out.append(plugin.help()) - else: - out.append(str(plugin.help)) - - elif plugin.hasattr("help_topics"): + fullname, plugin = self._plugins.get(name, (name, None)) + if self.plugins.loaded(fullname): + # First check for help_topics + if hasattr(plugin, "help_topics"): # Check if it is a "help_topics" dictionary, mapping topic # (first keyword) to handler function keywords = topic.strip().split(' ', 1) @@ -78,11 +107,12 @@ elif '*' in plugin.help_topics: out.append(plugin.help_topics['*'](' '.join(keywords))) else: - out.append("Unknown topic '{0}' for plugin {1}".format(topic, - name)) + out.append("Unknown topic '{}' for plugin {}".format(topic, + name)) + else: - out.append("Plugin '{0}' provides no help".format(name)) + out.append("Plugin '{}' provides no help".format(name)) else: - out.append("Plugin '{0}' is not loaded".format(name)) + out.append("Plugin '{}' is not loaded".format(name)) return '\n'.join(out) diff -Nru endroid-1.1.2/src/endroid/plugins/hi5.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/hi5.py --- endroid-1.1.2/src/endroid/plugins/hi5.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/hi5.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,192 @@ +# Endroid - XMPP Bot +# Copyright 2012, Ensoft Ltd. +# Created by Jonathan Millican, and mangled beyond recognition by SimonC + +import logging, re, time +from twisted.internet import defer, error, protocol, reactor +from endroid.plugins.command import CommandPlugin, command + +HI5_TABLE = 'hi5s' + +class FilterProtocol(protocol.ProcessProtocol): + """ + Send some data to a process via its stdin, close it, and reap the output + from its stdout. Twisted arguably ought to provide a utility function for + this - there's nothing specific to GPG or high-fiving here. + """ + def __init__(self, in_data, deferred, args): + self.in_data = in_data + self.deferred = deferred + self.args = args + self.out_data= '' + + def connectionMade(self): + self.transport.write(self.in_data.encode('utf-8')) + self.transport.closeStdin() + + def outReceived(self, out_data): + self.out_data += out_data.decode('utf-8') + + def outConnectionLost(self): + d, self.deferred = self.deferred, None + d.callback(self.out_data) + + def processEnded(self, reason): + if isinstance(reason.value, error.ProcessTerminated): + logging.error("Problem running filter ({}): {}". + format(self.args, reason.value)) + d, self.deferred = self.deferred, None + d.errback(reason.value) + +class Hi5(CommandPlugin): + """ + The Hi5 plugin lets you send anonymous 'High Five!' messages to other + users known to Endroid. The idea is that it makes it easy to send a + compliment to somebody. The most basic usage is: + + hi5 user@example.com Nice presentation dude! + + which, if user@example.com is known to EnDroid and currently logged in, + sends both a unicast chat to that user with the anonymous compliment, + and also anonymously announces to one or more configured chatrooms that + user@example.com got the High Five 'Nice presentation dude!'. + + Slightly more complicated examples: it's possible to send a compliment + to multiple users at once, by using comma-separation, and also omit + the domain part of the JID if the user is unambiguous given all the + users known to EnDroid. So for example: + + hi5 bilbo@baggins.org, frodo, sam Good work with the Nazgul guys :-) + + There is some basic anonymous logging performed by default, that includes + only the time/date and recipient JID. However, if you configure a GPG + public key, then an asymmetrically encrypted log that also includes the + sender and message is done. That provides a last-resort mechanism should + someone use the mechanism for poisonous purposes, but requires the private + key and passphrase. The 'spelunk_hi5' script can be used for this. + """ + + name = "hi5" + help = ("Send anonymous 'hi5s' to folks! Your message is sent from EnDroid" + " direct to the recipient, as well as being broadcast in any " + "configured public chat rooms.") + + def endroid_init(self): + if 'gpg' in self.vars: + self.gpg = ('/usr/bin/gpg', '--encrypt', '--armor', + '--batch', '--trust-model', 'always', + '--keyring', self.vars['gpg'][0], + '--recipient', self.vars['gpg'][1]) + else: + self.gpg = None + if not self.database.table_exists(HI5_TABLE): + self.database.create_table(HI5_TABLE, ['jids', 'date', 'encrypted']) + + @command(helphint="{user}[,{user}] {message}") + def hi5(self, msg, arg): + # Parse the request + try: + jids, text = self._parse(arg) + assert len(text) > 0 + except Exception: + msg.reply("Sorry, couldn't spot a message to send in there. Use " + "something like:\n" + "hi5 frodo@shire.org, sam, bilbo@rivendell Nice job!") + return + + # Sanity checks, and also expand out 'user' to 'user@host' + # if we can do so unambiguously + fulljids = [] + for jid in jids: + if '/' in jid: + msg.reply("Recipients can't contain '/'s".format(jid)) + return + fulljid = self._get_fulljid(jid) + if not fulljid: + msg.reply("{0} is not a currently online valid receipient. " + "Sorry.".format(jid)) + return + elif fulljid == msg.sender: + msg.reply("You really don't have to resort to complimenting " + "yourself. I already think you're great") + return + fulljids.append(fulljid) + + # Do it + self._do_hi5(jids, fulljids, text, msg) + + def _do_hi5(self, jids, fulljids, text, msg): + """ + Actually send the hi5 + """ + # jidlist is a nice human-readable representation of the lucky + # receipients, like 'Tom, Dick & Harry' + if len(jids) > 1: + jidlist = ', '.join(jids[:-1]) + ' & ' + jids[-1] + else: + jidlist = jids[0] + + msg.reply('A High Five "' + text + '" is being sent to ' + jidlist) + self._log_hi5(','.join(fulljids), msg.sender, text) + + for jid in fulljids: + self.messagehandler.send_chat(jid, "You've been sent an anonymous " + "High Five: " + text) + for group in self.vars.get('broadcast', []): + groupmsg = '{} {} been sent an anonymous High Five: {}'.format( + jidlist, 'have' if len(jids) > 1 else 'has', text) + self.messagehandler.send_muc(group, groupmsg) + + @staticmethod + def _parse(msg): + """ + Parse something like ' bilbo@baggins.org, frodo, sam great job! ' into + (['bilbo@baggsins.org', 'frodo', 'sam'], 'great job!') + """ + jids = [] + msg = msg.strip() + while True: + m = re.match(r'([^ ,]+)( *,? *)(.*)', msg) + jid, sep, rest = m.groups(1) + jids.append(jid) + if sep.strip(): + msg = rest + else: + return jids, rest + + def _get_fulljid(self, jid): + """ + Expand a simple 'user' JID to 'user@host' if we can do so unambiguously + """ + users = self.usermanagement.get_available_users() + if jid in users: + return jid + expansions = [] + for user in users: + if user.startswith(jid + '@'): + expansions.append(user) + if len(expansions) == 1: + return expansions[0] + + def _log_hi5(self, jidlist, sender, text): + """ + Log the hi5. This either means spawning a GPG process to do an + asymmetric encryption of the whole thing, or just writing a basic + summary straight away. + """ + now = time.ctime() + def db_insert(encrypted): + self.database.insert(HI5_TABLE, {'jids':jidlist, + 'date':now, 'encrypted': encrypted}) + def db_insert_err(err): + logging.error("Error with hi5 database entry: {}".format(err)) + db_insert(None) + if self.gpg: + d = defer.Deferred() + d.addCallbacks(db_insert, db_insert_err) + gpg_log = '{}: {} -> {}: {}'.format(now, sender, jidlist, text) + fp = FilterProtocol(gpg_log, d, self.gpg) + reactor.spawnProcess(fp, self.gpg[0], self.gpg, {}) + else: + db_insert(None) + diff -Nru endroid-1.1.2/src/endroid/plugins/httpinterface.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/httpinterface.py --- endroid-1.1.2/src/endroid/plugins/httpinterface.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/httpinterface.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,203 @@ +# ----------------------------------------------------------------------------- +# EnDroid - HTTP Interface +# Copyright 2012, Ensoft Ltd +# ----------------------------------------------------------------------------- + +import collections +import re +import logging + +from endroid.pluginmanager import Plugin +from twisted.internet import reactor +from twisted.web.resource import Resource +from twisted.web.server import Site +from twisted.web.static import File + +DEFAULT_HTTP_PORT = 8880 +DEFAULT_HTTP_INTERFACE = '127.0.0.1' +DEFAULT_MEDIA_DIR = "/usr/share/endroid/media/" + +NOT_FOUND_TEMPLATE = """ + + Handler not found + +

Handler not found

+ Handler not found: %s + + +""" + +INDEX_TEMPLATE = """ + + EnDroid + +

EnDroid HTTP interface

+{} + + +""" + +class HandlerNotFoundError(Exception): + pass + +class IndexPage(Resource): + """ + Only registered resource. Route requests to callbacks. + """ + + def __init__(self, interface): + Resource.__init__(self) + self.interface = interface + + def getChild(self, name, request): + if name == "_media": + return self.interface._media + else: + return self + + def _render(self, request): + try: + callback = self.interface.lookup_handler(request.path) + except HandlerNotFoundError as e: + page = NOT_FOUND_TEMPLATE % e + else: + page = callback(request) + + return page + + render_GET = _render + render_POST = _render + + +class HTTPInterfaceSingleton(object): + """ + Start a webserver, allow callback registrations on URL paths, and route + requests to callbacks. + """ + + def __init__(self): + self.registrations = collections.defaultdict(list) + + def _index(self, request): + return INDEX_TEMPLATE.format("\n".join("

{0}

" + .format(name) + for name in self.registrations)) + + def lookup_handler(self, path): + """" + Search for a callback function registered to handle the given path. + + Raises HandlerNotFoundError if no callback has been registered on the + given path. + """ + + assert path[0] == '/' + path = path[1:] + + spl = path.split('/', 1) + if len(spl) != 2 and not spl[0]: + return self._index + if len(spl) != 2: + raise HandlerNotFoundError("Path only has one component") + plugin_name, sub_path = spl + + if plugin_name not in self.registrations: + raise HandlerNotFoundError("Plugin %s has no registered paths" % + plugin_name) + + for regex, cb in self.registrations[plugin_name]: + if regex.match(sub_path): + callback = cb + break + else: + raise HandlerNotFoundError("Plugin %s is not registered on %s" % + (plugin_name, sub_path)) + + return callback + + def register_regex_path(self, plugin, callback, path_regex): + """ + See HTTPInterface.register_regex_path() + """ + if isinstance(path_regex, str): + path_regex = re.compile(path_regex) + + self.registrations[plugin.name].append((path_regex, callback)) + + def register_path(self, plugin, callback, path_prefix=''): + """ + See HTTPInterface.register_path() + """ + if not path_prefix: + re_src = r".*" + else: + if path_prefix[0] == '/': + raise ValueError("Prefix %s begins with a slash" % path_prefix) + if path_prefix[-1] == '/': + raise ValueError("Prefix %s ends with a slash" % path_prefix) + re_src = re.escape(path_prefix) + r"(/.*)?" + self.register_regex_path(plugin, callback, re_src) + + def register_resource(self, plugin, resource): + self.root.putChild(plugin.name, resource) + + def endroid_init(self, port, interface, media_dir): + self.root = IndexPage(self) + logging.info("Publishing static files from {}".format(media_dir)) + self._media = File(media_dir) + self.root.putChild("_media", self._media) + factory = Site(self.root) + reactor.listenTCP(port, factory, interface=interface) + +class HTTPInterface(Plugin): + """ + The actual plugin class. This may be instantiated multiple times, but is + just a wrapper around a HTTPInterfaceSingleton object. + """ + + object = None + enInited = False + name = "httpinterface" + hidden = True + + def __init__(self): + if HTTPInterface.object == None: + HTTPInterface.object = HTTPInterfaceSingleton() + + def register_regex_path(self, plugin, callback, path_regex): + """ + Register a callback to be called for requests whose URI matches: + http:////[?] + + Callback arguments: + request: A twisted.web.http.Request object. + """ + + HTTPInterface.object.register_regex_path(plugin, callback, path_regex) + + def register_path(self, plugin, callback, path_prefix): + """ + Register a callback to be called for requests whose URI matches: + http:////[?] + + Or: + http://///[?] + + Or if the prefix is the empty string: + http:////[?] + """ + + HTTPInterface.object.register_path(plugin, callback, path_prefix) + + def register_resource(self, plugin, resource): + HTTPInterface.object.register_resource(self, plugin, resource) + + def endroid_init(self): + if not HTTPInterface.enInited: + port = self.vars.get("port", DEFAULT_HTTP_PORT) + interface = self.vars.get("interface", DEFAULT_HTTP_INTERFACE) + media_dir = self.vars.get("media_dir", DEFAULT_MEDIA_DIR) + HTTPInterface.object.endroid_init(port, interface, media_dir) + HTTPInterface.enInited = True diff -Nru endroid-1.1.2/src/endroid/plugins/invite.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/invite.py --- endroid-1.1.2/src/endroid/plugins/invite.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/invite.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,191 @@ +# ----------------------------------------- +# Endroid - Room inviter +# Copyright 2013, Ensoft Ltd. +# Created by Ben Hutchings +# ----------------------------------------- + +from endroid.plugins.command import CommandPlugin, command +import shlex +import re + +def parse_string(string, options=None): + """ + Parse a shell command like string into an args tuple and a kwargs dict. + + Options is an iterable of string tuples, each tuple representing a keyword + followed by its synonyms. + + Words in string will be appended to the args tuple until a keyword is + reached, at which point they will be appended to a list in kwargs. + + Eg parse_string("a b c -u 1 2 3 -r 5 6", [("-u",), ("room", "-r")]) + will return: ('a', 'b', 'c'), {'-u': ['1','2','3'], 'room': ['5','6']} + + """ + options = options or [] + aliases = {} + + keys = [] + # build the kwargs dict with all the keywords and an aliases dict for synonyms + for option in options: + if isinstance(option, (list, tuple)): + main = option[0] + keys.append(main) + for alias in option[1:]: + aliases[alias] = main + elif isinstance(option, (str, unicode)): + keys.append(option) + + args = [] + kwargs = {} + current = None + # parse the string - first split into shell 'words' + parts = shlex.split(string) + # then add to args or the kwargs dictionary as appropriate + for part in parts: + # if it's a synonym get the main command, else leave it + part = aliases.get(part, part) + if part in keys: + # we have come to a keyword argument - create its list + kwargs[part] = [] + # keep track of where we are sending non-keyword words to + current = kwargs[part] + elif current is not None: + # we are adding words to a keyword's list + current.append(part) + else: + # no keywords has been found yet - we are still in args + args.append(part) + + return args, kwargs + +def replace(l, search, replace): + return [replace if item == search else item for item in l] + + +class Invite(CommandPlugin): + help = "Invite users to rooms" + name = "invite" + PARSE_OPTIONS = (("to", "into"),) + + @command(helphint="{to|into}? +") + def invite_me(self, msg, arg): + """ + Invite user to the rooms listed in args, or to all their rooms + if args is empty. + + """ + args, kwargs = parse_string(arg, self.PARSE_OPTIONS) + users = [msg.sender] + rooms = set(args + kwargs.get("to", [])) or ["all"] + + results = self._do_invites(users, rooms) + msg.reply(results) + + @command(helphint="", muc_only=True) + def invite_all(self, msg, arg): + """Invite all of a room's registered users to the room.""" + users = self.usermanagement.get_available_users(self.place_name) + rooms = [self.place_name] + + results = self._do_invites(users, rooms) + msg.reply(results) + + @command(helphint="+ {to|into} +") + def invite_users(self, msg, arg): + """Invite a list of users to a list of rooms.""" + args, kwargs = parse_string(arg, self.PARSE_OPTIONS) + users = replace(args, "me", msg.sender_full) + rooms = kwargs.get("to", []) + + results = self._do_invites(users, rooms) + msg.reply(results) + + def _do_invites(self, users, rooms): + if 'all' in users: + if len(rooms) == 1: + users = self.usermanagement.get_users(rooms[0]) + else: + return "Can only invite 'all' users to a single room" + + users = self._fuzzy_match(users, self.usermanagement.get_users()) + + if 'all' in rooms: + if len(users) == 1: + rooms = self.usermanagement.get_rooms(users[0]) + if not rooms: + return ("There are no rooms to invite user '{}' " + "to.".format(users[0])) + else: + return "Can only invite a single user to 'all' rooms" + + rooms = self._fuzzy_match(rooms, self.usermanagement.get_rooms()) + + if not users: + return "User not found." + if not rooms: + return "Room not found." + + results = [] + invitations = 0 + for room in rooms: + for user in users: + s, reason = self.usermanagement.invite(user, room) + if not s: + results.append("{} to {} failed: {}".format(user, room, reason)) + else: + invitations += 1 + + reply = "Sent {} invitations.".format(invitations) + if results: + reply += '\n' + '\n'.join(results) + return reply + + @staticmethod + def _fuzzy_match(partials, fulls): + """ + For lists 'partials' and 'fulls', elements of partials (

) are + mapped to elements of fulls () by the following rules: + + 1) If

is in , then return

(exact_match) + 2) If "

@.*" matches exactly one then return

(startswith_at) + 3) If "

.*" matches exactly one then return

(startswith) + 4) If ".*

.*" matches exactly one then return

(contains) + + """ + result = [] + + for partial in partials: + exact_match = None # an exact match for '' in fulls + startswith_at = [] # list of fulls starting with '@' + startswith = [] # list of fulls starting with '' + contains = [] # list of fulls containing '' + + for full in fulls: + if partial == full: + # we have found an exact match, don't look at other fulls + exact_match = full + break + # eg room will match room@serv.er + elif full.startswith(partial + '@'): + startswith_at.append(full) + # eg room will match room@serv.er, room1@serv.er etc + elif full.startswith(partial): + startswith.append(full) + # eg room will match aroom@serv.er, broom1@serv.er etc + elif partial in full: + contains.append(full) + + # case 1 + if exact_match: + result.append(exact_match) + # cases 2, 3, 4: for each check that there is exactly one match + elif len(startswith_at) == 1: + result.extend(startswith_at) + elif len(startswith) == 1: + result.extend(startswith) + elif len(contains) == 1: + result.extend(contains) + # else: we have multiple possible matches, so ignore them + + return result diff -Nru endroid-1.1.2/src/endroid/plugins/memo.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/memo.py --- endroid-1.1.2/src/endroid/plugins/memo.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/memo.py 2013-09-16 14:30:23.000000000 +0000 @@ -8,8 +8,7 @@ See MESSAGES['usage'] for details. """ -import endroid.messagehandler as messagehandler -from endroid.pluginmanager import Plugin +from endroid.plugins.command import CommandPlugin, command from endroid.database import Database from endroid.database import EndroidUniqueID @@ -27,11 +26,12 @@ memo usage - Output this message memo [list] - List messages in inbox memo send - Send a message -memo {view|delete} -Handle a specific message""", +memo {view|delete} - Handle a specific message""", 'usage-send' : "memo send \t Send a message", 'usage-view' : "memo view \t View a specific message", 'usage-delete' : "memo delete \t Delete a specific message", + 'duplicate-id-error' : "Error: There are messages sharing the same PK id", 'id-not-found-error' : "There is no message with id {0}. Try 'memo list'.", 'deletion-sucess' : "Sucessfully deleted one message", @@ -45,33 +45,21 @@ } -class Memo(Plugin): +class Memo(CommandPlugin): name = "memo" + help_topics = { + '': lambda _: MESSAGES['help'], + 'usage': lambda _: MESSAGES['usage'], + 'send': lambda _: MESSAGES['usage-send'], + 'view': lambda _: MESSAGES['usage-view'], + 'delete': lambda _: MESSAGES['usage-delete'], + } - def dependencies(self): - return ('endroid.plugins.command',) - - def enInit(self): - com = self.get('endroid.plugins.command') - com.register_chat(self._handle_list, 'memo', '[list]') - com.register_chat(self._handle_list, ('memo', 'list'), hidden=True) - com.register_chat(self._handle_send, ('memo', 'send'), - ' ') - com.register_chat(self._handle_view, ('memo', 'view'), '') - com.register_chat(self._handle_delete, ('memo', 'delete'), - '') - com.register_chat(lambda m, _: m.reply(MESSAGES['usage']), - ('memo', 'usage')) + def endroid_init(self): self.db = Database(DB_NAME) - self.setup_db() - - def setup_db(self): if not self.db.table_exists(DB_TABLE): self.db.create_table(DB_TABLE, DB_COLUMNS) - def help(self): - return MESSAGES['help'] - def _message_text_summary(self, text): # First assume text is too long, try to shorten. summary = "" @@ -82,9 +70,14 @@ summary += word + ' ' # Looks like memo is already short enough. Return it. return summary[:-1] - - def _handle_delete(self, msg, args): - args = arg.split() + + @command + def memo_usage(self, msg, args): + msg.reply(MESSAGES['usage']) + + @command(helphint="") + def memo_delete(self, msg, args): + args = args.split() if len(args) != 1 or not args[0].isdigit(): msg.reply(MESSAGES['usage-delete']) return @@ -100,9 +93,17 @@ self.db.delete(DB_TABLE, {EndroidUniqueID : int(args[0])}) msg.reply(MESSAGES['deletion-sucess']) - def _handle_list(self, msg, args): + @command(helphint="[list]") + def memo(self, msg, args): + args = args.split() + if len(args) > 0 and args[0] in {"send", "view", "delete", "usage"}: + msg.unhandled() + return + if len(args) > 1 or (len(args) == 1 and args[0] != "list"): + msg.reply(MESSAGES['usage']) + return memos = [] - cond = {"recipient" : msg.sender.userhost()} + cond = {"recipient" : msg.sender} rows = self.db.fetch(DB_TABLE, DB_COLUMNS, cond) for row in rows: data = (row.id, row["sender"], @@ -115,8 +116,9 @@ else: msg.reply(MESSAGES['inbox-empty']) - def _handle_view(self, msg, args): - args = arg.split() + @command(helphint="") + def memo_view(self, msg, args): + args = args.split() if len(args) != 1 or not args[0].isdigit(): msg.reply(MESSAGES['usage-view']) return @@ -133,18 +135,19 @@ data = (row["sender"], row["text"]) msg.reply(MESSAGES['view-message'].format(*data)) - def _handle_send(self, msg, args): - args = arg.split() + @command(helphint=" ") + def memo_send(self, msg, args): + args = args.split() if len(args) < 2: msg.reply(MESSAGES['usage-send']) return recipient, memo = args[0], ' '.join(args[1:]) - if recipient not in self.presence().get_roster(): + if recipient not in self.usermanagement.get_available_users(): msg.reply(MESSAGES['bad-recipient'].format(recipient)) return - self.db.insert(DB_TABLE, {'sender': msg.sender.userhost(), + self.db.insert(DB_TABLE, {'sender': msg.sender, 'recipient': recipient, 'text': memo}) msg.reply(MESSAGES['sent-message']) diff -Nru endroid-1.1.2/src/endroid/plugins/passthebomb.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/passthebomb.py --- endroid-1.1.2/src/endroid/plugins/passthebomb.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/passthebomb.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,211 @@ +from endroid.plugins.command import CommandPlugin +from endroid.cron import Cron +from collections import defaultdict +from endroid.database import Database + +DB_NAME = "PTB" +DB_TABLE = "PTB" + +class User(object): + __slots__ = ('name', 'kills', 'shield') + def __init__(self, name, kills=0, shield=True): + self.name = name + self.kills = kills + self.shield = shield + + def __repr__(self): + fmt = "User(name={}, kills={}, shield={})" + return fmt.format(self.name, self.kills, self.shield) + +class Bomb(object): + ID = 0 + def __init__(self, source, fuse, plugin): + self.source = source # who lit the bomb? + self.user = None # our current holder + self.plugin = plugin # plugin instance we belong to + self.history = set() # who has held us? + + idstring = self.get_id() # get a unique registration_name + plugin.cron.register(self.explode, idstring) + plugin.cron.setTimeout(fuse, idstring, None) # schedule detonation + + # this function is called by Cron and given an argument. We don't need an + # argument so just ignore it + def explode(self, _): + # some shorthands + get_rooms = self.plugin.usermanagement.get_available_rooms + send_muc = self.plugin.messagehandler.send_muc + send_chat = self.plugin.messagehandler.send_chat + + msg_explode = "!!!BOOM!!!" + msg_farexplode = "You hear a distant boom" + msg_kill = "{} was got by the bomb" + + rooms = get_rooms(self.user) + for room in rooms: + # let everyone in a room with self.user here the explosion + send_muc(room, msg_explode) + send_muc(room, msg_kill.format(self.user)) + + # alert those who passed the bomb that it has exploded + for user in self.history: + if user == self.user: + send_chat(self.user, msg_explode) + send_chat(self.user, msg_kill.format("You")) + else: + send_chat(user, msg_farexplode) + send_chat(user, msg_kill.format(self.user)) + + self.plugin.register_kill(self.source) + self.plugin.bombs[self.user].discard(self) + + + def throw(self, user): + # remove this bomb from our current user + self.plugin.bombs[self.user].discard(self) + + self.history.add(user) + self.user = user + + # add it to the new user + self.plugin.bombs[self.user].add(self) + + @classmethod + def get_id(cls): + # generate a unique id string to register our explode method against + result = Bomb.ID + cls.ID += 1 + return "bomb" + str(result) + + +class PassTheBomb(CommandPlugin): + help = "Pass the bomb game for EnDroid" + bombs = defaultdict(set) # users : set of bombs + users = dict() # user strings : User objects + + def endroid_init(self): + self.db = Database(DB_NAME) + if not self.db.table_exists(DB_TABLE): + self.db.create_table(DB_TABLE, ('user', 'kills')) + + # make a local copy of the registration database + data = self.db.fetch(DB_TABLE, ['user', 'kills']) + for dct in data: + self.users[dct['user']] = User(dct['user'], dct['kills']) + + def cmd_furl_umbrella(self, msg, arg): + """This is how a user enters the game - allows them to be targeted + and to create and throw bombs""" + user = msg.sender + if not self.get_shielded(user): + msg.reply("Your umbrella is already furled!") + else: + if self.get_registered(user): + self.users[user].shield = False + else: # they are not - register them + self.db.insert(DB_TABLE, {'user': user, 'kills': 0}) + self.users[user] = User(user, kills=0, shield=False) + msg.reply("You furl your umbrella!") + cmd_furl_umbrella.helphint = ("Furl your umbrella to participate in the " + "noble game of pass the bomb!") + + def cmd_unfurl_umbrella(self, msg, arg): + """A user with an unfurled umbrella cannot create or receive bombs""" + user = msg.sender + if self.get_shielded(user): + msg.reply("Your umbrella is already unfurled!") + else: + # to get user must not have been shielded ie they must have furled + # so they will be in the database + self.users[user].shield = True + msg.reply("You unfurl your umbrella! No bomb can reach you now!") + cmd_unfurl_umbrella.helphint = ("Unfurl your umbrella to cower from the " + "rain of boms!") + + def cmd_bomb(self, msg, arg): + """Create a bomb with a specified timer. + + eg: 'bomb 1.5' for a 1.5 second fuse + + """ + + holder = msg.sender + if self.get_shielded(holder): + return msg.reply("Your sense of honour insists that you furl your " + "umbrella before lighting the fuse") + # otherwise get a time from the first word of arg + try: + time = float(arg.split(' ', 1)[0]) + # make a new bomb and throw it to its creator + Bomb(msg.sender, time, self).throw(msg.sender) + msg.reply("Sniggering evilly, you light the fuse...") + # provision for a failure to read a time float... + except ValueError: + msg.reply("You struggle with the matches") + cmd_bomb.helphint = ("Light the fuse!") + + def cmd_throw(self, msg, arg): + """Throw a bomb to a user, eg: 'throw benh@ensoft.co.uk'""" + target = arg.split(' ')[0] + # we need a bomb to thrown + if not self.bombs[msg.sender]: + msg.reply("You idly throw your hat, wishing you had something " + "rounder, heavier and with more smoking fuses.") + # need our umbrella to be furled + elif self.get_shielded(msg.sender): + msg.reply("You notice that your unfurled umbrella would hinder " + "your throw.") + # check that target is online + elif not target in self.usermanagement.get_available_users(): + msg.reply("You look around but cannot spot your target") + elif self.get_shielded(target): # target registered/vulnerable? + msg.reply("You see your target hunkered down under their umbrella. " + "No doubt a bomb would have little effect on that " + "monstrosity.") + else: + self.bombs[msg.sender].pop().throw(target) + msg.reply("You throw the bomb!") + self.messagehandler.send_chat(target, "A bomb lands by your feet!") + cmd_throw.helphint = ("Throw a bomb!") + + def cmd_kills(self, msg, arg): + kills = self.get_kills(msg.sender) + nick = self.usermanagement.get_nickname(msg.sender, + self.place_name) + level = self.get_level(kills) + + text = "{} the {} has {} kill".format(nick, level, kills) + text += ("" if kills == 1 else "s") + msg.reply(text) + cmd_kills.helphint = ("Receive and gloat over you score!") + + def register_kill(self, user): + kills = self.get_kills(user) + # change the value of 'kills' to kills+1 in the row where 'user' = user + self.users[user].kills += 1 + self.db.update(DB_TABLE, {'kills': kills+1}, {'user': user}) + + def get_kills(self, user): + return self.users[user].kills if user in self.users else 0 + + def get_shielded(self, user): + return self.users[user].shield if user in self.users else True + + def get_registered(self, user): + return user in self.users + + @staticmethod + def get_level(kills): + if kills < 5: + level = 'novice' + elif kills < 15: + level = 'apprentice' + elif kills < 35: + level = 'journeyman' + elif kills < 65: + level = 'expert' + elif kills < 100: + level = 'master' + else: + level = 'grand-master' + return level diff -Nru endroid-1.1.2/src/endroid/plugins/patternmatcher.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/patternmatcher.py --- endroid-1.1.2/src/endroid/plugins/patternmatcher.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/patternmatcher.py 2013-09-16 14:30:23.000000000 +0000 @@ -12,6 +12,7 @@ class PatternMatcher(Plugin): name = "patternmatcher" + hidden = True def __init__(self): self._muc_match_list = [] diff -Nru endroid-1.1.2/src/endroid/plugins/pubpicker.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/pubpicker.py --- endroid-1.1.2/src/endroid/plugins/pubpicker.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/pubpicker.py 2013-09-16 14:30:23.000000000 +0000 @@ -16,6 +16,10 @@ # Some regular expressions for the alias command ALIAS_FOR = re.compile("(.*?) for (.*)", re.I) ALIAS_TO = re.compile("(.*?) to (.*)", re.I) +ALIAS_ERROR = "Alias loop detected! (starts at '{}')" + +class AliasError(Exception): + pass class PubPicker(Plugin): name = "pubpicker" @@ -75,12 +79,19 @@ self.add_alias(alias, alias.lower()) def resolve_alias(self, alias): + seen = set() while alias in self.aliases: + if alias in seen: + raise AliasError(alias) alias = self.aliases[alias] + seen.add(alias) return alias def vote_up(self, msg, pub): - pub = self.resolve_alias(pub) + try: + pub = self.resolve_alias(pub) + except AliasError as e: + return msg.reply(ALIAS_ERROR.format(e)) if pub not in self.pubs: self.pubs[pub] = 10 self.db.insert(DB_TABLE, {"name": pub, "score": 10}) @@ -90,9 +101,12 @@ self.save_pub(pub) def vote_down(self, msg, pub): - pub = self.resolve_alias(pub) + try: + pub = self.resolve_alias(pub) + except AliasError as e: + return msg.reply(ALIAS_ERROR.format(e)) if pub in self.pubs: - self.pubs[pub] = min(self.pubs[pub] - 1, 0) + self.pubs[pub] = max(self.pubs[pub] - 1, 0) self.save_pub(pub) def rename_pub(self, oldname, newname): @@ -113,14 +127,24 @@ pubs = [] for pub, score in self.pubs.items(): pubs += [pub] * score - return random.choice(pubs) + if pubs: + return random.choice(pubs) + else: + return None def register(self, msg, arg): - self.vote_up(self.resolve_alias(arg)) + try: + self.vote_up(msg, self.resolve_alias(arg)) + except AliasError as e: + msg.reply(ALIAS_ERROR.format(e)) def picker(self, msg, arg): pub = self.pick_a_pub() - msg.reply("Today, you should definitely go to %s" % pub) + if pub: + msg.reply("Today, you should definitely go to %s" % pub) + else: + msg.reply("Unfortunately, I don't seem to know about any pubs " + "that anyone wants to go to") def alias(self, msg, arg): mf = ALIAS_FOR.match(arg) @@ -135,7 +159,10 @@ def rename(self, msg, arg): mt = ALIAS_TO.match(arg) if mt: - self.rename_pub(self.resolve_alias(mt.group(1)), mt.group(2)) + try: + self.rename_pub(self.resolve_alias(mt.group(1)), mt.group(2)) + except AliasError as e: + msg.reply(ALIAS_ERROR.format(e)) else: msg.unhandled() diff -Nru endroid-1.1.2/src/endroid/plugins/ratelimit.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/ratelimit.py --- endroid-1.1.2/src/endroid/plugins/ratelimit.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/ratelimit.py 2013-09-16 14:30:23.000000000 +0000 @@ -4,18 +4,19 @@ # Created by Martin Morrison # ----------------------------------------------------------------------------- -from collections import defaultdict, deque + import time import logging +from collections import defaultdict, deque from endroid.pluginmanager import Plugin -from endroid.messagehandler import PRIORITY_URGENT -from endroid.database import Database -from endroid.cron import Cron +from endroid.messagehandler import Priority +from endroid.cron import task # Cron constants CRON_SENDAGAIN = "RateLimit_SendAgain" + class Bucket(object): """ Implementation of a Token Bucket. @@ -64,19 +65,19 @@ return "".format(self.tokens, self.capacity, self.fillrate, self.timestamp) + class SendClass(object): """ Represents an independently rate limited sender class. Usually, there is one instance of this class for each destination JID. """ - __slot__ = ('last_sent', 'queue', 'maxlen', 'bucket') + __slots__ = ('queue', 'maxlen', 'bucket') def __init__(self, bucket, maxlen=None): """ Initialise the sender class with the given TokenBucket, and the specified maxiumum queue length. """ - self.last_sent = 0 # Don't use maxlen in the deque - it drops from the wrong end! self.queue = deque() self.maxlen = maxlen @@ -99,10 +100,10 @@ Note that calls to this function consume tokens in the bucket. """ - if len(self.queue) > 0 and self.accept(): + if len(self.queue) > 0 and self._accept(): return self.queue.popleft() - def accept(self, msg=None, now=None): + def _accept(self, now=None): """ Check whether this sender class will accept sending a message, by checking the TokenBucket. If a msg is specified, and there are not @@ -114,12 +115,29 @@ """ if now is None: now = time.time() - acc = self.bucket.use_token(now=now) - if acc: - self.last_sent = now - elif msg: + + return self.bucket.use_token(now=now) + + def accept_msg(self, msg): + accept = self._accept() + + if accept: + # We can send a message, now lets find out which message + if len(self.queue) > 0: + # There are already msgs on the queue. Queue this message + # and return the first message from the queue to preserve + # ordering + self.append(msg) + msg_to_send = self.queue.popleft() + else: + msg_to_send = msg + else: + # Can't send a message so queue it self.append(msg) - return acc + msg_to_send = None + + return msg_to_send + class RateLimit(Plugin): """ @@ -127,13 +145,15 @@ """ name = "ratelimit" hidden = True + help = "Implements a Token Bucket rate limiter, per recipient JID" + preferences = ("endroid.plugins.blacklist",) - def enInit(self): + def endroid_init(self): """ Initialise the plugin. Registers required Crons, and extracts configuration. """ - self.min_interval = float(self.vars.get('min_interval', 1.0)) + self.maxburst = float(self.vars.get('maxburst', 5.0)) self.fillrate = float(self.vars.get('fillrate', 1.0)) self.maxqueuelen = int(self.vars.get('maxqueuelen', 20)) @@ -143,29 +163,21 @@ self.abusecooloff = int(self.vars.get('abusecooloff', 3600)) self.blacklist = self.get("endroid.plugins.blacklist") - self.register_muc_send_filter(self.ratelimit, priority=10) - self.register_chat_send_filter(self.ratelimit, priority=10) + self.messages.register(self.ratelimit, priority=10, send_filter=True) + self.messages.register(self.checkabuse, priority=10, recv_filter=True) - self.register_muc_filter(self.checkabuse, priority=10) - self.register_chat_filter(self.checkabuse, priority=10) + # Make all the state attributes class attributes + # This means that users are limited globally accross all usergroups and + # rooms rather than on a per room/user basis. + # It also means that it doesn't matter which instance is called back + # by the cron module + RateLimit.limiters = defaultdict( + lambda: SendClass(Bucket(self.maxburst, self.fillrate), + self.maxqueuelen)) + RateLimit.abusers = defaultdict( + lambda: Bucket(self.abuseallowance, self.abuserecovery)) - self.limiters = defaultdict(lambda: SendClass(Bucket(self.maxburst, - self.fillrate), - self.maxqueuelen)) - self.abusers = defaultdict(lambda: Bucket(self.abuseallowance, - self.abuserecovery)) - - self.waitingusers = set() - - self.cron = Cron.get().register(self.sendagain, CRON_SENDAGAIN) - - def preferences(self): - """Other plugins that we could use if they are loaded.""" - return ("endroid.plugins.blacklist",) - - def help(self): - "Help string for the plugin" - return "Implements a Token Bucket rate limiter, per recipient JID" + RateLimit.waitingusers = set() def ratelimit(self, msg): """ @@ -176,16 +188,25 @@ messages. TODO: store queued messages in the DB so they survive a process restart? - PRIORITY_URGENT messages are not rate limited. + Priority.URGENT messages are not rate limited. """ - now = time.time() sc = self.limiters[msg.recipient] # Don't ratelimit things we're sending ourselves, or URGENT messages - accept = (msg.sender is self or - msg.priority == PRIORITY_URGENT or - sc.accept(msg, now)) - self.set_timeout(msg.recipient, now) + if (msg.sender == self.name or + msg.priority == Priority.URGENT): + accept = True + else: + # Otherwise always return false because either: we'll send the msg + # ourselves or we're queuing the message for later sending + accept = False + msg_to_send = sc.accept_msg(msg) + if msg_to_send: + self.send(msg_to_send) + else: + logging.info("Ratelimiting msgs to {}".format(msg.recipient)) + + self.set_timeout(msg.recipient) return accept @@ -196,10 +217,18 @@ """ if not self.abusers[msg.sender].use_token(): if self.blacklist is not None: + logging.info("Blacklisting abusive user {}".format(msg.sender)) self.blacklist.blacklist(msg.sender.userhost(), self.abusecooloff) + else: + logging.info("Detected abusive user ({}) but unable to " + "blacklist. Dropping message instead".format( + msg.sender)) + return False + return True + @task(CRON_SENDAGAIN) def sendagain(self, user): """ Cron callback handler. Attempts to send as many messages as it can from @@ -207,28 +236,33 @@ """ sc = self.limiters[user] self.waitingusers.discard(user) + logging.info("Draining msg queue for {}, current len {}".format( + user, len(sc.queue))) while True: msg = sc.pop() if msg: - # Update the message to indicate it's sent from us (so we don't - # rate limit it again! - msg.sender = self - msg.send() + self.send(msg) else: break - self.set_timeout(user, time.time()) + self.set_timeout(user) - def set_timeout(self, user, now): + def send(self, msg): + # Update the message to indicate it's sent from us (so we don't + # rate limit it again! + msg.sender = self.name + msg.send() + + def set_timeout(self, user): """ Starts a cron timer if there are any messages queued for the given - user. the now argument is the current time (well, the time to assume is - now). + user. - The timer is always set for at least min_interval after the last - successful send to the given user (which gives an additional level of - delay. Maybe not useful, and should just use 1/fillrate?) + The timer is set for 1 / fillrate i.e. the time it takes for a single + token to be added to the bucket. """ + sc = self.limiters[user] - if len(sc.queue) > 0 and not user in self.waitingusers: + if len(sc.queue) > 0 and user not in self.waitingusers: self.waitingusers.add(user) - self.cron.setTimeout(self.fillrate / 1.0, user) + timedelta = 1.0 / self.fillrate + self.sendagain.setTimeout(timedelta, user) diff -Nru endroid-1.1.2/src/endroid/plugins/remote.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/remote.py --- endroid-1.1.2/src/endroid/plugins/remote.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/remote.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,202 @@ +# ----------------------------------------------------------------------------- +# EnDroid - Remote notification plugin +# Copyright 2012, Ensoft Ltd +# ----------------------------------------------------------------------------- + +import random +import string +import UserDict + +from endroid.database import Database +from endroid.pluginmanager import Plugin + +# Database and table names for the key database. +DB_NAME = "Remote" +DB_TABLE = "Keys" + +# Length and set of characters that make up keys. +KEY_LENGTH = 16 +KEY_CHARS = string.ascii_uppercase + string.digits + +# Templates for HTML responses. +FORM_PAGE = """ + + + +

+ + +""" + +ERROR_PAGE = """ + + + Error + +

Error

+ Error: {error_string} + + +""" + +# Message displayed by the help message. +HELP_MESSAGE = """ +Send messages to users via a web interface. A key is required to send +a user messages. The following commands are supported: + - allow remote: Generate a key to allow others to message you. + - deny remote: Delete a previously generated key. +""" + +class InputError(Exception): + pass + +class DatabaseDict(object, UserDict.DictMixin): + """ + Dict-like object backed by a sqlite DB. + """ + def __init__(self, db, table, key_column, val_column): + """ + db: Database to store the dictionary data. + table: Name of the table to store the dictionary data. + key_column: Name of the column to store dictionary keys. + val_column: Name of the column to store dictionary values. + """ + + self.db = db + self.table = table + self.key_column = key_column + self.val_column = val_column + + if not self.db.table_exists(self.table): + self.db.create_table(self.table, (key_column, val_column)) + + def keys(): + return (result[self.key_column] for key + in self.db.fetch(self.table, [self.key_column])) + + def __delitem__(self, key): + if key in self: + c = self.db.delete(self.table, {self.key_column: key}) + assert c == 1 + + def __setitem__(self, key, val): + if key in self: + c = self.db.update(self.table, + {self.key_column: key, self.val_column: val}, + {self.key_column: key}) + assert c == 1 + else: + self.db.insert(self.table, + {self.key_column: key, self.val_column: val}) + + def __getitem__(self, key): + results = self.db.fetch(self.table, + [self.key_column, self.val_column], + {self.key_column: key}) + assert len(results) <= 1 + if len(results) == 0: + raise KeyError(key) + return results[0][self.val_column] + +class RemoteNotification(Plugin): + name = "remote" + + def endroid_init(self): + com = self.get('endroid.plugins.command') + + com.register_chat(self.allow, ('allow', 'remote')) + com.register_chat(self.deny, ('deny', 'remote')) + + http = self.get('endroid.plugins.httpinterface') + http.register_path(self, self.http_request_handler, '') + + self.keys = DatabaseDict(Database(DB_NAME), DB_TABLE, "users", "keys") + + def help(self): + return HELP_MESSAGE + + def dependencies(self): + return ['endroid.plugins.command', + 'endroid.plugins.httpinterface'] + + @staticmethod + def _make_key(): + return ''.join(random.choice(KEY_CHARS) for x in range(KEY_LENGTH)) + + def allow(self, msg, arg): + jid = msg.sender + if jid in self.keys: + msg.reply("Remote notifications already allowed. (Your key is %s.)" + % self.keys[jid]) + else: + key = RemoteNotification._make_key() + self.keys[jid] = key + msg.reply("Remote notifications allowed. Your key is %s." % key) + + def deny(self, msg, arg): + jid = msg.sender + if jid in self.keys: + del self.keys[jid] + msg.reply("Remote notifications denied.") + else: + msg.reply("Remote notifications already denied. Nothing to do.") + + def _validate_args(self, args): + """ + Validate an args dict from a POST request. Validation includes: + * Checking expected arguments are present. + * Checking the user is in the database. + * Checking the key matches the user's. + + Raises: + InputError: If the args are invalid + """ + + req_args = ['user', 'key', 'message'] + missing_args = list(set(req_args) - set(args.keys())) + + if len(missing_args) > 0: + raise InputError("Missing arguments: %s" % ' '.join(missing_args)) + + # Arguments come in the form of singleton arrays. Do some preprocessing + # to extract only the first element. + args = dict((key, val[0]) for key, val in args.iteritems()) + + if args['user'] not in self.keys: + raise InputError("User {user} has not allowed remote messaging. " + "{user} can generate a key with " + "'allow remote'".format(**args)) + + if self.keys[args['user']] != args['key']: + raise InputError("Incorrect key provided for {user}" + .format(**args)) + + def http_request_handler(self, request): + """ + A callback from the httpinterface plugin. Renders a form to allow + sending a user a message. If POST data from the form is included + a message is sent, unless the input is invalid in which case an + error page is displayed. + """ + + try: + header_msg = '' + if request.method == 'POST': + self._validate_args(request.args) + + self.messagehandler.send_chat(request.args['user'][0], + "Remote notification received: %s" % request.args['message'][0]) + header_msg = \ + "Message delivered to %s
" % \ + request.args['user'][0] + + return FORM_PAGE.format(header_msg=header_msg) + except InputError as e: + return ERROR_PAGE.format(error_string=str(e)) + diff -Nru endroid-1.1.2/src/endroid/plugins/roomowner.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/roomowner.py --- endroid-1.1.2/src/endroid/plugins/roomowner.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/roomowner.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,80 @@ +import logging +from endroid.pluginmanager import Plugin +from twisted.internet.defer import DeferredList + + +class RoomOwner(Plugin): + + def endroid_init(self): + if self.place != "room": + return + + def owner_result(is_owner): + if not is_owner: + logging.error("EnDroid doesn't appear to be the owner for " + "room {}".format(self.place_name)) + return + + logging.debug("EnDroid owns room {}".format(self.place_name)) + + self._update_memberlist() + + # Apply the config + # @@@Config mark and sweep should be added here + # configure_room internally sanitises anything it gets + # allowing only predefined keys and ignoring the rest (so giving it + # our whole .vars dictionary is safe (and easy)) + self.usermanagement.configure_room(self.place_name, self.vars) + + # First check if EnDroid owns this room + d = self.usermanagement.is_room_owner(self.place_name) + d.addCallback(owner_result) + + def _get_configured_memberlist(self): + if 'users' in self.vars: + memberlist = set(self.vars['users']) + else: + # Check for old-style config + memberlist = self.usermanagement.get_configured_room_memberlist( + self.place_name) + + return memberlist + + def _update_memberlist(self): + """Update the member list of this room based on config.""" + + def parse_memberlist(results): + successes, results = zip(*results) + + if not all(successes): + # One of the calls failed + logging.error('Failed to get member or owner list for {}'. + format(self.place_name)) + return + + current_memberlist = set(results[0]) + current_ownerlist = set(results[1]) + conf_memberlist = self._get_configured_memberlist() + + logging.debug('Configured memberlist for room {}: {}'.format( + self.place_name, ", ".join(conf_memberlist))) + logging.debug('Current memberlist for room {}: {}'.format( + self.place_name, ", ".join(current_memberlist))) + logging.debug('Current ownerlist for room {}: {}'.format( + self.place_name, ", ".join(current_ownerlist))) + + # As another owner we can't perform any affiliation changes to + # existing owners so remove them from any lists + new_members = conf_memberlist - current_memberlist - current_ownerlist + dead_members = current_memberlist - conf_memberlist - current_ownerlist + if new_members: + self.usermanagement.room_memberlist_change( + self.place_name, new_members) + if dead_members: + self.usermanagement.room_memberlist_change( + self.place_name, dead_members, remove=True) + + # Get the current memberlist to determine what changes need to be made + d1 = self.usermanagement.get_room_memberlist(self.place_name) + d2 = self.usermanagement.get_room_ownerlist(self.place_name) + DeferredList([d1, d2]).addCallback(parse_memberlist) diff -Nru endroid-1.1.2/src/endroid/plugins/speak.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/speak.py --- endroid-1.1.2/src/endroid/plugins/speak.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/speak.py 2013-09-16 14:30:23.000000000 +0000 @@ -4,44 +4,32 @@ # Created by Jonathan Millican # ----------------------------------------- -from twisted.words.protocols.jabber.jid import JID -from endroid.pluginmanager import Plugin +from endroid.plugins.command import CommandPlugin -class Speak(Plugin): +class Speak(CommandPlugin): name = "speak" + help = ("Speak allows you to speak as EnDroid. Don't abuse it\n" + "Command syntax: speak ") - def dependencies(self): - return ['endroid.plugins.command'] - - def enInit(self): - com = self.get('endroid.plugins.command') - com.register_chat(self.do_speak, 'speak', ' ') - com.register_chat(self.do_many_speak, 'repeat', ' ') - - def do_speak(self, msg, args): - tojid, text = self.split(args) - if tojid in self.suc_users(): - self.send_chat(JID(tojid), text) + def cmd_speak(self, msg, args): + tojid, text = self._split(args) + if tojid in self.rosters.available_users: + self.messages.send_chat(tojid, text, msg.sender) else: msg.reply("You can't send messages to that user. Sorry.") + cmd_speak.helphint = " " - def do_many_speak(self, msg, args): + def repeat(self, msg, args): count, tojid, text = args.split(' ', 2) - if tojid in self.suc_users(): + if tojid in self.rosters.available_users: for i in range(int(count)): - self.send_chat(JID(tojid), text) + self.messages.send_chat(tojid, text, msg.sender) else: msg.reply("You can't send messages to that user. Sorry.") + repeat.helphint = " " - def split(self, message): + def _split(self, message): if message.count(' ') == 0: return (message, '') else: return message.split(' ', 1) - - def help(self): - return ("Speak allows you to speak as EnDroid. Don't abuse it\n" - "Command syntax: speak ") - -def get_plugin(): - return Speak() diff -Nru endroid-1.1.2/src/endroid/plugins/spell.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/spell.py --- endroid-1.1.2/src/endroid/plugins/spell.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/spell.py 2013-09-16 14:30:23.000000000 +0000 @@ -24,17 +24,13 @@ words marked with a '(sp?)' after them. """ name = "spell" + dependencies = ("endroid.plugins.patternmatcher",) + help = "Check spelling of words by typing '(sp?)' after them." - def enInit(self): + def endroid_init(self): pat = self.get("endroid.plugins.patternmatcher") pat.register_both(self.heard, REOBJ) - def dependencies(self): - return ('endroid.plugins.patternmatcher',) - - def help(self): - return "Check spelling of words by typing '(sp?)' after them." - def heard(self, msg): """ Checks spelling of all the matches. diff -Nru endroid-1.1.2/src/endroid/plugins/trains.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/trains.py --- endroid-1.1.2/src/endroid/plugins/trains.py 1970-01-01 00:00:00.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/trains.py 2013-09-16 14:30:23.000000000 +0000 @@ -0,0 +1,120 @@ +# ----------------------------------------- +# Endroid - Trains Live Departures +# Copyright 2013, Ensoft Ltd. +# Created by Martin Morrison +# ----------------------------------------- + +import re +import urllib +from HTMLParser import HTMLParser +from twisted.web.client import getPage + +from endroid.plugins.command import CommandPlugin, command + +TIMERE_STR = r'(\d+)(?::(\d+))? *(am|pm)?' +ULRE = re.compile(r'

*(.*?) *

|delete}") + def nearest_station(self, msg, args): + self._station_update(msg, args, STATION_TABLE, msg.sender_full, + "nearest") + + @command(helphint="{|delete}") + def home_station(self, msg, args): + self._station_update(msg, args, HOME_TABLE, msg.sender, "home") + + @command(helphint="from to [[arriving|leaving] at ]", + synonyms=("next train",)) + def train(self, msg, args): + match = CMDRE.match(args) + if not match: + msg.reply("Brain the size of a planet, but I can't parse that request") + return + + def extract_results(data): + results = RESULTRE.findall(ULRE.search(data).group(1)) + if results: + msg.reply(u"Trains from {} to {}: {}" + .format(src, dst, + HTMLParser().unescape(u", ".join(results)))) + else: + msg.reply("Either your request is malformed, or there are no matching trains") + + home, src, dst, typ, when, time, _,_,_ = match.groups() + time = self._canonical_time(time) if time is not None else time + if dst == "home" or home == "home": + rows = self.database.fetch(HOME_TABLE, ("station",), + {"jid": msg.sender}) + if rows: + dst = rows[0]['station'] + else: + msg.reply("You must save a home station with the 'home station'" + " command") + return + if src is None: + rows = self.database.fetch(STATION_TABLE, ("station",), + {"jid": msg.sender_full}) + if rows: + src = rows[0]['station'] + else: + msg.reply("You must either specify a source station, or save " + "a nearest station (with the 'nearest station' " + "command)") + return + url = "/{}/{}{}{}{}".format( + src, dst, ("/" + time) if time else "", + "a" if typ == "arriving" else "", + ("/" + when.replace(" ", "-")) if when else "") + getPage("http://www.traintimes.org.uk" + urllib.quote(url) + ).addCallbacks(extract_results, msg.unhandled) + + @staticmethod + def _canonical_time(time): + match = TIMERE.match(time.strip()) + assert match, "We've already checked this - how can it fail?!" + hour, minute, half = match.groups() + hour, minute = map(lambda n: int(n) if n else 0, (hour, minute)) + if half and half == 'pm': + if hour <= 12: + hour += 12 + if not minute: + minute = 0 + return "{}:{:02}".format(hour, minute) diff -Nru endroid-1.1.2/src/endroid/plugins/unhandled.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/unhandled.py --- endroid-1.1.2/src/endroid/plugins/unhandled.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/unhandled.py 2013-09-16 14:30:23.000000000 +0000 @@ -10,8 +10,9 @@ class UnHandled(Plugin): name = "unhandled" help = "I'm a personality prototype. You can tell, can't you...?" + hidden = True - messages = [ + _messages = [ "404 Error: message not found", "Command not found, perhaps it can be found in the bottom of a locked " "filing cabinet stuck in a disused lavatory with a sign on the door " @@ -38,7 +39,7 @@ self.register_unhandled_muc_callback(self.unhandled) def unhandled(self, msg): - messages = self.messages + messages = self._messages if date.weekday(date.today()) == 3: messages = messages[:] + ["This must be a Thursday, I could never " "get the hang of Thursdays"] diff -Nru endroid-1.1.2/src/endroid/plugins/whosonline.py endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/whosonline.py --- endroid-1.1.2/src/endroid/plugins/whosonline.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/plugins/whosonline.py 2013-09-16 14:30:23.000000000 +0000 @@ -4,46 +4,26 @@ # Created by Jonathan Millican # ----------------------------------------- -from twisted.words.protocols.jabber.jid import JID from endroid.pluginmanager import Plugin class WhosOnline(Plugin): name = "whosonline" + dependencies = ('endroid.plugins.command',) + help = "What? No. My name's not important. You must come with me, or you'll be late." - def dependencies(self): - return ['endroid.plugins.command'] - - def enInit(self): + def endroid_init(self): com = self.get('endroid.plugins.command') com.register_muc(self.show_online, 'whosonline') com.register_chat(self.show_online, 'whosonline') com.register_muc(self.show_rooms_in, 'listrooms') com.register_chat(self.show_rooms_in, 'listrooms') - self.presence = self.presence() def show_online(self, msg, arg): msg.reply(self.online_list()) def online_list(self): - out = "" - for i in self.presence.get_available(): - out = out + "\n" + i.userhost() - return out + return '\n' + '\n'.join(self.usermanagement.get_available_users()) def show_rooms_in(self, msg, arg): - if self.room_list(): - msg.reply(self.room_list()) - else: - msg.reply("I'm not in any rooms") - - def room_list(self): - out = "" - for i in self.presence.get_rooms(): - out = out + "\n" + i.userhost() - return out - - def help(self): - return "What? No. My name's not important. You must come with me, or you'll be late." - -def get_plugin(): - return WhosOnline() + rooms = self.usermanagement.get_available_rooms() or ["I'm not in any rooms!"] + msg.reply('\n' + '\n'.join(rooms)) diff -Nru endroid-1.1.2/src/endroid/rosterhandler.py endroid-1.2~68~ubuntu12.10.1/src/endroid/rosterhandler.py --- endroid-1.1.2/src/endroid/rosterhandler.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/rosterhandler.py 2013-09-16 14:30:23.000000000 +0000 @@ -4,62 +4,111 @@ # Created by Jonathan Millican # ----------------------------------------- -import logging +import logging -from wokkel.xmppim import RosterClientProtocol, PresenceProtocol +from endroid.usermanagement import JID +from wokkel.xmppim import RosterClientProtocol, PresenceClientProtocol, RosterItem -class RosterHandler(RosterClientProtocol, PresenceProtocol): + +class RosterHandler(RosterClientProtocol, PresenceClientProtocol): def __init__(self): RosterClientProtocol.__init__(self) - PresenceProtocol.__init__(self) + PresenceClientProtocol.__init__(self) self.deferred = None - - def set_usermanagement(self, um): - self.usermanagement = um - + + def set_presence_handler(self, um): + self.um = um + def setHandlerParent(self, parent): RosterClientProtocol.setHandlerParent(self, parent) - PresenceProtocol.setHandlerParent(self, parent) + PresenceClientProtocol.setHandlerParent(self, parent) - def set_loaded_handler(self, d): + def set_connected_handler(self, d): self.deferred = d def connectionInitialized(self): RosterClientProtocol.connectionInitialized(self) - PresenceProtocol.connectionInitialized(self) + PresenceClientProtocol.connectionInitialized(self) + + def purge_roster(roster, self): + # roster.keys() is a list of the users we are currently friends with. + for user in (item.userhost() for item in roster.keys()): + # if they have been removed from config since our last start + if not user in self.um.users(): + # get rid of them + self.um.deregister_user(user) + return roster # pass the roster on for further callbacks + rosterd = self.reRoster() + rosterd.addCallback(purge_roster, self) + if self.deferred: d, self.deferred = self.deferred, None rosterd.addCallback(d.callback) # Advertises as available - otherwise MUC will probably work # but SUC clients won't send messages on to EnDroid self.available() - + def reRoster(self): - d = self.getRoster() - d.addCallback(self.usermanagement.got_roster) - return d - -####################### -# This version of EnDroid is designed to be bashful so -# will simply ignore subscribe requests. Its contact list -# is simply determined by the config file -####################### -# def subscribeReceived(self, presence): -# PresenceProtocol.subscribeReceived(self, presence) -# # Accept subscription -# self.subscribed(presence.sender) -# # Send available -# self.available(presence.sender) -# # Add them -# UserManagement.add_contact(presence.sender) -# self.reRoster() - + return self.getRoster() + + def setItem(self, name): + if isinstance(name, RosterItem): + super(RosterHandler, self).setItem(name) + elif isinstance(name, (str, unicode)): + super(RosterHandler, self).setItem(RosterItem(JID(name))) + else: + raise TypeError("RosterHandler.setItem got invalid type") + + def removeItem(self, name): + logging.info("removeItem {}".format(name)) + super(RosterHandler, self).removeItem(JID(name)) + def subscribedReceived(self, presence): - PresenceProtocol.subscribedReceived(self, presence) - self.available(presence.sender) - self.reRoster() + PresenceClientProtocol.subscribedReceived(self, presence) + logging.info("Subscription request from {}".format(presence.userhost())) + if presence.userhost() in self.um.users(): + # this is generated when someone has confirmed our subscription request + # send a subscription _confirmation_ back (== authorizing in pidgin) + # (a wokkel API) + self.subscribed(presence) + # let the presence know that we are available (this does not affect + # subscription status) + self.available(presence) def probeReceived(self, presence): - PresenceProtocol.probeReceived(self, presence) + PresenceClientProtocol.probeReceived(self, presence) self.available() + + def availableReceived(self, entity, show=None, statuses=None, priority=0): + jid = JID(entity.full()) + userhost = jid.userhost() + logging.info("Available from {} '{}' priority: '{}'".format(jid, show, priority)) + # entity has come online - update our online set + if userhost in self.um.users(): + self.um.set_available(jid, show=show, priority=priority) + # make them available in their groups + for group in self.um.get_groups(userhost): + self.um.set_available(jid, group, show=show, priority=priority) + else: + # Probably a user entering a room EnDroid is in. + # If this is the case EnDroid will find out via a userJoinedRoom call + # on wokkelhandler + pass + + def unavailableReceived(self, entity, statuses=None): + jid = JID(entity.full()) + userhost = jid.userhost() + logging.info("Unavailable from {}".format(str(jid))) + # entity has gone offline - update our online set + if userhost in self.um.available_users(): + self.um.set_unavailable(jid) + # make them unavailable in their groups + for group in self.um.get_groups(userhost): + self.um.set_unavailable(jid, group) + else: + # Probably a user leaving a room EnDroid is in. + # If this is the case EnDroid will find out via a userLeftRoom call + # on wokkelhandler + pass + diff -Nru endroid-1.1.2/src/endroid/usermanagement.py endroid-1.2~68~ubuntu12.10.1/src/endroid/usermanagement.py --- endroid-1.1.2/src/endroid/usermanagement.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/usermanagement.py 2013-09-16 14:30:23.000000000 +0000 @@ -3,133 +3,789 @@ # Copyright 2012, Ensoft Ltd. # Created by Jonathan Millican # ----------------------------------------- -from twisted.words.protocols.jabber.jid import JID + import logging +import twisted.words.protocols.jabber.jid +from twisted.words.protocols.jabber.jid import InvalidFormat +from twisted.words.protocols.jabber.error import StanzaError +from endroid.pluginmanager import PluginManager +from random import choice +from collections import namedtuple + +# we use ADJECTIVES to generate a random new nick if endroid's is taken +ADJECTIVES = [ + "affronted", "annoyed", "antagonized", "bitter", "chafed", "convulsed", + "cross", "displeased", "enraged", "exasperated", "ferocious", "fierce", + "fiery", "fuming", "furious", "galled", "hateful", "heated", "impassioned", + "incensed", "indignant", "inflamed", "infuriated", "irascible", "irate", + "ireful", "irritated", "maddened", "offended", "outraged", "provoked", + "raging", "resentful", "splenetic", "storming", "vexed", "wrathful"] + +MUC = "muc#roomconfig_" + +Place = namedtuple("Place", ("type", "name")) -# -# Note: in this file a fair bit is commented out. This is functionality -# that was deliberately removed early on, but should be restored in a -# later revision, once EnDroid's behaviour is more flexible. (e.g. -# joining and leaving rooms dynamically, as opposed to on load-time -# from the config file). -# -class Presence(object): +class JID(twisted.words.protocols.jabber.jid.JID): """ - Object for plugins to access data from within UserManagement, without - exposing the lower level endroid functionality to plugins + Wrapper around twisteds JID class to provide more functionality. + + + Attributes: + Inherited from twisted: + user - the user part of the JID + host - the host part of the JID + resource - the resource part of the JID + Added by this class: + nick - nickname of this JID if in a room + + Methods: + Inherited from twisted: + full - string representation of the JID - user str(JID) instead + userhost - string representation of just the user and host + parts of this JID + userhostJID - a new JID object representing just the user and + host parts of this JID + """ - def __init__(self, usermanagement): - self._usermanagement = usermanagement - - def get_available(self): + + def __init__(self, str=None, tuple=None, nick=None, **kwargs): + self.nick = nick + super(JID, self).__init__(str=str, tuple=tuple, **kwargs) + + def __str__(self): + return self.full() + + +class Roster(object): + """ + Provides functions for maintaining sets of users registered with and + available in a contact list, user group or room. + + """ + def __init__(self, name=None, registration_cb=None, deregistration_cb=None): + self.name = name or "contacts" + + self._members = {} # dict of userhosts to full jid strings + self.registration_cb = registration_cb or (lambda a, b: None) + self.deregistration_cb = deregistration_cb or (lambda a, b: None) + + @property + def available(self): + # jids is a set of the resources on which a user is avaialbe + # if jids is empty then the user is unavailable + return set(u for (u, avs) in self._members.items() if avs) + + @property + def registered(self): + return set(self._members.keys()) + + def get_resources(self, name): + return self._members.get(name, {}) + + def set_registration_list(self, names): + # if we have a list callback then don't do sub-callbacks + for name in self.registered: + if not name in names: + self.deregister_user(name) + for name in names: + self.register_user(name) + + def register_user(self, name): + if not name in self._members: + self._members[name] = {} + self.registration_cb(name, self.name) + + def deregister_user(self, name): + self._members.pop(name, None) + self.deregistration_cb(name, self.name) + + def set_available(self, jid, show=None, priority=0): """ - Returns the set of available contacts + Mark a JID as available. + + jid should be a JID object + """ - return self._usermanagement.available - - def get_roster(self): + + logging.debug("{} available at resource {}".format(jid.userhost(), jid.resource)) + if jid.userhost() in self._members: + self._members[jid.userhost()][jid.full()] = Resource(show, priority) + + def set_unavailable(self, jid): """ - Returns the full roster + Mark a JID as unavailable. + + jid should be a JID object + """ - return self._usermanagement.roster - - def get_rooms(self): + + logging.debug("{} unavailable at resource {}".format(jid.userhost(), jid.resource)) + if jid.userhost() in self._members: + self._members[jid.userhost()].pop(jid.full(), None) + + def __repr__(self): + name = self.name or "contacts" + users = [u + ("(available)" if jids else "") + for (u, jids) in self._members.items()] + return "{}({}: {})".format(type(self).__name__, name, ', '.join(users)) + + +class Room(Roster): + config_default = {MUC + k : v for (k, v) in [ + ("allowinvites", False), + ("changesubject",True), + ("membersonly", True), + ("moderatedroom", True), + ("passwordprotectedroom", False), + ("persistentroom", False), + ("publicroom", False), + ("roomdesc", "An Endroid chatroom"), + ("roomname", "Ensoft"), + ] + } + # these are the user configurable options + config_options = { + 'password' : "roomsecret", + 'persistent' : "persistentroom", + 'name' : "roomname", + 'description' : "roomdesc", + } + + @staticmethod + def translate_options(options): + def translate(key): + return MUC + Room.config_options[key] + + do_password = options.get('password', False) + options = {translate(k): v for (k, v) in options.items() + if k in Room.config_options} + if do_password: + options[MUC + "passwordprotectedroom"] = True + return options + + def __init__(self, name, nick, password, um, *args, **kwargs): + self.nick = nick + self.password = password + + # Keep a reference to the usermanagement object + # @@@ Evil hack until the roomowner plugin can register for + # presence notifications - the UM ref is needed to kick + # unwanted members + self.um = um + + super(Room, self).__init__(name, *args, **kwargs) + + def set_available(self, user): """ - Returns the set of rooms that EnDroid is in + Mark a user as being available in a room. + + user is a JID object. + If the user isn't registered with the room they are kicked. + """ - return self._usermanagement.rooms + + logging.debug("{} ({}) joined room {}".format( + user.nick, user, self.name)) + if user.userhost() in self._members: + self._members[user.userhost()][user.full()] = Resource(False, 1) + else: + # This person shouldn't be here, kick + self.um.kick(room=self.name, nick=user.nick, reason="You are " + "not on the memberlist, sorry.") + + def set_unavailable(self, user): + """Process a user leaving a room.""" + + logging.debug("{} ({}) left room {}".format( + user.nick, user, self.name)) + if user.userhost() in self._members: + self._members[user.userhost()].pop(user.full(), None) + + +class Resource(object): + __slots__ = ("show", "priority") + + def __init__(self, show=None, priority=0): + self.show = show + self.priority = priority + + def __repr__(self): + name = type(self).__name__ + return "{0}(show='{1.show}', priority='{1.priority}'".format(name, self) class UserManagement(object): - """ - Object to keep track of who's online, and what rooms EnDroid is in. - Presence is handled in this. - """ - def __init__(self, rh, wh): - self.available = set() - self.rooms = set() - - self.roster = None - self.roster_handler = rh - self.roster_handler.set_usermanagement(self) - self.wokkel_handler = wh - self.wokkel_handler.set_usermanagement(self) - - self.presence = Presence(self) + """An abstraction of XMPP's presence protocols.""" + + JOIN_ATTEMPTS_MAX = 5 + + def __init__(self, wh, rh, config): + self.wh = wh + self.rh = rh + # as yet unused - is analagous to the _handlers attribute of + # messagehandler but will respond to presence notifications + self._handlers = {} + + self._pms = {} # a dict of {room/group names : pluginmanager objects} + + self.jid = None + self.jid_obj = None + # our contact list and room list + self._users = Roster(None, self._cb_add_contact, self._cb_rem_contact) + self._rooms = Roster() + # dictionaries of Roster objects for our groups and rooms + self.group_rosters = {} + self.room_rosters = {} + + self.conf = config + self._read_config(config) + + def _allowed_users(self, r_g, name): + """Get the set of allowed users for this room or group.""" + + # The config get could return an empty list e.g. if 'users=' + users = set(self.conf.get(r_g, name, "users", default=self.users())) + return users & self.users() + + def _read_config(self, config): + # Set our contact list and room list + self.jid = config.get("setup", "jid") + self.jid_obj = JID(self.jid) + self._users.set_registration_list(config.get("setup", "users", default=[])) + self._rooms.set_registration_list(config.get("setup", "rooms", default=[])) + + self.join_attempts = config.get("setup", "join_attempts", + default=self.JOIN_ATTEMPTS_MAX) + + nick = config.get("setup", "nick", default=self.jid_obj.user) + # Set contact lists for our rooms + for room in config.get("setup", "rooms", default=[]): + # What we need to join the room + # @@@ Evil hack until roomowner can be made a global plugin + # that triggers room joins + password = config.get("room", room, "plugin", + "endroid.plugins.roomowner", "password", + default="") + try: + users = config.get("room", room, "plugin", + "endroid.plugins.roomowner", "users") + users = set(users) & self.users() + except KeyError: + # User list may have been specified old style: + users = self._allowed_users('room', room) + self.room_rosters[room] = Room(room, nick, password, self) + self.room_rosters[room].set_registration_list(users) -# self._invite_cbs = [] + for group in config.get("setup", "groups", default=['all']): + self.group_rosters[group] = Roster(group) + users = self._allowed_users("group", group) + self.group_rosters[group].set_registration_list(users) - def got_roster(self, rost): + # rosterhandler receives presence notifications and gives them to us + self.rh.set_presence_handler(self) + self.wh.set_presence_handler(self) + + # @@@ The below two function are unused - but show the structure that should + # be used by register and call presence callbacks. + def register_callback(self): + # register functions to be called when we receive an 'online' or + # 'offline' notifications + pass + + def do_callback(self): + pass + + ### Function about users and groups ### + + # given a group or room or None (our contact list), return list of users + # registered/available there + def users(self, name=None): """ - Callback for when roster has been received from the server + Return an iterable of users registered with 'name'. + + If name is None, look in contact list. + """ - self.roster = rost + if name is None: + return self._users.registered + elif name in self.group_rosters: + return self.group_rosters[name].registered + elif name in self.room_rosters: + return self.room_rosters[name].registered + get_users = users - def init_contacts(self, contactInit): + def resources(self, name=None): """ - Called by __init__.py; contactInit is loaded from the config file - and is a list of contacts that should be in the roster. This - function enforces this strictly - adding any which are not in the - roster, and removing any from the roster which aren't in contactInit. + Return an iterable of full jids at which 'name' is available. + """ - for i in self.roster: - if not i in contactInit: - self.remove_contact(JID(i)) - for i in contactInit: - self.roster_handler.available(JID(i)) - if not self.roster.has_key(i): - self.add_contact(JID(i)) - -# def join_room(self, rjid): -# d = self.wokkel_handler.join(rjid, wokkel_handler.nick) -# d.addCallback(self.joined_room) -# return d -# - def joined_room(self, room): - self.rooms.add(room.roomJID) - logging.info("Joined Room: " + room.roomJID.userhost()) - - def left_room(self, rjid): - self.rooms.remove(rjid) - -# def register_invite_callback(self, callback): -# self._invite_cbs.append(callback) -# -# def receive_invite(self, room, user): -# for i in self._invite_cbs: -# i(room, user) - - def set_available(self, userJID): + if name is None: + return self.jid + else: + return self._users.get_resources(name) + + def available_users(self, name=None): """ - Record that user with JID userJID is available + Return an iterable of users present in 'name'. + + If name is None, look in contact list. + """ - isIn = False - self.roster_handler.available(userJID) - self.available.add(userJID) - - def set_unavailable(self, userJID): + if name is None: + return self._users.available + elif name in self.group_rosters: + return self.group_rosters[name].available + elif name in self.room_rosters: + return self.room_rosters[name].available + get_available_users = available_users + + # given a user or None (us), return list of groups/rooms the user is + # registered/available in + def groups(self, user=None): + """ + Return an iterable of groups 'user' is registered with. + + If user is None, return all registered groups. + + """ + return self._get_user_place(user, self.group_rosters, get_available=False) + get_groups = groups + + def available_groups(self, user=None): + """ + Return an iterable of groups 'user' is present in. + + If user is None, return all groups EnDroid is available in. + + """ + return self._get_user_place(user, self.group_rosters, get_available=True) + get_available_groups = available_groups + + def rooms(self, user=None): + """ + Return an iterable of rooms 'user' is registered with. + + If user is None, return all registered rooms. + + """ + return self._get_user_place(user, self.room_rosters, get_available=False) + get_rooms = rooms + + def available_rooms(self, user=None): + """ + Return an iterable of rooms 'user' is present in. + + If user is None, return all rooms EnDroid is available in. + + """ + return self._get_user_place(user, self.room_rosters, get_available=True) + get_available_rooms = available_rooms + + def _get_user_place(self, user, dct, get_available): + """ + Return the list of places in dct 'user' is available in + (if get_available) or registered with. + """ - Record that user with JID userJID is unavailable + user = self.get_userhost(user) + if user is None: + return dct.keys() + elif user in self.users(): + attr = "available" if get_available else "registered" + return [p for p in dct.keys() if user in getattr(dct[p], attr)] + else: + return [] + + def nickname(self, user, place=None): + """ + Given a user jid (user@ho.s.t) return the user's nickname in place, + or if place is None (default), the user part of the jid. + + """ + user_jid = JID(user) + if place is None or place in self.group_rosters: + return user_jid.user + elif place in self.room_rosters: + for (nick, rosteritem) in self.wh._rooms[JID(place)].roster.items(): + if user_jid.userhost() == rosteritem.entity.userhost(): + return nick + return "unknown" + get_nickname = nickname + + ### Functions for managing contact lists ### + + def register_user(self, name, place=None): + """ + Add a user to the 'member' list for our contacts (place=None) or in a + group or room. + + """ + if place is None: + self._users.register_user(name) + elif place in self.group_rosters: + self.group_rosters[place].register_user(name) + elif place in self.room_rosters: + self.room_rosters[place].register_user(name) + + def deregister_user(self, name, place=None): + """ + Remove a user from the 'member' list for our contacts (place=None) or + in a group or room. + + """ + if place is None: + self._users.deregister_user(name) + elif place in self.group_rosters: + self.group_rosters[place].deregister_user(name) + elif place in self.room_rosters: + self.room_rosters[place].deregister_user(name) + + def set_available(self, user, place=None, show=None, priority=0): + """ + Add a user to the 'available' list for our contacts (place=None) or in a + group or room. + + user should be a JID object + + """ + if place is None: + self._users.set_available(user, show, priority) + elif place in self.group_rosters: + self.group_rosters[place].set_available(user, show, priority) + elif place in self.room_rosters: + self.room_rosters[place].set_available(user) + else: + logging.error("User {} available but {} not in any roster".format( + user, place)) + + def set_unavailable(self, user, place=None): + """ + Add a user to the 'available' list for our contacts (place=None) or in a + group or room. + + user should be a JID object + + """ + if place is None: + self._users.set_unavailable(user) + elif place in self.group_rosters: + self.group_rosters[place].set_unavailable(user) + elif place in self.room_rosters: + self.room_rosters[place].set_unavailable(user) + else: + logging.error("User {} unavailable but {} not in any roster".format( + user, room)) + + # callbacks for adding/removing from our main contact list + def _cb_add_contact(self, name, _): + logging.info("Adding contact: {}".format(name)) + self.rh.setItem(name) + # send a subscribe request - confirmation in rosterhandler.subscribeReceived + self.rh.subscribe(JID(name)) + self.rh.available(JID(name)) + + def _cb_rem_contact(self, name, _): + logging.debug("Removing contact: {}".format(name)) + self.rh.removeItem(name) # sets the subscription to None both ways + logging.info("Removed {} from {}".format(name, "contacts")) + + ### Room functions + + # @@@ at the moment this assumes that if we failed to join a room it was because + # our nickname was taken - no provision for wrong passwords (should never be an + # issue) or other failures + def join_room(self, name, attempts=0): + """ + Attempt to join the room 'name'. On failure will try again with + different nicknames until attempts == join_attempts. + + """ + if not name in self.room_rosters: + return "Failed to join room {}: not allowed".format(name) + + def retry(failure, room, nick, attempts): + if attempts < self.join_attempts: + return self.join_room(room, attempts+1) + else: + return "Failed to join room {} as {}".format(room, nick) + def joined(_, room, nick, attempts): + if attempts: + self.kick(room, nick, "You've taken EnDroid's nick, " + "please reconnect with another nick") + self.wh.nick(JID(room), nick) + return "Joined room {} as {}".format(room, nick) + + room = self.room_rosters[name] + nick = room.nick + if attempts: # someone has stolen our nickname - generate a new one + nick += " ({} and {})".format(choice(ADJECTIVES), choice(ADJECTIVES)) + + d = self.wh.join(JID(name), nick, password=room.password) + d.addErrback(retry, name, room.nick, attempts) + d.addCallback(joined, name, room.nick, attempts) + + return d + + def kick(self, room, nick, reason=None): + """ + Kick the user with the specified nick from the room. + + Returns a deferred which can be monitored to determine if the kick was + successful. + + """ + + def success(_): + logging.info("Kicked {} from {} ({})".format(nick, room, reason)) + def failure(_): + logging.error("Failed to kick {} from {} ({})".format( + nick, room, reason)) + + return self.wh.kick(JID(room), nick, reason).addCallbacks(success, failure) + + def joined_room(self, name): + logging.info("Joined room {}".format(name)) + self._rooms.set_available(JID(name)) + if name not in self._pms: + self.start_pm(None, "room", name) + + def joined_group(self, name): + logging.info("Initialised group {}".format(name)) + if not name in self._pms: + self.start_pm(None, "group", name) + + # register a new pluginmanager (which will initialise plugins) in room or + # group 'name' + def start_pm(self, _, place, name): + self._pms[name] = PluginManager(self.wh.messagehandler, self, place, + name, self.conf) + + def connected(self): + self._pms[None] = PluginManager(self.wh.messagehandler, self, "global", + None, self.conf) + # Should join all rooms and groups here + # Currently called from elsewhere + + def join_all_rooms(self): + for room in self.get_rooms(): + d = self.join_room(room) + d.addCallback(lambda _, r: self.joined_room(r), room) + + # @@@ This function is in the wrong place. This is the room section + def join_all_groups(self): + for group in self.get_groups(): + self.joined_group(group) + + def room_modify_affiliation(self, room, users, affiliation): + """Update the affiliation list for this room.""" + + # Check that only EnDroid's contacts can be added to rooms + user_set = set(users) + un_reg_users = user_set - self.users() + if len(un_reg_users) > 0 and affiliation != 'none': + logging.warning('Attempt to allow {} unregistered user(s) ' + 'access to {}'.format(len(un_reg_users), room)) + + allowed_users = user_set & self.users() + + jids = [JID(user) for user in allowed_users] + d = self.wh.modifyAffiliationList(JID(room), jids, affiliation) + log_fmt = '{} affiliation for {} users in room {} to {}' + d.addCallback(lambda _: logging.info( + log_fmt.format('Changed', len(users), room, affiliation))) + d.addErrback(lambda _: logging.error( + log_fmt.format('Failed to change', len(users), room, + affiliation))) + return d + + def room_memberlist_change(self, room, users, remove=False): + if remove: + return self.room_modify_affiliation(room, users, 'none') + else: + return self.room_modify_affiliation(room, users, 'member') + + def configure_room(self, name, options): + """ + Set/modify the configuration of room 'name'. Options is a dictionary + of option names to values. Currently configurable options + (Room.config_options) are: password, persistent, name (roomname) and + description. + """ - isIn = False - self.available.remove(userJID) + def conf_failed(failure): + failure.trap(StanzaError) + logging.error("Failure configuring {}: code {}".format(name, + failure.value.code)) + + def cb(value): + logging.info("Configured {}".format(name)) + + mucoptions = Room.config_default.copy() + # options is a human-readable dict, we intersect with Room.config_options + # and translate into muc#roomconfig_xxx terms in translate_options + mucoptions.update(Room.translate_options(options)) + d = self.wh.configure(JID(name), mucoptions) + d.addCallback(cb) + d.addErrback(conf_failed) + return d + + def get_configuration(self, name): + """ + Return the configuration of a room. This will return a list of strings + representing option : value pairs in the configuration. + + """ + def form_to_string(form): + items = ((k.replace(MUC, ""), v) for (k, v) in form.items()) + return '\n'.join("{} : {}".format(k, v) for (k, v) in items) + + if name in self.get_rooms(): + d = self.wh.getConfiguration(JID(name)) + return d.addCallback(form_to_string) + + def is_room_owner(self, room): + """Find out if EnDroid is an owner for the specified room. """ + + def determine_if_owner(owner_list): + """True if EnDroid's userhost is in the owner list.""" + + return self.jid_obj.userhost() in owner_list + + def error_determining_ownership(failure): + # Re-raise the failure if its not a StanzaError + failure.trap(StanzaError) - def add_contact(self, userJID): + if failure.value.code == '403': + # This is the forbidden code - so no EnDroid doesn't own the + # room + return False + else: + # If it's any other error let the caller deal with it + logging.error("Error determining ownership of {}. Code " + "{}".format(room, failure.value.code)) + return failure + + if room in self.get_rooms(): + return self.get_room_ownerlist(room).addCallbacks( + determine_if_owner, error_determining_ownership) + else: + # Always return a deferred + return twisted.internet.defer.fail() + + def get_configured_room_memberlist(self, room): """ - Add a contact to EnDroid's roster + Return the list (if any) of configured members for this room. + + This is to support old style config where the user list was owned by + EnDroid core. + """ - logging.info("Adding contact: " + userJID.userhost()) - if not self.roster.has_key(userJID.userhost()): - self.roster_handler.subscribe(userJID) - self.roster_handler.available(userJID) - self.roster_handler.reRoster() - - def remove_contact(self, userJID): + return self._allowed_users('room', room) + + def _convert_admin_list(self, admin_list): + """Convert the list of AdminItems into userhosts.""" + + return [admin.entity.userhost() for admin in admin_list] + + def get_room_ownerlist(self, room): """ - Remove a contact from EnDroid's roster + Get the owner list for a room. + + Note: EnDroid must be room owner for this to work. + """ - logging.info("Removing contact: " + userJID.userhost()) - if self.roster.has_key(userJID.userhost()): - self.roster_handler.removeItem(userJID) - self.roster_handler.unsubscribe(userJID) - self.roster_handler.unsubscribed(userJID) + + if room in self.get_rooms(): + return self.wh.getOwnerList(JID(room)).addCallback( + self._convert_admin_list) + else: + # Always return a deferred + return twisted.internet.defer.fail() + + def get_room_memberlist(self, room): + """ + Get the member list for a room. + + Note: EnDroid must be room owner for this to work. + + """ + + if room in self.get_rooms(): + return self.wh.getMemberList(JID(room)).addCallback( + self._convert_admin_list) + else: + # Always return a deferred + return twisted.internet.defer.fail() + + def invite(self, user, room, reason=None): + """ + Invite a user to a room. + + Will only send invitation if the user is in our contact list and online, + and if the user is registered in the room but not currently in it. + + Returns a tuple (success, message) + + """ + user = self.get_userhost(user) + if not user in self.users(): + return (False, "User not registered") + elif not user in self.users(): + return (False, "User not available") + elif not room in self.get_rooms(user): + if not room in self.get_rooms(): + reason = "Room not registered" + else: + reason = "User not registered in room" + return (False, reason) + elif room in self.available_rooms(user): + return (False, "User already in room") + else: + for full_jid in self.resources(user): + self.wh.invite(JID(room), JID(full_jid), reason) + return (True, "Invitation sent") + + @staticmethod + def get_userhost(item): + """ + This is usually applied to a Message's sender attribute which we expect + to be a string or None. It will attempt to return a userhost string but + if it fails will just return the input. + + """ + try: + return JID(item).userhost() + # will raise a RuntimeError if item is None + # or an InvalidFormat if item is a string but not formatted properly + # If the item is not even a string, will raise AttributeError + except (RuntimeError, InvalidFormat, AttributeError): + return item + + def for_plugin(self, pluginmanager, plugin): + return PluginUserManagement(self, pluginmanager, plugin) + +class PluginUserManagement(object): + """ + One of these exists per plugin, provides the API to handle rosters. + """ + def __init__(self, usermanagement, pluginmanager, plugin): + self._usermanagement = usermanagement + self._pluginmanager = pluginmanager + self._plugin = plugin + + @property + def users(self): + return self._usermanagement.users(self._pluginmanager.name) + + @property + def available_users(self): + return self._usermanagement.available_users(self._pluginmanager.name) + + def nickname(self, user): + return self._usermanagement.nickname(user, self._pluginmanager.name) + + def invite(self, user, reason=None): + if self._pluginmanager.place != "room": + raise ValueError("Must be in a room to invite users") + return self._usermanagement.invite(user, self._pluginmanager.name, + reason=reason) diff -Nru endroid-1.1.2/src/endroid/wokkelhandler.py endroid-1.2~68~ubuntu12.10.1/src/endroid/wokkelhandler.py --- endroid-1.1.2/src/endroid/wokkelhandler.py 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid/wokkelhandler.py 2013-09-16 14:30:23.000000000 +0000 @@ -4,54 +4,73 @@ # Created by Jonathan Millican # ----------------------------------------- -from endroid.messagehandler import Message -from endroid.cron import Cron -import logging +import re, logging +from twisted.internet.task import LoopingCall from wokkel.muc import MUCClient from wokkel.xmppim import MessageProtocol -from twisted.words.protocols.jabber.jid import JID -from twisted.internet.task import LoopingCall -from twisted.internet.defer import DeferredList, Deferred, inlineCallbacks +from endroid.messagehandler import Message +from endroid.usermanagement import JID +from endroid.cron import Cron + +# See Section 2.2 of XML spec +_naughty_xml = re.compile( + u'[\x00-\x08\x0b\x0c\x0e-\x1f\ud800-\udfff\ufffe\uffff]') + +def sanitize_xml(stanza): + """ + Turn any body output that doesn't conform to section 2.2 of the XML + standard into a '__?__' string, rather than provoke our XMPP + peer into kicking us out with an xml-not-well-formed error. + """ + sanitized = _naughty_xml.sub('__?__', stanza) + if sanitized != stanza: + logging.error("Correcting XML '{}' to '{}'".format(stanza, sanitized)) + return sanitized + + +# MUCClient provides muc messaging + room handling +# MessageProtocol provides suc messaging class WokkelHandler(MUCClient, MessageProtocol): - def __init__(self, jid, nick, rooms): + def __init__(self): MUCClient.__init__(self) MessageProtocol.__init__(self) - self.nick = nick - self.jid = jid.userhost() - self.rooms = rooms self.messagehandler = None + self.usermanagement = None self.deferred = None self.keepalive = LoopingCall(self.send, " ") - + + self.jid = None + def set_connected_handler(self, d): self.deferred = d def set_message_handler(self, mh): self.messagehandler = mh - - def set_usermanagement(self, um): + + def set_presence_handler(self, um): self.usermanagement = um + self.jid = self.usermanagement.jid_obj - @inlineCallbacks + # called when the xml stream has been initialized + # use to do further initialization work def connectionInitialized(self): + # adds MUCClientProtocol._onGroupChat to the xmlstream observers + # notified by GROUPCHAT = "/message[@type="groupchat"]" MUCClient.connectionInitialized(self) + # adds MessageProtocol._onMessage to the xmlstream observers + # notified by "/message" i.e. anything MessageProtocol.connectionInitialized(self) - self.keepalive.start(300) logging.info("Connected to XMPP") - roomjoinds = [] - for rjid, rconf in self.rooms.items(): - rnick = rconf.get('nick', self.nick) - logging.info("Joining Room " + rjid + " as \"" + rnick + "\"") - d = self.join(JID(rjid), rnick) - d.addCallback(self.usermanagement.joined_room) - roomjoinds.append(d) - yield DeferredList(roomjoinds) + self.usermanagement.join_all_rooms() + self.usermanagement.join_all_groups() + + # we start the cron here, then cancel it in connectionLost Cron.get().do_crons() if self.deferred: @@ -63,19 +82,9 @@ logging.warning("Lost connection to XMPP") Cron.get().cancel() - def receivedGroupChat(self, room, user, message): - MUCClient.receivedGroupChat(self, room, user, message) - if hasattr(user, 'nick') and hasattr(user, 'entity'): - - m = Message('muc', user.entity, message.body, self.messagehandler, - rjid=room.roomJID, sendernick=user.nick) - if not user.entity.userhost() == self.jid: - logging.debug('MUC Message received from: ' + user.entity.userhost()) - self.messagehandler.receive_muc(m) - else: - logging.debug('MUC Message received from self') - self.messagehandler.receive_self_muc(m) + # called by _onMessage whenever a stanza of type "/message" is received + # we use it to pass the message onto our messagehandler def onMessage(self, message): MessageProtocol.onMessage(self, message) if message.hasAttribute('type'): @@ -84,54 +93,97 @@ sender = JID(message.attributes['from']) recipient = JID(message.attributes['to']) for i in message.children: - if i.name == 'body': + # Note: in theory multiple bodies are allowed; in practice, + # this isn't seen, so just get the first one. + if getattr(i, "name", "") == 'body': body = i.children[0] - - if not (body == None or sender == None or recipient == None): - m = Message('chat', sender, body, self.messagehandler) - if sender.userhost() == self.jid: + break + + if not (body is None or sender is None or recipient is None): + # Use the full JIDs here so that if a user is logged on + # from multiple resources, we know which one sent the + # message + m = Message("chat", sender.full(), body, + self.messagehandler, recipient.full()) + # Only check the userhost for self because we might not + # know endroid's resource + if sender.userhost() == self.jid.userhost(): + logging.info('SUC Message received from self') self.messagehandler.receive_self_chat(m) else: + logging.info('SUC Message received from {}'.format( + sender.full())) self.messagehandler.receive_chat(m) - else: - if message.children[0].children[0].name == "invite": - ujid = message.children[0].children[0].attributes['from'] + elif len(message.children) > 0: + # Try and identify this message type + msg_child = message.children[0] + if (msg_child.name == 'x' and len(msg_child.children) > 0 and + msg_child.children[0].name == 'invite'): + # Looks like an invite + ujid = msg_child.children[0].attributes['from'] rjid = message.attributes['from'] logging.info("Invitation received to " + rjid + " from " + ujid) - logging.info("Rejected. To enable uncomment receiving line and enable InviteBot") + logging.info(("Rejected. To enable uncomment receiving " + "line and enable InviteBot")) + elif (msg_child.name == 'body' and len(msg_child.children) > 0 and + 'granted' in msg_child.children[0]): + logging.info("Received affiliation change message: {}".format( + msg_child.children[0])) + else: + logging.error("Received unknown message with child: " + "{}".format(message.toXml())) + else: + logging.error("Received unknown message: {}".format(message.toXml())) + # MUCClient methods to be overridden - def availableReceived(self, presence): - logging.debug("Receive available request from " + str(presence)) - MUCClient.availableReceived(self, presence) - jid = WokkelHandler.getuserjid(presence) - if not jid.userhost() == self.jid: - # Note that this person is available - self.usermanagement.set_available(jid) - - def unavailableReceived(self, presence): - logging.debug("Receive unavailable request from " + str(presence)) - MUCClient.unavailableReceived(self, presence) - if presence.mucStatuses: - if presence.mucStatuses.pop().name == "KICKED": - # In this case, we we want presence.sender.userhostJID (room - # JID, rather than JID of kicker) - self.usermanagement.left_room(presence.sender.userhostJID()) - else: - # Note that this person is unavailable - self.usermanagement.set_unavailable(WokkelHandler.getuserjid(presence)) + def userJoinedRoom(self, room, user): + user_obj = JID(user.entity.full(), nick=user.nick) + if user_obj.userhost() == self.jid.userhost(): + # This is EnDroid joining a room nothing to do + pass else: - self.usermanagement.set_available(WokkelHandler.getuserjid(presence)) + self.usermanagement.set_available(user_obj, + room.roomJID.userhost()) + + def userLeftRoom(self, room, user): + user_obj = JID(user.entity.full(), nick=user.nick) + self.usermanagement.set_unavailable(user_obj, + room.roomJID.userhost()) + + def userUpdatedStatus(self, room, user, show, status): + pass + + # new room subject received + def receivedSubject(self, room, user, subject): + pass - @staticmethod - def getuserjid(presence): - """ - This will return the JID of the user involved. Anything received in MUC will have - presence.sender as group@serv.er/UserNick, and presence.entity as the user who - actually sent it. - """ - if not presence.entity == None: - jid = presence.entity.userhostJID() + def receivedGroupChat(self, room, user, message): + MUCClient.receivedGroupChat(self, room, user, message) + if user is None: + logging.info('Received group chat with none user - ' + 'perhaps from a room? : {}'.format(message.body)) + return + + sender_jid = user.entity.full() + room_userhost = room.roomJID.userhost() + + m = Message("muc", sender_jid, message.body, + self.messagehandler, room_userhost) + + if user.entity.userhost() == self.jid.userhost(): + logging.info('MUC Message received in {} from self'.format(room_userhost)) + self.messagehandler.receive_self_muc(m) else: - jid = presence.sender.userhostJID() - return jid + logging.info('MUC Message received in {} from: {} ({})'.format( + room_userhost, sender_jid, user.nick)) + self.messagehandler.receive_muc(m) + + def receivedHistory(self, room, user, message): + pass + + def chat(self, jid, body): + return super(WokkelHandler, self).chat(jid, sanitize_xml(body)) + + def groupChat(self, jid, body): + return super(WokkelHandler, self).groupChat(jid, sanitize_xml(body)) diff -Nru endroid-1.1.2/src/endroid.sh endroid-1.2~68~ubuntu12.10.1/src/endroid.sh --- endroid-1.1.2/src/endroid.sh 2012-09-04 12:12:59.000000000 +0000 +++ endroid-1.2~68~ubuntu12.10.1/src/endroid.sh 2013-09-16 14:30:23.000000000 +0000 @@ -1,2 +1,20 @@ -#!/bin/sh -PYTHONPATH="../lib/wokkel-0.7.0-py2.7.egg":"${PYTHONPATH}" python -c "import endroid; endroid.main()" $@ +#!/bin/bash + +if [ -z "$ENDROID" ]; then + # Try and work out the path based on location of this script + # This assumes this script hasn't been moved out of the repo + # Note: this might not work in all cases but this only going to be + # used in the dev phase so good enough + ENDROID="$( cd $( dirname "$0" ) && cd .. && pwd )" +fi + +if [ -z "$ENDROID_PLUGINS" ]; then + # Default to looking in ~/.endroid/plugins/ for plugins + ENDROID_PLUGINS="${HOME}/.endroid/plugins" +fi + +export PYTHONPATH="${ENDROID}/lib/wokkel-0.7.1-py2.7.egg":"${ENDROID}/src/":"${ENDROID_PLUGINS}":"${PYTHONPATH}" +echo "Running endroid at ${ENDROID} with plugins at ${ENDROID_PLUGINS}" +echo "Setting PYTHONPATH=${PYTHONPATH}" +python -m endroid "$@" +