Merge lp:~slimey/endroid/hi5 into lp:endroid

[Simon C]

Move High Five plugin over from Ensoft proprietary repo and upgrade with added awesomeness. Absolutely no overkill here.

Upgrade of High Five plugin:

 - moving from Ensoft-proprietary to open source
 - you can no longer hi5 yourself
 - you can hi5 multiple people with the same compliment
 - you can omit the domain part of the JID if EnDroid can unambiguously resolve this
 - optional asymmetric encryption of messages as a last-resort backstop against idiots

Note that this entails a non-backwards-compatible database schema change for those installations with the previous Ensoft plugin.

Incorporates review comments.

[Martin Morrison (isoschiz)]

Can anyone say "overkill"? ;-)

- The executable should have a main function, and should use argparse to parse the args so that it doesn't just splurge an exception when miscalled

- reference to spelunk script in docstring uses the .py suffix

- you've used "except Exception as e" but then not used e. It's quite a bit cheaper to not specify the variable to bind to in that case.

- your xrange-based joiner is very unpythonic. Instead, try something like:

if len(jids) > 1:
    jidlist = ' & '.join([', '.join(jids[:-1])] + jids[-1:])
else:
    jidlist = jids[0]

Might even be possible to eliminate the if.

- the have/has code is a prime candidate for the ternary if

review: Needs Fixing

[Martin Morrison (isoschiz)]

review: Approve

=== added file 'bin/spelunk_hi5s'
--- bin/spelunk_hi5s	1970-01-01 00:00:00 +0000
+++ bin/spelunk_hi5s	2013-09-10 19:44:32 +0000
@@ -0,0 +1,53 @@
+#!/usr/bin/python
+#
+# Decrypt hi5s
+#
+# This is all a last-resort mechanism (the whole point of hi5s is that they're
+# anonymous). The EnDroid database (eg /var/lib/endroid/endroid.db) is the only
+# required command-line parameter.
+#
+# Copyright (C) Ensoft 2013
+# Created by SimonC
+
+import argparse, sqlite3
+from getpass import getpass
+from subprocess import Popen, PIPE
+
+HI5_DB = 'hi5_hi5s'
+
+def set_params():
+    """
+    Set all parameters
+    """
+    parser = argparse.ArgumentParser(description=
+                                     'Spelunk encrypted high five messages')
+    parser.add_argument('--keyring', help='gpg secret keyring')
+    parser.add_argument('db_file', help='path to endroid.db')
+    args = parser.parse_args()
+    args.passphrase = getpass('Enter passphrase: ')
+    return args
+
+def main():
+    args = set_params()    
+    conn = sqlite3.connect(args.db_file)
+    cur = conn.cursor()
+    cur.execute('select * from ' + HI5_DB)
+    for row in cur.fetchall():
+        gpg_args = ['gpg', '--decrypt', '--armor', '--passphrase-fd', '0',
+                    '--batch', '--quiet']
+        if args.keyring:
+            gpg_args.extend(('--secret-keyring', args.keyring))
+        p = Popen(gpg_args, stdin=PIPE, stdout=PIPE)
+        p.stdin.write(args.passphrase + '\n')
+        out, err = p.communicate(row[-1])
+        p.wait()
+        if err:
+            print '!! ERROR:', err
+        elif p.returncode != 0:
+            # No encrypted data, so display what we have
+            print '{}: {}'.format(row[2], row[1])
+        else:
+            print out
+
+if __name__ == '__main__':
+    main()

=== modified file 'debian/endroid.install'
--- debian/endroid.install	2013-08-29 16:00:37 +0000
+++ debian/endroid.install	2013-09-10 19:44:32 +0000
@@ -3,6 +3,7 @@
 etc/init/endroid.conf etc/init/
 bin/endroid usr/bin/
 bin/endroid_remote usr/bin/
+bin/spelunk_hi5s usr/sbin/
 lib/wokkel-0.7.1-py2.7.egg usr/lib/endroid/dependencies
 var/endroid.db var/lib/endroid/db
 doc/EnDroid.png usr/share/endroid/media/

=== modified file 'etc/endroid.conf'
--- etc/endroid.conf	2013-08-30 17:48:34 +0000
+++ etc/endroid.conf	2013-09-10 19:44:32 +0000
@@ -45,6 +45,7 @@
   endroid.plugins.coolit
   endroid.plugins.correct
   endroid.plugins.exec
+  endroid.plugins.hi5
   endroid.plugins.remote
   endroid.plugins.theyfightcrime
   endroid.plugins.whosonline
@@ -66,6 +67,7 @@
   endroid.plugins.compute
   endroid.plugins.coolit
   endroid.plugins.exec
+  endroid.plugins.hi5
   endroid.plugins.memo
   endroid.plugins.remote
   endroid.plugins.theyfightcrime
@@ -103,6 +105,13 @@
 # and then put it below - good for 2000 free queries/month.
 #api_key = 123ABC-DE45FGJIJK
 
+[ group | room : * : plugin : endroid.plugins.hi5 ]
+# Configure one or more chatrooms to broadcast anonymous High Fives
+#broadcast = [e-mail],
+# Configure GPG to asymmetrically encrypt logs if desired, with
+# both the keyring containing the public key and the userid to encrypt for
+#gpg = /home/admin/.gnupg/pubring.gpg, [e-mail]
+
 [ group | room : * : plugin : endroid.plugins.exec ]
 # Configure commands that just spawn a process and send the output.
 # Format:

=== added file 'src/endroid/plugins/hi5.py'
--- src/endroid/plugins/hi5.py	1970-01-01 00:00:00 +0000
+++ src/endroid/plugins/hi5.py	2013-09-10 19:44:32 +0000
@@ -0,0 +1,191 @@
+# 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 [e-mail] Nice presentation dude!
+
+    which, if [e-mail] 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
+    [e-mail] 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 [e-mail], 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',
+                        '--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 [e-mail], 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 ' [e-mail], frodo, sam great job! ' into
+        (['[e-mail]', '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)
+