← 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-07-27 10:25:59 UTC
  • Revision ID: grantw@unimelb.edu.au-20100727102559-cvt3fhlaiaknd5bp
https://launchpad.net/bugs/610407
Validate uniqueness of Subject.code at the form layer, so we don't crash due to DB constraints.

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
37
38
import time
38
39
 
39
40
import mod_python
40
 
import routes
41
41
 
42
42
from ivle import util
43
43
import ivle.config
45
45
import ivle.webapp.security
46
46
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
47
47
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
48
 
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
 
48
from ivle.webapp.errors import BadRequest, HTTPError, NotFound, Unauthorized
 
49
from ivle.webapp.publisher import Publisher, PublishingError
 
50
from ivle.webapp import ApplicationRoot
49
51
 
50
52
config = ivle.config.Config()
51
53
 
52
 
def generate_router(view_plugins, attr):
 
54
class ObjectPermissionCheckingPublisher(Publisher):
 
55
    """A specialised publisher that checks object permissions.
 
56
 
 
57
    This publisher verifies that the user holds any permission at all
 
58
    on the model objects through which the resolution path passes. If
 
59
    no permission is held, resolution is aborted with an Unauthorized
 
60
    exception.
 
61
 
 
62
    IMPORTANT: This does NOT check view permissions. It only checks
 
63
    the objects in between the root and the view, exclusive!
 
64
    """
 
65
 
 
66
    def traversed_to_object(self, obj):
 
67
        """Check that the user has any permission at all over the object."""
 
68
        if (hasattr(obj, 'get_permissions') and
 
69
            len(obj.get_permissions(self.root.user, config)) == 0):
 
70
            # Indicate the forbidden object if this is an admin.
 
71
            if self.root.user and self.root.user.admin:
 
72
                raise Unauthorized('Unauthorized: %s' % obj)
 
73
            else:
 
74
                raise Unauthorized()
 
75
 
 
76
 
 
77
def generate_publisher(view_plugins, root, publicmode=False):
53
78
    """
54
79
    Build a Mapper object for doing URL matching using 'routes', based on the
55
80
    given plugin registry.
56
81
    """
57
 
    m = routes.Mapper(explicit=True)
 
82
    r = ObjectPermissionCheckingPublisher(root=root)
 
83
 
 
84
    r.add_set_switch('api', 'api')
 
85
 
 
86
    if publicmode:
 
87
        view_attr = 'public_views'
 
88
        forward_route_attr = 'public_forward_routes'
 
89
        reverse_route_attr = 'public_reverse_routes'
 
90
    else:
 
91
        view_attr = 'views'
 
92
        forward_route_attr = 'forward_routes'
 
93
        reverse_route_attr = 'reverse_routes'
 
94
 
 
95
 
58
96
    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
 
97
        if hasattr(plugin, forward_route_attr):
 
98
            for fr in getattr(plugin, forward_route_attr):
 
99
                # An annotated function can also be passed in directly.
 
100
                if hasattr(fr, '_forward_route_meta'):
 
101
                    r.add_forward_func(fr)
 
102
                else:
 
103
                    r.add_forward(*fr)
 
104
 
 
105
        if hasattr(plugin, reverse_route_attr):
 
106
            for rr in getattr(plugin, reverse_route_attr):
 
107
                # An annotated function can also be passed in directly.
 
108
                if hasattr(rr, '_reverse_route_src'):
 
109
                    r.add_reverse_func(rr)
 
110
                else:
 
111
                    r.add_reverse(*rr)
 
112
 
 
113
        if hasattr(plugin, view_attr):
 
114
            for v in getattr(plugin, view_attr):
 
115
                r.add_view(*v)
 
116
 
 
117
    return r
67
118
 
