def StartServer(host, port, client_port):
# replace exit (see comments on method)
# note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = _DoExit
from _pydev_xmlrpc_hook import InputHookedXMLRPCServer
try:
server = InputHookedXMLRPCServer((host, port), logRequests=False)
interpreter = InterpreterInterface(host, client_port, server)
except:
sys.stderr.write(
'Error starting server with host: %s, port: %s, client_port: %s\n'
% (host, port, client_port))
raise
# Tell UMD the proper default namespace
_set_globals_function(interpreter.getNamespace)
# Functions for basic protocol
server.register_function(interpreter.addExec)
server.register_function(interpreter.getCompletions)
server.register_function(interpreter.getDescription)
server.register_function(interpreter.close)
# Functions so that the console can work as a debugger (i.e.: variables view, expressions...)
server.register_function(interpreter.connectToDebugger)
server.register_function(interpreter.hello)
# Functions for GUI main loop integration
server.register_function(interpreter.enableGui)
server.serve_forever()
def get_interpreter():
try:
interpreterInterface = getattr(__builtin__, 'interpreter')
except AttributeError:
interpreterInterface = InterpreterInterface(None, None, threading.currentThread())
setattr(__builtin__, 'interpreter', interpreterInterface)
return interpreterInterface
def StartServer(host, port, client_port):
# replace exit (see comments on method)
# note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = _DoExit
for loop_cls in (
QtMainLoop,
WxMainLoop,
# GtkMainLoop
):
try:
main_loop = loop_cls()
sys.stderr.write('Info: UI event loop integration active: %s\n' %
(loop_cls.ui_name))
break
except:
try:
sys.exc_clear()
except:
pass # Not there in Jython 2.1
else:
main_loop = NoGuiMainLoop()
sys.stderr.write(
'Warning: No UI framework found to integrate event loop (supported: Qt, Gtk)\n'
)
try:
interpreter = InterpreterInterface(host, client_port)
server = ThreadedXMLRPCServer((host, port),
main_loop,
logRequests=False)
except:
sys.stderr.write(
'Error starting server with host: %s, port: %s, client_port: %s\n'
% (host, port, client_port))
raise
# Functions for basic protocol
server.register_function(interpreter.addExec, 'addExec')
server.register_function(interpreter.getCompletions, 'getCompletions')
server.register_function(interpreter.getDescription, 'getDescription')
server.register_function(interpreter.close, 'close')
# Functions so that the console can work as a debugger (i.e.: variables view, expressions...)
server.register_function(interpreter.connectToDebugger,
'connectToDebugger')
server.register_function(interpreter.postCommand, 'postCommand')
server.register_function(interpreter.hello, 'hello')
try:
atexit.register(server.shutdown)
except:
pass # server.shutdown not there for jython 2.1
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
main_loop.run()
def StartServer(host, port, client_port):
#replace exit (see comments on method)
#note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = DoExit
interpreter = InterpreterInterface(host, client_port, threading.currentThread())
start_new_thread(start_server,(host, port, interpreter))
process_exec_queue(interpreter)
def get_interpreter():
try:
interpreterInterface = getattr(__builtin__, 'interpreter')
except AttributeError:
# fake return_controll_callback function just to prevent exception in PyCharm bebug console
from pydev_ipython.inputhook import set_return_control_callback
set_return_control_callback(lambda x: True)
interpreterInterface = InterpreterInterface(None, None,
threading.currentThread())
setattr(__builtin__, 'interpreter', interpreterInterface)
return interpreterInterface
def StartServer(host, port, client_port):
#replace exit (see comments on method)
#note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = _DoExit
interpreter = InterpreterInterface(host, client_port, threading.currentThread())
server_thread = threading.Thread(target=start_server,
name='ServerThread',
args=(host, port, interpreter))
server_thread.setDaemon(True)
server_thread.start()
process_exec_queue(interpreter)
def StartServer(host, port, client_port):
#replace exit (see comments on method)
#note that this does not work in jython!!! (sys method can't be replaced).
sys.exit = _DoExit
from pydev_imports import SimpleXMLRPCServer
try:
interpreter = InterpreterInterface(host, client_port)
server = SimpleXMLRPCServer((host, port), logRequests=False)
except:
sys.stderr.write(
'Error starting server with host: %s, port: %s, client_port: %s\n'
% (host, port, client_port))
raise
if True:
#Functions for basic protocol
server.register_function(interpreter.addExec)
server.register_function(interpreter.getCompletions)
server.register_function(interpreter.getDescription)
server.register_function(interpreter.close)
#Functions so that the console can work as a debugger (i.e.: variables view, expressions...)
server.register_function(interpreter.connectToDebugger)
server.register_function(interpreter.postCommand)
server.register_function(interpreter.hello)
server.serve_forever()
else:
#This is still not finished -- that's why the if True is there :)
from pydev_imports import Queue
queue_requests_received = Queue.Queue() #@UndefinedVariable
queue_return_computed = Queue.Queue() #@UndefinedVariable
def addExec(line):
queue_requests_received.put(('addExec', line))
return queue_return_computed.get(block=True)
def getCompletions(text):
queue_requests_received.put(('getCompletions', text))
return queue_return_computed.get(block=True)
def getDescription(text):
queue_requests_received.put(('getDescription', text))
return queue_return_computed.get(block=True)
def close():
queue_requests_received.put(('close', None))
return queue_return_computed.get(block=True)
server.register_function(addExec)
server.register_function(getCompletions)
server.register_function(getDescription)
server.register_function(close)
try:
import PyQt4.QtGui #We can only start the PyQt4 loop if we actually have access to it.
except ImportError:
print('Unable to process gui events (PyQt4.QtGui not imported)')
server.serve_forever()
else:
import threading
class PydevHandleRequestsThread(threading.Thread):
def run(self):
while 1:
#This is done on a thread (so, it may be blocking or not blocking, it doesn't matter)
#anyways, the request will be put on a queue and the return will be gotten from another
#one -- and those queues are shared with the main thread.
server.handle_request()
app = PyQt4.QtGui.QApplication([])
def serve_forever():
"""Handle one request at a time until doomsday."""
while 1:
try:
try:
func, param = queue_requests_received.get(
block=True,
timeout=1.0 / 20.0) #20 loops/second
attr = getattr(interpreter, func)
if param is not None:
queue_return_computed.put(attr(param))
else:
queue_return_computed.put(attr())
except Queue.Empty: #@UndefinedVariable
pass
PyQt4.QtGui.qApp.processEvents()
except:
import traceback
traceback.print_exc()
PydevHandleRequestsThread().start()
serve_forever()
