Performance improvements to XMLRPC

Lib/SimpleXMLRPCServer.py

 """Simple XML-RPC Server.
 
 This module can be used to create simple XML-RPC servers
 by creating a server and either installing functions, a
 class instance, or by extending the SimpleXMLRPCServer
 class.
 
 It can also be used to handle XML-RPC requests in a CGI
 environment using CGIXMLRPCRequestHandler.
 
@@ skipping 88 matching lines @@
 # Written by Brian Quinlan (brian@sweetapp.com).
 # Based on code written by Fredrik Lundh.
 
 import xmlrpclib
 from xmlrpclib import Fault
 import SocketServer
 import BaseHTTPServer
 import sys
 import os
 import traceback
+import re
 try:
     import fcntl
 except ImportError:
     fcntl = None
 
 def resolve_dotted_attribute(obj, attr, allow_dotted_names=True):
     """resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d
 
     Resolves a dotted attribute name to an object.  Raises
     an AttributeError if any attribute in the chain starts with a '_'.
@@ skipping 304 matching lines @@
     """Simple XML-RPC request handler class.
 
     Handles all HTTP POST requests and attempts to decode them as
     XML-RPC requests.
     """
 
     # Class attribute listing the accessible path components;
     # paths not on this list will result in a 404 error.
     rpc_paths = ('/', '/RPC2')
 
+    #if not None, encode responses larger than this, if possible
+    encode_threshold = 1400 #a common MTU
+
+    #Override form StreamRequestHandler: full buffering of output
+    #and no Nagle.
+    wbufsize = -1

[krisvale, 2009/06/14 21:43:45]

Make the default server high-performing

+    disable_nagle_algorithm = True
+
+    # a re to match a gzip Accept-Encoding
+    aepattern = re.compile(r"""
+                            \s* ([^\s;]+) \s*            #content-coding
+                            (;\s* q \s*=\s* ([0-9\.]+))? #q
+                            """, re.VERBOSE | re.IGNORECASE)
+
+    def accept_encodings(self):
+        r = {}
+        ae = self.headers.get("Accept-Encoding", "")
+        for e in ae.split(","):
+            match = self.aepattern.match(e)
+            if match:
+                v = match.group(3)
+                v = float(v) if v else 1.0
+                r[match.group(1)] = v
+        return r
+
     def is_rpc_path_valid(self):
         if self.rpc_paths:
             return self.path in self.rpc_paths
         else:
             # If .rpc_paths is empty, just assume all paths are legal
             return True
 
     def do_POST(self):
         """Handles the HTTP POST request.
 
@@ skipping 13 matching lines @@
             # begin to have problems (bug #792570).
             max_chunk_size = 10*1024*1024
             size_remaining = int(self.headers["content-length"])
             L = []
             while size_remaining:
                 chunk_size = min(size_remaining, max_chunk_size)
                 L.append(self.rfile.read(chunk_size))
                 size_remaining -= len(L[-1])
             data = ''.join(L)
 
+            data = self.decode_request_content(data)
+            if data is None:
+                return #response has been sent
+
             # In previous versions of SimpleXMLRPCServer, _dispatch
             # could be overridden in this class, instead of in
             # SimpleXMLRPCDispatcher. To maintain backwards compatibility,
             # check to see if a subclass implements _dispatch and dispatch
             # using that method if present.
             response = self.server._marshaled_dispatch(
                     data, getattr(self, '_dispatch', None)
                 )
         except Exception, e: # This should only happen if the module is buggy
             # internal error, report as HTTP server error
             self.send_response(500)
 
             # Send information about the exception if requested
             if hasattr(self.server, '_send_traceback_header') and \
                     self.server._send_traceback_header:
                 self.send_header("X-exception", str(e))
                 self.send_header("X-traceback", traceback.format_exc())
 
+            self.send_header("Content-length", "0")
             self.end_headers()
         else:
             # got a valid XML RPC response
             self.send_response(200)
             self.send_header("Content-type", "text/xml")
+            if self.encode_threshold is not None:
+                if len(response) > self.encode_threshold:
+                    q = self.accept_encodings().get("gzip", 0)
+                    if q:
+                        response = xmlrpclib.gzip_encode(response)
+                        self.send_header("Content-Encoding", "gzip")
             self.send_header("Content-length", str(len(response)))
             self.end_headers()
             self.wfile.write(response)
 
-            # shut down the connection
-            self.wfile.flush()
-            self.connection.shutdown(1)
+    def decode_request_content(self, data):
+        #support gzip encoding of request
+        encoding = self.headers.get("content-encoding", "identity").lower()
+        if encoding == "identity":
+            return data
+        if encoding == "gzip":
+            try:
+                return xmlrpclib.gzip_decode(data)
+            except ValueError:
+                self.send_response(400, "error decoding gzip content")
+        else:
+            self.send_response(501, "encoding %r not supported" % encoding)
+        self.send_header("Content-length", "0")
+        self.end_headers()
 
     def report_404 (self):
             # Report a 404 error
         self.send_response(404)
         response = 'No such page'
         self.send_header("Content-type", "text/plain")
         self.send_header("Content-length", str(len(response)))
         self.end_headers()
         self.wfile.write(response)
-        # shut down the connection
-        self.wfile.flush()
-        self.connection.shutdown(1)
 
     def log_request(self, code='-', size='-'):
         """Selectively log an accepted request."""
 
         if self.server.logRequests:
             BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
 
 class SimpleXMLRPCServer(SocketServer.TCPServer,
                          SimpleXMLRPCDispatcher):
     """Simple XML-RPC server.
 
     Simple XML-RPC server that allows functions and a single instance
     to be installed to handle requests. The default implementation
     attempts to dispatch XML-RPC calls to the functions or instance
     installed in the server. Override the _dispatch method inhereted
     from SimpleXMLRPCDispatcher to change this behavior.
     """
 
     allow_reuse_address = True
 
+
     # Warning: this is for debugging purposes only! Never set this to True in
     # production code, as will be sending out sensitive information (exception
     # and stack trace details) when exceptions are raised inside
     # SimpleXMLRPCRequestHandler.do_POST
     _send_traceback_header = False
 
     def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
                  logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
         self.logRequests = logRequests
 
@@ skipping 68 matching lines @@
                 request_text = sys.stdin.read(length)
 
             self.handle_xmlrpc(request_text)
 
 if __name__ == '__main__':
     print 'Running XML-RPC server on port 8000'
     server = SimpleXMLRPCServer(("localhost", 8000))
     server.register_function(pow)
     server.register_function(lambda x,y: x+y, 'add')
     server.serve_forever()