def do_POST(self):
     try:
         # get arguments
         data = self.rfile.read(int(self.headers["content-length"]))
         params, method = xmlrpclib.loads(data)
         if debug:
             print "method:", repr(method)
             print "params:", repr(params)
         # generate response
         try:
             response = self.call(method, params)
             if debug:
                 print 'call response: %r' % response
             if type(response) != type(()):
                 response = (response,)
         except:
             # report exception back to server
             response = xmlrpclib.dumps(
                 xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type,
                                               sys.exc_value)))
         else:
             response = xmlrpclib.dumps(response,
                                        methodresponse=1)
     except Exception, e:
         # internal error, report as HTTP server error
         self.send_response(500)
         self.end_headers()

	def continue_request (self, data, request):
		params, method = xmlrpclib.loads (data)
		try:
			# generate response
			try:
				response = self.call (method, params)
				#if type(response) == type(()):
				response = (response,)
			except:
				# report exception back to server
				response = xmlrpclib.dumps (
					xmlrpclib.Fault (1, "%s:%s" % (sys.exc_type, sys.exc_value))
					)
			else:
				response = xmlrpclib.dumps (response, methodresponse=1)
		except:
			import traceback
			traceback.print_exc()
			# internal error, report as HTTP server error
			request.error (500)
		else:
			# got a valid XML RPC response
			request['Content-Type'] = 'text/xml'
			request.push (response)
			request.done()

    def execute (self, request=sys.stdin, response=sys.stdout,
                        meta=None):
        """processes a request and dispatches the call"""
        
        if not meta:
            meta = {}

        meta['xmlrpcserver'] = self

        params = method = result = None

        try:
            params, rpccall = xmlrpclib.loads(request.read())
        except:
            response.write(
                xmlrpclib.dumps(xmlrpclib.Fault
                                (-32000, self.systemerrors[-32000]),
                                methodresponse = True))
            return

        try:

            result = self.resolve(rpccall)(meta, *params)

            response.write(
                xmlrpclib.dumps((result,), methodresponse = True,
                                allow_none=True))
        except xmlrpclib.Fault, fault:
            response.write(
                xmlrpclib.dumps(fault, methodresponse = True))

def test_xml_loads():
    """
    Test the `ipalib.rpc.xml_loads` function.
    """
    f = rpc.xml_loads
    params = (binary_bytes, utf8_bytes, unicode_str, None)
    wrapped = rpc.xml_wrap(params, API_VERSION)

    # Test un-serializing an RPC request:
    data = dumps(wrapped, b'the_method', allow_none=True)
    (p, m) = f(data)
    assert_equal(m, u'the_method')
    assert_equal(p, params)

    # Test un-serializing an RPC response:
    data = dumps((wrapped,), methodresponse=True, allow_none=True)
    (tup, m) = f(data)
    assert m is None
    assert len(tup) == 1
    assert type(tup) is tuple
    assert_equal(tup[0], params)

    # Test un-serializing an RPC response containing a Fault:
    for error in (unicode_str, u'hello'):
        fault = Fault(69, error)
        data = dumps(fault, methodresponse=True, allow_none=True, encoding='UTF-8')
        e = raises(Fault, f, data)
        assert e.faultCode == 69
        assert_equal(e.faultString, error)
        assert type(e.faultString) is unicode

 def test_xmlrpc_marshal(self):
     from supervisor import xmlrpc
     data = xmlrpc.xmlrpc_marshal(1)
     self.assertEqual(data, xmlrpclib.dumps((1,), methodresponse=True))
     fault = xmlrpclib.Fault(1, 'foo')
     data = xmlrpc.xmlrpc_marshal(fault)
     self.assertEqual(data, xmlrpclib.dumps(fault))

    def test_kwargs(self):
        xml = dumps((1, 2), 'kwargstest')
        ret = self.dispatcher.dispatch(xml)
        out, name = loads(ret)
        self.assertFalse(out[0])

        ret = self.dispatcher.dispatch(xml, c=1)
        out, name = loads(ret)
        self.assertTrue(out[0])
        
        xml = dumps((1,),'requestargtest')
        ret = self.dispatcher.dispatch(xml, request=True)
        out, name = loads(ret)
        self.assertTrue(out[0])
        
        xml = """<?xml version='1.0'?>
<methodCall>
<methodName>withoutargstest</methodName>
<params>
</params>
</methodCall>
        """
        ret = self.dispatcher.dispatch(xml, request='fakerequest')
        out, name = loads(ret)
        self.assertTrue(out[0])

