← 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: mattgiuca
  • Date: 2008-01-09 21:33:56 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:144
Trunk, and all subdirectories with Python files:
    Added to svn:ignore all *.pyc *.pyo, to avoid compiled files
    showing up in svn st / diff / commit lists.
    Added to svn:ignore trampoline/trampoline.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/dispatch/__init__.py
27
27
# Then passes the request along to the appropriate ivle app.
28
28
 
29
29
import mod_python
30
 
from mod_python import apache, Cookie
 
30
from mod_python import apache
31
31
 
32
 
import sys
33
32
import os
34
33
import os.path
35
 
import urllib
36
 
 
37
34
import conf
38
35
import conf.apps
39
 
import conf.conf
40
36
import apps
41
37
 
42
38
from request import Request
43
39
import html
44
 
import cgi
45
40
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"]
 
41
from common import util
55
42
 
56
43
def handler(req):
57
44
    """Handles a request which may be to anywhere in the site except media.
61
48
    """
62
49
    # Make the request object into an IVLE request which can be passed to apps
63
50
    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)
 
51
    req = Request(req, html.write_html_head)
95
52
 
96
53
    # Check req.app to see if it is valid. 404 if not.
97
54
    if req.app is not None and req.app not in conf.apps.app_url:
99
56
        if req.app == 'logout':
100
57
            logout(req)
101
58
        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
 
59
            # TODO: Nicer 404 message?
 
60
            req.throw_error(Request.HTTP_NOT_FOUND)
116
61
 
117
62
    # app is the App object for the chosen app
118
63
    if req.app is None:
119
 
        app = conf.apps.app_url[conf.apps.default_app]
 
64
        app = conf.apps.app_url[conf.default_app]
120
65
    else:
121
66
        app = conf.apps.app_url[req.app]
122
67
 
123
68
    # 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
69
    if app.requireauth:
127
 
        req.user = login.login(req)
128
 
        logged_in = req.user is not None
 
70
        req.username = login.login(req)
 
71
        logged_in = req.username is not None
129
72
    else:
130
 
        req.user = login.get_user_details(req)
 
73
        req.username = login.get_username(req)
131
74
        logged_in = True
132
75
 
133
76
    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
 
        
140
77
        # If user did not specify an app, HTTP redirect to default app and
141
78
        # exit.
142
79
        if req.app is None:
143
 
            req.throw_redirect(util.make_path(conf.apps.default_app))
 
80
            req.throw_redirect(util.make_path(conf.default_app))
144
81
 
145
82
        # Set the default title to the app's tab name, if any. Otherwise URL
146
83
        # name.
151
88
 
152
89
        # Call the specified app with the request object
153
90
        apps.call_app(app.dir, req)
154
 
 
155
91
    # if not logged in, login.login will have written the login box.
156
92
    # Just clean up and exit.
157
93
 
162
98
 
163
99
    # When done, write out the HTML footer if the app has requested it
164
100
    if req.write_html_head_foot:
165
 
        # Show the console if required
166
 
        if logged_in and app.useconsole:
167
 
            plugins.console.present(req, windowpane=True)
168
101
        html.write_html_foot(req)
169
102
 
170
103
    # Note: Apache will not write custom HTML error messages here.
177
110
    session = req.get_session()
178
111
    session.invalidate()
179
112
    session.delete()
180
 
    # Invalidates all IVLE cookies
181
 
    all_cookies = Cookie.get_cookies(req)
182
 
    for cookie in all_cookies:
183
 
        if cookie in ivle_cookies:
184
 
            req.add_cookie(Cookie.Cookie(cookie,'',expires=1,path='/'))
185
 
    req.throw_redirect(util.make_path('')) 
186
 
 
187
 
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
188
 
    """
189
 
    Given an exception that has just been thrown from IVLE, print its details
190
 
    to the request.
191
 
    This is a full handler. It assumes nothing has been written, and writes a
192
 
    complete HTML page.
193
 
    req: May be EITHER an IVLE req or an Apache req.
194
 
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
195
 
    the handler code may pass an apache req if an exception occurs before
196
 
    the IVLE request is created.
197
 
    """
198
 
    req.content_type = "text/html"
199
 
    logfile = os.path.join(conf.conf.log_path, 'ivle_error.log')
200
 
    logfail = False
201
 
    # For some reason, some versions of mod_python have "_server" instead of
202
 
    # "main_server". So we check for both.
203
 
    try:
204
 
        admin_email = apache.main_server.server_admin
205
 
    except AttributeError:
206
 
        try:
207
 
            admin_email = apache._server.server_admin
208
 
        except AttributeError:
209
 
            admin_email = ""
210
 
    try:
211
 
        httpcode = exc_value.httpcode
212
 
        req.status = httpcode
213
 
    except AttributeError:
214
 
        httpcode = None
215
 
        req.status = apache.HTTP_INTERNAL_SERVER_ERROR
216
 
    try:
217
 
        login = req.user.login
