MINIFICPP-2782 - Remove resources from class loader on extension unload

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

@@ -74,8 +74,8 @@ class ProcessorImpl {
   static constexpr auto OutputAttributes = std::array<minifi::core::OutputAttributeReference, 0>{};
 
   std::string getName() const;
-  utils::Identifier getUUID() const;
-  utils::SmallString<36> getUUIDStr() const;
+  minifi::utils::Identifier getUUID() const;
+  minifi::utils::SmallString<36> getUUIDStr() const;
 
   virtual PublishedMetrics calculateMetrics() const {return {};}
 

libminifi/include/core/extension/Extension.h

@@ -62,6 +62,10 @@ class Extension {
     return info_;
   }
 
+  void addClass(std::string class_name) {
+    classes_.push_back(std::move(class_name));
+  }
+
  private:
 #ifdef WIN32
   std::map<void*, std::string> resource_mapping_;
@@ -85,6 +89,7 @@ class Extension {
   gsl::owner<void*> handle_ = nullptr;
 
   std::optional<Info> info_;
+  std::vector<std::string> classes_;
   uint32_t api_version_{0};
 
   const std::shared_ptr<logging::Logger> logger_;

libminifi/src/core/extension/Extension.cpp

@@ -39,6 +39,7 @@
 #include "minifi-c/minifi-c.h"
 #include "minifi-cpp/agent/agent_docs.h"
 #include "utils/RegexUtils.h"
+#include "core/ClassLoader.h"
 
 namespace org::apache::nifi::minifi::core::extension {
 
@@ -116,6 +117,11 @@ Extension::~Extension() {
   if (info_ && info_->deinit) {
     info_->deinit(info_->user_data);
   }
+  if (info_) {
+    for (auto& class_name : classes_) {
+      core::ClassLoader::getDefaultClassLoader().getClassLoader(info_->name).unregisterClass(class_name);
+    }
+  }
   unload();
 
   const std::string bundle_name = info_ ? info_->name : library_name_;

libminifi/src/minifi-c.cpp

@@ -243,7 +243,8 @@ MinifiExtension* MinifiRegisterExtension(MinifiExtensionContext* extension_conte
 MinifiStatus MinifiRegisterProcessor(MinifiExtension* extension_handle, const MinifiProcessorClassDefinition* processor) {
   gsl_Assert(extension_handle);
   gsl_Assert(processor);
-  auto extension_info = reinterpret_cast<org::apache::nifi::minifi::core::extension::Extension*>(extension_handle)->getInfo();
+  auto* extension = reinterpret_cast<org::apache::nifi::minifi::core::extension::Extension*>(extension_handle);
+  auto extension_info = extension->getInfo();
   if (!extension_info) {
     return MINIFI_STATUS_UNKNOWN_ERROR;
   }
@@ -257,6 +258,7 @@ MinifiStatus MinifiRegisterProcessor(MinifiExtension* extension_handle, const Mi
       c_class_description.name,
       std::make_unique<CProcessorFactory>(extension_info->name, toString(processor->full_name), c_class_description));
     bundle_components.processors.emplace_back(description);
+    extension->addClass(c_class_description.name);
   });
   return MINIFI_STATUS_SUCCESS;
 }

libminifi/test/integration/extension-verification-test/CApiExtension.cpp

@@ -18,12 +18,28 @@
 
 #include "api/core/Resource.h"
 #include "api/utils/minifi-c-utils.h"
+#include "api/core/ProcessorImpl.h"
 
 #define MKSOC(x) #x
 #define MAKESTRING(x) MKSOC(x)  // NOLINT(cppcoreguidelines-macro-usage)
 
 namespace minifi = org::apache::nifi::minifi;
 
+class DummyCProcessor : public minifi::api::core::ProcessorImpl {
+ public:
+  using ProcessorImpl::ProcessorImpl;
+
+  static constexpr const char* Description = "C processor that does nothing";
+
+  static constexpr auto Relationships = std::array<minifi::core::RelationshipDefinition, 0>{};
+  static constexpr auto Properties = std::array<minifi::core::PropertyReference, 0>{};
+  static constexpr auto OutputAttributes = std::array<minifi::core::OutputAttributeReference, 0>{};
+  static constexpr bool SupportsDynamicProperties = false;
+  static constexpr bool SupportsDynamicRelationships = false;
+  static constexpr minifi::core::annotation::Input InputRequirement = minifi::core::annotation::Input::INPUT_ALLOWED;
+  static constexpr bool IsSingleThreaded = true;
+};
+
 CEXTENSIONAPI const uint32_t MinifiApiVersion = MINIFI_TEST_API_VERSION;
 
 CEXTENSIONAPI void MinifiInitExtension(MinifiExtensionContext* extension_context) {
@@ -33,5 +49,8 @@ CEXTENSIONAPI void MinifiInitExtension(MinifiExtensionContext* extension_context
     .deinit = nullptr,
     .user_data = nullptr
   };
-  MinifiRegisterExtension(extension_context, &extension_definition);
+  auto extension = MinifiRegisterExtension(extension_context, &extension_definition);
+  minifi::api::core::useProcessorClassDescription<DummyCProcessor>([&] (const MinifiProcessorClassDefinition& description) {
+    MinifiRegisterProcessor(extension, &description);
+  });
 }

libminifi/test/integration/extension-verification-test/CMakeLists.txt

@@ -85,3 +85,12 @@ create_loading_test_extension(test-extension-loading-missing-init InvalidMissing
 create_loading_test_extension(test-extension-loading-create-not-called CreateNotCalled.cpp)
 target_link_libraries(test-extension-loading-create-not-called minifi-cpp-extension-lib)
 target_compile_definitions(test-extension-loading-create-not-called PRIVATE MINIFI_TEST_API_VERSION=10)
+
+### Extension Loading Tests
+add_minifi_executable(ExtensionLoadingTests ExtensionLoadingTests.cpp)
+createIntegrationTests(ExtensionLoadingTests)
+target_link_libraries(ExtensionLoadingTests core-minifi Catch2WithMain Threads::Threads)
+add_test(NAME ExtensionLoadingTests COMMAND ExtensionLoadingTests)
+
+create_c_test_extension(c-resources 10)
+add_dependencies(ExtensionLoadingTests test-extension-loading-c-resources)

libminifi/test/integration/extension-verification-test/ExtensionLoadingTests.cpp

@@ -0,0 +1,54 @@
+/**
+*
+ * 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 CUSTOM_EXTENSION_INIT
+
+#include "unit/TestBase.h"
+#include "unit/Catch.h"
+#include "unit/TestUtils.h"
+#include "core/extension/ExtensionManager.h"
+#include "core/extension/ApiVersion.h"
+#include "core/ClassLoader.h"
+
+namespace minifi = org::apache::nifi::minifi;
+
+class ExtensionLoadingTestController {
+ public:
+  explicit ExtensionLoadingTestController(std::string pattern): extension_manager_{[&] () {
+    LogTestController::getInstance().clear();
+    LogTestController::getInstance().setTrace<core::extension::ExtensionManager>();
+    LogTestController::getInstance().setTrace<core::extension::Extension>();
+    minifi::core::extension::test_setAgentApiVersion(10);
+    minifi::core::extension::test_setMinSupportedApiVersion(5);
+    auto config = minifi::Configure::create();
+    config->set(minifi::Configuration::nifi_extension_path, pattern);
+    return config;
+  }()} {}
+
+  std::optional<core::extension::ExtensionManager> extension_manager_;
+};
+
+TEST_CASE("Loading an extension makes the processors available") {
+  CHECK_FALSE(core::ClassLoader::getDefaultClassLoader().instantiate("DummyCProcessor", "dummy"));
+  {
+    ExtensionLoadingTestController controller{"*test-extension-loading-c-resources*"};
+    CHECK(core::ClassLoader::getDefaultClassLoader().instantiate("DummyCProcessor", "dummy"));
+  }
+  CHECK_FALSE(core::ClassLoader::getDefaultClassLoader().instantiate("DummyCProcessor", "dummy"));
+}
+