← 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-01-20 06:00:55 UTC
  • mto: This revision was merged to the branch mainline in revision 1090.
  • Revision ID: grantw@unimelb.edu.au-20090120060055-iuvd8hycor67acfa
ivle.rpc.decorators: Add (new package, too). Has a couple of decorators to
    apply most security policy in userservice, making it significantly shorter
    and easier to audit.
www/apps/userservice: Use the decorators to protect all actions whose existing
    policy can be easily replaced with them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
1
 
# IVLE - Informatics Virtual Learning Environment
2
 
# Copyright (C) 2007-2009 The University of Melbourne
 
1
# IVLE
 
2
# Copyright (C) 2007-2008 The University of Melbourne
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 
18
 
# Author: Matt Giuca, Will Grant
19
 
 
20
 
"""
21
 
This is a mod_python handler program. The correct way to call it is to have
22
 
Apache send all requests to be handled by the module 'dispatch'.
23
 
 
24
 
Top-level handler. Handles all requests to all pages in IVLE.
25
 
Handles authentication (not authorization).
26
 
Then passes the request along to the appropriate ivle app.
27
 
"""
 
18
# Module: dispatch
 
19
# Author: Matt Giuca
 
20
# Date: 11/12/2007
 
21
 
 
22
# This is a mod_python handler program. The correct way to call it is to have
 
23
# Apache send all requests to be handled by the module 'dispatch'.
 
24
 
 
25
# Top-level handler. Handles all requests to all pages in IVLE.
 
26
# Handles authentication (not authorization).
 
27
# Then passes the request along to the appropriate ivle app.
28
28
 
29
29
import sys
30
30
import os
35
35
import logging
36
36
import socket
37
37
import time
38
 
import inspect
39
38
 
40
39
import mod_python
41
 
import routes
 
40
from mod_python import apache, Cookie
42
41
 
43
42
from ivle import util
44
43
import ivle.conf
45
44
import ivle.conf.apps
46
 
from ivle.dispatch.request import Request
47
 
from ivle.dispatch import login
48
 
from ivle.webapp.base.plugins import ViewPlugin
49
 
from ivle.webapp.errors import HTTPError
50
45
import apps
 
46
import login
51
47
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
 
] 
68
 
 
69
 
def generate_route_mapper(view_plugins):
70
 
    """
71
 
    Build a Mapper object for doing URL matching using 'routes', based on the
72
 
    given plugin registry.
73
 
    """
74
 
    m = routes.Mapper(explicit=True)
75
 
    for plugin in view_plugins:
76
 
        # Establish a URL pattern for each element of plugin.urls
77
 
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
78
 
        for url in plugin.urls:
79
 
            routex = url[0]
80
 
            view_class = url[1]
81
 
            kwargs_dict = url[2] if len(url) >= 3 else {}
82
 
            m.connect(routex, view=view_class, **kwargs_dict)
83
 
    return m
84
 
 
85
 
def get_plugin(pluginstr):
86
 
    plugin_path, classname = pluginstr.split('#')
87
 
    # Load the plugin module from somewhere in the Python path
88
 
    # (Note that plugin_path is a fully-qualified Python module name).
89
 
    return (plugin_path,
90
 
            getattr(__import__(plugin_path, fromlist=[classname]), classname))
 
48
from request import Request
 
49
import plugins.console # XXX: Relies on www/ being in the Python path.
91
50
 
92
51
def handler(req):
93
52
    """Handles a request which may be to anywhere in the site except media.
104
63
        # yet.
105
64
        handle_unknown_exception(apachereq, *sys.exc_info())
106
65
        # Tell Apache not to generate its own errors as well
107
 
        return mod_python.apache.OK
 
66
        return apache.OK
108
67
 
109
68
    # Run the main handler, and catch all exceptions
110
69
    try:
116
75
    except Exception:
117
76
        handle_unknown_exception(req, *sys.exc_info())
118
77
        # Tell Apache not to generate its own errors as well
119
 
        return mod_python.apache.OK
 
78
        return apache.OK
120
79
 
121
80
def handler_(req, apachereq):
122
81
    """
129
88
    if not req.publicmode:
130
89
        req.user = login.get_user_details(req)
131
90
 
132
 
    ### BEGIN New plugins framework ###
133
 
    # XXX This should be done ONCE per Python process, not per request.
134
 
    # (Wait till WSGI)
135
 
    # XXX No authentication is done here
136
 
    req.plugins = dict([get_plugin(pluginstr) for pluginstr in plugins_HACK])
137
 
    # Index the plugins by base class
138
 
    req.plugin_index = {}
139
 
    for plugin in req.plugins.values():
140
 
        # Getmro returns a tuple of all the super-classes of the plugin
141
 
        for base in inspect.getmro(plugin):
142
 
            if base not in req.plugin_index:
143
 
                req.plugin_index[base] = []
144
 
            req.plugin_index[base].append(plugin)
145
 
    req.reverse_plugins = dict([(v, k) for (k, v) in req.plugins.items()])
146
 
    req.mapper = generate_route_mapper(req.plugin_index[ViewPlugin])
147
 
 
148
 
    matchdict = req.mapper.match(req.uri)
149
 
    if matchdict is not None:
150
 
        viewcls = matchdict['view']
151
 
        # Get the remaining arguments, less 'view', 'action' and 'controller'
