← 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: 2010-02-18 08:13:32 UTC
  • Revision ID: matt.giuca@gmail.com-20100218081332-2tw8i5sa5j3lxtlb
https://launchpad.net/bugs/523654
fileservice_lib.listing: Deleted a stupid line which took a path, treated it as a URL, and took the path segment out. This fixes launchpad bug #523654 -- files with # in their name, and presumably other characters, can't open a dir listing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
 
1
# IVLE - Informatics Virtual Learning Environment
 
2
# Copyright (C) 2007-2009 The University of Melbourne
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 
 
18
# Author: Matt Giuca, Will Grant
 
19
 
 
20
"""
 
21
This is a mod_python handler program. The correct way to call it is to have
 
22
Apache send all requests to be handled by the module 'dispatch'.
 
23
 
 
24
Top-level handler. Handles all requests to all pages in IVLE.
 
25
Handles authentication and delegates to views for authorization,
 
26
then passes the request along to the appropriate view.
 
27
"""
 
28
 
 
29
import sys
 
30
import os
 
31
import os.path
 
32
import urllib
 
33
import cgi
 
34
import traceback
 
35
import logging
 
36
import socket
 
37
import time
 
38
 
 
39
import mod_python
 
40
 
 
41
from ivle import util
 
42
import ivle.config
 
43
from ivle.dispatch.request import Request
 
44
import ivle.webapp.security
 
45
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
 
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):
 
77
    """
 
78
    Build a Mapper object for doing URL matching using 'routes', based on the
 
79
    given plugin registry.
 
80
    """
 
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
 
 
95
    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
 
117
 
 
118
def handler(apachereq):
 
119
    """Handles an HTTP request.
 
120
 
 
121
    Intended to be called by mod_python, as a handler.
 
122
 
 
123
    @param apachereq: An Apache request object.
 
124
    """
 
125
    # Make the request object into an IVLE request which can be given to views
 
126
    req = Request(apachereq, config)
 
127
 
 
128
    # Hack? Try and get the user login early just in case we throw an error
 
129
    # (most likely 404) to stop us seeing not logged in even when we are.
 
130
    if not req.publicmode:
 
131
        user = ivle.webapp.security.get_user_details(req)
 
132
 
 
133
        # Don't set the user if it is disabled or hasn't accepted the ToS.
 
134
        if user and user.valid:
 
135
            req.user = user
 
136
 
 
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'))
 
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
 
 
149
            # Instantiate the view, which should be a BaseView class
 
150
            view = viewcls(req, obj, subpath)
 
151
 
 
152
            # Check that the request (mainly the user) is permitted to access
 
153
            # the view.
 
154
            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()
 
160
            # Render the output
 
161
            view.render(req)
 
162
        except HTTPError, e:
 
163
            # A view explicitly raised an HTTP error. Respect it.
 
164
            req.status = e.code
 
165
 
 
166
            # Try to find a custom error view.
 
167
            if hasattr(viewcls, 'get_error_view'):
 
168
                errviewcls = viewcls.get_error_view(e)
 
169
            else:
 
170
                errviewcls = XHTMLView.get_error_view(e)
 
171
 
 
172
            if errviewcls:
 
173
                errview = errviewcls(req, e, obj)
 
174
                errview.render(req)
 
175
                return req.OK
 
176
            elif e.message:
 
177
                req.write(e.message)
 
178
                return req.OK
 
179
            else:
 
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
 
186
        except Exception, e:
 
187
            # A non-HTTPError appeared. We have an unknown exception. Panic.
 
188
            handle_unknown_exception(req, *sys.exc_info())
 
189
            return req.OK
 
190
        else:
 
191
            req.store.commit()
 
192
            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()
 
210
 
 
211
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
 
212
    """
 
213
    Given an exception that has just been thrown from IVLE, print its details
 
214
    to the request.
 
215
    This is a full handler. It assumes nothing has been written, and writes a
 
216
    complete HTML page.
 
217
    req: May be EITHER an IVLE req or an Apache req.
 
218
    The handler code may pass an apache req if an exception occurs before
 
219
    the IVLE request is created.
 
220
    """
 
221
    req.content_type = "text/html"
 
222
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
 
223
    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
    try:
 
228
        httpcode = exc_value.httpcode
 
229
        req.status = httpcode
 
230
    except AttributeError:
 
231
        httpcode = None
 
232
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
233
 
 
234
    try:
 
235
        publicmode = req.publicmode
 
236
    except AttributeError:
 
237
        publicmode = True
 
238
    try:
 
239
        login = req.user.login
 
240
    except AttributeError:
 
241
        login = None
 
242
 
 
243
    # Log File
 
244
    try:
 
245
        for h in logging.getLogger().handlers:
 
246
            logging.getLogger().removeHandler(h)
 
247
        logging.basicConfig(level=logging.INFO,
 
248
            format='%(asctime)s %(levelname)s: ' +
 
249
                '(HTTP: ' + str(req.status) +
 
250
                ', Ref: ' + str(login) + '@' +
 
251
                str(socket.gethostname()) + str(req.uri) +
 
252
                ') %(message)s',
 
253
            filename=logfile,
 
254
            filemode='a')
 
255
    except IOError:
 
256
        logfail = True
 
257
 
 
258
    # A "bad" error message. We shouldn't get here unless IVLE
 
259
    # misbehaves (which is currently very easy, if things aren't set up
 
260
    # correctly).
 
261
    # Write the traceback.
 
262
 
 
263
    # We need to special-case IVLEJailError, as we can get another
 
264
    # almost-exception out of it.
 
265
    if exc_type is util.IVLEJailError:
 
266
        tb = 'Exception information extracted from IVLEJailError:\n'
 
267
        tb += urllib.unquote(exc_value.info)
 
268
    else:
 
269
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
 
270
                                                exc_traceback))
 
271
 
 
272
    logging.error('\n' + tb)
 
273
 
 
274
    # Error messages are only displayed is the user is NOT a student,
 
275
    # or if there has been a problem logging the error message
 
276
    show_errors = (not publicmode) and ((login and req.user.admin) or logfail)
 
277
    req.write("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"                 
 
278
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">                                      
 
279
<html xmlns="http://www.w3.org/1999/xhtml">
 
280
<head><title>IVLE Internal Server Error</title></head>
 
281
<body>
 
282
<h1>IVLE Internal Server Error</h1>
 
283
<p>An error has occured which is the fault of the IVLE developers or
 
284
administrators. """)
 
285
 
 
286
    if logfail:
 
287
        req.write("Please report this issue to the server administrators, "
 
288
                  "along with the following information.")
 
289
    else:
 
290
        req.write("Details have been logged for further examination.")
 
291
    req.write("</p>")
 
292
 
 
293
    if show_errors:
 
294
        req.write("<h2>Debugging information</h2>")
 
295
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
 
296
    req.write("</body></html>")