* get rid of dht explore for service nodes

* add Time_t using std::chrono for future uses
* make decaying hashset constructor with llarp_time_t explicit
* add decaying hashset implicit constructor using Time_t
* add timeouts for gossiper replay
* allow regossip of our RC

llarp/router/i_gossiper.hpp

@@ -14,7 +14,15 @@ namespace llarp
     GossipRC(const RouterContact &rc) = 0;
 
     virtual void
-    Decay(llarp_time_t now) = 0;
+    Decay(Time_t now) = 0;
+
+    /// return true if we should gossip our RC now
+    virtual bool
+    ShouldGossipOurRC(Time_t now) const = 0;
+
+    /// return true if that rc is owned by us
+    virtual bool
+    IsOurRC(const RouterContact &rc) const = 0;
   };
 }  // namespace llarp
 

llarp/router/rc_gossiper.cpp

@@ -1,24 +1,47 @@
 #include <router/rc_gossiper.hpp>
 #include <messages/dht_immediate.hpp>
 #include <dht/messages/gotrouter.hpp>
+#include <util/time.hpp>
 
 namespace llarp
 {
+  // 30 minutes
+  static constexpr auto RCGossipFilterDecayInterval = 30min;
+  // 60 - 5 minutes
+  static constexpr auto GossipOurRCInterval =
+      (RCGossipFilterDecayInterval * 2) - (5min);
+
   RCGossiper::RCGossiper()
-      : I_RCGossiper(), m_Filter(RouterContact::UpdateInterval)
+      : I_RCGossiper()
+      , m_Filter(
+            std::chrono::duration_cast< Time_t >(RCGossipFilterDecayInterval))
   {
   }
 
   void
-  RCGossiper::Init(ILinkManager* l)
+  RCGossiper::Init(ILinkManager* l, const RouterID& ourID)
   {
+    m_OurRouterID = ourID;
     m_LinkManager = l;
   }
 
+  bool
+  RCGossiper::ShouldGossipOurRC(Time_t now) const
+  {
+    return now >= (m_LastGossipedOurRC + GossipOurRCInterval);
+  }
+
+  bool
+  RCGossiper::IsOurRC(const RouterContact& rc) const
+  {
+    return rc.pubkey == m_OurRouterID;
+  }
+
   void
-  RCGossiper::Decay(llarp_time_t now)
+  RCGossiper::Decay(Time_t now)
   {
-    m_Filter.Decay(now);
+    LogDebug("decay filter at ", now.count());
+    m_Filter.Decay(now.count());
   }
 
   bool
@@ -29,15 +52,31 @@ namespace llarp
       return false;
     if(m_LinkManager == nullptr)
       return false;
-    // check for filter hit
-    if(not m_Filter.Insert(rc.pubkey))
+    const RouterID k(rc.pubkey);
+    // filter check
+    if(m_Filter.Contains(k))
       return false;
-    bool sent = false;
-    // unwarrented GRCM
+    m_Filter.Insert(k);
+
+    const auto now = time_now();
+    // is this our rc?
+    if(IsOurRC(rc))
+    {
+      // should we gossip our rc?
+      if(not ShouldGossipOurRC(now))
+      {
+        // nah drop it
+        return false;
+      }
+      // ya pop it
+      m_LastGossipedOurRC = now;
+    }
+
+    // send unwarrented GRCM as gossip method
     DHTImmediateMessage m;
     m.msgs.emplace_back(
         new dht::GotRouterMessage(dht::Key_t{}, 0, {rc}, false));
-
+    // send it to everyone
     m_LinkManager->ForEachPeer([&](ILinkSession* s) {
       // ensure connected session
       if(not(s && s->IsEstablished()))
@@ -46,23 +85,17 @@ namespace llarp
       const auto other_rc = s->GetRemoteRC();
       if(not other_rc.IsPublicRouter())
         return;
-      // dont send it to the owner
-      if(other_rc.pubkey == rc.pubkey)
-        return;
       // encode message
       ILinkSession::Message_t msg;
-      msg.resize(1024);
+      msg.reserve(1024);
       llarp_buffer_t buf(msg);
       if(not m.BEncode(&buf))
         return;
       msg.resize(buf.cur - buf.base);
       // send message
-      if(s->SendMessageBuffer(std::move(msg), nullptr))
-      {
-        sent = true;
-      }
+      s->SendMessageBuffer(std::move(msg), nullptr);
     });
-    return sent;
+    return true;
   }
 
 }  // namespace llarp

