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

« back to all changes in this revision

Viewing changes to lib/fileservice_lib/action.py

  • Committer: wagrant
  • Date: 2008-08-19 12:49:58 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:1031
Example worksheets: Fix the element names in worksheet 1 to be actually
                    correct. Also fix the first exercise so it too
                    functions properly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# IVLE
 
2
# Copyright (C) 2007-2008 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
# Module: File Service / Action
 
19
# Author: Matt Giuca
 
20
# Date: 10/1/2008
 
21
 
 
22
# Handles actions requested by the client as part of the 2-stage process of
 
23
# fileservice (the second part being the return listing).
 
24
 
 
25
### Actions ###
 
26
 
 
27
# The most important argument is "action". This determines which action is
 
28
# taken. Note that action, and all other arguments, are ignored unless the
 
29
# request is a POST request. The other arguments depend upon the action.
 
30
# Note that paths are often specified as arguments. Paths that begin with a
 
31
# slash are taken relative to the user's home directory (the top-level
 
32
# directory seen when fileservice has no arguments or path). Paths without a
 
33
# slash are taken relative to the specified path.
 
34
 
 
35
# action=remove: Delete a file(s) or directory(s) (recursively).
 
36
#       path:   The path to the file or directory to delete. Can be specified
 
37
#               multiple times.
 
38
#
 
39
# action=move: Move or rename a file or directory.
 
40
#       from:   The path to the file or directory to be renamed.
 
41
#       to:     The path of the target filename. Error if the file already
 
42
#               exists.
 
43
#
 
44
# action=putfile: Upload a file to the student workspace.
 
45
#       path:   The path to the file to be written. Error if the target
 
46
#               file is a directory.
 
47
#       data:   Bytes to be written to the file verbatim. May either be
 
48
#               a string variable or a file upload.
 
49
#       overwrite: Optional. If supplied, the file will be overwritten.
 
50
#               Otherwise, error if path already exists.
 
51
#
 
52
# action=putfiles: Upload multiple files to the student workspace, and
 
53
#                 optionally accept zip files which will be unpacked.
 
54
#       path:   The path to the DIRECTORY to place files in. Must not be a
 
55
#               file.
 
56
#       data:   A file upload (may not be a simple string). The filename
 
57
#               will be used to determine the target filename within
 
58
#               the given path.
 
59
#       unpack: Optional. If supplied, if any data is a valid ZIP file,
 
60
#               will create a directory instead and unpack the ZIP file
 
61
#               into it.
 
62
#
 
63
# action=mkdir: Create a directory. The parent dir must exist.
 
64
#       path:   The path to a file which does not exist, but whose parent
 
65
#               does. The dir will be made with this name.
 
66
#
 
67
# The differences between putfile and putfiles are:
 
68
# * putfile can only accept a single file, and can't unpack zipfiles.
 
69
# * putfile can accept string data, doesn't have to be a file upload.
 
70
# * putfile ignores the upload filename, the entire filename is specified on
 
71
#       path. putfiles calls files after the name on the user's machine.
 
72
#
 
73
# action=paste: Copy or move the files to a specified dir.
 
74
#       src:    The path to the DIRECTORY to get the files from (relative).
 
75
#       dst:    The path to the DIRECTORY to paste the files to. Must not
 
76
#               be a file.
 
77
#       mode:   'copy' or 'move'
 
78
#       file:   File to be copied or moved, relative to src, to a destination
 
79
#               relative to dst. Can be specified multiple times.
 
80
#
 
81
# Subversion actions.
 
82
# action=svnadd: Add an existing file(s) to version control.
 
83
#       path:   The path to the file to be added. Can be specified multiple
 
84
#               times.
 
85
#
 
86
# action=svnrevert: Revert a file(s) to its state as of the current revision
 
87
#               / undo local edits.
 
88
#       path:   The path to the file to be reverted. Can be specified multiple
 
