def __init__(self, mainThread):
self.mainThread = mainThread
self.interruptable = False
self.exec_queue = _queue.Queue(0)
self.buffer = None
self.banner_shown = False
self.default_banner = ''
def __init__(self, mainThread, connect_status_queue=None):
self.mainThread = mainThread
self.interruptable = False
self.exec_queue = _queue.Queue(0)
self.buffer = None
self.banner_shown = False
self.connect_status_queue = connect_status_queue
self.mpl_modules_for_patching = {}
self.init_mpl_modules_for_patching()
def __init__(self, sock):
PyDBDaemonThread.__init__(self)
self.sock = sock
self.setName("pydevd.Writer")
self.cmdQueue = _queue.Queue()
if pydevd_vm_type.get_vm_type() == 'python':
self.timeout = 0
else:
self.timeout = 0.1
def __init__(self):
self.interruptable = False
self.exec_queue = _queue.Queue(0)
self.buffer = None
self.mpl_modules_for_patching = {}
self.init_mpl_modules_for_patching()
# `vars_lock` synchronizes commands which modify and read variables values. It's needed, because we call
# `getFrame()` and `add_exec()` from different threads, which can lead to incorrect variables presentation in UI
self.vars_lock = threading.Lock()
def __init__(self, mainThread):
self.mainThread = mainThread
self.interruptable = False
self.exec_queue = _queue.Queue(0)
self.buffer = None
def __init__(self):
self.interruptable = False
self.exec_queue = _queue.Queue(0)
self.buffer = None
self.mpl_modules_for_patching = {}
self.init_mpl_modules_for_patching()
def console_setup(tmpdir):
server_queue = queue.Queue()
def notify_finished(more):
server_queue.put(('notify_finished', more))
return ''
class ConsoleRunner(DebuggerRunnerSimple):
@overrides(DebuggerRunnerSimple.add_command_line_args)
def add_command_line_args(self, args):
port, client_port = get_socket_names(2, close=True)
args.extend((writer.get_pydevconsole_file(), str(port[1]),
str(client_port[1])))
self.port = port
self.client_port = client_port
server = SimpleXMLRPCServer(client_port)
server.register_function(notify_finished, "NotifyFinished")
start_in_daemon_thread(server.serve_forever, [])
self.proxy = xmlrpclib.ServerProxy("http://%s:%s/" % port)
return args
class WriterThread(AbstractWriterThread):
if IS_JYTHON:
EXPECTED_RETURNCODE = 'any'
@overrides(AbstractWriterThread.additional_output_checks)
def additional_output_checks(self, stdout, stderr):
print('output found: %s - %s' % (stdout, stderr))
@overrides(AbstractWriterThread.write_dump_threads)
def write_dump_threads(self):
pass # no-op (may be called on timeout).
def execute_line(self, command, more=False):
runner.proxy.execLine(command)
assert server_queue.get(timeout=5.) == ('notify_finished', more)
def hello(self):
def _hello():
try:
msg = runner.proxy.hello('ignored')
if msg is not None:
if isinstance(msg, (list, tuple)):
msg = next(iter(msg))
if msg.lower().startswith('hello'):
return True
except:
# That's ok, communication still not ready.
pass
return False
wait_for_condition(_hello)
def close(self):
try:
runner.proxy.close()
except:
# Ignore any errors on close.
pass
def connect_to_debugger(self, debugger_port):
runner.proxy.connectToDebugger(debugger_port)
runner = ConsoleRunner(tmpdir)
writer = WriterThread()
class CaseSetup(object):
@contextmanager
def check_console(self, **kwargs):
for key, value in kwargs.items():
assert hasattr(WriterThread, key)
setattr(WriterThread, key, value)
self.writer = writer
args = runner.get_command_line()
args = runner.add_command_line_args(args)
if SHOW_OTHER_DEBUG_INFO:
print('executing: %s' % (' '.join(args), ))
try:
with runner.run_process(args, writer) as dct_with_stdout_stder:
writer.get_stdout = lambda: ''.join(dct_with_stdout_stder[
'stdout'])
writer.get_stderr = lambda: ''.join(dct_with_stdout_stder[
'stderr'])
# Make sure communication is setup.
writer.hello()
yield writer
finally:
writer.log = []
stdout = dct_with_stdout_stder['stdout']
stderr = dct_with_stdout_stder['stderr']
writer.additional_output_checks(''.join(stdout), ''.join(stderr))
return CaseSetup()