llarp/router/rc_gossiper.hpp

@@ -18,12 +18,20 @@ namespace llarp
     GossipRC(const RouterContact &rc) override;
 
     void
-    Decay(llarp_time_t now) override;
+    Decay(Time_t now) override;
+
+    bool
+    ShouldGossipOurRC(Time_t now) const override;
+
+    bool
+    IsOurRC(const RouterContact &rc) const override;
 
     void
-    Init(ILinkManager *);
+    Init(ILinkManager *, const RouterID &);
 
    private:
+    RouterID m_OurRouterID;
+    Time_t m_LastGossipedOurRC  = 0s;
     ILinkManager *m_LinkManager = nullptr;
     util::DecayingHashSet< RouterID > m_Filter;
   };

llarp/router/rc_lookup_handler.cpp

@@ -288,7 +288,10 @@ namespace llarp
         GetRC(r, nullptr, true);
       return;
     }
-    // TODO: only explore via random subset
+    // service nodes gossip, not explore
+    if(_dht->impl->GetRouter()->IsServiceNode())
+      return;
+
     // explore via every connected peer
     _linkManager->ForEachPeer([&](ILinkSession *s) {
       if(!s->IsEstablished())

llarp/router/router.cpp

@@ -518,7 +518,6 @@ namespace llarp
     _rcLookupHandler.Init(_dht, _nodedb, threadpool(), &_linkManager,
                           &_hiddenServiceContext, strictConnectPubkeys,
                           bootstrapRCList, whitelistRouters, m_isServiceNode);
-    _rcGossiper.Init(&_linkManager);
 
     if(!usingSNSeed)
     {
@@ -687,7 +686,7 @@ namespace llarp
       ReportStats();
     }
 
-    _rcGossiper.Decay(now);
+    _rcGossiper.Decay(time_now());
 
     _rcLookupHandler.PeriodicUpdate(now);
 
@@ -1012,9 +1011,10 @@ namespace llarp
         LogError("Failed to initialize service node");
         return false;
       }
-      RouterID us = pubkey();
+      const RouterID us = pubkey();
       LogInfo("initalized service node: ", us);
-
+      // init gossiper here
+      _rcGossiper.Init(&_linkManager, us);
       // relays do not use profiling
       routerProfiling().Disable();
     }

llarp/util/decaying_hashset.hpp

@@ -11,11 +11,11 @@ namespace llarp
     template < typename Val_t, typename Hash_t = typename Val_t::Hash >
     struct DecayingHashSet
     {
-      DecayingHashSet(std::chrono::milliseconds cacheInterval)
+      DecayingHashSet(Time_t cacheInterval)
           : DecayingHashSet(cacheInterval.count())
       {
       }
-      DecayingHashSet(llarp_time_t cacheInterval = 5000)
+      explicit DecayingHashSet(llarp_time_t cacheInterval = 5000)
           : m_CacheInterval(cacheInterval)
       {
       }

llarp/util/time.cpp

@@ -29,6 +29,12 @@ namespace llarp
         - started_at_steady;
   }
 
+  Time_t
+  time_now()
+  {
+    return Time_t(time_now_ms());
+  }
+
   llarp_time_t
   time_now_ms()
   {

llarp/util/time.hpp

@@ -4,11 +4,21 @@
 #include <util/types.hpp>
 #include <chrono>
 
+#include <chrono>
+using namespace std::chrono_literals;
+
 namespace llarp
 {
   /// get time right now as milliseconds, this is monotonic
   llarp_time_t
   time_now_ms();
+
+  using Time_t = std::chrono::milliseconds;
+
+  /// get time right now as a Time_t, monotonic
+  Time_t
+  time_now();
+
 }  // namespace llarp
 
 #endif