[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / lib / python2.4 / idlelib / RemoteDebugger.py

"""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 types
import rpc
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 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 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'
Commit	Line	Data
920dae64 AT	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 sys
	24	import types
	25	import rpc
	26	import Debugger
	27
	28	debugging = 0
	29
	30	idb_adap_oid = "idb_adapter"
	31	gui_adap_oid = "gui_adapter"
	32
	33	#=======================================
	34	#
	35	# In the PYTHON subprocess:
	36
	37	frametable = {}
	38	dicttable = {}
	39	codetable = {}
	40	tracebacktable = {}
	41
	42	def wrap_frame(frame):
	43	fid = id(frame)
	44	frametable[fid] = frame
	45	return fid
	46
	47	def wrap_info(info):
	48	"replace info[2], a traceback instance, by its ID"
	49	if info is None:
	50	return None
	51	else:
	52	traceback = info[2]
	53	assert isinstance(traceback, types.TracebackType)
	54	traceback_id = id(traceback)
	55	tracebacktable[traceback_id] = traceback
	56	modified_info = (info[0], info[1], traceback_id)
	57	return modified_info
	58
	59	class GUIProxy:
	60
	61	def __init__(self, conn, gui_adap_oid):
	62	self.conn = conn
	63	self.oid = gui_adap_oid
	64
65	def interaction(self, message, frame, info=None):
66	# calls rpc.SocketIO.remotecall() via run.MyHandler instance
67	# pass frame and traceback object IDs instead of the objects themselves
68	self.conn.remotecall(self.oid, "interaction",
69	(message, wrap_frame(frame), wrap_info(info)),
70	{})
71
72	class IdbAdapter:
73
74	def __init__(self, idb):
75	self.idb = idb
76
77	#----------called by an IdbProxy----------
78
79	def set_step(self):
80	self.idb.set_step()
81
82	def set_quit(self):
83	self.idb.set_quit()
84
85	def set_continue(self):
86	self.idb.set_continue()
87
88	def set_next(self, fid):
89	frame = frametable[fid]
90	self.idb.set_next(frame)
91
92	def set_return(self, fid):
93	frame = frametable[fid]
94	self.idb.set_return(frame)
95
96	def get_stack(self, fid, tbid):
97	##print >>sys.__stderr__, "get_stack(%r, %r)" % (fid, tbid)
98	frame = frametable[fid]
99	if tbid is None:
100	tb = None
101	else:
102	tb = tracebacktable[tbid]
103	stack, i = self.idb.get_stack(frame, tb)
104	##print >>sys.__stderr__, "get_stack() ->", stack
105	stack = [(wrap_frame(frame), k) for frame, k in stack]
106	##print >>sys.__stderr__, "get_stack() ->", stack
107	return stack, i
108
109	def run(self, cmd):
110	import __main__
111	self.idb.run(cmd, __main__.__dict__)
112
113	def set_break(self, filename, lineno):
114	msg = self.idb.set_break(filename, lineno)
115	return msg
116
117	def clear_break(self, filename, lineno):
118	msg = self.idb.clear_break(filename, lineno)
119	return msg
120
121	def clear_all_file_breaks(self, filename):
122	msg = self.idb.clear_all_file_breaks(filename)
123	return msg
124
125	#----------called by a FrameProxy----------
126
127	def frame_attr(self, fid, name):
128	frame = frametable[fid]
129	return getattr(frame, name)
130
131	def frame_globals(self, fid):
132	frame = frametable[fid]
133	dict = frame.f_globals
134	did = id(dict)
135	dicttable[did] = dict
136	return did
137
138	def frame_locals(self, fid):
139	frame = frametable[fid]
140	dict = frame.f_locals
141	did = id(dict)
142	dicttable[did] = dict
143	return did
144
145	def frame_code(self, fid):
146	frame = frametable[fid]
147	code = frame.f_code
148	cid = id(code)
149	codetable[cid] = code
150	return cid
151
152	#----------called by a CodeProxy----------
153
154	def code_name(self, cid):
155	code = codetable[cid]
156	return code.co_name
157
158	def code_filename(self, cid):
159	code = codetable[cid]
160	return code.co_filename
161
162	#----------called by a DictProxy----------
163
164	def dict_keys(self, did):
165	dict = dicttable[did]
166	return dict.keys()
167
168	def dict_item(self, did, key):
169	dict = dicttable[did]
170	value = dict[key]
171	value = repr(value)
172	return value
173
174	#----------end class IdbAdapter----------
175
176
177	def start_debugger(rpchandler, gui_adap_oid):
178	"""Start the debugger and its RPC link in the Python subprocess
179
180	Start the subprocess side of the split debugger and set up that side of the
181	RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter
182	objects and linking them together. Register the IdbAdapter with the
183	RPCServer to handle RPC requests from the split debugger GUI via the
184	IdbProxy.
185
186	"""
187	gui_proxy = GUIProxy(rpchandler, gui_adap_oid)
188	idb = Debugger.Idb(gui_proxy)
189	idb_adap = IdbAdapter(idb)
190	rpchandler.register(idb_adap_oid, idb_adap)
191	return idb_adap_oid
192
193
194	#=======================================
195	#
196	# In the IDLE process:
197
198
199	class FrameProxy:
200
201	def __init__(self, conn, fid):
202	self._conn = conn
203	self._fid = fid
204	self._oid = "idb_adapter"
205	self._dictcache = {}
206
207	def __getattr__(self, name):
208	if name[:1] == "_":
209	raise AttributeError, name
210	if name == "f_code":
211	return self._get_f_code()
212	if name == "f_globals":
213	return self._get_f_globals()
214	if name == "f_locals":
215	return self._get_f_locals()
216	return self._conn.remotecall(self._oid, "frame_attr",
217	(self._fid, name), {})
218
219	def _get_f_code(self):
220	cid = self._conn.remotecall(self._oid, "frame_code", (self._fid,), {})
221	return CodeProxy(self._conn, self._oid, cid)
222
223	def _get_f_globals(self):
224	did = self._conn.remotecall(self._oid, "frame_globals",
225	(self._fid,), {})
226	return self._get_dict_proxy(did)
227
228	def _get_f_locals(self):
229	did = self._conn.remotecall(self._oid, "frame_locals",
230	(self._fid,), {})
231	return self._get_dict_proxy(did)
232
233	def _get_dict_proxy(self, did):
234	if self._dictcache.has_key(did):
235	return self._dictcache[did]
236	dp = DictProxy(self._conn, self._oid, did)
237	self._dictcache[did] = dp
238	return dp
239
240
241	class CodeProxy:
242
243	def __init__(self, conn, oid, cid):
244	self._conn = conn
245	self._oid = oid
246	self._cid = cid
247
248	def __getattr__(self, name):
249	if name == "co_name":
250	return self._conn.remotecall(self._oid, "code_name",
251	(self._cid,), {})
252	if name == "co_filename":
253	return self._conn.remotecall(self._oid, "code_filename",
254	(self._cid,), {})
255
256
257	class DictProxy:
258
259	def __init__(self, conn, oid, did):
260	self._conn = conn
261	self._oid = oid
262	self._did = did
263
264	def keys(self):
265	return self._conn.remotecall(self._oid, "dict_keys", (self._did,), {})
266
267	def __getitem__(self, key):
268	return self._conn.remotecall(self._oid, "dict_item",
269	(self._did, key), {})
270
271	def __getattr__(self, name):
272	##print >>sys.__stderr__, "failed DictProxy.__getattr__:", name
273	raise AttributeError, name
274
275
276	class GUIAdapter:
277
278	def __init__(self, conn, gui):
279	self.conn = conn
280	self.gui = gui
281
282	def interaction(self, message, fid, modified_info):
283	##print "interaction: (%s, %s, %s)" % (message, fid, modified_info)
284	frame = FrameProxy(self.conn, fid)
285	self.gui.interaction(message, frame, modified_info)
286
287
288	class IdbProxy:
289
290	def __init__(self, conn, shell, oid):
291	self.oid = oid
292	self.conn = conn
293	self.shell = shell
294
295	def call(self, methodname, args, *kwargs):
296	##print "**IdbProxy.call %s %s %s" % (methodname, args, kwargs)
297	value = self.conn.remotecall(self.oid, methodname, args, kwargs)
298	##print "**IdbProxy.call %s returns %r" % (methodname, value)
299	return value
300
301	def run(self, cmd, locals):
302	# Ignores locals on purpose!
303	seq = self.conn.asyncqueue(self.oid, "run", (cmd,), {})
304	self.shell.interp.active_seq = seq
305
306	def get_stack(self, frame, tbid):
307	# passing frame and traceback IDs, not the objects themselves
308	stack, i = self.call("get_stack", frame._fid, tbid)
309	stack = [(FrameProxy(self.conn, fid), k) for fid, k in stack]
310	return stack, i
311
312	def set_continue(self):
313	self.call("set_continue")
314
315	def set_step(self):
316	self.call("set_step")
317
318	def set_next(self, frame):
319	self.call("set_next", frame._fid)
320
321	def set_return(self, frame):
322	self.call("set_return", frame._fid)
323
324	def set_quit(self):
325	self.call("set_quit")
326
327	def set_break(self, filename, lineno):
328	msg = self.call("set_break", filename, lineno)
329	return msg
330
331	def clear_break(self, filename, lineno):
332	msg = self.call("clear_break", filename, lineno)
333	return msg
334
335	def clear_all_file_breaks(self, filename):
336	msg = self.call("clear_all_file_breaks", filename)
337	return msg
338
339	def start_remote_debugger(rpcclt, pyshell):
340	"""Start the subprocess debugger, initialize the debugger GUI and RPC link
341
342	Request the RPCServer start the Python subprocess debugger and link. Set
343	up the Idle side of the split debugger by instantiating the IdbProxy,
344	debugger GUI, and debugger GUIAdapter objects and linking them together.
345
346	Register the GUIAdapter with the RPCClient to handle debugger GUI
347	interaction requests coming from the subprocess debugger via the GUIProxy.
348
349	The IdbAdapter will pass execution and environment requests coming from the
350	Idle debugger GUI to the subprocess debugger via the IdbProxy.
351
352	"""
353	global idb_adap_oid
354
355	idb_adap_oid = rpcclt.remotecall("exec", "start_the_debugger",\
356	(gui_adap_oid,), {})
357	idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid)
358	gui = Debugger.Debugger(pyshell, idb_proxy)
359	gui_adap = GUIAdapter(rpcclt, gui)
360	rpcclt.register(gui_adap_oid, gui_adap)
361	return gui
362
363	def close_remote_debugger(rpcclt):
364	"""Shut down subprocess debugger and Idle side of debugger RPC link
365
366	Request that the RPCServer shut down the subprocess debugger and link.
367	Unregister the GUIAdapter, which will cause a GC on the Idle process
368	debugger and RPC link objects. (The second reference to the debugger GUI
369	is deleted in PyShell.close_remote_debugger().)
370
371	"""
372	close_subprocess_debugger(rpcclt)
373	rpcclt.unregister(gui_adap_oid)
374
375	def close_subprocess_debugger(rpcclt):
376	rpcclt.remotecall("exec", "stop_the_debugger", (idb_adap_oid,), {})
377
378	def restart_subprocess_debugger(rpcclt):
379	idb_adap_oid_ret = rpcclt.remotecall("exec", "start_the_debugger",\
380	(gui_adap_oid,), {})
381	assert idb_adap_oid_ret == idb_adap_oid, 'Idb restarted with different oid'