Poodletooth-iLand/panda/python/Lib/site-packages/wx/lib/rpcMixin.py

#
#  This was modified from rpcMixin.py distributed with wxPython
#
#----------------------------------------------------------------------
# Name:        rpcMixin
# Version:     0.2.0
# Purpose:     provides xmlrpc server functionality for wxPython
#              applications via a mixin class
#
# Requires:    (1) Python with threading enabled.
#              (2) xmlrpclib from PythonWare
#                  (http://www.pythonware.com/products/xmlrpc/)
#                  the code was developed and tested using version 0.9.8
#
# Author:      greg Landrum (Landrum@RationalDiscovery.com)
#
# Copyright:   (c) 2000, 2001 by Greg Landrum and Rational Discovery LLC
# Licence:     wxWindows license
# Tags:        phoenix-port
#----------------------------------------------------------------------
# 12/11/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o 2.5 compatability update.
# o xmlrpcserver not available.
#

"""provides xmlrpc server functionality for wxPython applications via a mixin class

**Some Notes:**

  1)  The xmlrpc server runs in a separate thread from the main GUI
      application, communication between the two threads using a custom
      event (see the Threads demo in the wxPython docs for more info).

  2)  Neither the server nor the client are particularly smart about
      checking method names.  So it's easy to shoot yourself in the foot
      by calling improper methods.  It would be pretty easy to add
      either a list of allowed methods or a list of forbidden methods.

  3)  Authentication of xmlrpc clients is *not* performed.  I think it
      would be pretty easy to do this in a hacky way, but I haven't done
      it yet.

  4)  See the bottom of this file for an example of using the class.

**Obligatory disclaimer:**
  This is my first crack at both using xmlrpc and multi-threaded
  programming, so there could be huge horrible bugs or design
  flaws. If you see one, I'd love to hear about them.

"""


""" ChangeLog
23 May 2001:  Version bumped to 0.2.0
  Numerous code and design changes

21 Mar. 2001:  Version bumped to 0.1.4
  Updated rpcMixin.OnExternal to support methods with further references
   (i.e. now you can do rpcClient.foo.bar() and have it work)
  This probably ain't super legal in xmlrpc land, but it works just fine here
   and we need it.

6  Mar. 2001:  Version bumped to 0.1.3
  Documentation changes to make this compatible with happydoc

21 Jan. 2001:  Version bumped to 0.1.2
  OnExternal() method in the mixin class now uses getattr() to check if
    a desired method is present.  It should have been done this way in
    the first place.
14 Dec. 2000:  Version bumped to 0.1.1
  rearranged locking code and made other changes so that multiple
    servers in one application are possible.

"""

import new
import SocketServer
import sys
import threading
import xmlrpclib
import xmlrpcserver

import wx

rpcPENDING = 0
rpcDONE = 1
rpcEXCEPT = 2

class RPCMixinError(Exception):
    pass

class RPCRequest:
    """A wrapper to use for handling requests and their responses"""
    status = rpcPENDING
    result = None

# here's the ID for external events
wxEVT_EXTERNAL_EVENT = wx.NewEventType()
EVT_EXTERNAL_EVENT = wx.PyEventBinder(wxEVT_EXTERNAL_EVENT, 0)

class ExternalEvent(wx.PyEvent):
    """The custom event class used to pass xmlrpc calls from
       the server thread into the GUI thread

    """
    def __init__(self,method,args):
        wx.PyEvent.__init__(self)
        self.SetEventType(wxEVT_EXTERNAL_EVENT)
        self.method = method
        self.args = args
        self.rpcStatus = RPCRequest()
        self.rpcStatusLock = threading.Lock()
        self.rpcCondVar = threading.Condition()

    def Destroy(self):
        self.method=None
        self.args=None
        self.rpcStatus = None
        self.rpcStatusLock = None
        self.rpcondVar = None

