Re-enable expected logging, start server proto

include/parselink/BUILD

@@ -11,7 +11,7 @@ cc_library(
     name = "logging",
     hdrs = glob(["logging.h", "logging/**/*.h"]),
     includes = ["."],
-    deps = ["@fmt", "@magic_enum", "//include:path"],
+    deps = ["@fmt", "@magic_enum", "@expected", "//include:path"],
     visibility = ["//visibility:public"],
 )
 

include/parselink/logging/formatters.h

@@ -23,7 +23,7 @@
 #include "traits.h"
 #include "theme.h"
 
-/* #include <parselink/util/expected.h> */
+#include <tl/expected.hpp>
 
 #include <magic_enum.hpp>
 
@@ -105,25 +105,25 @@ struct fmt::formatter<T> : fmt::formatter<void const*> {
     }
 };
 
-#if 0
 // TODO(ksassenrath): Re-enable when expected has been integrated
 template <typename T, typename Err>
-struct fmt::formatter<parselink::expected<T, Err>> {
+struct fmt::formatter<tl::expected<T, Err>> {
     template <typename ParseContext>
     constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
         return ctx.begin();
     }
 
     template<typename FormatContext>
-    auto format(parselink::expected<T, Err> const& v, FormatContext& ctx) const {
-        if (v.has_value()) {
-            return fmt::format_to(ctx.out(), "{}", parselink::logging::format_arg<T>{v.value()});
+    auto format(tl::expected<T, Err> const& v, FormatContext& ctx) const {
+        if (v) {
+            return fmt::format_to(ctx.out(), "{}",
+                    parselink::logging::format_arg<T>{v.value()});
         } else {
-            return fmt::format_to(ctx.out(), "{}", parselink::logging::format_arg<Err>{v.error()});
+            return fmt::format_to(ctx.out(), "{}",
+                    parselink::logging::format_arg<Err>{v.error()});
         }
     }
 };
-#endif
 
 // Support format_arg wrappers, which will be used to colorize output.
 template <typename T>

include/parselink/logging/theme.h

@@ -32,7 +32,7 @@
 #include "level.h"
 #include "traits.h"
 
-/* #include <parselink/util/expected.h> */
+#include <tl/expected.hpp>
 
 #include <fmt/color.h>
 
@@ -154,19 +154,12 @@ constexpr auto get_theme(T const& value) {
     return out;
 }
 
-#if 0
-// TODO(ksassenrath): Enable when expected is supported
 template <typename T, typename Err>
-struct theme<expected<T, Err>> {
+struct theme<tl::expected<T, Err>> {
     static constexpr auto style(auto const& e) noexcept {
-        if (e.has_value()) {
-            return get_theme(e.value());
-        } else {
-            return get_theme(e.error());
-        }
+        return e ? get_theme(e.value()) : get_theme(e.error());
     }
 };
-#endif
 
 template <typename T>
 struct themed_arg : format_arg<T> {};

include/parselink/msgpack/token/reader.h

@@ -143,6 +143,10 @@ public:
         return std::next(data_.begin(), curr_);
     }
 
+    constexpr auto end() const noexcept {
+        return data_.end();
+    }
+
     constexpr auto remaining(auto itr) noexcept {
         using dist_type = decltype(std::distance(itr, data_.end()));
         return std::max(dist_type(0), std::distance(itr, data_.end()));

source/server.cpp

@@ -21,7 +21,7 @@
 #include "parselink/logging.h"
 #include "parselink/server.h"
 
-#include "parselink/proto/message.h"
+#include "parselink/msgpack/token/reader.h"
 
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/signal_set.hpp>
@@ -93,6 +93,10 @@ namespace {
     constexpr auto no_ex_defer = net::as_tuple(deferred);
 }
 
+struct msgbuf {
+    std::vector<std::byte> payload;
+};
+
 class user_session : public std::enable_shared_from_this<user_session> {
 public:
     user_session(net::ip::tcp::socket sock) : socket_(std::move(sock)) {}
@@ -103,20 +107,44 @@ public:
     void start() {
         logger.debug("New connection from {}", socket_.remote_endpoint());
         co_spawn(socket_.get_executor(), [self = shared_from_this()]{
-            return self->reader();
+            return self->await_auth();
         }, detached);
     }
 
-    awaitable<void> reader() {
-        std::array<std::byte, 4096> buffer;
+    awaitable<void> await_auth() {
+        std::array<std::byte, 16> buffer;
         auto [ec, n] = co_await socket_.async_read_some(
                 net::buffer(buffer), no_ex_coro);
         if (ec) {
             logger.error("Reading from user socket failed: {}", ec);
             co_return;
         }
-        logger.info("Read {} bytes from client: {}", n,
+        logger.debug("Read {} bytes from client: {}", n,
                 std::string_view(reinterpret_cast<char*>(buffer.data()), n));
+
+        // TODO(ksassenrath): Clean this part up. This could be handled in its
+        // own read_message_header() method.
+        auto reader = msgpack::token_reader(std::span(buffer.data(), n));
+        auto magic = reader.read_one().map(
+                [](auto t){ return t == std::string_view{"prs"}; });
+        if (magic && *magic) {
+            logger.debug("Got magic from client");
+        } else {
+            logger.debug("Got error from client: {}", magic);
+            co_return;
+        }
+        auto sz = reader.read_one().and_then(
+                [](auto t){ return t.template get<std::size_t>(); });
+        if (sz && *sz) {
+            logger.debug("Got packet size from client: {}", *sz);
+        } else {
+            logger.debug("Got error from client: {}", sz);
+            co_return;
+        }
+        // Copy the rest of the message to the buffer for parsing.
+        std::vector<std::byte> msg(*sz);
+        std::copy(reader.current(), reader.end(), msg.begin());
+        //auto [ec, n] = co_await socket_.async_read_some(net::buffer());
     }
 
     enum class state {
@@ -153,7 +181,7 @@ monolithic_server::monolithic_server(std::string_view address,
         , user_port_{user_port}
         , websocket_port_{websocket_port} {
     logger.debug("Creating monolithic_server(address = {}, user_port = {}, "
-            "websocket_port = {}, sizeof(message) = {})", address, user_port_, websocket_port_, sizeof(proto::message));
+            "websocket_port = {})", address, user_port_, websocket_port_);
 }
 
 awaitable<void> monolithic_server::user_listen() {