root/foreignclient.py

# -*- coding: utf-8 -*-
# vi: sts=4 et sw=4

from common import debug
from xmpp.client import Client
from xmpp.protocol import JID, Presence, NS_PRESENCE, NS_IQ, NodeProcessed
import threading
try:
    from xmpp.jep0106 import JIDEncode
except ImportError:
    debug("Using embedded jep0106 module")   # Old versions of xmpppy
    from jep0106 import JIDEncode            # don't provide this module

class ConnectionError(Exception): pass

class ForeignClient(threading.Thread):
    '''A connection to a Jabber account, as a client.'''

    def __init__(self, jid, password, resource, registerer, pizzjaInstance):
        '''Constructor. Initiates a new account from the given information.
        '''
        threading.Thread.__init__(self, name=registerer)
        debug('Initializing client for %s/%s, registered by %s' \
              % (jid, resource, registerer))
        self.jid = jid
        self.password = password
        self.resource = resource
        self.registerer = registerer
        self.component = pizzjaInstance
        self.cnx = Client(JID(self.jid).getDomain(), debug=['socket'])
        self.isConnected = self.cnx.isConnected
        self.presence = Presence()
        self.bye = False
        self.controllers = {} # {'Home/Amarok': -42, 'Home/sendxmpp': 1}

    def run(self):
        '''This method is run when self.start() is called. It overrides the
        default Thread.run() method. It processes incoming stanzas in a loop
        until disconnection.
        '''
        debug('Client starts looping.')
        while not self.bye:
            self.cnx.Process(10)
        self.onDisconnect()
        debug('Disconnected. Client stopped looping.')

    def disconnect(self):
        self.bye = True

    def connect(self):
        '''Try to connect and auth, then pass every incoming stanza to the
           main component. If the connection fails, simulate onDisconnect()
           event, which will have the component clean us up.
        '''
        #TODO: Don't crash because of invalid accounts, cf. ticket #5.
        #TODO: In the future, we might want to call start() earlier for
        #      performance reasons: until we call start(), the process is
        #      blocking.
        debug('Registering disconnect handler')
        self.cnx.RegisterDisconnectHandler(self.onDisconnect)
        if not self.cnx.connect():
            debug('Could not connect.')
            self.onDisconnect()
            raise ConnectionError('Unable to connect')
        debug('Connection OK.')
        if not self.cnx.auth(self.jid, self.password, self.resource):
            debug('Could not auth. Disconnecting.')
            self.cnx.disconnect()
            raise ConnectionError('Unable to authenticate as %s' % (self.jid))
        debug('Authentified OK. Registering handlers.')
        self.cnx.RegisterHandler(NS_IQ, self.iqReceived)
        self.cnx.RegisterDefaultHandler(self.stanzaReceived)
        debug('Start listening (in a separate thread)')
        self.start()
        debug('Thread started. Life is going on.')

    def iqReceived(self, cnx, iq):
        '''When an IQ is received, decide what resource it should be
           forwarded to, then pass it to the component.
           - get/set: pick the most appropriate recipient. Reply with error
             service-unavailable if no appropriate recipient is found.
           - result/error: retrieve who sent the initial IQ get/set (ignore
             if not found).
        '''
        debug('An IQ was received.')
        resource = None
        if iq.getType() in ['get', 'set']:
            debug('IQ get or set, picking a recipient...')
            resource = self.pickIqRecipient(iq)
            debug('... %s will do the job.' % resource)
            if resource is None:
                debug('Apologizing, nobody can handle the IQ.')
                cnx.send(Error(iq, 'service-unavailable'))
        elif iq.getType() in ['result', 'error']:
            debug('IQ result or error, we should retrieve the initial sender.')
            try:
                resource = self.sentIQs.pop(iq.getId())
                debug('Found, the sender was %s.')
            except KeyError:
                debug('Unknown IQ response with id %s. Ignoring.' % iq.getId())
        if resource is not None:
            jid = '%s/%s' % (self.registerer, resource)
            debug('Now we have a recipient (%s), forwarding IQ.' % (jid))
            self.component.forwardStanzaIn(iq, [jid])
        debug('All right, IQ forwarded.')
        raise NodeProcessed

    def stanzaReceived(self, cnx, stz):
        '''When a stanza (other than IQ) is received, forward it to all the
           controllers.'''
        debug('A presence or message was received, forwarding in to everyone.')
        self.component.forwardStanzaIn(stz, self.getControllers())

    def send(self, stz):
        '''Send the specified stanza on the client's connection.
           For IQs get/set, remember which resource sent it.
           When sending presence, remember it, and have the component reflect
           it to the controlling resources.
        '''
        debug('About to send a stanza as a client.')
        id = self.cnx.send(stz)
        debug('Stanza sent, id was %s' % id)
        if stz.getName() == NS_IQ and stz.getType() in ['get', 'set']:
            debug('It was an IQ get or set, recording id for the answer.')
            self.sentIQs[id] = stz.getFrom().getResource()
        elif stz.getName() == NS_PRESENCE and \
           stz.getType() not in ['subscribe', 'subscribed', 'unsubscribe',
                                 'unsubscribed', 'probe', 'error']:
            debug('It was an presence change, reflecting it locally.')
            self.presence = stz
            self.component.reflectClientPresence(self)
        return id

    def onDisconnect(self):
        '''When disconnected, inform the component. Also Update self.presence
           so that the component can reflect it to all controllers.
        '''
        debug('Disconnect handler called, setting client unavailable presence',
              'and informing the component.')
        self.presence = Presence(typ='unavailable')
        self.component.clientDisconnected(self.registerer, self.resource)

    def hasController(self, resource):
        '''Tell whether the given resource already showed up as a controller.'''
        return (resource in self.controllers)

    def getControllers(self):
        '''Return a list with the full JID of current controllers.'''
        return ['%s/%s' % (self.registerer, resource) \
                for resource in self.controllers]

    def getMostAvailableController(self):
        '''Return the 'most available' controller. Currently, this means the
           resource with highest priority (the last one found if several of
           them have the same priority).
        '''
        resources = self.controllers.keys()
        debug('We are wondering who is the most available controller among %s' \
              % resources)
        current_best = resources[0]
        for resource in resources:
            debug('Considering %s (%s)' % (resource, self.controllers[resource]))
            if self.controllers[resource] >= self.controllers[current_best]:
                current_best = resource
        debug('And the winner is... %s.' % current_best)
        return current_best

    def resourceAvailable(self, resource, priority):
        '''A controller sent an availability information. Create or update the
           association between the resource and the priority.
           If it is the first controller, connect.
        '''
        debug('Resource %s sent availability, priority=%s' % (resource, priority))
        if self.controllers == {}:
            debug('First available controller, congratulations. Connecting.')
            self.connect()
        if priority is None:
            debug('No priority, assuming 0.')
            priority = 0
        debug('Recording controller %s with priority %s' % (resource, priority))
        self.controllers[resource] = priority

    def resourceUnavailable(self, resource):
        '''A controller sent unavailability information. Delete it from the
           list of controllers.
           If is was the last controller, disconnect.
        '''
        debug('Resource %s sent unavailable presence.' % (resource))
        if resource in self.controllers:
            debug('Removing from controllers.')
            del self.controllers[resource]
            if self.controllers == {}:
                debug('It was the last controller, disconnecting.')
                self.bye = True
                debug('Disconnected.')
        else:
            debug("We didn't know %s/%s was online anyway." \
                  % (self.registerer, resource))

    def updatePriority(self):
        '''Change priority according to controllers' ability to receive
           messages.
           THINKME: What criteria should be used? Currently, the highest
                    priority is reflected.'''
        debug('We should for some reason re-evaluate our priorities ;)')
        new_prio = max(self.controllers.values())
        debug('New priority is %s' % (new_prio))
        if new_prio != self.presence.getPriority():
            debug('Change needed, sending new presence.')
            self.presence.setPriority(new_prio)
            self.send(self.presence)

    def pickIqRecipient(self, iq):
        '''Return the name of the resource the incoming IQ should be
           forwarded to, or None is no acceptable candidate could be
           determined.
           Currently, the most available resource is chosen.'''
        return self.getMostAvailableController()

    def getPresence(self):
        return self.presence