class Handler(xmlrpcserver.RequestHandler):
    """The handler class that the xmlrpcserver actually calls
       when a request comes in.

    """
    def log_message(self,*args):
        """ causes the server to stop spewing messages every time a request comes in

        """
        pass
    def call(self,method,params):
        """When an xmlrpc request comes in, this is the method that
        gets called.

        **Arguments**

            - method: name of the method to be called

            - params: arguments to that method

        """
        if method == '_rpcPing':
            # we just acknowledge these without processing them
            return 'ack'

        # construct the event
        evt = ExternalEvent(method,params)

        # update the status variable
        evt.rpcStatusLock.acquire()
        evt.rpcStatus.status = rpcPENDING
        evt.rpcStatusLock.release()

        evt.rpcCondVar.acquire()
        # dispatch the event to the GUI
        wx.PostEvent(self._app,evt)

        # wait for the GUI to finish
        while evt.rpcStatus.status == rpcPENDING:
            evt.rpcCondVar.wait()
        evt.rpcCondVar.release()
        evt.rpcStatusLock.acquire()
        if evt.rpcStatus.status == rpcEXCEPT:
            # The GUI threw an exception, release the status lock
            #  and re-raise the exception
            evt.rpcStatusLock.release()
            raise evt.rpcStatus.result[0](evt.rpcStatus.result[1])
        else:
            # everything went through without problems
            s = evt.rpcStatus.result

            evt.rpcStatusLock.release()
            evt.Destroy()
            self._app = None
            return s

# this global Event is used to let the server thread
# know when it should quit
stopEvent = threading.Event()
stopEvent.clear()

class _ServerThread(threading.Thread):
    """ this is the Thread class which actually runs the server

    """
    def __init__(self,server,verbose=0):
        self._xmlServ = server
        threading.Thread.__init__(self,verbose=verbose)

    def stop(self):
        stopEvent.set()

    def shouldStop(self):
        return stopEvent.isSet()

    def run(self):
        while not self.shouldStop():
            self._xmlServ.handle_request()
        self._xmlServ = None

class rpcMixin:
    """A mixin class to provide xmlrpc server functionality to wxPython
       frames/windows

       If you want to customize this, probably the best idea is to
       override the OnExternal method, which is what's invoked when an
       RPC is handled.

    """

    # we'll try a range of ports for the server, this is the size of the
    #  range to be scanned
    nPortsToTry=20
    if sys.platform == 'win32':
        defPort = 800
    else:
        defPort = 8023

    def __init__(self,host='',port=-1,verbose=0,portScan=1):
        """Constructor

        **Arguments**

            - host: (optional) the hostname for the server

            - port: (optional) the port the server will use

            - verbose: (optional) if set, the server thread will be launched
            in verbose mode

            - portScan: (optional) if set, we'll scan across a number of ports
            to find one which is avaiable

        """
        if port == -1:
            port = self.defPort
        self.verbose=verbose
        self.Bind(EVT_EXTERNAL_EVENT,self.OnExternal)
        if hasattr(self,'OnClose'):
            self._origOnClose = self.OnClose
            self.Disconnect(-1,-1,wx.EVT_CLOSE_WINDOW)
        else:
            self._origOnClose = None
        self.OnClose = self.RPCOnClose
        self.Bind(wx.EVT_CLOSE,self.RPCOnClose)

        tClass = new.classobj('Handler%d'%(port),(Handler,),{})
        tClass._app = self
        if portScan:
            self.rpcPort = -1
            for i in xrange(self.nPortsToTry):
                try:
                    xmlServ = SocketServer.TCPServer((host,port+i),tClass)
                except Exception:
                    pass
                else:
                    self.rpcPort = port+i
        else:
            self.rpcPort = port
            try:
                xmlServ = SocketServer.TCPServer((host,port),tClass)
            except:
                self.rpcPort = -1

        if self.rpcPort == -1:
            raise RPCMixinError('Cannot initialize server')
        self.servThread = _ServerThread(xmlServ,verbose=self.verbose)
        self.servThread.setName('XML-RPC Server')
        self.servThread.start()

    def RPCOnClose(self,event):
        """ callback for when the application is closed

            be sure to shutdown the server and the server thread before
            leaving

        """
        # by setting the global stopEvent we inform the server thread
        # that it's time to shut down.
        stopEvent.set()
        if event is not None:
            # if we came in here from a user event (as opposed to an RPC event),
            #  then we'll need to kick the server one last time in order
            #  to get that thread to terminate.  do so now
            s1 = xmlrpclib.Server('http://localhost:%d'%(self.rpcPort))
            try:
                s1._rpcPing()
            except Exception:
                pass

        if self._origOnClose is not None:
            self._origOnClose(event)

    def RPCQuit(self):
        """ shuts down everything, including the rpc server

        """
        self.RPCOnClose(None)
    def OnExternal(self,event):
        """ this is the callback used to handle RPCs

        **Arguments**

            - event: an _ExternalEvent_ sent by the rpc server

        Exceptions are caught and returned in the global _rpcStatus
        structure.  This allows the xmlrpc server to report the
        exception to the client without mucking up any of the delicate
        thread stuff.

        """
        event.rpcStatusLock.acquire()
        doQuit = 0
        try:
            methsplit = event.method.split('.')
            meth = self
            for piece in methsplit:
                meth = getattr(meth,piece)
        except AttributeError as exc:
            event.rpcStatus.result = 'No Such Method', exc
            event.rpcStatus.status = rpcEXCEPT
        else:
            try:
                res = meth(event.args)
            except:
                import traceback
                if self.verbose: traceback.print_exc()
                event.rpcStatus.result = sys.exc_info()[:2]
                event.rpcStatus.status = rpcEXCEPT
            else:
                if res is None:
                    # returning None across the xmlrpc interface is problematic
                    event.rpcStatus.result = []
                else:
                    event.rpcStatus.result = res
                event.rpcStatus.status = rpcDONE

        event.rpcStatusLock.release()

        # broadcast (using the condition var) that we're done with the event
        event.rpcCondVar.acquire()
        event.rpcCondVar.notify()
        event.rpcCondVar.release()


