1 files changed, 164 insertions, 158 deletions
diff --git a/server/src/http_server.cppm b/server/src/http_server.cppm
index 366037f..f5b4c3e 100644
--- a/server/src/http_server.cppm
+++ b/server/src/http_server.cppm
@@ -41,7 +41,7 @@ private:
    virtual ~impl_base() = default;
    virtual auto header() -> bhttp::response_header<bhttp::fields>& = 0;
    virtual auto header() const
-      -> bhttp::response_header<bhttp::fields> const& = 0;
+        -> bhttp::response_header<bhttp::fields> const& = 0;
    virtual auto is_done() const -> bool = 0;
    virtual auto prepare(beast::error_code&) -> const_buffers_type = 0;
    virtual auto consume(std::size_t n) -> void = 0;
@@ -121,12 +121,12 @@ private:
    auto keep_alive() const noexcept -> bool override
    {
      return state_.visit(
-        util::overloaded{
+          util::overloaded{
-          [](bhttp::response<Body> const& rsp) -> bool
+            [](bhttp::response<Body> const& rsp) -> bool
-          { return rsp.keep_alive(); },
+            { return rsp.keep_alive(); },
-          [](bhttp::message_generator const& gen) -> bool
+            [](bhttp::message_generator const& gen) -> bool
-          { return gen.keep_alive(); },
+            { return gen.keep_alive(); },
-        });
+          });
    }
  };
@@ -164,15 +164,15 @@ using next_handler_t = std::function<auto(Ctx)->net::awaitable<presponse>>;
 template <class OuterCtx, class InnerCtx>
 using middleware_t =
-  std::function<auto(
+    std::function<auto(
-                  OuterCtx, bhttp::request_header<bhttp::fields>&,
+                      OuterCtx, bhttp::request_header<bhttp::fields>&,
-                  next_handler_t<InnerCtx>)
+                      next_handler_t<InnerCtx>)
-                  ->net::awaitable<presponse>>;
+                      ->net::awaitable<presponse>>;
 template <class Ctx>
 auto lax_cors_middleware(
-  Ctx ctx, bhttp::request_header<bhttp::fields>& req_hdr,
+    Ctx ctx, bhttp::request_header<bhttp::fields>& req_hdr,
-  next_handler_t<Ctx> next) -> net::awaitable<presponse>
+    next_handler_t<Ctx> next) -> net::awaitable<presponse>
 {
  std::ignore = req_hdr;
  auto prersp = co_await next(ctx);
@@ -188,16 +188,16 @@ struct trace_id_ctx : InnerCtx
 template <class OuterCtx>
 auto trace_id_middleware(
-  OuterCtx ctx0, bhttp::request_header<bhttp::fields>& req_hdr,
+    OuterCtx ctx0, bhttp::request_header<bhttp::fields>& req_hdr,
-  next_handler_t<trace_id_ctx<OuterCtx>> next) -> net::awaitable<presponse>
+    next_handler_t<trace_id_ctx<OuterCtx>> next) -> net::awaitable<presponse>
 {
  std::ignore = req_hdr;
  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()});
+      "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");
+      bhttp::field::access_control_expose_headers, "X-Routemon-Trace-Id");
  co_return std::move(prersp);
 }
@@ -208,8 +208,8 @@ struct base_ctx
 template <class Ctx>
 using basic_route_handler_fn_t = std::function<
-  auto(Ctx, readable_request, std::vector<std::string> const& matches)
+    auto(Ctx, readable_request, std::vector<std::string> const& matches)
-    ->net::awaitable<presponse>>;
+        ->net::awaitable<presponse>>;
 struct keep_alive
 {
@@ -228,8 +228,8 @@ 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)
+    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");
@@ -244,17 +244,18 @@ struct preflight_response
  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
+                               [](auto const& field) -> std::string_view
-                             { return bhttp::to_string(field); })
+                               { 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());
+      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;
@@ -265,7 +266,7 @@ auto make_preflight_rsp(preflight_response res, keep_alive ka)
 // 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>>
