bounded_subprocess 2.2.0__tar.gz → 2.3.1__tar.gz

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bounded_subprocess
-Version: 2.2.0
+Version: 2.3.1
 Summary: A library to facilitate running subprocesses that may misbehave.
 Project-URL: Homepage, https://github.com/arjunguha/bounded_subprocess
 Project-URL: Bug Tracker, https://github.com/arjunguha/bounded_subprocess

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bounded_subprocess"
-version = "2.2.0"
+version = "2.3.1"
 authors = [
   { name="Arjun Guha" },
   { name="Ming-Ho Yee" },

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/src/bounded_subprocess/bounded_subprocess.py

@@ -7,6 +7,7 @@ from .util import (
     SLEEP_BETWEEN_READS,
     write_loop_sync,
     _STDIN_WRITE_TIMEOUT,
+    SLEEP_BETWEEN_WRITES,
 )
 
 
@@ -16,6 +17,7 @@ def run(
     max_output_size: int = 2048,
     env=None,
     stdin_data: Optional[str] = None,
+    stdin_write_timeout: Optional[int] = None,
 ) -> Result:
     """
     Runs the given program with arguments. After the timeout elapses, kills the process
@@ -24,12 +26,16 @@ def run(
     """
     state = BoundedSubprocessState(args, env, max_output_size, stdin_data is not None)
     if stdin_data is not None:
-        write_loop_sync(
+        ok = write_loop_sync(
             state.write_chunk,
             stdin_data.encode(),
-            _STDIN_WRITE_TIMEOUT,
-            sleep_interval=SLEEP_BETWEEN_READS,
+            stdin_write_timeout if stdin_write_timeout is not None else 15,
+            sleep_interval=SLEEP_BETWEEN_WRITES,
         )
+        if not ok:
+            state.terminate()
+            return Result(True, -1, "", "failed to write to stdin")
+
         state.close_stdin()
 
     # We sleep for 0.1 seconds in each iteration.

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/src/bounded_subprocess/bounded_subprocess_async.py

@@ -4,7 +4,7 @@ from .util import (
     Result,
     BoundedSubprocessState,
     SLEEP_BETWEEN_READS,
-    write_loop_async,
+    write_nonblocking_async,
     _STDIN_WRITE_TIMEOUT,
 )
 
@@ -15,6 +15,7 @@ async def run(
     max_output_size: int = 2048,
     env=None,
     stdin_data: Optional[str] = None,
+    stdin_write_timeout: Optional[int] = None,
 ) -> Result:
     """
     Runs the given program with arguments. After the timeout elapses, kills the process
@@ -27,14 +28,16 @@ async def run(
     # async here? It's just the sleep between reads.
     state = BoundedSubprocessState(args, env, max_output_size, stdin_data is not None)
     if stdin_data is not None:
-        await write_loop_async(
-            state.write_chunk,
-            stdin_data.encode(),
-            _STDIN_WRITE_TIMEOUT,
-            sleep_interval=SLEEP_BETWEEN_READS,
+        write_ok = await write_nonblocking_async(
+            fd=state.p.stdin,
+            data=stdin_data.encode(),
+            timeout_seconds=stdin_write_timeout if stdin_write_timeout is not None else 15,
         )
         await state.close_stdin_async(_STDIN_WRITE_TIMEOUT)
 
+    # Notice that we do not immediately terminate if the write fails. This allows
+    # us to read an error message from the process.
+
     # We sleep for 0.1 seconds in each iteration.
     max_iterations = timeout_seconds * 10
 
@@ -45,5 +48,9 @@ async def run(
         else:
             break
 
-    return state.terminate()
+    result = state.terminate()
+    if stdin_data is not None and not write_ok:
+        result.exit_code = -1
+        result.stderr = result.stderr + "\nFailed to write all data to subprocess."
+    return result
 

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/src/bounded_subprocess/util.py

@@ -9,7 +9,8 @@ import asyncio
 
 MAX_BYTES_PER_READ = 1024
 SLEEP_BETWEEN_READS = 0.1
-_STDIN_WRITE_TIMEOUT = 3
+_STDIN_WRITE_TIMEOUT = 15
+SLEEP_BETWEEN_WRITES = 0.01
 
 
 class Result:
@@ -93,6 +94,59 @@ async def write_loop_async(
     return True
 
 
+async def can_write(fd):
+    """
+    Waits for the file descriptor to be writable.
+    """
+    future = asyncio.Future()
+    loop  = asyncio.get_running_loop()
+    loop.add_writer(fd, future.set_result, None)
+    future.add_done_callback(lambda f: loop.remove_writer(fd))
+    await future
+
+
+async def write_nonblocking_async(*, fd, data: bytes, timeout_seconds: int) -> bool:
+    """
+    Writes to a nonblocking file descriptor with the timeout.
+
+    Returns True if all the data was written. False indicates that there was
+    either a timeout or a broken pipe.
+    """
+    start_time_seconds = time.time()
+
+    # A slice, data[..], would create a copy. A memoryview does not.
+    mv = memoryview(data)
+    start = 0
+    while start < len(mv):
+        try:
+            # Write as much as possible without blocking.
+            written = fd.write(mv[start:])
+            if written is None:
+                written = 0
+            start = start + written
+        except BrokenPipeError:
+            return False
+        except BlockingIOError as exn:
+            if exn.errno != errno.EAGAIN:
+                # NOTE(arjun): I am not certain why this would happen. However,
+                # you are only supposed to retry on EAGAIN.
+                return False
+            # Some, but not all the bytes were written.
+            start = start + exn.characters_written
+            
+            # Compute how much more time we have left.
+            wait_timeout = timeout_seconds - (time.time() - start_time_seconds)
+            # We are already past the deadline, so abort.
+            if wait_timeout <= 0:
+                return False
+            try:
+                await asyncio.wait_for(can_write(fd), wait_timeout)
+            except asyncio.TimeoutError:
+                # Deadline elapsed, so abort.
+                return False
+
+    return True
+
 class BoundedSubprocessState:
     """State shared between synchronous and asynchronous subprocess helpers."""
 

bounded_subprocess-2.3.1/test/evil_programs/read_one_line.py

@@ -0,0 +1,5 @@
+import time
+x = input()
+print("I read one line")
+assert x == "Line 1"
+time.sleep(5)

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/test/test_async.py

@@ -103,3 +103,23 @@ async def test_stdin_data_async_echo():
     assert result.timeout is False
     assert result.stdout == data
     await assert_no_running_evil()
+
+@pytest.mark.asyncio
+async def test_read_one_line():
+    """
+    The test program reads just one line of input, but we are trying to send 
+    two. The program still runs and prints. It runs for longer than the
+    stdin_write_timeout, but shorter than timeout_seconds. However, we still
+    get -1 as the exit_code because it did not receive the entire input.
+    """
+    result = await run(
+        ["python3", ROOT / "read_one_line.py"],
+        timeout_seconds=30,
+        max_output_size=1024,
+        stdin_data="Line 1\n" + ("x" * 128 * 1024),
+        stdin_write_timeout=3,
+    )
+    assert result.exit_code == -1
+    assert result.timeout is False
+    assert result.stdout == "I read one line\n"
+    await assert_no_running_evil()

{bounded_subprocess-2.2.0 → bounded_subprocess-2.3.1}/uv.lock

@@ -4,7 +4,7 @@ requires-python = ">=3.9"
 
 [[package]]
 name = "bounded-subprocess"
-version = "1.5.0"
+version = "2.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "typeguard" },