Miras1984

Initial commit

f770010 over 2 years ago

8.26 kB

# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See LICENSE in the project root
# for license information.

import argparse
import atexit
import codecs
import locale
import os
import sys

# WARNING: debugpy and submodules must not be imported on top level in this module,
# and should be imported locally inside main() instead.


def main(args):
    # If we're talking DAP over stdio, stderr is not guaranteed to be read from,
    # so disable it to avoid the pipe filling and locking up. This must be done
    # as early as possible, before the logging module starts writing to it.
    if args.port is None:
        sys.stderr = stderr = open(os.devnull, "w")
        atexit.register(stderr.close)

    from debugpy import adapter
    from debugpy.common import json, log, sockets
    from debugpy.adapter import clients, 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).
            # NOTE: if process is already the session leader, then
            # setsid would fail with `operation not permitted`
            if os.getsid(os.getpid()) != os.getpid():
                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="debugpy.adapter")
    log.describe_environment("debugpy.adapter startup environment:")

    servers.access_token = args.server_access_token
    if args.for_server is None:
        adapter.access_token = codecs.encode(os.urandom(32), "hex").decode("ascii")

    endpoints = {}
    try:
        client_host, client_port = clients.serve(args.host, args.port)
    except Exception as exc:
        if args.for_server is None:
            raise
        endpoints = {"error": "Can't listen for client connections: " + str(exc)}
    else:
        endpoints["client"] = {"host": client_host, "port": client_port}

    if args.for_server is not None:
        try:
            server_host, server_port = servers.serve()
        except Exception as exc:
            endpoints = {"error": "Can't listen for server connections: " + str(exc)}
        else:
            endpoints["server"] = {"host": server_host, "port": server_port}

        log.info(
            "Sending endpoints info to debug server at localhost:{0}:\n{1}",
            args.for_server,
            json.repr(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:
            log.reraise_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("DEBUGPY_ADAPTER_ENDPOINTS")
    if listener_file is not None:
        log.info(
            "Writing endpoints info to {0!r}:\n{1}", listener_file, json.repr(endpoints)
        )

        def delete_listener_file():
            log.info("Listener ports closed; deleting {0!r}", listener_file)
            try:
                os.remove(listener_file)
            except Exception:
                log.swallow_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:
            log.reraise_exception("Error writing endpoints info to file:")

    if args.port is None:
        clients.Client("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_serving)
    atexit.register(clients.stop_serving)

    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 _parse_argv(argv):
    parser = argparse.ArgumentParser()

    parser.add_argument(
        "--for-server", type=int, metavar="PORT", help=argparse.SUPPRESS
    )

    parser.add_argument(
        "--port",
        type=int,
        default=None,
        metavar="PORT",
        help="start the adapter in debugServer mode on the specified port",
    )

    parser.add_argument(
        "--host",
        type=str,
        default="127.0.0.1",
        metavar="HOST",
        help="start the adapter in debugServer mode on the specified host",
    )

    parser.add_argument(
        "--access-token", type=str, help="access token expected from the server"
    )

    parser.add_argument(
        "--server-access-token", type=str, help="access token expected by the server"
    )

    parser.add_argument(
        "--log-dir",
        type=str,
        metavar="DIR",
        help="enable logging and use DIR to save adapter logs",
    )

    parser.add_argument(
        "--log-stderr", action="store_true", help="enable logging to stderr"
    )

    args = parser.parse_args(argv[1:])

    if args.port is None:
        if args.log_stderr:
            parser.error("--log-stderr requires --port")
        if args.for_server is not None:
            parser.error("--for-server requires --port")

    return args


if __name__ == "__main__":
    # debugpy can also be invoked directly rather than via -m. In this case, the first
    # entry on sys.path is the one added automatically by Python for the directory
    # containing this file. This means that import debugpy will not work, since we need
    # the parent directory of debugpy/ to be in sys.path, rather than debugpy/adapter/.
    #
    # The other issue is that many other absolute imports will break, because they
    # will be resolved relative to debugpy/adapter/ - e.g. `import state` will then try
    # to import debugpy/adapter/state.py.
    #
    # To fix both, we need to replace the automatically added entry such that it points
    # at parent directory of debugpy/ instead of debugpy/adapter, import debugpy with that
    # in sys.path, and then remove the first entry entry altogether, so that it doesn't
    # affect any further imports we might do. For example, suppose the user did:
    #
    #   python /foo/bar/debugpy/adapter ...
    #
    # At the beginning of this script, sys.path will contain "/foo/bar/debugpy/adapter"
    # as the first entry. What we want is to replace it with "/foo/bar', then import
    # debugpy with that in effect, and then remove the replaced entry before any more
    # code runs. The imported debugpy module will remain in sys.modules, and thus all
    # future imports of it or its submodules will resolve accordingly.
    if "debugpy" not in sys.modules:
        # Do not use dirname() to walk up - this can be a relative path, e.g. ".".
        sys.path[0] = sys.path[0] + "/../../"
        __import__("debugpy")
        del sys.path[0]

    # Apply OS-global and user-specific locale settings.
    try:
        locale.setlocale(locale.LC_ALL, "")
    except Exception:
        # On POSIX, locale is set via environment variables, and this can fail if
        # those variables reference a non-existing locale. Ignore and continue using
        # the default "C" locale if so.
        pass

    main(_parse_argv(sys.argv))

	# Copyright (c) Microsoft Corporation. All rights reserved.
	# Licensed under the MIT License. See LICENSE in the project root
	# for license information.

	import argparse
	import atexit
	import codecs
	import locale
	import os
	import sys

	# WARNING: debugpy and submodules must not be imported on top level in this module,
	# and should be imported locally inside main() instead.


	def main(args):
	# If we're talking DAP over stdio, stderr is not guaranteed to be read from,
	# so disable it to avoid the pipe filling and locking up. This must be done
	# as early as possible, before the logging module starts writing to it.
	if args.port is None:
	sys.stderr = stderr = open(os.devnull, "w")
	atexit.register(stderr.close)

	from debugpy import adapter
	from debugpy.common import json, log, sockets
	from debugpy.adapter import clients, 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).
	# NOTE: if process is already the session leader, then
	# setsid would fail with `operation not permitted`
	if os.getsid(os.getpid()) != os.getpid():
	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="debugpy.adapter")
	log.describe_environment("debugpy.adapter startup environment:")

	servers.access_token = args.server_access_token
	if args.for_server is None:
	adapter.access_token = codecs.encode(os.urandom(32), "hex").decode("ascii")

	endpoints = {}
	try:
	client_host, client_port = clients.serve(args.host, args.port)
	except Exception as exc:
	if args.for_server is None:
	raise
	endpoints = {"error": "Can't listen for client connections: " + str(exc)}
	else:
	endpoints["client"] = {"host": client_host, "port": client_port}

	if args.for_server is not None:
	try:
	server_host, server_port = servers.serve()
	except Exception as exc:
	endpoints = {"error": "Can't listen for server connections: " + str(exc)}
	else:
	endpoints["server"] = {"host": server_host, "port": server_port}

	log.info(
	"Sending endpoints info to debug server at localhost:{0}:\n{1}",
	args.for_server,
	json.repr(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:
	log.reraise_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("DEBUGPY_ADAPTER_ENDPOINTS")
	if listener_file is not None:
	log.info(
	"Writing endpoints info to {0!r}:\n{1}", listener_file, json.repr(endpoints)
	)

	def delete_listener_file():
	log.info("Listener ports closed; deleting {0!r}", listener_file)
	try:
	os.remove(listener_file)
	except Exception:
	log.swallow_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:
	log.reraise_exception("Error writing endpoints info to file:")

	if args.port is None:
	clients.Client("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_serving)
	atexit.register(clients.stop_serving)

	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 _parse_argv(argv):
	parser = argparse.ArgumentParser()

	parser.add_argument(
	"--for-server", type=int, metavar="PORT", help=argparse.SUPPRESS
	)

	parser.add_argument(
	"--port",
	type=int,
	default=None,
	metavar="PORT",
	help="start the adapter in debugServer mode on the specified port",
	)

	parser.add_argument(
	"--host",
	type=str,
	default="127.0.0.1",
	metavar="HOST",
	help="start the adapter in debugServer mode on the specified host",
	)

	parser.add_argument(
	"--access-token", type=str, help="access token expected from the server"
	)

	parser.add_argument(
	"--server-access-token", type=str, help="access token expected by the server"
	)

	parser.add_argument(
	"--log-dir",
	type=str,
	metavar="DIR",
	help="enable logging and use DIR to save adapter logs",
	)

	parser.add_argument(
	"--log-stderr", action="store_true", help="enable logging to stderr"
	)

	args = parser.parse_args(argv[1:])

	if args.port is None:
	if args.log_stderr:
	parser.error("--log-stderr requires --port")
	if args.for_server is not None:
	parser.error("--for-server requires --port")

	return args


	if __name__ == "__main__":
	# debugpy can also be invoked directly rather than via -m. In this case, the first
	# entry on sys.path is the one added automatically by Python for the directory
	# containing this file. This means that import debugpy will not work, since we need
	# the parent directory of debugpy/ to be in sys.path, rather than debugpy/adapter/.
	#
	# The other issue is that many other absolute imports will break, because they
	# will be resolved relative to debugpy/adapter/ - e.g. `import state` will then try
	# to import debugpy/adapter/state.py.
	#
	# To fix both, we need to replace the automatically added entry such that it points
	# at parent directory of debugpy/ instead of debugpy/adapter, import debugpy with that
	# in sys.path, and then remove the first entry entry altogether, so that it doesn't
	# affect any further imports we might do. For example, suppose the user did:
	#
	# python /foo/bar/debugpy/adapter ...
	#
	# At the beginning of this script, sys.path will contain "/foo/bar/debugpy/adapter"
	# as the first entry. What we want is to replace it with "/foo/bar', then import
	# debugpy with that in effect, and then remove the replaced entry before any more
	# code runs. The imported debugpy module will remain in sys.modules, and thus all
	# future imports of it or its submodules will resolve accordingly.
	if "debugpy" not in sys.modules:
	# Do not use dirname() to walk up - this can be a relative path, e.g. ".".
	sys.path[0] = sys.path[0] + "/../../"
	__import__("debugpy")
	del sys.path[0]

	# Apply OS-global and user-specific locale settings.
	try:
	locale.setlocale(locale.LC_ALL, "")
	except Exception:
	# On POSIX, locale is set via environment variables, and this can fail if
	# those variables reference a non-existing locale. Ignore and continue using
	# the default "C" locale if so.
	pass

	main(_parse_argv(sys.argv))