← 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-02-26 02:55:51 UTC
  • Revision ID: grantw@unimelb.edu.au-20090226025551-hofgfw6e7h3pt54i
Tags: 0.1.9.2, 0.1.9.3, 0.1.9.4
Move the group admin view to per-offering.

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
 
def generate_publisher(view_plugins, root):
 
49
 
 
50
def generate_route_mapper(view_plugins, attr):
54
51
    """
55
52
    Build a Mapper object for doing URL matching using 'routes', based on the
56
53
    given plugin registry.
57
54
    """
58
 
    r = Publisher(root=root)
59
 
 
60
 
    r.add_set_switch('api', 'api')
61
 
 
 
55
    m = routes.Mapper(explicit=True)
62
56
    for plugin in view_plugins:
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
 
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
84
65
 
85
66
def handler(apachereq):
86
67
    """Handles an HTTP request.
90
71
    @param apachereq: An Apache request object.
91
72
    """
92
73
    # Make the request object into an IVLE request which can be given to views
93
 
    req = Request(apachereq, config)
 
74
    req = Request(apachereq)
94
75
 
95
76
    # Hack? Try and get the user login early just in case we throw an error
96
77
    # (most likely 404) to stop us seeing not logged in even when we are.
101
82
        if user and user.valid:
102
83
            req.user = user
103
84
 
 
85
    conf = ivle.config.Config()
 
86
    req.config = conf
 
87
 
104
88
    if req.publicmode:
105
 
        raise NotImplementedError("no public mode with obtrav yet!")
106
 
 
107
 
    req.publisher = generate_publisher(config.plugin_index[ViewPlugin],
108
 
                                 ApplicationRoot(req.config, req.store))
109
 
 
110
 
    try:
111
 
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
 
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']
112
102
        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
 
 
117
103
            # Instantiate the view, which should be a BaseView class
118
 
            view = viewcls(req, obj, subpath)
 
104
            view = viewcls(req, **kwargs)
119
105
 
120
106
            # Check that the request (mainly the user) is permitted to access
121
107
            # the view.
134
120
                errviewcls = XHTMLView.get_error_view(e)
135
121
 
136
122
            if errviewcls:
137
 
                errview = errviewcls(req, e, obj)
 
123
                errview = errviewcls(req, e)
138
124
                errview.render(req)
139
125
                return req.OK
140
126
            elif e.message:
142
128
                return req.OK
143
129
            else:
144
130
                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
150
131
        except Exception, e:
151
132
            # A non-HTTPError appeared. We have an unknown exception. Panic.
152
133
            handle_unknown_exception(req, *sys.exc_info())
154
135
        else:
155
136
            req.store.commit()
156
137
            return req.OK
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
 
 
 
138
    else:
 
139
        XHTMLErrorView(req, NotFound()).render(req)
166
140
        return req.OK
167
141
 
168
142
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
176
150
    the IVLE request is created.
177
151
    """
178
152
    req.content_type = "text/html"
179
 
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
 
153
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
180
154
    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.
184
155
    try:
185
156
        httpcode = exc_value.httpcode
186
157
        req.status = httpcode
187
158
    except AttributeError:
188
159
        httpcode = None
189
160
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
190
 
 
191
161
    try:
192
162
        publicmode = req.publicmode
193
163
    except AttributeError:
216
186
    # misbehaves (which is currently very easy, if things aren't set up
217
187
    # correctly).
218
188
    # Write the traceback.
219
 
 
220
 
    # We need to special-case IVLEJailError, as we can get another
 
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
221
193
    # almost-exception out of it.
 
194
 
 
195
    codename, msg = None, None
 
196
 
222
197
    if exc_type is util.IVLEJailError:
 
198
        msg = exc_value.type_str + ": " + exc_value.message
223
199
        tb = 'Exception information extracted from IVLEJailError:\n'
224
200
        tb += urllib.unquote(exc_value.info)
225
201
    else:
 
202
        try:
 
203
            codename, msg = req.get_http_codename(httpcode)
 
204
        except AttributeError:
 
205
            pass
 
206
 
226
207
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
227
208
                                                exc_traceback))
228
209
 
229
 
    logging.error('\n' + tb)
 
210
    logging.error('%s\n%s'%(str(msg), tb))
230
211
 
231
212
    # Error messages are only displayed is the user is NOT a student,
232
213
    # or if there has been a problem logging the error message
236
217
<html xmlns="http://www.w3.org/1999/xhtml">
237
218
<head><title>IVLE Internal Server Error</title></head>
238
219
<body>
239
 
<h1>IVLE Internal Server Error</h1>
 
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>
240
227
<p>An error has occured which is the fault of the IVLE developers or
241
228
administrators. """)
242
229
 
248
235
    req.write("</p>")
249
236
 
250
237
    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)
251
242
        req.write("<h2>Debugging information</h2>")
 
243
 
252
244
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
253
245
    req.write("</body></html>")