[Python-checkins] CVS: python/dist/src/Lib SimpleXMLRPCServer.py,NONE,1.1

2001年9月17日 10:35:24 -0700

Update of /cvsroot/python/python/dist/src/Lib
In directory usw-pr-cvs1:/tmp/cvs-serv28674
Added Files:
	SimpleXMLRPCServer.py 
Log Message:
Brian Quinlan's XML-RPC server framework.
--- NEW FILE: SimpleXMLRPCServer.py ---
"""Simple XML-RPC Server.
This module can be used to create simple XML-RPC servers
by creating a server and either installing functions, a
class instance, or by extending the SimpleXMLRPCRequestHandler
class.
A list of possible usage patterns follows:
1. Install functions:
server = SimpleXMLRPCServer(("localhost", 8000))
server.register_function(pow)
server.register_function(lambda x,y: x+y, 'add')
server.serve_forever()
2. Install an instance:
class MyFuncs:
 def __init__(self):
 # make all of the string functions available through
 # string.func_name
 import string
 self.string = string
 def pow(self, x, y): return pow(x, y)
 def add(self, x, y) : return x + y
server = SimpleXMLRPCServer(("localhost", 8000))
server.register_instance(MyFuncs())
server.serve_forever()
3. Install an instance with custom dispatch method:
class Math:
 def _dispatch(self, method, params):
 if method == 'pow':
 return apply(pow, params)
 elif method == 'add':
 return params[0] + params[1]
 else:
 raise 'bad method'
server = SimpleXMLRPCServer(("localhost", 8000))
server.register_instance(Math())
server.serve_forever()
4. Subclass SimpleXMLRPCRequestHandler:
class MathHandler(SimpleXMLRPCRequestHandler):
 def _dispatch(self, method, params):
 try:
 # We are forcing the 'export_' prefix on methods that are
 # callable through XML-RPC to prevent potential security
 # problems
 func = getattr(self, 'export_' + method)
 except AttributeError:
 raise Exception('method "%s" is not supported' % method)
 else:
 return apply(func, params)
 def log_message(self, format, *args):
 pass # maybe do something fancy like write the messages to a file
 def export_add(self, x, y):
 return x + y
server = SimpleXMLRPCServer(("localhost", 8000), MathHandler)
server.serve_forever()
"""
# Written by Brian Quinlan (brian@sweetapp.com).
# Based on code written by Fredrik Lundh.
import xmlrpclib
import SocketServer
import BaseHTTPServer
import sys
class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
 """Simple XML-RPC request handler class.
 Handles all HTTP POST requests and attempts to decode them as
 XML-RPC requests.
 XML-RPC requests are dispatched to the _dispatch method, which
 may be overriden by subclasses. The default implementation attempts
 to dispatch XML-RPC calls to the functions or instance installed
 in the server.
 """
 def do_POST(self):
 """Handles the HTTP POST request.
 Attempts to interpret all HTTP POST requests as XML-RPC calls,
 which are forwarded to the _dispatch method for handling.
 """
 try:
 # get arguments
 data = self.rfile.read(int(self.headers["content-length"]))
 params, method = xmlrpclib.loads(data)
 # generate response
 try:
 response = self._dispatch(method, params)
 # wrap response in a singleton tuple
 response = (response,)
 except:
 # report exception back to server
 response = xmlrpclib.dumps(
 xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value))
 )
 else:
 response = xmlrpclib.dumps(response, methodresponse=1)
 except:
 # internal error, report as HTTP server error
 self.send_response(500)
 self.end_headers()
 else:
 # got a valid XML RPC response
 self.send_response(200)
 self.send_header("Content-type", "text/xml")
 self.send_header("Content-length", str(len(response)))
 self.end_headers()
 self.wfile.write(response)
 # shut down the connection
 self.wfile.flush()
 self.connection.shutdown(1)
 def _dispatch(self, method, params):
 """Dispatches the XML-RPC method.
 XML-RPC calls are forwarded to a registered function that
 matches the called XML-RPC method name. If no such function
 exists then the call is forwarded to the registered instance,
 if available.
 If the registered instance has a _dispatch method then that
 method will be called with the name of the XML-RPC method and
 it's parameters as a tuple
 e.g. instance._dispatch('add',(2,3))
 If the registered instance does not have a _dispatch method
 then the instance will be searched to find a matching method
 and, if found, will be called.
 Methods beginning with an '_' are considered private and will
 not be called by SimpleXMLRPCServer.
 """
 def resolve_dotted_attribute(obj, attr):
 """resolve_dotted_attribute(math, 'cos.__doc__') => math.cos.__doc__
 Resolves a dotted attribute name to an object. Raises
 an AttributeError if any attribute in the chain starts
 with a '_'.
 """
 for i in attr.split('.'):
 if i.startswith('_'):
 raise AttributeError(
 'attempt to access private attribute "%s"' % i
 )
 else:
 obj = getattr(obj,i)
 return obj
 func = None
 try:
 # check to see if a matching function has been registered
 func = self.server.funcs[method]
 except KeyError:
 if self.server.instance is not None:
 # check for a _dispatch method
 if hasattr(self.server.instance, '_dispatch'):
 return apply(
 getattr(self.server.instance,'_dispatch'),
 (method, params)
 )
 else:
 # call instance method directly
 try:
 func = resolve_dotted_attribute(
 self.server.instance,
 method
 )
 except AttributeError:
 pass
 if func is not None:
 return apply(func, params)
 else:
 raise Exception('method "%s" is not supported' % method)
 def log_request(self, code='-', size='-'):
 """Selectively log an accepted request."""
 if self.server.logRequests:
 BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
class SimpleXMLRPCServer(SocketServer.TCPServer):
 """Simple XML-RPC server.
 Simple XML-RPC server that allows functions and a single instance
 to be installed to handle requests.
 """
 def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
 logRequests=1):
 self.funcs = {}
 self.logRequests = logRequests
 self.instance = None
 SocketServer.TCPServer.__init__(self, addr, requestHandler)
 def register_instance(self, instance):
 """Registers an instance to respond to XML-RPC requests.
 Only one instance can be installed at a time.
 If the registered instance has a _dispatch method then that
 method will be called with the name of the XML-RPC method and
 it's parameters as a tuple
 e.g. instance._dispatch('add',(2,3))
 If the registered instance does not have a _dispatch method
 then the instance will be searched to find a matching method
 and, if found, will be called.
 Methods beginning with an '_' are considered private and will
 not be called by SimpleXMLRPCServer.
 If a registered function matches a XML-RPC request, then it
 will be called instead of the registered instance.
 """
 self.instance = instance
 def register_function(self, function, name = None):
 """Registers a function to respond to XML-RPC requests.
 The optional name argument can be used to set a Unicode name
 for the function.
 If an instance is also registered then it will only be called
 if a matching function is not found.
 """
 if name is None:
 name = function.__name__
 self.funcs[name] = function
if __name__ == '__main__':
 server = SimpleXMLRPCServer(("localhost", 8000))
 server.register_function(pow)
 server.register_function(lambda x,y: x+y, 'add')
 server.serve_forever()