← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/common/console.py

  • Committer: dcoles
  • Date: 2008-08-27 06:04:53 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:1043
Console: Minor fixes. ConsoleService will now also restart the python-console 
if the connection is reset by the server.
Removed some unused code in python-console and slighly shuffled program flow so 
that the terminate check is done after checking the cmdQ (rather than just 
before)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/common/console.py
 
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: Console
 
19
# Author: Matt Giuca, Tom Conway, David Coles (refactor)
 
20
# Date: 13/8/2008
 
21
 
 
22
# Mainly refactored out of consoleservice
 
23
 
 
24
import errno
 
25
import cPickle
 
26
import md5
 
27
import os
 
28
import random
 
29
import socket
 
30
import StringIO
 
31
import uuid
 
32
 
 
33
import cjson
 
34
 
 
35
import conf
 
36
from common import (chat, util)
 
37
 
 
38
# Outside Jail
 
39
trampoline_path = os.path.join(conf.ivle_install_dir, "bin/trampoline")
 
40
# Inside Jail
 
41
python_path = "/usr/bin/python"
 
42
console_dir = "/opt/ivle/scripts"
 
43
console_path = "/opt/ivle/scripts/python-console"
 
44
 
 
45
class ConsoleError(Exception):
 
46
    """ 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)
 
51
 
 
52
class ConsoleException(Exception):
 
53
    """ The code being exectuted on the console returned an exception. 
 
54
    """
 
55
    def __init__(self, value):
 
56
        self.value = value
 
57
    def __str__(self):
 
58
        return repr(self.value)
 
59
 
 
60
class TruncateStringIO(StringIO.StringIO):
 
61
    """ A class that wraps around StringIO and truncates the buffer when the 
 
62
    contents are read (except for when using getvalue).
 
63
    """
 
64
    def __init__(self, buffer=None):
 
65
        StringIO.StringIO.__init__(self, buffer)
 
66
    
 
67
    def read(self, n=-1):
 
68
        """ Read at most size bytes from the file (less if the read hits EOF 
 
69
        before obtaining size bytes).
 
70
 
 
71
        If the size argument is negative or omitted, read all data until EOF is      
 
72
        reached. The bytes are returned as a string object. An empty string is 
 
73
        returned when EOF is encountered immediately.
 
74
 
 
75
        Truncates the buffer.
 
76
        """
 
77
 
 
78
        self.seek(0)
 
79
        res = StringIO.StringIO.read(self, n)
 
80
        self.truncate(0)
 
81
        return res
 
82
 
 
83
    def readline(self, length=None):
 
84
        """ Read one entire line from the file.
 
85
 
 
86
        A trailing newline character is kept in the string (but may be absent 
 
87
        when a file ends with an incomplete line). If the size argument is   
 
88
        present and non-negative, it is a maximum byte count (including the      
 
89
        trailing newline) and an incomplete line may be returned.
 
90
 
 
91
        An empty string is returned only when EOF is encountered immediately.
 
92
        
 
93
        Note: Unlike stdio's fgets(), the returned string contains null   
 
94
        characters ('\0') if they occurred in the input.
 
95
 
 
96
        Removes the line from the buffer.
 
97
        """
 
98
 
 
99
        self.seek(0)
 
100
        res = StringIO.StringIO.readline(self, length)
 
101
        rest = StringIO.StringIO.read(self)
 
102
        self.truncate(0)
 
103
        self.write(rest)
 
104
        return res
 
105
 
 
106
    def readlines(self, sizehint=0):
 
107
        """ Read until EOF using readline() and return a list containing the        
 
108
        lines thus read.
 
109
        
 
110
        If the optional sizehint argument is present, instead of reading up to 
 
111
        EOF, whole lines totalling approximately sizehint bytes (or more to      
 
112
        accommodate a final whole line).
 
113
 
 
114
        Truncates the buffer.
 
115
        """
 
116
 
 
117
        self.seek(0)
 
118
        res = StringIO.StringIO.readlines(self, length)
 
119
        self.truncate(0)
 
120
        return res
 
121
 
 
122
class Console(object):
 
123
    """ Provides a nice python interface to the console
 
