path: root/src/IvyCpy.py

# -*- coding: iso-8859-1 -*-
REVISION = "$Id: "

# import
import threading
import ivycpy
import sys
import traceback
import re
import os

##
# class Ivy
# this class is an Object oriented interface for the Ivy-c Library
#
class Ivy:
    
    ##
    # __init__()
    # initialisation method
    # this method creates an Ivy Object and initializes an ivybus
    # @param name: name of the application to connect
    # @param message: the message displayed on connection
    # @param aIvyApplicationListener: the reference to the object used to treat connection / disconnection event for applications
    #
    def __init__(self, name, message, aIvyApplicationListener):
        self.lIvyApplicationlisteners=[]
        self.dIvyClient={}
        self.addApplicationListener(aIvyApplicationListener)
        self.sReadyMessage=message
        self.sAppName=name
        self.dRegexp={}
        self.lBindListeners=[]
        self.sendToSelf = False
        self.selfIvyClient = Ivy.SelfIvyClient(self)
        self.dIvyClient[str(self.selfIvyClient)] = self.selfIvyClient
        ivycpy.IvyInit(name,
                       message,
                       0,
                       self._appliCallback,
                       self._die)

    ##
    # method called on instruction Ivy()
    # this method creates and starts a thread listening for ivy events
    #
    def __call__(self):    
        self.theThread=threading.Thread(target=self.mainloop)
        self.theThread.setDaemon(1)
        self.theThread.start()
        
    ##
    # this method returns the IvyClient associated to an ivy-c client
    # @param ivyclient: the reference of the ivy-c client in the local database
    # @return the Ivy.IvyClient object corresponding to the ivyclient identifier
    #
    def getIvyClient(self, ivyclient):
        ivyClient = None
        if not self.dIvyClient.has_key(str(ivyclient)):
            ivyClient = Ivy.IvyClient(ivyclient)
            self.dIvyClient[str(ivyclient)] = ivyClient
        else:
            ivyClient = self.dIvyClient[str(ivyclient)]
        return ivyClient

    ##
    # getter of self Ivy client attribute
    # @return this IvyClient object  
    #
    def getSelfIvyClient(self):
        return self.selfIvyClient

    ##
    # getter of an Ivy client using his name
    # @param name: name of the client
    # @return the reference of the Ivy.IvyClient with the given name
    #
    def getIvyClientsByName(self, name):
        ivyclient = ivycpy.IvyGetApplication(name)
        return self.getIvyClient(ivyclient)

    ##
    # method returning the ivy-c clients connected to the ivybus
    # @return the list of Ivy.IvyClient connected to the ivybus 
    #
    def getIvyClients(self):
        lIvyClient = [ self.getIvyClientsByName(client)
                       for client in ivycpy.IvyGetApplicationList(",").split(",")]
        # suppression du dernier element car element vide
        lIvyClient.pop()
        return lIvyClient

    ##
    # methods starting the connection to ivybus
    # @param sdomainbus: address used for braodcast
    #
    def start(self, sdomainbus):
        #a partir de la chaine de caracteres
        addr, port = sdomainbus.split(":")
        self.sDomainBus= Ivy.Domain(addr, port)
        ivycpy.IvySetBindCallback(self._bindCallback)
        ivycpy.IvyBindDirectMsg(self._directMessage)
        ivycpy.IvyStart(sdomainbus)        
    
    ##
    # methods stopping the connection to ivybus
    #
    def stop(self):
        ivycpy.IvyStop()        

    ##
    # method launching the ivy mainloop in charge of listening events on the ivybus
    #
    def mainloop(self):
        ivycpy.IvyMainLoop()

    ##
    # method adding a ivy binding event listener to database
    # @param aBindListener: listener for ivy event
    #
    def addBindListener(self, aBindListener):
        self.lBindListeners.append(aBindListener)

    ##
    # method removing an ivy binding event listener from database
    # @param aBindListener: the listener to remove
    #
    def removeBindListener(self, aBindListener):
        self.lBindListeners.remove(aBindListener)
    
    ##
    # method adding application listener to database
    # @param aApplicationListener: the listener to application connection
    #
    def addApplicationListener(self, aApplicationListener):
        self.lIvyApplicationlisteners.append(aApplicationListener)

    ##
    # method removing application listener from database
    # @param aApplicationListener: the listener to remove
    #
    def removeApplicationListener(self, aApplicationListener):
        try:
            self.lIvyApplicationlisteners.remove(aApplicationListener)
        except ValueError, x:
            IvyException(str(x))()

    ##
    # protected method called on bindings events
    # @param client: reference to the ivy-c subscribing client 
    # @param id : unique id of the binding 
    # @param regexp: regular expression to match
    # @param event: binding or removal of an existing binding
    #
    def _bindCallback(self, client, id, regexp, event):
        if (event == ivycpy.IvyAddBind ):
            for bl in self.lBindListeners:
                bl.bindPerformed(client, id, regexp)
        elif (event == ivycpy.IvyRemoveBind ):
            for bl in self.lBindListeners:
                bl.unbindPerformed(client, id, regexp)
    
    ##
    # method called on applications connection
    # @param ivyclient: reference to the client connected or disconnected
    # @param connected: connection or disconnection
    #
    def _appliCallback(self, ivyclient, connected):
        ivyClient = self.getIvyClient(ivyclient)
        if connected == ivycpy.IvyApplicationConnected:
            self._connect(ivyClient)
        else:
            self._disconnect(ivyClient)
    
    ##
    # method calling the connect method of the applications listeners
    # @param arg: anything
    #
    def _connect(self, *arg):
        for listener in self.lIvyApplicationlisteners:
            listener.connect(*arg)

    ##
    # method calling the disconnect method of the applications listeners
    # @param arg: anything
    #
    def _disconnect(self, *arg):
        for listener in self.lIvyApplicationlisteners:
            listener.disconnect(*arg)

    ##
    # method called on die message
    # @param ivyclient: reference to  the client to kill
    # @param id: id of the message
    #
    def _die(self, ivyclient, id):
        ivyClient = self.getIvyClient(ivyclient)
        for listener in self.lIvyApplicationlisteners:
            listener.die(ivyClient, id)

    ##
    # method called on direct message
    # @param ivyclient: reference of the client
    # @param id: id of the message
    # @param msg: the message
    #
    def _directMessage(self, ivyclient, id, msg):
        ivyClient = self.getIvyClient(ivyclient)
        for listener in self.lIvyApplicationlisteners:
            listener.directMessage(ivyClient, id, msg)
    
    ##
    # method which binds message for application
    # @param regexp: the regular expression to match
    # @param aIvyMessageListener: the listener to call on reception
    # @return the id of the subscription
    #
    def bindMsg(self, regexp, aIvyMessageListener):
        id = ivycpy.IvyBindMsg(aIvyMessageListener.receive,regexp)
        self.dRegexp[regexp] = id
        self.selfIvyClient.bindMsg(regexp,aIvyMessageListener,id)
        return id
    
    ##
    # method which unbinds message for client
    # @param param: regexp or id of the message to unbind
    #
    def unBindMsg(self, param):
        if type(param) == type(1):
            ivycpy.IvyUnBindMsg(param)
            self.selfIvyClient.unbindMsg(param)
        else:
            if self.dRegexp.has_key(param):
                self.selfIvyClient.unbindMsg(param)
                id=self.dRegexp[param]
                ivycpy.IvyUnBindMsg(id)
            else:
                IvyException("This expression did not exist")()

    ##
    # method sending message on the ivybus
    # @param message: the message to send
    # @return the result of the operation 0 if error, 1 if ok
    #
    def sendMsg(self, message):
        if self.getSendToSelf() is True:
            self.selfIvyClient.sendMsg(message)
        return ivycpy.IvySendMsg(message)

    ##
    # method sending a die message to the ivy-c client
    # @param ivyclient : ivy-c client to kill
    #
    def sendDie(self, ivyclient):
        if type(ivyclient) == type(self.selfIvyClient):
            self.selfIvyClient.sendDie()
        else:
            ivycpy.IvySendDieMsg(ivyclient)
    
    ##
    # methods sending a message directly to a client
    # @param ivyclient : the ivy-c client to contact
    # @param id : id with no real meanings
    # @param message : the message to send
    #
    def sendDirectMsg(self, ivyclient, id, message):
        if type(ivyclient) == type(self.selfIvyClient):
            self.selfIvyClient.sendDirectMsg(id, message)
        else :
            ivycpy.IvySendDirectMsg(ivyclient,id,message)

    ##
    # methods sending an error message directly to a client
    # @param ivyclient : the ivy-c client to contact
    # @param id : id with no real meanings
    # @param error : the message to send
    #
    def sendError(self, ivyclient, id, error):
        if type(ivyclient) == type(self.selfIvyClient):
            self.selfIvyClient.sendError(id, error)
        else:
            ivycpy.IvySendError(ivyclient,id,error)

    ##
    # method launching a timer
    # @param nbticks : number of ticks
    # @param delay: delay before launching
    # @param callback: method to call at the end
    # @return the id of the timer
    #
    def timer_repeat(self, nbticks, delay, callback):
        try:
            timerid = ivycpy.IvyTimerRepeatAfter(nbticks, long(delay), callback)
        except:
            IvyException("An error occurred in IvyTimerRepeatAfter")()
            timerid = None            
            
        return (timerid)

    ##
    # method modifying the timer
    # @param timerid: id of the timer to modify
    # @param newdelay: waiting delay
    #
    def timer_modify(self, timerid, newdelay):
        ivycpy.IvyTimerModify(timerid, long(newdelay))

    ##
    # method removing timer
    # @param timerid: id of the timer to remove
    #
    def timer_remove(self, timerid):
        ivycpy.IvyTimerRemove(timerid)
    
    ##
    # method setting the value of boolean sendToSelf
    # @param value : boolean representing the falg sendToSelf
    #
    def setSendToSelf(self, value):
        self.sendToSelf = value
    
    ##
    # method returning the value of the flag sendToSelf
    # @return boolean representing the value of the flag sendToSelf
    #
    def getSendToSelf(self):
        return self.sendToSelf
    
    ##
    # class IvyClient
    # this class encapsulates an ivy-c client and gives methodes to access this client
    #
    class IvyClient:
        
        ##
        # initialisation of the IvyClient
        # @param ptr: (ivy-c client) pointer on the ivy-c client
        #
        def __init__(self, ptr):
            self.ptr = ptr

        ##
        # getter of the ivy-c client attribute
        # @return a pointer on an ivy-c client 
        #
        def getPtr(self):
            return self.ptr
        
        ##
        # getter of the ivy-c client name
        # @return a string representing the name of the ivy-c client
        #
        def getName(self):
            return ivycpy.IvyGetApplicationName(self.ptr)

        ##
        # getter of the ivy-c client host
        # @return a string representing the host of the ivy-c client
        #
        def getHost(self):
            return ivycpy.IvyGetApplicationHost(self.ptr)
        
        ##
        # getter of the ivy-c client messages bindings
        # @return a table of strings representing the message for this ivy-c client
        #
        def getMessages(self):
            return ivycpy.IvyGetApplicationMessages(self.ptr)
        
        ##
        # method sending a die message to the ivy-c client
        # @param ivyclient : ivy-c client to kill
        #
        def sendDie(self):
            ivycpy.IvySendDieMsg(self.ptr)
        
        ##
        # methods sending a message directly to a client
        # @param ivyclient : the ivy-c client to contact
        # @param id : id with no real meanings
        # @param message : the message to send
        #
        def sendDirectMsg(self, id, message):
            ivycpy.IvySendDirectMsg(self.ptr,id,message)

        ##
        # methods sending an error message directly to a client
        # @param ivyclient : the ivy-c client to contact
        # @param id : id with no real meanings
        # @param error : the message to send
        #
        def sendError(self, id, error):
            ivycpy.IvySendError(self.ptr,id,error)

    ##
    # class SelfIvyClient
    # this class works like an IvyClient class but represents the application client
    #
    class SelfIvyClient(IvyClient):
        
        ##
        # initialization of the SelfIvyClient
        # @param ptr: pointer on the Ivy object
        #
        def __init__(self, ptr):
            self.ptr = ptr
            self.dBindings = {}
            self.dId2Regexp = {}
            self.dRegexp2Id = {}
        
        ##
        # getter of the ptr attribute
        # @return a pointer on an Ivy object 
        # 
        def getPtr(self):
            return self.ptr
        
        ##
        # getter of the self Client name
        # @return a string representing the name of the selfclient
        #
        def getName(self):
            return self.ptr.sAppName

        ##
        # getter of the self Client host
        # @return a string representing the host of the selfclient
        #
        def getHost(self):
            return os.uname()[1]
        
        ##
        # getter of the self Client messages bindings
        # @return a tuple of strings representing the message for this selfIvyClient
        #
        def getMessages(self):
            return tuple(self.ptr.dRegexp.keys())
        
        ##
        # method sending a die message to the self Client
        #
        def sendDie(self):
            self.ptr._die(self,0)
        
        ##
        # methods sending a message directly to self Client
        # @param id : id with no real meanings
        # @param message : the message to send
        #
        def sendDirectMsg(self, id, message):
            self.ptr._directMessage(self,id,message)
        
        ##
        # methods sending an error message directly to self Client
        # @param id : id with no real meanings
        # @param error : the message to send
        #
        def sendError(self, id, error):
            self.ptr._directMessage(self,id,error)
        
        ##
        # method sending a message to self
        # @param message : string representing the message to send
        #
        def sendMsg(self,message):
            for regexp in self.dBindings.keys():
                r =  re.compile(regexp)
                captures = r.match(message)
                if captures:
                    captures=captures.groups()
                    if len(captures)==0:
                        captures=''
                    self.dBindings[regexp](message)
        
        ##
        # method in charge of treating bindings
        # @param regexp : String representing the regular expression to match
        # @param aIvyMessageListener : the reference to object to call on reception
        # @param id : id with no real meanings
        #
        def bindMsg(self, regexp, aIvyMessageListener, id):
            self.dId2Regexp[id] = regexp
            self.dRegexp2Id[regexp] = id
            self.dBindings[regexp] = aIvyMessageListener.receive
        
        ##
        # method sending a message to self
        # @param message : id or regexp to delete
        #
        def unbindMsg(self, param):
            if type(param) == type(1):
                regexp = self.dId2Regexp.pop(param)
                self.dRegexp2Id.pop(regexp)
                self.dBindings.pop(regexp)
            else:
                if self.dRegexp.has_key(param):
                    id = self.dRegexp2Id.pop(param)
                    self.dRegexp2Id.pop(id)
                    self.dBindings.pop(param)
                else:
                    IvyException("This expression did not exist")()
    
    ##
    # class domain
    # this class contains and allows access to ivybus properties
    #
    class Domain:
        ##
        # initialisation method
        # @param domainaddr: Ip adress for broadcast
        # @param port: port for braodcast
        #
        def __init__(self, domainaddr, port):
            self.domainaddr=domainaddr
            self.port=port
        
        ##
        # method call on print
        # display address and port used by ivybus
        # @return the string to print
        #
        def __str__(self):
            return self.domainaddr+":"+self.port

        ##
        # getter of broadcast Ip adress
        # @return the IP address
        #
        def getDomainaddr(self):
            return self.domainaddr
        
        ##
        # getter of broadcast port
        # @return the IP port
        #
        def getPort(self):
            return self.port


