Want a strange XML RPC server

[Laszlo Nagy]

Hi,

I would like to have a strage XML RPC server. It should use one main
thread for all connections.

I have some code like this (using a custom RPC server class):


server_address = (LISTEN_HOST, LISTEN_PORT) # (address, port)
server = mess.SecureXMLRPCServer.SecureXMLRPCServer(
server_address,
RequestHandler,
KEYFILE,CERTFILE,
allow_none=True,
logger =
servicelog.getLogger('SecureXMLRPCServer',filename=LOGFILENAME),
logRequests=False,
stop_requested = stop_requested
)
rpcserver = RPCServer() # Object containing public RPC methods.
server.register_instance(rpcserver)

It works perfectly.

Now here is the tricky part. I would like to send back events. It is
implemented by an RPC callback:

#1. client calls server.get_event()
#2. server waits until the event happens (or until a given timeout)
#3. server returns the event (if any)

The clients are running on multiple threads, and the idea is that any
client can send an event by calling server.send_event(event).

That event will be returned to another client by the server. Since the
clients are blocking (waiting for the RPC call to return), events will
go from one client to another immediatelly (through the rpc server).
This goes through different kinds of proxies, and can be used from
different programming languages (Python and PHP clients, in my case...)

The problem is that in #2, waiting for the event to happen inside the
RPC server's handler method will block all other connections to the RPC
server.

Preferred solution: The get_event() method should run in a different
thread inside the server, and return the event to its xmlrpc client from
that thread. However, all other methods should use one main thread. I
would like to implement this as a decorator like:


class RPCServer(object):
"""Object containing public RPC methods."""
def method1(self,arg1):
.....
def method2(self,arg1):
.....
def method3(self,arg1):
.....

@nonblocking
def get_event1(self):
try:
# Wait for 10 seconds until an event is available.
return self.asinharvester.queued_events1.get(True,10)
except Queue.Empty:
return None # Indicates that there was no queued event.

@nonblocking
def get_event2(self):
try:
# Wait for 10 seconds until an event is available.
return self.asinharvester.queued_events2.get(True,10)
except Queue.Empty:
return None # Indicates that there was no queued event.


Is this possible? I have no idea how to write this "nonblocking" decorator.

Thanks,

Laszlo