USB/IP: Run Blocking Operations in Thread

Some sysfs file writes block for more than 100 ms, which causes an
asyncio warning. Run those blocking writes in threads, so the event loop
isn't blocked.

not_my_board/_usbip.py

@@ -143,12 +143,15 @@ def refresh(self):
     async def _context_stack(self, stack):
         await stack.enter_async_context(self._lock)
         await self.available()
-        stack.callback(self.stop_export)
+        stack.push_async_callback(self.stop_export)
 
-    def stop_export(self):
+    async def stop_export(self):
         if self._is_exported:
             try:
-                (self._sysfs_path / "usbip_sockfd").write_text("-1\n")
+                # This can block for ~ 250 ms. Run it in a thread.
+                await util.run_in_thread(
+                    (self._sysfs_path / "usbip_sockfd").write_text, "-1\n"
+                )
             except (OSError, FileNotFoundError):
                 # client might have disconnected or device disappeared
                 pass
@@ -192,7 +195,10 @@ async def _ensure_usbip_host_driver(self):
                 logger.info(
                     'Unbinding USB device %s from driver "%s"', self._busid, driver_name
                 )
-                (driver_path / "unbind").write_text(self._busid)
+                # Unbinding can take more than 100 ms. Run in Thread.
+                await util.run_in_thread(
+                    (driver_path / "unbind").write_text, self._busid
+                )
                 await self._bind_usbip_host_driver()
         elif self._sysfs_path.exists():
             await self._bind_usbip_host_driver()

not_my_board/_util/__init__.py

@@ -10,6 +10,7 @@
     relay_streams,
     run,
     run_concurrently,
+    run_in_thread,
 )
 from ._logging import configure_logging
 from ._matching import find_matching

not_my_board/_util/_asyncio.py

@@ -247,9 +247,13 @@ async def __aexit__(self, exc_type, exc, tb):
 async def flock(f):
     """File lock as a context manager"""
 
-    loop = asyncio.get_running_loop()
     try:
-        await loop.run_in_executor(None, fcntl.flock, f.fileno(), fcntl.LOCK_EX)
+        await run_in_thread(fcntl.flock, f.fileno(), fcntl.LOCK_EX)
         yield
     finally:
         fcntl.flock(f, fcntl.LOCK_UN)
+
+
+async def run_in_thread(func, *args):
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(None, func, *args)