| """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 types |
| from idlelib import rpc |
| from idlelib import Debugger |
| |
| debugging = 0 |
| |
| idb_adap_oid = "idb_adapter" |
| gui_adap_oid = "gui_adapter" |
| |
| #======================================= |
| # |
| # In the PYTHON subprocess: |
| |
| frametable = {} |
| dicttable = {} |
| codetable = {} |
| tracebacktable = {} |
| |
| def wrap_frame(frame): |
| fid = id(frame) |
| frametable[fid] = frame |
| return fid |
| |
| def wrap_info(info): |
| "replace info[2], a traceback instance, by its ID" |
| if info is None: |
| return None |
| else: |
| traceback = info[2] |
| assert isinstance(traceback, types.TracebackType) |
| traceback_id = id(traceback) |
| tracebacktable[traceback_id] = traceback |
| modified_info = (info[0], info[1], traceback_id) |
| return modified_info |
| |
| class GUIProxy: |
| |
| def __init__(self, conn, gui_adap_oid): |
| self.conn = conn |
| self.oid = gui_adap_oid |
| |
| def interaction(self, message, frame, info=None): |
| # calls rpc.SocketIO.remotecall() via run.MyHandler instance |
| # pass frame and traceback object IDs instead of the objects themselves |
| self.conn.remotecall(self.oid, "interaction", |
| (message, wrap_frame(frame), wrap_info(info)), |
| {}) |
| |
| class IdbAdapter: |
| |
| def __init__(self, idb): |
| self.idb = idb |
| |
| #----------called by an IdbProxy---------- |
| |
| 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(%r, %r)" % (fid, tbid) |
| frame = frametable[fid] |
| if tbid is None: |
| tb = None |
| else: |
| tb = tracebacktable[tbid] |
| 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 set_break(self, filename, lineno): |
| msg = self.idb.set_break(filename, lineno) |
| return msg |
| |
| def clear_break(self, filename, lineno): |
| msg = self.idb.clear_break(filename, lineno) |
| return msg |
| |
| def clear_all_file_breaks(self, filename): |
| msg = self.idb.clear_all_file_breaks(filename) |
| return msg |
| |
| #----------called by a FrameProxy---------- |
| |
| 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 |
| |
| #----------called by a CodeProxy---------- |
| |
| def code_name(self, cid): |
| code = codetable[cid] |
| return code.co_name |
| |
| def code_filename(self, cid): |
| code = codetable[cid] |
| return code.co_filename |
| |
| #----------called by a DictProxy---------- |
| |
| def dict_keys(self, did): |
| dict = dicttable[did] |
| return dict.keys() |
| |
| def dict_item(self, did, key): |
| dict = dicttable[did] |
| value = dict[key] |
| value = repr(value) |
| return value |
| |
| #----------end class IdbAdapter---------- |
| |
| |
| def start_debugger(rpchandler, gui_adap_oid): |
| """Start the debugger and its RPC link in the Python subprocess |
| |
| Start the subprocess side of the split debugger and set up that side of the |
| RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter |
| objects and linking them together. Register the IdbAdapter with the |
| RPCServer to handle RPC requests from the split debugger GUI via the |
| IdbProxy. |
| |
| """ |
| gui_proxy = GUIProxy(rpchandler, gui_adap_oid) |
| idb = Debugger.Idb(gui_proxy) |
| idb_adap = IdbAdapter(idb) |
| rpchandler.register(idb_adap_oid, idb_adap) |
| return idb_adap_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 did in self._dictcache: |
| 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 GUIAdapter: |
| |
| def __init__(self, conn, gui): |
| self.conn = conn |
| self.gui = gui |
| |
| def interaction(self, message, fid, modified_info): |
| ##print "interaction: (%s, %s, %s)" % (message, fid, modified_info) |
| frame = FrameProxy(self.conn, fid) |
| self.gui.interaction(message, frame, modified_info) |
| |
| |
| class IdbProxy: |
| |
| def __init__(self, conn, shell, oid): |
| self.oid = oid |
| self.conn = conn |
| self.shell = shell |
| |
| def call(self, methodname, *args, **kwargs): |
| ##print "**IdbProxy.call %s %s %s" % (methodname, args, kwargs) |
| value = self.conn.remotecall(self.oid, methodname, args, kwargs) |
| ##print "**IdbProxy.call %s returns %r" % (methodname, value) |
| return value |
| |
| def run(self, cmd, locals): |
| # Ignores locals on purpose! |
| seq = self.conn.asyncqueue(self.oid, "run", (cmd,), {}) |
| self.shell.interp.active_seq = seq |
| |
| def get_stack(self, frame, tbid): |
| # passing frame and traceback IDs, not the objects themselves |
| stack, i = self.call("get_stack", frame._fid, tbid) |
| 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 set_break(self, filename, lineno): |
| msg = self.call("set_break", filename, lineno) |
| return msg |
| |
| def clear_break(self, filename, lineno): |
| msg = self.call("clear_break", filename, lineno) |
| return msg |
| |
| def clear_all_file_breaks(self, filename): |
| msg = self.call("clear_all_file_breaks", filename) |
| return msg |
| |
| def start_remote_debugger(rpcclt, pyshell): |
| """Start the subprocess debugger, initialize the debugger GUI and RPC link |
| |
| Request the RPCServer start the Python subprocess debugger and link. Set |
| up the Idle side of the split debugger by instantiating the IdbProxy, |
| debugger GUI, and debugger GUIAdapter objects and linking them together. |
| |
| Register the GUIAdapter with the RPCClient to handle debugger GUI |
| interaction requests coming from the subprocess debugger via the GUIProxy. |
| |
| The IdbAdapter will pass execution and environment requests coming from the |
| Idle debugger GUI to the subprocess debugger via the IdbProxy. |
| |
| """ |
| global idb_adap_oid |
| |
| idb_adap_oid = rpcclt.remotecall("exec", "start_the_debugger",\ |
| (gui_adap_oid,), {}) |
| idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid) |
| gui = Debugger.Debugger(pyshell, idb_proxy) |
| gui_adap = GUIAdapter(rpcclt, gui) |
| rpcclt.register(gui_adap_oid, gui_adap) |
| return gui |
| |
| def close_remote_debugger(rpcclt): |
| """Shut down subprocess debugger and Idle side of debugger RPC link |
| |
| Request that the RPCServer shut down the subprocess debugger and link. |
| Unregister the GUIAdapter, which will cause a GC on the Idle process |
| debugger and RPC link objects. (The second reference to the debugger GUI |
| is deleted in PyShell.close_remote_debugger().) |
| |
| """ |
| close_subprocess_debugger(rpcclt) |
| rpcclt.unregister(gui_adap_oid) |
| |
| def close_subprocess_debugger(rpcclt): |
| rpcclt.remotecall("exec", "stop_the_debugger", (idb_adap_oid,), {}) |
| |
| def restart_subprocess_debugger(rpcclt): |
| idb_adap_oid_ret = rpcclt.remotecall("exec", "start_the_debugger",\ |
| (gui_adap_oid,), {}) |
| assert idb_adap_oid_ret == idb_adap_oid, 'Idb restarted with different oid' |
