← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/dispatch/__init__.py

Modified the database so that exercises are now stored in the database, rather
than in flat files.

This also necessitated adding new tables and storm classes for test suites
and test cases.

Note that this commit merely changes the database and adds a script to
upload exercises. The code for actually reading exercises has yet
to be changed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
22
22
Apache send all requests to be handled by the module 'dispatch'.
23
23
 
24
24
Top-level handler. Handles all requests to all pages in IVLE.
25
 
Handles authentication and delegates to views for authorization,
26
 
then passes the request along to the appropriate view.
 
25
Handles authentication (not authorization).
 
26
Then passes the request along to the appropriate ivle app.
27
27
"""
28
28
 
29
29
import sys
35
35
import logging
36
36
import socket
37
37
import time
 
38
import inspect
38
39
 
39
40
import mod_python
 
41
import routes
40
42
 
41
43
from ivle import util
42
 
import ivle.config
 
44
import ivle.conf
 
45
import ivle.conf.apps
43
46
from ivle.dispatch.request import Request
44
 
import ivle.webapp.security
45
 
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
46
 
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
47
 
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
48
 
from ivle.webapp.urls import Router, RoutingError
49
 
from ivle.webapp import ApplicationRoot
50
 
 
51
 
config = ivle.config.Config()
52
 
 
53
 
def generate_router(view_plugins, root):
 
47
from ivle.dispatch import login
 
48
from ivle.webapp.base.plugins import ViewPlugin
 
49
from ivle.webapp.errors import HTTPError, Unauthorized
 
50
import apps
 
51
import html
 
52
 
 
53
# XXX List of plugins, which will eventually be read in from conf
 
54
plugins_HACK = [
 
55
    'ivle.webapp.core#Plugin',
 
56
    'ivle.webapp.admin.user#Plugin',
 
57
    'ivle.webapp.tutorial#Plugin',
 
58
    'ivle.webapp.admin.subject#Plugin',
 
59
    'ivle.webapp.filesystem.browser#Plugin',
 
60
    'ivle.webapp.filesystem.diff#Plugin',
 
61
    'ivle.webapp.filesystem.svnlog#Plugin',
 
62
    'ivle.webapp.groups#Plugin',
 
63
    'ivle.webapp.console#Plugin',
 
64
    'ivle.webapp.security#Plugin',
 
65
    'ivle.webapp.media#Plugin',
 
66
    'ivle.webapp.forum#Plugin',
 
67
    'ivle.webapp.help#Plugin',
 
68
    'ivle.webapp.tos#Plugin',
 
69
] 
 
70
 
 
71
def generate_route_mapper(view_plugins):
54
72
    """
55
73
    Build a Mapper object for doing URL matching using 'routes', based on the
56
74
    given plugin registry.
57
75
    """
58
 
    r = Router(root=root)
59
 
 
60
 
    r.add_set_switch('api', 'api')
61
 
 
 
76
    m = routes.Mapper(explicit=True)
62
77
    for plugin in view_plugins:
63
 
        if hasattr(plugin, 'forward_routes'):
64
 
            for fr in plugin.forward_routes:
65
 
                r.add_forward(*fr)
66
 
 
67
 
        if hasattr(plugin, 'views'):
68
 
            for v in plugin.views:
69
 
                r.add_view(*v)
70
 
 
71
 
    return r
72
 
 
73
 
def handler(apachereq):
74
 
    """Handles an HTTP request.
75
 
 
 
78
        # Establish a URL pattern for each element of plugin.urls
 
79
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
 
80
        for url in plugin.urls:
 
81
            routex = url[0]
 
82
            view_class = url[1]
 
83
            kwargs_dict = url[2] if len(url) >= 3 else {}
 
84
            m.connect(routex, view=view_class, **kwargs_dict)
 
85
    return m
 
86
 
 
87
def get_plugin(pluginstr):
 
88
    plugin_path, classname = pluginstr.split('#')
 
89
    # Load the plugin module from somewhere in the Python path
 
90
    # (Note that plugin_path is a fully-qualified Python module name).
 
91
    return (plugin_path,
 
92
            getattr(__import__(plugin_path, fromlist=[classname]), classname))
 
93
 
 
94
def handler(req):
 