89
#               times.
 
90
#
 
91
# action=svnupdate: Bring a file up to date with the head revision.
 
92
#       path:   The path to the file to be updated. Only one file may be
 
93
#               specified.
 
94
#
 
95
# action=svnpublish: Set the "published" flag on a file to True.
 
96
#       path:   The path to the file to be published. Can be specified
 
97
#               multiple times.
 
98
#
 
99
# action=svnunpublish: Set the "published" flag on a file to False.
 
100
#       path:   The path to the file to be unpublished. Can be specified
 
101
#               multiple times.
 
102
#
 
103
# action=svncommit: Commit a file(s) or directory(s) to the repository.
 
104
#       path:   The path to the file or directory to be committed. Can be
 
105
#               specified multiple times. Directories are committed
 
106
#               recursively.
 
107
#       logmsg: Text of the log message. Optional. There is a default log
 
108
#               message if unspecified.
 
109
# action=svncheckout: Checkout a file/directory from the repository.
 
110
#       path:   The [repository] path to the file or directory to be
 
111
#               checked out.
 
112
 
113
# action=svnrepomkdir: Create a directory in a repository (not WC).
 
114
#       path:   The path to the directory to be created (under the IVLE
 
115
#               repository base).
 
116
#       logmsg: Text of the log message.
 
117
 
118
# action=svnrepostat: Check if a path exists in a repository (not WC).
 
119
#       path:   The path to the directory to be checked (under the IVLE
 
120
#               repository base).
 
121
#
 
122
# TODO: Implement the following actions:
 
123
#   svnupdate (done?)
 
124
# TODO: Implement ZIP unpacking in putfiles (done?).
 
125
# TODO: svnupdate needs a digest to tell the user the files that were updated.
 
126
#   This can be implemented by some message passing between action and
 
127
#   listing, and having the digest included in the listing. (Problem if
 
128
#   the listing is not a directory, but we could make it an error to do an
 
129
#   update if the path is not a directory).
 
130
 
 
131
import os
 
132
import cStringIO
 
133
import shutil
 
134
 
 
135
import pysvn
 
136
 
 
137
from common import (util, studpath, zip)
 
138
import conf
 
139
 
 
140
def get_login(_realm, existing_login, _may_save):
 
141
    """Callback function used by pysvn for authentication.
 
142
    realm, existing_login, _may_save: The 3 arguments passed by pysvn to
 
143
        callback_get_login.
 
144
        The following has been determined empirically, not from docs:
 
145
        existing_login will be the name of the user who owns the process on
 
146
        the first attempt, "" on subsequent attempts. We use this fact.
 
147
    """
 
148
    # Only provide credentials on the _first_ attempt.
 
149
    # If we're being asked again, then it means the credentials failed for
 
150
    # some reason and we should just fail. (This is not desirable, but it's
 
151
    # better than being asked an infinite number of times).
 
152
    return (existing_login != "", conf.login, conf.svn_pass, True)
 
153
 
 
154
# Make a Subversion client object
 
155
svnclient = pysvn.Client()
 
156
svnclient.callback_get_login = get_login
 
157
svnclient.exception_style = 0               # Simple (string) exceptions
 
158
 
 
159
DEFAULT_LOGMESSAGE = "No log message supplied."
 
160
 
 
161
# Mime types
 
162
# application/json is the "best" content type but is not good for
 
163
# debugging because Firefox just tries to download it
 
164
mime_dirlisting = "text/html"
 
165
#mime_dirlisting = "application/json"
 
166
 
 
167
class ActionError(Exception):
 
168
    """Represents an error processing an action. This can be
 
169
    raised by any of the action functions, and will be caught
 
170
    by the top-level handler, put into the HTTP response field,
 
171
    and continue.
 
172
 
 
173
    Important Security Consideration: The message passed to this
 
174
    exception will be relayed to the client.
 
175
    """
 
176
    pass
 
