blob: 047929a8611d4440d7102630a60433a2e02dbc02 [file] [log] [blame]
Fredrik Lundhb9056332001-07-11 17:42:21 +00001#
2# XML-RPC CLIENT LIBRARY
3# $Id$
4#
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00005# an XML-RPC client interface for Python.
6#
7# the marshalling and response parser code can also be used to
8# implement XML-RPC servers.
9#
10# Notes:
Martin v. Löwis37af9862004-08-20 07:31:37 +000011# this version is designed to work with Python 2.1 or newer.
Fredrik Lundhc4c062f2001-09-10 19:45:02 +000012#
Fredrik Lundhb9056332001-07-11 17:42:21 +000013# History:
14# 1999-01-14 fl Created
15# 1999-01-15 fl Changed dateTime to use localtime
16# 1999-01-16 fl Added Binary/base64 element, default to RPC2 service
17# 1999-01-19 fl Fixed array data element (from Skip Montanaro)
18# 1999-01-21 fl Fixed dateTime constructor, etc.
19# 1999-02-02 fl Added fault handling, handle empty sequences, etc.
20# 1999-02-10 fl Fixed problem with empty responses (from Skip Montanaro)
21# 1999-06-20 fl Speed improvements, pluggable parsers/transports (0.9.8)
22# 2000-11-28 fl Changed boolean to check the truth value of its argument
23# 2001-02-24 fl Added encoding/Unicode/SafeTransport patches
24# 2001-02-26 fl Added compare support to wrappers (0.9.9/1.0b1)
25# 2001-03-28 fl Make sure response tuple is a singleton
26# 2001-03-29 fl Don't require empty params element (from Nicholas Riley)
Fredrik Lundh78eedce2001-08-23 20:04:33 +000027# 2001-06-10 fl Folded in _xmlrpclib accelerator support (1.0b2)
28# 2001-08-20 fl Base xmlrpclib.Error on built-in Exception (from Paul Prescod)
Fredrik Lundhc4c062f2001-09-10 19:45:02 +000029# 2001-09-03 fl Allow Transport subclass to override getparser
30# 2001-09-10 fl Lazy import of urllib, cgi, xmllib (20x import speedup)
Fredrik Lundh1538c232001-10-01 19:42:03 +000031# 2001-10-01 fl Remove containers from memo cache when done with them
32# 2001-10-01 fl Use faster escape method (80% dumps speedup)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000033# 2001-10-02 fl More dumps microtuning
34# 2001-10-04 fl Make sure import expat gets a parser (from Guido van Rossum)
Skip Montanaro5e9c71b2001-10-10 15:56:34 +000035# 2001-10-10 sm Allow long ints to be passed as ints if they don't overflow
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000036# 2001-10-17 sm Test for int and long overflow (allows use on 64-bit systems)
Fredrik Lundhb6ab93f2001-12-19 21:40:04 +000037# 2001-11-12 fl Use repr() to marshal doubles (from Paul Felix)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000038# 2002-03-17 fl Avoid buffered read when possible (from James Rucker)
39# 2002-04-07 fl Added pythondoc comments
40# 2002-04-16 fl Added __str__ methods to datetime/binary wrappers
41# 2002-05-15 fl Added error constants (from Andrew Kuchling)
42# 2002-06-27 fl Merged with Python CVS version
Fredrik Lundh1303c7c2002-10-22 18:23:00 +000043# 2002-10-22 fl Added basic authentication (based on code from Phillip Eby)
Martin v. Löwis541342f2003-07-12 07:53:04 +000044# 2003-01-22 sm Add support for the bool type
45# 2003-02-27 gvr Remove apply calls
46# 2003-04-24 sm Use cStringIO if available
47# 2003-04-25 ak Add support for nil
48# 2003-06-15 gn Add support for time.struct_time
49# 2003-07-12 gp Correct marshalling of Faults
Martin v. Löwis45394c22003-10-31 13:49:36 +000050# 2003-10-31 mvl Add multicall support
Martin v. Löwis37af9862004-08-20 07:31:37 +000051# 2004-08-20 mvl Bump minimum supported Python version to 2.1
Benjamin Peterson4e9cefa2014-12-05 20:15:15 -050052# 2014-12-02 ch/doko Add workaround for gzip bomb vulnerability
Fredrik Lundhb9056332001-07-11 17:42:21 +000053#
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000054# Copyright (c) 1999-2002 by Secret Labs AB.
55# Copyright (c) 1999-2002 by Fredrik Lundh.
Fredrik Lundhb9056332001-07-11 17:42:21 +000056#
57# info@pythonware.com
58# http://www.pythonware.com
59#
60# --------------------------------------------------------------------
61# The XML-RPC client interface is
62#
Fredrik Lundh3d9addd2002-06-27 21:36:21 +000063# Copyright (c) 1999-2002 by Secret Labs AB
64# Copyright (c) 1999-2002 by Fredrik Lundh
Fredrik Lundhb9056332001-07-11 17:42:21 +000065#
66# By obtaining, using, and/or copying this software and/or its
67# associated documentation, you agree that you have read, understood,
68# and will comply with the following terms and conditions:
69#
70# Permission to use, copy, modify, and distribute this software and
71# its associated documentation for any purpose and without fee is
72# hereby granted, provided that the above copyright notice appears in
73# all copies, and that both that copyright notice and this permission
74# notice appear in supporting documentation, and that the name of
75# Secret Labs AB or the author not be used in advertising or publicity
76# pertaining to distribution of the software without specific, written
77# prior permission.
78#
79# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
80# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
81# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
82# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
83# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
84# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
85# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
86# OF THIS SOFTWARE.
87# --------------------------------------------------------------------
88
Fred Drake1b410792001-09-04 18:55:03 +000089"""
90An XML-RPC client interface for Python.
91
92The marshalling and response parser code can also be used to
93implement XML-RPC servers.
94
Fred Drake1b410792001-09-04 18:55:03 +000095Exported exceptions:
96
Fredrik Lundhc4c062f2001-09-10 19:45:02 +000097 Error Base class for client errors
98 ProtocolError Indicates an HTTP protocol error
99 ResponseError Indicates a broken response package
100 Fault Indicates an XML-RPC fault package
Fred Drake1b410792001-09-04 18:55:03 +0000101
102Exported classes:
103
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000104 ServerProxy Represents a logical connection to an XML-RPC server
Fred Drake1b410792001-09-04 18:55:03 +0000105
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000106 MultiCall Executor of boxcared xmlrpc requests
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000107 DateTime dateTime wrapper for an ISO 8601 string or time tuple or
108 localtime integer value to generate a "dateTime.iso8601"
109 XML-RPC value
110 Binary binary data wrapper
Fred Drake1b410792001-09-04 18:55:03 +0000111
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000112 Marshaller Generate an XML-RPC params chunk from a Python data structure
113 Unmarshaller Unmarshal an XML-RPC response from incoming XML event message
114 Transport Handles an HTTP transaction to an XML-RPC server
115 SafeTransport Handles an HTTPS transaction to an XML-RPC server
Fred Drake1b410792001-09-04 18:55:03 +0000116
117Exported constants:
118
Florent Xiclunac4fec932011-10-30 20:19:32 +0100119 (none)
Fred Drake1b410792001-09-04 18:55:03 +0000120
121Exported functions:
122
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000123 getparser Create instance of the fastest available parser & attach
124 to an unmarshalling object
125 dumps Convert an argument tuple or a Fault instance to an XML-RPC
126 request (or response, if the methodresponse option is used).
127 loads Convert an XML-RPC packet to unmarshalled data plus a method
128 name (None if not present).
Fred Drake1b410792001-09-04 18:55:03 +0000129"""
130
Florent Xiclunac4fec932011-10-30 20:19:32 +0100131import base64
Florent Xicluna75861df2011-10-30 20:39:24 +0100132import sys
Florent Xiclunac4fec932011-10-30 20:19:32 +0100133import time
Florent Xiclunab6f019a2011-10-30 23:54:17 +0100134from datetime import datetime
Georg Brandl24420152008-05-26 16:32:26 +0000135import http.client
Ezio Melotti91932da2012-02-24 12:44:04 +0200136import urllib.parse
Georg Brandlcef803f2009-06-04 09:04:53 +0000137from xml.parsers import expat
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +0000138import errno
139from io import BytesIO
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +0000140try:
141 import gzip
Brett Cannoncd171c82013-07-04 17:43:24 -0400142except ImportError:
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +0000143 gzip = None #python can be built without zlib/gzip support
Fredrik Lundh1538c232001-10-01 19:42:03 +0000144
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000145# --------------------------------------------------------------------
146# Internal stuff
147
Neal Norwitzff113342007-04-17 08:42:15 +0000148def escape(s):
149 s = s.replace("&", "&")
150 s = s.replace("<", "&lt;")
151 return s.replace(">", "&gt;",)
Fredrik Lundh1538c232001-10-01 19:42:03 +0000152
Florent Xicluna75861df2011-10-30 20:39:24 +0100153# used in User-Agent header sent
154__version__ = sys.version[:3]
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000155
156# xmlrpc integer limits
Guido van Rossume2a383d2007-01-15 16:59:06 +0000157MAXINT = 2**31-1
158MININT = -2**31
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000159
160# --------------------------------------------------------------------
161# Error constants (from Dan Libby's specification at
162# http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php)
163
164# Ranges of errors
165PARSE_ERROR = -32700
166SERVER_ERROR = -32600
167APPLICATION_ERROR = -32500
168SYSTEM_ERROR = -32400
169TRANSPORT_ERROR = -32300
170
171# Specific errors
172NOT_WELLFORMED_ERROR = -32700
173UNSUPPORTED_ENCODING = -32701
174INVALID_ENCODING_CHAR = -32702
175INVALID_XMLRPC = -32600
176METHOD_NOT_FOUND = -32601
177INVALID_METHOD_PARAMS = -32602
178INTERNAL_ERROR = -32603
Fredrik Lundhb9056332001-07-11 17:42:21 +0000179
180# --------------------------------------------------------------------
181# Exceptions
182
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000183##
184# Base class for all kinds of client-side errors.
185
Fredrik Lundh78eedce2001-08-23 20:04:33 +0000186class Error(Exception):
Fred Drake1b410792001-09-04 18:55:03 +0000187 """Base class for client errors."""
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000188 def __str__(self):
189 return repr(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000190
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000191##
192# Indicates an HTTP-level protocol error. This is raised by the HTTP
193# transport layer, if the server returns an error code other than 200
194# (OK).
195#
196# @param url The target URL.
197# @param errcode The HTTP error code.
198# @param errmsg The HTTP error message.
199# @param headers The HTTP header dictionary.
200
Fredrik Lundhb9056332001-07-11 17:42:21 +0000201class ProtocolError(Error):
Fred Drake1b410792001-09-04 18:55:03 +0000202 """Indicates an HTTP protocol error."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000203 def __init__(self, url, errcode, errmsg, headers):
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000204 Error.__init__(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000205 self.url = url
206 self.errcode = errcode
207 self.errmsg = errmsg
208 self.headers = headers
209 def __repr__(self):
210 return (
Serhiy Storchaka465e60e2014-07-25 23:36:00 +0300211 "<%s for %s: %s %s>" %
212 (self.__class__.__name__, self.url, self.errcode, self.errmsg)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000213 )
214
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000215##
216# Indicates a broken XML-RPC response package. This exception is
217# raised by the unmarshalling layer, if the XML-RPC response is
218# malformed.
219
Fredrik Lundhb9056332001-07-11 17:42:21 +0000220class ResponseError(Error):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000221 """Indicates a broken response package."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000222 pass
223
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000224##
225# Indicates an XML-RPC fault response package. This exception is
226# raised by the unmarshalling layer, if the XML-RPC response contains
Florent Xiclunac4fec932011-10-30 20:19:32 +0100227# a fault string. This exception can also be used as a class, to
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000228# generate a fault XML-RPC message.
229#
230# @param faultCode The XML-RPC fault code.
231# @param faultString The XML-RPC fault string.
232
Fredrik Lundhb9056332001-07-11 17:42:21 +0000233class Fault(Error):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000234 """Indicates an XML-RPC fault package."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000235 def __init__(self, faultCode, faultString, **extra):
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000236 Error.__init__(self)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000237 self.faultCode = faultCode
238 self.faultString = faultString
239 def __repr__(self):
Serhiy Storchaka465e60e2014-07-25 23:36:00 +0300240 return "<%s %s: %r>" % (self.__class__.__name__,
241 self.faultCode, self.faultString)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000242
243# --------------------------------------------------------------------
244# Special values
245
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000246##
Georg Brandl38eceaa2008-05-26 11:14:17 +0000247# Backwards compatibility
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000248
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000249boolean = Boolean = bool
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000250
251##
252# Wrapper for XML-RPC DateTime values. This converts a time value to
253# the format used by XML-RPC.
254# <p>
Florent Xicluna2738a642011-11-01 00:06:58 +0100255# The value can be given as a datetime object, as a string in the
256# format "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000257# time.localtime()), or an integer value (as returned by time.time()).
258# The wrapper uses time.localtime() to convert an integer to a time
259# tuple.
260#
Florent Xicluna2738a642011-11-01 00:06:58 +0100261# @param value The time, given as a datetime object, an ISO 8601 string,
262# a time tuple, or an integer time value.
263
264
265# Issue #13305: different format codes across platforms
266_day0 = datetime(1, 1, 1)
267if _day0.strftime('%Y') == '0001': # Mac OS X
268 def _iso8601_format(value):
269 return value.strftime("%Y%m%dT%H:%M:%S")
270elif _day0.strftime('%4Y') == '0001': # Linux
271 def _iso8601_format(value):
272 return value.strftime("%4Y%m%dT%H:%M:%S")
273else:
274 def _iso8601_format(value):
275 return value.strftime("%Y%m%dT%H:%M:%S").zfill(17)
276del _day0
277
Fredrik Lundhb9056332001-07-11 17:42:21 +0000278
Christian Heimesdae2a892008-04-19 00:55:37 +0000279def _strftime(value):
Florent Xiclunab6f019a2011-10-30 23:54:17 +0100280 if isinstance(value, datetime):
Florent Xicluna2738a642011-11-01 00:06:58 +0100281 return _iso8601_format(value)
Christian Heimesdae2a892008-04-19 00:55:37 +0000282
283 if not isinstance(value, (tuple, time.struct_time)):
284 if value == 0:
285 value = time.time()
286 value = time.localtime(value)
287
288 return "%04d%02d%02dT%02d:%02d:%02d" % value[:6]
289
Fredrik Lundhb9056332001-07-11 17:42:21 +0000290class DateTime:
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000291 """DateTime wrapper for an ISO 8601 string or time tuple or
292 localtime integer value to generate 'dateTime.iso8601' XML-RPC
293 value.
294 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000295
296 def __init__(self, value=0):
Christian Heimesdae2a892008-04-19 00:55:37 +0000297 if isinstance(value, str):
298 self.value = value
299 else:
300 self.value = _strftime(value)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000301
Christian Heimes05e8be12008-02-23 18:30:17 +0000302 def make_comparable(self, other):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000303 if isinstance(other, DateTime):
Christian Heimes05e8be12008-02-23 18:30:17 +0000304 s = self.value
305 o = other.value
Florent Xiclunab6f019a2011-10-30 23:54:17 +0100306 elif isinstance(other, datetime):
Christian Heimes05e8be12008-02-23 18:30:17 +0000307 s = self.value
Florent Xicluna2738a642011-11-01 00:06:58 +0100308 o = _iso8601_format(other)
Florent Xicluna3fa29f72011-10-30 20:18:50 +0100309 elif isinstance(other, str):
Christian Heimes05e8be12008-02-23 18:30:17 +0000310 s = self.value
311 o = other
312 elif hasattr(other, "timetuple"):
313 s = self.timetuple()
314 o = other.timetuple()
315 else:
316 otype = (hasattr(other, "__class__")
317 and other.__class__.__name__
318 or type(other))
319 raise TypeError("Can't compare %s and %s" %
320 (self.__class__.__name__, otype))
321 return s, o
322
323 def __lt__(self, other):
324 s, o = self.make_comparable(other)
325 return s < o
326
327 def __le__(self, other):
328 s, o = self.make_comparable(other)
329 return s <= o
330
331 def __gt__(self, other):
332 s, o = self.make_comparable(other)
333 return s > o
334
335 def __ge__(self, other):
336 s, o = self.make_comparable(other)
337 return s >= o
338
339 def __eq__(self, other):
340 s, o = self.make_comparable(other)
341 return s == o
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000342
Christian Heimes05e8be12008-02-23 18:30:17 +0000343 def timetuple(self):
344 return time.strptime(self.value, "%Y%m%dT%H:%M:%S")
345
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000346 ##
347 # Get date/time value.
348 #
349 # @return Date/time value, as an ISO 8601 string.
350
351 def __str__(self):
352 return self.value
353
Fredrik Lundhb9056332001-07-11 17:42:21 +0000354 def __repr__(self):
Serhiy Storchaka465e60e2014-07-25 23:36:00 +0300355 return "<%s %r at %#x>" % (self.__class__.__name__, self.value, id(self))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000356
357 def decode(self, data):
Neal Norwitzff113342007-04-17 08:42:15 +0000358 self.value = str(data).strip()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000359
360 def encode(self, out):
361 out.write("<value><dateTime.iso8601>")
362 out.write(self.value)
363 out.write("</dateTime.iso8601></value>\n")
364
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000365def _datetime(data):
366 # decode xml element contents into a DateTime structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000367 value = DateTime()
368 value.decode(data)
369 return value
370
Skip Montanaro174dd222005-05-14 20:54:16 +0000371def _datetime_type(data):
Florent Xiclunab6f019a2011-10-30 23:54:17 +0100372 return datetime.strptime(data, "%Y%m%dT%H:%M:%S")
Skip Montanaro174dd222005-05-14 20:54:16 +0000373
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000374##
375# Wrapper for binary data. This can be used to transport any kind
376# of binary data over XML-RPC, using BASE64 encoding.
377#
378# @param data An 8-bit string containing arbitrary data.
379
Fredrik Lundhb9056332001-07-11 17:42:21 +0000380class Binary:
Fred Drake1b410792001-09-04 18:55:03 +0000381 """Wrapper for binary data."""
Fredrik Lundhb9056332001-07-11 17:42:21 +0000382
383 def __init__(self, data=None):
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000384 if data is None:
385 data = b""
386 else:
Florent Xicluna61665192011-11-15 20:53:25 +0100387 if not isinstance(data, (bytes, bytearray)):
388 raise TypeError("expected bytes or bytearray, not %s" %
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000389 data.__class__.__name__)
390 data = bytes(data) # Make a copy of the bytes!
Fredrik Lundhb9056332001-07-11 17:42:21 +0000391 self.data = data
392
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000393 ##
394 # Get buffer contents.
395 #
396 # @return Buffer contents, as an 8-bit string.
397
398 def __str__(self):
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000399 return str(self.data, "latin-1") # XXX encoding?!
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000400
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000401 def __eq__(self, other):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000402 if isinstance(other, Binary):
403 other = other.data
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000404 return self.data == other
405
Fredrik Lundhb9056332001-07-11 17:42:21 +0000406 def decode(self, data):
Georg Brandlb54d8012009-06-04 09:11:51 +0000407 self.data = base64.decodebytes(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000408
409 def encode(self, out):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000410 out.write("<value><base64>\n")
Georg Brandlb54d8012009-06-04 09:11:51 +0000411 encoded = base64.encodebytes(self.data)
Brett Cannon2dbde5e2007-07-30 03:50:35 +0000412 out.write(encoded.decode('ascii'))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000413 out.write("</base64></value>\n")
414
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000415def _binary(data):
416 # decode xml element contents into a Binary structure
Fredrik Lundhb9056332001-07-11 17:42:21 +0000417 value = Binary()
418 value.decode(data)
419 return value
420
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000421WRAPPERS = (DateTime, Binary)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000422
423# --------------------------------------------------------------------
424# XML parsers
425
Georg Brandlcef803f2009-06-04 09:04:53 +0000426class ExpatParser:
427 # fast expat parser for Python 2.0 and later.
428 def __init__(self, target):
429 self._parser = parser = expat.ParserCreate(None, None)
430 self._target = target
431 parser.StartElementHandler = target.start
432 parser.EndElementHandler = target.end
433 parser.CharacterDataHandler = target.data
434 encoding = None
435 target.xml(encoding, None)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000436
Georg Brandlcef803f2009-06-04 09:04:53 +0000437 def feed(self, data):
438 self._parser.Parse(data, 0)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000439
Georg Brandlcef803f2009-06-04 09:04:53 +0000440 def close(self):
441 self._parser.Parse("", 1) # end of data
442 del self._target, self._parser # get rid of circular references
Fredrik Lundhb9056332001-07-11 17:42:21 +0000443
Fredrik Lundhb9056332001-07-11 17:42:21 +0000444# --------------------------------------------------------------------
445# XML-RPC marshalling and unmarshalling code
446
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000447##
448# XML-RPC marshaller.
449#
450# @param encoding Default encoding for 8-bit strings. The default
451# value is None (interpreted as UTF-8).
452# @see dumps
453
Fredrik Lundhb9056332001-07-11 17:42:21 +0000454class Marshaller:
Fred Drake1b410792001-09-04 18:55:03 +0000455 """Generate an XML-RPC params chunk from a Python data structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000456
Fredrik Lundhc4c062f2001-09-10 19:45:02 +0000457 Create a Marshaller instance for each set of parameters, and use
458 the "dumps" method to convert your data (represented as a tuple)
459 to an XML-RPC params chunk. To write a fault response, pass a
460 Fault instance instead. You may prefer to use the "dumps" module
461 function for this purpose.
Fred Drake1b410792001-09-04 18:55:03 +0000462 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000463
464 # by the way, if you don't understand what's going on in here,
465 # that's perfectly ok.
466
Georg Brandlfe991052009-09-16 15:54:04 +0000467 def __init__(self, encoding=None, allow_none=False):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000468 self.memo = {}
469 self.data = None
470 self.encoding = encoding
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000471 self.allow_none = allow_none
Tim Petersc2659cf2003-05-12 20:19:37 +0000472
Fredrik Lundhb9056332001-07-11 17:42:21 +0000473 dispatch = {}
474
475 def dumps(self, values):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000476 out = []
477 write = out.append
478 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000479 if isinstance(values, Fault):
480 # fault instance
481 write("<fault>\n")
Martin v. Löwis541342f2003-07-12 07:53:04 +0000482 dump({'faultCode': values.faultCode,
483 'faultString': values.faultString},
484 write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000485 write("</fault>\n")
486 else:
487 # parameter block
Fredrik Lundhc266bb02001-08-23 20:13:08 +0000488 # FIXME: the xml-rpc specification allows us to leave out
489 # the entire <params> block if there are no parameters.
490 # however, changing this may break older code (including
491 # old versions of xmlrpclib.py), so this is better left as
492 # is for now. See @XMLRPC3 for more information. /F
Fredrik Lundhb9056332001-07-11 17:42:21 +0000493 write("<params>\n")
494 for v in values:
495 write("<param>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000496 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000497 write("</param>\n")
498 write("</params>\n")
Neal Norwitzff113342007-04-17 08:42:15 +0000499 result = "".join(out)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000500 return result
501
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000502 def __dump(self, value, write):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000503 try:
504 f = self.dispatch[type(value)]
505 except KeyError:
Thomas Wouters89f507f2006-12-13 04:49:30 +0000506 # check if this object can be marshalled as a structure
Florent Xicluna93dfee12011-10-30 20:22:25 +0100507 if not hasattr(value, '__dict__'):
Collin Winterce36ad82007-08-30 01:19:48 +0000508 raise TypeError("cannot marshal %s objects" % type(value))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000509 # check if this class is a sub-class of a basic type,
510 # because we don't know how to marshal these types
511 # (e.g. a string sub-class)
512 for type_ in type(value).__mro__:
513 if type_ in self.dispatch.keys():
Collin Winterce36ad82007-08-30 01:19:48 +0000514 raise TypeError("cannot marshal %s objects" % type(value))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000515 # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix
516 # for the p3yk merge, this should probably be fixed more neatly.
517 f = self.dispatch["_arbitrary_instance"]
518 f(self, value, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000519
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000520 def dump_nil (self, value, write):
521 if not self.allow_none:
Collin Winterce36ad82007-08-30 01:19:48 +0000522 raise TypeError("cannot marshal None unless allow_none is enabled")
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000523 write("<value><nil/></value>")
Guido van Rossum13257902007-06-07 23:15:56 +0000524 dispatch[type(None)] = dump_nil
Tim Petersc2659cf2003-05-12 20:19:37 +0000525
Georg Brandl38eceaa2008-05-26 11:14:17 +0000526 def dump_bool(self, value, write):
527 write("<value><boolean>")
528 write(value and "1" or "0")
529 write("</boolean></value>\n")
530 dispatch[bool] = dump_bool
Skip Montanaro9a7c96a2003-01-22 18:17:25 +0000531
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000532 def dump_long(self, value, write):
Skip Montanaro5449e082001-10-17 22:53:33 +0000533 if value > MAXINT or value < MININT:
Serhiy Storchaka95949422013-08-27 19:40:23 +0300534 raise OverflowError("int exceeds XML-RPC limits")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000535 write("<value><int>")
536 write(str(int(value)))
537 write("</int></value>\n")
Guido van Rossum13257902007-06-07 23:15:56 +0000538 dispatch[int] = dump_long
Skip Montanaro5e9c71b2001-10-10 15:56:34 +0000539
Florent Xicluna2bb96f52011-10-23 22:11:00 +0200540 # backward compatible
541 dump_int = dump_long
542
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000543 def dump_double(self, value, write):
544 write("<value><double>")
545 write(repr(value))
546 write("</double></value>\n")
Guido van Rossum13257902007-06-07 23:15:56 +0000547 dispatch[float] = dump_double
Fredrik Lundhb9056332001-07-11 17:42:21 +0000548
Guido van Rossum54ad5232007-05-27 09:17:48 +0000549 def dump_unicode(self, value, write, escape=escape):
Guido van Rossum54ad5232007-05-27 09:17:48 +0000550 write("<value><string>")
551 write(escape(value))
552 write("</string></value>\n")
553 dispatch[str] = dump_unicode
Fredrik Lundhb9056332001-07-11 17:42:21 +0000554
Florent Xicluna61665192011-11-15 20:53:25 +0100555 def dump_bytes(self, value, write):
556 write("<value><base64>\n")
557 encoded = base64.encodebytes(value)
558 write(encoded.decode('ascii'))
559 write("</base64></value>\n")
560 dispatch[bytes] = dump_bytes
561 dispatch[bytearray] = dump_bytes
562
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000563 def dump_array(self, value, write):
564 i = id(value)
Guido van Rossume2b70bc2006-08-18 22:13:04 +0000565 if i in self.memo:
Collin Winterce36ad82007-08-30 01:19:48 +0000566 raise TypeError("cannot marshal recursive sequences")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000567 self.memo[i] = None
Fredrik Lundh1538c232001-10-01 19:42:03 +0000568 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000569 write("<value><array><data>\n")
570 for v in value:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000571 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000572 write("</data></array></value>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000573 del self.memo[i]
Guido van Rossum13257902007-06-07 23:15:56 +0000574 dispatch[tuple] = dump_array
575 dispatch[list] = dump_array
Fredrik Lundhb9056332001-07-11 17:42:21 +0000576
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000577 def dump_struct(self, value, write, escape=escape):
578 i = id(value)
Guido van Rossume2b70bc2006-08-18 22:13:04 +0000579 if i in self.memo:
Collin Winterce36ad82007-08-30 01:19:48 +0000580 raise TypeError("cannot marshal recursive dictionaries")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000581 self.memo[i] = None
Fredrik Lundh1538c232001-10-01 19:42:03 +0000582 dump = self.__dump
Fredrik Lundhb9056332001-07-11 17:42:21 +0000583 write("<value><struct>\n")
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000584 for k, v in value.items():
Fredrik Lundhb9056332001-07-11 17:42:21 +0000585 write("<member>\n")
Guido van Rossum3172c5d2007-10-16 18:12:55 +0000586 if not isinstance(k, str):
Collin Winterce36ad82007-08-30 01:19:48 +0000587 raise TypeError("dictionary key must be string")
Fredrik Lundh1538c232001-10-01 19:42:03 +0000588 write("<name>%s</name>\n" % escape(k))
Andrew M. Kuchling5962f452004-06-05 12:35:58 +0000589 dump(v, write)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000590 write("</member>\n")
591 write("</struct></value>\n")
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000592 del self.memo[i]
Guido van Rossum13257902007-06-07 23:15:56 +0000593 dispatch[dict] = dump_struct
Fredrik Lundhb9056332001-07-11 17:42:21 +0000594
Florent Xiclunab6f019a2011-10-30 23:54:17 +0100595 def dump_datetime(self, value, write):
596 write("<value><dateTime.iso8601>")
597 write(_strftime(value))
598 write("</dateTime.iso8601></value>\n")
599 dispatch[datetime] = dump_datetime
Fred Drakeba613c32005-02-10 18:33:30 +0000600
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000601 def dump_instance(self, value, write):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000602 # check for special wrappers
603 if value.__class__ in WRAPPERS:
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000604 self.write = write
Fredrik Lundhb9056332001-07-11 17:42:21 +0000605 value.encode(self)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000606 del self.write
Fredrik Lundhb9056332001-07-11 17:42:21 +0000607 else:
608 # store instance attributes as a struct (really?)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000609 self.dump_struct(value.__dict__, write)
Guido van Rossume4dea982006-04-21 13:45:00 +0000610 dispatch[DateTime] = dump_instance
611 dispatch[Binary] = dump_instance
Thomas Wouters89f507f2006-12-13 04:49:30 +0000612 # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix
613 # for the p3yk merge, this should probably be fixed more neatly.
614 dispatch["_arbitrary_instance"] = dump_instance
Fredrik Lundhb9056332001-07-11 17:42:21 +0000615
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000616##
617# XML-RPC unmarshaller.
618#
619# @see loads
620
Fredrik Lundhb9056332001-07-11 17:42:21 +0000621class Unmarshaller:
Fred Drake1b410792001-09-04 18:55:03 +0000622 """Unmarshal an XML-RPC response, based on incoming XML event
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000623 messages (start, data, end). Call close() to get the resulting
Fred Drake1b410792001-09-04 18:55:03 +0000624 data structure.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000625
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000626 Note that this reader is fairly tolerant, and gladly accepts bogus
627 XML-RPC data without complaining (but not bogus XML).
Fred Drake1b410792001-09-04 18:55:03 +0000628 """
Fredrik Lundhb9056332001-07-11 17:42:21 +0000629
630 # and again, if you don't understand what's going on in here,
631 # that's perfectly ok.
632
Florent Xicluna61665192011-11-15 20:53:25 +0100633 def __init__(self, use_datetime=False, use_builtin_types=False):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000634 self._type = None
635 self._stack = []
636 self._marks = []
637 self._data = []
638 self._methodname = None
639 self._encoding = "utf-8"
640 self.append = self._stack.append
Florent Xicluna61665192011-11-15 20:53:25 +0100641 self._use_datetime = use_builtin_types or use_datetime
642 self._use_bytes = use_builtin_types
Fredrik Lundhb9056332001-07-11 17:42:21 +0000643
644 def close(self):
645 # return response tuple and target method
646 if self._type is None or self._marks:
647 raise ResponseError()
648 if self._type == "fault":
Guido van Rossum68468eb2003-02-27 20:14:51 +0000649 raise Fault(**self._stack[0])
Fredrik Lundhb9056332001-07-11 17:42:21 +0000650 return tuple(self._stack)
651
652 def getmethodname(self):
653 return self._methodname
654
655 #
656 # event handlers
657
658 def xml(self, encoding, standalone):
659 self._encoding = encoding
660 # FIXME: assert standalone == 1 ???
661
662 def start(self, tag, attrs):
663 # prepare to handle this element
664 if tag == "array" or tag == "struct":
665 self._marks.append(len(self._stack))
666 self._data = []
667 self._value = (tag == "value")
668
669 def data(self, text):
670 self._data.append(text)
671
Neal Norwitzff113342007-04-17 08:42:15 +0000672 def end(self, tag):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000673 # call the appropriate end tag handler
674 try:
675 f = self.dispatch[tag]
676 except KeyError:
677 pass # unknown tag ?
678 else:
Neal Norwitzff113342007-04-17 08:42:15 +0000679 return f(self, "".join(self._data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000680
681 #
682 # accelerator support
683
684 def end_dispatch(self, tag, data):
685 # dispatch data
686 try:
687 f = self.dispatch[tag]
688 except KeyError:
689 pass # unknown tag ?
690 else:
691 return f(self, data)
692
693 #
694 # element decoders
695
696 dispatch = {}
697
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000698 def end_nil (self, data):
699 self.append(None)
700 self._value = 0
701 dispatch["nil"] = end_nil
Tim Petersc2659cf2003-05-12 20:19:37 +0000702
Fredrik Lundh1538c232001-10-01 19:42:03 +0000703 def end_boolean(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000704 if data == "0":
705 self.append(False)
706 elif data == "1":
707 self.append(True)
708 else:
Collin Winterce36ad82007-08-30 01:19:48 +0000709 raise TypeError("bad boolean value")
Fredrik Lundhb9056332001-07-11 17:42:21 +0000710 self._value = 0
711 dispatch["boolean"] = end_boolean
712
Fredrik Lundh1538c232001-10-01 19:42:03 +0000713 def end_int(self, data):
714 self.append(int(data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000715 self._value = 0
716 dispatch["i4"] = end_int
Georg Brandlf08a9dd2008-06-10 16:57:31 +0000717 dispatch["i8"] = end_int
Fredrik Lundhb9056332001-07-11 17:42:21 +0000718 dispatch["int"] = end_int
719
Fredrik Lundh1538c232001-10-01 19:42:03 +0000720 def end_double(self, data):
721 self.append(float(data))
Fredrik Lundhb9056332001-07-11 17:42:21 +0000722 self._value = 0
723 dispatch["double"] = end_double
724
Fredrik Lundh1538c232001-10-01 19:42:03 +0000725 def end_string(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000726 if self._encoding:
Alexandre Vassalottie671fd22009-07-22 02:32:34 +0000727 data = data.decode(self._encoding)
728 self.append(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000729 self._value = 0
730 dispatch["string"] = end_string
731 dispatch["name"] = end_string # struct keys are always strings
732
733 def end_array(self, data):
Raymond Hettinger46ac8eb2002-06-30 03:39:14 +0000734 mark = self._marks.pop()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000735 # map arrays to Python lists
736 self._stack[mark:] = [self._stack[mark:]]
737 self._value = 0
738 dispatch["array"] = end_array
739
740 def end_struct(self, data):
Raymond Hettinger46ac8eb2002-06-30 03:39:14 +0000741 mark = self._marks.pop()
Fredrik Lundhb9056332001-07-11 17:42:21 +0000742 # map structs to Python dictionaries
743 dict = {}
744 items = self._stack[mark:]
745 for i in range(0, len(items), 2):
Alexandre Vassalottie671fd22009-07-22 02:32:34 +0000746 dict[items[i]] = items[i+1]
Fredrik Lundhb9056332001-07-11 17:42:21 +0000747 self._stack[mark:] = [dict]
748 self._value = 0
749 dispatch["struct"] = end_struct
750
Fredrik Lundh1538c232001-10-01 19:42:03 +0000751 def end_base64(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000752 value = Binary()
Guido van Rossum54a40cb2007-08-27 22:27:41 +0000753 value.decode(data.encode("ascii"))
Florent Xicluna61665192011-11-15 20:53:25 +0100754 if self._use_bytes:
755 value = value.data
Fredrik Lundhb9056332001-07-11 17:42:21 +0000756 self.append(value)
757 self._value = 0
758 dispatch["base64"] = end_base64
759
Fredrik Lundh1538c232001-10-01 19:42:03 +0000760 def end_dateTime(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000761 value = DateTime()
Fredrik Lundh1538c232001-10-01 19:42:03 +0000762 value.decode(data)
Skip Montanaro174dd222005-05-14 20:54:16 +0000763 if self._use_datetime:
764 value = _datetime_type(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000765 self.append(value)
766 dispatch["dateTime.iso8601"] = end_dateTime
767
768 def end_value(self, data):
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000769 # if we stumble upon a value element with no internal
Fredrik Lundhb9056332001-07-11 17:42:21 +0000770 # elements, treat it as a string element
771 if self._value:
772 self.end_string(data)
773 dispatch["value"] = end_value
774
775 def end_params(self, data):
776 self._type = "params"
777 dispatch["params"] = end_params
778
779 def end_fault(self, data):
780 self._type = "fault"
781 dispatch["fault"] = end_fault
782
Fredrik Lundh1538c232001-10-01 19:42:03 +0000783 def end_methodName(self, data):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000784 if self._encoding:
Alexandre Vassalottie671fd22009-07-22 02:32:34 +0000785 data = data.decode(self._encoding)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000786 self._methodname = data
787 self._type = "methodName" # no params
788 dispatch["methodName"] = end_methodName
789
Martin v. Löwis45394c22003-10-31 13:49:36 +0000790## Multicall support
791#
Fredrik Lundhb9056332001-07-11 17:42:21 +0000792
Martin v. Löwis45394c22003-10-31 13:49:36 +0000793class _MultiCallMethod:
794 # some lesser magic to store calls made to a MultiCall object
795 # for batch execution
796 def __init__(self, call_list, name):
797 self.__call_list = call_list
798 self.__name = name
799 def __getattr__(self, name):
800 return _MultiCallMethod(self.__call_list, "%s.%s" % (self.__name, name))
801 def __call__(self, *args):
802 self.__call_list.append((self.__name, args))
803
Martin v. Löwis12237b32004-08-22 16:04:50 +0000804class MultiCallIterator:
Martin v. Löwis45394c22003-10-31 13:49:36 +0000805 """Iterates over the results of a multicall. Exceptions are
Andrew Svetlov737fb892012-12-18 21:14:22 +0200806 raised in response to xmlrpc faults."""
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000807
Martin v. Löwis12237b32004-08-22 16:04:50 +0000808 def __init__(self, results):
809 self.results = results
810
811 def __getitem__(self, i):
812 item = self.results[i]
813 if type(item) == type({}):
814 raise Fault(item['faultCode'], item['faultString'])
815 elif type(item) == type([]):
816 return item[0]
Martin v. Löwis45394c22003-10-31 13:49:36 +0000817 else:
Collin Winterce36ad82007-08-30 01:19:48 +0000818 raise ValueError("unexpected type in multicall result")
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000819
Martin v. Löwis45394c22003-10-31 13:49:36 +0000820class MultiCall:
821 """server -> a object used to boxcar method calls
822
823 server should be a ServerProxy object.
824
825 Methods can be added to the MultiCall using normal
826 method call syntax e.g.:
827
828 multicall = MultiCall(server_proxy)
829 multicall.add(2,3)
830 multicall.get_address("Guido")
831
832 To execute the multicall, call the MultiCall object e.g.:
833
834 add_result, address = multicall()
835 """
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000836
Martin v. Löwis45394c22003-10-31 13:49:36 +0000837 def __init__(self, server):
838 self.__server = server
839 self.__call_list = []
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000840
Martin v. Löwis45394c22003-10-31 13:49:36 +0000841 def __repr__(self):
Serhiy Storchaka465e60e2014-07-25 23:36:00 +0300842 return "<%s at %#x>" % (self.__class__.__name__, id(self))
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000843
Martin v. Löwis45394c22003-10-31 13:49:36 +0000844 __str__ = __repr__
845
846 def __getattr__(self, name):
847 return _MultiCallMethod(self.__call_list, name)
848
849 def __call__(self):
850 marshalled_list = []
851 for name, args in self.__call_list:
852 marshalled_list.append({'methodName' : name, 'params' : args})
853
854 return MultiCallIterator(self.__server.system.multicall(marshalled_list))
Raymond Hettingercc523fc2003-11-02 09:47:05 +0000855
Fredrik Lundhb9056332001-07-11 17:42:21 +0000856# --------------------------------------------------------------------
857# convenience functions
858
Georg Brandl38eceaa2008-05-26 11:14:17 +0000859FastMarshaller = FastParser = FastUnmarshaller = None
860
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000861##
862# Create a parser object, and connect it to an unmarshalling instance.
863# This function picks the fastest available XML parser.
864#
865# return A (parser, unmarshaller) tuple.
866
Florent Xicluna61665192011-11-15 20:53:25 +0100867def getparser(use_datetime=False, use_builtin_types=False):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000868 """getparser() -> parser, unmarshaller
869
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000870 Create an instance of the fastest available parser, and attach it
871 to an unmarshalling object. Return both objects.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000872 """
873 if FastParser and FastUnmarshaller:
Florent Xicluna61665192011-11-15 20:53:25 +0100874 if use_builtin_types:
Skip Montanaro174dd222005-05-14 20:54:16 +0000875 mkdatetime = _datetime_type
Florent Xicluna61665192011-11-15 20:53:25 +0100876 mkbytes = base64.decodebytes
877 elif use_datetime:
878 mkdatetime = _datetime_type
879 mkbytes = _binary
Skip Montanaro174dd222005-05-14 20:54:16 +0000880 else:
881 mkdatetime = _datetime
Florent Xicluna61665192011-11-15 20:53:25 +0100882 mkbytes = _binary
883 target = FastUnmarshaller(True, False, mkbytes, mkdatetime, Fault)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000884 parser = FastParser(target)
885 else:
Florent Xicluna61665192011-11-15 20:53:25 +0100886 target = Unmarshaller(use_datetime=use_datetime, use_builtin_types=use_builtin_types)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000887 if FastParser:
888 parser = FastParser(target)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000889 else:
Georg Brandlcef803f2009-06-04 09:04:53 +0000890 parser = ExpatParser(target)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000891 return parser, target
892
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000893##
894# Convert a Python tuple or a Fault instance to an XML-RPC packet.
895#
896# @def dumps(params, **options)
897# @param params A tuple or Fault instance.
898# @keyparam methodname If given, create a methodCall request for
899# this method name.
900# @keyparam methodresponse If given, create a methodResponse packet.
901# If used with a tuple, the tuple must be a singleton (that is,
902# it must contain exactly one element).
903# @keyparam encoding The packet encoding.
904# @return A string containing marshalled data.
905
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000906def dumps(params, methodname=None, methodresponse=None, encoding=None,
Georg Brandlfe991052009-09-16 15:54:04 +0000907 allow_none=False):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000908 """data [,options] -> marshalled data
909
910 Convert an argument tuple or a Fault instance to an XML-RPC
911 request (or response, if the methodresponse option is used).
912
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000913 In addition to the data object, the following options can be given
914 as keyword arguments:
Fredrik Lundhb9056332001-07-11 17:42:21 +0000915
916 methodname: the method name for a methodCall packet
917
918 methodresponse: true to create a methodResponse packet.
919 If this option is used with a tuple, the tuple must be
920 a singleton (i.e. it can contain only one element).
921
922 encoding: the packet encoding (default is UTF-8)
923
Florent Xicluna61665192011-11-15 20:53:25 +0100924 All byte strings in the data structure are assumed to use the
Fredrik Lundhb9056332001-07-11 17:42:21 +0000925 packet encoding. Unicode strings are automatically converted,
Fredrik Lundhb0e8e9b2001-09-10 21:45:42 +0000926 where necessary.
Fredrik Lundhb9056332001-07-11 17:42:21 +0000927 """
928
Guido van Rossum13257902007-06-07 23:15:56 +0000929 assert isinstance(params, (tuple, Fault)), "argument must be tuple or Fault instance"
Fredrik Lundhb9056332001-07-11 17:42:21 +0000930 if isinstance(params, Fault):
931 methodresponse = 1
Guido van Rossum13257902007-06-07 23:15:56 +0000932 elif methodresponse and isinstance(params, tuple):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000933 assert len(params) == 1, "response tuple must be a singleton"
934
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000935 if not encoding:
Fredrik Lundhb9056332001-07-11 17:42:21 +0000936 encoding = "utf-8"
937
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000938 if FastMarshaller:
939 m = FastMarshaller(encoding)
940 else:
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +0000941 m = Marshaller(encoding, allow_none)
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000942
Fredrik Lundhb9056332001-07-11 17:42:21 +0000943 data = m.dumps(params)
944
945 if encoding != "utf-8":
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000946 xmlheader = "<?xml version='1.0' encoding='%s'?>\n" % str(encoding)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000947 else:
948 xmlheader = "<?xml version='1.0'?>\n" # utf-8 is default
949
950 # standard XML-RPC wrappings
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000951 if methodname:
Fredrik Lundhb9056332001-07-11 17:42:21 +0000952 # a method call
Guido van Rossum3172c5d2007-10-16 18:12:55 +0000953 if not isinstance(methodname, str):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000954 methodname = methodname.encode(encoding)
955 data = (
956 xmlheader,
957 "<methodCall>\n"
958 "<methodName>", methodname, "</methodName>\n",
959 data,
960 "</methodCall>\n"
961 )
962 elif methodresponse:
963 # a method response, or a fault structure
964 data = (
965 xmlheader,
966 "<methodResponse>\n",
967 data,
968 "</methodResponse>\n"
969 )
970 else:
971 return data # return as is
Neal Norwitzff113342007-04-17 08:42:15 +0000972 return "".join(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000973
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000974##
975# Convert an XML-RPC packet to a Python object. If the XML-RPC packet
976# represents a fault condition, this function raises a Fault exception.
977#
978# @param data An XML-RPC packet, given as an 8-bit string.
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000979# @return A tuple containing the unpacked data, and the method name
Fredrik Lundh3d9addd2002-06-27 21:36:21 +0000980# (None if not present).
981# @see Fault
982
Florent Xicluna61665192011-11-15 20:53:25 +0100983def loads(data, use_datetime=False, use_builtin_types=False):
Fredrik Lundhb9056332001-07-11 17:42:21 +0000984 """data -> unmarshalled data, method name
985
986 Convert an XML-RPC packet to unmarshalled data plus a method
987 name (None if not present).
988
989 If the XML-RPC packet represents a fault condition, this function
990 raises a Fault exception.
991 """
Florent Xicluna61665192011-11-15 20:53:25 +0100992 p, u = getparser(use_datetime=use_datetime, use_builtin_types=use_builtin_types)
Fredrik Lundhb9056332001-07-11 17:42:21 +0000993 p.feed(data)
994 p.close()
995 return u.close(), u.getmethodname()
996
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +0000997##
998# Encode a string using the gzip content encoding such as specified by the
999# Content-Encoding: gzip
1000# in the HTTP header, as described in RFC 1952
1001#
1002# @param data the unencoded data
1003# @return the encoded data
1004
1005def gzip_encode(data):
1006 """data -> gzip encoded data
1007
1008 Encode data using the gzip content encoding as described in RFC 1952
1009 """
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +00001010 if not gzip:
1011 raise NotImplementedError
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001012 f = BytesIO()
1013 gzf = gzip.GzipFile(mode="wb", fileobj=f, compresslevel=1)
1014 gzf.write(data)
1015 gzf.close()
1016 encoded = f.getvalue()
1017 f.close()
1018 return encoded
1019
1020##
1021# Decode a string using the gzip content encoding such as specified by the
1022# Content-Encoding: gzip
1023# in the HTTP header, as described in RFC 1952
1024#
1025# @param data The encoded data
Benjamin Peterson4e9cefa2014-12-05 20:15:15 -05001026# @keyparam max_decode Maximum bytes to decode (20MB default), use negative
1027# values for unlimited decoding
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001028# @return the unencoded data
1029# @raises ValueError if data is not correctly coded.
Benjamin Peterson4e9cefa2014-12-05 20:15:15 -05001030# @raises ValueError if max gzipped payload length exceeded
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001031
Benjamin Peterson4e9cefa2014-12-05 20:15:15 -05001032def gzip_decode(data, max_decode=20971520):
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001033 """gzip encoded data -> unencoded data
1034
1035 Decode data using the gzip content encoding as described in RFC 1952
1036 """
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +00001037 if not gzip:
1038 raise NotImplementedError
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001039 f = BytesIO(data)
1040 gzf = gzip.GzipFile(mode="rb", fileobj=f)
1041 try:
Benjamin Peterson4e9cefa2014-12-05 20:15:15 -05001042 if max_decode < 0: # no limit
1043 decoded = gzf.read()
1044 else:
1045 decoded = gzf.read(max_decode + 1)
Andrew Svetlovf7a17b42012-12-25 16:47:37 +02001046 except OSError:
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001047 raise ValueError("invalid data")
1048 f.close()
1049 gzf.close()
Benjamin Peterson4e9cefa2014-12-05 20:15:15 -05001050 if max_decode >= 0 and len(decoded) > max_decode:
1051 raise ValueError("max gzipped payload length exceeded")
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001052 return decoded
1053
1054##
1055# Return a decoded file-like object for the gzip encoding
1056# as described in RFC 1952.
1057#
1058# @param response A stream supporting a read() method
1059# @return a file-like object that the decoded data can be read() from
1060
Kristján Valur Jónsson9ab07312009-07-19 22:38:38 +00001061class GzipDecodedResponse(gzip.GzipFile if gzip else object):
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001062 """a file-like object to decode a response encoded with the gzip
1063 method, as described in RFC 1952.
1064 """
1065 def __init__(self, response):
1066 #response doesn't support tell() and read(), required by
1067 #GzipFile
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +00001068 if not gzip:
1069 raise NotImplementedError
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001070 self.io = BytesIO(response.read())
1071 gzip.GzipFile.__init__(self, mode="rb", fileobj=self.io)
1072
1073 def close(self):
1074 gzip.GzipFile.close(self)
1075 self.io.close()
1076
Fredrik Lundhb9056332001-07-11 17:42:21 +00001077
1078# --------------------------------------------------------------------
1079# request dispatcher
1080
1081class _Method:
1082 # some magic to bind an XML-RPC method to an RPC server.
1083 # supports "nested" methods (e.g. examples.getStateName)
1084 def __init__(self, send, name):
1085 self.__send = send
1086 self.__name = name
1087 def __getattr__(self, name):
1088 return _Method(self.__send, "%s.%s" % (self.__name, name))
1089 def __call__(self, *args):
1090 return self.__send(self.__name, args)
1091
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001092##
1093# Standard transport class for XML-RPC over HTTP.
1094# <p>
1095# You can create custom transports by subclassing this method, and
1096# overriding selected methods.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001097
1098class Transport:
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001099 """Handles an HTTP transaction to an XML-RPC server."""
Fredrik Lundhb9056332001-07-11 17:42:21 +00001100
1101 # client identifier (may be overridden)
Florent Xicluna75861df2011-10-30 20:39:24 +01001102 user_agent = "Python-xmlrpc/%s" % __version__
Fredrik Lundhb9056332001-07-11 17:42:21 +00001103
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001104 #if true, we'll request gzip encoding
1105 accept_gzip_encoding = True
1106
1107 # if positive, encode request using gzip if it exceeds this threshold
1108 # note that many server will get confused, so only use it if you know
1109 # that they can decode such a request
1110 encode_threshold = None #None = don't encode
1111
Florent Xicluna61665192011-11-15 20:53:25 +01001112 def __init__(self, use_datetime=False, use_builtin_types=False):
Skip Montanaro174dd222005-05-14 20:54:16 +00001113 self._use_datetime = use_datetime
Florent Xicluna61665192011-11-15 20:53:25 +01001114 self._use_builtin_types = use_builtin_types
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001115 self._connection = (None, None)
1116 self._extra_headers = []
Skip Montanaro174dd222005-05-14 20:54:16 +00001117
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001118 ##
1119 # Send a complete request, and parse the response.
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001120 # Retry request if a cached connection has disconnected.
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001121 #
1122 # @param host Target host.
1123 # @param handler Target PRC handler.
1124 # @param request_body XML-RPC request body.
1125 # @param verbose Debugging flag.
1126 # @return Parsed response.
1127
Georg Brandlfe991052009-09-16 15:54:04 +00001128 def request(self, host, handler, request_body, verbose=False):
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001129 #retry request once if cached connection has gone cold
1130 for i in (0, 1):
1131 try:
1132 return self.single_request(host, handler, request_body, verbose)
Andrew Svetlov0832af62012-12-18 23:10:48 +02001133 except OSError as e:
1134 if i or e.errno not in (errno.ECONNRESET, errno.ECONNABORTED,
1135 errno.EPIPE):
Kristján Valur Jónsson43535d92009-07-03 23:23:50 +00001136 raise
1137 except http.client.BadStatusLine: #close after we sent request
1138 if i:
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001139 raise
1140
Georg Brandlfe991052009-09-16 15:54:04 +00001141 def single_request(self, host, handler, request_body, verbose=False):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001142 # issue XML-RPC request
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001143 try:
1144 http_conn = self.send_request(host, handler, request_body, verbose)
1145 resp = http_conn.getresponse()
1146 if resp.status == 200:
1147 self.verbose = verbose
1148 return self.parse_response(resp)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001149
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001150 except Fault:
1151 raise
1152 except Exception:
1153 #All unexpected errors leave connection in
1154 # a strange state, so we clear it.
1155 self.close()
1156 raise
Fredrik Lundhb9056332001-07-11 17:42:21 +00001157
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001158 #We got an error response.
1159 #Discard any response data and raise exception
1160 if resp.getheader("content-length", ""):
1161 resp.read()
1162 raise ProtocolError(
1163 host + handler,
1164 resp.status, resp.reason,
1165 dict(resp.getheaders())
1166 )
Fredrik Lundhb9056332001-07-11 17:42:21 +00001167
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001168
1169 ##
1170 # Create parser.
1171 #
1172 # @return A 2-tuple containing a parser and a unmarshaller.
Fredrik Lundhb9056332001-07-11 17:42:21 +00001173
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001174 def getparser(self):
1175 # get parser and unmarshaller
Florent Xicluna61665192011-11-15 20:53:25 +01001176 return getparser(use_datetime=self._use_datetime,
1177 use_builtin_types=self._use_builtin_types)
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001178
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001179 ##
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001180 # Get authorization info from host parameter
1181 # Host may be a string, or a (host, x509-dict) tuple; if a string,
1182 # it is checked for a "user:pw@host" format, and a "Basic
1183 # Authentication" header is added if appropriate.
1184 #
1185 # @param host Host descriptor (URL or (URL, x509 info) tuple).
1186 # @return A 3-tuple containing (actual host, extra headers,
1187 # x509 info). The header and x509 fields may be None.
1188
1189 def get_host_info(self, host):
1190
1191 x509 = {}
Guido van Rossum13257902007-06-07 23:15:56 +00001192 if isinstance(host, tuple):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001193 host, x509 = host
1194
Jeremy Hylton1afc1692008-06-18 20:49:58 +00001195 auth, host = urllib.parse.splituser(host)
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001196
1197 if auth:
Georg Brandlc8dcfb62009-02-13 10:50:01 +00001198 auth = urllib.parse.unquote_to_bytes(auth)
Georg Brandlb54d8012009-06-04 09:11:51 +00001199 auth = base64.encodebytes(auth).decode("utf-8")
Neal Norwitzff113342007-04-17 08:42:15 +00001200 auth = "".join(auth.split()) # get rid of whitespace
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001201 extra_headers = [
1202 ("Authorization", "Basic " + auth)
1203 ]
1204 else:
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001205 extra_headers = []
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001206
1207 return host, extra_headers, x509
1208
1209 ##
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001210 # Connect to server.
1211 #
1212 # @param host Target host.
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001213 # @return An HTTPConnection object
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001214
Fredrik Lundhb9056332001-07-11 17:42:21 +00001215 def make_connection(self, host):
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001216 #return an existing connection if possible. This allows
1217 #HTTP/1.1 keep-alive.
1218 if self._connection and host == self._connection[0]:
1219 return self._connection[1]
Fredrik Lundhb9056332001-07-11 17:42:21 +00001220 # create a HTTP connection object from a host descriptor
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001221 chost, self._extra_headers, x509 = self.get_host_info(host)
1222 self._connection = host, http.client.HTTPConnection(chost)
1223 return self._connection[1]
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001224
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001225 ##
1226 # Clear any cached connection object.
1227 # Used in the event of socket errors.
1228 #
1229 def close(self):
1230 if self._connection[1]:
1231 self._connection[1].close()
1232 self._connection = (None, None)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001233
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001234 ##
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001235 # Send HTTP request.
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001236 #
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001237 # @param host Host descriptor (URL or (URL, x509 info) tuple).
1238 # @param handler Targer RPC handler (a path relative to host)
1239 # @param request_body The XML-RPC request body
1240 # @param debug Enable debugging if debug is true.
1241 # @return An HTTPConnection.
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001242
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001243 def send_request(self, host, handler, request_body, debug):
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001244 connection = self.make_connection(host)
1245 headers = self._extra_headers[:]
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001246 if debug:
1247 connection.set_debuglevel(1)
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +00001248 if self.accept_gzip_encoding and gzip:
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001249 connection.putrequest("POST", handler, skip_accept_encoding=True)
1250 headers.append(("Accept-Encoding", "gzip"))
1251 else:
1252 connection.putrequest("POST", handler)
1253 headers.append(("Content-Type", "text/xml"))
1254 headers.append(("User-Agent", self.user_agent))
1255 self.send_headers(connection, headers)
1256 self.send_content(connection, request_body)
Jeremy Hylton5d8a88a2007-08-14 16:47:39 +00001257 return connection
Fredrik Lundhb9056332001-07-11 17:42:21 +00001258
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001259 ##
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001260 # Send request headers.
1261 # This function provides a useful hook for subclassing
1262 #
1263 # @param connection httpConnection.
1264 # @param headers list of key,value pairs for HTTP headers
1265
1266 def send_headers(self, connection, headers):
1267 for key, val in headers:
1268 connection.putheader(key, val)
1269
1270 ##
1271 # Send request body.
1272 # This function provides a useful hook for subclassing
1273 #
1274 # @param connection httpConnection.
1275 # @param request_body XML-RPC request body.
1276
1277 def send_content(self, connection, request_body):
1278 #optionally encode the request
1279 if (self.encode_threshold is not None and
Kristján Valur Jónssonaefde242009-07-19 22:29:24 +00001280 self.encode_threshold < len(request_body) and
1281 gzip):
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001282 connection.putheader("Content-Encoding", "gzip")
1283 request_body = gzip_encode(request_body)
1284
1285 connection.putheader("Content-Length", str(len(request_body)))
1286 connection.endheaders(request_body)
1287
1288 ##
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001289 # Parse response.
1290 #
1291 # @param file Stream.
1292 # @return Response tuple and target method.
1293
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001294 def parse_response(self, response):
1295 # read response data from httpresponse, and parse it
Senthil Kumaranf34445f2010-12-08 08:04:49 +00001296 # Check for new http response object, otherwise it is a file object.
1297 if hasattr(response, 'getheader'):
1298 if response.getheader("Content-Encoding", "") == "gzip":
1299 stream = GzipDecodedResponse(response)
1300 else:
1301 stream = response
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001302 else:
1303 stream = response
Fredrik Lundhb9056332001-07-11 17:42:21 +00001304
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001305 p, u = self.getparser()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001306
1307 while 1:
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001308 data = stream.read(1024)
1309 if not data:
Fredrik Lundhb9056332001-07-11 17:42:21 +00001310 break
1311 if self.verbose:
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001312 print("body:", repr(data))
1313 p.feed(data)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001314
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001315 if stream is not response:
1316 stream.close()
Fredrik Lundhb9056332001-07-11 17:42:21 +00001317 p.close()
1318
1319 return u.close()
1320
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001321##
1322# Standard transport class for XML-RPC over HTTPS.
1323
Fredrik Lundhb9056332001-07-11 17:42:21 +00001324class SafeTransport(Transport):
Fredrik Lundhc4c062f2001-09-10 19:45:02 +00001325 """Handles an HTTPS transaction to an XML-RPC server."""
Fredrik Lundhb9056332001-07-11 17:42:21 +00001326
Benjamin Petersonc1da3d12014-11-29 23:32:57 -05001327 def __init__(self, use_datetime=False, use_builtin_types=False, *,
1328 context=None):
1329 super().__init__(use_datetime=use_datetime, use_builtin_types=use_builtin_types)
1330 self.context = context
1331
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001332 # FIXME: mostly untested
1333
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001334 def make_connection(self, host):
1335 if self._connection and host == self._connection[0]:
1336 return self._connection[1]
1337
Senthil Kumaran6a0b5c42010-11-18 17:08:48 +00001338 if not hasattr(http.client, "HTTPSConnection"):
Fredrik Lundh1303c7c2002-10-22 18:23:00 +00001339 raise NotImplementedError(
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001340 "your version of http.client doesn't support HTTPS")
1341 # create a HTTPS connection object from a host descriptor
1342 # host may be a string, or a (host, x509-dict) tuple
1343 chost, self._extra_headers, x509 = self.get_host_info(host)
1344 self._connection = host, http.client.HTTPSConnection(chost,
Benjamin Petersonc1da3d12014-11-29 23:32:57 -05001345 None, context=self.context, **(x509 or {}))
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001346 return self._connection[1]
Fredrik Lundhb9056332001-07-11 17:42:21 +00001347
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001348##
1349# Standard server proxy. This class establishes a virtual connection
1350# to an XML-RPC server.
1351# <p>
1352# This class is available as ServerProxy and Server. New code should
1353# use ServerProxy, to avoid confusion.
1354#
1355# @def ServerProxy(uri, **options)
1356# @param uri The connection point on the server.
1357# @keyparam transport A transport factory, compatible with the
1358# standard transport class.
1359# @keyparam encoding The default encoding used for 8-bit strings
1360# (default is UTF-8).
1361# @keyparam verbose Use a true value to enable debugging output.
1362# (printed to standard output).
1363# @see Transport
1364
Fredrik Lundhb9056332001-07-11 17:42:21 +00001365class ServerProxy:
1366 """uri [,options] -> a logical connection to an XML-RPC server
1367
1368 uri is the connection point on the server, given as
1369 scheme://host/target.
1370
1371 The standard implementation always supports the "http" scheme. If
1372 SSL socket support is available (Python 2.0), it also supports
1373 "https".
1374
1375 If the target part and the slash preceding it are both omitted,
1376 "/RPC2" is assumed.
1377
1378 The following options can be given as keyword arguments:
1379
1380 transport: a transport factory
1381 encoding: the request encoding (default is UTF-8)
1382
1383 All 8-bit strings passed to the server proxy are assumed to use
1384 the given encoding.
1385 """
1386
Georg Brandlfe991052009-09-16 15:54:04 +00001387 def __init__(self, uri, transport=None, encoding=None, verbose=False,
Benjamin Petersonc1da3d12014-11-29 23:32:57 -05001388 allow_none=False, use_datetime=False, use_builtin_types=False,
1389 *, context=None):
Fredrik Lundhb9056332001-07-11 17:42:21 +00001390 # establish a "logical" server connection
1391
1392 # get the url
Jeremy Hylton1afc1692008-06-18 20:49:58 +00001393 type, uri = urllib.parse.splittype(uri)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001394 if type not in ("http", "https"):
Andrew Svetlovf7a17b42012-12-25 16:47:37 +02001395 raise OSError("unsupported XML-RPC protocol")
Jeremy Hylton1afc1692008-06-18 20:49:58 +00001396 self.__host, self.__handler = urllib.parse.splithost(uri)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001397 if not self.__handler:
1398 self.__handler = "/RPC2"
1399
1400 if transport is None:
1401 if type == "https":
Florent Xicluna61665192011-11-15 20:53:25 +01001402 handler = SafeTransport
Benjamin Petersonc1da3d12014-11-29 23:32:57 -05001403 extra_kwargs = {"context": context}
Fredrik Lundhb9056332001-07-11 17:42:21 +00001404 else:
Florent Xicluna61665192011-11-15 20:53:25 +01001405 handler = Transport
Benjamin Petersonc1da3d12014-11-29 23:32:57 -05001406 extra_kwargs = {}
Florent Xicluna61665192011-11-15 20:53:25 +01001407 transport = handler(use_datetime=use_datetime,
Benjamin Petersonc1da3d12014-11-29 23:32:57 -05001408 use_builtin_types=use_builtin_types,
1409 **extra_kwargs)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001410 self.__transport = transport
1411
Senthil Kumaranb3af08f2009-04-01 20:20:43 +00001412 self.__encoding = encoding or 'utf-8'
Fredrik Lundhb9056332001-07-11 17:42:21 +00001413 self.__verbose = verbose
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001414 self.__allow_none = allow_none
Tim Petersc2659cf2003-05-12 20:19:37 +00001415
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001416 def __close(self):
1417 self.__transport.close()
1418
Fredrik Lundhb9056332001-07-11 17:42:21 +00001419 def __request(self, methodname, params):
1420 # call a method on the remote server
1421
Andrew M. Kuchlinga4c2b742003-04-25 00:26:51 +00001422 request = dumps(params, methodname, encoding=self.__encoding,
Senthil Kumaranb3af08f2009-04-01 20:20:43 +00001423 allow_none=self.__allow_none).encode(self.__encoding)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001424
1425 response = self.__transport.request(
1426 self.__host,
1427 self.__handler,
1428 request,
1429 verbose=self.__verbose
1430 )
1431
1432 if len(response) == 1:
1433 response = response[0]
1434
1435 return response
1436
1437 def __repr__(self):
1438 return (
Serhiy Storchaka465e60e2014-07-25 23:36:00 +03001439 "<%s for %s%s>" %
1440 (self.__class__.__name__, self.__host, self.__handler)
Fredrik Lundhb9056332001-07-11 17:42:21 +00001441 )
1442
1443 __str__ = __repr__
Raymond Hettingercc523fc2003-11-02 09:47:05 +00001444
Fredrik Lundhb9056332001-07-11 17:42:21 +00001445 def __getattr__(self, name):
1446 # magic method dispatcher
1447 return _Method(self.__request, name)
1448
1449 # note: to call a remote object with an non-standard name, use
1450 # result getattr(server, "strange-python-name")(args)
1451
Kristján Valur Jónsson985fc6a2009-07-01 10:01:31 +00001452 def __call__(self, attr):
1453 """A workaround to get special attributes on the ServerProxy
1454 without interfering with the magic __getattr__
1455 """
1456 if attr == "close":
1457 return self.__close
1458 elif attr == "transport":
1459 return self.__transport
1460 raise AttributeError("Attribute %r not found" % (attr,))
1461
Brett Cannon33a40002014-03-21 11:24:40 -04001462 def __enter__(self):
1463 return self
1464
1465 def __exit__(self, *args):
1466 self.__close()
1467
Fredrik Lundh78eedce2001-08-23 20:04:33 +00001468# compatibility
Fredrik Lundh3d9addd2002-06-27 21:36:21 +00001469
Fredrik Lundhb9056332001-07-11 17:42:21 +00001470Server = ServerProxy
1471
1472# --------------------------------------------------------------------
1473# test code
1474
1475if __name__ == "__main__":
1476
1477 # simple test program (from the XML-RPC specification)
1478
Senthil Kumaran939e2db2014-01-12 16:06:58 -08001479 # local server, available from Lib/xmlrpc/server.py
1480 server = ServerProxy("http://localhost:8000")
Fredrik Lundhb9056332001-07-11 17:42:21 +00001481
Fredrik Lundhb9056332001-07-11 17:42:21 +00001482 try:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001483 print(server.currentTime.getCurrentTime())
Guido van Rossumb940e112007-01-10 16:19:56 +00001484 except Error as v:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001485 print("ERROR", v)
Martin v. Löwis12237b32004-08-22 16:04:50 +00001486
1487 multi = MultiCall(server)
Senthil Kumaran939e2db2014-01-12 16:06:58 -08001488 multi.getData()
1489 multi.pow(2,9)
1490 multi.add(1,2)
Martin v. Löwis12237b32004-08-22 16:04:50 +00001491 try:
1492 for response in multi():
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001493 print(response)
Guido van Rossumb940e112007-01-10 16:19:56 +00001494 except Error as v:
Guido van Rossumbe19ed72007-02-09 05:37:30 +00001495 print("ERROR", v)