1 """Support for remote Python debugging.

     2 

     3 Some ASCII art to describe the structure:

     4 

     5        IN PYTHON SUBPROCESS          #             IN IDLE PROCESS

     6                                      #

     7                                      #        oid='gui_adapter'

     8                  +----------+        #       +------------+          +-----+

     9                  | GUIProxy |--remote#call-->| GUIAdapter |--calls-->| GUI |

    10 +-----+--calls-->+----------+        #       +------------+          +-----+

    11 | Idb |                               #                             /

    12 +-----+<-calls--+------------+         #      +----------+<--calls-/

    13                 | IdbAdapter |<--remote#call--| IdbProxy |

    14                 +------------+         #      +----------+

    15                 oid='idb_adapter'      #

    16 

    17 The purpose of the Proxy and Adapter classes is to translate certain

    18 arguments and return values that cannot be transported through the RPC

    19 barrier, in particular frame and traceback objects.

    20 

    21 """

    22 

    23 import types

    24 import rpc

    25 import Debugger

    26 

    27 debugging = 0

    28 

    29 idb_adap_oid = "idb_adapter"

    30 gui_adap_oid = "gui_adapter"

    31 

    32 #=======================================

    33 #

    34 # In the PYTHON subprocess:

    35 

    36 frametable = {}

    37 dicttable = {}

    38 codetable = {}

    39 tracebacktable = {}

    40 

    41 def wrap_frame(frame):

    42     fid = id(frame)

    43     frametable[fid] = frame

    44     return fid

    45 

    46 def wrap_info(info):

    47     "replace info[2], a traceback instance, by its ID"

    48     if info is None:

    49         return None

    50     else:

    51         traceback = info[2]

    52         assert isinstance(traceback, types.TracebackType)

    53         traceback_id = id(traceback)

    54         tracebacktable[traceback_id] = traceback

    55         modified_info = (info[0], info[1], traceback_id)

    56         return modified_info

    57 

    58 class GUIProxy:

    59 

    60     def __init__(self, conn, gui_adap_oid):

    61         self.conn = conn

    62         self.oid = gui_adap_oid

    63 

    64     def interaction(self, message, frame, info=None):

    65         # calls rpc.SocketIO.remotecall() via run.MyHandler instance

    66         # pass frame and traceback object IDs instead of the objects themselves

    67         self.conn.remotecall(self.oid, "interaction",

    68                              (message, wrap_frame(frame), wrap_info(info)),

    69                              {})

    70 

    71 class IdbAdapter:

    72 

    73     def __init__(self, idb):

    74         self.idb = idb

    75 

    76     #----------called by an IdbProxy----------

    77 

    78     def set_step(self):

    79         self.idb.set_step()

    80 

    81     def set_quit(self):

    82         self.idb.set_quit()

    83 

    84     def set_continue(self):

    85         self.idb.set_continue()

    86 

    87     def set_next(self, fid):

    88         frame = frametable[fid]

    89         self.idb.set_next(frame)

    90 

    91     def set_return(self, fid):

    92         frame = frametable[fid]

    93         self.idb.set_return(frame)

    94 

    95     def get_stack(self, fid, tbid):

    96         ##print >>sys.__stderr__, "get_stack(%r, %r)" % (fid, tbid)

    97         frame = frametable[fid]

    98         if tbid is None:

    99             tb = None

   100         else:

   101             tb = tracebacktable[tbid]

   102         stack, i = self.idb.get_stack(frame, tb)

   103         ##print >>sys.__stderr__, "get_stack() ->", stack

   104         stack = [(wrap_frame(frame), k) for frame, k in stack]

   105         ##print >>sys.__stderr__, "get_stack() ->", stack

   106         return stack, i

   107 

   108     def run(self, cmd):

   109         import __main__

   110         self.idb.run(cmd, __main__.__dict__)

   111 

   112     def set_break(self, filename, lineno):

   113         msg = self.idb.set_break(filename, lineno)

   114         return msg

   115 

   116     def clear_break(self, filename, lineno):

   117         msg = self.idb.clear_break(filename, lineno)

   118         return msg

   119 

   120     def clear_all_file_breaks(self, filename):

   121         msg = self.idb.clear_all_file_breaks(filename)

   122         return msg

   123 

   124     #----------called by a FrameProxy----------

   125 

   126     def frame_attr(self, fid, name):

   127         frame = frametable[fid]

   128         return getattr(frame, name)

   129 

   130     def frame_globals(self, fid):

   131         frame = frametable[fid]

   132         dict = frame.f_globals

   133         did = id(dict)

   134         dicttable[did] = dict

   135         return did

   136 

   137     def frame_locals(self, fid):

   138         frame = frametable[fid]

   139         dict = frame.f_locals

   140         did = id(dict)

   141         dicttable[did] = dict

   142         return did

   143 

   144     def frame_code(self, fid):

   145         frame = frametable[fid]

   146         code = frame.f_code

   147         cid = id(code)

   148         codetable[cid] = code

   149         return cid

   150 

   151     #----------called by a CodeProxy----------

   152 

   153     def code_name(self, cid):

   154         code = codetable[cid]

   155         return code.co_name

   156 

   157     def code_filename(self, cid):

   158         code = codetable[cid]

   159         return code.co_filename

   160 

   161     #----------called by a DictProxy----------

   162 

   163     def dict_keys(self, did):

   164         dict = dicttable[did]

   165         return dict.keys()

   166 

   167     def dict_item(self, did, key):

   168         dict = dicttable[did]

   169         value = dict[key]

   170         value = repr(value)

   171         return value

   172 

   173 #----------end class IdbAdapter----------

   174 

   175 

   176 def start_debugger(rpchandler, gui_adap_oid):

   177     """Start the debugger and its RPC link in the Python subprocess

   178 

   179     Start the subprocess side of the split debugger and set up that side of the

   180     RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter

   181     objects and linking them together.  Register the IdbAdapter with the

   182     RPCServer to handle RPC requests from the split debugger GUI via the

   183     IdbProxy.

   184 

   185     """

   186     gui_proxy = GUIProxy(rpchandler, gui_adap_oid)

   187     idb = Debugger.Idb(gui_proxy)

   188     idb_adap = IdbAdapter(idb)

   189     rpchandler.register(idb_adap_oid, idb_adap)

   190     return idb_adap_oid

   191 

   192 

   193 #=======================================

   194 #

   195 # In the IDLE process:

   196 

   197 

   198 class FrameProxy:

   199 

   200     def __init__(self, conn, fid):

   201         self._conn = conn

   202         self._fid = fid

   203         self._oid = "idb_adapter"

   204         self._dictcache = {}

   205 

   206     def __getattr__(self, name):

   207         if name[:1] == "_":

   208             raise AttributeError, name

   209         if name == "f_code":

   210             return self._get_f_code()

   211         if name == "f_globals":

   212             return self._get_f_globals()

   213         if name == "f_locals":

   214             return self._get_f_locals()

   215         return self._conn.remotecall(self._oid, "frame_attr",

   216                                      (self._fid, name), {})

   217 

   218     def _get_f_code(self):

   219         cid = self._conn.remotecall(self._oid, "frame_code", (self._fid,), {})

   220         return CodeProxy(self._conn, self._oid, cid)

   221 

   222     def _get_f_globals(self):

   223         did = self._conn.remotecall(self._oid, "frame_globals",

   224                                     (self._fid,), {})

   225         return self._get_dict_proxy(did)

   226 

   227     def _get_f_locals(self):

   228         did = self._conn.remotecall(self._oid, "frame_locals",

   229                                     (self._fid,), {})

   230         return self._get_dict_proxy(did)

   231 

   232     def _get_dict_proxy(self, did):

   233         if self._dictcache.has_key(did):

   234             return self._dictcache[did]

   235         dp = DictProxy(self._conn, self._oid, did)

   236         self._dictcache[did] = dp

   237         return dp

   238 

   239 

   240 class CodeProxy:

   241 

   242     def __init__(self, conn, oid, cid):

   243         self._conn = conn

   244         self._oid = oid

   245         self._cid = cid

   246 

   247     def __getattr__(self, name):

   248         if name == "co_name":

   249             return self._conn.remotecall(self._oid, "code_name",

   250                                          (self._cid,), {})

   251         if name == "co_filename":

   252             return self._conn.remotecall(self._oid, "code_filename",

   253                                          (self._cid,), {})

   254 

   255 

   256 class DictProxy:

   257 

   258     def __init__(self, conn, oid, did):

   259         self._conn = conn

   260         self._oid = oid

   261         self._did = did

   262 

   263     def keys(self):

   264         return self._conn.remotecall(self._oid, "dict_keys", (self._did,), {})

   265 

   266     def __getitem__(self, key):

   267         return self._conn.remotecall(self._oid, "dict_item",

   268                                      (self._did, key), {})

   269 

   270     def __getattr__(self, name):

   271         ##print >>sys.__stderr__, "failed DictProxy.__getattr__:", name

   272         raise AttributeError, name

   273 

   274 

   275 class GUIAdapter:

   276 

   277     def __init__(self, conn, gui):

   278         self.conn = conn

   279         self.gui = gui

   280 

   281     def interaction(self, message, fid, modified_info):

   282         ##print "interaction: (%s, %s, %s)" % (message, fid, modified_info)

   283         frame = FrameProxy(self.conn, fid)

   284         self.gui.interaction(message, frame, modified_info)

   285 

   286 

   287 class IdbProxy:

   288 

   289     def __init__(self, conn, shell, oid):

   290         self.oid = oid

   291         self.conn = conn

   292         self.shell = shell

   293 

   294     def call(self, methodname, *args, **kwargs):

   295         ##print "**IdbProxy.call %s %s %s" % (methodname, args, kwargs)

   296         value = self.conn.remotecall(self.oid, methodname, args, kwargs)

   297         ##print "**IdbProxy.call %s returns %r" % (methodname, value)

   298         return value

   299 

   300     def run(self, cmd, locals):

   301         # Ignores locals on purpose!

   302         seq = self.conn.asyncqueue(self.oid, "run", (cmd,), {})

   303         self.shell.interp.active_seq = seq

   304 

   305     def get_stack(self, frame, tbid):

   306         # passing frame and traceback IDs, not the objects themselves

   307         stack, i = self.call("get_stack", frame._fid, tbid)

   308         stack = [(FrameProxy(self.conn, fid), k) for fid, k in stack]

   309         return stack, i

   310 

   311     def set_continue(self):

   312         self.call("set_continue")

   313 

   314     def set_step(self):

   315         self.call("set_step")

   316 

   317     def set_next(self, frame):

   318         self.call("set_next", frame._fid)

   319 

   320     def set_return(self, frame):

   321         self.call("set_return", frame._fid)

   322 

   323     def set_quit(self):

   324         self.call("set_quit")

   325 

   326     def set_break(self, filename, lineno):

   327         msg = self.call("set_break", filename, lineno)

   328         return msg

   329 

   330     def clear_break(self, filename, lineno):

   331         msg = self.call("clear_break", filename, lineno)

   332         return msg

   333 

   334     def clear_all_file_breaks(self, filename):

   335         msg = self.call("clear_all_file_breaks", filename)

   336         return msg

   337 

   338 def start_remote_debugger(rpcclt, pyshell):

   339     """Start the subprocess debugger, initialize the debugger GUI and RPC link

   340 

   341     Request the RPCServer start the Python subprocess debugger and link.  Set

   342     up the Idle side of the split debugger by instantiating the IdbProxy,

   343     debugger GUI, and debugger GUIAdapter objects and linking them together.

   344 

   345     Register the GUIAdapter with the RPCClient to handle debugger GUI

   346     interaction requests coming from the subprocess debugger via the GUIProxy.

   347 

   348     The IdbAdapter will pass execution and environment requests coming from the

   349     Idle debugger GUI to the subprocess debugger via the IdbProxy.

   350 

   351     """

   352     global idb_adap_oid

   353 

   354     idb_adap_oid = rpcclt.remotecall("exec", "start_the_debugger",\

   355                                    (gui_adap_oid,), {})

   356     idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid)

   357     gui = Debugger.Debugger(pyshell, idb_proxy)

   358     gui_adap = GUIAdapter(rpcclt, gui)

   359     rpcclt.register(gui_adap_oid, gui_adap)

   360     return gui

   361 

   362 def close_remote_debugger(rpcclt):

   363     """Shut down subprocess debugger and Idle side of debugger RPC link

   364 

   365     Request that the RPCServer shut down the subprocess debugger and link.

   366     Unregister the GUIAdapter, which will cause a GC on the Idle process

   367     debugger and RPC link objects.  (The second reference to the debugger GUI

   368     is deleted in PyShell.close_remote_debugger().)

   369 

   370     """

   371     close_subprocess_debugger(rpcclt)

   372     rpcclt.unregister(gui_adap_oid)

   373 

   374 def close_subprocess_debugger(rpcclt):

   375     rpcclt.remotecall("exec", "stop_the_debugger", (idb_adap_oid,), {})

   376 

   377 def restart_subprocess_debugger(rpcclt):

   378     idb_adap_oid_ret = rpcclt.remotecall("exec", "start_the_debugger",\

   379                                          (gui_adap_oid,), {})

   380     assert idb_adap_oid_ret == idb_adap_oid, 'Idb restarted with different oid'