177
 
 
178
def handle_action(req, action, fields):
 
179
    """Perform the "action" part of the response.
 
180
    This function should only be called if the response is a POST.
 
181
    This performs the action's side-effect on the server. If unsuccessful,
 
182
    writes the X-IVLE-Action-Error header to the request object. Otherwise,
 
183
    does not touch the request object. Does NOT write any bytes in response.
 
184
 
 
185
    May throw an ActionError. The caller should put this string into the
 
186
    X-IVLE-Action-Error header, and then continue normally.
 
187
 
 
188
    action: String, the action requested. Not sanitised.
 
189
    fields: FieldStorage object containing all arguments passed.
 
190
    """
 
191
    global actions_table        # Table of function objects
 
192
    try:
 
193
        action = actions_table[action]
 
194
    except KeyError:
 
195
        # Default, just send an error but then continue
 
196
        raise ActionError("Unknown action")
 
197
    action(req, fields)
 
198
 
 
199
def actionpath_to_urlpath(req, path):
 
200
    """Determines the URL path (relative to the student home) upon which the
 
201
    action is intended to act. See actionpath_to_local.
 
202
    """
 
203
    if path is None:
 
204
        return req.path
 
205
    elif len(path) > 0 and path[0] == os.sep:
 
206
        # Relative to student home
 
207
        return path[1:]
 
208
    else:
 
209
        # Relative to req.path
 
210
        return os.path.join(req.path, path)
 
211
 
 
212
def actionpath_to_local(req, path):
 
213
    """Determines the local path upon which an action is intended to act.
 
214
    Note that fileservice actions accept two paths: the request path,
 
215
    and the "path" argument given to the action.
 
216
    According to the rules, if the "path" argument begins with a '/' it is
 
217
    relative to the user's home; if it does not, it is relative to the
 
218
    supplied path.
 
219
 
 
220
    This resolves the path, given the request and path argument.
 
221
 
 
222
    May raise an ActionError("Invalid path"). The caller is expected to
 
223
    let this fall through to the top-level handler, where it will be
 
224
    put into the HTTP response field. Never returns None.
 
225
 
 
226
    Does not mutate req.
 
227
    """
 
228
    (_, _, r) = studpath.url_to_jailpaths(actionpath_to_urlpath(req, path))
 
229
    if r is None:
 
230
        raise ActionError("Invalid path")
 
231
    return r
 
232
 
 
233
def movefile(req, frompath, topath, copy=False):
 
234
    """Performs a file move, resolving filenames, checking for any errors,
 
235
    and throwing ActionErrors if necessary. Can also be used to do a copy
 
236
    operation instead.
 
237
 
 
238
    frompath and topath are straight paths from the client. Will be checked.
 
239
    """
 
240
    # TODO: Do an SVN mv if the file is versioned.
 
241
    # TODO: Disallow tampering with student's home directory
 
242
    if frompath is None or topath is None:
 
243
        raise ActionError("Required field missing")
 
244
    frompath = actionpath_to_local(req, frompath)
 
245
    topath = actionpath_to_local(req, topath)
 
246
    if not os.path.exists(frompath):
 
247
        raise ActionError("The source file does not exist")
 
248
    if os.path.exists(topath):
 
249
        if frompath == topath:
 
250
            raise ActionError("Source and destination are the same")
 
251
        raise ActionError("A file already exists with that name")
 
252
 
 
253
    try:
 
254
        if copy:
 
255
            if os.path.isdir(frompath):
 
256
                shutil.copytree(frompath, topath)
 
257
            else:
 
258
                shutil.copy2(frompath, topath)
 
259
        else:
 
260
            shutil.move(frompath, topath)
 
261
    except OSError:
 
262
        raise ActionError("Could not move the file specified")
 
263
    except shutil.Error:
 
264
        raise ActionError("Could not move the file specified")
 
265
 
 
266
### ACTIONS ###
 
