snp quic

DEPRECATED.md

@@ -0,0 +1,69 @@
+These features were rejected, don't suggest them again.
+
+```c++
+#define FORWARD(x) std::forward<decltype(x)>(x)
+auto foo(auto &&x) {
+  bar(FORWARD(x));
+}
+```
+
+```c++
+#define MAKE_SHARED_(x_, ...) std::make_shared<decltype(x_)::element_type>(...)
+struct Foo {
+  Foo() : MAKE_SHARED_(bar_, ...) {}
+  std::shared_ptr<Bar> bar_;
+};
+```
+
+```c++
+#define MAKE_SHARED_T(x) std::forward<decltype(x)>(x)
+using Foo = std::shared_ptr<...>;
+MAKE_SHARED_T(Foo, ...);
+```
+
+```c++
+#define MOVE(x) x{std::move(x)}
+auto lambda = [MOVE(x)]() {};
+```
+
+```c++
+#define MOVE_(x) x##_{std::move(x)}
+struct Foo {
+  Foo(Bar bar) : MOVE_(bar) {}
+  Bar bar_;
+};
+```
+
+```c++
+#define WEAK_SELF weak_self{weak_from_this()}
+auto lambda = [WEAK_SELF]() {};
+```
+
+```c++
+#define WEAK_LOCK(x) auto x = weak_##x.lock(); if (not x) return
+auto lambda = [weak_self]() {
+  WEAK_LOCK(self);
+  ...
+};
+```
+
+```c++
+class MakeSharedPrivate {
+ private:
+  MakeSharedPrivate() = default;
+ public:
+  static auto make() {
+    return MakeSharedPrivate{};
+  }
+};
+class Foo : public std::enable_shared_from_this<> {
+ public:
+  Foo(MakeSharedPrivate, ...);
+  static std::shared_ptr<Foo> factory(...) {
+    // `Foo` can call `MakeSharedPrivate` constructor
+    return std::make_shared<Foo>(MakeSharedPrivate::make(), ...);
+  }
+};
+// error, MakeSharedPrivate has private constructor
+injector.create<std::shared_ptr<Foo>>();
+```

example/snp_chat/main.cpp

@@ -10,6 +10,7 @@
 #include <qtils/unhex.hpp>
 
 #include "coro/spawn.hpp"
+#include "crypto/ed25519_literal.hpp"
 #include "log/simple.hpp"
 #include "snp/connections/address.hpp"
 #include "snp/connections/connection.hpp"
@@ -36,11 +37,6 @@ using jam::snp::StreamPtr;
 
 auto logsys = jam::log::simpleLoggingSystem();
 
