fdsdump: storageSorted: define component

Author: Lukas Hutak

src/tools/fdsdump/src/storageSorted.cpp

@@ -0,0 +1,65 @@
+
+#include <cassert>
+#include <iterator>
+
+#include "storageSorted.hpp"
+
+StorageSorted::StorageSorted(StorageSorter sorter, size_t capacity)
+    : m_sorter{sorter}, m_records{m_sorter}, m_capacity{capacity}
+{
+}
+
+void
+StorageSorted::insert(struct Flow *flow)
+{
+    const enum Direction dir_backup = flow->dir;
+
+    if ((dir_backup & DIRECTION_FWD) != 0) {
+        flow->dir = DIRECTION_FWD;
+        insert_single_direction(flow);
+    }
+
+    if ((dir_backup & DIRECTION_REV) != 0) {
+        flow->dir = DIRECTION_REV;
+        insert_single_direction(flow);
+    }
+
+    flow->dir = dir_backup;
+}
+
+void
+StorageSorted::insert_single_direction(struct Flow *flow)
+{
+    // Exactly single direction must be specified
+    assert(flow->dir == DIRECTION_FWD || flow->dir == DIRECTION_REV);
+
+    if (m_capacity == 0 || m_records.size() < m_capacity) {
+        insert_storage_record(flow);
+        return;
+    }
+
+    const auto last_iter = std::prev(m_records.end());
+    const Flow &last_rec = last_iter->get_flow_const();
+
+    if (!m_sorter(*flow, last_rec)) {
+        // Don't insert the record as it should be placed after the last one
+        return;
+    }
+
+    m_records.erase(last_iter);
+    insert_storage_record(flow);
+}
+
+void
+StorageSorted::insert_storage_record(struct Flow *flow)
+{
+    shared_tsnapshot snapshot{
+        fds_tsnapshot_deep_copy(flow->rec.snap),
+        &fds_tsnapshot_destroy};
+
+    if (!snapshot) {
+        throw std::runtime_error("fds_tsnapshot_deep_copy() has failed");
+    }
+
+    m_records.emplace(flow->rec, flow->dir, snapshot);
+}

src/tools/fdsdump/src/storageSorted.hpp

@@ -0,0 +1,56 @@
+
+#pragma once
+
+#include <set>
+
+#include "storageRecord.hpp"
+#include "storageSorter.hpp"
+
+/**
+ * @brief Sorted storage of flow records
+ */
+class StorageSorted {
+public:
+    using Storage = std::multiset<StorageRecord, StorageSorter>;
+
+    /**
+     * @brief Create a storage for Flow Data records where the records are
+     * sorted based on the @p sorter.
+     *
+     * @param[in] sorter   Sorter of Flow Record
+     * @param[in] capacity Maximal capacity of the storage. If zero, the
+     *   storage capacity is not limited.
+     */
+    StorageSorted(StorageSorter sorter, size_t capacity = 0);
+
+    /**
+     * @brief Insert a Flow Data record to the storage and place it based
+     * on the order given by the sorter.
+     *
+     * If the capacity has been reached and the new record would be placed
+     * (based on the sorter) after the last record in the storage, no action
+     * is performed.
+     *
+     * @param[in] flow Flow Data record to be stored
+     */
+    void insert(struct Flow *flow);
+
+    /**
+     * @brief Get an iterator to the first element of the storage.
+     * @return Constant iterator
+     */
+    Storage::iterator begin() const { return m_records.begin(); };
+    /**
+     * @brief Get an iterator to the element following the last element the storage.
+     * @return Constant iterator
+     */
+    Storage::iterator end() const { return m_records.end(); };
+
+private:
+    StorageSorter m_sorter;
+    Storage m_records;
+    size_t m_capacity;
+
+    void insert_single_direction(struct Flow *flow);
+    void insert_storage_record(struct Flow *flow);
+};