68
119
def handler(apachereq):
69
120
    """Handles an HTTP request.
75
126
    # Make the request object into an IVLE request which can be given to views
76
127
    req = Request(apachereq, config)
77
128
 
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']
 
129
    req.publisher = generate_publisher(
 
130
        config.plugin_index[ViewPlugin], ApplicationRoot(req),
 
131
        publicmode=req.publicmode)
 
132
 
 
133
    try:
 
134
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
100
135
        try:
 
136
            # We 404 if we have a subpath but the view forbids it.
 
137
            if not viewcls.subpath_allowed and subpath:
 
138
                raise NotFound()
 
139
 
101
140
            # Instantiate the view, which should be a BaseView class
102
 
            view = viewcls(req, **kwargs)
 
141
            view = viewcls(req, obj, subpath)
103
142
 
104
143
            # Check that the request (mainly the user) is permitted to access
105
144
            # the view.
106
145
            if not view.authorize(req):
107
 
                raise Unauthorized()
 
146
                # Indicate the forbidden object if this is an admin.
 
147
                if req.user and req.user.admin:
 
148
                    raise Unauthorized('Unauthorized: %s' % view)
 
149
                else:
 
150
                    raise Unauthorized()
 
151
 
 
152
            # Non-GET requests from other sites leave us vulnerable to
 
153
            # CSRFs. Block them.
 
154
            referer = req.headers_in.get('Referer')
 
155
            if (referer is None or
 
156
                urlparse.urlparse(req.headers_in.get('Referer')).netloc !=
 
157
                    req.hostname):
 
158
                if req.method != 'GET' and not view.offsite_posts_allowed:
 
159
                    raise BadRequest(
 
160
                        "Non-GET requests from external sites are forbidden "
 
161
                        "for security reasons.")
 
162
 
108
163
            # Render the output
109
164
            view.render(req)
110
165
        except HTTPError, e:
118
173
                errviewcls = XHTMLView.get_error_view(e)
119
174
 
120
175
            if errviewcls:
121
 
                errview = errviewcls(req, e)
 
176
                errview = errviewcls(req, e, obj)
122
177
                errview.render(req)
123
178
                return req.OK
124
179
            elif e.message:
136
191
            handle_unknown_exception(req, *sys.exc_info())
137
192
            return req.OK
138
193
        else:
139
 
            req.store.commit()
 
194
            # Commit the transaction if we have a store open.
 
195
            req.commit()
140
196
            return req.OK
141
 
    else:
142
 
        XHTMLErrorView(req, NotFound()).render(req)
143
 
        return req.OK
 
197
    except Unauthorized, e:
 
198
        # Resolution failed due to a permission check. Display a pretty
 
199
        # error, or maybe a login page.
 
200
        XHTMLView.get_error_view(e)(req, e, req.publisher.root).render(req)
 
201
        return req.OK
 
202
    except PublishingError, e:
 
203
        req.status = 404
 
204
 
 
205
        if req.user and req.user.admin:
 
206
            XHTMLErrorView(req, NotFound('Not found: ' +
 
207
                                         str(e.args)), e[0]).render(req)
 
208
        else:
 
209
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
 
210
 
 
211
        return req.OK
 
212
    finally:
 
213
        # Make sure we close the store.
 
214
        req.cleanup()
144
215
 
145
216
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
146
217
    """
155
226
    req.content_type = "text/html"
156
227
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
157
228
    logfail = False
158
 
    try:
159
 
        httpcode = exc_value.httpcode
160
 
        req.status = httpcode
161
 
    except AttributeError:
162
 
        httpcode = None
163
 
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
229
 
 
230
    req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
231
 
164
232
    try:
165
233
        publicmode = req.publicmode
166
234
    except AttributeError:
189
257
    # misbehaves (which is currently very easy, if things aren't set up
190
258
    # correctly).
191
259
    # Write the traceback.
192
 
    # If this is a non-4xx IVLEError, get the message and httpcode and
193
 
    # make the error message a bit nicer (but still include the
194
 
    # traceback).
195
 
    # We also need to special-case IVLEJailError, as we can get another
 
260
 
 
261
    # We need to special-case IVLEJailError, as we can get another
196
262
    # almost-exception out of it.
197
 
 
198
 
    codename, msg = None, None
199
 
 
200
263
    if exc_type is util.IVLEJailError:
201
 
        msg = exc_value.type_str + ": " + exc_value.message
202
264
        tb = 'Exception information extracted from IVLEJailError:\n'
203
265
        tb += urllib.unquote(exc_value.info)
204
266
    else:
205
 
        try:
206
 
            codename, msg = req.get_http_codename(httpcode)
207
 
        except AttributeError:
208
 
            pass
209
 
 
210
267
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
211
268
                                                exc_traceback))
212
269
 
213
 
    logging.error('%s\n%s'%(str(msg), tb))
 
270
    logging.error('\n' + tb)
214
271
 
215
272
    # Error messages are only displayed is the user is NOT a student,
216
273
    # or if there has been a problem logging the error message
220
277
<html xmlns="http://www.w3.org/1999/xhtml">
221
278
<head><title>IVLE Internal Server Error</title></head>
222
279
<body>
223
 
<h1>IVLE Internal Server Error""")
224
 
    if show_errors:
225
 
        if codename is not None and \
226
 
           httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR:
227
 
            req.write(": %s" % cgi.escape(codename))
228
 
 
229
 
    req.write("""</h1>
 
280
<h1>IVLE Internal Server Error</h1>
230
281
<p>An error has occured which is the fault of the IVLE developers or
231
282
administrators. """)
232
283
 
238
289
    req.write("</p>")
239
290
 
240
291
    if show_errors:
241
 
        if msg is not None:
242
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
243
 
        if httpcode is not None:
244
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
245
292
        req.write("<h2>Debugging information</h2>")
246
 
 
247
293
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
248
294
    req.write("</body></html>")