Changeset 1082

Timestamp:

05/01/06 01:40:59

Author:

fumanchu

Message:

Lots of changes to error and log handling:

1. Removed RequestHandled? and InternalError?.
   
2. Error response is now overridable by replacing request.error_response. Tools should do this in setup().
   
3. New request.log_access attribute.
   
4. Moved response.handleError to request.handle_error.
   
5. Logging of tracebacks and request headers are now tools.
   
6. New ErrorRedirect? tool class.
   
7. Tools may now be anonymous (not necessary to be placed in tools module globals).
   
8. Continued the move to lower_with_underscores.
   

Files:

• trunk/cherrypy/__init__.py (modified) (1 diff)
• trunk/cherrypy/_cperror.py (modified) (7 diffs)
• trunk/cherrypy/_cprequest.py (modified) (13 diffs)
• trunk/cherrypy/_cputil.py (modified) (5 diffs)
• trunk/cherrypy/_cpwsgi.py (modified) (4 diffs)
• trunk/cherrypy/config.py (modified) (2 diffs)
• trunk/cherrypy/lib/cptools.py (modified) (2 diffs)
• trunk/cherrypy/lib/httptools.py (modified) (1 diff)
• trunk/cherrypy/lib/sessions.py (modified) (1 diff)
• trunk/cherrypy/lib/wsgiapp.py (modified) (1 diff)
• trunk/cherrypy/lib/xmlrpc.py (modified) (1 diff)
• trunk/cherrypy/test/benchmark.py (modified) (1 diff)
• trunk/cherrypy/test/helper.py (modified) (1 diff)
• trunk/cherrypy/test/test_config.py (modified) (1 diff)
• trunk/cherrypy/test/test_core.py (modified) (6 diffs)
• trunk/cherrypy/test/test_custom_filters.py (modified) (1 diff)
• trunk/cherrypy/test/test_virtualhost_filter.py (modified) (1 diff)
• trunk/cherrypy/tools.py (modified) (6 diffs)

trunk/cherrypy/__init__.py

@@ -86 +86 @@
-    # Load _cputil lazily to avoid circular references, and
-    # to allow profiler and coverage tools to work on it.
-
+, _cperror
-    logfunc = _cputil.get_special_attribute('_cp_log_message')
-    
-    if traceback:
-util.formatE
+error.format_e
-    
-    logfunc(msg, context, severity)

trunk/cherrypy/_cperror.py