if __name__ == '__main__':
    import time
    if sys.platform == 'win32':
        port = 800
    else:
        port = 8023

    class rpcFrame(wx.Frame,rpcMixin):
        """A simple wxFrame with the rpcMixin functionality added
        """
        def __init__(self,*args,**kwargs):
            """ rpcHost or rpcPort keyword arguments will be passed along to
                the xmlrpc server.
            """
            mixinArgs = {}
            if 'rpcHost' in kwargs:
                mixinArgs['host'] = kwargs['rpcHost']
                del kwargs['rpcHost']
            if 'rpcPort' in kwargs:
                mixinArgs['port'] = kwargs['rpcPort']
                del kwargs['rpcPort']
            if 'rpcPortScan' in kwargs:
                mixinArgs['portScan'] = kwargs['rpcPortScan']
                del kwargs['rpcPortScan']

            wx.Frame.__init__(self, *args, **kwargs)
            rpcMixin.__init__(self, mixinArgs)

            self.Bind(wx.EVT_CHAR,self.OnChar)

        def TestFunc(self,args):
            """a demo method"""
            return args

        def OnChar(self,event):
            key = event.GetKeyCode()
            if key == ord('q'):
                self.OnQuit(event)

        def OnQuit(self,event):
            self.OnClose(event)

        def OnClose(self,event):
            self.Destroy()



    class MyApp(wx.App):
        def OnInit(self):
            self.frame = rpcFrame(None, -1, "wxPython RPCDemo", wx.DefaultPosition,
                                 (300,300), rpcHost='localhost',rpcPort=port)
            self.frame.Show(True)
            return True


    def testcon(port):
        s1 = xmlrpclib.Server('http://localhost:%d'%(port))
        s1.SetTitle('Munged')
        s1._rpcPing()
        if doQuit:
            s1.RPCQuit()

        doQuit = 1
        if len(sys.argv)>1 and sys.argv[1] == '-q':
            doQuit = 0
        nT = threading.activeCount()
        app = MyApp(0)
        activePort = app.frame.rpcPort
        t = threading.Thread(target=lambda x=activePort:testcon(x),verbose=0)
        t.start()

    app.MainLoop()
    # give the threads time to shut down
    if threading.activeCount() > nT:
        print('waiting for all threads to terminate')
        while threading.activeCount() > nT:
            time.sleep(0.5)