← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/webapp/tutorial/service.py

ivle.chat now opens /dev/null as std{in,out,err} when daemonising.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/tutorial/service.py
1
1
# IVLE - Informatics Virtual Learning Environment
2
 
# Copyright (C) 2007-2008 The University of Melbourne
 
2
# Copyright (C) 2007-2009 The University of Melbourne
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 
18
 
# Module: TutorialService
19
 
# Author: Matt Giuca
20
 
# Date:   25/1/2008
21
 
 
22
 
# Provides the AJAX backend for the tutorial application.
23
 
# This allows several actions to be performed on the code the student has
24
 
# typed into one of the exercise boxes.
25
 
 
26
 
# Calling syntax
27
 
# Path must be empty.
28
 
# The arguments determine what is to be done on this file.
29
 
 
30
 
# "exercise" - The path to a exercise file (including the .xml extension),
31
 
#    relative to the subjects base directory.
32
 
# "code" - Full text of the student's code being submitted.
33
 
# "action". May be "test". (More to come).
34
 
 
35
 
# Returns a JSON response string indicating the results.
 
18
# Author: Matt Giuca, Nick Chadwick
 
19
 
 
20
'''AJAX backend for the tutorial application.'''
36
21
 
37
22
import os
38
 
import time
39
 
 
40
 
import cjson
41
 
 
42
 
from common import (db, util)
43
 
import test
44
 
import conf
45
 
 
46
 
def handle(req):
47
 
    """Handler for Ajax backend TutorialService app."""
48
 
    # Set request attributes
49
 
    req.write_html_head_foot = False     # No HTML
50
 
 
51
 
    if req.path != "":
52
 
        req.throw_error(req.HTTP_BAD_REQUEST)
53
 
    # Get all the arguments, if POST.
54
 
    # Ignore arguments if not POST, since we aren't allowed to cause
55
 
    # side-effects on the server.
56
 
    fields = req.get_fieldstorage()
57
 
    act = fields.getfirst('action')
58
 
    exercise = fields.getfirst('exercise')
59
 
    code = fields.getfirst('code')
60
 
 
61
 
    if exercise == None or code == None or act == None:
62
 
        req.throw_error(req.HTTP_BAD_REQUEST)
63
 
    act = act.value
64
 
    exercise = exercise.value
65
 
    code = code.value
66
 
 
67
 
    if act == "save":
68
 
        handle_save(req, exercise, code, fields)
69
 
    elif act == "test":
70
 
        handle_test(req, exercise, code, fields)
71
 
    elif act == "run":
72
 
        handle_run(req, exercise, code, fields)
73
 
    else:
74
 
        req.throw_error(req.HTTP_BAD_REQUEST)
75
 
 
76
 
def handle_save(req, exercise, code, fields):
77
 
    """Handles a save action. This saves the user's code without executing it.
78
 
    """
79
 
    # Need to open JUST so we know this is a real exercise.
80
 
    # (This avoids users submitting code for bogus exercises).
81
 
    exercisefile = util.open_exercise_file(exercise)
82
 
    if exercisefile is None:
83
 
        req.throw_error(req.HTTP_NOT_FOUND,
84
 
            "The exercise was not found.")
85
 
    exercisefile.close()
86
 
 
87
 
    req.write('{"result": "ok"}')
88
 
 
89
 
    conn = db.DB()
90
 
 
91
 
    try:
92
 
        conn.write_problem_save(
93
 
            login = req.user.login,
94
 
            exercisename = exercise,
95
 
            date = time.localtime(),
96
 
            text = code)
97
 
    finally:
98
 
        conn.close()
99
 
 
100
 
def handle_test(req, exercise, code, fields):
101
 
    """Handles a test action."""
102
 
 
103
 
    exercisefile = util.open_exercise_file(exercise)
104
 
    if exercisefile is None:
105
 
        req.throw_error(req.HTTP_NOT_FOUND,
106
 
            "The exercise was not found.")
107
 
 
108
 
    # Parse the file into a exercise object using the test suite
109
 
    exercise_obj = test.parse_exercise_file(exercisefile)
110
 
    exercisefile.close()
111
 
    # Run the test cases. Get the result back as a JSONable object.
112
 
    # Return it.
113
 
    test_results = exercise_obj.run_tests(code)
114
 
 
115
 
    conn = db.DB()
116
 
    try:
117
 
        conn.insert_problem_attempt(
118
 
            login = req.user.login,
119
 
            exercisename = exercise,
120
 
            date = time.localtime(),
121
 
            complete = test_results['passed'],
122
 
            attempt = code)
 
23
import datetime
 
24
 
 
25
import ivle.util
 
26
import ivle.console
 
27
import ivle.database
 
28
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, Offering, Subject, Semester
 
29
import ivle.worksheet
 
30
import ivle.conf
 
31
import ivle.webapp.tutorial.test
 
32
 
 
33
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
 
34
                                   require_permission)
 
35
from ivle.webapp.errors import NotFound
 
36
 
 
37
# If True, getattempts or getattempt will allow browsing of inactive/disabled
 
38
# attempts. If False, will not allow this.
 
39
HISTORY_ALLOW_INACTIVE = False
 
40
 
 
41
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
 
42
 
 
43
 
 
44
class AttemptsRESTView(JSONRESTView):
 
45
    '''REST view of a user's attempts at an exercise.'''
 
46
    def __init__(self, req, subject, year, semester, worksheet, 
 
47
                                                exercise, username):
 
48
        self.user = ivle.database.User.get_by_login(req.store, username)
 
49
        if self.user is None:
 
50
            raise NotFound()
 
51
        self.exercise = exercise
 
