← 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: Nick Chadwick
  • Date: 2009-02-19 05:47:56 UTC
  • mto: (1099.1.180 new-dispatch)
  • mto: This revision was merged to the branch mainline in revision 1100.
  • Revision ID: chadnickbok@gmail.com-20090219054756-v984vmc7kheiq6xy
Updated the tutorial service, to now allow users to edit worksheets
online.

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
40
41
import routes
41
42
 
42
43
from ivle import util
43
44
import ivle.conf
 
45
import ivle.conf.apps
44
46
from ivle.dispatch.request import Request
45
 
import ivle.webapp.security
 
47
from ivle.dispatch import login
46
48
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
47
 
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
48
 
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
 
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.filesystem.serve#Plugin',
 
63
    'ivle.webapp.groups#Plugin',
 
64
    'ivle.webapp.console#Plugin',
 
65
    'ivle.webapp.security#Plugin',
 
66
    'ivle.webapp.media#Plugin',
 
67
    'ivle.webapp.forum#Plugin',
 
68
    'ivle.webapp.help#Plugin',
 
69
    'ivle.webapp.tos#Plugin',
 
70
    'ivle.webapp.userservice#Plugin',
 
71
] 
49
72
 
50
73
def generate_route_mapper(view_plugins, attr):
51
74
    """
63
86
            m.connect(routex, view=view_class, **kwargs_dict)
64
87
    return m
65
88
 
66
 
def handler(apachereq):
67
 
    """Handles an HTTP request.
 
89
def get_plugin(pluginstr):
 
90
    plugin_path, classname = pluginstr.split('#')
 
91
    # Load the plugin module from somewhere in the Python path
 
92
    # (Note that plugin_path is a fully-qualified Python module name).
 
93
    return (plugin_path,
 
94
            getattr(__import__(plugin_path, fromlist=[classname]), classname))
68
95
 
 
96
def handler(req):
 
97
    """Handles a request which may be to anywhere in the site except media.
69
98
    Intended to be called by mod_python, as a handler.
70
99
 
71
 
    @param apachereq: An Apache request object.
72
 
    """
73
 
    # Make the request object into an IVLE request which can be given to views
74
 
    req = Request(apachereq)
75
 
 
 
100
    req: An Apache request object.
 
101
    """
 
102
    # Make the request object into an IVLE request which can be passed to apps
 
103
    apachereq = req
 
104
    try:
 
105
        req = Request(req, html.write_html_head)
 
106
    except Exception:
 
107
        # Pass the apachereq to error reporter, since ivle req isn't created
 
108
        # yet.
 
109
        handle_unknown_exception(apachereq, *sys.exc_info())
 
110
        # Tell Apache not to generate its own errors as well
 
111
        return mod_python.apache.OK
 
112
 
 
113
    # Run the main handler, and catch all exceptions
 
114
    try:
 
115
        return handler_(req, apachereq)
 
116
    except mod_python.apache.SERVER_RETURN:
 
117
        # An apache error. We discourage these, but they might still happen.
 
118
        # Just raise up.
 
119
        raise
 
120
    except Exception:
 
121
        handle_unknown_exception(req, *sys.exc_info())
 
122
        # Tell Apache not to generate its own errors as well
 
123
        return mod_python.apache.OK
 
124
 
 
125
def handler_(req, apachereq):
 
126
    """
 
127
    Nested handler function. May raise exceptions. The top-level handler is
 
128
    just used to catch exceptions.
 
129
    Takes both an IVLE request and an Apache req.
 
