| 1 | import sys
|
|---|
| 2 | import linecache
|
|---|
| 3 | import time
|
|---|
| 4 | import socket
|
|---|
| 5 | import traceback
|
|---|
| 6 | import thread
|
|---|
| 7 | import threading
|
|---|
| 8 | import Queue
|
|---|
| 9 |
|
|---|
| 10 | import CallTips
|
|---|
| 11 | import AutoComplete
|
|---|
| 12 |
|
|---|
| 13 | import RemoteDebugger
|
|---|
| 14 | import RemoteObjectBrowser
|
|---|
| 15 | import StackViewer
|
|---|
| 16 | import rpc
|
|---|
| 17 |
|
|---|
| 18 | import __main__
|
|---|
| 19 |
|
|---|
| 20 | LOCALHOST = '127.0.0.1'
|
|---|
| 21 |
|
|---|
| 22 | try:
|
|---|
| 23 | import warnings
|
|---|
| 24 | except ImportError:
|
|---|
| 25 | pass
|
|---|
| 26 | else:
|
|---|
| 27 | def idle_formatwarning_subproc(message, category, filename, lineno,
|
|---|
| 28 | file=None, line=None):
|
|---|
| 29 | """Format warnings the IDLE way"""
|
|---|
| 30 | s = "\nWarning (from warnings module):\n"
|
|---|
| 31 | s += ' File \"%s\", line %s\n' % (filename, lineno)
|
|---|
| 32 | line = linecache.getline(filename, lineno).strip() \
|
|---|
| 33 | if line is None else line
|
|---|
| 34 | if line:
|
|---|
| 35 | s += " %s\n" % line
|
|---|
| 36 | s += "%s: %s\n" % (category.__name__, message)
|
|---|
| 37 | return s
|
|---|
| 38 | warnings.formatwarning = idle_formatwarning_subproc
|
|---|
| 39 |
|
|---|
| 40 | # Thread shared globals: Establish a queue between a subthread (which handles
|
|---|
| 41 | # the socket) and the main thread (which runs user code), plus global
|
|---|
| 42 | # completion, exit and interruptable (the main thread) flags:
|
|---|
| 43 |
|
|---|
| 44 | exit_now = False
|
|---|
| 45 | quitting = False
|
|---|
| 46 | interruptable = False
|
|---|
| 47 |
|
|---|
| 48 | def main(del_exitfunc=False):
|
|---|
| 49 | """Start the Python execution server in a subprocess
|
|---|
| 50 |
|
|---|
| 51 | In the Python subprocess, RPCServer is instantiated with handlerclass
|
|---|
| 52 | MyHandler, which inherits register/unregister methods from RPCHandler via
|
|---|
| 53 | the mix-in class SocketIO.
|
|---|
| 54 |
|
|---|
| 55 | When the RPCServer 'server' is instantiated, the TCPServer initialization
|
|---|
| 56 | creates an instance of run.MyHandler and calls its handle() method.
|
|---|
| 57 | handle() instantiates a run.Executive object, passing it a reference to the
|
|---|
| 58 | MyHandler object. That reference is saved as attribute rpchandler of the
|
|---|
| 59 | Executive instance. The Executive methods have access to the reference and
|
|---|
| 60 | can pass it on to entities that they command
|
|---|
| 61 | (e.g. RemoteDebugger.Debugger.start_debugger()). The latter, in turn, can
|
|---|
| 62 | call MyHandler(SocketIO) register/unregister methods via the reference to
|
|---|
| 63 | register and unregister themselves.
|
|---|
| 64 |
|
|---|
| 65 | """
|
|---|
| 66 | global exit_now
|
|---|
| 67 | global quitting
|
|---|
| 68 | global no_exitfunc
|
|---|
| 69 | no_exitfunc = del_exitfunc
|
|---|
| 70 | port = 8833
|
|---|
| 71 | #time.sleep(15) # test subprocess not responding
|
|---|
| 72 | if sys.argv[1:]:
|
|---|
| 73 | port = int(sys.argv[1])
|
|---|
| 74 | sys.argv[:] = [""]
|
|---|
| 75 | sockthread = threading.Thread(target=manage_socket,
|
|---|
| 76 | name='SockThread',
|
|---|
| 77 | args=((LOCALHOST, port),))
|
|---|
| 78 | sockthread.setDaemon(True)
|
|---|
| 79 | sockthread.start()
|
|---|
| 80 | while 1:
|
|---|
| 81 | try:
|
|---|
| 82 | if exit_now:
|
|---|
| 83 | try:
|
|---|
| 84 | exit()
|
|---|
| 85 | except KeyboardInterrupt:
|
|---|
| 86 | # exiting but got an extra KBI? Try again!
|
|---|
| 87 | continue
|
|---|
| 88 | try:
|
|---|
| 89 | seq, request = rpc.request_queue.get(block=True, timeout=0.05)
|
|---|
| 90 | except Queue.Empty:
|
|---|
| 91 | continue
|
|---|
| 92 | method, args, kwargs = request
|
|---|
| 93 | ret = method(*args, **kwargs)
|
|---|
| 94 | rpc.response_queue.put((seq, ret))
|
|---|
| 95 | except KeyboardInterrupt:
|
|---|
| 96 | if quitting:
|
|---|
| 97 | exit_now = True
|
|---|
| 98 | continue
|
|---|
| 99 | except SystemExit:
|
|---|
| 100 | raise
|
|---|
| 101 | except:
|
|---|
| 102 | type, value, tb = sys.exc_info()
|
|---|
| 103 | try:
|
|---|
| 104 | print_exception()
|
|---|
| 105 | rpc.response_queue.put((seq, None))
|
|---|
| 106 | except:
|
|---|
| 107 | # Link didn't work, print same exception to __stderr__
|
|---|
| 108 | traceback.print_exception(type, value, tb, file=sys.__stderr__)
|
|---|
| 109 | exit()
|
|---|
| 110 | else:
|
|---|
| 111 | continue
|
|---|
| 112 |
|
|---|
| 113 | def manage_socket(address):
|
|---|
| 114 | for i in range(3):
|
|---|
| 115 | time.sleep(i)
|
|---|
| 116 | try:
|
|---|
| 117 | server = MyRPCServer(address, MyHandler)
|
|---|
| 118 | break
|
|---|
| 119 | except socket.error, err:
|
|---|
| 120 | print>>sys.__stderr__,"IDLE Subprocess: socket error: "\
|
|---|
| 121 | + err[1] + ", retrying...."
|
|---|
| 122 | else:
|
|---|
| 123 | print>>sys.__stderr__, "IDLE Subprocess: Connection to "\
|
|---|
| 124 | "IDLE GUI failed, exiting."
|
|---|
| 125 | show_socket_error(err, address)
|
|---|
| 126 | global exit_now
|
|---|
| 127 | exit_now = True
|
|---|
| 128 | return
|
|---|
| 129 | server.handle_request() # A single request only
|
|---|
| 130 |
|
|---|
| 131 | def show_socket_error(err, address):
|
|---|
| 132 | import Tkinter
|
|---|
| 133 | import tkMessageBox
|
|---|
| 134 | root = Tkinter.Tk()
|
|---|
| 135 | root.withdraw()
|
|---|
| 136 | if err[0] == 61: # connection refused
|
|---|
| 137 | msg = "IDLE's subprocess can't connect to %s:%d. This may be due "\
|
|---|
| 138 | "to your personal firewall configuration. It is safe to "\
|
|---|
| 139 | "allow this internal connection because no data is visible on "\
|
|---|
| 140 | "external ports." % address
|
|---|
| 141 | tkMessageBox.showerror("IDLE Subprocess Error", msg, parent=root)
|
|---|
| 142 | else:
|
|---|
| 143 | tkMessageBox.showerror("IDLE Subprocess Error", "Socket Error: %s" % err[1])
|
|---|
| 144 | root.destroy()
|
|---|
| 145 |
|
|---|
| 146 | def print_exception():
|
|---|
| 147 | import linecache
|
|---|
| 148 | linecache.checkcache()
|
|---|
| 149 | flush_stdout()
|
|---|
| 150 | efile = sys.stderr
|
|---|
| 151 | typ, val, tb = excinfo = sys.exc_info()
|
|---|
| 152 | sys.last_type, sys.last_value, sys.last_traceback = excinfo
|
|---|
| 153 | tbe = traceback.extract_tb(tb)
|
|---|
| 154 | print>>efile, '\nTraceback (most recent call last):'
|
|---|
| 155 | exclude = ("run.py", "rpc.py", "threading.py", "Queue.py",
|
|---|
| 156 | "RemoteDebugger.py", "bdb.py")
|
|---|
| 157 | cleanup_traceback(tbe, exclude)
|
|---|
| 158 | traceback.print_list(tbe, file=efile)
|
|---|
| 159 | lines = traceback.format_exception_only(typ, val)
|
|---|
| 160 | for line in lines:
|
|---|
| 161 | print>>efile, line,
|
|---|
| 162 |
|
|---|
| 163 | def cleanup_traceback(tb, exclude):
|
|---|
| 164 | "Remove excluded traces from beginning/end of tb; get cached lines"
|
|---|
| 165 | orig_tb = tb[:]
|
|---|
| 166 | while tb:
|
|---|
| 167 | for rpcfile in exclude:
|
|---|
| 168 | if tb[0][0].count(rpcfile):
|
|---|
| 169 | break # found an exclude, break for: and delete tb[0]
|
|---|
| 170 | else:
|
|---|
| 171 | break # no excludes, have left RPC code, break while:
|
|---|
| 172 | del tb[0]
|
|---|
| 173 | while tb:
|
|---|
| 174 | for rpcfile in exclude:
|
|---|
| 175 | if tb[-1][0].count(rpcfile):
|
|---|
| 176 | break
|
|---|
| 177 | else:
|
|---|
| 178 | break
|
|---|
| 179 | del tb[-1]
|
|---|
| 180 | if len(tb) == 0:
|
|---|
| 181 | # exception was in IDLE internals, don't prune!
|
|---|
| 182 | tb[:] = orig_tb[:]
|
|---|
| 183 | print>>sys.stderr, "** IDLE Internal Exception: "
|
|---|
| 184 | rpchandler = rpc.objecttable['exec'].rpchandler
|
|---|
| 185 | for i in range(len(tb)):
|
|---|
| 186 | fn, ln, nm, line = tb[i]
|
|---|
| 187 | if nm == '?':
|
|---|
| 188 | nm = "-toplevel-"
|
|---|
| 189 | if not line and fn.startswith("<pyshell#"):
|
|---|
| 190 | line = rpchandler.remotecall('linecache', 'getline',
|
|---|
| 191 | (fn, ln), {})
|
|---|
| 192 | tb[i] = fn, ln, nm, line
|
|---|
| 193 |
|
|---|
| 194 | def flush_stdout():
|
|---|
| 195 | try:
|
|---|
| 196 | if sys.stdout.softspace:
|
|---|
| 197 | sys.stdout.softspace = 0
|
|---|
| 198 | sys.stdout.write("\n")
|
|---|
| 199 | except (AttributeError, EOFError):
|
|---|
| 200 | pass
|
|---|
| 201 |
|
|---|
| 202 | def exit():
|
|---|
| 203 | """Exit subprocess, possibly after first deleting sys.exitfunc
|
|---|
| 204 |
|
|---|
| 205 | If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any
|
|---|
| 206 | sys.exitfunc will be removed before exiting. (VPython support)
|
|---|
| 207 |
|
|---|
| 208 | """
|
|---|
| 209 | if no_exitfunc:
|
|---|
| 210 | try:
|
|---|
| 211 | del sys.exitfunc
|
|---|
| 212 | except AttributeError:
|
|---|
| 213 | pass
|
|---|
| 214 | sys.exit(0)
|
|---|
| 215 |
|
|---|
| 216 | class MyRPCServer(rpc.RPCServer):
|
|---|
| 217 |
|
|---|
| 218 | def handle_error(self, request, client_address):
|
|---|
| 219 | """Override RPCServer method for IDLE
|
|---|
| 220 |
|
|---|
| 221 | Interrupt the MainThread and exit server if link is dropped.
|
|---|
| 222 |
|
|---|
| 223 | """
|
|---|
| 224 | global quitting
|
|---|
| 225 | try:
|
|---|
| 226 | raise
|
|---|
| 227 | except SystemExit:
|
|---|
| 228 | raise
|
|---|
| 229 | except EOFError:
|
|---|
| 230 | global exit_now
|
|---|
| 231 | exit_now = True
|
|---|
| 232 | thread.interrupt_main()
|
|---|
| 233 | except:
|
|---|
| 234 | erf = sys.__stderr__
|
|---|
| 235 | print>>erf, '\n' + '-'*40
|
|---|
| 236 | print>>erf, 'Unhandled server exception!'
|
|---|
| 237 | print>>erf, 'Thread: %s' % threading.currentThread().getName()
|
|---|
| 238 | print>>erf, 'Client Address: ', client_address
|
|---|
| 239 | print>>erf, 'Request: ', repr(request)
|
|---|
| 240 | traceback.print_exc(file=erf)
|
|---|
| 241 | print>>erf, '\n*** Unrecoverable, server exiting!'
|
|---|
| 242 | print>>erf, '-'*40
|
|---|
| 243 | quitting = True
|
|---|
| 244 | thread.interrupt_main()
|
|---|
| 245 |
|
|---|
| 246 |
|
|---|
| 247 | class MyHandler(rpc.RPCHandler):
|
|---|
| 248 |
|
|---|
| 249 | def handle(self):
|
|---|
| 250 | """Override base method"""
|
|---|
| 251 | executive = Executive(self)
|
|---|
| 252 | self.register("exec", executive)
|
|---|
| 253 | sys.stdin = self.console = self.get_remote_proxy("stdin")
|
|---|
| 254 | sys.stdout = self.get_remote_proxy("stdout")
|
|---|
| 255 | sys.stderr = self.get_remote_proxy("stderr")
|
|---|
| 256 | import IOBinding
|
|---|
| 257 | sys.stdin.encoding = sys.stdout.encoding = \
|
|---|
| 258 | sys.stderr.encoding = IOBinding.encoding
|
|---|
| 259 | self.interp = self.get_remote_proxy("interp")
|
|---|
| 260 | rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05)
|
|---|
| 261 |
|
|---|
| 262 | def exithook(self):
|
|---|
| 263 | "override SocketIO method - wait for MainThread to shut us down"
|
|---|
| 264 | time.sleep(10)
|
|---|
| 265 |
|
|---|
| 266 | def EOFhook(self):
|
|---|
| 267 | "Override SocketIO method - terminate wait on callback and exit thread"
|
|---|
| 268 | global quitting
|
|---|
| 269 | quitting = True
|
|---|
| 270 | thread.interrupt_main()
|
|---|
| 271 |
|
|---|
| 272 | def decode_interrupthook(self):
|
|---|
| 273 | "interrupt awakened thread"
|
|---|
| 274 | global quitting
|
|---|
| 275 | quitting = True
|
|---|
| 276 | thread.interrupt_main()
|
|---|
| 277 |
|
|---|
| 278 |
|
|---|
| 279 | class Executive(object):
|
|---|
| 280 |
|
|---|
| 281 | def __init__(self, rpchandler):
|
|---|
| 282 | self.rpchandler = rpchandler
|
|---|
| 283 | self.locals = __main__.__dict__
|
|---|
| 284 | self.calltip = CallTips.CallTips()
|
|---|
| 285 | self.autocomplete = AutoComplete.AutoComplete()
|
|---|
| 286 |
|
|---|
| 287 | def runcode(self, code):
|
|---|
| 288 | global interruptable
|
|---|
| 289 | try:
|
|---|
| 290 | self.usr_exc_info = None
|
|---|
| 291 | interruptable = True
|
|---|
| 292 | try:
|
|---|
| 293 | exec code in self.locals
|
|---|
| 294 | finally:
|
|---|
| 295 | interruptable = False
|
|---|
| 296 | except:
|
|---|
| 297 | self.usr_exc_info = sys.exc_info()
|
|---|
| 298 | if quitting:
|
|---|
| 299 | exit()
|
|---|
| 300 | # even print a user code SystemExit exception, continue
|
|---|
| 301 | print_exception()
|
|---|
| 302 | jit = self.rpchandler.console.getvar("<<toggle-jit-stack-viewer>>")
|
|---|
| 303 | if jit:
|
|---|
| 304 | self.rpchandler.interp.open_remote_stack_viewer()
|
|---|
| 305 | else:
|
|---|
| 306 | flush_stdout()
|
|---|
| 307 |
|
|---|
| 308 | def interrupt_the_server(self):
|
|---|
| 309 | if interruptable:
|
|---|
| 310 | thread.interrupt_main()
|
|---|
| 311 |
|
|---|
| 312 | def start_the_debugger(self, gui_adap_oid):
|
|---|
| 313 | return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)
|
|---|
| 314 |
|
|---|
| 315 | def stop_the_debugger(self, idb_adap_oid):
|
|---|
| 316 | "Unregister the Idb Adapter. Link objects and Idb then subject to GC"
|
|---|
| 317 | self.rpchandler.unregister(idb_adap_oid)
|
|---|
| 318 |
|
|---|
| 319 | def get_the_calltip(self, name):
|
|---|
| 320 | return self.calltip.fetch_tip(name)
|
|---|
| 321 |
|
|---|
| 322 | def get_the_completion_list(self, what, mode):
|
|---|
| 323 | return self.autocomplete.fetch_completions(what, mode)
|
|---|
| 324 |
|
|---|
| 325 | def stackviewer(self, flist_oid=None):
|
|---|
| 326 | if self.usr_exc_info:
|
|---|
| 327 | typ, val, tb = self.usr_exc_info
|
|---|
| 328 | else:
|
|---|
| 329 | return None
|
|---|
| 330 | flist = None
|
|---|
| 331 | if flist_oid is not None:
|
|---|
| 332 | flist = self.rpchandler.get_remote_proxy(flist_oid)
|
|---|
| 333 | while tb and tb.tb_frame.f_globals["__name__"] in ["rpc", "run"]:
|
|---|
| 334 | tb = tb.tb_next
|
|---|
| 335 | sys.last_type = typ
|
|---|
| 336 | sys.last_value = val
|
|---|
| 337 | item = StackViewer.StackTreeItem(flist, tb)
|
|---|
| 338 | return RemoteObjectBrowser.remote_object_tree_item(item)
|
|---|
