← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/util.py

  • Committer: William Grant
  • Date: 2010-02-24 07:22:43 UTC
  • Revision ID: grantw@unimelb.edu.au-20100224072243-xq5w2we8iuoteen1
Reword and reformat the tour a bit.

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.
25
23
 
26
24
import os
27
 
import mimetypes
28
 
import datetime
29
 
 
30
 
import ivle.conf
31
 
import ivle.conf.mimetypes
 
25
import sys
 
26
import stat
32
27
 
33
28
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
 
    """
 
29
    """Legacy general IVLE exception.
 
30
 
 
31
    This is the old "standard" exception class for IVLE errors. It is only
 
32
    used in fileservice, and should not be used in any new code.
 
33
    """
 
34
 
 
35
    message = None
 
36
 
44
37
    def __init__(self, httpcode, message=None):
45
38
        self.httpcode = httpcode
46
39
        self.message = message
47
40
        self.args = (httpcode, message)
48
41
 
49
42
class IVLEJailError(Exception):
50
 
    """
 
43
    """Exception proxying an in-jail error.
 
44
 
51
45
    This exception indicates an error that occurred inside an IVLE CGI script
52
46
    inside the jail. It should never be raised directly - only by the 
53
47
    interpreter.
70
64
    def __repr__(self):
71
65
        return "<Fake %s %s>"%(self.type, self.name)
72
66
 
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
 
 
102
67
def split_path(path):
103
68
    """Given a path, returns a tuple consisting of the top-level directory in
104
69
    the path, and the rest of the path. Note that both items in the tuple will
134
99
    else:
135
100
        return tuple(splitpath)
136
101
 
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")
 
102
def relpath(path, start=os.path.curdir):
 
103
    """Return a relative version of a path.
 
104
    XXX Backported from Python 2.6 posixpath.py.
 
105
    """
 
106
 
 
107
    if not path:
 
108
        raise ValueError("no path specified")
 
109
 
 
110
    start_list = os.path.abspath(start).split(os.path.sep)
 
111
    path_list = os.path.abspath(path).split(os.path.sep)
 
112
 
 
113
    # Work out how much of the filepath is shared by start and path.
 
114
    i = len(os.path.commonprefix([start_list, path_list]))
 
115
 
 
116
    rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:]
 
117
    if not rel_list:
 
118
        return os.path.curdir
 
119
    return os.path.join(*rel_list)
216
120
 
217
121
def incomplete_utf8_sequence(byteseq):
218
 
    """
219
 
    str -> int
 
122
    """Calculate the completeness of a UTF-8 encoded string.
 
123
 
220
124
    Given a UTF-8-encoded byte sequence (str), returns the number of bytes at
221
125
    the end of the string which comprise an incomplete UTF-8 character
222
126
    sequence.
293
197
        # Incomplete
294
198
        return count
295
199
 
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('_'))
 
200
def safe_rmtree(path, ignore_errors=False, onerror=None):
 
201
    """Recursively delete a directory tree.
 
202
 
 
203
    Copied from shutil.rmtree from Python 2.6, which does not follow symbolic
 
204
    links (it is otherwise unsafe to call as root on untrusted directories; do
 
205
    not use shutil.rmtree in this case, as you may be running Python 2.5).
 
206
 
 
207
    If ignore_errors is set, errors are ignored; otherwise, if onerror
 
208
    is set, it is called to handle the error with arguments (func,
 
209
    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
 
210
    path is the argument to that function that caused it to fail; and
 
211
    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
 
212
    is false and onerror is None, an exception is raised.
 
213
 
 
214
    """
 
215
    if ignore_errors:
 
216
        def onerror(*args):
 
217
            pass
 
218
    elif onerror is None:
 
219
        def onerror(*args):
 
220
            raise
 
221
    try:
 
222
        if os.path.islink(path):
 
223
            # symlinks to directories are forbidden, see bug #1669
 
224
            raise OSError("Cannot call safe_rmtree on a symbolic link")
 
225
    except OSError:
 
226
        onerror(os.path.islink, path, sys.exc_info())
 
227
        # can't continue even if onerror hook returns
 
228
        return
 
229
    names = []
 
230
    try:
 
231
        names = os.listdir(path)
 
232
    except os.error, err:
 
233
        onerror(os.listdir, path, sys.exc_info())
 
234
    for name in names:
 
235
        fullname = os.path.join(path, name)
 
236
        try:
 
237
            mode = os.lstat(fullname).st_mode
 
238
        except os.error:
 
239
            mode = 0
 
240
        if stat.S_ISDIR(mode):
 
241
            safe_rmtree(fullname, ignore_errors, onerror)
 
242
        else:
 
243
            try:
 
244
                os.remove(fullname)
 
245
            except os.error, err:
 
246
                onerror(os.remove, fullname, sys.exc_info())
 
247
    try:
 
248
        os.rmdir(path)
 
249
    except os.error:
 
250
        onerror(os.rmdir, path, sys.exc_info())
 
251
 
 
252
def format_submission_principal(user, principal):
 
253
    """Render a list of users to fit in the offering project listing.
 
254
 
 
255
    Given a user and a list of submitters, returns 'solo' if the
 
256
    only submitter is the user, or a string of the form
 
257
    'with A, B and C' if there are any other submitters.
 
258
 
 
259
    If submitters is None, we assume that the list of members could
 
260
    not be determined, so we just return 'group'.
 
261
    """
 
262
    if principal is None:
 
263
        return 'group'
 
264
 
 
265
    if principal is user:
 
266
        return 'solo'
 
267
 
 
268
    display_names = sorted(
 
269
        member.display_name for member in principal.members
 
270
        if member is not user)
 
271
 
 
272
    if len(display_names) == 0:
 
273
        return 'solo (%s)' % principal.name
 
274
    elif len(display_names) == 1:
 
275
        return 'with %s (%s)' % (display_names[0], principal.name)
 
276
    elif len(display_names) > 5:
 
277
        return 'with %d others (%s)' % (len(display_names), principal.name)
 
278
    else:
 
279
        return 'with %s and %s (%s)' % (', '.join(display_names[:-1]),
 
280
                                        display_names[-1], principal.name)