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
The following commit(s) were added to refs/heads/apache-rusty by this push:
new 71e26e126 MINIFICPP-2724 Add MinifiStatus return type to C api
function that might fail
71e26e126 is described below
commit 71e26e126861c69ea2147e0e01b9947ce8325f95
Author: Martin Zink <[email protected]>
AuthorDate: Thu Feb 19 13:00:01 2026 +0100
MINIFICPP-2724 Add MinifiStatus return type to C api function that might
fail
---
.../include/api/core/ProcessContext.h | 2 --
.../include/api/utils/ProcessorConfigUtils.h | 24 ++++++++---------
.../cpp-extension-lib/src/core/ProcessContext.cpp | 10 -------
.../cpp-extension-lib/src/core/ProcessSession.cpp | 22 ++++++++++-----
.../include/utils/ProcessorConfigUtils.h | 24 ++++++++---------
.../azure/tests/FetchAzureDataLakeStorageTests.cpp | 2 +-
.../llamacpp/tests/RunLlamaCppInferenceTests.cpp | 4 +--
extensions/mqtt/tests/ConsumeMQTTTests.cpp | 4 +--
extensions/mqtt/tests/PublishMQTTTests.cpp | 2 +-
.../tests/unit/SegmentContentTests.cpp | 4 +--
.../tests/unit/SplitContentTests.cpp | 2 +-
.../tests/unit/SplitTextTests.cpp | 2 +-
libminifi/src/minifi-c.cpp | 31 +++++++++++++---------
minifi-api/include/minifi-c/minifi-c.h | 7 +++--
minifi-api/minifi-c-api.def | 1 -
15 files changed, 71 insertions(+), 70 deletions(-)
diff --git
a/extension-framework/cpp-extension-lib/include/api/core/ProcessContext.h
b/extension-framework/cpp-extension-lib/include/api/core/ProcessContext.h
index 59eb52e02..50f5ebaa5 100644
--- a/extension-framework/cpp-extension-lib/include/api/core/ProcessContext.h
+++ b/extension-framework/cpp-extension-lib/include/api/core/ProcessContext.h
@@ -37,8 +37,6 @@ class ProcessContext {
bool hasNonEmptyProperty(std::string_view name) const;
- std::string getProcessorName() const;
-
private:
MinifiProcessContext* impl_;
};
diff --git
a/extension-framework/cpp-extension-lib/include/api/utils/ProcessorConfigUtils.h
b/extension-framework/cpp-extension-lib/include/api/utils/ProcessorConfigUtils.h
index 14644b9c7..6a14699d7 100644
---
a/extension-framework/cpp-extension-lib/include/api/utils/ProcessorConfigUtils.h
+++
b/extension-framework/cpp-extension-lib/include/api/utils/ProcessorConfigUtils.h
@@ -33,37 +33,37 @@ namespace org::apache::nifi::minifi::api::utils {
inline std::string parseProperty(const core::ProcessContext& ctx, const
minifi::core::PropertyReference& property, const core::FlowFile* flow_file =
nullptr) {
return ctx.getProperty(property.name, flow_file)
- | minifi::utils::orThrow(fmt::format("Expected valid value from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected valid value from \"{}\"",
property.name));
}
inline bool parseBoolProperty(const core::ProcessContext& ctx, const
minifi::core::PropertyReference& property, const core::FlowFile* flow_file =
nullptr) {
return ctx.getProperty(property.name, flow_file)
| minifi::utils::andThen(parsing::parseBool)
- | minifi::utils::orThrow(fmt::format("Expected parsable bool from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable bool from
\"{}\"", property.name));
}
inline uint64_t parseU64Property(const core::ProcessContext& ctx, const
minifi::core::PropertyReference& property, const core::FlowFile* flow_file =
nullptr) {
return ctx.getProperty(property.name, flow_file)
| minifi::utils::andThen(parsing::parseIntegral<uint64_t>)
- | minifi::utils::orThrow(fmt::format("Expected parsable uint64_t from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable uint64_t from
\"{}\"", property.name));
}
inline int64_t parseI64Property(const core::ProcessContext& ctx, const
minifi::core::PropertyReference& property, const core::FlowFile* flow_file =
nullptr) {
return ctx.getProperty(property.name, flow_file)
| minifi::utils::andThen(parsing::parseIntegral<int64_t>)
- | minifi::utils::orThrow(fmt::format("Expected parsable int64_t from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable int64_t from
\"{}\"", property.name));
}
inline std::chrono::milliseconds parseDurationProperty(const
core::ProcessContext& ctx, const minifi::core::PropertyReference& property,
const core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
|
minifi::utils::andThen(parsing::parseDuration<std::chrono::milliseconds>)
- | minifi::utils::orThrow(fmt::format("Expected parsable duration from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable duration from
\"{}\"", property.name));
}
inline uint64_t parseDataSizeProperty(const core::ProcessContext& ctx, const
minifi::core::PropertyReference& property, const core::FlowFile* flow_file =
nullptr) {
return ctx.getProperty(property.name, flow_file)
| minifi::utils::andThen(parsing::parseDataSize)
- | minifi::utils::orThrow(fmt::format("Expected parsable data size from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable data size from
\"{}\"", property.name));
}
inline std::optional<std::string> parseOptionalProperty(const
core::ProcessContext& ctx, const minifi::core::PropertyReference& property,
const core::FlowFile* flow_file = nullptr) {
@@ -74,7 +74,7 @@ inline std::optional<std::string> parseOptionalProperty(const
core::ProcessConte
inline std::optional<bool> parseOptionalBoolProperty(const
core::ProcessContext& ctx, const minifi::core::PropertyReference& property,
const core::FlowFile* flow_file = nullptr) {
if (const auto property_str = ctx.getProperty(property.name, flow_file)) {
return parsing::parseBool(*property_str)
- | minifi::utils::orThrow(fmt::format("Expected parsable bool from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable bool from
\"{}\"", property.name));
}
return std::nullopt;
}
@@ -85,7 +85,7 @@ inline std::optional<uint64_t> parseOptionalU64Property(const
core::ProcessConte
return std::nullopt;
}
return parsing::parseIntegral<uint64_t>(*property_str)
- | minifi::utils::orThrow(fmt::format("Expected parsable uint64_t from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable uint64_t from
\"{}\"", property.name));
}
return std::nullopt;
@@ -97,7 +97,7 @@ inline std::optional<int64_t> parseOptionalI64Property(const
core::ProcessContex
return std::nullopt;
}
return parsing::parseIntegral<int64_t>(*property_str)
- | minifi::utils::orThrow(fmt::format("Expected parsable int64_t from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable int64_t from
\"{}\"", property.name));
}
return std::nullopt;
@@ -111,7 +111,7 @@ inline std::optional<std::chrono::milliseconds>
parseOptionalDurationProperty(co
return std::nullopt;
}
return parsing::parseDuration(*property_str)
- | minifi::utils::orThrow(fmt::format("Expected parsable duration from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable duration from
\"{}\"", property.name));
}
return std::nullopt;
@@ -123,7 +123,7 @@ inline std::optional<uint64_t>
parseOptionalDataSizeProperty(const core::Process
return std::nullopt;
}
return parsing::parseDataSize(*property_str)
- | minifi::utils::orThrow(fmt::format("Expected parsable data size from
\"{}::{}\"", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable data size from
\"{}\"", property.name));
}
return std::nullopt;
@@ -135,7 +135,7 @@ inline std::optional<float>
parseOptionalFloatProperty(const core::ProcessContex
return std::nullopt;
}
return parsing::parseFloat(*property_str)
- | minifi::utils::orThrow(fmt::format("Expected parsable float from
{}::{}", ctx.getProcessorName(), property.name));
+ | minifi::utils::orThrow(fmt::format("Expected parsable float from
\"{}\"", property.name));
}
return std::nullopt;
}
diff --git a/extension-framework/cpp-extension-lib/src/core/ProcessContext.cpp
b/extension-framework/cpp-extension-lib/src/core/ProcessContext.cpp
index 76ed2231b..58016d804 100644
--- a/extension-framework/cpp-extension-lib/src/core/ProcessContext.cpp
+++ b/extension-framework/cpp-extension-lib/src/core/ProcessContext.cpp
@@ -38,14 +38,4 @@ bool ProcessContext::hasNonEmptyProperty(std::string_view
name) const {
return MinifiProcessContextHasNonEmptyProperty(impl_,
utils::toStringView(name));
}
-std::string ProcessContext::getProcessorName() const {
- std::string result;
- MinifiProcessContextGetProcessorName(impl_, [] (void* data, MinifiStringView
name) {
- *static_cast<std::string*>(data) = std::string(name.data, name.length);
- }, &result);
- return result;
-}
-
-
-
} // namespace org::apache::nifi::minifi::api::core
diff --git a/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp
b/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp
index c5c51765c..6b22c0bbc 100644
--- a/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp
+++ b/extension-framework/cpp-extension-lib/src/core/ProcessSession.cpp
@@ -79,11 +79,15 @@ FlowFile ProcessSession::create(const FlowFile* parent) {
void ProcessSession::transfer(FlowFile ff, const minifi::core::Relationship&
relationship) {
const auto rel_name = relationship.getName();
- MinifiProcessSessionTransfer(impl_, ff.release(),
utils::toStringView(rel_name));
+ if (MINIFI_STATUS_SUCCESS != MinifiProcessSessionTransfer(impl_,
ff.release(), utils::toStringView(rel_name))) {
+ throw minifi::Exception(minifi::FILE_OPERATION_EXCEPTION, "Failed to
transfer flowfile");
+ }
}
void ProcessSession::remove(FlowFile ff) {
- MinifiProcessSessionRemove(impl_, ff.release());
+ if (MINIFI_STATUS_SUCCESS != MinifiProcessSessionRemove(impl_,
ff.release())) {
+ throw minifi::Exception(minifi::FILE_OPERATION_EXCEPTION, "Failed to
remove flowfile");
+ }
}
void ProcessSession::write(FlowFile& flow_file, const
io::OutputStreamCallback& callback) {
@@ -104,13 +108,17 @@ void ProcessSession::read(FlowFile& flow_file, const
io::InputStreamCallback& ca
}
}
-void ProcessSession::setAttribute(FlowFile& ff, std::string_view key,
std::string value) { // NOLINT(performance-unnecessary-value-param)
- MinifiStringView value_ref = utils::toStringView(value);
- MinifiFlowFileSetAttribute(impl_, ff.get(), utils::toStringView(key),
&value_ref);
+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)) {
+ throw minifi::Exception(minifi::FILE_OPERATION_EXCEPTION, "Failed to set
attribute");
+ }
}
-void ProcessSession::removeAttribute(FlowFile& ff, std::string_view key) {
- MinifiFlowFileSetAttribute(impl_, ff.get(), utils::toStringView(key),
nullptr);
+void ProcessSession::removeAttribute(FlowFile& ff, const std::string_view key)
{
+ if (MINIFI_STATUS_SUCCESS != MinifiFlowFileSetAttribute(impl_, ff.get(),
utils::toStringView(key), nullptr)) {
+ throw minifi::Exception(minifi::FILE_OPERATION_EXCEPTION, "Failed to
remove attribute");
+ }
}
std::optional<std::string> ProcessSession::getAttribute(FlowFile& ff,
std::string_view key) {
diff --git a/extension-framework/include/utils/ProcessorConfigUtils.h
b/extension-framework/include/utils/ProcessorConfigUtils.h
index 312d168af..92afdf61f 100644
--- a/extension-framework/include/utils/ProcessorConfigUtils.h
+++ b/extension-framework/include/utils/ProcessorConfigUtils.h
@@ -34,37 +34,37 @@ namespace org::apache::nifi::minifi::utils {
inline std::string parseProperty(const core::ProcessContext& ctx, const
core::PropertyReference& property, const core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
- | orThrow(fmt::format("Expected valid value from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | orThrow(fmt::format("Expected valid value from \"{}\"",
property.name));
}
inline bool parseBoolProperty(const core::ProcessContext& ctx, const
core::PropertyReference& property, const core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
| andThen(parsing::parseBool)
- | orThrow(fmt::format("Expected parsable bool from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | orThrow(fmt::format("Expected parsable bool from \"{}\"",
property.name));
}
inline uint64_t parseU64Property(const core::ProcessContext& ctx, const
core::PropertyReference& property, const core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
| andThen(parsing::parseIntegral<uint64_t>)
- | orThrow(fmt::format("Expected parsable uint64_t from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | orThrow(fmt::format("Expected parsable uint64_t from \"{}\"",
property.name));
}
inline int64_t parseI64Property(const core::ProcessContext& ctx, const
core::PropertyReference& property, const core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
| andThen(parsing::parseIntegral<int64_t>)
- | orThrow(fmt::format("Expected parsable int64_t from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | orThrow(fmt::format("Expected parsable int64_t from \"{}\"",
property.name));
}
inline std::chrono::milliseconds parseDurationProperty(const
core::ProcessContext& ctx, const core::PropertyReference& property, const
core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
| andThen(parsing::parseDuration<std::chrono::milliseconds>)
- | orThrow(fmt::format("Expected parsable duration from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | orThrow(fmt::format("Expected parsable duration from \"{}\"",
property.name));
}
inline uint64_t parseDataSizeProperty(const core::ProcessContext& ctx, const
core::PropertyReference& property, const core::FlowFile* flow_file = nullptr) {
return ctx.getProperty(property.name, flow_file)
| andThen(parsing::parseDataSize)
- | orThrow(fmt::format("Expected parsable data size from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | orThrow(fmt::format("Expected parsable data size from \"{}\"",
property.name));
}
inline std::optional<std::string> parseOptionalProperty(const
core::ProcessContext& ctx, const core::PropertyReference& property, const
core::FlowFile* flow_file = nullptr) {
@@ -75,7 +75,7 @@ inline std::optional<std::string> parseOptionalProperty(const
core::ProcessConte
inline std::optional<bool> parseOptionalBoolProperty(const
core::ProcessContext& ctx, const core::PropertyReference& property, const
core::FlowFile* flow_file = nullptr) {
if (const auto property_str = ctx.getProperty(property.name, flow_file)) {
return parsing::parseBool(*property_str)
- | utils::orThrow(fmt::format("Expected parsable bool from \"{}::{}\"",
ctx.getProcessorInfo().getName(), property.name));
+ | utils::orThrow(fmt::format("Expected parsable bool from \"{}\"",
property.name));
}
return std::nullopt;
}
@@ -86,7 +86,7 @@ inline std::optional<uint64_t> parseOptionalU64Property(const
core::ProcessConte
return std::nullopt;
}
return parsing::parseIntegral<uint64_t>(*property_str)
- | utils::orThrow(fmt::format("Expected parsable uint64_t from
\"{}::{}\"", ctx.getProcessorInfo().getName(), property.name));
+ | utils::orThrow(fmt::format("Expected parsable uint64_t from \"{}\"",
property.name));
}
return std::nullopt;
@@ -98,7 +98,7 @@ inline std::optional<int64_t> parseOptionalI64Property(const
core::ProcessContex
return std::nullopt;
}
return parsing::parseIntegral<int64_t>(*property_str)
- | utils::orThrow(fmt::format("Expected parsable int64_t from
\"{}::{}\"", ctx.getProcessorInfo().getName(), property.name));
+ | utils::orThrow(fmt::format("Expected parsable int64_t from \"{}\"",
property.name));
}
return std::nullopt;
@@ -110,7 +110,7 @@ inline std::optional<std::chrono::milliseconds>
parseOptionalDurationProperty(co
return std::nullopt;
}
return parsing::parseDuration(*property_str)
- | utils::orThrow(fmt::format("Expected parsable duration from
\"{}::{}\"", ctx.getProcessorInfo().getName(), property.name));
+ | utils::orThrow(fmt::format("Expected parsable duration from \"{}\"",
property.name));
}
return std::nullopt;
@@ -122,7 +122,7 @@ inline std::optional<uint64_t>
parseOptionalDataSizeProperty(const core::Process
return std::nullopt;
}
return parsing::parseDataSize(*property_str)
- | utils::orThrow(fmt::format("Expected parsable data size from
\"{}::{}\"", ctx.getProcessorInfo().getName(), property.name));
+ | utils::orThrow(fmt::format("Expected parsable data size from
\"{}\"", property.name));
}
return std::nullopt;
@@ -134,7 +134,7 @@ inline std::optional<float>
parseOptionalFloatProperty(const core::ProcessContex
return std::nullopt;
}
return parsing::parseFloat(*property_str)
- | utils::orThrow(fmt::format("Expected parsable float from {}::{}",
ctx.getProcessorInfo().getName(), property.name));
+ | utils::orThrow(fmt::format("Expected parsable float from \"{}\"",
property.name));
}
return std::nullopt;
}
diff --git a/extensions/azure/tests/FetchAzureDataLakeStorageTests.cpp
b/extensions/azure/tests/FetchAzureDataLakeStorageTests.cpp
index c5505f49e..af0016141 100644
--- a/extensions/azure/tests/FetchAzureDataLakeStorageTests.cpp
+++ b/extensions/azure/tests/FetchAzureDataLakeStorageTests.cpp
@@ -157,7 +157,7 @@ TEST_CASE_METHOD(FetchAzureDataLakeStorageTestsFixture,
"Valid Number of Retries
TEST_CASE_METHOD(FetchAzureDataLakeStorageTestsFixture, "Invalid Number of
Retries is set via EL", "[azureDataLakeStorageFetch]") {
plan_->setProperty(azure_data_lake_storage_,
minifi::azure::processors::FetchAzureDataLakeStorage::NumberOfRetries,
"${literal(\"asd\")}");
- REQUIRE_THROWS_WITH(test_controller_.runSession(plan_, true), "Expected
parsable uint64_t from \"AzureDataLakeStorageProcessor::Number of Retries\",
but got GeneralParsingError (Parsing Error:0)");
+ REQUIRE_THROWS_WITH(test_controller_.runSession(plan_, true), "Expected
parsable uint64_t from \"Number of Retries\", but got GeneralParsingError
(Parsing Error:0)");
CHECK_FALSE(mock_data_lake_storage_client_ptr_->getPassedFetchParams().number_of_retries);
}
diff --git a/extensions/llamacpp/tests/RunLlamaCppInferenceTests.cpp
b/extensions/llamacpp/tests/RunLlamaCppInferenceTests.cpp
index ec507af33..13754f1f5 100644
--- a/extensions/llamacpp/tests/RunLlamaCppInferenceTests.cpp
+++ b/extensions/llamacpp/tests/RunLlamaCppInferenceTests.cpp
@@ -229,7 +229,7 @@ TEST_CASE("Invalid values for optional double type
properties throw exception")
REQUIRE_THROWS(controller.trigger(minifi::test::InputFlowFileData{.content =
"42", .attributes = {}}));
CHECK(minifi::test::utils::verifyLogLinePresenceInPollTime(1s,
- fmt::format("Expected parsable float from RunLlamaCppInference::{}, but
got GeneralParsingError (Parsing Error:0)", property_name)));
+ fmt::format("Expected parsable float from \"{}\", but got
GeneralParsingError (Parsing Error:0)", property_name)));
}
TEST_CASE("Top K property empty and invalid values are handled properly") {
@@ -252,7 +252,7 @@ TEST_CASE("Top K property empty and invalid values are
handled properly") {
REQUIRE(controller.getProcessor()->setProperty(processors::RunLlamaCppInference::TopK.name,
"invalid_value"));
REQUIRE_THROWS(controller.trigger(minifi::test::InputFlowFileData{.content
= "42", .attributes = {}}));
CHECK(minifi::test::utils::verifyLogLinePresenceInPollTime(1s,
- "Expected parsable int64_t from
\"RunLlamaCppInference::Top K\", but got GeneralParsingError (Parsing
Error:0)"));
+ "Expected parsable int64_t from \"Top K\", but got
GeneralParsingError (Parsing Error:0)"));
}
}
diff --git a/extensions/mqtt/tests/ConsumeMQTTTests.cpp
b/extensions/mqtt/tests/ConsumeMQTTTests.cpp
index 8b02e2df1..8b63b1aec 100644
--- a/extensions/mqtt/tests/ConsumeMQTTTests.cpp
+++ b/extensions/mqtt/tests/ConsumeMQTTTests.cpp
@@ -120,13 +120,13 @@ using namespace std::literals::chrono_literals;
TEST_CASE_METHOD(ConsumeMqttTestFixture, "ConsumeMQTTTest_EmptyTopic",
"[consumeMQTTTest]") {
REQUIRE(test_controller_.plan->setProperty(consume_mqtt_processor_,
minifi::processors::AbstractMQTTProcessor::BrokerURI.name, "127.0.0.1:1883"));
REQUIRE_THROWS_WITH(test_controller_.plan->scheduleProcessor(consume_mqtt_processor_),
- Catch::Matchers::EndsWith("Expected valid value from
\"TestConsumeMQTTProcessor::Topic\", but got PropertyNotSet (Property
Error:2)"));
+ Catch::Matchers::EndsWith("Expected valid value from \"Topic\", but got
PropertyNotSet (Property Error:2)"));
}
TEST_CASE_METHOD(ConsumeMqttTestFixture, "ConsumeMQTTTest_EmptyBrokerURI",
"[consumeMQTTTest]") {
REQUIRE(test_controller_.plan->setProperty(consume_mqtt_processor_,
minifi::processors::ConsumeMQTT::Topic.name, "mytopic"));
REQUIRE_THROWS_WITH(test_controller_.plan->scheduleProcessor(consume_mqtt_processor_),
- Catch::Matchers::EndsWith("Expected valid value from
\"TestConsumeMQTTProcessor::Broker URI\", but got PropertyNotSet (Property
Error:2)"));
+ Catch::Matchers::EndsWith("Expected valid value from \"Broker URI\", but
got PropertyNotSet (Property Error:2)"));
}
TEST_CASE_METHOD(ConsumeMqttTestFixture,
"ConsumeMQTTTest_DurableSessionWithID", "[consumeMQTTTest]") {
diff --git a/extensions/mqtt/tests/PublishMQTTTests.cpp
b/extensions/mqtt/tests/PublishMQTTTests.cpp
index 98ff17280..62205ae84 100644
--- a/extensions/mqtt/tests/PublishMQTTTests.cpp
+++ b/extensions/mqtt/tests/PublishMQTTTests.cpp
@@ -80,7 +80,7 @@ TEST_CASE_METHOD(PublishMQTTTestFixture,
"PublishMQTTTest_EmptyTopic", "[publish
TEST_CASE_METHOD(PublishMQTTTestFixture, "PublishMQTTTest_EmptyBrokerURI",
"[publishMQTTTest]") {
REQUIRE(test_controller_.plan->setProperty(publish_mqtt_processor_,
minifi::processors::PublishMQTT::Topic.name, "mytopic"));
REQUIRE_THROWS_WITH(test_controller_.plan->scheduleProcessor(publish_mqtt_processor_),
- Catch::Matchers::EndsWith("Expected valid value from
\"TestPublishMQTTProcessor::Broker URI\", but got PropertyNotSet (Property
Error:2)"));
+ Catch::Matchers::EndsWith("Expected valid value from \"Broker URI\", but
got PropertyNotSet (Property Error:2)"));
}
TEST_CASE_METHOD(PublishMQTTTestFixture, "PublishMQTTTest_EmptyClientID_V_3",
"[publishMQTTTest]") {
diff --git a/extensions/standard-processors/tests/unit/SegmentContentTests.cpp
b/extensions/standard-processors/tests/unit/SegmentContentTests.cpp
index bb74db80d..6d86feadb 100644
--- a/extensions/standard-processors/tests/unit/SegmentContentTests.cpp
+++ b/extensions/standard-processors/tests/unit/SegmentContentTests.cpp
@@ -62,11 +62,11 @@ TEST_CASE("Invalid segmentSize tests") {
SECTION("foo") {
REQUIRE(segment_content->setProperty(SegmentContent::SegmentSize.name,
"foo"));
- REQUIRE_THROWS_WITH(controller.trigger("bar"), "Expected parsable data
size from \"SegmentContent::Segment Size\", but got GeneralParsingError
(Parsing Error:0)");
+ REQUIRE_THROWS_WITH(controller.trigger("bar"), "Expected parsable data
size from \"Segment Size\", but got GeneralParsingError (Parsing Error:0)");
}
SECTION("10 foo") {
REQUIRE(segment_content->setProperty(SegmentContent::SegmentSize.name, "10
foo"));
- REQUIRE_THROWS_WITH(controller.trigger("bar"), "Expected parsable data
size from \"SegmentContent::Segment Size\", but got GeneralParsingError
(Parsing Error:0)");
+ REQUIRE_THROWS_WITH(controller.trigger("bar"), "Expected parsable data
size from \"Segment Size\", but got GeneralParsingError (Parsing Error:0)");
}
SECTION("0") {
REQUIRE(segment_content->setProperty(SegmentContent::SegmentSize.name,
"0"));
diff --git a/extensions/standard-processors/tests/unit/SplitContentTests.cpp
b/extensions/standard-processors/tests/unit/SplitContentTests.cpp
index 57a13e5c7..d24edc9b5 100644
--- a/extensions/standard-processors/tests/unit/SplitContentTests.cpp
+++ b/extensions/standard-processors/tests/unit/SplitContentTests.cpp
@@ -39,7 +39,7 @@ TEST_CASE("WithoutByteSequence") {
REQUIRE(split_content->setProperty(SplitContent::KeepByteSequence.name,
"true"));
REQUIRE(split_content->setProperty(SplitContent::ByteSequenceLocationProperty.name,
std::string{magic_enum::enum_name(SplitContent::ByteSequenceLocation::Leading)}));
- REQUIRE_THROWS_WITH(controller.trigger("rub-a-dub-dub"), "Expected valid
value from \"SplitContent::Byte Sequence\", but got PropertyNotSet (Property
Error:2)");
+ REQUIRE_THROWS_WITH(controller.trigger("rub-a-dub-dub"), "Expected valid
value from \"Byte Sequence\", but got PropertyNotSet (Property Error:2)");
}
TEST_CASE("EmptyFlowFile") {
diff --git a/extensions/standard-processors/tests/unit/SplitTextTests.cpp
b/extensions/standard-processors/tests/unit/SplitTextTests.cpp
index 53c437627..f3ae69673 100644
--- a/extensions/standard-processors/tests/unit/SplitTextTests.cpp
+++ b/extensions/standard-processors/tests/unit/SplitTextTests.cpp
@@ -193,7 +193,7 @@ void runSplitTextTest(const std::string& input, const
std::vector<ExpectedSplitT
TEST_CASE("Line Split Count property is required") {
SingleProcessorTestController
controller{minifi::test::utils::make_processor<processors::SplitText>("SplitText")};
- REQUIRE_THROWS_WITH(controller.trigger("", {}), "Expected parsable uint64_t
from \"SplitText::Line Split Count\", but got PropertyNotSet (Property
Error:2)");
+ REQUIRE_THROWS_WITH(controller.trigger("", {}), "Expected parsable uint64_t
from \"Line Split Count\", but got PropertyNotSet (Property Error:2)");
}
TEST_CASE("Line Split Count property can only be 0 if Maximum Fragment Size is
set") {
diff --git a/libminifi/src/minifi-c.cpp b/libminifi/src/minifi-c.cpp
index 3fc5c1ec4..b085dbf66 100644
--- a/libminifi/src/minifi-c.cpp
+++ b/libminifi/src/minifi-c.cpp
@@ -346,12 +346,6 @@ 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(name));
-}
-
MinifiBool MinifiProcessContextHasNonEmptyProperty(MinifiProcessContext*
context, MinifiStringView property_name) {
gsl_Assert(context != MINIFI_NULL);
return
reinterpret_cast<minifi::core::ProcessContext*>(context)->hasNonEmptyProperty(toString(property_name));
@@ -421,15 +415,27 @@ MINIFI_OWNED MinifiFlowFile*
MinifiProcessSessionCreate(MinifiProcessSession* se
return MINIFI_NULL;
}
-void MinifiProcessSessionTransfer(MinifiProcessSession* session, MINIFI_OWNED
MinifiFlowFile* flowfile, MinifiStringView relationship_name) {
+MinifiStatus MinifiProcessSessionTransfer(MinifiProcessSession* session,
MINIFI_OWNED MinifiFlowFile* flowfile, MinifiStringView relationship_name) {
+ gsl_Assert(session != MINIFI_NULL);
gsl_Assert(flowfile != MINIFI_NULL);
- reinterpret_cast<minifi::core::ProcessSession*>(session)->transfer(
- *reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile),
minifi::core::Relationship{toString(relationship_name), ""});
+ try {
+ reinterpret_cast<minifi::core::ProcessSession*>(session)->transfer(
+ *reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile),
minifi::core::Relationship{toString(relationship_name), ""});
+ return MINIFI_STATUS_SUCCESS;
+ } catch (...) {
+ return MINIFI_STATUS_UNKNOWN_ERROR;
+ }
}
-void MinifiProcessSessionRemove(MinifiProcessSession* session, MINIFI_OWNED
MinifiFlowFile* flowfile) {
+MinifiStatus MinifiProcessSessionRemove(MinifiProcessSession* session,
MINIFI_OWNED MinifiFlowFile* flowfile) {
+ gsl_Assert(session != MINIFI_NULL);
gsl_Assert(flowfile != MINIFI_NULL);
-
reinterpret_cast<minifi::core::ProcessSession*>(session)->remove(*reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile));
+ try {
+
reinterpret_cast<minifi::core::ProcessSession*>(session)->remove(*reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile));
+ return MINIFI_STATUS_SUCCESS;
+ } catch (...) {
+ return MINIFI_STATUS_UNKNOWN_ERROR;
+ }
}
MinifiStatus MinifiProcessSessionRead(MinifiProcessSession* session,
MinifiFlowFile* flowfile, int64_t(*cb)(void* user_ctx, MinifiInputStream*),
void* user_ctx) {
@@ -488,7 +494,7 @@ void MinifiStatusToString(MinifiStatus status,
void(*cb)(void* user_ctx, MinifiS
cb(user_ctx, minifiStringView(message));
}
-void MinifiFlowFileSetAttribute(MinifiProcessSession* session, MinifiFlowFile*
flowfile, MinifiStringView attribute_name, const MinifiStringView*
attribute_value) {
+MinifiStatus MinifiFlowFileSetAttribute(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) {
@@ -497,6 +503,7 @@ void MinifiFlowFileSetAttribute(MinifiProcessSession*
session, MinifiFlowFile* f
reinterpret_cast<minifi::core::ProcessSession*>(session)->putAttribute(
**reinterpret_cast<std::shared_ptr<minifi::core::FlowFile>*>(flowfile),
toString(attribute_name), toString(*attribute_value));
}
+ return MINIFI_STATUS_SUCCESS;
}
MinifiBool MinifiFlowFileGetAttribute(MinifiProcessSession* session,
MinifiFlowFile* flowfile, MinifiStringView attribute_name,
diff --git a/minifi-api/include/minifi-c/minifi-c.h
b/minifi-api/include/minifi-c/minifi-c.h
index 610395830..0b2a110c8 100644
--- a/minifi-api/include/minifi-c/minifi-c.h
+++ b/minifi-api/include/minifi-c/minifi-c.h
@@ -222,7 +222,6 @@ MINIFI_OWNED MinifiPublishedMetrics*
MinifiPublishedMetricsCreate(size_t count,
MinifiStatus MinifiProcessContextGetProperty(MinifiProcessContext* context,
MinifiStringView property_name, MinifiFlowFile* flowfile,
void(*cb)(void* user_ctx,
MinifiStringView property_value), void* user_ctx);
-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,
@@ -236,8 +235,8 @@ MinifiLogLevel MinifiLoggerLevel(MinifiLogger*);
MINIFI_OWNED MinifiFlowFile* MinifiProcessSessionGet(MinifiProcessSession*);
MINIFI_OWNED MinifiFlowFile* MinifiProcessSessionCreate(MinifiProcessSession*
session, MinifiFlowFile* parent_flowfile);
-void MinifiProcessSessionTransfer(MinifiProcessSession* session, MINIFI_OWNED
MinifiFlowFile* flowfile, MinifiStringView relationship_name);
-void MinifiProcessSessionRemove(MinifiProcessSession* session, MINIFI_OWNED
MinifiFlowFile* flowfile);
+MinifiStatus MinifiProcessSessionTransfer(MinifiProcessSession* session,
MINIFI_OWNED MinifiFlowFile* flowfile, MinifiStringView relationship_name);
+MinifiStatus MinifiProcessSessionRemove(MinifiProcessSession* session,
MINIFI_OWNED MinifiFlowFile* flowfile);
MinifiStatus MinifiProcessSessionRead(MinifiProcessSession*, MinifiFlowFile*,
int64_t(*cb)(void* user_ctx, MinifiInputStream*), void* user_ctx);
MinifiStatus MinifiProcessSessionWrite(MinifiProcessSession*, MinifiFlowFile*,
int64_t(*cb)(void* user_ctx, MinifiOutputStream*), void* user_ctx);
@@ -251,7 +250,7 @@ int64_t MinifiOutputStreamWrite(MinifiOutputStream* stream,
const char* data, si
void MinifiStatusToString(MinifiStatus, void(*cb)(void* user_ctx,
MinifiStringView str), void* user_ctx);
-void MinifiFlowFileSetAttribute(MinifiProcessSession* session, MinifiFlowFile*
flowfile, MinifiStringView attribute_name, const MinifiStringView*
attribute_value);
+MinifiStatus MinifiFlowFileSetAttribute(MinifiProcessSession* session,
MinifiFlowFile* flowfile, MinifiStringView attribute_name, const
MinifiStringView* attribute_value);
MinifiBool MinifiFlowFileGetAttribute(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);
diff --git a/minifi-api/minifi-c-api.def b/minifi-api/minifi-c-api.def
index 11c07093c..d45c31996 100644
--- a/minifi-api/minifi-c-api.def
+++ b/minifi-api/minifi-c-api.def
@@ -4,7 +4,6 @@ EXPORTS
MinifiPublishedMetricsCreate
MinifiProcessContextGetControllerService
MinifiProcessContextGetProperty
- MinifiProcessContextGetProcessorName
MinifiProcessContextHasNonEmptyProperty
MinifiControllerServiceContextGetProperty
MinifiLoggerSetMaxLogSize
