Automation wrapped xmlrpc Server

[=?ISO-8859-1?Q?Juan_Carlos_CORU=D1A?=]

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.