← Back to branch summary

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

« back to all changes in this revision

Viewing changes to services/python-console

  • Committer: mattgiuca
  • Date: 2008-02-05 06:29:54 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:418
Renamed trunk/console to trunk/scripts. We are now able to put more scripts in
here such as fileservice.
Added fileservice (empty at the moment).
setup.py, consoleservice: Updated so they refer to scripts now instead of
console directory. (This changes listmake and install_list.py as well).

Added remakeuser.py which lets you recreate a user's jail without creating a
DB entry (but the user is already supposed to exist).

Show diffs side-by-side

added added

removed removed

Lines of Context:
services/python-console
1
 
#!/usr/bin/python
2
 
 
3
 
# usage:
4
 
#   python-console <port> <magic> [<working-dir>]
5
 
 
6
 
import cjson
7
 
import codeop
8
 
import cPickle
9
 
import cStringIO
10
 
import md5
11
 
import Queue
12
 
import signal
13
 
import socket
14
 
import sys
15
 
import traceback
16
 
from threading import Thread
17
 
 
18
 
import ivle.chat
19
 
import ivle.util
20
 
 
21
 
# This version must be supported by both the local and remote code
22
 
PICKLEVERSION = 0
23
 
 
24
 
class Interrupt(Exception):
25
 
    def __init__(self):
26
 
        Exception.__init__(self, "Interrupted!")
27
 
 
28
 
class ExpiryTimer(object):
29
 
    def __init__(self, idle):
30
 
        self.idle = idle
31
 
        signal.signal(signal.SIGALRM, self.timeout)
32
 
 
33
 
    def ping(self):
34
 
        signal.alarm(self.idle)
35
 
 
36
 
    def start(self, time):
37
 
        signal.alarm(time)
38
 
 
39
 
    def stop(self):
40
 
        self.ping()
41
 
 
42
 
    def timeout(self, signum, frame):
43
 
        sys.exit(1)
44
 
 
45
 
class StdinFromWeb(object):
46
 
    def __init__(self, cmdQ, lineQ):
47
 
        self.cmdQ = cmdQ
48
 
        self.lineQ = lineQ
49
 
 
50
 
    def readline(self):
51
 
        self.cmdQ.put({"input":None})
52
 
        expiry.ping()
53
 
        action, params = self.lineQ.get()
54
 
        if action == 'chat':
55
 
            return params
56
 
        elif action == 'interrupt':
57
 
            raise Interrupt()
58
 
 
59
 
class StdoutToWeb(object):
60
 
    def __init__(self, cmdQ, lineQ):
61
 
        self.cmdQ = cmdQ
62
 
        self.lineQ = lineQ
63
 
        self.remainder = ''
64
 
 
65
 
    def _trim_incomplete_final(self, stuff):
66
 
        '''Trim an incomplete UTF-8 character from the end of a string.
67
 
           Returns (trimmed_string, count_of_trimmed_bytes).
68
 
        '''
69
 
        tokill = ivle.util.incomplete_utf8_sequence(stuff)
70
 
        if tokill == 0:
71
 
            return (stuff, tokill)
72
 
        else:
73
 
            return (stuff[:-tokill], tokill)
74
 
 
75
 
    def write(self, stuff):
76
 
        # print will only give a non-file a unicode or str. There's no way
77
 
        # to convince it to encode unicodes, so we have to do it ourselves.
78
 
        # Yay for file special-cases (fileobject.c, PyFile_WriteObject).
79
 
        # If somebody wants to write some other object to here, they do it
80
 
        # at their own peril.
81
 
        if isinstance(stuff, unicode):
82
 
            stuff = stuff.encode('utf-8')
83
 
        self.remainder = self.remainder + stuff
84
 
 
85
 
        # if there's less than 128 bytes, buffer
86
 
        if len(self.remainder) < 128:
87
 
            return
88
 
 
89
 
        # if there's lots, then send it in 1/2K blocks
90
 
        while len(self.remainder) > 512:
91
 
            # We send things as Unicode inside JSON, so we must only send
92
 
            # complete UTF-8 characters.
93
 
            (blk, count) = self._trim_incomplete_final(self.remainder[:512])
94
 
            self.cmdQ.put({"output":blk.decode('utf-8', 'replace')})
95
 
            expiry.ping()
96
 
            action, params = self.lineQ.get()
97
 
            self.remainder = self.remainder[512 - count:]
98
 
 
99
 
        # Finally, split the remainder up into lines, and ship all the
100
 
        # completed lines off to the server.
