chore: routing refactor

Author: vinniefalco

example/server/main.cpp

@@ -68,6 +68,7 @@ int server_main( int argc, char* argv[] )
             std::atoi(argv[4]));
 
         //srv.wwwroot.use("/log", serve_log_admin(app));
+        srv.wwwroot.use("/alt", serve_static( argv[3] ));
         srv.wwwroot.use("/", serve_static( argv[3] ));
 
         app.start();

example/server/serve_detached.hpp

@@ -42,17 +42,20 @@ class serve_detached
         Request&,
         Response& res) const
     {
-        auto resume = res.detach();
-        asio::post(*tp_,
-            [&, resume]()
+        return res.detach(
+            [&](resumer resume)
             {
-                // Simulate some asynchronous work
-                std::this_thread::sleep_for(std::chrono::seconds(1));
-                res.status(http_proto::status::ok);
-                res.set_body("Hello from serve_detached!\n");
-                resume(error::success);
+                asio::post(*tp_,
+                    [&, resume]()
+                    {
+                        // Simulate some asynchronous work
+                        std::this_thread::sleep_for(std::chrono::seconds(1));
+                        res.status(http_proto::status::ok);
+                        res.set_body("Hello from serve_detached!\n");
+                        resume(route::send);
+                        // resume( res.send("Hello from serve_detached!\n") );
+                    });
             });
-        return error::detach;
     }
 
 private:

include/boost/beast2/error.hpp

@@ -24,20 +24,6 @@ namespace beast2 {
 enum class error
 {
     success = 0,
-
-    // Routing
-
-    /** The route handler did not satisfy the request
-    */
-    next,
-
-    /** The route handler is detaching from the session
-    */
-    detach,
-
-    /** The route handler wants to close the connection
-    */
-    close
 };
 
 } // beast2

include/boost/beast2/server/basic_router.hpp

@@ -15,7 +15,7 @@
 #include <boost/beast2/detail/call_traits.hpp>
 #include <boost/beast2/detail/type_traits.hpp>
 #include <boost/http_proto/method.hpp>
-#include <boost/url/segments_encoded_view.hpp>
+#include <boost/url/url_view.hpp>
 #include <boost/core/detail/string_view.hpp>
 #include <type_traits>
 
@@ -26,17 +26,21 @@ struct route_state
 {
 private:
     friend class detail::any_router;
-    template<class Res, class Req>
+    template<class, class>
     friend class basic_router;
 
     std::size_t pos = 0;
     std::size_t resume = 0;
-    system::error_code ec;
+    route_result ec;
+    http_proto::method verb;
+    core::string_view verb_str;
+    std::string decoded_path;
 };
 
 //------------------------------------------------
 
 /** A container for HTTP route handlers
+
     The basic_router class template is used to
     store and invoke route handlers based on
     the request method and path.
@@ -46,99 +50,154 @@ struct route_state
     Handlers are invoked by calling the
     function call operator with a request
     and response object.
-    @tparam Request The type of request object.
-    @tparam Response The type of response object.
+
+    Express treats all route definitions as decoded path patterns, not raw URL-encoded ones.
+    So a literal %2F in the pattern string is indistinguishable from a literal / once Express builds the layer.
+    Therefore "/x%2Fz" is the same as "/x/z"
+
     @par Example
     @code
-    using router_type = basic_router<Request, Response>;
+    using router_type = basic_router<Req, Res>;
     router_type router;
     router.get("/hello",
-        [](Request& req, Response& res)
+        [](Req& req, Res& res)
         {
             res.status(http_proto::status::ok);
             res.set_body("Hello, world!");
             return system::error_code{};
         });
     @endcode
+
+    @tparam Req The type of request object.
+    @tparam Res The type of response object.
 */
-template<class Request, class Response>
+template<class Req, class Res>
 class basic_router : public detail::any_router
 {
-    static constexpr http_proto::method all_methods =
-        http_proto::method::unknown;
+    static constexpr http_proto::method
+        middleware = http_proto::method::unknown;
 
 public:
     /** The type of request object used in handlers
 
         Route handlers must have this invocable signature
         @code
-        system::error_code(Request&, Response&)
+        system::error_code(Req&, Res&)
         @endcode
     */
-    using request_type = Request;
+    using request_type = Req;
 
     /** The type of response object used in handlers
 
         Route handlers must have this invocable signature
         @code
-        system::error_code(Request&, Response&)
+        system::error_code(Req&, Res&)
         @endcode
     */
-    using response_type = Response;
+    using response_type = Res;
 
     /** Constructor
     */
     basic_router()
         : any_router(
             [](void* preq) -> req_info
             {
-                auto& req = *reinterpret_cast<Request*>(preq);
-                req_info ri;
-                ri.method = req.method;
-                ri.base_path = &req.base_path;
-                ri.suffix_path = &req.suffix_path;
-                ri.path = &req.path;
-                return ri;
+                auto& req = *reinterpret_cast<Req*>(preq);
+                return req_info{ req.base_path, req.path };
             })
     {
     }
 
     /** Constructor
     */
     template<
-        class DerivedRequest, class DerivedResponse,
+        class OtherReq, class OtherRes,
         class = typename std::enable_if<
-            detail::derived_from<Request, DerivedRequest>::value &&
-            detail::derived_from<Response, DerivedResponse>::value>::type
+            detail::derived_from<Req, OtherReq>::value &&
+            detail::derived_from<Res, OtherRes>::value>::type
     >
     basic_router(
-        basic_router<DerivedRequest, DerivedResponse> const& other)
+        basic_router<OtherReq, OtherRes> const& other)
         : any_router(other)
     {
     }
 
-    /** Add a global middleware
-        The handler will run for every request.
+    /** Add one or more global middleware handlers.
+
+        Each handler registered with this function runs for every incoming
+        request, regardless of its HTTP method or path. Handlers execute in
+        the order they were added, and may call `next()` to transfer control
+        to the subsequent handler in the chain.
+
+        This is equivalent to writing
+        @code
+        use( "/", h1, hn... );
+        @endcode
     */
-    template<class H0, class... HN
-    , class = typename std::enable_if<
-        ! std::is_convertible<H0, core::string_view>::value>::type
+    template<class H1, class... HN
+        , class = typename std::enable_if<! std::is_convertible<
+            H1, core::string_view>::value>::type
     >
-    void use(H0&& h0, HN&&... hn)
+    void use(H1&& h1, HN&&... hn)
     {
-        append(true, all_methods, "",
-            std::forward<H0>(h0),
-            std::forward<HN>(hn)...);
+        use("/", std::forward<H1>(h1), std::forward<HN>(hn)...);
     }
 
-    /** Add a mounted middleware
-        The handler will run for every request matching the given prefix.
+    /** Add one or more middleware handlers for a path prefix.
+
+        Each handler registered with this function runs for every request
+        whose path begins with the specified prefix, regardless of the
+        request method. The prefix match is not strict: middleware attached
+        to `"/api"` will also match `"/api/users"` and `"/api/data"`.
+        Handlers execute in the order they were added, and may call `next()`
+        to transfer control to the subsequent handler.
+
+        This function behaves analogously to `app.use(path, ...)` in
+        Express.js. The registered middleware executes for requests matching
+        the prefix, and when registered before route handlers for the same
+        prefix, runs prior to those routes.
+
+        @par Example
+        @code
+        router.use("/api",
+            [](Request& req, Response& res)
+            {
+                if(!authenticate(req))
+                    return res.setStatus(401), res.end("Unauthorized");
+                return res.next();
+            },
+            [](Request&, Response& res)
+            {
+                res.setHeader("X-Powered-By", "MyServer");
+            });
+        @endcode
+
+        @par Constraints
+        - `pattern` must be a valid path prefix; it may be empty to indicate
+          the root scope.
+        - Each handler must be callable with the signature  
+          `void(Request&, Response&, NextHandler)`.
+        - Each handler must be copy- or move-constructible, depending on how
+          it is passed.
+
+        @throws Any exception thrown by a handler during execution.
+
+        @param pattern  The path prefix to match. Middleware runs for any
+            request whose path begins with this prefix.
+        @param h0  The first middleware handler to install.
+        @param hn  Additional middleware handlers to install, executed in
+            declaration order.
+
+        @return (none)
     */
     template<class H0, class... HN>
-    void use(core::string_view pattern,
+    void use(
+        core::string_view pattern,
         H0&& h0, HN... hn)
     {
-        append(true, all_methods, pattern,
+        if(pattern.empty())
+            pattern = "/";
+        append(false, middleware, pattern,
             std::forward<H0>(h0),
             std::forward<HN>(hn)...);
     }
@@ -173,7 +232,7 @@ class basic_router : public detail::any_router
         core::string_view pattern,
         H0&& h0, HN&&... hn)
     {
-        return add(all_methods, pattern,
+        return add(middleware, pattern,
             std::forward<H0>(h0), std::forward<HN>(hn)...);
     }
 
@@ -197,32 +256,39 @@ class basic_router : public detail::any_router
             std::forward<H0>(h0), std::forward<HN>(hn)...);
     }
 
-    auto
-    operator()(
-        Request& req,
-        Response& res,
-        route_state& st) const ->
-            system::error_code 
+    auto dispatch(
+        http_proto::method method,
+        urls::url_view const& url,
+        Req& req, Res& res, route_state& st) ->
+            route_result
     {
-        return invoke(&req, &res, st);
+        return dispatch_impl(
+            method, url, &req, &res, st);
     }
 
     auto
     resume(
-        Request& req,
-        Response& res,
-        system::error_code const& ec,
+        Req& req,
+        Res& res,
+        route_result const& ec,
         route_state& st) const ->
-            system::error_code
+            route_result
     {
         st.pos = 0;
         st.ec = ec;
-        return invoke(&req, &res, st);
+        return dispatch_impl(&req, &res, st);
     }
 
 private:
+    template<class H>
+    handler_ptr make_handler(H&& h)
+    {
+        return handler_ptr(new handler_impl<
+            Req, Res, H>(std::forward<H>(h)));
+    }
+
     void append(bool, http_proto::method,
-        core::string_view ) const noexcept
+        core::string_view) const noexcept
     {
     }
 
@@ -231,24 +297,17 @@ class basic_router : public detail::any_router
         core::string_view pat, H0&& h, HN&&... hn)
     {
         any_router::append(prefix, method, pat,
-            handler_ptr(new handler_impl<Request, Response, H0>(
-                std::forward<H0>(h))));
+            make_handler<H0>(std::forward<H0>(h)));
         append(prefix, method, pat, std::forward<HN>(hn)...);
     }
 
-    void append_err() const noexcept
-    {
-    }
-
     template<class H0, class... HN>
     void append_err(H0&& h, HN&&... hn)
     {
-        any_router::append_err(errfn_ptr(new
-            errfn_impl<Request, Response, H0>(
-                std::forward<H0>(h))));
-        append_err(std::forward<HN>(hn)...);
+        append(true, middleware, {},
+            std::forward<H0>(h),
+            std::forward<HN>(hn)...);
     }
-
 };
 
 } // beast2