← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/dispatch/__init__.py

  • Committer: William Grant
  • Date: 2010-02-25 07:34:50 UTC
  • Revision ID: grantw@unimelb.edu.au-20100225073450-zcl8ev5hlyhbszeu
Activate the Storm C extensions if possible. Moar speed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
30
30
import os
31
31
import os.path
32
32
import urllib
 
33
import urlparse
33
34
import cgi
34
35
import traceback
35
36
import logging
36
37
import socket
37
38
import time
38
39
 
 
40
# We want to use the Storm C extensions if at all possible.
 
41
# Since we can't use SetEnv in Apache, do this here. It *must* appear
 
42
# before storm is imported for the first time.
 
43
os.environ['STORM_CEXTENSIONS'] = '1'
 
44
 
39
45
import mod_python
40
 
import routes
41
46
 
42
47
from ivle import util
43
48
import ivle.config
45
50
import ivle.webapp.security
46
51
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
47
52
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
48
 
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
 
53
from ivle.webapp.errors import BadRequest, HTTPError, NotFound, Unauthorized
 
54
from ivle.webapp.publisher import Publisher, PublishingError
 
55
from ivle.webapp import ApplicationRoot
49
56
 
50
57
config = ivle.config.Config()
51
58
 
52
 
def generate_router(view_plugins, attr):
 
59
class ObjectPermissionCheckingPublisher(Publisher):
 
60
    """A specialised publisher that checks object permissions.
 
61
 
 
62
    This publisher verifies that the user holds any permission at all
 
63
    on the model objects through which the resolution path passes. If
 
64
    no permission is held, resolution is aborted with an Unauthorized
 
65
    exception.
 
66
 
 
67
    IMPORTANT: This does NOT check view permissions. It only checks
 
68
    the objects in between the root and the view, exclusive!
 
69
    """
 
70
 
 
71
    def traversed_to_object(self, obj):
 
72
        """Check that the user has any permission at all over the object."""
 
73
        if (hasattr(obj, 'get_permissions') and
 
74
            len(obj.get_permissions(self.root.user, config)) == 0):
 
75
            # Indicate the forbidden object if this is an admin.
 
76
            if self.root.user and self.root.user.admin:
 
77
                raise Unauthorized('Unauthorized: %s' % obj)
 
78
            else:
 
79
                raise Unauthorized()
 
80
 
 
81
 
 
82
def generate_publisher(view_plugins, root, publicmode=False):
53
83
    """
54
84
    Build a Mapper object for doing URL matching using 'routes', based on the
55
85
    given plugin registry.
56
86
    """
57
 
    m = routes.Mapper(explicit=True)
 
87
    r = ObjectPermissionCheckingPublisher(root=root)
 
88
 
 
89
    r.add_set_switch('api', 'api')
 
90
 
 
91
    if publicmode:
 
92
        view_attr = 'public_views'
 
93
        forward_route_attr = 'public_forward_routes'
 
94
        reverse_route_attr = 'public_reverse_routes'
 
95
    else:
 
96
        view_attr = 'views'
 
97
        forward_route_attr = 'forward_routes'
 
98
        reverse_route_attr = 'reverse_routes'
 
99
 
 
100
 
58
101
    for plugin in view_plugins:
59
 
        # Establish a URL pattern for each element of plugin.urls
60
 
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
61
 
        for url in getattr(plugin, attr):
62
 
            routex = url[0]
63
 
            view_class = url[1]
64
 
            kwargs_dict = url[2] if len(url) >= 3 else {}
65
 
            m.connect(routex, view=view_class, **kwargs_dict)
66
 
    return m
 
102
        if hasattr(plugin, forward_route_attr):
 
103
            for fr in getattr(plugin, forward_route_attr):
 
104
                # An annotated function can also be passed in directly.
 
105
                if hasattr(fr, '_forward_route_meta'):
 
106
                    r.add_forward_func(fr)
 
107
                else:
 
108
                    r.add_forward(*fr)
 
109
 
 
110
        if hasattr(plugin, reverse_route_attr):
 
111
            for rr in getattr(plugin, reverse_route_attr):
 
112
                # An annotated function can also be passed in directly.
 
113
                if hasattr(rr, '_reverse_route_src'):
 
114
                    r.add_reverse_func(rr)
 
115
                else:
 
116
                    r.add_reverse(*rr)
 
117
 
 
118
        if hasattr(plugin, view_attr):
 
119
            for v in getattr(plugin, view_attr):
 
