ipfixprobe - refactor OutputPlugin

Author: SiskaPavel

include/ipfixprobe/output.hpp

@@ -0,0 +1,80 @@
+/**
+ * @file
+ * @brief Generic interface of output plugin
+ * @author Pavel Siska <[email protected]>
+ * @author Vaclav Bartos <[email protected]>
+ * @author Jiri Havranek <[email protected]>
+ * @date 2025
+ *
+ * Copyright (c) 2025 CESNET
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+#include "api.hpp"
+#include "flowifc.hpp"
+#include "plugin.hpp"
+#include "process.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ipxp {
+
+#define DEFAULT_EXPORTER_ID 1
+
+/**
+ * \brief Base class for flow exporters.
+ */
+class IPXP_API OutputPlugin : public Plugin {
+public:
+	typedef std::vector<std::pair<std::string, ProcessPlugin*>> Plugins;
+	uint64_t m_flows_seen; /**< Number of flows received to export. */
+	uint64_t m_flows_dropped; /**< Number of flows that could not be exported. */
+
+	OutputPlugin()
+		: m_flows_seen(0)
+		, m_flows_dropped(0)
+	{
+	}
+	virtual ~OutputPlugin() {}
+
+	virtual void init(const char* params, Plugins& plugins) = 0;
+
+	enum class Result { EXPORTED = 0, DROPPED };
+	/**
+	 * \brief Send flow record to output interface.
+	 * \param [in] flow Flow to send.
+	 * \return 0 on success
+	 */
+	virtual int export_flow(const Flow& flow) = 0;
+
+	/**
+	 * \brief Force exporter to flush flows to collector.
+	 */
+	virtual void flush() {}
+};
+
+/**
+ * @brief Factory template for creating plugins.
+ *
+ * This template allows dynamic creation of plugin instances based on the specified
+ * base class and constructor argument types.
+ *
+ * @tparam Base The base class for the plugin.
+ * @tparam Args The argument types required for the plugin constructor.
+ */
+template<typename Base, typename... Args>
+class IPXP_API PluginFactory;
+
+/**
+ * @brief Type alias for the OutputPlugin factory.
+ *
+ * Provides a factory for creating OutputPlugin instances using a string-based constructor.
+ */
+using OutputPluginFactory = PluginFactory<OutputPlugin, const std::string&>;
+
+} // namespace ipxp

include/ipfixprobe/outputPlugin.hpp

@@ -42,7 +42,7 @@
 #include <appFs.hpp>
 #include <ipfixprobe/inputPlugin.hpp>
 #include <ipfixprobe/options.hpp>
-#include <ipfixprobe/output.hpp>
+#include <ipfixprobe/outputPlugin.hpp>
 #include <ipfixprobe/packet.hpp>
 #include <ipfixprobe/plugin.hpp>
 #include <ipfixprobe/process.hpp>

src/core/ipfixprobe.hpp

