← 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: David Coles
  • Date: 2009-08-02 08:57:44 UTC
  • mto: (1294.2.119 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: coles.david@gmail.com-20090802085744-ig0mr5fcm29ngibv
Show drop down icon for breadcrumbs with a sub-menu.

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.publisher import Publisher, PublishingError
 
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 = Publisher(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.
120
134
                errviewcls = XHTMLView.get_error_view(e)
121
135
 
122
136
            if errviewcls:
123
 
                errview = errviewcls(req, e)
 
137
                errview = errviewcls(req, e, obj)
124
138
                errview.render(req)
125
139
                return req.OK
126
140
            elif e.message:
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 PublishingError, e:
 
158
        req.status = 404
 
159
 
 
160
        if req.user.admin:
 
161
            XHTMLErrorView(req, NotFound('Not found: ' +
 
162
                                         str(e.args)), e[0]).render(req)
 
163
        else:
 
164
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
 
165
 
140
166
        return req.OK
141
167
 
142
168
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
150
176
    the IVLE request is created.
151
177
    """
152
178
    req.content_type = "text/html"
153
 
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
 
179
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
154
180
    logfail = False
 
181
 
 
182
    # XXX: This remains here for ivle.interpret's IVLEErrors. Once we rewrite
 
183
    #      fileservice, req.status should always be 500 (ISE) here.
155
184
    try:
156
185
        httpcode = exc_value.httpcode
157
186
        req.status = httpcode
158
187
    except AttributeError:
159
188
        httpcode = None
160
189
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
190
 
161
191
    try:
162
192
        publicmode = req.publicmode
163
193
    except AttributeError:
186
216
    # misbehaves (which is currently very easy, if things aren't set up
187
217
    # correctly).
188
218
    # Write the traceback.
189
 
    # If this is a non-4xx IVLEError, get the message and httpcode and
190
 
    # make the error message a bit nicer (but still include the
191
 
    # traceback).
192
 
    # We also need to special-case IVLEJailError, as we can get another
 
219
 
 
220
    # We need to special-case IVLEJailError, as we can get another
193
221
    # almost-exception out of it.
194
 
 
195
 
    codename, msg = None, None
196
 
 
197
222
    if exc_type is util.IVLEJailError:
198
 
        msg = exc_value.type_str + ": " + exc_value.message
199
223
        tb = 'Exception information extracted from IVLEJailError:\n'
200
224
        tb += urllib.unquote(exc_value.info)
201
225
    else:
202
 
        try:
203
 
            codename, msg = req.get_http_codename(httpcode)
204
 
        except AttributeError:
205
 
            pass
206
 
 
207
226
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
208
227
                                                exc_traceback))
209
228
 
210
 
    logging.error('%s\n%s'%(str(msg), tb))
 
229
    logging.error('\n' + tb)
211
230
 
212
231
    # Error messages are only displayed is the user is NOT a student,
213
232
    # or if there has been a problem logging the error message
217
236
<html xmlns="http://www.w3.org/1999/xhtml">
218
237
<head><title>IVLE Internal Server Error</title></head>
219
238
<body>
220
 
<h1>IVLE Internal Server Error""")
221
 
    if show_errors:
222
 
        if codename is not None and \
223
 
           httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR:
224
 
            req.write(": %s" % cgi.escape(codename))
225
 
 
226
 
    req.write("""</h1>
 
239
<h1>IVLE Internal Server Error</h1>
227
240
<p>An error has occured which is the fault of the IVLE developers or
228
241
administrators. """)
229
242
 
235
248
    req.write("</p>")
236
249
 
237
250
    if show_errors:
238
 
        if msg is not None:
239
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
240
 
        if httpcode is not None:
241
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
242
251
        req.write("<h2>Debugging information</h2>")
243
 
 
244
252
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
245
253
    req.write("</body></html>")