@@ -1 +1 @@
-"""Error classes for CherryPy."""
-
+import cgi
+import sys
+import traceback
-import urllib
+import urlparse
+
+from cherrypy.lib import httptools
+
-
-class Error(Exception):
@@ -14 +21 @@
-    pass
-
-class RequestHandled(Exception):
-    """Exception raised when no further request handling should occur."""
-    pass
-
-class InternalRedirect(Exception):
-    """Exception raised when processing should be handled by a different path.
@@ -31 +34 @@
-    def __init__(self, path, params=None):
-        import cherrypy
-        import cgi
-        request = cherrypy.request
-        
@@ -48 +50 @@
-            else:
-                request.query_string = urllib.urlencode(params)
-                request.queryString = request.query_string
-                request.params = params.copy()
-        
@@ -65 +66 @@
-    
-    def __init__(self, urls, status=None):
-        import urlparse
-        import cherrypy
-        
@@ -152 +152 @@
-    
-    def set_response(self):
+        """Set cherrypy.response status, headers, and body."""
-        import cherrypy
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -168 +201 @@
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/cherrypy/_cprequest.py

@@ -7 +7 @@
-
-import cherrypy
-
+error, _cp
-from cherrypy.lib import cptools, httptools
-
@@ -22 +22 @@
-        scheme should be a string, either "http" or "https".
-        """
- 
- 
- 
+
+
+
-        
-        self.scheme = scheme
@@ -43 +43 @@
-            cherrypy.serving.__dict__.clear()
-    
-L
+_l
-        """Process the Request.
-        
-L
+_l
-        headers should be a list of (name, value) tuples.
-        rfile should be a file-like object containing the HTTP request
@@ -60 +60 @@
-        
-        """
-
+
+
+
+
-        self.header_list = list(headers)
-        self.rfile = rfile
-        
-        self.headers = httptools.HeaderMap()
-        self.simple_cookie = Cookie.SimpleCookie()
@@ -76 +78 @@
-            cherrypy.response.body = []
-        
-_cputil.get_special_attribute("_cp_log_access")
+self.log_access
-        
-        return cherrypy.response
-    
-    def _run(self):
+        conf = cherrypy.config.get
-        
-        try:
@@ -86 +89 @@
-            # because request.object_path is used for config lookups
-            # right away.
-RequestL
-herrypy.config.get
+_request_l
+onf
-            self.hooks.setup()
-            
@@ -94 +97 @@
-                
-                try:
-H
+_h
-                    
-                    self.hooks.run('before_request_body')
-RequestB
-B
+_request_b
+_b
-                    
-                    # Loop to allow for InternalRedirect.
@@ -112 +115 @@
-                    self.hooks.run('before_finalize')
-                    cherrypy.response.finalize()
-                except cherrypy.RequestHandled:
-                    pass
-                except (cherrypy.HTTPRedirect, cherrypy.HTTPError), inst:
-                    # For an HTTPRedirect or HTTPError (including NotFound),
@@ -126 +127 @@
-            raise
-        except:
-herrypy.config.get
+onf
-                raise
-
-
-
-
-
+
+
+
+
+
+
-        if path == "*":
-            path = "global"
-        
-        self.method = method
-RequestB
+_request_b
-        
-        self.path = path
@@ -169 +171 @@
-        cherrypy.response.version = min(self.version, server_v)
-    
-H
+_h
-        self.params = httptools.parseQueryString(self.query_string)
-        
@@ -202 +204 @@
-                          doc="The URL as entered in a browser (read-only).")
-    
-
+
+
-        # Create a copy of headers with lowercase keys because
-        # FieldStorage doesn't work otherwise
@@ -225 +228 @@
-        else:
-            self.params.update(httptools.paramsFromCGIForm(forms))
+    
+    def handle_error(self, exc):
+        response = cherrypy.response
+        try:
+            self.hooks.run("before_error_response")
+            if self.error_response:
+                self.error_response()
+            self.hooks.run("after_error_response")
+            response.finalize()
+            return
+        except cherrypy.HTTPRedirect, inst:
+            try:
+                inst.set_response()
+                response.finalize()
+                return
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except:
+                # Fall through to the second error handler
+                pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except:
+            # Fall through to the second error handler
+            pass
+        
+        # Failure in error handler or finalize. Bypass them.
+        if cherrypy.config.get('server.show_tracebacks', False):
+            dbltrace = ("\n===First Error===\n\n%s"
+                        "\n\n===Second Error===\n\n%s\n\n")
+            body = dbltrace % (_cperror.format_exc(exc),
+                               _cperror.format_exc())
+        else:
+            body = ""
+        r = _cperror.bare_error(body)
+        response.status, response.header_list, response.body = r
-
-
@@ -325 +364 @@
-                name, value = line.split(": ", 1)
-                self.header_list.append((name, value))
-    
-    dbltrace = "\n===First Error===\n\n%s\n\n===Second Error===\n\n%s\n\n"
-    
-    def handleError(self, exc):
-        """Set status, headers, and body when an unanticipated error occurs."""
-        try:
-            cherrypy.request.hooks.run('before_error_response')
-            
-            _cputil.get_special_attribute('_cp_on_error')()
-            self.finalize()
-            
-            cherrypy.request.hooks.run('after_error_response')
-            return
-        except cherrypy.HTTPRedirect, inst:
-            try:
-                inst.set_response()
-                self.finalize()
-                return
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except:
-                # Fall through to the second error handler
-                pass
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except:
-            # Fall through to the second error handler
-            pass
-        
-        # Failure in error hooks or finalize.
-        # Bypass them all.
-        if cherrypy.config.get('server.show_tracebacks', False):
-            body = self.dbltrace % (_cputil.formatExc(exc),
-                                    _cputil.formatExc())
-        else:
-            body = ""
-        self.setBareError(body)
-    
-    def setBareError(self, body=None):
-        self.status, self.header_list, self.body = _cputil.bareError(body)
-

trunk/cherrypy/_cputil.py