267
 
 
268
def action_delete(req, fields):
 
269
    # TODO: Disallow removal of student's home directory
 
270
    """Removes a list of files or directories.
 
271
 
 
272
    Reads fields: 'path' (multiple)
 
273
    """
 
274
    paths = fields.getlist('path')
 
275
    goterror = False
 
276
    for path in paths:
 
277
        path = actionpath_to_local(req, path)
 
278
        try:
 
279
            if os.path.isdir(path):
 
280
                shutil.rmtree(path)
 
281
            else:
 
282
                os.remove(path)
 
283
        except OSError:
 
284
            goterror = True
 
285
        except shutil.Error:
 
286
            goterror = True
 
287
    if goterror:
 
288
        if len(paths) == 1:
 
289
            raise ActionError("Could not delete the file specified")
 
290
        else:
 
291
            raise ActionError(
 
292
                "Could not delete one or more of the files specified")
 
293
 
 
294
def action_move(req, fields):
 
295
    # TODO: Do an SVN mv if the file is versioned.
 
296
    # TODO: Disallow tampering with student's home directory
 
297
    """Removes a list of files or directories.
 
298
 
 
299
    Reads fields: 'from', 'to'
 
300
    """
 
301
    frompath = fields.getfirst('from')
 
302
    topath = fields.getfirst('to')
 
303
    movefile(req, frompath, topath)
 
304
 
 
305
def action_mkdir(req, fields):
 
306
    """Creates a directory with the given path.
 
307
    Reads fields: 'path'
 
308
    """
 
309
    path = fields.getfirst('path')
 
310
    if path is None:
 
311
        raise ActionError("Required field missing")
 
312
    path = actionpath_to_local(req, path)
 
313
 
 
314
    if os.path.exists(path):
 
315
        raise ActionError("A file already exists with that name")
 
316
 
 
317
    # Create the directory
 
318
    try:
 
319
        os.mkdir(path)
 
320
    except OSError:
 
321
        raise ActionError("Could not create directory")
 
322
 
 
323
def action_putfile(req, fields):
 
324
    """Writes data to a file, overwriting it if it exists and creating it if
 
325
    it doesn't.
 
326
 
 
327
    Reads fields: 'path', 'data' (file upload), 'overwrite'
 
328
    """
 
329
    # TODO: Read field "unpack".
 
330
    # Important: Data is "None" if the file submitted is empty.
 
331
    path = fields.getfirst('path')
 
332
    data = fields.getfirst('data')
 
333
    if path is None:
 
334
        raise ActionError("Required field missing")
 
335
    if data is None:
 
336
        # Workaround - field reader treats "" as None, so this is the only
 
337
        # way to allow blank file uploads
 
338
        data = ""
 
339
    path = actionpath_to_local(req, path)
 
340
 
 
341
    if data is not None:
 
342
        data = cStringIO.StringIO(data)
 
343
 
 
344
    overwrite = fields.getfirst('overwrite')
 
345
    if overwrite is None:
 
346
        overwrite = False
 
347
    else:
 
348
        overwrite = True
 
349
 
 
350
    if overwrite:
 
351
        # Overwrite files; but can't if it's a directory
 
352
        if os.path.isdir(path):
 
353
            raise ActionError("A directory already exists "
 
354
                    + "with that name")
 
355
    else:
 
356
        if os.path.exists(path):
 
357
            raise ActionError("A file already exists with that name")
 
358
 
 
359
    # Copy the contents of file object 'data' to the path 'path'
 
360
    try:
 
361
        dest = open(path, 'wb')
 
362
        if data is not None:
 
363
            shutil.copyfileobj(data, dest)
 
364
    except (IOError, OSError), e:
 
365
        raise ActionError("Could not write to target file: %s" % e.strerror)
 
366
 
 
367
def action_putfiles(req, fields):
 
