← 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 07:54:29 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-20090705075429-qyh9midyp0v73gnv
Add export details for the breadcrumb chevron SVG.

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
42
import ivle.config
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
 
48
from ivle.webapp.routing import Router, RoutingError
 
49
from ivle.webapp import ApplicationRoot
49
50
 
50
51
config = ivle.config.Config()
51
52
 
52
 
def generate_router(view_plugins, attr):
 
53
def generate_router(view_plugins, root):
53
54
    """
54
55
    Build a Mapper object for doing URL matching using 'routes', based on the
55
56
    given plugin registry.
56
57
    """
57
 
    m = routes.Mapper(explicit=True)
 
58
    r = Router(root=root)
 
59
 
 
60
    r.add_set_switch('api', 'api')
 
61
 
58
62
    for plugin in view_plugins:
59
 
        # Establish a URL pattern for each element of plugin.urls
60
 
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
61
 
        for url in getattr(plugin, attr):
62
 
            routex = url[0]
63
 
            view_class = url[1]
64
 
            kwargs_dict = url[2] if len(url) >= 3 else {}
65
 
            m.connect(routex, view=view_class, **kwargs_dict)
66
 
    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
67
84
 
68
85
def handler(apachereq):
69
86
    """Handles an HTTP request.
85
102
            req.user = user
86
103
 
87
104
    if req.publicmode:
88
 
        req.mapper = generate_router(config.plugin_index[PublicViewPlugin],
89
 
                                    'public_urls')
90
 
    else:
91
 
        req.mapper = generate_router(config.plugin_index[ViewPlugin], 'urls')
92
 
 
93
 
    matchdict = req.mapper.match(req.uri)
94
 
    if matchdict is not None:
95
 
        viewcls = matchdict['view']
96
 
        # Get the remaining arguments, less 'view', 'action' and 'controller'
97
 
        # (The latter two seem to be built-in, and we don't want them).
98
 
        kwargs = matchdict.copy()
99
 
        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'))
100
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
 
101
117
            # Instantiate the view, which should be a BaseView class
102
 
            view = viewcls(req, **kwargs)
 
118
            view = viewcls(req, obj, subpath)
103
119
 
104
120
            # Check that the request (mainly the user) is permitted to access
105
121
            # the view.
138
154
        else:
139
155
            req.store.commit()
140
156
            return req.OK
141
 
    else:
142
 
        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
 
143
164
        return req.OK
144
165
 
145
166
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
155
176
    req.content_type = "text/html"
156
177
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
157
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.
158
182
    try:
159
183
        httpcode = exc_value.httpcode
160
184
        req.status = httpcode
161
185
    except AttributeError:
162
186
        httpcode = None
163
187
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
188
 
164
189
    try:
165
190
        publicmode = req.publicmode
166
191
    except AttributeError:
189
214
    # misbehaves (which is currently very easy, if things aren't set up
190
215
    # correctly).
191
216
    # Write the traceback.
192
 
    # If this is a non-4xx IVLEError, get the message and httpcode and
193
 
    # make the error message a bit nicer (but still include the
194
 
    # traceback).
195
 
    # 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
196
219
    # almost-exception out of it.
197
 
 
198
 
    codename, msg = None, None
199
 
 
200
220
    if exc_type is util.IVLEJailError:
201
 
        msg = exc_value.type_str + ": " + exc_value.message
202
221
        tb = 'Exception information extracted from IVLEJailError:\n'
203
222
        tb += urllib.unquote(exc_value.info)
204
223
    else:
205
 
        try:
206
 
            codename, msg = req.get_http_codename(httpcode)
207
 
        except AttributeError:
208
 
            pass
209
 
 
210
224
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
211
225
                                                exc_traceback))
212
226
 
213
 
    logging.error('%s\n%s'%(str(msg), tb))
 
227
    logging.error('\n' + tb)
214
228
 
215
229
    # Error messages are only displayed is the user is NOT a student,
216
230
    # or if there has been a problem logging the error message
220
234
<html xmlns="http://www.w3.org/1999/xhtml">
221
235
<head><title>IVLE Internal Server Error</title></head>
222
236
<body>
223
 
<h1>IVLE Internal Server Error""")
224
 
    if show_errors:
225
 
        if codename is not None and \
226
 
           httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR:
227
 
            req.write(": %s" % cgi.escape(codename))
228
 
 
229
 
    req.write("""</h1>
 
237
<h1>IVLE Internal Server Error</h1>
230
238
<p>An error has occured which is the fault of the IVLE developers or
231
239
administrators. """)
232
240
 
238
246
    req.write("</p>")
239
247
 
240
248
    if show_errors:
241
 
        if msg is not None:
242
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
243
 
        if httpcode is not None:
244
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
245
249
        req.write("<h2>Debugging information</h2>")
246
 
 
247
250
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
248
251
    req.write("</body></html>")