← 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: mattgiuca
  • Date: 2008-02-15 04:45:12 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:472
db.py: No longer exceptions if password is not supplied.
makeuser: Converted explicit args into kwargs which are simply forwarded along
    to db. Makeuser db NO LONGER accepts "force" argument (which used to
    delete and replace login rows). This is dangerous, and we have removed the
    delete user functionality altogether - because we never delete users.
makeuser.py (script): Major change. Replaced the command-line interface so it
    now only takes 3 required arguments, and a bunch of optional arguments
    getopts style.
    All the arguments are specified at the top; the rest of the code works
    with these data structures so they are only specified in one place
    (including all the work of putting them into a dict and passing it to the
    database).
    Note that makeuser.py is a *second* point of control for the list of the
    login fields (the other is in db.DB.login_fields_list). This is by design,
    because there is a semantic difference between "what fields are in the db"
    and "what arguments should we accept on the command line".

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
3
 
#
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License as published by
6
 
# the Free Software Foundation; either version 2 of the License, or
7
 
# (at your option) any later version.
8
 
#
9
 
# This program is distributed in the hope that it will be useful,
10
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
# GNU General Public License for more details.
13
 
#
14
 
# You should have received a copy of the GNU General Public License
15
 
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
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
 
"""
28
 
 
29
 
import sys
30
 
import os
31
 
import os.path
32
 
import urllib
33
 
import cgi
34
 
import traceback
35
 
import logging
36
 
import socket
37
 
import time
38
 
import inspect
39
 
 
40
 
import mod_python
41
 
import routes
42
 
 
43
 
from ivle import util
44
 
import ivle.conf
45
 
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
 
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
 
] 
69
 
 
70
 
def generate_route_mapper(view_plugins):
71
 
    """
72
 
    Build a Mapper object for doing URL matching using 'routes', based on the
73
 
    given plugin registry.
74
 
    """
75
 
    m = routes.Mapper(explicit=True)
76
 
    for plugin in view_plugins:
77
 
        # Establish a URL pattern for each element of plugin.urls
78
 
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
79
 
        for url in plugin.urls:
80
 
            routex = url[0]
81
 
            view_class = url[1]
82
 
            kwargs_dict = url[2] if len(url) >= 3 else {}
83
 
            m.connect(routex, view=view_class, **kwargs_dict)
84
 
    return m
85
 
 
86
 
def get_plugin(pluginstr):
87
 
    plugin_path, classname = pluginstr.split('#')
88
 
    # Load the plugin module from somewhere in the Python path
89
 
    # (Note that plugin_path is a fully-qualified Python module name).
90
 
    return (plugin_path,
91
 
            getattr(__import__(plugin_path, fromlist=[classname]), classname))
92
 
 
93
 
def handler(req):
94
 
    """Handles a request which may be to anywhere in the site except media.
95
 
    Intended to be called by mod_python, as a handler.
96
 
 
97
 
    req: An Apache request object.
98
 
    """
99
 
    # Make the request object into an IVLE request which can be passed to apps
100
 
    apachereq = req
101
 
    try:
102
 
        req = Request(req, html.write_html_head)
103
 
    except Exception:
104
 
        # Pass the apachereq to error reporter, since ivle req isn't created
105
 
        # yet.
106
 
        handle_unknown_exception(apachereq, *sys.exc_info())
107
 
        # Tell Apache not to generate its own errors as well
108
 
        return mod_python.apache.OK
109
 
 
110
 
    # Run the main handler, and catch all exceptions
111
 
    try:
112
 
        return handler_(req, apachereq)
113
 
    except mod_python.apache.SERVER_RETURN:
114
 
        # An apache error. We discourage these, but they might still happen.
115
 
        # Just raise up.
116
 
        raise
117
 
    except Exception:
118
 
        handle_unknown_exception(req, *sys.exc_info())
119
 
        # Tell Apache not to generate its own errors as well
120
 
        return mod_python.apache.OK
121
 
 
122
 
def handler_(req, apachereq):
123
 
    """
124
 
    Nested handler function. May raise exceptions. The top-level handler is
125
 
    just used to catch exceptions.
126
 
    Takes both an IVLE request and an Apache req.
