|
r"""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 SimpleXMLRPCServer |
|
class. |
|
|
|
It can also be used to handle XML-RPC requests in a CGI |
|
environment using CGIXMLRPCRequestHandler. |
|
|
|
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 _listMethods(self): |
|
# implement this method so that system.listMethods |
|
# knows to advertise the strings methods |
|
return list_public_methods(self) + \ |
|
['string.' + method for method in list_public_methods(self.string)] |
|
def pow(self, x, y): return pow(x, y) |
|
def add(self, x, y) : return x + y |
|
|
|
server = SimpleXMLRPCServer(("localhost", 8000)) |
|
server.register_introspection_functions() |
|
server.register_instance(MyFuncs()) |
|
server.serve_forever() |
|
|
|
3. Install an instance with custom dispatch method: |
|
|
|
class Math: |
|
def _listMethods(self): |
|
# this method must be present for system.listMethods |
|
# to work |
|
return ['add', 'pow'] |
|
def _methodHelp(self, method): |
|
# this method must be present for system.methodHelp |
|
# to work |
|
if method == 'add': |
|
return "add(2,3) => 5" |
|
elif method == 'pow': |
|
return "pow(x, y[, z]) => number" |
|
else: |
|
# By convention, return empty |
|
# string if no help is available |
|
return "" |
|
def _dispatch(self, method, params): |
|
if method == 'pow': |
|
return pow(*params) |
|
elif method == 'add': |
|
return params[0] + params[1] |
|
else: |
|
raise 'bad method' |
|
|
|
server = SimpleXMLRPCServer(("localhost", 8000)) |
|
server.register_introspection_functions() |
|
server.register_instance(Math()) |
|
server.serve_forever() |
|
|
|
4. Subclass SimpleXMLRPCServer: |
|
|
|
class MathServer(SimpleXMLRPCServer): |
|
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 func(*params) |
|
|
|
def export_add(self, x, y): |
|
return x + y |
|
|
|
server = MathServer(("localhost", 8000)) |
|
server.serve_forever() |
|
|
|
5. CGI script: |
|
|
|
server = CGIXMLRPCRequestHandler() |
|
server.register_function(pow) |
|
server.handle_request() |
|
""" |
|
|
|
# Written by Brian Quinlan (brian@sweetapp.com). |
|
# Based on code written by Fredrik Lundh. |
|
|
|
import xmlrpclib |
|
from xmlrpclib import Fault |
|
import SocketServer |
|
import BaseHTTPServer |
|
import sys |
|
import os |
|
import traceback |
|
import re |
|
try: |
|
import fcntl |
|
except ImportError: |
|
fcntl = None |
|
|
|
def resolve_dotted_attribute(obj, attr, allow_dotted_names=True): |
|
"""resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d |
|
|
|
Resolves a dotted attribute name to an object. Raises |
|
an AttributeError if any attribute in the chain starts with a '_'. |
|
|
|
If the optional allow_dotted_names argument is false, dots are not |
|
supported and this function operates similar to getattr(obj, attr). |
|
""" |
|
|
|
if allow_dotted_names: |
|
attrs = attr.split('.') |
|
else: |
|
attrs = [attr] |
|
|
|
for i in attrs: |
|
if i.startswith('_'): |
|
raise AttributeError( |
|
'attempt to access private attribute "%s"' % i |
|
) |
|
else: |
|
obj = getattr(obj,i) |
|
return obj |
|
|
|
def list_public_methods(obj): |
|
"""Returns a list of attribute strings, found in the specified |
|
object, which represent callable attributes""" |
|
|
|
return [member for member in dir(obj) |
|
if not member.startswith('_') and |
|
hasattr(getattr(obj, member), '__call__')] |
|
|
|
def remove_duplicates(lst): |
|
"""remove_duplicates([2,2,2,1,3,3]) => [3,1,2] |
|
|
|
Returns a copy of a list without duplicates. Every list |
|
item must be hashable and the order of the items in the |
|
resulting list is not defined. |
|
""" |
|
u = {} |
|
for x in lst: |
|
u[x] = 1 |
|
|
|
return u.keys() |
|
|
|
class SimpleXMLRPCDispatcher: |
|
"""Mix-in class that dispatches XML-RPC requests. |
|
|
|
This class is used to register XML-RPC method handlers |
|
and then to dispatch them. This class doesn't need to be |
|
instanced directly when used by SimpleXMLRPCServer but it |
|
can be instanced when used by the MultiPathXMLRPCServer. |
|
""" |
|
|
|
def __init__(self, allow_none=False, encoding=None): |
|
self.funcs = {} |
|
self.instance = None |
|
self.allow_none = allow_none |
|
self.encoding = encoding |
|
|
|
def register_instance(self, instance, allow_dotted_names=False): |
|
"""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 |
|
its 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 an XML-RPC request, then it |
|
will be called instead of the registered instance. |
|
|
|
If the optional allow_dotted_names argument is true and the |
|
instance does not have a _dispatch method, method names |
|
containing dots are supported and resolved, as long as none of |
|
the name segments start with an '_'. |
|
|
|
*** SECURITY WARNING: *** |
|
|
|
Enabling the allow_dotted_names options allows intruders |
|
to access your module's global variables and may allow |
|
intruders to execute arbitrary code on your machine. Only |
|
use this option on a secure, closed network. |
|
|
|
""" |
|
|
|
self.instance = instance |
|
self.allow_dotted_names = allow_dotted_names |
|
|
|
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 name is None: |
|
name = function.__name__ |
|
self.funcs[name] = function |
|
|
|
def register_introspection_functions(self): |
|
"""Registers the XML-RPC introspection methods in the system |
|
namespace. |
|
|
|
see http://xmlrpc.usefulinc.com/doc/reserved.html |
|
""" |
|
|
|
self.funcs.update({'system.listMethods' : self.system_listMethods, |
|
'system.methodSignature' : self.system_methodSignature, |
|
'system.methodHelp' : self.system_methodHelp}) |
|
|
|
def register_multicall_functions(self): |
|
"""Registers the XML-RPC multicall method in the system |
|
namespace. |
|
|
|
see http://www.xmlrpc.com/discuss/msgReader$1208""" |
|
|
|
self.funcs.update({'system.multicall' : self.system_multicall}) |
|
|
|
def _marshaled_dispatch(self, data, dispatch_method = None, path = None): |
|
"""Dispatches an XML-RPC method from marshalled (XML) data. |
|
|
|
XML-RPC methods are dispatched from the marshalled (XML) data |
|
using the _dispatch method and the result is returned as |
|
marshalled data. For backwards compatibility, a dispatch |
|
function can be provided as an argument (see comment in |
|
SimpleXMLRPCRequestHandler.do_POST) but overriding the |
|
existing method through subclassing is the preferred means |
|
of changing method dispatch behavior. |
|
""" |
|
|
|
try: |
|
params, method = xmlrpclib.loads(data) |
|
|
|
# generate response |
|
if dispatch_method is not None: |
|
response = dispatch_method(method, params) |
|
else: |
|
response = self._dispatch(method, params) |
|
# wrap response in a singleton tuple |
|
response = (response,) |
|
response = xmlrpclib.dumps(response, methodresponse=1, |
|
allow_none=self.allow_none, encoding=self.encoding) |
|
except Fault, fault: |
|
response = xmlrpclib.dumps(fault, allow_none=self.allow_none, |
|
encoding=self.encoding) |
|
except: |
|
# report exception back to server |
|
exc_type, exc_value, exc_tb = sys.exc_info() |
|
response = xmlrpclib.dumps( |
|
xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)), |
|
encoding=self.encoding, allow_none=self.allow_none, |
|
) |
|
|
|
return response |
|
|
|
def system_listMethods(self): |
|
"""system.listMethods() => ['add', 'subtract', 'multiple'] |
|
|
|
Returns a list of the methods supported by the server.""" |
|
|
|
methods = self.funcs.keys() |
|
if self.instance is not None: |
|
# Instance can implement _listMethod to return a list of |
|
# methods |
|
if hasattr(self.instance, '_listMethods'): |
|
methods = remove_duplicates( |
|
methods + self.instance._listMethods() |
|
) |
|
# if the instance has a _dispatch method then we |
|
# don't have enough information to provide a list |
|
# of methods |
|
elif not hasattr(self.instance, '_dispatch'): |
|
methods = remove_duplicates( |
|
methods + list_public_methods(self.instance) |
|
) |
|
methods.sort() |
|
return methods |
|
|
|
def system_methodSignature(self, method_name): |
|
"""system.methodSignature('add') => [double, int, int] |
|
|
|
Returns a list describing the signature of the method. In the |
|
above example, the add method takes two integers as arguments |
|
and returns a double result. |
|
|
|
This server does NOT support system.methodSignature.""" |
|
|
|
# See http://xmlrpc.usefulinc.com/doc/sysmethodsig.html |
|
|
|
return 'signatures not supported' |
|
|
|
def system_methodHelp(self, method_name): |
|
"""system.methodHelp('add') => "Adds two integers together" |
|
|
|
Returns a string containing documentation for the specified method.""" |
|
|
|
method = None |
|
if method_name in self.funcs: |
|
method = self.funcs[method_name] |
|
elif self.instance is not None: |
|
# Instance can implement _methodHelp to return help for a method |
|
if hasattr(self.instance, '_methodHelp'): |
|
return self.instance._methodHelp(method_name) |
|
# if the instance has a _dispatch method then we |
|
# don't have enough information to provide help |
|
elif not hasattr(self.instance, '_dispatch'): |
|
try: |
|
method = resolve_dotted_attribute( |
|
self.instance, |
|
method_name, |
|
self.allow_dotted_names |
|
) |
|
except AttributeError: |
|
pass |
|
|
|
# Note that we aren't checking that the method actually |
|
# be a callable object of some kind |
|
if method is None: |
|
return "" |
|
else: |
|
import pydoc |
|
return pydoc.getdoc(method) |
|
|
|
def system_multicall(self, call_list): |
|
"""system.multicall([{'methodName': 'add', 'params': [2, 2]}, ...]) => \ |
|
[[4], ...] |
|
|
|
Allows the caller to package multiple XML-RPC calls into a single |
|
request. |
|
|
|
See http://www.xmlrpc.com/discuss/msgReader$1208 |
|
""" |
|
|
|
results = [] |
|
for call in call_list: |
|
method_name = call['methodName'] |
|
params = call['params'] |
|
|
|
try: |
|
# XXX A marshalling error in any response will fail the entire |
|
# multicall. If someone cares they should fix this. |
|
results.append([self._dispatch(method_name, params)]) |
|
except Fault, fault: |
|
results.append( |
|
{'faultCode' : fault.faultCode, |
|
'faultString' : fault.faultString} |
|
) |
|
except: |
|
exc_type, exc_value, exc_tb = sys.exc_info() |
|
results.append( |
|
{'faultCode' : 1, |
|
'faultString' : "%s:%s" % (exc_type, exc_value)} |
|
) |
|
return results |
|
|
|
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 |
|
its 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. |
|
""" |
|
|
|
func = None |
|
try: |
|
# check to see if a matching function has been registered |
|
func = self.funcs[method] |
|
except KeyError: |
|
if self.instance is not None: |
|
# check for a _dispatch method |
|
if hasattr(self.instance, '_dispatch'): |
|
return self.instance._dispatch(method, params) |
|
else: |
|
# call instance method directly |
|
try: |
|
func = resolve_dotted_attribute( |
|
self.instance, |
|
method, |
|
self.allow_dotted_names |
|
) |
|
except AttributeError: |
|
pass |
|
|
|
if func is not None: |
|
return func(*params) |
|
else: |
|
raise Exception('method "%s" is not supported' % method) |
|
|
|
class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): |
|
"""Simple XML-RPC request handler class. |
|
|
|
Handles all HTTP POST requests and attempts to decode them as |
|
XML-RPC requests. |
|
""" |
|
|
|
# Class attribute listing the accessible path components; |
|
# paths not on this list will result in a 404 error. |
|
rpc_paths = ('/', '/RPC2') |
|
|
|
#if not None, encode responses larger than this, if possible |
|
encode_threshold = 1400 #a common MTU |
|
|
|
#Override form StreamRequestHandler: full buffering of output |
|
#and no Nagle. |
|
wbufsize = -1 |
|
disable_nagle_algorithm = True |
|
|
|
# a re to match a gzip Accept-Encoding |
|
aepattern = re.compile(r""" |
|
\s* ([^\s;]+) \s* #content-coding |
|
(;\s* q \s*=\s* ([0-9\.]+))? #q |
|
""", re.VERBOSE | re.IGNORECASE) |
|
|
|
def accept_encodings(self): |
|
r = {} |
|
ae = self.headers.get("Accept-Encoding", "") |
|
for e in ae.split(","): |
|
match = self.aepattern.match(e) |
|
if match: |
|
v = match.group(3) |
|
v = float(v) if v else 1.0 |
|
r[match.group(1)] = v |
|
return r |
|
|
|
def is_rpc_path_valid(self): |
|
if self.rpc_paths: |
|
return self.path in self.rpc_paths |
|
else: |
|
# If .rpc_paths is empty, just assume all paths are legal |
|
return True |
|
|
|
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 server's _dispatch method for handling. |
|
""" |
|
|
|
# Check that the path is legal |
|
if not self.is_rpc_path_valid(): |
|
self.report_404() |
|
return |
|
|
|
try: |
|
# Get arguments by reading body of request. |
|
# We read this in chunks to avoid straining |
|
# socket.read(); around the 10 or 15Mb mark, some platforms |
|
# begin to have problems (bug #792570). |
|
max_chunk_size = 10*1024*1024 |
|
size_remaining = int(self.headers["content-length"]) |
|
L = [] |
|
while size_remaining: |
|
chunk_size = min(size_remaining, max_chunk_size) |
|
chunk = self.rfile.read(chunk_size) |
|
if not chunk: |
|
break |
|
L.append(chunk) |
|
size_remaining -= len(L[-1]) |
|
data = ''.join(L) |
|
|
|
data = self.decode_request_content(data) |
|
if data is None: |
|
return #response has been sent |
|
|
|
# In previous versions of SimpleXMLRPCServer, _dispatch |
|
# could be overridden in this class, instead of in |
|
# SimpleXMLRPCDispatcher. To maintain backwards compatibility, |
|
# check to see if a subclass implements _dispatch and dispatch |
|
# using that method if present. |
|
response = self.server._marshaled_dispatch( |
|
data, getattr(self, '_dispatch', None), self.path |
|
) |
|
except Exception, e: # This should only happen if the module is buggy |
|
# internal error, report as HTTP server error |
|
self.send_response(500) |
|
|
|
# Send information about the exception if requested |
|
if hasattr(self.server, '_send_traceback_header') and \ |
|
self.server._send_traceback_header: |
|
self.send_header("X-exception", str(e)) |
|
self.send_header("X-traceback", traceback.format_exc()) |
|
|
|
self.send_header("Content-length", "0") |
|
self.end_headers() |
|
else: |
|
# got a valid XML RPC response |
|
self.send_response(200) |
|
self.send_header("Content-type", "text/xml") |
|
if self.encode_threshold is not None: |
|
if len(response) > self.encode_threshold: |
|
q = self.accept_encodings().get("gzip", 0) |
|
if q: |
|
try: |
|
response = xmlrpclib.gzip_encode(response) |
|
self.send_header("Content-Encoding", "gzip") |
|
except NotImplementedError: |
|
pass |
|
self.send_header("Content-length", str(len(response))) |
|
self.end_headers() |
|
self.wfile.write(response) |
|
|
|
def decode_request_content(self, data): |
|
#support gzip encoding of request |
|
encoding = self.headers.get("content-encoding", "identity").lower() |
|
if encoding == "identity": |
|
return data |
|
if encoding == "gzip": |
|
try: |
|
return xmlrpclib.gzip_decode(data) |
|
except NotImplementedError: |
|
self.send_response(501, "encoding %r not supported" % encoding) |
|
except ValueError: |
|
self.send_response(400, "error decoding gzip content") |
|
else: |
|
self.send_response(501, "encoding %r not supported" % encoding) |
|
self.send_header("Content-length", "0") |
|
self.end_headers() |
|
|
|
def report_404 (self): |
|
# Report a 404 error |
|
self.send_response(404) |
|
response = 'No such page' |
|
self.send_header("Content-type", "text/plain") |
|
self.send_header("Content-length", str(len(response))) |
|
self.end_headers() |
|
self.wfile.write(response) |
|
|
|
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, |
|
SimpleXMLRPCDispatcher): |
|
"""Simple XML-RPC server. |
|
|
|
Simple XML-RPC server that allows functions and a single instance |
|
to be installed to handle requests. The default implementation |
|
attempts to dispatch XML-RPC calls to the functions or instance |
|
installed in the server. Override the _dispatch method inhereted |
|
from SimpleXMLRPCDispatcher to change this behavior. |
|
""" |
|
|
|
allow_reuse_address = True |
|
|
|
# Warning: this is for debugging purposes only! Never set this to True in |
|
# production code, as will be sending out sensitive information (exception |
|
# and stack trace details) when exceptions are raised inside |
|
# SimpleXMLRPCRequestHandler.do_POST |
|
_send_traceback_header = False |
|
|
|
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler, |
|
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True): |
|
self.logRequests = logRequests |
|
|
|
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) |
|
SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate) |
|
|
|
# [Bug #1222790] If possible, set close-on-exec flag; if a |
|
# method spawns a subprocess, the subprocess shouldn't have |
|
# the listening socket open. |
|
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'): |
|
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD) |
|
flags |= fcntl.FD_CLOEXEC |
|
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags) |
|
|
|
class MultiPathXMLRPCServer(SimpleXMLRPCServer): |
|
"""Multipath XML-RPC Server |
|
This specialization of SimpleXMLRPCServer allows the user to create |
|
multiple Dispatcher instances and assign them to different |
|
HTTP request paths. This makes it possible to run two or more |
|
'virtual XML-RPC servers' at the same port. |
|
Make sure that the requestHandler accepts the paths in question. |
|
""" |
|
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler, |
|
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True): |
|
|
|
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests, allow_none, |
|
encoding, bind_and_activate) |
|
self.dispatchers = {} |
|
self.allow_none = allow_none |
|
self.encoding = encoding |
|
|
|
def add_dispatcher(self, path, dispatcher): |
|
self.dispatchers[path] = dispatcher |
|
return dispatcher |
|
|
|
def get_dispatcher(self, path): |
|
return self.dispatchers[path] |
|
|
|
def _marshaled_dispatch(self, data, dispatch_method = None, path = None): |
|
try: |
|
response = self.dispatchers[path]._marshaled_dispatch( |
|
data, dispatch_method, path) |
|
except: |
|
# report low level exception back to server |
|
# (each dispatcher should have handled their own |
|
# exceptions) |
|
exc_type, exc_value = sys.exc_info()[:2] |
|
response = xmlrpclib.dumps( |
|
xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)), |
|
encoding=self.encoding, allow_none=self.allow_none) |
|
return response |
|
|
|
class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher): |
|
"""Simple handler for XML-RPC data passed through CGI.""" |
|
|
|
def __init__(self, allow_none=False, encoding=None): |
|
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) |
|
|
|
def handle_xmlrpc(self, request_text): |
|
"""Handle a single XML-RPC request""" |
|
|
|
response = self._marshaled_dispatch(request_text) |
|
|
|
print 'Content-Type: text/xml' |
|
print 'Content-Length: %d' % len(response) |
|
print |
|
sys.stdout.write(response) |
|
|
|
def handle_get(self): |
|
"""Handle a single HTTP GET request. |
|
|
|
Default implementation indicates an error because |
|
XML-RPC uses the POST method. |
|
""" |
|
|
|
code = 400 |
|
message, explain = \ |
|
BaseHTTPServer.BaseHTTPRequestHandler.responses[code] |
|
|
|
response = BaseHTTPServer.DEFAULT_ERROR_MESSAGE % \ |
|
{ |
|
'code' : code, |
|
'message' : message, |
|
'explain' : explain |
|
} |
|
print 'Status: %d %s' % (code, message) |
|
print 'Content-Type: %s' % BaseHTTPServer.DEFAULT_ERROR_CONTENT_TYPE |
|
print 'Content-Length: %d' % len(response) |
|
print |
|
sys.stdout.write(response) |
|
|
|
def handle_request(self, request_text = None): |
|
"""Handle a single XML-RPC request passed through a CGI post method. |
|
|
|
If no XML data is given then it is read from stdin. The resulting |
|
XML-RPC response is printed to stdout along with the correct HTTP |
|
headers. |
|
""" |
|
|
|
if request_text is None and \ |
|
os.environ.get('REQUEST_METHOD', None) == 'GET': |
|
self.handle_get() |
|
else: |
|
# POST data is normally available through stdin |
|
try: |
|
length = int(os.environ.get('CONTENT_LENGTH', None)) |
|
except (TypeError, ValueError): |
|
length = -1 |
|
if request_text is None: |
|
request_text = sys.stdin.read(length) |
|
|
|
self.handle_xmlrpc(request_text) |
|
|
|
if __name__ == '__main__': |
|
print 'Running XML-RPC server on port 8000' |
|
server = SimpleXMLRPCServer(("localhost", 8000)) |
|
server.register_function(pow) |
|
server.register_function(lambda x,y: x+y, 'add') |
|
server.register_multicall_functions() |
|
server.serve_forever() |
