1 files changed, 723 insertions, 526 deletions
diff --git a/server/src/http_server.cppm b/server/src/http_server.cppm
index 0770d97..0f7fda7 100644
--- a/server/src/http_server.cppm
+++ b/server/src/http_server.cppm
@@ -1,12 +1,12 @@
 module;
-#include <boost/config.hpp>
 #include <boost/asio/as_tuple.hpp>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
+#include <boost/config.hpp>
 #include <boost/json/serialize.hpp>
 #include <boost/url.hpp>
@@ -23,639 +23,836 @@ using tcp = net::ip::tcp;
 namespace routemon::http {
-  struct readable_request {
+struct readable_request
-    util::not_null<bhttp::request_parser<bhttp::empty_body>*> p;
+{
-    util::not_null<beast::tcp_stream*> strm;
+  util::not_null<bhttp::request_parser<bhttp::empty_body>*> p;
-    util::not_null<beast::flat_buffer*> buf;
+  util::not_null<beast::tcp_stream*> strm;
-  };
+  util::not_null<beast::flat_buffer*> buf;
+};
-  class presponse {
+class presponse
-  public:
+{
-    using const_buffers_type = beast::span<net::const_buffer>;
+public:
+  using const_buffers_type = beast::span<net::const_buffer>;
-  private:
+private:
-    struct impl_base {
+  struct impl_base
-      virtual ~impl_base() = default;
+  {
-      virtual auto header() -> bhttp::response_header<bhttp::fields>& = 0;
+    virtual ~impl_base() = default;
-      virtual auto header() const -> bhttp::response_header<bhttp::fields> const& = 0;
+    virtual auto header() -> bhttp::response_header<bhttp::fields>& = 0;
-      virtual auto is_done() const -> bool = 0;
+    virtual auto header() const
-      virtual auto prepare(beast::error_code&) -> const_buffers_type = 0;
+        -> bhttp::response_header<bhttp::fields> const& = 0;
-      virtual auto consume(std::size_t n) -> void = 0;
+    virtual auto is_done() const -> bool = 0;
-      virtual auto keep_alive() const -> bool = 0;
+    virtual auto prepare(beast::error_code&) -> const_buffers_type = 0;
-    };
+    virtual auto consume(std::size_t n) -> void = 0;
-    std::unique_ptr<impl_base> impl_;
+    virtual auto keep_alive() const -> bool = 0;
+  };
+  std::unique_ptr<impl_base> impl_;
-    template<bhttp::concepts::body Body>
+  template <bhttp::concepts::body Body>
-    class impl : public impl_base {
+  class impl : public impl_base
-      // Initializes in the response state.
+  {
-      // At the first call to prepare, we switch to the message generator state.
+    // Initializes in the response state.
-      // After that point, header may not be called anymore (it will throw).
+    // At the first call to prepare, we switch to the message generator
-      std::variant<bhttp::response<Body>, bhttp::message_generator> state_;
+    // state. After that point, header may not be called anymore (it will
+    // throw).
+    std::variant<bhttp::response<Body>, bhttp::message_generator> state_;
-      auto ensure_message_generator() -> bhttp::message_generator& {
+    auto ensure_message_generator() -> bhttp::message_generator&
-        if (auto prsp = std::get_if<bhttp::response<Body>>(&state_)) {
+    {
-          auto rsp = bhttp::response<Body>{std::move(*prsp)};
+      if (auto prsp = std::get_if<bhttp::response<Body>>(&state_))
-          state_.template emplace<bhttp::message_generator>(std::move(rsp));
+      {
-        }
+        auto rsp = bhttp::response<Body>{std::move(*prsp)};
-        return std::get<bhttp::message_generator>(state_);
+        state_.template emplace<bhttp::message_generator>(std::move(rsp));
      }
+      return std::get<bhttp::message_generator>(state_);
+    }
-    public:
+  public:
-      explicit impl(bhttp::response<Body>&& rsp) : state_{std::move(rsp)} {}
+    explicit impl(bhttp::response<Body>&& rsp) : state_{std::move(rsp)} {}
-      auto header() -> bhttp::response_header<bhttp::fields>& override {
+    auto header() -> bhttp::response_header<bhttp::fields>& override
-        if (auto prsp = std::get_if<bhttp::response<Body>>(&state_)) {
+    {
-          return prsp->base();
+      if (auto prsp = std::get_if<bhttp::response<Body>>(&state_))
-        } else {
+      {
-          // TODO: define custom exception type presponse::bad_header_access
+        return prsp->base();
-          throw std::logic_error{"header() may not be called after prepare()"};
-        }
      }
-      auto header() const -> bhttp::response_header<bhttp::fields> const& override {
+      else
-        if (auto prsp = std::get_if<bhttp::response<Body>>(&state_)) {
+      {
-          return prsp->base();
+        // TODO: define custom exception type
-        } else {
+        // presponse::bad_header_access
-          throw std::logic_error{"header() may not be called after prepare()"};
+        throw std::logic_error{"header() may not be called after prepare()"};
-        }
      }
+    }
-      auto is_done() const -> bool override {
+    auto header() const -> bhttp::response_header<bhttp::fields> const& override
-        if (auto pgen = std::get_if<bhttp::message_generator>(&state_)) {
+    {
-          return pgen->is_done();
+      if (auto prsp = std::get_if<bhttp::response<Body>>(&state_))
-        } else /* still in the response state */ {
+      {
-          return false;
+        return prsp->base();
-        }
      }
+      else
-      auto prepare(beast::error_code& ec) -> const_buffers_type override {
+      {
-        return ensure_message_generator().prepare(ec);
+        throw std::logic_error{"header() may not be called after prepare()"};
      }
+    }
-      auto consume(std::size_t n) -> void override {
+    auto is_done() const -> bool override
-        ensure_message_generator().consume(n);
+    {
+      if (auto pgen = std::get_if<bhttp::message_generator>(&state_))
+      {
+        return pgen->is_done();
      }
+      else /* still in the response state */
-      auto keep_alive() const noexcept -> bool override {
+      {
-        return state_.visit(util::overloaded{
+        return false;
-            [](bhttp::response<Body> const& rsp) -> bool {
-              return rsp.keep_alive();
-            },
-            [](bhttp::message_generator const& gen) -> bool {
-              return gen.keep_alive();
-            },
-          });
      }
-    };
-  public:
-    template<bhttp::concepts::body Body>
-    explicit presponse(bhttp::response<Body>&& rsp)
-      : impl_{new impl{std::move(rsp)}}
-    {}
-    auto header() -> bhttp::response_header<bhttp::fields>& {
-      return impl_->header();
-    }
-    auto header() const -> bhttp::response_header<bhttp::fields> const& {
-      return impl_->header();
-    }
-    auto is_done() const -> bool {
-      return impl_->is_done();
    }
-    auto prepare(beast::error_code& ec) -> const_buffers_type {
+    auto prepare(beast::error_code& ec) -> const_buffers_type override
-      return impl_->prepare(ec);
+    {
+      return ensure_message_generator().prepare(ec);
    }
-    auto consume(std::size_t n) -> void {
+    auto consume(std::size_t n) -> void override
-      return impl_->consume(n);
+    {
+      ensure_message_generator().consume(n);
    }
-    auto keep_alive() const noexcept -> bool {
+    auto keep_alive() const noexcept -> bool override
-      return impl_->keep_alive();
+    {
+      return state_.visit(
+          util::overloaded{
+              [](bhttp::response<Body> const& rsp) -> bool
+              { return rsp.keep_alive(); },
+              [](bhttp::message_generator const& gen) -> bool
+              { return gen.keep_alive(); },
+          });
    }
  };
-  static_assert(beast::concepts::buffers_generator<presponse>);
-  template<class Ctx>
-  using next_handler_t = std::function<auto(Ctx) -> net::awaitable<presponse>>;
-  template<class OuterCtx, class InnerCtx>
+public:
-  using middleware_t = std::function<auto(OuterCtx, bhttp::request_header<bhttp::fields>&, next_handler_t<InnerCtx>) -> net::awaitable<presponse>>;
+  template <bhttp::concepts::body Body>
+  explicit presponse(bhttp::response<Body>&& rsp)
+    : impl_{new impl{std::move(rsp)}}
+  {
+  }
-  template<class Ctx>
+  auto header() -> bhttp::response_header<bhttp::fields>&
-  auto lax_cors_middleware(Ctx ctx, bhttp::request_header<bhttp::fields>& req_hdr, next_handler_t<Ctx> next) -> net::awaitable<presponse> {
+  {
-    std::ignore = req_hdr;
+    return impl_->header();
-    auto prersp = co_await next(ctx);
+  }
-    prersp.header().set(bhttp::field::access_control_allow_origin, "*");
+  auto header() const -> bhttp::response_header<bhttp::fields> const&
-    co_return std::move(prersp);
+  {
+    return impl_->header();
  }
-  template<class InnerCtx>
+  auto is_done() const -> bool { return impl_->is_done(); }
-  struct trace_id_ctx : InnerCtx {
-    trace::id trace_id = {};
-  };
-  template<class OuterCtx>
+  auto prepare(beast::error_code& ec) -> const_buffers_type
-  auto trace_id_middleware(OuterCtx ctx0, bhttp::request_header<bhttp::fields>& req_hdr, next_handler_t<trace_id_ctx<OuterCtx>> next) -> net::awaitable<presponse> {
+  {
-    std::ignore = req_hdr;
+    return impl_->prepare(ec);
-    auto ctx = trace_id_ctx{std::move(ctx0)};
-    auto prersp = co_await next(std::move(ctx));
-    prersp.header().set("X-Routemon-Trace-Id", std::string_view{ctx.trace_id.as_string()});
-    prersp.header().insert(bhttp::field::access_control_expose_headers, "X-Routemon-Trace-Id");
-    co_return std::move(prersp);
  }
-  struct base_ctx {
+  auto consume(std::size_t n) -> void { return impl_->consume(n); }
-    std::locale locale;
-  };
-  template<class Ctx>
+  auto keep_alive() const noexcept -> bool { return impl_->keep_alive(); }
-  using basic_route_handler_fn_t = std::function<auto(Ctx, readable_request, std::vector<std::string> const& matches) -> net::awaitable<presponse>>;
+};
+static_assert(beast::concepts::buffers_generator<presponse>);
-  struct keep_alive {
+template <class Ctx>
-    bool value;
+using next_handler_t = std::function<auto(Ctx)->net::awaitable<presponse>>;
-    explicit keep_alive(bool value) : value{value} {}
+template <class OuterCtx, class InnerCtx>
-  };
+using middleware_t =
+    std::function<auto(
+                      OuterCtx, bhttp::request_header<bhttp::fields>&,
+                      next_handler_t<InnerCtx>)
+                      ->net::awaitable<presponse>>;
-  template<bhttp::concepts::body Body>
+template <class Ctx>
-  auto make_rsp(bhttp::status status, keep_alive ka) -> bhttp::response<Body> {
+auto lax_cors_middleware(
-    auto rsp = bhttp::response<Body>{}; // HTTP version gets set later
+    Ctx ctx, bhttp::request_header<bhttp::fields>& req_hdr,
-    rsp.result(status);
+    next_handler_t<Ctx> next) -> net::awaitable<presponse>
-    rsp.keep_alive(ka.value);
+{
-    return rsp;
+  std::ignore = req_hdr;
-  }
+  auto prersp = co_await next(ctx);
+  prersp.header().set(bhttp::field::access_control_allow_origin, "*");
+  co_return std::move(prersp);
+}
-  auto problem_rsp(base_ctx const& ctx, problem::details const& problem, keep_alive ka) -> presponse {
+template <class InnerCtx>
-    auto rsp = make_rsp<bhttp::string_body>(problem.status, ka);
+struct trace_id_ctx : InnerCtx
-    rsp.set(bhttp::field::content_type, "application/problem+json");
+{
-    rsp.body() = json::serialize(json::value_from(problem, ctx.locale));
+  trace::id trace_id = {};
-    rsp.prepare_payload();
+};
-    return presponse{std::move(rsp)};
-  }
-  struct preflight_response {
+template <class OuterCtx>
-    verb_set allow_methods;
+auto trace_id_middleware(
-    std::vector<bhttp::field> allow_headers;
+    OuterCtx ctx0, bhttp::request_header<bhttp::fields>& req_hdr,
-  };
+    next_handler_t<trace_id_ctx<OuterCtx>> next) -> net::awaitable<presponse>
-  auto make_preflight_rsp(preflight_response res, keep_alive ka) -> bhttp::response<bhttp::empty_body> {
+{
-    auto rsp = make_rsp<bhttp::empty_body>(bhttp::status::no_content, ka);
+  std::ignore = req_hdr;
-    auto allow_headers_str = res.allow_headers
+  auto ctx = trace_id_ctx{std::move(ctx0)};
-      | std::views::transform([](auto const& field) -> std::string_view { return bhttp::to_string(field); })
+  auto prersp = co_await next(std::move(ctx));
-      | std::views::join_with(std::string_view{", "})
+  prersp.header().set(
-      | std::ranges::to<std::string>();
+      "X-Routemon-Trace-Id", std::string_view{ctx.trace_id.as_string()});
-    rsp.set(bhttp::field::access_control_allow_methods, res.allow_methods.to_string());
+  prersp.header().insert(
-    rsp.set(bhttp::field::access_control_allow_headers, allow_headers_str);
+      bhttp::field::access_control_expose_headers, "X-Routemon-Trace-Id");
-    rsp.prepare_payload();
+  co_return std::move(prersp);
-    return rsp;
+}
-  }
-  // Using base_ctx instead of a template here since that saves you
+struct base_ctx
-  // typing on invocation (and we do not care about the context type
+{
-  // anyway, but all context types should derive from base_ctx).
+  std::locale locale;
-  template<bhttp::concepts::body_reader Body>
+};
-  auto read_request(base_ctx const& ctx, readable_request&& r) -> net::awaitable<std::expected<bhttp::request<Body>, presponse>> {
-    std::ignore = ctx;
+template <class Ctx>
-    auto p = bhttp::request_parser<Body>{std::move(*r.p)};
+using basic_route_handler_fn_t = std::function<
-    co_await bhttp::async_read(*r.strm, *r.buf, p);
+    auto(Ctx, readable_request, std::vector<std::string> const& matches)
-    co_return std::move(p.release());
+        ->net::awaitable<presponse>>;
-  }
+struct keep_alive
+{
+  bool value;
-  template<>
+  explicit keep_alive(bool value) : value{value} {}
-  auto read_request<bhttp::empty_body>(base_ctx const& ctx, readable_request&& r) -> net::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);
-    if (ec == bhttp::error::unexpected_body) {
+template <bhttp::concepts::body Body>
-      auto tpl = problem::tpl{
+auto make_rsp(bhttp::status status, keep_alive ka) -> bhttp::response<Body>
-        .status   = bhttp::status::bad_request,
+{
-        .title    = translate("No body expected for this request"),
+  auto rsp = bhttp::response<Body>{}; // HTTP version gets set later
+  rsp.result(status);
+  rsp.keep_alive(ka.value);
+  return rsp;
+}
+auto problem_rsp(
+    base_ctx const& ctx, problem::details const& problem, keep_alive ka)
+    -> 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>
+{
+  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
+// anyway, but all context types should derive from base_ctx).
+template <bhttp::concepts::body_reader Body>
+auto read_request(base_ctx const& ctx, readable_request&& r)
+    -> net::awaitable<std::expected<bhttp::request<Body>, presponse>>
+{
+  std::ignore = ctx;
+  auto p = bhttp::request_parser<Body>{std::move(*r.p)};
+  co_await bhttp::async_read(*r.strm, *r.buf, p);
+  co_return std::move(p.release());
+}
+template <>
+auto read_request<bhttp::empty_body>(base_ctx const& ctx, readable_request&& r)
+    -> net::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);
+  if (ec == bhttp::error::unexpected_body)
+  {
+    auto tpl = problem::tpl{
+        .status = bhttp::status::bad_request,
+        .title = translate("No body expected for this request"),
        .type_uri = "https://routemon.fautchen.eu/problems/unexpected-body",
-      };
+    };
-      co_return std::unexpected{problem_rsp(ctx, tpl.instantiate(), keep_alive{false})};
+    co_return std::unexpected{problem_rsp(
-    } else if (ec) {
+        ctx, tpl.instantiate(), keep_alive{false})};
-      throw boost::system::system_error{ec};
-    }
-    co_return r.p->release();
  }
+  else if (ec)
+  {
+    throw boost::system::system_error{ec};
+  }
+  co_return r.p->release();
+}
-  template<class InnerCtx>
+template <class InnerCtx>
-  struct routed_ctx : InnerCtx {
+struct routed_ctx : InnerCtx
-    verb_set route_methods;
+{
-  };
+  verb_set route_methods;
+};
-  template<class Ctx>
+template <class Ctx>
  requires requires(Ctx ctx) {
    // Ctx must be derived from an instantiation of routed_ctx
    []<class InnerCtx>(routed_ctx<InnerCtx> const&) {}(ctx);
  }
-  auto default_options_handler(Ctx const& ctx, readable_request r, std::vector<std::string> const&) -> net::awaitable<presponse> {
+auto default_options_handler(
-    auto mreq = co_await read_request<bhttp::empty_body>(ctx, std::move(r));
+    Ctx const& ctx, readable_request r, std::vector<std::string> const&)
-    if (!mreq)
+    -> net::awaitable<presponse>
-      co_return std::move(mreq.error());
+{
+  auto mreq = co_await read_request<bhttp::empty_body>(ctx, std::move(r));
+  if (!mreq)
+    co_return std::move(mreq.error());
-    if (mreq->find(bhttp::field::access_control_request_method) != mreq->end()) {
+  if (mreq->find(bhttp::field::access_control_request_method) != mreq->end())
-      // CORS preflight request
+  {
-      co_return make_preflight_rsp(preflight_response{
+    // CORS preflight request
-          // TODO: should access-control-allow-methods contain OPTIONS?
+    co_return make_preflight_rsp(
-          .allow_methods = ctx.route_methods,
+        preflight_response{
-          .allow_headers = {bhttp::field::content_type},
+            // TODO: should access-control-allow-methods contain OPTIONS?
-        }, keep_alive{mreq->keep_alive()});
+            .allow_methods = ctx.route_methods,
-    } else {
+            .allow_headers = {bhttp::field::content_type},
-      // Normal OPTIONS request
+        },
-      auto rsp = make_rsp<bhttp::empty_body>(bhttp::status::no_content, keep_alive{mreq->keep_alive()});
+        keep_alive{mreq->keep_alive()});
-      rsp.set(bhttp::field::allow, ctx.route_methods.to_string());
-      rsp.prepare_payload();
-      co_return std::move(rsp);
-    }
  }
+  else
-  auto global_options_handler(base_ctx const& ctx, readable_request r) -> net::awaitable<presponse> {
+  {
-    // TODO: switch to "small (4KB) discarded" body type, similar to what Go does?
+    // Normal OPTIONS request
-    // Same goes for default_options_handler? Not sure.
+    auto rsp = make_rsp<bhttp::empty_body>(
-    if (auto res = co_await read_request<bhttp::empty_body>(ctx, std::move(r)); !res)
+        bhttp::status::no_content, keep_alive{mreq->keep_alive()});
-      co_return std::move(res.error());
+    rsp.set(bhttp::field::allow, ctx.route_methods.to_string());
-    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 global_options_handler(base_ctx const& ctx, readable_request r)
-  auto id_middleware(Ctx ctx, bhttp::request_header<bhttp::fields>&, next_handler_t<Ctx> next) -> net::awaitable<presponse> {
+    -> net::awaitable<presponse>
-    co_return co_await next(std::move(ctx));
+{
-  }
+  // 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 A, class B, class C>
+template <class Ctx>
-  auto middleware_compose(middleware_t<A, B> ab, middleware_t<B, C> bc) -> middleware_t<A, C> {
+auto id_middleware(
-    return [ab = std::move(ab), bc = std::move(bc)](A a, bhttp::request_header<bhttp::fields>& header, next_handler_t<C> next) -> net::awaitable<presponse> {
+    Ctx ctx, bhttp::request_header<bhttp::fields>&, next_handler_t<Ctx> next)
-      co_return co_await ab(std::move(a), header, [&](B b) -> net::awaitable<presponse> {
+    -> net::awaitable<presponse>
-          co_return co_await bc(std::move(b), header, next);
+{
-        });
+  co_return co_await next(std::move(ctx));
-    };
+}
-  }
-  template<class A, class B>
+template <class A, class B, class C>
-  auto middleware_wrap_fn(middleware_t<A, B> ab, basic_route_handler_fn_t<B> fn) -> basic_route_handler_fn_t<A> {
+auto middleware_compose(middleware_t<A, B> ab, middleware_t<B, C> bc)
-    return [ab = std::move(ab), fn = std::move(fn)](A a_ctx, readable_request r, std::vector<std::string> const& matches) -> net::awaitable<presponse> {
+    -> middleware_t<A, C>
-      co_return co_await ab(std::move(a_ctx), r.p->get().base(), [&](B b_ctx) -> net::awaitable<presponse> {
+{
-          co_return co_await fn(std::move(b_ctx), r, matches);
+  return [ab = std::move(ab), bc = std::move(bc)](
-        });
+             A a, bhttp::request_header<bhttp::fields>& header,
-    };
+             next_handler_t<C> next) -> net::awaitable<presponse>
-  }
+  {
+    co_return co_await ab(
+        std::move(a), header, [&](B b) -> net::awaitable<presponse>
+        { co_return co_await bc(std::move(b), header, next); });
+  };
+}
+template <class A, class B>
+auto middleware_wrap_fn(middleware_t<A, B> ab, basic_route_handler_fn_t<B> fn)
+    -> basic_route_handler_fn_t<A>
+{
+  return
+      [ab = std::move(ab), fn = std::move(fn)](
+          A a_ctx, readable_request r,
+          std::vector<std::string> const& matches) -> net::awaitable<presponse>
+  {
+    co_return co_await ab(
+        std::move(a_ctx), r.p->get().base(),
+        [&](B b_ctx) -> net::awaitable<presponse>
+        { co_return co_await fn(std::move(b_ctx), r, matches); });
+  };
+}
-  template<std::default_initializable V>
+template <std::default_initializable V>
  requires requires(V v) {
    { static_cast<bool>(v) };
  }
-  struct handler_map {
+struct handler_map
-    V options = {};
+{
-    V delete_ = {};
+  V options = {};
-    V get     = {};
+  V delete_ = {};
-    V head    = {};
+  V get = {};
-    V post    = {};
+  V head = {};
-    V put     = {};
+  V post = {};
+  V put = {};
-    template<class Self>
+  template <class Self>
-    auto lookup(this Self&& self, supported_verb v) -> auto&& {
+  auto lookup(this Self&& self, supported_verb v) -> auto&&
-      switch (v.value) {
+  {
-      case supported_verb::options: return std::forward<Self>(self).options;
+    switch (v.value)
-      case supported_verb::delete_: return std::forward<Self>(self).delete_;
+    {
-      case supported_verb::get:     return std::forward<Self>(self).get;
+    case supported_verb::options:
-      case supported_verb::head:    return std::forward<Self>(self).head;
+      return std::forward<Self>(self).options;
-      case supported_verb::post:    return std::forward<Self>(self).post;
+    case supported_verb::delete_:
-      case supported_verb::put:     return std::forward<Self>(self).put;
+      return std::forward<Self>(self).delete_;
-      }
+    case supported_verb::get:
+      return std::forward<Self>(self).get;
+    case supported_verb::head:
+      return std::forward<Self>(self).head;
+    case supported_verb::post:
+      return std::forward<Self>(self).post;
+    case supported_verb::put:
+      return std::forward<Self>(self).put;
    }
+  }
-    auto verbs() const -> verb_set {
+  auto verbs() const -> verb_set
-      auto set = verb_set{};
+  {
-      if (static_cast<bool>(options))
+    auto set = verb_set{};
-        set.enable(supported_verb::options);
+    if (static_cast<bool>(options))
-      if (static_cast<bool>(delete_))
+      set.enable(supported_verb::options);
-        set.enable(supported_verb::delete_);
+    if (static_cast<bool>(delete_))
-      if (static_cast<bool>(get))
+      set.enable(supported_verb::delete_);
-        set.enable(supported_verb::get);
+    if (static_cast<bool>(get))
-      if (static_cast<bool>(head))
+      set.enable(supported_verb::get);
-        set.enable(supported_verb::head);
+    if (static_cast<bool>(head))
-      if (static_cast<bool>(post))
+      set.enable(supported_verb::head);
-        set.enable(supported_verb::post);
+    if (static_cast<bool>(post))
-      if (static_cast<bool>(put))
+      set.enable(supported_verb::post);
-        set.enable(supported_verb::put);
+    if (static_cast<bool>(put))
-      return set;
+      set.enable(supported_verb::put);
-    }
+    return set;
+  }
-    auto empty() const -> bool {
+  auto empty() const -> bool { return verbs().empty(); }
-      return verbs().empty();
-    }
-    template<std::default_initializable U>
+  template <std::default_initializable U>
-    auto map(std::invocable<V const&> auto f) const -> handler_map<U>
+  auto map(std::invocable<V const&> auto f) const -> handler_map<U>
-      requires std::assignable_from<U&, std::invoke_result_t<decltype(f), V const&>>
+    requires std::assignable_from<
-    {
+        U&, std::invoke_result_t<decltype(f), V const&>>
-      return {
+  {
+    return {
        .options = static_cast<bool>(options) ? f(options) : U{},
        .delete_ = static_cast<bool>(delete_) ? f(delete_) : U{},
-        .get     = static_cast<bool>(get)     ? f(get)     : U{},
+        .get = static_cast<bool>(get) ? f(get) : U{},
-        .head    = static_cast<bool>(head)    ? f(head)    : U{},
+        .head = static_cast<bool>(head) ? f(head) : U{},
-        .post    = static_cast<bool>(post)    ? f(post)    : U{},
+        .post = static_cast<bool>(post) ? f(post) : U{},
-        .put     = static_cast<bool>(put)     ? f(put)     : U{},
+        .put = static_cast<bool>(put) ? f(put) : U{},
-      };
+    };
-    }
+  }
-  };
+};
-  template<class Ctx>
+template <class Ctx>
-  struct route_tree {
+struct route_tree
-    using leaves = handler_map<basic_route_handler_fn_t<Ctx>>;
+{
-    using named_subtrees = std::unordered_map<std::string, route_tree>;
+  using leaves = handler_map<basic_route_handler_fn_t<Ctx>>;
-    using wildcard_subtree = std::indirect<route_tree>;
+  using named_subtrees = std::unordered_map<std::string, route_tree>;
+  using wildcard_subtree = std::indirect<route_tree>;
-    leaves here;
+  leaves here;
-    // TODO: consider making the first alternative a radix tree
+  // TODO: consider making the first alternative a radix tree
-    // Note: the map is the first variant here; the variant will be
+  // Note: the map is the first variant here; the variant will be
-    // default-constructed with the default-constructed first
+  // default-constructed with the default-constructed first
-    // alternative. The empty map denotes a lack of subtrees.
+  // alternative. The empty map denotes a lack of subtrees.
-    std::variant<named_subtrees, wildcard_subtree> sub;
+  std::variant<named_subtrees, wildcard_subtree> sub;
-  };
+};
-  template<class OuterCtx, class InnerCtx>
+template <class OuterCtx, class InnerCtx>
-  auto middleware_wrap_tree(middleware_t<OuterCtx, InnerCtx> mw, route_tree<InnerCtx> const& tree) -> route_tree<OuterCtx> {
+auto middleware_wrap_tree(
-    auto new_leaves = tree.here.template map<basic_route_handler_fn_t<OuterCtx>>(std::bind_front(middleware_wrap_fn<OuterCtx, InnerCtx>, mw));
+    middleware_t<OuterCtx, InnerCtx> mw, route_tree<InnerCtx> const& tree)
-    auto new_sub = tree.sub.visit(util::overloaded{
+    -> route_tree<OuterCtx>
-        [&mw](route_tree<InnerCtx>::named_subtrees const& subtrees) -> decltype(route_tree<OuterCtx>::sub) {
+{
-          auto new_subtrees = typename route_tree<OuterCtx>::named_subtrees{};
+  auto new_leaves = tree.here.template map<basic_route_handler_fn_t<OuterCtx>>(
-          for (auto [seg, subtree] : subtrees)
+      std::bind_front(middleware_wrap_fn<OuterCtx, InnerCtx>, mw));
-            new_subtrees[seg] = middleware_wrap_tree(mw, subtree);
+  auto new_sub = tree.sub.visit(
-          return new_subtrees;
+      util::overloaded{
-        },
+          [&mw](route_tree<InnerCtx>::named_subtrees const& subtrees)
-        [&mw](route_tree<InnerCtx>::wildcard_subtree const& subtree) -> decltype(route_tree<OuterCtx>::sub) {
+              -> decltype(route_tree<OuterCtx>::sub)
-          return typename route_tree<OuterCtx>::wildcard_subtree{middleware_wrap_tree(mw, *subtree)};
+          {
-        },
+            auto new_subtrees = typename route_tree<OuterCtx>::named_subtrees{};
+            for (auto [seg, subtree] : subtrees)
+              new_subtrees[seg] = middleware_wrap_tree(mw, subtree);
+            return new_subtrees;
+          },
+          [&mw](route_tree<InnerCtx>::wildcard_subtree const& subtree)
+              -> decltype(route_tree<OuterCtx>::sub)
+          {
+            return typename route_tree<OuterCtx>::wildcard_subtree{
+                middleware_wrap_tree(mw, *subtree)
+            };
+          },
      });
-    return {.here = new_leaves, .sub = new_sub};
+  return {.here = new_leaves, .sub = new_sub};
-  }
+}
-  template<class T>
+template <class T>
-  concept match_arg = std::constructible_from<T, std::string const&>;
+concept match_arg = std::constructible_from<T, std::string const&>;
-  template<class Ctx, match_arg... MatchArgs>
+template <class Ctx, match_arg... MatchArgs>
-  using route_handler_fn_t = std::function<auto(Ctx, readable_request, MatchArgs...) -> net::awaitable<presponse>>;
+using route_handler_fn_t = std::function<
+    auto(Ctx, readable_request, MatchArgs...)->net::awaitable<presponse>>;
-  template<class Ctx, match_arg... MatchArgs>
+template <class Ctx, match_arg... MatchArgs>
-  auto degen_route_handler(route_handler_fn_t<Ctx, MatchArgs...> fn) -> basic_route_handler_fn_t<Ctx> {
+auto degen_route_handler(route_handler_fn_t<Ctx, MatchArgs...> fn)
-    return [fn = std::move(fn)](Ctx ctx, readable_request r, std::vector<std::string> const& matches) -> net::awaitable<presponse> {
+    -> basic_route_handler_fn_t<Ctx>
-      if (sizeof...(MatchArgs) != matches.size())
+{
-        throw std::runtime_error{"got unexpected amount of matches"};
+  return
-      auto it = matches.begin();
+      [fn = std::move(fn)](
-      co_return co_await fn(std::move(ctx), r, MatchArgs{static_cast<std::string const&>(*it++)}...);
+          Ctx ctx, readable_request r,
-    };
+          std::vector<std::string> const& matches) -> net::awaitable<presponse>
-  }
+  {
+    if (sizeof...(MatchArgs) != matches.size())
-  template<class Ctx, match_arg... MatchArgs>
+      throw std::runtime_error{"got unexpected amount of matches"};
-  struct ctree : route_tree<Ctx> {
+    auto it = matches.begin();
-    template<class OuterCtx>
+    co_return co_await fn(
-    auto wrap(middleware_t<OuterCtx, Ctx> mw) const -> ctree<OuterCtx, MatchArgs...> {
+        std::move(ctx), r,
-      return {middleware_wrap_tree(std::move(mw), *this)};
+        MatchArgs{static_cast<std::string const&>(*it++)}...);
-    }
  };
+}
-  template<class Ctx, match_arg... MatchArgs>
+template <class Ctx, match_arg... MatchArgs>
-  struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>> {
+struct ctree : route_tree<Ctx>
-    [[nodiscard]] auto to_leaves() const -> typename route_tree<Ctx>::leaves {
+{
-      auto here = this->template map<basic_route_handler_fn_t<Ctx>>(degen_route_handler<Ctx, MatchArgs...>);
+  template <class OuterCtx>
-      if (!here.verbs().empty() && !static_cast<bool>(this->options))
+  auto wrap(middleware_t<OuterCtx, Ctx> mw) const
-        here.options = default_options_handler<Ctx>;
+      -> ctree<OuterCtx, MatchArgs...>
-      return here;
+  {
-    }
+    return {middleware_wrap_tree(std::move(mw), *this)};
+  }
+};
-    [[nodiscard]] auto named_subtrees(std::initializer_list<std::pair<std::string, ctree<Ctx, MatchArgs...>>> subtrees) const -> ctree<Ctx, MatchArgs...> {
+template <class Ctx, match_arg... MatchArgs>
-      auto sub = typename route_tree<Ctx>::named_subtrees{
+struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>>
-        std::from_range,
+{
-        subtrees | std::views::transform([](auto const& p) {
+  [[nodiscard]] auto to_leaves() const -> typename route_tree<Ctx>::leaves
-          return std::make_pair(p.first, static_cast<route_tree<Ctx>>(p.second));
+  {
-        })
+    auto here = this->template map<basic_route_handler_fn_t<Ctx>>(
-      };
+        degen_route_handler<Ctx, MatchArgs...>);
-      return {route_tree<Ctx>{.here = to_leaves(), .sub = sub}};
+    if (!here.verbs().empty() && !static_cast<bool>(this->options))
-    }
+      here.options = default_options_handler<Ctx>;
+    return here;
+  }
-    template<match_arg MatchArg>
+  [[nodiscard]] auto named_subtrees(
-    [[nodiscard]] auto wildcard_subtree(ctree<Ctx, MatchArgs..., MatchArg> subtree) -> ctree<Ctx, MatchArgs...> {
+      std::initializer_list<std::pair<std::string, ctree<Ctx, MatchArgs...>>>
-      return {route_tree<Ctx>{.here = to_leaves(), .sub = typename route_tree<Ctx>::wildcard_subtree{static_cast<route_tree<Ctx>>(subtree)}}};
+          subtrees) const -> ctree<Ctx, MatchArgs...>
-    }
+  {
+    auto sub = typename route_tree<Ctx>::named_subtrees{
+        std::from_range, subtrees
+                             | std::views::transform(
+                                 [](auto const& p)
+                                 {
+                                   return std::make_pair(
+                                       p.first,
+                                       static_cast<route_tree<Ctx>>(p.second));
+                                 })
+    };
+    return {route_tree<Ctx>{.here = to_leaves(), .sub = sub}};
+  }
-    [[nodiscard]] auto no_subtrees() const -> ctree<Ctx, MatchArgs...> {
+  template <match_arg MatchArg>
-      return {route_tree<Ctx>{.here = to_leaves(), .sub = {}}};
+  [[nodiscard]] auto
-    }
+  wildcard_subtree(ctree<Ctx, MatchArgs..., MatchArg> subtree)
-  };
+      -> ctree<Ctx, MatchArgs...>
+  {
+    return {route_tree<Ctx>{
+        .here = to_leaves(),
+        .sub = typename route_tree<Ctx>::wildcard_subtree{
+            static_cast<route_tree<Ctx>>(subtree)
+        }
+    }};
+  }
-  template<std::derived_from<base_ctx> PreRouteCtx>
+  [[nodiscard]] auto no_subtrees() const -> ctree<Ctx, MatchArgs...>
-  class server {
+  {
-    log::logger l_;
+    return {route_tree<Ctx>{.here = to_leaves(), .sub = {}}};
-    locale::selector lsel_;
+  }
-    middleware_t<base_ctx, PreRouteCtx> global_middleware_;
+};
-    route_tree<routed_ctx<PreRouteCtx>> routes_;
-  public:
+template <std::derived_from<base_ctx> PreRouteCtx>
-    explicit server(log::logger const& l, locale::selector&& lsel, middleware_t<base_ctx, PreRouteCtx> global_middleware, route_tree<routed_ctx<PreRouteCtx>> routes)
+class server
-      : l_{l.sub("http_server")}, lsel_{std::move(lsel)}, global_middleware_{std::move(global_middleware)}, routes_{std::move(routes)}
+{
-    {}
+  log::logger l_;
+  locale::selector lsel_;
+  middleware_t<base_ctx, PreRouteCtx> global_middleware_;
+  route_tree<routed_ctx<PreRouteCtx>> routes_;
-    struct match_result {
+public:
-      util::not_null<handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*> route_handlers;
+  explicit server(
-      std::vector<std::string> wildcard_matches;
+      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)}
+  {
+  }
-      auto allowed_methods() const -> verb_set {
+  struct match_result
-        return route_handlers->verbs();
+  {
-      }
+    util::not_null<
-    };
+        handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*>
+        route_handlers;
+    std::vector<std::string> wildcard_matches;
-    auto match(boost::urls::segments_view segments) const -> std::optional<match_result> {
+    auto allowed_methods() const -> verb_set { return route_handlers->verbs(); }
-      auto const* tree = &routes_;
+  };
-      auto wildcard_matches = std::vector<std::string>{};
-      for (auto const& seg : segments) {
+  auto match(boost::urls::segments_view segments) const
-        tree->sub.visit(util::overloaded{
+      -> std::optional<match_result>
-            [&](route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const& subtrees) {
+  {
-              auto it = subtrees.find(seg);
+    auto const* tree = &routes_;
-              tree = it == subtrees.end() ? nullptr : &it->second;
+    auto wildcard_matches = std::vector<std::string>{};
-            },
+    for (auto const& seg : segments)
-            [&](route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const& wildcard_subtree) {
+    {
-              wildcard_matches.push_back(seg);
+      tree->sub.visit(
-              tree = &*wildcard_subtree;
+          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)
-      }
+        return std::nullopt;
-      if (tree->here.empty()) return std::nullopt;
-      return match_result{
-        .route_handlers   = util::not_null{&tree->here},
-        .wildcard_matches = wildcard_matches,
-      };
    }
+    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 -> net::awaitable<presponse> {
+  auto route_request(PreRouteCtx ctx, readable_request r) const
-      auto req_base = r.p->get().base();
+      -> net::awaitable<presponse>
+  {
+    auto req_base = r.p->get().base();
-      auto const bad_request_tpl = problem::tpl{
+    auto const bad_request_tpl = problem::tpl{
-        .status   = bhttp::status::bad_request,
+        .status = bhttp::status::bad_request,
-        .title    = translate("Bad request"),
+        .title = translate("Bad request"),
        .type_uri = "https://routemon.fautchen.eu/problems/bad-request",
-      };
+    };
-      if (req_base.target() == "*") {
+    if (req_base.target() == "*")
-        // request-target is in asterisk-form (RFC 9112, § 3.2.4),
+    {
-        // so the request must be a server-wide OPTIONS request.
+      // request-target is in asterisk-form (RFC 9112, § 3.2.4),
+      // so the request must be a server-wide OPTIONS request.
-        if (req_base.method() != bhttp::verb::options) {
+      if (req_base.method() != bhttp::verb::options)
-          auto tpl = problem::tpl{
+      {
-            .status   = bhttp::status::method_not_allowed,
+        auto tpl = problem::tpl{
-            .title    = translate("Method not allowed"),
+            .status = bhttp::status::method_not_allowed,
-            .type_uri = "https://routemon.fautchen.eu/problems/method-not-allowed",
+            .title = translate("Method not allowed"),
-          };
+            .type_uri = "https://routemon.fautchen.eu/problems/"
-          co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+                        "method-not-allowed",
-        }
+        };
+        co_return problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+      }
-        co_return co_await global_options_handler(ctx, r);
+      co_return co_await global_options_handler(ctx, r);
-      } else if (auto mreq_url0 = boost::urls::parse_origin_form(req_base.target())) {
+    }
-        // request-target is in origin-form (RFC 9112, § 3.2.1),
+    else if (auto mreq_url0 = boost::urls::parse_origin_form(req_base.target()))
-        // so it must be a normal request (not a CONNECT or
+    {
-        // server-wide OPTIONS request).
+      // request-target is in origin-form (RFC 9112, § 3.2.1),
+      // so it must be a normal request (not a CONNECT or
+      // server-wide OPTIONS request).
-        auto req_url = boost::urls::url{*mreq_url0};
+      auto req_url = boost::urls::url{*mreq_url0};
-        req_url.normalize();
+      req_url.normalize();
-        if (!req_url.is_path_absolute()) {
+      if (!req_url.is_path_absolute())
-          auto problem = bad_request_tpl.instantiate().
+      {
-            set_detail(translate("Path of normalized (RFC 3986, § 6) "
+        auto problem = bad_request_tpl.instantiate().set_detail(translate(
-                                 "origin-form request-target (RFC "
+            "Path of normalized (RFC 3986, § 6) "
-                                 "9112, § 3.2.1) should be "
+            "origin-form request-target (RFC "
-                                 "absolute"));
+            "9112, § 3.2.1) should be "
-          co_return problem_rsp(ctx, problem, keep_alive{false});
+            "absolute"));
-        }
+        co_return problem_rsp(ctx, problem, keep_alive{false});
+      }
-        auto mres = match(req_url.segments());
+      auto mres = match(req_url.segments());
-        if (!mres) {
+      if (!mres)
-          auto tpl = problem::tpl{
+      {
-            .status   = bhttp::status::not_found,
+        auto tpl = problem::tpl{
-            .title    = translate("Not found"),
+            .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});
+        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 mverb = supported_verb::from(req_base.method());
-          auto new_ctx = routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
+      if (!mverb)
-          co_return co_await mhdl(std::move(new_ctx), r, mres->wildcard_matches);
+      {
-        } else {
+        // Method not implemented.
-          // Path recognized, but method not allowed.
+        auto tpl = problem::tpl{
-          auto tpl = problem::tpl{
+            .status = bhttp::status::not_implemented,
-            .status   = bhttp::status::method_not_allowed,
+            .title = translate("Method not implemented"),
-            .title    = translate("Method not allowed"),
+            .type_uri = "https://routemon.fautchen.eu/problems/"
-            .type_uri = "https://routemon.fautchen.eu/problems/method-not-allowed",
+                        "method-not-implemented",
-          };
+        };
-          auto rsp = problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
+        co_return 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().
+      if (auto mhdl = mres->route_handlers->lookup(*mverb))
-          set_detail(translate("Invalid request-target, expected "
+      {
-                               "asterisk-form or origin-form "
+        auto new_ctx =
-                               "(see RFC 9112, § 3.2)"));
+            routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
-        co_return problem_rsp(ctx, problem, keep_alive{false});
+        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
+    {
+      // We do not accept any other request-target forms.
-    auto handle_request(readable_request r) const -> net::awaitable<presponse> {
+      auto problem = bad_request_tpl.instantiate().set_detail(translate(
-      auto header = r.p->get().base();
+          "Invalid request-target, expected "
-      auto locale = lsel_.select(header[bhttp::field::accept_language]);
+          "asterisk-form or origin-form "
-      auto ctx0 = base_ctx{.locale = locale};
+          "(see RFC 9112, § 3.2)"));
+      co_return problem_rsp(ctx, problem, keep_alive{false});
-      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{};
+  {
+    auto header = r.p->get().base();
+    auto locale = lsel_.select(header[bhttp::field::accept_language]);
+    auto ctx0 = base_ctx{.locale = locale};
-      while (true) {
+    co_return co_await global_middleware_(
-        auto p0 = bhttp::request_parser<bhttp::empty_body>{};
+        std::move(ctx0), header,
-        p0.body_limit(boost::none);
+        [&](PreRouteCtx ctx) -> net::awaitable<presponse>
-        auto [ec, _] = co_await bhttp::async_read_header(strm, buf, p0, net::as_tuple);
+        { co_return co_await route_request(std::move(ctx), std::move(r)); });
-        if (ec == bhttp::error::end_of_stream) {
+  }
-          break;
-        } else if (ec) {
-          throw boost::system::system_error{ec};
-        }
-        auto http_version = p0.get().version();
+  auto do_session(beast::tcp_stream strm) -> net::awaitable<void>
-        auto&& rsp = co_await handle_request(readable_request{
+  {
-            .p    = util::not_null{&p0},
+    auto buf = beast::flat_buffer{};
-            .strm = util::not_null{&strm},
-            .buf  = util::not_null{&buf},
+    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);
+      rsp.header().version(http_version);
-        bool keep_alive = rsp.keep_alive();
+      bool keep_alive = rsp.keep_alive();
-        co_await beast::async_write(strm, std::move(rsp));
+      co_await beast::async_write(strm, std::move(rsp));
-        if (!keep_alive) {
+      if (!keep_alive)
-          break;
+      {
-        }
+        break;
      }
-      strm.socket().shutdown(tcp::socket::shutdown_send);
    }
-    auto do_listen(tcp::endpoint endpoint) -> net::awaitable<void> {
+    strm.socket().shutdown(tcp::socket::shutdown_send);
-      auto executor = co_await net::this_coro::executor;
+  }
-      auto acceptor = tcp::acceptor{executor, endpoint};
+  auto do_listen(tcp::endpoint endpoint) -> net::awaitable<void>
+  {
+    auto executor = co_await net::this_coro::executor;
+    auto acceptor = tcp::acceptor{executor, endpoint};
-      l_.with("endpoint", endpoint.address().to_string()).
+    l_.with("endpoint", endpoint.address().to_string())
-        with("port", std::to_string(endpoint.port())).
+        .with("port", std::to_string(endpoint.port()))
-        info("Serving");
+        .info("Serving");
-      while (true) {
+    while (true)
-        net::co_spawn(executor,
+    {
-                      do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
+      net::co_spawn(
-                      [this](std::exception_ptr e) {
+          executor,
-                        if (e) {
+          do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
-                          try {
+          [this](std::exception_ptr e)
-                            std::rethrow_exception(e);
+          {
-                          } catch (std::exception const& e) {
+            if (e)
-                            l_.error("Error in session: {}", e.what());
+            {
-                          }
+              try
-                        }
+              {
-                      });
+                std::rethrow_exception(e);
-      }
+              }
+              catch (std::exception const& e)
+              {
+                l_.error("Error in session: {}", e.what());
+              }
+            }
+          });
    }
+  }
-    auto spawn(net::io_context& ioc) -> void {
+  auto spawn(net::io_context& ioc) -> void
-      auto const addr = net::ip::make_address("0.0.0.0");
+  {
-      auto const endpoint = tcp::endpoint{addr, 8284};
+    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
+    // TODO: make exception handling as nice as in srv.cpp
-      net::co_spawn(ioc,
+    net::co_spawn(
-                    do_listen(endpoint),
+        ioc, do_listen(endpoint),
-                    [this](std::exception_ptr e) {
+        [this](std::exception_ptr e)
-                      if (e) {
+        {
-                        try {
+          if (e)
-                          std::rethrow_exception(e);
+          {
-                        } catch (std::exception const& e) {
+            try
-                          l_.error("Error: {}", e.what());
+            {
-                        }
+              std::rethrow_exception(e);
-                      }
+            }
-                    });
+            catch (std::exception const& e)
-    }
+            {
-  };
+              l_.error("Error: {}", e.what());
+            }
+          }
+        });
+  }
+};
 } // namespace routemon::http