52
        
 
53
        self.worksheet = req.store.find(Worksheet,
 
54
            Worksheet.name == worksheet,
 
55
            Worksheet.offering_id == Offering.id,
 
56
            Offering.subject_id == Subject.id,
 
57
            Subject.code == subject,
 
58
            Offering.semester_id == Semester.id,
 
59
            Semester.year == year,
 
60
            Semester.semester == semester).one()
 
61
        
 
62
        self.context = self.user # XXX: Not quite right.
 
63
 
 
64
    @require_permission('edit')
 
65
    def GET(self, req):
 
66
        """Handles a GET Attempts action."""
 
67
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
68
 
 
69
        attempts = req.store.find(ExerciseAttempt, 
 
70
                ExerciseAttempt.exercise_id == exercise.id,
 
71
                ExerciseAttempt.user_id == self.user.id)
 
72
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
 
73
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
 
74
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
 
75
                for a in attempts]
 
76
 
 
77
        return attempts
 
78
 
 
79
 
 
80
    @require_permission('edit')
 
81
    def PUT(self, req, data):
 
82
        """ Tests the given submission """
 
83
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
84
        if exercise is None:
 
85
            raise NotFound()
 
86
 
 
87
        # Start a console to run the tests on
 
88
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
 
89
        working_dir = os.path.join("/home", req.user.login)
 
90
        cons = ivle.console.Console(req.user.unixid, jail_path, working_dir)
 
91
 
 
92
        # Parse the file into a exercise object using the test suite
 
93
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
94
                                                            exercise, cons)
 
95
 
 
96
        # Run the test cases. Get the result back as a JSONable object.
 
97
        # Return it.
 
98
        test_results = exercise_obj.run_tests(data['code'])
 
99
 
 
100
        # Close the console
 
101
        cons.close()
 
102
 
 
103
        attempt = ivle.database.ExerciseAttempt(user=req.user,
 
104
                                                exercise=exercise,
 
105
                                                date=datetime.datetime.now(),
 
106
                                                complete=test_results['passed'],
 
107
                                                worksheet=self.worksheet,
 
108
                                                text=unicode(data['code']))
 
109
 
 
110
        req.store.add(attempt)
123
111
 
124
112
        # Query the DB to get an updated score on whether or not this problem
125
113
        # has EVER been completed (may be different from "passed", if it has
126
114
        # been completed before), and the total number of attempts.
127
 
        completed, attempts = conn.get_problem_status(req.user.login,
128
 
            exercise)
 
115
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
 
116
            req.user, exercise, self.worksheet)
129
117
        test_results["completed"] = completed
130
118
        test_results["attempts"] = attempts
131
119
 
132
 
        req.write(cjson.encode(test_results))
133
 
    finally:
134
 
        conn.close()
135
 
 
136
 
def handle_run(req, exercise, code, fields):
137
 
    """Handles a run action."""
138
 
    # Extremely makeshift.
139
 
    # For now, just echo the code back
140
 
    output = code
141
 
    out_json = {"stdout": output}
142
 
    req.write(cjson.encode(out_json))
 
120
        return test_results
 
121
 
 
122
 
 
123
class AttemptRESTView(JSONRESTView):
 
124
    '''REST view of an exercise attempt.'''
 
125
 
 
126
    def __init__(self, req, subject, worksheet, exercise, username, date):
 
127
        # TODO: Find exercise within worksheet.
 
128
        user = ivle.database.User.get_by_login(req.store, username)
 
129
        if user is None:
 
130
            raise NotFound()
 
131
 
 
132
        try:
 
133
            date = datetime.datetime.strptime(date, TIMESTAMP_FORMAT)
 
134
        except ValueError:
 
135
            raise NotFound()
 
136
 
 
137
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
 
138
        worksheet = req.store.find(Worksheet,
 
139
            Worksheet.name == self.worksheet,
 
140
            Worksheet.offering_id == Offering.id,
 
141
            Offering.subject_id == Subject.id,
 
142
            Subject.code == self.subject,
 
143
            Offering.semester_id == Semester.id,
 
144
            Semester.year == self.year,
 
145
            Semester.semester == self.semester).one()
 
146
 
 
147
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
 
148
            exercise, worksheet, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
149
 
 
150
        if attempt is None:
 
151
            raise NotFound()
 
152
 
 
153
        self.context = attempt
 
154
 
 
155
    @require_permission('view')
 
156
    def GET(self, req):
 
157
        return {'code': self.context.text}
 
158
 
 
159
 
 
160
class ExerciseRESTView(JSONRESTView):
 
161
    '''REST view of an exercise.'''
 
162
 
 
163
    def get_permissions(self, user):
 
164
        # XXX: Do it properly.
 
165
        if user is not None:
 
166
            return set(['save'])
 
167
        else:
 
168
            return set()
 
169
 
 
170
    @named_operation('save')
 
171
    def save(self, req, text):
 
172
        # Need to open JUST so we know this is a real exercise.
 
173
        # (This avoids users submitting code for bogus exercises).
 
174
        exercise = req.store.find(Exercise,
 
175
            Exercise.id == self.exercise).one()
 
176
        worksheet = req.store.find(Worksheet,
 
177
            Worksheet.name == self.worksheet,
 
178
            Worksheet.offering_id == Offering.id,
 
179
            Offering.subject_id == Subject.id,
 
180
            Subject.code == self.subject,
 
181
            Offering.semester_id == Semester.id,
 
182
            Semester.year == self.year,
 
183
            Semester.semester == self.semester).one()
 
184
        ivle.worksheet.save_exercise(req.store, req.user, exercise, worksheet,
 
185
                                     unicode(text), datetime.datetime.now())
 
186
        return {"result": "ok"}