Changeset 4087

Timestamp:

10/30/06 16:07:14 (3 years ago)

Author:

cmlenz

Message:

Use a more transparent method to avoid building the authenticaton, session and chrome data for requests that don't need them: the Request object now supports specifying callback functions that are called when undefined request attributes are accessed. The request dispatcher provides callbacks for req.authname, req.session, req.hdf, etc, so that those are evaluated lazily.

Location:

trunk/trac/web

Files:

• api.py (modified) (7 diffs)
• chrome.py (modified) (14 diffs)
• main.py (modified) (6 diffs)
• session.py (modified) (1 diff)

trunk/trac/web/api.py

@@ -124 +124 @@
     This class provides a convenience API over WSGI.
     """
-    args = None
-    hdf = None
-    authname = None
-    perm = None
-    session = None
 
     def __init__(self, environ, start_response):
@@ -135 +130 @@
         @param environ: The WSGI environment dict
         @param start_response: The WSGI callback for starting the response
+        @param callbacks: A dictionary of functions that are used to lazily
+            evaluate attribute lookups
         """
         self.environ = environ
@@ -142 +139 @@
         self._response = None
 
-        self._inheaders = [(name[5:].replace('_', '-').lower(), value)
-                           for name, value in environ.items()
-                           if name.startswith('HTTP_')]
-        if 'CONTENT_LENGTH' in environ:
-            self._inheaders.append(('content-length',
-                                    environ['CONTENT_LENGTH']))
-        if 'CONTENT_TYPE' in environ:
-            self._inheaders.append(('content-type', environ['CONTENT_TYPE']))
         self._outheaders = []
         self._outcharset = None
-
-        self.incookie = Cookie()
-        cookie = self.get_header('Cookie')
-        if cookie:
-            self.incookie.load(cookie, ignore_parse_errors=True)
         self.outcookie = Cookie()
+
+        self.callbacks = {
+            'args': Request._parse_args,
+            'incookie': Request._parse_cookies,
+            '_inheaders': Request._parse_headers
+        }
 
         self.base_url = self.environ.get('trac.base_url')
@@ -165 +155 @@
         self.abs_href = Href(self.base_url)
 
