1 files changed, 214 insertions, 308 deletions
diff --git a/server/src/http_server.cppm b/server/src/http_server.cppm
index f5b4c3e..dc8c183 100644
--- a/server/src/http_server.cppm
+++ b/server/src/http_server.cppm
@@ -137,25 +137,12 @@ public:
  {
  }
-  auto header() -> bhttp::response_header<bhttp::fields>&
+  auto header() -> bhttp::response_header<bhttp::fields>&;
-  {
+  auto header() const -> bhttp::response_header<bhttp::fields> const&;
-    return impl_->header();
+  auto is_done() const -> bool;
-  }
+  auto prepare(beast::error_code& ec) -> const_buffers_type;
-  auto header() const -> bhttp::response_header<bhttp::fields> const&
+  auto consume(std::size_t n) -> void;
-  {
+  auto keep_alive() const noexcept -> bool;
-    return impl_->header();
-  }
-  auto is_done() const -> bool { return impl_->is_done(); }
-  auto prepare(beast::error_code& ec) -> const_buffers_type
-  {
-    return impl_->prepare(ec);
-  }
-  auto consume(std::size_t n) -> void { return impl_->consume(n); }
-  auto keep_alive() const noexcept -> bool { return impl_->keep_alive(); }
 };
 static_assert(beast::concepts::buffers_generator<presponse>);
@@ -207,15 +194,17 @@ struct base_ctx
 };
 template <class Ctx>
-using basic_route_handler_fn_t = std::function<
+using basic_route_handler_fn_t =
-    auto(Ctx, readable_request, std::vector<std::string> const& matches)
+    std::function<auto(
-        ->net::awaitable<presponse>>;
+                      Ctx, readable_request,
+                      std::vector<std::string> const& matches)
+                      ->net::awaitable<presponse>>;
 struct keep_alive
 {
  bool value;
-  explicit keep_alive(bool value) : value{value} {}
+  explicit keep_alive(bool value);
 };
 template <bhttp::concepts::body Body>
@@ -229,37 +218,16 @@ auto make_rsp(bhttp::status status, keep_alive ka) -> bhttp::response<Body>
 auto problem_rsp(
    base_ctx const& ctx, problem::details const& problem, keep_alive ka)
-    -> presponse
+    -> presponse;
-{
-  auto rsp = make_rsp<bhttp::string_body>(problem.status, ka);
-  rsp.set(bhttp::field::content_type, "application/problem+json");
-  rsp.body() = json::serialize(json::value_from(problem, ctx.locale));
-  rsp.prepare_payload();
-  return presponse{std::move(rsp)};
-}
 struct preflight_response
 {
  verb_set allow_methods;
  std::vector<bhttp::field> allow_headers;
 };
 auto make_preflight_rsp(preflight_response res, keep_alive ka)
-    -> bhttp::response<bhttp::empty_body>
+    -> bhttp::response<bhttp::empty_body>;
-{
-  auto rsp = make_rsp<bhttp::empty_body>(bhttp::status::no_content, ka);
-  auto allow_headers_str = res.allow_headers
-                           | std::views::transform(
-                               [](auto const& field) -> std::string_view
-                               { return bhttp::to_string(field); })
-                           | std::views::join_with(std::string_view{", "})
-                           | std::ranges::to<std::string>();
-  rsp.set(
-      bhttp::field::access_control_allow_methods,
-      res.allow_methods.to_string());
-  rsp.set(bhttp::field::access_control_allow_headers, allow_headers_str);
-  rsp.prepare_payload();
-  return rsp;
-}
 // Using base_ctx instead of a template here since that saves you
 // typing on invocation (and we do not care about the context type
@@ -276,8 +244,8 @@ auto read_request(base_ctx const& ctx, readable_request&& r)
 template <>
 auto read_request<bhttp::empty_body>(base_ctx const& ctx, readable_request&& r)
