import RemoteObjectBrowser
def idle_formatwarning_subproc(message
, category
, filename
, lineno
):
"""Format warnings the IDLE way"""
s
= "\nWarning (from warnings module):\n"
s
+= ' File \"%s\", line %s\n' % (filename
, lineno
)
line
= linecache
.getline(filename
, lineno
).strip()
s
+= "%s: %s\n" % (category
.__name
__, message
)
warnings
.formatwarning
= idle_formatwarning_subproc
# Thread shared globals: Establish a queue between a subthread (which handles
# the socket) and the main thread (which runs user code), plus global
# completion and exit flags:
def main(del_exitfunc
=False):
"""Start the Python execution server in a subprocess
In the Python subprocess, RPCServer is instantiated with handlerclass
MyHandler, which inherits register/unregister methods from RPCHandler via
the mix-in class SocketIO.
When the RPCServer 'server' is instantiated, the TCPServer initialization
creates an instance of run.MyHandler and calls its handle() method.
handle() instantiates a run.Executive object, passing it a reference to the
MyHandler object. That reference is saved as attribute rpchandler of the
Executive instance. The Executive methods have access to the reference and
can pass it on to entities that they command
(e.g. RemoteDebugger.Debugger.start_debugger()). The latter, in turn, can
call MyHandler(SocketIO) register/unregister methods via the reference to
register and unregister themselves.
no_exitfunc
= del_exitfunc
#time.sleep(15) # test subprocess not responding
sockthread
= threading
.Thread(target
=manage_socket
,
args
=((LOCALHOST
, port
),))
sockthread
.setDaemon(True)
except KeyboardInterrupt:
# exiting but got an extra KBI? Try again!
seq
, request
= rpc
.request_queue
.get(0)
method
, args
, kwargs
= request
ret
= method(*args
, **kwargs
)
rpc
.response_queue
.put((seq
, ret
))
except KeyboardInterrupt:
type, value
, tb
= sys
.exc_info()
rpc
.response_queue
.put((seq
, None))
# Link didn't work, print same exception to __stderr__
traceback
.print_exception(type, value
, tb
, file=sys
.__stderr
__)
def manage_socket(address
):
server
= MyRPCServer(address
, MyHandler
)
except socket
.error
, err
:
print>>sys
.__stderr
__,"IDLE Subprocess: socket error: "\
+ err
[1] + ", retrying...."
print>>sys
.__stderr
__, "IDLE Subprocess: Connection to "\
"IDLE GUI failed, exiting."
show_socket_error(err
, address
)
server
.handle_request() # A single request only
def show_socket_error(err
, address
):
if err
[0] == 61: # connection refused
msg
= "IDLE's subprocess can't connect to %s:%d. This may be due "\
"to your personal firewall configuration. It is safe to "\
"allow this internal connection because no data is visible on "\
"external ports." % address
tkMessageBox
.showerror("IDLE Subprocess Error", msg
, parent
=root
)
tkMessageBox
.showerror("IDLE Subprocess Error", "Socket Error: %s" % err
[1])
typ
, val
, tb
= excinfo
= sys
.exc_info()
sys
.last_type
, sys
.last_value
, sys
.last_traceback
= excinfo
tbe
= traceback
.extract_tb(tb
)
print>>efile
, '\nTraceback (most recent call last):'
exclude
= ("run.py", "rpc.py", "threading.py", "Queue.py",
"RemoteDebugger.py", "bdb.py")
cleanup_traceback(tbe
, exclude
)
traceback
.print_list(tbe
, file=efile
)
lines
= traceback
.format_exception_only(typ
, val
)
def cleanup_traceback(tb
, exclude
):
"Remove excluded traces from beginning/end of tb; get cached lines"
if tb
[0][0].count(rpcfile
):
break # found an exclude, break for: and delete tb[0]
break # no excludes, have left RPC code, break while:
if tb
[-1][0].count(rpcfile
):
# exception was in IDLE internals, don't prune!
print>>sys
.stderr
, "** IDLE Internal Exception: "
rpchandler
= rpc
.objecttable
['exec'].rpchandler
if not line
and fn
.startswith("<pyshell#"):
line
= rpchandler
.remotecall('linecache', 'getline',
except (AttributeError, EOFError):
"""Exit subprocess, possibly after first deleting sys.exitfunc
If config-main.cfg/.def 'General' 'delete-exitfunc' is True, then any
sys.exitfunc will be removed before exiting. (VPython support)
class MyRPCServer(rpc
.RPCServer
):
def handle_error(self
, request
, client_address
):
"""Override RPCServer method for IDLE
Interrupt the MainThread and exit server if link is dropped.
print>>erf
, '\n' + '-'*40
print>>erf
, 'Unhandled server exception!'
print>>erf
, 'Thread: %s' % threading
.currentThread().getName()
print>>erf
, 'Client Address: ', client_address
print>>erf
, 'Request: ', repr(request
)
traceback
.print_exc(file=erf
)
print>>erf
, '\n*** Unrecoverable, server exiting!'
class MyHandler(rpc
.RPCHandler
):
"""Override base method"""
executive
= Executive(self
)
self
.register("exec", executive
)
sys
.stdin
= self
.console
= self
.get_remote_proxy("stdin")
sys
.stdout
= self
.get_remote_proxy("stdout")
sys
.stderr
= self
.get_remote_proxy("stderr")
sys
.stdin
.encoding
= sys
.stdout
.encoding
= \
sys
.stderr
.encoding
= IOBinding
.encoding
self
.interp
= self
.get_remote_proxy("interp")
rpc
.RPCHandler
.getresponse(self
, myseq
=None, wait
=0.05)
"override SocketIO method - wait for MainThread to shut us down"
"Override SocketIO method - terminate wait on callback and exit thread"
def decode_interrupthook(self
):
"interrupt awakened thread"
def __init__(self
, rpchandler
):
self
.rpchandler
= rpchandler
self
.locals = __main__
.__dict
__
self
.calltip
= CallTips
.CallTips()
self
.usr_exc_info
= sys
.exc_info()
# even print a user code SystemExit exception, continue
jit
= self
.rpchandler
.console
.getvar("<<toggle-jit-stack-viewer>>")
self
.rpchandler
.interp
.open_remote_stack_viewer()
def interrupt_the_server(self
):
def start_the_debugger(self
, gui_adap_oid
):
return RemoteDebugger
.start_debugger(self
.rpchandler
, gui_adap_oid
)
def stop_the_debugger(self
, idb_adap_oid
):
"Unregister the Idb Adapter. Link objects and Idb then subject to GC"
self
.rpchandler
.unregister(idb_adap_oid
)
def get_the_calltip(self
, name
):
return self
.calltip
.fetch_tip(name
)
def stackviewer(self
, flist_oid
=None):
typ
, val
, tb
= self
.usr_exc_info
if flist_oid
is not None:
flist
= self
.rpchandler
.get_remote_proxy(flist_oid
)
while tb
and tb
.tb_frame
.f_globals
["__name__"] in ["rpc", "run"]:
item
= StackViewer
.StackTreeItem(flist
, tb
)
return RemoteObjectBrowser
.remote_object_tree_item(item
)