218
 
    except AttributeError:
219
 
        login = None
220
 
 
221
 
    # Log File
222
 
    try:
223
 
        logging.basicConfig(level=logging.INFO,
224
 
            format='%(asctime)s %(levelname)s: ' +
225
 
                '(HTTP: ' + str(req.status) +
226
 
                ', Ref: ' + str(login) + '@' +
227
 
                str(socket.gethostname()) + str(req.uri) +
228
 
                ') %(message)s',
229
 
            filename=logfile,
230
 
            filemode='a')
231
 
    except IOError:
232
 
        logfail = True
233
 
    logging.debug('Logging Unhandled Exception')
234
 
 
235
 
    # We handle 3 types of error.
236
 
    # IVLEErrors with 4xx response codes (client error).
237
 
    # IVLEErrors with 5xx response codes (handled server error).
238
 
    # Other exceptions (unhandled server error).
239
 
    # IVLEErrors should not have other response codes than 4xx or 5xx
240
 
    # (eg. throw_redirect should have been used for 3xx codes).
241
 
    # Therefore, that is treated as an unhandled error.
242
 
 
243
 
    if (exc_type == util.IVLEError and httpcode >= 400
244
 
        and httpcode <= 499):
245
 
        # IVLEErrors with 4xx response codes are client errors.
246
 
        # Therefore, these have a "nice" response (we even coat it in the IVLE
247
 
        # HTML wrappers).
248
 
        
249
 
        req.write_html_head_foot = True
250
 
        req.write('<div id="ivle_padding">\n')
251
 
        try:
252
 
            codename, msg = req.get_http_codename(httpcode)
253
 
        except AttributeError:
254
 
            codename, msg = None, None
255
 
        # Override the default message with the supplied one,
256
 
        # if available.
257
 
        if exc_value.message is not None:
258
 
            msg = exc_value.message
259
 
        if codename is not None:
260
 
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
261
 
        else:
262
 
            req.write("<h1>Error</h1>\n")
263
 
        if msg is not None:
264
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
265
 
        else:
266
 
            req.write("<p>An unknown error occured.</p>\n")
267
 
        
268
 
        # Logging
269
 
        logging.info(str(msg))
270
 
        
271
 
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
272
 
        if logfail:
273
 
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
274
 
                %cgi.escape(logfile))
275
 
        req.write('</div>\n')
276
 
    else:
277
 
        # A "bad" error message. We shouldn't get here unless IVLE
278
 
        # misbehaves (which is currently very easy, if things aren't set up
279
 
        # correctly).
280
 
        # Write the traceback.
281
 
        # If this is a non-4xx IVLEError, get the message and httpcode and
282
 
        # make the error message a bit nicer (but still include the
283
 
        # traceback).
284
 
        # We also need to special-case IVLEJailError, as we can get another
285
 
        # almost-exception out of it.
286
 
 
287
 
        codename, msg = None, None
288
 
 
289
 
        if exc_type is util.IVLEJailError:
290
 
            msg = exc_value.type_str + ": " + exc_value.message
291
 
            tb = 'Exception information extracted from IVLEJailError:\n'
292
 
            tb += urllib.unquote(exc_value.info)
293
 
        else:
294
 
            try:
295
 
                codename, msg = req.get_http_codename(httpcode)
296
 
            except AttributeError:
297
 
                pass
298
 
            # Override the default message with the supplied one,
299
 
            # if available.
300
 
            if hasattr(exc_value, 'message') and exc_value.message is not None:
301
 
                msg = exc_value.message
302
 
                # Prepend the exception type
303
 
                if exc_type != util.IVLEError:
304
 
                    msg = exc_type.__name__ + ": " + msg
305
 
 
306
 
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
307
 
                                                    exc_traceback))
308
 
 
309
 
        # Logging
310
 
        logging.error('%s\n%s'%(str(msg), tb))
311
 
 
312
 
        req.write("""<html>
313
 
<head><title>IVLE Internal Server Error</title></head>
314
 
<body>
315
 
<h1>IVLE Internal Server Error""")
316
 
        if (codename is not None
317
 
            and httpcode != apache.HTTP_INTERNAL_SERVER_ERROR):
318
 
            req.write(": %s" % cgi.escape(codename))
319
 
        req.write("""</h1>
320
 
<p>An error has occured which is the fault of the IVLE developers or
321
 
administration.</p>
322
 
""")
323
 
        if msg is not None:
324
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
325
 
        if httpcode is not None:
326
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
327
 
        req.write("""
328
 
<p>Please report this to <a href="mailto:%s">%s</a> (the system
329
 
administrator). Include the following information:</p>
330
 
""" % (cgi.escape(admin_email), cgi.escape(admin_email)))
331
 
 
332
 
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
333
 
        if logfail:
334
 
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
335
 
                %cgi.escape(logfile))
336
 
        req.write("</body>")
 
113
    req.throw_redirect(util.make_path(''))