Initial revision
diff --git a/Lib/idlelib/protocol.py b/Lib/idlelib/protocol.py
new file mode 100644
index 0000000..10295bf
--- /dev/null
+++ b/Lib/idlelib/protocol.py
@@ -0,0 +1,369 @@
+"""protocol (David Scherer <dscherer@cmu.edu>)
+
+ This module implements a simple RPC or "distributed object" protocol.
+ I am probably the 100,000th person to write this in Python, but, hey,
+ it was fun.
+
+ Contents:
+
+ connectionLost is an exception that will be thrown by functions in
+ the protocol module or calls to remote methods that fail because
+ the remote program has closed the socket or because no connection
+ could be established in the first place.
+
+ Server( port=None, connection_hook=None ) creates a server on a
+ well-known port, to which clients can connect. When a client
+ connects, a Connection is created for it. If connection_hook
+ is defined, then connection_hook( socket.getpeername() ) is called
+ before a Connection is created, and if it returns false then the
+ connection is refused. connection_hook must be prepared to be
+ called from any thread.
+
+ Client( ip='127.0.0.1', port=None ) returns a Connection to a Server
+ object at a well-known address and port.
+
+ Connection( socket ) creates an RPC connection on an arbitrary socket,
+ which must already be connected to another program. You do not
+ need to use this directly if you are using Client() or Server().
+
+ publish( name, connect_function ) provides an object with the
+ specified name to some or all Connections. When another program
+ calls Connection.getobject() with the specified name, the
+ specified connect_function is called with the arguments
+
+ connect_function( conn, addr )
+
+ where conn is the Connection object to the requesting client and
+ addr is the address returned by socket.getpeername(). If that
+ function returns an object, that object becomes accessible to
+ the caller. If it returns None, the caller's request fails.
+
+ Connection objects:
+
+ .close() refuses additional RPC messages from the peer, and notifies
+ the peer that the connection has been closed. All pending remote
+ method calls in either program will fail with a connectionLost
+ exception. Further remote method calls on this connection will
+ also result in errors.
+
+ .getobject(name) returns a proxy for the remote object with the
+ specified name, if it exists and the peer permits us access.
+ Otherwise, it returns None. It may throw a connectionLost
+ exception. The returned proxy supports basic attribute access
+ and method calls, and its methods have an extra attribute,
+ .void, which is a function that has the same effect but always
+ returns None. This last capability is provided as a performance
+ hack: object.method.void(params) can return without waiting for
+ the remote process to respond, but object.method(params) needs
+ to wait for a return value or exception.
+
+ .rpc_loop(block=0) processes *incoming* messages for this connection.
+ If block=1, it continues processing until an exception or return
+ value is received, which is normally forever. Otherwise it
+ returns when all currently pending messages have been delivered.
+ It may throw a connectionLost exception.
+
+ .set_close_hook(f) specifies a function to be called when the remote
+ object closes the connection during a call to rpc_loop(). This
+ is a good way for servers to be notified when clients disconnect.
+
+ .set_shutdown_hook(f) specifies a function called *immediately* when
+ the receive loop detects that the connection has been lost. The
+ provided function must be prepared to run in any thread.
+
+ Server objects:
+
+ .rpc_loop() processes incoming messages on all connections, and
+ returns when all pending messages have been processed. It will
+ *not* throw connectionLost exceptions; the
+ Connection.set_close_hook() mechanism is much better for servers.
+"""
+
+import sys, os, string, types
+import socket
+from threading import Thread
+from Queue import Queue, Empty
+from cPickle import Pickler, Unpickler, PicklingError
+
+class connectionLost:
+ def __init__(self, what=""): self.what = what
+ def __repr__(self): return self.what
+ def __str__(self): return self.what
+
+def getmethods(cls):
+ "Returns a list of the names of the methods of a class."
+ methods = []
+ for b in cls.__bases__:
+ methods = methods + getmethods(b)
+ d = cls.__dict__
+ for k in d.keys():
+ if type(d[k])==types.FunctionType:
+ methods.append(k)
+ return methods
+
+class methodproxy:
+ "Proxy for a method of a remote object."
+ def __init__(self, classp, name):
+ self.classp=classp
+ self.name=name
+ self.client = classp.client
+ def __call__(self, *args, **keywords):
+ return self.client.call( 'm', self.classp.name, self.name, args, keywords )
+
+ def void(self, *args, **keywords):
+ self.client.call_void( 'm', self.classp.name,self.name,args,keywords)
+
+class classproxy:
+ "Proxy for a remote object."
+ def __init__(self, client, name, methods):
+ self.__dict__['client'] = client
+ self.__dict__['name'] = name
+
+ for m in methods:
+ prox = methodproxy( self, m )
+ self.__dict__[m] = prox
+
+ def __getattr__(self, attr):
+ return self.client.call( 'g', self.name, attr )
+
+ def __setattr__(self, attr, value):
+ self.client.call_void( 's', self.name, attr, value )
+
+local_connect = {}
+def publish(name, connect_function):
+ local_connect[name]=connect_function
+
+class socketFile:
+ "File emulator based on a socket. Provides only blocking semantics for now."
+
+ def __init__(self, socket):
+ self.socket = socket
+ self.buffer = ''
+
+ def _recv(self,bytes):
+ try:
+ r=self.socket.recv(bytes)
+ except:
+ raise connectionLost()
+ if not r:
+ raise connectionLost()
+ return r
+
+ def write(self, string):
+ try:
+ self.socket.send( string )
+ except:
+ raise connectionLost()
+
+ def read(self,bytes):
+ x = bytes-len(self.buffer)
+ while x>0:
+ self.buffer=self.buffer+self._recv(x)
+ x = bytes-len(self.buffer)
+ s = self.buffer[:bytes]
+ self.buffer=self.buffer[bytes:]
+ return s
+
+ def readline(self):
+ while 1:
+ f = string.find(self.buffer,'\n')
+ if f>=0:
+ s = self.buffer[:f+1]
+ self.buffer=self.buffer[f+1:]
+ return s
+ self.buffer = self.buffer + self._recv(1024)
+
+
+class Connection (Thread):
+ debug = 0
+ def __init__(self, socket):
+ self.local_objects = {}
+ self.socket = socket
+ self.name = socket.getpeername()
+ self.socketfile = socketFile(socket)
+ self.queue = Queue(-1)
+ self.refuse_messages = 0
+ self.cmds = { 'm': self.r_meth,
+ 'g': self.r_get,
+ 's': self.r_set,
+ 'o': self.r_geto,
+ 'e': self.r_exc,
+ #'r' handled by rpc_loop
+ }
+
+ Thread.__init__(self)
+ self.setDaemon(1)
+ self.start()
+
+ def getobject(self, name):
+ methods = self.call( 'o', name )
+ if methods is None: return None
+ return classproxy(self, name, methods)
+
+ # close_hook is called from rpc_loop(), like a normal remote method
+ # invocation
+ def set_close_hook(self,hook): self.close_hook = hook
+
+ # shutdown_hook is called directly from the run() thread, and needs
+ # to be "thread safe"
+ def set_shutdown_hook(self,hook): self.shutdown_hook = hook
+
+ close_hook = None
+ shutdown_hook = None
+
+ def close(self):
+ self._shutdown()
+ self.refuse_messages = 1
+
+ def call(self, c, *args):
+ self.send( (c, args, 1 ) )
+ return self.rpc_loop( block = 1 )
+
+ def call_void(self, c, *args):
+ try:
+ self.send( (c, args, 0 ) )
+ except:
+ pass
+
+ # the following methods handle individual RPC calls:
+
+ def r_geto(self, obj):
+ c = local_connect.get(obj)
+ if not c: return None
+ o = c(self, self.name)
+ if not o: return None
+ self.local_objects[obj] = o
+ return getmethods(o.__class__)
+
+ def r_meth(self, obj, name, args, keywords):
+ return apply( getattr(self.local_objects[obj],name), args, keywords)
+
+ def r_get(self, obj, name):
+ return getattr(self.local_objects[obj],name)
+
+ def r_set(self, obj, name, value):
+ setattr(self.local_objects[obj],name,value)
+
+ def r_exc(self, e, v):
+ raise e, v
+
+ def rpc_exec(self, cmd, arg, ret):
+ if self.refuse_messages: return
+ if self.debug: print cmd,arg,ret
+ if ret:
+ try:
+ r=apply(self.cmds.get(cmd), arg)
+ self.send( ('r', r, 0) )
+ except:
+ try:
+ self.send( ('e', sys.exc_info()[:2], 0) )
+ except PicklingError:
+ self.send( ('e', (TypeError, 'Unpicklable exception.'), 0 ) )
+ else:
+ # we cannot report exceptions to the caller, so
+ # we report them in this process.
+ r=apply(self.cmds.get(cmd), arg)
+
+ # the following methods implement the RPC and message loops:
+
+ def rpc_loop(self, block=0):
+ if self.refuse_messages: raise connectionLost('(already closed)')
+ try:
+ while 1:
+ try:
+ cmd, arg, ret = self.queue.get( block )
+ except Empty:
+ return None
+ if cmd=='r': return arg
+ self.rpc_exec(cmd,arg,ret)
+ except connectionLost:
+ if self.close_hook:
+ self.close_hook()
+ self.close_hook = None
+ raise
+
+ def run(self):
+ try:
+ while 1:
+ data = self.recv()
+ self.queue.put( data )
+ except:
+ self.queue.put( ('e', sys.exc_info()[:2], 0) )
+
+ # The following send raw pickled data to the peer
+
+ def send(self, data):
+ try:
+ Pickler(self.socketfile,1).dump( data )
+ except connectionLost:
+ self._shutdown()
+ if self.shutdown_hook: self.shutdown_hook()
+ raise
+
+ def recv(self):
+ try:
+ return Unpickler(self.socketfile).load()
+ except connectionLost:
+ self._shutdown()
+ if self.shutdown_hook: self.shutdown_hook()
+ raise
+ except:
+ raise
+
+ def _shutdown(self):
+ try:
+ self.socket.shutdown(1)
+ self.socket.close()
+ except:
+ pass
+
+
+class Server (Thread):
+ default_port = 0x1D1E # "IDlE"
+
+ def __init__(self, port=None, connection_hook=None):
+ self.connections = []
+ self.port = port or self.default_port
+ self.connection_hook = connection_hook
+
+ try:
+ self.wellknown = s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ s.bind('', self.port)
+ s.listen(3)
+ except:
+ raise connectionLost
+
+ Thread.__init__(self)
+ self.setDaemon(1)
+ self.start()
+
+ def run(self):
+ s = self.wellknown
+ while 1:
+ conn, addr = s.accept()
+ if self.connection_hook and not self.connection_hook(addr):
+ try:
+ conn.shutdown(1)
+ except:
+ pass
+ continue
+ self.connections.append( Connection(conn) )
+
+ def rpc_loop(self):
+ cns = self.connections[:]
+ for c in cns:
+ try:
+ c.rpc_loop(block = 0)
+ except connectionLost:
+ if c in self.connections:
+ self.connections.remove(c)
+
+def Client(ip='127.0.0.1', port=None):
+ try:
+ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ s.connect(ip,port or Server.default_port)
+ except socket.error, what:
+ raise connectionLost(str(what))
+ except:
+ raise connectionLost()
+ return Connection(s)