-    -> net::awaitable<
+    -> net::
-        std::expected<bhttp::request<bhttp::empty_body>, presponse>>
+        awaitable<std::expected<bhttp::request<bhttp::empty_body>, presponse>>
 {
  auto [ec, _] =
      co_await bhttp::async_read(*r.strm, *r.buf, *r.p, net::as_tuple);
@@ -340,19 +308,7 @@ auto default_options_handler(
 }
 auto global_options_handler(base_ctx const& ctx, readable_request r)
-    -> net::awaitable<presponse>
+    -> net::awaitable<presponse>;
-{
-  // TODO: switch to "small (4KB) discarded" body type, similar to what Go
-  // does? Same goes for default_options_handler? Not sure.
-  if (auto res = co_await read_request<bhttp::empty_body>(ctx, std::move(r));
-      !res)
-    co_return std::move(res.error());
-  auto req = r.p->release();
-  auto rsp = make_rsp<bhttp::empty_body>(
-      bhttp::status::no_content, keep_alive{req.keep_alive()});
-  rsp.prepare_payload();
-  co_return std::move(rsp);
-}
 template <class Ctx>
 auto id_middleware(
@@ -427,28 +383,22 @@ struct handler_map
  auto verbs() const -> verb_set
  {
-    auto set = verb_set{};
+    return verb_set{
-    if (static_cast<bool>(options))
+      .options = static_cast<bool>(options),
-      set.enable(supported_verb::options);
+      .delete_ = static_cast<bool>(delete_),
-    if (static_cast<bool>(delete_))
+      .get = static_cast<bool>(get),
-      set.enable(supported_verb::delete_);
+      .head = static_cast<bool>(head),
-    if (static_cast<bool>(get))
+      .post = static_cast<bool>(post),
-      set.enable(supported_verb::get);
+      .put = static_cast<bool>(put),
-    if (static_cast<bool>(head))
+    };
-      set.enable(supported_verb::head);
-    if (static_cast<bool>(post))
-      set.enable(supported_verb::post);
-    if (static_cast<bool>(put))
-      set.enable(supported_verb::put);
-    return set;
  }
  auto empty() const -> bool { return verbs().empty(); }
  template <std::default_initializable U>
  auto map(std::invocable<V const&> auto f) const -> handler_map<U>
-    requires std::assignable_from<
+    requires std::
-        U&, std::invoke_result_t<decltype(f), V const&>>
+        assignable_from<U&, std::invoke_result_t<decltype(f), V const&>>
  {
    return {
      .options = static_cast<bool>(options) ? f(options) : U{},
@@ -508,8 +458,9 @@ template <class T>
 concept match_arg = std::constructible_from<T, std::string const&>;
 template <class Ctx, match_arg... MatchArgs>
-using route_handler_fn_t = std::function<
+using route_handler_fn_t =
-    auto(Ctx, readable_request, MatchArgs...)->net::awaitable<presponse>>;
+    std::function<auto(Ctx, readable_request, MatchArgs...)
+                      ->net::awaitable<presponse>>;
 template <class Ctx, match_arg... MatchArgs>
 auto degen_route_handler(route_handler_fn_t<Ctx, MatchArgs...> fn)
@@ -588,271 +539,226 @@ struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>>
  }
 };
-template <std::derived_from<base_ctx> PreRouteCtx>
+class router
-class server
 {
-  log::logger l_;
+  struct impl_base
-  locale::selector lsel_;
-  middleware_t<base_ctx, PreRouteCtx> global_middleware_;
-  route_tree<routed_ctx<PreRouteCtx>> routes_;
-public:
-  explicit server(
-      log::logger const& l, locale::selector&& lsel,
-      middleware_t<base_ctx, PreRouteCtx> global_middleware,
-      route_tree<routed_ctx<PreRouteCtx>> routes)
-    : l_{l.sub("http_server")}, lsel_{std::move(lsel)},
-      global_middleware_{std::move(global_middleware)},
-      routes_{std::move(routes)}
-  {
-  }
-  struct match_result
  {
-    util::not_null<
+    virtual ~impl_base() = default;
-        handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*>
+    virtual auto handle_request(readable_request r) const
-        route_handlers;
+        -> net::awaitable<presponse> = 0;
-    std::vector<std::string> wildcard_matches;
-    auto allowed_methods() const -> verb_set { return route_handlers->verbs(); }
  };
-  auto match(boost::urls::segments_view segments) const
+  std::unique_ptr<impl_base> impl_;
-      -> std::optional<match_result>
+  template <std::derived_from<base_ctx> PreRouteCtx>
+  class impl : public impl_base
  {
-    auto const* tree = &routes_;
+    locale::selector lsel_;
-    auto wildcard_matches = std::vector<std::string>{};
+    middleware_t<base_ctx, PreRouteCtx> global_middleware_;
-    for (auto const& seg : segments)
+    route_tree<routed_ctx<PreRouteCtx>> routes_;
+  public:
+    explicit impl(
+        locale::selector&& lsel,
+        middleware_t<base_ctx, PreRouteCtx> global_middleware,
+        route_tree<routed_ctx<PreRouteCtx>> routes)
+      : lsel_{std::move(lsel)},
+        global_middleware_{std::move(global_middleware)},
+        routes_{std::move(routes)}
    {
-      tree->sub.visit(
-          util::overloaded{
-            [&](route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const&
-                    subtrees)
-            {
-              auto it = subtrees.find(seg);
-              tree = it == subtrees.end() ? nullptr : &it->second;
-            },
-            [&](route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const&
-                    wildcard_subtree)
-            {
-              wildcard_matches.push_back(seg);
-              tree = &*wildcard_subtree;
-            },
-          });
-      if (!tree)
-        return std::nullopt;
    }
-    if (tree->here.empty())
-      return std::nullopt;
-    return match_result{
-      .route_handlers = util::not_null{&tree->here},
-      .wildcard_matches = wildcard_matches,
-    };
-  }
-  auto route_request(PreRouteCtx ctx, readable_request r) const
+    struct match_result
-      -> net::awaitable<presponse>
+    {
-  {
+      util::not_null<
-    auto req_base = r.p->get().base();
+          handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*
+      >
+          route_handlers;
+      std::vector<std::string> wildcard_matches;
-    auto const bad_request_tpl = problem::tpl{
+      auto allowed_methods() const -> verb_set
-      .status = bhttp::status::bad_request,
+      {
-      .title = translate("Bad request"),
+        return route_handlers->verbs();
-      .type_uri = "https://routemon.fautchen.eu/problems/bad-request",
+      }
    };
-    if (req_base.target() == "*")
+    auto match(boost::urls::segments_view segments) const
+        -> std::optional<match_result>
    {
-      // request-target is in asterisk-form (RFC 9112, § 3.2.4),
+      auto const* tree = &routes_;
-      // so the request must be a server-wide OPTIONS request.
+      auto wildcard_matches = std::vector<std::string>{};
+      for (auto const& seg : segments)
-      if (req_base.method() != bhttp::verb::options)
      {
-        auto tpl = problem::tpl{
+        tree->sub.visit(
-          .status = bhttp::status::method_not_allowed,
+            util::overloaded{
-          .title = translate("Method not allowed"),
+              [&](route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const&
-          .type_uri = "https://routemon.fautchen.eu/problems/"
+                      subtrees)
-                      "method-not-allowed",
+              {
-        };
+                auto it = subtrees.find(seg);
-        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+                tree = it == subtrees.end() ? nullptr : &it->second;
+              },
+              [&](route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const&
+                      wildcard_subtree)
+              {
+                wildcard_matches.push_back(seg);
+                tree = &*wildcard_subtree;
+              },
+            });
+        if (!tree)
+          return std::nullopt;
      }
+      if (tree->here.empty())
-      co_return co_await global_options_handler(ctx, r);
+        return std::nullopt;
+      return match_result{
+        .route_handlers = util::not_null{&tree->here},
+        .wildcard_matches = wildcard_matches,
+      };
    }
-    else if (auto mreq_url0 = boost::urls::parse_origin_form(req_base.target()))
+    auto route_request(PreRouteCtx ctx, readable_request r) const
+        -> net::awaitable<presponse>
    {
-      // request-target is in origin-form (RFC 9112, § 3.2.1),
+      auto req_base = r.p->get().base();
-      // so it must be a normal request (not a CONNECT or
-      // server-wide OPTIONS request).
-      auto req_url = boost::urls::url{*mreq_url0};
+      auto const bad_request_tpl = problem::tpl{
-      req_url.normalize();
+        .status = bhttp::status::bad_request,
-      if (!req_url.is_path_absolute())
+        .title = translate("Bad request"),
-      {
+        .type_uri = "https://routemon.fautchen.eu/problems/bad-request",
-        auto problem = bad_request_tpl.instantiate().set_detail(translate(
+      };
-            "Path of normalized (RFC 3986, § 6) "
-            "origin-form request-target (RFC "
-            "9112, § 3.2.1) should be "
-            "absolute"));
-        co_return problem_rsp(ctx, problem, keep_alive{false});
-      }
-      auto mres = match(req_url.segments());
+      if (req_base.target() == "*")
-      if (!mres)
      {
-        auto tpl = problem::tpl{
+        // request-target is in asterisk-form (RFC 9112, § 3.2.4),
-          .status = bhttp::status::not_found,
+        // so the request must be a server-wide OPTIONS request.
-          .title = translate("Not found"),
-          .type_uri = "https://routemon.fautchen.eu/problems/not-found",
-        };
-        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
-      }
-      auto mverb = supported_verb::from(req_base.method());
+        if (req_base.method() != bhttp::verb::options)
-      if (!mverb)
+        {
-      {
+          auto tpl = problem::tpl{
-        // Method not implemented.
+            .status = bhttp::status::method_not_allowed,
-        auto tpl = problem::tpl{
+            .title = translate("Method not allowed"),
-          .status = bhttp::status::not_implemented,
+            .type_uri = "https://routemon.fautchen.eu/problems/"
-          .title = translate("Method not implemented"),
+                        "method-not-allowed",
-          .type_uri = "https://routemon.fautchen.eu/problems/"
+          };
-                      "method-not-implemented",
+          co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
-        };
+        }
-        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
-      }
-      if (auto mhdl = mres->route_handlers->lookup(*mverb))
+        co_return co_await global_options_handler(ctx, r);
+      }
+      else if (auto mreq_url0 =
+                   boost::urls::parse_origin_form(req_base.target()))
      {
-        auto new_ctx =
+        // request-target is in origin-form (RFC 9112, § 3.2.1),
-            routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
+        // so it must be a normal request (not a CONNECT or
-        co_return co_await mhdl(std::move(new_ctx), r, mres->wildcard_matches);
+        // server-wide OPTIONS request).
+        auto req_url = boost::urls::url{*mreq_url0};
+        req_url.normalize();
+        if (!req_url.is_path_absolute())
+        {
+          auto problem = bad_request_tpl.instantiate().set_detail(translate(
+              "Path of normalized (RFC 3986, § 6) "
+              "origin-form request-target (RFC "
+              "9112, § 3.2.1) should be "
+              "absolute"));
+          co_return problem_rsp(ctx, problem, keep_alive{false});
+        }
+        auto mres = match(req_url.segments());
+        if (!mres)
+        {
+          auto tpl = problem::tpl{
+            .status = bhttp::status::not_found,
+            .title = translate("Not found"),
+            .type_uri = "https://routemon.fautchen.eu/problems/not-found",
+          };
+          co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+        }
+        auto mverb = supported_verb::from(req_base.method());
+        if (!mverb)
+        {
+          // Method not implemented.
+          auto tpl = problem::tpl{
+            .status = bhttp::status::not_implemented,
+            .title = translate("Method not implemented"),
+            .type_uri = "https://routemon.fautchen.eu/problems/"
+                        "method-not-implemented",
+          };
+          co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+        }
+        if (auto mhdl = mres->route_handlers->lookup(*mverb))
+        {
+          auto new_ctx =
+              routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
+          co_return co_await mhdl(
+              std::move(new_ctx), r, mres->wildcard_matches);
+        }
+        else
+        {
+          // Path recognized, but method not allowed.
+          auto tpl = problem::tpl{
+            .status = bhttp::status::method_not_allowed,
+            .title = translate("Method not allowed"),
+            .type_uri = "https://routemon.fautchen.eu/problems/"
+                        "method-not-allowed",
+          };
+          auto rsp = problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+          rsp.header().set(
+              bhttp::field::allow, mres->allowed_methods().to_string());
+          co_return std::move(rsp);
+        }
      }
      else
      {
-        // Path recognized, but method not allowed.
+        // We do not accept any other request-target forms.
-        auto tpl = problem::tpl{
-          .status = bhttp::status::method_not_allowed,
+        auto problem = bad_request_tpl.instantiate().set_detail(translate(
-          .title = translate("Method not allowed"),
+            "Invalid request-target, expected "
-          .type_uri = "https://routemon.fautchen.eu/problems/"
+            "asterisk-form or origin-form "
-                      "method-not-allowed",
+            "(see RFC 9112, § 3.2)"));
-        };
+        co_return problem_rsp(ctx, problem, keep_alive{false});
-        auto rsp = problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
-        rsp.header().set(
-            bhttp::field::allow, mres->allowed_methods().to_string());
-        co_return std::move(rsp);
      }
    }
-    else
-    {
-      // We do not accept any other request-target forms.
-      auto problem = bad_request_tpl.instantiate().set_detail(translate(
+    auto handle_request(readable_request r) const
-          "Invalid request-target, expected "
+        -> net::awaitable<presponse> override
-          "asterisk-form or origin-form "
+    {
-          "(see RFC 9112, § 3.2)"));
+      auto header = r.p->get().base();
-      co_return problem_rsp(ctx, problem, keep_alive{false});
+      auto locale = lsel_.select(header[bhttp::field::accept_language]);
+      co_return co_await global_middleware_(
+          base_ctx{.locale = locale}, header,
+          [&](PreRouteCtx ctx) -> net::awaitable<presponse>
+          { co_return co_await route_request(std::move(ctx), std::move(r)); });
    }
-  }
+  };
-  auto handle_request(readable_request r) const -> net::awaitable<presponse>
+public:
+  template <std::derived_from<base_ctx> PreRouteCtx>
+  explicit router(
+      locale::selector&& lsel,
+      middleware_t<base_ctx, PreRouteCtx> global_middleware,
+      route_tree<routed_ctx<PreRouteCtx>> routes)
+    : impl_{std::make_unique<impl<PreRouteCtx>>(
+          std::move(lsel), std::move(global_middleware), std::move(routes))}
  {
-    auto header = r.p->get().base();
-    auto locale = lsel_.select(header[bhttp::field::accept_language]);
-    auto ctx0 = base_ctx{.locale = locale};
-    co_return co_await global_middleware_(
-        std::move(ctx0), header,
-        [&](PreRouteCtx ctx) -> net::awaitable<presponse>
-        { co_return co_await route_request(std::move(ctx), std::move(r)); });
  }
-  auto do_session(beast::tcp_stream strm) -> net::awaitable<void>
+  auto handle_request(readable_request r) const -> net::awaitable<presponse>;
-  {
+};
-    auto buf = beast::flat_buffer{};
-    while (true)
-    {
-      auto p0 = bhttp::request_parser<bhttp::empty_body>{};
-      p0.body_limit(boost::none);
-      auto [ec, _] =
-          co_await bhttp::async_read_header(strm, buf, p0, net::as_tuple);
-      if (ec == bhttp::error::end_of_stream)
-        break;
-      else if (ec)
-        throw boost::system::system_error{ec};
-      auto http_version = p0.get().version();
-      auto&& rsp = co_await handle_request(
-          readable_request{
-            .p = util::not_null{&p0},
-            .strm = util::not_null{&strm},
-            .buf = util::not_null{&buf},
-          });
-      rsp.header().version(http_version);
-      bool keep_alive = rsp.keep_alive();
-      co_await beast::async_write(strm, std::move(rsp));
-      if (!keep_alive)
-      {
-        break;
-      }
-    }
-    strm.socket().shutdown(tcp::socket::shutdown_send);
-  }
-  auto do_listen(tcp::endpoint endpoint) -> net::awaitable<void>
+class server
-  {
+{
-    auto executor = co_await net::this_coro::executor;
+  log::logger l_;
-    auto acceptor = tcp::acceptor{executor, endpoint};
+  router r_;
-    l_.with("endpoint", endpoint.address().to_string())
+  auto do_session(beast::tcp_stream strm) -> net::awaitable<void>;
-        .with("port", std::to_string(endpoint.port()))
+  auto do_listen(tcp::endpoint endpoint) -> net::awaitable<void>;
-        .info("Serving");
-    while (true)
-    {
-      net::co_spawn(
-          executor,
-          do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
-          [this](std::exception_ptr e)
-          {
-            if (e)
-            {
-              try
-              {
-                std::rethrow_exception(e);
-              }
-              catch (std::exception const& e)
-              {
-                l_.error("Error in session: {}", e.what());
-              }
-            }
-          });
-    }
-  }
-  auto spawn(net::io_context& ioc) -> void
+public:
-  {
+  explicit server(log::logger const& l, router&& r);
-    auto const addr = net::ip::make_address("0.0.0.0");
-    auto const endpoint = tcp::endpoint{addr, 8284};
-    // TODO: make exception handling as nice as in srv.cpp
+  auto spawn(net::io_context& ioc) -> void;
-    net::co_spawn(
-        ioc, do_listen(endpoint),
-        [this](std::exception_ptr e)
-        {
-          if (e)
-          {
-            try
-            {
-              std::rethrow_exception(e);
-            }
-            catch (std::exception const& e)
-            {
-              l_.error("Error: {}", e.what());
-            }
-          }
-        });
-  }
 };
 } // namespace routemon::http