Automation wrapped xmlrpc Server

[Juan Carlos CORUÑA]

Hello all,

I'm trying to create a COM Server with an embedded xmlrpc server.

Here is way it must work:
- The client application (programmed with a COM capable language)
instantiates my COM server (programmed with python).
- The COM server must have a connect interface in order to let the
client application process the xmlrpc request.
- After executing a "serveforever" method on the COM server it begins
to listen on a configured port for xmlrpc requests.
- When the COM server receives a xmlrpc request it passes this request
to the client application event (connect interface) in order to
process it.
- The client application processes the request and returns a result to
the COM server. The COM server returns this result to the xmlrpc
requester.

So, I must say that I have programmed some COM servers in python with
the aid of Mark's book, but in this case I have some problems:
- Must I instantiate a new thread for the xmlrpc server?
- If the xmlrpc server is a different thread  how can this thread call
the _BroadcastNotify method from the main thread (the COM server)?
- I have successfully called the _BroadcastNotify method from the main
thread, but I become a strange behaviuor calling it from other thread.
- I tryied to pass the calling object reference to the xmlrpc thread,
so the xmlrpc thread has a reference to the _BroadcastNotify method,
but it does not work correctly.

Here is part of my code (I have deleted some parts):

class xmlrpcServer(Thread):
    def __init__(self, mainthread, host, port):
        Thread.__init__(self)
        self.host = host
        self.port = port
        self.mainthread = mainthread
    def run(self):
        while 1:
            # the following line simulates the reception
            # of a xmlrpc request
            request = xmlrpcRequest('testmethod', [n, 'parameter2'])
            wrapped = wrap(request, useDispatcher=useDispatcher)
            self.mainthread._BroadcastNotify(self.mainthread.NotifyCall,
                (wrapped,))


class COMServer(ConnectableServer):
    _public_methods_ = ['Serve'] + ConnectableServer._public_methods_
    _connect_interfaces_ = [IID_IxmlrpcEvents]

    def __init__(self):
        ConnectableServer.__init__(self)
        self.Host = ''
        self.Port = None

    def Serve(self):
        # method Serve
        #req = xmlrpcRequest('testmethod', ['parameter1', 23])
        #wrapped = wrap(req, useDispatcher=useDispatcher)
        #self._BroadcastNotify(self.NotifyCall, (wrapped,))
        #req = unwrap(wrapped)
        self._s = xmlrpcServer(self)
        self._s.start()

    def NotifyCall(self, interface, arg):
        interface.Invoke(1000, 0, pythoncom.DISPATCH_METHOD, 1, arg)

class xmlrpcRequest:
    # wraps a xmlrpc request as a COM object in order to pass it to
    # a client event
    _public_methods_ = ['Method', 'Parameter', 'Result']

    def __init__(self, method, parameters):
        self.Result = None
        self._method = method
        self._parameters = parameters



If I call the _BroadcastNotify method directly from the Serve method,
it works correctly.

Has anybody examples of a similar COM server?
Helps will be appreciated.

Thank you.