home *** CD-ROM | disk | FTP | other *** search
/ PC World 2002 May / PCWorld_2002-05_cd.bin / Software / TemaCD / activepython / ActivePython-2.1.1.msi / Python21_PPM_soaplib.py < prev    next >
Encoding:
Python Source  |  2001-07-26  |  22.8 KB  |  857 lines
  1. #
  2. # SOAP CLIENT LIBRARY
  3. # $Id$
  4. #
  5. # an SOAP 1.1 client interface for Python.
  6. #
  7. # the marshalling and response parser code can also be used to
  8. # implement SOAP servers.
  9. #
  10. # Notes:
  11. # this version uses the sgmlop XML parser, if installed.  this is
  12. # typically 10-15x faster than using Python's standard XML parser.
  13. #
  14. # you can get the sgmlop distribution from:
  15. #
  16. #    http://www.pythonware.com/products/xml
  17. #
  18. # also note that this version is designed to work with Python 1.5.2
  19. # and newer.  it does not work under 1.5.1 or earlier.
  20. #
  21. # Contact:
  22. # fredrik@pythonware.com
  23. # http://www.pythonware.com
  24. #
  25. # History:
  26. # 2000-01-05 fl  First experimental version (based on xmlrpclib.py)
  27. # 2000-02-15 fl  Updated to SOAP 1.0
  28. # 2000-04-30 fl  Major overhaul, updated for SOAP 1.1
  29. # 2000-05-27 fl  Fixed xmllib support
  30. # 2000-06-20 fl  Frontier interoperability testing
  31. #
  32. # Copyright (c) 1999-2000 by Secret Labs AB.
  33. # Copyright (c) 1999-2000 by Fredrik Lundh.
  34. #
  35. # Portions of this engine have been developed in cooperation with
  36. # Loudcloud, Inc.
  37. #
  38. # --------------------------------------------------------------------
  39. # The soaplib.py library is
  40. # 
  41. # Copyright (c) 1999-2000 by Secret Labs AB
  42. # Copyright (c) 1999-2000 by Fredrik Lundh
  43. #
  44. # By obtaining, using, and/or copying this software and/or its
  45. # associated documentation, you agree that you have read, understood,
  46. # and will comply with the following terms and conditions:
  47. #
  48. # Permission to use, copy, modify, and distribute this software and
  49. # its associated documentation for any purpose and without fee is
  50. # hereby granted, provided that the above copyright notice appears in
  51. # all copies, and that both that copyright notice and this permission
  52. # notice appear in supporting documentation, and that the name of
  53. # Secret Labs AB or the author not be used in advertising or publicity
  54. # pertaining to distribution of the software without specific, written
  55. # prior permission.
  56. #
  57. # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
  58. # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
  59. # ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
  60. # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  61. # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  62. # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  63. # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  64. # OF THIS SOFTWARE.
  65. # --------------------------------------------------------------------
  66.  
  67. # FIXME: handle Fault messages correctly
  68. # FIXME: handle homogenous arrays
  69. # FIXME: handle more time types
  70. # FIXME: add support for more character sets (under 1.6)
  71. # FIXME: incorporate id/href patches (from John Lehmann)
  72. #
  73. # 2001-02-20 fixed the bugs in the XML namespaces and also added __repr__
  74. #            method to the Binary class.
  75. #            Houman Gharmi <houmangh@activestate.com>
  76. #
  77.  
  78. import string, time, re
  79. import urllib, xmllib
  80. from types import *
  81. from cgi import escape
  82.  
  83. try:
  84.     import sgmlop
  85. except ImportError:
  86.     sgmlop = None # accelerator not available
  87.  
  88. # how far we're from a real 1.0 :-)
  89. __version__ = "0.8-hacked"
  90.  
  91. # schema namespaces
  92. NS_XSD = "http://www.w3.org/1999/XMLSchema"
  93. NS_XSI = "http://www.w3.org/1999/XMLSchema-instance"
  94.  
  95. # soap namespaces
  96. NS_ENV = "http://schemas.xmlsoap.org/soap/envelope/"
  97. NS_ENC = "http://schemas.xmlsoap.org/soap/encoding/"
  98.  
  99. # experimental extensions
  100. NS_LAB = "http://www.pythonware.com/soap/"
  101.  
  102. # envelope tag.  declare all namespaces used by the payload
  103. ENVELOPE = (
  104.     "<env:Envelope "
  105.     "xmlns:env='" + NS_ENV + "' "
  106.     "xmlns:enc='" + NS_ENC + "' "
  107.     "xmlns:lab='" + NS_LAB + "' "
  108.     "xmlns:xsd='" + NS_XSD + "' "
  109.     "xmlns:xsi='" + NS_XSI + "' "
  110.     "env:encodingStyle='" + NS_ENC + "'"
  111.     ">\n"
  112.     )
  113.  
  114. SOAPTAGS = NS_ENV + "Envelope", NS_ENV + "Body"
  115.  
  116. # check if a string is valid XML tag
  117. _is_valid_tag = re.compile("^[a-zA-Z_][-a-zA-Z0-9._]*$").match
  118. # FIXME: this should reject strings that start with [Xx][Mm][Ll]
  119.  
  120. # --------------------------------------------------------------------
  121. # Exceptions
  122.  
  123. class Error:
  124.     # base class for client errors
  125.     pass
  126.  
  127. class ProtocolError(Error):
  128.     # indicates an HTTP protocol error
  129.     def __init__(self, url, errcode, errmsg, headers):
  130.     self.url = url
  131.     self.errcode = errcode
  132.     self.errmsg = errmsg
  133.     self.headers = headers
  134.     def __repr__(self):
  135.     return (
  136.         "<ProtocolError for %s: %s %s>" %
  137.         (self.url, self.errcode, repr(self.errmsg))
  138.         )
  139.  
  140. class ResponseError(Error):
  141.     # indicates a broken response package
  142.     pass
  143.  
  144. class Fault(Error):
  145.     # indicates a SOAP fault package
  146.     def __init__(self, faultcode, faultstring, detail=None):
  147.     self.faultcode = faultcode
  148.     self.faultstring = faultstring
  149.     self.detail = None
  150.     def encode(self, out):
  151.     write = out.write
  152.     write("<env:Fault>\n")
  153.     write("<faultcode>%s</faultcode>" % self.faultcode)
  154.     write("<faultstring>%s</faultstring>" % self.faultstring)
  155.     if self.detail:
  156.         out._dump("detail", self.detail)
  157.     write("</env:Fault>\n")
  158.     def __repr__(self):
  159.     return (
  160.         "<Fault %s: %s>" %
  161.         (self.faultcode, repr(self.faultstring))
  162.         )
  163.  
  164. class MethodCall:
  165.     # (experimental) represents a set of named parameters
  166.     def __init__(self, method, namespace, pargs=(), kwargs={}):
  167.     self.method = method
  168.     self.namespace = namespace
  169.     self.pargs = pargs
  170.     self.kwargs = kwargs
  171.     def encode(self, out):
  172.     if self.namespace:
  173.         method = "rpc:" + self.method
  174.         out.write("<%s xmlns:rpc=%s>\n" % (method, repr(self.namespace)))
  175.     else:
  176.         method = self.method
  177.         out.write("<%s>\n" % method)
  178.     i = 1
  179.     for v in self.pargs:
  180.         out._dump("v.%d" % i, v)
  181.         i = i + 1
  182.     for k, v in self.kwargs.items():
  183.         out._dump(k, v)
  184.     out.write("</%s>\n" % method)
  185.  
  186. class Response:
  187.     # (experimental) represents a response tuple
  188.     def __init__(self, method, namespace, value=()):
  189.     self.method = method
  190.     self.namespace = namespace
  191.     self.value = value
  192.     def encode(self, out):
  193.     method = self.method + "Response"
  194.     if self.namespace:
  195.         method = "rpc:" + method
  196.         out.write("<%s xmlns:rpc=%s>\n" % (method, repr(self.namespace)))
  197.     else:
  198.         out.write("<%s>\n" % method)
  199.     i = 1
  200.     for v in self.value:
  201.         out._dump("v.%d" % i, v)
  202.         i = i + 1
  203.     out.write("</%s>\n" % method)
  204.  
  205.  
  206. # --------------------------------------------------------------------
  207. # Special values
  208.  
  209. # boolean wrapper
  210. # (you must use True or False to generate a "boolean" SOAP value)
  211.  
  212. class Boolean:
  213.  
  214.     def __init__(self, value = 0):
  215.     self.value = not not value
  216.  
  217.     def encode(self, tag, out):
  218.     out.write(
  219.         "<%s xsi:type='xsd:boolean'>%d</%s>\n" % (tag, self.value, tag)
  220.         )
  221.  
  222.     def __repr__(self):
  223.     if self.value:
  224.         return "<Boolean True at %x>" % id(self)
  225.     else:
  226.         return "<Boolean False at %x>" % id(self)
  227.  
  228.     def __int__(self):
  229.     return self.value
  230.  
  231.     def __nonzero__(self):
  232.     return self.value
  233.  
  234. True, False = Boolean(1), Boolean(0)
  235.  
  236. #
  237. # timePeriod wrapper
  238. # (wrap your iso8601 string or time tuple or localtime time value in
  239. # this class to generate a "timePeriod" SOAP value)
  240.  
  241. class DateTime:
  242.  
  243.     def __init__(self, value = 0):
  244.     t = type(value)
  245.     if t is not StringType:
  246.         if t is not TupleType:
  247.         value = time.localtime(value)
  248.         value = time.strftime("%Y%m%dT%H:%M:%S", value)
  249.     self.value = value
  250.  
  251.     def __repr__(self):
  252.     return "<DateTime %s at %x>" % (self.value, id(self))
  253.  
  254.     def decode(self, data):
  255.     self.value = string.strip(data)
  256.  
  257.     def encode(self, tag, out):
  258.     out.write(
  259.         "<%s xsi:type='xsd:timePeriod'>%s</%s>\n", (tag, self.value, tag)
  260.         )
  261.  
  262. #
  263. # binary data wrapper.  you must use this for strings that are not
  264. # valid XML strings (in other words, strings that cannot be stored
  265. # as a plain XML element).
  266.  
  267. class Binary:
  268.  
  269.     def __init__(self, data=None):
  270.     self.data = data
  271.  
  272.     def decode(self, data):
  273.     import base64
  274.     self.data = base64.decodestring(data)
  275.  
  276.     def encode(self, tag, out):
  277.     import base64, StringIO
  278.     out.write("<%s xsi:type='enc:base64'>\n" % tag)
  279.     base64.encode(StringIO.StringIO(self.data), out)
  280.     out.write("</%s>\n" % tag)
  281.  
  282.     def __repr__(self):
  283.         return self.data
  284.  
  285.     def __len__(self):
  286.         return len(self.data)
  287.  
  288.     __str__ = __repr__
  289.  
  290. WRAPPERS = DateTime, Binary, Boolean
  291.  
  292. # --------------------------------------------------------------------
  293. # XML parsers
  294.  
  295. if sgmlop:
  296.  
  297.     class FastParser:
  298.     # sgmlop based XML parser.  this is typically 15x faster
  299.     # than SlowParser...
  300.  
  301.     def __init__(self, target):
  302.  
  303.         # setup callbacks
  304.         self.finish_endtag = target.end
  305.         self.handle_data = target.data
  306.  
  307.         self.start = target.start
  308.  
  309.         self.namespace = {"xmlns": "xmlns"}
  310.  
  311.         # activate parser
  312.         self.parser = sgmlop.XMLParser()
  313.         self.parser.register(self)
  314.         self.feed = self.parser.feed
  315.         self.entity = {
  316.         "amp": "&", "gt": ">", "lt": "<",
  317.         "apos": "'", "quot": '"'
  318.         }
  319.  
  320.     def close(self):
  321.         try:
  322.         self.parser.close()
  323.         finally:
  324.         self.parser = self.feed = None # nuke circular reference
  325.  
  326.     def finish_starttag(self, tag, attrs):
  327.         # FIXME: this doesn't handle nested namespaces
  328.         items = attrs.items()
  329.         for k, v in items:
  330.         if k[:6] == "xmlns:":
  331.             self.namespace[k[6:]] = v
  332.         # fixup names
  333.         if ":" in tag:
  334.         ns, tag = string.split(tag, ":")
  335.         tag = self.namespace[ns] + tag
  336.         for k, v in items:
  337.         if ":" in k:
  338.             ns, k = string.split(k, ":")
  339.             k = self.namespace[ns] + k
  340.         attrs[k] = v
  341.         self.start(tag, attrs, self.namespace.get)
  342.  
  343.     def handle_entityref(self, entity):
  344.         # <string> entity
  345.         try:
  346.         self.handle_data(self.entity[entity])
  347.         except KeyError:
  348.         self.handle_data("&%s;" % entity)
  349.  
  350. else:
  351.  
  352.     FastParser = None
  353.  
  354. class SlowParser(xmllib.XMLParser):
  355.     # slow but safe standard parser, based on the XML parser in
  356.     # Python's standard library
  357.  
  358.     def __init__(self, target):
  359.     self.__start = target.start
  360.     self.handle_data = target.data
  361.     self.unknown_endtag = target.end
  362.     xmllib.XMLParser.__init__(self)
  363.  
  364.     def __namespace(self, prefix):
  365.     # map namespace prefix to full namespace
  366.     for tag, namespace, tag in self.stack:
  367.         if namespace.has_key(prefix):
  368.         return namespace[prefix]
  369.     return None
  370.  
  371.     def unknown_starttag(self, tag, attrs):
  372.     # fixup tags and attribute names (ouch!)
  373.     tag = string.replace(tag, " ", "")
  374.     for k, v in attrs.items():
  375.         k = string.replace(k, " ", "")
  376.         attrs[k] = v
  377.     self.__start(tag, attrs, self.__namespace)
  378.  
  379. # --------------------------------------------------------------------
  380. # SOAP marshalling and unmarshalling code
  381.  
  382. class Marshaller:
  383.     """Generate an SOAP body from a Python data structure"""
  384.  
  385.     # USAGE: create a marshaller instance for each set of parameters,
  386.     # and use "dumps" to convert your data (represented as a tuple) to
  387.     # a SOAP body chunk.  to write a fault response, pass a Fault
  388.     # instance instead.  you may prefer to use the "dumps" convenience
  389.     # function for this purpose (see below).
  390.  
  391.     # by the way, if you don't understand what's going on in here,
  392.     # that's perfectly ok.
  393.  
  394.     def __init__(self):
  395.     self.memo = {}
  396.     self.data = None
  397.  
  398.     dispatch = {}
  399.  
  400.     def dumps(self, value, envelope=0):
  401.     self.__out = []
  402.     self.write = write = self.__out.append
  403.     if envelope:
  404.         write(ENVELOPE)
  405.     write("<env:Body>\n")
  406.     if (isinstance(value, MethodCall) or
  407.         isinstance(value, Response) or
  408.         isinstance(value, Fault)):
  409.         value.encode(self)
  410.     else:
  411.         for item in value:
  412.         self._dump("v", item)
  413.     write("</env:Body>\n")
  414.     if envelope:
  415.         write("</env:Envelope>\n")
  416.     result = string.join(self.__out, "")
  417.     del self.__out, self.write # don't need this any more
  418.     return result
  419.  
  420.     def _dump(self, tag, value):
  421.     try:
  422.         f = self.dispatch[type(value)]
  423.     except KeyError:
  424.         raise TypeError, "cannot marshal %s objects" % type(value)
  425.     else:
  426.         f(self, tag, value)
  427.  
  428.     def dump_none(self, tag, value):
  429.     self.write(
  430.         "<%s xsi:null='1'></%s>\n" % (tag, tag)
  431.         )
  432.     dispatch[NoneType] = dump_none
  433.  
  434.     def dump_int(self, tag, value):
  435.     self.write(
  436.         "<%s xsi:type='xsd:int'>%s</%s>\n" % (tag, value, tag)
  437.         )
  438.     dispatch[IntType] = dump_int
  439.  
  440.     def dump_long(self, tag, value):
  441.     self.write(
  442.         "<%s xsi:type='xsd:integer'>%s</%s>\n" % (tag, value, tag)
  443.         )
  444.  
  445.     def dump_long_old(self, tag, value):
  446.     value = str(value)[:-1] # 1.5.2 and earlier
  447.     self.write(
  448.         "<%s xsi:type='xsd:integer'>%s</%s>\n" % (tag, value, tag)
  449.         )
  450.  
  451.     if ("%s" % 1L) == "1":
  452.     dispatch[LongType] = dump_long
  453.     else:
  454.     dispatch[LongType] = dump_long_old
  455.  
  456.     def dump_double(self, tag, value):
  457.     self.write(
  458.         "<%s xsi:type='xsd:double'>%s</%s>\n" % (tag, value, tag)
  459.         )
  460.     dispatch[FloatType] = dump_double
  461.  
  462.     def dump_string(self, tag, value):
  463.     self.write(
  464.         "<%s xsi:type='xsd:string'>%s</%s>\n" % (tag, escape(value), tag)
  465.         )
  466.     dispatch[StringType] = dump_string
  467.  
  468.     def container(self, value):
  469.     if value:
  470.         i = id(value)
  471.         if self.memo.has_key(i):
  472.         raise TypeError, "cannot marshal recursive data structures"
  473.         self.memo[i] = None
  474.  
  475.     def dump_array(self, tag, value):
  476.     self.container(value)
  477.     write = self.write
  478.     write("<%s enc:arrayType='xsd:ur-type[%d]'>\n" % (tag, len(value)))
  479.     for v in value:
  480.         self._dump("v", v)
  481.     write("</%s>\n" % tag)
  482.     dispatch[TupleType] = dump_array
  483.     dispatch[ListType] = dump_array
  484.  
  485.     def dump_dict(self, tag, value):
  486.     self.container(value)
  487.     write = self.write
  488.     write("<%s xsi:type='lab:PythonDict'>\n" % tag)
  489.     for k, v in value.items():
  490.         self._dump("k", k)
  491.         self._dump("v", v)
  492.     write("</%s>\n" % tag)
  493.     dispatch[DictType] = dump_dict
  494.  
  495.     def dump_instance(self, tag, value):
  496.     # check for special wrappers
  497.     if value.__class__ in WRAPPERS:
  498.         value.encode(tag, self)
  499.     else:
  500.         write = self.write
  501.         write("<%s>\n" % tag)
  502.         for k, v in vars(value).items():
  503.         self._dump(k, v)
  504.         write("</%s>\n" % tag)
  505.     dispatch[InstanceType] = dump_instance
  506.  
  507.  
  508. class Unmarshaller:
  509.  
  510.     # unmarshal an SOAP response, based on incoming XML events (start,
  511.     # data, end).  call close to get the resulting data structure
  512.  
  513.     # note that this reader is fairly tolerant, and gladly accepts
  514.     # bogus SOAP data without complaining (but not bogus XML).
  515.  
  516.     # and again, if you don't understand what's going on in here,
  517.     # that's perfectly ok.
  518.  
  519.     def __init__(self):
  520.     self._stack = []
  521.         self._marks = []
  522.     self._data = []
  523.     self.append = self._stack.append
  524.  
  525.     def close(self):
  526.     # return response code and the actual response
  527.     if self._marks or len(self._stack) != 1:
  528.         raise ResponseError()
  529.     # FIXME: should this really be done here?
  530.     method, params = self._stack[0]
  531.     args = []
  532.     for k, v in params:
  533.         args.append(v)
  534.     return method, tuple(args)
  535.  
  536.     #
  537.     # event handlers
  538.  
  539.     def start(self, tag, attrs, fixup):
  540.     # handle start tag
  541.     type = attrs.get(NS_XSI + "type")
  542.     if type is None:
  543.         type = attrs.get(NS_ENC + "arrayType")
  544.     if type and ":" in type:
  545.         prefix, type = string.split(type, ":")
  546.         ns = fixup(prefix)
  547.         if ns is None:
  548.         raise SyntaxError,\
  549.               "undefined namespace prefix %s" % repr(prefix)
  550.         type = ns + type
  551.     self._marks.append((tag, type, len(self._stack)))
  552.     self._data = []
  553.  
  554.     def data(self, text):
  555.     self._data.append(text)
  556.  
  557.     dispatch = {}
  558.  
  559.     def end(self, tag):
  560.     # call the appropriate type handler
  561.     tag, type, mark = self._marks.pop()
  562.     if type is None and tag in SOAPTAGS:
  563.         pass
  564.     else:
  565.         try:
  566.         f = self.dispatch[type]
  567.         except KeyError:
  568.         self.end_unknown(type)
  569.         else:
  570.         self._mark = mark
  571.                 self._stack.append((tag, f(self)))
  572.  
  573.     #
  574.     # element decoders
  575.  
  576.     def end_unknown(self, type, join=string.join):
  577.     print "***", type
  578.     raise SyntaxError, ("unknown type %s (for now)" % repr(type))
  579.  
  580.     def end_boolean(self, join=string.join):
  581.     value = join(self._data, "")
  582.     if value in ("0", "false"):
  583.         return False
  584.     elif value in ("1", "true"):
  585.         return True
  586.     else:
  587.         raise TypeError, "bad boolean value"
  588.     dispatch[NS_XSD + "boolean"] = end_boolean
  589.  
  590.     def end_int(self, join=string.join):
  591.     return int(join(self._data, ""))
  592.     dispatch[NS_XSD + "int"] = end_int
  593.     dispatch[NS_XSD + "byte"] = end_int
  594.     dispatch[NS_XSD + "unsignedByte"] = end_int
  595.     dispatch[NS_XSD + "short"] = end_int
  596.     dispatch[NS_XSD + "unsignedShort"] = end_int
  597.     dispatch[NS_XSD + "long"] = end_int
  598.  
  599.     def end_long(self, join=string.join):
  600.     return long(join(self._data, ""))
  601.     dispatch[NS_XSD + "integer"] = end_long
  602.     dispatch[NS_XSD + "unsignedInt"] = end_long
  603.     dispatch[NS_XSD + "unsignedLong"] = end_long
  604.  
  605.     def end_double(self, join=string.join):
  606.     return float(join(self._data, ""))
  607.     dispatch[NS_XSD + "double"] = end_double
  608.  
  609.     def end_string(self, join=string.join):
  610.     return join(self._data, "")
  611.     dispatch[NS_XSD + "string"] = end_string
  612.  
  613.     def end_array(self):
  614.     # map arrays to Python lists
  615.     list = []
  616.     data = self._stack[self._mark:]
  617.     del self._stack[self._mark:]
  618.     for tag, item in data:
  619.         list.append(item)
  620.     return list
  621.     dispatch[NS_XSD + "ur-type[]"] = end_array
  622.  
  623.     def end_dict(self):
  624.         dict = {}
  625.     data = self._stack[self._mark:]
  626.     del self._stack[self._mark:]
  627.         for i in range(0, len(data), 2):
  628.             dict[data[i][1]] = data[i+1][1]
  629.     return dict
  630.     dispatch[NS_LAB + "PythonDict"] = end_dict
  631.  
  632.     def end_struct(self):
  633.     # typeless elements are assumed to be structs.  map
  634.     # them to a (name, value) list
  635.     data = self._stack[self._mark:]
  636.     del self._stack[self._mark:]
  637.     return data
  638.     dispatch[None] = end_struct
  639.  
  640.     def end_base64(self, join=string.join):
  641.     value = Binary()
  642.     value.decode(join(self._data, ""))
  643.     return str(value)
  644.     dispatch[NS_ENC + "base64"] = end_base64
  645.  
  646.     def end_dateTime(self, join=string.join):
  647.     value = DateTime()
  648.     value.decode(join(self._data, ""))
  649.     return value
  650.     dispatch[NS_XSD + "timePeriod"] = end_dateTime
  651.     dispatch[NS_XSD + "timeInstant"] = end_dateTime
  652.  
  653. # --------------------------------------------------------------------
  654. # convenience functions
  655.  
  656. def getparser():
  657.     # get the fastest available parser, and attach it to an
  658.     # unmarshalling object.  return both objects.
  659.     target = Unmarshaller()
  660.     if FastParser:
  661.     return FastParser(target), target
  662.     return SlowParser(target), target
  663.  
  664. def dumps(params, envelope=0):
  665.     # convert a tuple or a fault object to an SOAP packet
  666.  
  667.     assert (type(params) == TupleType or
  668.         isinstance(params, MethodCall) or
  669.         isinstance(params, Response) or
  670.         isinstance(params, Fault)
  671.         ),\
  672.        "argument must be tuple, method call/response, or fault instance"
  673.  
  674.     m = Marshaller()
  675.  
  676.     return m.dumps(params, envelope)
  677.  
  678. def loads(data):
  679.     # convert an SOAP packet to data plus a method name (None
  680.     # if not present).  if the SOAP packet represents a fault
  681.     # condition, this function raises a Fault exception.
  682.     p, u = getparser()
  683.     p.feed(data)
  684.     p.close()
  685.     return u.close()
  686.  
  687.  
  688. # --------------------------------------------------------------------
  689. # request dispatcher
  690.  
  691. class _Method:
  692.     # some magic to bind an SOAP method to an RPC server.
  693.     # supports "nested" methods (e.g. examples.getStateName)
  694.     def __init__(self, send, name):
  695.     self.__send = send
  696.     self.__name = name
  697.     def __getattr__(self, name):
  698.     return _Method(self.__send, "%s.%s" % (self.__name, name))
  699.     def __call__(self, *pargs, **kwargs):
  700.     return self.__send(self.__name, pargs, kwargs)
  701.  
  702. class Transport:
  703.     """Handles an HTTP transaction to an SOAP server"""
  704.  
  705.     # client identifier (may be overridden)
  706.     user_agent = "soaplib.py/%s (from www.pythonware.com)" % __version__
  707.  
  708.     def request(self, host, handler, request_body):
  709.     # issue SOAP request
  710.  
  711.     import ppmhttplib
  712.     h = ppmhttplib.PPMHTTP(host)
  713.     h.debuglevel = 0
  714.         h.set_debuglevel(0)
  715.         h.postrequest("POST", handler)
  716.     # required by HTTP/1.1
  717.     h.putheader("Host", host)
  718.  
  719.     if h.debuglevel > 0:
  720.         print "-- REQUEST --"
  721.         print request_body
  722.  
  723.     # required by SOAP
  724.     h.putheader("User-Agent", self.user_agent)
  725.     h.putheader("Content-Type", "text/xml")
  726.     h.putheader("Content-Length", str(len(request_body)))
  727.         # Removed by ActiveState -- incompatible with Perl SOAP server
  728.         # XXX we should investigate the real problem...the SOAPAction
  729.         # XXX header is required in SOAP 1.1
  730.     # h.putheader("SOAPAction", '""')
  731.  
  732.     h.endheaders()
  733.  
  734.     if request_body:
  735.         h.send(request_body)
  736.  
  737.     errcode, errmsg, headers = h.getreply()
  738.  
  739.     if h.debuglevel > 0:
  740.         print "-- RESPONSE --"
  741.         print errcode, errmsg, headers
  742.  
  743.     if errcode not in (200, 500):
  744.         raise ProtocolError(
  745.         host + handler,
  746.         errcode, errmsg,
  747.         headers
  748.         )
  749.  
  750.     response = self.parse_response(h.getfile())
  751.  
  752.     # should this really be done in here?
  753.     response = response[1]
  754.     if len(response) == 1:
  755.         response = response[0]
  756.  
  757.     return response
  758.  
  759.     def parse_response(self, f):
  760.     # read response from input file, and parse it
  761.  
  762.     p, u = getparser()
  763.  
  764.     while 1:
  765.         response = f.read(1024)
  766.         if not response:
  767.         break
  768.         p.feed(response)
  769.  
  770.     f.close()
  771.     p.close()
  772.  
  773.     return u.close()
  774.  
  775.  
  776. class ServerProxy:
  777.     """Represents a connection to an SOAP server"""
  778.  
  779.     def __init__(self, uri, transport=None):
  780.     # establish a "logical" server connection
  781.  
  782.     # get the url
  783.     type, uri = urllib.splittype(uri)
  784.     if type != "http":
  785.         raise IOError, "unsupported SOAP protocol"
  786.     self.__host, self.__handler = urllib.splithost(uri)
  787.     if not self.__handler:
  788.         self.__handler = "/"
  789.  
  790.     if transport is None:
  791.         transport = Transport()
  792.     self.__transport = transport
  793.  
  794.     self.__methods = {} # known methods
  795.  
  796.     def _defmethod(self, methodname, namespace):
  797.     # associate information with a remote methodname
  798.  
  799.     self.__methods[methodname] = namespace
  800.  
  801.     def __request(self, methodname, pargs, kwargs):
  802.     # call a method on the remote server
  803.  
  804.     # wrap the arguments up
  805.     params = MethodCall(
  806.         methodname, self.__methods.get(methodname), pargs, kwargs
  807.         )
  808.  
  809.     request = dumps(params, 1)
  810.  
  811.     response = self.__transport.request(
  812.         self.__host,
  813.         self.__handler,
  814.         request
  815.         )
  816.     return response
  817.  
  818.     def __repr__(self):
  819.     return (
  820.         "<Server proxy for %s%s>" %
  821.         (self.__host, self.__handler)
  822.         )
  823.  
  824.     __str__ = __repr__
  825.  
  826.     def __getattr__(self, name):
  827.     # magic method dispatcher
  828.     return _Method(self.__request, name)
  829.  
  830.     def __getitem__(self, name):
  831.     # alternate method dispatcher
  832.     return _Method(self.__request, name)
  833.  
  834.  
  835. # xmlrpclib compatibility
  836. Server = ServerProxy
  837.  
  838.  
  839. if __name__ == "__main__":
  840.  
  841.     # simple test, using soapserver.py
  842.     server = ServerProxy("http://localhost:8000")
  843.     print server.call("hello")
  844.  
  845.  
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854.  
  855.  
  856.  
  857.