120
                r.add_view(*v)
 
121
 
 
122
    return r
67
123
 
68
124
def handler(apachereq):
69
125
    """Handles an HTTP request.
75
131
    # Make the request object into an IVLE request which can be given to views
76
132
    req = Request(apachereq, config)
77
133
 
78
 
    # Hack? Try and get the user login early just in case we throw an error
79
 
    # (most likely 404) to stop us seeing not logged in even when we are.
80
 
    if not req.publicmode:
81
 
        user = ivle.webapp.security.get_user_details(req)
82
 
 
83
 
        # Don't set the user if it is disabled or hasn't accepted the ToS.
84
 
        if user and user.valid:
85
 
            req.user = user
86
 
 
87
 
    if req.publicmode:
88
 
        req.mapper = generate_router(config.plugin_index[PublicViewPlugin],
89
 
                                    'public_urls')
90
 
    else:
91
 
        req.mapper = generate_router(config.plugin_index[ViewPlugin], 'urls')
92
 
 
93
 
    matchdict = req.mapper.match(req.uri)
94
 
    if matchdict is not None:
95
 
        viewcls = matchdict['view']
96
 
        # Get the remaining arguments, less 'view', 'action' and 'controller'
97
 
        # (The latter two seem to be built-in, and we don't want them).
98
 
        kwargs = matchdict.copy()
99
 
        del kwargs['view']
 
134
    req.publisher = generate_publisher(
 
135
        config.plugin_index[ViewPlugin], ApplicationRoot(req),
 
136
        publicmode=req.publicmode)
 
137
 
 
138
    try:
 
139
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
100
140
        try:
 
141
            # We 404 if we have a subpath but the view forbids it.
 
142
            if not viewcls.subpath_allowed and subpath:
 
143
                raise NotFound()
 
144
 
101
145
            # Instantiate the view, which should be a BaseView class
102
 
            view = viewcls(req, **kwargs)
 
146
            view = viewcls(req, obj, subpath)
103
147
 
104
148
            # Check that the request (mainly the user) is permitted to access
105
149
            # the view.
106
150
            if not view.authorize(req):
107
 
                raise Unauthorized()
 
151
                # Indicate the forbidden object if this is an admin.
 
152
                if req.user and req.user.admin:
 
153
                    raise Unauthorized('Unauthorized: %s' % view)
 
154
                else:
 
155
                    raise Unauthorized()
 
156
 
 
157
            # Non-GET requests from other sites leave us vulnerable to
 
158
            # CSRFs. Block them.
 
159
            referer = req.headers_in.get('Referer')
 
160
            if (referer is None or
 
161
                urlparse.urlparse(req.headers_in.get('Referer')).netloc !=
 
162
                    req.hostname):
 
163
                if req.method != 'GET' and not view.offsite_posts_allowed:
 
164
                    raise BadRequest(
 
165
                        "Non-GET requests from external sites are forbidden "
 
166
                        "for security reasons.")
 
167
 
108
168
            # Render the output
109
169
            view.render(req)
110
170
        except HTTPError, e:
118
178
                errviewcls = XHTMLView.get_error_view(e)
119
179
 
120
180
            if errviewcls:
121
 
                errview = errviewcls(req, e)
 
181
                errview = errviewcls(req, e, obj)
122
182
                errview.render(req)
123
183
                return req.OK
124
184
            elif e.message:
136
196
            handle_unknown_exception(req, *sys.exc_info())
137
197
            return req.OK
138
198
        else:
139
 
            req.store.commit()
 
199
            # Commit the transaction if we have a store open.
 
200
            req.commit()
140
201
            return req.OK
141
 
    else:
 
202
    except Unauthorized, e:
 
203
        # Resolution failed due to a permission check. Display a pretty
 
204
        # error, or maybe a login page.
 
205
        XHTMLView.get_error_view(e)(req, e, req.publisher.root).render(req)
 
206
        return req.OK
 
207
    except PublishingError, e:
142
208
        req.status = 404
143
 
        XHTMLErrorView(req, NotFound()).render(req)
 
209
 
 
210
        if req.user and req.user.admin:
 
211
            XHTMLErrorView(req, NotFound('Not found: ' +
 
212
                                         str(e.args)), e[0]).render(req)
 
213
        else:
 
214
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
 
215
 
144
216
        return req.OK
 
217
    finally:
 
218
        # Make sure we close the store.
 
219
        req.cleanup()
145
220
 
146
221
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
147
222
    """