Changeset 1530

Timestamp:

12/15/06 17:09:19

Author:

fumanchu

Message:

Blurg. Horrible late rewrite of WSGI stack due to missing close calls (one test fails still: IR with HTTP/1.0).

Files:

• trunk/cherrypy/_cpwsgi.py (modified) (6 diffs)
• trunk/cherrypy/test/test_tools.py (modified) (2 diffs)
• trunk/cherrypy/wsgiserver.py (modified) (2 diffs)

trunk/cherrypy/_cpwsgi.py

@@ -7 +7 @@
-from cherrypy import _cperror, wsgiserver
-from cherrypy.lib import http as _http
+
+
+#                            Internal Redirect                            #
-
-
@@ -37 +40 @@
-    
-    def __call__(self, environ, start_response):
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        while True:
-            try:
-for chunk in self.nextapp(env, start_response):
-    yield chunk
+self.response = self.nextapp(self.environ, self.start_response)
+self.iter_response = iter(self.response)
-                break
-            except _cherrypy.InternalRedirect, ir:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    throws = (KeyboardInterrupt, SystemExit, _cherrypy.InternalRedirect)
+    request = None
+    
+    def __init__(self, environ, start_response, cpapp):
+        try:
+            self.request = self.get_engine_request(environ, cpapp)
+            
+            meth = environ['REQUEST_METHOD']
+            path = environ.get('SCRIPT_NAME', '') + environ.get('PATH_INFO', '')
+            qs = environ.get('QUERY_STRING', '')
+            rproto = environ.get('SERVER_PROTOCOL')
+            headers = self.translate_headers(environ)
+            rfile = environ['wsgi.input']
+            
+            response = self.request.run(meth, path, qs, rproto, headers, rfile)
+            s, h, b = response.status, response.header_list, response.body
+            exc = None
+        except self.throws:
+            self.close()
+            raise
+        except:
+            if getattr(self.request, "throw_errors", False):
+                self.close()
+                raise
+            
+            tb = _cperror.format_exc()
+            _cherrypy.log(tb)
+            if not getattr(self.request, "show_tracebacks", True):
+                tb = ""
+            s, h, b = _cperror.bare_error(tb)
+            exc = _sys.exc_info()
+        
+        self.iter_response = iter(b)
+        
+        try:
+            start_response(s, h, exc)
+        except self.throws:
+            self.close()
+            raise
+        except:
+            if getattr(self.request, "throw_errors", False):
+                self.close()
+                raise
+            
+            _cherrypy.log(traceback=True)
+            self.close()
+            
+            # CherryPy test suite expects bare_error body to be output,
+            # so don't call start_response (which, according to PEP 333,
+            # may raise its own error at that point).
+            s, h, b = _cperror.bare_error()
+            self.iter_response = iter(b)
+    
+    def __iter__(self):
+        return self
+    
+    def next(self):
+        try:
+            chunk = self.iter_response.next()
+            # WSGI requires all data to be of type "str". This coercion should
+            # not take any time at all if chunk is already of type "str".
+            # If it's unicode, it could be a big performance hit (x ~500).
+            if not isinstance(chunk, str):
+                chunk = chunk.encode("ISO-8859-1")
+            return chunk
+        except self.throws:
+            raise
+        except StopIteration:
+            raise
+        except:
+            if getattr(self.request, "throw_errors", False):
+                raise
+            
+            _cherrypy.log(traceback=True)
+            
+            # CherryPy test suite expects bare_error body to be output,
+            # so don't call start_response (which, according to PEP 333,
+            # may raise its own error at that point).
+            s, h, b = _cperror.bare_error()
+            self.iter_response = iter([])
+            return "".join(b)
+    
+    def close(self):
+        if hasattr(self.request, "close"):
+            try:
+                self.request.close()
+            except:
+                _cherrypy.log(traceback=True)
+    
+    def get_engine_request(self, environ, cpapp):
+        """Return a Request object from the CherryPy Engine using environ."""
+        env = environ.get
+        
+        local = _http.Host('', int(env('SERVER_PORT', 80)),
+                           env('SERVER_NAME', ''))
+        remote = _http.Host(env('REMOTE_ADDR', ''),
+                            int(env('REMOTE_PORT', -1)),
+                            env('REMOTE_HOST', ''))
+        scheme = env('wsgi.url_scheme')
+        sproto = env('ACTUAL_SERVER_PROTOCOL', "HTTP/1.1")
+        request = _cherrypy.engine.request(local, remote, scheme, sproto)
+        
+        # LOGON_USER is served by IIS, and is the name of the
+        # user after having been mapped to a local account.
+        # Both IIS and Apache set REMOTE_USER, when possible.
+        request.login = env('LOGON_USER') or env('REMOTE_USER') or None
+        request.multithread = environ['wsgi.multithread']
+        request.multiprocess = environ['wsgi.multiprocess']
+        request.wsgi_environ = environ
+        request.app = cpapp
+        request.prev = env('cherrypy.request')
+        environ['cherrypy.request'] = request
+        return request
-    
-    headerNames = {'HTTP_CGI_AUTHORIZATION': 'Authorization',
@@ -107 +236 @@
-                translatedHeader = cgiName[5:].replace("_", "-")
-                yield translatedHeader, environ[cgiName]
+
+
+class CPWSGIApp(object):
+    """A WSGI application object for a CherryPy Application.
+    
+    pipeline: a list of (name, wsgiapp) pairs. Each 'wsgiapp' MUST be a
+        constructor that takes an initial, positional 'nextapp' argument,
+        plus optional keyword arguments, and returns a WSGI application
+        (that takes environ and start_response arguments). The 'name' can
+        be any you choose, and will correspond to keys in self.config.
+    
+    head: rather than nest all apps in the pipeline on each call, it's only
+        done the first time, and the result is memoized into self.head. Set
+        this to None again if you change self.pipeline after calling self.
+    
+    config: a dict whose keys match names listed in the pipeline. Each
+        value is a further dict which will be passed to the corresponding
+        named WSGI callable (from the pipeline) as keyword arguments.
+    """
+    
+    pipeline = [('iredir', InternalRedirector)]
+    head = None
+    config = {}
-    
-    def __init__(self, cpapp, pipeline=None):
@@ -115 +267 @@
-        self.config = self.config.copy()
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    def tail(self, environ, start_response):
@@ -145 +275 @@
-        so that any WSGI middleware in self.pipeline can run first.
-        """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    def __call__(self, environ, start_response):
@@ -211 +281 @@
-        if head is None:
-            # Create and nest the WSGI apps in our pipeline (in reverse order).
+            # Then memoize the result in self.head.
-            head = self.tail
-            for name, callable in self.pipeline[::-1]:

trunk/cherrypy/test/test_tools.py

@@ -159 +159 @@
-        def err_in_onstart(self):
-            return "success!"
+        
+        def stream(self):
+            for x in xrange(100000000):
+                yield str(x)
+        stream._cp_config = {'response.stream': True}
-    
-    
@@ -236 +241 @@
-        self.getPage("/demo/userid")
-        self.assertBody("Welcome!")
+        
+        # Test that on_end_request is called even if the client drops.
+        self.persistent = True
+        try:
+            conn = self.HTTP_CONN
+            conn.putrequest("GET", "/demo/stream", skip_host=True)
+            conn.putheader("Host", self.HOST)
+            conn.endheaders()
+            # Skip the rest of the request and close the conn. This will
+            # cause the server's active socket to error, which *should*
+            # result in the request being aborted, and request.close being
+            # called all the way up the stack (including WSGI middleware),
+            # eventually calling our on_end_request hook.
+        finally:
+            self.persistent = False
+        time.sleep(0.1)
+        # Test that the on_end_request hooks was called.
+        self.getPage("/demo/ended/9")
+        self.assertBody("True")
-    
-    def testGuaranteedHooks(self):

trunk/cherrypy/wsgiserver.py

@@ -280 +280 @@
-        response = self.wsgi_app(self.environ, self.start_response)
-        try:
-line
+chunk
-                if not self.sent_headers:
-                    self.sent_headers = True
-                    self.send_headers()
-                if self.chunked_write:
-line
+chunk
-                    wfile.write("\r\n")
-line
+chunk
-                    wfile.write("\r\n")
-                else:
-line
+chunk
-                wfile.flush()
-        finally:
@@ -669 +669 @@
-                # Despite the socket module docs, using '' does not
-                # allow AI_PASSIVE to work. Passing None instead
-
+
+
+
+
+
+
-                host = None
-                flags = socket.AI_PASSIVE