async def read_async(self, event_loop: asyncio.AbstractEventLoop) -> bytes: done = asyncio.Event(loop=event_loop) def read_cb() -> None: try: self.__read_internal() except OSError: event_loop.remove_reader(self.fd_in) done.set() return except: event_loop.remove_reader(self.fd_in) raise if self.__reader_done: event_loop.remove_reader(self.fd_in) done.set() self.__reader_start() event_loop.add_reader(self.fd_in, read_cb) await done.wait() if self.__reader_done: return self.__reader_response else: raise OSError("Failed to read from connection")
def __init__(self, sock_fam: socket.AddressFamily, icmp_proto: int, src: IPAddressType, send_limiter: TokenBucket, *, loop: asyncio.AbstractEventLoop = None) -> None: tcp_sock = socket.socket(sock_fam, socket.SOCK_RAW, socket.IPPROTO_TCP) icmp_sock = socket.socket(sock_fam, socket.SOCK_RAW, icmp_proto) for sock in (tcp_sock, icmp_sock): sock.setblocking(False) sock.setsockopt(socket.SOL_SOCKET, _SO_RCVBUFFORCE, 8_388_608) sock.bind((str(src), 0)) if loop is None: loop = asyncio.get_event_loop() loop.add_reader(tcp_sock.fileno(), self._handle_read) loop.add_reader(icmp_sock.fileno(), self._handle_icmp_read) loop.add_writer(tcp_sock.fileno(), self._handle_write) self._sock = tcp_sock self._icmp_sock = icmp_sock self._src_addr: IPAddressType = src self._test_map: Dict[Tuple[int, bytes, int], "BaseTest[IPAddressType]"] = {} self._send_queue: Deque[OutgoingPacket[IPAddressType]] = deque() self._send_limiter = send_limiter self._sent_rsts: Dict[Tuple[int, bytes, int], int] = {} self._loop = loop
def __init__(self, loop: asyncio.AbstractEventLoop, device_registry: BluetoothDeviceRegistry): return self.dev = evdev.InputDevice(mouse_event_device) self.hidraw = os.open(mouse_raw_device, os.O_RDWR | os.O_NONBLOCK) self.dev.grab() self.device_registry = device_registry self.loop = loop loop.add_reader(self.hidraw, self.mouse_event)
def setup_listener(self, qtile: "Qtile", eventloop: asyncio.AbstractEventLoop) -> None: """Setup a listener for the given qtile instance :param qtile: The qtile instance to dispatch events to. :param eventloop: The eventloop to use to listen to the file descriptor. """ logger.debug("Adding io watch") self.qtile = qtile fd = self.conn.conn.get_file_descriptor() eventloop.add_reader(fd, self._xpoll)
def __init__(self, event_loop: AbstractEventLoop, device="/dev/ttyUSB0"): """Create and open a new connection to an Optolink device.""" self.device = device self.loop = event_loop # timeout=0 for non-blocking reads self.port = serial.Serial( self.device, 4800, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_TWO, timeout=0, ) self.read_queue = asyncio.Queue() event_loop.add_reader(self.port.fileno(), self._read_serial)
def start_door_switch_watcher(self, loop: asyncio.AbstractEventLoop, update_door_state: Callable[[DoorState], None]): current_door_value = self.read_window_switches() if current_door_value == 0: update_door_state(DoorState.OPEN) else: update_door_state(DoorState.CLOSED) try: door_fd = self.lines['window_door_sw'].event_get_fd() loop.add_reader(door_fd, _event_callback, update_door_state, self.get_door_state) except Exception: MODULE_LOG.exception( "Failed to add fd reader, cannot not monitor window door " "switch properly")
def __init__(self, device: _Device, filter: HIDMessageFilter, loop: asyncio.AbstractEventLoop, device_registry: HIDDeviceRegistry): self.loop = loop self.filter = filter self.device_registry = device_registry self.device_id = device["instance"] self.device_class = device["id"] self.name = device["name"] self.hidraw = cast(str, device["hidraw"]) self.events = cast(List[str], device["events"]) self.events_devices = [] for event in self.events: event_device = evdev.InputDevice('/dev/input/'+event) event_device.grab() self.events_devices.append(event_device) self.hidraw_file: Optional[int] = os.open('/dev/'+self.hidraw, os.O_RDWR | os.O_NONBLOCK) loop.add_reader(self.hidraw_file, self.hidraw_event) print("HID Device ",self.device_id," created")
async def start_client(loop: asyncio.AbstractEventLoop, url: str) -> None: name = input("Please enter your name: ") # input reader def stdin_callback() -> None: line = sys.stdin.buffer.readline().decode("utf-8") if not line: loop.stop() else: ws.send_str(name + ": " + line) loop.add_reader(sys.stdin.fileno(), stdin_callback) async def dispatch() -> None: while True: msg = await ws.receive() if msg.type == aiohttp.WSMsgType.TEXT: print("Text: ", msg.data.strip()) elif msg.type == aiohttp.WSMsgType.BINARY: print("Binary: ", msg.data) elif msg.type == aiohttp.WSMsgType.PING: await ws.pong() elif msg.type == aiohttp.WSMsgType.PONG: print("Pong received") else: if msg.type == aiohttp.WSMsgType.CLOSE: await ws.close() elif msg.type == aiohttp.WSMsgType.ERROR: print("Error during receive %s" % ws.exception()) elif msg.type == aiohttp.WSMsgType.CLOSED: pass break # send request async with aiohttp.ClientSession() as client: async with client.ws_connect(url, autoclose=False, autoping=False) as ws: await dispatch()
async def setup_server(loop: asyncio.AbstractEventLoop) -> None: loop.create_task(heartbeat()) loop.add_reader(sys.stdin.fileno(), process_stdin) loop.add_signal_handler(signal.SIGINT, ask_exit)
async def _watch(self, loop: AbstractEventLoop): future = asyncio.Future() loop.add_reader(self.fd, future.set_result, None) future.add_done_callback(lambda _: loop.remove_reader(self.fd)) await future
async def wait_for_reader(fd: Union[int, io.BufferedReader], loop: asyncio.AbstractEventLoop) -> None: f: asyncio.Future = asyncio.Future() loop.add_reader(fd, f.set_result, None) f.add_done_callback(lambda f: loop.remove_reader(fd)) await f