95
    """Handles a request which may be to anywhere in the site except media.
76
96
    Intended to be called by mod_python, as a handler.
77
97
 
78
 
    @param apachereq: An Apache request object.
79
 
    """
80
 
    # Make the request object into an IVLE request which can be given to views
81
 
    req = Request(apachereq, config)
82
 
 
 
98
    req: An Apache request object.
 
99
    """
 
100
    # Make the request object into an IVLE request which can be passed to apps
 
101
    apachereq = req
 
102
    try:
 
103
        req = Request(req, html.write_html_head)
 
104
    except Exception:
 
105
        # Pass the apachereq to error reporter, since ivle req isn't created
 
106
        # yet.
 
107
        handle_unknown_exception(apachereq, *sys.exc_info())
 
108
        # Tell Apache not to generate its own errors as well
 
109
        return mod_python.apache.OK
 
110
 
 
111
    # Run the main handler, and catch all exceptions
 
112
    try:
 
113
        return handler_(req, apachereq)
 
114
    except mod_python.apache.SERVER_RETURN:
 
115
        # An apache error. We discourage these, but they might still happen.
 
116
        # Just raise up.
 
117
        raise
 
118
    except Exception:
 
119
        handle_unknown_exception(req, *sys.exc_info())
 
120
        # Tell Apache not to generate its own errors as well
 
121
        return mod_python.apache.OK
 
122
 
 
123
def handler_(req, apachereq):
 
124
    """
 
125
    Nested handler function. May raise exceptions. The top-level handler is
 
126
    just used to catch exceptions.
 
127
    Takes both an IVLE request and an Apache req.
 
