Router refactoring to push Not Allowed and Not Found in middleware processing

Author: asvetlov

CHANGES.txt

@@ -28,6 +28,8 @@ CHANGES
   (`MultiDictProxy` and `CIMultiDictProxy`). Previous edition of
   multidicts was not a part of public API BTW.
 
+- Router refactoring to push Not Allowed and Not Found in middleware processing
+
 
 0.13.1 (12-31-2014)
 --------------------

aiohttp/web.py

@@ -1242,6 +1242,44 @@ def __repr__(self):
             directory=self._directory)
 
 
+class _NotFoundMatchInfo(UrlMappingMatchInfo):
+
+    def __init__(self):
+        super().__init__({}, None)
+
+    @property
+    def handler(self):
+        return self._not_found
+
+    @property
+    def route(self):
+        return None
+
+    @asyncio.coroutine
+    def _not_found(self, request):
+        raise HTTPNotFound()
+
+
+class _MethodNotAllowedMatchInfo(UrlMappingMatchInfo):
+
+    def __init__(self, method, allowed_methods):
+        super().__init__({}, None)
+        self._method = method
+        self._allowed_methods = allowed_methods
+
+    @property
+    def handler(self):
+        return self._not_allowed
+
+    @property
+    def route(self):
+        return None
+
+    @asyncio.coroutine
+    def _not_allowed(self, request):
+        raise HTTPMethodNotAllowed(self._method, self._allowed_methods)
+
+
 class UrlDispatcher(AbstractRouter, collections.abc.Mapping):
 
     DYN = re.compile(r'^\{(?P<var>[a-zA-Z][_a-zA-Z0-9]*)\}$')
@@ -1273,9 +1311,9 @@ def resolve(self, request):
                 return UrlMappingMatchInfo(match_dict, route)
         else:
             if allowed_methods:
-                raise HTTPMethodNotAllowed(method, allowed_methods)
+                return _MethodNotAllowedMatchInfo(method, allowed_methods)
             else:
-                raise HTTPNotFound()
+                return _NotFoundMatchInfo()
 
     def __iter__(self):
         return iter(self._routes)

docs/web.rst

@@ -367,7 +367,7 @@ other, like displaying *403 Forbidden page* or raising
 resource.  Also middleware may render errors raised by handler, do
 some pre- and post- processing like handling *CORS* and so on.
 
-.. warning::
+.. versionchanged:: 0.14
 
-   Middleware is executing **after** routing, thus it cannot process
-   route exceptions.
+   Middleware accepts route exceptions (:exc:`HTTPNotFound` and
+   :exc:`HTTPMethodNotAllowed`).

docs/web_reference.rst

@@ -924,12 +924,26 @@ Router is any object that implements :class:`AbstractRouter` interface.
    .. method:: resolve(requst)
 
       A :ref:`coroutine<coroutine>` that returns
-      :class:`AbstractMatchInfo` for *request* or raises http
-      exception like :exc:`HTTPNotFound` if there is no registered
-      route for *request*.
+      :class:`AbstractMatchInfo` for *request*.
+
+      The method never raises exception, but returns
+      :class:`AbstractMatchInfo` instance with ``None``
+      :attr:`~AbstractMatchInfo.route` and
+      :attr:`~AbstractMatchInfo.handler` which raises
+      :exc:`HTTPNotFound` or :exc:`HTTPMethodNotAllowed` on handler's
+      execution if there is no registered route for *request*.
+
+      *Middlewares* can process that exceptions to render
+      pretty-looking error page for example.
 
       Used by internal machinery, end user unlikely need to call the method.
 
+      .. versionchanged:: 0.14
+
+         The method don't raise :exc:`HTTPNotFound` and
+         :exc:`HTTPMethodNotAllowed` anymore.
+
+
 .. _aiohttp-web-route:
 
 Route

tests/test_urldispatch.py

@@ -130,8 +130,12 @@ def test_raise_method_not_allowed(self):
         self.router.add_route('POST', '/', handler2)
         req = self.make_request('PUT', '/')
 
+        match_info = self.loop.run_until_complete(self.router.resolve(req))
+        self.assertIsNone(match_info.route)
+        self.assertEqual({}, match_info)
+
         with self.assertRaises(HTTPMethodNotAllowed) as ctx:
-            self.loop.run_until_complete(self.router.resolve(req))
+            self.loop.run_until_complete(match_info.handler(req))
 
         exc = ctx.exception
         self.assertEqual('PUT', exc.method)
@@ -143,8 +147,12 @@ def test_raise_method_not_found(self):
         self.router.add_route('GET', '/a', handler)
         req = self.make_request('GET', '/b')
 
+        match_info = self.loop.run_until_complete(self.router.resolve(req))
+        self.assertIsNone(match_info.route)
+        self.assertEqual({}, match_info)
+
         with self.assertRaises(HTTPNotFound) as ctx:
-            self.loop.run_until_complete(self.router.resolve(req))
+            self.loop.run_until_complete(match_info.handler(req))
 
         exc = ctx.exception
         self.assertEqual(404, exc.status)
@@ -281,8 +289,11 @@ def test_add_route_with_re_not_match(self):
         self.router.add_route('GET', r'/handler/{to:\d+}', handler)
 
         req = self.make_request('GET', '/handler/tail')
+        match_info = self.loop.run_until_complete(self.router.resolve(req))
+        self.assertIsNone(match_info.route)
+        self.assertEqual({}, match_info)
         with self.assertRaises(HTTPNotFound):
-            self.loop.run_until_complete(self.router.resolve(req))
+            self.loop.run_until_complete(match_info.handler(req))
 
     def test_add_route_with_re_including_slashes(self):
         handler = asyncio.coroutine(lambda req: Response(req))