--- /dev/null
+import select
+import socket
+import struct
+import sys
+import types
+
+VERBOSE = None
+
+class SocketProtocol:
+ """A simple protocol for sending strings across a socket"""
+ BUF_SIZE = 8192
+
+ def __init__(self, sock):
+ self.sock = sock
+ self._buffer = ''
+ self._closed = 0
+
+ def close(self):
+ self._closed = 1
+ self.sock.close()
+
+ def send(self, buf):
+ """Encode buf and write it on the socket"""
+ if VERBOSE:
+ VERBOSE.write('send %d:%s\n' % (len(buf), `buf`))
+ self.sock.send('%d:%s' % (len(buf), buf))
+
+ def receive(self, timeout=0):
+ """Get next complete string from socket or return None
+
+ Raise EOFError on EOF
+ """
+ buf = self._read_from_buffer()
+ if buf is not None:
+ return buf
+ recvbuf = self._read_from_socket(timeout)
+ if recvbuf is None:
+ return None
+ if recvbuf == '' and self._buffer == '':
+ raise EOFError
+ if VERBOSE:
+ VERBOSE.write('recv %s\n' % `recvbuf`)
+ self._buffer = self._buffer + recvbuf
+ r = self._read_from_buffer()
+ return r
+
+ def _read_from_socket(self, timeout):
+ """Does not block"""
+ if self._closed:
+ return ''
+ if timeout is not None:
+ r, w, x = select.select([self.sock], [], [], timeout)
+ if timeout is None or r:
+ return self.sock.recv(self.BUF_SIZE)
+ else:
+ return None
+
+ def _read_from_buffer(self):
+ buf = self._buffer
+ i = buf.find(':')
+ if i == -1:
+ return None
+ buflen = int(buf[:i])
+ enclen = i + 1 + buflen
+ if len(buf) >= enclen:
+ s = buf[i+1:enclen]
+ self._buffer = buf[enclen:]
+ return s
+ else:
+ self._buffer = buf
+ return None
+
+# helpers for registerHandler method below
+
+def get_methods(obj):
+ methods = []
+ for name in dir(obj):
+ attr = getattr(obj, name)
+ if callable(attr):
+ methods.append(name)
+ if type(obj) == types.InstanceType:
+ methods = methods + get_methods(obj.__class__)
+ if type(obj) == types.ClassType:
+ for super in obj.__bases__:
+ methods = methods + get_methods(super)
+ return methods
+
+class CommandProtocol:
+ def __init__(self, sockp):
+ self.sockp = sockp
+ self.seqno = 0
+ self.handlers = {}
+
+ def close(self):
+ self.sockp.close()
+ self.handlers.clear()
+
+ def registerHandler(self, handler):
+ """A Handler is an object with handle_XXX methods"""
+ for methname in get_methods(handler):
+ if methname[:7] == "handle_":
+ name = methname[7:]
+ self.handlers[name] = getattr(handler, methname)
+
+ def send(self, cmd, arg='', seqno=None):
+ if arg:
+ msg = "%s %s" % (cmd, arg)
+ else:
+ msg = cmd
+ if seqno is None:
+ seqno = self.get_seqno()
+ msgbuf = self.encode_seqno(seqno) + msg
+ self.sockp.send(msgbuf)
+ if cmd == "reply":
+ return
+ reply = self.sockp.receive(timeout=None)
+ r_cmd, r_arg, r_seqno = self._decode_msg(reply)
+ assert r_seqno == seqno and r_cmd == "reply", "bad reply"
+ return r_arg
+
+ def _decode_msg(self, msg):
+ seqno = self.decode_seqno(msg[:self.SEQNO_ENC_LEN])
+ msg = msg[self.SEQNO_ENC_LEN:]
+ parts = msg.split(" ", 2)
+ if len(parts) == 1:
+ cmd = msg
+ arg = ''
+ else:
+ cmd = parts[0]
+ arg = parts[1]
+ return cmd, arg, seqno
+
+ def dispatch(self):
+ msg = self.sockp.receive()
+ if msg is None:
+ return
+ cmd, arg, seqno = self._decode_msg(msg)
+ self._current_reply = seqno
+ h = self.handlers.get(cmd, self.default_handler)
+ try:
+ r = h(arg)
+ except TypeError, msg:
+ raise TypeError, "handle_%s: %s" % (cmd, msg)
+ if self._current_reply is None:
+ if r is not None:
+ sys.stderr.write("ignoring %s return value type %s\n" % \
+ (cmd, type(r).__name__))
+ return
+ if r is None:
+ r = ''
+ if type(r) != types.StringType:
+ raise ValueError, "invalid return type for %s" % cmd
+ self.send("reply", r, seqno=seqno)
+
+ def reply(self, arg=''):
+ """Send a reply immediately
+
+ otherwise reply will be sent when handler returns
+ """
+ self.send("reply", arg, self._current_reply)
+ self._current_reply = None
+
+ def default_handler(self, arg):
+ sys.stderr.write("WARNING: unhandled message %s\n" % arg)
+ return ''
+
+ SEQNO_ENC_LEN = 4
+
+ def get_seqno(self):
+ seqno = self.seqno
+ self.seqno = seqno + 1
+ return seqno
+
+ def encode_seqno(self, seqno):
+ return struct.pack("I", seqno)
+
+ def decode_seqno(self, buf):
+ return struct.unpack("I", buf)[0]
+
+
+class StdioRedirector:
+ """Redirect sys.std{in,out,err} to a set of file-like objects"""
+
+ def __init__(self, stdin, stdout, stderr):
+ self.stdin = stdin
+ self.stdout = stdout
+ self.stderr = stderr
+
+ def redirect(self):
+ self.save()
+ sys.stdin = self.stdin
+ sys.stdout = self.stdout
+ sys.stderr = self.stderr
+
+ def save(self):
+ self._stdin = sys.stdin
+ self._stdout = sys.stdout
+ self._stderr = sys.stderr
+
+ def restore(self):
+ sys.stdin = self._stdin
+ sys.stdout = self._stdout
+ sys.stderr = self._stderr
+
+class IOWrapper:
+ """Send output from a file-like object across a SocketProtocol
+
+ XXX Should this be more tightly integrated with the CommandProtocol?
+ """
+
+ def __init__(self, name, cmdp):
+ self.name = name
+ self.cmdp = cmdp
+ self.buffer = []
+
+class InputWrapper(IOWrapper):
+ def write(self, buf):
+ # XXX what should this do on Windows?
+ raise IOError, (9, '[Errno 9] Bad file descriptor')
+
+ def read(self, arg=None):
+ if arg is not None:
+ if arg <= 0:
+ return ''
+ else:
+ arg = 0
+ return self.cmdp.send(self.name, "read,%s" % arg)
+
+ def readline(self):
+ return self.cmdp.send(self.name, "readline")
+
+class OutputWrapper(IOWrapper):
+ def write(self, buf):
+ self.cmdp.send(self.name, buf)
+
+ def read(self, arg=None):
+ return ''
+
+class RemoteInterp:
+ def __init__(self, sock):
+ self._sock = SocketProtocol(sock)
+ self._cmd = CommandProtocol(self._sock)
+ self._cmd.registerHandler(self)
+
+ def run(self):
+ try:
+ while 1:
+ self._cmd.dispatch()
+ except EOFError:
+ pass
+
+ def handle_execfile(self, arg):
+ self._cmd.reply()
+ io = StdioRedirector(InputWrapper("stdin", self._cmd),
+ OutputWrapper("stdout", self._cmd),
+ OutputWrapper("stderr", self._cmd))
+ io.redirect()
+ execfile(arg, {'__name__':'__main__'})
+ io.restore()
+ self._cmd.send("terminated")
+
+ def handle_quit(self, arg):
+ self._cmd.reply()
+ self._cmd.close()
+
+def startRemoteInterp(id):
+ import os
+ # UNIX domain sockets are simpler for starters
+ sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ sock.bind("/var/tmp/ri.%s" % id)
+ try:
+ sock.listen(1)
+ cli, addr = sock.accept()
+ rinterp = RemoteInterp(cli)
+ rinterp.run()
+ finally:
+ os.unlink("/var/tmp/ri.%s" % id)
+
+class RIClient:
+ """Client of the remote interpreter"""
+ def __init__(self, sock):
+ self._sock = SocketProtocol(sock)
+ self._cmd = CommandProtocol(self._sock)
+ self._cmd.registerHandler(self)
+
+ def execfile(self, file):
+ self._cmd.send("execfile", file)
+
+ def run(self):
+ try:
+ while 1:
+ self._cmd.dispatch()
+ except EOFError:
+ pass
+
+ def handle_stdout(self, buf):
+ sys.stdout.write(buf)
+## sys.stdout.flush()
+
+ def handle_stderr(self, buf):
+ sys.stderr.write(buf)
+
+ def handle_stdin(self, arg):
+ if arg == "readline":
+ return sys.stdin.readline()
+ i = arg.find(",") + 1
+ bytes = int(arg[i:])
+ if bytes == 0:
+ return sys.stdin.read()
+ else:
+ return sys.stdin.read(bytes)
+
+ def handle_terminated(self, arg):
+ self._cmd.reply()
+ self._cmd.send("quit")
+ self._cmd.close()
+
+def riExec(id, file):
+ sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ sock.connect("/var/tmp/ri.%s" % id)
+ cli = RIClient(sock)
+ cli.execfile(file)
+ cli.run()
+
+if __name__ == "__main__":
+ import sys
+ import getopt
+
+ SERVER = 1
+ opts, args = getopt.getopt(sys.argv[1:], 'cv')
+ for o, v in opts:
+ if o == '-c':
+ SERVER = 0
+ elif o == '-v':
+ VERBOSE = sys.stderr
+ id = args[0]
+
+ if SERVER:
+ startRemoteInterp(id)
+ else:
+ file = args[1]
+ riExec(id, file)
+
projects / python / commitdiff