128
    """
83
129
    # Hack? Try and get the user login early just in case we throw an error
84
130
    # (most likely 404) to stop us seeing not logged in even when we are.
85
131
    if not req.publicmode:
86
 
        user = ivle.webapp.security.get_user_details(req)
87
 
 
88
 
        # Don't set the user if it is disabled or hasn't accepted the ToS.
89
 
        if user and user.valid:
90
 
            req.user = user
91
 
 
92
 
    if req.publicmode:
93
 
        raise NotImplementedError("no public mode with obtrav yet!")
94
 
 
95
 
    req.router = generate_router(config.plugin_index[ViewPlugin],
96
 
                                 ApplicationRoot(req.config, req.store))
97
 
 
98
 
    try:
99
 
        obj, viewcls, subpath = req.router.resolve(req.uri.decode('utf-8'))
 
132
        req.user = login.get_user_details(req)
 
133
 
 
134
    ### BEGIN New plugins framework ###
 
135
    # XXX This should be done ONCE per Python process, not per request.
 
136
    # (Wait till WSGI)
 
137
    # XXX No authentication is done here
 
138
    req.plugins = dict([get_plugin(pluginstr) for pluginstr in plugins_HACK])
 
139
    # Index the plugins by base class
 
140
    req.plugin_index = {}
 
141
    for plugin in req.plugins.values():
 
142
        # Getmro returns a tuple of all the super-classes of the plugin
 
143
        for base in inspect.getmro(plugin):
 
144
            if base not in req.plugin_index:
 
145
                req.plugin_index[base] = []
 
146
            req.plugin_index[base].append(plugin)
 
147
    req.reverse_plugins = dict([(v, k) for (k, v) in req.plugins.items()])
 
148
    req.mapper = generate_route_mapper(req.plugin_index[ViewPlugin])
 
149
 
 
150
    matchdict = req.mapper.match(req.uri)
 
151
    if matchdict is not None:
 
152
        viewcls = matchdict['view']
 
153
        # Get the remaining arguments, less 'view', 'action' and 'controller'
 
154
        # (The latter two seem to be built-in, and we don't want them).
 
155
        kwargs = matchdict.copy()
 
156
        del kwargs['view']
100
157
        try:
101
158
            # Instantiate the view, which should be a BaseView class
102
 
            view = viewcls(req, obj)
 
159
            view = viewcls(req, **kwargs)
103
160
 
104
161
            # Check that the request (mainly the user) is permitted to access
105
162
            # the view.
115
172
            if hasattr(viewcls, 'get_error_view'):
116
173
                errviewcls = viewcls.get_error_view(e)
117
174
            else:
118
 
                errviewcls = XHTMLView.get_error_view(e)
 
175
                errviewcls = None
119
176
 
120
177
            if errviewcls:
121
178
                errview = errviewcls(req, e)
122
179
                errview.render(req)
123
180
                return req.OK
124
 
            elif e.message:
 
181
            else:
125
182
                req.write(e.message)
126
 
                return req.OK
127
 
            else:
128
183
                return e.code
129
 
        except mod_python.apache.SERVER_RETURN:
130
 
            # A mod_python-specific Apache error.
131
 
            # XXX: We need to raise these because req.throw_error() uses them.
132
 
            # Remove this after Google Code issue 117 is fixed.
133
 
            raise
134
184
        except Exception, e:
135
185
            # A non-HTTPError appeared. We have an unknown exception. Panic.
136
186
            handle_unknown_exception(req, *sys.exc_info())
138
188
        else:
139
189
            req.store.commit()
140
190
            return req.OK
141
 
    except RoutingError, e:
142
 
        if req.user.admin:
143
 
            XHTMLErrorView(req, NotFound('Not found: ' +
144
 
                                         str(e.args))).render(req)
145
 
        else:
146
 
            XHTMLErrorView(req, NotFound()).render(req)
147
 
 
 
191
    ### END New plugins framework ###
 
192
 
 
193
    # Check req.app to see if it is valid. 404 if not.
 
194
    if req.app is not None and req.app not in ivle.conf.apps.app_url:
 
195
        req.throw_error(Request.HTTP_NOT_FOUND,
 
196
            "There is no application called %s." % repr(req.app))
 
197
 
 
198
    # Special handling for public mode - only allow the public app, call it
 
199
    # and get out.
 
200
    # NOTE: This will not behave correctly if the public app uses
 
201
    # write_html_head_foot, but "serve" does not.
 
202
    if req.publicmode:
 
203
        if req.app != ivle.conf.apps.public_app:
 
204
            req.throw_error(Request.HTTP_FORBIDDEN,
 
205
                "This application is not available on the public site.")
 
206
        app = ivle.conf.apps.app_url[ivle.conf.apps.public_app]
 
207
        apps.call_app(app.dir, req)
148
208
        return req.OK
149
209
 
 
210
    # app is the App object for the chosen app
 
211
    if req.app is None:
 
212
        app = ivle.conf.apps.app_url[ivle.conf.apps.default_app]
 
213
    else:
 
214
        app = ivle.conf.apps.app_url[req.app]
 
215
 
 
216
    # Check if app requires auth. If so, perform authentication and login.
 
217
    # This will either return a User object, None, or perform a redirect
 
218
    # which we will not catch here.
 
219
    if app.requireauth:
 
220
        req.user = login.login(req)
 
221
        logged_in = req.user is not None
 
222
    else:
 
223
        req.user = login.get_user_details(req)
 
224
        logged_in = True
 
225
 
 
226
    if logged_in:
 
227
        # Keep the user's session alive by writing to the session object.
 
228
        # req.get_session().save()
 
229
        # Well, it's a fine idea, but it creates considerable grief in the
 
230
        # concurrent update department, so instead, we'll just make the
 
231
        # sessions not time out.
 
232
        req.get_session().unlock()
 
233
 
 
234
        # If user did not specify an app, HTTP redirect to default app and
 
235
        # exit.
 
236
        if req.app is None:
 
237
            req.throw_redirect(util.make_path(ivle.conf.apps.default_app))
 
238
 
 
239
        # Set the default title to the app's tab name, if any. Otherwise URL
 
240
        # name.
 
241
        if app.name is not None:
 
242
            req.title = app.name
 
243
        else:
 
244
            req.title = req.app
 
245
 
 
246
        # Call the specified app with the request object
 
247
        apps.call_app(app.dir, req)
 
248
 
 
249
    # if not logged in, login.login will have written the login box.
 
250
    # Just clean up and exit.
 
251
 
 
252
    # MAKE SURE we write the HTTP (and possibly HTML) header. This
 
253
    # wouldn't happen if nothing else ever got written, so we have to make
 
254
    # sure.
 
255
    req.ensure_headers_written()
 
256
 
 
257
    # When done, write out the HTML footer if the app has requested it
 
258
    if req.write_html_head_foot:
 
259
        html.write_html_foot(req)
 
260
 
 
261
    # Note: Apache will not write custom HTML error messages here.
 
262
    # Use req.throw_error to do that.
 
263
    return req.OK
 
264
 
150
265
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
151
266
    """
