Changeset 843

Timestamp:

11/27/05 21:08:38

Author:

fumanchu

Message:

Fix for #388 (IPv6 support). While I was up to my elbows in the HTTP servers, I went ahead and:

1. Implemented MaxSize? limits in _cphttpserver
   
2. Made PooledThreadServer? a subclass of CherryHTTPServer, which consolidated a lot of features that each had which the other didn't, including AF_UNIX support.
   
3. Implemented AF_UNIX support for _cpwsgiserver.
   
4. Pulled the MaxSize? logic out of _cpwsgiserver completely; the upshot is that both server interfaces can now use the same wrapper (now in lib/httptools), and 413 errors in the headers are now logged by CP.
   
5. Implemented server.socketQueueSize for _cpwsgiserver.
   

Files:

• trunk/cherrypy/_cphttpserver.py (modified) (9 diffs)
• trunk/cherrypy/_cphttptools.py (modified) (2 diffs)
• trunk/cherrypy/_cpwsgi.py (modified) (3 diffs)
• trunk/cherrypy/_cpwsgiserver.py (modified) (9 diffs)
• trunk/cherrypy/lib/httptools.py (modified) (1 diff)
• trunk/cherrypy/test/test_core.py (modified) (2 diffs)

trunk/cherrypy/_cphttpserver.py

@@ -1 +1 @@
-"""A native HTTP server for CherryPy."""
-
-
-
+
+
+
+
+
+
+
+
-import cherrypy
-from cherrypy import _cputil
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    
-    def address_string(self):
-[server]
+server.
-        if cherrypy.config.get('server.reverseDNS'):
-Server.BaseHTTP
+
-        else:
-            return self.client_address[0]
-    
-    def _headerlist(self):
-
+h
-        hit = 0
-        for line in self.headers.headers:
@@ -32 +31 @@
-                if line[0] in ' \t':
-                    # Continuation line. Add to previous entry.
-
-
+h
+h
-                else:
-                    # New header. Add a new entry. We don't catch
-                    # ValueError here because we trust rfc822.py.
-                    name, value = line.split(":", 1)
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def handle_one_request(self):
@@ -107 +131 @@
-
-
-TCP
-TCP
+Base
+Base
-    # getfqdn call was timing out on localhost when calling gethostbyaddr.
-    
-    ready = False
-    interrupt = None
-
+RequestHandlerClass = CherryHTTPRequestHandler
-    allow_reuse_address = True
-    
-    def __init__(self):
+        # SocketServer __init__'s all say "do not override",
+        # but we have to in order to implement SSL and IPv6 support!
+        
-        # Set protocol_version
-
-
+
+
+
+
-        
-        # Select the appropriate server based on config options
@@ -135 +164 @@
-            except: pass
-            
-
+
+
+
-        else:
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def server_activate(self):
-        """Override server_activate to set timeout on our listener socket"""
-        self.socket.settimeout(1)
-
+
+
+
+
+
+
+
+
+
+
+
-    
-    def get_request(self):
@@ -156 +215 @@
-        # (where wfile and rfile are set in SocketServer.py) we explicitly
-        # set the request socket to blocking
-        
-        request, client_address = self.socket.accept()
-
+
+
-        return request, client_address
-    
@@ -166 +225 @@
-        try:
-            request, client_address = self.get_request()
-
-
-
+
-            # The only reason for the timeout is so we can notice keyboard
-            # interrupts on Win32, which don't interrupt accept() by default
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    
-    def handle_error(self, request, client_address):
-
-
+
-    
-    def serve_forever(self):
@@ -191 +246 @@
-        self.ready = True
-        while self.ready:
-            self.handle_request()
-            if self.interrupt:
-                raise self.interrupt
+            self.handle_request()
+        self.server_close()
-    start = serve_forever
-    
-hutdown
+erver_close
-        self.ready = False
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    """A TCP Server using a pool of worker threads. This is superior to the
-       alternatives provided by the Python standard library, which only offer
@@ -264 +268 @@
-       requests (i.e. you don't have to bother with Deferreds)."""
-    
-    allow_reuse_address = 1
-    ready = False
-    interrupt = None
-    
-    def __init__(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    def createThread(self):
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """Gracefully shutdown a server that is serve_forever()ing."""
-
-
-
+
-        
-        # Must shut down threads here so the code that calls
-        # this method can know when all threads are stopped.
-_
-_
+
+
-        current = threading.currentThread()
-_
+
-            if worker is not current and worker.isAlive:
-                worker.join()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -366 +354 @@
-    
-    # Select the appropriate server based on config options
-
-
-
+
-        ServerClass = PooledThreadServer
-    else:

trunk/cherrypy/_cphttptools.py

@@ -7 +7 @@
-
-import cherrypy
-, _cpwsgiserver
+
-from cherrypy.filters import applyFilters
-from cherrypy.lib import cptools, httptools
@@ -219 +219 @@
-                                          environ=methenv,
-                                          keep_blank_values=1)
-_cpwsgiserver
+httptools
-            # Post data is too big
-            raise cherrypy.HTTPError(413)

