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/02/12 15:53:58 UTC
(nifi-minifi-cpp) 01/04: MINIFICPP-2708 Controller Service C API
This is an automated email from the ASF dual-hosted git repository.
martinzink pushed a commit to branch apache-rusty
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git
commit 2d943909b60d099fe86de15cf7408bd837bba328
Author: Martin Zink <ma...@apache.org>
AuthorDate: Thu Feb 12 16:51:46 2026 +0100
MINIFICPP-2708 Controller Service C API
Built upon ongoing #2065 #2098 and #2105 PR-s
Closes #2096
Signed-off-by: Martin Zink <ma...@apache.org>
---
Extensions.md | 4 +-
core-framework/include/agent/agent_docs.h | 13 +-
.../core/controller/ControllerServiceBase.h | 6 +-
.../core/controller/ControllerServiceFactoryImpl.h | 4 +-
core-framework/include/http/HTTPClient.h | 1 +
core-framework/include/utils/ThreadPool.h | 2 +-
.../aws/tests/MultipartUploadStateStorageTest.cpp | 2 +-
.../llamacpp/processors/ExtensionInitializer.cpp | 2 +
extensions/opencv/OpenCVLoader.cpp | 4 +-
.../python/pythonlibloader/PythonLibLoader.cpp | 4 +-
extensions/python/pythonloader/PyProcLoader.cpp | 4 +-
extensions/sftp/SFTPLoader.cpp | 4 +-
.../controllers/NetworkPrioritizerService.h | 2 +-
.../include/core/controller/ControllerService.h | 9 +-
libminifi/include/utils/CControllerService.h | 110 ++++++++++++++++
libminifi/include/utils/CProcessor.h | 9 +-
libminifi/src/controllers/SSLContextService.cpp | 2 +-
libminifi/src/minifi-c.cpp | 138 +++++++++++++++++++--
libminifi/src/properties/Properties.cpp | 1 +
libminifi/test/libtest/integration/HTTPHandlers.h | 13 +-
.../test/libtest/unit/ControllerServiceUtils.h | 2 +-
.../test/unit/NetworkPrioritizerServiceTests.cpp | 2 +-
.../minifi-cpp/core}/ControllerServiceMetadata.h | 6 +-
minifi-api/include/minifi-c/minifi-c.h | 35 ++++++
minifi-api/include/minifi-cpp/agent/agent_docs.h | 4 +-
.../minifi-cpp/controllers/RecordSetReader.h | 4 +-
.../minifi-cpp/controllers/RecordSetWriter.h | 4 +-
.../controllers/SSLContextServiceInterface.h | 6 +-
...trollerServiceApi.h => ControllerServiceType.h} | 6 +-
...inition.h => ControllerServiceTypeDefinition.h} | 2 +-
.../core/controller/ControllerServiceDescriptor.h | 1 +
.../core/controller/ControllerServiceFactory.h | 5 +-
.../core/controller/ControllerServiceInterface.h | 15 ---
minifi-api/minifi-c-api.def | 2 +
34 files changed, 352 insertions(+), 76 deletions(-)
diff --git a/Extensions.md b/Extensions.md
index 3a82e212f..0dcf4c604 100644
--- a/Extensions.md
+++ b/Extensions.md
@@ -47,7 +47,9 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.deinit = nullptr,
.user_data = nullptr,
.processors_count = 0,
- .processors_ptr = nullptr
+ .processors_ptr = nullptr,
+ .controller_services_count = 0,
+ .controller_services_ptr = nullptr,
};
return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
}
diff --git a/core-framework/include/agent/agent_docs.h b/core-framework/include/agent/agent_docs.h
index 14544f2d6..4c7e25035 100644
--- a/core-framework/include/agent/agent_docs.h
+++ b/core-framework/include/agent/agent_docs.h
@@ -16,18 +16,17 @@
*/
#pragma once
-#include "minifi-cpp/agent/agent_docs.h"
-
#include <map>
#include <string>
#include <utility>
#include <vector>
-#include "utils/StringUtils.h"
#include "core/ClassName.h"
-#include "minifi-cpp/core/OutputAttribute.h"
-#include "minifi-cpp/core/ControllerServiceApi.h"
+#include "minifi-cpp/agent/agent_docs.h"
+#include "minifi-cpp/core/ControllerServiceType.h"
#include "minifi-cpp/core/DynamicProperty.h"
+#include "minifi-cpp/core/OutputAttribute.h"
+#include "utils/StringUtils.h"
namespace org::apache::nifi::minifi {
@@ -44,8 +43,8 @@ inline auto toVector(std::span<const core::OutputAttributeReference> attributes)
return std::vector<core::OutputAttribute>(attributes.begin(), attributes.end());
}
-inline auto toVector(std::span<const core::ControllerServiceApiDefinition> apis) {
- return std::vector<core::ControllerServiceApi>(apis.begin(), apis.end());
+inline auto toVector(std::span<const core::ControllerServiceTypeDefinition> apis) {
+ return std::vector<core::ControllerServiceType>(apis.begin(), apis.end());
}
inline auto toVector(std::span<const core::DynamicPropertyDefinition> properties) {
diff --git a/core-framework/include/core/controller/ControllerServiceBase.h b/core-framework/include/core/controller/ControllerServiceBase.h
index 2fd22b299..621f48295 100644
--- a/core-framework/include/core/controller/ControllerServiceBase.h
+++ b/core-framework/include/core/controller/ControllerServiceBase.h
@@ -28,8 +28,8 @@
#include "core/Connectable.h"
#include "minifi-cpp/core/controller/ControllerServiceApi.h"
#include "minifi-cpp/core/controller/ControllerServiceInterface.h"
-#include "minifi-cpp/core/ControllerServiceApiDefinition.h"
-#include "minifi-cpp/core/controller/ControllerServiceMetadata.h"
+#include "minifi-cpp/core/ControllerServiceTypeDefinition.h"
+#include "minifi-cpp/core/ControllerServiceMetadata.h"
namespace org::apache::nifi::minifi::core::controller {
@@ -95,7 +95,7 @@ class ControllerServiceBase : public ControllerServiceApi {
}
- static constexpr auto ImplementsApis = std::array<ControllerServiceApiDefinition, 0>{};
+ static constexpr auto ImplementsApis = std::array<ControllerServiceTypeDefinition, 0>{};
protected:
std::string name_;
diff --git a/core-framework/include/core/controller/ControllerServiceFactoryImpl.h b/core-framework/include/core/controller/ControllerServiceFactoryImpl.h
index 4060e9d18..a30bd48c6 100644
--- a/core-framework/include/core/controller/ControllerServiceFactoryImpl.h
+++ b/core-framework/include/core/controller/ControllerServiceFactoryImpl.h
@@ -17,10 +17,12 @@
#pragma once
-#include <string>
#include <memory>
+#include <string>
#include <utility>
+
#include "core/ClassName.h"
+#include "minifi-cpp/core/ControllerServiceMetadata.h"
#include "minifi-cpp/core/controller/ControllerServiceFactory.h"
namespace org::apache::nifi::minifi::core::controller {
diff --git a/core-framework/include/http/HTTPClient.h b/core-framework/include/http/HTTPClient.h
index 9339a5b21..b27c54df5 100644
--- a/core-framework/include/http/HTTPClient.h
+++ b/core-framework/include/http/HTTPClient.h
@@ -45,6 +45,7 @@
#include "minifi-cpp/core/logging/Logger.h"
#include "core/logging/LoggerFactory.h"
#include "minifi-cpp/controllers/SSLContextServiceInterface.h"
+#include "minifi-cpp/core/PropertyDefinition.h"
#include "utils/ByteArrayCallback.h"
namespace org::apache::nifi::minifi::http {
diff --git a/core-framework/include/utils/ThreadPool.h b/core-framework/include/utils/ThreadPool.h
index f7ecf8cd6..4f2b2af79 100644
--- a/core-framework/include/utils/ThreadPool.h
+++ b/core-framework/include/utils/ThreadPool.h
@@ -135,7 +135,7 @@ class WorkerThread {
*/
class ThreadPool {
public:
- ThreadPool(int max_worker_threads = 2, std::string name = "NamelessPool");
+ explicit ThreadPool(int max_worker_threads = 2, std::string name = "NamelessPool");
ThreadPool(const ThreadPool &other) = delete;
ThreadPool& operator=(const ThreadPool &other) = delete;
diff --git a/extensions/aws/tests/MultipartUploadStateStorageTest.cpp b/extensions/aws/tests/MultipartUploadStateStorageTest.cpp
index c791e85c9..fc6f757be 100644
--- a/extensions/aws/tests/MultipartUploadStateStorageTest.cpp
+++ b/extensions/aws/tests/MultipartUploadStateStorageTest.cpp
@@ -32,7 +32,7 @@ class MultipartUploadStateStorageTestFixture {
MultipartUploadStateStorageTestFixture() {
LogTestController::getInstance().setDebug<minifi::aws::s3::MultipartUploadStateStorage>();
const auto storage_uuid = minifi::utils::IdGenerator::getIdGenerator()->generate();
- state_storage_ = std::make_unique<minifi::controllers::VolatileMapStateStorage>(core::controller::ControllerServiceMetadata{
+ state_storage_ = std::make_unique<minifi::controllers::VolatileMapStateStorage>(core::ControllerServiceMetadata{
.uuid = storage_uuid,
.name = "KeyValueStateStorage",
.logger = logging::LoggerFactory<minifi::controllers::VolatileMapStateStorage>::getLogger(storage_uuid)
diff --git a/extensions/llamacpp/processors/ExtensionInitializer.cpp b/extensions/llamacpp/processors/ExtensionInitializer.cpp
index b90b8b133..f55afba69 100644
--- a/extensions/llamacpp/processors/ExtensionInitializer.cpp
+++ b/extensions/llamacpp/processors/ExtensionInitializer.cpp
@@ -34,6 +34,8 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.user_data = nullptr,
.processors_count = 1,
.processors_ptr = &description,
+ .controller_services_count = 0,
+ .controller_services_ptr = nullptr,
};
extension = MinifiCreateExtension(minifi::api::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
});
diff --git a/extensions/opencv/OpenCVLoader.cpp b/extensions/opencv/OpenCVLoader.cpp
index 3f91395c4..f159cae8e 100644
--- a/extensions/opencv/OpenCVLoader.cpp
+++ b/extensions/opencv/OpenCVLoader.cpp
@@ -40,7 +40,9 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
.deinit = nullptr,
.user_data = nullptr,
.processors_count = 0,
- .processors_ptr = nullptr
+ .processors_ptr = nullptr,
+ .controller_services_count = 0,
+ .controller_services_ptr = nullptr,
};
return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
}
diff --git a/extensions/python/pythonlibloader/PythonLibLoader.cpp b/extensions/python/pythonlibloader/PythonLibLoader.cpp
index cdf0356b7..c2617f186 100644
--- a/extensions/python/pythonlibloader/PythonLibLoader.cpp
+++ b/extensions/python/pythonlibloader/PythonLibLoader.cpp
@@ -112,7 +112,9 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* config) {
.deinit = nullptr,
.user_data = nullptr,
.processors_count = 0,
- .processors_ptr = nullptr
+ .processors_ptr = nullptr,
+ .controller_services_count = 0,
+ .controller_services_ptr = nullptr,
};
return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
}
diff --git a/extensions/python/pythonloader/PyProcLoader.cpp b/extensions/python/pythonloader/PyProcLoader.cpp
index 55ad4ebef..f37041340 100644
--- a/extensions/python/pythonloader/PyProcLoader.cpp
+++ b/extensions/python/pythonloader/PyProcLoader.cpp
@@ -47,7 +47,9 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* config) {
.deinit = nullptr,
.user_data = nullptr,
.processors_count = 0,
- .processors_ptr = nullptr
+ .processors_ptr = nullptr,
+ .controller_services_count = 0,
+ .controller_services_ptr = nullptr,
};
return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
}
diff --git a/extensions/sftp/SFTPLoader.cpp b/extensions/sftp/SFTPLoader.cpp
index bb23e9998..8b8d9bffa 100644
--- a/extensions/sftp/SFTPLoader.cpp
+++ b/extensions/sftp/SFTPLoader.cpp
@@ -42,7 +42,9 @@ extern "C" MinifiExtension* MinifiInitExtension(MinifiConfig* /*config*/) {
},
.user_data = nullptr,
.processors_count = 0,
- .processors_ptr = nullptr
+ .processors_ptr = nullptr,
+ .controller_services_count = 0,
+ .controller_services_ptr = nullptr,
};
return MinifiCreateExtension(minifi::utils::toStringView(MINIFI_API_VERSION), &ext_create_info);
}
diff --git a/libminifi/include/controllers/NetworkPrioritizerService.h b/libminifi/include/controllers/NetworkPrioritizerService.h
index 6e8e8593b..a3fc85cb6 100644
--- a/libminifi/include/controllers/NetworkPrioritizerService.h
+++ b/libminifi/include/controllers/NetworkPrioritizerService.h
@@ -51,7 +51,7 @@ class NetworkPrioritizerService : public core::controller::ControllerServiceBase
public:
using ControllerServiceBase::ControllerServiceBase;
- explicit NetworkPrioritizerService(core::controller::ControllerServiceMetadata metadata,
+ explicit NetworkPrioritizerService(core::ControllerServiceMetadata metadata,
std::shared_ptr<utils::timeutils::Clock> clock)
: ControllerServiceBase(std::move(metadata)),
clock_(std::move(clock)) {
diff --git a/libminifi/include/core/controller/ControllerService.h b/libminifi/include/core/controller/ControllerService.h
index c80830db7..0dff3a884 100644
--- a/libminifi/include/core/controller/ControllerService.h
+++ b/libminifi/include/core/controller/ControllerService.h
@@ -27,7 +27,7 @@
#include "core/ConfigurableComponentImpl.h"
#include "core/Connectable.h"
#include "minifi-cpp/core/controller/ControllerServiceApi.h"
-#include "minifi-cpp/core/ControllerServiceApiDefinition.h"
+#include "minifi-cpp/core/ControllerServiceTypeDefinition.h"
namespace org::apache::nifi::minifi::core::controller {
@@ -44,6 +44,7 @@ class ControllerService : public ConfigurableComponentImpl, public CoreComponent
public:
explicit ControllerServiceDescriptorImpl(ControllerService& impl): impl_(impl) {}
void setSupportedProperties(std::span<const PropertyReference> properties) override;
+ void setSupportedProperties(std::span<const Property> properties) override;
private:
ControllerService& impl_;
@@ -130,7 +131,7 @@ class ControllerService : public ConfigurableComponentImpl, public CoreComponent
return false;
}
- static constexpr auto ImplementsApis = std::array<ControllerServiceApiDefinition, 0>{};
+ static constexpr auto ImplementsApis = std::array<ControllerServiceTypeDefinition, 0>{};
protected:
std::unique_ptr<ControllerServiceApi> impl_;
@@ -146,6 +147,10 @@ inline void ControllerService::ControllerServiceDescriptorImpl::setSupportedProp
impl_.setSupportedProperties(properties);
}
+inline void ControllerService::ControllerServiceDescriptorImpl::setSupportedProperties(std::span<const Property> properties) {
+ impl_.setSupportedProperties(properties);
+}
+
inline nonstd::expected<std::string, std::error_code> ControllerService::ControllerServiceContextImpl::getProperty(std::string_view name) const {
return impl_.getProperty(name);
}
diff --git a/libminifi/include/utils/CControllerService.h b/libminifi/include/utils/CControllerService.h
new file mode 100644
index 000000000..0d0ea4929
--- /dev/null
+++ b/libminifi/include/utils/CControllerService.h
@@ -0,0 +1,110 @@
+/**
+* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "minifi-c/minifi-c.h"
+#include "minifi-cpp/Exception.h"
+#include "minifi-cpp/core/ControllerServiceMetadata.h"
+#include "minifi-cpp/core/Property.h"
+#include "minifi-cpp/core/controller/ControllerServiceApi.h"
+
+namespace org::apache::nifi::minifi::utils {
+class CControllerService;
+
+
+struct CControllerServiceClassDescription {
+ std::string group_name;
+ std::string name;
+ std::string version;
+
+ std::vector<core::Property> class_properties;
+
+ MinifiControllerServiceCallbacks callbacks;
+};
+
+class CControllerService final : public core::controller::ControllerServiceApi, public core::controller::ControllerServiceInterface {
+ public:
+ CControllerService(CControllerServiceClassDescription class_description, core::ControllerServiceMetadata metadata)
+ : class_description_(std::move(class_description)),
+ metadata_(std::move(metadata)) {
+ MinifiControllerServiceMetadata c_metadata;
+ auto uuid_str = metadata_.uuid.to_string();
+ c_metadata.uuid = MinifiStringView{.data = uuid_str.data(), .length = uuid_str.length()};
+ c_metadata.name = MinifiStringView{.data = metadata_.name.data(), .length = metadata_.name.length()};
+ c_metadata.logger = reinterpret_cast<MinifiLogger*>(&metadata_.logger);
+ impl_ = class_description_.callbacks.create(c_metadata);
+ }
+ CControllerService(CControllerServiceClassDescription class_description, core::ControllerServiceMetadata metadata, gsl::owner<void*> impl)
+ : class_description_(std::move(class_description)),
+ impl_(impl),
+ metadata_(std::move(metadata)) {}
+ ~CControllerService() override {
+ class_description_.callbacks.destroy(impl_);
+ }
+
+ void initialize(core::controller::ControllerServiceDescriptor& descriptor) override {
+ descriptor.setSupportedProperties(std::span(class_description_.class_properties));
+ }
+
+ void onEnable(core::controller::ControllerServiceContext& controller_service_context,
+ const std::shared_ptr<Configure>&,
+ const std::vector<std::shared_ptr<core::controller::ControllerServiceInterface>>&) override {
+ const auto enable_status = class_description_.callbacks.enable(impl_, reinterpret_cast<MinifiControllerServiceContext*>(&controller_service_context));
+ if (enable_status != MINIFI_STATUS_SUCCESS) {
+ throw Exception(PROCESS_SCHEDULE_EXCEPTION, "Could not enable controller service");
+ }
+ }
+
+ void notifyStop() override {
+ class_description_.callbacks.notifyStop(impl_);
+ }
+
+ ControllerServiceInterface* getControllerServiceInterface() override {
+ return this;
+ }
+
+ [[nodiscard]] std::string getName() const {
+ return metadata_.name;
+ }
+
+ [[nodiscard]] Identifier getUUID() const {
+ return metadata_.uuid;
+ }
+
+ [[nodiscard]] void* getImpl() const {
+ return this->impl_;
+ }
+
+ [[nodiscard]] const CControllerServiceClassDescription& getClassDescription() const {
+ return class_description_;
+ }
+
+ private:
+ CControllerServiceClassDescription class_description_;
+ gsl::owner<void*> impl_;
+ minifi::core::ControllerServiceMetadata metadata_;
+};
+
+void useCControllerServiceClassDescription(const MinifiControllerServiceClassDefinition& class_description,
+ const BundleIdentifier& bundle_id,
+ const std::function<void(ClassDescription, CControllerServiceClassDescription)>& fn);
+
+} // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/CProcessor.h b/libminifi/include/utils/CProcessor.h
index bef73d9e9..6b8e6660e 100644
--- a/libminifi/include/utils/CProcessor.h
+++ b/libminifi/include/utils/CProcessor.h
@@ -18,6 +18,7 @@
#pragma once
#include <string>
+#include <utility>
#include "minifi-cpp/core/Annotation.h"
#include "core/ProcessorMetrics.h"
@@ -63,18 +64,18 @@ class CProcessor : public minifi::core::ProcessorApi {
CProcessor(CProcessorClassDescription class_description, minifi::core::ProcessorMetadata metadata)
: class_description_(std::move(class_description)),
metrics_extension_(std::make_shared<CProcessorMetricsWrapper>(*this)) {
- metadata_ = metadata;
+ metadata_ = std::move(metadata);
MinifiProcessorMetadata c_metadata;
- auto uuid_str = metadata.uuid.to_string();
+ const auto uuid_str = metadata.uuid.to_string();
c_metadata.uuid = MinifiStringView{.data = uuid_str.data(), .length = uuid_str.length()};
- c_metadata.name = MinifiStringView{.data = metadata.name.data(), .length = metadata.name.length()};
+ c_metadata.name = MinifiStringView{.data = metadata_.name.data(), .length = metadata_.name.length()};
c_metadata.logger = reinterpret_cast<MinifiLogger*>(&metadata_.logger);
impl_ = class_description_.callbacks.create(c_metadata);
}
CProcessor(CProcessorClassDescription class_description, minifi::core::ProcessorMetadata metadata, gsl::owner<void*> impl)
: class_description_(std::move(class_description)),
impl_(impl),
- metadata_(metadata),
+ metadata_(std::move(metadata)),
metrics_extension_(std::make_shared<CProcessorMetricsWrapper>(*this)) {}
~CProcessor() override {
class_description_.callbacks.destroy(impl_);
diff --git a/libminifi/src/controllers/SSLContextService.cpp b/libminifi/src/controllers/SSLContextService.cpp
index 584b5109d..5d7cfc72e 100644
--- a/libminifi/src/controllers/SSLContextService.cpp
+++ b/libminifi/src/controllers/SSLContextService.cpp
@@ -598,7 +598,7 @@ void SSLContextService::verifyCertificateExpiration() {
std::shared_ptr<SSLContextService> SSLContextService::createAndEnable(std::string_view name, const std::shared_ptr<Configure>& configuration) {
auto uuid = utils::IdGenerator::getIdGenerator()->generate();
auto logger = core::logging::LoggerFactory<SSLContextService>::getLogger(uuid);
- auto service = std::make_shared<core::controller::ControllerService>(name, uuid, std::make_unique<SSLContextService>(core::controller::ControllerServiceMetadata{
+ auto service = std::make_shared<core::controller::ControllerService>(name, uuid, std::make_unique<SSLContextService>(core::ControllerServiceMetadata{
.uuid = uuid,
.name = std::string{name},
.logger = logger,
diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp
index 6a2d947ab..9c85a26bb 100644
--- a/libminifi/src/minifi-c.cpp
+++ b/libminifi/src/minifi-c.cpp
@@ -37,11 +37,16 @@
#include "core/extension/ExtensionManager.h"
#include "utils/PropertyErrors.h"
#include "utils/CProcessor.h"
+#include "utils/CControllerService.h"
namespace minifi = org::apache::nifi::minifi;
namespace {
+MinifiStringView minifiStringView(const std::string_view s) {
+ return MinifiStringView{.data = s.data(), .length = s.size()};
+}
+
std::string toString(MinifiStringView sv) {
return {sv.data, sv.length};
}
@@ -146,6 +151,37 @@ class CProcessorFactory : public minifi::core::ProcessorFactory {
minifi::utils::CProcessorClassDescription class_description_;
};
+class CControllerServiceFactory : public minifi::core::controller::ControllerServiceFactory {
+ public:
+ CControllerServiceFactory(std::string group_name, std::string class_name, minifi::utils::CControllerServiceClassDescription class_description)
+ : group_name_(std::move(group_name)),
+ class_name_(std::move(class_name)),
+ class_description_(std::move(class_description)) {}
+ std::unique_ptr<minifi::core::controller::ControllerServiceApi> create(minifi::core::ControllerServiceMetadata metadata) override {
+ return std::make_unique<minifi::utils::CControllerService>(class_description_, std::move(metadata));
+ }
+
+ [[nodiscard]] std::string getGroupName() const override {
+ return group_name_;
+ }
+
+ [[nodiscard]] std::string getClassName() const override {
+ return class_name_;
+ }
+
+ CControllerServiceFactory() = delete;
+ CControllerServiceFactory(const CControllerServiceFactory&) = delete;
+ CControllerServiceFactory& operator=(const CControllerServiceFactory&) = delete;
+ CControllerServiceFactory(CControllerServiceFactory&&) = delete;
+ CControllerServiceFactory& operator=(CControllerServiceFactory&&) = delete;
+ ~CControllerServiceFactory() override = default;
+
+ private:
+ std::string group_name_;
+ std::string class_name_;
+ minifi::utils::CControllerServiceClassDescription 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);
@@ -162,6 +198,14 @@ MinifiExtension* MinifiCreateExtensionImpl(MinifiStringView /*api_version*/, con
bundle_components.processors.emplace_back(description);
});
}
+ for (size_t controller_service_idx = 0; controller_service_idx < extension_create_info->controller_services_count; ++controller_service_idx) {
+ minifi::utils::useCControllerServiceClassDescription(extension_create_info->controller_services_ptr[controller_service_idx], bundle, [&](const auto& description, const auto& c_class_description) {
+ minifi::core::ClassLoader::getDefaultClassLoader().getClassLoader(extension_name).registerClass(
+ c_class_description.name,
+ std::make_unique<CControllerServiceFactory>(extension_name, toString(extension_create_info->controller_services_ptr[controller_service_idx].full_name), c_class_description));
+ bundle_components.controller_services.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),
@@ -245,6 +289,35 @@ void useCProcessorClassDescription(const MinifiProcessorClassDefinition& class_d
fn(description, c_class_description);
}
+void useCControllerServiceClassDescription(const MinifiControllerServiceClassDefinition& class_description,
+ const BundleIdentifier& bundle_id,
+ const std::function<void(ClassDescription, CControllerServiceClassDescription)>& fn) {
+ std::vector<minifi::core::Property> properties;
+ properties.reserve(class_description.class_properties_count);
+ for (size_t i = 0; i < class_description.class_properties_count; ++i) {
+ properties.push_back(createProperty(&class_description.class_properties_ptr[i]));
+ }
+
+ auto name_segments = minifi::utils::string::split(toStringView(class_description.full_name), "::");
+ gsl_Assert(!name_segments.empty());
+
+ minifi::ClassDescription description{
+ .type_ = minifi::ResourceType::ControllerService,
+ .short_name_ = name_segments.back(),
+ .full_name_ = minifi::utils::string::join(".", name_segments),
+ .description_ = toString(class_description.description),
+ .class_properties_ = properties,
+ };
+
+ minifi::utils::CControllerServiceClassDescription c_class_description{
+ .group_name = bundle_id.name,
+ .name = name_segments.back(),
+ .version = bundle_id.version,
+ .class_properties = properties,
+ .callbacks = class_description.callbacks
+ };
+ fn(description, c_class_description);
+}
} // namespace org::apache::nifi::minifi::utils
extern "C" {
@@ -266,7 +339,7 @@ MinifiStatus MinifiProcessContextGetProperty(MinifiProcessContext* context, Mini
auto result = reinterpret_cast<minifi::core::ProcessContext*>(context)->getProperty(toStringView(property_name),
flowfile != MINIFI_NULL ? reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile)->get() : nullptr);
if (result) {
- result_cb(user_ctx, MinifiStringView{.data = result.value().data(), .length = result.value().length()});
+ result_cb(user_ctx, minifiStringView(result.value()));
return MINIFI_STATUS_SUCCESS;
}
switch (static_cast<minifi::core::PropertyErrorCode>(result.error().value())) {
@@ -281,7 +354,7 @@ MinifiStatus MinifiProcessContextGetProperty(MinifiProcessContext* context, Mini
void MinifiProcessContextGetProcessorName(MinifiProcessContext* context, void(*cb)(void* user_ctx, MinifiStringView result), void* user_ctx) {
gsl_Assert(context != MINIFI_NULL);
auto name = reinterpret_cast<minifi::core::ProcessContext*>(context)->getProcessorInfo().getName();
- cb(user_ctx, MinifiStringView{.data = name.data(), .length = name.length()});
+ cb(user_ctx, minifiStringView(name));
}
MinifiBool MinifiProcessContextHasNonEmptyProperty(MinifiProcessContext* context, MinifiStringView property_name) {
@@ -293,10 +366,7 @@ void MinifiConfigGet(MinifiConfig* configure, MinifiStringView key, void(*cb)(vo
gsl_Assert(configure != MINIFI_NULL);
auto value = reinterpret_cast<minifi::Configure*>(configure)->get(toString(key));
if (value) {
- cb(user_ctx, MinifiStringView{
- .data = value->data(),
- .length = value->length()
- });
+ cb(user_ctx, minifiStringView(*value));
}
}
@@ -420,7 +490,7 @@ void MinifiStatusToString(MinifiStatus status, void(*cb)(void* user_ctx, MinifiS
default: return "Unknown error";
}
}();
- cb(user_ctx, MinifiStringView{.data = message.data(), .length = message.size()});
+ cb(user_ctx, minifiStringView(message));
}
void MinifiFlowFileSetAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, const MinifiStringView* attribute_value) {
@@ -442,7 +512,7 @@ MinifiBool MinifiFlowFileGetAttribute(MinifiProcessSession* session, MinifiFlowF
if (!value.has_value()) {
return false;
}
- cb(user_ctx, MinifiStringView{.data = value->data(), .length = value->size()});
+ cb(user_ctx, minifiStringView(*value));
return true;
}
@@ -451,8 +521,58 @@ void MinifiFlowFileGetAttributes(MinifiProcessSession* session, MinifiFlowFile*
gsl_Assert(session != MINIFI_NULL);
gsl_Assert(flowfile != MINIFI_NULL);
for (auto& [key, value] : (*reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile))->getAttributes()) {
- cb(user_ctx, MinifiStringView{.data = key.data(), .length = key.size()}, MinifiStringView{.data = value.data(), .length = value.size()});
+ cb(user_ctx, minifiStringView(key), minifiStringView(value));
}
}
+MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceContext* context, MinifiStringView property_name,
+ void (*result_cb)(void* user_ctx, MinifiStringView result), void* user_ctx) {
+ gsl_Assert(context != MINIFI_NULL);
+ auto result = reinterpret_cast<minifi::core::controller::ControllerServiceContext*>(context)->getProperty(toStringView(property_name));
+ if (result) {
+ result_cb(user_ctx, minifiStringView(result.value()));
+ return MINIFI_STATUS_SUCCESS;
+ }
+ switch (static_cast<minifi::core::PropertyErrorCode>(result.error().value())) {
+ case minifi::core::PropertyErrorCode::NotSupportedProperty: return MINIFI_STATUS_NOT_SUPPORTED_PROPERTY;
+ case minifi::core::PropertyErrorCode::DynamicPropertiesNotSupported: return MINIFI_STATUS_DYNAMIC_PROPERTIES_NOT_SUPPORTED;
+ case minifi::core::PropertyErrorCode::PropertyNotSet: return MINIFI_STATUS_PROPERTY_NOT_SET;
+ case minifi::core::PropertyErrorCode::ValidationFailed: return MINIFI_STATUS_VALIDATION_FAILED;
+ default: return MINIFI_STATUS_UNKNOWN_ERROR;
+ }
+}
+
+
+MinifiStatus MinifiProcessContextGetControllerService(
+ MinifiProcessContext* process_context,
+ MinifiStringView controller_service_name,
+ void(*cb)(
+ void* user_ctx,
+ void* service,
+ MinifiStringView type,
+ MinifiStringView group,
+ MinifiStringView version),
+ void* user_ctx) {
+
+ gsl_Assert(process_context != MINIFI_NULL);
+ const auto context = reinterpret_cast<minifi::core::ProcessContext*>(process_context);
+ const auto name_str = std::string{toStringView(controller_service_name)};
+ const auto service_shared_ptr = context->getControllerService(name_str, context->getProcessorInfo().getUUID());
+ if (!service_shared_ptr) {
+ return MINIFI_STATUS_UNKNOWN_ERROR;
+ }
+ const minifi::utils::CControllerService* c_controller_service = dynamic_cast<minifi::utils::CControllerService*>(&*service_shared_ptr);
+ if (c_controller_service) {
+ const auto class_description = c_controller_service->getClassDescription();
+ cb(user_ctx,
+ c_controller_service->getImpl(),
+ minifiStringView(class_description.group_name),
+ minifiStringView(class_description.name),
+ minifiStringView(class_description.version));
+ return MINIFI_STATUS_SUCCESS;
+ }
+ return MINIFI_STATUS_UNKNOWN_ERROR; // TODO(mzink) better error handling
+}
+
+
} // extern "C"
diff --git a/libminifi/src/properties/Properties.cpp b/libminifi/src/properties/Properties.cpp
index 1624a8557..2f5723a64 100644
--- a/libminifi/src/properties/Properties.cpp
+++ b/libminifi/src/properties/Properties.cpp
@@ -22,6 +22,7 @@
#include <string>
#include "core/logging/LoggerConfiguration.h"
+#include "minifi-cpp/core/PropertyValidator.h"
#include "properties/Configuration.h"
#include "properties/PropertiesFile.h"
#include "utils/StringUtils.h"
diff --git a/libminifi/test/libtest/integration/HTTPHandlers.h b/libminifi/test/libtest/integration/HTTPHandlers.h
index 25a0dba5d..40304948a 100644
--- a/libminifi/test/libtest/integration/HTTPHandlers.h
+++ b/libminifi/test/libtest/integration/HTTPHandlers.h
@@ -21,21 +21,22 @@
#include <map>
#include <memory>
#include <optional>
+#include <set>
#include <string>
+#include <unordered_map>
#include <utility>
#include <vector>
-#include <set>
-#include <unordered_map>
-#include "civetweb.h"
#include "CivetServer.h"
-#include "concurrentqueue.h"
-#include "rapidjson/document.h"
-#include "utils/HTTPUtils.h"
#include "ServerAwareHandler.h"
#include "c2/C2Payload.h"
+#include "civetweb.h"
+#include "concurrentqueue.h"
+#include "minifi-cpp/properties/Configure.h"
#include "properties/Configure.h"
+#include "rapidjson/document.h"
#include "unit/Catch.h"
+#include "utils/HTTPUtils.h"
namespace org::apache::nifi::minifi::test {
diff --git a/libminifi/test/libtest/unit/ControllerServiceUtils.h b/libminifi/test/libtest/unit/ControllerServiceUtils.h
index ff19982d3..ee8d79c37 100644
--- a/libminifi/test/libtest/unit/ControllerServiceUtils.h
+++ b/libminifi/test/libtest/unit/ControllerServiceUtils.h
@@ -29,7 +29,7 @@ std::unique_ptr<core::controller::ControllerService> make_controller_service(std
if (!uuid) {
uuid = minifi::utils::IdGenerator::getIdGenerator()->generate();
}
- auto processor_impl = std::make_unique<T>(core::controller::ControllerServiceMetadata{
+ auto processor_impl = std::make_unique<T>(core::ControllerServiceMetadata{
.uuid = uuid.value(),
.name = std::string{name},
.logger = minifi::core::logging::LoggerFactory<T>::getLogger(uuid.value())
diff --git a/libminifi/test/unit/NetworkPrioritizerServiceTests.cpp b/libminifi/test/unit/NetworkPrioritizerServiceTests.cpp
index a54ba109a..a05d21ad2 100644
--- a/libminifi/test/unit/NetworkPrioritizerServiceTests.cpp
+++ b/libminifi/test/unit/NetworkPrioritizerServiceTests.cpp
@@ -31,7 +31,7 @@ std::shared_ptr<core::controller::ControllerService> createNetworkPrioritizerSer
const std::shared_ptr<utils::timeutils::Clock>& clock = std::make_shared<minifi::test::utils::ManualClock>()) {
return std::make_shared<core::controller::ControllerService>(
name, utils::Identifier{},
- std::make_unique<minifi::controllers::NetworkPrioritizerService>(core::controller::ControllerServiceMetadata{
+ std::make_unique<minifi::controllers::NetworkPrioritizerService>(core::ControllerServiceMetadata{
.uuid = utils::Identifier{},
.name = name,
.logger = logging::LoggerFactory<minifi::controllers::NetworkPrioritizerService>::getLogger()
diff --git a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceMetadata.h b/minifi-api/common/include/minifi-cpp/core/ControllerServiceMetadata.h
similarity index 84%
rename from minifi-api/include/minifi-cpp/core/controller/ControllerServiceMetadata.h
rename to minifi-api/common/include/minifi-cpp/core/ControllerServiceMetadata.h
index 3c6fb63b7..22200a84d 100644
--- a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceMetadata.h
+++ b/minifi-api/common/include/minifi-cpp/core/ControllerServiceMetadata.h
@@ -1,5 +1,5 @@
/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
+* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
@@ -21,7 +21,7 @@
#include "minifi-cpp/utils/Id.h"
#include "minifi-cpp/core/logging/Logger.h"
-namespace org::apache::nifi::minifi::core::controller {
+namespace org::apache::nifi::minifi::core {
struct ControllerServiceMetadata {
utils::Identifier uuid;
@@ -29,4 +29,4 @@ struct ControllerServiceMetadata {
std::shared_ptr<logging::Logger> logger;
};
-} // namespace org::apache::nifi::minifi::core::controller
+} // namespace org::apache::nifi::minifi::core
diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h
index 97af61f5b..811bd73ec 100644
--- a/minifi-api/include/minifi-c/minifi-c.h
+++ b/minifi-api/include/minifi-c/minifi-c.h
@@ -96,6 +96,8 @@ typedef struct MinifiExtension MinifiExtension;
typedef struct MinifiPublishedMetrics MinifiPublishedMetrics;
typedef struct MinifiApiVersion MinifiApiVersion;
+typedef struct MinifiControllerServiceContext MinifiControllerServiceContext;
+
typedef enum MinifiStatus {
MINIFI_STATUS_SUCCESS = 0,
MINIFI_STATUS_UNKNOWN_ERROR = 1,
@@ -149,6 +151,12 @@ typedef struct MinifiProcessorMetadata {
MinifiLogger* logger; // borrowed reference, live until the processor is live
} MinifiProcessorMetadata;
+typedef struct MinifiControllerServiceMetadata {
+ MinifiStringView uuid;
+ MinifiStringView name;
+ MinifiLogger* logger; // borrowed reference, live until the controller service is live
+} MinifiControllerServiceMetadata;
+
typedef struct MinifiProcessorCallbacks {
MINIFI_OWNED void*(*create)(MinifiProcessorMetadata);
void(*destroy)(MINIFI_OWNED void*);
@@ -161,6 +169,13 @@ typedef struct MinifiProcessorCallbacks {
MINIFI_OWNED MinifiPublishedMetrics*(*calculateMetrics)(void*);
} MinifiProcessorCallbacks;
+typedef struct MinifiControllerServiceCallbacks {
+ MINIFI_OWNED void*(*create)(MinifiControllerServiceMetadata);
+ void(*destroy)(MINIFI_OWNED void*);
+ MinifiStatus(*enable)(void*, MinifiControllerServiceContext*);
+ void(*notifyStop)(void*);
+} MinifiControllerServiceCallbacks;
+
typedef struct MinifiProcessorClassDefinition {
MinifiStringView full_name; // '::'-delimited fully qualified name e.g. 'org::apache::nifi::minifi::GenerateFlowFile'
MinifiStringView description;
@@ -180,6 +195,16 @@ typedef struct MinifiProcessorClassDefinition {
MinifiProcessorCallbacks callbacks;
} MinifiProcessorClassDefinition;
+typedef struct MinifiControllerServiceClassDefinition {
+ MinifiStringView full_name; // '::'-delimited fully qualified name e.g. 'org::apache::nifi::minifi::extensions::gcp::GCPCredentialsControllerService
+ MinifiStringView description;
+ size_t class_properties_count;
+ const MinifiPropertyDefinition* class_properties_ptr;
+
+ MinifiControllerServiceCallbacks callbacks;
+} MinifiControllerServiceClassDefinition;
+
+
typedef struct MinifiExtensionCreateInfo {
MinifiStringView name;
MinifiStringView version;
@@ -187,6 +212,8 @@ typedef struct MinifiExtensionCreateInfo {
void* user_data;
size_t processors_count;
const MinifiProcessorClassDefinition* processors_ptr;
+ size_t controller_services_count;
+ const MinifiControllerServiceClassDefinition* controller_services_ptr;
} MinifiExtensionCreateInfo;
// api_version is used to provide backwards compatible changes to the MinifiExtensionCreateInfo structure,
@@ -201,6 +228,9 @@ MinifiStatus MinifiProcessContextGetProperty(MinifiProcessContext* context, Mini
void MinifiProcessContextGetProcessorName(MinifiProcessContext* context, void(*cb)(void* user_ctx, MinifiStringView processor_name), void* user_ctx);
MinifiBool MinifiProcessContextHasNonEmptyProperty(MinifiProcessContext* context, MinifiStringView property_name);
+MinifiStatus MinifiProcessContextGetControllerService(MinifiProcessContext*, MinifiStringView controller_service_name,
+ void(*cb)(void* user_ctx, void* service, MinifiStringView type, MinifiStringView group, MinifiStringView version), void* user_ctx);
+
void MinifiLoggerSetMaxLogSize(MinifiLogger*, int32_t);
void MinifiLoggerLogString(MinifiLogger*, MinifiLogLevel, MinifiStringView);
MinifiBool MinifiLoggerShouldLog(MinifiLogger*, MinifiLogLevel);
@@ -229,6 +259,11 @@ MinifiBool MinifiFlowFileGetAttribute(MinifiProcessSession* session, MinifiFlowF
void(*cb)(void* user_ctx, MinifiStringView attribute_value), void* user_ctx);
void MinifiFlowFileGetAttributes(MinifiProcessSession* session, MinifiFlowFile* flowfile, void(*cb)(void* user_ctx, MinifiStringView attribute_name, MinifiStringView attribute_value), void* user_ctx);
+MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceContext* context,
+ MinifiStringView property_name,
+ void(*cb)(void* user_ctx, MinifiStringView property_value),
+ void* user_ctx);
+
#ifdef __cplusplus
} // extern "C"
#endif // __cplusplus
diff --git a/minifi-api/include/minifi-cpp/agent/agent_docs.h b/minifi-api/include/minifi-cpp/agent/agent_docs.h
index 912377d39..b6a6b9017 100644
--- a/minifi-api/include/minifi-cpp/agent/agent_docs.h
+++ b/minifi-api/include/minifi-cpp/agent/agent_docs.h
@@ -22,7 +22,7 @@
#include <vector>
#include "minifi-cpp/core/Annotation.h"
-#include "minifi-cpp/core/ControllerServiceApi.h"
+#include "minifi-cpp/core/ControllerServiceType.h"
#include "minifi-cpp/core/DynamicProperty.h"
#include "minifi-cpp/core/OutputAttribute.h"
#include "minifi-cpp/core/Property.h"
@@ -44,7 +44,7 @@ struct ClassDescription {
std::vector<core::DynamicProperty> dynamic_properties_{};
std::vector<core::Relationship> class_relationships_{};
std::vector<core::OutputAttribute> output_attributes_{};
- std::vector<core::ControllerServiceApi> api_implementations{};
+ std::vector<core::ControllerServiceType> api_implementations{};
bool supports_dynamic_properties_ = false;
bool supports_dynamic_relationships_ = false;
std::string inputRequirement_{};
diff --git a/minifi-api/include/minifi-cpp/controllers/RecordSetReader.h b/minifi-api/include/minifi-cpp/controllers/RecordSetReader.h
index f91dee361..2b8b8731d 100644
--- a/minifi-api/include/minifi-cpp/controllers/RecordSetReader.h
+++ b/minifi-api/include/minifi-cpp/controllers/RecordSetReader.h
@@ -17,7 +17,7 @@
#pragma once
#include "minifi-cpp/core/controller/ControllerServiceInterface.h"
-#include "minifi-cpp/core/ControllerServiceApiDefinition.h"
+#include "minifi-cpp/core/ControllerServiceTypeDefinition.h"
#include "minifi-cpp/core/Record.h"
#include "utils/Enum.h"
#include "utils/ProcessorConfigUtils.h"
@@ -28,7 +28,7 @@ namespace org::apache::nifi::minifi::core {
class RecordSetReader : public controller::ControllerServiceInterface {
public:
- static constexpr auto ProvidesApi = core::ControllerServiceApiDefinition{
+ static constexpr auto ProvidesApi = core::ControllerServiceTypeDefinition{
.artifact = "minifi-system",
.group = "org.apache.nifi.minifi",
.type = "org.apache.nifi.minifi.core.RecordSetReader",
diff --git a/minifi-api/include/minifi-cpp/controllers/RecordSetWriter.h b/minifi-api/include/minifi-cpp/controllers/RecordSetWriter.h
index bbe1ebdde..8453f2215 100644
--- a/minifi-api/include/minifi-cpp/controllers/RecordSetWriter.h
+++ b/minifi-api/include/minifi-cpp/controllers/RecordSetWriter.h
@@ -18,7 +18,7 @@
#include "minifi-cpp/core/controller/ControllerServiceInterface.h"
-#include "minifi-cpp/core/ControllerServiceApiDefinition.h"
+#include "minifi-cpp/core/ControllerServiceTypeDefinition.h"
#include "minifi-cpp/core/FlowFile.h"
#include "minifi-cpp/core/ProcessSession.h"
#include "minifi-cpp/core/Record.h"
@@ -28,7 +28,7 @@ namespace org::apache::nifi::minifi::core {
class RecordSetWriter : public controller::ControllerServiceInterface {
public:
- static constexpr auto ProvidesApi = core::ControllerServiceApiDefinition{
+ static constexpr auto ProvidesApi = core::ControllerServiceTypeDefinition{
.artifact = "minifi-system",
.group = "org.apache.nifi.minifi",
.type = "org.apache.nifi.minifi.core.RecordSetWriter",
diff --git a/minifi-api/include/minifi-cpp/controllers/SSLContextServiceInterface.h b/minifi-api/include/minifi-cpp/controllers/SSLContextServiceInterface.h
index 68d79380b..3058ade0b 100644
--- a/minifi-api/include/minifi-cpp/controllers/SSLContextServiceInterface.h
+++ b/minifi-api/include/minifi-cpp/controllers/SSLContextServiceInterface.h
@@ -16,12 +16,12 @@
*/
#pragma once
-#include <iostream>
+#include <filesystem>
#include <memory>
#include <string>
#include <utility>
-#include "minifi-cpp/core/ControllerServiceApiDefinition.h"
+#include "minifi-cpp/core/ControllerServiceTypeDefinition.h"
#include "minifi-cpp/agent/agent_version.h"
#include "minifi-cpp/core/controller/ControllerServiceInterface.h"
@@ -37,7 +37,7 @@ namespace org::apache::nifi::minifi::controllers {
*/
class SSLContextServiceInterface : public core::controller::ControllerServiceInterface {
public:
- static constexpr auto ProvidesApi = core::ControllerServiceApiDefinition{
+ static constexpr auto ProvidesApi = core::ControllerServiceTypeDefinition{
.artifact = "minifi-system",
.group = "org.apache.nifi.minifi",
.type = "org.apache.nifi.minifi.controllers.SSLContextServiceInterface",
diff --git a/minifi-api/include/minifi-cpp/core/ControllerServiceApi.h b/minifi-api/include/minifi-cpp/core/ControllerServiceType.h
similarity index 84%
rename from minifi-api/include/minifi-cpp/core/ControllerServiceApi.h
rename to minifi-api/include/minifi-cpp/core/ControllerServiceType.h
index fe0d450f7..6d5b39de3 100644
--- a/minifi-api/include/minifi-cpp/core/ControllerServiceApi.h
+++ b/minifi-api/include/minifi-cpp/core/ControllerServiceType.h
@@ -17,16 +17,16 @@
#pragma once
#include <string>
-#include "minifi-cpp/core/ControllerServiceApiDefinition.h"
+#include "minifi-cpp/core/ControllerServiceTypeDefinition.h"
namespace org::apache::nifi::minifi::core {
-struct ControllerServiceApi {
+struct ControllerServiceType {
std::string artifact;
std::string group;
std::string type;
- ControllerServiceApi(const ControllerServiceApiDefinition& definition) // NOLINT(runtime/explicit)
+ ControllerServiceType(const ControllerServiceTypeDefinition& definition) // NOLINT(runtime/explicit)
: artifact(definition.artifact),
group(definition.group),
type(definition.type) {}
diff --git a/minifi-api/include/minifi-cpp/core/ControllerServiceApiDefinition.h b/minifi-api/include/minifi-cpp/core/ControllerServiceTypeDefinition.h
similarity index 96%
rename from minifi-api/include/minifi-cpp/core/ControllerServiceApiDefinition.h
rename to minifi-api/include/minifi-cpp/core/ControllerServiceTypeDefinition.h
index 37084baea..f40d871a6 100644
--- a/minifi-api/include/minifi-cpp/core/ControllerServiceApiDefinition.h
+++ b/minifi-api/include/minifi-cpp/core/ControllerServiceTypeDefinition.h
@@ -20,7 +20,7 @@
namespace org::apache::nifi::minifi::core {
-struct ControllerServiceApiDefinition {
+struct ControllerServiceTypeDefinition {
std::string_view artifact;
std::string_view group;
std::string_view type;
diff --git a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceDescriptor.h b/minifi-api/include/minifi-cpp/core/controller/ControllerServiceDescriptor.h
index 525a6d6ce..39fb6da89 100644
--- a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceDescriptor.h
+++ b/minifi-api/include/minifi-cpp/core/controller/ControllerServiceDescriptor.h
@@ -26,6 +26,7 @@ class ControllerServiceDescriptor {
virtual ~ControllerServiceDescriptor() = default;
virtual void setSupportedProperties(std::span<const PropertyReference> properties) = 0;
+ virtual void setSupportedProperties(std::span<const Property> properties) = 0;
};
} // namespace org::apache::nifi::minifi::core::controller
diff --git a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceFactory.h b/minifi-api/include/minifi-cpp/core/controller/ControllerServiceFactory.h
index 725944bfa..aafc571dc 100644
--- a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceFactory.h
+++ b/minifi-api/include/minifi-cpp/core/controller/ControllerServiceFactory.h
@@ -17,10 +17,11 @@
#pragma once
-#include <string>
#include <memory>
+#include <string>
#include <utility>
-#include "minifi-cpp/core/controller/ControllerServiceMetadata.h"
+
+#include "minifi-cpp/core/ControllerServiceMetadata.h"
namespace org::apache::nifi::minifi::core::controller {
diff --git a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceInterface.h b/minifi-api/include/minifi-cpp/core/controller/ControllerServiceInterface.h
index e1d7da19e..799446f69 100644
--- a/minifi-api/include/minifi-cpp/core/controller/ControllerServiceInterface.h
+++ b/minifi-api/include/minifi-cpp/core/controller/ControllerServiceInterface.h
@@ -17,23 +17,8 @@
*/
#pragma once
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "minifi-cpp/properties/Configure.h"
-#include "minifi-cpp/core/ConfigurableComponent.h"
-#include "minifi-cpp/core/Connectable.h"
-
namespace org::apache::nifi::minifi::core::controller {
-/**
- * Controller Service base class that contains some pure virtual methods.
- *
- * Design: OnEnable is executed when the controller service is being enabled.
- * Note that keeping state here must be protected in this function.
- */
class ControllerServiceInterface {
public:
virtual ~ControllerServiceInterface() = default;
diff --git a/minifi-api/minifi-c-api.def b/minifi-api/minifi-c-api.def
index d7faf9426..de4b384b0 100644
--- a/minifi-api/minifi-c-api.def
+++ b/minifi-api/minifi-c-api.def
@@ -2,9 +2,11 @@ LIBRARY core-minifi.dll
EXPORTS
MinifiCreateExtension_0_1
MinifiPublishedMetricsCreate
+ MinifiProcessContextGetControllerService
MinifiProcessContextGetProperty
MinifiProcessContextGetProcessorName
MinifiProcessContextHasNonEmptyProperty
+ MinifiControllerServiceContextGetProperty
MinifiLoggerSetMaxLogSize
MinifiLoggerLogString
MinifiLoggerShouldLog