← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/util.py

Add an XHTMLUnauthorizedView which redirects unauthenticated users to the
login page if a page raises an Unauthorized. Alter UserSettingsView to raise
one in the right cases, for testing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/util.py
20
20
# Date: 12/12/2007
21
21
 
22
22
# Contains common utility functions.
 
23
# Also initialises mime types library. You must import util before using
 
24
# Python's builtin mimetypes module to make sure local settings are applied.
23
25
 
24
26
import os
25
 
import sys
26
 
import stat
 
27
import mimetypes
 
28
import datetime
 
29
 
 
30
import ivle.conf
 
31
import ivle.conf.mimetypes
 
32
 
 
33
class IVLEError(Exception):
 
34
    """
 
35
    This is the "standard" exception class for IVLE errors.
 
36
    It is the ONLY exception which should propagate to the top - it will then
 
37
    be displayed to the user as an HTTP error with the given code.
 
38
 
 
39
    All other exceptions are considered IVLE bugs and should not occur
 
40
    (they will display a traceback).
 
41
 
 
42
    This error should not be raised directly. Call req.throw_error.
 
43
    """
 
44
    def __init__(self, httpcode, message=None):
 
45
        self.httpcode = httpcode
 
46
        self.message = message
 
47
        self.args = (httpcode, message)
27
48
 
28
49
class IVLEJailError(Exception):
29
 
    """Exception proxying an in-jail error.
30
 
 
 
50
    """
31
51
    This exception indicates an error that occurred inside an IVLE CGI script
32
52
    inside the jail. It should never be raised directly - only by the 
33
53
    interpreter.
50
70
    def __repr__(self):
51
71
        return "<Fake %s %s>"%(self.type, self.name)
52
72
 
 
73
 
 
74
def make_path(path):
 
75
    """Given a path relative to the IVLE root, makes the path relative to the
 
76
    site root using ivle.conf.root_dir. This path can be used in URLs sent to
 
77
    the client."""
 
78
    return os.path.join(ivle.conf.root_dir, path)
 
79
 
 
80
def make_local_path(path):
 
81
    """Given a path relative to the IVLE root, on the local file system, makes
 
82
    the path relative to the root using ivle.conf.share_path. This path can
 
83
    be used in reading files from the local file system."""
 
84
    return os.path.join(ivle.conf.share_path, 'www', path)
 
85
 
 
86
def unmake_path(path):
 
87
    """Given a path relative to the site root, makes the path relative to the
 
88
    IVLE root by removing ivle.conf.root_dir if it appears at the beginning. If
 
89
    it does not appear at the beginning, returns path unchanged. Also
 
90
    normalises the path."""
 
91
    path = os.path.normpath(path)
 
92
    root = os.path.normpath(ivle.conf.root_dir)
 
93
 
 
94
    if path.startswith(root):
 
95
        path = path[len(root):]
 
96
        # Take out the slash as well
 
97
        if len(path) > 0 and path[0] == os.sep:
 
98
            path = path[1:]
 
99
 
 
100
    return path
 
101
 
53
102
def split_path(path):
54
103
    """Given a path, returns a tuple consisting of the top-level directory in
55
104
    the path, and the rest of the path. Note that both items in the tuple will
85
134
    else:
86
135
        return tuple(splitpath)
87
136
 
88
 
def relpath(path, start=os.path.curdir):
89
 
    """Return a relative version of a path.
90
 
    XXX Backported from Python 2.6 posixpath.py.
91
 
    """
92
 
 
93
 
    if not path:
94
 
        raise ValueError("no path specified")
95
 
 
96
 
    start_list = os.path.abspath(start).split(os.path.sep)
97
 
    path_list = os.path.abspath(path).split(os.path.sep)
98
 
 
99
 
    # Work out how much of the filepath is shared by start and path.
100
 
    i = len(os.path.commonprefix([start_list, path_list]))
101
 
 
102
 
    rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:]
103
 
    if not rel_list:
104
 
        return os.path.curdir
105
 
    return os.path.join(*rel_list)
 
137
def open_exercise_file(exercisename):
 
138
    """Given an exercise name, opens the corresponding XML file for reading.
 
