uhttp-server 2.3.1__tar.gz → 2.3.2__tar.gz

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-server
-Version: 2.3.1
+Version: 2.3.2
 Summary: Micro HTTP server for Python and MicroPython
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License: MIT

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/tests/test_mpy_websocket.py

@@ -67,7 +67,7 @@ WIFI_PASSWORD = _config['password']
 
 ESP32_SERVER_PORT = 8081  # Different from test_mpy_integration
 
-_WS_MAGIC = b'258EAFA5-E914-47DA-95CA-5AB9141B3175'
+_WS_MAGIC = b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
 
 WS_OPCODE_TEXT = 0x1
 WS_OPCODE_BINARY = 0x2

uhttp_server-2.3.2/tests/test_timeout_during_response.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Test that connections with in-progress response are not timed out with 408.
+
+When a connection is sending a large response (e.g., file streaming),
+the keep-alive timeout should not interrupt it with a 408 response.
+"""
+import unittest
+import socket
+import time
+import select
+import tempfile
+import os
+from uhttp import server as uhttp_server
+
+
+class TestTimeoutDuringResponse(unittest.TestCase):
+    """Test that _cleanup_idle_connections skips connections with _response_started"""
+
+    PORT = 9998
+
+    def test_no_408_while_response_in_progress(self):
+        """Connection streaming file response should not get 408 timeout"""
+        temp_dir = tempfile.mkdtemp()
+        large_file = os.path.join(temp_dir, 'large.bin')
+        with open(large_file, 'wb') as f:
+            f.write(b'X' * 200_000)
+
+        server = uhttp_server.HttpServer(
+            port=self.PORT, keep_alive_timeout=0.3, file_chunk_size=512)
+        trigger_sock = None
+
+        try:
+            client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            client_sock.connect(('localhost', self.PORT))
+            client_sock.setblocking(False)
+            client_sock.send(
+                b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
+            time.sleep(0.1)
+
+            connection = None
+            for _ in range(10):
+                r, _, _ = select.select(server.read_sockets, [], [], 0.1)
+                if r:
+                    connection = server.event_read(r)
+                    if connection:
+                        break
+            self.assertIsNotNone(connection)
+
+            connection.respond_file(large_file)
+            self.assertTrue(connection._response_started)
+
+            # Wait longer than keep_alive_timeout
+            time.sleep(0.5)
+
+            # Trigger cleanup via new connection
+            trigger_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            trigger_sock.connect(('localhost', self.PORT))
+            time.sleep(0.1)
+
+            r, _, _ = select.select(server.read_sockets, [], [], 0.2)
+            if r:
+                server.event_read(r)
+
+            self.assertIsNotNone(
+                connection.socket,
+                "Connection should not be closed while response is in progress")
+
+            # Drain the response
+            response = b""
+            for _ in range(200):
+                w = server.write_sockets
+                if w:
+                    _, ww, _ = select.select([], w, [], 0.1)
+                    if ww:
+                        server.event_write(ww)
+                try:
+                    chunk = client_sock.recv(65536)
+                    if chunk:
+                        response += chunk
+                    else:
+                        break
+                except BlockingIOError:
+                    continue
+
+            self.assertIn(b'200 OK', response)
+            self.assertIn(b'X' * 100, response)
+
+        finally:
+            client_sock.close()
+            if trigger_sock:
+                trigger_sock.close()
+            # Close server first so file handles are released (Windows)
+            server.close()
+            time.sleep(0.1)
+            try:
+                os.unlink(large_file)
+                os.rmdir(temp_dir)
+            except OSError:
+                pass
+
+    def test_idle_keepalive_still_gets_408(self):
+        """Idle keep-alive connection (no response started) should still get 408"""
+        server = uhttp_server.HttpServer(
+            port=self.PORT + 1, keep_alive_timeout=0.3)
+        trigger_sock = None
+
+        try:
+            client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            client_sock.connect(('localhost', self.PORT + 1))
+            client_sock.setblocking(False)
+
+            client_sock.send(
+                b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
+            time.sleep(0.1)
+
+            # Process the request and respond
+            for _ in range(10):
+                r, _, _ = select.select(server.read_sockets, [], [], 0.1)
+                if r:
+                    connection = server.event_read(r)
+                    if connection:
+                        connection.respond('ok')
+                        break
+
+            # Flush send buffer
+            for _ in range(20):
+                w = server.write_sockets
+                if w:
+                    _, ww, _ = select.select([], w, [], 0.1)
+                    if ww:
+                        server.event_write(ww)
+                else:
+                    break
+
+            # Drain the first response
+            try:
+                while True:
+                    client_sock.recv(4096)
+            except BlockingIOError:
+                pass
+
+            # Wait for keep-alive timeout
+            time.sleep(0.5)
+
+            # Trigger cleanup
+            trigger_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            trigger_sock.connect(('localhost', self.PORT + 1))
+            time.sleep(0.1)
+
+            r, _, _ = select.select(server.read_sockets, [], [], 0.2)
+            if r:
+                server.event_read(r)
+
+            # Flush 408 response
+            for _ in range(20):
+                w = server.write_sockets
+                if w:
+                    _, ww, _ = select.select([], w, [], 0.1)
+                    if ww:
+                        server.event_write(ww)
+                else:
+                    break
+
+            # Read the 408 response
+            time.sleep(0.1)
+            response = b""
+            try:
+                for _ in range(10):
+                    chunk = client_sock.recv(4096)
+                    if chunk:
+                        response += chunk
+                    else:
+                        break
+            except (BlockingIOError, ConnectionResetError, BrokenPipeError):
+                pass
+
+            self.assertIn(b'408', response)
+
+        finally:
+            client_sock.close()
+            if trigger_sock:
+                trigger_sock.close()
+            server.close()
+
+
+if __name__ == '__main__':
+    unittest.main()

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/tests/test_websocket.py

@@ -471,6 +471,42 @@ class TestWebSocketEventMode(unittest.TestCase):
         finally:
             sock.close()
 
+    def test_http_keepalive_then_ws_upgrade(self):
+        """Test HTTP keep-alive requests followed by WebSocket upgrade on same connection"""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            sock.connect(('localhost', self.PORT))
+            sock.settimeout(3)
+
+            # Send HTTP request on keep-alive connection
+            sock.sendall(
+                b"GET /test HTTP/1.1\r\n"
+                b"Host: localhost\r\n\r\n")
+            response = b''
+            while b'\r\n\r\n' not in response:
+                response += sock.recv(1024)
+            self.assertIn(b'200 OK', response)
+
+            # Send second HTTP request on same connection
+            sock.sendall(
+                b"GET /test2 HTTP/1.1\r\n"
+                b"Host: localhost\r\n\r\n")
+            response = b''
+            while b'\r\n\r\n' not in response:
+                response += sock.recv(1024)
+            self.assertIn(b'200 OK', response)
+
+            # Now upgrade to WebSocket on the same connection
+            ws_upgrade(sock)
+
+            # WebSocket should work
+            sock.sendall(build_masked_frame(WS_OPCODE_TEXT, 'after keepalive'))
+            fin, opcode, payload = recv_frame(sock)
+            self.assertEqual(opcode, WS_OPCODE_TEXT)
+            self.assertEqual(payload.decode(), 'after keepalive')
+        finally:
+            sock.close()
+
     def test_empty_ping(self):
         """Test ping with empty payload"""
         sock = self._connect_ws()

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/tests/test_websocket_utils.py

@@ -16,7 +16,7 @@ class TestWsAcceptKey(unittest.TestCase):
     def test_rfc_example(self):
         """Test with RFC 6455 example key"""
         key = "dGhlIHNhbXBsZSBub25jZQ=="
-        expected = "MWp/lNvnLAWD1TD0HICsGGCP88w="
+        expected = "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="
         self.assertEqual(_ws_accept_key(key), expected)
 
     def test_known_key(self):

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/uhttp/server.py

@@ -103,7 +103,7 @@ WS_OPCODE_CLOSE = 0x8
 WS_OPCODE_PING = 0x9
 WS_OPCODE_PONG = 0xA
 
-_WS_MAGIC = b'258EAFA5-E914-47DA-95CA-5AB9141B3175'
+_WS_MAGIC = b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
 
 STATUS_CODES = {
     100: "Continue",
@@ -1602,6 +1602,7 @@ class HttpConnection(_WsFrameMixin):
                 WS_OPCODE_TEXT, data.encode('utf-8')))
         else:
             self._send(_ws_build_frame(WS_OPCODE_BINARY, data))
+        self.update_activity()
 
     def ws_ping(self, data=b''):
         """Send WebSocket ping (event mode)"""
@@ -1741,6 +1742,8 @@ class HttpServer():
                 if connection.is_timed_out:
                     connection.close()
                 continue
+            if connection._response_started:
+                continue
             if not connection.is_loaded and connection.is_timed_out:
                 connection.respond(
                     'Request Timeout', status=408,

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/uhttp_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-server
-Version: 2.3.1
+Version: 2.3.2
 Summary: Micro HTTP server for Python and MicroPython
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License: MIT

{uhttp_server-2.3.1 → uhttp_server-2.3.2}/uhttp_server.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ tests/test_respond_falsy.py
 tests/test_respond_file.py
 tests/test_respond_file_race.py
 tests/test_ssl.py
+tests/test_timeout_during_response.py
 tests/test_utils.py
 tests/test_websocket.py
 tests/test_websocket_utils.py