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)