← Back to branch summary

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

« back to all changes in this revision

Viewing changes to scripts/python-console

  • Committer: mattgiuca
  • Date: 2008-03-15 02:15:55 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:690
tutorial: Added new balls (orange and grey) for new tutorial features.
Extended CSS with extra list styles.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scripts/python-console
1
1
#!/usr/bin/python
2
2
 
3
3
# usage:
4
 
#   python-console <port> <magic>
 
4
#   python-console <port> <magic> [<working-dir>]
5
5
 
6
6
import cjson
7
7
import codeop
8
 
import cStringIO
9
8
import md5
10
9
import os
11
10
import Queue
13
12
import socket
14
13
import sys
15
14
from threading import Thread
 
15
from functools import partial
16
16
 
17
17
import common.chat
18
18
 
 
19
class Interrupt(Exception):
 
20
    def __init__(self):
 
21
        Exception.__init__(self, "Interrupted!")
 
22
 
 
23
class ExpiryTimer(object):
 
24
    def __init__(self, idle):
 
25
        self.idle = idle
 
26
        signal.signal(signal.SIGALRM, partial(self.timeout))
 
27
 
 
28
    def ping(self):
 
29
        signal.alarm(self.idle)
 
30
 
 
31
    def start(self, time):
 
32
        signal.alarm(time)
 
33
 
 
34
    def stop(self):
 
35
        self.ping()
 
36
 
 
37
    def timeout(self, signum, frame):
 
38
        sys.exit(1)
 
39
        
19
40
class StdinFromWeb(object):
20
41
    def __init__(self, cmdQ, lineQ):
21
42
        self.cmdQ = cmdQ
22
43
        self.lineQ = lineQ
23
44
 
24
45
    def readline(self):
25
 
        # stop the clock!
26
 
        signal.alarm(0)
27
46
        self.cmdQ.put({"input":None})
 
47
        expiry.ping()
28
48
        ln = self.lineQ.get()
29
49
        if 'chat' in ln:
30
 
            # restart the clock:
31
 
            # Some of our 5 seconds may have elapsed, but never mind.
32
 
            signal.alarm(5)
33
50
            return ln['chat']
 
51
        if 'interrupt' in ln:
 
52
            raise Interrupt()
 
53
 
 
54
class StdoutToWeb(object):
 
55
    def __init__(self, cmdQ, lineQ):
 
56
        self.cmdQ = cmdQ
 
57
        self.lineQ = lineQ
 
58
        self.remainder = ''
 
59
 
 
60
    def write(self, stuff):
 
61
        self.remainder = self.remainder + stuff
 
62
 
 
63
        # if there's less than 128 bytes, buffer
 
64
        if len(self.remainder) < 128:
 
65
            return
 
66
 
 
67
        # if there's lots, then send it in 1/2K blocks
 
68
        while len(self.remainder) > 512:
 
69
            blk = self.remainder[0:512]
 
70
            self.cmdQ.put({"output":blk})
 
71
            expiry.ping()
 
72
            ln = self.lineQ.get()
 
73
            self.remainder = self.remainder[512:]
 
74
 
 
75
        # Finally, split the remainder up into lines, and ship all the
 
76
        # completed lines off to the server.
 
77
        lines = self.remainder.split("\n")
 
78
        self.remainder = lines[-1]
 
79
        del lines[-1]
 
80
 
 
81
        if len(lines) > 0:
 
82
            lines.append('')
 
83
            text = "\n".join(lines)
 
84
            self.cmdQ.put({"output":text})
 
85
            expiry.ping()
 
86
            ln = self.lineQ.get()
 
87
            if 'interrupt' in ln:
 
88
                raise Interrupt()
 
89
 
 
90
    def flush(self):
 
91
        if len(self.remainder) > 0:
 
92
            self.cmdQ.put({"output":self.remainder})
 
93
            expiry.ping()
 
94
            ln = self.lineQ.get()
 
95
            self.remainder = ''
 
96
            if 'interrupt' in ln:
 
97
                raise Interrupt()
34
98
 
35
99
class PythonRunner(Thread):
36
100
    def __init__(self, cmdQ, lineQ):