+    -> net::awaitable<std::expected<bhttp::request<Body>, presponse>>
 {
  std::ignore = ctx;
  auto p = bhttp::request_parser<Body>{std::move(*r.p)};
@@ -275,10 +276,11 @@ 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<std::expected<bhttp::request<bhttp::empty_body>, presponse>>
+    -> 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);
+      co_await bhttp::async_read(*r.strm, *r.buf, *r.p, net::as_tuple);
  if (ec == bhttp::error::unexpected_body)
  {
    auto tpl = problem::tpl{
@@ -287,7 +289,7 @@ auto read_request<bhttp::empty_body>(base_ctx const& ctx, readable_request&& r)
      .type_uri = "https://routemon.fautchen.eu/problems/unexpected-body",
    };
    co_return std::unexpected{problem_rsp(
-      ctx, tpl.instantiate(), keep_alive{false})};
+        ctx, tpl.instantiate(), keep_alive{false})};
  }
  else if (ec)
  {
@@ -308,8 +310,8 @@ template <class Ctx>
    []<class InnerCtx>(routed_ctx<InnerCtx> const&) {}(ctx);
  }
 auto default_options_handler(
-  Ctx const& ctx, readable_request r, std::vector<std::string> const&)
+    Ctx const& ctx, readable_request r, std::vector<std::string> const&)
-  -> net::awaitable<presponse>
+    -> net::awaitable<presponse>
 {
  auto mreq = co_await read_request<bhttp::empty_body>(ctx, std::move(r));
  if (!mreq)
@@ -319,18 +321,18 @@ auto default_options_handler(
  {
    // CORS preflight request
    co_return make_preflight_rsp(
-      preflight_response{
+        preflight_response{
-        // TODO: should access-control-allow-methods contain OPTIONS?
+          // TODO: should access-control-allow-methods contain OPTIONS?
-        .allow_methods = ctx.route_methods,
+          .allow_methods = ctx.route_methods,
-        .allow_headers = {bhttp::field::content_type},
+          .allow_headers = {bhttp::field::content_type},
-      },
+        },
-      keep_alive{mreq->keep_alive()});
+        keep_alive{mreq->keep_alive()});
  }
  else
  {
    // Normal OPTIONS request
    auto rsp = make_rsp<bhttp::empty_body>(
-      bhttp::status::no_content, keep_alive{mreq->keep_alive()});
+        bhttp::status::no_content, keep_alive{mreq->keep_alive()});
    rsp.set(bhttp::field::allow, ctx.route_methods.to_string());
    rsp.prepare_payload();
    co_return std::move(rsp);
@@ -338,7 +340,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.
@@ -347,45 +349,46 @@ auto global_options_handler(base_ctx const& ctx, readable_request r)
    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()});
+      bhttp::status::no_content, keep_alive{req.keep_alive()});
  rsp.prepare_payload();
  co_return std::move(rsp);
 }
 template <class Ctx>
 auto id_middleware(
-  Ctx ctx, bhttp::request_header<bhttp::fields>&, next_handler_t<Ctx> next)
+    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));
 }
 template <class A, class B, class C>
 auto middleware_compose(middleware_t<A, B> ab, middleware_t<B, C> bc)
-  -> middleware_t<A, C>
+    -> middleware_t<A, C>
 {
  return [ab = std::move(ab), bc = std::move(bc)](
-           A a, bhttp::request_header<bhttp::fields>& header,
+             A a, bhttp::request_header<bhttp::fields>& header,
-           next_handler_t<C> next) -> net::awaitable<presponse>
+             next_handler_t<C> next) -> net::awaitable<presponse>
  {
    co_return co_await ab(
-      std::move(a), header, [&](B b) -> net::awaitable<presponse>
+        std::move(a), header, [&](B b) -> net::awaitable<presponse>
-      { co_return co_await bc(std::move(b), header, next); });
+        { 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>
+    -> basic_route_handler_fn_t<A>
 {
-  return [ab = std::move(ab), fn = std::move(fn)](
+  return
-           A a_ctx, readable_request r,
+      [ab = std::move(ab), fn = std::move(fn)](
-           std::vector<std::string> const& matches) -> net::awaitable<presponse>
+          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(),
+        std::move(a_ctx), r.p->get().base(),
-      [&](B b_ctx) -> net::awaitable<presponse>
+        [&](B b_ctx) -> net::awaitable<presponse>
-      { co_return co_await fn(std::move(b_ctx), r, matches); });
+        { co_return co_await fn(std::move(b_ctx), r, matches); });
  };
 }