@@ -0,0 +1,110 @@
+/**
+ * @file
+ * @brief Implementation of PluginManager class for loading and unloading plugins.
+ * @author Pavel Siska <[email protected]>
+ * @date 2025
+ *
+ * Copyright (c) 2025 CESNET
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "pluginManager.hpp"
+
+#include <filesystem>
+#include <iostream>
+#include <stdexcept>
+#include <variant>
+
+#include <dlfcn.h>
+
+namespace ipxp {
+
+namespace fs = std::filesystem;
+
+static void clearErrorMessage()
+{
+	dlerror();
+}
+
+static void* openSharedObject(const std::string& path)
+{
+	const int dlFlags = RTLD_LAZY | RTLD_LOCAL;
+	return dlopen(path.c_str(), dlFlags);
+}
+
+template<typename Iterator>
+static bool isValidPlugin(const Iterator& entry)
+{
+	return entry.is_regular_file() && entry.path().extension() == ".so";
+}
+
+static void loadPluginsRecursive(const std::string& dirPath, PluginManager& pluginManager)
+{
+	for (const auto& entry : fs::recursive_directory_iterator(dirPath)) {
+		if (isValidPlugin(entry)) {
+			pluginManager.loadPlugin(entry.path().string());
+		}
+	}
+}
+
+static void loadPluginsNonRecursive(const std::string& dirPath, PluginManager& pluginManager)
+{
+	for (const auto& entry : fs::directory_iterator(dirPath)) {
+		if (isValidPlugin(entry)) {
+			pluginManager.loadPlugin(entry.path().string());
+		}
+	}
+}
+
+PluginManager::PluginManager(bool unloadAtExit)
+	: m_unloadAtExit(unloadAtExit)
+{
+}
+
+void PluginManager::loadPlugins(const std::string& dirPath, bool recursive)
+{
+	const auto loadPluginsFunction = recursive ? loadPluginsRecursive : loadPluginsNonRecursive;
+
+	try {
+		loadPluginsFunction(dirPath, *this);
+	} catch (const fs::filesystem_error& ex) {
+		std::cerr << "Error accessing directory '" << dirPath << "': " << ex.what() << std::endl;
+		// m_logger->error("Error accessing directory '{}': {}", dirPath, ex.what());
+		throw std::runtime_error("PluginManager::loadPlugins() has failed.");
+	}
+}
+
+void PluginManager::loadPlugin(const std::string& pluginPath)
+{
+	clearErrorMessage();
+	void* pluginHandle = openSharedObject(pluginPath);
+
+	if (!pluginHandle) {
+		std::cerr << "Error loading plugin '" << pluginPath << "': " << dlerror() << std::endl;
+		// m_logger->error(std::string(dlerror()));
+		throw std::runtime_error("PluginManager::loadPlugin() has failed.");
+	}
+
+	std::cerr << "Plugin '" << pluginPath << "' loaded." << std::endl;
+	// m_logger->info("Plugin '{}' loaded.", pluginPath);
+
+	m_pluginHandles.emplace_back(pluginHandle);
+}
+
+PluginManager::~PluginManager()
+{
+	if (m_unloadAtExit) {
+		unloadPlugins();
+	}
+}
+
+void PluginManager::unloadPlugins()
+{
+	for (auto handle : m_pluginHandles) {
+		dlclose(handle);
+	}
+	m_pluginHandles.clear();
+}
+
+} // namespace ipxp

src/core/pluginManager.cpp

@@ -0,0 +1,100 @@
+/**
+ * @file
+ * @brief Manages the loading and unloading of shared plugins in the PluginManager class.
+ *
+ * This class provides functionality for loading dynamic shared objects (plugins) from specified
+ * directories, optionally searching them recursively. It supports unloading plugins either
+ * automatically at exit or manually through a function call. The class uses the `dlopen()` and
+ * `dlclose()` system calls for managing shared object libraries, and the `std::filesystem` library
+ * to iterate over files in a directory.
+ *
+ * @author Pavel Siska <[email protected]>
+ * @date 2025
+ *
+ * Copyright (c) 2025 CESNET
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace ipxp {
+
+/**
+ * @brief Manages loading and unloading of plugins (shared objects).
+ *
+ * This class loads plugins from a specified directory (with optional recursion), unloads them,
+ * and manages their state. Plugins are loaded with `dlopen()` and unloaded with `dlclose()`.
+ *
+ * The `unloadAtExit` flag determines if plugins should be automatically unloaded when the
+ * `PluginManager` object is destroyed. If set to `false`, plugins remain loaded, which is useful
+ * for debugging (e.g., with Valgrind).
+ *
+ * It can load plugins from individual files or all `.so` files in a directory (recursively).
+ */
+class PluginManager {
+public:
+	/**
+	 * @brief Constructor for PluginManager.
+	 *
+	 * Initializes the PluginManager, optionally setting whether plugins should be unloaded
+	 * automatically when the PluginManager object is destroyed (in the destructor).
+	 *
+	 * @param unloadAtExit A boolean flag that determines if plugins should be unloaded when the
+	 * PluginManager object is destroyed. Defaults to `true`.
+	 */
+	PluginManager(bool unloadAtExit = true);
+
+	/**
+	 * @brief Destructor for PluginManager.
+	 *
+	 * If the `unloadAtExit` flag is set to `true`, this method will automatically unload
+	 * all loaded plugins by calling `dlclose()` on each plugin handle.
+	 */
+	~PluginManager();
+
+	/**
+	 * @brief Load a plugin from a specified file path.
+	 *
+	 * This method loads a single plugin (shared object) from the provided file path. If the plugin
+	 * cannot be loaded, it will log an error and throw a `std::runtime_error`.
+	 *
+	 * @param pluginPath The path to the plugin file (shared object).
+	 * @throws std::runtime_error if loading the plugin fails.
+	 */
+	void loadPlugin(const std::string& pluginPath);
+
+	/**
+	 * @brief Load plugins from a specified directory.
+	 *
+	 * This method loads all `.so` plugins from the specified directory. Optionally, it can
+	 * search subdirectories recursively for plugins. It uses `std::filesystem` to iterate over
+	 * the directory contents and attempts to load each `.so` file as a plugin. If an error occurs
+	 * while accessing the directory or loading a plugin, it will log the error and throw an
+	 * exception.
+	 *
+	 * @param dirPath The path to the directory containing the plugins.
+	 * @param recursive A boolean flag indicating whether to search subdirectories recursively.
+	 *
+	 * @throws std::runtime_error If there is an error accessing the directory or loading the
+	 * plugins.
+	 */
+	void loadPlugins(const std::string& dirPath, bool recursive = false);
+
+	/**
+	 * @brief Unload all loaded plugins.
+	 *
+	 * This method unloads all currently loaded plugins by calling `dlclose()` on each plugin
+	 * handle.
+	 */
+	void unloadPlugins();
+
+private:
+	std::vector<void*> m_pluginHandles;
+	bool m_unloadAtExit;
+};
+
+} // namespace ipxp

src/core/pluginManager.hpp

@@ -35,7 +35,7 @@
 #include <future>
 
 #include <ipfixprobe/inputPlugin.hpp>
-#include <ipfixprobe/output.hpp>
+#include <ipfixprobe/outputPlugin.hpp>
 #include <ipfixprobe/packet.hpp>
 #include <ipfixprobe/process.hpp>
 #include <ipfixprobe/ring.h>