130
    """
76
131
    # Hack? Try and get the user login early just in case we throw an error
77
132
    # (most likely 404) to stop us seeing not logged in even when we are.
78
133
    if not req.publicmode:
79
 
        user = ivle.webapp.security.get_user_details(req)
 
134
        user = login.get_user_details(req)
80
135
 
81
136
        # Don't set the user if it is disabled or hasn't accepted the ToS.
82
137
        if user and user.valid:
83
138
            req.user = user
84
139
 
85
 
    conf = ivle.config.Config()
86
 
    req.config = conf
 
140
    ### BEGIN New plugins framework ###
 
141
    # XXX This should be done ONCE per Python process, not per request.
 
142
    # (Wait till WSGI)
 
143
    req.plugins = dict([get_plugin(pluginstr) for pluginstr in plugins_HACK])
 
144
    # Index the plugins by base class
 
145
    req.plugin_index = {}
 
146
    for plugin in req.plugins.values():
 
147
        # Getmro returns a tuple of all the super-classes of the plugin
 
148
        for base in inspect.getmro(plugin):
 
149
            if base not in req.plugin_index:
 
150
                req.plugin_index[base] = []
 
151
            req.plugin_index[base].append(plugin)
 
152
    req.reverse_plugins = dict([(v, k) for (k, v) in req.plugins.items()])
87
153
 
88
154
    if req.publicmode:
89
 
        req.mapper = generate_route_mapper(conf.plugin_index[PublicViewPlugin],
 
155
        req.mapper = generate_route_mapper(req.plugin_index[PublicViewPlugin],
90
156
                                           'public_urls')
91
157
    else:
92
 
        req.mapper = generate_route_mapper(conf.plugin_index[ViewPlugin],
 
158
        req.mapper = generate_route_mapper(req.plugin_index[ViewPlugin],
93
159
                                           'urls')
94
160
 
95
161
    matchdict = req.mapper.match(req.uri)
117
183
            if hasattr(viewcls, 'get_error_view'):
118
184
                errviewcls = viewcls.get_error_view(e)
119
185
            else:
120
 
                errviewcls = XHTMLView.get_error_view(e)
 
186
                errviewcls = None
121
187
 
122
188
            if errviewcls:
123
189
                errview = errviewcls(req, e)
136
202
            req.store.commit()
137
203
            return req.OK
138
204
    else:
139
 
        XHTMLErrorView(req, NotFound()).render(req)
140
 
        return req.OK
 
205
        # We had no matching URL! Check if it matches an old-style app. If
 
206
        # not, 404.
 
207
        if req.app not in ivle.conf.apps.app_url:
 
208
            return req.HTTP_NOT_FOUND # TODO: Prettify.
 
209
    ### END New plugins framework ###
 
210
 
 
211
 
 
212
    ### BEGIN legacy application framework ###
 
213
    # We have no public apps back here.
 
214
    assert not req.publicmode
 
215
 
 
216
    # app is the App object for the chosen app
 
217
    if req.app is None:
 
218
        app = ivle.conf.apps.app_url[ivle.conf.apps.default_app]
 
219
    else:
 
220
        app = ivle.conf.apps.app_url[req.app]
 
221
 
 
222
    # Check if app requires auth. If so, perform authentication and login.
 
223
    # This will either return a User object, None, or perform a redirect
 
224
    # which we will not catch here.
 
225
    if app.requireauth:
 
226
        logged_in = req.user is not None
 
227
    else:
 
228
        logged_in = True
 
229
 
 
230
    assert logged_in # XXX
 
231
 
 
232
    if logged_in:
 
233
        # Keep the user's session alive by writing to the session object.
 
234
        # req.get_session().save()
 
235
        # Well, it's a fine idea, but it creates considerable grief in the
 
236
        # concurrent update department, so instead, we'll just make the
 
237
        # sessions not time out.
 
238
        req.get_session().unlock()
 
239
 
 
240
        # Call the specified app with the request object
 
241
        apps.call_app(app.dir, req)
 
242
 
 
243
    # MAKE SURE we write the HTTP (and possibly HTML) header. This
 
244
    # wouldn't happen if nothing else ever got written, so we have to make
 
245
    # sure.
 
246
    req.ensure_headers_written()
 
247
 
 
248
    # When done, write out the HTML footer if the app has requested it
 
249
    if req.write_html_head_foot:
 
250
        html.write_html_foot(req)
 
251
 
 
252
    # Note: Apache will not write custom HTML error messages here.
 
253
    # Use req.throw_error to do that.
 
254
    return req.OK
141
255
 
142
256
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
143
257
    """
