From fe0ed608829ccd43b7aa79a7fbf75e68a3662674 Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Wed, 1 Apr 2026 13:03:10 +0200 Subject: [PATCH 1/7] MINIFICPP-2797 Extend C Api for Kafka --- .../src/core/ProcessSession.cpp | 10 +-- libminifi/src/minifi-c.cpp | 80 ++++++++++++++++--- minifi-api/include/minifi-c/minifi-c.h | 25 +++++- minifi-api/minifi-c-api.def | 11 ++- 4 files changed, 105 insertions(+), 21 deletions(-) diff --git a/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp b/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp index cc7ab50e1d..8b13b09c2a 100644 --- a/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp +++ b/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp @@ -118,20 +118,20 @@ void ProcessSession::read(FlowFile& flow_file, const io::InputStreamCallback& ca void ProcessSession::setAttribute(FlowFile& ff, const std::string_view key, std::string value) { // NOLINT(performance-unnecessary-value-param) const MinifiStringView value_ref = utils::toStringView(value); - if (MINIFI_STATUS_SUCCESS != MinifiFlowFileSetAttribute(impl_, ff.get(), utils::toStringView(key), &value_ref)) { + if (MINIFI_STATUS_SUCCESS != MinifiProcessSessionSetFlowFileAttribute(impl_, ff.get(), utils::toStringView(key), &value_ref)) { throw minifi::Exception(minifi::FILE_OPERATION_EXCEPTION, "Failed to set attribute"); } } void ProcessSession::removeAttribute(FlowFile& ff, const std::string_view key) { - if (MINIFI_STATUS_SUCCESS != MinifiFlowFileSetAttribute(impl_, ff.get(), utils::toStringView(key), nullptr)) { + if (MINIFI_STATUS_SUCCESS != MinifiProcessSessionSetFlowFileAttribute(impl_, ff.get(), utils::toStringView(key), nullptr)) { throw minifi::Exception(minifi::FILE_OPERATION_EXCEPTION, "Failed to remove attribute"); } } std::optional ProcessSession::getAttribute(FlowFile& ff, std::string_view key) { std::optional result; - MinifiFlowFileGetAttribute(impl_, ff.get(), utils::toStringView(key), [] (void* user_ctx, MinifiStringView value) { + MinifiProcessSessionGetFlowFileAttribute(impl_, ff.get(), utils::toStringView(key), [] (void* user_ctx, MinifiStringView value) { *static_cast*>(user_ctx) = std::string{value.data, value.length}; }, &result); return result; @@ -139,8 +139,8 @@ std::optional ProcessSession::getAttribute(FlowFile& ff, std::strin std::map ProcessSession::getAttributes(FlowFile& ff) { std::map result; - MinifiFlowFileGetAttributes(impl_, ff.get(), [] (void* user_ctx, MinifiStringView value, MinifiStringView key) { - static_cast*>(user_ctx)->insert({std::string{value.data, value.length}, std::string{key.data, key.length}}); + MinifiProcessSessionGetFlowFileAttributes(impl_, ff.get(), [] (void* user_ctx, const MinifiStringView key, const MinifiStringView value) { + static_cast*>(user_ctx)->insert({std::string{key.data, key.length}, std::string{value.data, value.length}}); }, &result); return result; } diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp index 54a3dba8fb..c96be81c93 100644 --- a/libminifi/src/minifi-c.cpp +++ b/libminifi/src/minifi-c.cpp @@ -24,6 +24,7 @@ #include "core/ProcessorMetrics.h" #include "core/extension/ExtensionManager.h" #include "minifi-cpp/Exception.h" +#include "minifi-cpp/controllers/SSLContextServiceInterface.h" #include "minifi-cpp/core/Annotation.h" #include "minifi-cpp/core/ClassLoader.h" #include "minifi-cpp/core/ProcessContext.h" @@ -35,8 +36,8 @@ #include "minifi-cpp/core/PropertyValidator.h" #include "minifi-cpp/core/logging/Logger.h" #include "minifi-cpp/core/state/PublishedMetricProvider.h" -#include "utils/CProcessor.h" #include "utils/CControllerService.h" +#include "utils/CProcessor.h" #include "utils/PropertyErrors.h" namespace minifi = org::apache::nifi::minifi; @@ -192,7 +193,7 @@ void useCProcessorClassDescription(const MinifiProcessorClassDefinition& class_d std::vector dynamic_properties; dynamic_properties.reserve(class_description.dynamic_properties_count); for (size_t i = 0; i < class_description.dynamic_properties_count; ++i) { - dynamic_properties.push_back(minifi::core::DynamicPropertyDefinition{ + dynamic_properties.emplace_back(minifi::core::DynamicPropertyDefinition{ .name = toStringView(class_description.dynamic_properties_ptr[i].name), .value = toStringView(class_description.dynamic_properties_ptr[i].value), .description = toStringView(class_description.dynamic_properties_ptr[i].description), @@ -202,10 +203,9 @@ void useCProcessorClassDescription(const MinifiProcessorClassDefinition& class_d std::vector relationships; relationships.reserve(class_description.class_relationships_count); for (size_t i = 0; i < class_description.class_relationships_count; ++i) { - relationships.push_back(minifi::core::Relationship{ + relationships.emplace_back( toString(class_description.class_relationships_ptr[i].name), - toString(class_description.class_relationships_ptr[i].description) - }); + toString(class_description.class_relationships_ptr[i].description)); } std::vector output_attributes; for (size_t attribute_idx = 0; attribute_idx < class_description.output_attributes_count; ++attribute_idx) { @@ -265,7 +265,7 @@ void useCControllerServiceClassDescription(const MinifiControllerServiceClassDef auto name_segments = minifi::utils::string::split(toStringView(class_description.full_name), "::"); gsl_Assert(!name_segments.empty()); - minifi::ClassDescription description{ + const minifi::ClassDescription description{ .type_ = minifi::ResourceType::ControllerService, .short_name_ = name_segments.back(), .full_name_ = minifi::utils::string::join(".", name_segments), @@ -435,6 +435,18 @@ MINIFI_OWNED MinifiFlowFile* MinifiProcessSessionCreate(MinifiProcessSession* se return MINIFI_NULL; } +MinifiStatus MinifiProcessSessionPenalize(MinifiProcessSession* session, MinifiFlowFile* flowfile) { + gsl_Assert(session != MINIFI_NULL); + gsl_Assert(flowfile != MINIFI_NULL); + try { + reinterpret_cast(session)->penalize( + *reinterpret_cast*>(flowfile)); + return MINIFI_STATUS_SUCCESS; + } catch (...) { + return MINIFI_STATUS_UNKNOWN_ERROR; + } +} + MinifiStatus MinifiProcessSessionTransfer(MinifiProcessSession* session, MINIFI_OWNED MinifiFlowFile* flowfile, MinifiStringView relationship_name) { gsl_Assert(session != MINIFI_NULL); gsl_Assert(flowfile != MINIFI_NULL); @@ -501,7 +513,7 @@ int64_t MinifiOutputStreamWrite(MinifiOutputStream* stream, const char* data, si return gsl::narrow(reinterpret_cast(stream)->write(as_bytes(std::span(data, size)))); } -MinifiStatus MinifiFlowFileSetAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, const MinifiStringView* attribute_value) { +MinifiStatus MinifiProcessSessionSetFlowFileAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, const MinifiStringView* attribute_value) { gsl_Assert(session != MINIFI_NULL); gsl_Assert(flowfile != MINIFI_NULL); if (attribute_value == nullptr) { @@ -513,7 +525,7 @@ MinifiStatus MinifiFlowFileSetAttribute(MinifiProcessSession* session, MinifiFlo return MINIFI_STATUS_SUCCESS; } -MinifiBool MinifiFlowFileGetAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, +MinifiBool MinifiProcessSessionGetFlowFileAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, void(*cb)(void* user_ctx, MinifiStringView attribute_value), void* user_ctx) { gsl_Assert(session != MINIFI_NULL); gsl_Assert(flowfile != MINIFI_NULL); @@ -525,7 +537,7 @@ MinifiBool MinifiFlowFileGetAttribute(MinifiProcessSession* session, MinifiFlowF return true; } -void MinifiFlowFileGetAttributes(MinifiProcessSession* session, MinifiFlowFile* flowfile, +void MinifiProcessSessionGetFlowFileAttributes(MinifiProcessSession* session, MinifiFlowFile* flowfile, void(*cb)(void* user_ctx, MinifiStringView attribute_name, MinifiStringView attribute_value), void* user_ctx) { gsl_Assert(session != MINIFI_NULL); gsl_Assert(flowfile != MINIFI_NULL); @@ -534,6 +546,20 @@ void MinifiFlowFileGetAttributes(MinifiProcessSession* session, MinifiFlowFile* } } +uint64_t MinifiProcessSessionGetFlowFileSize(MinifiProcessSession* session, MinifiFlowFile* flowfile) { + gsl_Assert(session != MINIFI_NULL); + gsl_Assert(flowfile != MINIFI_NULL); + return (*reinterpret_cast*>(flowfile))->getSize(); +} + +MinifiStatus MinifiProcessSessionGetFlowFileId(MinifiProcessSession* session, MinifiFlowFile* flowfile, void(*cb)(void* user_ctx, MinifiStringView flow_file_id), void* user_ctx) { + gsl_Assert(session != MINIFI_NULL); + gsl_Assert(flowfile != MINIFI_NULL); + const auto uuid_small_str = (*reinterpret_cast*>(flowfile))->getUUIDStr(); + cb(user_ctx, minifiStringView(uuid_small_str.view())); + return MINIFI_STATUS_SUCCESS; +} + MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceContext* context, MinifiStringView property_name, void (*result_cb)(void* user_ctx, MinifiStringView result), void* user_ctx) { gsl_Assert(context != MINIFI_NULL); @@ -551,7 +577,6 @@ MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceCo } } - MinifiStatus MinifiProcessContextGetControllerService( MinifiProcessContext* process_context, const MinifiStringView controller_service_name, @@ -578,5 +603,40 @@ MinifiStatus MinifiProcessContextGetControllerService( return MINIFI_STATUS_VALIDATION_FAILED; } +void MinifiProcessContextGetDynamicProperties(MinifiProcessContext* context, MinifiFlowFile* minifi_flow_file, + void (*cb)(void* user_ctx, MinifiStringView dynamic_property_name, MinifiStringView dynamic_property_value), void* user_ctx) { + gsl_Assert(context != MINIFI_NULL); + auto flow_file = minifi_flow_file != MINIFI_NULL ? reinterpret_cast*>(minifi_flow_file)->get() : nullptr; + for (auto& [key, value] : reinterpret_cast(context)->getDynamicProperties(flow_file)) { + cb(user_ctx, minifiStringView(key), minifiStringView(value)); + } +} + +MinifiStatus MinifiProcessContextGetSslData(MinifiProcessContext* process_context, MinifiStringView controller_service_name, + void (*cb)(void* user_ctx, const MinifiSslData* ssl_data), void* user_ctx) { + gsl_Assert(process_context != MINIFI_NULL); + const auto context = reinterpret_cast(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_VALIDATION_FAILED; } + if (const auto ssl_context_service = dynamic_cast(service_shared_ptr.get())) { + const std::string ca_cert_file = ssl_context_service->getCACertificate().string(); + const std::string passphrase = ssl_context_service->getPassphrase(); + const std::string cert_file = ssl_context_service->getCertificateFile().string(); + const std::string private_key_file = ssl_context_service->getPrivateKeyFile().string(); + + MinifiSslData ssl_data{ + .version = 1, + .ca_certificate = minifiStringView(ca_cert_file), + .certificate_file = minifiStringView(cert_file), + .private_key_file = minifiStringView(private_key_file), + .passphrase = minifiStringView(passphrase), + }; + cb(user_ctx, &ssl_data); + return MINIFI_STATUS_SUCCESS; + } + return MINIFI_STATUS_VALIDATION_FAILED; +} + } // extern "C" diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h index 97c969ab49..0eb80f8d06 100644 --- a/minifi-api/include/minifi-c/minifi-c.h +++ b/minifi-api/include/minifi-c/minifi-c.h @@ -41,6 +41,8 @@ extern "C" { #define MINIFI_REGISTER_EXTENSION_FN MinifiRegisterExtension #endif +#define MINIFI_SSL_CONTEXT_SERVICE_API "org.apache.nifi.minifi.controllers.SSLContextServiceInterface" + enum : uint32_t { MINIFI_API_VERSION = 3 }; @@ -231,6 +233,8 @@ MinifiBool MinifiProcessContextHasNonEmptyProperty(MinifiProcessContext* context MinifiStatus MinifiProcessContextGetControllerService( MinifiProcessContext* process_context, MinifiStringView controller_service_name, MinifiStringView controller_service_type, MinifiControllerService** controller_service_out); +void MinifiProcessContextGetDynamicProperties(MinifiProcessContext* context, MinifiFlowFile* minifi_flow_file, + void (*cb)(void* user_ctx, MinifiStringView dynamic_property_name, MinifiStringView dynamic_property_value), void* user_ctx); void MinifiLoggerSetMaxLogSize(MinifiLogger*, int32_t); void MinifiLoggerLogString(MinifiLogger*, MinifiLogLevel, MinifiStringView); @@ -240,6 +244,7 @@ MinifiLogLevel MinifiLoggerLevel(MinifiLogger*); MINIFI_OWNED MinifiFlowFile* MinifiProcessSessionGet(MinifiProcessSession*); MINIFI_OWNED MinifiFlowFile* MinifiProcessSessionCreate(MinifiProcessSession* session, MinifiFlowFile* parent_flowfile); +MinifiStatus MinifiProcessSessionPenalize(MinifiProcessSession* session, MinifiFlowFile* flowfile); MinifiStatus MinifiProcessSessionTransfer(MinifiProcessSession* session, MINIFI_OWNED MinifiFlowFile* flowfile, MinifiStringView relationship_name); MinifiStatus MinifiProcessSessionRemove(MinifiProcessSession* session, MINIFI_OWNED MinifiFlowFile* flowfile); @@ -253,16 +258,30 @@ size_t MinifiInputStreamSize(MinifiInputStream*); int64_t MinifiInputStreamRead(MinifiInputStream* stream, char* buffer, size_t size); int64_t MinifiOutputStreamWrite(MinifiOutputStream* stream, const char* data, size_t size); -MinifiStatus MinifiFlowFileSetAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, const MinifiStringView* attribute_value); -MinifiBool MinifiFlowFileGetAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, +MinifiStatus MinifiProcessSessionSetFlowFileAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, const MinifiStringView* attribute_value); +MinifiBool MinifiProcessSessionGetFlowFileAttribute(MinifiProcessSession* session, MinifiFlowFile* flowfile, MinifiStringView attribute_name, 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); +void MinifiProcessSessionGetFlowFileAttributes(MinifiProcessSession* session, MinifiFlowFile* flowfile, + void (*cb)(void* user_ctx, MinifiStringView attribute_name, MinifiStringView attribute_value), void* user_ctx); +uint64_t MinifiProcessSessionGetFlowFileSize(MinifiProcessSession* session, MinifiFlowFile* flowfile); +MinifiStatus MinifiProcessSessionGetFlowFileId(MinifiProcessSession* session, MinifiFlowFile* flowfile, void(*cb)(void* user_ctx, MinifiStringView flow_file_id), void* user_ctx); MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceContext* context, MinifiStringView property_name, void(*cb)(void* user_ctx, MinifiStringView property_value), void* user_ctx); +struct MinifiSslData { + uint8_t version; + MinifiStringView ca_certificate; + MinifiStringView certificate_file; + MinifiStringView private_key_file; + MinifiStringView passphrase; +}; + +MinifiStatus MinifiProcessContextGetSslData(MinifiProcessContext* process_context, MinifiStringView controller_service_name, + void (*cb)(void* user_ctx, const MinifiSslData* ssl_data), void* user_ctx); + #ifdef __cplusplus } // extern "C" #endif // __cplusplus diff --git a/minifi-api/minifi-c-api.def b/minifi-api/minifi-c-api.def index b2cdcf4f43..0fcaf2ad97 100644 --- a/minifi-api/minifi-c-api.def +++ b/minifi-api/minifi-c-api.def @@ -16,12 +16,17 @@ EXPORTS MinifiProcessSessionCreate MinifiProcessSessionTransfer MinifiProcessSessionRemove + MinifiProcessSessionPenalize MinifiProcessSessionRead MinifiProcessSessionWrite MinifiConfigGet MinifiInputStreamSize MinifiInputStreamRead MinifiOutputStreamWrite - MinifiFlowFileSetAttribute - MinifiFlowFileGetAttribute - MinifiFlowFileGetAttributes + MinifiProcessSessionSetFlowFileAttribute + MinifiProcessSessionGetFlowFileAttribute + MinifiProcessSessionGetFlowFileAttributes + MinifiProcessSessionGetFlowFileSize + MinifiProcessSessionGetFlowFileId + MinifiProcessContextGetDynamicProperties + MinifiProcessContextGetSslData From f0fea19e44e51cab29c627bfcc563e4f76df1728 Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Wed, 29 Apr 2026 11:48:52 +0200 Subject: [PATCH 2/7] ca_certificate -> ca_certificate_file --- libminifi/src/minifi-c.cpp | 2 +- minifi-api/include/minifi-c/minifi-c.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp index c96be81c93..81a7e076af 100644 --- a/libminifi/src/minifi-c.cpp +++ b/libminifi/src/minifi-c.cpp @@ -627,7 +627,7 @@ MinifiStatus MinifiProcessContextGetSslData(MinifiProcessContext* process_contex MinifiSslData ssl_data{ .version = 1, - .ca_certificate = minifiStringView(ca_cert_file), + .ca_certificate_file = minifiStringView(ca_cert_file), .certificate_file = minifiStringView(cert_file), .private_key_file = minifiStringView(private_key_file), .passphrase = minifiStringView(passphrase), diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h index 0eb80f8d06..d7c2c0e036 100644 --- a/minifi-api/include/minifi-c/minifi-c.h +++ b/minifi-api/include/minifi-c/minifi-c.h @@ -273,7 +273,7 @@ MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceCo struct MinifiSslData { uint8_t version; - MinifiStringView ca_certificate; + MinifiStringView ca_certificate_file; MinifiStringView certificate_file; MinifiStringView private_key_file; MinifiStringView passphrase; From b3dffbb68e4273c68335351e2b6fc6b9d79f3ad2 Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Mon, 4 May 2026 16:43:15 +0200 Subject: [PATCH 3/7] empalce_back -> push_back --- libminifi/src/minifi-c.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp index 81a7e076af..bd192f638b 100644 --- a/libminifi/src/minifi-c.cpp +++ b/libminifi/src/minifi-c.cpp @@ -193,7 +193,7 @@ void useCProcessorClassDescription(const MinifiProcessorClassDefinition& class_d std::vector dynamic_properties; dynamic_properties.reserve(class_description.dynamic_properties_count); for (size_t i = 0; i < class_description.dynamic_properties_count; ++i) { - dynamic_properties.emplace_back(minifi::core::DynamicPropertyDefinition{ + dynamic_properties.push_back(minifi::core::DynamicPropertyDefinition{ .name = toStringView(class_description.dynamic_properties_ptr[i].name), .value = toStringView(class_description.dynamic_properties_ptr[i].value), .description = toStringView(class_description.dynamic_properties_ptr[i].description), @@ -203,9 +203,10 @@ void useCProcessorClassDescription(const MinifiProcessorClassDefinition& class_d std::vector relationships; relationships.reserve(class_description.class_relationships_count); for (size_t i = 0; i < class_description.class_relationships_count; ++i) { - relationships.emplace_back( + relationships.push_back(minifi::core::Relationship{ toString(class_description.class_relationships_ptr[i].name), - toString(class_description.class_relationships_ptr[i].description)); + toString(class_description.class_relationships_ptr[i].description) + }); } std::vector output_attributes; for (size_t attribute_idx = 0; attribute_idx < class_description.output_attributes_count; ++attribute_idx) { @@ -265,7 +266,7 @@ void useCControllerServiceClassDescription(const MinifiControllerServiceClassDef auto name_segments = minifi::utils::string::split(toStringView(class_description.full_name), "::"); gsl_Assert(!name_segments.empty()); - const minifi::ClassDescription description{ + minifi::ClassDescription description{ .type_ = minifi::ResourceType::ControllerService, .short_name_ = name_segments.back(), .full_name_ = minifi::utils::string::join(".", name_segments), From 7c4554cb9f83e73d1362ca49593581cdcb92482c Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Tue, 5 May 2026 11:10:13 +0200 Subject: [PATCH 4/7] MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE name change and explanatory comment --- minifi-api/include/minifi-c/minifi-c.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h index d7c2c0e036..1345a01b70 100644 --- a/minifi-api/include/minifi-c/minifi-c.h +++ b/minifi-api/include/minifi-c/minifi-c.h @@ -41,7 +41,8 @@ extern "C" { #define MINIFI_REGISTER_EXTENSION_FN MinifiRegisterExtension #endif -#define MINIFI_SSL_CONTEXT_SERVICE_API "org.apache.nifi.minifi.controllers.SSLContextServiceInterface" +/// To allow the proper usage of SSLContextServices set the MinifiPropertyDefinition::type to MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE +#define MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE "org.apache.nifi.minifi.controllers.SSLContextServiceInterface" enum : uint32_t { MINIFI_API_VERSION = 3 From 947837af22ced82e60490c93f4c5b74ebdea74b1 Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Wed, 6 May 2026 13:49:53 +0200 Subject: [PATCH 5/7] typedef MinifiSslData --- minifi-api/include/minifi-c/minifi-c.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h index 1345a01b70..9eb707f355 100644 --- a/minifi-api/include/minifi-c/minifi-c.h +++ b/minifi-api/include/minifi-c/minifi-c.h @@ -272,13 +272,13 @@ MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceCo void(*cb)(void* user_ctx, MinifiStringView property_value), void* user_ctx); -struct MinifiSslData { +typedef struct MinifiSslData { uint8_t version; MinifiStringView ca_certificate_file; MinifiStringView certificate_file; MinifiStringView private_key_file; MinifiStringView passphrase; -}; +} MinifiSslData; MinifiStatus MinifiProcessContextGetSslData(MinifiProcessContext* process_context, MinifiStringView controller_service_name, void (*cb)(void* user_ctx, const MinifiSslData* ssl_data), void* user_ctx); From 95ddfefbc6c02f86e0c4031323d01b211ff68385 Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Mon, 11 May 2026 11:38:01 +0200 Subject: [PATCH 6/7] review changes --- libminifi/src/minifi-c.cpp | 33 ++++++++++++++------------ minifi-api/include/minifi-c/minifi-c.h | 4 ++-- 2 files changed, 20 insertions(+), 17 deletions(-) diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp index bd192f638b..e1f1e0f930 100644 --- a/libminifi/src/minifi-c.cpp +++ b/libminifi/src/minifi-c.cpp @@ -616,27 +616,30 @@ void MinifiProcessContextGetDynamicProperties(MinifiProcessContext* context, Min MinifiStatus MinifiProcessContextGetSslData(MinifiProcessContext* process_context, MinifiStringView controller_service_name, void (*cb)(void* user_ctx, const MinifiSslData* ssl_data), void* user_ctx) { gsl_Assert(process_context != MINIFI_NULL); - const auto context = reinterpret_cast(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_VALIDATION_FAILED; } - if (const auto ssl_context_service = dynamic_cast(service_shared_ptr.get())) { - const std::string ca_cert_file = ssl_context_service->getCACertificate().string(); - const std::string passphrase = ssl_context_service->getPassphrase(); - const std::string cert_file = ssl_context_service->getCertificateFile().string(); - const std::string private_key_file = ssl_context_service->getPrivateKeyFile().string(); - - MinifiSslData ssl_data{ - .version = 1, + try { + const auto context = reinterpret_cast(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_VALIDATION_FAILED; } + if (const auto ssl_context_service = dynamic_cast(service_shared_ptr.get())) { + const std::string ca_cert_file = ssl_context_service->getCACertificate().string(); + const std::string passphrase = ssl_context_service->getPassphrase(); + const std::string cert_file = ssl_context_service->getCertificateFile().string(); + const std::string private_key_file = ssl_context_service->getPrivateKeyFile().string(); + + MinifiSslData ssl_data{ .ca_certificate_file = minifiStringView(ca_cert_file), .certificate_file = minifiStringView(cert_file), .private_key_file = minifiStringView(private_key_file), .passphrase = minifiStringView(passphrase), }; - cb(user_ctx, &ssl_data); - return MINIFI_STATUS_SUCCESS; + cb(user_ctx, &ssl_data); + return MINIFI_STATUS_SUCCESS; + } + return MINIFI_STATUS_VALIDATION_FAILED; + } catch (...) { + return MINIFI_STATUS_UNKNOWN_ERROR; } - return MINIFI_STATUS_VALIDATION_FAILED; } diff --git a/minifi-api/include/minifi-c/minifi-c.h b/minifi-api/include/minifi-c/minifi-c.h index 9eb707f355..e846efbdcf 100644 --- a/minifi-api/include/minifi-c/minifi-c.h +++ b/minifi-api/include/minifi-c/minifi-c.h @@ -41,7 +41,8 @@ extern "C" { #define MINIFI_REGISTER_EXTENSION_FN MinifiRegisterExtension #endif -/// To allow the proper usage of SSLContextServices set the MinifiPropertyDefinition::type to MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE +/// To declare a processor property that expects an SSLContextService, +/// use MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE in the type field of the property definition (MinifiPropertyDefinition::type) #define MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE "org.apache.nifi.minifi.controllers.SSLContextServiceInterface" enum : uint32_t { @@ -273,7 +274,6 @@ MinifiStatus MinifiControllerServiceContextGetProperty(MinifiControllerServiceCo void* user_ctx); typedef struct MinifiSslData { - uint8_t version; MinifiStringView ca_certificate_file; MinifiStringView certificate_file; MinifiStringView private_key_file; From ffb84614e567c883e6eb49ce88c12eb85e28e423 Mon Sep 17 00:00:00 2001 From: Martin Zink Date: Tue, 12 May 2026 15:11:36 +0200 Subject: [PATCH 7/7] Update libminifi/src/minifi-c.cpp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Márton Szász --- libminifi/src/minifi-c.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp index e1f1e0f930..1c5d98fcf0 100644 --- a/libminifi/src/minifi-c.cpp +++ b/libminifi/src/minifi-c.cpp @@ -632,7 +632,7 @@ MinifiStatus MinifiProcessContextGetSslData(MinifiProcessContext* process_contex .certificate_file = minifiStringView(cert_file), .private_key_file = minifiStringView(private_key_file), .passphrase = minifiStringView(passphrase), - }; + }; cb(user_ctx, &ssl_data); return MINIFI_STATUS_SUCCESS; }