368
    """Writes data to one or more files in a directory, overwriting them if
 
369
    it they exist.
 
370
 
 
371
    Reads fields: 'path', 'data' (file upload, multiple), 'unpack'
 
372
    """
 
373
 
 
374
    # Important: Data is "None" if the file submitted is empty.
 
375
    path = fields.getfirst('path')
 
376
    data = fields['data']
 
377
    if type(data) != type([]):
 
378
        data = [data]
 
379
    unpack = fields.getfirst('unpack')
 
380
    if unpack is None:
 
381
        unpack = False
 
382
    else:
 
383
        unpack = True
 
384
    if path is None:
 
385
        raise ActionError("Required field missing")
 
386
    path = actionpath_to_urlpath(req, path)
 
387
    goterror = False
 
388
 
 
389
    for datum in data:
 
390
        # Each of the uploaded files
 
391
        filepath = os.path.join(path, datum.filename)
 
392
        filedata = datum.file
 
393
 
 
394
        if unpack and datum.filename.lower().endswith(".zip"):
 
395
            # A zip file - unpack it instead of just copying
 
396
            # TODO: Use the magic number instead of file extension
 
397
            # Note: Just unzip into the current directory (ignore the
 
398
            # filename)
 
399
            try:
 
400
                # First get the entire path (within jail)
 
401
                _, _, abspath = studpath.url_to_jailpaths(path)
 
402
                abspath = os.path.join(os.sep, abspath)
 
403
                zip.unzip(abspath, filedata)
 
404
            except (OSError, IOError):
 
405
                goterror = True
 
406
        else:
 
407
            # Not a zip file
 
408
            (_, _, filepath_local) = studpath.url_to_jailpaths(filepath)
 
409
            if filepath_local is None:
 
410
                raise ActionError("Invalid path")
 
411
 
 
412
            # Copy the contents of file object 'data' to the path 'path'
 
413
            try:
 
414
                dest = open(filepath_local, 'wb')
 
415
                if data is not None:
 
416
                    shutil.copyfileobj(filedata, dest)
 
417
            except OSError:
 
418
                goterror = True
 
419
 
 
420
    if goterror:
 
421
        if len(data) == 1:
 
422
            raise ActionError("Could not write to target file")
 
423
        else:
 
424
            raise ActionError(
 
425
                "Could not write to one or more of the target files")
 
426
 
 
427
def action_paste(req, fields):
 
428
    """Performs the copy or move action with the files specified.
 
429
    Copies/moves the files to the specified directory.
 
430
 
 
431
    Reads fields: 'src', 'dst', 'mode', 'file' (multiple).
 
432
    src: Base path that all the files are relative to (source).
 
433
    dst: Destination path to paste into.
 
434
    mode: 'copy' or 'move'.
 
435
    file: (Multiple) Files relative to base, which will be copied
 
436
        or moved to new locations relative to path.
 
437
    """
 
438
    errormsg = None
 
439
 
 
440
    dst = fields.getfirst('dst')
 
441
    src = fields.getfirst('src')
 
442
    mode = fields.getfirst('mode')
 
443
    files = fields.getlist('file')
 
444
    if dst is None or src is None or mode is None:
 
445
        raise ActionError("Required field missing")
 
446
    if mode == "copy":
 
447
        copy = True
 
448
    elif mode == "move":
 
449
        copy = False
 
450
    else:
 
451
        raise ActionError("Invalid mode (must be 'copy' or 'move')")
 
452
    dst_local = actionpath_to_local(req, dst)
 
453
    if not os.path.isdir(dst_local):
 
454
        raise ActionError("dst is not a directory")
 
455
 
 
456
    errorfiles = []
 
457
    for file in files:
 
458
        # The source must not be interpreted as relative to req.path
 
459
        # Add a slash (relative to top-level)
 
460
        if src[:1] != '/':
 
461
            src = '/' + src
 
462
        frompath = os.path.join(src, file)
 
