def _accept_client(self):
client_socket, client_address = self.server.accept()
session = self.session_factory(client_socket)
cui.message('Connection received from %s:%s' % session.address)
self.clients[id(client_socket)] = session
self.clients_by_name[str(session)] = session
cui.register_waitable(client_socket, self.read)
def send_command(self, command, argument=''):
sequence_no = self._sequence_no
payload = ('%s\t%s\t%s\n' % (command, sequence_no, argument))
if cui.get_variable(constants.ST_DEBUG_LOG):
cui.message('=== Sending command: \n%s' % (payload, ))
self.send_all(payload.encode('utf-8'))
self._sequence_no += 2
return sequence_no
def unregister(self, waitable):
try:
self._waitables.remove(waitable)
del self._handlers[id(waitable)]
if not self._waitables and cui.is_update_func(self.select):
cui.message('Stopping socket selector')
cui.remove_update_func(self.select)
except ValueError:
pass
def _delete_window_set_by_index(self, index):
if index == 0:
cui.message('Can not delete window set 1.')
return
self._named_window_sets = {k:v for k, v in self._named_window_sets.items()
if v != index}
self._window_sets.pop(index)
if index <= self._active_window_set:
self._active_window_set -= 1
def start(self):
host = cui.get_variable(self.host_var)
port = cui.get_variable(self.port_var)
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server.bind((host, port))
self.server.listen(5)
cui.message('Listening on %s:%s' % self.server.getsockname())
cui.register_waitable(self.server, self.read)
cui.add_exit_handler(self.shutdown)
def evaluate(string, handle_result=True):
log_calls = cui.get_variable(['logging', 'emacs-calls'])
if log_calls:
cui.message('emacs-call: %s' % string)
proc = subprocess.run(
[cui.get_variable(['emacs', 'emacsclient']), "-e", string],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if (proc.returncode != 0):
raise LispException(proc.stderr.decode('utf-8'))
result = proc.stdout.decode('utf-8').strip()
if log_calls:
cui.message('emacs-result: %s' % result)
return parse(result) if handle_result else None
def _get_input(self):
try:
r = self.socket.recv(Session.BUFFER_SIZE)
if len(r) == 0:
if len(self._read_buffer) > 0:
cui.message('received incomplete message: %s' %
self._read_buffer)
raise ConnectionTerminated('received 0 bytes')
return r
except socket.error as e:
if e.args[0] not in [errno.EAGAIN, errno.EWOULDBLOCK]:
raise e
return b''
def close_socket(self, sock):
socket_key = id(sock)
try:
if sock == self.server:
cui.message('Closing server on %s:%s' %
self.server.getsockname())
self.server.close()
self.server = None
else:
try:
session = self.clients.get(socket_key)
session_name = str(session)
cui.message('Connection from %s:%s terminated' %
session.address)
session.close()
finally:
del self.clients_by_name[session_name]
del self.clients[socket_key]
finally:
cui.unregister_waitable(sock)
def _dispatch(self, response):
if response.command == constants.CMD_VERSION:
self.check_debugger_version(response.payload)
elif response.command == constants.CMD_RETURN:
for item in response.payload:
if item['type'] == 'thread_info':
self._dispatch_thread_info(item)
elif response.command == constants.CMD_THREAD_CREATE:
item = response.payload[0]
if item['type'] == 'thread_info':
self._dispatch_thread_info(item)
elif response.command == constants.CMD_THREAD_KILL:
self.threads.pop(response.payload).close()
cui.message('Thread %s killed.' % response.payload)
elif response.command == constants.CMD_THREAD_SUSPEND:
for item in response.payload:
if item['type'] == 'thread_suspend':
self.threads[item['id']].update_thread(item)
elif response.command == constants.CMD_THREAD_RESUME:
self.threads[response.payload['id']].update_thread(
response.payload)
elif response.command == constants.CMD_GET_FRAME:
for thread in self.threads.values():
thread.update_frame(response.sequence_no, response.payload)
elif response.command == constants.CMD_GET_VAR:
for thread in self.threads.values():
thread.update_variable(response.sequence_no, response.payload)
elif response.command == constants.CMD_EVAL_EXPR:
for thread in self.threads.values():
thread.on_eval(response.sequence_no, response.payload)
elif response.command == constants.CMD_ERROR:
cui.message(response.payload)
else:
cui.message('Unhandled response from pydevd: %s' %
response.command)
def initialize():
proc = subprocess.run(
[cui.get_variable(['emacs', 'emacsclient']), '--version'],
universal_newlines=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
if (proc.returncode != 0):
raise LispException(proc.stderr)
cui.message(proc.stdout)
# define functions from python
while len(FUNCTION_LIST):
evaluate(FUNCTION_LIST.pop(0))
while len(PACKAGE_LIST):
PACKAGE_LIST.pop(0).load()
# retrieve doc for declared functions
global DEFERRED_FN_INFO
while DEFERRED_FN_INFO:
fns = DEFERRED_FN_INFO[:10]
for fn, info in zip((fn for _, fn in fns),
_retrieve_function_infos((sym for sym, _ in fns))):
_set_function_info(fn, info)
DEFERRED_FN_INFO = DEFERRED_FN_INFO[10:]
def handle_line(self, line):
if cui.get_variable(constants.ST_DEBUG_LOG):
cui.message('=== Received response: \n%s' % (line, ))
self._dispatch(Command.from_string(self._file_mapping, line))
def check_debugger_version(self, version):
cui.message('pydevd version (%s): %s' % (self, version))
def register_async(self, name, handler):
if '\n' in name:
cui.message('Line-breaks not allowed in async-handler names.')
return
self._async_handlers[name] = handler
def register(self, waitable, handler):
if self._as_update_func and not cui.is_update_func(self.select):
cui.message('Starting socket selector')
cui.update_func(self.select)
self._waitables.append(waitable)
self._handlers[id(waitable)] = handler
def _fn(*args, **kwargs):
thread = cui.current_buffer().thread
if thread.state == constants.THREAD_STATE_SUSPENDED:
return fn(thread, *args, **kwargs)
else:
cui.message('Thread %s must be suspended.' % thread.name)