152
267
    Given an exception that has just been thrown from IVLE, print its details
154
269
    This is a full handler. It assumes nothing has been written, and writes a
155
270
    complete HTML page.
156
271
    req: May be EITHER an IVLE req or an Apache req.
157
 
    The handler code may pass an apache req if an exception occurs before
 
272
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
 
273
    the handler code may pass an apache req if an exception occurs before
158
274
    the IVLE request is created.
159
275
    """
160
276
    req.content_type = "text/html"
161
 
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
 
277
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
162
278
    logfail = False
163
 
 
164
 
    # XXX: This remains here for ivle.interpret's IVLEErrors. Once we rewrite
165
 
    #      fileservice, req.status should always be 500 (ISE) here.
 
279
    # For some reason, some versions of mod_python have "_server" instead of
 
280
    # "main_server". So we check for both.
 
281
    try:
 
282
        admin_email = mod_python.apache.main_server.server_admin
 
283
    except AttributeError:
 
284
        try:
 
285
            admin_email = mod_python.apache._server.server_admin
 
286
        except AttributeError:
 
287
            admin_email = ""
166
288
    try:
167
289
        httpcode = exc_value.httpcode
168
290
        req.status = httpcode
169
291
    except AttributeError:
170
292
        httpcode = None
171
293
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
172
 
 
173
294
    try:
174
295
        publicmode = req.publicmode
175
296
    except AttributeError:
178
299
        login = req.user.login
179
300
    except AttributeError:
180
301
        login = None
 
302
    try:
 
303
        role = req.user.role
 
304
    except AttributeError:
 
305
        role = None
181
306
 
182
307
    # Log File
183
308
    try:
193
318
            filemode='a')
194
319
    except IOError:
195
320
        logfail = True
196
 
 
197
 
    # A "bad" error message. We shouldn't get here unless IVLE
198
 
    # misbehaves (which is currently very easy, if things aren't set up
199
 
    # correctly).
200
 
    # Write the traceback.
201
 
 
202
 
    # We need to special-case IVLEJailError, as we can get another
203
 
    # almost-exception out of it.
204
 
    if exc_type is util.IVLEJailError:
205
 
        tb = 'Exception information extracted from IVLEJailError:\n'
206
 
        tb += urllib.unquote(exc_value.info)
 
321
    logging.debug('Logging Unhandled Exception')
 
322
 
 
323
    # We handle 3 types of error.
 
324
    # IVLEErrors with 4xx response codes (client error).
 
325
    # IVLEErrors with 5xx response codes (handled server error).
 
326
    # Other exceptions (unhandled server error).
 
327
    # IVLEErrors should not have other response codes than 4xx or 5xx
 
328
    # (eg. throw_redirect should have been used for 3xx codes).
 
329
    # Therefore, that is treated as an unhandled error.
 
330
 
 
331
    if (exc_type == util.IVLEError and httpcode >= 400
 
332
        and httpcode <= 499):
 
333
        # IVLEErrors with 4xx response codes are client errors.
 
334
        # Therefore, these have a "nice" response (we even coat it in the IVLE
 
335
        # HTML wrappers).
 
336
        
 
337
        req.write_html_head_foot = True
 
338
        req.write_javascript_settings = False
 
339
        req.write('<div id="ivle_padding">\n')
 
340
        try:
 
341
            codename, msg = req.get_http_codename(httpcode)
 
342
        except AttributeError:
 
343
            codename, msg = None, None
 
344
        # Override the default message with the supplied one,
 
345
        # if available.
 
346
        if exc_value.message is not None:
 
347
            msg = exc_value.message
 
348
        if codename is not None:
 
349
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
 
350
        else:
 
351
            req.write("<h1>Error</h1>\n")
 
352
        if msg is not None:
 
353
            req.write("<p>%s</p>\n" % cgi.escape(msg))
 
354
        else:
 
355
            req.write("<p>An unknown error occured.</p>\n")
 
356
        
 
357
        # Logging
 
358
        logging.info(str(msg))
 
359
        
 
360
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
361
        if logfail:
 
362
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
363
                %cgi.escape(logfile))
 
364
        req.write('</div>\n')
 
365
        html.write_html_foot(req)
207
366
    else:
208
 
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
209
 
                                                exc_traceback))
210
 
 
211
 
    logging.error('\n' + tb)
212
 
 
213
 
    # Error messages are only displayed is the user is NOT a student,
214
 
    # or if there has been a problem logging the error message
215
 
    show_errors = (not publicmode) and ((login and req.user.admin) or logfail)
216
 
    req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
 
367
        # A "bad" error message. We shouldn't get here unless IVLE
 
368
        # misbehaves (which is currently very easy, if things aren't set up
 
369
        # correctly).
 
370
        # Write the traceback.
 
371
        # If this is a non-4xx IVLEError, get the message and httpcode and
 
372
        # make the error message a bit nicer (but still include the
 
373
        # traceback).
 
374
        # We also need to special-case IVLEJailError, as we can get another
 
375
        # almost-exception out of it.
 
376
 
 
377
        codename, msg = None, None
 
378
 
 
379
        if exc_type is util.IVLEJailError:
 
380
            msg = exc_value.type_str + ": " + exc_value.message
 
381
            tb = 'Exception information extracted from IVLEJailError:\n'
 
382
            tb += urllib.unquote(exc_value.info)
 
383
        else:
 
384
            try:
 
385
                codename, msg = req.get_http_codename(httpcode)
 
386
            except AttributeError:
 
387
                pass
 
388
            # Override the default message with the supplied one,
 
389
            # if available.
 
390
            if hasattr(exc_value, 'message') and exc_value.message is not None:
 
391
                msg = exc_value.message
 
392
                # Prepend the exception type
 
393
                if exc_type != util.IVLEError:
 
394
                    msg = exc_type.__name__ + ": " + msg
 
395
 
 
396
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
 
397
                                                    exc_traceback))
 
398
 
 
399
        # Logging
 
400
        logging.error('%s\n%s'%(str(msg), tb))
 
401
        # Error messages are only displayed is the user is NOT a student,
 
402
        # or if there has been a problem logging the error message
 
403
        show_errors = (not publicmode) and ((login and \
 
404
                            str(role) != "student") or logfail)
 
405
        req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
217
406
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
218
407
<html xmlns="http://www.w3.org/1999/xhtml">
219
408
<head><title>IVLE Internal Server Error</title></head>
220
409
<body>
221
 
<h1>IVLE Internal Server Error</h1>
 
410
<h1>IVLE Internal Server Error""")
 