-inline auto operator""_ed25519(const char *c, size_t s) {
-  auto seed = qtils::unhex<jam::crypto::ed25519::Seed>({c, s}).value();
-  return jam::crypto::ed25519::from_seed(seed);
-}
-
 std::vector<KeyPair> keys{
     "f8dfdb0f1103d9fb2905204ac32529d5f148761c4321b2865b0a40e15be75f57"_ed25519,
     "96c891b8726cb18c781aefc082dbafcb827e16c8f18f22d461e83eabd618e780"_ed25519,

src/TODO_qtils/map_entry.hpp

@@ -71,7 +71,7 @@ namespace qtils {
       return std::move(node.mapped());
     }
 
-    void eraseIfExists() {
+    void erase() {
       if (has()) {
         auto it = std::get<I>(it_or_key);
         it_or_key = it->first;

src/crypto/ed25519_literal.hpp

@@ -0,0 +1,16 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <qtils/unhex.hpp>
+
+#include "crypto/ed25519.hpp"
+
+inline auto operator""_ed25519(const char *c, size_t s) {
+  auto seed = qtils::unhex<jam::crypto::ed25519::Seed>({c, s}).value();
+  return jam::crypto::ed25519::from_seed(seed);
+}

src/snp/connections/connections.cpp

@@ -44,15 +44,13 @@ namespace jam::snp {
     BOOST_OUTCOME_CO_TRY(self->client_,
                          lsquic::Engine::make(self->io_context_ptr_,
                                               self->logsys_,
-                                              self->connection_id_counter_,
                                               certificate,
                                               std::nullopt,
                                               self));
     if (self->config_.listen_port.has_value()) {
       BOOST_OUTCOME_CO_TRY(self->server_,
                            lsquic::Engine::make(self->io_context_ptr_,
                                                 self->logsys_,
-                                                self->connection_id_counter_,
                                                 certificate,
                                                 self->config_.listen_port,
                                                 self));
@@ -91,7 +89,7 @@ namespace jam::snp {
             controller->onOpen(address.key);
           }
         } else {
-          state.eraseIfExists();
+          state.erase();
         }
         CORO_WEAK_AWAIT_V(
             self, connecting->set(connecting, std::move(connection_result)));
@@ -128,7 +126,7 @@ namespace jam::snp {
         or std::get<Connected>(*state)->info() != connection_info) {
       todoPreferConnection();
     }
-    state.eraseIfExists();
+    state.erase();
     if (auto controller = controller_.lock()) {
       controller->onClose(connection_info.key);
     }

src/snp/connections/connections.hpp

@@ -15,7 +15,6 @@
 #include "coro/init.hpp"
 #include "coro/io_context_ptr.hpp"
 #include "snp/connections/config.hpp"
-#include "snp/connections/connection_id_counter.hpp"
 #include "snp/connections/connection_ptr.hpp"
 #include "snp/connections/key.hpp"
 #include "snp/connections/lsquic/controller.hpp"
@@ -94,6 +93,5 @@ namespace jam::snp {
                        qtils::BytesStdHash>
         connections_;
     std::unordered_map<ProtocolId, ServeProtocol> protocols_;
-    ConnectionIdCounter connection_id_counter_;
   };
 }  // namespace jam::snp

src/snp/connections/lsquic/engine.cpp

@@ -53,7 +53,6 @@ namespace jam::snp::lsquic {
   outcome::result<std::shared_ptr<Engine>> Engine::make(
       IoContextPtr io_context_ptr,
       std::shared_ptr<log::LoggingSystem> logsys,
-      ConnectionIdCounter connection_id_counter,
       TlsCertificate certificate,
       std::optional<uint16_t> listen_port,
       std::weak_ptr<EngineController> controller) {
@@ -102,14 +101,12 @@ namespace jam::snp::lsquic {
     if (ec) {
       return ec;
     }
-    auto self =
-        qtils::MakeSharedPrivate::make<Engine>(io_context_ptr,
-                                               std::move(logsys),
-                                               std::move(connection_id_counter),
-                                               std::move(certificate),
-                                               std::move(socket),
-                                               socket_local_endpoint,
-                                               std::move(controller));
+    auto self = create_shared(io_context_ptr,
+                              std::move(logsys),
+                              std::move(certificate),
+                              std::move(socket),
+                              socket_local_endpoint,
+                              std::move(controller));
 
     api.ea_stream_if = &stream_if;
     api.ea_stream_if_ctx = self.get();
@@ -131,16 +128,13 @@ namespace jam::snp::lsquic {
     return self;
   }
 
-  Engine::Engine(qtils::MakeSharedPrivate,
-                 IoContextPtr io_context_ptr,
+  Engine::Engine(IoContextPtr io_context_ptr,
                  std::shared_ptr<log::LoggingSystem> logsys,
-                 ConnectionIdCounter connection_id_counter,
                  TlsCertificate &&certificate,
                  Socket &&socket,
                  Socket::endpoint_type socket_local_endpoint,
                  std::weak_ptr<EngineController> controller)
       : io_context_ptr_{std::move(io_context_ptr)},
-        connection_id_counter_{std::move(connection_id_counter)},
         certificate_{std::move(certificate)},
         log_{logsys->getLogger("Engine", "snp")},
         socket_{std::move(socket)},
@@ -476,8 +470,9 @@ namespace jam::snp::lsquic {
       if (connecting.has_value() and key != connecting->address.key) {
         return ConnectionsError::ENGINE_CONNECT_KEY_MISMATCH;
       }
+      static std::atomic<ConnectionId> connection_id_counter = 0;
       conn_ctx->info = ConnectionInfo{
-          .id = self->connection_id_counter_.make(),
+          .id = connection_id_counter.fetch_add(1),
           .key = key,
       };
       auto connection = std::make_shared<Connection>(

src/snp/connections/lsquic/engine.hpp

@@ -9,15 +9,14 @@
 #include <deque>
 #include <lsquic.h>
 
-#include <TODO_qtils/make_shared_private.hpp>
 #include <boost/asio/ip/udp.hpp>
 #include <boost/asio/steady_timer.hpp>
+#include <qtils/create_smart_pointer_macros.hpp>
 
 #include "coro/coro.hpp"
 #include "coro/handler.hpp"
 #include "coro/io_context_ptr.hpp"
 #include "snp/connections/address.hpp"
-#include "snp/connections/connection_id_counter.hpp"
 #include "snp/connections/connection_info.hpp"
 #include "snp/connections/connection_ptr.hpp"
 #include "snp/connections/protocol_id.hpp"
@@ -91,24 +90,23 @@ namespace jam::snp::lsquic {
     }
   };
 
-  class Engine : public std::enable_shared_from_this<Engine> {
+  class Engine {
     friend Connection;
     friend Stream;
 
+    CREATE_SHARED_METHOD(Engine);
+
    public:
     using SelfSPtr = std::shared_ptr<Engine>;
 
     static outcome::result<std::shared_ptr<Engine>> make(
         IoContextPtr io_context_ptr,
         std::shared_ptr<log::LoggingSystem> logsys,
-        ConnectionIdCounter connection_id_counter,
         TlsCertificate certificate,
         std::optional<uint16_t> listen_port,
         std::weak_ptr<EngineController> controller);
-    Engine(qtils::MakeSharedPrivate,
-           IoContextPtr io_context_ptr,
+    Engine(IoContextPtr io_context_ptr,
            std::shared_ptr<log::LoggingSystem> logsys,
-           ConnectionIdCounter connection_id_counter,
            TlsCertificate &&certificate,
            Socket &&socket,
            Socket::endpoint_type socket_local_endpoint,
@@ -192,7 +190,6 @@ namespace jam::snp::lsquic {
 
     IoContextPtr io_context_ptr_;
     std::shared_ptr<soralog::Logger> log_;
-    ConnectionIdCounter connection_id_counter_;
     TlsCertificate certificate_;
     Socket socket_;
     Socket::endpoint_type socket_local_endpoint_;

tests/CMakeLists.txt

@@ -4,4 +4,15 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-message(STATUS "There are no tests yet")
+
+function(jam_add_test name)
+    add_executable(${name}
+        ${ARGN}
+    )
+    target_link_libraries(${name}
+        ${GTEST_DEPS}
+    )
+    add_test(${name} ${name})
+endfunction()
+
+add_subdirectory(snp)

tests/snp/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# Copyright Quadrivium LLC
+# All Rights Reserved
+# SPDX-License-Identifier: Apache-2.0
+#
+
+jam_add_test(snp_test snp_test.cpp)
+target_link_libraries(snp_test
+    logger
+    snp
+)