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 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)