← 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: 2010-02-17 06:48:28 UTC
  • Revision ID: grantw@unimelb.edu.au-20100217064828-dr43acvapzj45lic
Add a tiny bit of descriptive text to +clone-worksheets.

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