def __init__( self, sanitize_bracketed_paste='[\x03\x04\x0e\x0f\r\x07\x7f\x8d\x8e\x8f\x90\x9b\x9d\x9e\x9f]' ): self.wakeup_read_fd, self.wakeup_write_fd = safe_pipe() # For some reason on macOS the DefaultSelector fails when tty_fd is # open('/dev/tty') self.sel = s = selectors.PollSelector() s.register(self.wakeup_read_fd, selectors.EVENT_READ) self.return_code = 0 self.read_allowed = True self.read_buf = '' self.decoder = codecs.getincrementaldecoder('utf-8')('ignore') try: self.iov_limit = max(os.sysconf('SC_IOV_MAX') - 1, 255) except Exception: self.iov_limit = 255 self.parse_input_from_terminal = partial(parse_input_from_terminal, self._on_text, self._on_dcs, self._on_csi, self._on_osc, self._on_pm, self._on_apc) self.ebs_pat = re.compile('([\177\r\x03\x04])') self.in_bracketed_paste = False self.sanitize_bracketed_paste = bool(sanitize_bracketed_paste) if self.sanitize_bracketed_paste: self.sanitize_ibp_pat = re.compile(sanitize_bracketed_paste) self.jobs_queue = Queue()
def __init__(self, name, use_pty=False): SerialPort.__init__(self, name, use_pty) print("[Terminal %s].__init__(name=\"%s\")" % (self.name, self.name)) self.count = 0 self.cur_x = 1 self.cur_y = 1 self.saved_x = 1 self.saved_y = 1 self.min_x = 1 self.min_y = 1 self.max_x = 80 self.max_y = 24 self.seen_valid_ps = False self.Pt = self.min_y self.Pb = self.max_y self.scroll_enabled = False self.cursor_saved = False self.autowrap = True self.autoscroll = True selector = selectors.PollSelector() selector.register(self.filedes, selectors.EVENT_READ | selectors.EVENT_WRITE) self.selector = selector
def _await_socket(self, timeout): """Blocks for the nailgun subprocess to bind and emit a listening port in the nailgun stdout.""" start_time = time.time() accumulated_stdout = "" def calculate_remaining_time(): return time.time() - (start_time + timeout) def possibly_raise_timeout(remaining_time): if remaining_time > 0: stderr = read_file(self._ng_stderr, binary_mode=True) raise self.InitialNailgunConnectTimedOut( timeout=timeout, stdout=accumulated_stdout, stderr=stderr, ) # NB: We use PollSelector, rather than the more efficient DefaultSelector, because # DefaultSelector results in using the epoll() syscall on Linux, which does not work with # regular text files like ng_stdout. See https://stackoverflow.com/a/8645770. with selectors.PollSelector() as selector, safe_open(self._ng_stdout, "r") as ng_stdout: selector.register(ng_stdout, selectors.EVENT_READ) while 1: remaining_time = calculate_remaining_time() possibly_raise_timeout(remaining_time) events = selector.select(timeout=-1 * remaining_time) if events: line = ng_stdout.readline() # TODO: address deadlock risk here. try: return self._NG_PORT_REGEX.match(line).group(1) except AttributeError: pass accumulated_stdout += line
def __init__( self, sanitize_bracketed_paste='[\x03\x04\x0e\x0f\r\x07\x7f\x8d\x8e\x8f\x90\x9b\x9d\x9e\x9f]' ): if is_macos: # On macOS PTY devices are not supported by the KqueueSelector self.asycio_loop = asyncio.SelectorEventLoop( selectors.PollSelector()) asyncio.set_event_loop(self.asycio_loop) else: self.asycio_loop = asyncio.get_event_loop() self.return_code = 0 self.read_buf = '' self.decoder = codecs.getincrementaldecoder('utf-8')('ignore') try: self.iov_limit = max(os.sysconf('SC_IOV_MAX') - 1, 255) except Exception: self.iov_limit = 255 self.parse_input_from_terminal = partial(parse_input_from_terminal, self._on_text, self._on_dcs, self._on_csi, self._on_osc, self._on_pm, self._on_apc) self.ebs_pat = re.compile('([\177\r\x03\x04])') self.in_bracketed_paste = False self.sanitize_bracketed_paste = bool(sanitize_bracketed_paste) if self.sanitize_bracketed_paste: self.sanitize_ibp_pat = re.compile(sanitize_bracketed_paste)
def write(self, buf, timeout=None): """ write to our serial port """ buflist = list(buf) selector = selectors.PollSelector() selector.register(self.filedes, selectors.EVENT_WRITE) ret = 0 while buflist: before = time.time() events = selector.select(timeout) if not events: raise TimeoutError(ret) for key, mask in events: if mask & selectors.EVENT_WRITE and key.fd == self.filedes: c = buflist.pop(0) ret += os.write(key.fd, bytes(c, "UTF-8")) after = time.time() if not timeout is None: timeout -= after - before return ret
def read(self, count=None, timeout=None): """ read from our port """ selector = selectors.PollSelector() selector.register(self.filedes, selectors.EVENT_READ) ret = bytes() while count is None or count > 0: before = time.time() events = selector.select(timeout=timeout) if not events: raise TimeoutError(ret) for key, mask in events: if mask & selectors.EVENT_READ: b = os.read(key.fd, 1) ret += b if count is not None: count -= 1 after = time.time() if not timeout is None: timeout -= after - before return ret
def __init__(self, queue): super().__init__(name='mg-input-handler') self.daemon = True self.selector = selectors.PollSelector() self.inputs = {} self.queue = queue self.initial_events = []
def __init__(self, settings): SerialPort.__init__(self, settings, "mill") self.selector = selectors.PollSelector() self.buf = u"" self.selector.register(self.device, selectors.EVENT_READ)
def __init__(self, mode): print("mode: " + mode) if mode == 'poll': self.sel = selectors.PollSelector() elif mode == 'epoll': self.sel = selectors.EpollSelector() else: self.sel = selectors.SelectSelector()
def __init__(self) -> None: # EpollSelector doesn't allow regular files. self._sel = selectors.PollSelector() self._files: Dict["FileDescriptorLike", Multiplexer.File] = {} self._pending_writes: Set[Multiplexer.File] = set() self._pending_signals: Set[Callable[[], Any]] = set() self._signal_r: Optional[int] = None self._signal_w: Optional[int] = None self._old_wakeup_fd: Optional[int] = None self._to_modify: Set[Multiplexer.File] = set() self.done = False
def mainloop(self): with selectors.PollSelector() as server_selector: server_selector.register(self.socket, selectors.EVENT_READ) try: while not self.__is_dead: status = server_selector.select(.5) if status: self.__handle_incoming_request() finally: self.commit_suicide()
def _sendfile_use_sendfile(self, file, offset=0, count=None): self._check_sendfile_params(file, offset, count) sockno = self.fileno() try: fileno = file.fileno() except (AttributeError, io.UnsupportedOperation) as err: raise _GiveupOnSendfile(err) try: fsize = os.fstat(fileno).st_size except OSError as err: raise _GiveupOnSendfile(err) if not fsize: return 0 blocksize = fsize if not count else count timeout = self.gettimeout() if timeout == 0: raise ValueError('non-blocking sockets are not supported') if hasattr(selectors, 'PollSelector'): selector = selectors.PollSelector() else: selector = selectors.SelectSelector() selector.register(sockno, selectors.EVENT_WRITE) total_sent = 0 selector_select = selector.select os_sendfile = os.sendfile try: while True: if timeout and not selector_select(timeout): raise _socket.timeout('timed out') if count: blocksize = count - total_sent if blocksize <= 0: break try: sent = os_sendfile(sockno, fileno, offset, blocksize) except BlockingIOError: if not timeout: selector_select() continue except OSError as err: if total_sent == 0: raise _GiveupOnSendfile(err) raise err from None else: if sent == 0: break offset += sent total_sent += sent return total_sent finally: if total_sent > 0 and hasattr(file, 'seek'): file.seek(offset)
def drain(self): """ drain the file descriptor of its output, we've lost track """ selector = selectors.PollSelector() selector.register(self.filedes, selectors.EVENT_READ) count = 0 while True: events = selector.select(timeout=self._get_timeout()) if not events: count += 1 if count == 4: break for key, mask in events: if mask & selectors.EVENT_READ: os.read(key.fd, 1) count = 0 selector.close()
def __init__(self, default_timeout=None): self.poller = selectors.PollSelector() self.output_q = [] self.default_timeout = default_timeout self.seq = 0
def read_Ps_response(self, terminator: chr, starter: chr = '[', timeout=None): """ read a series of integer values of the flavor: ESC terminator ESC starter terminator ESC starter Ps terminator ESC starter Ps ; terminator ESC starter Ps ; Ps terminator ESC starter Ps ; Ps ; ... terminator """ # pylint: disable=too-many-nested-blocks,too-many-branches timeout = self._get_timeout(timeout) states = [ "\x1b", "%c" % (starter, ), "0123456789;%c" % (terminator, ), ] count = 0 val = 0 returns = [] seen_val = False terminated = False selector = selectors.PollSelector() selector.register(self.filedes, selectors.EVENT_READ) while not terminated: events = selector.select(timeout=self._get_timeout()) if not events: # print("read_Ps_response(): events: %s" % (events,)) count += 1 if count == 4: raise TimeoutError(timeout * count) continue # print("states: %s" % (states,)) for key, mask in events: if mask & selectors.EVENT_READ: c = os.read(key.fd, 1).decode('utf8') # print("read_Ps_response: read '%c'" % (c,)) count = 0 if c in states[0]: if len(states) > 1: states.pop(0) continue elif c == ';': if seen_val: returns.append(val) val = 0 seen_val = False continue elif c == terminator: if seen_val: returns.append(val) terminated = True break if len(states) == 1: seen_val = True val *= 10 val += int(c) else: if self.seen_valid_ps: print("unexpected character '\\x%02x'" % (ord(c), )) else: time.sleep(0.2) continue selector.close() if returns: self.seen_valid_ps = True return returns
def _sendfile_use_sendfile(self, file, offset=0, count=None): self._check_sendfile_params(file, offset, count) sockno = self.fileno() try: fileno = file.fileno() except (AttributeError, io.UnsupportedOperation) as err: raise _GiveupOnSendfile(err) # not a regular file try: fsize = os.fstat(fileno).st_size except OSError as err: raise _GiveupOnSendfile(err) # not a regular file if not fsize: return 0 # empty file # Truncate to 1GiB to avoid OverflowError, see bpo-38319. blocksize = min(count or fsize, 2 ** 30) timeout = self.gettimeout() if timeout == 0: raise ValueError("non-blocking sockets are not supported") # poll/select have the advantage of not requiring any # extra file descriptor, contrarily to epoll/kqueue # (also, they require a single syscall). if hasattr(selectors, 'PollSelector'): selector = selectors.PollSelector() else: selector = selectors.SelectSelector() selector.register(sockno, selectors.EVENT_WRITE) total_sent = 0 # localize variable access to minimize overhead selector_select = selector.select os_sendfile = os.sendfile try: while True: if timeout and not selector_select(timeout): raise _socket.timeout('timed out') if count: blocksize = count - total_sent if blocksize <= 0: break try: sent = os_sendfile(sockno, fileno, offset, blocksize) except BlockingIOError: if not timeout: # Block until the socket is ready to send some # data; avoids hogging CPU resources. selector_select() continue except OSError as err: if total_sent == 0: # We can get here for different reasons, the main # one being 'file' is not a regular mmap(2)-like # file, in which case we'll fall back on using # plain send(). raise _GiveupOnSendfile(err) raise err from None else: if sent == 0: break # EOF offset += sent total_sent += sent return total_sent finally: if total_sent > 0 and hasattr(file, 'seek'): file.seek(offset)
#!/bin/env python3 import socket import threading from time import sleep import time import ESocketS import selectors host = socket.gethostbyname(socket.gethostname()) port = 1234 server = ESocketS.Socket(selector=selectors.PollSelector()) server.run_in_subthread('all', True) server.start() conections = 20000 def connect(clients): conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) conn.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) conn.connect((host, port)) clients.append(conn) try: clients = [] t1 = time.time() for i in range(conections): threading.Thread(target=connect, args=(clients, )).start() # sleep(0.001)
def create_event_loop(self): return asyncio.SelectorEventLoop(selectors.PollSelector())
req.add_plane(plane1, ifb, crtc, dst=(0, 0, 400, 480)) req.add_plane(plane2, ofb, crtc, dst=(400, 0, 400, 480)) req.commit_sync(allow_modeset=True) time.sleep(1) loop_count += 1 if loop_count >= 10: exit(0) print("loop #", loop_count) src_streamer.queue(ifb) dst_streamer.queue(ofb) def readkey(conn, mask): print("KEY EVENT") sys.stdin.readline() exit(0) sel = selectors.PollSelector() sel.register(vid.fd, selectors.EVENT_READ, readvid) sel.register(sys.stdin, selectors.EVENT_READ, readkey) while True: events = sel.select() for key, mask in events: callback = key.data callback(key.fileobj, mask) print("done") exit(0)