← 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-02-03 04:21:06 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:383
Split media/browser/browser.css into 3 files (listing.css and editor.css).
browser/__init__.py includes all of these CSS files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/dispatch/__init__.py
29
29
import mod_python
30
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
36
import apps
40
37
 
41
38
from request import Request
42
39
import html
43
 
import cgi
44
40
import login
45
 
from common import (util, forumutil)
46
 
import traceback
 
41
from common import util
47
42
 
48
43
def handler(req):
49
44
    """Handles a request which may be to anywhere in the site except media.
53
48
    """
54
49
    # Make the request object into an IVLE request which can be passed to apps
55
50
    apachereq = req
56
 
    try:
57
 
        req = Request(req, html.write_html_head)
58
 
    except Exception:
59
 
        # Pass the apachereq to error reporter, since ivle req isn't created
60
 
        # yet.
61
 
        handle_unknown_exception(apachereq, *sys.exc_info())
62
 
        # Tell Apache not to generate its own errors as well
63
 
        return apache.OK
64
 
 
65
 
    # Run the main handler, and catch all exceptions
66
 
    try:
67
 
        return handler_(req, apachereq)
68
 
    except mod_python.apache.SERVER_RETURN:
69
 
        # An apache error. We discourage these, but they might still happen.
70
 
        # Just raise up.
71
 
        raise
72
 
    except Exception:
73
 
        handle_unknown_exception(req, *sys.exc_info())
74
 
        # Tell Apache not to generate its own errors as well
75
 
        return apache.OK
76
 
 
77
 
def handler_(req, apachereq):
78
 
    """
79
 
    Nested handler function. May raise exceptions. The top-level handler is
80
 
    just used to catch exceptions.
81
 
    Takes both an IVLE request and an Apache req.
82
 
    """
 
51
    req = Request(req, html.write_html_head)
 
52
 
83
53
    # Check req.app to see if it is valid. 404 if not.
84
54
    if req.app is not None and req.app not in conf.apps.app_url:
85
55
        # Maybe it is a special app!
86
56
        if req.app == 'logout':
87
57
            logout(req)
88
58
        else:
89
 
            req.throw_error(Request.HTTP_NOT_FOUND,
90
 
                "There is no application called %s." % repr(req.app))
 
59
            # TODO: Nicer 404 message?
 
60
            req.throw_error(Request.HTTP_NOT_FOUND)
91
61
 
92
62
    # Special handling for public mode - just call public app and get out
93
63
    # NOTE: This will not behave correctly if the public app uses
104
74
        app = conf.apps.app_url[req.app]
105
75
 
106
76
    # Check if app requires auth. If so, perform authentication and login.
107
 
    # This will either return a User object, None, or perform a redirect
108
 
    # which we will not catch here.
109
77
    if app.requireauth:
110
 
        req.user = login.login(req)
111
 
        logged_in = req.user is not None
 
78
        req.username = login.login(req)
 
79
        logged_in = req.username is not None
112
80
    else:
113
 
        req.user = login.get_user_details(req)
 
81
        req.username = login.get_username(req)
114
82
        logged_in = True
115
83
 
116
84
    if logged_in:
117
85
        # Keep the user's session alive by writing to the session object.
118
 
        # req.get_session().save()
119
 
        # Well, it's a fine idea, but it creates considerable grief in the
120
 
        # concurrent update department, so instead, we'll just make the
121
 
        # sessions not time out.
122
 
        
 
86
        req.get_session().save()
123
87
        # If user did not specify an app, HTTP redirect to default app and
124
88
        # exit.
125
89
        if req.app is None:
134
98
 
135
99
        # Call the specified app with the request object
136
100
        apps.call_app(app.dir, req)
137
 
 
138
101
    # if not logged in, login.login will have written the login box.
139
102
    # Just clean up and exit.
140
103
 
157
120
    session = req.get_session()
158
121
    session.invalidate()
159
122
    session.delete()
160
 
    req.add_cookie(forumutil.invalidated_forum_cookie())
161
123
    req.throw_redirect(util.make_path(''))
162
 
 
163
 
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
164
 
    """
165
 
    Given an exception that has just been thrown from IVLE, print its details
166
 
    to the request.
167
 
    This is a full handler. It assumes nothing has been written, and writes a
168
 
    complete HTML page.
169
 
    req: May be EITHER an IVLE req or an Apache req.
170
 
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
171
 
    the handler code may pass an apache req if an exception occurs before
172
 
    the IVLE request is created.
173
 
    """
174
 
    req.content_type = "text/html"