@@ -445,7 +448,7 @@ struct handler_map
  template <std::default_initializable 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&>>
+        U&, std::invoke_result_t<decltype(f), V const&>>
  {
    return {
      .options = static_cast<bool>(options) ? f(options) : U{},
@@ -475,29 +478,29 @@ struct route_tree
 template <class OuterCtx, class InnerCtx>
 auto middleware_wrap_tree(
-  middleware_t<OuterCtx, InnerCtx> mw, route_tree<InnerCtx> const& tree)
+    middleware_t<OuterCtx, InnerCtx> mw, route_tree<InnerCtx> const& tree)
-  -> route_tree<OuterCtx>
+    -> route_tree<OuterCtx>
 {
  auto new_leaves = tree.here.template map<basic_route_handler_fn_t<OuterCtx>>(
-    std::bind_front(middleware_wrap_fn<OuterCtx, InnerCtx>, mw));
+      std::bind_front(middleware_wrap_fn<OuterCtx, InnerCtx>, mw));
  auto new_sub = tree.sub.visit(
-    util::overloaded{
+      util::overloaded{
-      [&mw](route_tree<InnerCtx>::named_subtrees const& subtrees)
+        [&mw](route_tree<InnerCtx>::named_subtrees const& subtrees)
-        -> decltype(route_tree<OuterCtx>::sub)
+            -> decltype(route_tree<OuterCtx>::sub)
-      {
+        {
-        auto new_subtrees = typename route_tree<OuterCtx>::named_subtrees{};
+          auto new_subtrees = typename route_tree<OuterCtx>::named_subtrees{};
-        for (auto [seg, subtree] : subtrees)
+          for (auto [seg, subtree] : subtrees)
-          new_subtrees[seg] = middleware_wrap_tree(mw, subtree);
+            new_subtrees[seg] = middleware_wrap_tree(mw, subtree);
-        return new_subtrees;
+          return new_subtrees;
-      },
+        },
-      [&mw](route_tree<InnerCtx>::wildcard_subtree const& subtree)
+        [&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{
+          return typename route_tree<OuterCtx>::wildcard_subtree{
-          middleware_wrap_tree(mw, *subtree)
+            middleware_wrap_tree(mw, *subtree)
-        };
+          };
-      },
+        },
-    });
+      });
  return {.here = new_leaves, .sub = new_sub};
 }
@@ -506,21 +509,23 @@ concept match_arg = std::constructible_from<T, std::string const&>;
 template <class Ctx, match_arg... MatchArgs>
 using route_handler_fn_t = std::function<
-  auto(Ctx, readable_request, MatchArgs...)->net::awaitable<presponse>>;
+    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)
-  -> basic_route_handler_fn_t<Ctx>
+    -> basic_route_handler_fn_t<Ctx>
 {
-  return [fn = std::move(fn)](
+  return
-           Ctx ctx, readable_request r,
+      [fn = std::move(fn)](
-           std::vector<std::string> const& matches) -> net::awaitable<presponse>
+          Ctx ctx, readable_request r,
+          std::vector<std::string> const& matches) -> net::awaitable<presponse>
  {
    if (sizeof...(MatchArgs) != matches.size())
      throw std::runtime_error{"got unexpected amount of matches"};
    auto it = matches.begin();
    co_return co_await fn(
-      std::move(ctx), r, MatchArgs{static_cast<std::string const&>(*it++)}...);
+        std::move(ctx), r,
+        MatchArgs{static_cast<std::string const&>(*it++)}...);
  };
 }
