def _handle_subprocess(n, stream):
class Handlers(object):
_pid = None
def ptvsd_subprocess_request(self, request):
# When child process is spawned, the notification it sends only
# contains information about itself and its immediate parent.
# Add information about the root process before passing it on.
arguments = dict(request.arguments)
arguments.update({
'rootProcessId': os.getpid(),
'rootStartRequest': root_start_request,
})
self._pid = arguments['processId']
with subprocess_lock:
subprocesses[self._pid] = channel
debug('ptvsd_subprocess: %r' % arguments)
response = {'incomingConnection': False}
subprocess_queue.put((arguments, response))
subprocess_queue.join()
return response
def disconnect(self):
if self._pid is not None:
with subprocess_lock:
subprocesses.pop(self._pid, None)
name = 'SubprocessListener-%d' % n
channel = JsonMessageChannel(stream, Handlers(), name)
channel.start()
def test_events(self):
EVENTS = [
{'seq': 1, 'type': 'event', 'event': 'stopped', 'body': {'reason': 'pause'}},
{'seq': 2, 'type': 'event', 'event': 'unknown', 'body': {'something': 'else'}},
]
events_received = []
class Handlers(object):
def stopped_event(self, channel, body):
events_received.append((channel, body))
def event(self, channel, event, body):
events_received.append((channel, event, body))
input, input_exhausted = self.iter_with_event(EVENTS)
stream = LoggingJsonStream(JsonMemoryStream(input, []))
channel = JsonMessageChannel(stream, Handlers())
channel.start()
input_exhausted.wait()
assert events_received == [
(channel, EVENTS[0]['body']),
(channel, 'unknown', EVENTS[1]['body']),
]
def _setup_channel(self):
self.stream = LoggingJsonStream(JsonIOStream.from_socket(self.socket),
'ptvsd#%d' % self.ptvsd_port)
handlers = MessageHandlers(request=self._process_request,
event=self._process_event)
self.channel = JsonMessageChannel(self.stream, handlers)
self.channel.start()
self.connected.set()
def prepare_to_run(self,
perform_handshake=True,
filename=None,
module=None):
"""Spawns ptvsd using the configured method, telling it to execute the
provided Python file or module, and establishes a message channel to it.
If perform_handshake is True, calls self.handshake() before returning.
"""
argv = [sys.executable]
if self.method != 'attach_pid':
argv += ['-m', 'ptvsd']
if self.method == 'attach_socket':
if self.ptvsd_port is None:
self.ptvsd_port = 5678
argv += ['--port', str(self.ptvsd_port)]
else:
port = self._listen()
argv += ['--host', 'localhost', '--port', str(port)]
if filename:
assert not module
argv += [filename]
elif module:
assert not filename
argv += ['-m', module]
env = os.environ.copy()
env.update({'PYTHONPATH': PTVSD_SYS_PATH})
print('Spawning %r' % argv)
self.process = subprocess.Popen(argv, env=env, stdin=subprocess.PIPE)
if self.ptvsd_port:
# ptvsd will take some time to spawn and start listening on the port,
# so just hammer at it until it responds (or we time out).
while not self.socket:
try:
self._connect()
except socket.error:
pass
time.sleep(0.1)
else:
self.connected.wait()
assert self.socket
self.stream = LoggingJsonStream(JsonIOStream.from_socket(self.socket))
handlers = MessageHandlers(request=self._process_request,
event=self._process_event)
self.channel = JsonMessageChannel(self.stream, handlers)
self.channel.start()
if perform_handshake:
self.handshake()
def test_responses(self):
request1_sent = threading.Event()
request2_sent = threading.Event()
request3_sent = threading.Event()
def iter_responses():
request1_sent.wait()
yield {'seq': 1, 'type': 'response', 'request_seq': 1, 'command': 'next', 'success': True, 'body': {'threadId': 3}}
request2_sent.wait()
yield {'seq': 2, 'type': 'response', 'request_seq': 2, 'command': 'pause', 'success': False, 'message': 'pause error'}
request3_sent.wait()
yield {'seq': 3, 'type': 'response', 'request_seq': 3, 'command': 'next', 'success': True, 'body': {'threadId': 5}}
stream = LoggingJsonStream(JsonMemoryStream(iter_responses(), []))
channel = JsonMessageChannel(stream, None)
channel.start()
# Blocking wait.
request1 = channel.send_request('next')
request1_sent.set()
response1 = request1.wait_for_response()
assert response1 == Response(True, 'next', body={'threadId': 3})
# Async callback, registered before response is received.
request2 = channel.send_request('pause')
response2 = [None]
response2_received = threading.Event()
def response2_handler(response):
response2[0] = response
response2_received.set()
request2.on_response(response2_handler)
request2_sent.set()
response2_received.wait()
assert response2[0] == Response(False, 'pause', error_message='pause error')
# Async callback, registered after response is received.
request3 = channel.send_request('next')
request3_sent.set()
request3.wait_for_response()
response3 = [None]
response3_received = threading.Event()
def response3_handler(response):
response3[0] = response
response3_received.set()
request3.on_response(response3_handler)
response3_received.wait()
assert response3[0] == Response(True, 'next', body={'threadId': 5})
def notify_root(port):
assert options.subprocess_of
debug('Subprocess %d notifying root process at port %d' %
(os.getpid(), options.subprocess_notify))
conn = create_client()
conn.connect(('localhost', options.subprocess_notify))
stream = JsonIOStream.from_socket(conn)
channel = JsonMessageChannel(stream)
channel.start()
# Send the notification about ourselves to root, and wait for it to tell us
# whether an incoming connection is anticipated. This will be true if root
# had successfully propagated the notification to the IDE, and false if it
# couldn't do so (e.g. because the IDE is not attached). There's also the
# possibility that connection to root will just drop, e.g. if it crashes -
# in that case, just exit immediately.
request = channel.send_request(
'ptvsd_subprocess', {
'parentProcessId': options.subprocess_of,
'processId': os.getpid(),
'port': port,
})
try:
response = request.wait_for_response()
except Exception:
print('Failed to send subprocess notification; exiting',
file=sys.__stderr__)
traceback.print_exc()
sys.exit(0)
# Keep the channel open until we exit - root process uses open channels to keep
# track of which subprocesses are alive and which are not.
atexit.register(lambda: channel.close())
if not response['incomingConnection']:
debugger = get_global_debugger()
while debugger is None:
time.sleep(0.1)
debugger = get_global_debugger()
debugger.ready_to_run = True
def test_requests(self):
REQUESTS = [
{'seq': 1, 'type': 'request', 'command': 'next', 'arguments': {'threadId': 3}},
{'seq': 2, 'type': 'request', 'command': 'unknown', 'arguments': {'answer': 42}},
{'seq': 3, 'type': 'request', 'command': 'pause', 'arguments': {'threadId': 5}},
]
requests_received = []
class Handlers(object):
def next_request(self, request):
assert request.command == 'next'
requests_received.append((request.channel, request.arguments))
return {'threadId': 7}
def request(self, request):
requests_received.append((request.channel, request.command, request.arguments))
def pause_request(self, request):
assert request.command == 'pause'
requests_received.append((request.channel, request.arguments))
raise RequestFailure('pause error')
input, input_exhausted = self.iter_with_event(REQUESTS)
output = []
stream = LoggingJsonStream(JsonMemoryStream(input, output))
channel = JsonMessageChannel(stream, Handlers())
channel.start()
input_exhausted.wait()
assert requests_received == [
(channel, REQUESTS[0]['arguments']),
(channel, 'unknown', REQUESTS[1]['arguments']),
(channel, REQUESTS[2]['arguments']),
]
assert output == [
{'seq': 1, 'type': 'response', 'request_seq': 1, 'command': 'next', 'success': True, 'body': {'threadId': 7}},
{'seq': 2, 'type': 'response', 'request_seq': 2, 'command': 'unknown', 'success': True},
{'seq': 3, 'type': 'response', 'request_seq': 3, 'command': 'pause', 'success': False, 'message': 'pause error'},
]
def test_fuzz(self):
# Set up two channels over the same stream that send messages to each other
# asynchronously, and record everything that they send and receive.
# All records should match at the end.
class Fuzzer(object):
def __init__(self, name):
self.name = name
self.lock = threading.Lock()
self.sent = []
self.received = []
self.responses_sent = []
self.responses_received = []
def start(self, channel):
self._worker = threading.Thread(name=self.name, target=lambda: self._send_requests_and_events(channel))
self._worker.daemon = True
self._worker.start()
def wait(self):
self._worker.join()
def fizz_event(self, channel, body):
with self.lock:
self.received.append(('event', 'fizz', body))
def buzz_event(self, channel, body):
with self.lock:
self.received.append(('event', 'buzz', body))
def event(self, channel, event, body):
with self.lock:
self.received.append(('event', event, body))
def make_and_log_response(self, command):
x = random.randint(-100, 100)
if x >= 0:
response = Response(True, command, body=x)
else:
response = Response(False, command, error_message=str(x))
with self.lock:
self.responses_sent.append(response)
if response.success:
return x
else:
raise RuntimeError(response.error_message)
def fizz_request(self, channel, arguments):
with self.lock:
self.received.append(('request', 'fizz', arguments))
return self.make_and_log_response('fizz')
def buzz_request(self, channel, arguments):
with self.lock:
self.received.append(('request', 'buzz', arguments))
return self.make_and_log_response('buzz')
def request(self, channel, command, arguments):
with self.lock:
self.received.append(('request', command, arguments))
return self.make_and_log_response(command)
def _send_requests_and_events(self, channel):
pending_requests = [0]
for _ in range(0, 100):
typ = random.choice(('event', 'request'))
name = random.choice(('fizz', 'buzz', 'fizzbuzz'))
body = random.randint(0, 100)
with self.lock:
self.sent.append((typ, name, body))
if typ == 'event':
channel.send_event(name, body)
elif typ == 'request':
with self.lock:
pending_requests[0] += 1
req = channel.send_request(name, body)
def response_handler(response):
with self.lock:
self.responses_received.append(response)
pending_requests[0] -= 1
req.on_response(response_handler)
# Spin until we get responses to all requests.
while True:
with self.lock:
if pending_requests[0] == 0:
break
time.sleep(0.1)
fuzzer1 = Fuzzer('fuzzer1')
fuzzer2 = Fuzzer('fuzzer2')
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 0))
_, port = server_socket.getsockname()
server_socket.listen(0)
socket1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket1_thread = threading.Thread(target=lambda: socket1.connect(('localhost', port)))
socket1_thread.start()
socket2, _ = server_socket.accept()
socket1_thread.join()
try:
io1 = socket1.makefile('rwb', 0)
io2 = socket2.makefile('rwb', 0)
stream1 = LoggingJsonStream(JsonIOStream(io1, io1))
channel1 = JsonMessageChannel(stream1, fuzzer1)
channel1.start()
fuzzer1.start(channel1)
stream2 = LoggingJsonStream(JsonIOStream(io2, io2))
channel2 = JsonMessageChannel(stream2, fuzzer2)
channel2.start()
fuzzer2.start(channel2)
fuzzer1.wait()
fuzzer2.wait()
finally:
socket1.close()
socket2.close()
assert fuzzer1.sent == fuzzer2.received
assert fuzzer2.sent == fuzzer1.received
assert fuzzer1.responses_sent == fuzzer2.responses_received
assert fuzzer2.responses_sent == fuzzer1.responses_received
def test_responses(self):
request1_sent = threading.Event()
request2_sent = threading.Event()
request3_sent = threading.Event()
def iter_responses():
request1_sent.wait()
yield {
'seq': 1,
'type': 'response',
'request_seq': 1,
'command': 'next',
'success': True,
'body': {
'threadId': 3
}
}
request2_sent.wait()
yield {
'seq': 2,
'type': 'response',
'request_seq': 2,
'command': 'pause',
'success': False,
'message': 'pause error'
}
request3_sent.wait()
yield {
'seq': 3,
'type': 'response',
'request_seq': 3,
'command': 'next',
'success': True,
'body': {
'threadId': 5
}
}
stream = LoggingJsonStream(JsonMemoryStream(iter_responses(), []))
channel = JsonMessageChannel(stream, None)
channel.start()
# Blocking wait.
request1 = channel.send_request('next')
request1_sent.set()
response1_body = request1.wait_for_response()
response1 = request1.response
assert response1.success
assert response1.request is request1
assert response1.body == response1_body
assert response1.body == {'threadId': 3}
# Async callback, registered before response is received.
request2 = channel.send_request('pause')
response2 = []
response2_received = threading.Event()
def response2_handler(resp):
response2.append(resp)
response2_received.set()
request2.on_response(response2_handler)
request2_sent.set()
response2_received.wait()
response2, = response2
assert not response2.success
assert response2.request is request2
assert response2 is request2.response
assert response2.body == RequestFailure('pause error')
# Async callback, registered after response is received.
request3 = channel.send_request('next')
request3_sent.set()
request3.wait_for_response()
response3 = []
response3_received = threading.Event()
def response3_handler(resp):
response3.append(resp)
response3_received.set()
request3.on_response(response3_handler)
response3_received.wait()
response3, = response3
assert response3.success
assert response3.request is request3
assert response3 is request3.response
assert response3.body == {'threadId': 5}