37
101
        self.cmdQ = cmdQ
38
102
        self.lineQ = lineQ
39
 
        self.out = cStringIO.StringIO()
 
103
        self.stdout = StdoutToWeb(self.cmdQ, self.lineQ)
40
104
        Thread.__init__(self)
41
105
 
42
106
    def execCmd(self, cmd):
43
107
        try:
44
108
            sys.stdin = StdinFromWeb(self.cmdQ, self.lineQ)
45
 
            sys.stdout = self.out
46
 
            sys.stderr = self.out
47
 
            signal.alarm(5)
 
109
            sys.stdout = self.stdout
 
110
            sys.stderr = self.stdout
48
111
            res = eval(cmd, self.globs, self.locls)
49
 
            signal.alarm(0)
50
 
            self.cmdQ.put({"okay":(self.out.getvalue(),res)})
 
112
            self.stdout.flush()
 
113
            self.cmdQ.put({"okay":res})
51
114
            self.curr_cmd = ''
52
 
            self.out = cStringIO.StringIO()
53
115
        except Exception, exc:
54
 
            signal.alarm(0)
55
 
            self.cmdQ.put({"exc":(self.out.getvalue(),str(exc))})
 
116
            self.stdout.flush()
 
117
            self.cmdQ.put({"exc":str(exc)})
56
118
            self.curr_cmd = ''
57
 
            self.out = cStringIO.StringIO()
58
119
 
59
120
    def run(self):
60
 
        self.init_state()
 
121
        self.globs = {}
 
122
        self.globs['__builtins__'] = globals()['__builtins__']
 
123
        self.locls = {}
 
124
        self.curr_cmd = ''
61
125
        compiler = codeop.CommandCompiler()
62
126
 
63
127
        while True:
77
141
                    else:
78
142
                        self.execCmd(cmd)
79
143
                except Exception, exc:
80
 
                    signal.alarm(0)
81
 
                    self.cmdQ.put({"exc":(self.out.getvalue(),str(exc))})
 
144
                    self.stdout.flush()
 
145
                    self.cmdQ.put({"exc":str(exc)})
82
146
                    self.curr_cmd = ''
83
 
                    self.out = cStringIO.StringIO()
84
147
            if 'block' in ln:
85
148
                # throw away a partial command.
86
149
                try:
87
150
                    cmd = compile(ln['block'], "<web session>", 'exec');
88
151
                    self.execCmd(cmd)
89
152
                except Exception, exc:
90
 
                    signal.alarm(0)
91
 
                    self.cmdQ.put({"exc":(self.out.getvalue(),str(exc))})
 
153
                    self.stdout.flush()
 
154
                    self.cmdQ.put({"exc":str(exc)})
92
155
                    self.curr_cmd = ''
93
 
                    self.out = cStringIO.StringIO()
94
 
 
95
 
    def init_state(self):
96
 
        self.globs = {}
97
 
        self.globs['__builtins__'] = globals()['__builtins__']
98
 
        self.locls = {}
99
 
        self.curr_cmd = ''
100
156
 
101
157
def daemonize():
102
158
    if os.fork():   # launch child and...
115
171
lineQ = Queue.Queue()
116
172
interpThread = PythonRunner(cmdQ, lineQ)
117
173
 
 
174
# Default expiry time of 15 minutes
 
175
expiry = ExpiryTimer(15 * 60)
 
176
 
118
177
def initializer():
119
178
    interpThread.setDaemon(True)
120
179
    interpThread.start()
 
180
    expiry.ping()
121
181
 
122
182
def dispatch_msg(msg):
 
183
    expiry.ping()
123
184
    lineQ.put({msg['cmd']:msg['text']})
124
185
    return cmdQ.get()
125
186
 
126
187
if __name__ == "__main__":
127
188
    port = int(sys.argv[1])
128
189
    magic = sys.argv[2]
 
190
    if len(sys.argv) >= 4:
 
191
        # working_dir
 
192
        os.chdir(sys.argv[3])
 
193
        os.environ['HOME'] = sys.argv[3]
129
194
 
130
195
    common.chat.start_server(port, magic, True, dispatch_msg, initializer)