FEAT: refactor Simulator class (#513)

closes #512

---------

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

Author: PaulRalnikov

CMakeLists.txt

@@ -52,6 +52,7 @@ if(BUILD_TESTS)
 
     target_include_directories(${TEST_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/external/yaml-cpp/include)
     target_include_directories(${TEST_NAME} PUBLIC "source")
+    target_compile_definitions(${TEST_NAME} PRIVATE PROJECT_ROOT_DIR="${CMAKE_SOURCE_DIR}")
 
     target_compile_options(${TEST_NAME} PRIVATE -Wall -Wextra)
     target_link_libraries(${TEST_NAME} gtest gmock gtest_main yaml-cpp matplot)

source/link/link.cpp

@@ -26,16 +26,6 @@ Link::Link(Id a_id, std::weak_ptr<IDevice> a_from, std::weak_ptr<IDevice> a_to,
     }
 }
 
-Link::Link(LinkInitArgs args)
-    : Link(args.id.value_or_throw(),
-           IdentifierFactory::get_instance().get_object<IDevice>(
-               args.from_id.value_or_throw()),
-           IdentifierFactory::get_instance().get_object<IDevice>(
-               args.to_id.value_or_throw()),
-           args.speed.value_or_throw(), args.delay.value_or_throw(),
-           args.max_from_egress_buffer_size.value_or_throw(),
-           args.max_to_ingress_buffer_size.value_or_throw()) {}
-
 void Link::schedule_arrival(Packet packet) {
     if (m_to.expired()) {
         LOG_WARN("Destination device pointer is expired");

source/link/link.hpp

@@ -9,26 +9,12 @@
 
 namespace sim {
 
-struct LinkInitArgs {
-    utils::StrExpected<Id> id = std::unexpected("Missing id");
-    utils::StrExpected<Id> from_id = std::unexpected("Missing from id");
-    utils::StrExpected<Id> to_id = std::unexpected("Missing to id");
-    utils::StrExpected<SpeedGbps> speed = std::unexpected("Missing speed");
-    utils::StrExpected<TimeNs> delay = std::unexpected("Missing delay");
-    utils::StrExpected<SizeByte> max_from_egress_buffer_size =
-        std::unexpected("Missing max from egress buffer size");
-    utils::StrExpected<SizeByte> max_to_ingress_buffer_size =
-        std::unexpected("Missing max to ingress buffer size");
-    ;
-};
-
 class Link : public ILink, public std::enable_shared_from_this<Link> {
 public:
     Link(Id a_id, std::weak_ptr<IDevice> a_from, std::weak_ptr<IDevice> a_to,
          SpeedGbps a_speed = SpeedGbps(1), TimeNs a_delay = TimeNs(0),
          SizeByte a_max_from_egress_buffer_size = SizeByte(4096),
          SizeByte a_max_to_ingress_buffer_size = SizeByte(4096));
-    explicit Link(LinkInitArgs args);
     ~Link() = default;
 
     void schedule_arrival(Packet packet) final;

source/parser/config_reader/config_node.cpp

@@ -47,6 +47,12 @@ std::ostream& operator<<(std::ostream& out, const ConfigNode& node) {
     return out;
 }
 
+std::string ConfigNode::to_string() const {
+    std::stringstream ss;
+    ss << *this;
+    return ss.str();
+}
+
 YAML::NodeType::value ConfigNode::Type() const { return m_node.Type(); }
 
 bool ConfigNode::IsNull() const noexcept { return m_node.IsNull(); }

source/parser/config_reader/config_node.hpp

@@ -32,6 +32,8 @@ class ConfigNode {
 
     friend std::ostream& operator<<(std::ostream& out, const ConfigNode& node);
 
+    std::string to_string() const;
+
     // yaml-cpp functional
 
     [[nodiscard]] YAML::NodeType::value Type() const;

source/parser/network_parser.cpp

@@ -0,0 +1,44 @@
+#include "network_parser.hpp"
+
+#include "parser/simulation/new-connection/connection_parser.hpp"
+#include "parser/topology/topology_parser.hpp"
+#include "relative_path_parser.hpp"
+
+namespace sim {
+
+Network parse_network(const std::filesystem::path& path) {
+    ConfigNode node = load_file(path);
+
+    std::string topology_config_path =
+        parse_relative_path(node, "topology_config_path", path.parent_path());
+
+    const ConfigNode topology_config = load_file(topology_config_path);
+
+    Topology topology = parse_topology(topology_config);
+
+    const ConfigNode& connections_node = node["connections"].value_or_throw();
+
+    NetworkContext ctx(std::move(topology), utils::IdTable<INewConnection>{});
+
+    std::optional<ConfigNode> presets_node = node["presets"].to_optional();
+    std::optional<ConfigNode> connection_presets_node =
+        presets_node ? presets_node.value()["connection"].to_optional()
+                     : std::nullopt;
+
+    for (const auto& connection_node : connections_node) {
+        ConfigNodeWithPreset conn_node_with_preset(connection_node,
+                                                   connection_presets_node);
+
+        std::shared_ptr<INewConnection> connection = parse_i_connection(
+            conn_node_with_preset, ctx.topology.get_context().hosts_table);
+        Id conn_id = connection->get_id();
+        if (!ctx.connections_table.emplace(conn_id, connection).second) {
+            throw connections_node.create_parsing_error(
+                fmt::format("Two connection with same name: {}", conn_id));
+        }
+    }
+
+    return Network{std::move(ctx)};
+}
+
+}  // namespace sim

source/parser/network_parser.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <filesystem>
+
+#include "simulator/network/network.hpp"
+
+namespace sim {
+
+Network parse_network(const std::filesystem::path &path);
+
+}

source/parser/parser.cpp

@@ -8,7 +8,6 @@
 #include "parser/topology/host/host_parser.hpp"
 #include "parser/topology/link/link_parser.hpp"
 #include "parser/topology/switch/switch_parser.hpp"
-#include "preset_storage.hpp"
 
 namespace sim {
 
@@ -43,8 +42,8 @@ Simulator YamlParser::build_simulator_from_config(
 
     parse_if_present(topology_config["hosts"],
                      [this, &hosts_presets_node](ConfigNode node) {
-                        process_hosts(node, hosts_presets_node);
-                    });
+                         process_hosts(node, hosts_presets_node);
+                     });
 
     const ConfigNode packet_spraying_node =
         topology_config["packet-spraying"].value_or_throw();
@@ -56,10 +55,11 @@ Simulator YamlParser::build_simulator_from_config(
         }
     }
 
-    parse_if_present(topology_config["switches"],
-                     [this, &switches_presets_node, &packet_spraying_node](ConfigNode node) {
-                         process_switches(node, switches_presets_node, packet_spraying_node);
-                     });
+    parse_if_present(
+        topology_config["switches"],
+        [this, &switches_presets_node, &packet_spraying_node](ConfigNode node) {
+            process_switches(node, switches_presets_node, packet_spraying_node);
+        });
 
     std::optional<ConfigNode> links_presets_node = std::nullopt;
     if (topology_presets_node.has_value()) {
@@ -82,41 +82,50 @@ Simulator YamlParser::build_simulator_from_config(
     return std::move(m_simulator);
 }
 
-void YamlParser::process_hosts(const ConfigNode &hosts_node, const std::optional<ConfigNode> &hosts_presets_node) {
+void YamlParser::process_hosts(
+    const ConfigNode &hosts_node,
+    const std::optional<ConfigNode> &hosts_presets_node) {
     process_identifiables<IHost>(
         hosts_node,
         [this](std::shared_ptr<IHost> host) {
             return m_simulator.add_host(host);
         },
-        [&hosts_presets_node](const ConfigNode& hosts_node){
-            return HostParser::parse_i_host(ConfigNodeWithPreset(hosts_node, hosts_presets_node));
+        [&hosts_presets_node](const ConfigNode &hosts_node) {
+            return HostParser::parse_i_host(
+                ConfigNodeWithPreset(hosts_node, hosts_presets_node));
         },
         "Can not add host.");
 }
 
-void YamlParser::process_switches(const ConfigNode &switches_node,
-                                const std::optional<ConfigNode> &switches_presets_node,
-                                const ConfigNode &packet_spraying_node) {
+void YamlParser::process_switches(
+    const ConfigNode &switches_node,
+    const std::optional<ConfigNode> &switches_presets_node,
+    const ConfigNode &packet_spraying_node) {
     process_identifiables<ISwitch>(
         switches_node,
         [this](std::shared_ptr<ISwitch> swtch) {
             return m_simulator.add_switch(swtch);
         },
-        [&packet_spraying_node, &switches_presets_node](const ConfigNode &switch_node) {
-            return SwitchParser::parse_i_switch(ConfigNodeWithPreset(switch_node, switches_presets_node), packet_spraying_node);
+        [&packet_spraying_node,
+         &switches_presets_node](const ConfigNode &switch_node) {
+            return SwitchParser::parse_i_switch(
+                ConfigNodeWithPreset(switch_node, switches_presets_node),
+                packet_spraying_node);
         },
         "Can not add switch.");
 }
 
-void YamlParser::process_links(const ConfigNode &links_node,
-                               const std::optional<ConfigNode> &link_presets_node) {
+void YamlParser::process_links(
+    const ConfigNode &links_node,
+    const std::optional<ConfigNode> &link_presets_node) {
     process_identifiables<ILink>(
         links_node,
         [this](std::shared_ptr<ILink> link) {
             return m_simulator.add_link(link);
         },
         [&link_presets_node](const ConfigNode &link_node) {
-            return LinkParser::parse_i_link(ConfigNodeWithPreset(link_node, link_presets_node));
+            return LinkParser::parse_i_link(
+                ConfigNodeWithPreset(link_node, link_presets_node));
         },
         "Can not add link.");
 }

source/parser/preset_storage.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <string_view>
+
+#include "parser/config_reader/config_node.hpp"
+
+namespace sim {
+inline std::filesystem::path parse_relative_path(const ConfigNode& node,
+                                                 std::string_view field_name,
+                                                 std::filesystem::path prefix) {
+    return prefix /
+           node[field_name].value_or_throw().as_or_throw<std::string>();
+}
+}  // namespace sim