Lib/idlelib/RemoteDebugger.py

   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 did in self._dictcache:
 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'