##
# IvyApplicationAdapter
# Classe d'objets abstraite definissant l'interface des objets a fournir a l'objet de classe Ivy
# lors de son initialisation et par les methodes addApplicationListener et removeApplicationListener
#
class IvyApplicationAdapter :
    
    ##
    # abstract method called on application connection
    # @param client: name of the client
    #
    def connect(self,client):
        pass
    
    ##
    # abstract method called on application disconnection
    # @param client: name of the client
    #
    def disconnect(self,client):
        pass
    
    ##
    # abstract method called on die message
    # @param client: name of the client
    # @param id: id of the message
    #
    def die(self,client, id):
        pass
    
    ##
    # abstract method called on direct message
    # @param client: name of the client
    # @param id: id of the client
    # @param msg: message sent
    #
    def directMessage(self, client, id, msg):
        pass

##
# IvyBindAdapter
# Classe d'objets abstraite definissant l'interface des objets
# a fournir a l'objet de classe Ivy
# via addBindListener et removeBindListener
#
class IvyBindAdapter :
    
    ##
    # invoked when a Ivy Client performs a bind
    # @param client: name of the client
    # @param id: id of the client
    # @param regexp: regular expression to match
    #
    def bindPerformed(self,client, id, regexp):
        pass
    
    ##
    # invoked when a Ivy Client performs a unbind
    # @param client: name of the client
    # @param id: id of the client
    # @param regexp: regular expression to match
    #
    def unbindPerformed(self,client, id, regexp):
        pass


##
# class IvyMessageAdapter
# classe abstraite definissant l'interface a fournir à la classe Ivy
# pour la reception de message
#
class IvyMessageAdapter:
        
    ##
    # invoked when a message matching regexp is send on the bus
    # @param client: name of the sender
    # @param arg: message received
    #
    def receive(self, client, *arg):
        pass


##
# classe gerant les exceptions Ivy
# 
class IvyException :
        
    ##
    # on error send an IvyException
    #
    def __call__(self):
        raise self

    ##
    # print the message of the exception
    # @return the message to print
    #
    def __str__(self):
        return self.message
    
    ##
    # initialisation method
    # @param message :  the message to print
    #
    def __init__(self, message):
        self.message=message