← Back to branch summary

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

« back to all changes in this revision

Viewing changes to www/dispatch/__init__.py

  • Committer: Matt Giuca
  • Date: 2009-12-01 04:27:58 UTC
  • mfrom: (1164.2.46 sphinx-docs)
  • Revision ID: matt.giuca@gmail.com-20091201042758-wuxd9bdec00c283i
Merged sphinx-docs branch. This adds Sphinx documentation for the entire IVLE system (for system administrators and developers), and removes all of our random old document files (all either irrelevant, or moved into the Sphinx docs nicely). Currently incomplete, but ready to merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/dispatch/__init__.py
1
 
# IVLE
2
 
# Copyright (C) 2007-2008 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
 
# 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
 
 
29
 
import mod_python
30
 
from mod_python import apache, Cookie
31
 
 
32
 
import sys
33
 
import os
34
 
import os.path
35
 
import urllib
36
 
 
37
 
import conf
38
 
import conf.apps
39
 
import conf.conf
40
 
import apps
41
 
 
42
 
from request import Request
43
 
import html
44
 
import cgi
45
 
import login
46
 
from common import (util, forumutil)
47
 
import traceback
48
 
import plugins.console
49
 
import logging
50
 
import socket
51
 
import time
52
 
 
53
 
# List of cookies that IVLE uses (to be removed at logout)
54
 
ivle_cookies = ["ivleforumcookie", "clipboard"]
55
 
 
56
 
def handler(req):
57
 
    """Handles a request which may be to anywhere in the site except media.
58
 
    Intended to be called by mod_python, as a handler.
59
 
 
60
 
    req: An Apache request object.
61
 
    """
62
 
    # Make the request object into an IVLE request which can be passed to apps
63
 
    apachereq = req
64
 
    try:
65
 
        req = Request(req, html.write_html_head)
66
 
    except Exception:
67
 
        # Pass the apachereq to error reporter, since ivle req isn't created
68
 
        # yet.
69
 
        handle_unknown_exception(apachereq, *sys.exc_info())
70
 
        # Tell Apache not to generate its own errors as well
71
 
        return apache.OK
72
 
 
73
 
    # Run the main handler, and catch all exceptions
74
 
    try:
75
 
        return handler_(req, apachereq)
76
 
    except mod_python.apache.SERVER_RETURN:
77
 
        # An apache error. We discourage these, but they might still happen.
78
 
        # Just raise up.
79
 
        raise
80
 
    except Exception:
81
 
        handle_unknown_exception(req, *sys.exc_info())
82
 
        # Tell Apache not to generate its own errors as well
83
 
        return apache.OK
84
 
 
85
 
def handler_(req, apachereq):
86
 
    """
87
 
    Nested handler function. May raise exceptions. The top-level handler is
88
 
    just used to catch exceptions.
89
 
    Takes both an IVLE request and an Apache req.
90
 
    """
91
 
    # Hack? Try and get the user login early just in case we throw an error
92
 
    # (most likely 404) to stop us seeing not logged in even when we are.
93
 
    if not req.publicmode:
94
 
        req.user = login.get_user_details(req)
95
 
 
96
 
    # Check req.app to see if it is valid. 404 if not.
97
 
    if req.app is not None and req.app not in conf.apps.app_url:
98
 
        # Maybe it is a special app!
99
 
        if req.app == 'logout':
100
 
            logout(req)
101
 
        else:
102
 
            req.throw_error(Request.HTTP_NOT_FOUND,
103
 
                "There is no application called %s." % repr(req.app))
104
 
 
105
 
    # Special handling for public mode - only allow the public app, call it
106
 
    # and get out.
107
 
    # NOTE: This will not behave correctly if the public app uses
108
 
    # write_html_head_foot, but "serve" does not.
109
 
    if req.publicmode:
110
 
        if req.app != conf.apps.public_app:
111
 
            req.throw_error(Request.HTTP_FORBIDDEN,
112
 
                "This application is not available on the public site.")
113
 
        app = conf.apps.app_url[conf.apps.public_app]
114
 
        apps.call_app(app.dir, req)
115
 
        return req.OK
116
 
 
117
 
    # app is the App object for the chosen app
118
 
    if req.app is None:
119
 
        app = conf.apps.app_url[conf.apps.default_app]
120
 
    else:
121
 
        app = conf.apps.app_url[req.app]
122
 
 
123
 
    # Check if app requires auth. If so, perform authentication and login.
124
 
    # This will either return a User object, None, or perform a redirect