463
        # The destination is found by taking just the basename of the file
 
464
        topath = os.path.join(dst, os.path.basename(file))
 
465
        try:
 
466
            movefile(req, frompath, topath, copy)
 
467
        except ActionError, message:
 
468
            # Store the error for later; we want to copy as many as possible
 
469
            if errormsg is None:
 
470
                errormsg = message
 
471
            else:
 
472
                # Multiple errors; generic message
 
473
                errormsg = "One or more files could not be pasted"
 
474
            # Add this file to errorfiles; it will be put back on the
 
475
            # clipboard for possible future pasting.
 
476
            errorfiles.append(file)
 
477
    if errormsg is not None:
 
478
        raise ActionError(errormsg)
 
479
 
 
480
    # XXX errorfiles contains a list of files that couldn't be pasted.
 
481
    # we currently do nothing with this.
 
482
 
 
483
def action_publish(req,fields):
 
484
    """Marks the folder as published by adding a '.published' file to the 
 
485
    directory and ensuring that the parent directory permissions are correct
 
486
 
 
487
    Reads fields: 'path'
 
488
    """
 
489
    paths = fields.getlist('path')
 
490
    user = studpath.url_to_local(req.path)[0]
 
491
    homedir = "/home/%s" % user
 
492
    if len(paths):
 
493
        paths = map(lambda path: actionpath_to_local(req, path), paths)
 
494
    else:
 
495
        paths = [studpath.url_to_jailpaths(req.path)[2]]
 
496
 
 
497
    # Set all the dirs in home dir world browsable (o+r,o+x)
 
498
    #FIXME: Should really only do those in the direct path not all of the 
 
499
    # folders in a students home directory
 
500
    for root,dirs,files in os.walk(homedir):
 
501
        os.chmod(root, os.stat(root).st_mode|0005)
 
502
 
 
503
    try:
 
504
        for path in paths:
 
505
            if os.path.isdir(path):
 
506
                pubfile = open(os.path.join(path,'.published'),'w')
 
507
                pubfile.write("This directory is published\n")
 
508
                pubfile.close()
 
509
            else:
 
510
                raise ActionError("Can only publish directories")
 
511
    except OSError, e:
 
512
        raise ActionError("Directory could not be published")
 
513
 
 
514
def action_unpublish(req,fields):
 
515
    """Marks the folder as unpublished by removing a '.published' file in the 
 
516
    directory (if it exits). It does not change the permissions of the parent 
 
517
    directories.
 
518
 
 
519
    Reads fields: 'path'
 
520
    """
 
521
    paths = fields.getlist('path')
 
522
    if len(paths):
 
523
        paths = map(lambda path: actionpath_to_local(req, path), paths)
 
524
    else:
 
525
        paths = [studpath.url_to_jailpaths(req.path)[2]]
 
526
 
 
527
    try:
 
528
        for path in paths:
 
529
            if os.path.isdir(path):
 
530
                pubfile = os.path.join(path,'.published')
 
531
                if os.path.isfile(pubfile):
 
532
                    os.remove(pubfile)
 
533
            else:
 
534
                raise ActionError("Can only unpublish directories")
 
535
    except OSError, e:
 
536
        raise ActionError("Directory could not be unpublished")
 
537
 
 
538
 
 
539
def action_svnadd(req, fields):
 
540
    """Performs a "svn add" to each file specified.
 
541
 
 
542
    Reads fields: 'path' (multiple)
 
543
    """
 
544
    paths = fields.getlist('path')
 
545
    paths = map(lambda path: actionpath_to_local(req, path), paths)
 
546
 
 
547
    try:
 
548
        svnclient.add(paths, recurse=True, force=True)
 
549
    except pysvn.ClientError, e:
 
550
        raise ActionError(str(e))
 
551
 
 
552
def action_svnremove(req, fields):
 
