def __init__(self, component, message):
"""Parses an "initialize" request or response and extracts the feature flags.
For every "X" in self.PROPERTIES, sets self["X"] to the corresponding value
from message.payload if it's present there, or to the default value otherwise.
"""
assert message.is_request("initialize") or message.is_response(
"initialize")
self.component = component
payload = message.payload
for name, validate in self.PROPERTIES.items():
value = payload.get(name, ())
if not callable(validate):
validate = json.default(validate)
try:
value = validate(value)
except Exception as exc:
raise message.isnt_valid("{0!j} {1}", name, exc)
assert value != (), fmt(
"{0!j} must provide a default value for missing properties.",
validate)
self[name] = value
log.debug("{0}", self)
def debug(address, log_dir=None, multiprocess=True):
if log_dir:
log.log_dir = log_dir
log.to_file(prefix="ptvsd.server")
log.describe_environment("ptvsd.server debug start environment:")
log.debug("{0}{1!r}", func.__name__, (address, log_dir, multiprocess))
if is_attached():
log.info("{0}() ignored - already attached.", func.__name__)
return options.host, options.port
# Ensure port is int
if address is not options:
host, port = address
options.host, options.port = (host, int(port))
if multiprocess is not options:
options.multiprocess = multiprocess
ptvsd_path, _, _ = get_abs_path_real_path_and_base_from_file(ptvsd.__file__)
ptvsd_path = os.path.dirname(ptvsd_path)
start_patterns = (ptvsd_path,)
end_patterns = ("ptvsd_launcher.py",)
log.info(
"Won't trace filenames starting with: {0!j}\n"
"Won't trace filenames ending with: {1!j}",
start_patterns,
end_patterns,
)
try:
return func(start_patterns, end_patterns)
except Exception:
raise log.exception("{0}() failed:", func.__name__, level="info")
def _propagate_deferred_events(self):
log.debug("Propagating deferred events to {0}...", self.ide)
for event in self._deferred_events:
log.debug("Propagating deferred {0}", event.describe())
self.ide.channel.propagate(event)
log.info("All deferred events propagated to {0}.", self.ide)
self._deferred_events = None
def close(self):
sock = self._socket
if sock:
self._socket = None
log.debug("Closing {0} client socket...", self)
try:
sock.shutdown(socket.SHUT_RDWR)
except Exception:
pass
try:
sock.close()
except Exception:
pass
server_socket = self._server_socket
if server_socket:
self._server_socket = None
log.debug("Closing {0} server socket...", self)
try:
server_socket.shutdown(socket.SHUT_RDWR)
except Exception:
pass
try:
server_socket.close()
except Exception:
pass
def test_targets(target_kind, client, wait, subprocesses, extra):
args = ["--host", "localhost", "--port", "8888"]
if client:
args += ["--client"]
if wait:
args += ["--wait"]
if not subprocesses:
args += ["--no-subprocesses"]
if target_kind == "file":
target = "spam.py"
args += [target]
elif target_kind == "module":
target = "spam"
args += ["-m", target]
elif target_kind == "code":
target = "123"
args += ["-c", target]
else:
pytest.fail(target_kind)
if extra:
extra = [
"ham",
"--client",
"--wait",
"-y",
"spam",
"--",
"--host",
"--port",
"-c",
"--something",
"-m",
]
args += extra
else:
extra = []
log.debug("args = {0!r}", args)
reload(options)
rest = list(cli.parse(args))
assert rest == extra
expected_options = {
"target_kind": target_kind,
"target": target,
"host": "localhost",
"port": 8888,
"wait": bool(wait),
"multiprocess": bool(subprocesses),
}
actual_options = {name: vars(options)[name] for name in expected_options}
assert expected_options == actual_options
def enabled(filename):
os.environ["PYDEVD_DEBUG"] = "True"
os.environ["PYDEVD_DEBUG_FILE"] = filename
log.debug("pydevd log will be at {0}", filename)
try:
yield
finally:
del os.environ["PYDEVD_DEBUG"]
del os.environ["PYDEVD_DEBUG_FILE"]
def wait_for_attach():
log.debug("wait_for_attach()")
dbg = get_global_debugger()
if dbg is None:
raise RuntimeError("wait_for_attach() called before enable_attach()")
cancel_event = threading.Event()
ptvsd.wait_for_attach.cancel = wait_for_attach.cancel = cancel_event.set
pydevd._wait_for_attach(cancel=cancel_event)
def propagate_after_start(self, event):
# pydevd starts sending events as soon as we connect, but the IDE doesn't
# expect to see any until it receives the response to "launch" or "attach"
# request. If IDE is not ready yet, save the event instead of propagating
# it immediately.
if self._deferred_events is not None:
self._deferred_events.append(event)
log.debug("Propagation deferred.")
else:
self.ide.channel.propagate(event)
def wait(self, timeout=None):
"""Wait for all remaining output to be captured.
"""
if not self._worker_threads:
return
log.debug("Waiting for remaining {0} output...",
self.session.debuggee_id)
for t in self._worker_threads:
t.join(timeout)
self._worker_threads[:] = []
def setup_debug_server(argv_0):
# We need to set up sys.argv[0] before invoking attach() or enable_attach(),
# because they use it to report the "process" event. Thus, we can't rely on
# run_path() and run_module() doing that, even though they will eventually.
sys.argv[0] = compat.filename(argv_0)
log.debug("sys.argv after patching: {0!r}", sys.argv)
debug = ptvsd.attach if options.client else ptvsd.enable_attach
debug(address=options, multiprocess=options)
if options.wait:
ptvsd.wait_for_attach()
def run_file():
setup_debug_server(options.target)
# run_path has one difference with invoking Python from command-line:
# if the target is a file (rather than a directory), it does not add its
# parent directory to sys.path. Thus, importing other modules from the
# same directory is broken unless sys.path is patched here.
if os.path.isfile(options.target):
dir = os.path.dirname(options.target)
sys.path.insert(0, dir)
else:
log.debug("Not a file: {0!j}", options.target)
log.describe_environment("Pre-launch environment:")
log.info("Running file {0!j}", options.target)
runpy.run_path(options.target, run_name="__main__")
def close(self):
if self._socket:
log.debug("Closing {0} socket of {1}...", self, self.session)
try:
self._socket.shutdown(socket.SHUT_RDWR)
except Exception:
pass
self._socket = None
if self._server_socket:
log.debug("Closing {0} server socket of {1}...", self,
self.session)
try:
self._server_socket.shutdown(socket.SHUT_RDWR)
except Exception:
pass
self._server_socket = None
def _wait_for_user_input():
if sys.stdout and sys.stdin:
from ptvsd.common import log
can_getch = sys.stdin.isatty()
if can_getch:
try:
import msvcrt
except ImportError:
can_getch = False
if can_getch:
log.debug("msvcrt available - waiting for user input via getch()")
sys.stdout.write("Press any key to continue . . . ")
sys.stdout.flush()
msvcrt.getch()
else:
log.debug("msvcrt not available - waiting for user input via read()")
sys.stdout.write("Press Enter to continue . . . ")
sys.stdout.flush()
sys.stdin.read(1)
def break_into_debugger():
log.debug("break_into_debugger()")
if not is_attached():
log.info("break_into_debugger() ignored - debugger not attached")
return
# Get the first frame in the stack that's not an internal frame.
global_debugger = get_global_debugger()
stop_at_frame = sys._getframe().f_back
while (stop_at_frame is not None
and global_debugger.get_file_type(stop_at_frame)
== global_debugger.PYDEV_FILE):
stop_at_frame = stop_at_frame.f_back
_settrace(
suspend=True,
trace_only_current_thread=True,
patch_multiprocessing=False,
stop_at_frame=stop_at_frame,
)
stop_at_frame = None
def parse(args):
log.debug("Parsing argv: {0!r}", args)
try:
output = subprocess.check_output(
[sys.executable, "-u", cli_parser.strpath] + args)
argv, options = pickle.loads(output)
except subprocess.CalledProcessError as exc:
raise pickle.loads(exc.output)
log.debug("Adjusted sys.argv: {0!r}", argv)
log.debug("Parsed options: {0!r}", options)
return argv, options
def worker():
messages = MessageFactory()
worker_can_proceed.wait()
worker_can_proceed.clear()
timeline.record_event(messages.event("dum", {}))
log.debug("dum")
worker_can_proceed.wait()
timeline.record_event(messages.event("dee", {}))
log.debug("dee")
timeline.record_event(messages.event("dum", {}))
log.debug("dum")
def _log_message(self, dir, data):
format_string = "{0} {1} " + ("{2!j:indent=None}" if isinstance(
data, list) else "{2!j}")
return log.debug(format_string, self.name, dir, data)
def debug_this_thread():
log.debug("debug_this_thread()")
_settrace(suspend=False)
def _settrace(*args, **kwargs):
log.debug("pydevd.settrace(*{0!r}, **{1!r})", args, kwargs)
return pydevd.settrace(*args, **kwargs)
