ó
|
K\¬Qc @ sz d Z d d l Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z y d d l Z Wn e
|
k
|
r e Z n Xe d Z d Z d Z d f d YZ d e j f d
|
YZ d e j e f d YZ d e f d YZ d e f d YZ e d k rvd GHe d d f Z e j e e j d d e j n d S( s; 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()
|
iÿÿÿÿN( t Faultc C sg | r | j d } n | g } x? | D]7 } | j d rP t d | q( t | | } q( W| S( sG 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).
|
t .t _s( attempt to access private attribute "%s"( t splitt
|
startswitht AttributeErrort getattr( t objt attrt allow_dotted_namest attrst i( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt resolve_dotted_attributes s
|
c C sE g t | D]4 } | j d r t t | | d r | ^ q S( sk Returns a list of attribute strings, found in the specified
|
object, which represent callable attributesR t __call__( t dirR t hasattrR ( R t member( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt list_public_methods s c C s+ i } x | D] } d | | <q W| j S( sÌ 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.
|
i ( t keys( t lstt ut x( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt remove_duplicates s t SimpleXMLRPCDispatcherc B s e Z d Z e d d Z e d Z d d Z d Z d Z d d d Z
|
d Z d Z d Z d
|
Z d Z RS( s' 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.
|
c C s( i | _ d | _ | | _ | | _ d S( N( t funcst Nonet instancet
|
allow_nonet encoding( t selfR R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt __init__© s c C s | | _ | | _ d S( s 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 a 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.
|
|
N( R R ( R R R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt register_instance¯ s ! c C s) | d k r | j } n | | j | <d S( s Registers a function to respond to XML-RPC requests.
|
|
The optional name argument can be used to set a Unicode name
|
for the function.
|
N( R t __name__R ( R t functiont name( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt register_functionÓ s c C s2 | j j i | j d 6| j d 6| j d 6 d S( s Registers the XML-RPC introspection methods in the system
|
namespace.
|
|
see http://xmlrpc.usefulinc.com/doc/reserved.html
|
s system.listMethodss system.methodSignatures system.methodHelpN( R t updatet system_listMethodst system_methodSignaturet system_methodHelp( R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt register_introspection_functionsÞ s
|
c C s | j j i | j d 6 d S( s Registers the XML-RPC multicall method in the system
|
namespace.
|
|
see http://www.xmlrpc.com/discuss/msgReader$1208s system.multicallN( R R$ t system_multicall( R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt register_multicall_functionsé s c C s yy t j | \ } } | d k r6 | | | } n | j | | } | f } t j | d d d | j d | j } Wn t k
|
r¯ } t j | d | j d | j } nS t j \ } } }
|
t j t j d d | | f d | j d | j } n X| S( sú 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.
|
t methodresponsei R R s %s:%sN(
|
t xmlrpclibt loadsR t _dispatcht dumpsR R R t syst exc_info( R t datat dispatch_methodt patht paramst methodt responset faultt exc_typet exc_valuet exc_tb( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt _marshaled_dispatchñ s" c C s | j j } | j d k r} t | j d rL t | | j j } q} t | j d s} t | t | j } q} n | j | S( sw system.listMethods() => ['add', 'subtract', 'multiple']
|
|
Returns a list of the methods supported by the server.t _listMethodsR. N( R R R R R R R= R t sort( R t methods( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR% s
|
c C s d S( s# 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.s signatures not supported( ( R t method_name( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR& - s c C sË d } | | j k r% | j | } ny | j d k r t | j d rV | j j | St | j d s y t | j | | j } Wq t k
|
r q Xq n | d k r® d Sd d l } | j | Sd S( s
system.methodHelp('add') => "Adds two integers together"
|
|
Returns a string containing documentation for the specified method.t _methodHelpR. t iÿÿÿÿN(
|
R R R R RA R R R t pydoct getdoc( R R@ R6 RC ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR' : s$
|
c
|
C sÆ g } x¹ | D]± } | d } | d } y | j | j | | g Wq t k
|
r} } | j i | j d 6| j d 6 q t j \ } } } | j i d d 6d | | f d 6 q Xq W| S( sí 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
|
t
|
methodNameR5 t faultCodet faultStringi s %s:%s( t appendR. R RF RG R0 R1 (
|
R t call_listt resultst callR@ R5 R8 R9 R: R; ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR) Z s
|
|
|
|
c C s¼ d } y | j | } Wnx t k
|
r | j d k r t | j d r[ | j j | | Sy t | j | | j } Wq t k
|
r q Xq n X| d k r¨ | | St d | d S( só 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.
|
R. s method "%s" is not supportedN(
|
R R t KeyErrorR R R. R R R t Exception( R R6 R5 t func( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR. z s"
|
N( R t
|
__module__t __doc__t FalseR R R R# R( R* R< R% R& R' R) R. ( ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR s $ % t SimpleXMLRPCRequestHandlerc B s~ e Z d Z d Z d Z d Z e Z e j d e j
|
e j B Z d Z d Z d Z d Z d
|
Z d d d Z RS( s Simple XML-RPC request handler class.
|
|
Handles all HTTP POST requests and attempts to decode them as
|
XML-RPC requests.
|
t /s /RPC2ix iÿÿÿÿs¢
|
\s* ([^\s;]+) \s* #content-coding
|
(;\s* q \s*=\s* ([0-9\.]+))? #q
|
c C s i } | j j d d } xl | j d D][ } | j j | } | r+ | j d } | rj t | n d } | | | j d <q+ q+ W| S( Ns Accept-EncodingRB t ,i g ð?i ( t headerst getR t aepatternt matcht groupt float( R t rt aet eRX t v( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt accept_encodingsÁ s c C s! | j r | j | j k St Sd S( N( t rpc_pathsR4 t True( R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt is_rpc_path_validÌ s c
|
C sN | j s | j d SyÑ d } t | j d } g } xV | r t | | } | j j | } | sp Pn | j | | t | d 8} q? Wd j | } | j
|
| } | d k rà d S| j j | t | d d | j } Wn t k
|
rt} | j d t | j d rW| j j rW| j d
|
t | | j d t j n | j d d | j nÖ X| j d | j d d | j d k rt | | j k r| j j d d } | ry# t j | } | j d d Wqt k
|
r
|
qXqqn | j d t t | | j | j j | d S( sº 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.
|
Ni
|
i s content-lengthiÿÿÿÿRB R. iô t _send_traceback_headers X-exceptions X-tracebacks Content-lengtht 0iÈ s Content-types text/xmlt gzipi s Content-Encodingi ( i (! Rb t
|
report_404t intRU t mint rfilet readRH t lent joint decode_request_contentR t serverR< R R4 RM t send_responseR Rc t send_headert strt tracebackt
|
format_exct end_headerst encode_thresholdR_ RV R, t gzip_encodet NotImplementedErrort wfilet write(
|
R t max_chunk_sizet size_remainingt Lt
|
chunk_sizet chunkR2 R7 R] t q( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt do_POSTÓ sT
|
"
|
c C sÅ | j j d d j } | d k r+ | S| d k r y t j | SWq§ t k
|
ro | j d d | q§ t k
|
r | j d d q§ Xn | j d d | | j d d | j d S(
|
Ns content-encodingt identityRe iõ s encoding %r not supportedi s error decoding gzip contents Content-lengthRd (
|
RU RV t lowerR, t gzip_decodeRw Ro t
|
ValueErrorRp Rt ( R R2 R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyRm s c C s] | j d d } | j d d | j d t t | | j | j j | d S( Ni s No such pages Content-types
|
text/plains Content-length( Ro Rp Rq Rk Rt Rx Ry ( R R7 ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyRf * s
|
t -c C s) | j j r% t j j | | | n d S( s$ Selectively log an accepted request.N( Rn t logRequestst BaseHTTPServert BaseHTTPRequestHandlert log_request( R t codet size( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR 3 s ( RS s /RPC2( R RO RP R` Ru t wbufsizeRa t disable_nagle_algorithmt ret compilet VERBOSEt
|
IGNORECASERW R_ Rb R Rm Rf R ( ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyRR ¨ s F t SimpleXMLRPCServerc B s2 e Z d Z e Z e Z e e e d e d Z RS( sg 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.
|
c C s | | _ t j | | | t j j | | | | t d k r t t d r t j | j t j } | t j
|
O} t j | j t j | n d S( Nt
|
FD_CLOEXEC( R R R t SocketServert TCPServert fcntlR R t filenot F_GETFDR t F_SETFD( R t addrt requestHandlerR R R t bind_and_activatet flags( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR L s N(
|
R RO RP Ra t allow_reuse_addressRQ Rc RR R R ( ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR 9 s
|
t MultiPathXMLRPCServerc B sG e Z d Z e e e d e d Z d Z d Z d d d Z
|
RS( s\ 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.
|
c C s> t j | | | | | | | i | _ | | _ | | _ d S( N( R R t dispatchersR R ( R R R R R R R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR c s
|
|
c C s | | j | <| S( N( R ( R R4 t
|
dispatcher( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt add_dispatcherl s c C s | j | S( N( R ( R R4 ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt get_dispatcherp s c C s{ y | j | j | | | } WnT t j d \ } } t j t j d d | | f d | j d | j } n X| S( Ni i s %s:%sR R ( R R< R0 R1 R, R/ R R R ( R R2 R3 R4 R7 R9 R: ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR< s s N( R RO RP RR Ra RQ R R R¢ R£ R< ( ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR [ s t CGIXMLRPCRequestHandlerc B s; e Z d Z e d d Z d Z d Z d d Z RS( s3 Simple handler for XML-RPC data passed through CGI.c C s t j | | | d S( N( R R ( R R R ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR s c C s8 | j | } d GHd t | GHHt j j | d S( s Handle a single XML-RPC requests Content-Type: text/xmls Content-Length: %dN( R< Rk R0 t stdoutRy ( R t request_textR7 ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt handle_xmlrpc s
|
c C s} d } t j j | \ } } t j i | d 6| d 6| d 6} d | | f GHd t j GHd t | GHHt j j | d S( s Handle a single HTTP GET request.
|
|
Default implementation indicates an error because
|
XML-RPC uses the POST method.
|
i R t messaget explains Status: %d %ss Content-Type: %ss Content-Length: %dN( R R t responsest DEFAULT_ERROR_MESSAGEt DEFAULT_ERROR_CONTENT_TYPERk R0 R¥ Ry ( R R R¨ R© R7 ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt
|
handle_get s c C s¥ | d k r4 t j j d d d k r4 | j nm y t t j j d d } Wn t t f k
|
rr d } n X| d k r t j j
|
| } n | j | d S( sð 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.
|
t REQUEST_METHODt GETt CONTENT_LENGTHiÿÿÿÿN( R t ost environRV R Rg t TypeErrorR R0 t stdinRj R§ ( R R¦ t length( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt handle_request¨ s
|
N( R RO RP RQ R R R§ R R¶ ( ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyR¤ s
|
|
t __main__s# Running XML-RPC server on port 8000t localhosti@ c C s | | S( N( ( R t y( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt <lambda>Â s t add( RP R, R R R R0 R± Rr R R t ImportErrorR Ra R R R R R RR R R R R¤ R Rn R# t powt serve_forever( ( ( sZ /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/SimpleXMLRPCServer.pyt <module>a s8
|
ÿ !&=
|