def Dispatch(req, method, args):
    # Default configuration
    defcfg = {'xmlrpc_server': { 'datadir':     '/var/lib/rteval',
                                 'db_server':   'localhost',
                                 'db_port':     5432,
                                 'database':    'rteval',
                                 'db_username': 'rtevxmlrpc',
                                 'db_password': 'rtevaldb'
                                 }
              }

    # Fetch configuration
    cfg = rtevalConfig(defcfg)
    cfg.Load(append=True)

    # Prepare an object for executing the query
    xmlrpc = XMLRPC_API1(config=cfg.GetSection('xmlrpc_server'))

    # Exectute it
    result = xmlrpc.Dispatch(method, args)

    # Send the result
    if type(result) == types.TupleType:
        req.write(dumps(result, None, methodresponse=1))
    else:
        req.write(dumps((result,), None, methodresponse=1))

    def test_normal(self):

        from pyramid_xmlrpc import XMLRPCView

        class Test(XMLRPCView):
            def a_method(self, param):
                return param

        # set up a request
        param = 'what'
        import xmlrpclib
        packet = xmlrpclib.dumps((param,), methodname='a_method')
        request = testing.DummyRequest()
        request.body = packet
        request.content_length = len(packet)

        # instantiate the view
        context = testing.DummyModel()
        instance = Test(context, request)

        # these are fair game for the methods to use if they want
        self.failUnless(instance.context is context)
        self.failUnless(instance.request is request)

        # exercise it
        response = instance()
        self.assertEqual(response.body, xmlrpclib.dumps((param,),
                                                        methodresponse=True))

 def _system_methodSignature(self, *p, **kw):
     try:
         method = self._find_method(p[0])
         rpcresponse = xmlrpclib.dumps((method.signatures,), methodresponse=1)
     except:
         rpcresponse = xmlrpclib.dumps(('Invalid method',), methodresponse=1)
     return rpcresponse

    def RPC_handler(self, data):
        "Handler for incoming remote procedure calls"
        try:
            if self.stage == XMLRPC_STAGE_ZERO:
                self.stage = XMLRPC_STAGE_ONE  # Get client's headers out of the buffer
            elif self.stage == XMLRPC_STAGE_ONE:
                self.stage = XMLRPC_STAGE_TWO

                params, method = xmlrpclib.loads(data)
                if isinstance(params[0], type({})):
                    aside = params[0]
                    aside['_socket'] = self._sock
                    aside['_socket_info'] = (self.host, self.port)
                    params = (aside,)
                result = self.rpc_dispatch(method, params)
                if getattr(result, 'faultCode', None) is not None:
                    response = xmlrpclib.dumps(result)
                else:
                    response = xmlrpclib.dumps(result, methodresponse=1)

        except:
            response = xmlrpclib.dumps(xmlrpclib.Fault(1, "Socker(tm): %s" % traceback.format_exc()))

        if self.stage == XMLRPC_STAGE_TWO:
            final_output = ["HTTP/1.1 200 OK", "Server: BlueBridge Socker(tm)", "Content-Length: %i" % len(response), "Connection: close", "Content-Type: text/xml", "", response]
            self.send('\n'.join(final_output))
            self.terminate()

    def do_POST(self):
        try:
            # get arguments
            data = self.rfile.read(int(self.headers["content-length"]))
            params, method = xmlrpclib.loads(data)

            # generate response
            try:
                response = self.call(method, params)
                # wrap response in a singleton tuple
                response = (response,)
            except:
                # report exception back to server
                response = xmlrpclib.dumps(xmlrpclib.Fault(1, "%s:%s" % sys.exc_info()[:2]))
            else:
                response = xmlrpclib.dumps(response, methodresponse=1)
        except:
            # internal error, report as HTTP server error
            self.send_response(500)
            self.end_headers()
        else:
            # got a valid XML RPC response
            self.send_response(200)
            self.send_header("Content-type", "text/xml")
            self.send_header("Content-length", str(len(response)))
            self.end_headers()
            self.wfile.write(response)

            # shut down the connection (from Skip Montanaro)
            self.wfile.flush()
            self.connection.shutdown(1)

    def process(self):
        """
        Processes the xmlrpc request.
        """
        response = self._request.getResponse()
        # XML-RPC starts here
        try:
            # Get parameters
            params, method = xmlrpclib.loads(self._data)
            params = list(params)
            params.insert(0, self._request)
            params = tuple(params)

            try:
                # Call the method
                result = self.xmlrpcCall(method, params)
                if type(result) != type (()):
                    result = (result,)
            except xmlrpclib.Fault, faultobj:
                # Throw an xmlrpc exception
                result = xmlrpclib.dumps(faultobj)
            except:
                # Format other exceptions into xmlrpc faults
                result = xmlrpclib.dumps(xmlrpclib.Fault(1, '%s:%s' %
                        (sys.exc_type, sys.exc_value)))
            else:
                # Passed.
                result = xmlrpclib.dumps(result, methodresponse=1)

    def dispatch(self, data, **kwargs):
        """
        Extracts the xml marshaled parameters and method name and calls the
        underlying method and returns either an xml marshaled response
        or an XMLRPC fault

        Although very similar to the superclass' _marshaled_dispatch, this
        method has a different name due to the different parameters it takes
        from the superclass method.
        """

        try:
            params, method = xmlrpc.xmlrpc_client.loads(data)

            try:
                response = self._dispatch(method, params, **kwargs)
            except TypeError:
                # Catch unexpected keyword argument error
                response = self._dispatch(method, params)

            # wrap response in a singleton tuple
            response = (response,)
            response = dumps(response, methodresponse=1,
                             allow_none=self.allow_none,
                             encoding=self.encoding)
        except Fault as fault:
            response = dumps(fault, allow_none=self.allow_none,
                             encoding=self.encoding)
        except Exception:
            response = dumps(
                Fault(1, 'Unknown error'),
                encoding=self.encoding, allow_none=self.allow_none,
            )

        return response

 def dispatch(self, data, **kwargs):
     """
     Extracts the xml marshaled parameters and method name and calls the
     underlying method and returns either an xml marshaled response
     or an XMLRPC fault
     
     Although very similar to the superclass' _marshaled_dispatch, this
     method has a different name due to the different parameters it takes
     from the superclass method.
     """
     
     try:
         params, method = xmlrpclib.loads(data)
         
         try:
             response = self._dispatch(method, params, **kwargs)
         except TypeError as e:
             # XXX: Hack!
             if "unexpected keyword" in "%s" % e:
                 # Catch unexpected keyword argument error
                 response = self._dispatch(method, params)
             else:
                 raise
         
         # wrap response in a singleton tuple
         response = (response,)
         response = xmlrpclib.dumps(response, methodresponse=1,
                                    allow_none=self.allow_none, 
                                    encoding=self.encoding)
     except Fault, fault:
         logger.warn("Got fault when processing method %s" % method)
         traceback.print_exc()
         response = xmlrpclib.dumps(fault, allow_none=self.allow_none,
                                    encoding=self.encoding)

