home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / RemoteDebugger.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  11.4 KB  |  381 lines
  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'
  381.