@@ -529,7 +534,7 @@ struct ctree : route_tree<Ctx>
 {
  template <class OuterCtx>
  auto wrap(middleware_t<OuterCtx, Ctx> mw) const
-    -> ctree<OuterCtx, MatchArgs...>
+      -> ctree<OuterCtx, MatchArgs...>
  {
    return {middleware_wrap_tree(std::move(mw), *this)};
  }
@@ -541,24 +546,25 @@ struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>>
  [[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...>);
+        degen_route_handler<Ctx, MatchArgs...>);
    if (!here.verbs().empty() && !static_cast<bool>(this->options))
      here.options = default_options_handler<Ctx>;
    return here;
  }
  [[nodiscard]] auto named_subtrees(
-    std::initializer_list<std::pair<std::string, ctree<Ctx, MatchArgs...>>>
+      std::initializer_list<std::pair<std::string, ctree<Ctx, MatchArgs...>>>
-      subtrees) const -> ctree<Ctx, MatchArgs...>
+          subtrees) const -> ctree<Ctx, MatchArgs...>
  {
    auto sub = typename route_tree<Ctx>::named_subtrees{
      std::from_range, subtrees
-                         | std::views::transform(
+                           | std::views::transform(
-                           [](auto const& p)
+                               [](auto const& p)
-                           {
+                               {
-                             return std::make_pair(
+                                 return std::make_pair(
-                               p.first, static_cast<route_tree<Ctx>>(p.second));
+                                     p.first,
-                           })
+                                     static_cast<route_tree<Ctx>>(p.second));
+                               })
    };
    return {route_tree<Ctx>{.here = to_leaves(), .sub = sub}};
  }
@@ -566,7 +572,7 @@ struct dtree : handler_map<route_handler_fn_t<Ctx, MatchArgs...>>
  template <match_arg MatchArg>
  [[nodiscard]] auto
  wildcard_subtree(ctree<Ctx, MatchArgs..., MatchArg> subtree)
-    -> ctree<Ctx, MatchArgs...>
+      -> ctree<Ctx, MatchArgs...>
  {
    return {route_tree<Ctx>{
      .here = to_leaves(),
@@ -592,9 +598,9 @@ class server
 public:
  explicit server(
-    log::logger const& l, locale::selector&& lsel,
+      log::logger const& l, locale::selector&& lsel,
-    middleware_t<base_ctx, PreRouteCtx> global_middleware,
+      middleware_t<base_ctx, PreRouteCtx> global_middleware,
-    route_tree<routed_ctx<PreRouteCtx>> routes)
+      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)}
@@ -604,36 +610,35 @@ public:
  struct match_result
  {
    util::not_null<
-      handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*>
+        handler_map<basic_route_handler_fn_t<routed_ctx<PreRouteCtx>>> const*>
-      route_handlers;
+        route_handlers;
    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::optional<match_result>
+      -> std::optional<match_result>
  {
    auto const* tree = &routes_;
    auto wildcard_matches = std::vector<std::string>{};
    for (auto const& seg : segments)
    {
      tree->sub.visit(
-        util::overloaded{
+          util::overloaded{
-          [&](
+            [&](route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const&
-            route_tree<routed_ctx<PreRouteCtx>>::named_subtrees const& subtrees)
+                    subtrees)
-          {
+            {
-            auto it = subtrees.find(seg);
+              auto it = subtrees.find(seg);
-            tree = it == subtrees.end() ? nullptr : &it->second;
+              tree = it == subtrees.end() ? nullptr : &it->second;
-          },
+            },
-          [&](
+            [&](route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const&
-            route_tree<routed_ctx<PreRouteCtx>>::wildcard_subtree const&
+                    wildcard_subtree)
-              wildcard_subtree)
+            {
-          {
+              wildcard_matches.push_back(seg);
-            wildcard_matches.push_back(seg);
+              tree = &*wildcard_subtree;
-            tree = &*wildcard_subtree;
+            },
-          },
+          });
-        });
      if (!tree)
        return std::nullopt;
    }
@@ -646,7 +651,7 @@ public:
  }
  auto route_request(PreRouteCtx ctx, readable_request r) const
-    -> net::awaitable<presponse>
+      -> net::awaitable<presponse>
  {
    auto req_base = r.p->get().base();
@@ -685,10 +690,10 @@ public:
      if (!req_url.is_path_absolute())
      {
        auto problem = bad_request_tpl.instantiate().set_detail(translate(
-          "Path of normalized (RFC 3986, § 6) "
+            "Path of normalized (RFC 3986, § 6) "
-          "origin-form request-target (RFC "
+            "origin-form request-target (RFC "
-          "9112, § 3.2.1) should be "
+            "9112, § 3.2.1) should be "
-          "absolute"));
+            "absolute"));
        co_return problem_rsp(ctx, problem, keep_alive{false});
      }
