RemoteDebugger.py 10.9 KB
Newer Older
Chui Tey's avatar
Chui Tey committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
"""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
24
import types
Chui Tey's avatar
Chui Tey committed
25 26 27
import rpc
import Debugger

28 29
debugging = 0

30 31 32
#=======================================
#
# In the PYTHON subprocess:
Chui Tey's avatar
Chui Tey committed
33 34 35 36

frametable = {}
dicttable = {}
codetable = {}
37
tracebacktable = {}
Chui Tey's avatar
Chui Tey committed
38 39 40 41 42 43 44

def wrap_frame(frame):
    fid = id(frame)
    frametable[fid] = frame
    return fid

def wrap_info(info):
45
    "replace info[2], a traceback instance, by its ID"
Chui Tey's avatar
Chui Tey committed
46 47 48
    if info is None:
        return None
    else:
49 50 51 52 53 54
        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
Chui Tey's avatar
Chui Tey committed
55 56 57

class GUIProxy:

58
    def __init__(self, conn, gui_adap_oid):
Chui Tey's avatar
Chui Tey committed
59
        self.conn = conn
60
        self.oid = gui_adap_oid
Chui Tey's avatar
Chui Tey committed
61 62

    def interaction(self, message, frame, info=None):
63
        # calls rpc.SocketIO.remotecall() via run.MyHandler instance
64
        # pass frame and traceback object IDs instead of the objects themselves
Chui Tey's avatar
Chui Tey committed
65 66 67 68 69 70 71 72 73
        self.conn.remotecall(self.oid, "interaction",
                             (message, wrap_frame(frame), wrap_info(info)),
                             {})

class IdbAdapter:

    def __init__(self, idb):
        self.idb = idb

74 75
    #----------called by an IdbProxy----------

Chui Tey's avatar
Chui Tey committed
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
    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]
96 97 98 99
        if tbid is None:
            tb = None
        else:
            tb = tracebacktable[tbid]
Chui Tey's avatar
Chui Tey committed
100 101 102 103 104 105 106 107 108 109
        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__)

110 111 112 113 114 115 116
    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)

117 118
    def clear_all_file_breaks(self, filename):
        msg = self.idb.clear_all_file_breaks(filename)
119 120
        return msg
    
121 122
    #----------called by a FrameProxy----------

Chui Tey's avatar
Chui Tey committed
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
    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

148 149
    #----------called by a CodeProxy----------

Chui Tey's avatar
Chui Tey committed
150 151 152 153 154 155 156 157
    def code_name(self, cid):
        code = codetable[cid]
        return code.co_name

    def code_filename(self, cid):
        code = codetable[cid]
        return code.co_filename

158 159
    #----------called by a DictProxy----------

Chui Tey's avatar
Chui Tey committed
160 161 162 163 164 165 166
    def dict_keys(self, did):
        dict = dicttable[did]
        return dict.keys()

    def dict_item(self, did, key):
        dict = dicttable[did]
        value = dict[key]
167
        value = repr(value)
Chui Tey's avatar
Chui Tey committed
168 169
        return value

170 171 172
#----------end class IdbAdapter----------


173
def start_debugger(rpchandler, gui_adap_oid):
174 175 176
    """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
177
    RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter
178 179 180
    objects and linking them together.  Register the IdbAdapter with the
    RPCServer to handle RPC requests from the split debugger GUI via the
    IdbProxy.
181 182

    """
183
    gui_proxy = GUIProxy(rpchandler, gui_adap_oid)
184 185 186
    idb = Debugger.Idb(gui_proxy)
    idb_adap = IdbAdapter(idb)
    idb_adap_oid = "idb_adapter"
187
    rpchandler.register(idb_adap_oid, idb_adap)
188
    return idb_adap_oid
Chui Tey's avatar
Chui Tey committed
189

190 191 192 193 194

#=======================================
#
# In the IDLE process:

Chui Tey's avatar
Chui Tey committed
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236

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

237

Chui Tey's avatar
Chui Tey committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
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,), {})

253

Chui Tey's avatar
Chui Tey committed
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
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

272

273
class GUIAdapter:
Chui Tey's avatar
Chui Tey committed
274 275 276 277 278

    def __init__(self, conn, gui):
        self.conn = conn
        self.gui = gui

279 280
    def interaction(self, message, fid, modified_info):
        ##print "interaction: (%s, %s, %s)" % (message, fid, modified_info)
Chui Tey's avatar
Chui Tey committed
281
        frame = FrameProxy(self.conn, fid)
282
        self.gui.interaction(message, frame, modified_info)
Chui Tey's avatar
Chui Tey committed
283

284

Chui Tey's avatar
Chui Tey committed
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
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)

301 302 303
    def get_stack(self, frame, tbid):
        # passing frame and traceback IDs, not the objects themselves
        stack, i = self.call("get_stack", frame._fid, tbid)
Chui Tey's avatar
Chui Tey committed
304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
        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")

322 323 324 325 326 327 328
    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)

329 330
    def clear_all_file_breaks(self, filename):
        msg = self.call("clear_all_file_breaks", filename)
331
        return msg
332

333
def start_remote_debugger(rpcclt, pyshell):
334 335
    """Start the subprocess debugger, initialize the debugger GUI and RPC link

336 337
    Request the RPCServer start the Python subprocess debugger and link.  Set
    up the Idle side of the split debugger by instantiating the IdbProxy,
338
    debugger GUI, and debugger GUIAdapter objects and linking them together.
339

340 341
    Register the GUIAdapter with the RPCClient to handle debugger GUI
    interaction requests coming from the subprocess debugger via the GUIProxy.
342 343 344 345 346 347

    The IdbAdapter will pass execution and environment requests coming from the
    Idle debugger GUI to the subprocess debugger via the IdbProxy.

    """
    gui_adap_oid = "gui_adapter"
348
    idb_adap_oid = rpcclt.remotecall("exec", "start_the_debugger",\
349
                                   (gui_adap_oid,), {})
350
    idb_proxy = IdbProxy(rpcclt, idb_adap_oid)
351
    gui = Debugger.Debugger(pyshell, idb_proxy)
352 353
    gui_adap = GUIAdapter(rpcclt, gui)
    rpcclt.register(gui_adap_oid, gui_adap)
Chui Tey's avatar
Chui Tey committed
354
    return gui
355 356 357 358 359 360 361 362 363 364 365 366 367 368

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().)

    """    
    idb_adap_oid = "idb_adapter"
    rpcclt.remotecall("exec", "stop_the_debugger", (idb_adap_oid,), {})
    gui_adap_oid = "gui_adapter"
    rpcclt.unregister(gui_adap_oid)