# $Id: xmlrpclib.py,v 1.36.2.1 2005/02/11 17:59:58 fdrake Exp $
# an XML-RPC client interface for Python.
# the marshalling and response parser code can also be used to
# implement XML-RPC servers.
# this version is designed to work with Python 2.1 or newer.
# 1999-01-15 fl Changed dateTime to use localtime
# 1999-01-16 fl Added Binary/base64 element, default to RPC2 service
# 1999-01-19 fl Fixed array data element (from Skip Montanaro)
# 1999-01-21 fl Fixed dateTime constructor, etc.
# 1999-02-02 fl Added fault handling, handle empty sequences, etc.
# 1999-02-10 fl Fixed problem with empty responses (from Skip Montanaro)
# 1999-06-20 fl Speed improvements, pluggable parsers/transports (0.9.8)
# 2000-11-28 fl Changed boolean to check the truth value of its argument
# 2001-02-24 fl Added encoding/Unicode/SafeTransport patches
# 2001-02-26 fl Added compare support to wrappers (0.9.9/1.0b1)
# 2001-03-28 fl Make sure response tuple is a singleton
# 2001-03-29 fl Don't require empty params element (from Nicholas Riley)
# 2001-06-10 fl Folded in _xmlrpclib accelerator support (1.0b2)
# 2001-08-20 fl Base xmlrpclib.Error on built-in Exception (from Paul Prescod)
# 2001-09-03 fl Allow Transport subclass to override getparser
# 2001-09-10 fl Lazy import of urllib, cgi, xmllib (20x import speedup)
# 2001-10-01 fl Remove containers from memo cache when done with them
# 2001-10-01 fl Use faster escape method (80% dumps speedup)
# 2001-10-02 fl More dumps microtuning
# 2001-10-04 fl Make sure import expat gets a parser (from Guido van Rossum)
# 2001-10-10 sm Allow long ints to be passed as ints if they don't overflow
# 2001-10-17 sm Test for int and long overflow (allows use on 64-bit systems)
# 2001-11-12 fl Use repr() to marshal doubles (from Paul Felix)
# 2002-03-17 fl Avoid buffered read when possible (from James Rucker)
# 2002-04-07 fl Added pythondoc comments
# 2002-04-16 fl Added __str__ methods to datetime/binary wrappers
# 2002-05-15 fl Added error constants (from Andrew Kuchling)
# 2002-06-27 fl Merged with Python CVS version
# 2002-10-22 fl Added basic authentication (based on code from Phillip Eby)
# 2003-01-22 sm Add support for the bool type
# 2003-02-27 gvr Remove apply calls
# 2003-04-24 sm Use cStringIO if available
# 2003-04-25 ak Add support for nil
# 2003-06-15 gn Add support for time.struct_time
# 2003-07-12 gp Correct marshalling of Faults
# 2003-10-31 mvl Add multicall support
# 2004-08-20 mvl Bump minimum supported Python version to 2.1
# Copyright (c) 1999-2002 by Secret Labs AB.
# Copyright (c) 1999-2002 by Fredrik Lundh.
# http://www.pythonware.com
# --------------------------------------------------------------------
# The XML-RPC client interface is
# Copyright (c) 1999-2002 by Secret Labs AB
# Copyright (c) 1999-2002 by Fredrik Lundh
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# --------------------------------------------------------------------
# things to look into some day:
# TODO: sort out True/False/boolean issues for Python 2.3
An XML-RPC client interface for Python.
The marshalling and response parser code can also be used to
implement XML-RPC servers.
Error Base class for client errors
ProtocolError Indicates an HTTP protocol error
ResponseError Indicates a broken response package
Fault Indicates an XML-RPC fault package
ServerProxy Represents a logical connection to an XML-RPC server
MultiCall Executor of boxcared xmlrpc requests
Boolean boolean wrapper to generate a "boolean" XML-RPC value
DateTime dateTime wrapper for an ISO 8601 string or time tuple or
localtime integer value to generate a "dateTime.iso8601"
Binary binary data wrapper
SlowParser Slow but safe standard parser (based on xmllib)
Marshaller Generate an XML-RPC params chunk from a Python data structure
Unmarshaller Unmarshal an XML-RPC response from incoming XML event message
Transport Handles an HTTP transaction to an XML-RPC server
SafeTransport Handles an HTTPS transaction to an XML-RPC server
boolean Convert any Python value to an XML-RPC boolean
getparser Create instance of the fastest available parser & attach
to an unmarshalling object
dumps Convert an argument tuple or a Fault instance to an XML-RPC
request (or response, if the methodresponse option is used).
loads Convert an XML-RPC packet to unmarshalled data plus a method
name (None if not present).
import re
, string
, time
, operator
# --------------------------------------------------------------------
unicode = None # unicode support not available
_bool_is_builtin
= False.__class
__.__name
__ == "bool"
def _decode(data
, encoding
, is8bit
=re
.compile("[\x80-\xff]").search
):
# decode non-ascii string (if possible)
if unicode and encoding
and is8bit(data
):
data
= unicode(data
, encoding
)
def escape(s
, replace
=string
.replace
):
s
= replace(s
, "&", "&")
s
= replace(s
, "<", "<")
return replace(s
, ">", ">",)
# convert to 7-bit ascii if possible
return string
.encode("ascii")
# --------------------------------------------------------------------
# Error constants (from Dan Libby's specification at
# http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php)
APPLICATION_ERROR
= -32500
NOT_WELLFORMED_ERROR
= -32700
UNSUPPORTED_ENCODING
= -32701
INVALID_ENCODING_CHAR
= -32702
METHOD_NOT_FOUND
= -32601
INVALID_METHOD_PARAMS
= -32602
# --------------------------------------------------------------------
# Base class for all kinds of client-side errors.
"""Base class for client errors."""
# Indicates an HTTP-level protocol error. This is raised by the HTTP
# transport layer, if the server returns an error code other than 200
# @param url The target URL.
# @param errcode The HTTP error code.
# @param errmsg The HTTP error message.
# @param headers The HTTP header dictionary.
class ProtocolError(Error
):
"""Indicates an HTTP protocol error."""
def __init__(self
, url
, errcode
, errmsg
, headers
):
"<ProtocolError for %s: %s %s>" %
(self
.url
, self
.errcode
, self
.errmsg
)
# Indicates a broken XML-RPC response package. This exception is
# raised by the unmarshalling layer, if the XML-RPC response is
class ResponseError(Error
):
"""Indicates a broken response package."""
# Indicates an XML-RPC fault response package. This exception is
# raised by the unmarshalling layer, if the XML-RPC response contains
# a fault string. This exception can also used as a class, to
# generate a fault XML-RPC message.
# @param faultCode The XML-RPC fault code.
# @param faultString The XML-RPC fault string.
"""Indicates an XML-RPC fault package."""
def __init__(self
, faultCode
, faultString
, **extra
):
self
.faultCode
= faultCode
self
.faultString
= faultString
(self
.faultCode
, repr(self
.faultString
))
# --------------------------------------------------------------------
# Wrapper for XML-RPC boolean values. Use the xmlrpclib.True and
# xmlrpclib.False constants, or the xmlrpclib.boolean() function, to
# generate boolean XML-RPC values.
# @param value A boolean value. Any true value is interpreted as True,
# all other values are interpreted as False.
# to avoid breaking code which references xmlrpclib.{True,False}
True, False = True, False
"""Boolean-value wrapper.
Use True or False to generate a "boolean" XML-RPC value.
def __init__(self
, value
= 0):
self
.value
= operator
.truth(value
)
out
.write("<value><boolean>%d</boolean></value>\n" % self
.value
)
def __cmp__(self
, other
):
if isinstance(other
, Boolean
):
return cmp(self
.value
, other
)
return "<Boolean True at %x>" % id(self
)
return "<Boolean False at %x>" % id(self
)
True, False = Boolean(1), Boolean(0)
# Map true or false value to XML-RPC boolean values.
# @param value A boolean value. Any true value is mapped to True,
# all other values are mapped to False.
# @return xmlrpclib.True or xmlrpclib.False.
def boolean(value
, _truefalse
=(False, True)):
"""Convert any Python value to XML-RPC 'boolean'."""
return _truefalse
[operator
.truth(value
)]
# Wrapper for XML-RPC DateTime values. This converts a time value to
# the format used by XML-RPC.
# The value can be given as a string in the format
# "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
# time.localtime()), or an integer value (as returned by time.time()).
# The wrapper uses time.localtime() to convert an integer to a time
# @param value The time, given as an ISO 8601 string, a time
# tuple, or a integer time value.
"""DateTime wrapper for an ISO 8601 string or time tuple or
localtime integer value to generate 'dateTime.iso8601' XML-RPC
def __init__(self
, value
=0):
if not isinstance(value
, StringType
):
if not isinstance(value
, (TupleType
, time
.struct_time
)):
value
= time
.localtime(value
)
value
= time
.strftime("%Y%m%dT%H:%M:%S", value
)
def __cmp__(self
, other
):
if isinstance(other
, DateTime
):
return cmp(self
.value
, other
)
# @return Date/time value, as an ISO 8601 string.
return "<DateTime %s at %x>" % (repr(self
.value
), id(self
))
self
.value
= string
.strip(data
)
out
.write("<value><dateTime.iso8601>")
out
.write("</dateTime.iso8601></value>\n")
# decode xml element contents into a DateTime structure.
# Wrapper for binary data. This can be used to transport any kind
# of binary data over XML-RPC, using BASE64 encoding.
# @param data An 8-bit string containing arbitrary data.
import cStringIO
as StringIO
"""Wrapper for binary data."""
def __init__(self
, data
=None):
# @return Buffer contents, as an 8-bit string.
def __cmp__(self
, other
):
if isinstance(other
, Binary
):
return cmp(self
.data
, other
)
self
.data
= base64
.decodestring(data
)
out
.write("<value><base64>\n")
base64
.encode(StringIO
.StringIO(self
.data
), out
)
out
.write("</base64></value>\n")
# decode xml element contents into a Binary structure
WRAPPERS
= (DateTime
, Binary
)
WRAPPERS
= WRAPPERS
+ (Boolean
,)
# --------------------------------------------------------------------
# optional xmlrpclib accelerator
FastParser
= _xmlrpclib
.Parser
FastUnmarshaller
= _xmlrpclib
.Unmarshaller
except (AttributeError, ImportError):
FastParser
= FastUnmarshaller
= None
FastMarshaller
= _xmlrpclib
.Marshaller
except (AttributeError, ImportError):
# the SGMLOP parser is about 15x faster than Python's builtin
# XML parser. SGMLOP sources can be downloaded from:
# http://www.pythonware.com/products/xml/sgmlop.htm
if not hasattr(sgmlop
, "XMLParser"):
SgmlopParser
= None # sgmlop accelerator not available
def __init__(self
, target
):
self
.finish_starttag
= target
.start
self
.finish_endtag
= target
.end
self
.handle_data
= target
.data
self
.handle_xml
= target
.xml
self
.parser
= sgmlop
.XMLParser()
self
.parser
.register(self
)
self
.feed
= self
.parser
.feed
"amp": "&", "gt": ">", "lt": "<",
self
.parser
= self
.feed
= None # nuke circular reference
def handle_proc(self
, tag
, attr
):
m
= re
.search("encoding\s*=\s*['\"]([^\"']+)[\"']", attr
)
self
.handle_xml(m
.group(1), 1)
def handle_entityref(self
, entity
):
self
.handle_data(self
.entity
[entity
])
self
.handle_data("&%s;" % entity
)
from xml
.parsers
import expat
if not hasattr(expat
, "ParserCreate"):
ExpatParser
= None # expat not available
# fast expat parser for Python 2.0 and later. this is about
# 50% slower than sgmlop, on roundtrip testing
def __init__(self
, target
):
self
._parser
= parser
= expat
.ParserCreate(None, None)
parser
.StartElementHandler
= target
.start
parser
.EndElementHandler
= target
.end
parser
.CharacterDataHandler
= target
.data
if not parser
.returns_unicode
:
target
.xml(encoding
, None)
self
._parser
.Parse(data
, 0)
self
._parser
.Parse("", 1) # end of data
del self
._target
, self
._parser
# get rid of circular references
"""Default XML parser (based on xmllib.XMLParser)."""
# this is about 10 times slower than sgmlop, on roundtrip
def __init__(self
, target
):
import xmllib
# lazy subclassing (!)
if xmllib
.XMLParser
not in SlowParser
.__bases
__:
SlowParser
.__bases
__ = (xmllib
.XMLParser
,)
self
.handle_xml
= target
.xml
self
.unknown_starttag
= target
.start
self
.handle_data
= target
.data
self
.handle_cdata
= target
.data
self
.unknown_endtag
= target
.end
xmllib
.XMLParser
.__init
__(self
, accept_utf8
=1)
xmllib
.XMLParser
.__init
__(self
) # pre-2.0
# --------------------------------------------------------------------
# XML-RPC marshalling and unmarshalling code
# @param encoding Default encoding for 8-bit strings. The default
# value is None (interpreted as UTF-8).
"""Generate an XML-RPC params chunk from a Python data structure.
Create a Marshaller instance for each set of parameters, and use
the "dumps" method to convert your data (represented as a tuple)
to an XML-RPC params chunk. To write a fault response, pass a
Fault instance instead. You may prefer to use the "dumps" module
function for this purpose.
# by the way, if you don't understand what's going on in here,
def __init__(self
, encoding
=None, allow_none
=0):
self
.allow_none
= allow_none
if isinstance(values
, Fault
):
dump({'faultCode': values
.faultCode
,
'faultString': values
.faultString
},
# FIXME: the xml-rpc specification allows us to leave out
# the entire <params> block if there are no parameters.
# however, changing this may break older code (including
# old versions of xmlrpclib.py), so this is better left as
# is for now. See @XMLRPC3 for more information. /F
result
= string
.join(out
, "")
def __dump(self
, value
, write
):
f
= self
.dispatch
[type(value
)]
raise TypeError, "cannot marshal %s objects" % type(value
)
def dump_nil (self
, value
, write
):
raise TypeError, "cannot marshal None unless allow_none is enabled"
write("<value><nil/></value>")
dispatch
[NoneType
] = dump_nil
def dump_int(self
, value
, write
):
# in case ints are > 32 bits
if value
> MAXINT
or value
< MININT
:
raise OverflowError, "int exceeds XML-RPC limits"
write("</int></value>\n")
dispatch
[IntType
] = dump_int
def dump_bool(self
, value
, write
):
write("<value><boolean>")
write(value
and "1" or "0")
write("</boolean></value>\n")
dispatch
[bool] = dump_bool
def dump_long(self
, value
, write
):
if value
> MAXINT
or value
< MININT
:
raise OverflowError, "long int exceeds XML-RPC limits"
write("</int></value>\n")
dispatch
[LongType
] = dump_long
def dump_double(self
, value
, write
):
write("</double></value>\n")
dispatch
[FloatType
] = dump_double
def dump_string(self
, value
, write
, escape
=escape
):
write("</string></value>\n")
dispatch
[StringType
] = dump_string
def dump_unicode(self
, value
, write
, escape
=escape
):
value
= value
.encode(self
.encoding
)
write("</string></value>\n")
dispatch
[UnicodeType
] = dump_unicode
def dump_array(self
, value
, write
):
raise TypeError, "cannot marshal recursive sequences"
write("<value><array><data>\n")
write("</data></array></value>\n")
dispatch
[TupleType
] = dump_array
dispatch
[ListType
] = dump_array
def dump_struct(self
, value
, write
, escape
=escape
):
raise TypeError, "cannot marshal recursive dictionaries"
write("<value><struct>\n")
for k
, v
in value
.items():
if type(k
) is not StringType
:
if unicode and type(k
) is UnicodeType
:
k
= k
.encode(self
.encoding
)
raise TypeError, "dictionary key must be string"
write("<name>%s</name>\n" % escape(k
))
write("</struct></value>\n")
dispatch
[DictType
] = dump_struct
def dump_instance(self
, value
, write
):
# check for special wrappers
if value
.__class
__ in WRAPPERS
:
# store instance attributes as a struct (really?)
self
.dump_struct(value
.__dict
__, write
)
dispatch
[InstanceType
] = dump_instance
"""Unmarshal an XML-RPC response, based on incoming XML event
messages (start, data, end). Call close() to get the resulting
Note that this reader is fairly tolerant, and gladly accepts bogus
XML-RPC data without complaining (but not bogus XML).
# and again, if you don't understand what's going on in here,
self
.append
= self
._stack
.append
# return response tuple and target method
if self
._type
is None or self
._marks
:
if self
._type
== "fault":
raise Fault(**self
._stack
[0])
return tuple(self
._stack
)
def xml(self
, encoding
, standalone
):
self
._encoding
= encoding
# FIXME: assert standalone == 1 ???
def start(self
, tag
, attrs
):
# prepare to handle this element
if tag
== "array" or tag
== "struct":
self
._marks
.append(len(self
._stack
))
self
._value
= (tag
== "value")
def end(self
, tag
, join
=string
.join
):
# call the appropriate end tag handler
return f(self
, join(self
._data
, ""))
def end_dispatch(self
, tag
, data
):
def end_nil (self
, data
):
dispatch
["nil"] = end_nil
def end_boolean(self
, data
):
raise TypeError, "bad boolean value"
dispatch
["boolean"] = end_boolean
dispatch
["int"] = end_int
def end_double(self
, data
):
dispatch
["double"] = end_double
def end_string(self
, data
):
data
= _decode(data
, self
._encoding
)
self
.append(_stringify(data
))
dispatch
["string"] = end_string
dispatch
["name"] = end_string
# struct keys are always strings
def end_array(self
, data
):
# map arrays to Python lists
self
._stack
[mark
:] = [self
._stack
[mark
:]]
dispatch
["array"] = end_array
def end_struct(self
, data
):
# map structs to Python dictionaries
items
= self
._stack
[mark
:]
for i
in range(0, len(items
), 2):
dict[_stringify(items
[i
])] = items
[i
+1]
self
._stack
[mark
:] = [dict]
dispatch
["struct"] = end_struct
def end_base64(self
, data
):
dispatch
["base64"] = end_base64
def end_dateTime(self
, data
):
dispatch
["dateTime.iso8601"] = end_dateTime
def end_value(self
, data
):
# if we stumble upon a value element with no internal
# elements, treat it as a string element
dispatch
["value"] = end_value
def end_params(self
, data
):
dispatch
["params"] = end_params
def end_fault(self
, data
):
dispatch
["fault"] = end_fault
def end_methodName(self
, data
):
data
= _decode(data
, self
._encoding
)
self
._type
= "methodName" # no params
dispatch
["methodName"] = end_methodName
# some lesser magic to store calls made to a MultiCall object
def __init__(self
, call_list
, name
):
self
.__call
_list
= call_list
def __getattr__(self
, name
):
return _MultiCallMethod(self
.__call
_list
, "%s.%s" % (self
.__name
, name
))
def __call__(self
, *args
):
self
.__call
_list
.append((self
.__name
, args
))
"""Iterates over the results of a multicall. Exceptions are
thrown in response to xmlrpc faults."""
def __init__(self
, results
):
def __getitem__(self
, i
):
if type(item
) == type({}):
raise Fault(item
['faultCode'], item
['faultString'])
elif type(item
) == type([]):
"unexpected type in multicall result"
"""server -> a object used to boxcar method calls
server should be a ServerProxy object.
Methods can be added to the MultiCall using normal
multicall = MultiCall(server_proxy)
multicall.get_address("Guido")
To execute the multicall, call the MultiCall object e.g.:
add_result, address = multicall()
def __init__(self
, server
):
return "<MultiCall at %x>" % id(self
)
def __getattr__(self
, name
):
return _MultiCallMethod(self
.__call
_list
, name
)
for name
, args
in self
.__call
_list
:
marshalled_list
.append({'methodName' : name
, 'params' : args
})
return MultiCallIterator(self
.__server
.system
.multicall(marshalled_list
))
# --------------------------------------------------------------------
# Create a parser object, and connect it to an unmarshalling instance.
# This function picks the fastest available XML parser.
# return A (parser, unmarshaller) tuple.
"""getparser() -> parser, unmarshaller
Create an instance of the fastest available parser, and attach it
to an unmarshalling object. Return both objects.
if FastParser
and FastUnmarshaller
:
target
= FastUnmarshaller(True, False, _binary
, _datetime
, Fault
)
parser
= FastParser(target
)
parser
= FastParser(target
)
parser
= SgmlopParser(target
)
parser
= ExpatParser(target
)
parser
= SlowParser(target
)
# Convert a Python tuple or a Fault instance to an XML-RPC packet.
# @def dumps(params, **options)
# @param params A tuple or Fault instance.
# @keyparam methodname If given, create a methodCall request for
# @keyparam methodresponse If given, create a methodResponse packet.
# If used with a tuple, the tuple must be a singleton (that is,
# it must contain exactly one element).
# @keyparam encoding The packet encoding.
# @return A string containing marshalled data.
def dumps(params
, methodname
=None, methodresponse
=None, encoding
=None,
"""data [,options] -> marshalled data
Convert an argument tuple or a Fault instance to an XML-RPC
request (or response, if the methodresponse option is used).
In addition to the data object, the following options can be given
methodname: the method name for a methodCall packet
methodresponse: true to create a methodResponse packet.
If this option is used with a tuple, the tuple must be
a singleton (i.e. it can contain only one element).
encoding: the packet encoding (default is UTF-8)
All 8-bit strings in the data structure are assumed to use the
packet encoding. Unicode strings are automatically converted,
assert isinstance(params
, TupleType
) or isinstance(params
, Fault
),\
"argument must be tuple or Fault instance"
if isinstance(params
, Fault
):
elif methodresponse
and isinstance(params
, TupleType
):
assert len(params
) == 1, "response tuple must be a singleton"
m
= FastMarshaller(encoding
)
m
= Marshaller(encoding
, allow_none
)
xmlheader
= "<?xml version='1.0' encoding='%s'?>\n" % str(encoding
)
xmlheader
= "<?xml version='1.0'?>\n" # utf-8 is default
# standard XML-RPC wrappings
if not isinstance(methodname
, StringType
):
methodname
= methodname
.encode(encoding
)
"<methodName>", methodname
, "</methodName>\n",
# a method response, or a fault structure
return data
# return as is
return string
.join(data
, "")
# Convert an XML-RPC packet to a Python object. If the XML-RPC packet
# represents a fault condition, this function raises a Fault exception.
# @param data An XML-RPC packet, given as an 8-bit string.
# @return A tuple containing the unpacked data, and the method name
"""data -> unmarshalled data, method name
Convert an XML-RPC packet to unmarshalled data plus a method
name (None if not present).
If the XML-RPC packet represents a fault condition, this function
raises a Fault exception.
return u
.close(), u
.getmethodname()
# --------------------------------------------------------------------
# some magic to bind an XML-RPC method to an RPC server.
# supports "nested" methods (e.g. examples.getStateName)
def __init__(self
, send
, name
):
def __getattr__(self
, name
):
return _Method(self
.__send
, "%s.%s" % (self
.__name
, name
))
def __call__(self
, *args
):
return self
.__send
(self
.__name
, args
)
# Standard transport class for XML-RPC over HTTP.
# You can create custom transports by subclassing this method, and
# overriding selected methods.
"""Handles an HTTP transaction to an XML-RPC server."""
# client identifier (may be overridden)
user_agent
= "xmlrpclib.py/%s (by www.pythonware.com)" % __version__
# Send a complete request, and parse the response.
# @param host Target host.
# @param handler Target PRC handler.
# @param request_body XML-RPC request body.
# @param verbose Debugging flag.
# @return Parsed response.
def request(self
, host
, handler
, request_body
, verbose
=0):
h
= self
.make_connection(host
)
self
.send_request(h
, handler
, request_body
)
self
.send_content(h
, request_body
)
errcode
, errmsg
, headers
= h
.getreply()
return self
._parse
_response
(h
.getfile(), sock
)
# @return A 2-tuple containing a parser and a unmarshaller.
# get parser and unmarshaller
# Get authorization info from host parameter
# Host may be a string, or a (host, x509-dict) tuple; if a string,
# it is checked for a "user:pw@host" format, and a "Basic
# Authentication" header is added if appropriate.
# @param host Host descriptor (URL or (URL, x509 info) tuple).
# @return A 3-tuple containing (actual host, extra headers,
# x509 info). The header and x509 fields may be None.
def get_host_info(self
, host
):
if isinstance(host
, TupleType
):
auth
, host
= urllib
.splituser(host
)
auth
= base64
.encodestring(urllib
.unquote(auth
))
auth
= string
.join(string
.split(auth
), "") # get rid of whitespace
("Authorization", "Basic " + auth
)
return host
, extra_headers
, x509
# @param host Target host.
# @return A connection handle.
def make_connection(self
, host
):
# create a HTTP connection object from a host descriptor
host
, extra_headers
, x509
= self
.get_host_info(host
)
return httplib
.HTTP(host
)
# @param connection Connection handle.
# @param handler Target RPC handler.
# @param request_body XML-RPC body.
def send_request(self
, connection
, handler
, request_body
):
connection
.putrequest("POST", handler
)
# @param connection Connection handle.
def send_host(self
, connection
, host
):
host
, extra_headers
, x509
= self
.get_host_info(host
)
connection
.putheader("Host", host
)
if isinstance(extra_headers
, DictType
):
extra_headers
= extra_headers
.items()
for key
, value
in extra_headers
:
connection
.putheader(key
, value
)
# Send user-agent identifier.
# @param connection Connection handle.
def send_user_agent(self
, connection
):
connection
.putheader("User-Agent", self
.user_agent
)
# @param connection Connection handle.
# @param request_body XML-RPC request body.
def send_content(self
, connection
, request_body
):
connection
.putheader("Content-Type", "text/xml")
connection
.putheader("Content-Length", str(len(request_body
)))
connection
.send(request_body
)
# @return Response tuple and target method.
def parse_response(self
, file):
# compatibility interface
return self
._parse
_response
(file, None)
# Parse response (alternate interface). This is similar to the
# parse_response method, but also provides direct access to the
# underlying socket object (where available).
# @param sock Socket handle (or None, if the socket object
# could not be accessed).
# @return Response tuple and target method.
def _parse_response(self
, file, sock
):
# read response from input file/socket, and parse it
response
= sock
.recv(1024)
response
= file.read(1024)
print "body:", repr(response
)
# Standard transport class for XML-RPC over HTTPS.
class SafeTransport(Transport
):
"""Handles an HTTPS transaction to an XML-RPC server."""
def make_connection(self
, host
):
# create a HTTPS connection object from a host descriptor
# host may be a string, or a (host, x509-dict) tuple
host
, extra_headers
, x509
= self
.get_host_info(host
)
raise NotImplementedError(
"your version of httplib doesn't support HTTPS"
return HTTPS(host
, None, **(x509
or {}))
# Standard server proxy. This class establishes a virtual connection
# This class is available as ServerProxy and Server. New code should
# use ServerProxy, to avoid confusion.
# @def ServerProxy(uri, **options)
# @param uri The connection point on the server.
# @keyparam transport A transport factory, compatible with the
# standard transport class.
# @keyparam encoding The default encoding used for 8-bit strings
# @keyparam verbose Use a true value to enable debugging output.
# (printed to standard output).
"""uri [,options] -> a logical connection to an XML-RPC server
uri is the connection point on the server, given as
The standard implementation always supports the "http" scheme. If
SSL socket support is available (Python 2.0), it also supports
If the target part and the slash preceding it are both omitted,
The following options can be given as keyword arguments:
transport: a transport factory
encoding: the request encoding (default is UTF-8)
All 8-bit strings passed to the server proxy are assumed to use
def __init__(self
, uri
, transport
=None, encoding
=None, verbose
=0,
# establish a "logical" server connection
type, uri
= urllib
.splittype(uri
)
if type not in ("http", "https"):
raise IOError, "unsupported XML-RPC protocol"
self
.__host
, self
.__handler
= urllib
.splithost(uri
)
transport
= SafeTransport()
self
.__transport
= transport
self
.__encoding
= encoding
self
.__allow
_none
= allow_none
def __request(self
, methodname
, params
):
# call a method on the remote server
request
= dumps(params
, methodname
, encoding
=self
.__encoding
,
allow_none
=self
.__allow
_none
)
response
= self
.__transport
.request(
"<ServerProxy for %s%s>" %
(self
.__host
, self
.__handler
)
def __getattr__(self
, name
):
# magic method dispatcher
return _Method(self
.__request
, name
)
# note: to call a remote object with an non-standard name, use
# result getattr(server, "strange-python-name")(args)
# --------------------------------------------------------------------
if __name__
== "__main__":
# simple test program (from the XML-RPC specification)
# server = ServerProxy("http://localhost:8000") # local server
server
= ServerProxy("http://time.xmlrpc.com/RPC2")
print server
.currentTime
.getCurrentTime()
multi
= MultiCall(server
)
multi
.currentTime
.getCurrentTime()
multi
.currentTime
.getCurrentTime()