127
 
    """
128
 
    # Hack? Try and get the user login early just in case we throw an error
129
 
    # (most likely 404) to stop us seeing not logged in even when we are.
130
 
    if not req.publicmode:
131
 
        req.user = login.get_user_details(req)
132
 
 
133
 
    ### BEGIN New plugins framework ###
134
 
    # XXX This should be done ONCE per Python process, not per request.
135
 
    # (Wait till WSGI)
136
 
    # XXX No authentication is done here
137
 
    req.plugins = dict([get_plugin(pluginstr) for pluginstr in plugins_HACK])
138
 
    # Index the plugins by base class
139
 
    req.plugin_index = {}
140
 
    for plugin in req.plugins.values():
141
 
        # Getmro returns a tuple of all the super-classes of the plugin
142
 
        for base in inspect.getmro(plugin):
143
 
            if base not in req.plugin_index:
144
 
                req.plugin_index[base] = []
145
 
            req.plugin_index[base].append(plugin)
146
 
    req.reverse_plugins = dict([(v, k) for (k, v) in req.plugins.items()])
147
 
    req.mapper = generate_route_mapper(req.plugin_index[ViewPlugin])
148
 
 
149
 
    matchdict = req.mapper.match(req.uri)
150
 
    if matchdict is not None:
151
 
        viewcls = matchdict['view']
152
 
        # Get the remaining arguments, less 'view', 'action' and 'controller'
153
 
        # (The latter two seem to be built-in, and we don't want them).
154
 
        kwargs = matchdict.copy()
155
 
        del kwargs['view']
156
 
        try:
157
 
            # Instantiate the view, which should be a BaseView class
158
 
            view = viewcls(req, **kwargs)
159
 
            # Render the output
160
 
            view.render(req)
161
 
        except HTTPError, e:
162
 
            # A view explicitly raised an HTTP error. Respect it.
163
 
            req.status = e.code
164
 
 
165
 
            # Try to find a custom error view.
166
 
            if hasattr(viewcls, 'get_error_view'):
167
 
                errviewcls = viewcls.get_error_view(e)
168
 
            else:
169
 
                errviewcls = None
170
 
 
171
 
            if errviewcls:
172
 
                errview = errviewcls(req, e)
173
 
                errview.render(req)
174
 
                return req.OK
175
 
            else:
176
 
                req.write(e.message)
177
 
                return e.code
178
 
        except Exception, e:
179
 
            # A non-HTTPError appeared. We have an unknown exception. Panic.
180
 
            handle_unknown_exception(req, *sys.exc_info())
181
 
            return req.OK
182
 
        else:
183
 
            req.store.commit()
184
 
            return req.OK
185
 
    ### END New plugins framework ###
186
 
 
187
 
    # Check req.app to see if it is valid. 404 if not.
188
 
    if req.app is not None and req.app not in ivle.conf.apps.app_url:
189
 
        req.throw_error(Request.HTTP_NOT_FOUND,
190
 
            "There is no application called %s." % repr(req.app))
191
 
 
192
 
    # Special handling for public mode - only allow the public app, call it
193
 
    # and get out.
194
 
    # NOTE: This will not behave correctly if the public app uses
195
 
    # write_html_head_foot, but "serve" does not.
196
 
    if req.publicmode:
197
 
        if req.app != ivle.conf.apps.public_app:
198
 
            req.throw_error(Request.HTTP_FORBIDDEN,
199
 
                "This application is not available on the public site.")
200
 
        app = ivle.conf.apps.app_url[ivle.conf.apps.public_app]
201
 
        apps.call_app(app.dir, req)
202
 
        return req.OK
203
 
 
204
 
    # app is the App object for the chosen app
205
 
    if req.app is None:
206
 
        app = ivle.conf.apps.app_url[ivle.conf.apps.default_app]
207
 
    else:
208
 
        app = ivle.conf.apps.app_url[req.app]
209
 
 
210
 
    # Check if app requires auth. If so, perform authentication and login.
211
 
    # This will either return a User object, None, or perform a redirect
212
 
    # which we will not catch here.
213
 
    if app.requireauth:
214
 
        req.user = login.login(req)
215
 
        logged_in = req.user is not None
216
 
    else:
217
 
        req.user = login.get_user_details(req)
218
 
        logged_in = True
219
 
 
220
 
    if logged_in:
221
 
        # Keep the user's session alive by writing to the session object.
222
 
        # req.get_session().save()
223
 
        # Well, it's a fine idea, but it creates considerable grief in the
224
 
        # concurrent update department, so instead, we'll just make the
225
 
        # sessions not time out.
226
 
        req.get_session().unlock()
227
 
 
228
 
        # If user did not specify an app, HTTP redirect to default app and
229
 
        # exit.
230
 
        if req.app is None:
231
 
            req.throw_redirect(util.make_path(ivle.conf.apps.default_app))
232
 
 
233
 
        # Set the default title to the app's tab name, if any. Otherwise URL
234
 
        # name.
235
 
        if app.name is not None:
236
 
            req.title = app.name
237
 
        else:
238
 
            req.title = req.app
239
 
 
240
 
        # Call the specified app with the request object
241
 
        apps.call_app(app.dir, req)
242
 
 
243
 
    # if not logged in, login.login will have written the login box.
244
 
    # Just clean up and exit.
245
 
 
246
 
    # MAKE SURE we write the HTTP (and possibly HTML) header. This
247
 
    # wouldn't happen if nothing else ever got written, so we have to make
248
 
    # sure.
249
 
    req.ensure_headers_written()
250
 
 
251
 
    # When done, write out the HTML footer if the app has requested it
252
 
    if req.write_html_head_foot:
253
 
        html.write_html_foot(req)
254
 
 
255
 
    # Note: Apache will not write custom HTML error messages here.
256
 
    # Use req.throw_error to do that.
257
 
    return req.OK
258
 
 
259
 
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
260
 
    """
