You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by ma...@apache.org on 2026/03/11 07:48:09 UTC
(nifi-minifi-cpp) 05/07: MINIFICPP-2715 - Use symbol lookup to check version
This is an automated email from the ASF dual-hosted git repository.
martinzink pushed a commit to branch controller_c_api_requirements
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git
commit a8128b9f81be218adffbdcb3beae16717c1497a5
Author: Adam Debreceni <ad...@apache.org>
AuthorDate: Thu Feb 19 13:52:50 2026 +0100
MINIFICPP-2715 - Use symbol lookup to check version
---
Extensions.md | 43 ++++++++++++--
.../include/utils/ExtensionInitUtils.h | 4 ++
extensions/ExtensionInitializer.cpp | 4 +-
.../llamacpp/processors/ExtensionInitializer.cpp | 4 +-
extensions/opencv/OpenCVLoader.cpp | 4 +-
.../python/pythonlibloader/PythonLibLoader.cpp | 4 +-
extensions/python/pythonloader/PyProcLoader.cpp | 4 +-
extensions/sftp/SFTPLoader.cpp | 4 +-
libminifi/include/core/extension/Extension.h | 14 ++++-
.../include/core/extension/ExtensionManager.h | 2 +
libminifi/src/core/extension/Extension.cpp | 64 ++++++++++++++++-----
libminifi/src/core/extension/ExtensionManager.cpp | 22 ++++++--
libminifi/src/minifi-c.cpp | 65 ++++++++++------------
minifi-api/CMakeLists.txt | 2 +-
minifi-api/include/minifi-c/minifi-c.h | 19 ++-----
minifi-api/minifi-c-api.def | 2 +-
16 files changed, 176 insertions(+), 85 deletions(-)
diff --git a/Extensions.md b/Extensions.md
index 3a82e212f..0bfbd5bd9 100644
--- a/Extensions.md
+++ b/Extensions.md
@@ -17,8 +17,41 @@
To enable all extensions for your platform, you may use -DENABLE_ALL=TRUE OR select the option to "Enable all Extensions" in the bootstrap script. [ReadMe](https://github.com/apache/nifi-minifi-cpp/#bootstrapping)
# Extension internals
-Extensions are dynamic libraries loaded at runtime by the agent. An extension makes its
-capabilities (classes) available to the system through registrars. Registration must happen in source files, not headers.
+Extensions are dynamic libraries loaded at runtime by the agent.
+
+## C extensions
+You can build a shared library depending on the C capabilities of the agent as given in the `minifi-c.h` file.
+For the shared library to be considered a valid extension, it has to have a global symbol with the name `MinifiCApiVersion`
+with its value as a null terminated string (`const char*`) of the macro `MINIFI_API_VERSION` from `minifi-c.h`.
+
+Moreover the actual resource registration (processors/controller services) has to happen during the `MinifiInitExtension` call.
+One possible example of this is:
+
+```C++
+extern "C" const char* const MinifiApiVersion = MINIFI_API_VERSION;
+
+extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
+ MinifiExtension* extension = nullptr;
+ minifi::api::core::useProcessorClassDescription<minifi::extensions::llamacpp::processors::RunLlamaCppInference>([&] (const MinifiProcessorClassDefinition& description) {
+ MinifiExtensionCreateInfo ext_create_info{
+ .name = minifi::api::utils::toStringView(MAKESTRING(EXTENSION_NAME)),
+ .version = minifi::api::utils::toStringView(MAKESTRING(EXTENSION_VERSION)),
+ .deinit = nullptr,
+ .user_data = nullptr,
+ .processors_count = 1,
+ .processors_ptr = &description,
+ };
+ extension = MinifiCreateExtension(&ext_create_info);
+ });
+ return extension;
+}
+```
+
+## C++ extensions
+You can utilize the C++ api, linking to `minifi-api` and possibly using the helpers in `extension-framework`.
+No compatibilities are guaranteed beyond what extensions are built together with the agent at the same time.
+
+An extension makes its capabilities (classes) available to the system through registrars. Registration must happen in source files, not headers.
```C++
// register user-facing classes as
@@ -33,10 +66,10 @@ REGISTER_RESOURCE(RESTSender, DescriptionOnly);
```
Some extensions (e.g. `OpenCVExtension`) require initialization before use.
-You need to define an `MinifiInitExtension` function of type `MinifiExtension*(MinifiConfig*)` to be called.
+You need to define an `MinifiInitCppExtension` function of type `MinifiExtension*(MinifiConfig*)` to be called.
```C++
-extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
+extern "C" MinifiExtension* MinifiInitCppExtension(MinifiConfig* /*config*/) {
const auto success = org::apache::nifi::minifi::utils::Environment::setEnvironmentVariable("OPENCV_FFMPEG_CAPTURE_OPTIONS", "rtsp_transport;udp", false /*overwrite*/);
if (!success) {
return nullptr;
@@ -49,7 +82,7 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.processors_count = 0,
.processors_ptr = nullptr
};
- return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ return MinifiCreateCppExtension(&ext_create_info);
}
```
diff --git a/extension-framework/include/utils/ExtensionInitUtils.h b/extension-framework/include/utils/ExtensionInitUtils.h
index 1af7617e5..57f1d063f 100644
--- a/extension-framework/include/utils/ExtensionInitUtils.h
+++ b/extension-framework/include/utils/ExtensionInitUtils.h
@@ -30,4 +30,8 @@ inline MinifiStringView toStringView(std::string_view str) {
using ConfigReader = std::function<std::optional<std::string>(std::string_view key)>;
+static inline MinifiExtension* MinifiCreateCppExtension(const MinifiExtensionCreateInfo* create_info) {
+ return MINIFI_CREATE_EXTENSION_FN(create_info);
+}
+
} // namespace org::apache::nifi::minifi::utils
diff --git a/extensions/ExtensionInitializer.cpp b/extensions/ExtensionInitializer.cpp
index 3caaaeed0..e735a78e7 100644
--- a/extensions/ExtensionInitializer.cpp
+++ b/extensions/ExtensionInitializer.cpp
@@ -22,7 +22,7 @@
namespace minifi = org::apache::nifi::minifi;
-extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
+extern "C" MinifiExtension* MinifiInitCppExtension(MinifiConfig* /*config*/) {
MinifiExtensionCreateInfo ext_create_info{
.name = minifi::utils::toStringView(MAKESTRING(MODULE_NAME)),
.version = minifi::utils::toStringView(minifi::AgentBuild::VERSION),
@@ -31,5 +31,5 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.processors_count = 0,
.processors_ptr = nullptr
};
- return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ return minifi::utils::MinifiCreateCppExtension(&ext_create_info);
}
diff --git a/extensions/llamacpp/processors/ExtensionInitializer.cpp b/extensions/llamacpp/processors/ExtensionInitializer.cpp
index b90b8b133..29316f8b3 100644
--- a/extensions/llamacpp/processors/ExtensionInitializer.cpp
+++ b/extensions/llamacpp/processors/ExtensionInitializer.cpp
@@ -24,6 +24,8 @@
namespace minifi = org::apache::nifi::minifi;
+extern "C" const char* const MinifiApiVersion = MINIFI_API_VERSION;
+
extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
MinifiExtension* extension = nullptr;
minifi::api::core::useProcessorClassDescription<minifi::extensions::llamacpp::processors::RunLlamaCppInference>([&] (const MinifiProcessorClassDefinition& description) {
@@ -35,7 +37,7 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.processors_count = 1,
.processors_ptr = &description,
};
- extension = MinifiCreateExtension(minifi::api::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ extension = MinifiCreateExtension(&ext_create_info);
});
return extension;
}
diff --git a/extensions/opencv/OpenCVLoader.cpp b/extensions/opencv/OpenCVLoader.cpp
index 3f91395c4..53f61dbca 100644
--- a/extensions/opencv/OpenCVLoader.cpp
+++ b/extensions/opencv/OpenCVLoader.cpp
@@ -24,7 +24,7 @@
namespace minifi = org::apache::nifi::minifi;
-extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
+extern "C" MinifiExtension* MinifiInitCppExtension(MinifiConfig* /*config*/) {
// By default in OpenCV, ffmpeg capture is hardcoded to use TCP and this is a workaround
// also if UDP timeout, ffmpeg will retry with TCP
// Note:
@@ -42,5 +42,5 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.processors_count = 0,
.processors_ptr = nullptr
};
- return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ return minifi::utils::MinifiCreateCppExtension(&ext_create_info);
}
diff --git a/extensions/python/pythonlibloader/PythonLibLoader.cpp b/extensions/python/pythonlibloader/PythonLibLoader.cpp
index cdf0356b7..9c9a35d28 100644
--- a/extensions/python/pythonlibloader/PythonLibLoader.cpp
+++ b/extensions/python/pythonlibloader/PythonLibLoader.cpp
@@ -98,7 +98,7 @@ class PythonLibLoader {
std::shared_ptr<minifi::core::logging::Logger> logger_ = minifi::core::logging::LoggerFactory<PythonLibLoader>::getLogger();
};
-extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* config) {
+extern "C" MinifiExtension* MinifiInitCppExtension(MinifiConfig* config) {
static PythonLibLoader python_lib_loader([&] (std::string_view key) -> std::optional<std::string> {
std::optional<std::string> result;
MinifiConfigGet(config, minifi::utils::toStringView(key), [] (void* user_data, MinifiStringView value) {
@@ -114,5 +114,5 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* config) {
.processors_count = 0,
.processors_ptr = nullptr
};
- return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ return minifi::utils::MinifiCreateCppExtension(&ext_create_info);
}
diff --git a/extensions/python/pythonloader/PyProcLoader.cpp b/extensions/python/pythonloader/PyProcLoader.cpp
index 55ad4ebef..cd9cbb998 100644
--- a/extensions/python/pythonloader/PyProcLoader.cpp
+++ b/extensions/python/pythonloader/PyProcLoader.cpp
@@ -33,7 +33,7 @@ static minifi::extensions::python::PythonCreator& getPythonCreator() {
// the symbols of the python library
extern "C" const int LOAD_MODULE_AS_GLOBAL = 1;
-extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* config) {
+extern "C" MinifiExtension* MinifiInitCppExtension(MinifiConfig* config) {
getPythonCreator().configure([&] (std::string_view key) -> std::optional<std::string> {
std::optional<std::string> result;
MinifiConfigGet(config, minifi::utils::toStringView(key), [] (void* user_data, MinifiStringView value) {
@@ -49,5 +49,5 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* config) {
.processors_count = 0,
.processors_ptr = nullptr
};
- return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ return minifi::utils::MinifiCreateCppExtension( &ext_create_info);
}
diff --git a/extensions/sftp/SFTPLoader.cpp b/extensions/sftp/SFTPLoader.cpp
index bb23e9998..333ab173e 100644
--- a/extensions/sftp/SFTPLoader.cpp
+++ b/extensions/sftp/SFTPLoader.cpp
@@ -25,7 +25,7 @@
namespace minifi = org::apache::nifi::minifi;
-extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
+extern "C" MinifiExtension* MinifiInitCppExtension(MinifiConfig* /*config*/) {
if (libssh2_init(0) != 0) {
return nullptr;
}
@@ -44,5 +44,5 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.processors_count = 0,
.processors_ptr = nullptr
};
- return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
+ return minifi::utils::MinifiCreateCppExtension(&ext_create_info);
}
diff --git a/libminifi/include/core/extension/Extension.h b/libminifi/include/core/extension/Extension.h
index e14cb97ed..2a71a6fbc 100644
--- a/libminifi/include/core/extension/Extension.h
+++ b/libminifi/include/core/extension/Extension.h
@@ -17,11 +17,12 @@
#pragma once
-#include <memory>
+#include <filesystem>
#include <map>
+#include <memory>
#include <string>
-#include <filesystem>
+#include "minifi-c/minifi-c.h"
#include "minifi-cpp/core/logging/Logger.h"
#include "minifi-cpp/properties/Configure.h"
@@ -38,6 +39,12 @@ class Extension {
void* user_data;
};
+ struct Version {
+ int major{MINIFI_API_MAJOR_VERSION};
+ int minor{MINIFI_API_MINOR_VERSION};
+ int patch{MINIFI_API_PATCH_VERSION};
+ };
+
Extension(std::string name, std::filesystem::path library_path);
Extension(const Extension&) = delete;
@@ -49,6 +56,8 @@ class Extension {
bool initialize(const std::shared_ptr<minifi::Configure>& configure);
+ Version version() const {return version_;}
+
private:
#ifdef WIN32
std::map<void*, std::string> resource_mapping_;
@@ -71,6 +80,7 @@ class Extension {
std::filesystem::path library_path_;
gsl::owner<void*> handle_ = nullptr;
+ Version version_{};
std::unique_ptr<Info> info_;
const std::shared_ptr<logging::Logger> logger_;
diff --git a/libminifi/include/core/extension/ExtensionManager.h b/libminifi/include/core/extension/ExtensionManager.h
index c610bd70a..7b312ae4b 100644
--- a/libminifi/include/core/extension/ExtensionManager.h
+++ b/libminifi/include/core/extension/ExtensionManager.h
@@ -37,6 +37,8 @@ class ExtensionManager {
ExtensionManager& operator=(const ExtensionManager&) = delete;
ExtensionManager& operator=(ExtensionManager&&) = delete;
+ static Extension* getExtensionBeingInitialized();
+
private:
std::vector<std::unique_ptr<Extension>> extensions_;
diff --git a/libminifi/src/core/extension/Extension.cpp b/libminifi/src/core/extension/Extension.cpp
index 3034c8a8f..35d0634b9 100644
--- a/libminifi/src/core/extension/Extension.cpp
+++ b/libminifi/src/core/extension/Extension.cpp
@@ -38,6 +38,7 @@
#include "core/logging/LoggerFactory.h"
#include "minifi-c/minifi-c.h"
#include "minifi-cpp/agent/agent_docs.h"
+#include "utils/RegexUtils.h"
namespace org::apache::nifi::minifi::core::extension {
@@ -57,10 +58,43 @@ bool Extension::load(bool global) {
if (!handle_) {
logger_->log_error("Failed to load extension '{}' at '{}': {}", name_, library_path_, dlerror());
return false;
- } else {
- logger_->log_trace("Loaded extension '{}' at '{}'", name_, library_path_);
+ }
+ logger_->log_trace("Dlopen succeeded for extension '{}' at '{}'", name_, library_path_);
+ if (findSymbol("MinifiInitCppExtension")) {
+ logger_->log_trace("Loaded cpp extension '{}' at '{}'", name_, library_path_);
return true;
}
+ if (!findSymbol("MinifiInitExtension")) {
+ logger_->log_error("Failed to load c extension '{}' at '{}': No initializer found", name_, library_path_);
+ return false;
+ }
+ auto api_version = reinterpret_cast<const char* const*>(findSymbol("MinifiApiVersion"));
+ if (!api_version) {
+ logger_->log_error("Failed to load c extension '{}' at '{}': No MinifiApiVersion symbol found", name_, library_path_);
+ return false;
+ }
+ utils::SVMatch match;
+ if (!utils::regexSearch(*api_version, match, utils::Regex{R"(^([0-9]+)\.([0-9]+)\.([0-9]+)$)"})) {
+ logger_->log_error("Failed to load c extension '{}' at '{}': Api version is in invalid format: '{}'", name_, library_path_, *api_version);
+ return false;
+ }
+ gsl_Assert(match.size() == 4);
+ version_.major = std::stoi(match[1]);
+ version_.minor = std::stoi(match[2]);
+ version_.patch = std::stoi(match[3]);
+ if (version_.major != MINIFI_API_MAJOR_VERSION) {
+ logger_->log_error("Failed to load c extension '{}' at '{}': Api major version mismatch, application is '{}' while extension is '{}'",
+ name_, library_path_, MINIFI_API_VERSION, *api_version);
+ return false;
+ }
+ if (version_.minor > MINIFI_API_MINOR_VERSION) {
+ logger_->log_error("Failed to load c extension '{}' at '{}': Extension is built for a newer version, application is '{}' while extension is '{}'",
+ name_, library_path_, MINIFI_API_VERSION, *api_version);
+ return false;
+ }
+ logger_->log_debug("Loaded c extension '{}' at '{}': Application version is '{}', extension version is '{}'",
+ name_, library_path_, MINIFI_API_VERSION, *api_version);
+ return true;
}
bool Extension::unload() {
@@ -113,17 +147,21 @@ Extension::~Extension() {
bool Extension::initialize(const std::shared_ptr<minifi::Configure>& configure) {
logger_->log_trace("Initializing extension '{}'", name_);
- if (void* init_symbol_ptr = findSymbol("MinifiInitExtension")) {
- logger_->log_debug("Found custom initializer for '{}'", name_);
- auto init_fn = reinterpret_cast<MinifiExtension*(*)(MinifiConfig*)>(init_symbol_ptr);
- auto config_handle = reinterpret_cast<MinifiConfig*>(configure.get());
- info_.reset(reinterpret_cast<Info*>(init_fn(config_handle)));
- if (!info_) {
- logger_->log_error("Failed to initialize extension '{}'", name_);
- return false;
- }
- } else {
- logger_->log_debug("No custom initializer for '{}'", name_);
+ void* init_symbol_ptr = findSymbol("MinifiInitCppExtension");
+ if (!init_symbol_ptr) {
+ init_symbol_ptr = findSymbol("MinifiInitExtension");
+ }
+ if (!init_symbol_ptr) {
+ logger_->log_error("No initializer for '{}'", name_);
+ return false;
+ }
+ logger_->log_debug("Found initializer for '{}'", name_);
+ auto init_fn = reinterpret_cast<MinifiExtension*(*)(MinifiConfig*)>(init_symbol_ptr);
+ auto config_handle = reinterpret_cast<MinifiConfig*>(configure.get());
+ info_.reset(reinterpret_cast<Info*>(init_fn(config_handle)));
+ if (!info_) {
+ logger_->log_error("Failed to initialize extension '{}'", name_);
+ return false;
}
return true;
}
diff --git a/libminifi/src/core/extension/ExtensionManager.cpp b/libminifi/src/core/extension/ExtensionManager.cpp
index 0b144a251..689a6cd42 100644
--- a/libminifi/src/core/extension/ExtensionManager.cpp
+++ b/libminifi/src/core/extension/ExtensionManager.cpp
@@ -30,6 +30,16 @@
namespace org::apache::nifi::minifi::core::extension {
+namespace {
+
+std::atomic<Extension*> extension_being_initialized{nullptr};
+
+} // namespace
+
+Extension* ExtensionManager::getExtensionBeingInitialized() {
+ return extension_being_initialized.load();
+}
+
ExtensionManager::ExtensionManager(const std::shared_ptr<Configure>& config): logger_(logging::LoggerFactory<ExtensionManager>::getLogger()) {
logger_->log_trace("Initializing extensions");
if (!config) {
@@ -71,10 +81,14 @@ ExtensionManager::ExtensionManager(const std::shared_ptr<Configure>& config): lo
continue;
}
}
- if (!extension->initialize(config)) {
- logger_->log_error("Failed to initialize extension '{}' at '{}'", library->name, library->getFullPath());
- } else {
- extensions_.push_back(std::move(extension));
+ {
+ auto extension_guard = gsl::finally([] {extension_being_initialized = nullptr;});
+ extension_being_initialized = extension.get();
+ if (!extension->initialize(config)) {
+ logger_->log_error("Failed to initialize extension '{}' at '{}'", library->name, library->getFullPath());
+ } else {
+ extensions_.push_back(std::move(extension));
+ }
}
}
}
diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp
index 0e4144c33..e670c4415 100644
--- a/libminifi/src/minifi-c.cpp
+++ b/libminifi/src/minifi-c.cpp
@@ -22,6 +22,8 @@
#include "agent/agent_docs.h"
#include "core/ProcessorMetrics.h"
+#include "core/extension/ExtensionManager.h"
+#include "minifi-cpp/Exception.h"
#include "minifi-cpp/core/Annotation.h"
#include "minifi-cpp/core/ClassLoader.h"
#include "minifi-cpp/core/ProcessContext.h"
@@ -33,10 +35,8 @@
#include "minifi-cpp/core/PropertyValidator.h"
#include "minifi-cpp/core/logging/Logger.h"
#include "minifi-cpp/core/state/PublishedMetricProvider.h"
-#include "minifi-cpp/Exception.h"
-#include "core/extension/ExtensionManager.h"
-#include "utils/PropertyErrors.h"
#include "utils/CProcessor.h"
+#include "utils/PropertyErrors.h"
namespace minifi = org::apache::nifi::minifi;
@@ -146,30 +146,6 @@ class CProcessorFactory : public minifi::core::ProcessorFactory {
minifi::utils::CProcessorClassDescription class_description_;
};
-MinifiExtension* MinifiCreateExtensionImpl(MinifiStringView /*api_version*/, const MinifiExtensionCreateInfo* extension_create_info) {
- gsl_Assert(extension_create_info);
- auto extension_name = toString(extension_create_info->name);
- minifi::BundleIdentifier bundle{
- .name = extension_name,
- .version = toString(extension_create_info->version)
- };
- auto& bundle_components = minifi::ClassDescriptionRegistry::getMutableClassDescriptions()[bundle];
- for (size_t proc_idx = 0; proc_idx < extension_create_info->processors_count; ++proc_idx) {
- minifi::utils::useCProcessorClassDescription(extension_create_info->processors_ptr[proc_idx], [&] (const auto& description, const auto& c_class_description) {
- minifi::core::ClassLoader::getDefaultClassLoader().getClassLoader(extension_name).registerClass(
- c_class_description.name,
- std::make_unique<CProcessorFactory>(extension_name, toString(extension_create_info->processors_ptr[proc_idx].full_name), c_class_description));
- bundle_components.processors.emplace_back(description);
- });
- }
- return reinterpret_cast<MinifiExtension*>(new org::apache::nifi::minifi::core::extension::Extension::Info{
- .name = toString(extension_create_info->name),
- .version = toString(extension_create_info->version),
- .deinit = extension_create_info->deinit,
- .user_data = extension_create_info->user_data
- });
-}
-
} // namespace
namespace org::apache::nifi::minifi::utils {
@@ -249,16 +225,35 @@ void useCProcessorClassDescription(const MinifiProcessorClassDefinition& class_d
extern "C" {
-MinifiExtension* MINIFI_CREATE_EXTENSION_FN(MinifiStringView api_version, const MinifiExtensionCreateInfo* extension_create_info) {
- return MinifiCreateExtensionImpl(api_version, extension_create_info);
-}
-
-#define REGISTER_C_API_VERSION(major, minor) \
- MinifiExtension* MINIFI_PRIVATE_JOIN(MinifiCreateExtension, MINIFI_PRIVATE_JOIN(major, minor))(MinifiStringView api_version, const MinifiExtensionCreateInfo* extension_create_info) { \
- return MinifiCreateExtensionImpl(api_version, extension_create_info); \
+MinifiExtension* MinifiCreateExtension(const MinifiExtensionCreateInfo* extension_create_info) {
+ gsl_Assert(extension_create_info);
+ auto current_extension = minifi::core::extension::ExtensionManager::getExtensionBeingInitialized();
+ gsl_Assert(current_extension);
+ auto extension_name = toString(extension_create_info->name);
+ minifi::BundleIdentifier bundle{
+ .name = extension_name,
+ .version = toString(extension_create_info->version)
+ };
+ auto& bundle_components = minifi::ClassDescriptionRegistry::getMutableClassDescriptions()[bundle];
+ for (size_t proc_idx = 0; proc_idx < extension_create_info->processors_count; ++proc_idx) {
+ minifi::utils::useCProcessorClassDescription(extension_create_info->processors_ptr[proc_idx], [&] (const auto& description, const auto& c_class_description) {
+ minifi::core::ClassLoader::getDefaultClassLoader().getClassLoader(extension_name).registerClass(
+ c_class_description.name,
+ std::make_unique<CProcessorFactory>(extension_name, toString(extension_create_info->processors_ptr[proc_idx].full_name), c_class_description));
+ bundle_components.processors.emplace_back(description);
+ });
}
+ return reinterpret_cast<MinifiExtension*>(new org::apache::nifi::minifi::core::extension::Extension::Info{
+ .name = toString(extension_create_info->name),
+ .version = toString(extension_create_info->version),
+ .deinit = extension_create_info->deinit,
+ .user_data = extension_create_info->user_data
+ });
+}
-REGISTER_C_API_VERSION(0, 1)
+MinifiExtension* MINIFI_CREATE_EXTENSION_FN(const MinifiExtensionCreateInfo* extension_create_info) {
+ return MinifiCreateExtension(extension_create_info);
+}
MinifiStatus MinifiProcessContextGetProperty(MinifiProcessContext* context, MinifiStringView property_name, MinifiFlowFile* flowfile,
void (*result_cb)(void* user_ctx, MinifiStringView result), void* user_ctx) {
diff --git a/minifi-api/CMakeLists.txt b/minifi-api/CMakeLists.txt
index 05f78fc99..ebdd239c3 100644
--- a/minifi-api/CMakeLists.txt
+++ b/minifi-api/CMakeLists.txt
@@ -6,7 +6,7 @@ target_compile_definitions(minifi-api-common INTERFACE MINIFI_VERSION_STR="${MIN
add_library(minifi-api INTERFACE)
target_include_directories(minifi-api INTERFACE include)
target_link_libraries(minifi-api INTERFACE minifi-api-common)
-target_compile_definitions(minifi-api INTERFACE MINIFI_CREATE_EXTENSION_FN=MinifiCreateExtension_${BUILD_IDENTIFIER})
+target_compile_definitions(minifi-api INTERFACE MINIFI_CREATE_EXTENSION_FN=MinifiCreateCppExtension_${BUILD_IDENTIFIER})
add_library(minifi-c-api INTERFACE)
target_include_directories(minifi-c-api INTERFACE include/minifi-c)
diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h
index d246b773b..5bab74941 100644
--- a/minifi-api/include/minifi-c/minifi-c.h
+++ b/minifi-api/include/minifi-c/minifi-c.h
@@ -39,13 +39,13 @@ extern "C" {
#define MINIFI_API_PATCH_VERSION 0
#define MINIFI_API_VERSION MINIFI_PRIVATE_STRINGIFY(MINIFI_API_MAJOR_VERSION) "." MINIFI_PRIVATE_STRINGIFY(MINIFI_API_MINOR_VERSION) "." MINIFI_PRIVATE_STRINGIFY(MINIFI_API_PATCH_VERSION)
-#ifndef MINIFI_CREATE_EXTENSION_FN
-#define MINIFI_CREATE_EXTENSION_FN MINIFI_PRIVATE_JOIN(MinifiCreateExtension, MINIFI_PRIVATE_JOIN(MINIFI_API_MAJOR_VERSION, MINIFI_API_MINOR_VERSION))
-#endif
-
#define MINIFI_NULL nullptr
#define MINIFI_OWNED
+#ifndef MINIFI_CREATE_EXTENSION_FN
+#define MINIFI_CREATE_EXTENSION_FN MinifiCreateExtension
+#endif
+
typedef bool MinifiBool;
typedef enum MinifiInputRequirement : uint32_t {
@@ -94,7 +94,7 @@ typedef struct MinifiOutputStream MinifiOutputStream;
typedef struct MinifiConfig MinifiConfig;
typedef struct MinifiExtension MinifiExtension;
typedef struct MinifiPublishedMetrics MinifiPublishedMetrics;
-typedef struct MinifiApiVersion MinifiApiVersion;
+typedef struct MinifiAgent MinifiAgent;
typedef enum MinifiStatus : uint32_t {
MINIFI_STATUS_SUCCESS = 0,
@@ -189,10 +189,7 @@ typedef struct MinifiExtensionCreateInfo {
const MinifiProcessorClassDefinition* processors_ptr;
} MinifiExtensionCreateInfo;
-// api_version is used to provide backwards compatible changes to the MinifiExtensionCreateInfo structure,
-// e.g. if MinifiExtensionCreateInfo gets a new field in version 1.2.0, extensions built with api 1.1.0 do not
-// have to be rebuilt
-MinifiExtension* MINIFI_CREATE_EXTENSION_FN(MinifiStringView api_version, const MinifiExtensionCreateInfo* create_info);
+MinifiExtension* MINIFI_CREATE_EXTENSION_FN(const MinifiExtensionCreateInfo* create_info);
MINIFI_OWNED MinifiPublishedMetrics* MinifiPublishedMetricsCreate(size_t count, const MinifiStringView* metric_names, const double* metric_values);
@@ -232,8 +229,4 @@ void MinifiFlowFileGetAttributes(MinifiProcessSession* session, MinifiFlowFile*
} // extern "C"
#endif // __cplusplus
-static inline MinifiExtension* MinifiCreateExtension(MinifiStringView api_version, const MinifiExtensionCreateInfo* create_info) {
- return MINIFI_CREATE_EXTENSION_FN(api_version, create_info);
-}
-
#endif // MINIFI_API_INCLUDE_MINIFI_C_MINIFI_C_H_
diff --git a/minifi-api/minifi-c-api.def b/minifi-api/minifi-c-api.def
index a664bdd2d..fd303daee 100644
--- a/minifi-api/minifi-c-api.def
+++ b/minifi-api/minifi-c-api.def
@@ -1,6 +1,6 @@
LIBRARY core-minifi.dll
EXPORTS
- MinifiCreateExtension_0_1
+ MinifiCreateExtension
MinifiPublishedMetricsCreate
MinifiProcessContextGetProperty
MinifiProcessContextHasNonEmptyProperty