fix

Author: martinzink

behave_framework/src/minifi_behave/steps/checking_steps.py

@@ -119,7 +119,7 @@ def verify_minifi_logs_match_regex(context, regex, duration):
 @step('no errors were generated on the http-proxy regarding "{url}"')
 def verify_no_errors_on_http_proxy(context: MinifiTestContext, url: str):
     http_proxy_container = next(container for container in context.containers.values() if isinstance(container, HttpProxy))
-    assert http_proxy_container.check_http_proxy_access(url) or http_proxy_container.log_app_output()
+    assert http_proxy_container.check_http_proxy_access(url) or log_due_to_failure(context)
 
 
 @then('in the "{container}" container no files are placed in the "{directory}" directory in {duration} of running time')

extension-framework/cpp-extension-lib/include/api/core/ProcessContext.h

@@ -45,8 +45,8 @@ class ProcessContext {
   [[nodiscard]] virtual bool hasNonEmptyProperty(std::string_view name) const = 0;
   [[nodiscard]] virtual std::map<std::string, std::string> getDynamicProperties(const FlowFile* flow_file) const = 0;
 
-  [[nodiscard]] virtual std::expected<utils::net::SslData, std::error_code> getSslData(std::string_view name) const = 0;
-  [[nodiscard]] virtual std::expected<utils::ProxyData, std::error_code> getProxyData(std::string_view name) const = 0;
+  [[nodiscard]] virtual std::expected<std::optional<utils::net::SslData>, std::error_code> getSslData(const minifi::core::PropertyReference& prop) const = 0;
+  [[nodiscard]] virtual std::expected<std::optional<utils::ProxyData>, std::error_code> getProxyData(const minifi::core::PropertyReference& prop) const = 0;
 };
 
 class CffiProcessContext : public ProcessContext {
@@ -60,8 +60,8 @@ class CffiProcessContext : public ProcessContext {
   [[nodiscard]] std::map<std::string, std::string> getDynamicProperties(const FlowFile* flow_file) const override;
   [[nodiscard]] bool hasNonEmptyProperty(std::string_view name) const override;
 
-  [[nodiscard]] std::expected<utils::net::SslData, std::error_code> getSslData(std::string_view name) const override;
-  [[nodiscard]] std::expected<utils::ProxyData, std::error_code> getProxyData(std::string_view name) const override;
+  [[nodiscard]] std::expected<std::optional<utils::net::SslData>, std::error_code> getSslData(const minifi::core::PropertyReference& prop) const override;
+  [[nodiscard]] std::expected<std::optional<utils::ProxyData>, std::error_code> getProxyData(const minifi::core::PropertyReference& prop) const override;
 
  private:
   [[nodiscard]] std::expected<std::string, std::error_code> getProperty(std::string_view name, const FlowFile* flow_file) const;

extension-framework/cpp-extension-lib/mocklib/include/MockProcessContext.h

@@ -34,7 +34,8 @@ class MockProcessContext : public api::core::ProcessContext {
   [[nodiscard]] std::map<std::string, std::string> getDynamicProperties(const api::core::FlowFile* flow_file) const override;
   [[nodiscard]] bool hasNonEmptyProperty(std::string_view name) const override;
 
-  [[nodiscard]] std::expected<api::utils::net::SslData, std::error_code> getSslData(std::string_view name) const override;
+  [[nodiscard]] std::expected<std::optional<api::utils::net::SslData>, std::error_code> getSslData(const minifi::core::PropertyReference& prop) const override;
+  [[nodiscard]] std::expected<std::optional<api::utils::ProxyData>, std::error_code> getProxyData(const minifi::core::PropertyReference& prop) const override;
 
   std::map<std::string, std::string, std::less<>> properties_;
 

extension-framework/cpp-extension-lib/mocklib/src/MockProcessContext.cpp

@@ -44,7 +44,11 @@ bool MockProcessContext::hasNonEmptyProperty(const std::string_view name) const
   return properties_.contains(name);
 }
 
-std::expected<api::utils::net::SslData, std::error_code> MockProcessContext::getSslData(std::string_view) const {
-  return api::utils::net::SslData{};
+std::expected<std::optional<api::utils::net::SslData>, std::error_code> MockProcessContext::getSslData(const minifi::core::PropertyReference& prop) const {
+  return std::nullopt;
+}
+
+[[nodiscard]] std::expected<std::optional<api::utils::ProxyData>, std::error_code> MockProcessContext::getProxyData(const minifi::core::PropertyReference& prop) const {
+  return std::nullopt;
 }
 }  // namespace org::apache::nifi::minifi::mock

extension-framework/cpp-extension-lib/src/core/ProcessContext.cpp

@@ -69,10 +69,13 @@ std::map<std::string, std::string> CffiProcessContext::getDynamicProperties(cons
   return result;
 }
 
-std::expected<utils::net::SslData, std::error_code> CffiProcessContext::getSslData(const std::string_view name) const {
+std::expected<std::optional<utils::net::SslData>, std::error_code> CffiProcessContext::getSslData(const minifi::core::PropertyReference& prop) const {
+  const auto controller_name = getProperty(prop, nullptr);
+  if (!controller_name) { return std::nullopt; }
+
   auto ssl_data = utils::net::SslData{};
 
-  if (const auto status = MinifiProcessContextGetSslData(impl_, utils::minifiStringView(name), [](void* data, const MinifiSslData* minifi_ssl_data) {
+  if (const auto status = MinifiProcessContextGetSslData(impl_, utils::minifiStringView(*controller_name), [](void* data, const MinifiSslData* minifi_ssl_data) {
       auto* my_ssl_data = static_cast<utils::net::SslData*>(data);
       my_ssl_data->ca_loc = utils::toString(minifi_ssl_data->ca_certificate_file);
       my_ssl_data->cert_loc = utils::toString(minifi_ssl_data->certificate_file);
@@ -86,12 +89,14 @@ std::expected<utils::net::SslData, std::error_code> CffiProcessContext::getSslDa
   return ssl_data;
 }
 
-std::expected<utils::ProxyData, std::error_code> CffiProcessContext::getProxyData(const std::string_view name) const {
-  auto proxy_data = utils::ProxyData{};
+std::expected<std::optional<utils::ProxyData>, std::error_code> CffiProcessContext::getProxyData(const minifi::core::PropertyReference& prop) const {
+  const auto controller_name = getProperty(prop, nullptr);
+  if (!controller_name) { return std::nullopt; }
 
+  auto proxy_data = utils::ProxyData{};
   if (const auto status = MinifiProcessContextGetProxyData(
           impl_,
-          utils::minifiStringView(name),
+          utils::minifiStringView(*controller_name),
           [](void* data, const MinifiProxyData* minifi_proxy_data) {
             auto* proxy = static_cast<utils::ProxyData*>(data);
             proxy->host = utils::toString(minifi_proxy_data->hostname);

extensions/gcp/processors/GCSProcessor.cpp

@@ -47,7 +47,7 @@ MinifiStatus GCSProcessor::onScheduleImpl(api::core::ProcessContext& context) {
   if (endpoint_url_)
     logger_->log_debug("Endpoint overwritten: {}", *endpoint_url_);
 
-  const auto proxy_data = context.getProxyData(ProxyConfigurationService.name);
+  const auto proxy_data = context.getProxyData(ProxyConfigurationService) | utils::orThrow("Couldnt query ProxyConfigurationService");
   if (proxy_data && proxy_data->proxy_type != api::utils::ProxyType::DIRECT) {
     logger_->log_debug("Proxy configuration is set for GCS processor");
 

libminifi/src/minifi-c.cpp

@@ -181,6 +181,16 @@ class CControllerServiceFactory : public minifi::core::controller::ControllerSer
   minifi::utils::CControllerServiceClassDescription class_description_;
 };
 
+MinifiProxyType minifiProxyType(const minifi::controllers::ProxyType& proxy_type) {
+  switch (proxy_type) {
+    case minifi::controllers::ProxyType::DIRECT:
+      return MinifiProxyType::MINIFI_PROXY_TYPE_DIRECT;
+    case minifi::controllers::ProxyType::HTTP:
+      return MinifiProxyType::MINIFI_PROXY_TYPE_HTTP;
+  }
+  std::unreachable();
+}
+
 }  // namespace
 
 namespace org::apache::nifi::minifi::utils {
@@ -650,29 +660,17 @@ MinifiStatus MinifiProcessContextGetProxyData(MinifiProcessContext* process_cont
   if (!service_shared_ptr) { return MINIFI_STATUS_VALIDATION_FAILED; }
   if (const auto proxy_service = dynamic_cast<minifi::controllers::ProxyConfigurationServiceInterface*>(service_shared_ptr.get())) {
     const std::string hostname = proxy_service->getHost();
-    const uint16_t port = proxy_service->getPort();
     const auto basic_auth_data = proxy_service->getProxyCredentials();
     MinifiStringView username_holder = basic_auth_data ? minifiStringView(basic_auth_data->username) : MinifiStringView{};
     MinifiStringView password_holder = basic_auth_data ? minifiStringView(basic_auth_data->password) : MinifiStringView{};
-    MinifiProxyType proxy_type;
-    switch (proxy_service->getProxyType()) {
-      case minifi::controllers::ProxyType::DIRECT: {
-        proxy_type = MINIFI_PROXY_TYPE_DIRECT;
-        break;
-      }
-      case minifi::controllers::ProxyType::HTTP: {
-        proxy_type = MINIFI_PROXY_TYPE_HTTP;
-        break;
-      }
-    }
 
     MinifiProxyData proxy_data{
         .version = 1,
         .hostname = minifiStringView(hostname),
-        .port = port,
+        .port = proxy_service->getPort(),
         .username = basic_auth_data ? &username_holder : nullptr,
         .password = basic_auth_data ? &password_holder : nullptr,
-        .proxy_type = proxy_type,
+        .proxy_type = minifiProxyType(proxy_service->getProxyType()),
     };
     cb(user_ctx, &proxy_data);
     return MINIFI_STATUS_SUCCESS;