def test_server(self):
# Just making sure that the singleton is created in this thread.
try:
from _pydev_bundle.pydev_ipython_console_011 import get_pydev_frontend
except:
sys.stderr.write(
'Skipped test because IPython could not be imported.')
return
get_pydev_frontend(get_localhost(), 0)
client_port, server_port = self.get_free_addresses()
class ServerThread(threading.Thread):
def __init__(self, client_port, server_port):
threading.Thread.__init__(self)
self.client_port = client_port
self.server_port = server_port
def run(self):
from _pydev_bundle import pydev_localhost
print('Starting server with:', pydev_localhost.get_localhost(),
self.server_port, self.client_port)
pydevconsole.start_server(pydev_localhost.get_localhost(),
self.server_port, self.client_port)
server_thread = ServerThread(client_port, server_port)
server_thread.setDaemon(True)
server_thread.start()
client_thread = self.start_client_thread(client_port) #@UnusedVariable
try:
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
server = xmlrpclib.Server(
'http://%s:%s' %
(pydev_localhost.get_localhost(), server_port))
server.execLine(
"import sys; print('Running with: %s %s' % (sys.executable or sys.platform, sys.version))"
)
server.execLine('class Foo:')
server.execLine(' pass')
server.execLine('')
server.execLine('foo = Foo()')
server.execLine('a = %s()' % raw_input_name)
initial = time.time()
while not client_thread.requested_input:
if time.time() - initial > 2:
raise AssertionError(
'Did not get the return asked before the timeout.')
time.sleep(.1)
frame_xml = server.getFrame()
self.assert_('RequestInput' in frame_xml,
'Did not fid RequestInput in:\n%s' % (frame_xml, ))
finally:
client_thread.shutdown()
def test_server(self):
if os.environ.get('TRAVIS') == 'true':
# This test is too flaky on travis.
return
# Just making sure that the singleton is created in this thread.
try:
from _pydev_bundle.pydev_ipython_console_011 import get_pydev_frontend
except:
sys.stderr.write('Skipped test because IPython could not be imported.')
return
get_pydev_frontend(get_localhost(), 0)
client_port, server_port = self.get_free_addresses()
class ServerThread(threading.Thread):
def __init__(self, client_port, server_port):
threading.Thread.__init__(self)
self.client_port = client_port
self.server_port = server_port
def run(self):
from _pydev_bundle import pydev_localhost
print('Starting server with:', pydev_localhost.get_localhost(), self.server_port, self.client_port)
pydevconsole.start_server(pydev_localhost.get_localhost(), self.server_port, self.client_port)
server_thread = ServerThread(client_port, server_port)
server_thread.setDaemon(True)
server_thread.start()
client_thread = self.start_client_thread(client_port) #@UnusedVariable
try:
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), server_port))
server.execLine("import sys; print('Running with: %s %s' % (sys.executable or sys.platform, sys.version))")
server.execLine('class Foo:')
server.execLine(' pass')
server.execLine('')
server.execLine('foo = Foo()')
server.execLine('a = %s()' % raw_input_name)
initial = time.time()
while not client_thread.requested_input:
if time.time() - initial > 2:
raise AssertionError('Did not get the return asked before the timeout.')
time.sleep(.1)
frame_xml = server.getFrame()
self.assert_('RequestInput' in frame_xml, 'Did not fid RequestInput in:\n%s' % (frame_xml,))
finally:
client_thread.shutdown()
def start_socket(self, port=None):
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(socket_name)
self.port = socket_name[1]
s.listen(1)
if SHOW_WRITES_AND_READS:
print('Waiting in socket.accept()')
self.server_socket = s
new_sock, addr = s.accept()
if SHOW_WRITES_AND_READS:
print('Test Writer Thread Socket:', new_sock, addr)
reader_thread = self.reader_thread = ReaderThread(new_sock)
reader_thread.start()
self.sock = new_sock
self._sequence = -1
# initial command is always the version
self.write_version()
self.log.append('start_socket')
def do_connect_to_debugger():
try:
# Try to import the packages needed to attach the debugger
import pydevd
from _pydev_imps import _pydev_threading as threading
except:
# This happens on Jython embedded in host eclipse
traceback.print_exc()
sys.stderr.write('pydevd is not available, cannot connect\n',)
from _pydev_bundle import pydev_localhost
threading.currentThread().__pydevd_id__ = "console_main"
self.orig_find_frame = pydevd_vars.find_frame
pydevd_vars.find_frame = self._findFrame
self.debugger = pydevd.PyDB()
try:
self.debugger.connect(pydev_localhost.get_localhost(), debuggerPort)
self.debugger.prepare_to_run()
from _pydevd_bundle import pydevd_tracing
pydevd_tracing.SetTrace(None)
except:
traceback.print_exc()
sys.stderr.write('Failed to connect to target debugger.\n')
# Register to process commands when idle
self.debugrunning = False
try:
import pydevconsole
pydevconsole.set_debug_hook(self.debugger.process_internal_commands)
except:
traceback.print_exc()
sys.stderr.write('Version of Python does not support debuggable Interactive Console.\n')
def start_socket(self, port=None):
assert not hasattr(self, 'port'), 'Socket already initialized.'
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
self._sequence = -1
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(socket_name)
self.port = socket_name[1]
server_socket.listen(1)
if SHOW_WRITES_AND_READS:
print('Waiting in socket.accept()')
self.server_socket = server_socket
new_sock, addr = server_socket.accept()
if SHOW_WRITES_AND_READS:
print('Test Writer Thread Socket:', new_sock, addr)
reader_thread = self.reader_thread = ReaderThread(new_sock)
reader_thread.start()
self.sock = new_sock
# initial command is always the version
self.write_version()
self.log.append('start_socket')
self.finished_initialization = True
def start_socket(self, port=None):
assert not hasattr(self, 'port'), 'Socket already initialized.'
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
self._sequence = -1
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(socket_name)
self.port = socket_name[1]
server_socket.listen(1)
if SHOW_WRITES_AND_READS:
print('Waiting in socket.accept()')
self.server_socket = server_socket
new_sock, addr = server_socket.accept()
if SHOW_WRITES_AND_READS:
print('Test Writer Thread Socket:', new_sock, addr)
reader_thread = self.reader_thread = ReaderThread(new_sock)
reader_thread.start()
self.sock = new_sock
# initial command is always the version
self.write_version()
self.log.append('start_socket')
self.finished_initialization = True
def __init__(self):
self._sock_for_reader_thread = None
self._sock_for_fixture_test = None
self._socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._localhost = host = pydev_localhost.get_localhost()
self._socket_server.bind((host, 0))
self._socket_server.listen(1)
def __init__(self, tests_queue):
threading.Thread.__init__(self)
self.setDaemon(True)
self.queue = tests_queue
self.finished = False
from _pydev_bundle.pydev_imports import SimpleXMLRPCServer
# This is a hack to patch slow socket.getfqdn calls that
# BaseHTTPServer (and its subclasses) make.
# See: http://bugs.python.org/issue6085
# See: http://www.answermysearches.com/xmlrpc-server-slow-in-python-how-to-fix/2140/
try:
import BaseHTTPServer
def _bare_address_string(self):
host, port = self.client_address[:2]
return '%s' % host
BaseHTTPServer.BaseHTTPRequestHandler.address_string = _bare_address_string
except:
pass
# End hack.
# Create server
from _pydev_bundle import pydev_localhost
server = SimpleXMLRPCServer((pydev_localhost.get_localhost(), 0),
logRequests=False)
server.register_function(self.GetTestsToRun)
server.register_function(self.notifyStartTest)
server.register_function(self.notifyTest)
server.register_function(self.notifyCommands)
self.port = server.socket.getsockname()[1]
self.server = server
def start_socket(self, port=None):
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(socket_name)
self.port = socket_name[1]
s.listen(1)
if SHOW_WRITES_AND_READS:
print('Waiting in socket.accept()')
self.server_socket = s
newSock, addr = s.accept()
if SHOW_WRITES_AND_READS:
print('Test Writer Thread Socket:', newSock, addr)
reader_thread = self.reader_thread = ReaderThread(newSock)
reader_thread.start()
self.sock = newSock
self._sequence = -1
# initial command is always the version
self.write_version()
self.log.append('start_socket')
def __init__(self, notifications_queue, port, daemon=False):
threading.Thread.__init__(self)
self.setDaemon(
daemon
) # If False, wait for all the notifications to be passed before exiting!
self.finished = False
self.notifications_queue = notifications_queue
from _pydev_bundle import pydev_localhost
# It is necessary to specify an encoding, that matches
# the encoding of all bytes-strings passed into an
# XMLRPC call: "All 8-bit strings in the data structure are assumed to use the
# packet encoding. Unicode strings are automatically converted,
# where necessary."
# Byte strings most likely come from file names.
encoding = file_system_encoding
if encoding == "mbcs":
# Windos symbolic name for the system encoding CP_ACP.
# We need to convert it into a encoding that is recognized by Java.
# Unfortunately this is not always possible. You could use
# GetCPInfoEx and get a name similar to "windows-1251". Then
# you need a table to translate on a best effort basis. Much to complicated.
# ISO-8859-1 is good enough.
encoding = "ISO-8859-1"
self.server = xmlrpclib.Server('http://%s:%s' %
(pydev_localhost.get_localhost(), port),
encoding=encoding)
def test_console_hello(self):
self.original_stdout = sys.stdout
sys.stdout = pydevd_io.IOBuf()
try:
sys.stdout.encoding = sys.stdin.encoding
except AttributeError:
# In Python 3 encoding is not writable (whereas in Python 2 it doesn't exist).
pass
try:
client_port, _server_port = self.get_free_addresses()
client_thread = self.start_client_thread(
client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
interpreter = pydevconsole.InterpreterInterface(
pydev_localhost.get_localhost(), client_port,
threading.currentThread())
(result, ) = interpreter.hello("Hello pydevconsole")
self.assertEqual(result, "Hello eclipse")
finally:
sys.stdout = self.original_stdout
def attach_to_debugger(debugger_port):
ipython_shell = get_ipython()
if sys.platform not in ('darwin', 'win32'):
# temporarily disable Cython warnings on Linux
import os
os.environ['PYDEVD_USE_CYTHON'] = 'NO'
os.environ['PYDEVD_USE_FRAME_EVAL'] = 'NO'
import pydevd
from _pydev_bundle import pydev_localhost
debugger = pydevd.PyDB()
ipython_shell.debugger = debugger
try:
debugger.connect(pydev_localhost.get_localhost(), debugger_port)
debugger.prepare_to_run(enable_tracing_from_start=False)
except:
traceback.print_exc()
sys.stderr.write('Failed to connect to target debugger.\n')
# should be executed only once for kernel
if not hasattr(ipython_shell, "pydev_cell_info"):
ipython_shell.pydev_cell_info = DebugCellInfo()
patch_compile_cache(ipython_shell)
# save link in debugger for quick access
debugger.cell_info = ipython_shell.pydev_cell_info
debugger.cell_info.util_cell_names = {}
debugger.warn_once_map = {}
def __init__(self, tests_queue):
threading.Thread.__init__(self)
self.setDaemon(True)
self.queue = tests_queue
self.finished = False
from _pydev_bundle.pydev_imports import SimpleXMLRPCServer
# This is a hack to patch slow socket.getfqdn calls that
# BaseHTTPServer (and its subclasses) make.
# See: http://bugs.python.org/issue6085
# See: http://www.answermysearches.com/xmlrpc-server-slow-in-python-how-to-fix/2140/
try:
import BaseHTTPServer
def _bare_address_string(self):
host, port = self.client_address[:2]
return '%s' % host
BaseHTTPServer.BaseHTTPRequestHandler.address_string = _bare_address_string
except:
pass
# End hack.
# Create server
from _pydev_bundle import pydev_localhost
server = SimpleXMLRPCServer((pydev_localhost.get_localhost(), 0), logRequests=False)
server.register_function(self.GetTestsToRun)
server.register_function(self.notifyStartTest)
server.register_function(self.notifyTest)
server.register_function(self.notifyCommands)
self.port = server.socket.getsockname()[1]
self.server = server
def __init__(self, notifications_queue, port, daemon=False):
threading.Thread.__init__(self)
self.setDaemon(daemon) # If False, wait for all the notifications to be passed before exiting!
self.finished = False
self.notifications_queue = notifications_queue
from _pydev_bundle import pydev_localhost
# It is necessary to specify an encoding, that matches
# the encoding of all bytes-strings passed into an
# XMLRPC call: "All 8-bit strings in the data structure are assumed to use the
# packet encoding. Unicode strings are automatically converted,
# where necessary."
# Byte strings most likely come from file names.
encoding = file_system_encoding
if encoding == "mbcs":
# Windos symbolic name for the system encoding CP_ACP.
# We need to convert it into a encoding that is recognized by Java.
# Unfortunately this is not always possible. You could use
# GetCPInfoEx and get a name similar to "windows-1251". Then
# you need a table to translate on a best effort basis. Much to complicated.
# ISO-8859-1 is good enough.
encoding = "ISO-8859-1"
self.server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), port),
encoding=encoding)
def do_connect_to_debugger():
try:
# Try to import the packages needed to attach the debugger
import pydevd
from _pydev_imps._pydev_saved_modules import threading
except:
# This happens on Jython embedded in host eclipse
traceback.print_exc()
sys.stderr.write('pydevd is not available, cannot connect\n',)
from _pydev_bundle import pydev_localhost
threading.currentThread().__pydevd_id__ = "console_main"
self.orig_find_frame = pydevd_vars.find_frame
pydevd_vars.find_frame = self._findFrame
self.debugger = pydevd.PyDB()
try:
self.debugger.connect(pydev_localhost.get_localhost(), debuggerPort)
self.debugger.prepare_to_run()
import pydevd_tracing
pydevd_tracing.SetTrace(None)
except:
traceback.print_exc()
sys.stderr.write('Failed to connect to target debugger.\n')
# Register to process commands when idle
self.debugrunning = False
try:
import pydevconsole
pydevconsole.set_debug_hook(self.debugger.process_internal_commands)
except:
traceback.print_exc()
sys.stderr.write('Version of Python does not support debuggable Interactive Console.\n')
def setUp(self):
# PyDevFrontEnd depends on singleton in IPython, so you
# can't make multiple versions. So we reuse self.front_end for
# all the tests
self.front_end = get_pydev_frontend(get_localhost(), 0)
from pydev_ipython.inputhook import set_return_control_callback
set_return_control_callback(lambda:True)
self.front_end.clear_buffer()
def setUp(self):
# PyDevFrontEnd depends on singleton in IPython, so you
# can't make multiple versions. So we reuse self.front_end for
# all the tests
self.front_end = get_pydev_frontend(get_localhost(), 0)
from pydev_ipython.inputhook import set_return_control_callback
set_return_control_callback(lambda: True)
self.front_end.clear_buffer()
def test_server(self):
self.original_stdout = sys.stdout
sys.stdout = pydevd_io.IOBuf()
try:
client_port, server_port = self.get_free_addresses()
class ServerThread(threading.Thread):
def __init__(self, client_port, server_port):
threading.Thread.__init__(self)
self.client_port = client_port
self.server_port = server_port
def run(self):
from _pydev_bundle import pydev_localhost
pydevconsole.start_server(pydev_localhost.get_localhost(),
self.server_port,
self.client_port)
server_thread = ServerThread(client_port, server_port)
server_thread.setDaemon(True)
server_thread.start()
client_thread = self.start_client_thread(
client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
sys.stdout = pydevd_io.IOBuf()
from _pydev_bundle import pydev_localhost
server = xmlrpclib.Server(
'http://%s:%s' %
(pydev_localhost.get_localhost(), server_port))
server.execLine('class Foo:')
server.execLine(' pass')
server.execLine('')
server.execLine('foo = Foo()')
server.execLine('a = %s()' % (raw_input_name, ))
server.execLine('print (a)')
initial = time.time()
while not client_thread.requested_input:
if time.time() - initial > 2:
raise AssertionError(
'Did not get the return asked before the timeout.')
time.sleep(.1)
found = sys.stdout.getvalue()
while ['input_request'] != found.split():
found += sys.stdout.getvalue()
if time.time() - initial > 2:
break
time.sleep(.1)
self.assertEqual(['input_request'], found.split())
finally:
sys.stdout = self.original_stdout
def do_connect_to_debugger():
try:
# Try to import the packages needed to attach the debugger
import pydevd
from _pydev_imps._pydev_saved_modules import threading
except:
# This happens on Jython embedded in host eclipse
traceback.print_exc()
sys.stderr.write('pydevd is not available, cannot connect\n', )
from _pydevd_bundle.pydevd_constants import set_thread_id
from _pydev_bundle import pydev_localhost
set_thread_id(threading.currentThread(), "console_main")
VIRTUAL_FRAME_ID = "1" # matches PyStackFrameConsole.java
VIRTUAL_CONSOLE_ID = "console_main" # matches PyThreadConsole.java
f = FakeFrame()
f.f_back = None
f.f_globals = {
} # As globals=locals here, let's simply let it empty (and save a bit of network traffic).
f.f_locals = self.get_namespace()
self.debugger = pydevd.PyDB()
self.debugger.add_fake_frame(thread_id=VIRTUAL_CONSOLE_ID,
frame_id=VIRTUAL_FRAME_ID,
frame=f)
try:
pydevd.apply_debugger_options(debugger_options)
self.debugger.connect(pydev_localhost.get_localhost(),
debuggerPort)
self.debugger.prepare_to_run()
self.debugger.disable_tracing()
except:
traceback.print_exc()
sys.stderr.write('Failed to connect to target debugger.\n')
# Register to process commands when idle
self.debugrunning = False
try:
import pydevconsole
pydevconsole.set_debug_hook(
self.debugger.process_internal_commands)
except:
traceback.print_exc()
sys.stderr.write(
'Version of Python does not support debuggable Interactive Console.\n'
)
def add_command_line_args(self, args):
writer_thread = self.writer_thread
port = int(writer_thread.port)
localhost = pydev_localhost.get_localhost()
return args + [
writer_thread.get_pydevd_file(),
'--DEBUG_RECORD_SOCKET_READS',
'--qt-support',
'--client',
localhost,
'--port',
str(port),
'--file',
] + writer_thread.get_command_line_args()
return args
def add_command_line_args(self, args):
writer_thread = self.writer_thread
port = int(writer_thread.port)
localhost = pydev_localhost.get_localhost()
return args + [
writer_thread.get_pydevd_file(),
'--DEBUG_RECORD_SOCKET_READS',
'--qt-support',
'--client',
localhost,
'--port',
str(port),
'--file',
] + writer_thread.get_command_line_args()
return args
def test_server(self):
self.original_stdout = sys.stdout
sys.stdout = pydevd_io.IOBuf()
try:
client_port, server_port = self.get_free_addresses()
class ServerThread(threading.Thread):
def __init__(self, client_port, server_port):
threading.Thread.__init__(self)
self.client_port = client_port
self.server_port = server_port
def run(self):
from _pydev_bundle import pydev_localhost
pydevconsole.start_server(pydev_localhost.get_localhost(), self.server_port, self.client_port)
server_thread = ServerThread(client_port, server_port)
server_thread.setDaemon(True)
server_thread.start()
client_thread = self.start_client_thread(client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
sys.stdout = pydevd_io.IOBuf()
from _pydev_bundle import pydev_localhost
server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), server_port))
server.execLine('class Foo:')
server.execLine(' pass')
server.execLine('')
server.execLine('foo = Foo()')
server.execLine('a = %s()' % (raw_input_name,))
server.execLine('print (a)')
initial = time.time()
while not client_thread.requested_input:
if time.time() - initial > 2:
raise AssertionError('Did not get the return asked before the timeout.')
time.sleep(.1)
found = sys.stdout.getvalue()
while ['input_request'] != found.split():
found += sys.stdout.getvalue()
if time.time() - initial > 2:
break
time.sleep(.1)
self.assertEqual(['input_request'], found.split())
finally:
sys.stdout = self.original_stdout
def __init__(self, tests_queue):
threading.Thread.__init__(self)
self.daemon = True
self.queue = tests_queue
self.finished = False
from _pydev_bundle.pydev_imports import SimpleXMLRPCServer
from _pydev_bundle import pydev_localhost
# Create server
server = SimpleXMLRPCServer((pydev_localhost.get_localhost(), 0),
logRequests=False)
server.register_function(self.GetTestsToRun)
server.register_function(self.notifyStartTest)
server.register_function(self.notifyTest)
server.register_function(self.notifyCommands)
self.port = server.socket.getsockname()[1]
self.server = server
def run(self):
class HandleRequestInput:
def RequestInput(self):
called_RequestInput[0] = True
return '\n'
def IPythonEditor(self, name, line):
called_IPythonEditor[0] = (name, line)
return True
handle_request_input = HandleRequestInput()
from _pydev_bundle import pydev_localhost
self.client_server = client_server = SimpleXMLRPCServer(
(pydev_localhost.get_localhost(), self.client_port), logRequests=False)
client_server.register_function(handle_request_input.RequestInput)
client_server.register_function(handle_request_input.IPythonEditor)
client_server.serve_forever()
def run(self):
class HandleRequestInput:
def RequestInput(self):
client_thread.requested_input = True
return 'input_request'
def NotifyFinished(self, *args, **kwargs):
client_thread.notified_finished += 1
return 1
handle_request_input = HandleRequestInput()
from _pydev_bundle import pydev_localhost
client_server = SimpleXMLRPCServer((pydev_localhost.get_localhost(), self.client_port), logRequests=False)
client_server.register_function(handle_request_input.RequestInput)
client_server.register_function(handle_request_input.NotifyFinished)
client_server.serve_forever()
def test_console_hello(self):
self.original_stdout = sys.stdout
sys.stdout = StringIO()
try:
client_port, _server_port = self.get_free_addresses()
client_thread = self.start_client_thread(client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
interpreter = pydevconsole.InterpreterInterface(pydev_localhost.get_localhost(), client_port, threading.currentThread())
(result,) = interpreter.hello("Hello pydevconsole")
self.assertEqual(result, "Hello eclipse")
finally:
sys.stdout = self.original_stdout
def run(self):
class HandleRequestInput:
def RequestInput(self):
called_RequestInput[0] = True
return '\n'
def IPythonEditor(self, name, line):
called_IPythonEditor[0] = (name, line)
return True
handle_request_input = HandleRequestInput()
from _pydev_bundle import pydev_localhost
self.client_server = client_server = SimpleXMLRPCServer(
(pydev_localhost.get_localhost(), self.client_port), logRequests=False)
client_server.register_function(handle_request_input.RequestInput)
client_server.register_function(handle_request_input.IPythonEditor)
client_server.serve_forever()
def run(self):
class HandleRequestInput:
def RequestInput(self):
client_thread.requested_input = True
return 'RequestInput: OK'
def NotifyFinished(self, *args, **kwargs):
client_thread.notified_finished += 1
return 1
handle_request_input = HandleRequestInput()
from _pydev_bundle import pydev_localhost
self.client_server = client_server = SimpleXMLRPCServer((pydev_localhost.get_localhost(), self.client_port), logRequests=False)
client_server.register_function(handle_request_input.RequestInput)
client_server.register_function(handle_request_input.NotifyFinished)
client_server.serve_forever()
def start_client_thread(self):
from _pydev_bundle import pydev_localhost
enable_thrift_logging()
# here we start the test server
server_socket = start_rpc_server_and_make_client(pydev_localhost.get_localhost(), 0,
PythonConsoleFrontendService,
PythonConsoleBackendService,
create_server_handler_factory(self.create_frontend_handler()))
host, port = server_socket.getsockname()
import time
time.sleep(1)
rpc_client, _ = make_rpc_client(PythonConsoleFrontendService, host, port)
return rpc_client
def start_client_thread(self):
from _pydev_bundle import pydev_localhost
enable_thrift_logging()
# here we start the test server
server_socket = start_rpc_server_and_make_client(pydev_localhost.get_localhost(), 0,
PythonConsoleFrontendService,
PythonConsoleBackendService,
create_server_handler_factory(self.create_frontend_handler()))
host, port = server_socket.getsockname()
import time
time.sleep(1)
rpc_client, _ = make_rpc_client(PythonConsoleFrontendService, host, port)
return rpc_client
def test_console_hello(self):
self.original_stdout = sys.stdout
sys.stdout = StringIO()
try:
client_port, _server_port = self.get_free_addresses()
client_thread = self.start_client_thread(
client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
interpreter = pydevconsole.InterpreterInterface(
pydev_localhost.get_localhost(), client_port,
threading.currentThread())
(result, ) = interpreter.hello("Hello pydevconsole")
self.assertEqual(result, "Hello eclipse")
finally:
sys.stdout = self.original_stdout
def add_command_line_args(self, args):
writer_thread = self.writer_thread
port = int(writer_thread.port)
localhost = pydev_localhost.get_localhost()
ret = args + [
writer_thread.get_pydevd_file(),
'--DEBUG_RECORD_SOCKET_READS',
'--qt-support',
'--client',
localhost,
'--port',
str(port),
]
if writer_thread.IS_MODULE:
ret += ['--module']
ret = ret + ['--file'] + writer_thread.get_command_line_args()
return ret
def add_command_line_args(self, args):
writer_thread = self.writer_thread
port = int(writer_thread.port)
localhost = pydev_localhost.get_localhost()
ret = args + [
writer_thread.get_pydevd_file(),
'--DEBUG_RECORD_SOCKET_READS',
'--qt-support',
'--client',
localhost,
'--port',
str(port),
]
if writer_thread.IS_MODULE:
ret += ['--module']
ret = ret + ['--file'] + writer_thread.get_command_line_args()
return ret
def do_connect_to_debugger():
try:
# Try to import the packages needed to attach the debugger
import pydevd
from _pydev_imps._pydev_saved_modules import threading
except:
# This happens on Jython embedded in host eclipse
traceback.print_exc()
sys.stderr.write('pydevd is not available, cannot connect\n', )
from _pydevd_bundle.pydevd_constants import set_thread_id
from _pydev_bundle import pydev_localhost
set_thread_id(threading.currentThread(), "console_main")
VIRTUAL_FRAME_ID = "1" # matches PyStackFrameConsole.java
VIRTUAL_CONSOLE_ID = "console_main" # matches PyThreadConsole.java
f = FakeFrame()
f.f_back = None
f.f_globals = {} # As globals=locals here, let's simply let it empty (and save a bit of network traffic).
f.f_locals = self.get_namespace()
self.debugger = pydevd.PyDB()
self.debugger.add_fake_frame(thread_id=VIRTUAL_CONSOLE_ID, frame_id=VIRTUAL_FRAME_ID, frame=f)
try:
pydevd.apply_debugger_options(debugger_options)
self.debugger.connect(pydev_localhost.get_localhost(), debuggerPort)
self.debugger.prepare_to_run()
self.debugger.disable_tracing()
except:
traceback.print_exc()
sys.stderr.write('Failed to connect to target debugger.\n')
# Register to process commands when idle
self.debugrunning = False
try:
import pydevconsole
pydevconsole.set_debug_hook(self.debugger.process_internal_commands)
except:
traceback.print_exc()
sys.stderr.write('Version of Python does not support debuggable Interactive Console.\n')
def _create_socket(port=None):
if hasattr(_create_socket, '_used_ports'):
assert port not in _create_socket._used_ports, 'Socket already initialized.'
else:
_create_socket._used_ports = set()
if port is not None:
_create_socket._used_ports.add(port)
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(socket_name)
return sock
def add_command_line_args(self, args):
writer = self.writer
port = int(writer.port)
localhost = pydev_localhost.get_localhost()
ret = [
writer.get_pydevd_file(),
'--DEBUG_RECORD_SOCKET_READS',
'--qt-support',
'--client',
localhost,
'--port',
str(port),
]
if writer.IS_MODULE:
ret += ['--module']
ret += ['--file'] + writer.get_command_line_args()
ret = writer.update_command_line_args(ret) # Provide a hook for the writer
return args + ret
def add_command_line_args(self, args):
writer = self.writer
port = int(writer.port)
localhost = pydev_localhost.get_localhost()
ret = [
writer.get_pydevd_file(),
'--DEBUG_RECORD_SOCKET_READS',
'--qt-support',
'--client',
localhost,
'--port',
str(port),
]
if writer.IS_MODULE:
ret += ['--module']
ret += ['--file'] + writer.get_command_line_args()
ret = writer.update_command_line_args(ret) # Provide a hook for the writer
return args + ret
def test_console_hello(self):
self.original_stdout = sys.stdout
sys.stdout = pydevd_io.IOBuf()
try:
sys.stdout.encoding = sys.stdin.encoding
except AttributeError:
# In Python 3 encoding is not writable (whereas in Python 2 it doesn't exist).
pass
try:
client_port, _server_port = self.get_free_addresses()
client_thread = self.start_client_thread(client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
interpreter = pydevconsole.InterpreterInterface(pydev_localhost.get_localhost(), client_port, threading.currentThread())
(result,) = interpreter.hello("Hello pydevconsole")
self.assertEqual(result, "Hello eclipse")
finally:
sys.stdout = self.original_stdout
def start_socket(self, port=None):
assert not hasattr(self, 'port'), 'Socket already initialized.'
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
self._sequence = -1
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(socket_name)
self.port = socket_name[1]
server_socket.listen(1)
if SHOW_WRITES_AND_READS:
print('Waiting in socket.accept()')
self.server_socket = server_socket
new_socket, addr = server_socket.accept()
if SHOW_WRITES_AND_READS:
print('Test Writer Thread Socket:', new_socket, addr)
self._set_socket(new_socket)
def start_socket(self, port=None):
assert not hasattr(self, 'port'), 'Socket already initialized.'
from _pydev_bundle.pydev_localhost import get_socket_name
if SHOW_WRITES_AND_READS:
print('start_socket')
self._sequence = -1
if port is None:
socket_name = get_socket_name(close=True)
else:
socket_name = (pydev_localhost.get_localhost(), port)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(socket_name)
self.port = socket_name[1]
server_socket.listen(1)
if SHOW_WRITES_AND_READS:
print('Waiting in socket.accept()')
self.server_socket = server_socket
new_socket, addr = server_socket.accept()
if SHOW_WRITES_AND_READS:
print('Test Writer Thread Socket:', new_socket, addr)
self._set_socket(new_socket)
def test_console_requests(self):
self.original_stdout = sys.stdout
sys.stdout = pydevd_io.IOBuf()
try:
client_port, _server_port = self.get_free_addresses()
client_thread = self.start_client_thread(
client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
from _pydev_bundle.pydev_console_utils import CodeFragment
interpreter = pydevconsole.InterpreterInterface(
pydev_localhost.get_localhost(), client_port,
threading.currentThread())
sys.stdout = pydevd_io.IOBuf()
interpreter.add_exec(CodeFragment('class Foo:\n CONSTANT=1\n'))
interpreter.add_exec(CodeFragment('foo=Foo()'))
interpreter.add_exec(CodeFragment('foo.__doc__=None'))
interpreter.add_exec(
CodeFragment('val = %s()' % (raw_input_name, )))
interpreter.add_exec(CodeFragment('50'))
interpreter.add_exec(CodeFragment('print (val)'))
found = sys.stdout.getvalue().split()
try:
self.assertEqual(['50', 'input_request'], found)
except:
try:
self.assertEqual(['input_request'], found) #IPython
except:
self.assertEqual([u'50', u'input_request'],
found[1:]) # IPython 5.1
self.assertTrue(found[0].startswith(u'Out'))
comps = interpreter.getCompletions('foo.', 'foo.')
self.assert_(
('CONSTANT', '', '', '3') in comps or ('CONSTANT', '', '', '4') in comps, \
'Found: %s' % comps
)
comps = interpreter.getCompletions('"".', '"".')
self.assert_(
('__add__', 'x.__add__(y) <==> x+y', '', '3') in comps
or ('__add__', '', '', '4') in comps or
('__add__', 'x.__add__(y) <==> x+y\r\nx.__add__(y) <==> x+y',
'()', '2') in comps or
('__add__', 'x.\n__add__(y) <==> x+yx.\n__add__(y) <==> x+y',
'()', '2'), 'Did not find __add__ in : %s' % (comps, ))
completions = interpreter.getCompletions('', '')
for c in completions:
if c[0] == 'AssertionError':
break
else:
self.fail('Could not find AssertionError')
completions = interpreter.getCompletions('Assert', 'Assert')
for c in completions:
if c[0] == 'RuntimeError':
self.fail('Did not expect to find RuntimeError there')
self.assert_(
('__doc__', None, '',
'3') not in interpreter.getCompletions('foo.CO', 'foo.'))
comps = interpreter.getCompletions('va', 'va')
self.assert_(('val', '', '', '3') in comps
or ('val', '', '', '4') in comps)
interpreter.add_exec(CodeFragment('s = "mystring"'))
desc = interpreter.getDescription('val')
self.assert_(
desc.find('str(object) -> string') >= 0
or desc == "'input_request'"
or desc.find('str(string[, encoding[, errors]]) -> str') >= 0
or desc.find('str(Char* value)') >= 0
or desc.find('str(object=\'\') -> string') >= 0
or desc.find('str(value: Char*)') >= 0
or desc.find('str(object=\'\') -> str') >= 0,
'Could not find what was needed in %s' % desc)
desc = interpreter.getDescription('val.join')
self.assert_(
desc.find('S.join(sequence) -> string') >= 0
or desc.find('S.join(sequence) -> str') >= 0
or desc.find('S.join(iterable) -> string') >= 0
or desc == "<builtin method 'join'>"
or desc == "<built-in method join of str object>"
or desc.find('str join(str self, list sequence)') >= 0
or desc.find('S.join(iterable) -> str') >= 0
or desc.find('join(self: str, sequence: list) -> str') >= 0,
"Could not recognize: %s" % (desc, ))
finally:
sys.stdout = self.original_stdout
def run(self):
from _pydev_bundle import pydev_localhost
pydevconsole.start_server(pydev_localhost.get_localhost(),
self.server_port,
self.client_port)
def test_edit(self):
''' Make sure we can issue an edit command'''
called_RequestInput = [False]
called_IPythonEditor = [False]
def start_client_thread(client_port):
class ClientThread(threading.Thread):
def __init__(self, client_port):
threading.Thread.__init__(self)
self.client_port = client_port
def run(self):
class HandleRequestInput:
def RequestInput(self):
called_RequestInput[0] = True
return '\n'
def IPythonEditor(self, name, line):
called_IPythonEditor[0] = (name, line)
return True
handle_request_input = HandleRequestInput()
from _pydev_bundle import pydev_localhost
self.client_server = client_server = SimpleXMLRPCServer(
(pydev_localhost.get_localhost(), self.client_port), logRequests=False)
client_server.register_function(handle_request_input.RequestInput)
client_server.register_function(handle_request_input.IPythonEditor)
client_server.serve_forever()
def shutdown(self):
return
self.client_server.shutdown()
client_thread = ClientThread(client_port)
client_thread.setDaemon(True)
client_thread.start()
return client_thread
# PyDevFrontEnd depends on singleton in IPython, so you
# can't make multiple versions. So we reuse self.front_end for
# all the tests
s = socket.socket()
s.bind(('', 0))
self.client_port = client_port = s.getsockname()[1]
s.close()
self.front_end = get_pydev_frontend(get_localhost(), client_port)
client_thread = start_client_thread(self.client_port)
orig_stdin = sys.stdin
sys.stdin = StdIn(self, get_localhost(), self.client_port)
try:
filename = 'made_up_file.py'
self.add_exec('%edit ' + filename)
for i in xrange(10):
if called_IPythonEditor[0] == (os.path.abspath(filename), '0'):
break
time.sleep(.1)
if not called_IPythonEditor[0]:
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/interactiveshell.py", line 2883, in run_code
# exec(code_obj, self.user_global_ns, self.user_ns)
# File "<ipython-input-15-09583ca3bce1>", line 1, in <module>
# get_ipython().magic('edit made_up_file.py')
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/interactiveshell.py", line 2205, in magic
# return self.run_line_magic(magic_name, magic_arg_s)
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/interactiveshell.py", line 2126, in run_line_magic
# result = fn(*args,**kwargs)
# File "<string>", line 2, in edit
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/magic.py", line 193, in <lambda>
# call = lambda f, *a, **k: f(*a, **k)
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/magics/code.py", line 662, in edit
# self.shell.hooks.editor(filename,lineno)
# File "/home/travis/build/fabioz/PyDev.Debugger/pydev_ipython_console_011.py", line 70, in call_editor
# server.IPythonEditor(filename, str(line))
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1090, in __call__
# return self.__send(self.__name, args)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1419, in __request
# verbose=self.__verbose
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1132, in request
# return self.single_request(host, handler, request_body, verbose)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1143, in single_request
# http_conn = self.send_request(host, handler, request_body, verbose)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1255, in send_request
# self.send_content(connection, request_body)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1285, in send_content
# connection.endheaders(request_body)
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 1061, in endheaders
# self._send_output(message_body)
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 906, in _send_output
# self.send(msg)
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 844, in send
# self.connect()
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 822, in connect
# self.timeout, self.source_address)
# File "/home/travis/miniconda/lib/python3.3/socket.py", line 435, in create_connection
# raise err
# File "/home/travis/miniconda/lib/python3.3/socket.py", line 426, in create_connection
# sock.connect(sa)
# ConnectionRefusedError: [Errno 111] Connection refused
# I.e.: just warn that the test failing, don't actually fail.
sys.stderr.write('Test failed: this test is brittle in travis because sometimes the connection is refused (as above) and we do not have a callback.\n')
return
eq_(called_IPythonEditor[0], (os.path.abspath(filename), '0'))
assert called_RequestInput[0], "Make sure the 'wait' parameter has been respected"
finally:
sys.stdin = orig_stdin
client_thread.shutdown()
INFO1 = 1
INFO2 = 2
WARN = 4
ERROR = 8
DEBUG = INFO1 | ERROR
def dbg(s, prior):
if prior & DEBUG != 0:
sys.stdout.write('%s\n' % (s,))
# f = open('c:/temp/test.txt', 'a')
# print_ >> f, s
# f.close()
from _pydev_bundle import pydev_localhost
HOST = pydev_localhost.get_localhost() # Symbolic name meaning the local host
MSG_KILL_SERVER = '@@KILL_SERVER_END@@'
MSG_COMPLETIONS = '@@COMPLETIONS'
MSG_END = 'END@@'
MSG_INVALID_REQUEST = '@@INVALID_REQUEST'
MSG_JYTHON_INVALID_REQUEST = '@@JYTHON_INVALID_REQUEST'
MSG_CHANGE_DIR = '@@CHANGE_DIR:'
MSG_OK = '@@MSG_OK_END@@'
MSG_IMPORTS = '@@IMPORTS:'
MSG_PYTHONPATH = '@@PYTHONPATH_END@@'
MSG_CHANGE_PYTHONPATH = '@@CHANGE_PYTHONPATH:'
MSG_JEDI = '@@MSG_JEDI:'
MSG_SEARCH = '@@SEARCH'
BUFFER_SIZE = 1024
del sys.argv[1]
del sys.argv[1]
file = sys.argv[1]
del sys.argv[0]
from _pydev_bundle import pydev_localhost
if int(port) == 0 and int(client_port) == 0:
(h, p) = pydev_localhost.get_socket_name()
client_port = p
host = pydev_localhost.get_localhost()
#replace exit (see comments on method)
#note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = do_exit
interpreter = InterpreterInterface(host, int(client_port),
threading.currentThread())
server_thread = threading.Thread(target=start_console_server,
name='ServerThread',
args=(host, int(port), interpreter))
server_thread.setDaemon(True)
server_thread.start()
globals = run_file(file, None, None)
import subprocess
import sys
import os
import _debugger_case_remote_2
port = int(sys.argv[1])
root_dirname = os.path.dirname(os.path.dirname(__file__))
if root_dirname not in sys.path:
sys.path.append(root_dirname)
import pydevd
print('before pydevd.settrace')
sys.stdout.flush()
from _pydev_bundle import pydev_localhost
pydevd.settrace(host=pydev_localhost.get_localhost(),
port=port,
patch_multiprocessing=True)
print('after pydevd.settrace')
sys.stdout.flush()
f = _debugger_case_remote_2.__file__
if f.endswith('.pyc'):
f = f[:-1]
elif f.endswith('$py.class'):
f = f[:-len('$py.class')] + '.py'
print('before call')
sys.stdout.flush()
subprocess.check_call([sys.executable, '-u', f])
print('after call')
sys.stdout.flush()
def run_client(job_id, port, verbosity, coverage_output_file, coverage_include):
job_id = int(job_id)
from _pydev_bundle import pydev_localhost
server = xmlrpclib.Server('http://%s:%s' % (pydev_localhost.get_localhost(), port))
server.lock = threading.Lock()
server_comm = ServerComm(job_id, server)
server_comm.start()
try:
server_facade = ServerFacade(server_comm.notifications_queue)
from _pydev_runfiles import pydev_runfiles
from _pydev_runfiles import pydev_runfiles_xml_rpc
pydev_runfiles_xml_rpc.set_server(server_facade)
#Starts None and when the 1st test is gotten, it's started (because a server may be initiated and terminated
#before receiving any test -- which would mean a different process got all the tests to run).
coverage = None
try:
tests_to_run = [1]
while tests_to_run:
#Investigate: is it dangerous to use the same xmlrpclib server from different threads?
#It seems it should be, as it creates a new connection for each request...
server.lock.acquire()
try:
tests_to_run = server.GetTestsToRun(job_id)
finally:
server.lock.release()
if not tests_to_run:
break
if coverage is None:
_coverage_files, coverage = start_coverage_support_from_params(
None, coverage_output_file, 1, coverage_include)
files_to_tests = {}
for test in tests_to_run:
filename_and_test = test.split('|')
if len(filename_and_test) == 2:
files_to_tests.setdefault(filename_and_test[0], []).append(filename_and_test[1])
configuration = pydev_runfiles.Configuration(
'',
verbosity,
None,
None,
None,
files_to_tests,
1, #Always single job here
None,
#The coverage is handled in this loop.
coverage_output_file=None,
coverage_include=None,
)
test_runner = pydev_runfiles.PydevTestRunner(configuration)
sys.stdout.flush()
test_runner.run_tests(handle_coverage=False)
finally:
if coverage is not None:
coverage.stop()
coverage.save()
except:
traceback.print_exc()
server_comm.notifications_queue.put_nowait(KillServer())
sys.stdin = pydevconsole.BaseStdIn(sys.stdin)
# parse command-line arguments
optlist, _ = gnu_getopt(sys.argv, 'm:h:p', ['mode=', 'host=', 'port='])
mode = None
host = None
port = None
for opt, arg in optlist:
if opt in ('-m', '--mode'):
mode = arg
elif opt in ('-h', '--host'):
host = arg
elif opt in ('-p', '--port'):
port = int(arg)
if mode not in ('client', 'server'):
sys.exit(-1)
if mode == 'client':
if not port:
# port must be set for client
sys.exit(-1)
if not host:
from _pydev_bundle import pydev_localhost
host = client_host = pydev_localhost.get_localhost()
pydevconsole.start_client(host, port)
elif mode == 'server':
pydevconsole.start_server(port)
def run(self):
from _pydev_bundle import pydev_localhost
print('Starting server with:', pydev_localhost.get_localhost(),
self.server_port, self.client_port)
pydevconsole.start_server(pydev_localhost.get_localhost(),
self.server_port, self.client_port)
def test_edit(self):
''' Make sure we can issue an edit command'''
if os.environ.get('TRAVIS') == 'true':
# This test is too flaky on travis.
return
from _pydev_bundle.pydev_ipython_console_011 import get_pydev_frontend
from _pydev_comm.rpc import start_rpc_server_and_make_client
called_RequestInput = [False]
called_IPythonEditor = [False]
class RequestInputHandler:
def __init__(self):
self.rpc_client = None
def requestInput(self, path):
called_RequestInput[0] = True
return '\n'
def IPythonEditor(self, name, line):
called_IPythonEditor[0] = (name, line)
return True
enable_thrift_logging()
# here we start the test server
server_socket = start_rpc_server_and_make_client(get_localhost(), 0,
PythonConsoleFrontendService,
PythonConsoleBackendService,
create_server_handler_factory(RequestInputHandler()))
host, port = server_socket.getsockname()
rpc_client, _ = make_rpc_client(PythonConsoleFrontendService, host, port)
# PyDevFrontEnd depends on singleton in IPython, so you
# can't make multiple versions. So we reuse self.front_end for
# all the tests
self.front_end = get_pydev_frontend(rpc_client)
orig_stdin = sys.stdin
sys.stdin = StdIn(self, rpc_client)
try:
filename = 'made_up_file.py'
self.add_exec('%edit ' + filename)
for i in xrange(10):
if called_IPythonEditor[0] == (os.path.abspath(filename), '0'):
break
time.sleep(.1)
if not called_IPythonEditor[0]:
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/interactiveshell.py", line 2883, in run_code
# exec(code_obj, self.user_global_ns, self.user_ns)
# File "<ipython-input-15-09583ca3bce1>", line 1, in <module>
# get_ipython().magic('edit made_up_file.py')
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/interactiveshell.py", line 2205, in magic
# return self.run_line_magic(magic_name, magic_arg_s)
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/interactiveshell.py", line 2126, in run_line_magic
# result = fn(*args,**kwargs)
# File "<string>", line 2, in edit
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/magic.py", line 193, in <lambda>
# call = lambda f, *a, **k: f(*a, **k)
# File "/home/travis/miniconda/lib/python3.3/site-packages/IPython/core/magics/code.py", line 662, in edit
# self.shell.hooks.editor(filename,lineno)
# File "/home/travis/build/fabioz/PyDev.Debugger/pydev_ipython_console_011.py", line 70, in call_editor
# server.IPythonEditor(filename, str(line))
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1090, in __call__
# return self.__send(self.__name, args)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1419, in __request
# verbose=self.__verbose
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1132, in request
# return self.single_request(host, handler, request_body, verbose)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1143, in single_request
# http_conn = self.send_request(host, handler, request_body, verbose)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1255, in send_request
# self.send_content(connection, request_body)
# File "/home/travis/miniconda/lib/python3.3/xmlrpc/client.py", line 1285, in send_content
# connection.endheaders(request_body)
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 1061, in endheaders
# self._send_output(message_body)
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 906, in _send_output
# self.send(msg)
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 844, in send
# self.connect()
# File "/home/travis/miniconda/lib/python3.3/http/client.py", line 822, in connect
# self.timeout, self.source_address)
# File "/home/travis/miniconda/lib/python3.3/socket.py", line 435, in create_connection
# raise err
# File "/home/travis/miniconda/lib/python3.3/socket.py", line 426, in create_connection
# sock.connect(sa)
# ConnectionRefusedError: [Errno 111] Connection refused
# I.e.: just warn that the test failing, don't actually fail.
sys.stderr.write('Test failed: this test is brittle in travis because sometimes the connection is refused (as above) and we do not have a callback.\n')
return
eq_(called_IPythonEditor[0], (os.path.abspath(filename), '0'))
assert called_RequestInput[0], "Make sure the 'wait' parameter has been respected"
finally:
sys.stdin = orig_stdin
def run(self):
from _pydev_bundle import pydev_localhost
print('Starting server with:', pydev_localhost.get_localhost(), self.server_port, self.client_port)
pydevconsole.start_server(pydev_localhost.get_localhost(), self.server_port, self.client_port)
sys.stdin = pydevconsole.BaseStdIn(sys.stdin)
# parse command-line arguments
optlist, _ = gnu_getopt(sys.argv, 'm:h:p', ['mode=', 'host=', 'port='])
mode = None
host = None
port = None
for opt, arg in optlist:
if opt in ('-m', '--mode'):
mode = arg
elif opt in ('-h', '--host'):
host = arg
elif opt in ('-p', '--port'):
port = int(arg)
if mode not in ('client', 'server'):
sys.exit(-1)
if mode == 'client':
if not port:
# port must be set for client
sys.exit(-1)
if not host:
from _pydev_bundle import pydev_localhost
host = client_host = pydev_localhost.get_localhost()
pydevconsole.start_client(host, port)
elif mode == 'server':
pydevconsole.start_server(port)
def test_console_requests(self):
self.original_stdout = sys.stdout
sys.stdout = pydevd_io.IOBuf()
try:
client_port, _server_port = self.get_free_addresses()
client_thread = self.start_client_thread(client_port) #@UnusedVariable
import time
time.sleep(.3) #let's give it some time to start the threads
from _pydev_bundle import pydev_localhost
from _pydev_bundle.pydev_console_utils import CodeFragment
interpreter = pydevconsole.InterpreterInterface(pydev_localhost.get_localhost(), client_port, threading.currentThread())
sys.stdout = pydevd_io.IOBuf()
interpreter.add_exec(CodeFragment('class Foo:\n CONSTANT=1\n'))
interpreter.add_exec(CodeFragment('foo=Foo()'))
interpreter.add_exec(CodeFragment('foo.__doc__=None'))
interpreter.add_exec(CodeFragment('val = %s()' % (raw_input_name,)))
interpreter.add_exec(CodeFragment('50'))
interpreter.add_exec(CodeFragment('print (val)'))
found = sys.stdout.getvalue().split()
try:
self.assertEqual(['50', 'input_request'], found)
except:
try:
self.assertEqual(['input_request'], found) #IPython
except:
self.assertEqual([u'50', u'input_request'], found[1:]) # IPython 5.1
self.assertTrue(found[0].startswith(u'Out'))
comps = interpreter.getCompletions('foo.', 'foo.')
self.assert_(
('CONSTANT', '', '', '3') in comps or ('CONSTANT', '', '', '4') in comps, \
'Found: %s' % comps
)
comps = interpreter.getCompletions('"".', '"".')
self.assert_(
('__add__', 'x.__add__(y) <==> x+y', '', '3') in comps or
('__add__', '', '', '4') in comps or
('__add__', 'x.__add__(y) <==> x+y\r\nx.__add__(y) <==> x+y', '()', '2') in comps or
('__add__', 'x.\n__add__(y) <==> x+yx.\n__add__(y) <==> x+y', '()', '2'),
'Did not find __add__ in : %s' % (comps,)
)
completions = interpreter.getCompletions('', '')
for c in completions:
if c[0] == 'AssertionError':
break
else:
self.fail('Could not find AssertionError')
completions = interpreter.getCompletions('Assert', 'Assert')
for c in completions:
if c[0] == 'RuntimeError':
self.fail('Did not expect to find RuntimeError there')
self.assert_(('__doc__', None, '', '3') not in interpreter.getCompletions('foo.CO', 'foo.'))
comps = interpreter.getCompletions('va', 'va')
self.assert_(('val', '', '', '3') in comps or ('val', '', '', '4') in comps)
interpreter.add_exec(CodeFragment('s = "mystring"'))
desc = interpreter.getDescription('val')
self.assert_(desc.find('str(object) -> string') >= 0 or
desc == "'input_request'" or
desc.find('str(string[, encoding[, errors]]) -> str') >= 0 or
desc.find('str(Char* value)') >= 0 or
desc.find('str(object=\'\') -> string') >= 0 or
desc.find('str(value: Char*)') >= 0 or
desc.find('str(object=\'\') -> str') >= 0
,
'Could not find what was needed in %s' % desc)
desc = interpreter.getDescription('val.join')
self.assert_(desc.find('S.join(sequence) -> string') >= 0 or
desc.find('S.join(sequence) -> str') >= 0 or
desc.find('S.join(iterable) -> string') >= 0 or
desc == "<builtin method 'join'>" or
desc == "<built-in method join of str object>" or
desc.find('str join(str self, list sequence)') >= 0 or
desc.find('S.join(iterable) -> str') >= 0 or
desc.find('join(self: str, sequence: list) -> str') >= 0,
"Could not recognize: %s" % (desc,))
finally:
sys.stdout = self.original_stdout
def run(self):
from _pydev_bundle import pydev_localhost
pydevconsole.start_server(pydev_localhost.get_localhost(), self.server_port, self.client_port)
def get_free_port():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((pydev_localhost.get_localhost(), 0))
_, port = s.getsockname()
s.close()
return port
Exec(code, updated_globals, frame.f_locals)
except SystemExit:
raise
except:
interpreter.showtraceback()
else:
pydevd_save_locals.save_locals(frame)
return False
#=======================================================================================================================
# main
#=======================================================================================================================
if __name__ == '__main__':
#Important: don't use this module directly as the __main__ module, rather, import itself as pydevconsole
#so that we don't get multiple pydevconsole modules if it's executed directly (otherwise we'd have multiple
#representations of its classes).
#See: https://sw-brainwy.rhcloud.com/tracker/PyDev/446:
#'Variables' and 'Expressions' views stopped working when debugging interactive console
import pydevconsole
sys.stdin = pydevconsole.BaseStdIn(sys.stdin)
port, client_port = sys.argv[1:3]
from _pydev_bundle import pydev_localhost
if int(port) == 0 and int(client_port) == 0:
(h, p) = pydev_localhost.get_socket_name()
client_port = p
pydevconsole.start_server(pydev_localhost.get_localhost(), int(port), int(client_port))
except SystemExit:
raise
except:
interpreter.showtraceback()
else:
pydevd_save_locals.save_locals(frame)
return False
#=======================================================================================================================
# main
#=======================================================================================================================
if __name__ == '__main__':
#Important: don't use this module directly as the __main__ module, rather, import itself as pydevconsole
#so that we don't get multiple pydevconsole modules if it's executed directly (otherwise we'd have multiple
#representations of its classes).
#See: https://sw-brainwy.rhcloud.com/tracker/PyDev/446:
#'Variables' and 'Expressions' views stopped working when debugging interactive console
import pydevconsole
sys.stdin = pydevconsole.BaseStdIn(sys.stdin)
port, client_port = sys.argv[1:3]
from _pydev_bundle import pydev_localhost
if int(port) == 0 and int(client_port) == 0:
(h, p) = pydev_localhost.get_socket_name()
client_port = p
pydevconsole.start_server(pydev_localhost.get_localhost(), int(port),
int(client_port))
del sys.argv[1]
del sys.argv[1]
file = sys.argv[1]
del sys.argv[0]
from _pydev_bundle import pydev_localhost
if int(port) == 0 and int(client_port) == 0:
(h, p) = pydev_localhost.get_socket_name()
client_port = p
host = pydev_localhost.get_localhost()
# replace exit (see comments on method)
# note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = do_exit
interpreter = InterpreterInterface(host, int(client_port), threading.currentThread())
server_thread = threading.Thread(
target=start_console_server, name="ServerThread", args=(host, int(port), interpreter)
)
server_thread.setDaemon(True)
server_thread.start()
sys.stdin = StdIn(interpreter, host, client_port, sys.stdin)