@@ -719,7 +724,7 @@ public:
      if (auto mhdl = mres->route_handlers->lookup(*mverb))
      {
        auto new_ctx =
-          routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
+            routed_ctx<PreRouteCtx>{std::move(ctx), mres->allowed_methods()};
        co_return co_await mhdl(std::move(new_ctx), r, mres->wildcard_matches);
      }
      else
@@ -733,7 +738,7 @@ public:
        };
        auto rsp = problem_rsp(ctx, tpl.instantiate(), keep_alive{false});
        rsp.header().set(
-          bhttp::field::allow, mres->allowed_methods().to_string());
+            bhttp::field::allow, mres->allowed_methods().to_string());
        co_return std::move(rsp);
      }
    }
@@ -742,9 +747,9 @@ public:
      // We do not accept any other request-target forms.
      auto problem = bad_request_tpl.instantiate().set_detail(translate(
-        "Invalid request-target, expected "
+          "Invalid request-target, expected "
-        "asterisk-form or origin-form "
+          "asterisk-form or origin-form "
-        "(see RFC 9112, § 3.2)"));
+          "(see RFC 9112, § 3.2)"));
      co_return problem_rsp(ctx, problem, keep_alive{false});
    }
  }
@@ -756,8 +761,9 @@ public:
    auto ctx0 = base_ctx{.locale = locale};
    co_return co_await global_middleware_(
-      std::move(ctx0), header, [&](PreRouteCtx ctx) -> net::awaitable<presponse>
+        std::move(ctx0), header,
-      { co_return co_await route_request(std::move(ctx), std::move(r)); });
+        [&](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>
@@ -769,7 +775,7 @@ public:
      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);
+          co_await bhttp::async_read_header(strm, buf, p0, net::as_tuple);
      if (ec == bhttp::error::end_of_stream)
        break;
      else if (ec)
@@ -777,11 +783,11 @@ public:
      auto http_version = p0.get().version();
      auto&& rsp = co_await handle_request(
-        readable_request{
+          readable_request{
-          .p = util::not_null{&p0},
+            .p = util::not_null{&p0},
-          .strm = util::not_null{&strm},
+            .strm = util::not_null{&strm},
-          .buf = util::not_null{&buf},
+            .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));
@@ -800,27 +806,27 @@ public:
    auto acceptor = tcp::acceptor{executor, endpoint};
    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)
    {
      net::co_spawn(
-        executor,
+          executor,
-        do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
+          do_session(beast::tcp_stream{co_await acceptor.async_accept()}),
-        [this](std::exception_ptr e)
+          [this](std::exception_ptr e)
-        {
-          if (e)
          {
-            try
+            if (e)
-            {
-              std::rethrow_exception(e);
-            }
-            catch (std::exception const& 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());
+              }
            }
-          }
+          });
-        });
    }
  }
@@ -831,21 +837,21 @@ public:
    // TODO: make exception handling as nice as in srv.cpp
    net::co_spawn(
-      ioc, 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)
          {
-            l_.error("Error: {}", e.what());
+            try
+            {
+              std::rethrow_exception(e);
+            }
+            catch (std::exception const& e)
+            {
+              l_.error("Error: {}", e.what());
+            }
          }
-        }
+        });
-      });
  }
 };