← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/console.py

  • Committer: Matt Giuca
  • Date: 2010-07-27 06:53:03 UTC
  • Revision ID: matt.giuca@gmail.com-20100727065303-gs7fn3gc3ccaqfux
https://launchpad.net/bugs/610330
Changed database schema 'semester' table. 'year' and 'semester' fields now allow any length, not just 4 or 1 respectively. (LP: #610330).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/console.py
23
23
 
24
24
import errno
25
25
import cPickle
26
 
import md5
 
26
import hashlib
27
27
import os
28
28
import random
29
29
import socket
32
32
 
33
33
import cjson
34
34
 
35
 
import ivle.conf
36
 
from ivle import (chat, util)
37
 
 
38
 
# Outside Jail
39
 
trampoline_path = os.path.join(ivle.conf.lib_path, "trampoline")
40
 
# Inside Jail
41
 
python_path = "/usr/bin/python"
42
 
console_dir = os.path.join(ivle.conf.share_path, 'services')
43
 
console_path = os.path.join(console_dir, 'python-console')
 
35
from ivle import chat, interpret
44
36
 
45
37
class ConsoleError(Exception):
46
38
    """ The console failed in some way. This is bad. """
47
 
    def __init__(self, value):
48
 
        self.value = value
49
 
    def __str__(self):
50
 
        return repr(self.value)
 
39
    pass
51
40
 
52
41
class ConsoleException(Exception):
53
42
    """ The code being exectuted on the console returned an exception. 
54
43
    """
55
 
    def __init__(self, value):
56
 
        self.value = value
57
 
    def __str__(self):
58
 
        return repr(self.value)
 
44
    pass
59
45
 
60
46
class TruncateStringIO(StringIO.StringIO):
61
47
    """ A class that wraps around StringIO and truncates the buffer when the 
122
108
class Console(object):
123
109
    """ Provides a nice python interface to the console
124
110
    """
125
 
    def __init__(self, uid, jail_path, working_dir):
 
111
    def __init__(self, config, user, jail_path, working_dir):
126
112
        """Starts up a console service for user uid, inside chroot jail 
127
113
        jail_path with work directory of working_dir
128
114
        """
129
115
        super(Console, self).__init__()
130
116
 
131
 
        self.uid = uid
 
117
        self.config = config
 
118
        self.user = user
132
119
        self.jail_path = jail_path
133
120
        self.working_dir = working_dir
134
121
 
154
141
 
155
142
        # Create magic
156
143
        # TODO
157
 
        self.magic = md5.new(uuid.uuid4().bytes).digest().encode('hex')
 
144
        self.magic = hashlib.md5(uuid.uuid4().bytes).hexdigest()
158
145
 
159
146
        # Try to find a free port on the server.
160
147
        # Just try some random ports in the range [3000,8000)
165
152
        # is (k / N) ** t (e.g. 3.2*10e-9).
166
153
 
167
154
        tries = 0
 
155
        error = None
168
156
        while tries < 5:
169
157
            self.port = int(random.uniform(3000, 8000))
170
158
 
171
 
            # Start the console server (port, magic)
172
 
            # trampoline usage: tramp uid jail_dir working_dir script_path args
173
 
            # console usage:    python-console port magic
174
 
            res = os.spawnv(os.P_WAIT, trampoline_path, [
175
 
                trampoline_path,
176
 
                str(self.uid),
177
 
                ivle.conf.jail_base,
178
 
                ivle.conf.jail_src_base,
179
 
                ivle.conf.jail_system,
180
 
                self.jail_path,
181
 
                console_dir,
182
 
                python_path,
183
 
                console_path,
184
 
                str(self.port),
185
 
                str(self.magic),
186
 
                self.working_dir
187
 
                ])
 
159
            python_console = os.path.join(self.config['paths']['share'],
 
160
                        'services/python-console')
 
161
            args = [python_console, str(self.port), str(self.magic)]
188
162
 
189
 
            if res == 0:
 
163
            try:
 
164
                interpret.execute_raw(self.config, self.user, self.jail_path,
 
165
                        self.working_dir, "/usr/bin/python", args)
190
166
                # success
191
 
                break;
192
 
 
193
 
            tries += 1
194
 
 
195
 
        # If we can't start the console after 5 attemps (can't find a free port 
196
 
        # during random probing, syntax errors, segfaults) throw an exception.
 
167
                break
 
168
            except interpret.ExecutionError, e:
 
169
                tries += 1
 
170
                error = e.message
 
171
 
 
172
        # If we can't start the console after 5 attemps (can't find a free 
 
173
        # port during random probing, syntax errors, segfaults) throw an 
 
174
        # exception.
197
175
        if tries == 5:
198
 
            raise ConsoleError("Unable to start console service!")
 
176
            raise ConsoleError('Unable to start console service: %s'%error)
199
177
 
200
178
    def __chat(self, cmd, args):
201
179
        """ A wrapper around chat.chat to comunicate directly with the 
216
194
            # Couldn't decode the JSON
217
195
            raise ConsoleError(
218
196
                "Could not understand the python console response")
 
197
        except chat.ProtocolError, e:
 
198
            raise ConsoleError(*e.args)
219
199
 
220
200
        return response
221
201
 
300
280
              
301
281
        # Unpickle any exceptions
302
282
        if 'exception' in execute:
303
 
            return cPickle.loads(execute['exception'])
304
 
        else:
305
 
            return execute
 
283
            execute['exception'] = cPickle.loads(execute['exception'])
 
284
        return execute
306
285
 
307
286
 
308
287
    def set_vars(self, variables):