Add buf_read_size setting for configurable request body buffering

- Introduced `buf_read_size` setting to control buffer size for reading request data from the socket.
- Updated `Body` class to utilize `buf_read_size` for reading operations.
- Added validation for `buf_read_size` to ensure it is a positive integer.
- Enhanced tests to cover the new setting and its validation.

Author: ixunio

docs/content/reference/settings.md

@@ -1286,6 +1286,25 @@ If not set, the default temporary directory will be used.
     See [blocking-os-fchmod](#blocking_os_fchmod) for more detailed information
     and a solution for avoiding this problem.
 
+### `buf_read_size`
+
+**Command line:** `--buf-read-size INT`
+
+**Default:** `1024`
+
+Buffer size for reading request data from the socket.
+
+This controls the block size used while buffering request bodies for
+``wsgi.input``. Larger values can reduce Python loop overhead for large
+requests, while smaller values keep per-request buffering tighter.
+
+!!! note
+    Benchmarks show that, with WSGI workers, increased values up to
+    64 kB can improve bandwidth performance when transferring
+    large bodies, typically larger than 5 MB.
+
+The value must be greater than zero.
+
 ### `user`
 
 **Command line:** `-u USER`, `--user USER`

gunicorn/config.py

@@ -389,6 +389,17 @@ def validate_pos_int(val):
     return val
 
 
+def validate_strict_pos_int(val):
+    if not isinstance(val, int):
+        val = int(val, 0)
+    else:
+        # Booleans are ints!
+        val = int(val)
+    if val <= 0:
+        raise ValueError("Value must be greater than zero: %s" % val)
+    return val
+
+
 def validate_http2_frame_size(val):
     """Validate HTTP/2 max frame size per RFC 7540."""
     if not isinstance(val, int):
@@ -1192,6 +1203,30 @@ class WorkerTmpDir(Setting):
         """
 
 
+class BufReadSize(Setting):
+    name = "buf_read_size"
+    section = "Server Mechanics"
+    cli = ["--buf-read-size"]
+    meta = "INT"
+    validator = validate_strict_pos_int
+    type = int
+    default = 1024
+    desc = """\
+        Buffer size for reading request data from the socket.
+
+        This controls the block size used while buffering request bodies for
+        ``wsgi.input``. Larger values can reduce Python loop overhead for large
+        requests, while smaller values keep per-request buffering tighter.
+
+        .. note::
+              Benchmarks show that, with WSGI workers, increased values up to
+              64 kB can improve bandwidth performance when transferring
+              large bodies, typically larger than 5 MB.
+
+        The value must be greater than zero.
+        """
+
+
 class User(Setting):
     name = "user"
     section = "Server Mechanics"

gunicorn/http/body.py

@@ -184,8 +184,14 @@ def read(self, size):
 
 
 class Body:
-    def __init__(self, reader):
+    def __init__(self, reader, buf_read_size=1024):
+        if not isinstance(buf_read_size, int):
+            raise TypeError("buf_read_size must be an integral type")
+        if buf_read_size <= 0:
+            raise ValueError("buf_read_size must be greater than zero")
+
         self.reader = reader
+        self.buf_read_size = buf_read_size
         self.buf = io.BytesIO()
 
     def __iter__(self):
@@ -221,7 +227,7 @@ def read(self, size=None):
             return ret
 
         while size > self.buf.tell():
-            data = self.reader.read(1024)
+            data = self.reader.read(self.buf_read_size)
             if not data:
                 break
             self.buf.write(data)
@@ -251,7 +257,7 @@ def readline(self, size=None):
 
             ret.append(data)
             size -= len(data)
-            data = self.reader.read(min(1024, size))
+            data = self.reader.read(min(self.buf_read_size, size))
             if not data:
                 break
 

gunicorn/http/message.py

@@ -348,7 +348,7 @@ def set_body_reader(self):
                 # we cannot be certain the message framing we understood matches proxy intent
                 #  -> whatever happens next, remaining input must not be trusted
                 raise InvalidHeader("CONTENT-LENGTH", req=self)
-            self.body = Body(ChunkedReader(self, self.unreader))
+            self.body = Body(ChunkedReader(self, self.unreader), self.cfg.buf_read_size)
         elif content_length is not None:
             try:
                 if str(content_length).isnumeric():
@@ -361,9 +361,9 @@ def set_body_reader(self):
             if content_length < 0:
                 raise InvalidHeader("CONTENT-LENGTH", req=self)
 
-            self.body = Body(LengthReader(self.unreader, content_length))
+            self.body = Body(LengthReader(self.unreader, content_length), self.cfg.buf_read_size)
         else:
-            self.body = Body(EOFReader(self.unreader))
+            self.body = Body(EOFReader(self.unreader), self.cfg.buf_read_size)
 
     def should_close(self):
         if self.must_close:
@@ -828,4 +828,4 @@ def parse_request_line(self, line_bytes):
     def set_body_reader(self):
         super().set_body_reader()
         if isinstance(self.body.reader, EOFReader):
-            self.body = Body(LengthReader(self.unreader, 0))
+            self.body = Body(LengthReader(self.unreader, 0), self.cfg.buf_read_size)

gunicorn/uwsgi/message.py

@@ -222,7 +222,7 @@ def set_body_reader(self):
             except ValueError:
                 content_length = 0
 
-        self.body = Body(LengthReader(self.unreader, content_length))
+        self.body = Body(LengthReader(self.unreader, content_length), self.cfg.buf_read_size)
 
     def should_close(self):
         """Determine if the connection should be closed after this request."""

tests/test_config.py

@@ -157,6 +157,18 @@ def test_pos_int_validation():
     pytest.raises(TypeError, c.set, "workers", c)
 
 
+def test_strict_pos_int_validation():
+    c = config.Config()
+    assert c.buf_read_size == 1024
+    c.set("buf_read_size", 4096)
+    assert c.buf_read_size == 4096
+    c.set("buf_read_size", "8192")
+    assert c.buf_read_size == 8192
+    pytest.raises(ValueError, c.set, "buf_read_size", 0)
+    pytest.raises(ValueError, c.set, "buf_read_size", -1)
+    pytest.raises(TypeError, c.set, "buf_read_size", c)
+
+
 def test_str_validation():
     c = config.Config()
     assert c.proc_name == "gunicorn"
@@ -252,6 +264,9 @@ def test_cmd_line():
     with AltArgs(["prog_name", "-w", "3"]):
         app = NoConfigApp()
         assert app.cfg.workers == 3
+    with AltArgs(["prog_name", "--buf-read-size", "4096"]):
+        app = NoConfigApp()
+        assert app.cfg.buf_read_size == 4096
     with AltArgs(["prog_name", "--preload"]):
         app = NoConfigApp()
         assert app.cfg.preload_app

tests/test_http.py

@@ -81,6 +81,33 @@ def test_readline_buffer_loaded_with_size():
     assert body.readline(2) == b"f"
 
 
+def test_body_read_uses_configured_buf_read_size():
+    reader = mock.MagicMock()
+    reader.read.side_effect = [b"abcd", b"ef", b""]
+
+    body = Body(reader, buf_read_size=4)
+
+    assert body.read(6) == b"abcdef"
+    assert reader.read.call_args_list == [mock.call(4), mock.call(4)]
+
+
+def test_body_readline_uses_configured_buf_read_size():
+    reader = mock.MagicMock()
+    reader.read.side_effect = [b"abcd", b"ef\n", b""]
+
+    body = Body(reader, buf_read_size=4)
+
+    assert body.readline() == b"abcdef\n"
+    assert reader.read.call_args_list == [mock.call(4), mock.call(4)]
+
+
+def test_body_invalid_buf_read_size():
+    with pytest.raises(TypeError):
+        Body(io.BytesIO(b""), buf_read_size="1024")
+    with pytest.raises(ValueError):
+        Body(io.BytesIO(b""), buf_read_size=0)
+
+
 def test_http_header_encoding():
     """ tests whether http response headers are USASCII encoded """
 

tests/test_uwsgi.py

@@ -53,6 +53,7 @@ class MockConfig:
     def __init__(self, is_ssl=False, uwsgi_allow_ips=None):
         self.is_ssl = is_ssl
         self.uwsgi_allow_ips = uwsgi_allow_ips or ['127.0.0.1', '::1']
+        self.buf_read_size = 1024
 
 
 class TestUWSGIPacketConstruction: