← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/util.py

  • Committer: Matt Giuca
  • Date: 2009-05-13 03:18:42 UTC
  • mto: This revision was merged to the branch mainline in revision 1247.
  • Revision ID: matt.giuca@gmail.com-20090513031842-v24d9dvmog6adp2c
ivle-fetchsubmissions: Added -v option to print out submissions to stdout.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/util.py
22
22
# Contains common utility functions.
23
23
 
24
24
import os
25
 
import datetime
26
 
 
27
 
import ivle.conf
 
25
import sys
 
26
import stat
28
27
 
29
28
class IVLEError(Exception):
30
 
    """
31
 
    This is the "standard" exception class for IVLE errors.
32
 
    It is the ONLY exception which should propagate to the top - it will then
33
 
    be displayed to the user as an HTTP error with the given code.
34
 
 
35
 
    All other exceptions are considered IVLE bugs and should not occur
36
 
    (they will display a traceback).
37
 
 
38
 
    This error should not be raised directly. Call req.throw_error.
 
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.
39
33
    """
40
34
    def __init__(self, httpcode, message=None):
41
35
        self.httpcode = httpcode
43
37
        self.args = (httpcode, message)
44
38
 
45
39
class IVLEJailError(Exception):
46
 
    """
 
40
    """Exception proxying an in-jail error.
 
41
 
47
42
    This exception indicates an error that occurred inside an IVLE CGI script
48
43
    inside the jail. It should never be raised directly - only by the 
49
44
    interpreter.
66
61
    def __repr__(self):
67
62
        return "<Fake %s %s>"%(self.type, self.name)
68
63
 
69
 
def make_path(path):
70
 
    """Given a path relative to the IVLE root, makes the path relative to the
71
 
    site root using ivle.conf.root_dir. This path can be used in URLs sent to
72
 
    the client."""
73
 
    return os.path.join(ivle.conf.root_dir, path)
74
 
 
75
 
def unmake_path(path):
76
 
    """Given a path relative to the site root, makes the path relative to the
77
 
    IVLE root by removing ivle.conf.root_dir if it appears at the beginning. If
78
 
    it does not appear at the beginning, returns path unchanged. Also
79
 
    normalises the path."""
80
 
    path = os.path.normpath(path)
81
 
    root = os.path.normpath(ivle.conf.root_dir)
82
 
 
83
 
    if path.startswith(root):
84
 
        path = path[len(root):]
85
 
        # Take out the slash as well
86
 
        if len(path) > 0 and path[0] == os.sep:
87
 
            path = path[1:]
88
 
 
89
 
    return path
90
 
 
91
64
def split_path(path):
92
65
    """Given a path, returns a tuple consisting of the top-level directory in
93
66
    the path, and the rest of the path. Note that both items in the tuple will
123
96
    else:
124
97
        return tuple(splitpath)
125
98
 
 
99
def relpath(path, start=os.path.curdir):
 
100
    """Return a relative version of a path.
 
101
    XXX Backported from Python 2.6 posixpath.py.
 
102
    """
 
103
 
 
104
    if not path:
 
105
        raise ValueError("no path specified")
 
106
 
 
107
    start_list = os.path.abspath(start).split(os.path.sep)
 
108
    path_list = os.path.abspath(path).split(os.path.sep)
 
109
 
 
110
    # Work out how much of the filepath is shared by start and path.
 
111
    i = len(os.path.commonprefix([start_list, path_list]))
 
112
 
 
113
    rel_list = [os.path.pardir] * (len(start_list)-i) + path_list[i:]
 
114
    if not rel_list:
 
115
        return os.path.curdir
 
116
    return os.path.join(*rel_list)
 
117
 
126
118
def incomplete_utf8_sequence(byteseq):
127
 
    """
128
 
    str -> int
 
119
    """Calculate the completeness of a UTF-8 encoded string.
 
120
 
129
121
    Given a UTF-8-encoded byte sequence (str), returns the number of bytes at
130
122
    the end of the string which comprise an incomplete UTF-8 character
131
123
    sequence.
203
195
        return count
204
196
 
205
197
def object_to_dict(attrnames, obj):
206
 
    """
207
 
    Convert an object into a dictionary. This takes a shallow copy of the
208
 
    object.
209
 
    attrnames: Set (or iterable) of names of attributes to be copied into the
210
 
        dictionary. (We don't auto-lookup, because this function needs to be
211
 
        used on magical objects).
 
198
    """Convert an object into a dictionary.
 
199
 
 
200
    This takes a shallow copy of the object.
 
201
 
 
202
    @param attrnames: Set (or iterable) of names of attributes to be copied
 
203
                      into the dictionary. (We don't auto-lookup, because this
 
204
                      function needs to be used on magical objects).
212
205
    """
213
206
    return dict((k, getattr(obj, k))
214
207
        for k in attrnames if not k.startswith('_'))
 
208
 
 
209
def safe_rmtree(path, ignore_errors=False, onerror=None):
 
210
    """Recursively delete a directory tree.
 
211
 
 
212
    Copied from shutil.rmtree from Python 2.6, which does not follow symbolic
 
213
    links (it is otherwise unsafe to call as root on untrusted directories; do
 
214
    not use shutil.rmtree in this case, as you may be running Python 2.5).
 
215
 
 
216
    If ignore_errors is set, errors are ignored; otherwise, if onerror
 
217
    is set, it is called to handle the error with arguments (func,
 
218
    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
 
219
    path is the argument to that function that caused it to fail; and
 
220
    exc_info is a tuple returned by sys.exc_info().  If ignore_errors
 
221
    is false and onerror is None, an exception is raised.
 
222
 
 
223
    """
 
224
    if ignore_errors:
 
225
        def onerror(*args):
 
226
            pass
 
227
    elif onerror is None:
 
228
        def onerror(*args):
 
229
            raise
 
230
    try:
 
231
        if os.path.islink(path):
 
232
            # symlinks to directories are forbidden, see bug #1669
 
233
            raise OSError("Cannot call safe_rmtree on a symbolic link")
 
234
    except OSError:
 
235
        onerror(os.path.islink, path, sys.exc_info())
 
236
        # can't continue even if onerror hook returns
 
237
        return
 
238
    names = []
 
239
    try:
 
240
        names = os.listdir(path)
 
241
    except os.error, err:
 
242
        onerror(os.listdir, path, sys.exc_info())
 
243
    for name in names:
 
244
        fullname = os.path.join(path, name)
 
245
        try:
 
246
            mode = os.lstat(fullname).st_mode
 
247
        except os.error:
 
248
            mode = 0
 
249
        if stat.S_ISDIR(mode):
 
250
            safe_rmtree(fullname, ignore_errors, onerror)
 
251
        else:
 
252
            try:
 
253
                os.remove(fullname)
 
254
            except os.error, err:
 
255
                onerror(os.remove, fullname, sys.exc_info())
 
256
    try:
 
257
        os.rmdir(path)
 
258
    except os.error:
 
259
        onerror(os.rmdir, path, sys.exc_info())