101
 
        lines = self.remainder.split("\n")
102
 
        self.remainder = lines[-1]
103
 
        del lines[-1]
104
 
 
105
 
        if len(lines) > 0:
106
 
            lines.append('')
107
 
            text = "\n".join(lines)
108
 
            self.cmdQ.put({"output":text.decode('utf-8', 'replace')})
109
 
            expiry.ping()
110
 
            action, params = self.lineQ.get()
111
 
            if action == 'interrupt':
112
 
                raise Interrupt()
113
 
 
114
 
    def flush(self):
115
 
        if len(self.remainder) > 0:
116
 
            (out, count) = self._trim_incomplete_final(self.remainder)
117
 
            self.cmdQ.put({"output":out.decode('utf-8', 'replace')})
118
 
            expiry.ping()
119
 
            action, params = self.lineQ.get()
120
 
            # Leave incomplete characters in the buffer.
121
 
            # Yes, this does mean that an incomplete character will be left
122
 
            # off the end, but we discussed this and it was deemed best.
123
 
            self.remainder = self.remainder[len(self.remainder)-count:]
124
 
            if action == 'interrupt':
125
 
                raise Interrupt()
126
 
 
127
 
class WebIO(object):
128
 
    """Provides a file like interface to the Web front end of the console.
129
 
    You may print text to the console using write(), flush any buffered output 
130
 
    using flush(), or request text from the console using readline()"""
131
 
    # FIXME: Clean up the whole stdin, stdout, stderr mess. We really need to 
132
 
    # be able to deal with the streams individually.
133
 
    
134
 
    def __init__(self, cmdQ, lineQ):
135
 
        self.cmdQ = cmdQ
136
 
        self.lineQ = lineQ
137
 
        self.stdin = StdinFromWeb(self.cmdQ, self.lineQ)
138
 
        self.stdout = StdoutToWeb(self.cmdQ, self.lineQ)
139
 
 
140
 
    def write(self, stuff):
141
 
        self.stdout.write(stuff)
142
 
 
143
 
    def flush(self):
144
 
        self.stdout.flush()
145
 
 
146
 
    def readline(self):
147
 
        self.stdout.flush()
148
 
        return self.stdin.readline()
149
 
 
150
 
class PythonRunner(Thread):
151
 
    def __init__(self, cmdQ, lineQ):
152
 
        self.cmdQ = cmdQ
153
 
        self.lineQ = lineQ
154
 
        self.webio = WebIO(self.cmdQ, self.lineQ)
155
 
        self.cc = codeop.CommandCompiler()
156
 
        Thread.__init__(self)
157
 
 
158
 
    def execCmd(self, cmd):
159
 
        try:
160
 
            # We don't expect a return value - 'single' symbol prints it.
161
 
            self.eval(cmd)
162
 
            self.curr_cmd = ''
163
 
            self.webio.flush()
164
 
            return({"okay": None})
165
 
        except:
166
 
            self.curr_cmd = ''
167
 
            self.webio.flush()
168
 
            tb = format_exc_start(start=2)
169
 
            return({"exc": ''.join(tb).decode('utf-8', 'replace')})
170
 
 
171
 
    def run(self):
172
 
        # Set up global space and partial command buffer
173
 
        self.globs = {'__name__': '__main__'}
174
 
        self.curr_cmd = ''
175
 
 
176
 
        # Set up I/O to use web interface
177
 
        sys.stdin = self.webio
178
 
        sys.stdout = self.webio
179
 
        sys.stderr = self.webio
180
 
 
181
 
        # Handlers for each action
182
 
        actions = {
183
 
            'splash': self.handle_splash,
184
 
            'chat': self.handle_chat,
185
 
            'block': self.handle_block,
186
 
            'globals': self.handle_globals,
187
 
            'call': self.handle_call,
188
 
            'execute': self.handle_execute,
189
 
            'setvars': self.handle_setvars,
190
 
            }
191
 
 
192
 
        # Run the processing loop
193
 
        while True:
194
 
            action, params = self.lineQ.get()
195
 
            try:
196
 
                response = actions[action](params)
197
 
            except Exception, e:
198
 
                response = {'error': repr(e)}
199
 
            finally:
200
 
                self.cmdQ.put(response)
201
 
 
202
 
    def handle_splash(self, params):
203
 
        # Initial console splash screen
204
 
        python_version = '.'.join(str(v) for v in sys.version_info[:3])
