Refactor NotifyRouterEvent() to forward args, event code cleanup

This template-ifies Router::NotifyRouterEvent() up so that it accepts
the arguments to instantiate the specified event type, forwarding them
to std::make_unique. This would allow (in the future) the function to
no-op the call and avoid memory allocation. It also slightly reduces
the amount of code required to fire an event.

This commit also simplifies some of the RouterEvent code to reduce
redundancy.

llarp/dht/explorenetworkjob.cpp

@@ -18,9 +18,9 @@ namespace llarp
 
       auto msg = new FindRouterMessage(peer.txid);
       auto router = parent->GetRouter();
-      auto ev = std::make_unique< tooling::FindRouterSentEvent >(router->pubkey());
+      router->NotifyRouterEvent< tooling::FindRouterSentEvent >(
-      ev->targetKey = msg->targetKey;
+          router->pubkey(),
-      router->NotifyRouterEvent(std::move(ev));
+          msg);
 
       parent->DHTSendTo(peer.node.as_array(), msg);
     }

llarp/dht/messages/findrouter.cpp

@@ -156,13 +156,9 @@ namespace llarp
       auto &dht = *ctx->impl;
 
       auto router = dht.GetRouter();
-      auto ev = std::make_unique< tooling::FindRouterReceivedEvent >(router->pubkey());
+      router->NotifyRouterEvent< tooling::FindRouterReceivedEvent >(
-      ev->targetKey = targetKey;
+          router->pubkey(),
-      ev->iterative = iterative;
+          this);
-      ev->exploritory = exploritory;
-      ev->txid = txid;
-      ev->version = version;
-      router->NotifyRouterEvent(std::move(ev));
 
       if(!dht.AllowTransit())
       {

llarp/dht/messages/gotintro.cpp

@@ -27,11 +27,10 @@ namespace llarp
       auto &dht    = *ctx->impl;
       auto *router = dht.GetRouter();
 
-      auto ev = std::make_unique< tooling::GotIntroReceivedEvent >(
+      router->NotifyRouterEvent< tooling::GotIntroReceivedEvent >(
           router->pubkey(), Key_t(From.data()),
           (found.size() > 0 ? found[0] : llarp::service::EncryptedIntroSet{}),
           txid);
-      router->NotifyRouterEvent(std::move(ev));
 
       for(const auto &introset : found)
       {

llarp/dht/messages/gotrouter.cpp

@@ -129,10 +129,8 @@ namespace llarp
         {
           LogWarn("Received Gossiped RC, generating RCGossipReceivedEvent");
           auto *router = dht.GetRouter();
-          tooling::RouterEventPtr event =
+          router->NotifyRouterEvent< tooling::RCGossipReceivedEvent >(
-              std::make_unique< tooling::RCGossipReceivedEvent >(
                   router->pubkey(), rc);
-          router->NotifyRouterEvent(std::move(event));
           router->GossipRCIfNeeded(rc);
         }
       }

llarp/dht/messages/pubintro.cpp

@@ -63,10 +63,9 @@ namespace llarp
       const auto keyStr = addr.ToHex();
 
       auto router = ctx->impl->GetRouter();
-      auto ev     = std::make_unique< tooling::PubIntroReceivedEvent >(
+      router->NotifyRouterEvent< tooling::PubIntroReceivedEvent >(
           router->pubkey(), Key_t(relayed ? router->pubkey() : From.data()),
           addr, txID, relayOrder);
-      router->NotifyRouterEvent(std::move(ev));
 
       auto &dht = *ctx->impl;
       if(!introset.Verify(now))

llarp/messages/relay_commit.cpp

@@ -419,9 +419,8 @@ namespace llarp
       // TODO: check if we really want to accept it
       self->hop->started = now;
 
-      auto event = std::make_unique< tooling::PathRequestReceivedEvent >(
+      self->context->Router()->NotifyRouterEvent< tooling::PathRequestReceivedEvent >(
           self->context->Router()->pubkey(), self->hop);
-      self->context->Router()->NotifyRouterEvent(std::move(event));
 
       size_t sz = self->frames[0].size();
       // shift

llarp/messages/relay_status.cpp

@@ -44,9 +44,8 @@ namespace llarp
     void
     handle()
     {
-      auto ev = std::make_unique< tooling::PathStatusReceivedEvent >(
+      router->NotifyRouterEvent< tooling::PathStatusReceivedEvent >(
           router->pubkey(), pathid, status);
-      router->NotifyRouterEvent(std::move(ev));
 
       path->HandleLRSM(status, frames, router);
     }

llarp/path/pathbuilder.cpp

@@ -132,10 +132,9 @@ namespace llarp
   {
     if(!ctx->pathset->IsStopped())
     {
-      tooling::RouterEventPtr event =
+      ctx->router->NotifyRouterEvent< tooling::PathAttemptEvent >(
-          std::make_unique< tooling::PathAttemptEvent >(ctx->router->pubkey(),
+          ctx->router->pubkey(),
-                                                        ctx->path);
+          ctx->path);
-      ctx->router->NotifyRouterEvent(std::move(event));
 
       const RouterID remote   = ctx->path->Upstream();
       const ILinkMessage* msg = &ctx->LRCM;

llarp/router/abstractrouter.hpp

@@ -12,16 +12,15 @@
 #include <router_contact.hpp>
 #include <tooling/router_event.hpp>
 
+#ifdef LOKINET_HIVE
+#include "tooling/router_hive.hpp"
+#endif
+
 struct llarp_buffer_t;
 struct llarp_dht_context;
 struct llarp_nodedb;
 struct llarp_threadpool;
 
-namespace tooling
-{
-  struct RouterHive;
-}  // namespace tooling
-
 namespace llarp
 {
   class Logic;
@@ -271,8 +270,18 @@ namespace llarp
     virtual void
     GossipRCIfNeeded(const RouterContact rc) = 0;
 
-    virtual void
+    template<class EventType, class... Params>
-    NotifyRouterEvent(tooling::RouterEventPtr event) const = 0;
+    void
+    NotifyRouterEvent(Params&&... args) const
+    {
+      // TODO: no-op when appropriate
+      auto event = std::make_unique< EventType >(args...);
+#ifdef LOKINET_HIVE
+      hive->NotifyEvent(std::move(event));
+#elif LOKINET_DEBUG
+      LogDebug(event->ToString());
+#endif
+    }
   };
 }  // namespace llarp
 

llarp/router/rc_gossiper.cpp

@@ -99,10 +99,9 @@ namespace llarp
         return;
       msg.resize(buf.cur - buf.base);
 
-      tooling::RouterEventPtr event =
+      m_router->NotifyRouterEvent< tooling::RCGossipSentEvent >(
-          std::make_unique< tooling::RCGossipSentEvent >(m_router->pubkey(),
+          m_router->pubkey(),
-                                                         rc);
+          rc);
-      m_router->NotifyRouterEvent(std::move(event));
 
       // send message
       peerSession->SendMessageBuffer(std::move(msg), nullptr);

llarp/router/router.cpp

@@ -24,9 +24,6 @@
 #include <ev/ev.hpp>
 
 #include "tooling/router_event.hpp"
-#ifdef LOKINET_HIVE
-#include "tooling/router_hive.hpp"
-#endif
 
 #include <fstream>
 #include <cstdlib>
@@ -135,16 +132,6 @@ namespace llarp
     _rcGossiper.GossipRC(rc);
   }
 
-  void
-  Router::NotifyRouterEvent(tooling::RouterEventPtr event) const
-  {
-#ifdef LOKINET_HIVE
-    hive->NotifyEvent(std::move(event));
-#elif LOKINET_DEBUG
-    LogDebug(event->ToString());
-#endif
-  }
-
   bool
   Router::GetRandomGoodRouter(RouterID &router)
   {

llarp/router/router.hpp

@@ -43,11 +43,6 @@
 #include <unordered_map>
 #include <vector>
 
-namespace tooling
-{
-  struct RouterHive;
-}  // namespace tooling
-
 namespace llarp
 {
   struct Config;
@@ -314,9 +309,6 @@ namespace llarp
     void
     GossipRCIfNeeded(const RouterContact rc) override;
 
-    void
-    NotifyRouterEvent(tooling::RouterEventPtr event) const override;
-
     Router(std::shared_ptr< llarp::thread::ThreadPool > worker,
            llarp_ev_loop_ptr __netloop, std::shared_ptr< Logic > logic);
 

llarp/service/endpoint.cpp

@@ -1,4 +1,5 @@
 #include <chrono>
+#include <memory>
 #include <service/endpoint.hpp>
 
 #include <dht/context.hpp>
@@ -479,11 +480,10 @@ namespace llarp
       {
         for(size_t i = 0; i < llarp::dht::IntroSetRequestsPerRelay; ++i)
         {
-          auto ev = std::make_unique< tooling::PubIntroSentEvent >(
+          r->NotifyRouterEvent< tooling::PubIntroSentEvent >(
               r->pubkey(),
               llarp::dht::Key_t{introset.derivedSigningKey.as_array()},
               RouterID(path->hops[path->hops.size() - 1].rc.pubkey), published);
-          r->NotifyRouterEvent(std::move(ev));
           if(PublishIntroSetVia(introset, r, path, published))
             published++;
         }
@@ -771,6 +771,8 @@ namespace llarp
     bool
     Endpoint::LookupRouterAnon(RouterID router, RouterLookupHandler handler)
     {
+      using llarp::dht::FindRouterMessage;
+
       auto& routers = m_state->m_PendingRouters;
       if(routers.find(router) == routers.end())
       {
@@ -778,15 +780,19 @@ namespace llarp
         routing::DHTMessage msg;
         auto txid = GenTXID();
         msg.M.emplace_back(
-            std::make_unique< dht::FindRouterMessage >(txid, router));
+            std::make_unique< FindRouterMessage >(txid, router));
 
         if(path && path->SendRoutingMessage(msg, Router()))
         {
 
-          auto ev = std::make_unique< tooling::FindRouterSentEvent >(m_router->pubkey());
+          RouterLookupJob job(this, handler);
-          ev->txid = txid;
+
-          ev->targetKey = router;
+          assert(msg.M.size() == 1);
-          m_router->NotifyRouterEvent(std::move(ev));
+          auto dhtMsg = dynamic_cast< FindRouterMessage* >(msg.M[0].get());
+
+          m_router->NotifyRouterEvent< tooling::FindRouterSentEvent >(
+              m_router->pubkey(),
+              dhtMsg);
 
           routers.emplace(router, RouterLookupJob(this, handler));
           return true;

llarp/tooling/dht_event.hpp

@@ -3,6 +3,7 @@
 #include "router_event.hpp"
 #include "dht/key.hpp"
 #include "service/intro_set.hpp"
+#include "dht/messages/findrouter.hpp"
 
 namespace tooling
 {
@@ -55,17 +56,25 @@ namespace tooling
     ToString() const override;
   };
 
-  struct FindRouterSentEvent : public RouterEvent
+  struct FindRouterEvent : public RouterEvent
   {
     llarp::dht::Key_t from;
     llarp::RouterID targetKey;
-    bool iterative = false;
+    bool iterative;
-    bool exploritory = false;
+    bool exploritory;
-    uint64_t txid = 0;
+    uint64_t txid;
-    uint64_t version = 0;
+    uint64_t version;
-
+
-    FindRouterSentEvent(const llarp::RouterID& ourRouter)
+    FindRouterEvent(
-      : RouterEvent("DHT: FindRouterSentEvent", ourRouter, true)
+      const llarp::RouterID& ourRouter,
+      const llarp::dht::FindRouterMessage& msg)
+      : RouterEvent("DHT: FindRouterEvent", ourRouter, true)
+      , from(msg.From)
+      , targetKey(msg.targetKey)
+      , iterative(msg.iterative)
+      , exploritory(msg.exploritory)
+      , txid(msg.txid)
+      , version(msg.version)
     {
     }
 
@@ -82,31 +91,14 @@ namespace tooling
     }
   };
 
-  struct FindRouterReceivedEvent : public RouterEvent
+  struct FindRouterReceivedEvent : public FindRouterEvent
   {
-    llarp::dht::Key_t from;
+    using FindRouterEvent::FindRouterEvent;
-    llarp::RouterID targetKey;
+  };
-    bool iterative = false;
-    bool exploritory = false;
-    uint64_t txid = 0;
-    uint64_t version = 0;
-
-    FindRouterReceivedEvent(const llarp::RouterID& ourRouter)
-      : RouterEvent("DHT: FindRouterReceivedEvent", ourRouter, false)
-    {
-    }
 
-    std::string
+  struct FindRouterSentEvent : public FindRouterEvent
-    ToString() const override
+  {
-    {
+    using FindRouterEvent::FindRouterEvent;
-      return RouterEvent::ToString()
-        +" from "+ from.ShortHex()
-        +", targetKey: "+ targetKey.ToString()
-        +", iterative: "+ std::to_string(iterative)
-        +", exploritory "+ std::to_string(exploritory)
-        +", txid "+ std::to_string(txid)
-        +", version "+ std::to_string(version);
-    }
   };
 
 }  // namespace tooling

pybind/llarp/tooling/router_event.cpp

@@ -68,19 +68,20 @@ namespace tooling
         .def_readonly("rc", &RCGossipSentEvent::rc)
         .def("LongString", &RCGossipSentEvent::LongString);
 
-    py::class_< FindRouterSentEvent, RouterEvent >(mod, "FindRouterSentEvent")
+    py::class_< FindRouterEvent, RouterEvent >(mod, "FindRouterEvent")
-        .def_readonly("from", &FindRouterSentEvent::from)
+        .def_readonly("from", &FindRouterEvent::from)
-        .def_readonly("iterative", &FindRouterSentEvent::iterative)
+        .def_readonly("iterative", &FindRouterEvent::iterative)
-        .def_readonly("exploritory", &FindRouterSentEvent::exploritory)
+        .def_readonly("exploritory", &FindRouterEvent::exploritory)
-        .def_readonly("txid", &FindRouterSentEvent::txid)
+        .def_readonly("txid", &FindRouterEvent::txid)
-        .def_readonly("version", &FindRouterSentEvent::version);
+        .def_readonly("version", &FindRouterEvent::version);
 
-    py::class_< FindRouterReceivedEvent, RouterEvent >(mod, "FindRouterReceivedEvent")
+    py::class_< FindRouterReceivedEvent,
-        .def_readonly("from", &FindRouterReceivedEvent::from)
+                FindRouterEvent,
-        .def_readonly("iterative", &FindRouterReceivedEvent::iterative)
+                RouterEvent >(mod, "FindRouterReceivedEvent");
-        .def_readonly("exploritory", &FindRouterReceivedEvent::exploritory)
+
-        .def_readonly("txid", &FindRouterReceivedEvent::txid)
+    py::class_< FindRouterSentEvent,
-        .def_readonly("version", &FindRouterReceivedEvent::version);
+                FindRouterEvent,
+                RouterEvent >(mod, "FindRouterSentEvent");
   }
 
 }  // namespace tooling