IDLEfork NEWS
+++++++++++++
+What's New in IDLEfork 0.9 Alpha 3?
+===================================
+
+*Release date: xx-xxx-2003*
+
+- Exit IDLE cleanly even when doing subprocess I/O
+
+- Handle subprocess interrupt in Windows with an RPC message.
+
+- Calling Run will restart the subprocess even if user code is running.
+
+- Restart the subprocess if it terminates itself. (VPython programs do that)
+
+- Support subclassing of exceptions, including in the shell, by moving the
+ exception formatting to the subprocess.
+
+- Known issues:
+
+ + Can't kill/restart a tight loop in the Windows version: add
+ I/O to the loop or use the Task Manager to kill the subprocess.
+ + Typing two Control-C in close succession when the subprocess is busy can
+ cause IDLE to lose communication with the subprocess. Please type one
+ only and wait for the exception to complete.
+ + Printing under some versions of Linux may be problematic.
+
+
What's New in IDLEfork 0.9 Alpha 2?
===================================
- Modified idle, idle.py, idle.pyw to improve exception handling.
-- Known issues:
-
- + Can't kill a tight loop in the Windows version: Insert a
- ``print "*",`` in an outer loop or use the Task Manager to kill.
- + Typing two Control-C in close succession when the subprocess is busy can
- cause IDLE to lose communication with the subprocess. Please type one
- only and wait for the exception to complete.
- + Printing under some versions of Linux may be problematic.
-
What's New in IDLEfork 0.9 Alpha 1?
===================================
import re
import socket
import time
+import threading
import traceback
import types
import exceptions
# close only the subprocess debugger
debug = self.getdebugger()
if debug:
- RemoteDebugger.close_subprocess_debugger(self.rpcclt)
- # kill subprocess, spawn a new one, accept connection
- self.rpcclt.close()
+ try:
+ RemoteDebugger.close_subprocess_debugger(self.rpcclt)
+ except:
+ pass
+ # Kill subprocess, spawn a new one, accept connection.
+ if hasattr(os, 'kill'):
+ # We can interrupt any loop if we can use SIGINT. This doesn't
+ # work in Windows, currently we can only interrupt loops doing I/O.
+ self.__signal_interrupt()
+ # XXX KBK 13Feb03 Don't close the socket until the interrupt thread
+ # finishes.
+ self.tkconsole.executing = False
+ try:
+ self.rpcclt.close()
+ os.wait()
+ except:
+ pass
self.spawn_subprocess()
self.rpcclt.accept()
self.transfer_path()
console.write(halfbar + ' RESTART ' + halfbar)
console.text.mark_set("restart", "end-1c")
console.text.mark_gravity("restart", "left")
- # restart remote debugger
+ # restart subprocess debugger
if debug:
gui = RemoteDebugger.restart_subprocess_debugger(self.rpcclt)
# reload remote debugger breakpoints for all PyShellEditWindows
debug.load_breakpoints()
+ def __signal_interrupt(self):
+ try:
+ from signal import SIGINT
+ except ImportError:
+ SIGINT = 2
+ os.kill(self.rpcpid, SIGINT)
+
+ def __request_interrupt(self):
+ self.rpcclt.asynccall("exec", "interrupt_the_server", (), {})
+
+ def interrupt_subprocess(self):
+ if hasattr(os, "kill"):
+ self.__signal_interrupt()
+ else:
+ # Windows has no os.kill(), use an RPC message.
+ # This is async, must be done in a thread.
+ threading.Thread(target=self.__request_interrupt).start()
+
def transfer_path(self):
self.runcommand("""if 1:
import sys as _sys
clt = self.rpcclt
if clt is None:
return
- response = clt.pollresponse(self.active_seq)
+ try:
+ response = clt.pollresponse(self.active_seq)
+ except (EOFError, IOError):
+ # lost connection: subprocess terminated itself, restart
+ if self.tkconsole.closing:
+ return
+ response = None
+ try:
+ # stake any zombie before restarting
+ os.wait()
+ except (AttributeError, OSError):
+ pass
+ self.restart_subprocess()
+ self.tkconsole.endexecuting()
# Reschedule myself in 50 ms
self.tkconsole.text.after(50, self.poll_subprocess)
if response:
def runcode(self, code):
"Override base class method"
if self.tkconsole.executing:
- self.display_executing_dialog()
- return
+ self.interp.restart_subprocess()
self.checklinecache()
if self.save_warnings_filters is not None:
warnings.filters[:] = self.save_warnings_filters
if use_subprocess:
self.interp.start_subprocess()
- reading = 0
- executing = 0
- canceled = 0
- endoffile = 0
+ reading = False
+ executing = False
+ canceled = False
+ endoffile = False
+ closing = False
def toggle_debugger(self, event=None):
if self.executing:
def close(self):
"Extend EditorWindow.close()"
if self.executing:
- # XXX Need to ask a question here
- if not tkMessageBox.askokcancel(
+ response = tkMessageBox.askokcancel(
"Kill?",
- "The program is still running; do you want to kill it?",
+ "The program is still running!\n Do you want to kill it?",
default="ok",
- master=self.text):
+ master=self.text)
+ if response == False:
return "cancel"
- self.canceled = 1
- if self.reading:
- self.top.quit()
- return "cancel"
+ # interrupt the subprocess
+ self.closing = True
+ self.cancel_callback()
+ self.endexecuting()
return EditorWindow.close(self)
def _close(self):
def isatty(self):
return True
- def cancel_callback(self, event):
+ def cancel_callback(self, event=None):
try:
if self.text.compare("sel.first", "!=", "sel.last"):
return # Active selection -- always use default binding
self.showprompt()
return "break"
self.endoffile = 0
+ self.canceled = 1
if self.reading:
- self.canceled = 1
self.top.quit()
- elif (self.executing and self.interp.rpcclt and
- self.interp.rpcpid and hasattr(os, "kill")):
- try:
- from signal import SIGINT
- except ImportError:
- SIGINT = 2
- os.kill(self.interp.rpcpid, SIGINT)
- else:
- self.canceled = 1
+ elif (self.executing and self.interp.rpcclt):
+ self.interp.interrupt_subprocess()
return "break"
def eof_callback(self, event):
sys.stdout.softspace = 0
def write(self, s, tags=()):
- self.text.mark_gravity("iomark", "right")
- OutputWindow.write(self, s, tags, "iomark")
- self.text.mark_gravity("iomark", "left")
+ try:
+ self.text.mark_gravity("iomark", "right")
+ OutputWindow.write(self, s, tags, "iomark")
+ self.text.mark_gravity("iomark", "left")
+ except:
+ pass
if self.canceled:
self.canceled = 0
- raise KeyboardInterrupt
class PseudoFile:
flist = self.editwin.flist
shell = flist.open_shell()
interp = shell.interp
- if interp.tkconsole.executing:
- interp.display_executing_dialog()
- return
interp.restart_subprocess()
# XXX Too often this discards arguments the user just set...
interp.runcommand("""if 1:
"Override TCPServer method, return already connected socket"
return self.socket, self.server_address
+ def handle_error(self, request, client_address):
+ """Override TCPServer method, no error message if exiting"""
+ try:
+ raise
+ except SystemExit:
+ raise
+ else:
+ TCPServer.handle_error(request, client_address)
+
+
objecttable = {}
class SocketIO:
if objtable is None:
objtable = objecttable
self.objtable = objtable
- self.statelock = threading.Lock()
+ self.cvar = threading.Condition()
self.responses = {}
self.cvars = {}
+ self.interrupted = False
def close(self):
sock = self.sock
if isinstance(ret, RemoteObject):
ret = remoteref(ret)
return ("OK", ret)
+ except SystemExit:
+ raise
except:
self.debug("localcall:EXCEPTION")
+ if self.debugging: traceback.print_exc(file=sys.__stderr__)
efile = sys.stderr
typ, val, tb = info = sys.exc_info()
sys.last_type, sys.last_value, sys.last_traceback = info
tbe = traceback.extract_tb(tb)
- print >>efile, 'Traceback (most recent call last):'
+ print >>efile, '\nTraceback (most recent call last):'
exclude = ("run.py", "rpc.py", "RemoteDebugger.py", "bdb.py")
self.cleanup_traceback(tbe, exclude)
traceback.print_list(tbe, file=efile)
break
del tb[-1]
if len(tb) == 0:
- # error was in RPC internals, don't prune!
+ # exception was in RPC internals, don't prune!
tb[:] = orig_tb[:]
- print>>sys.stderr, "** RPC Internal Error: ", tb
+ print>>sys.stderr, "** IDLE RPC Internal Exception: "
for i in range(len(tb)):
fn, ln, nm, line = tb[i]
if nm == '?':
tb[i] = fn, ln, nm, line
def remotecall(self, oid, methodname, args, kwargs):
- self.debug("calling asynccall via remotecall")
+ self.debug("remotecall:asynccall: ", oid, methodname)
+ # XXX KBK 06Feb03 self.interrupted logic may not be necessary if
+ # subprocess is threaded.
+ if self.interrupted:
+ self.interrupted = False
+ raise KeyboardInterrupt
seq = self.asynccall(oid, methodname, args, kwargs)
return self.asyncreturn(seq)
if how == "OK":
return what
if how == "EXCEPTION":
- raise Exception, "RPC SocketIO.decoderesponse exception"
+ self.debug("decoderesponse: EXCEPTION")
+ return None
if how == "ERROR":
self.debug("decoderesponse: Internal ERROR:", what)
raise RuntimeError, what
return response
else:
# Auxiliary thread: wait for notification from main thread
- cvar = threading.Condition(self.statelock)
- self.statelock.acquire()
- self.cvars[myseq] = cvar
+ self.cvar.acquire()
+ self.cvars[myseq] = self.cvar
while not self.responses.has_key(myseq):
- cvar.wait()
+ self.cvar.wait()
response = self.responses[myseq]
del self.responses[myseq]
del self.cvars[myseq]
- self.statelock.release()
- return response # might be None
+ self.cvar.release()
+ return response
def newseq(self):
self.nextseq = seq = self.nextseq + 2
raise
s = struct.pack("<i", len(s)) + s
while len(s) > 0:
- n = self.sock.send(s)
- s = s[n:]
+ try:
+ n = self.sock.send(s)
+ except AttributeError:
+ # socket was closed
+ raise IOError
+ else:
+ s = s[n:]
def ioready(self, wait=0.0):
r, w, x = select.select([self.sock.fileno()], [], [], wait)
elif seq == myseq:
return resq
else:
- self.statelock.acquire()
- self.responses[seq] = resq
+ self.cvar.acquire()
cv = self.cvars.get(seq)
+ # response involving unknown sequence number is discarded,
+ # probably intended for prior incarnation
if cv is not None:
+ self.responses[seq] = resq
cv.notify()
- self.statelock.release()
+ self.cvar.release()
continue
#----------------- end class SocketIO --------------------
def runcode(self, code):
exec code in self.locals
+ def interrupt_the_server(self):
+ # XXX KBK 05Feb03 Windows requires this be done with messages and
+ # threads....
+ self.rpchandler.interrupted = True
+
def start_the_debugger(self, gui_adap_oid):
return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)
projects / python / commitdiff