205
 
        splash_text = ("""IVLE %s Python Console (Python %s)
206
 
Type "help", "copyright", "credits" or "license" for more information.
207
 
""" % (ivle.__version__, python_version))
208
 
        return {'output': splash_text}
209
 
 
210
 
    def handle_chat(self, params):
211
 
        # Set up the partial cmd buffer
212
 
        if self.curr_cmd == '':
213
 
            self.curr_cmd = params
214
 
        else:
215
 
            self.curr_cmd = self.curr_cmd + '\n' + params
216
 
 
217
 
        # Try to execute the buffer
218
 
        try:
219
 
            # A single trailing newline simply indicates that the line is
220
 
            # finished. Two trailing newlines indicate the end of a block.
221
 
            # Unfortunately, codeop.CommandCompiler causes even one to
222
 
            # terminate a block.
223
 
            # Thus we need to remove a trailing newline from the command,
224
 
            # unless there are *two* trailing newlines, or multi-line indented
225
 
            # blocks are impossible. See Google Code issue 105.
226
 
            cmd_text = self.curr_cmd
227
 
            if cmd_text.endswith('\n') and not cmd_text.endswith('\n\n'):
228
 
                cmd_text = cmd_text[:-1]
229
 
            cmd = self.cc(cmd_text, '<web session>')
230
 
            if cmd is None:
231
 
                # The command was incomplete, so send back a None, so the              
232
 
                # client can print a '...'
233
 
                return({"more":None})
234
 
            else:
235
 
                return(self.execCmd(cmd))
236
 
        except:
237
 
            # Clear any partial command
238
 
            self.curr_cmd = ''
239
 
            # Flush the output buffers
240
 
            sys.stderr.flush()
241
 
            sys.stdout.flush()
242
 
            # Return the exception
243
 
            tb = format_exc_start(start=3)
244
 
            return({"exc": ''.join(tb).decode('utf-8', 'replace')})
245
 
 
246
 
    def handle_block(self, params):
247
 
        # throw away any partial command.
248
 
        self.curr_cmd = ''
249
 
 
250
 
        # Try to execute a complete block of code
251
 
        try:
252
 
            cmd = compile(params, "<web session>", 'exec');
253
 
            return(self.execCmd(cmd))
254
 
        except:
255
 
            # Flush the output buffers
256
 
            sys.stderr.flush()
257
 
            sys.stdout.flush()
258
 
            # Return the exception
259
 
            tb = format_exc_start(start=1)
260
 
            return({"exc": ''.join(tb).decode('utf-8', 'replace')})
261
 
 
262
 
    def handle_globals(self, params):
263
 
        # Unpickle the new space (if provided)
264
 
        if isinstance(params, dict):
265
 
            self.globs = {'__name__': '__main__'}
266
 
            for g in params:
267
 
                try:
268
 
                    self.globs[g] = cPickle.loads(params[g])
269
 
                except:
270
 
                    pass
271
 
 
272
 
        # Return the current globals
273
 
        return({'globals': flatten(self.globs)})
274
 
 
275
 
    def handle_call(self, params):
276
 
        call = {}
277
 
        
278
 
        # throw away any partial command.
279
 
        self.curr_cmd = ''
280
 
 
281
 
        if isinstance(params, dict):
282
 
            try:
283
 
                # Expand parameters
284
 
                if isinstance(params['args'], list):
285
 
                    args = map(self.eval, params['args'])
286
 
                else:
287
 
                    args = []
288
 
                if isinstance(params['kwargs'], dict):
289
 
                    kwargs = {}
290
 
                    for kwarg in params['kwargs']:
291
 
                        kwargs[kwarg] = self.eval(
292
 
                            params['kwargs'][kwarg])
293
 
                else:
294
 
                    kwargs = {}
295
 
 
296
 
                # Run the fuction
297
 
                function = self.eval(params['function'])
298
 
                try:
299
 
                    call['result'] = function(*args, **kwargs)
300
 
                except Exception, e:
301
 
                    exception = {}
302
 
                    tb = format_exc_start(start=1)
303
 
                    exception['traceback'] = \
304
 
                        ''.join(tb).decode('utf-8', 'replace')
305
 
                    exception['except'] = cPickle.dumps(e,
306
 
                        PICKLEVERSION)
307
 
                    call['exception'] = exception
308
 
            except Exception, e:
309
 
                tb = format_exc_start(start=1)
310
 
                call = {"exc": ''.join(tb).decode('utf-8', 'replace')}
311
 
            
312
 
            # Flush the output buffers
313
 
            sys.stderr.flush()
314
 
            sys.stdout.flush()