124
    """
 
125
    def __init__(self, uid, jail_path, working_dir):
 
126
        """Starts up a console service for user uid, inside chroot jail 
 
127
        jail_path with work directory of working_dir
 
128
        """
 
129
        super(Console, self).__init__()
 
130
 
 
131
        self.uid = uid
 
132
        self.jail_path = jail_path
 
133
        self.working_dir = working_dir
 
134
 
 
135
        # Set up the buffers
 
136
        self.stdin = TruncateStringIO()
 
137
        self.stdout = TruncateStringIO()
 
138
        self.stderr = TruncateStringIO()
 
139
 
 
140
        # Fire up the console
 
141
        self.restart()
 
142
 
 
143
    def restart(self):
 
144
        # Empty all the buffers
 
145
        self.stdin.truncate(0)
 
146
        self.stdout.truncate(0)
 
147
        self.stderr.truncate(0)
 
148
 
 
149
        # TODO: Check if we are already running a console. If we are shut it 
 
150
        # down first.
 
151
 
 
152
        # TODO: Figure out the host name the console server is running on.
 
153
        self.host = socket.gethostname()
 
154
 
 
155
        # Create magic
 
156
        # TODO
 
157
        self.magic = md5.new(uuid.uuid4().bytes).digest().encode('hex')
 
158
 
 
159
        # Try to find a free port on the server.
 
160
        # Just try some random ports in the range [3000,8000)
 
161
        # until we either succeed, or give up. If you think this
 
162
        # sounds risky, it isn't:
 
163
        # For N ports (e.g. 5000) with k (e.g. 100) in use, the
 
164
        # probability of failing to find a free port in t (e.g. 5) tries
 
165
        # is (k / N) ** t (e.g. 3.2*10e-9).
 
166
 
 
167
        tries = 0
 
168
        while tries < 5:
 
169
            self.port = int(random.uniform(3000, 8000))
 
170
 
 
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
            cmd = ' '.join([
 
175
                trampoline_path,
 
176
                str(self.uid),
 
177
                self.jail_path,
 
178
                console_dir,
 
179
                python_path,
 
180
                console_path,
 
181
                str(self.port),
 
182
                str(self.magic),
 
183
                self.working_dir
 
184
                ])
 
185
 
 
186
            res = os.system(cmd)
 
187
 
 
188
            if res == 0:
 
189
                # success
 
190
                break;
 
191
 
 
192
            tries += 1
 
193
 
 
194
        # If we can't start the console after 5 attemps (can't find a free port 
 
195
        # during random probing, syntax errors, segfaults) throw an exception.
 
196
        if tries == 5:
 
197
            raise ConsoleError("Unable to start console service!")
 
198
 
 
199
    def __chat(self, cmd, args):
 
200
        """ A wrapper around chat.chat to comunicate directly with the 
 
201
        console.
 
202
        """
 
203
        try:
 
204
            response = chat.chat(self.host, self.port,
 
205
                {'cmd': cmd, 'text': args}, self.magic)
 
206
        except socket.error, (enumber, estring):
 
207
            if enumber == errno.ECONNREFUSED:
 
208
                # Timeout
 
209
                raise ConsoleError(
 
210
                    "Could not establish a connection to the python console")
 
211
            else:
 
212
                # Some other error - probably serious
 
213
                raise socket.error, (enumber, estring)
 
214
        except cjson.DecodeError:
 
215
            # Couldn't decode the JSON
 
216
            raise ConsoleError(
 
217
                "Could not understand the python console response")
 
218
 
 
219
        return response
 
220
 
 
221
    def __handle_chat(self, cmd, args):
 
222
        """ A wrapper around self.__chat that handles all the messy responses 
 
223
        of chat for higher level interfaces such as inspect
 
