[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r456291644
##
File path: libminifi/include/core/PropertyValidation.h
##
@@ -259,6 +259,22 @@ class UnsignedLongValidator : public PropertyValidator {
}
};
+class NonBlankValidator : public PropertyValidator {
+ public:
+ explicit NonBlankValidator(const std::string& name)
+ : PropertyValidator(name) {
+ }
+ ~NonBlankValidator() override = default;
+
+ ValidationResult validate(const std::string& subject, const
std::shared_ptr& input) const final {
+return validate(subject, input->getStringValue());
+ }
+
+ ValidationResult validate(const std::string& subject, const std::string&
input) const final {
+return
ValidationResult::Builder::createBuilder().withSubject(subject).withInput(input).isValid(utils::StringUtils::trimLeft(input).size()).build();
Review comment:
Should not be a factor in readibility.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r454397770
##
File path: libminifi/include/core/PropertyValidation.h
##
@@ -259,6 +259,22 @@ class UnsignedLongValidator : public PropertyValidator {
}
};
+class NonBlankValidator : public PropertyValidator {
+ public:
+ explicit NonBlankValidator(const std::string& name)
+ : PropertyValidator(name) {
+ }
+ ~NonBlankValidator() override = default;
+
+ ValidationResult validate(const std::string& subject, const
std::shared_ptr& input) const final {
+return validate(subject, input->getStringValue());
Review comment:
I thought yaml parsing ignored padding, so
```yaml
name: A
```
was the same as
```yaml
name: A
```
Will add trimming for the string.
##
File path: libminifi/include/core/PropertyValidation.h
##
@@ -259,6 +259,22 @@ class UnsignedLongValidator : public PropertyValidator {
}
};
+class NonBlankValidator : public PropertyValidator {
+ public:
+ explicit NonBlankValidator(const std::string& name)
+ : PropertyValidator(name) {
+ }
+ ~NonBlankValidator() override = default;
+
+ ValidationResult validate(const std::string& subject, const
std::shared_ptr& input) const final {
+return validate(subject, input->getStringValue());
Review comment:
I thought yaml parsing ignored padding, so
```yaml
name: A
```
was the same as
```yaml
name: A
```
**Will add trimming for the string.**
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r454397770
##
File path: libminifi/include/core/PropertyValidation.h
##
@@ -259,6 +259,22 @@ class UnsignedLongValidator : public PropertyValidator {
}
};
+class NonBlankValidator : public PropertyValidator {
+ public:
+ explicit NonBlankValidator(const std::string& name)
+ : PropertyValidator(name) {
+ }
+ ~NonBlankValidator() override = default;
+
+ ValidationResult validate(const std::string& subject, const
std::shared_ptr& input) const final {
+return validate(subject, input->getStringValue());
Review comment:
I thought yaml parsing ignored padding, so
```yaml
name: A
```
was the same as
```yaml
name: A
```
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r454388997
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
Review comment:
Added non-blank validator.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r454373723
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r454373723
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r454235239
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r452136985
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+ using GenerateFlowFile =
org::apache::nifi::minifi::processors::GenerateFlowFile;
+ using UpdateAttribute =
org::apache::nifi::minifi::processors::UpdateAttribute;
+ using RetryFlowFile = org::apache::nifi::minifi::processors::RetryFlowFile;
+ using PutFile = org::apache::nifi::minifi::processors::PutFile;
+ using LogAttribute = org::apache::nifi::minifi::processors::LogAttribute;
+ RetryFlowFileTest() :
+logTestController_(LogTestController::getInstance()),
+
logger_(logging::LoggerFactory::getLogger())
{
+reInitialize();
+ }
+ virtual ~RetryFlowFileTest() {
+logTestController_.reset();
+ }
+
+ protected:
+ void reInitialize() {
+testController_.reset(new TestController());
+plan_ = testController_->createPlan();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+ }
+
Review comment:
Added Jira here:
https://issues.apache.org/jira/browse/MINIFICPP-1285
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r451473323
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r451465600
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r451462518
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r451460991
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
Review comment:
[Same as
above.](http://nifi.apache.org/docs/nifi-docs/components/org.apache.nifi/nifi-standard-nar/1.11.4/org.apache.nifi.processors.standard.RetryFlowFile/index.html)
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r451460587
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
Review comment:
The NiFi implementation has this default value set:
http://nifi.apache.org/docs/nifi-docs/components/org.apache.nifi/nifi-standard-nar/1.11.4/org.apache.nifi.processors.standard.RetryFlowFile/index.html
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,183 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
Review comment:
Same as above.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r450110731
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r447732749
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r447569405
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+ using GenerateFlowFile =
org::apache::nifi::minifi::processors::GenerateFlowFile;
+ using UpdateAttribute =
org::apache::nifi::minifi::processors::UpdateAttribute;
+ using RetryFlowFile = org::apache::nifi::minifi::processors::RetryFlowFile;
+ using PutFile = org::apache::nifi::minifi::processors::PutFile;
+ using LogAttribute = org::apache::nifi::minifi::processors::LogAttribute;
+ RetryFlowFileTest() :
+logTestController_(LogTestController::getInstance()),
+
logger_(logging::LoggerFactory::getLogger())
{
+reInitialize();
+ }
+ virtual ~RetryFlowFileTest() {
+logTestController_.reset();
+ }
+
+ protected:
+ void reInitialize() {
+testController_.reset(new TestController());
+plan_ = testController_->createPlan();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+ }
+
Review comment:
Thanks, sorry for using the word "rules allow it", I should have written
"if others think there is added value in moving this to comment in the
codebase".
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r446196483
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r446196292
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445436769
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445452111
##
File path: libminifi/test/TestBase.h
##
@@ -251,6 +251,8 @@ class TestPlan {
std::shared_ptr addProcessor(const std::string
_name, utils::Identifier& uuid, const std::string , const
std::initializer_list& relationships,
bool linkToPrevious = false);
+ std::shared_ptr addConnection(const
std::shared_ptr source_proc, const core::Relationship&
source_relationship, const std::shared_ptr& destination_proc);
Review comment:
Good catch, corrected.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445481189
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,226 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/RegexUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
Review comment:
Replaced.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445478959
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445478959
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445477385
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445447521
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445443361
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445471740
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445455005
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445439076
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445463675
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445457106
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,226 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/RegexUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
Review comment:
Yeah, this was a stupid idea for what it is worth. `FileUtils` is a
class, so its methods cannot be used with `using`, so instead of stepping back
I went on with this. I will put an alias to `FileUtils` here instead :)
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445457106
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,226 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/RegexUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
Review comment:
Yeah, this was a stupid idea for what it is worth. `FileUtils` is a
class, so its methods cannot be used with `using`, so instead of stepping back
I went on with this. I will put an alias to FileUtils here instead :)
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445455005
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445452111
##
File path: libminifi/test/TestBase.h
##
@@ -251,6 +251,8 @@ class TestPlan {
std::shared_ptr addProcessor(const std::string
_name, utils::Identifier& uuid, const std::string , const
std::initializer_list& relationships,
bool linkToPrevious = false);
+ std::shared_ptr addConnection(const
std::shared_ptr source_proc, const core::Relationship&
source_relationship, const std::shared_ptr& destination_proc);
Review comment:
Good catch.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445451980
##
File path: libminifi/test/TestBase.h
##
@@ -251,6 +251,8 @@ class TestPlan {
std::shared_ptr addProcessor(const std::string
_name, utils::Identifier& uuid, const std::string , const
std::initializer_list& relationships,
bool linkToPrevious = false);
+ std::shared_ptr addConnection(const
std::shared_ptr source_proc, const core::Relationship&
source_relationship, const std::shared_ptr& destination_proc);
Review comment:
Well, this reflects the timeline of events.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445451400
##
File path: libminifi/test/TestBase.cpp
##
@@ -168,6 +168,30 @@ std::shared_ptr
TestPlan::addProcessor(const std::string
return addProcessor(processor_name, uuid, name, relationships,
linkToPrevious);
}
+std::shared_ptr TestPlan::addConnection(const
std::shared_ptr source_proc, const core::Relationship&
source_relationship, const std::shared_ptr& destination_proc) {
+ std::stringstream connection_name;
+ connection_name << source_proc->getUUIDStr() << "-to-" <<
destination_proc->getUUIDStr();
Review comment:
`TestPlan` does it like this. I would like to refactor this class at
some point anyway, want me to change the names then?
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445449972
##
File path: extensions/standard-processors/processors/RetryFlowFile.h
##
@@ -0,0 +1,121 @@
+/**
+ *
+ * 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.
+ */
+#ifndef EXTENSIONS_STANDARD_PROCESSORS_PROCESSORS_RETRYFLOWFILE_H_
+#define EXTENSIONS_STANDARD_PROCESSORS_PROCESSORS_RETRYFLOWFILE_H_
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "core/state/nodes/MetricsBase.h"
+#include "FlowFileRecord.h"
+#include "core/Processor.h"
+#include "core/ProcessSession.h"
+#include "core/Core.h"
+#include "core/Resource.h"
+#include "core/logging/LoggerConfiguration.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+class RetryFlowFile : public core::Processor {
+ public:
+ explicit RetryFlowFile(std::string name, utils::Identifier uuid =
utils::Identifier())
+ : Processor(name, uuid),
+logger_(logging::LoggerFactory::getLogger()) {}
+ // Destructor
+ virtual ~RetryFlowFile() = default;
+ // Processor Name
+ static constexpr char const* ProcessorName = "RetryFlowFile";
+ // Supported Properties
+ static core::Property RetryAttribute;
+ static core::Property MaximumRetries;
+ static core::Property PenalizeRetries;
+ static core::Property FailOnNonNumericalOverwrite;
+ static core::Property ReuseMode;
+ // Supported Relationships
+ static core::Relationship Retry;
+ static core::Relationship RetriesExceeded;
+ static core::Relationship Failure;
+ // ReuseMode allowable values
+ static constexpr char const* FAIL_ON_REUSE = "Fail on Reuse";
+ static constexpr char const* WARN_ON_REUSE = "Warn on Reuse";
+ static constexpr char const* RESET_REUSE = "Reset Reuse";
+
+ public:
+ bool supportsDynamicProperties() override {
+return true;
+ }
+ /**
+ * Function that's executed when the processor is scheduled.
+ * @param context process context.
+ * @param sessionFactory process session factory that is used when creating
+ * ProcessSession objects.
+ */
+ void onSchedule(core::ProcessContext* context, core::ProcessSessionFactory*
/* sessionFactory */) override;
+ /**
+ * Execution trigger for the RetryFlowFile Processor
+ * @param context processor context
+ * @param session processor session reference.
+ */
+ void onTrigger(core::ProcessContext* context, core::ProcessSession* session)
override;
+
+ // Initialize, overwrite by NiFi RetryFlowFile
+ void initialize() override;
+
+
+ private:
+ void readDynamicPropertyKeys(core::ProcessContext* context);
+ // Returns (1, true) on non-numerical or out-of-bounds retry value
+ std::pair getRetryPropertyValue(const
std::shared_ptr& flow_file);
+ // Returns true on fail on reuse scenario
+ bool updateUUIDMarkerAndCheckFailOnReuse(const
std::shared_ptr& flow_file);
+ bool setRetriesExceededAttributesOnFlowFile(core::ProcessContext* context,
const std::shared_ptr& flow_file);
+
+ std::string retry_attribute_;
+ uint64_t maximum_retries_ = 3; // The real default value is set by the
default on the MaximumRetries property
+ bool penalize_retries_ = true; // The real default value is set by the
default on the PenalizeRetries property
+ bool fail_on_non_numerical_overwrite_ = false; // The real default value is
set by the default on the FailOnNonNumericalOverwrite property
+ std::string reuse_mode_;
Review comment:
This is definitely not worth the trouble. There is already a list of
strings of allowable values, adding an enum and keeping the two sync is just an
extra layer of complexity.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445448048
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445447521
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445446325
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445444377
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445443865
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445443361
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445439076
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445436769
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445434347
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445434347
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445434347
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445433610
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445429826
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r445429826
##
File path: extensions/standard-processors/processors/RetryFlowFile.cpp
##
@@ -0,0 +1,212 @@
+/**
+ *
+ * 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.
+ */
+
+#include "RetryFlowFile.h"
+
+#include "core/PropertyValidation.h"
+
+namespace org {
+namespace apache {
+namespace nifi {
+namespace minifi {
+namespace processors {
+
+core::Property
RetryFlowFile::RetryAttribute(core::PropertyBuilder::createProperty("Retry
Attribute")
+->withDescription(
+"The name of the attribute that contains the current retry count for
the FlowFile."
+"WARNING: If the name matches an attribute already on the FlowFile
that does not contain a numerical value, "
+"the processor will either overwrite that attribute with '1' or fail
based on configuration.")
+->withDefaultValue("flowfile.retries")
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::MaximumRetries(core::PropertyBuilder::createProperty("Maximum
Retries")
+->withDescription("The maximum number of times a FlowFile can be retried
before being passed to the 'retries_exceeded' relationship.")
+->withDefaultValue(3)
+->supportsExpressionLanguage(true)
+->build());
+
+core::Property
RetryFlowFile::PenalizeRetries(core::PropertyBuilder::createProperty("Penalize
Retries")
+ ->withDescription("If set to 'true', this Processor will penalize input
FlowFiles before passing them to the 'retry' relationship. This does not apply
to the 'retries_exceeded' relationship.")
+ ->withDefaultValue(true)
+ ->build());
+
+core::Property
RetryFlowFile::FailOnNonNumericalOverwrite(core::PropertyBuilder::createProperty("Fail
on Non-numerical Overwrite")
+->withDescription("If the FlowFile already has the attribute defined in
'Retry Attribute' that is *not* a number, fail the FlowFile instead of
resetting that value to '1'")
+->withDefaultValue(false)
+->build());
+
+core::Property
RetryFlowFile::ReuseMode(core::PropertyBuilder::createProperty("Reuse Mode")
+->withDescription(
+"Defines how the Processor behaves if the retry FlowFile has a
different retry UUID than "
+"the instance that received the FlowFile. This generally means that
the attribute was "
+"not reset after being successfully retried by a previous instance of
this processor.")
+->withAllowableValues({FAIL_ON_REUSE, WARN_ON_REUSE,
RESET_REUSE})
+->withDefaultValue(FAIL_ON_REUSE)
+->build());
+
+core::Relationship RetryFlowFile::Retry("retry",
+ "Input FlowFile has not exceeded the configured maximum retry count, pass
this relationship back to the input Processor to create a limited feedback
loop.");
+core::Relationship RetryFlowFile::RetriesExceeded("retries_exceeded",
+ "Input FlowFile has exceeded the configured maximum retry count, do not pass
this relationship back to the input Processor to terminate the limited feedback
loop.");
+core::Relationship RetryFlowFile::Failure("failure",
+"The processor is configured such that a non-numerical value on 'Retry
Attribute' results in a failure instead of resetting "
+"that value to '1'. This will immediately terminate the limited feedback
loop. Might also include when 'Maximum Retries' contains "
+" attribute expression language that does not resolve to an Integer.");
+
+void RetryFlowFile::initialize() {
+ setSupportedProperties({
+RetryAttribute,
+MaximumRetries,
+PenalizeRetries,
+FailOnNonNumericalOverwrite,
+ReuseMode,
+ });
+ setSupportedRelationships({
+Retry,
+RetriesExceeded,
+Failure,
+ });
+}
+
+void RetryFlowFile::onSchedule(core::ProcessContext* context,
core::ProcessSessionFactory* /* sessionFactory */) {
+ context->getProperty(RetryAttribute.getName(), retry_attribute_);
+ context->getProperty(MaximumRetries.getName(), maximum_retries_);
+ context->getProperty(PenalizeRetries.getName(), penalize_retries_);
+ context->getProperty(FailOnNonNumericalOverwrite.getName(),
fail_on_non_numerical_overwrite_);
+ context->getProperty(ReuseMode.getName(),
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r444904692
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+ using GenerateFlowFile =
org::apache::nifi::minifi::processors::GenerateFlowFile;
+ using UpdateAttribute =
org::apache::nifi::minifi::processors::UpdateAttribute;
+ using RetryFlowFile = org::apache::nifi::minifi::processors::RetryFlowFile;
+ using PutFile = org::apache::nifi::minifi::processors::PutFile;
+ using LogAttribute = org::apache::nifi::minifi::processors::LogAttribute;
+ RetryFlowFileTest() :
+logTestController_(LogTestController::getInstance()),
+
logger_(logging::LoggerFactory::getLogger())
{
+reInitialize();
+ }
+ virtual ~RetryFlowFileTest() {
+logTestController_.reset();
+ }
+
+ protected:
+ void reInitialize() {
+testController_.reset(new TestController());
+plan_ = testController_->createPlan();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+ }
+
Review comment:
Here is a diagram for the test layout:
https://user-images.githubusercontent.com/64011968/85590760-f56fd600-b644-11ea-89a9-621e1fbb0a31.png;>
- `UpdateAttribute` is used to set the retry attribute and the marker
processor uuid
- `PutFile` is used to check which outbound relationship was choosen by
`RetryFlowFile`
- `LogAttribute` is used for checking dynamic properties added on
`retries_exceeded`
I also have an ASCII art version of the plan, which I can add as a comment
if the rules allow it.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r444904692
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+ using GenerateFlowFile =
org::apache::nifi::minifi::processors::GenerateFlowFile;
+ using UpdateAttribute =
org::apache::nifi::minifi::processors::UpdateAttribute;
+ using RetryFlowFile = org::apache::nifi::minifi::processors::RetryFlowFile;
+ using PutFile = org::apache::nifi::minifi::processors::PutFile;
+ using LogAttribute = org::apache::nifi::minifi::processors::LogAttribute;
+ RetryFlowFileTest() :
+logTestController_(LogTestController::getInstance()),
+
logger_(logging::LoggerFactory::getLogger())
{
+reInitialize();
+ }
+ virtual ~RetryFlowFileTest() {
+logTestController_.reset();
+ }
+
+ protected:
+ void reInitialize() {
+testController_.reset(new TestController());
+plan_ = testController_->createPlan();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+ }
+
Review comment:
Here is a diagram for the test layout:
https://user-images.githubusercontent.com/64011968/85590194-7da1ab80-b644-11ea-94c1-b0b0bda898f5.png;>
- `UpdateAttribute` is used to set the retry attribute and the marker
processur uuid
- `PutFile` is used to check which outbound relationship was choosen by
`RetryFlowFile`
- `LogAttribute` is used for checking dynamic properties added on
`retries_exceeded`
I also have an ASCII art version of the plan, which I can add as a comment
if the rules allow it.
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r444904692
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+ using GenerateFlowFile =
org::apache::nifi::minifi::processors::GenerateFlowFile;
+ using UpdateAttribute =
org::apache::nifi::minifi::processors::UpdateAttribute;
+ using RetryFlowFile = org::apache::nifi::minifi::processors::RetryFlowFile;
+ using PutFile = org::apache::nifi::minifi::processors::PutFile;
+ using LogAttribute = org::apache::nifi::minifi::processors::LogAttribute;
+ RetryFlowFileTest() :
+logTestController_(LogTestController::getInstance()),
+
logger_(logging::LoggerFactory::getLogger())
{
+reInitialize();
+ }
+ virtual ~RetryFlowFileTest() {
+logTestController_.reset();
+ }
+
+ protected:
+ void reInitialize() {
+testController_.reset(new TestController());
+plan_ = testController_->createPlan();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+ }
+
Review comment:
Here is an ASCII art diagram for the layout:
```
++
| GenerateFlowFile |
++
| success |
++
|
v +---+
+---+ | PutFile |
| UpdateAttribute | +---+
+---+ +->+ success +--+
| success | | +---+ |
+---+ | |
|| +---+ | ++
v| +--->+ PutFile | | | LogAttribute |
++ | |+---+ | ++
| RetryFlowFile| | || success +--+-->+ success+-X
++ | |+---+ | ++
|retry +--+ | |
++|+---+ |
| retries_exceeded ++ +->+ PutFile | |
++ | +---+ |
| failure +--+ | success +--+
++ +---+
```
- `UpdateAttribute` is used to set the retry attribute and the marker
processur uuid
- `PutFile` is used to check which outbound relationship was choosen by
`RetryFlowFile`
- `LogAttribute` is used for checking dynamic properties added on
`retries_exceeded`
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
[GitHub] [nifi-minifi-cpp] hunyadi-dev commented on a change in pull request #821: MINIFICPP-1251 - Implement and test RetryFlowFile processor
hunyadi-dev commented on a change in pull request #821:
URL: https://github.com/apache/nifi-minifi-cpp/pull/821#discussion_r444904692
##
File path: extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
##
@@ -0,0 +1,221 @@
+/**
+ *
+ * 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.
+ */
+
+#define CATCH_CONFIG_MAIN
+
+#include
+#include
+#include
+#include
+
+#include "TestBase.h"
+
+#include "processors/GenerateFlowFile.h"
+#include "processors/UpdateAttribute.h"
+#include "processors/RetryFlowFile.h"
+#include "processors/PutFile.h"
+#include "processors/LogAttribute.h"
+#include "utils/file/FileUtils.h"
+#include "utils/OptionalUtils.h"
+#include "utils/TestUtils.h"
+
+namespace {
+using org::apache::nifi::minifi::utils::createTempDir;
+using org::apache::nifi::minifi::utils::optional;
+
+std::vector> list_dir_all(const
std::string& dir, const std::shared_ptr& logger, bool
recursive = true) {
+ return org::apache::nifi::minifi::utils::file::FileUtils::list_dir_all(dir,
logger, recursive);
+}
+
+class RetryFlowFileTest {
+ public:
+ using Processor = org::apache::nifi::minifi::core::Processor;
+ using GenerateFlowFile =
org::apache::nifi::minifi::processors::GenerateFlowFile;
+ using UpdateAttribute =
org::apache::nifi::minifi::processors::UpdateAttribute;
+ using RetryFlowFile = org::apache::nifi::minifi::processors::RetryFlowFile;
+ using PutFile = org::apache::nifi::minifi::processors::PutFile;
+ using LogAttribute = org::apache::nifi::minifi::processors::LogAttribute;
+ RetryFlowFileTest() :
+logTestController_(LogTestController::getInstance()),
+
logger_(logging::LoggerFactory::getLogger())
{
+reInitialize();
+ }
+ virtual ~RetryFlowFileTest() {
+logTestController_.reset();
+ }
+
+ protected:
+ void reInitialize() {
+testController_.reset(new TestController());
+plan_ = testController_->createPlan();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+logTestController_.setDebug();
+ }
+
Review comment:
Here is an ASCII art diagram for the layout:
```
++
| GenerateFlowFile |
++
| success |
++
|
v +---+
+---+ | PutFile |
| UpdateAttribute | +---+
+---+ +->+ success +--+
| success | | +---+ |
+---+ | |
|| +---+ | ++
v| +--->+ PutFile | | | LogAttribute |
++ | |+---+ | ++
| RetryFlowFile| | || success +->+ success+-X
++ | |+---+ | ++
|retry +--+ | |
++|+---+ |
| retries_exceeded ++ +->+ PutFile | |
++ | +---+ |
| failure +--+ | success +--+
++ +---+
```
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