125
 
    # which we will not catch here.
126
 
    if app.requireauth:
127
 
        req.user = login.login(req)
128
 
        logged_in = req.user is not None
129
 
    else:
130
 
        req.user = login.get_user_details(req)
131
 
        logged_in = True
132
 
 
133
 
    if logged_in:
134
 
        # Keep the user's session alive by writing to the session object.
135
 
        # req.get_session().save()
136
 
        # Well, it's a fine idea, but it creates considerable grief in the
137
 
        # concurrent update department, so instead, we'll just make the
138
 
        # sessions not time out.
139
 
        req.get_session().unlock()
140
 
 
141
 
        # If user did not specify an app, HTTP redirect to default app and
142
 
        # exit.
143
 
        if req.app is None:
144
 
            req.throw_redirect(util.make_path(conf.apps.default_app))
145
 
 
146
 
        # Set the default title to the app's tab name, if any. Otherwise URL
147
 
        # name.
148
 
        if app.name is not None:
149
 
            req.title = app.name
150
 
        else:
151
 
            req.title = req.app
152
 
 
153
 
        # Call the specified app with the request object
154
 
        apps.call_app(app.dir, req)
155
 
 
156
 
    # if not logged in, login.login will have written the login box.
157
 
    # Just clean up and exit.
158
 
 
159
 
    # MAKE SURE we write the HTTP (and possibly HTML) header. This
160
 
    # wouldn't happen if nothing else ever got written, so we have to make
161
 
    # sure.
162
 
    req.ensure_headers_written()
163
 
 
164
 
    # When done, write out the HTML footer if the app has requested it
165
 
    if req.write_html_head_foot:
166
 
        # Show the console if required
167
 
        if logged_in and app.useconsole:
168
 
            plugins.console.present(req, windowpane=True)
169
 
        html.write_html_foot(req)
170
 
 
171
 
    # Note: Apache will not write custom HTML error messages here.
172
 
    # Use req.throw_error to do that.
173
 
    return req.OK
174
 
 
175
 
def logout(req):
176
 
    """Log out the current user (if any) by destroying the session state.
177
 
    Then redirect to the top-level IVLE page."""
178
 
    session = req.get_session()
179
 
    session.invalidate()
180
 
    session.delete()
181
 
    # Invalidates all IVLE cookies
182
 
    all_cookies = Cookie.get_cookies(req)
183
 
    for cookie in all_cookies:
184
 
        if cookie in ivle_cookies:
185
 
            req.add_cookie(Cookie.Cookie(cookie,'',expires=1,path='/'))
186
 
    req.throw_redirect(util.make_path('')) 
187
 
 
188
 
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
189
 
    """
190
 
    Given an exception that has just been thrown from IVLE, print its details
191
 
    to the request.
192
 
    This is a full handler. It assumes nothing has been written, and writes a
193
 
    complete HTML page.
194
 
    req: May be EITHER an IVLE req or an Apache req.
195
 
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
196
 
    the handler code may pass an apache req if an exception occurs before
197
 
    the IVLE request is created.
198
 
    """
199
 
    req.content_type = "text/html"
200
 
    logfile = os.path.join(conf.conf.log_path, 'ivle_error.log')
201
 
    logfail = False
202
 
    # For some reason, some versions of mod_python have "_server" instead of
203
 
    # "main_server". So we check for both.
204
 
    try:
205
 
        admin_email = apache.main_server.server_admin
206
 
    except AttributeError:
207
 
        try:
208
 
            admin_email = apache._server.server_admin
209
 
        except AttributeError:
210
 
            admin_email = ""
211
 
    try:
212
 
        httpcode = exc_value.httpcode
213
 
        req.status = httpcode
214
 
    except AttributeError:
215
 
        httpcode = None
216
 
        req.status = apache.HTTP_INTERNAL_SERVER_ERROR
217
 
    try:
218
 
        login = req.user.login
219
 
    except AttributeError:
220
 
        login = None
221
 
 
222
 
    # Log File
223
 
    try:
224
 
        for h in logging.getLogger().handlers:
225
 
            logging.getLogger().removeHandler(h)
226
 
        logging.basicConfig(level=logging.INFO,
227
 
            format='%(asctime)s %(levelname)s: ' +
228
 
                '(HTTP: ' + str(req.status) +
229
 
                ', Ref: ' + str(login) + '@' +
230
 
                str(socket.gethostname()) + str(req.uri) +
231
 
                ') %(message)s',
232
 
            filename=logfile,
233
 
            filemode='a')
