GvR's rpc patch

Lib/idlelib/RemoteDebugger.py

@@ -0,0 +1,287 @@
+"""Support for remote Python debugging.
+
+Some ASCII art to describe the structure:
+
+       IN PYTHON SUBPROCESS          #             IN IDLE PROCESS
+                                     #
+                                     #        oid='gui_adapter'
+                 +----------+        #       +------------+          +-----+
+                 | GUIProxy |--remote#call-->| GUIAdapter |--calls-->| GUI |
++-----+--calls-->+----------+        #       +------------+          +-----+
+| Idb |                               #                             /
++-----+<-calls--+------------+         #      +----------+<--calls-/
+                | IdbAdapter |<--remote#call--| IdbProxy |
+                +------------+         #      +----------+
+                oid='idb_adapter'      #
+
+The purpose of the Proxy and Adapter classes is to translate certain
+arguments and return values that cannot be transported through the RPC
+barrier, in particular frame and traceback objects.
+
+"""
+
+import sys
+import rpc
+import Debugger
+
+# In the PYTHON subprocess
+
+frametable = {}
+dicttable = {}
+codetable = {}
+
+def wrap_frame(frame):
+    fid = id(frame)
+    frametable[fid] = frame
+    return fid
+
+def wrap_info(info):
+    if info is None:
+        return None
+    else:
+        return None # XXX for now
+
+class GUIProxy:
+
+    def __init__(self, conn, oid):
+        self.conn = conn
+        self.oid = oid
+
+    def interaction(self, message, frame, info=None):
+        self.conn.remotecall(self.oid, "interaction",
+                             (message, wrap_frame(frame), wrap_info(info)),
+                             {})
+
+class IdbAdapter:
+
+    def __init__(self, idb):
+        self.idb = idb
+
+    def set_step(self):
+        self.idb.set_step()
+
+    def set_quit(self):
+        self.idb.set_quit()
+
+    def set_continue(self):
+        self.idb.set_continue()
+
+    def set_next(self, fid):
+        frame = frametable[fid]
+        self.idb.set_next(frame)
+
+    def set_return(self, fid):
+        frame = frametable[fid]
+        self.idb.set_return(frame)
+
+    def get_stack(self, fid, tbid):
+        ##print >>sys.__stderr__, "get_stack(%s, %s)" % (`fid`, `tbid`)
+        frame = frametable[fid]
+        tb = None # XXX for now
+        stack, i = self.idb.get_stack(frame, tb)
+        ##print >>sys.__stderr__, "get_stack() ->", stack
+        stack = [(wrap_frame(frame), k) for frame, k in stack]
+        ##print >>sys.__stderr__, "get_stack() ->", stack
+        return stack, i
+
+    def run(self, cmd):
+        import __main__
+        self.idb.run(cmd, __main__.__dict__)
+
+    def frame_attr(self, fid, name):
+        frame = frametable[fid]
+        return getattr(frame, name)
+
+    def frame_globals(self, fid):
+        frame = frametable[fid]
+        dict = frame.f_globals
+        did = id(dict)
+        dicttable[did] = dict
+        return did
+
+    def frame_locals(self, fid):
+        frame = frametable[fid]
+        dict = frame.f_locals
+        did = id(dict)
+        dicttable[did] = dict
+        return did
+
+    def frame_code(self, fid):
+        frame = frametable[fid]
+        code = frame.f_code
+        cid = id(code)
+        codetable[cid] = code
+        return cid
+
+    def code_name(self, cid):
+        code = codetable[cid]
+        return code.co_name
+
+    def code_filename(self, cid):
+        code = codetable[cid]
+        return code.co_filename
+
+    def dict_keys(self, did):
+        dict = dicttable[did]
+        return dict.keys()
+
+    def dict_item(self, did, key):
+        dict = dicttable[did]
+        value = dict[key]
+        try:
+            # Test for picklability
+            import cPickle
+            cPickle.dumps(value)
+        except:
+            value = None
+        return value
+
+def start_debugger(conn, gui_oid):
+    #
+    # launched in the python subprocess
+    #
+    gui = GUIProxy(conn, gui_oid)
+    idb = Debugger.Idb(gui)
+    ada = IdbAdapter(idb)
+    ada_oid = "idb_adapter"
+    conn.register(ada_oid, ada)
+    return ada_oid
+
+# In the IDLE process
+
+class FrameProxy:
+
+    def __init__(self, conn, fid):
+        self._conn = conn
+        self._fid = fid
+        self._oid = "idb_adapter"
+        self._dictcache = {}
+
+    def __getattr__(self, name):
+        if name[:1] == "_":
+            raise AttributeError, name
+        if name == "f_code":
+            return self._get_f_code()
+        if name == "f_globals":
+            return self._get_f_globals()
+        if name == "f_locals":
+            return self._get_f_locals()
+        return self._conn.remotecall(self._oid, "frame_attr",
+                                     (self._fid, name), {})
+
+    def _get_f_code(self):
+        cid = self._conn.remotecall(self._oid, "frame_code", (self._fid,), {})
+        return CodeProxy(self._conn, self._oid, cid)
+
+    def _get_f_globals(self):
+        did = self._conn.remotecall(self._oid, "frame_globals",
+                                    (self._fid,), {})
+        return self._get_dict_proxy(did)
+
+    def _get_f_locals(self):
+        did = self._conn.remotecall(self._oid, "frame_locals",
+                                    (self._fid,), {})
+        return self._get_dict_proxy(did)
+
+    def _get_dict_proxy(self, did):
+        if self._dictcache.has_key(did):
+            return self._dictcache[did]
+        dp = DictProxy(self._conn, self._oid, did)
+        self._dictcache[did] = dp
+        return dp
+
+class CodeProxy:
+
+    def __init__(self, conn, oid, cid):
+        self._conn = conn
+        self._oid = oid
+        self._cid = cid
+
+    def __getattr__(self, name):
+        if name == "co_name":
+            return self._conn.remotecall(self._oid, "code_name",
+                                         (self._cid,), {})
+        if name == "co_filename":
+            return self._conn.remotecall(self._oid, "code_filename",
+                                         (self._cid,), {})
+
+class DictProxy:
+
+    def __init__(self, conn, oid, did):
+        self._conn = conn
+        self._oid = oid
+        self._did = did
+
+    def keys(self):
+        return self._conn.remotecall(self._oid, "dict_keys", (self._did,), {})
+
+    def __getitem__(self, key):
+        return self._conn.remotecall(self._oid, "dict_item",
+                                     (self._did, key), {})
+
+    def __getattr__(self, name):
+        ##print >>sys.__stderr__, "failed DictProxy.__getattr__:", name
+        raise AttributeError, name
+
+class GUIAdaper:
+
+    def __init__(self, conn, gui):
+        self.conn = conn
+        self.gui = gui
+
+    def interaction(self, message, fid, iid):
+        print "interaction(%s, %s, %s)" % (`message`, `fid`, `iid`)
+        frame = FrameProxy(self.conn, fid)
+        info = None # XXX for now
+        self.gui.interaction(message, frame, info)
+
+class IdbProxy:
+
+    def __init__(self, conn, oid):
+        self.oid = oid
+        self.conn = conn
+
+    def call(self, methodname, *args, **kwargs):
+        ##print "call %s %s %s" % (methodname, args, kwargs)
+        value = self.conn.remotecall(self.oid, methodname, args, kwargs)
+        ##print "return %s" % `value`
+        return value
+
+    def run(self, cmd, locals):
+        # Ignores locals on purpose!
+        self.call("run", cmd)
+
+    def get_stack(self, frame, tb):
+        stack, i = self.call("get_stack", frame._fid, None)
+        stack = [(FrameProxy(self.conn, fid), k) for fid, k in stack]
+        return stack, i
+
+    def set_continue(self):
+        self.call("set_continue")
+
+    def set_step(self):
+        self.call("set_step")
+
+    def set_next(self, frame):
+        self.call("set_next", frame._fid)
+
+    def set_return(self, frame):
+        self.call("set_return", frame._fid)
+
+    def set_quit(self):
+        self.call("set_quit")
+
+def start_remote_debugger(conn, pyshell):
+    #
+    # instruct the (remote) subprocess to create
+    # a debugger instance, and lets it know that 
+    # the local GUIAdapter called "gui_adapter"
+    # is waiting notification of debugging events
+    #
+    ada_oid = "gui_adapter"
+    idb_oid = conn.remotecall("exec", "start_debugger", (ada_oid,), {})
+    idb = IdbProxy(conn, idb_oid)
+    gui = Debugger.Debugger(pyshell, idb)
+    ada = GUIAdaper(conn, gui)
+    conn.register(ada_oid, ada)
+    return gui