146
260
    This is a full handler. It assumes nothing has been written, and writes a
147
261
    complete HTML page.
148
262
    req: May be EITHER an IVLE req or an Apache req.
149
 
    The handler code may pass an apache req if an exception occurs before
 
263
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
 
264
    the handler code may pass an apache req if an exception occurs before
150
265
    the IVLE request is created.
151
266
    """
152
267
    req.content_type = "text/html"
153
268
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
154
269
    logfail = False
 
270
    # For some reason, some versions of mod_python have "_server" instead of
 
271
    # "main_server". So we check for both.
 
272
    try:
 
273
        admin_email = mod_python.apache.main_server.server_admin
 
274
    except AttributeError:
 
275
        try:
 
276
            admin_email = mod_python.apache._server.server_admin
 
277
        except AttributeError:
 
278
            admin_email = ""
155
279
    try:
156
280
        httpcode = exc_value.httpcode
157
281
        req.status = httpcode
185
309
            filemode='a')
186
310
    except IOError:
187
311
        logfail = True
188
 
 
189
 
    # A "bad" error message. We shouldn't get here unless IVLE
190
 
    # misbehaves (which is currently very easy, if things aren't set up
191
 
    # correctly).
192
 
    # Write the traceback.
193
 
    # If this is a non-4xx IVLEError, get the message and httpcode and
194
 
    # make the error message a bit nicer (but still include the
195
 
    # traceback).
196
 
    # We also need to special-case IVLEJailError, as we can get another
197
 
    # almost-exception out of it.
198
 
 
199
 
    codename, msg = None, None
200
 
 
201
 
    if exc_type is util.IVLEJailError:
202
 
        msg = exc_value.type_str + ": " + exc_value.message
203
 
        tb = 'Exception information extracted from IVLEJailError:\n'
204
 
        tb += urllib.unquote(exc_value.info)
205
 
    else:
 
312
    logging.debug('Logging Unhandled Exception')
 
313
 
 
314
    # We handle 3 types of error.
 
315
    # IVLEErrors with 4xx response codes (client error).
 
316
    # IVLEErrors with 5xx response codes (handled server error).
 
317
    # Other exceptions (unhandled server error).
 
318
    # IVLEErrors should not have other response codes than 4xx or 5xx
 
319
    # (eg. throw_redirect should have been used for 3xx codes).
 
320
    # Therefore, that is treated as an unhandled error.
 
321
 
 
322
    if (exc_type == util.IVLEError and httpcode >= 400
 
323
        and httpcode <= 499):
 
324
        # IVLEErrors with 4xx response codes are client errors.
 
325
        # Therefore, these have a "nice" response (we even coat it in the IVLE
 
326
        # HTML wrappers).
 
327
        
 
328
        req.write_html_head_foot = True
 
329
        req.write_javascript_settings = False
 
330
        req.write('<div id="ivle_padding">\n')
206
331
        try:
207
332
            codename, msg = req.get_http_codename(httpcode)
208
333
        except AttributeError:
209
 
            pass
210
 
 
211
 
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
212
 
                                                exc_traceback))
213
 
 
214
 
    logging.error('%s\n%s'%(str(msg), tb))
215
 
 
216
 
    # Error messages are only displayed is the user is NOT a student,
217
 
    # or if there has been a problem logging the error message
218
 
    show_errors = (not publicmode) and ((login and \
219
 
                        str(role) != "student") or logfail)
220
 
    req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
 
334
            codename, msg = None, None
 
335
        # Override the default message with the supplied one,
 
336
        # if available.
 
337
        if exc_value.message is not None:
 
338
            msg = exc_value.message
 
339
        if codename is not None:
 
340
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
 
341
        else:
 
342
            req.write("<h1>Error</h1>\n")
 
343
        if msg is not None:
 
344
            req.write("<p>%s</p>\n" % cgi.escape(msg))
 
345
        else:
 
346
            req.write("<p>An unknown error occured.</p>\n")
 
347
        
 
348
        # Logging
 
349
        logging.info(str(msg))
 
350
        
 
351
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
352
        if logfail:
 
353
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
354
                %cgi.escape(logfile))
 
355
        req.write('</div>\n')
 
356
        html.write_html_foot(req)
 
357
    else:
 
358
        # A "bad" error message. We shouldn't get here unless IVLE
 
359
        # misbehaves (which is currently very easy, if things aren't set up
 
360
        # correctly).
 
361
        # Write the traceback.
 
362
        # If this is a non-4xx IVLEError, get the message and httpcode and
 
363
        # make the error message a bit nicer (but still include the
 
364
        # traceback).
 
365
        # We also need to special-case IVLEJailError, as we can get another
 
366
        # almost-exception out of it.
 
367
 
 
368
        codename, msg = None, None
 
369
 
 
370
        if exc_type is util.IVLEJailError:
 
371
            msg = exc_value.type_str + ": " + exc_value.message
 
372
            tb = 'Exception information extracted from IVLEJailError:\n'
 
373
            tb += urllib.unquote(exc_value.info)
 
374
        else:
 
375
            try:
 
376
                codename, msg = req.get_http_codename(httpcode)
 
377
            except AttributeError:
 
378
                pass
 
379
            # Override the default message with the supplied one,
 
380
            # if available.
 
381
            if hasattr(exc_value, 'message') and exc_value.message is not None:
 
382
                msg = exc_value.message
 
383
                # Prepend the exception type
 
384
                if exc_type != util.IVLEError:
 
385
                    msg = exc_type.__name__ + ": " + msg
 
386
 
 
387
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
 
388
                                                    exc_traceback))
 
389
 
 
390
        # Logging
 
391
        logging.error('%s\n%s'%(str(msg), tb))
 
392
        # Error messages are only displayed is the user is NOT a student,
 
393
        # or if there has been a problem logging the error message
 
394
        show_errors = (not publicmode) and ((login and \
 
395
                            str(role) != "student") or logfail)
 
396
        req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
221
397
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
222
398
<html xmlns="http://www.w3.org/1999/xhtml">
223
399
<head><title>IVLE Internal Server Error</title></head>
224
400
<body>
225
401
<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>
 
402
        if (show_errors):
 
403
            if (codename is not None
 
404
                        and httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR):
 
405
                req.write(": %s" % cgi.escape(codename))
 
406
        
 
407
        req.write("""</h1>
232
408
<p>An error has occured which is the fault of the IVLE developers or
233
 
administrators. """)
234
 
 
235
 
    if logfail:
236
 
        req.write("Please report this issue to the server administrators, "
237
 
                  "along with the following information.")
238
 
    else:
239
 
        req.write("Details have been logged for further examination.")
240
 
    req.write("</p>")
241
 
 
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)
247
 
        req.write("<h2>Debugging information</h2>")
248
 
 
249
 
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
250
 
    req.write("</body></html>")
 
409
administration. The developers have been notified.</p>
 
410
""")
 
411
        if (show_errors):
 
412
            if msg is not None:
 
413
                req.write("<p>%s</p>\n" % cgi.escape(msg))
 
414
            if httpcode is not None:
 
415
                req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
416
            req.write("""
 
417
    <p>Please report this to <a href="mailto:%s">%s</a> (the system
 
418
    administrator). Include the following information:</p>
 
419
    """ % (cgi.escape(admin_email), cgi.escape(admin_email)))
 
420
 
 
421
            req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
 
422
            if logfail:
 
423
                req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
424
                    %cgi.escape(logfile))
 
425
        req.write("</body></html>")