@@ -117 +117 @@
-def get_special_attribute(name):
-    """Return the special attribute. A special attribute is one that
-
-
+
-    
-    # First, we look in the right-most object to see if this special
@@ -153 +152 @@
-_cpGlobalHandler.exposed = True
-
+
-def logtime():
-    now = datetime.datetime.now()
@@ -159 +159 @@
-        now.day, month, now.year, now.hour, now.minute, now.second)
-
-_cp_
+
-    """Default method for logging access"""
+    request = cherrypy.request
-    
-    tmpl = '%(h)s %(l)s %(u)s [%(t)s] "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'
-cherrypy.
+
-                'l': '-',
-cherrypy.
+
-                't': logtime(),
-cherrypy.request.requestL
+request.request_l
-                's': cherrypy.response.status.split(" ", 1)[0],
-                'b': cherrypy.response.headers.get('Content-Length', '') or "-",
-cherrypy.
-cherrypy.
+
+
-                }
-    
@@ -182 +183 @@
-        f.write(s + '\n')
-        f.close()
-
-
-_log_severity_levels = {0: "INFO", 1: "WARNING", 2: "ERROR"}
@@ -209 +209 @@
-        f.close()
-
-
-_HTTPErrorTemplate = '''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"></meta>
-    <title>%(status)s</title>
-    <style type="text/css">
-    #powered_by {
-        margin-top: 20px;
-        border-top: 2px solid black;
-        font-style: italic;
-    }
-
-    #traceback {
-        color: red;
-    }
-    </style>
-</head>
-    <body>
-        <h2>%(status)s</h2>
-        <p>%(message)s</p>
-        <pre id="traceback">%(traceback)s</pre>
-    <div id="powered_by">
-    <span>Powered by <a href="http://www.cherrypy.org">CherryPy %(version)s</a></span>
-    </div>
-    </body>
-</html>
-'''
-
-def getErrorPage(status, **kwargs):
-    """Return an HTML page, containing a pretty error response.
-    
-    status should be an int or a str.
-    kwargs will be interpolated into the page template.
-    """
-    
-    try:
-        code, reason, message = httptools.validStatus(status)
-    except ValueError, x:
-        raise cherrypy.HTTPError(500, x.args[0])
-    
-    # We can't use setdefault here, because some
-    # callers send None for kwarg values.
-    if kwargs.get('status') is None:
-        kwargs['status'] = "%s %s" % (code, reason)
-    if kwargs.get('message') is None:
-        kwargs['message'] = message
-    if kwargs.get('traceback') is None:
-        kwargs['traceback'] = ''
-    if kwargs.get('version') is None:
-        kwargs['version'] = cherrypy.__version__
-    for k, v in kwargs.iteritems():
-        if v is None:
-            kwargs[k] = ""
-        else:
-            kwargs[k] = cgi.escape(kwargs[k])
-    
-    template = _HTTPErrorTemplate
-    error_page_file = cherrypy.config.get('error_page.%s' % code, '')
-    if error_page_file:
-        try:
-            template = file(error_page_file, 'rb').read()
-        except:
-            m = kwargs['message']
-            if m:
-                m += "<br />"
-            m += ("In addition, the custom error page "
-                  "failed:\n<br />%s" % (sys.exc_info()[1]))
-            kwargs['message'] = m
-    
-    return template % kwargs
-
-def _cp_on_error():
-    """ Default _cp_on_error method """
-    # Allow logging of only *unexpected* HTTPError's.
-    if (not cherrypy.config.get('server.log_tracebacks', True)
-        and cherrypy.config.get('server.log_unhandled_tracebacks', True)):
-        cherrypy.log(traceback=True)
-    cherrypy.HTTPError(500).set_response()
-
-def _cp_on_http_error(status, message):
-    """Default _cp_on_http_error method.
-    
-    status should be an int.
-    """
-    tb = formatExc()
-    logmsg = ""
-    
-    if cherrypy.config.get('server.log_tracebacks', True):
-        logmsg = tb
-    if cherrypy.config.get('server.log_request_headers', True):
-        h = ["  %s: %s" % (k, v) for k, v in cherrypy.request.header_list]
-        logmsg += 'Request Headers:\n' + '\n'.join(h)
-    if logmsg:
-        cherrypy.log(logmsg, "HTTP")
-    
-    if not cherrypy.config.get('server.show_tracebacks', False):
-        tb = None
-    
-    response = cherrypy.response
-    
-    # Remove headers which applied to the original content,
-    # but do not apply to the error page.
-    for key in ["Accept-Ranges", "Age", "ETag", "Location", "Retry-After",
-                "Vary", "Content-Encoding", "Content-Length", "Expires",
-                "Content-Location", "Content-MD5", "Last-Modified"]:
-        if response.headers.has_key(key):
-            del response.headers[key]
-    
-    if status != 416:
-        # A server sending a response with status code 416 (Requested
-        # range not satisfiable) SHOULD include a Content-Range field
-        # with a byte-range- resp-spec of "*". The instance-length
-        # specifies the current length of the selected resource.
-        # A response with status code 206 (Partial Content) MUST NOT
-        # include a Content-Range field with a byte-range- resp-spec of "*".
-        if response.headers.has_key("Content-Range"):
-            del response.headers["Content-Range"]
-    
-    # In all cases, finalize will be called after this method,
-    # so don't bother cleaning up response values here.
-    response.status = status
-    content = getErrorPage(status, traceback=tb, message=message)
-    response.body = content
-    response.headers['Content-Length'] = len(content)
-    response.headers['Content-Type'] = "text/html"
-    
-    be_ie_unfriendly(status)
-
-
-_ie_friendly_error_sizes = {
-    400: 512, 403: 256, 404: 512, 405: 256,
-    406: 512, 408: 512, 409: 512, 410: 256,
-    500: 512, 501: 512, 505: 512,
-    }
-
-
-def be_ie_unfriendly(status):
-    
-    response = cherrypy.response
-    
-    # For some statuses, Internet Explorer 5+ shows "friendly error
-    # messages" instead of our response.body if the body is smaller
-    # than a given size. Fix this by returning a body over that size
-    # (by adding whitespace).
-    # See http://support.microsoft.com/kb/q218155/
-    s = _ie_friendly_error_sizes.get(status, 0)
-    if s:
-        s += 1
-        # Since we are issuing an HTTP error status, we assume that
-        # the entity is short, and we should just collapse it.
-        content = response.collapse_body()
-        l = len(content)
-        if l and l < s:
-            # IN ADDITION: the response must be written to IE
-            # in one chunk or it will still get replaced! Bah.
-            content = content + (" " * (s - l))
-        response.body = content
-        response.headers['Content-Length'] = len(content)
-
-def lower_to_camel(s):
-    """Turns lowercase_with_underscore into camelCase."""
-    sp = s.split('_')
-    new_sp = []
-    for i, s in enumerate(sp):
-        if i != 0:
-            s = s[0].upper() + s[1:]
-        new_sp.append(s)
-    return ''.join(new_sp)
-
-def formatExc(exc=None):
-    """formatExc(exc=None) -> exc (or sys.exc_info if None), formatted."""
-    if exc is None:
-        exc = sys.exc_info()
-    
-    if exc == (None, None, None):
-        return ""
-    
-    page_handler_str = ""
-    args = list(getattr(exc[1], "args", []))
-    if args:
-        if len(args) > 1:
-            page_handler = args.pop()
-            page_handler_str = 'Page handler: %s\n' % repr(page_handler)
-            exc[1].args = tuple(args)
-    return page_handler_str + "".join(traceback.format_exception(*exc))
-
-def bareError(extrabody=None):
-    """Produce status, headers, body for a critical error.
-    
-    Returns a triple without calling any other questionable functions,
-    so it should be as error-free as possible. Call it from an HTTP server
-    if you get errors after Request() is done.
-    
-    If extrabody is None, a friendly but rather unhelpful error message
-    is set in the body. If extrabody is a string, it will be appended
-    as-is to the body.
-    """
-    
-    # The whole point of this function is to be a last line-of-defense
-    # in handling errors. That is, it must not raise any errors itself;
-    # it cannot be allowed to fail. Therefore, don't add to it!
-    # In particular, don't call any other CP functions.
-    
-    body = "Unrecoverable error in the server."
-    if extrabody is not None:
-        body += "\n" + extrabody
-    
-    return ("500 Internal Server Error",
-            [('Content-Type', 'text/plain'),
-             ('Content-Length', str(len(body)))],
-            [body])
-

trunk/cherrypy/_cpwsgi.py

@@ -4 +4 @@
-import cherrypy
-from cherrypy import _cputil, _cpwsgiserver
+from cherrypy._cperror import format_exc, bare_error
-from cherrypy.lib import httptools
-
-
-L
+_l
-    """Rebuild first line of the request (e.g. "GET /path HTTP/1.0")."""
-    
@@ -71 +72 @@
-        request.multiprocess = environ['wsgi.multiprocess']
-        request.wsgi_environ = environ
-L
+_l
-                               translate_headers(environ),
-                               environ['wsgi.input'])
@@ -81 +82 @@
-        if cherrypy.config.get("server.throw_errors", False):
-            raise
-_cputil.formatE
+format_e
-        cherrypy.log(tb)
-        if not cherrypy.config.get("server.show_tracebacks", False):
-            tb = ""
-_cputil.bareE
+bare_e
-        exc = sys.exc_info()
-    
@@ -115 +116 @@
-            cherrypy.log(traceback=True)
-        request = None
-_cputil.bareE
-E
+bare_e
+_e
-        # so don't call start_response (which, according to PEP 333,
-        # may raise its own error at that point).

trunk/cherrypy/config.py

@@ -21 +21 @@
-    'server.protocol_version': 'HTTP/1.0',
-    'server.log_to_screen': True,
-    'server.log_tracebacks': True,
-    'server.log_file': '',
+    'tools.log_tracebacks.on': True,
-    'server.reverse_dns': False,
-    'server.thread_pool': 10,
@@ -230 +230 @@
-                  'server.log_to_screen',
-                  'server.log_file',
-                  'server.log_tracebacks',
-                  'server.log_request_headers',
-                  'server.protocol_version',
-                  'server.socket_host',

trunk/cherrypy/lib/cptools.py

@@ -7 +7 @@
-
-import cherrypy
-
-
-
@@ -315 +314 @@
-        cherrypy.request.object_path = prefix + "/" + cherrypy.request.object_path
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/cherrypy/lib/httptools.py

@@ -304 +304 @@
-    return code, reason, message
-
-RequestLine(requestL
-L
-L
+_request_line(request_l
+_l
+_l
-    
-    # path may be an abs_path (including "http://host.domain.tld");

trunk/cherrypy/lib/sessions.py

@@ -362 +362 @@
-
-# Users access sessions through cherrypy.session, but we want this
-special wrapper that forward
-calls 
+wrapper that forwards call
+
-#   cherrypy.request._session.data
-class SessionWrapper:

trunk/cherrypy/lib/wsgiapp.py

@@ -92 +92 @@
-        """A custom Request object for running a WSGI app within CP."""
-       
-B
+_b
-            pass
-        

trunk/cherrypy/lib/xmlrpc.py

@@ -41 +41 @@
-                                  allow_none=allow_none))
-
-wrap
+on
-    body = str(sys.exc_info()[1])
-    _set_response(xmlrpclib.dumps(xmlrpclib.Fault(1, body)))

trunk/cherrypy/test/benchmark.py

@@ -87 +87 @@
-        pass
-    
-L
+_l
-        cherrypy.response.status = "204 No Content"
-        cherrypy.response.header_list = [("Content-Type", 'text/html'),

trunk/cherrypy/test/helper.py

@@ -55 +55 @@
-        
-        # This will never contain a traceback:
-util.getErrorP
+error.get_error_p
-        
-        # First, test the response body without checking the traceback.

trunk/cherrypy/test/test_config.py

@@ -95 +95 @@
-        err = ('WrongConfigValue: ("section: '
-               "'global', option: 'server.environment', value: 'production'"
-
+, ('production',)
-        self.getPage("/env/wrong")
-        self.assertErrorPage(500, pattern=err)

trunk/cherrypy/test/test_core.py

@@ -105 +105 @@
-        
-        class Error:
-
-
+
-            
-            def index(self):
@@ -207 +206 @@
-            # Since status must start with an int, this should error.
-            cherrypy.response.status = "ZOO OK"
-        
-        def log_unhandled(self):
-            raise ValueError()
-        
-        def rethrow(self):
@@ -356 +352 @@
-        '/error': {
-            'server.log_file': log_file,
-server.log_tracebacks
+tools.log_tracebacks.on
-        },
-        '/error/page_streamed': {
@@ -370 +366 @@
-            'error_page.404': "nonexistent.html",
-        },
-        '/error/log_unhandled': {
-            'server.log_tracebacks': False,
-            'server.log_unhandled_tracebacks': True,
-        },
-        '/error/rethrow': {
-            'server.throw_errors': True,
@@ -488 +480 @@
-            self.assertEqual(data[0][-41:], ' INFO Traceback (most recent call last):\n')
-            self.assertEqual(data[-3], '    raise ValueError()\n')
-            
-            # Test that unhandled tracebacks get written