FEAT: parsers for new acrhitecture (#511)

closes #510

---------

Co-authored-by: Alexey Zharkov <62723911+Az3git@users.noreply.github.com>

Author: PaulRalnikov

source/connection/flow/i_new_flow.hpp

@@ -8,26 +8,28 @@
 
 namespace sim {
 
-struct FlowContext {
+struct Endpoints {
+    std::shared_ptr<IHost> sender;
+    std::shared_ptr<IHost> receiver;
+};
+
+struct FlowContext : public Endpoints {
     SizeByte sent_size;
     SizeByte delivered_size;
     SizeByte retransmit_size;
 
     std::optional<TimeNs> start_time;
     std::optional<TimeNs> last_ack_receive_time;
     utils::Statistics<TimeNs> rtt_statistics;
-
-    std::weak_ptr<IHost> sender;
-    std::weak_ptr<IHost> receiver;
 };
 
 // Transport layer interface for reliable data delivery along single physical
 // path
-    class INewFlow : public virtual Identifiable {
-    public:
-        virtual void send(std::vector<PacketInfo> packets) = 0;
+class INewFlow : public virtual Identifiable {
+public:
+    virtual void send(std::vector<PacketInfo> packets) = 0;
 
-        virtual const FlowContext& get_context() const = 0;
-    };
+    virtual const FlowContext& get_context() const = 0;
+};
 
 }  // namespace sim

source/connection/flow/tcp/new_tcp_flow.cpp

@@ -20,13 +20,8 @@ void NewTcpFlow::send(std::vector<PacketInfo> packets_info) {
     if (packets_info.empty()) {
         return;
     }
-    auto exp_endpoints = get_endpoints();
-    if (!exp_endpoints.has_value()) {
-        LOG_ERROR(fmt::format("Flow {}; error while sending packets: {}", m_id,
-                              exp_endpoints.error()));
-        return;
-    }
-    auto [sender, receiver] = exp_endpoints.value();
+    auto sender = m_context.sender;
+    auto receiver = m_context.receiver;
     for (auto info : packets_info) {
         Packet data = create_data_packet(std::move(info), sender, receiver);
 
@@ -42,31 +37,19 @@ NewTcpFlow::NewTcpFlow(Id a_id, std::shared_ptr<IHost> a_sender,
                        std::shared_ptr<IHost> a_receiver, bool a_ecn_capable,
                        RTO a_rto)
     : m_id(std::move(a_id)),
-      m_context({SizeByte(0), SizeByte(0), SizeByte(0),
+      m_context({Endpoints{a_sender, a_receiver}, SizeByte(0), SizeByte(0),
+                 SizeByte(0),
 
-                 std::nullopt, std::nullopt, utils::Statistics<TimeNs>(),
-
-                 a_sender, a_receiver}),
+                 std::nullopt, std::nullopt, utils::Statistics<TimeNs>()}),
       m_ecn_capable(a_ecn_capable),
       m_rto(std::move(a_rto)) {
     if (!m_flag_manager.register_flag_by_amount(m_packet_type_label,
                                                 PacketType::ENUM_SIZE)) {
-        throw std::runtime_error("Can not registrate packet type label");
+        throw std::runtime_error("Can not register packet type label");
     }
     if (!register_packet_avg_rtt_flag(m_flag_manager)) {
-        throw std::runtime_error("Can not registrate packet avg rtt label");
-    }
-}
-
-utils::StrExpected<NewTcpFlow::Endpoints> NewTcpFlow::get_endpoints() const {
-    if (m_context.sender.expired()) {
-        return std::unexpected("sender pointer expired");
-    }
-
-    if (m_context.receiver.expired()) {
-        return std::unexpected("receiver pointer expired");
+        throw std::runtime_error("Can not register packet avg rtt label");
     }
-    return Endpoints{m_context.sender.lock(), m_context.receiver.lock()};
 }
 
 Packet NewTcpFlow::create_data_packet(PacketInfo info,
@@ -120,38 +103,21 @@ void NewTcpFlow::set_avg_rtt_if_present(Packet& packet) {
 }
 
 void NewTcpFlow::send_data_packet(Packet data) {
-    if (m_context.sender.expired()) {
-        LOG_ERROR(fmt::format(
-            "Flow {}: sender pointer expired; could not send data packet {}",
-            m_id, data.to_string()));
-        return;
-    }
-    auto sender = m_context.sender.lock();
-
     TimeNs now = Scheduler::get_instance().get_current_time();
 
     Scheduler::get_instance().add<Timeout>(now + m_rto.current,
                                            shared_from_this(), data);
     m_context.sent_size += data.size;
 
     data.sent_time = now;
-    sender->enqueue_packet(std::move(data));
+    m_context.sender->enqueue_packet(std::move(data));
 }
 
 void NewTcpFlow::process_data_packet(const Packet& data,
                                      PacketCallback callback) {
-    auto exp_endpoints = get_endpoints();
-    if (!exp_endpoints.has_value()) {
-        LOG_ERROR(
-            fmt::format("Flow {}: error while processing data packet {}: {}",
-                        m_id, data.to_string(), exp_endpoints.error()));
-        return;
-    }
-    auto [sender, receiver] = exp_endpoints.value();
-
     Packet ack = data;
-    ack.source_id = receiver->get_id();
-    ack.dest_id = sender->get_id();
+    ack.source_id = m_context.receiver->get_id();
+    ack.dest_id = m_context.sender->get_id();
     ack.size = SizeByte(1);
     ack.ttl = M_MAX_TTL;
     ack.flags.set_flag(m_packet_type_label, PacketType::ACK)
@@ -173,7 +139,7 @@ void NewTcpFlow::process_data_packet(const Packet& data,
                                       callback);
     };
 
-    receiver->enqueue_packet(ack);
+    m_context.receiver->enqueue_packet(ack);
 }
 
 void NewTcpFlow::process_ack(const Packet& ack, SizeByte data_packet_size,
@@ -189,8 +155,9 @@ void NewTcpFlow::process_ack(const Packet& ack, SizeByte data_packet_size,
     update_rto_on_ack();
 
     if (!m_ack_monitor.confirm_one(ack.packet_num)) {
-        LOG_WARN(fmt::format("Flow {} got ack {} that confirms nothing; ignored", m_id,
-                 ack.to_string()));
+        LOG_WARN(
+            fmt::format("Flow {} got ack {} that confirms nothing; ignored",
+                        m_id, ack.to_string()));
         return;
     }
 
@@ -217,7 +184,7 @@ void NewTcpFlow::update_rto_on_ack() {
 void NewTcpFlow::on_timeout(Packet data) {
     if (m_ack_monitor.is_confirmed(data.packet_num)) {
         LOG_INFO(fmt::format(
-            "Flow {}: packet {} is confirmed when timeout reashed; no "
+            "Flow {}: packet {} is confirmed when timeout reached; no "
             "retransmit",
             m_id, data.packet_num));
         return;
@@ -247,7 +214,7 @@ class NewTcpFlow::Timeout : public Event {
     void operator()() {
         if (m_flow.expired()) {
             LOG_ERROR(
-                "Could not run TCP flow timout event: flow pointer expired");
+                "Could not run TCP flow timeout event: flow pointer expired");
             return;
         }
         m_flow.lock()->on_timeout(std::move(m_packet));

source/connection/flow/tcp/new_tcp_flow.hpp

@@ -24,13 +24,6 @@ class NewTcpFlow : public INewFlow,
                std::shared_ptr<IHost> a_receiver, bool a_ecn_capable,
                RTO a_rto);
 
-    struct Endpoints {
-        std::shared_ptr<IHost> sender;
-        std::shared_ptr<IHost> receiver;
-    };
-
-    utils::StrExpected<Endpoints> get_endpoints() const;
-
     Packet create_data_packet(PacketInfo info, std::shared_ptr<IHost> sender,
                               std::shared_ptr<IHost> receiver);
 

source/parser/config_reader/config_node_with_preset.cpp

@@ -1,17 +1,22 @@
 #include "./config_node_with_preset.hpp"
 
-namespace sim{
+namespace sim {
 
-ConfigNodeWithPreset::ConfigNodeWithPreset(ConfigNode a_node, std::optional<ConfigNode> a_presets_node, std::optional<ConfigNode> a_preset)
-    : m_node(std::move(a_node)), m_presets_node(std::move(a_presets_node)), m_preset(std::move(a_preset)){}
+ConfigNodeWithPreset::ConfigNodeWithPreset(
+    ConfigNode a_node, std::optional<ConfigNode> a_presets_node,
+    std::optional<ConfigNode> a_preset)
+    : m_node(std::move(a_node)),
+      m_presets_node(std::move(a_presets_node)),
+      m_preset(std::move(a_preset)) {}
 
-ConfigNodeWithPresetExpected ConfigNodeWithPreset::operator[](std::string_view key) const{
+ConfigNodeWithPresetExpected ConfigNodeWithPreset::operator[](
+    std::string_view key) const {
     const ConfigNodeExpected child_node = m_node[key];
-    if (!child_node.has_value()){
+    if (!child_node.has_value()) {
         // m_node hasn't key. Tries to find key in m_preset
-        if (!m_preset.has_value()){
+        if (!m_preset.has_value()) {
             // m_preset doesn't exist. Tries to find preset for this node
-            if (!m_presets_node.has_value()){
+            if (!m_presets_node.has_value()) {
                 // m_presets_node doesn't exist. Returns message about it
                 std::stringstream ss;
                 ss << "Key error: node " << m_node << ":\n";
@@ -20,7 +25,7 @@ ConfigNodeWithPresetExpected ConfigNodeWithPreset::operator[](std::string_view k
             }
             // m_presets_node exist. Tries to find field 'preset-name' in m_node
             ConfigNodeExpected node_preset_name = m_node["preset-name"];
-            if (!node_preset_name.has_value()){
+            if (!node_preset_name.has_value()) {
                 // config hasn't field 'preset-name'. Returns message about it
                 std::stringstream ss;
                 ss << "Key error: node " << m_node << ":\n";
@@ -29,48 +34,66 @@ ConfigNodeWithPresetExpected ConfigNodeWithPreset::operator[](std::string_view k
             }
             // field 'preset-name' was found. Tries to convert it to string
             ConfigNode presets_node = m_presets_node.value();
-            utils::StrExpected<std::string> preset_name = node_preset_name.value().as<std::string>();
-            if (!preset_name.has_value()){
-                // field 'preset-name' couldn't be converted to string. Returns message about it
+            utils::StrExpected<std::string> preset_name =
+                node_preset_name.value().as<std::string>();
+            if (!preset_name.has_value()) {
+                // field 'preset-name' couldn't be converted to string. Returns
+                // message about it
                 std::stringstream ss;
                 ss << "Error: field 'preset-name' in node " << m_node << '\n';
                 ss << "couldn't be converted to string";
                 return std::unexpected(ss.str());
             }
             // conversion is successful. tries to find preset in m_presets_node
             ConfigNodeExpected preset_node = presets_node[preset_name.value()];
-            if (!preset_node.has_value()){
-                // m_presets_node hasn't preset with the specified name in config. Retruns message about it
+            if (!preset_node.has_value()) {
+                // m_presets_node hasn't preset with the specified name in
+                // config. Returns message about it
                 std::stringstream ss;
-                ss << "Error: preset named '" << preset_name.value() << "' of node " << m_node << '\n';
-                ss << "can not be found in presets node:" << presets_node << ":\n";
+                ss << "Error: preset named '" << preset_name.value()
+                   << "' of node " << m_node << '\n';
+                ss << "can not be found in presets node:" << presets_node
+                   << ":\n";
                 return std::unexpected(ss.str());
             }
             // preset was found successfull. put the found value in m_preset
             m_preset.emplace(preset_node.value());
         }
         // tries to find key in preset
         ConfigNodeExpected key_node = m_preset.value()[key];
-        if (!key_node.has_value()){
+        if (!key_node.has_value()) {
             // m_preset hasn't key. Returns message about it
             std::stringstream ss;
-            ss << "Key error: preset '" << m_preset.value().get_name().value() << "' ";
+            ss << "Key error: preset '" << m_preset.value().get_name().value()
+               << "' ";
             ss << "does not have key: " << key;
             return std::unexpected(ss.str());
         }
-        // key was found in preset
-        return ConfigNodeWithPreset(key_node.value(), m_presets_node, m_preset);
+        // key was found in preset; use key_node as main node; DROP PRESET NODE
+        return ConfigNodeWithPreset(key_node.value(), m_presets_node,
+                                    std::nullopt);
     }
-    // key was found in m_node
-    return ConfigNodeWithPreset(child_node.value(), m_presets_node, m_preset);
+    // key was found in m_node: go to child value; DROP PRESET NODE
+    return ConfigNodeWithPreset(child_node.value(), m_presets_node,
+                                std::nullopt);
 }
 
-const std::string& ConfigNodeWithPreset::get_name_or_throw() const{
+const std::string& ConfigNodeWithPreset::get_name_or_throw() const {
     return m_node.get_name_or_throw();
 }
 
-const ConfigNode& ConfigNodeWithPreset::get_node() const noexcept{
+std::runtime_error ConfigNodeWithPreset::create_parsing_error(
+    std::string_view error) const {
+    return m_node.create_parsing_error(error);
+}
+
+const ConfigNode& ConfigNodeWithPreset::get_node() const noexcept {
     return m_node;
 }
 
-} // namespace sim
+const std::optional<ConfigNode> ConfigNodeWithPreset::get_presets_node()
+    const noexcept {
+    return m_presets_node;
+}
+
+}  // namespace sim

source/parser/config_reader/config_node_with_preset.hpp

@@ -2,28 +2,29 @@
 
 #include "./config_node.hpp"
 
-namespace sim{
+namespace sim {
 
 class ConfigNodeWithPreset;
 
 using ConfigNodeWithPresetExpected = utils::StrExpected<ConfigNodeWithPreset>;
 
 // Config node that supports preset inheritance.
-class ConfigNodeWithPreset{
+class ConfigNodeWithPreset {
 public:
-
     explicit ConfigNodeWithPreset(
         ConfigNode a_node,
         std::optional<ConfigNode> a_presets_node = std::nullopt,
-        std::optional<ConfigNode> a_preset = std::nullopt
-    );
+        std::optional<ConfigNode> a_preset = std::nullopt);
 
     ConfigNodeWithPresetExpected operator[](std::string_view key) const;
 
     // Returns the base config node.
     const ConfigNode& get_node() const noexcept;
 
-    // Converts m_node to type T. Probably this method will return message about error
+    const std::optional<ConfigNode> get_presets_node() const noexcept;
+
+    // Converts m_node to type T. Probably this method will return message about
+    // error
     template <typename T>
     [[nodiscard]] utils::StrExpected<T> as() const noexcept {
         return m_node.as<T>();
@@ -36,14 +37,17 @@ class ConfigNodeWithPreset{
 
     [[nodiscard]] const std::string& get_name_or_throw() const;
 
-private:
+    [[nodiscard]] std::runtime_error create_parsing_error(
+        std::string_view error) const;
 
+private:
     // m_node contains information about config node and probably preset name
     // m_preset - preset node which that is used to supplement fields of m_node
-    // m_presets_node - node it which preset node should be searched (id it needs)
+    // m_presets_node - node it which preset node should be searched (id it
+    // needs)
     const ConfigNode m_node;
     const std::optional<ConfigNode> m_presets_node;
     mutable std::optional<ConfigNode> m_preset;
 };
 
-} // namespace sim 
+}  // namespace sim