← 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: Matt Giuca
  • Date: 2009-02-24 02:02:03 UTC
  • mto: This revision was merged to the branch mainline in revision 1119.
  • Revision ID: matt.giuca@gmail.com-20090224020203-aqdcjnsj6y7wl32o
Added a new look to the IVLE header bar. Mmmm... Web 2.0.
Added top-level directory image-source, containing SVG and script files for
    generating the images.
ivle/webapp/coremedia/images: Added 'chrome' directory containing the rendered
    images.
Modified ivle/webapp/base/ivle-headings.html and
    ivle/webapp/coremedia/ivle.css to support the new images.
    Note that the H1 and H2 at the top of the page are no longer displayed
    (and their custom styles have been removed). There is a heading image
    instead.

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
40
41
 
41
42
from ivle import util
42
 
import ivle.config
 
43
import ivle.conf
43
44
from ivle.dispatch.request import Request
44
45
import ivle.webapp.security
45
46
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
46
47
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
47
48
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):
 
49
 
 
50
def generate_route_mapper(view_plugins, attr):
77
51
    """
78
52
    Build a Mapper object for doing URL matching using 'routes', based on the
79
53
    given plugin registry.
80
54
    """
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
    m = routes.Mapper(explicit=True)
95
56
    for plugin in view_plugins:
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
 
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
117
65
 
118
66
def handler(apachereq):
119
67
    """Handles an HTTP request.
123
71
    @param apachereq: An Apache request object.
124
72
    """
125
73
    # Make the request object into an IVLE request which can be given to views
126
 
    req = Request(apachereq, config)
 
74
    req = Request(apachereq)
127
75
 
128
76
    # Hack? Try and get the user login early just in case we throw an error
129
77
    # (most likely 404) to stop us seeing not logged in even when we are.
134
82
        if user and user.valid:
135
83
            req.user = user
136
84
 
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'))
 
85
    conf = ivle.config.Config()
 
86
    req.config = conf
 
87
 
 
88
    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']
144
102
        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
 
 
149
103
            # Instantiate the view, which should be a BaseView class
150
 
            view = viewcls(req, obj, subpath)
 
104
            view = viewcls(req, **kwargs)
151
105
 
152
106
            # Check that the request (mainly the user) is permitted to access
153
107
            # the view.
154
108
            if not view.authorize(req):
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
                raise Unauthorized()
160
110
            # Render the output
161
111
            view.render(req)
162
112
        except HTTPError, e:
170
120
                errviewcls = XHTMLView.get_error_view(e)
171
121
 
172
122
            if errviewcls:
173
 
                errview = errviewcls(req, e, obj)
 
123
                errview = errviewcls(req, e)
174
124
                errview.render(req)
175
125
                return req.OK
176
126
            elif e.message:
178
128
                return req.OK
179
129
            else:
180
130
                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
186
131
        except Exception, e:
187
132
            # A non-HTTPError appeared. We have an unknown exception. Panic.
188
133
            handle_unknown_exception(req, *sys.exc_info())
190
135
        else:
191
136
            req.store.commit()
192
137
            return req.OK
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
208
 
    finally:
209
 
        req.store.close()
 
138
    else:
 
139
        XHTMLErrorView(req, NotFound()).render(req)
 
140
        return req.OK
210
141
 
211
142
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
212
143
    """
219
150
    the IVLE request is created.
220
151
    """
221
152
    req.content_type = "text/html"
222
 
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
 
153
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
223
154
    logfail = False
224
 
 
225
 
    # XXX: This remains here for ivle.interpret's IVLEErrors. Once we rewrite
226
 
    #      fileservice, req.status should always be 500 (ISE) here.
227
155
    try:
228
156
        httpcode = exc_value.httpcode
229
157
        req.status = httpcode
230
158
    except AttributeError:
231
159
        httpcode = None
232
160
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
233
 
 
234
161
    try:
235
162
        publicmode = req.publicmode
236
163
    except AttributeError:
239
166
        login = req.user.login
240
167
    except AttributeError:
241
168
        login = None
 
169
    try:
 
170
        role = req.user.role
 
171
    except AttributeError:
 
172
        role = None
242
173
 
243
174
    # Log File
244
175
    try:
259
190
    # misbehaves (which is currently very easy, if things aren't set up
260
191
    # correctly).
261
192
    # Write the traceback.
262
 
 
263
 
    # We need to special-case IVLEJailError, as we can get another
 
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
264
197
    # almost-exception out of it.
 
198
 
 
199
    codename, msg = None, None
 
200
 
265
201
    if exc_type is util.IVLEJailError:
 
202
        msg = exc_value.type_str + ": " + exc_value.message
266
203
        tb = 'Exception information extracted from IVLEJailError:\n'
267
204
        tb += urllib.unquote(exc_value.info)
268
205
    else:
 
206
        try:
 
207
            codename, msg = req.get_http_codename(httpcode)
 
208
        except AttributeError:
 
209
            pass
 
210
 
269
211
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
270
212
                                                exc_traceback))
271
213
 
272
 
    logging.error('\n' + tb)
 
214
    logging.error('%s\n%s'%(str(msg), tb))
273
215
 
274
216
    # Error messages are only displayed is the user is NOT a student,
275
217
    # or if there has been a problem logging the error message
276
 
    show_errors = (not publicmode) and ((login and req.user.admin) or logfail)
 
218
    show_errors = (not publicmode) and ((login and \
 
219
                        str(role) != "student") or logfail)
277
220
    req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
278
221
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
279
222
<html xmlns="http://www.w3.org/1999/xhtml">
280
223
<head><title>IVLE Internal Server Error</title></head>
281
224
<body>
282
 
<h1>IVLE Internal Server Error</h1>
 
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>
283
232
<p>An error has occured which is the fault of the IVLE developers or
284
233
administrators. """)
285
234
 
291
240
    req.write("</p>")
292
241
 
293
242
    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)
294
247
        req.write("<h2>Debugging information</h2>")
 
248
 
295
249
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
296
250
    req.write("</body></html>")