139
    Returns None if the exercise file was not found.
 
140
    (For tutorials / worksheets).
 
141
    """
 
142
    # First normalise the path
 
143
    exercisename = os.path.normpath(exercisename)
 
144
    # Now if it begins with ".." or separator, then it's illegal
 
145
    if exercisename.startswith("..") or exercisename.startswith(os.sep):
 
146
        exercisefile = None
 
147
    else:
 
148
        exercisefile = os.path.join(ivle.conf.exercises_base, exercisename)
 
149
 
 
150
    try:
 
151
        return open(exercisefile)
 
152
    except (TypeError, IOError):    # TypeError if exercisefile == None
 
153
        return None
 
154
 
 
155
# Initialise mime types library
 
156
mimetypes.init()
 
157
for (ext, mimetype) in ivle.conf.mimetypes.additional_mime_types.items():
 
158
    mimetypes.add_type(mimetype, ext)
 
159
 
 
160
def nice_filetype(filename):
 
161
    """Given a filename or basename, returns a "friendly" name for that
 
162
    file's type.
 
163
    eg. nice_mimetype("file.py") == "Python source code".
 
164
        nice_filetype("file.bzg") == "BZG file".
 
165
        nice_filetype("directory/") == "Directory".
 
166
    """
 
167
    if filename[-1] == os.sep:
 
168
        return "Directory"
 
169
    else:
 
170
        try:
 
171
            return ivle.conf.mimetypes.nice_mimetypes[
 
172
                mimetypes.guess_type(filename)[0]]
 
173
        except KeyError:
 
174
            filename = os.path.basename(filename)
 
175
            try:
 
176
                return filename[filename.rindex('.')+1:].upper() + " file"
 
177
            except ValueError:
 
178
                return "File"
 
179
 
 
180
def send_terms_of_service(req):
 
181
    """
 
182
    Sends the Terms of Service document to the req object.
 
183
    This consults conf to find out where the TOS is located on disk, and sends
 
184
    that. If it isn't found, it sends a generic message explaining to admins
 
185
    how to create a real one.
 
186
    """
 
187
    try:
 
188
        req.sendfile(ivle.conf.tos_path)
 
189
    except IOError:
 
190
        req.write(
 
191
"""<h1>Terms of Service</h1>
 
192
<p><b>*** SAMPLE ONLY ***</b></p>
 
193
<p>This is the text of the IVLE Terms of Service.</p>
 
194
<p>The administrator should create a license file with an appropriate
 
195
"Terms of Service" license for your organisation.</p>
 
196
<h2>Instructions for Administrators</h2>
 
197
<p>You are seeing this message because you have not configured a Terms of
 
198
Service document.</p>
 
199
<p>When you configured IVLE, you specified a path to the Terms of Service
 
200
document (this is found in <b><tt>ivle/conf/conf.py</tt></b> under
 
201
"<tt>tos_path</tt>").</p>
 
202
<p>Create a file at this location; an HTML file with the appropriately-worded
 
203
license.</p>
 
204
<p>This should be a normal XHTML file, except it should not contain
 
205
<tt>html</tt>, <tt>head</tt> or <tt>body</tt> elements - it should
 
206
just be the contents of a body element (IVLE will wrap it accordingly).</p>
 
207
<p>This will automatically be used as the license text instead of this
 
208
placeholder text.</p>
 
209
""")
 
210
 
 
211
def parse_iso8601(str):
 
212
    """Parses ISO8601 string into a datetime object."""
 
213
    # FIXME: Terrific hack that means we only accept the format that is 
 
214
    # produced by json.js module when it encodes date objects.
 
215
    return datetime.datetime.strptime(str, "%Y-%m-%dT%H:%M:%SZ")
106
216
 
107
217
def incomplete_utf8_sequence(byteseq):
108
 
    """Calculate the completeness of a UTF-8 encoded string.
109
 
 
 
