← 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-07-05 12:11:48 UTC
  • mto: (1294.4.2 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: grantw@unimelb.edu.au-20090705121148-9z2x7kk92ox2ncqi
Replace the breadcrumb-h1 with proper breadcrumbs throughout the filesystem views.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
37
37
import time
38
38
 
39
39
import mod_python
40
 
import routes
41
40
 
42
41
from ivle import util
43
 
import ivle.conf
 
42
import ivle.config
44
43
from ivle.dispatch.request import Request
45
44
import ivle.webapp.security
46
45
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
47
46
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
48
47
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
49
 
 
50
 
def generate_route_mapper(view_plugins, attr):
 
48
from ivle.webapp.routing import Router, RoutingError
 
49
from ivle.webapp import ApplicationRoot
 
50
 
 
51
config = ivle.config.Config()
 
52
 
 
53
def generate_router(view_plugins, root):
51
54
    """
52
55
    Build a Mapper object for doing URL matching using 'routes', based on the
53
56
    given plugin registry.
54
57
    """
55
 
    m = routes.Mapper(explicit=True)
 
58
    r = Router(root=root)
 
59
 
 
60
    r.add_set_switch('api', 'api')
 
61
 
56
62
    for plugin in view_plugins:
57
 
        # Establish a URL pattern for each element of plugin.urls
58
 
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
59
 
        for url in getattr(plugin, attr):
60
 
            routex = url[0]
61
 
            view_class = url[1]
62
 
            kwargs_dict = url[2] if len(url) >= 3 else {}
63
 
            m.connect(routex, view=view_class, **kwargs_dict)
64
 
    return m
 
63
        if hasattr(plugin, 'forward_routes'):
 
64
            for fr in plugin.forward_routes:
 
65
                # An annotated function can also be passed in directly.
 
66
                if hasattr(fr, '_forward_route_meta'):
 
67
                    r.add_forward_func(fr)
 
68
                else:
 
69
                    r.add_forward(*fr)
 
70
 
 
71
        if hasattr(plugin, 'reverse_routes'):
 
72
            for rr in plugin.reverse_routes:
 
73
                # An annotated function can also be passed in directly.
 
74
                if hasattr(rr, '_reverse_route_src'):
 
75
                    r.add_reverse_func(rr)
 
76
                else:
 
77
                    r.add_reverse(*rr)
 
78
 
 
79
        if hasattr(plugin, 'views'):
 
80
            for v in plugin.views:
 
81
                r.add_view(*v)
 
82
 
 
83
    return r
65
84
 
66
85
def handler(apachereq):
67
86
    """Handles an HTTP request.
71
90
    @param apachereq: An Apache request object.
72
91
    """
73
92
    # Make the request object into an IVLE request which can be given to views
74
 
    req = Request(apachereq)
 
93
    req = Request(apachereq, config)
75
94
 
76
95
    # Hack? Try and get the user login early just in case we throw an error
77
96
    # (most likely 404) to stop us seeing not logged in even when we are.
82
101
        if user and user.valid:
83
102
            req.user = user
84
103
 
85
 
    conf = ivle.config.Config()
86
 
    req.config = conf
87
 
 
88
104
    if req.publicmode:
89
 
        req.mapper = generate_route_mapper(conf.plugin_index[PublicViewPlugin],
90
 
                                           'public_urls')
91
 
    else:
92
 
        req.mapper = generate_route_mapper(conf.plugin_index[ViewPlugin],
93
 
                                           'urls')
94
 
 
95
 
    matchdict = req.mapper.match(req.uri)
96
 
    if matchdict is not None:
97
 
        viewcls = matchdict['view']
98
 
        # Get the remaining arguments, less 'view', 'action' and 'controller'
99
 
        # (The latter two seem to be built-in, and we don't want them).
100
 
        kwargs = matchdict.copy()
101
 
        del kwargs['view']
 
105
        raise NotImplementedError("no public mode with obtrav yet!")
 
106
 
 
107
    req.router = generate_router(config.plugin_index[ViewPlugin],
 
108
                                 ApplicationRoot(req.config, req.store))
 
109
 
 
110
    try:
 
111
        obj, viewcls, subpath = req.router.resolve(req.uri.decode('utf-8'))
102
112
        try:
 
113
            # We 404 if we have a subpath but the view forbids it.
 
114
            if not viewcls.subpath_allowed and subpath:
 
115
                raise NotFound()
 
116
 
103
117
            # Instantiate the view, which should be a BaseView class
104
 
            view = viewcls(req, **kwargs)
 
118
            view = viewcls(req, obj, subpath)
105
119
 
106
120
            # Check that the request (mainly the user) is permitted to access
107
121
            # the view.
128
142
                return req.OK
129
143
            else:
130
144
                return e.code
 
145
        except mod_python.apache.SERVER_RETURN:
 
146
            # A mod_python-specific Apache error.
 
147
            # XXX: We need to raise these because req.throw_error() uses them.
 
148
            # Remove this after Google Code issue 117 is fixed.
 
149
            raise
131
150
        except Exception, e:
132
151
            # A non-HTTPError appeared. We have an unknown exception. Panic.
133
152
            handle_unknown_exception(req, *sys.exc_info())
135
154
        else:
136
155
            req.store.commit()
137
156
            return req.OK
138
 
    else:
139
 
        XHTMLErrorView(req, NotFound()).render(req)
 
157
    except RoutingError, e:
 
158
        if req.user.admin:
 
159
            XHTMLErrorView(req, NotFound('Not found: ' +
 
160
                                         str(e.args))).render(req)
 
161
        else:
 
162
            XHTMLErrorView(req, NotFound()).render(req)
 
163
 
140
164
        return req.OK
141
165
 
142
166
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
150
174
    the IVLE request is created.
151
175
    """
152
176
    req.content_type = "text/html"
153
 
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
 
177
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
154
178
    logfail = False
 
179
 
 
180
    # XXX: This remains here for ivle.interpret's IVLEErrors. Once we rewrite
 
181
    #      fileservice, req.status should always be 500 (ISE) here.
155
182
    try:
156
183
        httpcode = exc_value.httpcode
157
184
        req.status = httpcode
158
185
    except AttributeError:
159
186
        httpcode = None
160
187
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
188
 
161
189
    try:
162
190
        publicmode = req.publicmode
163
191
    except AttributeError:
166
194
        login = req.user.login
167
195
    except AttributeError:
168
196
        login = None
169
 
    try:
170
 
        role = req.user.role
171
 
    except AttributeError:
172
 
        role = None
173
197
 
174
198
    # Log File
175
199
    try:
190
214
    # misbehaves (which is currently very easy, if things aren't set up
191
215
    # correctly).
192
216
    # Write the traceback.
193
 
    # If this is a non-4xx IVLEError, get the message and httpcode and
194
 
    # make the error message a bit nicer (but still include the
195
 
    # traceback).
196
 
    # We also need to special-case IVLEJailError, as we can get another
 
217
 
 
218
    # We need to special-case IVLEJailError, as we can get another
197
219
    # almost-exception out of it.
198
 
 
199
 
    codename, msg = None, None
200
 
 
201
220
    if exc_type is util.IVLEJailError:
202
 
        msg = exc_value.type_str + ": " + exc_value.message
203
221
        tb = 'Exception information extracted from IVLEJailError:\n'
204
222
        tb += urllib.unquote(exc_value.info)
205
223
    else:
206
 
        try:
207
 
            codename, msg = req.get_http_codename(httpcode)
208
 
        except AttributeError:
209
 
            pass
210
 
 
211
224
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
212
225
                                                exc_traceback))
213
226
 
214
 
    logging.error('%s\n%s'%(str(msg), tb))
 
227
    logging.error('\n' + tb)
215
228
 
216
229
    # Error messages are only displayed is the user is NOT a student,
217
230
    # or if there has been a problem logging the error message
218
 
    show_errors = (not publicmode) and ((login and \
219
 
                        str(role) != "student") or logfail)
 
231
    show_errors = (not publicmode) and ((login and req.user.admin) or logfail)
220
232
    req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
221
233
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
222
234
<html xmlns="http://www.w3.org/1999/xhtml">
223
235
<head><title>IVLE Internal Server Error</title></head>
224
236
<body>
225
 
<h1>IVLE Internal Server Error""")
226
 
    if show_errors:
227
 
        if codename is not None and \
228
 
           httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR:
229
 
            req.write(": %s" % cgi.escape(codename))
230
 
 
231
 
    req.write("""</h1>
 
237
<h1>IVLE Internal Server Error</h1>
232
238
<p>An error has occured which is the fault of the IVLE developers or
233
239
administrators. """)
234
240
 
240
246
    req.write("</p>")
241
247
 
242
248
    if show_errors:
243
 
        if msg is not None:
244
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
245
 
        if httpcode is not None:
246
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
247
249
        req.write("<h2>Debugging information</h2>")
248
 
 
249
250
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
250
251
    req.write("</body></html>")