mirror of
https://github.com/microsoft/debugpy.git
synced 2025-12-23 08:48:12 +00:00
Wait-on-exit before sending "disconnect" response. (#475)
(fixes gh-459) We must wait-for-user before the "disconnect" response is sent. This PR fixes that.
This commit is contained in:
Eric Snow
GitHub
parent
bbeebea696
commit
0d7e0d2656
16 changed files with 379 additions and 167 deletions
|
|
@ -3,6 +3,7 @@ from __future__ import print_function
|
|||
import contextlib
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
import sys
|
||||
|
||||
|
||||
|
|
@ -46,6 +47,62 @@ def call_all(callables, *args, **kwargs):
|
|||
return results
|
||||
|
||||
|
||||
########################
|
||||
# threading stuff
|
||||
|
||||
try:
|
||||
TimeoutError = __builtins__.TimeoutError
|
||||
except AttributeError:
|
||||
class TimeoutError(OSError):
|
||||
"""Timeout expired."""
|
||||
|
||||
|
||||
def is_locked(lock):
|
||||
"""Return True if the lock is locked."""
|
||||
if lock is None:
|
||||
return False
|
||||
if not lock.acquire(False):
|
||||
return True
|
||||
lock_release(lock)
|
||||
return False
|
||||
|
||||
|
||||
def lock_release(lock):
|
||||
"""Ensure that the lock is released."""
|
||||
if lock is None:
|
||||
return
|
||||
try:
|
||||
lock.release()
|
||||
except RuntimeError: # already unlocked
|
||||
pass
|
||||
|
||||
|
||||
def lock_wait(lock, timeout=None):
|
||||
"""Wait until the lock is not locked."""
|
||||
if not _lock_acquire(lock, timeout):
|
||||
raise TimeoutError
|
||||
lock_release(lock)
|
||||
|
||||
|
||||
if sys.version_info > (2,):
|
||||
def _lock_acquire(lock, timeout):
|
||||
if timeout is None:
|
||||
timeout = -1
|
||||
return lock.acquire(timeout=timeout)
|
||||
else:
|
||||
def _lock_acquire(lock, timeout):
|
||||
if timeout is None or timeout <= 0:
|
||||
return lock.acquire()
|
||||
if lock.acquire(False):
|
||||
return True
|
||||
for _ in range(int(timeout * 100)):
|
||||
time.sleep(0.01)
|
||||
if lock.acquire(False):
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
########################
|
||||
# closing stuff
|
||||
|
||||
|
|
|
|||
185
ptvsd/daemon.py
185
ptvsd/daemon.py
|
|
@ -9,7 +9,7 @@ from .exit_handlers import (
|
|||
ExitHandlers, UnsupportedSignalError,
|
||||
kill_current_proc)
|
||||
from .session import PyDevdDebugSession
|
||||
from ._util import ignore_errors, debug
|
||||
from ._util import ClosedError, NotRunningError, ignore_errors, debug
|
||||
|
||||
|
||||
def _wait_for_user():
|
||||
|
|
@ -54,13 +54,15 @@ class DaemonBase(object):
|
|||
|
||||
SESSION = None
|
||||
|
||||
exitcode = 0
|
||||
exitcode = None
|
||||
|
||||
def __init__(self, wait_for_user=_wait_for_user,
|
||||
addhandlers=True, killonclose=True,
|
||||
singlesession=False):
|
||||
|
||||
self._lock = threading.Lock()
|
||||
self._started = False
|
||||
self._stopped = False
|
||||
self._closed = False
|
||||
|
||||
# socket-related
|
||||
|
|
@ -82,7 +84,6 @@ class DaemonBase(object):
|
|||
self._killonclose = killonclose
|
||||
|
||||
self._exiting_via_atexit_handler = False
|
||||
self._wait_on_exit = (lambda ec: False)
|
||||
|
||||
self._exithandlers = ExitHandlers()
|
||||
if addhandlers:
|
||||
|
|
@ -118,19 +119,21 @@ class DaemonBase(object):
|
|||
|
||||
def is_running(self):
|
||||
"""Return True if the daemon is running."""
|
||||
if self._closed:
|
||||
return False
|
||||
if self._sock is None:
|
||||
return False
|
||||
return True
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
return False
|
||||
if self._sock is None:
|
||||
return False
|
||||
return self._started and not self._stopped
|
||||
|
||||
def start(self):
|
||||
"""Return the "socket" to use for pydevd after setting it up."""
|
||||
if self._closed:
|
||||
raise DaemonClosedError()
|
||||
if self._started:
|
||||
raise RuntimeError('already started')
|
||||
self._started = True
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
raise DaemonClosedError()
|
||||
if self._started:
|
||||
raise RuntimeError('already started')
|
||||
self._started = True
|
||||
|
||||
sock = self._start()
|
||||
self._sock = sock
|
||||
|
|
@ -187,6 +190,7 @@ class DaemonBase(object):
|
|||
def start_client(self, addr):
|
||||
"""Return ("socket", start_session) with a new client socket."""
|
||||
addr = Address.from_raw(addr)
|
||||
self._singlesession = True
|
||||
with self.started():
|
||||
assert self.session is None
|
||||
client = create_client()
|
||||
|
|
@ -226,72 +230,101 @@ class DaemonBase(object):
|
|||
|
||||
def close(self):
|
||||
"""Stop all loops and release all resources."""
|
||||
if self._closed:
|
||||
raise DaemonClosedError('already closed')
|
||||
self._closed = True
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
raise DaemonClosedError('already closed')
|
||||
self._closed = True
|
||||
|
||||
self._close()
|
||||
|
||||
# internal methods
|
||||
|
||||
def _check_ready_for_session(self, checksession=True):
|
||||
if self._closed:
|
||||
raise DaemonClosedError()
|
||||
if not self._started:
|
||||
raise DaemonStoppedError('never started')
|
||||
if self._sock is None:
|
||||
raise DaemonStoppedError()
|
||||
if checksession and self.session is not None:
|
||||
raise RuntimeError('session already started')
|
||||
with self._lock:
|
||||
if self._closed:
|
||||
raise DaemonClosedError()
|
||||
if not self._started:
|
||||
raise DaemonStoppedError('never started')
|
||||
if self._stopped or self._sock is None:
|
||||
raise DaemonStoppedError()
|
||||
if checksession and self.session is not None:
|
||||
raise RuntimeError('session already started')
|
||||
|
||||
def _close(self):
|
||||
self._stop()
|
||||
|
||||
self._sock = None
|
||||
|
||||
if self._wait_on_exit(self.exitcode):
|
||||
self._wait_for_user()
|
||||
|
||||
def _stop(self):
|
||||
sessionlock = self._sessionlock
|
||||
self._sessionlock = None
|
||||
with self._lock:
|
||||
if self._stopped:
|
||||
return
|
||||
self._stopped = True
|
||||
|
||||
server = self._server
|
||||
self._server = None
|
||||
|
||||
with ignore_errors():
|
||||
self._finish_session()
|
||||
|
||||
if sessionlock is not None:
|
||||
try:
|
||||
sessionlock.release()
|
||||
except Exception:
|
||||
pass
|
||||
self._sessionlock = None # TODO: Call self._clear_sessionlock?
|
||||
|
||||
# TODO: Close the server socket *before* finish the session?
|
||||
if server is not None:
|
||||
with ignore_errors():
|
||||
close_socket(server)
|
||||
|
||||
# TODO: Close self._sock *before* finishing the session?
|
||||
if self._sock is not None:
|
||||
with ignore_errors():
|
||||
close_socket(self._sock)
|
||||
|
||||
def _stop_quietly(self):
|
||||
if self._closed: # XXX wrong?
|
||||
return
|
||||
with ignore_errors():
|
||||
self._stop()
|
||||
|
||||
def _handle_session_closing(self, session, kill=False):
|
||||
def _handle_session_closing(self, session, can_disconnect=None):
|
||||
debug('handling closing session')
|
||||
if self._server is not None and not kill:
|
||||
self._finish_session(stop=False)
|
||||
return
|
||||
|
||||
if not self._closed: # XXX wrong?
|
||||
self._close()
|
||||
if kill and self._killonclose:
|
||||
if not self._exiting_via_atexit_handler:
|
||||
kill_current_proc()
|
||||
if self._exiting_via_atexit_handler:
|
||||
# This must be done before we send a disconnect response
|
||||
# (which implies before we close the client socket).
|
||||
# TODO: Call session.wait_on_exit() directly?
|
||||
wait_on_exit = session.get_wait_on_exit()
|
||||
if wait_on_exit(self.exitcode or 0):
|
||||
self._wait_for_user()
|
||||
if can_disconnect is not None:
|
||||
can_disconnect()
|
||||
|
||||
if self._singlesession:
|
||||
if self._killonclose:
|
||||
with self._lock:
|
||||
if not self._exiting_via_atexit_handler:
|
||||
# Ensure the proc is exiting before closing
|
||||
# socket. Note that we kill the proc instead
|
||||
# of calling sys.exit(0).
|
||||
# Note that this will trigger either the atexit
|
||||
# handler or the signal handler.
|
||||
kill_current_proc()
|
||||
else:
|
||||
try:
|
||||
self.close()
|
||||
except DaemonClosedError:
|
||||
pass
|
||||
else:
|
||||
self._finish_session()
|
||||
|
||||
def _clear_sessionlock(self, done=False):
|
||||
sessionlock = self._sessionlock
|
||||
if done:
|
||||
self._sessionlock = None
|
||||
if sessionlock is not None:
|
||||
try:
|
||||
sessionlock.release()
|
||||
except Exception: # TODO: Make it more specific?
|
||||
debug('session lock not released')
|
||||
else:
|
||||
debug('session lock released')
|
||||
|
||||
# internal session-related methods
|
||||
|
||||
|
|
@ -312,39 +345,40 @@ class DaemonBase(object):
|
|||
self._finish_session()
|
||||
raise
|
||||
|
||||
def _finish_session(self, stop=True):
|
||||
def _finish_session(self):
|
||||
try:
|
||||
session = self._release_session(stop=stop)
|
||||
session = self._release_session()
|
||||
debug('session stopped')
|
||||
finally:
|
||||
sessionlock = self._sessionlock
|
||||
try:
|
||||
sessionlock.release()
|
||||
except Exception: # TODO: Make it more specific?
|
||||
debug('session lock not released')
|
||||
else:
|
||||
debug('session lock released')
|
||||
self._clear_sessionlock()
|
||||
|
||||
if self._singlesession:
|
||||
debug('closing daemon after single session')
|
||||
self._wait_on_exit = session.get_wait_on_exit()
|
||||
try:
|
||||
self.close()
|
||||
except DaemonClosedError:
|
||||
pass
|
||||
return session
|
||||
|
||||
def _release_session(self, stop=True):
|
||||
def _release_session(self):
|
||||
session = self.session
|
||||
if not self._singlesession:
|
||||
# TODO: This shouldn't happen if we are exiting?
|
||||
self._session = None
|
||||
|
||||
if stop:
|
||||
exitcode = None
|
||||
if self._server is None:
|
||||
# Trigger a VSC "exited" event.
|
||||
exitcode = self.exitcode or 0
|
||||
# Possibly trigger VSC "exited" and "terminated" events.
|
||||
exitcode = self.exitcode
|
||||
if exitcode is None:
|
||||
if self._exiting_via_atexit_handler or self._singlesession:
|
||||
exitcode = 0
|
||||
try:
|
||||
session.stop(exitcode)
|
||||
except NotRunningError:
|
||||
pass
|
||||
try:
|
||||
session.close()
|
||||
except ClosedError:
|
||||
pass
|
||||
|
||||
return session
|
||||
|
||||
|
|
@ -370,15 +404,23 @@ class DaemonBase(object):
|
|||
pass
|
||||
|
||||
def _handle_atexit(self):
|
||||
self._exiting_via_atexit_handler = True
|
||||
if not self._closed: # XXX wrong?
|
||||
self._close()
|
||||
if self.session is not None:
|
||||
self.session.wait_until_stopped()
|
||||
debug('handling atexit')
|
||||
with self._lock:
|
||||
self._exiting_via_atexit_handler = True
|
||||
session = self.session
|
||||
try:
|
||||
self.close()
|
||||
except DaemonClosedError:
|
||||
pass
|
||||
if session is not None:
|
||||
session.wait_until_stopped()
|
||||
|
||||
def _handle_signal(self, signum, frame):
|
||||
if not self._closed: # XXX wrong?
|
||||
self._close()
|
||||
debug('handling signal')
|
||||
try:
|
||||
self.close()
|
||||
except DaemonClosedError:
|
||||
pass
|
||||
if not self._exiting_via_atexit_handler:
|
||||
sys.exit(0)
|
||||
|
||||
|
|
@ -437,9 +479,10 @@ class Daemon(DaemonBase):
|
|||
self.session.handle_pydevd_message(cmdid, seq, text)
|
||||
|
||||
def _handle_pydevd_close(self):
|
||||
if self._closed: # XXX wrong?
|
||||
return
|
||||
self._close()
|
||||
try:
|
||||
self.close()
|
||||
except DaemonClosedError:
|
||||
pass
|
||||
|
||||
def _getpeername(self):
|
||||
if self.session is None or self.session.closed:
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
from .socket import is_socket, close_socket
|
||||
from .wrapper import VSCodeMessageProcessor
|
||||
from ._util import Closeable, Startable, debug
|
||||
from ._util import TimeoutError, ClosedError, Closeable, Startable, debug
|
||||
|
||||
|
||||
class DebugSession(Startable, Closeable):
|
||||
|
|
@ -33,23 +33,29 @@ class DebugSession(Startable, Closeable):
|
|||
def __init__(self, sock, notify_closing=None, ownsock=False):
|
||||
super(DebugSession, self).__init__()
|
||||
|
||||
if notify_closing is not None:
|
||||
def handle_closing(before):
|
||||
if before:
|
||||
notify_closing(self, can_disconnect=self._can_disconnect)
|
||||
self.add_close_handler(handle_closing)
|
||||
|
||||
self._sock = sock
|
||||
if ownsock:
|
||||
# Close the socket *after* calling sys.exit() (via notify_closing).
|
||||
def handle_closing(before):
|
||||
if before:
|
||||
return
|
||||
proc = self._msgprocessor
|
||||
if proc is not None:
|
||||
try:
|
||||
proc.wait_while_connected(10) # seconds
|
||||
except TimeoutError:
|
||||
debug('timed out waiting for disconnect')
|
||||
close_socket(self._sock)
|
||||
self.add_close_handler(handle_closing)
|
||||
|
||||
self._killrequested = False
|
||||
if notify_closing is not None:
|
||||
def handle_closing(before):
|
||||
if not before:
|
||||
return
|
||||
notify_closing(self, kill=self._killrequested)
|
||||
self.add_close_handler(handle_closing)
|
||||
|
||||
self._msgprocessor = None
|
||||
self._can_disconnect = None
|
||||
|
||||
@property
|
||||
def socket(self):
|
||||
|
|
@ -61,16 +67,18 @@ class DebugSession(Startable, Closeable):
|
|||
|
||||
def wait_options(self):
|
||||
"""Return (normal, abnormal) based on the session's launch config."""
|
||||
if self._msgprocessor is None:
|
||||
proc = self._msgprocessor
|
||||
if proc is None:
|
||||
return (False, False)
|
||||
return self._msgprocessor._wait_options()
|
||||
return proc._wait_options()
|
||||
|
||||
def wait_until_stopped(self):
|
||||
"""Block until all resources (e.g. message processor) have stopped."""
|
||||
if self._msgprocessor is None:
|
||||
proc = self._msgprocessor
|
||||
if proc is None:
|
||||
return
|
||||
# TODO: Do this in VSCodeMessageProcessor.close()?
|
||||
self._msgprocessor._wait_for_server_thread()
|
||||
proc._wait_for_server_thread()
|
||||
|
||||
def get_wait_on_exit(self):
|
||||
"""Return a wait_on_exit(exitcode) func.
|
||||
|
|
@ -105,7 +113,7 @@ class DebugSession(Startable, Closeable):
|
|||
if self._msgprocessor is None:
|
||||
return
|
||||
|
||||
# TODO: This is not correct in the "attach" case.
|
||||
debug('proc stopping')
|
||||
self._msgprocessor.handle_session_stopped(exitcode)
|
||||
self._msgprocessor.close()
|
||||
self._msgprocessor = None
|
||||
|
|
@ -122,10 +130,13 @@ class DebugSession(Startable, Closeable):
|
|||
|
||||
# internal methods for VSCodeMessageProcessor
|
||||
|
||||
def _handle_vsc_disconnect(self, kill=False):
|
||||
if kill:
|
||||
self._killrequested = kill
|
||||
self.close()
|
||||
def _handle_vsc_disconnect(self, can_disconnect=None):
|
||||
debug('disconnecting')
|
||||
self._can_disconnect = can_disconnect
|
||||
try:
|
||||
self.close()
|
||||
except ClosedError:
|
||||
pass
|
||||
|
||||
def _handle_vsc_close(self):
|
||||
debug('processor closing')
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ import ptvsd.untangle as untangle # noqa
|
|||
from ptvsd.pathutils import PathUnNormcase # noqa
|
||||
from ptvsd.safe_repr import SafeRepr # noqa
|
||||
from ptvsd.version import __version__ # noqa
|
||||
from ptvsd._util import debug # noqa
|
||||
from ptvsd._util import debug, is_locked, lock_release, lock_wait # noqa
|
||||
from ptvsd.socket import TimeoutError # noqa
|
||||
|
||||
|
||||
|
|
@ -789,7 +789,7 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
"""The base class for VSC message processors."""
|
||||
|
||||
def __init__(self, socket, notify_closing,
|
||||
timeout=None, logfile=None,
|
||||
timeout=None, logfile=None, own_socket=False
|
||||
):
|
||||
super(VSCodeMessageProcessorBase, self).__init__(
|
||||
socket=socket,
|
||||
|
|
@ -798,6 +798,7 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
logfile=logfile,
|
||||
)
|
||||
self.socket = socket
|
||||
self._own_socket = own_socket
|
||||
self._notify_closing = notify_closing
|
||||
|
||||
self.server_thread = None
|
||||
|
|
@ -805,6 +806,37 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
self.readylock = threading.Lock()
|
||||
self.readylock.acquire() # Unlock at the end of start().
|
||||
|
||||
self._connected = threading.Lock()
|
||||
self._listening = None
|
||||
self._connlock = threading.Lock()
|
||||
|
||||
@property
|
||||
def connected(self): # may send responses/events
|
||||
with self._connlock:
|
||||
return is_locked(self._connected)
|
||||
|
||||
@property
|
||||
def listening(self):
|
||||
# TODO: must be disconnected?
|
||||
with self._connlock:
|
||||
if self._listening is None:
|
||||
return False
|
||||
return is_locked(self._listening)
|
||||
|
||||
def wait_while_connected(self, timeout=None):
|
||||
"""Wait until the client socket is disconnected."""
|
||||
with self._connlock:
|
||||
lock = self._listening
|
||||
lock_wait(lock, timeout) # Wait until no longer connected.
|
||||
|
||||
def wait_while_listening(self, timeout=None):
|
||||
"""Wait until no longer listening for incoming messages."""
|
||||
with self._connlock:
|
||||
lock = self._listening
|
||||
if lock is None:
|
||||
raise RuntimeError('not listening yet')
|
||||
lock_wait(lock, timeout) # Wait until no longer listening.
|
||||
|
||||
def start(self, threadname):
|
||||
# event loop
|
||||
self._start_event_loop()
|
||||
|
|
@ -812,10 +844,15 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
# VSC msg processing loop
|
||||
def process_messages():
|
||||
self.readylock.acquire()
|
||||
with self._connlock:
|
||||
self._listening = threading.Lock()
|
||||
try:
|
||||
self.process_messages()
|
||||
except (EOFError, TimeoutError):
|
||||
debug('client socket closed')
|
||||
with self._connlock:
|
||||
lock_release(self._listening)
|
||||
lock_release(self._connected)
|
||||
self.close()
|
||||
self.server_thread = threading.Thread(
|
||||
target=process_messages,
|
||||
|
|
@ -839,15 +876,20 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
|
||||
def close(self):
|
||||
"""Stop the message processor and release its resources."""
|
||||
debug('raw closing')
|
||||
if self._closed:
|
||||
return
|
||||
self._closed = True
|
||||
debug('raw closing')
|
||||
|
||||
self._notify_closing()
|
||||
# Close the editor-side socket.
|
||||
self._stop_vsc_message_loop()
|
||||
|
||||
# Ensure that the connection is marked as closed.
|
||||
with self._connlock:
|
||||
lock_release(self._listening)
|
||||
lock_release(self._connected)
|
||||
|
||||
# VSC protocol handlers
|
||||
|
||||
def send_error_response(self, request, message=None):
|
||||
|
|
@ -859,6 +901,10 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
|
||||
# internal methods
|
||||
|
||||
def _set_disconnected(self):
|
||||
with self._connlock:
|
||||
lock_release(self._connected)
|
||||
|
||||
def _wait_for_server_thread(self):
|
||||
if self.server_thread is None:
|
||||
return
|
||||
|
|
@ -869,10 +915,11 @@ class VSCodeMessageProcessorBase(ipcjson.SocketIO, ipcjson.IpcChannel):
|
|||
def _stop_vsc_message_loop(self):
|
||||
self.set_exit()
|
||||
self._stop_event_loop()
|
||||
if self.socket:
|
||||
if self.socket is not None and self._own_socket:
|
||||
try:
|
||||
self.socket.shutdown(socket.SHUT_RDWR)
|
||||
self.socket.close()
|
||||
self._set_disconnected()
|
||||
except Exception:
|
||||
# TODO: log the error
|
||||
pass
|
||||
|
|
@ -931,25 +978,25 @@ class VSCLifecycleMsgProcessor(VSCodeMessageProcessorBase):
|
|||
self._notify_launch = notify_launch or (lambda: None)
|
||||
self._notify_disconnecting = notify_disconnecting
|
||||
|
||||
self._exited = False
|
||||
self._stopped = False
|
||||
|
||||
# adapter state
|
||||
self.disconnect_request = None
|
||||
self.debug_options = {}
|
||||
self.disconnect_request_event = threading.Event()
|
||||
self.start_reason = None
|
||||
self.debug_options = {}
|
||||
|
||||
def handle_session_stopped(self, exitcode=None):
|
||||
"""Finalize the protocol connection."""
|
||||
if self._exited:
|
||||
if self._stopped:
|
||||
return
|
||||
self._exited = True
|
||||
self._stopped = True
|
||||
|
||||
if exitcode is not None:
|
||||
# Notify the editor that the "debuggee" (e.g. script, app) exited.
|
||||
self.send_event('exited', exitCode=exitcode)
|
||||
# Notify the editor that the debugger has stopped.
|
||||
self.send_event('terminated')
|
||||
# Notify the editor that the debugger has stopped.
|
||||
self.send_event('terminated')
|
||||
|
||||
# The editor will send a "disconnect" request at this point.
|
||||
self._wait_for_disconnect()
|
||||
|
|
@ -984,11 +1031,15 @@ class VSCLifecycleMsgProcessor(VSCodeMessageProcessorBase):
|
|||
|
||||
def on_disconnect(self, request, args):
|
||||
# TODO: docstring
|
||||
if self.start_reason == 'launch':
|
||||
self._handle_disconnect(request)
|
||||
else:
|
||||
self.send_response(request)
|
||||
self._notify_disconnecting(kill=False)
|
||||
def done():
|
||||
self.disconnect_request = request
|
||||
self.disconnect_request_event.set()
|
||||
self._notify_disconnecting(done)
|
||||
# TODO: We should be able drop the remaining lines.
|
||||
if not self._closed and self.start_reason == 'launch':
|
||||
# Closing the socket causes pydevd to resume all threads,
|
||||
# so just terminate the process altogether.
|
||||
sys.exit(0)
|
||||
|
||||
# internal methods
|
||||
|
||||
|
|
@ -1005,20 +1056,13 @@ class VSCLifecycleMsgProcessor(VSCodeMessageProcessorBase):
|
|||
timeout = WAIT_FOR_DISCONNECT_REQUEST_TIMEOUT
|
||||
|
||||
if not self.disconnect_request_event.wait(timeout):
|
||||
warnings.warn('timed out waiting for disconnect request')
|
||||
warnings.warn(('timed out (after {} seconds) '
|
||||
'waiting for disconnect request'
|
||||
).format(timeout))
|
||||
if self.disconnect_request is not None:
|
||||
self.send_response(self.disconnect_request)
|
||||
self.disconnect_request = None
|
||||
|
||||
def _handle_disconnect(self, request):
|
||||
assert self.start_reason == 'launch'
|
||||
self.disconnect_request = request
|
||||
self.disconnect_request_event.set()
|
||||
self._notify_disconnecting(kill=not self._closed)
|
||||
if not self._closed:
|
||||
# Closing the socket causes pydevd to resume all threads,
|
||||
# so just terminate the process altogether.
|
||||
sys.exit(0)
|
||||
self._set_disconnected()
|
||||
|
||||
def _wait_options(self):
|
||||
# In attach scenarios, we can't assume that the process is actually
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ class EasyDebugClient(DebugClient):
|
|||
|
||||
def run():
|
||||
self._session = DebugSession.create_server(addr, **kwargs)
|
||||
t = threading.Thread(target=run)
|
||||
t = threading.Thread(target=run, name='ptvsd.test.client')
|
||||
t.start()
|
||||
|
||||
def wait():
|
||||
|
|
|
|||
|
|
@ -116,6 +116,8 @@ class DebugSession(Closeable):
|
|||
HOST = 'localhost'
|
||||
PORT = 8888
|
||||
|
||||
TIMEOUT = None
|
||||
|
||||
@classmethod
|
||||
def create_client(cls, addr=None, **kwargs):
|
||||
if addr is None:
|
||||
|
|
@ -147,7 +149,10 @@ class DebugSession(Closeable):
|
|||
else:
|
||||
self._add_handler(*handler)
|
||||
self._received = []
|
||||
self._listenerthread = threading.Thread(target=self._listen)
|
||||
self._listenerthread = threading.Thread(
|
||||
target=self._listen,
|
||||
name='ptvsd.test.session',
|
||||
)
|
||||
self._listenerthread.start()
|
||||
|
||||
@property
|
||||
|
|
@ -261,6 +266,8 @@ class DebugSession(Closeable):
|
|||
|
||||
@contextlib.contextmanager
|
||||
def _wait_for_message(self, match, handlername, timeout=None):
|
||||
if timeout is None:
|
||||
timeout = self.TIMEOUT
|
||||
lock, wait = get_locked_and_waiter()
|
||||
|
||||
def handler(msg):
|
||||
|
|
@ -272,4 +279,4 @@ class DebugSession(Closeable):
|
|||
try:
|
||||
yield
|
||||
finally:
|
||||
wait(timeout or self._timeout, handlername)
|
||||
wait(timeout or self._timeout, handlername, fail=True)
|
||||
|
|
|
|||
|
|
@ -28,7 +28,9 @@ class Server:
|
|||
raise RuntimeError('already started')
|
||||
self._server = HTTPServer(self._addr, self.handler)
|
||||
self._thread = threading.Thread(
|
||||
target=lambda: self._server.serve_forever())
|
||||
target=(lambda: self._server.serve_forever()),
|
||||
name='ptvsd.test.http',
|
||||
)
|
||||
self._thread.start()
|
||||
|
||||
def stop(self):
|
||||
|
|
|
|||
|
|
@ -174,7 +174,10 @@ class Daemon(object):
|
|||
def run():
|
||||
self._sock = connect()
|
||||
self._handle_connected()
|
||||
t = threading.Thread(target=run)
|
||||
t = threading.Thread(
|
||||
target=run,
|
||||
name='ptvsd.test.daemon',
|
||||
)
|
||||
t.pydev_do_not_trace = True
|
||||
t.is_pydev_daemon_thread = True
|
||||
t.start()
|
||||
|
|
@ -292,7 +295,10 @@ class MessageDaemon(Daemon):
|
|||
|
||||
def _handle_connected(self):
|
||||
# TODO: make it a daemon thread?
|
||||
self._listener = threading.Thread(target=self._listen)
|
||||
self._listener = threading.Thread(
|
||||
target=self._listen,
|
||||
name='ptvsd.test.msgdaemon',
|
||||
)
|
||||
self._listener.pydev_do_not_trace = True
|
||||
self._listener.is_pydev_daemon_thread = True
|
||||
self._listener.start()
|
||||
|
|
|
|||
|
|
@ -18,14 +18,17 @@ class PTVSD(ptvsd.daemon.Daemon):
|
|||
"""
|
||||
|
||||
@classmethod
|
||||
def from_connect_func(cls, connect):
|
||||
def from_connect_func(cls, connect, singlesession=None):
|
||||
"""Return a new instance using the socket returned by connect()."""
|
||||
client, server = connect()
|
||||
if singlesession is None:
|
||||
singlesession = (server is None)
|
||||
self = cls(
|
||||
wait_for_user=(lambda: None),
|
||||
addhandlers=False,
|
||||
killonclose=False,
|
||||
singlesession=singlesession,
|
||||
)
|
||||
client, server = connect()
|
||||
self.start()
|
||||
self.start_session(client, 'ptvsd.Server')
|
||||
self.server = server
|
||||
|
|
@ -70,10 +73,12 @@ class BinderBase(object):
|
|||
runs the debugger in the background.
|
||||
"""
|
||||
|
||||
def __init__(self, address=None, ptvsd=None):
|
||||
def __init__(self, address=None, ptvsd=None, singlesession=None):
|
||||
if address is not None or ptvsd is not None:
|
||||
raise NotImplementedError
|
||||
|
||||
self.singlesession = singlesession
|
||||
|
||||
# Set when bind() called:
|
||||
self.address = None
|
||||
self._connect = None
|
||||
|
|
@ -117,6 +122,8 @@ class BinderBase(object):
|
|||
def connect():
|
||||
if self._thread is not None:
|
||||
raise RuntimeError('already connected')
|
||||
# We do not give this thread a name because we actually do
|
||||
# want ptvsd to track it.
|
||||
self._thread = threading.Thread(target=self._run)
|
||||
self._thread.start()
|
||||
# Wait for ptvsd to start up.
|
||||
|
|
@ -150,7 +157,10 @@ class BinderBase(object):
|
|||
def _start_ptvsd(self):
|
||||
if self.ptvsd is not None:
|
||||
raise RuntimeError('already connected')
|
||||
self.ptvsd = PTVSD.from_connect_func(self._connect)
|
||||
self.ptvsd = PTVSD.from_connect_func(
|
||||
self._connect,
|
||||
singlesession=self.singlesession,
|
||||
)
|
||||
self._waiter.release()
|
||||
|
||||
def _run(self):
|
||||
|
|
|
|||
|
|
@ -19,8 +19,10 @@ PROTOCOL = protocol.MessageProtocol(
|
|||
|
||||
class Binder(BinderBase):
|
||||
|
||||
def __init__(self):
|
||||
super(Binder, self).__init__()
|
||||
def __init__(self, singlesession=True):
|
||||
super(Binder, self).__init__(
|
||||
singlesession=singlesession,
|
||||
)
|
||||
self._lock = threading.Lock()
|
||||
self._lock.acquire()
|
||||
|
||||
|
|
@ -108,8 +110,8 @@ class FakePyDevd(protocol.MessageDaemon):
|
|||
else:
|
||||
return None
|
||||
|
||||
def __init__(self, handler=None):
|
||||
self.binder = Binder()
|
||||
def __init__(self, handler=None, **kwargs):
|
||||
self.binder = Binder(**kwargs)
|
||||
|
||||
super(FakePyDevd, self).__init__(
|
||||
self.binder.bind,
|
||||
|
|
|
|||
|
|
@ -11,8 +11,11 @@ from ._binder import BinderBase
|
|||
|
||||
class Binder(BinderBase):
|
||||
|
||||
def __init__(self, filename, module, **kwargs):
|
||||
super(Binder, self).__init__(**kwargs)
|
||||
def __init__(self, filename, module, singlesession=True, **kwargs):
|
||||
super(Binder, self).__init__(
|
||||
singlesession=singlesession,
|
||||
**kwargs
|
||||
)
|
||||
self.filename = filename
|
||||
self.module = module
|
||||
self._lock = threading.Lock()
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@ import threading
|
|||
import time
|
||||
import warnings
|
||||
|
||||
from ptvsd._util import TimeoutError
|
||||
|
||||
|
||||
if sys.version_info < (3,):
|
||||
def acquire_with_timeout(lock, timeout):
|
||||
|
|
@ -26,14 +28,16 @@ def get_locked_and_waiter(timeout=1.0):
|
|||
lock = threading.Lock()
|
||||
lock.acquire()
|
||||
|
||||
def wait(timeout=_timeout, reason=None):
|
||||
def wait(timeout=_timeout, reason=None, fail=False):
|
||||
if timeout is None:
|
||||
timeout = _timeout
|
||||
if acquire_with_timeout(lock, timeout):
|
||||
lock.release()
|
||||
else:
|
||||
msg = 'timed out waiting'
|
||||
msg = 'timed out (after {} seconds) waiting'.format(timeout)
|
||||
if reason:
|
||||
msg += ' for {}'.format(reason)
|
||||
warnings.warn(msg)
|
||||
if fail:
|
||||
raise TimeoutError(msg)
|
||||
warnings.warn(msg, stacklevel=2)
|
||||
return lock, wait
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@ from _pydevd_bundle.pydevd_comm import (
|
|||
CMD_SET_PROJECT_ROOTS,
|
||||
)
|
||||
|
||||
from ptvsd import wrapper
|
||||
from tests.helpers.pydevd import FakePyDevd, PyDevdMessages
|
||||
from tests.helpers.vsc import FakeVSC, VSCMessages
|
||||
|
||||
|
|
@ -167,24 +166,24 @@ class VSCLifecycle(object):
|
|||
self.requests = None
|
||||
|
||||
@contextlib.contextmanager
|
||||
def daemon_running(self, port=None, hide=False):
|
||||
def daemon_running(self, port=None, hide=False, disconnect=True):
|
||||
with self._fix.hidden() if hide else noop_cm():
|
||||
daemon = self._start_daemon(port)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
with self._fix.hidden() if hide else noop_cm():
|
||||
self._stop_daemon(daemon)
|
||||
self._stop_daemon(daemon, disconnect=disconnect)
|
||||
|
||||
@contextlib.contextmanager
|
||||
def launched(self, port=None, hide=False, **kwargs):
|
||||
with self.daemon_running(port, hide=hide):
|
||||
def launched(self, port=None, hide=False, disconnect=True, **kwargs):
|
||||
with self.daemon_running(port, hide=hide, disconnect=disconnect):
|
||||
self.launch(**kwargs)
|
||||
yield
|
||||
|
||||
@contextlib.contextmanager
|
||||
def attached(self, port=None, hide=False, **kwargs):
|
||||
with self.daemon_running(port, hide=hide):
|
||||
def attached(self, port=None, hide=False, disconnect=True, **kwargs):
|
||||
with self.daemon_running(port, hide=hide, disconnect=disconnect):
|
||||
self.attach(**kwargs)
|
||||
yield
|
||||
|
||||
|
|
@ -199,7 +198,7 @@ class VSCLifecycle(object):
|
|||
self._handshake('attach', **kwargs)
|
||||
|
||||
def disconnect(self, exitcode=0, **reqargs):
|
||||
wrapper.ptvsd_sys_exit_code = exitcode
|
||||
self._fix.daemon.exitcode = exitcode
|
||||
self._send_request('disconnect', reqargs)
|
||||
# TODO: wait for an exit event?
|
||||
# TODO: call self._fix.vsc.close()?
|
||||
|
|
@ -235,12 +234,15 @@ class VSCLifecycle(object):
|
|||
daemon.wait_until_connected()
|
||||
return daemon
|
||||
|
||||
def _stop_daemon(self, daemon):
|
||||
def _stop_daemon(self, daemon, disconnect=True):
|
||||
# We must close ptvsd directly (rather than closing the external
|
||||
# socket (i.e. "daemon"). This is because cloing ptvsd blocks,
|
||||
# keeping us from sending the disconnect request we need to send
|
||||
# at the end.
|
||||
t = threading.Thread(target=self._fix.close_ptvsd)
|
||||
t = threading.Thread(
|
||||
target=self._fix.close_ptvsd,
|
||||
name='ptvsd.test.lifecycle',
|
||||
)
|
||||
with self._fix.wait_for_events(['exited', 'terminated']):
|
||||
# The thread runs close_ptvsd(), which sends the two
|
||||
# events and then waits for a "disconnect" request. We send
|
||||
|
|
@ -248,7 +250,8 @@ class VSCLifecycle(object):
|
|||
t.pydev_do_not_trace = True
|
||||
t.is_pydev_daemon_thread = True
|
||||
t.start()
|
||||
self.disconnect()
|
||||
if disconnect:
|
||||
self.disconnect()
|
||||
t.join()
|
||||
daemon.close()
|
||||
|
||||
|
|
@ -545,13 +548,18 @@ class VSCFixture(FixtureBase):
|
|||
self._lifecycle = self.LIFECYCLE(self)
|
||||
return self._lifecycle
|
||||
|
||||
@property
|
||||
def daemon(self):
|
||||
# TODO: This is a horrendous use of internal details!
|
||||
return self.fake._adapter.daemon.binder.ptvsd
|
||||
|
||||
@property
|
||||
def _proc(self):
|
||||
# This is used below in close_ptvsd().
|
||||
# TODO: This is a horrendous use of internal details!
|
||||
try:
|
||||
return self.fake._adapter.daemon.binder.ptvsd.proc
|
||||
return self.daemon.proc
|
||||
except AttributeError:
|
||||
# TODO: Fall back to self.daemon.session._msgprocessor?
|
||||
return None
|
||||
|
||||
def send_request(self, cmd, args=None, handle_response=None, timeout=1):
|
||||
|
|
@ -601,11 +609,14 @@ class VSCFixture(FixtureBase):
|
|||
self.send_request('threads', handle_response=handle_response)
|
||||
return threads, threads.pop(None)
|
||||
|
||||
def close_ptvsd(self):
|
||||
def close_ptvsd(self, exitcode=None):
|
||||
# TODO: Use the session instead.
|
||||
if self._proc is None:
|
||||
warnings.warn('"proc" not bound')
|
||||
else:
|
||||
self._proc.close()
|
||||
self.daemon.exitcode = exitcode
|
||||
self.daemon.close()
|
||||
|
||||
|
||||
class HighlevelFixture(object):
|
||||
|
|
@ -686,6 +697,10 @@ class HighlevelFixture(object):
|
|||
def ishidden(self):
|
||||
return self._vsc.ishidden and self._pydevd.ishidden
|
||||
|
||||
@property
|
||||
def daemon(self):
|
||||
return self._vsc.daemon
|
||||
|
||||
@contextlib.contextmanager
|
||||
def hidden(self):
|
||||
with self._vsc.hidden():
|
||||
|
|
@ -742,8 +757,8 @@ class HighlevelFixture(object):
|
|||
def send_debugger_event(self, cmdid, payload):
|
||||
self._pydevd.send_event(cmdid, payload)
|
||||
|
||||
def close_ptvsd(self):
|
||||
self._vsc.close_ptvsd()
|
||||
def close_ptvsd(self, **kwargs):
|
||||
self._vsc.close_ptvsd(**kwargs)
|
||||
|
||||
# combinations
|
||||
|
||||
|
|
|
|||
|
|
@ -47,6 +47,7 @@ class LifecycleTests(HighlevelTest, unittest.TestCase):
|
|||
|
||||
def attach(self, expected_os_id, attach_args):
|
||||
version = self.debugger.VERSION
|
||||
self.fix.debugger.binder.singlesession = False
|
||||
addr = (None, 8888)
|
||||
daemon = self.vsc.start(addr)
|
||||
with self.vsc.wait_for_event('output'):
|
||||
|
|
@ -70,11 +71,13 @@ class LifecycleTests(HighlevelTest, unittest.TestCase):
|
|||
# end
|
||||
req_disconnect = self.send_request('disconnect')
|
||||
finally:
|
||||
received = self.vsc.received
|
||||
with self._fix.wait_for_events(['exited', 'terminated']):
|
||||
self.fix.close_ptvsd()
|
||||
daemon.close()
|
||||
#self.fix.close_ptvsd()
|
||||
|
||||
self.assert_received(self.vsc, [
|
||||
self.assert_vsc_received(received, [
|
||||
self.new_event(
|
||||
'output',
|
||||
category='telemetry',
|
||||
|
|
@ -91,8 +94,6 @@ class LifecycleTests(HighlevelTest, unittest.TestCase):
|
|||
startMethod='attach',
|
||||
)),
|
||||
self.new_response(req_disconnect),
|
||||
self.new_event('exited', exitCode=0),
|
||||
self.new_event('terminated'),
|
||||
])
|
||||
self.assert_received(self.debugger, [
|
||||
self.debugger_msgs.new_request(CMD_VERSION,
|
||||
|
|
@ -106,6 +107,11 @@ class LifecycleTests(HighlevelTest, unittest.TestCase):
|
|||
def test_attach(self):
|
||||
self.attach(expected_os_id=OS_ID, attach_args={})
|
||||
|
||||
@unittest.skip('not implemented')
|
||||
def test_attach_exit_during_session(self):
|
||||
# TODO: Ensure we see the "terminated" and "exited" events.
|
||||
raise NotImplementedError
|
||||
|
||||
def test_attach_from_unix_os(self):
|
||||
attach_args = {'options': 'WINDOWS_CLIENT=False'}
|
||||
self.attach(expected_os_id='UNIX', attach_args=attach_args)
|
||||
|
|
|
|||
|
|
@ -170,6 +170,7 @@ class VSCFlowTest(TestBase):
|
|||
@contextlib.contextmanager
|
||||
def launched(self, port=8888, **kwargs):
|
||||
kwargs.setdefault('process', False)
|
||||
kwargs.setdefault('disconnect', False)
|
||||
with self.lifecycle.launched(port=port, hide=True, **kwargs):
|
||||
yield
|
||||
self.fix.binder.done(close=False)
|
||||
|
|
|
|||
|
|
@ -99,7 +99,6 @@ class CLITests(TestsBase, unittest.TestCase):
|
|||
)
|
||||
lifecycle_handshake(session, 'launch')
|
||||
lockwait(timeout=2.0)
|
||||
session.send_request('disconnect')
|
||||
out = adapter.output
|
||||
|
||||
self.assertIn(u"[{!r}, '--eggs']".format(filename),
|
||||
|
|
@ -251,8 +250,7 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
|
||||
# Skipping the 'thread exited' and 'terminated' messages which
|
||||
# may appear randomly in the received list.
|
||||
received = session.received[:8]
|
||||
self.assert_received(received, [
|
||||
self.assert_received(session.received[:7], [
|
||||
self.new_version_event(session.received),
|
||||
self.new_response(req_initialize, **INITIALIZE_RESPONSE),
|
||||
self.new_event('initialized'),
|
||||
|
|
@ -265,7 +263,6 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
'name': filename,
|
||||
}),
|
||||
self.new_event('thread', reason='started', threadId=1),
|
||||
self.new_event('exited', exitCode=0),
|
||||
])
|
||||
|
||||
def test_launch_ptvsd_server(self):
|
||||
|
|
@ -286,7 +283,7 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
adapter.wait()
|
||||
|
||||
self.maxDiff = None
|
||||
self.assert_received(session.received, [
|
||||
self.assert_received(session.received[:7], [
|
||||
self.new_version_event(session.received),
|
||||
self.new_response(req_initialize, **INITIALIZE_RESPONSE),
|
||||
self.new_event('initialized'),
|
||||
|
|
@ -299,8 +296,9 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
'name': filename,
|
||||
}),
|
||||
self.new_event('thread', reason='started', threadId=1),
|
||||
self.new_event('exited', exitCode=0),
|
||||
self.new_event('terminated'),
|
||||
#self.new_event('thread', reason='exited', threadId=1),
|
||||
#self.new_event('exited', exitCode=0),
|
||||
#self.new_event('terminated'),
|
||||
])
|
||||
|
||||
def test_attach_started_separately(self):
|
||||
|
|
@ -319,7 +317,7 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
done()
|
||||
adapter.wait()
|
||||
|
||||
self.assert_received(session.received, [
|
||||
self.assert_received(session.received[:7], [
|
||||
self.new_version_event(session.received),
|
||||
self.new_response(req_initialize, **INITIALIZE_RESPONSE),
|
||||
self.new_event('initialized'),
|
||||
|
|
@ -332,8 +330,9 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
'name': filename,
|
||||
}),
|
||||
self.new_event('thread', reason='started', threadId=1),
|
||||
self.new_event('exited', exitCode=0),
|
||||
self.new_event('terminated'),
|
||||
#self.new_event('thread', reason='exited', threadId=1),
|
||||
#self.new_event('exited', exitCode=0),
|
||||
#self.new_event('terminated'),
|
||||
])
|
||||
|
||||
def test_attach_embedded(self):
|
||||
|
|
@ -405,7 +404,6 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
|
||||
adapter.wait()
|
||||
|
||||
# self.maxDiff = None
|
||||
self.assert_received(session1.received, [
|
||||
self.new_version_event(session1.received),
|
||||
self.new_response(reqs[0], **INITIALIZE_RESPONSE),
|
||||
|
|
@ -420,8 +418,6 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
}),
|
||||
self.new_event('thread', reason='started', threadId=1),
|
||||
self.new_response(req_disconnect),
|
||||
# TODO: Shouldn't there be a "terminated" event?
|
||||
# self.new_event('terminated'),
|
||||
])
|
||||
self.messages.reset_all()
|
||||
self.assert_received(session2.received, [
|
||||
|
|
@ -440,6 +436,11 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
self.new_event('terminated'),
|
||||
])
|
||||
|
||||
@unittest.skip('not implemented')
|
||||
def test_attach_exit_during_session(self):
|
||||
# TODO: Ensure we see the "terminated" and "exited" events.
|
||||
raise NotImplementedError
|
||||
|
||||
@unittest.skip('re-attach needs fixing')
|
||||
def test_attach_unknown(self):
|
||||
lockfile = self.workspace.lockfile()
|
||||
|
|
@ -500,7 +501,7 @@ class LifecycleTests(TestsBase, unittest.TestCase):
|
|||
done()
|
||||
adapter.wait()
|
||||
|
||||
self.assert_received(session.received, [
|
||||
self.assert_received(session.received[:11], [
|
||||
self.new_version_event(session.received),
|
||||
self.new_response(req_initialize, **INITIALIZE_RESPONSE),
|
||||
self.new_event('initialized'),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue