fdsdump: add view factory component for creating views/fields

Author: sedmicha

src/tools/fdsdump/src/aggregator/field.hpp

@@ -35,6 +35,8 @@ enum class CmpResult {
  * @brief The base class for all aggregator fields
  */
 class Field {
+    friend class ViewFactory;
+
 public:
     /**
      * @brief Get the size of the field in bytes

src/tools/fdsdump/src/aggregator/view.hpp

@@ -21,6 +21,8 @@ namespace aggregator {
  * @brief A view object for accessing fields and their values in an aggregation record
  */
 class View {
+    friend class ViewFactory;
+
 public:
     /**
      * @brief The ordering/sorting direction

src/tools/fdsdump/src/aggregator/viewFactory.cpp

@@ -0,0 +1,338 @@
+/**
+ * @file
+ * @author Michal Sedlak <[email protected]>
+ * @brief View factory
+ *
+ * Copyright: (C) 2024 CESNET, z.s.p.o.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <aggregator/aggregatedField.hpp>
+#include <aggregator/aliasField.hpp>
+#include <aggregator/extraFields.hpp>
+#include <aggregator/inOutField.hpp>
+#include <aggregator/ipfixField.hpp>
+#include <aggregator/viewFactory.hpp>
+#include <common/common.hpp>
+#include <common/ieMgr.hpp>
+
+#include <limits>
+#include <stdexcept>
+
+namespace fdsdump {
+namespace aggregator {
+
+static bool
+check_strip_prefix(std::string& str, const std::string &prefix)
+{
+    if (string_to_lower(str.substr(0, prefix.size())) == string_to_lower(prefix)) {
+        str = str.substr(prefix.size());
+        return true;
+    }
+    return false;
+}
+
+static bool
+check_strip_suffix(std::string& str, const std::string &suffix)
+{
+    if (str.size() < suffix.size()) {
+        return false;
+    }
+
+    const std::string &tail_lower = string_to_lower(
+        str.substr(str.size() - suffix.size(), suffix.size()));
+    const std::string &suffix_lower = string_to_lower(suffix);
+    if (tail_lower == suffix_lower) {
+        str = str.substr(0, str.size() - suffix.size());
+        return true;
+    }
+    return false;
+}
+
+static Optional<int>
+parse_number(const std::string &str)
+{
+    char *end;
+    errno = 0;
+    long value = std::strtol(str.c_str(), &end, 10);
+    if (errno != 0
+            || *end != '\0'
+            || value < std::numeric_limits<int>::min()
+            || value > std::numeric_limits<int>::max()) {
+        return {};
+    }
+    return value;
+}
+
+static Optional<int>
+parse_time_unit_to_millisecs(std::string str)
+{
+    int multiplier = 1;
+    if (check_strip_suffix(str, "s")) {
+        multiplier = 1;
+    } else if (check_strip_suffix(str, "m")) {
+        multiplier = 60;
+    } else if (check_strip_suffix(str, "h")) {
+        multiplier = 3600;
+    }
+
+    auto secs = parse_number(str);
+    if (!secs) {
+        return {};
+    }
+
+    return *secs * multiplier * 1000;
+}
+
+static std::string
+parse_func_name(std::string &def)
+{
+    if (def.empty()) {
+        return "";
+    }
+    if (def[def.size() - 1] != ')') {
+        return "";
+    }
+
+    const auto &pieces = string_split(std::string(def.begin(), def.end() - 1), "(", 2);
+    if (pieces.size() != 2) {
+        return "";
+    }
+
+    def = pieces[1];
+    return string_to_lower(pieces[0]);
+}
+
+std::unique_ptr<Field>
+ViewFactory::create_elem_or_alias(const std::string &def)
+{
+    const fds_iemgr_alias *alias =
+        fds_iemgr_alias_find(IEMgr::instance().ptr(), def.c_str());
+    if (alias) {
+        std::unique_ptr<Field> field(new AliasField(*alias));
+        field->set_name(def);
+        return field;
+    }
+
+    const fds_iemgr_elem *elem =
+        fds_iemgr_elem_find_name(IEMgr::instance().ptr(), def.c_str());
+    if (elem) {
+        std::unique_ptr<Field> field(new IpfixField(*elem));
+        field->set_name(def);
+        return field;
+    }
+
+    throw std::invalid_argument("cannot find field \"" + def + "\"");
+}
+
+std::unique_ptr<Field>
+ViewFactory::parse_timewindow_func(const std::string &def)
+{
+    std::string def_copy = def;
+    auto func = parse_func_name(def_copy);
+    if (func != "timewindow") {
+        return {};
+    }
+
+    auto args = string_split(def_copy, ",");
+    if (args.size() != 2) {
+        throw std::runtime_error("timewindow field bad args"); //FIXME
+    }
+
+    for (auto &arg : args) {
+        string_trim(arg);
+    }
+
+    auto inner = create_elem_or_alias(args[0]);
+    auto millis = parse_time_unit_to_millisecs(args[1]);
+    if (!millis) {
+        throw std::runtime_error("timewindow field bad time unit"); //FIXME
+    }
+
+    std::unique_ptr<Field> field(new TimeWindowField(std::move(inner), *millis));
+    field->set_name(def);
+    return field;
+}
+
+std::unique_ptr<Field>
+ViewFactory::parse_prefixlen_field(const std::string &def)
+{
+    auto pieces = string_split(def, "/", 2);
+    if (pieces.size() != 2) {
+        return {};
+    }
+
+    auto prefix_len = parse_number(pieces[1]);
+    if (!prefix_len) {
+        throw std::runtime_error("invalid ip prefix len"); //FIXME
+    }
+
+    auto inner = create_elem_or_alias(pieces[0]);
+
+    std::unique_ptr<Field> field(new SubnetField(std::move(inner), *prefix_len));
+    field->set_name(def);
+    return field;
+}
+
+std::unique_ptr<Field>
+ViewFactory::parse_dir_field(const std::string &def)
+{
+    std::string def_lower = string_to_lower(def);
+    if (def_lower == "direction" || def_lower == "dir" || def_lower == "biflowdir") {
+        std::unique_ptr<Field> field(new DirectionField);
+        field->set_name(def);
+        return field;
+    } else {
+        return {};
+    }
+}
+
+std::unique_ptr<Field>
+ViewFactory::create_key_field(const std::string &def)
+{
+    std::unique_ptr<Field> field;
+
+    if ((field = parse_timewindow_func(def))) {
+        return field;
+    }
+
+    if ((field = parse_prefixlen_field(def))) {
+        return field;
+    }
+
+    if ((field = parse_dir_field(def))) {
+        return field;
+    }
+
+    field = create_elem_or_alias(def);
+    return field;
+}
+
+std::unique_ptr<Field>
+ViewFactory::create_value_field(const std::string& def)
+{
+    std::string rem_def = def;
+
+    std::unique_ptr<Field> field;
+
+    std::string func = parse_func_name(rem_def);
+    std::string prefix = parse_inout_prefix(rem_def);
+
+    std::string rem_def_lower = string_to_lower(rem_def);
+    if (rem_def_lower == "flows" || rem_def_lower == "flowcount" || rem_def_lower == "count") {
+        field.reset(new FlowCountField);
+        field->set_name(rem_def);
+    } else {
+        field = create_elem_or_alias(rem_def);
+    }
+
+    if (func == "min") {
+        field.reset(new MinAggregatedField(std::move(field)));
+    } else if (func == "max") {
+        field.reset(new MaxAggregatedField(std::move(field)));
+    } else if (func == "sum") {
+        field.reset(new SumAggregatedField(std::move(field)));
+    } else if (func == "" && field->is_number()) {
+        field.reset(new SumAggregatedField(std::move(field)));
+    } else {
+        throw std::invalid_argument("invalid aggregation function " + func);
+    }
+
+    field->set_name(def);
+    return field;
+}
+
+static std::vector<std::string>
+split_args(const std::string &str)
+{
+    std::vector<std::string> pieces;
+    std::string tmp;
+    int depth = 0;
+    for (char c : str) {
+        if (c == '(') {
+            depth++;
+            tmp.push_back(c);
+        } else if (c == ')') {
+            depth--;
+            tmp.push_back(c);
+        } else if (c == ',' && depth == 0) {
+            pieces.push_back(tmp);
+            tmp.clear();
+        } else {
+            tmp.push_back(c);
+        }
+    }
+    pieces.push_back(tmp);
+    return pieces;
+}
+
+std::shared_ptr<View> 
+ViewFactory::create_view(
+    const std::string &key_def, 
+    const std::string &value_def, 
+    const std::string &order_def)
+{
+    std::shared_ptr<View> view(new View);
+    create_view(*view.get(), key_def, value_def, order_def);
+    return view;
+}
+
+void 
+ViewFactory::create_view(
+    View &view, 
+    const std::string &key_def, 
+    const std::string &value_def, 
+    const std::string &order_def)
+{
+    for (auto def : split_args(key_def)) {
+        string_trim(def);
+        auto field = create_key_field(def);
+        field->set_offset(view.m_key_size);
+        view.m_key_size += field->size();
+        view.m_key_count++;
+        view.m_fields.push_back(std::move(field));
+    }
+
+    for (auto def : split_args(value_def)) {
+        string_trim(def);
+
+        auto field = create_value_field(def);
+        field->set_offset(view.m_key_size + view.m_value_size);
+        view.m_value_size += field->size();
+        view.m_value_count++;
+
+        view.m_fields.push_back(std::move(field));
+    }
+
+    if (!order_def.empty()) {
+        for (auto def : split_args(order_def)) {
+            string_trim(def);
+
+            const auto &pieces = string_split(def, "/", 2);
+
+            const auto *field = view.find_field(pieces[0]);
+            if (!field) {
+                throw std::invalid_argument("cannot find compare field \"" + def + "\"");
+            }
+
+            View::OrderDirection dir;
+            if (pieces.size() == 2) {
+                if (pieces[1] == "asc") {
+                    dir = View::OrderDirection::Ascending;
+                } else if (pieces[1] == "desc") {
+                    dir = View::OrderDirection::Descending;
+                } else {
+                    throw std::invalid_argument("invalid compare field dir \"" + def + "\"");
+                }
+            } else {
+                // Default
+                dir = View::OrderDirection::Ascending;
+            }
+
+            view.m_order_fields.push_back({field, dir});
+        }
+    }
+}
+
+} // namespace aggregator
+} // namespace fdsdump