← 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: 2009-03-17 04:48:07 UTC
  • mfrom: (1099.1.243 exercise-ui)
  • Revision ID: grantw@unimelb.edu.au-20090317044807-pozdt54fapazp2sp
Merge lp:~ivle-dev/ivle/exercise-ui.

Lecturers can now add and edit exercises, and worksheets can be written
in RST directly inside IVLE.

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
34
33
import cgi
35
34
import traceback
36
35
import logging
38
37
import time
39
38
 
40
39
import mod_python
 
40
import routes
41
41
 
42
42
from ivle import util
43
 
import ivle.config
 
43
import ivle.conf
44
44
from ivle.dispatch.request import Request
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 BadRequest, HTTPError, NotFound, Unauthorized
49
 
from ivle.webapp.publisher import Publisher, PublishingError
50
 
from ivle.webapp import ApplicationRoot
51
 
 
52
 
config = ivle.config.Config()
53
 
 
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):
 
48
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
 
49
 
 
50
def generate_route_mapper(view_plugins, attr):
78
51
    """
79
52
    Build a Mapper object for doing URL matching using 'routes', based on the
80
53
    given plugin registry.
81
54
    """
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
 
 
 
55
    m = routes.Mapper(explicit=True)
96
56
    for plugin in view_plugins:
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
 
57
        # Establish a URL pattern for each element of plugin.urls
 
58
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
 
59
        for url in getattr(plugin, attr):
 
60
            routex = url[0]
 
61
            view_class = url[1]
 
62
            kwargs_dict = url[2] if len(url) >= 3 else {}
 
63
            m.connect(routex, view=view_class, **kwargs_dict)
 
64
    return m
118
65
 
119
66
def handler(apachereq):
120
67
    """Handles an HTTP request.
124
71
    @param apachereq: An Apache request object.
125
72
    """
126
73
    # Make the request object into an IVLE request which can be given to views
127
 
    req = Request(apachereq, config)
 
74
    req = Request(apachereq)
128
75
 
129
76
    # Hack? Try and get the user login early just in case we throw an error
130
77
    # (most likely 404) to stop us seeing not logged in even when we are.
135
82
        if user and user.valid:
136
83
            req.user = user
137
84
 
138
 
    req.publisher = generate_publisher(
139
 
        config.plugin_index[ViewPlugin],
140
 
        ApplicationRoot(req.config, req.store, req.user),
141
 
        publicmode=req.publicmode)
142
 
 
143
 
    try:
144
 
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
 
85
    conf = ivle.config.Config()
 
86
    req.config = conf
 
87
 
 
88
    if req.publicmode:
 
89
        req.mapper = generate_route_mapper(conf.plugin_index[PublicViewPlugin],
 
90
                                           'public_urls')
 
91
    else:
 
92
        req.mapper = generate_route_mapper(conf.plugin_index[ViewPlugin],
 
93
                                           'urls')
 
94
 
 
95
    matchdict = req.mapper.match(req.uri)
 
96
    if matchdict is not None:
 
97
        viewcls = matchdict['view']
 
98
        # Get the remaining arguments, less 'view', 'action' and 'controller'
 
99
        # (The latter two seem to be built-in, and we don't want them).
 
100
        kwargs = matchdict.copy()
 
101
        del kwargs['view']
145
102
        try:
146
 
            # We 404 if we have a subpath but the view forbids it.
147
 
            if not viewcls.subpath_allowed and subpath:
148
 
                raise NotFound()
149
 
 
150
103
            # Instantiate the view, which should be a BaseView class
151
 
            view = viewcls(req, obj, subpath)
 
104
            view = viewcls(req, **kwargs)
152
105
 
153
106
            # Check that the request (mainly the user) is permitted to access
154
107
            # the view.
155
108
            if not view.authorize(req):
156
 
                # Indicate the forbidden object if this is an admin.
157
 
                if req.user and req.user.admin:
158
 
                    raise Unauthorized('Unauthorized: %s' % view)
159
 
                else:
160
 
                    raise Unauthorized()
161
 
 
162
 
            # Non-GET requests from other sites leave us vulnerable to
163
 
            # CSRFs. Block them.
164
 
            referer = req.headers_in.get('Referer')
165
 
            if (referer is None or
166
 
                urlparse.urlparse(req.headers_in.get('Referer')).netloc !=
167
 
                    req.hostname):
168
 
                if req.method != 'GET' and not view.offsite_posts_allowed:
