home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / ZSI / dispatch.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  8.4 KB  |  317 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import types
  5. import os
  6. import sys
  7. from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
  8. from ZSI import *
  9. from ZSI import _child_elements, _copyright, _seqtypes, _find_arraytype, _find_type, resolvers
  10. from ZSI.auth import _auth_tc, AUTH, ClientBinding
  11. _client_binding = None
  12.  
  13. def GetClientBinding():
  14.     return _client_binding
  15.  
  16.  
  17. gettypecode = lambda mod, e: getattr(mod, str(e.localName)).typecode
  18.  
  19. def _Dispatch(ps, modules, SendResponse, SendFault, nsdict = { }, typesmodule = None, gettypecode = gettypecode, rpc = False, docstyle = False, **kw):
  20.     global _client_binding
  21.     
  22.     try:
  23.         what = str(ps.body_root.localName)
  24.         if modules is None:
  25.             modules = (sys.modules['__main__'],)
  26.         
  27.         handlers = _[1]
  28.         if len(handlers) == 0:
  29.             raise TypeError('Unknown method ' + what)
  30.         len(handlers) == 0
  31.         handlers = _[2]
  32.         if len(handlers) == 0:
  33.             raise TypeError('Unimplemented method ' + what)
  34.         len(handlers) == 0
  35.         if len(handlers) > 1:
  36.             raise TypeError('Multiple implementations found: ' + `handlers`)
  37.         len(handlers) > 1
  38.         handler = handlers[0]
  39.         _client_binding = ClientBinding(ps)
  40.         if docstyle:
  41.             result = handler(ps.body_root)
  42.             tc = TC.XML(aslist = 1, pname = what + 'Response')
  43.         elif not rpc:
  44.             
  45.             try:
  46.                 tc = gettypecode(typesmodule, ps.body_root)
  47.             except Exception:
  48.                 []
  49.                 []
  50.                 []
  51.                 tc = TC.Any()
  52.             except:
  53.                 []
  54.  
  55.             
  56.             try:
  57.                 arg = tc.parse(ps.body_root, ps)
  58.             except EvaluateException:
  59.                 []
  60.                 ex = []
  61.                 SendFault(FaultFromZSIException(ex), **kw)
  62.                 return None
  63.  
  64.             
  65.             try:
  66.                 result = handler(arg)
  67.             except Exception:
  68.                 []
  69.                 ex = []
  70.                 SendFault(FaultFromZSIException(ex), **kw)
  71.                 return None
  72.  
  73.             
  74.             try:
  75.                 tc = result.typecode
  76.             except AttributeError:
  77.                 []
  78.                 ex = []
  79.                 SendFault(FaultFromZSIException(ex), **kw)
  80.                 return None
  81.             
  82.  
  83.         []<EXCEPTION MATCH>AttributeError
  84.         if typesmodule is not None:
  85.             kwargs = { }
  86.             for e in _child_elements(ps.body_root):
  87.                 
  88.                 try:
  89.                     tc = gettypecode(typesmodule, e)
  90.                 except Exception:
  91.                     []
  92.                     []
  93.                     []
  94.                     tc = TC.Any()
  95.                 except:
  96.                     []
  97.  
  98.                 
  99.                 try:
  100.                     kwargs[str(e.localName)] = tc.parse(e, ps)
  101.                 continue
  102.                 except EvaluateException:
  103.                     []
  104.                     ex = []
  105.                     []
  106.                     SendFault(FaultFromZSIException(ex), **kw)
  107.                     return None
  108.                 
  109.  
  110.             
  111.             result = handler(**kwargs)
  112.             aslist = False
  113.             if type(result) in _seqtypes:
  114.                 for o in result:
  115.                     aslist = hasattr(result, 'typecode')
  116.                     if aslist:
  117.                         break
  118.                         continue
  119.                     []<EXCEPTION MATCH>EvaluateException
  120.                 
  121.             elif type(result) is not dict:
  122.                 aslist = not hasattr(result, 'typecode')
  123.                 result = (result,)
  124.             
  125.             tc = TC.Any(pname = what + 'Response', aslist = aslist)
  126.         else:
  127.             tp = _find_type(ps.body_root)
  128.             if not type(tp) in (tuple, list) or tp[1] == 'Array':
  129.                 pass
  130.             isarray = _find_arraytype(ps.body_root)
  131.             data = _child_elements(ps.body_root)
  132.             tc = TC.Any()
  133.             if isarray and len(data) == 0:
  134.                 result = handler()
  135.             elif isarray:
  136.                 
  137.                 try:
  138.                     arg = [ tc.parse(e, ps) for e in data ]
  139.                 except EvaluateException:
  140.                     e = None
  141.                     SendFault(RuntimeError('THIS IS AN ARRAY: %s' % isarray))
  142.                     return None
  143.  
  144.                 result = handler(*arg)
  145.             else:
  146.                 
  147.                 try:
  148.                     kwarg = []([ (str(e.localName), tc.parse(e, ps)) for e in data ])
  149.                 except EvaluateException:
  150.                     e = None
  151.                     SendFault(FaultFromZSIException(e), **kw)
  152.                     return None
  153.  
  154.                 result = handler(**kwarg)
  155.             tc = TC.Any(pname = what + 'Response')
  156.         sw = SoapWriter(nsdict = nsdict)
  157.         sw.serialize(result, tc)
  158.         return SendResponse(str(sw), **kw)
  159.     except Fault:
  160.         e = None
  161.         return SendFault(e, **kw)
  162.         except Exception:
  163.             e = None
  164.             return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)
  165.         else:
  166.             return None
  167.  
  168.  
  169.  
  170. def _ModPythonSendXML(text, code = 200, **kw):
  171.     req = kw['request']
  172.     req.content_type = 'text/xml'
  173.     req.content_length = len(text)
  174.     req.send_http_header()
  175.     req.write(text)
  176.  
  177.  
  178. def _ModPythonSendFault(f, **kw):
  179.     _ModPythonSendXML(f.AsSOAP(), 500, **kw)
  180.  
  181.  
  182. def _JonPySendFault(f, **kw):
  183.     _JonPySendXML(f.AsSOAP(), 500, **kw)
  184.  
  185.  
  186. def _JonPySendXML(text, code = 200, **kw):
  187.     req = kw['request']
  188.     req.set_header('Content-Type', 'text/xml; charset="%s"' % UNICODE_ENCODING)
  189.     req.set_header('Content-Length', str(len(text)))
  190.     req.write(text)
  191.  
  192.  
  193. def _CGISendXML(text, code = 200, **kw):
  194.     print 'Status: %d' % code
  195.     print 'Content-Type: text/xml; charset="%s"' % UNICODE_ENCODING
  196.     print 'Content-Length: %d' % len(text)
  197.     print ''
  198.     print text
  199.  
  200.  
  201. def _CGISendFault(f, **kw):
  202.     _CGISendXML(f.AsSOAP(), 500, **kw)
  203.  
  204.  
  205. class SOAPRequestHandler(BaseHTTPRequestHandler):
  206.     server_version = 'ZSI/1.1 ' + BaseHTTPRequestHandler.server_version
  207.     
  208.     def send_xml(self, text, code = 200):
  209.         self.send_response(code)
  210.         if text:
  211.             self.send_header('Content-type', 'text/xml; charset="%s"' % UNICODE_ENCODING)
  212.             self.send_header('Content-Length', str(len(text)))
  213.         
  214.         self.end_headers()
  215.         if text:
  216.             self.wfile.write(text)
  217.         
  218.         self.wfile.flush()
  219.  
  220.     
  221.     def send_fault(self, f, code = 500):
  222.         self.send_xml(f.AsSOAP(), code)
  223.  
  224.     
  225.     def do_POST(self):
  226.         
  227.         try:
  228.             ct = self.headers['content-type']
  229.             if ct.startswith('multipart/'):
  230.                 cid = resolvers.MIMEResolver(ct, self.rfile)
  231.                 xml = cid.GetSOAPPart()
  232.                 ps = ParsedSoap(xml, resolver = cid.Resolve)
  233.             else:
  234.                 length = int(self.headers['content-length'])
  235.                 ps = ParsedSoap(self.rfile.read(length))
  236.         except ParseException:
  237.             e = None
  238.             self.send_fault(FaultFromZSIException(e))
  239.             return None
  240.             except Exception:
  241.                 e = None
  242.                 self.send_fault(FaultFromException(e, 1, sys.exc_info()[2]))
  243.                 return None
  244.             else:
  245.                 _Dispatch(ps, self.server.modules, self.send_xml, self.send_fault, docstyle = self.server.docstyle, nsdict = self.server.nsdict, typesmodule = self.server.typesmodule, rpc = self.server.rpc)
  246.                 return None
  247.  
  248.  
  249.  
  250.  
  251. def AsServer(port = 80, modules = None, docstyle = False, nsdict = { }, typesmodule = None, rpc = False, addr = ''):
  252.     address = (addr, port)
  253.     httpd = HTTPServer(address, SOAPRequestHandler)
  254.     httpd.modules = modules
  255.     httpd.docstyle = docstyle
  256.     httpd.nsdict = nsdict
  257.     httpd.typesmodule = typesmodule
  258.     httpd.rpc = rpc
  259.     httpd.serve_forever()
  260.  
  261.  
  262. def AsCGI(nsdict = { }, typesmodule = None, rpc = False, modules = None):
  263.     if os.environ.get('REQUEST_METHOD') != 'POST':
  264.         _CGISendFault(Fault(Fault.Client, 'Must use POST'))
  265.         return None
  266.     ct = os.environ['CONTENT_TYPE']
  267.     
  268.     try:
  269.         if ct.startswith('multipart/'):
  270.             cid = resolvers.MIMEResolver(ct, sys.stdin)
  271.             xml = cid.GetSOAPPart()
  272.             ps = ParsedSoap(xml, resolver = cid.Resolve)
  273.         else:
  274.             length = int(os.environ['CONTENT_LENGTH'])
  275.             ps = ParsedSoap(sys.stdin.read(length))
  276.     except ParseException:
  277.         os.environ.get('REQUEST_METHOD') != 'POST'
  278.         e = os.environ.get('REQUEST_METHOD') != 'POST'
  279.         _CGISendFault(FaultFromZSIException(e))
  280.         return None
  281.  
  282.     _Dispatch(ps, modules, _CGISendXML, _CGISendFault, nsdict = nsdict, typesmodule = typesmodule, rpc = rpc)
  283.  
  284.  
  285. def AsHandler(request = None, modules = None, **kw):
  286.     ps = ParsedSoap(request)
  287.     kw['request'] = request
  288.     _Dispatch(ps, modules, _ModPythonSendXML, _ModPythonSendFault, **kw)
  289.  
  290.  
  291. def AsJonPy(request = None, modules = None, **kw):
  292.     kw['request'] = request
  293.     if request.environ.get('REQUEST_METHOD') != 'POST':
  294.         _JonPySendFault(Fault(Fault.Client, 'Must use POST'), **kw)
  295.         return None
  296.     ct = request.environ['CONTENT_TYPE']
  297.     
  298.     try:
  299.         if ct.startswith('multipart/'):
  300.             cid = resolvers.MIMEResolver(ct, request.stdin)
  301.             xml = cid.GetSOAPPart()
  302.             ps = ParsedSoap(xml, resolver = cid.Resolve)
  303.         else:
  304.             length = int(request.environ['CONTENT_LENGTH'])
  305.             ps = ParsedSoap(request.stdin.read(length))
  306.     except ParseException:
  307.         request.environ.get('REQUEST_METHOD') != 'POST'
  308.         e = request.environ.get('REQUEST_METHOD') != 'POST'
  309.         _JonPySendFault(FaultFromZSIException(e), **kw)
  310.         return None
  311.  
  312.     _Dispatch(ps, modules, _JonPySendXML, _JonPySendFault, **kw)
  313.  
  314. if __name__ == '__main__':
  315.     print _copyright
  316.  
  317.