Python code coverage for Lib/idlelib/RemoteDebugger.py

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