169
 
                    raise BadRequest(
170
 
                        "Non-GET requests from external sites are forbidden "
171
 
                        "for security reasons.")
172
 
 
 
109
                raise Unauthorized()
173
110
            # Render the output
174
111
            view.render(req)
175
112
        except HTTPError, e:
183
120
                errviewcls = XHTMLView.get_error_view(e)
184
121
 
185
122
            if errviewcls:
186
 
                errview = errviewcls(req, e, obj)
 
123
                errview = errviewcls(req, e)
187
124
                errview.render(req)
188
125
                return req.OK
189
126
            elif e.message:
203
140
        else:
204
141
            req.store.commit()
205
142
            return req.OK
206
 
    except Unauthorized, e:
207
 
        # Resolution failed due to a permission check. Display a pretty
208
 
        # error, or maybe a login page.
209
 
        XHTMLView.get_error_view(e)(req, e, req.publisher.root).render(req)
210
 
        return req.OK
211
 
    except PublishingError, e:
212
 
        req.status = 404
213
 
 
214
 
        if req.user and req.user.admin:
215
 
            XHTMLErrorView(req, NotFound('Not found: ' +
216
 
                                         str(e.args)), e[0]).render(req)
217
 
        else:
218
 
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
219
 
 
220
 
        return req.OK
221
 
    finally:
222
 
        req.store.close()
 
143
    else:
 
144
        XHTMLErrorView(req, NotFound()).render(req)
 
145
        return req.OK
223
146
 
224
147
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
225
148
    """
232
155
    the IVLE request is created.
233
156
    """
234
157
    req.content_type = "text/html"
235
 
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
 
158
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
236
159
    logfail = False
237
 
 
238
 
    # XXX: This remains here for ivle.interpret's IVLEErrors. Once we rewrite
239
 
    #      fileservice, req.status should always be 500 (ISE) here.
240
160
    try:
241
161
        httpcode = exc_value.httpcode
242
162
        req.status = httpcode
243
163
    except AttributeError:
244
164
        httpcode = None
245
165
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
246
 
 
247
166
    try:
248
167
        publicmode = req.publicmode
249
168
    except AttributeError:
272
191
    # misbehaves (which is currently very easy, if things aren't set up
273
192
    # correctly).
274
193
    # Write the traceback.
275
 
 
276
 
    # We need to special-case IVLEJailError, as we can get another
 
194
    # If this is a non-4xx IVLEError, get the message and httpcode and
 
195
    # make the error message a bit nicer (but still include the
 
196
    # traceback).
 
197
    # We also need to special-case IVLEJailError, as we can get another
277
198
    # almost-exception out of it.
 
199
 
 
200
    codename, msg = None, None
 
201
 
278
202
    if exc_type is util.IVLEJailError:
 
203
        msg = exc_value.type_str + ": " + exc_value.message
279
204
        tb = 'Exception information extracted from IVLEJailError:\n'
280
205
        tb += urllib.unquote(exc_value.info)
281
206
    else:
 
207
        try:
 
208
            codename, msg = req.get_http_codename(httpcode)
 
209
        except AttributeError:
 
210
            pass
 
211
 
282
212
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
283
213
                                                exc_traceback))
284
214
 
285
 
    logging.error('\n' + tb)
 
215
    logging.error('%s\n%s'%(str(msg), tb))
286
216
 
287
217
    # Error messages are only displayed is the user is NOT a student,
288
218
    # or if there has been a problem logging the error message
292
222
<html xmlns="http://www.w3.org/1999/xhtml">
293
223
<head><title>IVLE Internal Server Error</title></head>
294
224
<body>
295
 
<h1>IVLE Internal Server Error</h1>
 
225
<h1>IVLE Internal Server Error""")
 
226
    if show_errors:
 
227
        if codename is not None and \
 
228
           httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR:
 
229
            req.write(": %s" % cgi.escape(codename))
 
230
 
 
231
    req.write("""</h1>
296
232
<p>An error has occured which is the fault of the IVLE developers or
297
233
administrators. """)
298
234
 
304
240
    req.write("</p>")
305
241
 
306
242
    if show_errors:
 
243
        if msg is not None:
 
244
            req.write("<p>%s</p>\n" % cgi.escape(msg))
 
245
        if httpcode is not None:
 
246
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
307
247
        req.write("<h2>Debugging information</h2>")
 
248
 
308
249
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
309
250
    req.write("</body></html>")