Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 8 additions & 2 deletions src/evdev/eventio_async.py
Original file line number Diff line number Diff line change
Expand Up @@ -44,10 +44,14 @@ def __anext__(self) -> "asyncio.Future[InputEvent]":

def next_batch_ready(batch):
try:
self.current_batch = batch.result()
result = batch.result()
if future.done():
return
self.current_batch = result
future.set_result(next(self.current_batch))
except Exception as e:
future.set_exception(e)
if not future.done():
future.set_exception(e)

self.device.async_read().add_done_callback(next_batch_ready)
return future
Expand All @@ -71,6 +75,8 @@ def ready():
loop.add_reader(self.fileno(), ready)

def _set_result(self, future, cb) -> None:
if future.done():
return
try:
future.set_result(cb())
except Exception as error:
Expand Down
107 changes: 107 additions & 0 deletions tests/test_async_cancellation.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,107 @@
import asyncio
import os

import pytest

from evdev import _uinput, ecodes
from evdev.eventio_async import EventIO


class PipeEventIO(EventIO):
"""Drive the native input-event reader with a pipe instead of hardware."""

def __init__(self):
self.fd, self.writer = os.pipe2(os.O_NONBLOCK)
self.readable = asyncio.Event()

def _do_when_readable(self, callback):
def observed():
try:
callback()
finally:
self.readable.set()

super()._do_when_readable(observed)

def write_key(self):
_uinput.write(self.writer, ecodes.EV_KEY, ecodes.KEY_A, 1)

def close(self):
super().close()
os.close(self.fd)
os.close(self.writer)


def start_read(device, mode):
if mode == "loop":
return device.async_read_loop().__anext__()
return getattr(device, "async_" + mode)()


@pytest.mark.parametrize("mode", ["read_one", "read", "loop"])
@pytest.mark.parametrize("read_error", [False, True])
def test_cancelled_read_preserves_next_event(mode, read_error):
async def check():
errors = []
loop = asyncio.get_running_loop()
loop.set_exception_handler(lambda loop, context: errors.append(context))
device = PipeEventIO()
try:
pending = start_read(device, mode)
if read_error:
def fail():
raise OSError("device disconnected")

device.read = device.read_one = fail
pending.cancel()
device.write_key()
await asyncio.wait_for(device.readable.wait(), 1)
assert pending.cancelled()
assert errors == []
if read_error:
del device.read, device.read_one
event = await asyncio.wait_for(device.async_read_one(), 1)
assert (event.type, event.code, event.value) == (ecodes.EV_KEY, ecodes.KEY_A, 1)
finally:
device.close()

asyncio.run(check())


@pytest.mark.parametrize("mode", ["read_one", "read", "loop"])
def test_active_read_preserves_error(mode):
async def check():
device = PipeEventIO()
error = OSError("device disconnected")

def fail():
raise error

device.read = device.read_one = fail
try:
pending = start_read(device, mode)
device.write_key()
with pytest.raises(OSError) as caught:
await asyncio.wait_for(pending, 1)
assert caught.value is error
finally:
device.close()

asyncio.run(check())


@pytest.mark.parametrize("mode", ["read_one", "read", "loop"])
def test_active_read_still_delivers_event(mode):
async def check():
device = PipeEventIO()
try:
pending = start_read(device, mode)
device.write_key()
event = await asyncio.wait_for(pending, 1)
if mode == "read":
event = next(event)
assert (event.type, event.code, event.value) == (ecodes.EV_KEY, ecodes.KEY_A, 1)
finally:
device.close()

asyncio.run(check())