175
 
    # For some reason, some versions of mod_python have "_server" instead of
176
 
    # "main_server". So we check for both.
177
 
    try:
178
 
        admin_email = apache.main_server.server_admin
179
 
    except AttributeError:
180
 
        try:
181
 
            admin_email = apache._server.server_admin
182
 
        except AttributeError:
183
 
            admin_email = ""
184
 
    try:
185
 
        httpcode = exc_value.httpcode
186
 
        req.status = httpcode
187
 
    except AttributeError:
188
 
        httpcode = None
189
 
        req.status = apache.HTTP_INTERNAL_SERVER_ERROR
190
 
    # We handle 3 types of error.
191
 
    # IVLEErrors with 4xx response codes (client error).
192
 
    # IVLEErrors with 5xx response codes (handled server error).
193
 
    # Other exceptions (unhandled server error).
194
 
    # IVLEErrors should not have other response codes than 4xx or 5xx
195
 
    # (eg. throw_redirect should have been used for 3xx codes).
196
 
    # Therefore, that is treated as an unhandled error.
197
 
 
198
 
    if (exc_type == util.IVLEError and httpcode >= 400
199
 
        and httpcode <= 499):
200
 
        # IVLEErrors with 4xx response codes are client errors.
201
 
        # Therefore, these have a "nice" response (we even coat it in the IVLE
202
 
        # HTML wrappers).
203
 
        req.write_html_head_foot = True
204
 
        req.write('<div id="ivle_padding">\n')
205
 
        try:
206
 
            codename, msg = req.get_http_codename(httpcode)
207
 
        except AttributeError:
208
 
            codename, msg = None, None
209
 
        # Override the default message with the supplied one,
210
 
        # if available.
211
 
        if exc_value.message is not None:
212
 
            msg = exc_value.message
213
 
        if codename is not None:
214
 
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
215
 
        else:
216
 
            req.write("<h1>Error</h1>\n")
217
 
        if msg is not None:
218
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
219
 
        else:
220
 
            req.write("<p>An unknown error occured.</p>\n")
221
 
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
222
 
        req.write('</div>\n')
223
 
    else:
224
 
        # A "bad" error message. We shouldn't get here unless IVLE
225
 
        # misbehaves (which is currently very easy, if things aren't set up
226
 
        # correctly).
227
 
        # Write the traceback.
228
 
        # If this is a non-4xx IVLEError, get the message and httpcode and
229
 
        # make the error message a bit nicer (but still include the
230
 
        # traceback).
231
 
        # We also need to special-case IVLEJailError, as we can get another
232
 
        # almost-exception out of it.
233
 
 
234
 
        codename, msg = None, None
235
 
 
236
 
        if exc_type is util.IVLEJailError:
237
 
            msg = exc_value.type_str + ": " + exc_value.message
238
 
            tb = 'Exception information extracted from IVLEJailError:\n'
239
 
            tb += urllib.unquote(exc_value.info)
240
 
        else:
241
 
            try:
242
 
                codename, msg = req.get_http_codename(httpcode)
243
 
            except AttributeError:
244
 
                pass
245
 
            # Override the default message with the supplied one,
246
 
            # if available.
247
 
            if hasattr(exc_value, 'message') and exc_value.message is not None:
248
 
                msg = exc_value.message
249
 
                # Prepend the exception type
250
 
                if exc_type != util.IVLEError:
251
 
                    msg = exc_type.__name__ + ": " + msg
252
 
 
253
 
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
254
 
                                                    exc_traceback))
255
 
 
256
 
        req.write("""<html>
257
 
<head><title>IVLE Internal Server Error</title></head>
258
 
<body>
259
 
<h1>IVLE Internal Server Error""")
260
 
        if (codename is not None
261
 
            and httpcode != apache.HTTP_INTERNAL_SERVER_ERROR):
262
 
            req.write(": %s" % cgi.escape(codename))
263
 
        req.write("""</h1>
264
 
<p>An error has occured which is the fault of the IVLE developers or
265
 
administration.</p>
266
 
""")
267
 
        if msg is not None:
268
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
269
 
        if httpcode is not None:
270
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
271
 
        req.write("""
272
 
<p>Please report this to <a href="mailto:%s">%s</a> (the system
273
 
administrator). Include the following information:</p>
274
 
""" % (cgi.escape(admin_email), cgi.escape(admin_email)))
275
 
 
276
 
        req.write("<pre>\n")
277
 
        req.write(cgi.escape(tb))
278
 
        req.write("</pre>\n</body>\n")