218
    """
 
219
    str -> int
110
220
    Given a UTF-8-encoded byte sequence (str), returns the number of bytes at
111
221
    the end of the string which comprise an incomplete UTF-8 character
112
222
    sequence.
183
293
        # Incomplete
184
294
        return count
185
295
 
186
 
def safe_rmtree(path, ignore_errors=False, onerror=None):
187
 
    """Recursively delete a directory tree.
188
 
 
189
 
    Copied from shutil.rmtree from Python 2.6, which does not follow symbolic
190
 
    links (it is otherwise unsafe to call as root on untrusted directories; do
191
 
    not use shutil.rmtree in this case, as you may be running Python 2.5).
192
 
 
193
 
    If ignore_errors is set, errors are ignored; otherwise, if onerror
194
 
    is set, it is called to handle the error with arguments (func,
195
 
    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
196
 
    path is the argument to that function that caused it to fail; and
197
 
    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
198
 
    is false and onerror is None, an exception is raised.
199
 
 
200
 
    """
201
 
    if ignore_errors:
202
 
        def onerror(*args):
203
 
            pass
204
 
    elif onerror is None:
205
 
        def onerror(*args):
206
 
            raise
207
 
    try:
208
 
        if os.path.islink(path):
209
 
            # symlinks to directories are forbidden, see bug #1669
210
 
            raise OSError("Cannot call safe_rmtree on a symbolic link")
211
 
    except OSError:
212
 
        onerror(os.path.islink, path, sys.exc_info())
213
 
        # can't continue even if onerror hook returns
214
 
        return
215
 
    names = []
216
 
    try:
217
 
        names = os.listdir(path)
218
 
    except os.error, err:
219
 
        onerror(os.listdir, path, sys.exc_info())
220
 
    for name in names:
221
 
        fullname = os.path.join(path, name)
222
 
        try:
223
 
            mode = os.lstat(fullname).st_mode
224
 
        except os.error:
225
 
            mode = 0
226
 
        if stat.S_ISDIR(mode):
227
 
            safe_rmtree(fullname, ignore_errors, onerror)
228
 
        else:
229
 
            try:
230
 
                os.remove(fullname)
231
 
            except os.error, err:
232
 
                onerror(os.remove, fullname, sys.exc_info())
233
 
    try:
234
 
        os.rmdir(path)
235
 
    except os.error:
236
 
        onerror(os.rmdir, path, sys.exc_info())
237
 
 
238
 
def format_submission_principal(user, principal):
239
 
    """Render a list of users to fit in the offering project listing.
240
 
 
241
 
    Given a user and a list of submitters, returns 'solo' if the
242
 
    only submitter is the user, or a string of the form
243
 
    'with A, B and C' if there are any other submitters.
244
 
 
245
 
    If submitters is None, we assume that the list of members could
246
 
    not be determined, so we just return 'group'.
247
 
    """
248
 
    if principal is None:
249
 
        return 'group'
250
 
 
251
 
    if principal is user:
252
 
        return 'solo'
253
 
 
254
 
    display_names = sorted(
255
 
        member.display_name for member in principal.members
256
 
        if member is not user)
257
 
 
258
 
    if len(display_names) == 0:
259
 
        return 'solo (%s)' % principal.name
260
 
    elif len(display_names) == 1:
261
 
        return 'with %s (%s)' % (display_names[0], principal.name)
262
 
    elif len(display_names) > 5:
263
 
        return 'with %d others (%s)' % (len(display_names), principal.name)
264
 
    else:
265
 
        return 'with %s and %s (%s)' % (', '.join(display_names[:-1]),
266
 
                                        display_names[-1], principal.name)
 
296
def object_to_dict(attrnames, obj):
 
297
    """
 
298
    Convert an object into a dictionary. This takes a shallow copy of the
 
299
    object.
 
300
    attrnames: Set (or iterable) of names of attributes to be copied into the
 
301
        dictionary. (We don't auto-lookup, because this function needs to be
 
302
        used on magical objects).
 
303
    """
 
304
    return dict((k, getattr(obj, k))
 
305
        for k in attrnames if not k.startswith('_'))