trunk/cherrypy/_cpwsgi.py

@@ -3 +3 @@
-import sys
-import cherrypy
-
-_cpwsgiserver import CherryPyWSGIServer as server
+, _cpwsgiserver
+lib import httptools
-
-
@@ -108 +108 @@
-
-
-
-# Server components.
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    """Wrapper for _cpwsgiserver.CherryPyWSGIServer.
@@ -121 +158 @@
-    """
-    
+    RequestHandlerClass = CPHTTPRequest
+    
-    def __init__(self):
-        conf = cherrypy.config.get
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/cherrypy/_cpwsgiserver.py

@@ -13 +13 @@
-                   'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
-class MaxSizeExceeded(Exception):
-    pass
-
-class SizeCheckWrapper(object):
-    """ Wrapper around the rfile object. For each data reading method,
-        it reads the data but it checks that the size of the data doesn't
-        exceed a certain limit
-    """
-    def __init__(self, rfile, maxlen):
-        self.rfile = rfile
-        self.maxlen = maxlen
-        self.bytes_read = 0
-    def _check_length(self):
-        if self.maxlen and self.bytes_read > self.maxlen:
-            raise MaxSizeExceeded()
-    def read(self, size = None):
-        data = self.rfile.read(size)
-        self.bytes_read += len(data)
-        self._check_length()
-        return data
-    def readline(self, size = None):
-        if size is not None:
-            data = self.rfile.readline(size)
-            self.bytes_read += len(data)
-            self._check_length()
-            return data
-
-        # User didn't specify a size ...
-        # We read the line in chunks to make sure it's not a 100MB line !
-        res = []
-        while True:
-            data = self.rfile.readline(256)
-            self.bytes_read += len(data)
-            self._check_length()
-            res.append(data)
-            if len(data) < 256:
-                return ''.join(res)
-    def close(self):
-        self.rfile.close()
-
-    def __iter__(self):
-        return self.rfile
-
-    def next(self):
-        data = self.rfile.next()
-        self.bytes_read += len(data)
-        self._check_length()
-##      Normally the next method must raise StopIteration when it
-##      fails but CP expects MaxSizeExceeded 
-##        try:
-##            self._check_length()
-##        except:
-##            raise StopIteration()
-        return data
-
-class HTTPRequest(object):
+    
+    stderr = sys.stderr
+    bufsize = -1
+    
-    def __init__(self, socket, addr, server):
-        self.socket = socket
@@ -79 +29 @@
-        self.outheaders = []
-        self.outheaderkeys = []
-
-
-
-
-
-
-
+
+
-        self.sent_headers = False
-    
@@ -94 +39 @@
-        self.environ["wsgi.url_scheme"] = "http"
-        self.environ["wsgi.input"] = self.rfile
-erver.s
+
-        self.environ["wsgi.multithread"] = True
-        self.environ["wsgi.multiprocess"] = False
@@ -116 +61 @@
-        self.environ["SERVER_PROTOCOL"] = version
-        self.environ["SERVER_NAME"] = self.server.server_name
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        # then all the http headers
-        headers = mimetools.Message(self.rfile)
@@ -129 +79 @@
-            self.environ[envname] = v
-        self.ready = True
-
-        # Request header is parsed
-        # We prepare the SizeCheckWrapper for the request body
-        if self.server.config:
-            mbs = self.server.config.get(
-                'server.maxRequestBodySize',
-                100 * 1024 * 1024, # 100MB by default
-                path = path)
-            self.rfile.bytes_read = 0
-            self.rfile.maxlen = mbs
-    
-    def start_response(self, status, headers, exc_info = None):
@@ -224 +164 @@
-                        else:
-                            raise
-                    except MaxSizeExceeded:
-                        str = "Request Entity Too Large"
-                        proto = request.environ.get("SERVER_PROTOCOL", "HTTP/1.0")
-                        request.wfile.write("%s 413 %s\r\n" % (proto, str))
-                        request.wfile.write("Content-Length: %s\r\n\r\n" % len(str))
-                        request.wfile.write(str)
-                        request.wfile.flush()
-                    except (KeyboardInterrupt, SystemExit), exc:
-                        self.server.interrupt = exc
@@ -246 +179 @@
-    ready = False
-    interrupt = None
+    RequestHandlerClass = HTTPRequest
-    
-    def __init__(self, bind_addr, wsgi_app, numthreads=10, server_name=None,
-
-
+
-        '''
-        be careful w/ max
@@ -257 +190 @@
-        self.bind_addr = bind_addr
-        self.numthreads = numthreads or 1
-
-
-
-
-
-
-
+
+
+
+
-        self._workerThreads = []
-    
-    def start(self):
-
-
-
+
-        # We don't have to trap KeyboardInterrupt or SystemExit here,
-        # because cherrpy.server already does so, calling self.stop() for us.
-        # If you're using this server with another framework, you should
-        # trap those exceptions in whatever code block calls start().
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        # Timeout so KeyboardInterrupt can be caught on Win32
-        self.socket.settimeout(1)
-5
+self.request_queue_size
-        
-        # Create worker threads
@@ -301 +264 @@
-            if hasattr(s, 'setblocking'):
-                s.setblocking(1)
-HTTPRequest
+self.RequestHandlerClass
-            self.requests.put(request)
-            # optimized version follows
-            #self.requests.put(HTTPRequest(*self.socket.accept()))
-        except socket.timeout:
-            # The only reason for the timeout in start() is so we can

trunk/cherrypy/lib/httptools.py

@@ -410 +410 @@
-            return None
-        return header_elements(key, h)
+
+
+class MaxSizeExceeded(Exception):
+    pass
+
+class SizeCheckWrapper(object):
+    """ Wrapper around an rfile object. For each data reading method,
+        it reads the data but it checks that the size of the data doesn't
+        exceed a certain limit
+    """
+    def __init__(self, rfile, maxlen):
+        self.rfile = rfile
+        self.maxlen = maxlen
+        self.bytes_read = 0
+    
+    def _check_length(self):
+        if self.maxlen and self.bytes_read > self.maxlen:
+            raise MaxSizeExceeded()
+    
+    def read(self, size = None):
+        data = self.rfile.read(size)
+        self.bytes_read += len(data)
+        self._check_length()
+        return data
+    
+    def readline(self, size = None):
+        if size is not None:
+            data = self.rfile.readline(size)
+            self.bytes_read += len(data)
+            self._check_length()
+            return data
+
+        # User didn't specify a size ...
+        # We read the line in chunks to make sure it's not a 100MB line !
+        res = []
+        while True:
+            data = self.rfile.readline(256)
+            self.bytes_read += len(data)
+            self._check_length()
+            res.append(data)
+            if len(data) < 256:
+                return ''.join(res)
+    
+    def close(self):
+        self.rfile.close()
+    
+    def __iter__(self):
+        return self.rfile
+    
+    def next(self):
+        data = self.rfile.next()
+        self.bytes_read += len(data)
+        self._check_length()
+##      Normally the next method must raise StopIteration when it
+##      fails but CP expects MaxSizeExceeded 
+##        try:
+##            self._check_length()
+##        except:
+##            raise StopIteration()
+        return data

trunk/cherrypy/test/test_core.py

@@ -834 +834 @@
-        
-        httpcls = cherrypy.server.httpserverclass
- and httpcls.__name__ == "WSGIServer"
+
-            cherrypy.config.update({'server.maxRequestHeaderSize': 10})
-            self.getPage("/maxrequestsize/index")
-            self.assertStatus("413 Request Entity Too Large")
-
+In
-            cherrypy.config.update({'server.maxRequestHeaderSize': 0})
-        
@@ -855 +855 @@
-        
-        httpcls = cherrypy.server.httpserverclass
- and httpcls.__name__ == "WSGIServer"
+
-            cherrypy.config.update({
-                '%s/maxrequestsize' % helper.vroot: {'server.maxRequestBodySize': 3}})