-        self.args = self._parse_args()
-
-    def _parse_args(self):
-        """Parse the supplied request parameters into a dictionary."""
-        args = _RequestArgs()
-
-        fp = self.environ['wsgi.input']
-        ctype = self.get_header('Content-Type')
-        if ctype:
-            # Avoid letting cgi.FieldStorage consume the input stream when the
-            # request does not contain form data
-            ctype, options = cgi.parse_header(ctype)
-            if ctype not in ('application/x-www-form-urlencoded',
-                             'multipart/form-data'):
-                fp = StringIO('')
-
-        fs = cgi.FieldStorage(fp, environ=self.environ, keep_blank_values=True)
-        if fs.list:
-            for name in fs.keys():
-                values = fs[name]
-                if not isinstance(values, list):
-                    values = [values]
-                for value in values:
-                    if not value.filename:
-                        value = unicode(value.value, 'utf-8')
-                    if name in args:
-                        if isinstance(args[name], list):
-                            args[name].append(value)
-                        else:
-                            args[name] = [args[name], value]
-                    else:
-                        args[name] = value
-
-        return args
-
-    def _reconstruct_url(self):
-        """Reconstruct the absolute base URL of the application."""
-        host = self.get_header('Host')
-        if not host:
-            # Missing host header, so reconstruct the host from the
-            # server name and port
-            default_port = {'http': 80, 'https': 443}
-            if self.server_port and self.server_port != default_port[self.scheme]:
-                host = '%s:%d' % (self.server_name, self.server_port)
-            else:
-                host = self.server_name
-        return urlparse.urlunparse((self.scheme, host, self.base_path, None,
-                                    None, None))
+    def __getattr__(self, name):
+        """Performs lazy attribute lookup by delegating to the functions in the
+        callbacks dictionary."""
+        if name in self.callbacks:
+            value = self.callbacks[name](self)
+            setattr(self, name, value)
+            return value
+        return getattr(super(Request, self), name)
+
+    def __repr__(self):
+        return '<%s "%s %s">' % (self.__class__.__name__, self.method,
+                                 self.path_info)
+
+    # Public API
 
     method = property(fget=lambda self: self.environ['REQUEST_METHOD'],
@@ -258 +214 @@
         self._outheaders.append((name, unicode(value).encode('utf-8')))
 
-    def _send_cookie_headers(self):
-        for name in self.outcookie.keys():
-            path = self.outcookie[name].get('path')
-            if path:
-                path = path.replace(' ', '%20') \
-                           .replace(';', '%3B') \
-                           .replace(',', '%3C')
-            self.outcookie[name]['path'] = path
-
-        cookies = self.outcookie.output(header='')
-        for cookie in cookies.splitlines():
-            self._outheaders.append(('Set-Cookie', cookie.strip()))
-
     def end_headers(self):
         """Must be called after all headers have been sent and before the actual
@@ -463 +406 @@
         self._write(data)
 
+    # Internal methods
+
+    def _parse_args(self):
+        """Parse the supplied request parameters into a dictionary."""
+        args = _RequestArgs()
+
+        fp = self.environ['wsgi.input']
+        ctype = self.get_header('Content-Type')
+        if ctype:
+            # Avoid letting cgi.FieldStorage consume the input stream when the
+            # request does not contain form data
+            ctype, options = cgi.parse_header(ctype)
+            if ctype not in ('application/x-www-form-urlencoded',
+                             'multipart/form-data'):
+                fp = StringIO('')
+
+        fs = cgi.FieldStorage(fp, environ=self.environ, keep_blank_values=True)
+        if fs.list:
+            for name in fs.keys():
+                values = fs[name]
+                if not isinstance(values, list):
+                    values = [values]
+                for value in values:
+                    if not value.filename:
+                        value = unicode(value.value, 'utf-8')
+                    if name in args:
+                        if isinstance(args[name], list):
+                            args[name].append(value)
+                        else:
+                            args[name] = [args[name], value]
+                    else:
+                        args[name] = value
+
+        return args
+
+    def _parse_cookies(self):
+        cookies = Cookie()
+        header = self.get_header('Cookie')
+        if header:
+            cookies.load(header, ignore_parse_errors=True)
+        return cookies
+
+    def _parse_headers(self):
+        headers = [(name[5:].replace('_', '-').lower(), value)
+                   for name, value in self.environ.items()
+                   if name.startswith('HTTP_')]
+        if 'CONTENT_LENGTH' in self.environ:
+            headers.append(('content-length', self.environ['CONTENT_LENGTH']))
+        if 'CONTENT_TYPE' in self.environ:
+            headers.append(('content-type', self.environ['CONTENT_TYPE']))
+        return headers
+
+    def _reconstruct_url(self):
+        """Reconstruct the absolute base URL of the application."""
+        host = self.get_header('Host')
+        if not host:
+            # Missing host header, so reconstruct the host from the
+            # server name and port
+            default_port = {'http': 80, 'https': 443}
+            if self.server_port and self.server_port != default_port[self.scheme]:
+                host = '%s:%d' % (self.server_name, self.server_port)
+            else:
+                host = self.server_name
+        return urlparse.urlunparse((self.scheme, host, self.base_path, None,
+                                    None, None))
+
+    def _send_cookie_headers(self):
+        for name in self.outcookie.keys():
+            path = self.outcookie[name].get('path')
+            if path:
+                path = path.replace(' ', '%20') \
+                           .replace(';', '%3B') \
+                           .replace(',', '%3C')
+            self.outcookie[name]['path'] = path
+
+        cookies = self.outcookie.output(header='')
+        for cookie in cookies.splitlines():
+            self._outheaders.append(('Set-Cookie', cookie.strip()))
+
 
 class IAuthenticator(Interface):
@@ -476 +498 @@
     """Extension point interface for request handlers."""
 
-    # implementing classes should set this property to `True` if they
-    # don't need session and authentication related information
-    anonymous_request = False
-    
-    # implementing classes should set this property to `False` if they
-    # don't need the HDF data and don't produce content using a template
-    use_template = True
-    
     def match_request(req):
         """Return whether the handler wants to process the given request."""

trunk/trac/web/chrome.py

@@ -27 +27 @@
 from genshi.template import TemplateLoader, MarkupTemplate, TextTemplate
 
+from trac import __version__ as VERSION
 from trac import mimeview
 from trac.config import *
@@ -45 +46 @@
     """
     linkid = '%s:%s' % (rel, href)
-    linkset = req.environ.setdefault('trac.chrome.linkset', set())
+    linkset = req.chrome.setdefault('linkset', set())
     if linkid in linkset:
         return # Already added that link
@@ -57 +58 @@
         link['class'] = classname
 
-    links = req.environ.setdefault('trac.chrome.links', {})
+    links = req.chrome.setdefault('links', {})
     links.setdefault(rel, []).append(link)
     linkset.add(linkid)
@@ -65 +66 @@
     in the generated HTML page.
     """
-    if filename.startswith('common/') and 'trac.htdocs_location' in req.environ:
-        href = Href(req.environ['trac.htdocs_location'])
+    if filename.startswith('common/') and 'htdocs_location' in req.chrome:
+        href = Href(req.chrome['htdocs_location'])
         filename = filename[7:]
     else:
@@ -74 +75 @@
 def add_script(req, filename, mimetype='text/javascript'):
     """Add a reference to an external javascript file to the template."""
-    scriptset = req.environ.setdefault('trac.chrome.scriptset', set())
+    scriptset = req.chrome.setdefault('trac.chrome.scriptset', set())
     if filename in scriptset:
         return False # Already added that script
 
-    if filename.startswith('common/') and 'trac.htdocs_location' in req.environ:
-        href = Href(req.environ['trac.htdocs_location'])
+    if filename.startswith('common/') and 'htdocs_location' in req.chrome:
+        href = Href(req.chrome['htdocs_location'])
         filename = filename[7:]
     else:
@@ -85 +86 @@
     script = {'href': href(filename), 'type': mimetype}
 
-    req.environ.setdefault('trac.chrome.scripts', []).append(script)
+    req.chrome.setdefault('scripts', []).append(script)
     scriptset.add(filename)
 
@@ -227 +228 @@
     # IRequestHandler methods
 
-    anonymous_request = True
-    use_template = False
-
     def match_request(self, req):
         match = re.match(r'/chrome/(?P<prefix>[^/]+)/+(?P<filename>[/\w\-\.]+)',
@@ -286 +284 @@
 
     def prepare_request(self, req, handler=None):
-        req.environ['trac.chrome.links'] = {}
-        req.environ['trac.chrome.scripts'] = []
+        """Prepare the basic chrome data for the request.
+        
+        @param req: the request object
+        @param handler: the `IRequestHandler` instance that is processing the
+            request
+        """
+        self.log.debug('Prepare chrome data for request')
+
+        chrome = {'links': {}, 'scripts': []}
+
+        # This is ugly... we can't pass the real Request object to the
+        # add_xxx methods, because it doesn't yet have the chrome attribute
+        class FakeRequest(object):
+            def __init__(self, req):
+                self.base_path = req.base_path
+                self.chrome = chrome
+        fakereq = FakeRequest(req)
+
         htdocs_location = self.htdocs_location or req.href.chrome('common')
-        req.environ['trac.htdocs_location'] = htdocs_location.rstrip('/') + '/'
+        chrome['htdocs_location'] = htdocs_location.rstrip('/') + '/'
 
         # HTML <head> links
-        add_link(req, 'start', req.href.wiki())
-        add_link(req, 'search', req.href.search())
-        add_link(req, 'help', req.href.wiki('TracGuide'))
-        add_stylesheet(req, 'common/css/trac.css')
-        add_script(req, 'common/js/jquery.js')
-        add_script(req, 'common/js/trac.js')
-        add_script(req, 'common/js/search.js')
+        add_link(fakereq, 'start', req.href.wiki())
+        add_link(fakereq, 'search', req.href.search())
+        add_link(fakereq, 'help', req.href.wiki('TracGuide'))
+        add_stylesheet(fakereq, 'common/css/trac.css')
+        add_script(fakereq, 'common/js/jquery.js')
+        add_script(fakereq, 'common/js/trac.js')
+        add_script(fakereq, 'common/js/search.js')
 
         icon = self.env.project_icon
@@ -308 +322 @@
                     icon = req.href.chrome('common', icon)
             mimetype = mimeview.get_mimetype(icon)
-            add_link(req, 'icon', icon, mimetype=mimetype)
-            add_link(req, 'shortcut icon', icon, mimetype=mimetype)
+            add_link(fakereq, 'icon', icon, mimetype=mimetype)
+            add_link(fakereq, 'shortcut icon', icon, mimetype=mimetype)
 
         # Logo image
-        req.environ['trac.chrome.logo'] = self.get_logo_data(req.href)
+        chrome['logo'] = self.get_logo_data(req.href)
 
         # Navigation links
@@ -342 +356 @@
                     nav[category][-1]['active'] = True
 
-        req.environ['trac.chrome.nav'] = nav
+        chrome['nav'] = nav
+
+        return chrome
 
     def get_logo_data(self, href):
@@ -369 +385 @@
         """Add chrome-related data to the HDF (deprecated)."""
         req.hdf['HTTP.PathInfo'] = req.path_info
-        req.hdf['htdocs_location'] = req.environ.get('trac.htdocs_location')
+        req.hdf['htdocs_location'] = req.chrome['htdocs_location']
 
         req.hdf['chrome.href'] = req.href.chrome()
-        req.hdf['chrome.links'] = req.environ.get('trac.chrome.links', [])
-        req.hdf['chrome.logo'] = req.environ.get('trac.chrome.logo', {})
-        req.hdf['chrome.scripts'] = req.environ.get('trac.chrome.scripts', [])
-
-        for category, items in req.environ.get('trac.chrome.nav', {}).items():
+        req.hdf['chrome.links'] = req.chrome['links']
+        req.hdf['chrome.scripts'] = req.chrome['scripts']
+        req.hdf['chrome.logo'] = req.chrome['logo']
+
+        for category, items in chrome['nav'].items():
             for item in items:
                 prefix = 'chrome.nav.%s.%s' % (category, item['name'])
@@ -382 +398 @@
 
     def populate_data(self, req, data):
-        from trac import __version__ as VERSION
-
         data.update(self._default_context_data)
         data.setdefault('trac', {}).update({
@@ -398 +412 @@
 
         chrome = data.setdefault('chrome', {})
-        chrome.update({
-            'footer': Markup(self.env.project_footer),
-        })
         if req:
-            chrome.update({
-                'htdocs_location': req.environ.get('trac.htdocs_location'),
-                'logo': req.environ.get('trac.chrome.logo', {}),
-                'links': req.environ.get('trac.chrome.links', []),
-                'nav': req.environ.get('trac.chrome.nav', {}),
-                'scripts': req.environ.get('trac.chrome.scripts', []),
-            })
+            chrome.update(req.chrome)
         else:
             chrome.update({
@@ -414 +419 @@
                 'logo': self.get_logo_data(self.env.abs_href),
             })
-
-        data['req'] = req
-        data['abs_href'] = req and req.abs_href or self.env.abs_href
-        data['href'] = req and req.href
-        data['perm'] = req and req.perm
-        data['authname'] = req and req.authname or '<trac>'
-
-        # Timezone-dependant functions
+        chrome.update({
+            'footer': Markup(self.env.project_footer)
+        })
+
         tzinfo = None
         if req:
             tzinfo = req.tz
-        data['format_datetime'] = partial(format_datetime, tzinfo=tzinfo)
-        data['format_date'] = partial(format_date, tzinfo=tzinfo)
-        data['format_time'] = partial(format_time, tzinfo=tzinfo)
-        data['fromtimestamp'] = partial(datetime.fromtimestamp, tz=tzinfo)
+
+        data.update({
+            'req': req,
+            'abs_href': req and req.abs_href or self.env.abs_href,
+            'href': req and req.href,
+            'perm': req and req.perm,
+            'authname': req and req.authname or '<trac>',
+            'format_datetime': partial(format_datetime, tzinfo=tzinfo),
+            'format_date': partial(format_date, tzinfo=tzinfo),
+            'format_time': partial(format_time, tzinfo=tzinfo),
+            'fromtimestamp': partial(datetime.fromtimestamp, tz=tzinfo)
+        })
 
     def load_template(self, filename, method=None):

trunk/trac/web/main.py

@@ -31 +31 @@
 from trac.env import open_environment
 from trac.perm import PermissionCache, NoPermissionCache, PermissionError
-from trac.util import reversed, get_lines_from_file, get_last_traceback
+from trac.util import get_lines_from_file, get_last_traceback
+from trac.util.compat import partial, reversed
 from trac.util.datefmt import format_datetime, http_date, localtz, timezone
 from trac.util.html import Markup
@@ -116 +117 @@
         if req.perm:
             for action in req.perm.permissions():
-                req.hdf['trac.acl.' + action] = True
+                hdf['trac.acl.' + action] = True
 
         for arg in [k for k in req.args.keys() if k]:
@@ -144 +145 @@
 
     default_timezone = Option('trac', 'default_timezone', '',
-                              doc="""The default timezone to use""")
-
-
+        """The default timezone to use""")
 
     # Public API
@@ -165 +164 @@
         site chrome.
         """
+        self.log.debug('Dispatching %r', req)
+        chrome = Chrome(self.env)
+
+        # Setup request callbacks for lazily-evaluated properties
+        req.callbacks.update({
+            'authname': self.authenticate,
+            'chrome': chrome.prepare_request,
+            'hdf': self._get_hdf,
+            'perm': self._get_perm,
+            'session': self._get_session,
+            'tz': self._get_timezone
+        })
+
         # Select the component that should handle the request
         chosen_handler = None
-        early_error = None
-        try:
-            if not req.path_info or req.path_info == '/':
-                chosen_handler = self.default_handler
-            else:
-                for handler in self.handlers:
-                    if handler.match_request(req):
-                        chosen_handler = handler
-                        break
-
-            chosen_handler = self._pre_process_request(req, chosen_handler)
-        except:
-            early_error = sys.exc_info()
-            
-        if not chosen_handler and not early_error:
-            early_error = (HTTPNotFound('No handler matched request to %s',
-                                        req.path_info),
-                           None, None)
-
-        # Attach user information to the request
-        anonymous_request = getattr(chosen_handler, 'anonymous_request',
-                                    False)
-        if not anonymous_request:
-            try:
-                req.authname = self.authenticate(req)
-                req.perm = PermissionCache(self.env, req.authname)
-                req.session = Session(self.env, req)
-            except:
-                anonymous_request = True
-                early_error = sys.exc_info()
-        if anonymous_request:
-            req.authname = 'anonymous'
-            req.perm = NoPermissionCache()
-
-        try:
-            req.tz = timezone(req.session.get('tz', self.default_timezone
-                                              or 'missing'))
-        except:
-            req.tz = localtz
-
-        # Prepare HDF for the clearsilver template
-        try:
-            use_template = getattr(chosen_handler, 'use_template', True)
-            req.hdf = None
-            if use_template:
-                chrome = Chrome(self.env)
-                req.hdf = HDFWrapper(loadpaths=chrome.get_all_templates_dirs())
-                populate_hdf(req.hdf, self.env, req)
-                chrome.prepare_request(req, chosen_handler)
-        except:
-            req.hdf = None # revert to sending plaintext error
-            if not early_error:
-                raise
-
-        if early_error:
-            try:
-                self._post_process_request(req)
-            except Exception, e:
-                self.log.exception(e)
-            raise early_error[0], early_error[1], early_error[2]
+        if not req.path_info or req.path_info == '/':
+            chosen_handler = self.default_handler
+        else:
+            for handler in self.handlers:
+                if handler.match_request(req):
+                    chosen_handler = handler
+                    break
+        chosen_handler = self._pre_process_request(req, chosen_handler)
+        if not chosen_handler:
+            raise HTTPNotFound('No handler matched request to %s',
+                               req.path_info)
+
+        req.callbacks['chrome'] = partial(chrome.prepare_request,
+                                          handler=chosen_handler)
 
         # Process the request and render the template
@@ -233 +199 @@
                 resp = chosen_handler.process_request(req)
                 if resp:
-                    chrome = Chrome(self.env)
                     if len(resp) == 2: # Clearsilver
                         chrome.populate_hdf(req)
@@ -267 +232 @@
             raise HTTPInternalError(e.message)
 
+    # Internal methods
+
+    def _get_hdf(self, req):
+        hdf = HDFWrapper(loadpaths=Chrome(self.env).get_all_templates_dirs())
+        populate_hdf(hdf, self.env, req)
+        return hdf
+
+    def _get_perm(self, req):
+        return PermissionCache(self.env, req.authname)
+
+    def _get_session(self, req):
+        return Session(self.env, req)
+
+    def _get_timezone(self, req):
+        try:
+            return timezone(req.session.get('tz', self.default_timezone
+                                            or 'missing'))
+        except:
+            return localtz
+
     def _pre_process_request(self, req, chosen_handler):
-        for f in self.filters:
-            chosen_handler = f.pre_process_request(req, chosen_handler)
+        for filter_ in self.filters:
+            chosen_handler = filter_.pre_process_request(req, chosen_handler)
         return chosen_handler
-                
+
     def _post_process_request(self, req, template=None, content_type=None):
         for f in reversed(self.filters):

trunk/trac/web/session.py

@@ -60 +60 @@
 
     def get_session(self, sid, authenticated=False):
+        self.env.log.debug('Retrieving session for ID %r', sid)
+
         db = self.env.get_db_cnx()
         cursor = db.cursor()