152
 
        # (The latter two seem to be built-in, and we don't want them).
153
 
        kwargs = matchdict.copy()
154
 
        del kwargs['view']
155
 
        try:
156
 
            # Instantiate the view, which should be a BaseView class
157
 
            view = viewcls(req, **kwargs)
158
 
            # Render the output
159
 
            view.render(req)
160
 
        except HTTPError, e:
161
 
            # A view explicitly raised an HTTP error. Respect it.
162
 
            req.status = e.code
163
 
 
164
 
            # Try to find a custom error view.
165
 
            if hasattr(viewcls, 'get_error_view'):
166
 
                errviewcls = viewcls.get_error_view(e)
167
 
            else:
168
 
                errviewcls = None
169
 
 
170
 
            if errviewcls:
171
 
                errview = errviewcls(req, e)
172
 
                errview.render(req)
173
 
                return req.OK
174
 
            else:
175
 
                req.write(e.message)
176
 
                return e.code
177
 
        except Exception, e:
178
 
            # A non-HTTPError appeared. We have an unknown exception. Panic.
179
 
            handle_unknown_exception(req, *sys.exc_info())
180
 
            return req.OK
181
 
        else:
182
 
            req.store.commit()
183
 
            return req.OK
184
 
    ### END New plugins framework ###
185
 
 
186
91
    # Check req.app to see if it is valid. 404 if not.
187
92
    if req.app is not None and req.app not in ivle.conf.apps.app_url:
188
93
        req.throw_error(Request.HTTP_NOT_FOUND,
249
154
 
250
155
    # When done, write out the HTML footer if the app has requested it
251
156
    if req.write_html_head_foot:
 
157
        # Show the console if required
 
158
        if logged_in and app.useconsole:
 
159
            plugins.console.present(req, windowpane=True)
252
160
        html.write_html_foot(req)
253
161
 
254
162
    # Note: Apache will not write custom HTML error messages here.
272
180
    # For some reason, some versions of mod_python have "_server" instead of
273
181
    # "main_server". So we check for both.
274
182
    try:
275
 
        admin_email = mod_python.apache.main_server.server_admin
 
183
        admin_email = apache.main_server.server_admin
276
184
    except AttributeError:
277
185
        try:
278
 
            admin_email = mod_python.apache._server.server_admin
 
186
            admin_email = apache._server.server_admin
279
187
        except AttributeError:
280
188
            admin_email = ""
281
189
    try:
283
191
        req.status = httpcode
284
192
    except AttributeError:
285
193
        httpcode = None
286
 
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
287
 
    try:
288
 
        publicmode = req.publicmode
289
 
    except AttributeError:
290
 
        publicmode = True
 
194
        req.status = apache.HTTP_INTERNAL_SERVER_ERROR
291
195
    try:
292
196
        login = req.user.login
293
197
    except AttributeError:
294
198
        login = None
295
 
    try:
296
 
        role = req.user.role
297
 
    except AttributeError:
298
 
        role = None
299
199
 
300
200
    # Log File
301
201
    try:
391
291
 
392
292
        # Logging
393
293
        logging.error('%s\n%s'%(str(msg), tb))
394
 
        # Error messages are only displayed is the user is NOT a student,
395
 
        # or if there has been a problem logging the error message
396
 
        show_errors = (not publicmode) and ((login and \
397
 
                            str(role) != "student") or logfail)
 
294
 
398
295
        req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
399
296
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
400
297
<html xmlns="http://www.w3.org/1999/xhtml">
401
298
<head><title>IVLE Internal Server Error</title></head>
402
299
<body>
403
300
<h1>IVLE Internal Server Error""")
404
 
        if (show_errors):
405
 
            if (codename is not None
406
 
                        and httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR):
407
 
                req.write(": %s" % cgi.escape(codename))
408
 
        
 
301
        if (codename is not None
 
302
            and httpcode != apache.HTTP_INTERNAL_SERVER_ERROR):
 
303
            req.write(": %s" % cgi.escape(codename))
409
304
        req.write("""</h1>
410
305
<p>An error has occured which is the fault of the IVLE developers or
411
 
administration. The developers have been notified.</p>
 
306
administration.</p>
412
307
""")
413
 
        if (show_errors):
414
 
            if msg is not None:
415
 
                req.write("<p>%s</p>\n" % cgi.escape(msg))
416
 
            if httpcode is not None:
417
 
                req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
418
 
            req.write("""
419
 
    <p>Please report this to <a href="mailto:%s">%s</a> (the system
420
 
    administrator). Include the following information:</p>
421
 
    """ % (cgi.escape(admin_email), cgi.escape(admin_email)))
 
308
        if msg is not None:
 
309
            req.write("<p>%s</p>\n" % cgi.escape(msg))
 
310
        if httpcode is not None:
 
311
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
312
        req.write("""
 
313
<p>Please report this to <a href="mailto:%s">%s</a> (the system
 
314
administrator). Include the following information:</p>
 
315
""" % (cgi.escape(admin_email), cgi.escape(admin_email)))
422
316
 
423
 
            req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
424
 
            if logfail:
425
 
                req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
426
 
                    %cgi.escape(logfile))
 
317
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
 
318
        if logfail:
 
319
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
320
                %cgi.escape(logfile))
427
321
        req.write("</body></html>")