uhttp-workers 1.0.0__tar.gz → 1.1.0__tar.gz

{uhttp_workers-1.0.0/uhttp_workers.egg-info → uhttp_workers-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-workers
-Version: 1.0.0
+Version: 1.1.0
 Summary: Multi-process worker dispatcher built on uhttp-server
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License-Expression: MIT
@@ -269,6 +269,7 @@ def process(self, request):
     # request.query        — {'page': '1'} or None
     # request.data         — dict (JSON), bytes (binary), or None
     # request.headers      — dict
+    # request.cookies      — dict (lazy-parsed from Cookie header)
     # request.content_type — 'application/json'
 
     # return data (status 200)
@@ -315,6 +316,43 @@ class MyDispatcher(_workers.Dispatcher):
 
 `do_check()` is only called for requests going to worker pools — static files and sync handlers are not affected.
 
+### Worker-Level Validation
+
+Override `do_check()` on the worker — runs before routing to handler:
+
+```python
+class MyWorker(_workers.Worker):
+    def do_check(self, request):
+        token = request.cookies.get('session')
+        if not token:
+            return {'error': 'unauthorized'}, 401
+```
+
+Return `(data, status)` tuple to reject, or `None` to continue. You can also raise `RejectRequest`:
+
+```python
+    def do_check(self, request):
+        if not self.validate_token(request.cookies.get('session')):
+            raise _workers.RejectRequest(
+                data={'error': 'forbidden'}, status=403)
+```
+
+`RejectRequest` accepts optional `data` (default: `{'error': 'Rejected'}`) and `status` (default: `403`).
+
+### Error Handling
+
+Override `on_request_error()` on the worker to customize error handling when a request handler raises an exception:
+
+```python
+class MyWorker(_workers.Worker):
+    def on_request_error(self, request, err):
+        if isinstance(err, DatabaseError):
+            self.db.reconnect()
+        return super().on_request_error(request, err)
+```
+
+Default behavior logs the error with traceback and returns 500.
+
 ## Post-Response Hook
 
 Override `on_response()` on the dispatcher to post-process after a response is sent to the client — e.g., forward data to another worker pool:
@@ -394,6 +432,15 @@ Log messages are sent to the dispatcher via the shared response queue and printe
 
 **Log levels:** `LOG_DEBUG` (10), `LOG_INFO` (20), `LOG_WARNING` (30), `LOG_ERROR` (40), `LOG_CRITICAL` (50)
 
+Check current level with `is_*` properties to skip expensive formatting:
+
+```python
+if self.log.is_debug:
+    self.log.debug("Details: %s", expensive_computation())
+```
+
+Available: `is_debug`, `is_info`, `is_warning`, `is_error`.
+
 Set minimum level per pool:
 
 ```python

{uhttp_workers-1.0.0 → uhttp_workers-1.1.0}/README.md

@@ -255,6 +255,7 @@ def process(self, request):
     # request.query        — {'page': '1'} or None
     # request.data         — dict (JSON), bytes (binary), or None
     # request.headers      — dict
+    # request.cookies      — dict (lazy-parsed from Cookie header)
     # request.content_type — 'application/json'
 
     # return data (status 200)
@@ -301,6 +302,43 @@ class MyDispatcher(_workers.Dispatcher):
 
 `do_check()` is only called for requests going to worker pools — static files and sync handlers are not affected.
 
+### Worker-Level Validation
+
+Override `do_check()` on the worker — runs before routing to handler:
+
+```python
+class MyWorker(_workers.Worker):
+    def do_check(self, request):
+        token = request.cookies.get('session')
+        if not token:
+            return {'error': 'unauthorized'}, 401
+```
+
+Return `(data, status)` tuple to reject, or `None` to continue. You can also raise `RejectRequest`:
+
+```python
+    def do_check(self, request):
+        if not self.validate_token(request.cookies.get('session')):
+            raise _workers.RejectRequest(
+                data={'error': 'forbidden'}, status=403)
+```
+
+`RejectRequest` accepts optional `data` (default: `{'error': 'Rejected'}`) and `status` (default: `403`).
+
+### Error Handling
+
+Override `on_request_error()` on the worker to customize error handling when a request handler raises an exception:
+
+```python
+class MyWorker(_workers.Worker):
+    def on_request_error(self, request, err):
+        if isinstance(err, DatabaseError):
+            self.db.reconnect()
+        return super().on_request_error(request, err)
+```
+
+Default behavior logs the error with traceback and returns 500.
+
 ## Post-Response Hook
 
 Override `on_response()` on the dispatcher to post-process after a response is sent to the client — e.g., forward data to another worker pool:
@@ -380,6 +418,15 @@ Log messages are sent to the dispatcher via the shared response queue and printe
 
 **Log levels:** `LOG_DEBUG` (10), `LOG_INFO` (20), `LOG_WARNING` (30), `LOG_ERROR` (40), `LOG_CRITICAL` (50)
 
+Check current level with `is_*` properties to skip expensive formatting:
+
+```python
+if self.log.is_debug:
+    self.log.debug("Details: %s", expensive_computation())
+```
+
+Available: `is_debug`, `is_info`, `is_warning`, `is_error`.
+
 Set minimum level per pool:
 
 ```python

{uhttp_workers-1.0.0 → uhttp_workers-1.1.0}/tests/test_worker.py

@@ -4,7 +4,9 @@ import time
 import unittest
 import multiprocessing as mp
 
-from uhttp.workers import Worker, Request, Response, api, MSG_RESPONSE, MSG_HEARTBEAT
+from uhttp.workers import (
+    Worker, Request, Response, api, RejectRequest,
+    MSG_RESPONSE, MSG_HEARTBEAT)
 
 
 class SimpleWorker(Worker):
@@ -95,6 +97,101 @@ class TestWorkerHandleRequest(unittest.TestCase):
         self.assertEqual(resp.status, 405)
 
 
+class CheckWorker(Worker):
+    """Worker with do_check that rejects unauthorized requests."""
+
+    def do_check(self, request):
+        token = request.cookies.get('session')
+        if not token:
+            return {'error': 'unauthorized'}, 401
+
+    @api('/secret', 'GET')
+    def secret(self, request):
+        return {'data': 'secret'}
+
+
+class RejectWorker(Worker):
+    """Worker with do_check that raises RejectRequest."""
+
+    def do_check(self, request):
+        raise RejectRequest()
+
+    @api('/data', 'GET')
+    def data(self, request):
+        return {'data': 'ok'}
+
+
+class FailCheckWorker(Worker):
+    """Worker with do_check that raises unexpected exception."""
+
+    def do_check(self, request):
+        raise RuntimeError("check failed")
+
+    @api('/data', 'GET')
+    def data(self, request):
+        return {'data': 'ok'}
+
+
+class TestWorkerDoCheck(unittest.TestCase):
+
+    def test_do_check_reject(self):
+        queues = [mp.Queue() for _ in range(3)]
+        worker = CheckWorker(0, *queues)
+        worker._build_routes()
+        req = Request(1, 'GET', '/secret')
+        resp = worker._handle_request(req)
+        self.assertEqual(resp.status, 401)
+
+    def test_do_check_pass(self):
+        queues = [mp.Queue() for _ in range(3)]
+        worker = CheckWorker(0, *queues)
+        worker._build_routes()
+        req = Request(1, 'GET', '/secret',
+            headers={'cookie': 'session=abc123'})
+        resp = worker._handle_request(req)
+        self.assertEqual(resp.status, 200)
+        self.assertEqual(resp.data, {'data': 'secret'})
+
+    def test_do_check_reject_request(self):
+        queues = [mp.Queue() for _ in range(3)]
+        worker = RejectWorker(0, *queues)
+        worker._build_routes()
+        req = Request(1, 'GET', '/data')
+        resp = worker._handle_request(req)
+        self.assertEqual(resp.status, 403)
+
+    def test_do_check_exception(self):
+        queues = [mp.Queue() for _ in range(3)]
+        worker = FailCheckWorker(0, *queues)
+        worker._build_routes()
+        req = Request(1, 'GET', '/data')
+        resp = worker._handle_request(req)
+        self.assertEqual(resp.status, 500)
+
+
+class TestRequestCookies(unittest.TestCase):
+
+    def test_cookies_parsed(self):
+        req = Request(1, 'GET', '/',
+            headers={'cookie': 'session=abc; user=john'})
+        self.assertEqual(req.cookies, {'session': 'abc', 'user': 'john'})
+
+    def test_cookies_empty(self):
+        req = Request(1, 'GET', '/')
+        self.assertEqual(req.cookies, {})
+
+    def test_cookies_no_cookie_header(self):
+        req = Request(1, 'GET', '/', headers={'content-type': 'text/html'})
+        self.assertEqual(req.cookies, {})
+
+    def test_cookies_cached(self):
+        req = Request(1, 'GET', '/',
+            headers={'cookie': 'a=1'})
+        c1 = req.cookies
+        c2 = req.cookies
+        self.assertIs(c1, c2)
+
+
 class TestWorkerMatchRoute(unittest.TestCase):
 
     def setUp(self):

{uhttp_workers-1.0.0 → uhttp_workers-1.1.0}/uhttp/workers.py

@@ -69,7 +69,11 @@ class ApiException(Exception):
 
 
 class RejectRequest(ApiException):
-    """Raised in do_check() to reject request (response already sent)."""
+    """Raised in do_check() to reject request with custom status/data."""
+
+    def __init__(self, data=None, status=403):
+        self.data = data if data is not None else {'error': 'Rejected'}
+        self.status = status
 
 
 # Route decorator
@@ -199,7 +203,8 @@ class Request:
 
     __slots__ = (
         'request_id', 'method', 'path', 'query',
-        'data', 'headers', 'content_type', 'path_params')
+        'data', 'headers', 'content_type', 'path_params',
+        '_cookies')
 
     def __init__(
             self, request_id, method, path, query=None,
@@ -212,6 +217,16 @@ class Request:
         self.headers = headers or {}
         self.content_type = content_type
         self.path_params = {}
+        self._cookies = None
+
+    @property
+    def cookies(self):
+        """Cookies dict, parsed from Cookie header."""
+        if self._cookies is None:
+            raw = self.headers.get('cookie', '')
+            self._cookies = (
+                _uhttp_server.parse_cookies(raw) if raw else {})
+        return self._cookies
 
 
 class Response:
@@ -271,6 +286,22 @@ class Logger:
         self.level = level
         self._queue = queue
 
+    @property
+    def is_debug(self):
+        return self.level <= LOG_DEBUG
+
+    @property
+    def is_info(self):
+        return self.level <= LOG_INFO
+
+    @property
+    def is_warning(self):
+        return self.level <= LOG_WARNING
+
+    @property
+    def is_error(self):
+        return self.level <= LOG_ERROR
+
     def _log(self, level, msg, *args, **kwargs):
         if level >= self.level:
             try:
@@ -453,8 +484,37 @@ class Worker(_mp.Process):
             if isinstance(msg, tuple) and msg[0] == CTL_CONFIG:
                 self.on_config(msg[1])
 
+    def do_check(self, request):
+        """Validation hook called before routing request to handler.
+
+        Override for authentication, session validation, etc.
+        Raise RejectRequest to reject with custom response.
+
+        Args:
+            request: Request object with headers, cookies, etc.
+
+        Returns:
+            None to continue, or (data, status) tuple to reject.
+        """
+
     def _handle_request(self, request):
         """Route and handle a single request, return Response."""
+        try:
+            result = self.do_check(request)
+            if result is not None:
+                data, status = result
+                return Response(request.request_id, data=data, status=status)
+        except RejectRequest as err:
+            return Response(
+                request.request_id,
+                data=err.data,
+                status=err.status)
+        except Exception as err:
+            self.log.error("do_check: %s\n%s", err, _traceback.format_exc())
+            return Response(
+                request.request_id,
+                data={'error': 'Internal server error'},
+                status=500)
         handler = self._match_route(request)
         if handler is None:
             # check if path matches but method doesn't
@@ -477,14 +537,22 @@ class Worker(_mp.Process):
                 data, status = result, 200
             return Response(request.request_id, data=data, status=status)
         except Exception as err:
-            self.log.error(
-                "%s %s: %s\n%s",
-                request.method, request.path, err,
-                _traceback.format_exc())
-            return Response(
-                request.request_id,
-                data={'error': str(err)},
-                status=500)
+            return self.on_request_error(request, err)
+
+    def on_request_error(self, request, err):
+        """Called when request handler raises an exception.
+
+        Override to customize error handling (e.g., DB reconnect).
+        Default logs the error with traceback and returns 500 response.
+        """
+        self.log.error(
+            "%s %s: %s\n%s",
+            request.method, request.path, err,
+            _traceback.format_exc())
+        return Response(
+            request.request_id,
+            data={'error': str(err)},
+            status=500)
 
     def run(self):
         """Worker main loop using select for multiplexing."""

{uhttp_workers-1.0.0 → uhttp_workers-1.1.0/uhttp_workers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uhttp-workers
-Version: 1.0.0
+Version: 1.1.0
 Summary: Multi-process worker dispatcher built on uhttp-server
 Author-email: Pavel Revak <pavelrevak@gmail.com>
 License-Expression: MIT
@@ -269,6 +269,7 @@ def process(self, request):
     # request.query        — {'page': '1'} or None
     # request.data         — dict (JSON), bytes (binary), or None
     # request.headers      — dict
+    # request.cookies      — dict (lazy-parsed from Cookie header)
     # request.content_type — 'application/json'
 
     # return data (status 200)
@@ -315,6 +316,43 @@ class MyDispatcher(_workers.Dispatcher):
 
 `do_check()` is only called for requests going to worker pools — static files and sync handlers are not affected.
 
+### Worker-Level Validation
+
+Override `do_check()` on the worker — runs before routing to handler:
+
+```python
+class MyWorker(_workers.Worker):
+    def do_check(self, request):
+        token = request.cookies.get('session')
+        if not token:
+            return {'error': 'unauthorized'}, 401
+```
+
+Return `(data, status)` tuple to reject, or `None` to continue. You can also raise `RejectRequest`:
+
+```python
+    def do_check(self, request):
+        if not self.validate_token(request.cookies.get('session')):
+            raise _workers.RejectRequest(
+                data={'error': 'forbidden'}, status=403)
+```
+
+`RejectRequest` accepts optional `data` (default: `{'error': 'Rejected'}`) and `status` (default: `403`).
+
+### Error Handling
+
+Override `on_request_error()` on the worker to customize error handling when a request handler raises an exception:
+
+```python
+class MyWorker(_workers.Worker):
+    def on_request_error(self, request, err):
+        if isinstance(err, DatabaseError):
+            self.db.reconnect()
+        return super().on_request_error(request, err)
+```
+
+Default behavior logs the error with traceback and returns 500.
+
 ## Post-Response Hook
 
 Override `on_response()` on the dispatcher to post-process after a response is sent to the client — e.g., forward data to another worker pool:
@@ -394,6 +432,15 @@ Log messages are sent to the dispatcher via the shared response queue and printe
 
 **Log levels:** `LOG_DEBUG` (10), `LOG_INFO` (20), `LOG_WARNING` (30), `LOG_ERROR` (40), `LOG_CRITICAL` (50)
 
+Check current level with `is_*` properties to skip expensive formatting:
+
+```python
+if self.log.is_debug:
+    self.log.debug("Details: %s", expensive_computation())
+```
+
+Available: `is_debug`, `is_info`, `is_warning`, `is_error`.
+
 Set minimum level per pool:
 
 ```python