234
 
    except IOError:
235
 
        logfail = True
236
 
    logging.debug('Logging Unhandled Exception')
237
 
 
238
 
    # We handle 3 types of error.
239
 
    # IVLEErrors with 4xx response codes (client error).
240
 
    # IVLEErrors with 5xx response codes (handled server error).
241
 
    # Other exceptions (unhandled server error).
242
 
    # IVLEErrors should not have other response codes than 4xx or 5xx
243
 
    # (eg. throw_redirect should have been used for 3xx codes).
244
 
    # Therefore, that is treated as an unhandled error.
245
 
 
246
 
    if (exc_type == util.IVLEError and httpcode >= 400
247
 
        and httpcode <= 499):
248
 
        # IVLEErrors with 4xx response codes are client errors.
249
 
        # Therefore, these have a "nice" response (we even coat it in the IVLE
250
 
        # HTML wrappers).
251
 
        
252
 
        req.write_html_head_foot = True
253
 
        req.write_javascript_settings = False
254
 
        req.write('<div id="ivle_padding">\n')
255
 
        try:
256
 
            codename, msg = req.get_http_codename(httpcode)
257
 
        except AttributeError:
258
 
            codename, msg = None, None
259
 
        # Override the default message with the supplied one,
260
 
        # if available.
261
 
        if exc_value.message is not None:
262
 
            msg = exc_value.message
263
 
        if codename is not None:
264
 
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
265
 
        else:
266
 
            req.write("<h1>Error</h1>\n")
267
 
        if msg is not None:
268
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
269
 
        else:
270
 
            req.write("<p>An unknown error occured.</p>\n")
271
 
        
272
 
        # Logging
273
 
        logging.info(str(msg))
274
 
        
275
 
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
276
 
        if logfail:
277
 
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
278
 
                %cgi.escape(logfile))
279
 
        req.write('</div>\n')
280
 
        html.write_html_foot(req)
281
 
    else:
282
 
        # A "bad" error message. We shouldn't get here unless IVLE
283
 
        # misbehaves (which is currently very easy, if things aren't set up
284
 
        # correctly).
285
 
        # Write the traceback.
286
 
        # If this is a non-4xx IVLEError, get the message and httpcode and
287
 
        # make the error message a bit nicer (but still include the
288
 
        # traceback).
289
 
        # We also need to special-case IVLEJailError, as we can get another
290
 
        # almost-exception out of it.
291
 
 
292
 
        codename, msg = None, None
293
 
 
294
 
        if exc_type is util.IVLEJailError:
295
 
            msg = exc_value.type_str + ": " + exc_value.message
296
 
            tb = 'Exception information extracted from IVLEJailError:\n'
297
 
            tb += urllib.unquote(exc_value.info)
298
 
        else:
299
 
            try:
300
 
                codename, msg = req.get_http_codename(httpcode)
301
 
            except AttributeError:
302
 
                pass
303
 
            # Override the default message with the supplied one,
304
 
            # if available.
305
 
            if hasattr(exc_value, 'message') and exc_value.message is not None:
306
 
                msg = exc_value.message
307
 
                # Prepend the exception type
308
 
                if exc_type != util.IVLEError:
309
 
                    msg = exc_type.__name__ + ": " + msg
310
 
 
311
 
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
312
 
                                                    exc_traceback))
313
 
 
314
 
        # Logging
315
 
        logging.error('%s\n%s'%(str(msg), tb))
316
 
 
317
 
        req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
318
 
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
319
 
<html xmlns="http://www.w3.org/1999/xhtml">
320
 
<head><title>IVLE Internal Server Error</title></head>
321
 
<body>
322
 
<h1>IVLE Internal Server Error""")
323
 
        if (codename is not None
324
 
            and httpcode != apache.HTTP_INTERNAL_SERVER_ERROR):
325
 
            req.write(": %s" % cgi.escape(codename))
326
 
        req.write("""</h1>
327
 
<p>An error has occured which is the fault of the IVLE developers or
328
 
administration.</p>
329
 
""")
330
 
        if msg is not None:
331
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
332
 
        if httpcode is not None:
333
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
334
 
        req.write("""
335
 
<p>Please report this to <a href="mailto:%s">%s</a> (the system
336
 
administrator). Include the following information:</p>
337
 
""" % (cgi.escape(admin_email), cgi.escape(admin_email)))
338
 
 
339
 
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
340
 
        if logfail:
341
 
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
342
 
                %cgi.escape(logfile))
343
 
        req.write("</body></html>")