def main(request):
    params, method = xmlrpclib.loads(request.data)

    try:
        fn = eval(method)
    except:
        fn = None
        result = xmlrpclib.Fault(1, "Function '%s' not found" % method)
        response = xmlrpclib.dumps(result)
    
    if fn:
        try:
            result = fn(request, *params)
            if result == None:
                result = ""
            response = xmlrpclib.dumps((result,), methodresponse=1)
        except:
            result = xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value))
            response = xmlrpclib.dumps(result)
            raise

    request.send_response(200)
    request.send_header("Content-type", "text/xml")
    request.send_header("Content-length", str(len(response)))
    request.end_headers()
    request.wfile.write(response)

    def do_POST(self):
        # Simplified version of SimpleXMLRPCRequestHandler.do_POST
        l = int(self.headers["Content-Length"])
        request_txt = self.rfile.read(l)
        params, func = xmlrpclib.loads(request_txt)
        if self.path not in peers:
            self.send_response(404)
            self.end_headers()
            return
        self.send_response(200)
        self.end_headers()

        peer = peers[self.path]
        try:
            if not hasattr(peer, func):
                raise "No such method"
            result = getattr(peer, func)(*params)
            response = xmlrpclib.dumps((result,))
        except:
            exc_type, exc_value, exc_tb = sys.exc_info()
            response = xmlrpclib.dumps(
                xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value)),
                )
        # need to call a function with (*params)
        self.wfile.write(response)

    def _marshaled_dispatch(self, data, dispatch_method = None):
        params, method = xmlrpclib.loads(data)
        try:
            if dispatch_method is not None:
                response = dispatch_method(method, params)
            else:
                response = self._dispatch(method, params)

            # With either Unicode or normal strings, we can only transmit
            # \t, \n, \r, \u0020-\ud7ff, \ue000-\ufffd, and \u10000-\u10ffff
            # in an XML document.  xmlrpclib does not escape these values
            # properly, and then breaks when it comes to parse the document.
            # To hack around this problem, we use repr here and exec above
            # to transmit the string using Python encoding.
            # Thanks to David Mertz <[email protected]> for the trick (buried
            # in xml_pickle.py).
            if (isinstance(response, types.StringType) or
                isinstance(response, unicode)):
                response = repr(response)[1:-1]

            response = (response,)
            response = xmlrpclib.dumps(response,
                                       methodresponse=1,
                                       allow_none=1)
        except xmlrpclib.Fault, fault:
            response = xmlrpclib.dumps(fault)

 def do_POST(s):
     s.do_HEAD()
     clen = int( s.headers.getheader( "content-length" ) )
     body = s.rfile.read( clen )
     d = cgi.parse_qs( body )
     try:
         uli_string = d.get( "ULI", d.get( "uli", d.get( "Uli", [None] )))[0]
     except KEYERROR:
         uli_string = None
     try:
         (args,func_name) = xmlrpclib.loads( body )
         if func_name == "uli":
             uli_result = s.server.dingding.uli.uli( args[0] )
             s.wfile.write( xmlrpclib.dumps( (uli_result,) ) )
             return
         s.wfile.write( xmlrpclib.dumps( (1,) ) ) # auto response, for now
         if func_name == "subscribe":
             s.handle_xmlrpc_subscribe( *args )
         elif func_name == "unsubscribe":
             s.handle_xmlrpc_unsubscribe( *args )
     except ExpatError:
         pass
     if uli_string != None:
         s.wfile.write( s.server.dingding.uli.uli( uli_string ) )
         return

    def respondToPost(self, transaction):
        """Respond to a Post request.

        This is similar to the xmlrpcserver.py example from the xmlrpc
        library distribution, only it's been adapted to work within a
        WebKit servlet.

        """
        try:
            # get arguments
            data = transaction.request().rawInput(rewind=1).read()
            encoding = _getXmlDeclAttr(data, "encoding")
            params, method = xmlrpclib.loads(data)

            # generate response
            try:
                # This first test helps us to support PythonWin, which uses
                # repeated calls to __methods__.__getitem__ to determine the
                # allowed methods of an object.
                if method == "__methods__.__getitem__":
                    response = self.exposedMethods()[params[0]]
                else:
                    response = self.call(method, *params)
                if not isinstance(response, tuple):
                    response = (response,)
            except xmlrpclib.Fault, fault:
                response = xmlrpclib.dumps(fault, encoding=encoding, allow_none=self.allow_none)
                self.sendOK("text/xml", response, transaction)
                self.handleException(transaction)
            except Exception, e:
                fault = self.resultForException(e, transaction)
                response = xmlrpclib.dumps(xmlrpclib.Fault(1, fault), encoding=encoding, allow_none=self.allow_none)
                self.sendOK("text/xml", response, transaction)
                self.handleException(transaction)

def test_serialize_request(methodname, *args):
    for arg in args:
        try:
            xmlrpclib.dumps((arg,), methodresponse=True, methodname=methodname)
        except Exception as e:
            print "Could not serialize arg %s" % str(arg)
            raise e