315
 
 
316
 
            # Write out the inspection object
317
 
            return(call)
318
 
        else:
319
 
            return({'response': 'failure'})
320
 
 
321
 
    def handle_execute(self, params):
322
 
        # throw away any partial command.
323
 
        self.curr_cmd = ''
324
 
        
325
 
        # Like block but return a serialization of the state
326
 
        # throw away partial command
327
 
        response = {'okay': None}
328
 
        try:
329
 
            cmd = compile(params, "<web session>", 'exec');
330
 
            # We don't expect a return value - 'single' symbol prints it.
331
 
            self.eval(cmd)
332
 
        except Exception, e:
333
 
            response = {'exception': cPickle.dumps(e, PICKLEVERSION)}
334
 
           
335
 
        # Flush the output
336
 
        sys.stderr.flush()
337
 
        sys.stdout.flush()
338
 
               
339
 
        # Return the inspection object
340
 
        return(response)
341
 
 
342
 
    def handle_setvars(self, params):
343
 
        # Adds some variables to the global dictionary
344
 
        for var in params['set_vars']:
345
 
            try:
346
 
                self.globs[var] = self.eval(params['set_vars'][var])
347
 
            except Exception, e:
348
 
                tb = format_exc_start(start=1)
349
 
                return({"exc": ''.join(tb).decode('utf-8', 'replace')})
350
 
 
351
 
        return({'okay': None})
352
 
 
353
 
    def eval(self, source):
354
 
        """ Evaluates a string in the private global space """
355
 
        return eval(source, self.globs)
356
 
 
357
 
# The global 'magic' is the secret that the client and server share
358
 
# which is used to create and md5 digest to authenticate requests.
359
 
# It is assigned a real value at startup.
360
 
magic = ''
361
 
 
362
 
cmdQ = Queue.Queue()
363
 
lineQ = Queue.Queue()
364
 
interpThread = PythonRunner(cmdQ, lineQ)
365
 
terminate = None
366
 
 
367
 
# Default expiry time of 15 minutes
368
 
expiry = ExpiryTimer(15 * 60)
369
 
 
370
 
def initializer():
371
 
    interpThread.setDaemon(True)
372
 
    interpThread.start()
373
 
    signal.signal(signal.SIGXCPU, sig_handler)
374
 
    expiry.ping()
375
 
 
376
 
def sig_handler(signum, frame):
377
 
    """Handles response from signals"""
378
 
    global terminate
379
 
    if signum == signal.SIGXCPU:
380
 
        terminate = "CPU time limit exceeded"
381
 
 
382
 
def dispatch_msg(msg):
383
 
    global terminate
384
 
    if msg['cmd'] == 'terminate':
385
 
        terminate = "User requested restart"
386
 
    if terminate:
387
 
        raise ivle.chat.Terminate({"terminate":terminate})
388
 
    expiry.ping()
389
 
    lineQ.put((msg['cmd'],msg['text']))
390
 
    response = cmdQ.get()
391
 
    if terminate:
392
 
        raise ivle.chat.Terminate({"terminate":terminate})
393
 
    return response
394
 
 
395
 
def format_exc_start(start=0):
396
 
    etype, value, tb = sys.exc_info()
397
 
    tbbits = traceback.extract_tb(tb)[start:]
398
 
    list = ['Traceback (most recent call last):\n']
399
 
    list = list + traceback.format_list(tbbits)
400
 
    list = list + traceback.format_exception_only(etype, value)
401
 
    return ''.join(list)
402
 
 
403
 
 
404
 
# Takes an object and returns a flattened version suitable for JSON
405
 
def flatten(object):
406
 
    flat = {}
407
 
    for o in object:
408
 
        try:
409
 
            flat[o] = cPickle.dumps(object[o], PICKLEVERSION)
410
 
        except (TypeError, cPickle.PicklingError):
411
 
            try:
412
 
                o_type = type(object[o]).__name__
413
 
                o_name = object[o].__name__
414
 
                fake_o = ivle.util.FakeObject(o_type, o_name)
415
 
                flat[o] = cPickle.dumps(fake_o, PICKLEVERSION)
416
 
            except AttributeError:
417
 
                pass
418
 
    return flat
419
 
 
420
 
if __name__ == "__main__":
421
 
    port = int(sys.argv[1])
422
 
    magic = sys.argv[2]
423
 
 
424
 
    # Make python's search path follow the cwd
425
 
    sys.path[0] = ''
426
 
 
427
 
    ivle.chat.start_server(port, magic, True, dispatch_msg, initializer)