Changeset 1915

Timestamp:

03/12/08 01:39:38

Author:

fumanchu

Message:

Merging the 598-sendall branch. This fixes #598, #783, and perhaps #589.

Files:

• trunk/cherrypy/test/test_http.py (modified) (4 diffs)
• trunk/cherrypy/test/test_session.py (modified) (2 diffs)
• trunk/cherrypy/wsgiserver/__init__.py (modified) (12 diffs)

trunk/cherrypy/test/test_http.py

@@ -6 +6 @@
-import httplib
-import cherrypy
-d5, m
+
-
-
@@ -39 +39 @@
-        
-        def post_multipart(self, file):
-# compute and return md5 of posted file
+"""Return a summary ("a * 65536\nb * 65536") of the uploaded file."""
-            contents = file.file.read()
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        post_multipart.exposed = True
-    
@@ -57 +70 @@
-        # will hang. Verify that CP times out the socket and responds
-        # with 411 Length Required.
-
+
+
+
+
-        c.request("POST", "/")
-        self.assertEqual(c.getresponse().status, 411)
-    
-    def test_post_multipart(self):
+        alphabet = "abcdefghijklmnopqrstuvwxyz"
-        # generate file contents for a large post
-
-
+
-        
-        # encode as multipart form data
@@ -85 +101 @@
-        
-        response_body = c.file.read()
-
+
+
-
-

trunk/cherrypy/test/test_session.py

@@ -2 +2 @@
-test.prefer_parent_path()
-
+import httplib
-import os
-localDir = os.path.dirname(__file__)
@@ -190 +191 @@
-        
-        def request(index):
+            if self.scheme == 'https':
+                c = httplib.HTTPSConnection('127.0.0.1:%s' % self.PORT)
+            else:
+                c = httplib.HTTPConnection('127.0.0.1:%s' % self.PORT)
-            for i in xrange(request_count):
-
+
+
+
+
+
+
+
+
-                # Uncomment the following line to prove threads overlap.
-##                print index,
-v = int(self.body
+max(data_dict[index], int(body)
-        
-        # Start <request_count> requests from each of

trunk/cherrypy/wsgiserver/__init__.py

@@ -37 +37 @@
-let the name "CherryPyWSGIServer" throw you; the name merely reflects
-its origin, not its coupling.
+
+For those of you wanting to understand internals of this module, here's the
+basic call flow. The server's listening thread runs a very tight loop,
+sticking incoming connections onto a Queue:
+
+    server = CherryPyWSGIServer(...)
+    server.start()
+    while True:
+        tick()
+        # This blocks until a request comes in:
+        child = socket.accept()
+        conn = HTTPConnection(child, ...)
+        server.requests.put(conn)
+
+Worker threads are kept in a pool and poll the Queue, popping off and then
+handling each connection in turn. Each connection can consist of an arbitrary
+number of requests and their responses, so we run a nested loop:
+
+    while True:
+        conn = server.requests.get()
+        conn.communicate()
+        ->  while True:
+                req = HTTPRequest(...)
+                req.parse_request()
+                ->  # Read the Request-Line, e.g. "GET /page HTTP/1.1"
+                    req.rfile.readline()
+                    req.read_headers()
+                req.respond()
+                ->  response = wsgi_app(...)
+                    try:
+                        for chunk in response:
+                            if chunk:
+                                req.write(chunk)
+                    finally:
+                        if hasattr(response, "close"):
+                            response.close()
+                if req.close_connection:
+                    return
-"""
-
-
-import base64
+import os
-import Queue
-import os
-import re
-quoted_slash = re.compile("(?i)%2F")
@@ -203 +241 @@
-    A single HTTP connection may consist of multiple request/response pairs.
-    
-all: the 'sendall' method from the connection's file
+: the 'send' method from the connection's socket 
-    wsgi_app: the WSGI application to call.
-    environ: a partial WSGI environ (server and connection entries).
@@ -236 +274 @@
-    max_request_body_size = 0
-    
-all
+
-        self.rfile = environ['wsgi.input']
-all = sendall
+ = send
-        self.environ = environ.copy()
-        self.wsgi_app = wsgi_app
@@ -570 +608 @@
-            self.sendall(chunk)
-    
+    def sendall(self, data):
+        """Sendall for non-blocking sockets."""
+        while data:
+            try:
+                bytes_sent = self.send(data)
+                data = data[bytes_sent:]
+            except socket.error, e:
+                if e.args[0] not in socket_errors_nonblocking:
+                    raise
+    
-    def send_headers(self):
-        """Assert, process, and send the HTTP response message-headers."""
@@ -643 +691 @@
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        start = time.time()
-        while True:
-            try:
-method(self, 
+call(
-            except (SSL.WantReadError, SSL.WantWriteError):
-                # Sleep and try again. This is dangerous, because it means
@@ -685 +877 @@
-                    raise NoSSLError()
-                raise
+            except:
+                raise
-            if time.time() - start > self.ssl_timeout:
-                raise socket.timeout("timed out")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-
@@ -712 +900 @@
-    
-    rfile: a fileobject for reading from the socket.
-all
+
-    """
-    
@@ -737 +925 @@
-            self.rfile = SSL_fileobject(sock, "r", self.rbufsize)
-            self.rfile.ssl_timeout = timeout
-all = _ssl_wrap_method(sock.sendall)
+ = self.rfile.send
-        else:
-sock.makefile(
-all = sock.sendall
+CP_fileobject(sock, 
+ = sock.send
-        
-        # Wrap wsgi.input but not HTTPConnection.rfile itself.
@@ -756 +944 @@
-                # get written to the previous request.
-                req = None
-all
+
-                                               self.wsgi_app)
-                
@@ -772 +960 @@
-            if errnum not in socket_errors_to_ignore:
-                if req:
+                    fd = open("ssl_errors.txt", "a")
+                    fd.write("1" * 80)
+                    fd.write("\n")
+                    fd.write(str(type(e)))
+                    fd.write(format_exc())
-                    req.simple_response("500 Internal Server Error",
-                                        format_exc())
@@ -778 +971 @@
-            raise
-        except NoSSLError:
-all
-all = self.socket._sock.sendall
+
+ = self.socket._sock.send
-            req.simple_response("400 Bad Request",
-                                "The client sent a plain HTTP request, but "
-                                "this server only speaks HTTPS on this port.")
-
+ Exception, e
-            if req:
+                fd = open("ssl_errors.txt", "a")
+                fd.write("2" * 80)
+                fd.write("\n")
+                fd.write(format_exc())
-                req.simple_response("500 Internal Server Error", format_exc())
-    
@@ -790 +987 @@
-        """Close the socket underlying this connection."""
-        self.rfile.close()
+        
+        # Python's socket module does NOT call close on the kernel socket
+        # when you call socket.close(). We do so manually here because we
+        # want this server to send a FIN TCP segment immediately. Note this
+        # must be called *before* calling socket.close(), because the latter
+        # drops its reference to the kernel socket.
+        self.socket._sock.close()
+        
-        self.socket.close()
-