def test_flask_breakpoint_no_multiproc(start_flask, bp_target): bp_file, bp_line, bp_name = { "code": (paths.app_py, lines.app_py["bphome"], "home"), "template": (paths.hello_html, 8, "template"), }[bp_target] bp_var_content = compat.force_str("Flask-Jinja-Test") with debug.Session() as session: with start_flask(session): session.set_breakpoints(bp_file, [bp_line]) with flask_server: home_request = flask_server.get("/") session.wait_for_stop( "breakpoint", expected_frames=[ some.dap.frame(some.dap.source(bp_file), name=bp_name, line=bp_line) ], ) var_content = session.get_variable("content") assert var_content == some.dict.containing( { "name": "content", "type": "str", "value": repr(bp_var_content), "presentationHint": {"attributes": ["rawString"]}, "evaluateName": "content", "variablesReference": 0, } ) session.request_continue() assert bp_var_content in home_request.response_text()
def Response(request, body=some.object): assert isinstance(request, Expectation) or isinstance( request, RequestOccurrence) exp = PatternExpectation("response", request, body) exp.timeline = request.timeline exp.has_lower_bound = request.has_lower_bound # Try to be as specific as possible. if isinstance(request, Expectation): if request.circumstances[0] != "request": exp.describe = lambda: fmt("response to {0!r}", request) return else: items = (("command", request.circumstances[1]), ) else: items = (("command", request.command), ) if isinstance(request, Occurrence): items += (("request_seq", request.seq), ) if body is some.object: items += (("\002...", "...\003"), ) elif body is some.error or body == some.error: items += (("success", False), ) if body == some.error: items += (("message", compat.force_str(body)), ) else: items += (("body", body), ) exp.describe = lambda: _describe_message("response", *items) return exp
def test_flask_breakpoint_multiproc(start_flask): bp_line = lines.app_py["bphome"] bp_var_content = compat.force_str("Flask-Jinja-Test") with debug.Session() as parent_session: with start_flask(parent_session, multiprocess=True): parent_session.set_breakpoints(paths.app_py, [bp_line]) child_pid = parent_session.wait_for_next_subprocess() with debug.Session() as child_session: # TODO: this is wrong, but we don't have multiproc attach # yet, so update this when that is done # https://github.com/microsoft/ptvsd/issues/1776 with child_session.attach_by_pid(child_pid): child_session.set_breakpoints(paths.app_py, [bp_line]) with flask_server: home_request = flask_server.get("/") child_session.wait_for_stop( "breakpoint", expected_frames=[ some.dap.frame(some.dap.source(paths.app_py), line=bp_line, name="home") ], ) var_content = child_session.get_variable("content") assert var_content == some.dict.containing({ "name": "content", "type": "str", "value": repr(bp_var_content), "presentationHint": { "attributes": ["rawString"] }, "evaluateName": "content", "variablesReference": 0, }) child_session.request_continue() assert bp_var_content in home_request.response_text()
def test_django_breakpoint_multiproc(start_django): bp_line = lines.app_py["bphome"] bp_var_content = compat.force_str("Django-Django-Test") with debug.Session() as parent_session: with start_django(parent_session, multiprocess=True): parent_session.set_breakpoints(paths.app_py, [bp_line]) with parent_session.wait_for_next_subprocess() as child_session: with child_session.start(): child_session.set_breakpoints(paths.app_py, [bp_line]) with django_server: home_request = django_server.get("/home") child_session.wait_for_stop( "breakpoint", expected_frames=[ some.dap.frame(some.dap.source(paths.app_py), line=bp_line, name="home") ], ) var_content = child_session.get_variable("content") assert var_content == some.dict.containing({ "name": "content", "type": "str", "value": compat.unicode_repr(bp_var_content), "presentationHint": { "attributes": ["rawString"] }, "evaluateName": "content", }) child_session.request_continue() assert bp_var_content in home_request.response_text()
def spawn(process_name, cmdline, cwd, env, redirect_output): log.info( "Spawning debuggee process:\n\n" "Current directory: {0!j}\n\n" "Command line: {1!j}\n\n" "Environment variables: {2!j}\n\n", cwd, cmdline, env, ) close_fds = set() try: if redirect_output: # subprocess.PIPE behavior can vary substantially depending on Python version # and platform; using our own pipes keeps it simple, predictable, and fast. stdout_r, stdout_w = os.pipe() stderr_r, stderr_w = os.pipe() close_fds |= {stdout_r, stdout_w, stderr_r, stderr_w} kwargs = dict(stdout=stdout_w, stderr=stderr_w) else: kwargs = {} try: global process process = subprocess.Popen(cmdline, cwd=cwd, env=env, bufsize=0, **kwargs) except Exception as exc: raise messaging.MessageHandlingError( fmt("Couldn't spawn debuggee: {0}\n\nCommand line:{1!r}", exc, cmdline)) log.info("Spawned {0}.", describe()) atexit.register(kill) launcher.channel.send_event( "process", { "startMethod": "launch", "isLocalProcess": True, "systemProcessId": process.pid, "name": process_name, "pointerSize": struct.calcsize(compat.force_str("P")) * 8, }, ) if redirect_output: for category, fd, tee in [ ("stdout", stdout_r, sys.stdout), ("stderr", stderr_r, sys.stderr), ]: output.CaptureOutput(describe(), category, fd, tee) close_fds.remove(fd) wait_thread = threading.Thread(target=wait_for_exit, name="wait_for_exit()") wait_thread.daemon = True wait_thread.start() finally: for fd in close_fds: try: os.close(fd) except Exception: log.exception()
def enable_attach(dont_trace_start_patterns, dont_trace_end_patterns): # Errors below are logged with level="info", because the caller might be catching # and handling exceptions, and we don't want to spam their stderr unnecessarily. import subprocess if hasattr(enable_attach, "adapter"): raise AssertionError("enable_attach() can only be called once per process") server_access_token = compat.force_str(codecs.encode(os.urandom(32), "hex")) try: endpoints_listener = sockets.create_server("127.0.0.1", 0, timeout=5) except Exception as exc: log.exception("Can't listen for adapter endpoints:") raise RuntimeError("can't listen for adapter endpoints: " + str(exc)) endpoints_host, endpoints_port = endpoints_listener.getsockname() log.info( "Waiting for adapter endpoints on {0}:{1}...", endpoints_host, endpoints_port ) adapter_args = [ sys.executable, os.path.dirname(adapter.__file__), "--for-server", str(endpoints_port), "--host", options.host, "--port", str(options.port), "--server-access-token", server_access_token, ] if log.log_dir is not None: adapter_args += ["--log-dir", log.log_dir] log.info("enable_attach() spawning adapter: {0!j}", adapter_args) # On Windows, detach the adapter from our console, if any, so that it doesn't # receive Ctrl+C from it, and doesn't keep it open once we exit. creationflags = 0 if sys.platform == "win32": creationflags |= 0x08000000 # CREATE_NO_WINDOW creationflags |= 0x00000200 # CREATE_NEW_PROCESS_GROUP # Adapter will outlive this process, so we shouldn't wait for it. However, we # need to ensure that the Popen instance for it doesn't get garbage-collected # by holding a reference to it in a non-local variable, to avoid triggering # https://bugs.python.org/issue37380. try: enable_attach.adapter = subprocess.Popen( adapter_args, close_fds=True, creationflags=creationflags ) if os.name == "posix": # It's going to fork again to daemonize, so we need to wait on it to # clean it up properly. enable_attach.adapter.wait() else: # Suppress misleading warning about child process still being alive when # this process exits (https://bugs.python.org/issue38890). enable_attach.adapter.returncode = 0 pydevd.add_dont_terminate_child_pid(enable_attach.adapter.pid) except Exception as exc: log.exception("Error spawning debug adapter:", level="info") raise RuntimeError("error spawning debug adapter: " + str(exc)) try: sock, _ = endpoints_listener.accept() try: sock.settimeout(None) sock_io = sock.makefile("rb", 0) try: endpoints = json.loads(sock_io.read().decode("utf-8")) finally: sock_io.close() finally: sockets.close_socket(sock) except socket.timeout: log.exception("Timed out waiting for adapter to connect:", level="info") raise RuntimeError("timed out waiting for adapter to connect") except Exception as exc: log.exception("Error retrieving adapter endpoints:", level="info") raise RuntimeError("error retrieving adapter endpoints: " + str(exc)) log.info("Endpoints received from adapter: {0!j}", endpoints) if "error" in endpoints: raise RuntimeError(str(endpoints["error"])) try: host = str(endpoints["server"]["host"]) port = int(endpoints["server"]["port"]) options.port = int(endpoints["ide"]["port"]) except Exception as exc: log.exception( "Error parsing adapter endpoints:\n{0!j}\n", endpoints, level="info" ) raise RuntimeError("error parsing adapter endpoints: " + str(exc)) log.info( "Adapter is accepting incoming IDE connections on {0}:{1}", options.host, options.port, ) _settrace( host=host, port=port, suspend=False, patch_multiprocessing=options.multiprocess, wait_for_ready_to_run=False, block_until_connected=True, dont_trace_start_patterns=dont_trace_start_patterns, dont_trace_end_patterns=dont_trace_end_patterns, access_token=server_access_token, client_access_token=options.client_access_token, ) log.info("pydevd is connected to adapter at {0}:{1}", host, port) return options.host, options.port
def enable_attach(dont_trace_start_patterns, dont_trace_end_patterns): if hasattr(enable_attach, "called"): raise RuntimeError( "enable_attach() can only be called once per process.") server_access_token = compat.force_str(codecs.encode( os.urandom(32), "hex")) import subprocess adapter_args = [ sys.executable, _ADAPTER_PATH, "--for-server", "--host", options.host, "--port", str(options.port), "--server-access-token", server_access_token, ] if log.log_dir is not None: adapter_args += ["--log-dir", log.log_dir] log.info("enable_attach() spawning adapter: {0!r}", adapter_args) # Adapter will outlive this process, so we shouldn't wait for it. However, we do # need to ensure that the Popen instance for it doesn't get garbage-collected, to # avoid triggering https://bugs.python.org/issue37380. enable_attach.process = process = subprocess.Popen(adapter_args, bufsize=0, stdout=subprocess.PIPE) line = process.stdout.readline() if isinstance(line, bytes): line = line.decode("utf-8") connection_details = json.JSONDecoder().decode(line) log.info("Connection details received from adapter: {0!r}", connection_details) host = "127.0.0.1" # This should always be loopback address. port = connection_details["server"]["port"] pydevd.settrace( host=host, port=port, suspend=False, patch_multiprocessing=options.multiprocess, wait_for_ready_to_run=False, block_until_connected=True, dont_trace_start_patterns=dont_trace_start_patterns, dont_trace_end_patterns=dont_trace_end_patterns, access_token=server_access_token, client_access_token=options.client_access_token, ) log.info("pydevd debug client connected to: {0}:{1}", host, port) # Ensure that we ignore the adapter process when terminating the debugger. pydevd.add_dont_terminate_child_pid(process.pid) options.port = connection_details["ide"]["port"] enable_attach.called = True log.info("ptvsd debug server running at: {0}:{1}", options.host, options.port) return options.host, options.port
def main(args): from ptvsd import adapter from ptvsd.common import compat, log, sockets from ptvsd.adapter import ide, servers, sessions if args.for_server is not None: if os.name == "posix": # On POSIX, we need to leave the process group and its session, and then # daemonize properly by double-forking (first fork already happened when # this process was spawned). os.setsid() if os.fork() != 0: sys.exit(0) for stdio in sys.stdin, sys.stdout, sys.stderr: if stdio is not None: stdio.close() if args.log_stderr: log.stderr.levels |= set(log.LEVELS) if args.log_dir is not None: log.log_dir = args.log_dir log.to_file(prefix="ptvsd.adapter") log.describe_environment("ptvsd.adapter startup environment:") servers.access_token = args.server_access_token if args.for_server is None: adapter.access_token = compat.force_str( codecs.encode(os.urandom(32), "hex")) try: server_host, server_port = servers.listen() except Exception as exc: if args.for_server is None: raise endpoints = { "error": "Can't listen for server connections: " + str(exc) } else: endpoints = {"server": {"host": server_host, "port": server_port}} try: ide_host, ide_port = ide.listen(port=args.port) except Exception as exc: if args.for_server is None: raise endpoints = { "error": "Can't listen for IDE connections: " + str(exc) } else: endpoints["ide"] = {"host": ide_host, "port": ide_port} if args.for_server is not None: log.info( "Sending endpoints info to debug server at localhost:{0}:\n{1!j}", args.for_server, endpoints, ) try: sock = sockets.create_client() try: sock.settimeout(None) sock.connect(("127.0.0.1", args.for_server)) sock_io = sock.makefile("wb", 0) try: sock_io.write(json.dumps(endpoints).encode("utf-8")) finally: sock_io.close() finally: sockets.close_socket(sock) except Exception: raise log.exception( "Error sending endpoints info to debug server:") if "error" in endpoints: log.error("Couldn't set up endpoints; exiting.") sys.exit(1) listener_file = os.getenv("PTVSD_ADAPTER_ENDPOINTS") if listener_file is not None: log.info("Writing endpoints info to {0!r}:\n{1!j}", listener_file, endpoints) def delete_listener_file(): log.info("Listener ports closed; deleting {0!r}", listener_file) try: os.remove(listener_file) except Exception: log.exception("Failed to delete {0!r}", listener_file, level="warning") try: with open(listener_file, "w") as f: atexit.register(delete_listener_file) print(json.dumps(endpoints), file=f) except Exception: raise log.exception("Error writing endpoints info to file:") if args.port is None: ide.IDE("stdio") # These must be registered after the one above, to ensure that the listener sockets # are closed before the endpoint info file is deleted - this way, another process # can wait for the file to go away as a signal that the ports are no longer in use. atexit.register(servers.stop_listening) atexit.register(ide.stop_listening) servers.wait_until_disconnected() log.info( "All debug servers disconnected; waiting for remaining sessions...") sessions.wait_until_ended() log.info("All debug sessions have ended; exiting.")
def main(args): from ptvsd import adapter from ptvsd.common import compat, log from ptvsd.adapter import ide, servers, sessions if args.log_stderr: log.stderr.levels |= set(log.LEVELS) if args.log_dir is not None: log.log_dir = args.log_dir log.to_file(prefix="ptvsd.adapter") log.describe_environment("ptvsd.adapter startup environment:") if args.for_server and args.port is None: log.error("--for-server requires --port") sys.exit(64) servers.access_token = args.server_access_token if not args.for_server: adapter.access_token = compat.force_str( codecs.encode(os.urandom(32), "hex")) server_host, server_port = servers.listen() ide_host, ide_port = ide.listen(port=args.port) endpoints_info = { "ide": { "host": ide_host, "port": ide_port }, "server": { "host": server_host, "port": server_port }, } if args.for_server: log.info("Writing endpoints info to stdout:\n{0!r}", endpoints_info) print(json.dumps(endpoints_info)) sys.stdout.flush() if args.port is None: ide.IDE("stdio") listener_file = os.getenv("PTVSD_ADAPTER_ENDPOINTS") if listener_file is not None: log.info("Writing endpoints info to {0!r}:\n{1!r}", listener_file, endpoints_info) def delete_listener_file(): log.info("Listener ports closed; deleting {0!r}", listener_file) try: os.remove(listener_file) except Exception: log.exception("Failed to delete {0!r}", listener_file, level="warning") with open(listener_file, "w") as f: atexit.register(delete_listener_file) print(json.dumps(endpoints_info), file=f) # These must be registered after the one above, to ensure that the listener sockets # are closed before the endpoint info file is deleted - this way, another process # can wait for the file to go away as a signal that the ports are no longer in use. atexit.register(servers.stop_listening) atexit.register(ide.stop_listening) servers.wait_until_disconnected() log.info( "All debug servers disconnected; waiting for remaining sessions...") sessions.wait_until_ended() log.info("All debug sessions have ended; exiting.")