def test_reuse_same_address_port(self):
try:
sock1 = create_server(self.HOST1, self.PORT1)
with pytest.raises(Exception):
create_server(self.HOST1, self.PORT1)
assert sock1.getsockname() == (self.HOST1, self.PORT1)
finally:
shut_down(sock1)
def test_reuse_same_port(self):
try:
sock1 = create_server(self.HOST1, self.PORT1)
sock2 = create_server(self.HOST2, self.PORT1)
assert sock1.getsockname() == (self.HOST1, self.PORT1)
assert sock2.getsockname() == (self.HOST2, self.PORT1)
finally:
shut_down(sock1)
shut_down(sock2)
def test_reuse_same_address_port(self):
# NOTE: This test should ensure that same address port can be used by two
# sockets. This to prevent accidental changes to socket options. In Windows
# SO_REUSEADDR flag allows two sockets to bind to same address:port combination.
# Windows should always use SO_EXCLUSIVEADDRUSE
try:
sock1 = create_server(self.HOST1, self.PORT1)
with pytest.raises(Exception):
create_server(self.HOST1, self.PORT1)
assert sock1.getsockname() == (self.HOST1, self.PORT1)
finally:
close_socket(sock1)
def test_reuse_same_port(self):
try:
sock1, sock2 = None, None
sock1 = create_server(self.HOST1, self.PORT1)
sock2 = create_server(self.HOST2, self.PORT1)
assert sock1.getsockname() == (self.HOST1, self.PORT1)
assert sock2.getsockname() == (self.HOST2, self.PORT1)
except Exception:
pytest.fail()
finally:
if sock1 is not None:
close_socket(sock1)
if sock2 is not None:
close_socket(sock2)
def listen_for_subprocesses():
"""Starts a listener for incoming 'ptvsd_subprocess' notifications that
enqueues them in subprocess_queue.
"""
global subprocess_listener_socket
assert subprocess_listener_socket is None
subprocess_listener_socket = create_server('localhost', 0)
atexit.register(stop_listening_for_subprocesses)
new_hidden_thread('SubprocessListener', _subprocess_listener).start()
def start_server(self, addr, hidebadsessions=True):
"""Return ("socket", next_session) with a new server socket."""
ptvsd.log.debug('Starting server daemon on {0!r}.', addr)
addr = Address.from_raw(addr)
with self.started():
assert self._sessionlock is None
assert self.session is None
self._server = create_server(addr.host, addr.port)
host, port = self._server.getsockname()
ptvsd.log.debug('Server socket created on {0!r}', addr)
self._sessionlock = threading.Lock()
sock = self._sock
def check_ready(**kwargs):
self._check_ready_for_session(**kwargs)
if self._server is None:
raise DaemonStoppedError()
def next_session(timeout=None, **kwargs):
server = self._server
sessionlock = self._sessionlock
check_ready(checksession=False)
ptvsd.log.debug('Getting next session...')
sessionlock.acquire() # Released in _finish_session().
ptvsd.log.debug('Session lock acquired.')
# It may have closed or stopped while we waited.
check_ready()
timeout = kwargs.pop('timeout', None)
try:
ptvsd.log.debug('Getting session socket...')
client = connect(server, None, **kwargs)
self._bind_session(client)
ptvsd.log.debug('Starting session...')
self._start_session_safely('ptvsd.Server', timeout=timeout)
ptvsd.log.debug('Session started.')
return self._session
except Exception:
ptvsd.log.exception(category=('D' if hidebadsessions else 'E'))
with ignore_errors():
self._finish_session()
if hidebadsessions:
ptvsd.log.debug('Hiding bad session')
return None
self._stop_quietly()
raise
if options.subprocess_notify:
multiproc.notify_root(port)
return sock, next_session
def listen_for_subprocesses():
"""Starts a listener for incoming 'ptvsd_subprocess' notifications that
enqueues them in subprocess_queue.
"""
global subprocess_listener_socket
assert subprocess_listener_socket is None
subprocess_listener_socket = create_server('localhost', 0)
atexit.register(stop_listening_for_subprocesses)
new_hidden_thread('SubprocessListener', _subprocess_listener).start()
def start_server(self, addr, hidebadsessions=True):
"""Return ("socket", next_session) with a new server socket."""
addr = Address.from_raw(addr)
with self.started():
assert self._sessionlock is None
assert self.session is None
self._server = create_server(addr.host, addr.port)
host, port = self._server.getsockname()
debug('server socket created on %r:%r' % (host, port))
self._sessionlock = threading.Lock()
sock = self._sock
def check_ready(**kwargs):
self._check_ready_for_session(**kwargs)
if self._server is None:
raise DaemonStoppedError()
def next_session(timeout=None, **kwargs):
server = self._server
sessionlock = self._sessionlock
check_ready(checksession=False)
debug('getting next session')
sessionlock.acquire() # Released in _finish_session().
debug('session lock acquired')
# It may have closed or stopped while we waited.
check_ready()
timeout = kwargs.pop('timeout', None)
try:
debug('getting session socket')
client = connect(server, None, **kwargs)
self._bind_session(client)
debug('starting session')
self._start_session_safely('ptvsd.Server', timeout=timeout)
debug('session started')
return self._session
except Exception as exc:
debug('session exc:', exc, tb=True)
with ignore_errors():
self._finish_session()
if hidebadsessions:
debug('hiding bad session')
# TODO: Log the error?
return None
self._stop_quietly()
raise
if options.subprocess_notify:
multiproc.notify_root(port)
return sock, next_session
def wait_for_connection(daemon, host, port):
debugger = get_global_debugger()
while debugger is None:
time.sleep(0.1)
debugger = get_global_debugger()
debugger.ready_to_run = True
server = create_server(host, port)
client, _ = server.accept()
daemon.set_connection(client)
daemon.re_build_breakpoints()
on_attach()
def start_server(daemon, host, port):
"""Return a socket to a (new) local pydevd-handling daemon.
The daemon supports the pydevd client wire protocol, sending
requests and handling responses (and events).
This is a replacement for _pydevd_bundle.pydevd_comm.start_server.
"""
server = create_server(host, port)
client, _ = server.accept()
pydevd = daemon.start(server)
daemon.set_connection(client)
return pydevd
def create_server(address):
"""Return a server socket after binding."""
return _ptvsd.create_server(*address)