553
    """Performs a "svn remove" on each file specified.
 
554
 
 
555
    Reads fields: 'path' (multiple)
 
556
    """
 
557
    paths = fields.getlist('path')
 
558
    paths = map(lambda path: actionpath_to_local(req, path), paths)
 
559
 
 
560
    try:
 
561
        svnclient.remove(paths, force=True)
 
562
    except pysvn.ClientError, e:
 
563
        raise ActionError(str(e))
 
564
 
 
565
def action_svnupdate(req, fields):
 
566
    """Performs a "svn update" to each file specified.
 
567
 
 
568
    Reads fields: 'path'
 
569
    """
 
570
    path = fields.getfirst('path')
 
571
    if path is None:
 
572
        raise ActionError("Required field missing")
 
573
    path = actionpath_to_local(req, path)
 
574
 
 
575
    try:
 
576
        svnclient.update(path, recurse=True)
 
577
    except pysvn.ClientError, e:
 
578
        raise ActionError(str(e))
 
579
 
 
580
def action_svnresolved(req, fields):
 
581
    """Performs a "svn resolved" to each file specified.
 
582
 
 
583
    Reads fields: 'path'
 
584
    """
 
585
    path = fields.getfirst('path')
 
586
    if path is None:
 
587
        raise ActionError("Required field missing")
 
588
    path = actionpath_to_local(req, path)
 
589
 
 
590
    try:
 
591
        svnclient.resolved(path, recurse=True)
 
592
    except pysvn.ClientError, e:
 
593
        raise ActionError(str(e))
 
594
 
 
595
def action_svnrevert(req, fields):
 
596
    """Performs a "svn revert" to each file specified.
 
597
 
 
598
    Reads fields: 'path' (multiple)
 
599
    """
 
600
    paths = fields.getlist('path')
 
601
    paths = map(lambda path: actionpath_to_local(req, path), paths)
 
602
 
 
603
    try:
 
604
        svnclient.revert(paths, recurse=True)
 
605
    except pysvn.ClientError, e:
 
606
        raise ActionError(str(e))
 
607
 
 
608
def action_svnpublish(req, fields):
 
609
    """Sets svn property "ivle:published" on each file specified.
 
610
    Should only be called on directories (only effective on directories
 
611
    anyway).
 
612
 
 
613
    Reads fields: 'path'
 
614
 
 
615
    XXX Currently unused by the client (calls action_publish instead, which
 
616
    has a completely different publishing model).
 
617
    """
 
618
    paths = fields.getlist('path')
 
619
    if len(paths):
 
620
        paths = map(lambda path: actionpath_to_local(req, path), paths)
 
621
    else:
 
622
        paths = [studpath.url_to_jailpaths(req.path)[2]]
 
623
 
 
624
    try:
 
625
        for path in paths:
 
626
            # Note: Property value doesn't matter
 
627
            svnclient.propset("ivle:published", "", path, recurse=False)
 
628
    except pysvn.ClientError, e:
 
629
        raise ActionError("Directory could not be published")
 
630
 
 
631
def action_svnunpublish(req, fields):
 
632
    """Deletes svn property "ivle:published" on each file specified.
 
633
 
 
634
    Reads fields: 'path'
 
635
 
 
636
    XXX Currently unused by the client (calls action_unpublish instead, which
 
637
    has a completely different publishing model).
 
638
    """
 
639
    paths = fields.getlist('path')
 
640
    paths = map(lambda path: actionpath_to_local(req, path), paths)
 
641
 
 
642
    try:
 
643
        for path in paths:
 
644
            svnclient.propdel("ivle:published", path, recurse=False)
 
645
    except pysvn.ClientError, e:
 
646
        raise ActionError("Directory could not be unpublished")
 
647
 
 
648
def action_svncommit(req, fields):
 
649
    """Performs a "svn commit" to each file specified.
 
650
 
 
651
    Reads fields: 'path' (multiple), 'logmsg' (optional)
 
652
    """
 
653
    paths = fields.getlist('path')
 
654
    paths = map(lambda path: actionpath_to_local(req, str(path)), paths)
 
655
    logmsg = str(fields.getfirst('logmsg', DEFAULT_LOGMESSAGE))
 
656
    if logmsg == '': logmsg = DEFAULT_LOGMESSAGE
 
657
 
 
658
    try:
 
659
        svnclient.checkin(paths, logmsg, recurse=True)
 
660
    except pysvn.ClientError, e:
 
661
        raise ActionError(str(e))
 
662
 
 
663
def action_svncheckout(req, fields):
 
664
    """Performs a "svn checkout" of the first path into the second path.
 
665
 
 
666
    Reads fields: 'path'    (multiple)
 
667
    """
 
668
    paths = fields.getlist('path')
 
669
    if len(paths) != 2:
 
670
        raise ActionError("usage: svncheckout url local-path")
 
671
    url = conf.svn_addr + "/" + paths[0]
 
672
    local_path = actionpath_to_local(req, str(paths[1]))
 
673
    try:
 
674
        svnclient.callback_get_login = get_login
 
675
        svnclient.checkout(url, local_path, recurse=True)
 
676
    except pysvn.ClientError, e:
 
677
        raise ActionError(str(e))
 
678
 
 
679
def action_svnrepomkdir(req, fields):
 
680
    """Performs a "svn mkdir" on a path under the IVLE SVN root.
 
681
 
 
682
    Reads fields: 'path'
 
683
    """
 
684
    path = fields.getfirst('path')
 
685
    logmsg = fields.getfirst('logmsg')
 
686
    url = conf.svn_addr + "/" + path
 
687
    try:
 
688
        svnclient.callback_get_login = get_login
 
689
        svnclient.mkdir(url, log_message=logmsg)
 
690
    except pysvn.ClientError, e:
 
691
        raise ActionError(str(e))
 
692
 
 
693
def action_svnrepostat(req, fields):
 
694
    """Discovers whether a path exists in a repo under the IVLE SVN root.
 
695
 
 
696
    Reads fields: 'path'
 
697
    """
 
698
    path = fields.getfirst('path')
 
699
    url = conf.svn_addr + "/" + path
 
700
    svnclient.exception_style = 1 
 
701
 
 
702
    try:
 
703
        svnclient.callback_get_login = get_login
 
704
        svnclient.info2(url)
 
705
    except pysvn.ClientError, e:
 
706
        # Error code 170000 means ENOENT in this revision.
 
707
        if e[1][0][1] == 170000:
 
708
            raise util.IVLEError(404, 'The specified repository path does not exist')
 
709
        else:
 
710
            raise ActionError(str(e[0]))
 
711
 
 
712
# Table of all action functions #
 
713
# Each function has the interface f(req, fields).
 
714
 
 
715
actions_table = {
 
716
    "delete" : action_delete,
 
717
    "move" : action_move,
 
718
    "mkdir" : action_mkdir,
 
719
    "putfile" : action_putfile,
 
720
    "putfiles" : action_putfiles,
 
721
    "paste" : action_paste,
 
722
    "publish" : action_publish,
 
723
    "unpublish" : action_unpublish,
 
724
 
 
725
    "svnadd" : action_svnadd,
 
726
    "svnremove" : action_svnremove,
 
727
    "svnupdate" : action_svnupdate,
 
728
    "svnresolved" : action_svnresolved,
 
729
    "svnrevert" : action_svnrevert,
 
730
    "svnpublish" : action_svnpublish,
 
731
    "svnunpublish" : action_svnunpublish,
 
732
    "svncommit" : action_svncommit,
 
733
    "svncheckout" : action_svncheckout,
 
734
    "svnrepomkdir" : action_svnrepomkdir,
 
735
    "svnrepostat" : action_svnrepostat,
 
736
}