261
 
    Given an exception that has just been thrown from IVLE, print its details
262
 
    to the request.
263
 
    This is a full handler. It assumes nothing has been written, and writes a
264
 
    complete HTML page.
265
 
    req: May be EITHER an IVLE req or an Apache req.
266
 
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
267
 
    the handler code may pass an apache req if an exception occurs before
268
 
    the IVLE request is created.
269
 
    """
270
 
    req.content_type = "text/html"
271
 
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
272
 
    logfail = False
273
 
    # For some reason, some versions of mod_python have "_server" instead of
274
 
    # "main_server". So we check for both.
275
 
    try:
276
 
        admin_email = mod_python.apache.main_server.server_admin
277
 
    except AttributeError:
278
 
        try:
279
 
            admin_email = mod_python.apache._server.server_admin
280
 
        except AttributeError:
281
 
            admin_email = ""
282
 
    try:
283
 
        httpcode = exc_value.httpcode
284
 
        req.status = httpcode
285
 
    except AttributeError:
286
 
        httpcode = None
287
 
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
288
 
    try:
289
 
        publicmode = req.publicmode
290
 
    except AttributeError:
291
 
        publicmode = True
292
 
    try:
293
 
        login = req.user.login
294
 
    except AttributeError:
295
 
        login = None
296
 
    try:
297
 
        role = req.user.role
298
 
    except AttributeError:
299
 
        role = None
300
 
 
301
 
    # Log File
302
 
    try:
303
 
        for h in logging.getLogger().handlers:
304
 
            logging.getLogger().removeHandler(h)
305
 
        logging.basicConfig(level=logging.INFO,
306
 
            format='%(asctime)s %(levelname)s: ' +
307
 
                '(HTTP: ' + str(req.status) +
308
 
                ', Ref: ' + str(login) + '@' +
309
 
                str(socket.gethostname()) + str(req.uri) +
310
 
                ') %(message)s',
311
 
            filename=logfile,
312
 
            filemode='a')
313
 
    except IOError:
314
 
        logfail = True
315
 
    logging.debug('Logging Unhandled Exception')
316
 
 
317
 
    # We handle 3 types of error.
318
 
    # IVLEErrors with 4xx response codes (client error).
319
 
    # IVLEErrors with 5xx response codes (handled server error).
320
 
    # Other exceptions (unhandled server error).
321
 
    # IVLEErrors should not have other response codes than 4xx or 5xx
322
 
    # (eg. throw_redirect should have been used for 3xx codes).
323
 
    # Therefore, that is treated as an unhandled error.
324
 
 
325
 
    if (exc_type == util.IVLEError and httpcode >= 400
326
 
        and httpcode <= 499):
327
 
        # IVLEErrors with 4xx response codes are client errors.
328
 
        # Therefore, these have a "nice" response (we even coat it in the IVLE
329
 
        # HTML wrappers).
330
 
        
331
 
        req.write_html_head_foot = True
332
 
        req.write_javascript_settings = False
333
 
        req.write('<div id="ivle_padding">\n')
334
 
        try:
335
 
            codename, msg = req.get_http_codename(httpcode)
336
 
        except AttributeError:
337
 
            codename, msg = None, None
338
 
        # Override the default message with the supplied one,
339
 
        # if available.
340
 
        if exc_value.message is not None:
341
 
            msg = exc_value.message
342
 
        if codename is not None:
343
 
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
344
 
        else:
345
 
            req.write("<h1>Error</h1>\n")
346
 
        if msg is not None:
347
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
348
 
        else:
349
 
            req.write("<p>An unknown error occured.</p>\n")
350
 
        
351
 
        # Logging
352
 
        logging.info(str(msg))
353
 
        
354
 
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
355
 
        if logfail:
356
 
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
357
 
                %cgi.escape(logfile))
358
 
        req.write('</div>\n')
359
 
        html.write_html_foot(req)
360
 
    else:
361
 
        # A "bad" error message. We shouldn't get here unless IVLE
362
 
        # misbehaves (which is currently very easy, if things aren't set up
363
 
        # correctly).
364
 
        # Write the traceback.
365
 
        # If this is a non-4xx IVLEError, get the message and httpcode and
366
 
        # make the error message a bit nicer (but still include the
367
 
        # traceback).
368
 
        # We also need to special-case IVLEJailError, as we can get another
369
 
        # almost-exception out of it.
370
 
 
371
 
        codename, msg = None, None
372
 
 
373
 
        if exc_type is util.IVLEJailError:
374
 
            msg = exc_value.type_str + ": " + exc_value.message
375
 
            tb = 'Exception information extracted from IVLEJailError:\n'
376
 
            tb += urllib.unquote(exc_value.info)
377
 
        else:
378
 
            try:
379
 
                codename, msg = req.get_http_codename(httpcode)
380
 
            except AttributeError:
381
 
                pass
382
 
            # Override the default message with the supplied one,
383
 
            # if available.
384
 
            if hasattr(exc_value, 'message') and exc_value.message is not None:
385
 
                msg = exc_value.message
386
 
                # Prepend the exception type
387
 
                if exc_type != util.IVLEError:
388
 
                    msg = exc_type.__name__ + ": " + msg
389
 
 
390
 
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
391
 
                                                    exc_traceback))
392
 
 
393
 
        # Logging
394
 
        logging.error('%s\n%s'%(str(msg), tb))
395
 
        # Error messages are only displayed is the user is NOT a student,
396
 
        # or if there has been a problem logging the error message
397
 
        show_errors = (not publicmode) and ((login and \
398
 
                            str(role) != "student") or logfail)
399
 
        req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
400
 
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
401
 
<html xmlns="http://www.w3.org/1999/xhtml">
402
 
<head><title>IVLE Internal Server Error</title></head>
403
 
<body>
404
 
<h1>IVLE Internal Server Error""")
405
 
        if (show_errors):
406
 
            if (codename is not None
407
 
                        and httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR):
408
 
                req.write(": %s" % cgi.escape(codename))
409
 
        
410
 
        req.write("""</h1>
411
 
<p>An error has occured which is the fault of the IVLE developers or
412
 
administration. The developers have been notified.</p>
413
 
""")
414
 
        if (show_errors):
415
 
            if msg is not None:
416
 
                req.write("<p>%s</p>\n" % cgi.escape(msg))
417
 
            if httpcode is not None:
418
 
                req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
419
 
            req.write("""
420
 
    <p>Please report this to <a href="mailto:%s">%s</a> (the system
421
 
    administrator). Include the following information:</p>
422
 
    """ % (cgi.escape(admin_email), cgi.escape(admin_email)))
423
 
 
424
 
            req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
425
 
            if logfail:
426
 
                req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
427
 
                    %cgi.escape(logfile))
428
 
        req.write("</body></html>")