Weakly connected status announcement. (#135)

* Forward others' messages only to the weakly connected nodes instead of broadcasting to all the connected peers.
* Announcing connected status depends on a threshold to other connected peers.
* Forwarding messages of weakly connected peers to other peers.

src/msg/fbuf/p2pmsg_content.fbs

@@ -24,7 +24,18 @@ table UserInputGroup {
     messages:[UserInput];
 }
 
-union Message { Peer_Challenge_Response_Message, Peer_Challenge_Message, NonUnl_Proposal_Message, Proposal_Message, Npl_Message, State_Request_Message, State_Response_Message, History_Request_Message, History_Response_Message } //message content type
+union Message {
+    Peer_Challenge_Response_Message,
+    Peer_Challenge_Message,
+    NonUnl_Proposal_Message,
+    Proposal_Message,
+    Npl_Message,
+    State_Request_Message,
+    State_Response_Message,
+    History_Request_Message,
+    History_Response_Message,
+    Connected_Status_Announcement_Message
+} //message content type
 
 table Content {
     message:Message;
@@ -110,4 +121,8 @@ table State_FS_Hash_Entry{
     hash: [ubyte];
 }
 
+table Connected_Status_Announcement_Message{
+    is_weakly_connected: bool;
+}
+
 root_type Content; //root type for message content

src/msg/fbuf/p2pmsg_content_generated.h

@@ -66,6 +66,9 @@ struct Block_ResponseBuilder;
 struct State_FS_Hash_Entry;
 struct State_FS_Hash_EntryBuilder;
 
+struct Connected_Status_Announcement_Message;
+struct Connected_Status_Announcement_MessageBuilder;
+
 enum Message {
   Message_NONE = 0,
   Message_Peer_Challenge_Response_Message = 1,
@@ -77,11 +80,12 @@ enum Message {
   Message_State_Response_Message = 7,
   Message_History_Request_Message = 8,
   Message_History_Response_Message = 9,
+  Message_Connected_Status_Announcement_Message = 10,
   Message_MIN = Message_NONE,
-  Message_MAX = Message_History_Response_Message
+  Message_MAX = Message_Connected_Status_Announcement_Message
 };
 
-inline const Message (&EnumValuesMessage())[10] {
+inline const Message (&EnumValuesMessage())[11] {
   static const Message values[] = {
     Message_NONE,
     Message_Peer_Challenge_Response_Message,
@@ -92,13 +96,14 @@ inline const Message (&EnumValuesMessage())[10] {
     Message_State_Request_Message,
     Message_State_Response_Message,
     Message_History_Request_Message,
-    Message_History_Response_Message
+    Message_History_Response_Message,
+    Message_Connected_Status_Announcement_Message
   };
   return values;
 }
 
 inline const char * const *EnumNamesMessage() {
-  static const char * const names[11] = {
+  static const char * const names[12] = {
     "NONE",
     "Peer_Challenge_Response_Message",
     "Peer_Challenge_Message",
@@ -109,13 +114,14 @@ inline const char * const *EnumNamesMessage() {
     "State_Response_Message",
     "History_Request_Message",
     "History_Response_Message",
+    "Connected_Status_Announcement_Message",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameMessage(Message e) {
-  if (flatbuffers::IsOutRange(e, Message_NONE, Message_History_Response_Message)) return "";
+  if (flatbuffers::IsOutRange(e, Message_NONE, Message_Connected_Status_Announcement_Message)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesMessage()[index];
 }
@@ -160,6 +166,10 @@ template<> struct MessageTraits<msg::fbuf::p2pmsg::History_Response_Message> {
   static const Message enum_value = Message_History_Response_Message;
 };
 
+template<> struct MessageTraits<msg::fbuf::p2pmsg::Connected_Status_Announcement_Message> {
+  static const Message enum_value = Message_Connected_Status_Announcement_Message;
+};
+
 bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type);
 bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
@@ -574,6 +584,9 @@ struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const msg::fbuf::p2pmsg::History_Response_Message *message_as_History_Response_Message() const {
     return message_type() == msg::fbuf::p2pmsg::Message_History_Response_Message ? static_cast<const msg::fbuf::p2pmsg::History_Response_Message *>(message()) : nullptr;
   }
+  const msg::fbuf::p2pmsg::Connected_Status_Announcement_Message *message_as_Connected_Status_Announcement_Message() const {
+    return message_type() == msg::fbuf::p2pmsg::Message_Connected_Status_Announcement_Message ? static_cast<const msg::fbuf::p2pmsg::Connected_Status_Announcement_Message *>(message()) : nullptr;
+  }
   void *mutable_message() {
     return GetPointer<void *>(VT_MESSAGE);
   }
@@ -622,6 +635,10 @@ template<> inline const msg::fbuf::p2pmsg::History_Response_Message *Content::me
   return message_as_History_Response_Message();
 }
 
+template<> inline const msg::fbuf::p2pmsg::Connected_Status_Announcement_Message *Content::message_as<msg::fbuf::p2pmsg::Connected_Status_Announcement_Message>() const {
+  return message_as_Connected_Status_Announcement_Message();
+}
+
 struct ContentBuilder {
   typedef Content Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -1688,6 +1705,50 @@ inline flatbuffers::Offset<State_FS_Hash_Entry> CreateState_FS_Hash_EntryDirect(
       hash__);
 }
 
+struct Connected_Status_Announcement_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef Connected_Status_Announcement_MessageBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_IS_WEAKLY_CONNECTED = 4
+  };
+  bool is_weakly_connected() const {
+    return GetField<uint8_t>(VT_IS_WEAKLY_CONNECTED, 0) != 0;
+  }
+  bool mutate_is_weakly_connected(bool _is_weakly_connected) {
+    return SetField<uint8_t>(VT_IS_WEAKLY_CONNECTED, static_cast<uint8_t>(_is_weakly_connected), 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_IS_WEAKLY_CONNECTED) &&
+           verifier.EndTable();
+  }
+};
+
+struct Connected_Status_Announcement_MessageBuilder {
+  typedef Connected_Status_Announcement_Message Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_is_weakly_connected(bool is_weakly_connected) {
+    fbb_.AddElement<uint8_t>(Connected_Status_Announcement_Message::VT_IS_WEAKLY_CONNECTED, static_cast<uint8_t>(is_weakly_connected), 0);
+  }
+  explicit Connected_Status_Announcement_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<Connected_Status_Announcement_Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Connected_Status_Announcement_Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Connected_Status_Announcement_Message> CreateConnected_Status_Announcement_Message(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    bool is_weakly_connected = false) {
+  Connected_Status_Announcement_MessageBuilder builder_(_fbb);
+  builder_.add_is_weakly_connected(is_weakly_connected);
+  return builder_.Finish();
+}
+
 inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type) {
   switch (type) {
     case Message_NONE: {
@@ -1729,6 +1790,10 @@ inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Mess
       auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::History_Response_Message *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Message_Connected_Status_Announcement_Message: {
+      auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Connected_Status_Announcement_Message *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }

src/msg/fbuf/p2pmsg_helpers.cpp

@@ -3,7 +3,6 @@
 #include "../../crypto.hpp"
 #include "../../util.hpp"
 #include "../../hplog.hpp"
-#include "../../p2p/p2p.hpp"
 #include "../../hpfs/h32.hpp"
 #include "../../hpfs/hpfs.hpp"
 #include "p2pmsg_container_generated.h"
@@ -415,7 +414,7 @@ namespace msg::fbuf::p2pmsg
 
         // Now that we have built the content message,
         // we need to sign it and place it inside a container message.
-        create_containermsg_from_content(container_builder, builder, {}, true);
+        create_containermsg_from_content(container_builder, builder, {}, false);
     }
 
     /**
@@ -439,7 +438,7 @@ namespace msg::fbuf::p2pmsg
 
         // Now that we have built the content message,
         // we need to sign it and place it inside a container message.
-        create_containermsg_from_content(container_builder, builder, {}, true);
+        create_containermsg_from_content(container_builder, builder, {}, false);
     }
 
     /**
@@ -464,7 +463,7 @@ namespace msg::fbuf::p2pmsg
 
         // Now that we have built the content message,
         // we need to sign it and place it inside a container message.
-        create_containermsg_from_content(container_builder, builder, lcl, true);
+        create_containermsg_from_content(container_builder, builder, lcl, false);
     }
 
     /**
@@ -569,6 +568,28 @@ namespace msg::fbuf::p2pmsg
         create_containermsg_from_content(container_builder, builder, lcl, true);
     }
 
+    /**
+     * Create connected status announcement message.
+     * @param container_builder Flatbuffer builder for the container message.
+     * @param is_weakly_connected True if number of connections are below threshold and false otherwise.
+     * @param lcl Lcl value to be passed in the container message.
+     */
+    void create_msg_for_connected_status_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool is_weakly_connected, std::string_view lcl)
+    {
+        flatbuffers::FlatBufferBuilder builder(1024);
+
+        const flatbuffers::Offset<Connected_Status_Announcement_Message> announcement =
+            CreateConnected_Status_Announcement_Message(
+                builder,
+                is_weakly_connected);
+
+        const flatbuffers::Offset<Content> message = CreateContent(builder, Message_Connected_Status_Announcement_Message, announcement.Union());
+        builder.Finish(message); // Finished building message content to get serialised content.
+
+        // Now that we have built the content message,
+        create_containermsg_from_content(container_builder, builder, lcl, false);
+    }
+
     /**
  * Creates a Flatbuffer container message from the given Content message.
  * @param container_builder The Flatbuffer builder to which the final container message should be written to.
@@ -739,5 +760,4 @@ namespace msg::fbuf::p2pmsg
         }
         return builder.CreateVector(fbvec);
     }
-
 } // namespace msg::fbuf::p2pmsg

src/msg/fbuf/p2pmsg_helpers.hpp

@@ -95,6 +95,8 @@ namespace msg::fbuf::p2pmsg
         flatbuffers::FlatBufferBuilder &builder,
         std::vector<hpfs::child_hash_node> &hash_nodes);
 
+    void create_msg_for_connected_status_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool is_weakly_connected, std::string_view lcl);
+
 } // namespace msg::fbuf::p2pmsg
 
-#endif
+#endif