minifi_processor_class_definition -> minifi_processor_definition

martinzink · martinzink · commit b7ce7e9da117 · 2026-07-06T16:55:26.000+02:00
minifi_controller_service_class_definition -&gt; minifi_controller_service_definition
MINIFI_PROXY_CONFIGURATION_SERVICE_PROPERTY_TYPE -&gt; MINIFI_PROXY_CONFIGURATION_SERVICE_INTERFACE_PROPERTY_TYPE
MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE -&gt; MINIFI_SSL_CONTEXT_SERVICE_INTERFACE_PROPERTY_TYPE
diff --git a/Extensions.md b/Extensions.md
@@ -48,7 +48,7 @@ extern "C" void minifi_init_extension(minifi_extension_context* extension_contex
     .user_data = nullptr
   };
   auto* extension = minifi_register_extension(extension_context, &extension_definition);
-  minifi::api::core::useProcessorClassDefinition<minifi::extensions::llamacpp::processors::RunLlamaCppInference>([&] (const minifi_processor_class_definition& definition) {
+  minifi::api::core::useProcessorClassDefinition<minifi::extensions::llamacpp::processors::RunLlamaCppInference>([&] (const minifi_processor_definition& definition) {
     minifi_register_processor(extension, &definition);
   });
 }
diff --git a/extension-framework/cpp-extension-lib/include/api/core/Resource.h b/extension-framework/cpp-extension-lib/include/api/core/Resource.h
@@ -78,7 +78,7 @@ void useProcessorClassDefinition(Fn&& fn) {
     attribute_relationships_cache.push_back(std::move(rel_cache));
   }
 
-  minifi_processor_class_definition definition{
+  minifi_processor_definition definition{
     .full_name = utils::minifiStringView(full_name),
     .description = utils::minifiStringView(Class::Description),
     .properties_count = gsl::narrow<uint32_t>(class_properties.size()),
@@ -149,7 +149,7 @@ void useControllerServiceClassDefinition(Fn&& fn) {
     }
   }
 
-  minifi_controller_service_class_definition definition{.full_name = utils::minifiStringView(full_name),
+  minifi_controller_service_definition definition{.full_name = utils::minifiStringView(full_name),
       .description = utils::minifiStringView(Class::Description),
       .properties_count = gsl::narrow<uint32_t>(class_properties.size()),
       .properties_ptr = class_properties.data(),
@@ -198,14 +198,14 @@ void useControllerServiceClassDefinition(Fn&& fn) {
 
 template <typename... Processors>
 void registerProcessors(minifi_extension* extension) {
-  (core::useProcessorClassDefinition<Processors>([&](const minifi_processor_class_definition& definition) {
+  (core::useProcessorClassDefinition<Processors>([&](const minifi_processor_definition& definition) {
       minifi_register_processor(extension, &definition);
   }), ...);
 }
 
 template <typename... ControllerServices>
 void registerControllerServices(minifi_extension* extension) {
-  (core::useControllerServiceClassDefinition<ControllerServices>([&](const minifi_controller_service_class_definition& definition) {
+  (core::useControllerServiceClassDefinition<ControllerServices>([&](const minifi_controller_service_definition& definition) {
       minifi_register_controller_service(extension, &definition);
   }), ...);
 }
diff --git a/extension-framework/cpp-extension-lib/libtest/CProcessorTestUtils.h b/extension-framework/cpp-extension-lib/libtest/CProcessorTestUtils.h
@@ -32,7 +32,7 @@ template<typename T, typename... Args>
 std::unique_ptr<minifi::core::Processor> make_custom_c_processor(minifi::core::ProcessorMetadata metadata,
     Args&&... args) {  // NOLINT(cppcoreguidelines-missing-std-forward)
   std::unique_ptr<minifi::core::ProcessorApi> processor_impl;
-  minifi::api::core::useProcessorClassDefinition<T>([&](const minifi_processor_class_definition& definition) {
+  minifi::api::core::useProcessorClassDefinition<T>([&](const minifi_processor_definition& definition) {
     minifi::utils::useCProcessorClassDescription(definition, [&](const auto&, auto c_description) {
       processor_impl = std::make_unique<minifi::utils::CProcessor>(std::move(c_description), metadata, new T(metadata, std::forward<Args>(args)...));
     });
@@ -44,7 +44,7 @@ template<typename T, typename... Args>
 std::shared_ptr<minifi::core::controller::ControllerService> make_custom_c_controller_service(minifi::core::ControllerServiceMetadata metadata,
     Args&&... args) {  // NOLINT(cppcoreguidelines-missing-std-forward)
   std::unique_ptr<minifi::core::controller::ControllerServiceApi> controller_service_impl;
-  minifi::api::core::useControllerServiceClassDefinition<T>([&](const minifi_controller_service_class_definition& definition) {
+  minifi::api::core::useControllerServiceClassDefinition<T>([&](const minifi_controller_service_definition& definition) {
     minifi::utils::useCControllerServiceClassDescription("test_bundle", definition, [&](const auto&, auto c_description) {
       controller_service_impl = std::make_unique<minifi::utils::CControllerService>(std::move(c_description),
           metadata,
diff --git a/extension-framework/cpp-extension-lib/mocklib/src/mock-minifi-api.cpp b/extension-framework/cpp-extension-lib/mocklib/src/mock-minifi-api.cpp
@@ -24,11 +24,11 @@ minifi_extension* MINIFI_REGISTER_EXTENSION_FN(minifi_extension_context*, const
   throw std::runtime_error("Not implemented");
 }
 
-minifi_status minifi_register_processor(minifi_extension*, const minifi_processor_class_definition*) {
+minifi_status minifi_register_processor(minifi_extension*, const minifi_processor_definition*) {
   throw std::runtime_error("Not implemented");
 }
 
-minifi_status minifi_register_controller_service(minifi_extension*, const minifi_controller_service_class_definition*) {
+minifi_status minifi_register_controller_service(minifi_extension*, const minifi_controller_service_definition*) {
   throw std::runtime_error("Not implemented");
 }
 
diff --git a/extensions/gcp/processors/GCSProcessor.h b/extensions/gcp/processors/GCSProcessor.h
@@ -53,7 +53,7 @@ class GCSProcessor : public api::core::ProcessorImpl {
       .build();
   EXTENSIONAPI static constexpr auto ProxyConfigurationService = core::PropertyDefinitionBuilder<>::createProperty("Proxy Configuration Service")
       .withDescription("Specifies the Proxy Configuration Controller Service to proxy network requests.")
-      .withAllowedType<MINIFI_PROXY_CONFIGURATION_SERVICE_PROPERTY_TYPE>()
+      .withAllowedType<MINIFI_PROXY_CONFIGURATION_SERVICE_INTERFACE_PROPERTY_TYPE>()
       .build();
   EXTENSIONAPI static constexpr auto Properties = std::to_array<core::PropertyReference>({
       GCPCredentials,
diff --git a/extensions/kafka/KafkaProcessorBase.h b/extensions/kafka/KafkaProcessorBase.h
@@ -41,7 +41,7 @@ class KafkaProcessorBase : public api::core::ProcessorImpl {
   EXTENSIONAPI static constexpr auto SSLContextService =
       core::PropertyDefinitionBuilder<>::createProperty("SSL Context Service")
           .withDescription("SSL Context Service Name")
-          .withAllowedType<MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE>()
+          .withAllowedType<MINIFI_SSL_CONTEXT_SERVICE_INTERFACE_PROPERTY_TYPE>()
           .build();
   EXTENSIONAPI static constexpr auto SecurityProtocol =
       core::PropertyDefinitionBuilder<magic_enum::enum_count<kafka::SecurityProtocolOption>()>::createProperty(
diff --git a/libminifi/include/utils/CControllerService.h b/libminifi/include/utils/CControllerService.h
@@ -111,7 +111,7 @@ class CControllerService final : public core::controller::ControllerServiceApi,
   minifi::core::ControllerServiceMetadata metadata_;
 };
 
-void useCControllerServiceClassDescription(std::string_view bundle_name, const minifi_controller_service_class_definition& class_description,
+void useCControllerServiceClassDescription(std::string_view bundle_name, const minifi_controller_service_definition& class_description,
     const std::function<void(const ClassDescription&, CControllerServiceClassDescription)>& fn);
 
 }  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/CProcessor.h b/libminifi/include/utils/CProcessor.h
@@ -177,6 +177,6 @@ class CProcessor : public minifi::core::ProcessorApi {
   std::vector<minifi::state::PublishedMetric> reported_metrics_;
 };
 
-void useCProcessorClassDescription(const minifi_processor_class_definition& class_description, const std::function<void(ClassDescription, CProcessorClassDescription)>& fn);
+void useCProcessorClassDescription(const minifi_processor_definition& class_description, const std::function<void(ClassDescription, CProcessorClassDescription)>& fn);
 
 }  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/minifi-api.cpp b/libminifi/src/minifi-api.cpp
@@ -194,7 +194,7 @@ minifi_proxy_type minifiProxyType(const minifi::controllers::ProxyType& proxy_ty
 
 namespace org::apache::nifi::minifi::utils {
 
-void useCProcessorClassDescription(const minifi_processor_class_definition& class_description, const std::function<void(minifi::ClassDescription, minifi::utils::CProcessorClassDescription)>& fn) {
+void useCProcessorClassDescription(const minifi_processor_definition& class_description, const std::function<void(minifi::ClassDescription, minifi::utils::CProcessorClassDescription)>& fn) {
   std::vector<minifi::core::Property> properties;
   properties.reserve(class_description.properties_count);
   for (size_t i = 0; i < class_description.properties_count; ++i) {
@@ -265,7 +265,7 @@ void useCProcessorClassDescription(const minifi_processor_class_definition& clas
   fn(description, c_class_description);
 }
 
-void useCControllerServiceClassDescription(const std::string_view bundle_name, const minifi_controller_service_class_definition& class_description,
+void useCControllerServiceClassDescription(const std::string_view bundle_name, const minifi_controller_service_definition& class_description,
     const std::function<void(const ClassDescription&, CControllerServiceClassDescription)>& fn) {
   std::vector<minifi::core::Property> properties;
   properties.reserve(class_description.properties_count);
@@ -321,7 +321,7 @@ minifi_extension* minifi_register_extension(minifi_extension_context* extension_
   return nullptr;
 }
 
-minifi_status minifi_register_processor(minifi_extension* extension, const minifi_processor_class_definition* processor) {
+minifi_status minifi_register_processor(minifi_extension* extension, const minifi_processor_definition* processor) {
   gsl_Assert(extension);
   gsl_Assert(processor);
   auto* extension_ = reinterpret_cast<minifi::core::extension::Extension*>(extension);
@@ -344,7 +344,7 @@ minifi_status minifi_register_processor(minifi_extension* extension, const minif
   return MINIFI_STATUS_SUCCESS;
 }
 
-minifi_status minifi_register_controller_service(minifi_extension* extension, const minifi_controller_service_class_definition* controller_service) {
+minifi_status minifi_register_controller_service(minifi_extension* extension, const minifi_controller_service_definition* controller_service) {
   gsl_Assert(extension);
   gsl_Assert(controller_service);
   auto extension_info = reinterpret_cast<minifi::core::extension::Extension*>(extension)->getInfo();
diff --git a/libminifi/test/integration/extension-verification-test/CApiExtension.cpp b/libminifi/test/integration/extension-verification-test/CApiExtension.cpp
@@ -50,7 +50,7 @@ CEXTENSIONAPI void minifi_init_extension(minifi_extension_context* extension_con
     .user_data = nullptr
   };
   auto extension = minifi_register_extension(extension_context, &extension_definition);
-  minifi::api::core::useProcessorClassDefinition<DummyCProcessor>([&] (const minifi_processor_class_definition& definition) {
+  minifi::api::core::useProcessorClassDefinition<DummyCProcessor>([&] (const minifi_processor_definition& definition) {
     minifi_register_processor(extension, &definition);
   });
 }
diff --git a/minifi-api/include/minifi-api.h b/minifi-api/include/minifi-api.h
@@ -42,12 +42,12 @@ extern "C" {
 #endif
 
 /// To declare a processor property that expects an SSLContextService,
-/// use MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE in the type field of the property definition (minifi_property_definition::allowed_type)
-#define MINIFI_SSL_CONTEXT_SERVICE_PROPERTY_TYPE "org.apache.nifi.minifi.controllers.SSLContextServiceInterface"
+/// use MINIFI_SSL_CONTEXT_SERVICE_INTERFACE_PROPERTY_TYPE in the type field of the property definition (minifi_property_definition::allowed_type)
+#define MINIFI_SSL_CONTEXT_SERVICE_INTERFACE_PROPERTY_TYPE "org.apache.nifi.minifi.controllers.SSLContextServiceInterface"
 
 /// To declare a processor property that expects an ProxyConfigurationService,
-/// use MINIFI_PROXY_CONFIGURATION_SERVICE_PROPERTY_TYPE in the type field of the property definition (minifi_property_definition::allowed_type)
-#define MINIFI_PROXY_CONFIGURATION_SERVICE_PROPERTY_TYPE "org.apache.nifi.minifi.controllers.ProxyConfigurationServiceInterface"
+/// use MINIFI_PROXY_CONFIGURATION_SERVICE_INTERFACE_PROPERTY_TYPE in the type field of the property definition (minifi_property_definition::allowed_type)
+#define MINIFI_PROXY_CONFIGURATION_SERVICE_INTERFACE_PROPERTY_TYPE "org.apache.nifi.minifi.controllers.ProxyConfigurationServiceInterface"
 
 enum : uint32_t {
   MINIFI_API_VERSION = 1
@@ -182,7 +182,7 @@ struct minifi_controller_service_callbacks {
   void* (*get_interface)(void* ctx, struct minifi_string_view interface_type);
 };
 
-struct minifi_processor_class_definition {
+struct minifi_processor_definition {
   struct minifi_string_view full_name;  // '::'-delimited fully qualified name e.g. 'org::apache::nifi::minifi::GenerateFlowFile'
   struct minifi_string_view description;
   size_t properties_count;
@@ -201,7 +201,7 @@ struct minifi_processor_class_definition {
   struct minifi_processor_callbacks callbacks;
 };
 
-struct minifi_controller_service_class_definition {
+struct minifi_controller_service_definition {
   struct minifi_string_view full_name;  // '::'-delimited fully qualified name e.g. 'org::apache::nifi::minifi::extensions::gcp::GCPCredentialsControllerService
   struct minifi_string_view description;
   size_t properties_count;
@@ -225,9 +225,9 @@ struct minifi_extension_definition {
 struct minifi_extension* MINIFI_REGISTER_EXTENSION_FN(struct minifi_extension_context* extension_context,
     const struct minifi_extension_definition* extension_definition);
 
-enum minifi_status minifi_register_processor(struct minifi_extension* extension, const struct minifi_processor_class_definition* processor);
+enum minifi_status minifi_register_processor(struct minifi_extension* extension, const struct minifi_processor_definition* processor);
 enum minifi_status minifi_register_controller_service(struct minifi_extension* extension,
-    const struct minifi_controller_service_class_definition* controller_service);
+    const struct minifi_controller_service_definition* controller_service);
 
 enum minifi_status minifi_process_context_set_trigger_when_empty(struct minifi_process_context*, bool trigger_when_empty);
 enum minifi_status minifi_process_context_report_metrics(struct minifi_process_context*, size_t count, const struct minifi_string_view* metric_names,

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ extern "C" void minifi_init_extension(minifi_extension_context* extension_contex`
`48`	`48`	`.user_data = nullptr`
`49`	`49`	`};`
`50`	`50`	`auto* extension = minifi_register_extension(extension_context, &extension_definition);`
`51`		`- minifi::api::core::useProcessorClassDefinition<minifi::extensions::llamacpp::processors::RunLlamaCppInference>([&] (const minifi_processor_class_definition& definition) {`
	`51`	`+ minifi::api::core::useProcessorClassDefinition<minifi::extensions::llamacpp::processors::RunLlamaCppInference>([&] (const minifi_processor_definition& definition) {`
`52`	`52`	`minifi_register_processor(extension, &definition);`
`53`	`53`	`});`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ void useProcessorClassDefinition(Fn&& fn) {`
`78`	`78`	`attribute_relationships_cache.push_back(std::move(rel_cache));`
`79`	`79`	`}`
`80`	`80`
`81`		`- minifi_processor_class_definition definition{`
	`81`	`+ minifi_processor_definition definition{`
`82`	`82`	`.full_name = utils::minifiStringView(full_name),`
`83`	`83`	`.description = utils::minifiStringView(Class::Description),`
`84`	`84`	`.properties_count = gsl::narrow<uint32_t>(class_properties.size()),`
`@@ -149,7 +149,7 @@ void useControllerServiceClassDefinition(Fn&& fn) {`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`		`- minifi_controller_service_class_definition definition{.full_name = utils::minifiStringView(full_name),`
	`152`	`+ minifi_controller_service_definition definition{.full_name = utils::minifiStringView(full_name),`
`153`	`153`	`.description = utils::minifiStringView(Class::Description),`
`154`	`154`	`.properties_count = gsl::narrow<uint32_t>(class_properties.size()),`
`155`	`155`	`.properties_ptr = class_properties.data(),`
`@@ -198,14 +198,14 @@ void useControllerServiceClassDefinition(Fn&& fn) {`
`198`	`198`
`199`	`199`	`template <typename... Processors>`
`200`	`200`	`void registerProcessors(minifi_extension* extension) {`
`201`		`- (core::useProcessorClassDefinition<Processors>([&](const minifi_processor_class_definition& definition) {`
	`201`	`+ (core::useProcessorClassDefinition<Processors>([&](const minifi_processor_definition& definition) {`
`202`	`202`	`minifi_register_processor(extension, &definition);`
`203`	`203`	`}), ...);`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`template <typename... ControllerServices>`
`207`	`207`	`void registerControllerServices(minifi_extension* extension) {`
`208`		`- (core::useControllerServiceClassDefinition<ControllerServices>([&](const minifi_controller_service_class_definition& definition) {`
	`208`	`+ (core::useControllerServiceClassDefinition<ControllerServices>([&](const minifi_controller_service_definition& definition) {`
`209`	`209`	`minifi_register_controller_service(extension, &definition);`
`210`	`210`	`}), ...);`
`211`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,11 @@ minifi_extension* MINIFI_REGISTER_EXTENSION_FN(minifi_extension_context*, const`
`24`	`24`	`throw std::runtime_error("Not implemented");`
`25`	`25`	`}`
`26`	`26`
`27`		`-minifi_status minifi_register_processor(minifi_extension, const minifi_processor_class_definition) {`
	`27`	`+minifi_status minifi_register_processor(minifi_extension, const minifi_processor_definition) {`
`28`	`28`	`throw std::runtime_error("Not implemented");`
`29`	`29`	`}`
`30`	`30`
`31`		`-minifi_status minifi_register_controller_service(minifi_extension, const minifi_controller_service_class_definition) {`
	`31`	`+minifi_status minifi_register_controller_service(minifi_extension, const minifi_controller_service_definition) {`
`32`	`32`	`throw std::runtime_error("Not implemented");`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ CEXTENSIONAPI void minifi_init_extension(minifi_extension_context* extension_con`
`50`	`50`	`.user_data = nullptr`
`51`	`51`	`};`
`52`	`52`	`auto extension = minifi_register_extension(extension_context, &extension_definition);`
`53`		`- minifi::api::core::useProcessorClassDefinition<DummyCProcessor>([&] (const minifi_processor_class_definition& definition) {`
	`53`	`+ minifi::api::core::useProcessorClassDefinition<DummyCProcessor>([&] (const minifi_processor_definition& definition) {`
`54`	`54`	`minifi_register_processor(extension, &definition);`
`55`	`55`	`});`
`56`	`56`	`}`