411
        if (show_errors):
 
412
            if (codename is not None
 
413
                        and httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR):
 
414
                req.write(": %s" % cgi.escape(codename))
 
415
        
 
416
        req.write("""</h1>
222
417
<p>An error has occured which is the fault of the IVLE developers or
223
 
administrators. """)
224
 
 
225
 
    if logfail:
226
 
        req.write("Please report this issue to the server administrators, "
227
 
                  "along with the following information.")
228
 
    else:
229
 
        req.write("Details have been logged for further examination.")
230
 
    req.write("</p>")
231
 
 
232
 
    if show_errors:
233
 
        req.write("<h2>Debugging information</h2>")
234
 
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
235
 
    req.write("</body></html>")
 
418
administration. The developers have been notified.</p>
 
419
""")
 
420
        if (show_errors):
 
421
            if msg is not None:
 
422
                req.write("<p>%s</p>\n" % cgi.escape(msg))
 
423
            if httpcode is not None:
 
424
                req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
425
            req.write("""
 
426
    <p>Please report this to <a href="mailto:%s">%s</a> (the system
 
427
    administrator). Include the following information:</p>
 
428
    """ % (cgi.escape(admin_email), cgi.escape(admin_email)))
 
429
 
 
430
            req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
 
431
            if logfail:
 
432
                req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
433
                    %cgi.escape(logfile))
 
434
        req.write("</body></html>")