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)
