Merge lp:~ben-hutchings/endroid/presence into lp:endroid

[Martin Morrison]

Rosterhandler pushes up more information about available presences - now storing the priority and status of resources.

The broadcast plugin can be configured to the following levels:
 - all: broadcast to all a user's available resources
 - positive: broadcast to all a user's available resources with positive (or zero) priorities
 - max: broadcast to the user's highest priority resource
 - none: do not broadcast (leave it up to the server)

This should allow EnDroid to emulate the most common server behaviours when it comes to sending messages.

Rosterhandler pushes up more information about available presences - now storing the priority and status of resources.

The broadcast plugin can be configured to the following levels:
 - all: broadcast to all a user's available resources
 - positive: broadcast to all a user's available resources with positive (or zero) priorities
 - max: broadcast to the user's highest priority resource
 - none: do not broadcast (leave it up to the server)

This should allow EnDroid to emulate the most common server behaviours when it comes to sending messages.

[Martin Morrison (isoschiz)]

usermanagement and rosterhandler changes are logically nice. However, the implementation is a little too voodoo for my liking. :-)

I think it's as simple as turning _members[userhost] from a set of magic (and error-prone) Resource object into a dictionary of full_jid -> "properties" (which can be as simple as a tuple of (show, priority)). This would make the "updating" look less magic, without any loss of functionality.

In the broadcast plugin, the StringKeys stuff is a little nasty too. You can get the same behaviour with the simpler:

class Level(object):
    NONE = "none"
    ALL = "all"
    POSITIVE = "positive"
    MAX = "max"

Which incidentally is also closer to the true enum support that now exists in Python 3.4.

[Ben Hutchings (ben-hutchings)]

Done all this and added a bit more nice functionality to the plugin.
Ben

On 10/08/2013 21:22, Martin Morrison wrote:
> usermanagement and rosterhandler changes are logically nice. However, the implementation is a little too voodoo for my liking. :-)
>
> I think it's as simple as turning _members[userhost] from a set of magic (and error-prone) Resource object into a dictionary of full_jid -> "properties" (which can be as simple as a tuple of (show, priority)). This would make the "updating" look less magic, without any loss of functionality.
>
>
> In the broadcast plugin, the StringKeys stuff is a little nasty too. You can get the same behaviour with the simpler:
>
> class Level(object):
> NONE = "none"
> ALL = "all"
> POSITIVE = "positive"
> MAX = "max"
>
> Which incidentally is also closer to the true enum support that now exists in Python 3.4.

[Martin Morrison (isoschiz)]

Ideally the new plugin would be migrated to some of the new APIs that are being collapsed as well, but accepting this as is for now.

One change that could be made is that Resource is effectively just a namedtuple - and using namedtuple would make the code slightly shorter/simpler.

review: Approve

[Martin Morrison (isoschiz)]

No proposals found for merge of lp:~ben-hutchings/endroid/roomowner into lp:endroid.

[Martin Morrison (isoschiz)]

Approving resubmit (which was to remove dependent branch that was confusing tarmac)

review: Approve

=== added file 'src/endroid/plugins/broadcast.py'
--- src/endroid/plugins/broadcast.py	1970-01-01 00:00:00 +0000
+++ src/endroid/plugins/broadcast.py	2013-08-15 18:05:18 +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.users.get_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    

=== modified file 'src/endroid/rosterhandler.py'
--- src/endroid/rosterhandler.py	2013-08-06 13:52:29 +0000
+++ src/endroid/rosterhandler.py	2013-08-15 18:05:18 +0000
@@ -47,11 +47,8 @@
             rosterd.addCallback(d.callback)
         # Advertises as available - otherwise MUC will probably work
         # but SUC clients won't send messages on to EnDroid
-        self.set_available()
+        self.available()
 
-    def set_available(self, entity=None):
-        super(RosterHandler, self).available(entity)
-        
     def reRoster(self):
         return self.getRoster()
 
@@ -77,21 +74,21 @@
             self.subscribed(presence)
         # let the presence know that we are available (this does not affect 
         # subscription status)
-        self.set_available(presence)
+        self.available(presence)
         
     def probeReceived(self, presence):
         PresenceClientProtocol.probeReceived(self, presence)
-        self.set_available()
+        self.available()
 
     def availableReceived(self, entity, show=None, statuses=None, priority=0):
         userhost, full_jid = entity.userhost(), entity.full()
         logging.info("Available from {} '{}' priority: '{}'".format(full_jid, show, priority))
         # entity has come online - update our online set
         if userhost in self.um.users.registered:
-            self.um.users.set_available(full_jid)
+            self.um.users.set_available(full_jid, show, priority)
             # make them available in their groups
             for group in self.um.get_groups(userhost):
-                self.um.group_rosters[group].set_available(full_jid)
+                self.um.group_rosters[group].set_available(full_jid, show, priority)
 
     def unavailableReceived(self, entity, statuses=None):
         userhost, full_jid = entity.userhost(), entity.full()

=== modified file 'src/endroid/usermanagement.py'
--- src/endroid/usermanagement.py	2013-08-14 18:45:45 +0000
+++ src/endroid/usermanagement.py	2013-08-15 18:05:18 +0000
@@ -41,14 +41,14 @@
     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, jids) in self._members.items() if jids)
+        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, set())
+        return self._members.get(name, {})
 
     def set_registration_list(self, names):
         # if we have a list callback then don't do sub-callbacks
@@ -60,24 +60,24 @@
 
     def register_user(self, name):
         if not name in self._members:
-            self._members[name] = set()
+            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, full_jid):
+    def set_available(self, full_jid, show=None, priority=0):
         userhost = UserManagement.get_userhost(full_jid)
         logging.debug("{} came online as {}".format(userhost, full_jid))
         if userhost in self._members:
-            self._members[userhost].add(full_jid)
+            self._members[userhost][full_jid] = Resource(show, priority)
 
     def set_unavailable(self, full_jid):
         userhost = UserManagement.get_userhost(full_jid)
         logging.debug("{} went offline as {}".format(userhost, full_jid))
         if userhost in self._members:
-            self._members[userhost].discard(full_jid)
+            self._members[userhost].pop(full_jid, None)
 
     def __repr__(self):
         name = self.name or "contacts"
@@ -127,6 +127,16 @@
         self.deferreds = []
         super(Room, self).__init__(name, *args, **kwargs)
 
+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):
     """An abstraction of XMPP's presence protocols."""
@@ -352,7 +362,7 @@
         self.rh.setItem(name)
         # send a subscribe request - confirmation in rosterhandler.subscribeReceived
         self.rh.subscribe(JID(name))
-        self.rh.set_available(JID(name))
+        self.rh.available(JID(name))
 
     def _cb_rem_contact(self, name, _):
         logging.debug("Removing contact: {}".format(name))