224
        """
 
225
        # Do the request
 
226
        response = self.__chat(cmd, args)
 
227
 
 
228
        # Process I/O requests
 
229
        while 'output' in response or 'input' in response:
 
230
            if 'output' in response:
 
231
                self.stdout.write(response['output'])
 
232
                response = self.chat()
 
233
            elif 'input' in response:
 
234
                response = self.chat(self.stdin.readline())
 
235
 
 
236
        # Process user exceptions
 
237
        if 'exc' in response:
 
238
            raise ConsoleException(response['exc'])
 
239
 
 
240
        return response
 
241
 
 
242
    def chat(self, code=''):
 
243
        """ Executes a partial block of code """
 
244
        return self.__chat('chat', code)
 
245
 
 
246
    def block(self, code):
 
247
        """ Executes a block of code and returns the output """
 
248
        block = self.__handle_chat('block', code)
 
249
        if 'output' in block:
 
250
            return block['output']
 
251
        elif 'okay' in block:
 
252
            return
 
253
        else:
 
254
            raise ConsoleException("Bad response from console: %s"%str(block))
 
255
 
 
256
    def globals(self, globs=None):
 
257
        """ Returns a dictionary of the console's globals and optionally set 
 
258
        them to a new value
 
259
        """
 
260
        # Pickle the globals
 
261
        pickled_globs = None
 
262
        if globs is not None:
 
263
            pickled_globs = {}
 
264
            for g in globs:
 
265
                pickled_globs[g] = cPickle.dumps(globs[g])
 
266
 
 
267
        globals = self.__handle_chat('globals', pickled_globs)
 
268
 
 
269
        # Unpickle the globals
 
270
        for g in globals['globals']:
 
271
            globals['globals'][g] = cPickle.loads(globals['globals'][g])
 
272
 
 
273
        return globals['globals']
 
274
        
 
275
 
 
276
    def call(self, function, *args, **kwargs):
 
277
        """ Calls a function in the python console. Can take in a list of 
 
278
        repr() args and dictionary of repr() values kwargs. These will be 
 
279
        evaluated on the server side.
 
280
        """
 
281
        call_args = {
 
282
            'function': function,
 
283
            'args': args,
 
284
            'kwargs': kwargs}
 
285
        call = self.__handle_chat('call', call_args)
 
286
 
 
287
        # Unpickle any exceptions
 
288
        if 'exception' in call:
 
289
            call['exception']['except'] = \
 
290
                cPickle.loads(call['exception']['except'])
 
291
 
 
292
        return call
 
293
 
 
294
    def execute(self, code=''):
 
295
        """ Runs a block of code in the python console.
 
296
        If an exception was thrown then returns an exception object.
 
297
        """
 
298
        execute = self.__handle_chat('execute', code)
 
299
              
 
300
        # Unpickle any exceptions
 
301
        if 'exception' in execute:
 
302
            return cPickle.loads(execute['exception'])
 
303
        else:
 
304
            return execute
 
305
 
 
306
 
 
307
    def set_vars(self, variables):
 
308
        """ Takes a dictionary of varibles to add to the console's global 
 
309
        space. These are evaluated in the local space so you can't use this to 
 
310
        set a varible to a value to be calculated on the console side.
 
311
        """
 
312
        vars = {}
 
313
        for v in variables:
 
314
            vars[v] = repr(variables[v])
 
315
 
 
316
        set_vars = self.__handle_chat('set_vars', vars)
 
317
 
 
318
        if set_vars.get('response') != 'okay':
 
319
            raise ConsoleError("Could not set variables")
 
320
 
 
321
    def close(self):
 
322
        """ Causes the console process to terminate """
 
323
        return self.__chat('terminate', None)
 
324
    
 
325
class ExistingConsole(Console):
 
326
    """ Provides a nice python interface to an existing console.
 
327
    Note: You can't restart an existing console since there is no way to infer 
 
328
    all the starting parameters. Just start a new Console instead.
 
329
    """
 
330
    def __init__(self, host, port, magic):
 
331
        self.host = host
 
332
        self.port = port
 
333
        self.magic = magic
 
334
 
 
335
        # Set up the buffers
 
336
        self.stdin = TruncateStringIO()
 
337
        self.stdout = TruncateStringIO()
 
338
        self.stderr = TruncateStringIO()
 
339
 
 
340
    def restart():
 
341
        raise NotImplementedError('You can not restart an existing console')
 
342