You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by sz...@apache.org on 2024/10/18 15:08:37 UTC

(nifi-minifi-cpp) branch main updated (6c0979ff4 -> 8ba39e475)

This is an automated email from the ASF dual-hosted git repository.

szaszm pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git


    from 6c0979ff4 MINIFICPP-2464 Drop the GPS extension
     new 49e5b9370 MINIFICPP-2346-P1: Integrated Conan2 for OpenSSL, CURL, ZLIB & Build MiNiFi
     new ba91eb884 MINIFICPP-2378 Add support for parameters in controller services
     new 8ba39e475 MINIFICPP-2473 Add .clang-format to project

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .clang-format                                      |  54 +++++
 CMakeLists.txt                                     |  33 +--
 CONAN.md                                           | 137 ++++++++++++
 README.md                                          |   9 +
 cmake/BuildTests.cmake                             |   3 +-
 cmake/BundledOpenSSL.cmake                         |   1 +
 cmake/BundledRocksDB.cmake                         |   6 +-
 cmake/Bustache.cmake                               |   4 +-
 cmake/{Coroutines.cmake => GetBZip2.cmake}         |  13 +-
 cmake/{Coroutines.cmake => GetCatch2.cmake}        |  13 +-
 cmake/{Coroutines.cmake => GetCivetWeb.cmake}      |  12 +-
 cmake/{Coroutines.cmake => GetFmt.cmake}           |  12 +-
 cmake/{Coroutines.cmake => GetLibCURL.cmake}       |  13 +-
 cmake/{Coroutines.cmake => GetLibXml2.cmake}       |  13 +-
 cmake/{Coroutines.cmake => GetOpenSSL.cmake}       |  13 +-
 cmake/{Coroutines.cmake => GetRocksDB.cmake}       |  20 +-
 cmake/{Coroutines.cmake => GetSpdlog.cmake}        |  17 +-
 cmake/{Coroutines.cmake => GetZLIB.cmake}          |  13 +-
 cmake/{Coroutines.cmake => GetZstd.cmake}          |  13 +-
 cmake/MiNiFiOptions.cmake                          |  41 +++-
 cmake/Spdlog.cmake                                 |   2 +-
 conanfile.py                                       |  90 ++++++++
 etc/conan/profiles/release-linux                   |  12 +
 extensions/aws/processors/DeleteS3Object.h         |   4 +-
 extensions/aws/processors/FetchS3Object.h          |   4 +-
 extensions/aws/processors/PutS3Object.h            |   4 +-
 extensions/aws/processors/S3Processor.cpp          |   4 +-
 extensions/aws/tests/PutS3ObjectTests.cpp          |   2 +-
 extensions/aws/tests/S3TestsFixture.h              |  23 +-
 .../azure/processors/AzureStorageProcessorBase.cpp |   2 +-
 .../azure/tests/AzureBlobStorageTestsFixture.h     |  15 +-
 .../azure/tests/AzureDataLakeStorageTestsFixture.h |  15 +-
 .../azure/tests/ListAzureBlobStorageTests.cpp      |   7 +-
 .../azure/tests/ListAzureDataLakeStorageTests.cpp  |   7 +-
 extensions/bustache/tests/ApplyTemplateTests.cpp   |   8 +-
 extensions/civetweb/CMakeLists.txt                 |   2 +-
 extensions/civetweb/tests/ListenHTTPTests.cpp      |  14 +-
 extensions/elasticsearch/PostElasticsearch.cpp     |  10 +-
 extensions/elasticsearch/PostElasticsearch.h       |   2 +
 .../elasticsearch/tests/PostElasticsearchTests.cpp |   5 +-
 .../execute-process/test/ExecuteProcessTests.cpp   |   6 +-
 .../tests/ProcessContextExprTests.cpp              |   2 +-
 extensions/gcp/processors/GCSProcessor.cpp         |   6 +-
 extensions/gcp/processors/GCSProcessor.h           |   1 +
 extensions/gcp/tests/DeleteGCSObjectTests.cpp      |   6 +-
 extensions/gcp/tests/FetchGCSObjectTests.cpp       |   5 +-
 extensions/gcp/tests/ListGCSBucketTests.cpp        |   5 +-
 extensions/gcp/tests/PutGCSObjectTests.cpp         |   5 +-
 extensions/grafana-loki/PushGrafanaLoki.cpp        |   4 +-
 extensions/grafana-loki/PushGrafanaLoki.h          |   2 +-
 .../grafana-loki/tests/PushGrafanaLokiGrpcTest.cpp |  18 +-
 .../grafana-loki/tests/PushGrafanaLokiRESTTest.cpp |  23 +-
 .../processors/CollectKubernetesPodMetrics.cpp     |   2 +-
 extensions/libarchive/tests/FocusArchiveTests.cpp  |  14 +-
 .../libarchive/tests/ManipulateArchiveTests.cpp    |   8 +-
 extensions/libarchive/tests/MergeFileTests.cpp     |  10 +-
 extensions/librdkafka/tests/PublishKafkaTests.cpp  |   4 +-
 .../TestExecuteScriptProcessorWithLuaScript.cpp    |  54 ++---
 extensions/mqtt/tests/ConsumeMQTTTests.cpp         |   2 +-
 extensions/mqtt/tests/PublishMQTTTests.cpp         |   2 +-
 extensions/opc/CMakeLists.txt                      |   2 +-
 extensions/opencv/tests/CaptureRTSPFrameTest.cpp   |   4 +-
 .../pdh/tests/PerformanceDataMonitorTests.cpp      |   4 +-
 extensions/procfs/tests/ProcFsMonitorTests.cpp     |   4 +-
 .../python/tests/ExecutePythonProcessorTests.cpp   |  10 +-
 .../TestExecuteScriptProcessorWithPythonScript.cpp |  54 ++---
 extensions/python/types/PyProcessContext.cpp       |   2 +-
 extensions/rocksdb-repos/CMakeLists.txt            |   9 +-
 extensions/sftp/tests/FetchSFTPTests.cpp           |   8 +-
 extensions/sftp/tests/ListSFTPTests.cpp            |   8 +-
 extensions/sftp/tests/ListThenFetchSFTPTests.cpp   |   8 +-
 extensions/sftp/tests/PutSFTPTests.cpp             |   4 +-
 extensions/smb/SmbConnectionControllerService.cpp  |   2 +-
 extensions/smb/tests/FetchSmbTests.cpp             |   8 +-
 extensions/smb/tests/ListAndFetchSmbTests.cpp      |   8 +-
 extensions/smb/tests/ListSmbTests.cpp              |   8 +-
 extensions/smb/tests/PutSmbTests.cpp               |  12 +-
 extensions/splunk/SplunkHECProcessor.cpp           |   4 +-
 extensions/splunk/SplunkHECProcessor.h             |   2 +-
 extensions/splunk/tests/PutSplunkHTTPTests.cpp     |  14 +-
 .../tests/QuerySplunkIndexingStatusTests.cpp       |  14 +-
 extensions/sql/processors/SQLProcessor.cpp         |   2 +-
 extensions/sql/tests/PutSQLTests.cpp               |   1 -
 extensions/sql/tests/SQLTestPlan.h                 |   6 +-
 .../standard-processors/modbus/FetchModbusTcp.cpp  |   4 +-
 .../standard-processors/processors/GetTCP.cpp      |   6 +-
 extensions/standard-processors/processors/GetTCP.h |   2 +-
 .../standard-processors/processors/InvokeHTTP.cpp  |   2 +-
 .../standard-processors/processors/PutTCP.cpp      |   4 +-
 .../standard-processors/processors/TailFile.cpp    |   2 +-
 .../tests/integration/InvokeHTTPTests.cpp          |  54 ++---
 .../tests/unit/AppendHostInfoTests.cpp             |  18 +-
 .../tests/unit/AttributeRollingWindowTests.cpp     |   4 +-
 .../tests/unit/AttributesToJSONTests.cpp           |  10 +-
 .../tests/unit/DefragmentTextTests.cpp             |  32 +--
 .../tests/unit/ExtractTextTests.cpp                |  16 +-
 .../tests/unit/FetchFileTests.cpp                  |   6 +-
 .../tests/unit/FlowJsonTests.cpp                   | 137 +++++++++++-
 .../tests/unit/GenerateFlowFileTests.cpp           |  25 ++-
 .../tests/unit/GetFileTests.cpp                    |  10 +-
 .../standard-processors/tests/unit/GetTCPTests.cpp |  16 +-
 .../tests/unit/HashContentTest.cpp                 |  21 +-
 .../tests/unit/JoltTransformJSONTests.cpp          |  28 +--
 .../tests/unit/ListFileTests.cpp                   |  10 +-
 .../tests/unit/ListenSyslogTests.cpp               |  23 +-
 .../tests/unit/ListenTcpTests.cpp                  |  24 +-
 .../tests/unit/ListenUDPTests.cpp                  |  12 +-
 .../tests/unit/LogAttributeTests.cpp               |  16 +-
 .../tests/unit/ProcessorTests.cpp                  |  28 ++-
 .../tests/unit/PutFileTests.cpp                    |  34 +--
 .../standard-processors/tests/unit/PutTCPTests.cpp |   8 +-
 .../standard-processors/tests/unit/PutUDPTests.cpp |   4 +-
 .../tests/unit/ReplaceTextTests.cpp                |  24 +-
 .../tests/unit/RetryFlowFileTests.cpp              |  14 +-
 .../tests/unit/RouteTextTests.cpp                  |   4 +-
 .../tests/unit/SplitTextTests.cpp                  |  47 ++--
 .../tests/unit/TailFileTests.cpp                   |  70 +++---
 .../tests/unit/YamlConfigurationTests.cpp          | 123 ++++++++++-
 extensions/systemd/tests/ConsumeJournaldTest.cpp   |   2 +-
 libminifi/CMakeLists.txt                           |   2 +-
 libminifi/include/core/ProcessContext.h            |  44 +---
 libminifi/include/core/ProcessGroup.h              |   6 +-
 .../core/controller/ControllerServiceLookup.h      |   8 +
 .../core/controller/ControllerServiceNodeMap.h     |  48 ++--
 .../core/controller/ControllerServiceProvider.h    |   7 +-
 .../ForwardingControllerServiceProvider.h          |   8 +
 .../include/core/flow/StructuredConfiguration.h    |   2 +-
 libminifi/src/RemoteProcessorGroupPort.cpp         |   2 +-
 libminifi/src/core/ProcessGroup.cpp                |  64 ++++--
 .../core/controller/ControllerServiceNodeMap.cpp   |  96 ++++++++
 .../core/controller/ControllerServiceProvider.cpp  |  12 +-
 .../controller/StandardControllerServiceNode.cpp   |   2 +-
 .../src/core/flow/StructuredConfiguration.cpp      |  24 +-
 libminifi/src/utils/net/Ssl.cpp                    |   2 +-
 .../ControllerServiceIntegrationTests.cpp          |  15 +-
 libminifi/test/libtest/unit/CMakeLists.txt         |   2 +-
 .../libtest/unit/ContentRepositoryDependentTests.h |   2 +-
 libminifi/test/libtest/unit/MockClasses.h          |  42 +++-
 libminifi/test/libtest/unit/RecordSetTesters.h     |   2 +-
 .../libtest/unit/SingleProcessorTestController.h   |  37 ++--
 libminifi/test/libtest/unit/TestBase.cpp           |  82 ++++---
 libminifi/test/libtest/unit/TestBase.h             |  46 ++--
 libminifi/test/libtest/unit/TestUtils.h            |   2 +-
 .../test/resources/TestControllerServices.yml      | 164 +++++++++-----
 libminifi/test/unit/LoggerTests.cpp                |   4 +-
 libminifi/test/unit/ProcessSessionTests.cpp        |   2 +-
 thirdparty/rocksdb/all/conandata.yml               |  15 ++
 thirdparty/rocksdb/all/conanfile.py                | 243 +++++++++++++++++++++
 thirdparty/rocksdb/{ => all/patches}/arm7.patch    |   0
 thirdparty/rocksdb/{ => all/patches}/cstdint.patch |   0
 .../patches}/dboptions_equality_operator.patch     |   0
 thirdparty/rocksdb/config.yml                      |   3 +
 152 files changed, 1970 insertions(+), 907 deletions(-)
 create mode 100644 .clang-format
 create mode 100644 CONAN.md
 copy cmake/{Coroutines.cmake => GetBZip2.cmake} (67%)
 copy cmake/{Coroutines.cmake => GetCatch2.cmake} (67%)
 copy cmake/{Coroutines.cmake => GetCivetWeb.cmake} (70%)
 copy cmake/{Coroutines.cmake => GetFmt.cmake} (73%)
 copy cmake/{Coroutines.cmake => GetLibCURL.cmake} (65%)
 copy cmake/{Coroutines.cmake => GetLibXml2.cmake} (66%)
 copy cmake/{Coroutines.cmake => GetOpenSSL.cmake} (66%)
 copy cmake/{Coroutines.cmake => GetRocksDB.cmake} (54%)
 copy cmake/{Coroutines.cmake => GetSpdlog.cmake} (66%)
 copy cmake/{Coroutines.cmake => GetZLIB.cmake} (67%)
 copy cmake/{Coroutines.cmake => GetZstd.cmake} (69%)
 create mode 100644 conanfile.py
 create mode 100644 etc/conan/profiles/release-linux
 create mode 100644 libminifi/src/core/controller/ControllerServiceNodeMap.cpp
 create mode 100644 thirdparty/rocksdb/all/conandata.yml
 create mode 100644 thirdparty/rocksdb/all/conanfile.py
 rename thirdparty/rocksdb/{ => all/patches}/arm7.patch (100%)
 rename thirdparty/rocksdb/{ => all/patches}/cstdint.patch (100%)
 rename thirdparty/rocksdb/{ => all/patches}/dboptions_equality_operator.patch (100%)
 create mode 100644 thirdparty/rocksdb/config.yml


(nifi-minifi-cpp) 01/03: MINIFICPP-2346-P1: Integrated Conan2 for OpenSSL, CURL, ZLIB & Build MiNiFi

Posted by sz...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

szaszm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git

commit 49e5b937084a5639ea2f84300bb388175610ee1e
Author: james94 <ja...@gmail.com>
AuthorDate: Fri Oct 18 17:07:47 2024 +0200

    MINIFICPP-2346-P1: Integrated Conan2 for OpenSSL, CURL, ZLIB & Build MiNiFi
    
    Closes #1793
    
    Signed-off-by: Marton Szasz <sz...@apache.org>
---
 CMakeLists.txt                                     |  33 +--
 CONAN.md                                           | 137 ++++++++++++
 README.md                                          |   9 +
 cmake/BuildTests.cmake                             |   3 +-
 cmake/BundledOpenSSL.cmake                         |   1 +
 cmake/BundledRocksDB.cmake                         |   6 +-
 cmake/Bustache.cmake                               |   4 +-
 cmake/{Bustache.cmake => GetBZip2.cmake}           |  21 +-
 cmake/{Bustache.cmake => GetCatch2.cmake}          |  21 +-
 cmake/{Bustache.cmake => GetCivetWeb.cmake}        |  20 +-
 cmake/{Bustache.cmake => GetFmt.cmake}             |  20 +-
 cmake/{Bustache.cmake => GetLibCURL.cmake}         |  21 +-
 cmake/{Bustache.cmake => GetLibXml2.cmake}         |  21 +-
 cmake/{Bustache.cmake => GetOpenSSL.cmake}         |  21 +-
 cmake/{Bustache.cmake => GetRocksDB.cmake}         |  28 ++-
 cmake/{Bustache.cmake => GetSpdlog.cmake}          |  25 ++-
 cmake/{Bustache.cmake => GetZLIB.cmake}            |  21 +-
 cmake/{Bustache.cmake => GetZstd.cmake}            |  21 +-
 cmake/MiNiFiOptions.cmake                          |  41 +++-
 cmake/Spdlog.cmake                                 |   2 +-
 conanfile.py                                       |  90 ++++++++
 etc/conan/profiles/release-linux                   |  12 +
 extensions/civetweb/CMakeLists.txt                 |   2 +-
 extensions/opc/CMakeLists.txt                      |   2 +-
 extensions/rocksdb-repos/CMakeLists.txt            |   9 +-
 libminifi/CMakeLists.txt                           |   2 +-
 libminifi/test/libtest/unit/CMakeLists.txt         |   2 +-
 libminifi/test/unit/LoggerTests.cpp                |   4 +-
 thirdparty/rocksdb/all/conandata.yml               |  15 ++
 thirdparty/rocksdb/all/conanfile.py                | 243 +++++++++++++++++++++
 thirdparty/rocksdb/{ => all/patches}/arm7.patch    |   0
 thirdparty/rocksdb/{ => all/patches}/cstdint.patch |   0
 .../patches}/dboptions_equality_operator.patch     |   0
 thirdparty/rocksdb/config.yml                      |   3 +
 34 files changed, 708 insertions(+), 152 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1699e95f9..9b31d6c0e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -221,9 +221,15 @@ else()
     message(VERBOSE "No custom malloc implementation")
 endif()
 
+# OpenSSL
+include(GetOpenSSL)
+get_openssl("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/ssl")
+
+
 if (ENABLE_BZIP2 AND (ENABLE_LIBARCHIVE OR (ENABLE_ROCKSDB AND NOT WIN32)))
-    include(BundledBZip2)
-    use_bundled_bzip2(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
+    include(GetBZip2)
+    get_bzip2(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
     list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/bzip2/dummy")
 endif()
 
@@ -238,11 +244,6 @@ if(NOT WIN32)
     use_bundled_osspuuid(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 
-# OpenSSL
-include(BundledOpenSSL)
-use_openssl("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/ssl")
-
 # libsodium
 include(BundledLibSodium)
 use_bundled_libsodium("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
@@ -250,17 +251,18 @@ use_bundled_libsodium("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}
 list(APPEND MINIFI_CPP_COMPILE_DEFINITIONS SODIUM_STATIC=1)
 
 # zlib
-include(BundledZLIB)
-use_bundled_zlib(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+include(GetZLIB)
+get_zlib(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/zlib/dummy")
 
 # cURL
-include(BundledLibcURL)
-use_bundled_curl(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+include(GetLibCURL)
+get_curl(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/curl/dummy")
 
 # spdlog
-include(Spdlog)
+include(GetSpdlog)
+get_spdlog()
 
 # yaml-cpp
 include(BundledYamlCpp)
@@ -340,13 +342,14 @@ include(Extensions)
 add_subdirectory(libminifi)
 
 if (ENABLE_ALL OR ENABLE_AZURE)
-    include(BundledLibXml2)
-    use_bundled_libxml2(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+    include(GetLibXml2)
+    get_libxml2(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
     list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/libxml2/dummy")
 endif()
 
 if (ENABLE_ALL OR ENABLE_PROMETHEUS OR ENABLE_CIVET)
-    include(CivetWeb)
+    include(GetCivetWeb)
+    get_civetweb()
     list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/civetweb/dummy")
 endif()
 
diff --git a/CONAN.md b/CONAN.md
new file mode 100644
index 000000000..f4a5d04f2
--- /dev/null
+++ b/CONAN.md
@@ -0,0 +1,137 @@
+<!--
+  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.
+-->
+
+# Apache NiFi - MiNiFi - C++ Conan Build Guide
+
+We will walk through the steps to build MiNiFi using conan version 2 that comes with CMake integration. We will also go through the process of creating a MiNiFi conan package for easier integration into other C++ projects. We will start with a discussion on building MiNiFi using the standalone CMake approach and the conan approach. After we have built MiNiFi and created a MiNiFi conan package, we will conclude by elaborating on some of the benefits that can come with integrating a MiNiFi [...]
+
+Conan build support is experimental, and not yet suitable for general use.
+
+## Table of Contents
+
+- [Apache NiFi - MiNiFi - C++ Conan Build Guide](#apache-nifi---minifi---c---conan-build-guide)
+  - [Table of Contents](#table-of-contents)
+  - [Description](#description)
+  - [Build MiNiFi C++ with Conan](#build-minifi-c---with-conan)
+  - [Create MiNiFi C++ Conan Package](#create-minifi-c---conan-package)
+  - [Conclusion](#conclusion)
+  - [Appendix](#appendix)
+
+## Description
+
+Apache NiFi MiNiFi C++ is normally built using standalone CMake. Similarly, we can also create a MiNiFi C++ package using make package. However, each time we build MiNiFi from
+source, it uses CMake to install the third party external libraries that are enabled by downloading the source code and then building each library until it is available to use toward building MiNiFi. If a change is made toward MiNiFi's CMake code in regards to one or more of the external libraries, then potentially the long process of installing one or more of the externl library(ies) happens again before the MiNiFi source code is built. Another way we can build MiNiFi and create MiNiFi  [...]
+
+## Build MiNiFi C++ with Conan
+
+To build MiNiFi using conan, first we install conan version 2, then we create a **default** conan profile that will later be ignored for our custom conan profile, create a MINIFI_HOME environment variable, then we install prebuilt conan packages representing the MiNiFi external libraries and finally we compile MiNiFi.
+
+~~~bash
+sudo pip install --force-reinstall -v "conan==2.0.17"
+
+# create a "default" conan profile, so conan has it on record in ~/.conan2/, before using your own custom profile.
+conan profile detect
+
+# conanfile.py is in root dir of MiNiFi C++ project
+cd $HOME/nifi-minifi-cpp
+
+# create MINIFI_HOME env variable for binary executable minifi
+export MINIFI_HOME=$(pwd)
+
+# install conan packages for MiNiFi C++ using conanfile.py invoking Conan
+# since we created default profile earlier, we can override it with our own minifi profile
+conan install . --build=missing --output-folder=build_conan -pr=etc/conan/profiles/release-linux
+
+# build MiNiFi C++ using conanfile.py invoking Conan & CMake
+conan build . --output-folder=build_conan -pr=etc/conan/profiles/release-linux
+~~~
+
+- **NOTE**: After building MiNiFi, we must have the MINIFI_HOME environment variable created in order to successfully run the minifi binary executable.
+
+- **NOTE**: When we install the prebuilt conan package representing the MiNiFi third party libraries, we add the `--build=missing` in case some of the prebuilt missing conan packages are not found from conancenter, jfrog, or one of our conan repositories, then conan will build the conan packages from source. We can upload new prebuilt conan packages by **[conan upload](https://docs.conan.io/2/reference/commands/upload.html)**.
+
+- **NOTE**: When we tell conan to build MiNiFi, conan first installs prebuilt conan packages and then it compiles MiNiFi from source, so we have the MiNiFi library and its binary executable available.
+
+### Run MiNiFi CTESTs from Build Folder
+
+~~~bash
+pushd build_conan/
+ctest
+popd # build_conan/
+~~~
+
+### Run MiNiFi Executable
+
+~~~bash
+# verify we can run minifi binary executable
+./build_conan/bin/minifi
+~~~
+
+## Create MiNiFi C++ Conan Package
+
+To create a MiNiFi package, we will follow the similar steps we took to build MiNiFi. Then right after we install the prebuilt conan packages representing MiNiFi's external libraries, we create that MiNiFi conan package.
+
+~~~bash
+# make sure to install conan2 for your environment
+sudo pip install --force-reinstall -v "conan==2.0.17"
+
+# create a "default" conan profile, so conan has it on record, before using your own custom profile. Gets created in ~/.conan2/
+conan profile detect
+
+# conanfile.py is in root dir of MiNiFi C++ project
+cd $HOME/nifi-minifi-cpp
+
+# create MINIFI_HOME env variable for binary executable minifi
+export MINIFI_HOME=$(pwd)
+
+# install conan packages for MiNiFi C++ using conanfile.py invoking Conan
+# since we created default profile earlier, we can override it with our own minifi profile
+# make sure path is correct
+conan install . --build=missing --output-folder=build_conan -pr=etc/conan/profiles/release-linux
+
+# create MiNiFi C++ conan package using conanfile.py invoking Conan & CMake
+conan create . --user=minifi --channel=develop -pr=etc/conan/profiles/release-linux
+~~~
+
+- **NOTE**: When we tell conan to create the MiNiFi conan package, conan first installs prebuilt conan packages, then it compiles MiNiFi from source inside `~/.conan2/p/b/minif<UUID>/b`, and then it copies over MiNiFi's libraries and its binary executables into the conan package folder `~/.conan2/p/b/minif<UUID>/p`. Once we have the MiNiFi conan package, we can integrate it into other C++ infrastructure using CMake.
+
+### Run MiNiFi CTESTs from Its Conan Package
+
+~~~bash
+# Example of minif<UUID> conan package folder name: minifbd17f6a02da35
+pushd ~/.conan2/p/b/minif<UUID>/b
+ctest
+popd # build_conan/
+~~~
+
+## Conclusion
+
+To have a more consistent quick build process for MiNiFi, we can use conan version 2. When we use conan with MiNiFi's build process, we can install prebuilt conan packages that can represent MiNiFi's external libraries and then build MiNiFi quickly. We also have a bit more control over when we want to make updates to MiNiFi's external libraries that impact their build and then re-build them as prebuilt conan packages. So these external library conan packages can be used toward building M [...]
+
+There are multiple benefits of having MiNiFi prebuilt conan packages. We can upload these MiNiFi conan packages to a conan repository like jfrog for version management. We can easily integrate MiNiFi's edge data pipeline features into other C++ software infrastructure using conan's CMake support. We can still use MiNiFi for edge data collection from the IoT devices embedded on robotic systems. We can integrate MiNiFi into self-driving cars (sensor examples: cameras, lidar, radar, inertia [...]
+
+By leveraging MiNiFi as a conan package, we can leverage MiNiFi that comes with the best practices of building data pipelines from NiFi and bring them into existing C++ real-time robotics infrastructure. Some teams across companies typically have their own custom edge data pipelines that process data for the different events to eventually perform actions on that data. As an alternative to all these companies and their teams having their own custom edge data pipeline libraries, MiNiFi C++ [...]
+
+## Appendix
+
+### Create Custom RocksDB Conan Package
+
+~~~bash
+pushd nifi-minifi-cpp/thirdparty/rocksdb/all
+
+conan create . --user=minifi --channel=develop --version=8.10.2 -pr=../../../etc/conan/profiles/release-linux
+
+popd
+~~~
diff --git a/README.md b/README.md
index 13c83f08f..b80108b8d 100644
--- a/README.md
+++ b/README.md
@@ -358,6 +358,8 @@ advanced features.
 
 ### Building
 
+#### Build MiNiFi using Standalone CMake
+
 - From your source checkout, create a directory to perform the build (e.g. build) and cd into that directory.
   ```
   # ~/Development/code/apache/nifi-minifi-cpp on git:master
@@ -403,6 +405,8 @@ advanced features.
   [100%] Built target run-tests
   ```
 
+#### Create MiNiFi Package using Standalone CMake
+
 - Create a binary assembly located in your build directory with suffix .tar.gz
   ```
   ~/Development/code/apache/nifi-minifi-cpp/build
@@ -427,6 +431,11 @@ advanced features.
   CPack: - package: ~/Development/code/apache/nifi-minifi-cpp/build/nifi-minifi-cpp-0.99.0-source.tar.gz generated.
   ```
 
+#### Build MiNiFi & Create MiNiFi Package using Conan v2
+
+Building MiNiFi and creating MiNiFi package supporting a portion of the extensions has been tested with Conan version 2 using VS code as an alternative to standalone CMake. By building MiNiFi using prebuilt conan packages for the external libraries as an alternative to CMake building the sources of those external libraries, we maybe able to speed up MiNiFi builds. Additionally, by creating a MiNiFi package as a conan package, it should be easier to integrate MiNiFi library and its execut [...]
+project infrastructure to build out data pipelines on the edge. For instance, once we create the MiNiFi conan package, we can upload it to jfrog, conancenter or some other supported conan cloud repository and then download the prebuilt MiNiFi conan package to our new C++ project by adding it to our conanfile. For more details on the conan commands to build MiNiFi and create a MiNiFi conan package, see [CONAN.md](CONAN.md).
+
 ### Building a docker image
 
 #### Building your own custom image
diff --git a/cmake/BuildTests.cmake b/cmake/BuildTests.cmake
index e55500242..37e19fa10 100644
--- a/cmake/BuildTests.cmake
+++ b/cmake/BuildTests.cmake
@@ -15,7 +15,8 @@
 # specific language governing permissions and limitations
 # under the License.
 
-include(Catch2)
+include(GetCatch2)
+get_catch2()
 
 ### test functions
 MACRO(GETSOURCEFILES result curdir)
diff --git a/cmake/BundledOpenSSL.cmake b/cmake/BundledOpenSSL.cmake
index 275e9ca1d..4ffa51e80 100644
--- a/cmake/BundledOpenSSL.cmake
+++ b/cmake/BundledOpenSSL.cmake
@@ -148,4 +148,5 @@ function(use_openssl SOURCE_DIR BINARY_DIR)
         set_property(TARGET OpenSSL::Crypto APPEND PROPERTY INTERFACE_LINK_LIBRARIES crypt32.lib )
         set_property(TARGET OpenSSL::SSL APPEND PROPERTY INTERFACE_LINK_LIBRARIES crypt32.lib)
     endif()
+
 endfunction(use_openssl)
diff --git a/cmake/BundledRocksDB.cmake b/cmake/BundledRocksDB.cmake
index 2d4211e94..ac2a6e203 100644
--- a/cmake/BundledRocksDB.cmake
+++ b/cmake/BundledRocksDB.cmake
@@ -27,9 +27,9 @@ function(use_bundled_rocksdb SOURCE_DIR BINARY_DIR)
     endif()
 
     # Patch to fix build issue on ARM7 architecture: https://github.com/facebook/rocksdb/issues/8609#issuecomment-1009572506
-    set(PATCH_FILE_1 "${SOURCE_DIR}/thirdparty/rocksdb/arm7.patch")
-    set(PATCH_FILE_2 "${SOURCE_DIR}/thirdparty/rocksdb/dboptions_equality_operator.patch")
-    set(PATCH_FILE_3 "${SOURCE_DIR}/thirdparty/rocksdb/cstdint.patch")
+    set(PATCH_FILE_1 "${SOURCE_DIR}/thirdparty/rocksdb/all/patches/arm7.patch")
+    set(PATCH_FILE_2 "${SOURCE_DIR}/thirdparty/rocksdb/all/patches/dboptions_equality_operator.patch")
+    set(PATCH_FILE_3 "${SOURCE_DIR}/thirdparty/rocksdb/all/patches/cstdint.patch")
     set(PC ${Bash_EXECUTABLE} -c "set -x &&\
             (\"${Patch_EXECUTABLE}\" -p1 -R -s -f --dry-run -i \"${PATCH_FILE_1}\" || \"${Patch_EXECUTABLE}\" -p1 -N -i \"${PATCH_FILE_1}\") &&\
             (\"${Patch_EXECUTABLE}\" -p1 -R -s -f --dry-run -i \"${PATCH_FILE_2}\" || \"${Patch_EXECUTABLE}\" -p1 -N -i \"${PATCH_FILE_2}\") &&\
diff --git a/cmake/Bustache.cmake b/cmake/Bustache.cmake
index 116028775..6c037af6c 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/Bustache.cmake
@@ -17,7 +17,9 @@
 # under the License.
 #
 include(FetchContent)
-include(fmt)
+include(GetFmt)
+get_fmt()
+
 set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
 FetchContent_Declare(Bustache
         GIT_REPOSITORY  https://github.com/jamboree/bustache.git
diff --git a/cmake/Bustache.cmake b/cmake/GetBZip2.cmake
similarity index 66%
copy from cmake/Bustache.cmake
copy to cmake/GetBZip2.cmake
index 116028775..2a7d47e9e 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetBZip2.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_bzip2 SOURCE_DIR BINARY_DIR)
+    if(MINIFI_BZIP2_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install bzip2")
+        find_package(BZip2 REQUIRED)
+    elseif(MINIFI_BZIP2_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build bzip2 from source")
+        include(BundledBZip2)
+        use_bundled_bzip2(${SOURCE_DIR} ${BINARY_DIR})
+    endif()
+endfunction(get_bzip2)
diff --git a/cmake/Bustache.cmake b/cmake/GetCatch2.cmake
similarity index 67%
copy from cmake/Bustache.cmake
copy to cmake/GetCatch2.cmake
index 116028775..d6c1d6acc 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetCatch2.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_catch2)
+    if(MINIFI_CATCH2_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install Catch2")
+        find_package(Catch2 REQUIRED)
+        add_library(Catch2WithMain ALIAS Catch2::Catch2WithMain)
+    elseif(MINIFI_CATCH2_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build Catch2 from source")
+        include(Catch2)
+    endif()
+endfunction(get_catch2)
diff --git a/cmake/Bustache.cmake b/cmake/GetCivetWeb.cmake
similarity index 69%
copy from cmake/Bustache.cmake
copy to cmake/GetCivetWeb.cmake
index 116028775..f30d22289 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetCivetWeb.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,13 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_civetweb)
+    if(MINIFI_CIVETWEB_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install CivetWeb")
+        find_package(civetweb REQUIRED)
+    elseif(MINIFI_CIVETWEB_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build CivetWeb from source")
+        include(CivetWeb)
+    endif()
+endfunction(get_civetweb)
diff --git a/cmake/Bustache.cmake b/cmake/GetFmt.cmake
similarity index 72%
copy from cmake/Bustache.cmake
copy to cmake/GetFmt.cmake
index 116028775..f4f28458d 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetFmt.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,13 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_fmt)
+    if(MINIFI_FMT_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install Fmt")
+        find_package(fmt REQUIRED)
+    elseif(MINIFI_FMT_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build Fmt from source")
+        include(fmt)
+    endif()
+endfunction(get_fmt)
diff --git a/cmake/Bustache.cmake b/cmake/GetLibCURL.cmake
similarity index 64%
copy from cmake/Bustache.cmake
copy to cmake/GetLibCURL.cmake
index 116028775..afd38f3c9 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetLibCURL.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_curl SOURCE_DIR BINARY_DIR)
+    if(MINIFI_LIBCURL_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install libcurl")
+        find_package(CURL REQUIRED)
+    elseif(MINIFI_LIBCURL_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build libcurl from source")
+        include(BundledLibcURL)
+        use_bundled_curl(${SOURCE_DIR} ${BINARY_DIR})
+    endif()
+endfunction(get_curl SOURCE_DIR BINARY_DIR)
diff --git a/cmake/Bustache.cmake b/cmake/GetLibXml2.cmake
similarity index 65%
copy from cmake/Bustache.cmake
copy to cmake/GetLibXml2.cmake
index 116028775..5915b117d 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetLibXml2.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_libxml2 SOURCE_DIR BINARY_DIR)
+    if(MINIFI_LIBXML2_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install libxml2")
+        find_package(libxml2 REQUIRED)
+    elseif(MINIFI_LIBXML2_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build libxml2 from source")
+        include(BundledLibXml2)
+        use_bundled_libxml2(${SOURCE_DIR} ${BINARY_DIR})
+    endif()
+endfunction(get_libxml2)
diff --git a/cmake/Bustache.cmake b/cmake/GetOpenSSL.cmake
similarity index 65%
copy from cmake/Bustache.cmake
copy to cmake/GetOpenSSL.cmake
index 116028775..58132c6bf 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetOpenSSL.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_openssl SOURCE_DIR BINARY_DIR)
+    if(MINIFI_OPENSSL_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install OpenSSL")
+        find_package(OpenSSL REQUIRED)
+    elseif(MINIFI_OPENSSL_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build OpenSSL from source")
+        include(BundledOpenSSL)
+        use_openssl(${SOURCE_DIR} ${BINARY_DIR})
+    endif()
+endfunction(get_openssl)
diff --git a/cmake/Bustache.cmake b/cmake/GetRocksDB.cmake
similarity index 53%
copy from cmake/Bustache.cmake
copy to cmake/GetRocksDB.cmake
index 116028775..0968afc38 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetRocksDB.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,21 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_rocksdb SOURCE_DIR BINARY_DIR)
+    if(MINIFI_ROCKSDB_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install RocksDB")
+        find_package(RocksDB REQUIRED)
+        add_library(RocksDB::RocksDB ALIAS RocksDB::rocksdb)
+    elseif(MINIFI_ROCKSDB_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build RocksDB from source")
+
+        if (BUILD_ROCKSDB)
+            include(BundledRocksDB)
+            use_bundled_rocksdb(${SOURCE_DIR} ${BINARY_DIR})
+        else()
+            list(APPEND CMAKE_MODULE_PATH "${SOURCE_DIR}/cmake/rocksdb/sys")
+            find_package(RocksDB REQUIRED)
+        endif()
+    endif()
+endfunction(get_rocksdb SOURCE_DIR BINARY_DIR)
diff --git a/cmake/Bustache.cmake b/cmake/GetSpdlog.cmake
similarity index 65%
copy from cmake/Bustache.cmake
copy to cmake/GetSpdlog.cmake
index 116028775..747894984 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetSpdlog.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,18 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_spdlog)
+    include(GetFmt)
+    get_fmt()
+
+    if(MINIFI_SPDLOG_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install spdlog")
+        find_package(spdlog REQUIRED)
+
+        add_library(spdlog ALIAS spdlog::spdlog)
+    elseif(MINIFI_SPDLOG_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build spdlog from source")
+        include(Spdlog)
+    endif()
+endfunction(get_spdlog)
diff --git a/cmake/Bustache.cmake b/cmake/GetZLIB.cmake
similarity index 66%
copy from cmake/Bustache.cmake
copy to cmake/GetZLIB.cmake
index 116028775..6e7bea1e3 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetZLIB.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_zlib SOURCE_DIR BINARY_DIR)
+    if(MINIFI_ZLIB_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install zlib")
+        find_package(ZLIB REQUIRED)
+    elseif(MINIFI_ZLIB_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build zlib from source")
+        include(BundledZLIB)
+        use_bundled_zlib(${SOURCE_DIR} ${BINARY_DIR})
+    endif()
+endfunction(get_zlib)
diff --git a/cmake/Bustache.cmake b/cmake/GetZstd.cmake
similarity index 68%
copy from cmake/Bustache.cmake
copy to cmake/GetZstd.cmake
index 116028775..a0334b02d 100644
--- a/cmake/Bustache.cmake
+++ b/cmake/GetZstd.cmake
@@ -1,4 +1,3 @@
-#
 # 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
@@ -15,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#
-include(FetchContent)
-include(fmt)
-set(BUSTACHE_USE_FMT ON CACHE STRING "" FORCE)
-FetchContent_Declare(Bustache
-        GIT_REPOSITORY  https://github.com/jamboree/bustache.git
-        GIT_TAG         47096caa8e1f9f7ebe34e3a022dbb822c174011d
-)
-FetchContent_MakeAvailable(Bustache)
+
+function(get_zstd)
+    if(MINIFI_ZSTD_SOURCE STREQUAL "CONAN")
+        message("Using Conan to install zstd")
+        find_package(zstd REQUIRED)
+        add_library(zstd::zstd ALIAS zstd::libzstd_static)
+    elseif(MINIFI_ZSTD_SOURCE STREQUAL "BUILD")
+        message("Using CMake to build zstd from source")
+        include(Zstd)
+    endif()
+endfunction(get_zstd)
diff --git a/cmake/MiNiFiOptions.cmake b/cmake/MiNiFiOptions.cmake
index 536e93557..8a7ccc58c 100644
--- a/cmake/MiNiFiOptions.cmake
+++ b/cmake/MiNiFiOptions.cmake
@@ -23,6 +23,13 @@ function(add_minifi_option OPTION_NAME OPTION_DESCRIPTION OPTION_VALUE)
     set(MINIFI_OPTIONS ${MINIFI_OPTIONS} PARENT_SCOPE)
 endfunction()
 
+function(add_minifi_multi_option OPTION_NAME OPTION_DESCRIPTION OPTION_VALUES DEFAULT_VALUE)
+    set(${OPTION_NAME} ${DEFAULT_VALUE} CACHE STRING ${OPTION_DESCRIPTION})
+    set_property(CACHE ${OPTION_NAME} PROPERTY STRINGS ${OPTION_VALUES})
+    list(APPEND MINIFI_OPTIONS ${OPTION_NAME})
+    set(MINIFI_OPTIONS ${MINIFI_OPTIONS} PARENT_SCOPE)
+endfunction()
+
 function(add_minifi_dependent_option OPTION_NAME OPTION_DESCRIPTION OPTION_VALUE DEPENDS FORCE)
     cmake_dependent_option(${OPTION_NAME} ${OPTION_DESCRIPTION} ${OPTION_VALUE} ${DEPENDS} ${FORCE})
     list(APPEND MINIFI_OPTIONS ${OPTION_NAME})
@@ -65,15 +72,6 @@ add_minifi_option(AWS_ENABLE_UNITY_BUILD "If enabled, AWS SDK libraries will be
 add_minifi_dependent_option(MINIFI_ADVANCED_ASAN_BUILD "Uses AddressSanitizer to instrument the code" OFF "NOT WIN32" OFF)
 add_minifi_dependent_option(MINIFI_ADVANCED_CODE_COVERAGE "Use coverage build options and enable coverage build target" OFF "NOT WIN32" OFF)
 
-# Option: STRICT_GSL_CHECKS
-# AUDIT: Enable all checks, including gsl_ExpectsAudit() and gsl_EnsuresAudit()
-# ON: Enable all checks, excluding gsl_ExpectsAudit() and gsl_EnsuresAudit() (GSL default)
-# DEBUG_ONLY: Like ON in the Debug configuration, OFF in others (MiNiFi C++ default)
-# OFF: Throw on contract checking and assertion failures instead of calling std::terminate()
-set(STRICT_GSL_CHECKS "DEBUG_ONLY" CACHE STRING "Contract checking and assertion failures call terminate")
-list(APPEND STRICT_GSL_CHECKS_Values AUDIT ON DEBUG_ONLY OFF)
-set_property(CACHE STRICT_GSL_CHECKS PROPERTY STRINGS ${STRICT_GSL_CHECKS_Values})
-
 if (WIN32)
     add_minifi_option(MINIFI_INCLUDE_VC_REDIST_MERGE_MODULES "Include merge modules for Visual C++ Redistributable with the MSI generated by CPack. The resulting MSI is not distributable under Apache 2.0." OFF)
     add_minifi_option(MINIFI_INCLUDE_VC_REDIST_DLLS "Include Visual C++ Redistributable DLLs with the MSI generated by CPack. The resulting MSI is not distributable under Apache 2.0." OFF)
@@ -123,6 +121,31 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     add_minifi_option(ENABLE_PROCFS "Enables the procfs extension." ON)
 endif()
 
+## Each Option provides a list of possible values
+
+# Option: STRICT_GSL_CHECKS
+# AUDIT: Enable all checks, including gsl_ExpectsAudit() and gsl_EnsuresAudit()
+# ON: Enable all checks, excluding gsl_ExpectsAudit() and gsl_EnsuresAudit() (GSL default)
+# DEBUG_ONLY: Like ON in the Debug configuration, OFF in others (MiNiFi C++ default)
+# OFF: Throw on contract checking and assertion failures instead of calling std::terminate()
+set(STRICT_GSL_CHECKS "DEBUG_ONLY" CACHE STRING "Contract checking and assertion failures call terminate")
+list(APPEND STRICT_GSL_CHECKS_Values AUDIT ON DEBUG_ONLY OFF)
+set_property(CACHE STRICT_GSL_CHECKS PROPERTY STRINGS ${STRICT_GSL_CHECKS_Values})
+
+# BUILD: Fetch and build from source using CMake FetchContent or ExternalProject
+# SYSTEM: Use find_package to use the system version
+# CONAN: Use Conan packages
+add_minifi_multi_option(MINIFI_LIBCURL_SOURCE "Retrieves LibCURL from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_OPENSSL_SOURCE "Retrieves OpenSSL from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_ZLIB_SOURCE "Retrieves ZLib from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_ROCKSDB_SOURCE "Retrieves RocksDB from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_ZSTD_SOURCE "Retrieves Zstd from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_BZIP2_SOURCE "Retrieves BZip2 from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_CIVETWEB_SOURCE "Retrieves CivetWeb from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_LIBXML2_SOURCE "Retrieves LibXml2 from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_FMT_SOURCE "Retrieves Fmt from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_SPDLOG_SOURCE "Retrieves Spdlog from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
+add_minifi_multi_option(MINIFI_CATCH2_SOURCE "Retrieves Catch2 from provided source" "BUILD;SYSTEM;CONAN" "BUILD")
 
 # Docker options
 
diff --git a/cmake/Spdlog.cmake b/cmake/Spdlog.cmake
index 07eb0f103..3b0729829 100644
--- a/cmake/Spdlog.cmake
+++ b/cmake/Spdlog.cmake
@@ -17,7 +17,7 @@
 # under the License.
 #
 include(FetchContent)
-include(fmt)
+
 set(SPDLOG_FMT_EXTERNAL ON CACHE STRING "" FORCE)
 FetchContent_Declare(Spdlog
         URL  https://github.com/gabime/spdlog/archive/refs/tags/v1.12.0.tar.gz
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 000000000..5dd4db1fc
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,90 @@
+from conan import ConanFile
+from conan.tools.cmake import CMake, CMakeToolchain
+from conan.tools.files import collect_libs, copy
+from conan.errors import ConanException
+import os
+import shutil
+
+required_conan_version = ">=2.0"
+
+shared_requires = ("openssl/3.2.1", "libcurl/8.4.0", "civetweb/1.16", "libxml2/2.12.6", "fmt/10.2.1", "spdlog/1.14.0", "catch2/3.5.4", "zlib/1.2.11", "zstd/1.5.2", "bzip2/1.0.8", "rocksdb/8.10.2@minifi/develop")
+
+shared_sources = ("CMakeLists.txt", "libminifi/*", "extensions/*", "minifi_main/*", "nanofi/*", "bin/*", "bootstrap/*", "cmake/*", "conf/*", "controller/*", "encrypt-config/*", "etc/*", "examples/*", "msi/*", "thirdparty/*", "docker/*", "LICENSE", "NOTICE", "README.md", "C2.md", "CONFIGURE.md", "CONTRIBUTING.md", "CONTROLLERS.md", "EXPRESSIONS.md", "Extensions.md", "JNI.md", "METRICS.md", "OPS.md", "PROCESSORS.md", "ThirdParties.md", "Windows.md", "aptitude.sh", "arch.sh", "bootstrap.sh" [...]
+
+
+class MiNiFiCppMain(ConanFile):
+    name = "minifi-cpp"
+    version = "0.99.1"
+    license = "Apache-2.0"
+    requires = shared_requires
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "CMakeDeps"
+    options = {"shared": [True, False], "fPIC": [True, False]}
+
+    default_options = {"shared": False, "fPIC": True}
+
+    exports_sources = shared_sources
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+
+        tc.variables["MINIFI_LIBCURL_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_OPENSSL_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_ZLIB_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_ROCKSDB_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_ZSTD_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_BZIP2_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_CIVETWEB_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_LIBXML2_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_FMT_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_SPDLOG_SOURCE"] = "CONAN"
+        tc.variables["MINIFI_CATCH2_SOURCE"] = "CONAN"
+
+        tc.variables["SKIP_TESTS"] = "OFF"
+        tc.variables["ENABLE_CIVET"] = "ON"
+        tc.variables["ENABLE_EXPRESSION_LANGUAGE"] = "ON"
+        tc.variables["ENABLE_LIBARCHIVE"] = "OFF"
+        tc.variables["ENABLE_AWS"] = "OFF"
+        tc.variables["ENABLE_SQL"] = "OFF"
+        tc.variables["ENABLE_GCP"] = "OFF"
+        tc.variables["ENABLE_LUA_SCRIPTING"] = "OFF"
+
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def overwrite_libfile(self, oldfile, newfile):
+        print("Copying {} to {}".format(oldfile, newfile))
+        if os.path.exists(oldfile):
+            try:
+                if os.path.exists(newfile):
+                    os.remove(newfile)
+
+                shutil.copy2(oldfile, newfile)
+            except Exception as e:
+                raise ConanException(f"Error copying {newfile}: {e}")
+        else:
+            raise ConanException(f"Error: {oldfile} does not exist")
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+        include_dir = os.path.join(self.source_folder)
+        built_dir = os.path.join(self.source_folder, self.folders.build)
+        copy(self, pattern="*.h*", dst=os.path.join(self.package_folder, "include"), src=include_dir, keep_path=True)
+        copy(self, pattern="*.i*", dst=os.path.join(self.package_folder, "include"), src=include_dir, keep_path=True)
+        copy(self, pattern="*.a", dst=os.path.join(self.package_folder, "lib"), src=built_dir, keep_path=False)
+        copy(self, pattern="*.so*", dst=os.path.join(self.package_folder, "lib"), src=built_dir, keep_path=False)
+
+        minifi_py_ext_oldfile = os.path.join(self.package_folder, "lib", "libminifi-python-script-extension.so")
+        minifi_py_ext_copynewfile = os.path.join(self.package_folder, "lib", "libminifi_native.so")
+        self.overwrite_libfile(minifi_py_ext_oldfile, minifi_py_ext_copynewfile)
+
+    def package_info(self):
+        self.cpp_info.libs = collect_libs(self, folder=os.path.join(self.package_folder, "lib"))
+        self.cpp_info.set_property("cmake_file_name", "minifi-cpp")
+        self.cpp_info.set_property("cmake_target_name", "minifi-cpp::minifi-cpp")
+        self.cpp_info.set_property("pkg_config_name", "minifi-cpp")
diff --git a/etc/conan/profiles/release-linux b/etc/conan/profiles/release-linux
new file mode 100644
index 000000000..9233901a5
--- /dev/null
+++ b/etc/conan/profiles/release-linux
@@ -0,0 +1,12 @@
+[settings]
+os=Linux
+arch=x86_64
+build_type=Release
+compiler=gcc
+compiler.cppstd=20
+compiler.libcxx=libstdc++11
+compiler.version=11
+[conf]
+tools.system.package_manager:mode=install
+tools.system.package_manager:sudo=True
+[options]
diff --git a/extensions/civetweb/CMakeLists.txt b/extensions/civetweb/CMakeLists.txt
index 0eab2b98c..c6f45d280 100644
--- a/extensions/civetweb/CMakeLists.txt
+++ b/extensions/civetweb/CMakeLists.txt
@@ -32,7 +32,7 @@ target_include_directories(minifi-civet-extensions BEFORE PUBLIC
                            ${CMAKE_SOURCE_DIR}/thirdparty/
                            ${civetweb_SOURCE_DIR}/include
                            ./include)
-target_link_libraries(minifi-civet-extensions ${LIBMINIFI} Threads::Threads civetweb::civetweb-cpp civetweb::c-library)
+target_link_libraries(minifi-civet-extensions ${LIBMINIFI} Threads::Threads civetweb::civetweb-cpp)
 
 register_extension(minifi-civet-extensions CIVETWEB CIVETWEB "This enables ListenHTTP" "extensions/civetweb/tests")
 register_extension_linter(minifi-civet-extensions-linter)
diff --git a/extensions/opc/CMakeLists.txt b/extensions/opc/CMakeLists.txt
index 9f1267cf9..0d120de83 100644
--- a/extensions/opc/CMakeLists.txt
+++ b/extensions/opc/CMakeLists.txt
@@ -38,7 +38,7 @@ file(GLOB SOURCES "src/*.cpp")
 add_minifi_library(minifi-opc-extensions SHARED ${SOURCES})
 
 target_link_libraries(minifi-opc-extensions ${LIBMINIFI} Threads::Threads)
-target_link_libraries(minifi-opc-extensions ${CMAKE_DL_LIBS} spdlog open62541::open62541)
+target_link_libraries(minifi-opc-extensions ${CMAKE_DL_LIBS} spdlog::spdlog open62541::open62541)
 
 register_extension(minifi-opc-extensions "OPC EXTENSIONS" OPC-EXTENSIONS "This enables OPC-UA support")
 register_extension_linter(minifi-opc-extensions-linter)
diff --git a/extensions/rocksdb-repos/CMakeLists.txt b/extensions/rocksdb-repos/CMakeLists.txt
index e9d0a7af8..2f43753c7 100644
--- a/extensions/rocksdb-repos/CMakeLists.txt
+++ b/extensions/rocksdb-repos/CMakeLists.txt
@@ -21,13 +21,8 @@ if (NOT ENABLE_ROCKSDB)
     return()
 endif()
 
-if (BUILD_ROCKSDB)
-    include(BundledRocksDB)
-    use_bundled_rocksdb(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
-else()
-    list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/rocksdb/sys")
-    find_package(RocksDB REQUIRED)
-endif()
+include(GetRocksDB)
+get_rocksdb(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
 
 include(${CMAKE_SOURCE_DIR}/extensions/ExtensionHeader.txt)
 
diff --git a/libminifi/CMakeLists.txt b/libminifi/CMakeLists.txt
index 3a7778236..73a3fc262 100644
--- a/libminifi/CMakeLists.txt
+++ b/libminifi/CMakeLists.txt
@@ -76,7 +76,7 @@ endif()
 include(RangeV3)
 include(Asio)
 include(MagicEnum)
-list(APPEND LIBMINIFI_LIBRARIES yaml-cpp ZLIB::ZLIB concurrentqueue RapidJSON spdlog Threads::Threads gsl-lite libsodium range-v3 expected-lite date::date date::tz asio magic_enum OpenSSL::Crypto OpenSSL::SSL CURL::libcurl RapidJSON)
+list(APPEND LIBMINIFI_LIBRARIES yaml-cpp ZLIB::ZLIB concurrentqueue RapidJSON spdlog::spdlog Threads::Threads gsl-lite libsodium range-v3 expected-lite date::date date::tz asio magic_enum OpenSSL::Crypto OpenSSL::SSL CURL::libcurl RapidJSON fmt::fmt)
 if(NOT WIN32)
     list(APPEND LIBMINIFI_LIBRARIES OSSP::libuuid++)
 endif()
diff --git a/libminifi/test/libtest/unit/CMakeLists.txt b/libminifi/test/libtest/unit/CMakeLists.txt
index 75847685e..3b90524e9 100644
--- a/libminifi/test/libtest/unit/CMakeLists.txt
+++ b/libminifi/test/libtest/unit/CMakeLists.txt
@@ -18,7 +18,7 @@
 #
 file(GLOB TEST_BASE_SOURCES "*.cpp")
 add_minifi_library(libminifi-unittest STATIC ${TEST_BASE_SOURCES})
-target_link_libraries(libminifi-unittest core-minifi Catch2)
+target_link_libraries(libminifi-unittest core-minifi Catch2WithMain)
 target_include_directories(libminifi-unittest BEFORE PRIVATE "${CMAKE_SOURCE_DIR}/libminifi/include/")
 if(WIN32)
     target_include_directories(libminifi-unittest BEFORE PRIVATE "${CMAKE_SOURCE_DIR}/libminifi/opsys/win")
diff --git a/libminifi/test/unit/LoggerTests.cpp b/libminifi/test/unit/LoggerTests.cpp
index 573ad2029..fc87ee500 100644
--- a/libminifi/test/unit/LoggerTests.cpp
+++ b/libminifi/test/unit/LoggerTests.cpp
@@ -380,7 +380,9 @@ TEST_CASE("Setting max log entry length to unlimited results in unlimited log en
 TEST_CASE("fmt formatting works with the logger") {
   LogTestController::getInstance().setTrace<logging::Logger>();
   std::shared_ptr<logging::Logger> logger = logging::LoggerFactory<logging::Logger>::getLogger();
-  logger->log_critical("{} equals to {}", 1min, 60s);
+  std::chrono::minutes duration{1};
+  std::string formatted_min_duration = fmt::format("{0}m", duration.count());
+  logger->log_critical("{} equals to {}", formatted_min_duration, 60s);
   logger->log_critical("{} in hex is {:#x}", 13, 13);
   logger->log_critical("Unix epoch: {}", std::chrono::system_clock::time_point());
   logger->log_critical("{:%Q %q} equals to {:%Q %q}", 2h, std::chrono::duration_cast<std::chrono::seconds>(2h));
diff --git a/thirdparty/rocksdb/all/conandata.yml b/thirdparty/rocksdb/all/conandata.yml
new file mode 100644
index 000000000..f5c3ecd30
--- /dev/null
+++ b/thirdparty/rocksdb/all/conandata.yml
@@ -0,0 +1,15 @@
+sources:
+  "8.10.2":
+    url: "https://github.com/facebook/rocksdb/archive/refs/tags/v8.10.2.tar.gz"
+    sha256: "44b6ec2f4723a0d495762da245d4a59d38704e0d9d3d31c45af4014bee853256"
+patches:
+  "8.10.2":
+    - patch_file: "patches/arm7.patch"
+      patch_description: "Fix for ARM7"
+      patch_type: "portability"
+      patch_source: "https://github.com/apache/nifi-minifi-cpp/commit/36244376bb46c5c85657c6dfe92a6a0c4cea650a"
+    - patch_file: "patches/dboptions_equality_operator.patch"
+      patch_description: "Fix for missing equality operator in DBOptions and make DBOptions configurable"
+      patch_type: "portability"
+      patch_source: "https://github.com/apache/nifi-minifi-cpp/commit/545236fd06b613f2d2b38f74ff9ee85df9190d59"
+    - patch_file: "patches/cstdint.patch"
diff --git a/thirdparty/rocksdb/all/conanfile.py b/thirdparty/rocksdb/all/conanfile.py
new file mode 100644
index 000000000..a1ff97ad8
--- /dev/null
+++ b/thirdparty/rocksdb/all/conanfile.py
@@ -0,0 +1,243 @@
+import os
+import glob
+import shutil
+
+from conan import ConanFile
+from conan.errors import ConanInvalidConfiguration
+from conan.tools.build import check_min_cppstd
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import patch, collect_libs, copy, export_conandata_patches, get, rm, rmdir
+from conan.tools.microsoft import check_min_vs, is_msvc, is_msvc_static_runtime
+from conan.tools.scm import Version
+
+required_conan_version = ">=1.53.0"
+
+
+class RocksDBConan(ConanFile):
+    name = "rocksdb"
+    homepage = "https://github.com/facebook/rocksdb"
+    license = ("GPL-2.0-only", "Apache-2.0")
+    url = "https://github.com/conan-io/conan-center-index"
+    description = "A library that provides an embeddable, persistent key-value store for fast storage"
+    topics = ("database", "leveldb", "facebook", "key-value")
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "lite": [True, False],
+        "with_gflags": [True, False],
+        "with_snappy": [True, False],
+        "with_lz4": [True, False],
+        "with_zlib": [True, False],
+        "with_bz2": [True, False],
+        "with_zstd": [True, False],
+        "with_tbb": [True, False],
+        "with_jemalloc": [True, False],
+        "enable_sse": [False, "sse42", "avx2"],
+        "use_rtti": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "lite": False,
+        "with_snappy": False,
+        "with_lz4": True,
+        "with_zlib": True,
+        "with_bz2": True,
+        "with_zstd": True,
+        "with_gflags": False,
+        "with_tbb": False,
+        "with_jemalloc": False,
+        "enable_sse": False,
+        "use_rtti": True,
+    }
+
+    @property
+    def _min_cppstd(self):
+        return "11" if Version(self.version) < "8.8.1" else "20"
+
+    @property
+    def _compilers_minimum_version(self):
+        return {} if self._min_cppstd == "11" else {
+                "apple-clang": "10",
+                "clang": "7",
+                "gcc": "7",
+                "msvc": "191",
+                "Visual Studio": "15",
+            }
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+        if self.settings.arch != "x86_64":
+            del self.options.with_tbb
+        if self.settings.build_type == "Debug":
+            self.options.use_rtti = True  # Rtti are used in asserts for debug mode...
+
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def requirements(self):
+        if self.options.with_gflags:
+            self.requires("gflags/2.2.2")
+        if self.options.with_snappy:
+            self.requires("snappy/1.1.10")
+        if self.options.with_lz4:
+            self.requires("lz4/1.9.4")
+        if self.options.with_zlib:
+            self.requires("zlib/[>=1.2.11 <2]")
+        if self.options.with_bz2:
+            self.requires("bzip2/1.0.8")
+        if self.options.with_zstd:
+            self.requires("zstd/1.5.2")
+        if self.options.get_safe("with_tbb"):
+            self.requires("onetbb/2021.10.0")
+        if self.options.with_jemalloc:
+            self.requires("jemalloc/5.3.0")
+
+    def validate(self):
+        if self.settings.compiler.get_safe("cppstd"):
+            check_min_cppstd(self, self._min_cppstd)
+
+        minimum_version = self._compilers_minimum_version.get(str(self.settings.compiler), False)
+        if minimum_version and Version(self.settings.compiler.version) < minimum_version:
+            raise ConanInvalidConfiguration(
+                f"{self.ref} requires C++{self._min_cppstd}, which your compiler does not support."
+            )
+
+        if self.settings.arch not in ["x86_64", "ppc64le", "ppc64", "mips64", "armv8"]:
+            raise ConanInvalidConfiguration("Rocksdb requires 64 bits")
+
+        check_min_vs(self, "191")
+
+        if self.version == "6.20.3" and \
+           self.settings.os == "Linux" and \
+           self.settings.compiler == "gcc" and \
+           Version(self.settings.compiler.version) < "5":
+            raise ConanInvalidConfiguration("Rocksdb 6.20.3 is not compilable with gcc <5.") # See https://github.com/facebook/rocksdb/issues/3522
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["FAIL_ON_WARNINGS"] = False
+        tc.variables["WITH_TESTS"] = False
+        tc.variables["WITH_TOOLS"] = True
+        tc.variables["WITH_CORE_TOOLS"] = False
+        tc.variables["WITH_BENCHMARK_TOOLS"] = False
+        tc.variables["WITH_FOLLY_DISTRIBUTED_MUTEX"] = False
+        if is_msvc(self):
+            tc.variables["WITH_MD_LIBRARY"] = not is_msvc_static_runtime(self)
+        tc.variables["ROCKSDB_INSTALL_ON_WINDOWS"] = self.settings.os == "Windows"
+        tc.variables["ROCKSDB_LITE"] = self.options.lite
+        tc.variables["WITH_GFLAGS"] = self.options.with_gflags
+        tc.variables["WITH_SNAPPY"] = self.options.with_snappy
+        tc.variables["WITH_LZ4"] = self.options.with_lz4
+        tc.variables["WITH_ZLIB"] = self.options.with_zlib
+        tc.variables["WITH_BZ2"] = self.options.with_bz2
+        tc.variables["WITH_ZSTD"] = self.options.with_zstd
+        tc.variables["WITH_TBB"] = self.options.get_safe("with_tbb", False)
+        tc.variables["WITH_JEMALLOC"] = self.options.with_jemalloc
+        tc.variables["ROCKSDB_BUILD_SHARED"] = self.options.shared
+        tc.variables["ROCKSDB_LIBRARY_EXPORTS"] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["ROCKSDB_DLL" ] = self.settings.os == "Windows" and self.options.shared
+        tc.variables["USE_RTTI"] = self.options.use_rtti
+        if not bool(self.options.enable_sse):
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = False
+        elif self.options.enable_sse == "sse42":
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = True
+        elif self.options.enable_sse == "avx2":
+            tc.variables["PORTABLE"] = True
+            tc.variables["FORCE_SSE42"] = False
+        # not available yet in CCI
+        tc.variables["WITH_NUMA"] = False
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        if self.options.with_jemalloc:
+            deps.set_property("jemalloc", "cmake_file_name", "JeMalloc")
+            deps.set_property("jemalloc", "cmake_target_name", "JeMalloc::JeMalloc")
+        if self.options.with_zstd:
+            deps.set_property("zstd", "cmake_target_name", "zstd::zstd")
+        deps.generate()
+
+    def build(self):
+        for patch_data in self.conan_data.get("patches", {}).get(self.version, []):
+            patch(self, patch_file=patch_data["patch_file"], base_path=self.source_folder, strip=1, fuzz=True)
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def _remove_static_libraries(self):
+        rm(self, "rocksdb.lib", os.path.join(self.package_folder, "lib"))
+        for lib in glob.glob(os.path.join(self.package_folder, "lib", "*.a")):
+            if not lib.endswith(".dll.a"):
+                os.remove(lib)
+
+    def _remove_cpp_headers(self):
+        for path in glob.glob(os.path.join(self.package_folder, "include", "rocksdb", "*")):
+            if path != os.path.join(self.package_folder, "include", "rocksdb", "c.h"):
+                if os.path.isfile(path):
+                    os.remove(path)
+                else:
+                    shutil.rmtree(path)
+
+    def package(self):
+        copy(self, "COPYING", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        copy(self, "LICENSE*", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+        cmake = CMake(self)
+        cmake.install()
+        if self.options.shared:
+            self._remove_static_libraries()
+            self._remove_cpp_headers() # Force stable ABI for shared libraries
+        rmdir(self, os.path.join(self.package_folder, "lib", "cmake"))
+        rmdir(self, os.path.join(self.package_folder, "lib", "pkgconfig"))
+
+    def package_info(self):
+        cmake_target = "rocksdb-shared" if self.options.shared else "rocksdb"
+        self.cpp_info.set_property("cmake_file_name", "RocksDB")
+        self.cpp_info.set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        # TODO: back to global scope in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.components["librocksdb"].libs = collect_libs(self)
+        if self.settings.os == "Windows":
+            self.cpp_info.components["librocksdb"].system_libs = ["shlwapi", "rpcrt4"]
+            if self.options.shared:
+                self.cpp_info.components["librocksdb"].defines = ["ROCKSDB_DLL"]
+        elif self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.components["librocksdb"].system_libs = ["pthread", "m"]
+        if self.options.lite:
+            self.cpp_info.components["librocksdb"].defines.append("ROCKSDB_LITE")
+
+        # TODO: to remove in conan v2 once cmake_find_package* generators removed
+        self.cpp_info.names["cmake_find_package"] = "RocksDB"
+        self.cpp_info.names["cmake_find_package_multi"] = "RocksDB"
+        self.cpp_info.components["librocksdb"].names["cmake_find_package"] = cmake_target
+        self.cpp_info.components["librocksdb"].names["cmake_find_package_multi"] = cmake_target
+        self.cpp_info.components["librocksdb"].set_property("cmake_target_name", f"RocksDB::{cmake_target}")
+        if self.options.with_gflags:
+            self.cpp_info.components["librocksdb"].requires.append("gflags::gflags")
+        if self.options.with_snappy:
+            self.cpp_info.components["librocksdb"].requires.append("snappy::snappy")
+        if self.options.with_lz4:
+            self.cpp_info.components["librocksdb"].requires.append("lz4::lz4")
+        if self.options.with_zlib:
+            self.cpp_info.components["librocksdb"].requires.append("zlib::zlib")
+        if self.options.with_bz2:
+            self.cpp_info.components["librocksdb"].requires.append("bzip2::bzip2")
+        if self.options.with_zstd:
+            self.cpp_info.components["librocksdb"].requires.append("zstd::zstd")
+        if self.options.get_safe("with_tbb"):
+            self.cpp_info.components["librocksdb"].requires.append("onetbb::onetbb")
+        if self.options.with_jemalloc:
+            self.cpp_info.components["librocksdb"].requires.append("jemalloc::jemalloc")
diff --git a/thirdparty/rocksdb/arm7.patch b/thirdparty/rocksdb/all/patches/arm7.patch
similarity index 100%
rename from thirdparty/rocksdb/arm7.patch
rename to thirdparty/rocksdb/all/patches/arm7.patch
diff --git a/thirdparty/rocksdb/cstdint.patch b/thirdparty/rocksdb/all/patches/cstdint.patch
similarity index 100%
rename from thirdparty/rocksdb/cstdint.patch
rename to thirdparty/rocksdb/all/patches/cstdint.patch
diff --git a/thirdparty/rocksdb/dboptions_equality_operator.patch b/thirdparty/rocksdb/all/patches/dboptions_equality_operator.patch
similarity index 100%
rename from thirdparty/rocksdb/dboptions_equality_operator.patch
rename to thirdparty/rocksdb/all/patches/dboptions_equality_operator.patch
diff --git a/thirdparty/rocksdb/config.yml b/thirdparty/rocksdb/config.yml
new file mode 100644
index 000000000..21a3c25ea
--- /dev/null
+++ b/thirdparty/rocksdb/config.yml
@@ -0,0 +1,3 @@
+versions:
+  "8.10.2":
+    folder: all


(nifi-minifi-cpp) 03/03: MINIFICPP-2473 Add .clang-format to project

Posted by sz...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

szaszm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git

commit 8ba39e475a67d3903ef4c3458a18c45283460468
Author: Martin Zink <ma...@apache.org>
AuthorDate: Fri Oct 18 17:08:22 2024 +0200

    MINIFICPP-2473 Add .clang-format to project
    
    Closes #1876
    
    Signed-off-by: Marton Szasz <sz...@apache.org>
---
 .clang-format | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 000000000..2ca04dd4e
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,54 @@
+BasedOnStyle: Google
+AccessModifierOffset: -1
+AlignAfterOpenBracket: DontAlign
+AlignConsecutiveAssignments: None
+AlignOperands: DontAlign
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: Always
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Attach
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+BreakInheritanceList: BeforeColon
+ColumnLimit: 200
+CompactNamespaces: false
+ContinuationIndentWidth: 4
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth: 2
+InsertBraces: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyIndentedWhitespace: 1
+PointerAlignment: Left
+ReferenceAlignment: Left
+ReflowComments: false
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: c++20
+TabWidth: 2
+UseTab: Never


(nifi-minifi-cpp) 02/03: MINIFICPP-2378 Add support for parameters in controller services

Posted by sz...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

szaszm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/nifi-minifi-cpp.git

commit ba91eb88465239a4472319e9ae0a6e8eb3ae7bc3
Author: Gabor Gyimesi <ga...@gmail.com>
AuthorDate: Fri Oct 18 17:08:12 2024 +0200

    MINIFICPP-2378 Add support for parameters in controller services
    
    Closes #1868
    
    Signed-off-by: Marton Szasz <sz...@apache.org>
---
 extensions/aws/processors/DeleteS3Object.h         |   4 +-
 extensions/aws/processors/FetchS3Object.h          |   4 +-
 extensions/aws/processors/PutS3Object.h            |   4 +-
 extensions/aws/processors/S3Processor.cpp          |   4 +-
 extensions/aws/tests/PutS3ObjectTests.cpp          |   2 +-
 extensions/aws/tests/S3TestsFixture.h              |  23 ++-
 .../azure/processors/AzureStorageProcessorBase.cpp |   2 +-
 .../azure/tests/AzureBlobStorageTestsFixture.h     |  15 +-
 .../azure/tests/AzureDataLakeStorageTestsFixture.h |  15 +-
 .../azure/tests/ListAzureBlobStorageTests.cpp      |   7 +-
 .../azure/tests/ListAzureDataLakeStorageTests.cpp  |   7 +-
 extensions/bustache/tests/ApplyTemplateTests.cpp   |   8 +-
 extensions/civetweb/tests/ListenHTTPTests.cpp      |  14 +-
 extensions/elasticsearch/PostElasticsearch.cpp     |  10 +-
 extensions/elasticsearch/PostElasticsearch.h       |   2 +
 .../elasticsearch/tests/PostElasticsearchTests.cpp |   5 +-
 .../execute-process/test/ExecuteProcessTests.cpp   |   6 +-
 .../tests/ProcessContextExprTests.cpp              |   2 +-
 extensions/gcp/processors/GCSProcessor.cpp         |   6 +-
 extensions/gcp/processors/GCSProcessor.h           |   1 +
 extensions/gcp/tests/DeleteGCSObjectTests.cpp      |   6 +-
 extensions/gcp/tests/FetchGCSObjectTests.cpp       |   5 +-
 extensions/gcp/tests/ListGCSBucketTests.cpp        |   5 +-
 extensions/gcp/tests/PutGCSObjectTests.cpp         |   5 +-
 extensions/grafana-loki/PushGrafanaLoki.cpp        |   4 +-
 extensions/grafana-loki/PushGrafanaLoki.h          |   2 +-
 .../grafana-loki/tests/PushGrafanaLokiGrpcTest.cpp |  18 +--
 .../grafana-loki/tests/PushGrafanaLokiRESTTest.cpp |  23 +--
 .../processors/CollectKubernetesPodMetrics.cpp     |   2 +-
 extensions/libarchive/tests/FocusArchiveTests.cpp  |  14 +-
 .../libarchive/tests/ManipulateArchiveTests.cpp    |   8 +-
 extensions/libarchive/tests/MergeFileTests.cpp     |  10 +-
 extensions/librdkafka/tests/PublishKafkaTests.cpp  |   4 +-
 .../TestExecuteScriptProcessorWithLuaScript.cpp    |  54 +++----
 extensions/mqtt/tests/ConsumeMQTTTests.cpp         |   2 +-
 extensions/mqtt/tests/PublishMQTTTests.cpp         |   2 +-
 extensions/opencv/tests/CaptureRTSPFrameTest.cpp   |   4 +-
 .../pdh/tests/PerformanceDataMonitorTests.cpp      |   4 +-
 extensions/procfs/tests/ProcFsMonitorTests.cpp     |   4 +-
 .../python/tests/ExecutePythonProcessorTests.cpp   |  10 +-
 .../TestExecuteScriptProcessorWithPythonScript.cpp |  54 +++----
 extensions/python/types/PyProcessContext.cpp       |   2 +-
 extensions/sftp/tests/FetchSFTPTests.cpp           |   8 +-
 extensions/sftp/tests/ListSFTPTests.cpp            |   8 +-
 extensions/sftp/tests/ListThenFetchSFTPTests.cpp   |   8 +-
 extensions/sftp/tests/PutSFTPTests.cpp             |   4 +-
 extensions/smb/SmbConnectionControllerService.cpp  |   2 +-
 extensions/smb/tests/FetchSmbTests.cpp             |   8 +-
 extensions/smb/tests/ListAndFetchSmbTests.cpp      |   8 +-
 extensions/smb/tests/ListSmbTests.cpp              |   8 +-
 extensions/smb/tests/PutSmbTests.cpp               |  12 +-
 extensions/splunk/SplunkHECProcessor.cpp           |   4 +-
 extensions/splunk/SplunkHECProcessor.h             |   2 +-
 extensions/splunk/tests/PutSplunkHTTPTests.cpp     |  14 +-
 .../tests/QuerySplunkIndexingStatusTests.cpp       |  14 +-
 extensions/sql/processors/SQLProcessor.cpp         |   2 +-
 extensions/sql/tests/PutSQLTests.cpp               |   1 -
 extensions/sql/tests/SQLTestPlan.h                 |   6 +-
 .../standard-processors/modbus/FetchModbusTcp.cpp  |   4 +-
 .../standard-processors/processors/GetTCP.cpp      |   6 +-
 extensions/standard-processors/processors/GetTCP.h |   2 +-
 .../standard-processors/processors/InvokeHTTP.cpp  |   2 +-
 .../standard-processors/processors/PutTCP.cpp      |   4 +-
 .../standard-processors/processors/TailFile.cpp    |   2 +-
 .../tests/integration/InvokeHTTPTests.cpp          |  54 +++----
 .../tests/unit/AppendHostInfoTests.cpp             |  18 +--
 .../tests/unit/AttributeRollingWindowTests.cpp     |   4 +-
 .../tests/unit/AttributesToJSONTests.cpp           |  10 +-
 .../tests/unit/DefragmentTextTests.cpp             |  32 ++--
 .../tests/unit/ExtractTextTests.cpp                |  16 +-
 .../tests/unit/FetchFileTests.cpp                  |   6 +-
 .../tests/unit/FlowJsonTests.cpp                   | 137 ++++++++++++++++-
 .../tests/unit/GenerateFlowFileTests.cpp           |  25 ++--
 .../tests/unit/GetFileTests.cpp                    |  10 +-
 .../standard-processors/tests/unit/GetTCPTests.cpp |  16 +-
 .../tests/unit/HashContentTest.cpp                 |  21 ++-
 .../tests/unit/JoltTransformJSONTests.cpp          |  28 ++--
 .../tests/unit/ListFileTests.cpp                   |  10 +-
 .../tests/unit/ListenSyslogTests.cpp               |  23 ++-
 .../tests/unit/ListenTcpTests.cpp                  |  24 +--
 .../tests/unit/ListenUDPTests.cpp                  |  12 +-
 .../tests/unit/LogAttributeTests.cpp               |  16 +-
 .../tests/unit/ProcessorTests.cpp                  |  28 ++--
 .../tests/unit/PutFileTests.cpp                    |  34 ++---
 .../standard-processors/tests/unit/PutTCPTests.cpp |   8 +-
 .../standard-processors/tests/unit/PutUDPTests.cpp |   4 +-
 .../tests/unit/ReplaceTextTests.cpp                |  24 +--
 .../tests/unit/RetryFlowFileTests.cpp              |  14 +-
 .../tests/unit/RouteTextTests.cpp                  |   4 +-
 .../tests/unit/SplitTextTests.cpp                  |  47 +++---
 .../tests/unit/TailFileTests.cpp                   |  70 ++++-----
 .../tests/unit/YamlConfigurationTests.cpp          | 123 +++++++++++++++-
 extensions/systemd/tests/ConsumeJournaldTest.cpp   |   2 +-
 libminifi/include/core/ProcessContext.h            |  44 +-----
 libminifi/include/core/ProcessGroup.h              |   6 +-
 .../core/controller/ControllerServiceLookup.h      |   8 +
 .../core/controller/ControllerServiceNodeMap.h     |  48 ++----
 .../core/controller/ControllerServiceProvider.h    |   7 +-
 .../ForwardingControllerServiceProvider.h          |   8 +
 .../include/core/flow/StructuredConfiguration.h    |   2 +-
 libminifi/src/RemoteProcessorGroupPort.cpp         |   2 +-
 libminifi/src/core/ProcessGroup.cpp                |  64 +++++---
 .../core/controller/ControllerServiceNodeMap.cpp   |  96 ++++++++++++
 .../core/controller/ControllerServiceProvider.cpp  |  12 +-
 .../controller/StandardControllerServiceNode.cpp   |   2 +-
 .../src/core/flow/StructuredConfiguration.cpp      |  24 ++-
 libminifi/src/utils/net/Ssl.cpp                    |   2 +-
 .../ControllerServiceIntegrationTests.cpp          |  15 +-
 .../libtest/unit/ContentRepositoryDependentTests.h |   2 +-
 libminifi/test/libtest/unit/MockClasses.h          |  42 ++++--
 libminifi/test/libtest/unit/RecordSetTesters.h     |   2 +-
 .../libtest/unit/SingleProcessorTestController.h   |  37 ++---
 libminifi/test/libtest/unit/TestBase.cpp           |  82 ++++++-----
 libminifi/test/libtest/unit/TestBase.h             |  46 +++---
 libminifi/test/libtest/unit/TestUtils.h            |   2 +-
 .../test/resources/TestControllerServices.yml      | 164 ++++++++++++++-------
 libminifi/test/unit/ProcessSessionTests.cpp        |   2 +-
 117 files changed, 1230 insertions(+), 821 deletions(-)

diff --git a/extensions/aws/processors/DeleteS3Object.h b/extensions/aws/processors/DeleteS3Object.h
index 5949d4e67..94dbf0f4f 100644
--- a/extensions/aws/processors/DeleteS3Object.h
+++ b/extensions/aws/processors/DeleteS3Object.h
@@ -31,7 +31,7 @@
 
 
 template<typename T>
-class S3TestsFixture;
+class FlowProcessorS3TestsFixture;
 
 namespace org::apache::nifi::minifi::aws::processors {
 
@@ -74,7 +74,7 @@ class DeleteS3Object : public S3Processor {
   void onTrigger(core::ProcessContext& context, core::ProcessSession& session) override;
 
  private:
-  friend class ::S3TestsFixture<DeleteS3Object>;
+  friend class ::FlowProcessorS3TestsFixture<DeleteS3Object>;
 
   explicit DeleteS3Object(std::string_view name, const minifi::utils::Identifier& uuid, std::unique_ptr<aws::s3::S3RequestSender> s3_request_sender)
     : S3Processor(name, uuid, core::logging::LoggerFactory<DeleteS3Object>::getLogger(uuid), std::move(s3_request_sender)) {
diff --git a/extensions/aws/processors/FetchS3Object.h b/extensions/aws/processors/FetchS3Object.h
index 06e934220..3a836bde1 100644
--- a/extensions/aws/processors/FetchS3Object.h
+++ b/extensions/aws/processors/FetchS3Object.h
@@ -33,7 +33,7 @@
 #include "utils/GeneralUtils.h"
 
 template<typename T>
-class S3TestsFixture;
+class FlowProcessorS3TestsFixture;
 
 namespace org::apache::nifi::minifi::aws::processors {
 
@@ -85,7 +85,7 @@ class FetchS3Object : public S3Processor {
   void onTrigger(core::ProcessContext& context, core::ProcessSession& session) override;
 
  private:
-  friend class ::S3TestsFixture<FetchS3Object>;
+  friend class ::FlowProcessorS3TestsFixture<FetchS3Object>;
 
   explicit FetchS3Object(const std::string& name, const minifi::utils::Identifier& uuid, std::unique_ptr<aws::s3::S3RequestSender> s3_request_sender)
     : S3Processor(name, uuid, core::logging::LoggerFactory<FetchS3Object>::getLogger(uuid), std::move(s3_request_sender)) {
diff --git a/extensions/aws/processors/PutS3Object.h b/extensions/aws/processors/PutS3Object.h
index 07b0fdfa3..849de3137 100644
--- a/extensions/aws/processors/PutS3Object.h
+++ b/extensions/aws/processors/PutS3Object.h
@@ -38,7 +38,7 @@
 #include "utils/Id.h"
 
 template<typename T>
-class S3TestsFixture;
+class FlowProcessorS3TestsFixture;
 
 namespace org::apache::nifi::minifi::aws::processors {
 
@@ -181,7 +181,7 @@ class PutS3Object : public S3Processor {
   static constexpr uint64_t MIN_PART_SIZE = 5_MiB;
   static constexpr uint64_t MAX_UPLOAD_SIZE = 5_GiB;
 
-  friend class ::S3TestsFixture<PutS3Object>;
+  friend class ::FlowProcessorS3TestsFixture<PutS3Object>;
 
   explicit PutS3Object(const std::string& name, const minifi::utils::Identifier& uuid, std::unique_ptr<aws::s3::S3RequestSender> s3_request_sender)
     : S3Processor(name, uuid, core::logging::LoggerFactory<PutS3Object>::getLogger(uuid), std::move(s3_request_sender)) {
diff --git a/extensions/aws/processors/S3Processor.cpp b/extensions/aws/processors/S3Processor.cpp
index 1b7e2ae0c..9c40a313b 100644
--- a/extensions/aws/processors/S3Processor.cpp
+++ b/extensions/aws/processors/S3Processor.cpp
@@ -48,7 +48,7 @@ std::optional<Aws::Auth::AWSCredentials> S3Processor::getAWSCredentialsFromContr
     return std::nullopt;
   }
 
-  std::shared_ptr<core::controller::ControllerService> service = context.getControllerService(service_name);
+  std::shared_ptr<core::controller::ControllerService> service = context.getControllerService(service_name, getUUID());
   if (!service) {
     logger_->log_error("AWS credentials service with name: '{}' could not be found", service_name);
     return std::nullopt;
@@ -121,7 +121,7 @@ void S3Processor::onSchedule(core::ProcessContext& context, core::ProcessSession
 
   if (auto communications_timeout = context.getProperty<core::TimePeriodValue>(CommunicationsTimeout)) {
     logger_->log_debug("S3Processor: Communications Timeout {}", communications_timeout->getMilliseconds());
-    client_config_->connectTimeoutMs = gsl::narrow<long>(communications_timeout->getMilliseconds().count());  // NOLINT(runtime/int)
+    client_config_->connectTimeoutMs = gsl::narrow<long>(communications_timeout->getMilliseconds().count());  // NOLINT(runtime/int,google-runtime-int)
   } else {
     throw Exception(PROCESS_SCHEDULE_EXCEPTION, "Communications Timeout missing or invalid");
   }
diff --git a/extensions/aws/tests/PutS3ObjectTests.cpp b/extensions/aws/tests/PutS3ObjectTests.cpp
index aaa207ae5..4477dc98f 100644
--- a/extensions/aws/tests/PutS3ObjectTests.cpp
+++ b/extensions/aws/tests/PutS3ObjectTests.cpp
@@ -43,7 +43,7 @@ class PutS3ObjectTestsFixture : public FlowProcessorS3TestsFixture<minifi::aws::
 
 class PutS3ObjectLimitChanged : public minifi::aws::processors::PutS3Object {
  protected:
-  friend class ::S3TestsFixture<PutS3ObjectLimitChanged>;
+  friend class ::FlowProcessorS3TestsFixture<PutS3ObjectLimitChanged>;
 
   explicit PutS3ObjectLimitChanged(const std::string& name, const minifi::utils::Identifier& uuid, std::unique_ptr<minifi::aws::s3::S3RequestSender> s3_request_sender)
     : PutS3Object(name, uuid, std::move(s3_request_sender)) {
diff --git a/extensions/aws/tests/S3TestsFixture.h b/extensions/aws/tests/S3TestsFixture.h
index 7e8055c6c..99493f3f9 100644
--- a/extensions/aws/tests/S3TestsFixture.h
+++ b/extensions/aws/tests/S3TestsFixture.h
@@ -58,9 +58,6 @@ class S3TestsFixture {
 
     // Build MiNiFi processing graph
     plan = test_controller.createPlan();
-    mock_s3_request_sender_ptr = new MockS3RequestSender();
-    std::unique_ptr<minifi::aws::s3::S3RequestSender> mock_s3_request_sender(mock_s3_request_sender_ptr);
-    s3_processor = std::shared_ptr<T>(new T("S3Processor", utils::Identifier(), std::move(mock_s3_request_sender)));
     aws_credentials_service = plan->addController("AWSCredentialsService", "AWSCredentialsService");
   }
 
@@ -121,8 +118,8 @@ class S3TestsFixture {
   TestController test_controller;
   std::shared_ptr<TestPlan> plan;
   MockS3RequestSender* mock_s3_request_sender_ptr;
-  std::shared_ptr<core::Processor> s3_processor;
-  std::shared_ptr<core::Processor> update_attribute;
+  core::Processor* s3_processor;
+  core::Processor* update_attribute;
   std::shared_ptr<core::controller::ControllerServiceNode> aws_credentials_service;
 };
 
@@ -136,6 +133,11 @@ class FlowProcessorS3TestsFixture : public S3TestsFixture<T> {
     LogTestController::getInstance().setTrace<minifi::processors::GetFile>();
     LogTestController::getInstance().setDebug<minifi::processors::UpdateAttribute>();
 
+    auto mock_s3_request_sender = std::make_unique<MockS3RequestSender>();
+    this->mock_s3_request_sender_ptr = mock_s3_request_sender.get();
+    auto s3_processor_unique_ptr = std::unique_ptr<T>(new T("S3Processor", utils::Identifier(), std::move(mock_s3_request_sender)));
+    this->s3_processor = s3_processor_unique_ptr.get();
+
     auto input_dir = this->test_controller.createTempDirectory();
     std::ofstream input_file_stream(input_dir / INPUT_FILENAME);
     input_file_stream << INPUT_DATA;
@@ -149,7 +151,7 @@ class FlowProcessorS3TestsFixture : public S3TestsFixture<T> {
       core::Relationship("success", "d"),
       true);
     this->plan->addProcessor(
-      this->s3_processor,
+      std::move(s3_processor_unique_ptr),
       "S3Processor",
       core::Relationship("success", "d"),
       true);
@@ -186,15 +188,20 @@ class FlowProcessorS3TestsFixture : public S3TestsFixture<T> {
   }
 
  protected:
-  std::shared_ptr<core::Processor> update_attribute;
+  core::Processor* update_attribute;
 };
 
 template<typename T>
 class FlowProducerS3TestsFixture : public S3TestsFixture<T> {
  public:
   FlowProducerS3TestsFixture() {
+    auto mock_s3_request_sender = std::make_unique<MockS3RequestSender>();
+    this->mock_s3_request_sender_ptr = mock_s3_request_sender.get();
+    auto s3_processor_unique_ptr = std::unique_ptr<T>(new T("S3Processor", utils::Identifier(), std::move(mock_s3_request_sender)));
+    this->s3_processor = s3_processor_unique_ptr.get();
+
     this->plan->addProcessor(
-      this->s3_processor,
+      std::move(s3_processor_unique_ptr),
       "S3Processor");
     auto log_attribute = this->plan->addProcessor(
       "LogAttribute",
diff --git a/extensions/azure/processors/AzureStorageProcessorBase.cpp b/extensions/azure/processors/AzureStorageProcessorBase.cpp
index 599a7376d..a93697019 100644
--- a/extensions/azure/processors/AzureStorageProcessorBase.cpp
+++ b/extensions/azure/processors/AzureStorageProcessorBase.cpp
@@ -35,7 +35,7 @@ std::tuple<AzureStorageProcessorBase::GetCredentialsFromControllerResult, std::o
     return std::make_tuple(GetCredentialsFromControllerResult::CONTROLLER_NAME_EMPTY, std::nullopt);
   }
 
-  std::shared_ptr<core::controller::ControllerService> service = context.getControllerService(service_name);
+  std::shared_ptr<core::controller::ControllerService> service = context.getControllerService(service_name, getUUID());
   if (nullptr == service) {
     logger_->log_error("Azure Storage credentials service with name: '{}' could not be found", service_name);
     return std::make_tuple(GetCredentialsFromControllerResult::CONTROLLER_NAME_INVALID, std::nullopt);
diff --git a/extensions/azure/tests/AzureBlobStorageTestsFixture.h b/extensions/azure/tests/AzureBlobStorageTestsFixture.h
index b847b5d68..7ca59170d 100644
--- a/extensions/azure/tests/AzureBlobStorageTestsFixture.h
+++ b/extensions/azure/tests/AzureBlobStorageTestsFixture.h
@@ -61,8 +61,9 @@ class AzureBlobStorageTestsFixture {
     plan_ = test_controller_.createPlan();
     auto mock_blob_storage = std::make_unique<MockBlobStorage>();
     mock_blob_storage_ptr_ = mock_blob_storage.get();
-    azure_blob_storage_processor_ = std::shared_ptr<ProcessorType>(
+    auto azure_blob_storage_processor_unique_ptr = std::unique_ptr<ProcessorType>(
       new ProcessorType("AzureBlobStorageProcessor", utils::Identifier(), std::move(mock_blob_storage)));
+    azure_blob_storage_processor_ = azure_blob_storage_processor_unique_ptr.get();
     auto input_dir = test_controller_.createTempDirectory();
     std::ofstream input_file_stream(input_dir / GET_FILE_NAME);
     input_file_stream << TEST_DATA;
@@ -71,7 +72,7 @@ class AzureBlobStorageTestsFixture {
     plan_->setProperty(get_file_processor_, minifi::processors::GetFile::Directory, input_dir.string());
     plan_->setProperty(get_file_processor_, minifi::processors::GetFile::KeepSourceFile, "false");
     update_attribute_processor_ = plan_->addProcessor("UpdateAttribute", "UpdateAttribute", { {"success", "d"} },  true);
-    plan_->addProcessor(azure_blob_storage_processor_, "AzureBlobStorageProcessor", { {"success", "d"} }, true);
+    plan_->addProcessor(std::move(azure_blob_storage_processor_unique_ptr), "AzureBlobStorageProcessor", { {"success", "d"} }, true);
     auto logattribute = plan_->addProcessor("LogAttribute", "LogAttribute", { {"success", "d"} }, true);
     success_putfile_ = plan_->addProcessor("PutFile", "SuccessPutFile", { {"success", "d"} }, false);
     plan_->addConnection(logattribute, {"success", "d"}, success_putfile_);
@@ -122,11 +123,11 @@ class AzureBlobStorageTestsFixture {
   TestController test_controller_;
   std::shared_ptr<TestPlan> plan_;
   MockBlobStorage* mock_blob_storage_ptr_;
-  std::shared_ptr<core::Processor> azure_blob_storage_processor_;
-  std::shared_ptr<core::Processor> get_file_processor_;
-  std::shared_ptr<core::Processor> update_attribute_processor_;
-  std::shared_ptr<core::Processor> success_putfile_;
-  std::shared_ptr<core::Processor> failure_putfile_;
+  core::Processor* azure_blob_storage_processor_;
+  core::Processor* get_file_processor_;
+  core::Processor* update_attribute_processor_;
+  core::Processor* success_putfile_;
+  core::Processor* failure_putfile_;
   std::filesystem::path failure_output_dir_;
   std::filesystem::path success_output_dir_;
 };
diff --git a/extensions/azure/tests/AzureDataLakeStorageTestsFixture.h b/extensions/azure/tests/AzureDataLakeStorageTestsFixture.h
index 7d121726d..4206ef52f 100644
--- a/extensions/azure/tests/AzureDataLakeStorageTestsFixture.h
+++ b/extensions/azure/tests/AzureDataLakeStorageTestsFixture.h
@@ -60,8 +60,9 @@ class AzureDataLakeStorageTestsFixture {
     plan_ = test_controller_.createPlan();
     auto mock_data_lake_storage_client = std::make_unique<MockDataLakeStorageClient>();
     mock_data_lake_storage_client_ptr_ = mock_data_lake_storage_client.get();
-    azure_data_lake_storage_ = std::shared_ptr<AzureDataLakeStorageProcessor>(
+    auto azure_data_lake_storage_unique_ptr = std::unique_ptr<AzureDataLakeStorageProcessor>(
       new AzureDataLakeStorageProcessor("AzureDataLakeStorageProcessor", utils::Identifier(), std::move(mock_data_lake_storage_client)));
+    azure_data_lake_storage_ = azure_data_lake_storage_unique_ptr.get();
     auto input_dir = test_controller_.createTempDirectory();
     minifi::test::utils::putFileToDir(input_dir, GETFILE_FILE_NAME, TEST_DATA);
 
@@ -70,7 +71,7 @@ class AzureDataLakeStorageTestsFixture {
     plan_->setProperty(get_file_, minifi::processors::GetFile::KeepSourceFile, "false");
 
     update_attribute_ = plan_->addProcessor("UpdateAttribute", "UpdateAttribute", { {"success", "d"} },  true);
-    plan_->addProcessor(azure_data_lake_storage_, "AzureDataLakeStorageProcessor", { {"success", "d"}, {"failure", "d"} }, true);
+    plan_->addProcessor(std::move(azure_data_lake_storage_unique_ptr), "AzureDataLakeStorageProcessor", { {"success", "d"}, {"failure", "d"} }, true);
     auto logattribute = plan_->addProcessor("LogAttribute", "LogAttribute", { {"success", "d"} }, true);
 
     success_putfile_ = plan_->addProcessor("PutFile", "SuccessPutFile", { {"success", "d"} }, false);
@@ -127,11 +128,11 @@ class AzureDataLakeStorageTestsFixture {
   TestController test_controller_;
   std::shared_ptr<TestPlan> plan_;
   MockDataLakeStorageClient* mock_data_lake_storage_client_ptr_;
-  std::shared_ptr<core::Processor> azure_data_lake_storage_;
-  std::shared_ptr<core::Processor> get_file_;
-  std::shared_ptr<core::Processor> update_attribute_;
-  std::shared_ptr<core::Processor> success_putfile_;
-  std::shared_ptr<core::Processor> failure_putfile_;
+  core::Processor* azure_data_lake_storage_;
+  core::Processor* get_file_;
+  core::Processor* update_attribute_;
+  core::Processor* success_putfile_;
+  core::Processor* failure_putfile_;
   std::shared_ptr<core::controller::ControllerServiceNode> azure_storage_cred_service_;
   std::filesystem::path failure_output_dir_;
   std::filesystem::path success_output_dir_;
diff --git a/extensions/azure/tests/ListAzureBlobStorageTests.cpp b/extensions/azure/tests/ListAzureBlobStorageTests.cpp
index 31e7bf973..3977df86d 100644
--- a/extensions/azure/tests/ListAzureBlobStorageTests.cpp
+++ b/extensions/azure/tests/ListAzureBlobStorageTests.cpp
@@ -45,9 +45,10 @@ class ListAzureBlobStorageTestsFixture {
     plan_ = test_controller_.createPlan();
     auto mock_blob_storage = std::make_unique<MockBlobStorage>();
     mock_blob_storage_ptr_ = mock_blob_storage.get();
-    list_azure_blob_storage_ = std::make_shared<minifi::azure::processors::ListAzureBlobStorage>("ListAzureBlobStorage", std::move(mock_blob_storage));
+    auto list_azure_blob_storage_unique_ptr = std::make_unique<minifi::azure::processors::ListAzureBlobStorage>("ListAzureBlobStorage", std::move(mock_blob_storage));
+    list_azure_blob_storage_ = list_azure_blob_storage_unique_ptr.get();
 
-    plan_->addProcessor(list_azure_blob_storage_, "ListAzureBlobStorage", { {"success", "d"} });
+    plan_->addProcessor(std::move(list_azure_blob_storage_unique_ptr), "ListAzureBlobStorage", { {"success", "d"} });
     auto logattribute = plan_->addProcessor("LogAttribute", "LogAttribute", { {"success", "d"} }, true);
     plan_->setProperty(logattribute, minifi::processors::LogAttribute::FlowFilesToLog, "0");
 
@@ -72,7 +73,7 @@ class ListAzureBlobStorageTestsFixture {
   TestController test_controller_;
   std::shared_ptr<TestPlan> plan_;
   MockBlobStorage* mock_blob_storage_ptr_;
-  std::shared_ptr<core::Processor> list_azure_blob_storage_;
+  core::Processor* list_azure_blob_storage_;
   std::shared_ptr<core::controller::ControllerServiceNode> azure_storage_cred_service_;
 };
 
diff --git a/extensions/azure/tests/ListAzureDataLakeStorageTests.cpp b/extensions/azure/tests/ListAzureDataLakeStorageTests.cpp
index fdf3071e1..ebd89aa49 100644
--- a/extensions/azure/tests/ListAzureDataLakeStorageTests.cpp
+++ b/extensions/azure/tests/ListAzureDataLakeStorageTests.cpp
@@ -42,10 +42,11 @@ class ListAzureDataLakeStorageTestsFixture {
     plan_ = test_controller_.createPlan();
     auto mock_data_lake_storage_client = std::make_unique<MockDataLakeStorageClient>();
     mock_data_lake_storage_client_ptr_ = mock_data_lake_storage_client.get();
-    list_azure_data_lake_storage_ = std::shared_ptr<minifi::azure::processors::ListAzureDataLakeStorage>(
+    auto list_azure_data_lake_storage_unique_ptr = std::unique_ptr<minifi::azure::processors::ListAzureDataLakeStorage>(
       new minifi::azure::processors::ListAzureDataLakeStorage("ListAzureDataLakeStorage", utils::Identifier(), std::move(mock_data_lake_storage_client)));
+    list_azure_data_lake_storage_ = list_azure_data_lake_storage_unique_ptr.get();
 
-    plan_->addProcessor(list_azure_data_lake_storage_, "ListAzureDataLakeStorage", { {"success", "d"} });
+    plan_->addProcessor(std::move(list_azure_data_lake_storage_unique_ptr), "ListAzureDataLakeStorage", { {"success", "d"} });
     auto logattribute = plan_->addProcessor("LogAttribute", "LogAttribute", { {"success", "d"} }, true);
     plan_->setProperty(logattribute, minifi::processors::LogAttribute::FlowFilesToLog, "0");
 
@@ -73,7 +74,7 @@ class ListAzureDataLakeStorageTestsFixture {
   TestController test_controller_;
   std::shared_ptr<TestPlan> plan_;
   MockDataLakeStorageClient* mock_data_lake_storage_client_ptr_;
-  std::shared_ptr<core::Processor> list_azure_data_lake_storage_;
+  core::Processor* list_azure_data_lake_storage_;
   std::shared_ptr<core::controller::ControllerServiceNode> azure_storage_cred_service_;
 };
 
diff --git a/extensions/bustache/tests/ApplyTemplateTests.cpp b/extensions/bustache/tests/ApplyTemplateTests.cpp
index 3755014d7..1af8bcb32 100644
--- a/extensions/bustache/tests/ApplyTemplateTests.cpp
+++ b/extensions/bustache/tests/ApplyTemplateTests.cpp
@@ -75,16 +75,16 @@ TEST_CASE("Test usage of ApplyTemplate", "[ApplyTemplateTest]") {
   REQUIRE_FALSE(template_source_dir.empty());
   REQUIRE_FALSE(put_file_destination_dir.empty());
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getFile");
+  auto getfile = plan->addProcessor("GetFile", "getFile");
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::Directory, get_file_source_dir.string());
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> extract_text = plan->addProcessor("ExtractText", "testExtractText", core::Relationship("success", "description"), true);
+  auto extract_text = plan->addProcessor("ExtractText", "testExtractText", core::Relationship("success", "description"), true);
   plan->setProperty(extract_text, org::apache::nifi::minifi::processors::ExtractText::Attribute, TEST_ATTR);
 
-  std::shared_ptr<core::Processor> apply_template = plan->addProcessor("ApplyTemplate", "testApplyTemplate", core::Relationship("success", "description"), true);
+  auto apply_template = plan->addProcessor("ApplyTemplate", "testApplyTemplate", core::Relationship("success", "description"), true);
 
-  std::shared_ptr<core::Processor> put_file = plan->addProcessor("PutFile", "put_file", core::Relationship("success", "description"), true);
+  auto put_file = plan->addProcessor("PutFile", "put_file", core::Relationship("success", "description"), true);
   plan->setProperty(put_file, org::apache::nifi::minifi::processors::PutFile::Directory, put_file_destination_dir.string());
   plan->setProperty(put_file, org::apache::nifi::minifi::processors::PutFile::ConflictResolution, magic_enum::enum_name(minifi::processors::PutFile::FileExistsResolutionStrategy::replace));
 
diff --git a/extensions/civetweb/tests/ListenHTTPTests.cpp b/extensions/civetweb/tests/ListenHTTPTests.cpp
index f9883515d..91beabff6 100644
--- a/extensions/civetweb/tests/ListenHTTPTests.cpp
+++ b/extensions/civetweb/tests/ListenHTTPTests.cpp
@@ -141,7 +141,7 @@ class ListenHTTPTestsFixture {
     plan->runNextProcessor();  // UpdateAttribute
     plan->runNextProcessor();  // ListenHTTP
 
-    auto raw_ptr = dynamic_cast<org::apache::nifi::minifi::processors::ListenHTTP*>(listen_http.get());
+    auto raw_ptr = dynamic_cast<org::apache::nifi::minifi::processors::ListenHTTP*>(listen_http);
     std::string protocol = std::string("http") + (raw_ptr->isSecure() ? "s" : "");
     std::string portstr = raw_ptr->getPort();
     REQUIRE(LogTestController::getInstance().contains("Listening on port " + portstr));
@@ -228,10 +228,10 @@ class ListenHTTPTestsFixture {
   std::filesystem::path tmp_dir;
   TestController testController;
   std::shared_ptr<TestPlan> plan;
-  std::shared_ptr<core::Processor> get_file;
-  std::shared_ptr<core::Processor> update_attribute;
-  std::shared_ptr<core::Processor> listen_http;
-  std::shared_ptr<core::Processor> log_attribute;
+  core::Processor* get_file = nullptr;
+  core::Processor* update_attribute = nullptr;
+  core::Processor* listen_http = nullptr;
+  core::Processor* log_attribute = nullptr;
 
   std::shared_ptr<minifi::controllers::SSLContextService> ssl_context_service;
   HttpRequestMethod method = HttpRequestMethod::GET;
@@ -672,8 +672,8 @@ TEST_CASE_METHOD(ListenHTTPTestsFixture, "HTTPS minimum SSL version", "[https]")
 
 TEST_CASE("ListenHTTP bored yield", "[listenhttp][bored][yield]") {
   using processors::ListenHTTP;
-  const auto listen_http = std::make_shared<ListenHTTP>("listenhttp");
-  SingleProcessorTestController controller{listen_http};
+  SingleProcessorTestController controller{std::make_unique<ListenHTTP>("listenhttp")};
+  auto listen_http = controller.getProcessor();
   listen_http->setProperty(ListenHTTP::Port, "0");
 
   REQUIRE(!listen_http->isYield());
diff --git a/extensions/elasticsearch/PostElasticsearch.cpp b/extensions/elasticsearch/PostElasticsearch.cpp
index 29798060d..6d9f8cf4f 100644
--- a/extensions/elasticsearch/PostElasticsearch.cpp
+++ b/extensions/elasticsearch/PostElasticsearch.cpp
@@ -37,19 +37,17 @@ void PostElasticsearch::initialize() {
   setSupportedRelationships(Relationships);
 }
 
-namespace {
-auto getSSLContextService(core::ProcessContext& context) {
+auto PostElasticsearch::getSSLContextService(core::ProcessContext& context) const {
   if (auto ssl_context = context.getProperty(PostElasticsearch::SSLContext))
-    return std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(*ssl_context));
+    return std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(*ssl_context, getUUID()));
   return std::shared_ptr<minifi::controllers::SSLContextService>{};
 }
 
-auto getCredentialsService(core::ProcessContext& context) {
+auto PostElasticsearch::getCredentialsService(core::ProcessContext& context) const {
   if (auto credentials = context.getProperty(PostElasticsearch::ElasticCredentials))
-    return std::dynamic_pointer_cast<ElasticsearchCredentialsControllerService>(context.getControllerService(*credentials));
+    return std::dynamic_pointer_cast<ElasticsearchCredentialsControllerService>(context.getControllerService(*credentials, getUUID()));
   return std::shared_ptr<ElasticsearchCredentialsControllerService>{};
 }
-}  // namespace
 
 void PostElasticsearch::onSchedule(core::ProcessContext& context, core::ProcessSessionFactory&) {
   context.getProperty(MaxBatchSize, max_batch_size_);
diff --git a/extensions/elasticsearch/PostElasticsearch.h b/extensions/elasticsearch/PostElasticsearch.h
index 7306640a6..b36cc4d82 100644
--- a/extensions/elasticsearch/PostElasticsearch.h
+++ b/extensions/elasticsearch/PostElasticsearch.h
@@ -108,6 +108,8 @@ class PostElasticsearch : public core::Processor {
 
  private:
   std::string collectPayload(core::ProcessContext&, core::ProcessSession&, std::vector<std::shared_ptr<core::FlowFile>>&) const;
+  auto getSSLContextService(core::ProcessContext& context) const;
+  auto getCredentialsService(core::ProcessContext& context) const;
 
   uint64_t max_batch_size_ = 100;
   std::string host_url_;
diff --git a/extensions/elasticsearch/tests/PostElasticsearchTests.cpp b/extensions/elasticsearch/tests/PostElasticsearchTests.cpp
index f8e7aba54..8bb45c7b8 100644
--- a/extensions/elasticsearch/tests/PostElasticsearchTests.cpp
+++ b/extensions/elasticsearch/tests/PostElasticsearchTests.cpp
@@ -25,9 +25,8 @@ namespace org::apache::nifi::minifi::extensions::elasticsearch::test {
 
 TEST_CASE("PostElasticsearch", "[elastic]") {
   MockElastic mock_elastic("10433");
-
-  auto post_elasticsearch_json = std::make_shared<PostElasticsearch>("PostElasticsearch");
-  minifi::test::SingleProcessorTestController test_controller{post_elasticsearch_json};
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<PostElasticsearch>("PostElasticsearch")};
+  auto post_elasticsearch_json = test_controller.getProcessor();
   auto elasticsearch_credentials_controller_service = test_controller.plan->addController("ElasticsearchCredentialsControllerService", "elasticsearch_credentials_controller_service");
   CHECK(test_controller.plan->setProperty(post_elasticsearch_json,
                                      PostElasticsearch::ElasticCredentials,
diff --git a/extensions/execute-process/test/ExecuteProcessTests.cpp b/extensions/execute-process/test/ExecuteProcessTests.cpp
index 7bd1ca4ce..0f993f53e 100644
--- a/extensions/execute-process/test/ExecuteProcessTests.cpp
+++ b/extensions/execute-process/test/ExecuteProcessTests.cpp
@@ -28,13 +28,13 @@ namespace org::apache::nifi::minifi::test {
 class ExecuteProcessTestsFixture {
  public:
   ExecuteProcessTestsFixture()
-      : execute_process_(std::make_shared<processors::ExecuteProcess>("ExecuteProcess")),
-        controller_(execute_process_) {
+      : controller_(std::make_unique<processors::ExecuteProcess>("ExecuteProcess")),
+        execute_process_(controller_.getProcessor<processors::ExecuteProcess>()) {
     LogTestController::getInstance().setTrace<processors::ExecuteProcess>();
   }
  protected:
-  std::shared_ptr<processors::ExecuteProcess> execute_process_;
   test::SingleProcessorTestController controller_;
+  processors::ExecuteProcess* execute_process_;
 };
 
 TEST_CASE_METHOD(ExecuteProcessTestsFixture, "ExecuteProcess can run a single command", "[ExecuteProcess]") {
diff --git a/extensions/expression-language/tests/ProcessContextExprTests.cpp b/extensions/expression-language/tests/ProcessContextExprTests.cpp
index bcd285e59..89da89d83 100644
--- a/extensions/expression-language/tests/ProcessContextExprTests.cpp
+++ b/extensions/expression-language/tests/ProcessContextExprTests.cpp
@@ -60,7 +60,7 @@ REGISTER_RESOURCE(DummyProcessor, Processor);
 TEST_CASE("ProcessContextExpr can update existing processor properties", "[setProperty][getProperty]") {
   TestController test_controller;
   std::shared_ptr<TestPlan> test_plan = test_controller.createPlan();
-  std::shared_ptr<minifi::core::Processor> dummy_processor = test_plan->addProcessor("DummyProcessor", "dummy_processor");
+  [[maybe_unused]] minifi::core::Processor* dummy_processor = test_plan->addProcessor("DummyProcessor", "dummy_processor");
   std::shared_ptr<minifi::core::ProcessContext> context = [test_plan] { test_plan->runNextProcessor(); return test_plan->getCurrentContext(); }();
   REQUIRE(dynamic_pointer_cast<minifi::core::ProcessContextExpr>(context) != nullptr);
 
diff --git a/extensions/gcp/processors/GCSProcessor.cpp b/extensions/gcp/processors/GCSProcessor.cpp
index 1a49eee6e..c09206d24 100644
--- a/extensions/gcp/processors/GCSProcessor.cpp
+++ b/extensions/gcp/processors/GCSProcessor.cpp
@@ -24,18 +24,16 @@ namespace gcs = ::google::cloud::storage;
 
 namespace org::apache::nifi::minifi::extensions::gcp {
 
-namespace {
-std::shared_ptr<google::cloud::storage::oauth2::Credentials> getCredentials(core::ProcessContext& context) {
+std::shared_ptr<google::cloud::storage::oauth2::Credentials> GCSProcessor::getCredentials(core::ProcessContext& context) const {
   std::string service_name;
   if (context.getProperty(GCSProcessor::GCPCredentials, service_name) && !IsNullOrEmpty(service_name)) {
-    auto gcp_credentials_controller_service = std::dynamic_pointer_cast<const GCPCredentialsControllerService>(context.getControllerService(service_name));
+    auto gcp_credentials_controller_service = std::dynamic_pointer_cast<const GCPCredentialsControllerService>(context.getControllerService(service_name, getUUID()));
     if (!gcp_credentials_controller_service)
       return nullptr;
     return gcp_credentials_controller_service->getCredentials();
   }
   return nullptr;
 }
-}  // namespace
 
 void GCSProcessor::onSchedule(core::ProcessContext& context, core::ProcessSessionFactory&) {
   if (auto number_of_retries = context.getProperty<uint64_t>(NumberOfRetries)) {
diff --git a/extensions/gcp/processors/GCSProcessor.h b/extensions/gcp/processors/GCSProcessor.h
index fae3bf547..d161064ca 100644
--- a/extensions/gcp/processors/GCSProcessor.h
+++ b/extensions/gcp/processors/GCSProcessor.h
@@ -67,6 +67,7 @@ class GCSProcessor : public core::Processor {
 
  protected:
   virtual google::cloud::storage::Client getClient() const;
+  std::shared_ptr<google::cloud::storage::oauth2::Credentials> getCredentials(core::ProcessContext& context) const;
 
   std::optional<std::string> endpoint_url_;
   std::shared_ptr<google::cloud::storage::oauth2::Credentials> gcp_credentials_;
diff --git a/extensions/gcp/tests/DeleteGCSObjectTests.cpp b/extensions/gcp/tests/DeleteGCSObjectTests.cpp
index 5d277fe8a..465cd6baa 100644
--- a/extensions/gcp/tests/DeleteGCSObjectTests.cpp
+++ b/extensions/gcp/tests/DeleteGCSObjectTests.cpp
@@ -49,6 +49,7 @@ REGISTER_RESOURCE(DeleteGCSObjectMocked, Processor);
 class DeleteGCSObjectTests : public ::testing::Test {
  public:
   void SetUp() override {
+    delete_gcs_object_ = test_controller_.getProcessor<DeleteGCSObjectMocked>();
     gcp_credentials_node_ = test_controller_.plan->addController("GCPCredentialsControllerService", "gcp_credentials_controller_service");
     test_controller_.plan->setProperty(gcp_credentials_node_,
                                        GCPCredentialsControllerService::CredentialsLoc,
@@ -57,9 +58,10 @@ class DeleteGCSObjectTests : public ::testing::Test {
                                        DeleteGCSObject::GCPCredentials,
                                        "gcp_credentials_controller_service");
   }
-  std::shared_ptr<DeleteGCSObjectMocked> delete_gcs_object_ = std::make_shared<DeleteGCSObjectMocked>("DeleteGCSObjectMocked");
-  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{delete_gcs_object_};
+
+  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{std::make_unique<DeleteGCSObjectMocked>("DeleteGCSObjectMocked")};
   std::shared_ptr<minifi::core::controller::ControllerServiceNode>  gcp_credentials_node_;
+  DeleteGCSObjectMocked* delete_gcs_object_ = nullptr;
 };
 
 TEST_F(DeleteGCSObjectTests, MissingBucket) {
diff --git a/extensions/gcp/tests/FetchGCSObjectTests.cpp b/extensions/gcp/tests/FetchGCSObjectTests.cpp
index d19473d65..4323528fb 100644
--- a/extensions/gcp/tests/FetchGCSObjectTests.cpp
+++ b/extensions/gcp/tests/FetchGCSObjectTests.cpp
@@ -46,6 +46,7 @@ REGISTER_RESOURCE(FetchGCSObjectMocked, Processor);
 class FetchGCSObjectTests : public ::testing::Test {
  public:
   void SetUp() override {
+    fetch_gcs_object_ = test_controller_.getProcessor<FetchGCSObjectMocked>();
     gcp_credentials_node_ = test_controller_.plan->addController("GCPCredentialsControllerService", "gcp_credentials_controller_service");
     test_controller_.plan->setProperty(gcp_credentials_node_,
                                        GCPCredentialsControllerService::CredentialsLoc,
@@ -54,8 +55,8 @@ class FetchGCSObjectTests : public ::testing::Test {
                                        FetchGCSObject::GCPCredentials,
                                        "gcp_credentials_controller_service");
   }
-  std::shared_ptr<FetchGCSObjectMocked> fetch_gcs_object_ = std::make_shared<FetchGCSObjectMocked>("FetchGCSObjectMocked");
-  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{fetch_gcs_object_};
+  FetchGCSObjectMocked* fetch_gcs_object_ = nullptr;
+  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{std::make_unique<FetchGCSObjectMocked>("FetchGCSObjectMocked")};
   std::shared_ptr<minifi::core::controller::ControllerServiceNode>  gcp_credentials_node_;
 };
 
diff --git a/extensions/gcp/tests/ListGCSBucketTests.cpp b/extensions/gcp/tests/ListGCSBucketTests.cpp
index 89ccdc718..8eac024c2 100644
--- a/extensions/gcp/tests/ListGCSBucketTests.cpp
+++ b/extensions/gcp/tests/ListGCSBucketTests.cpp
@@ -65,6 +65,7 @@ auto CreateObject(int index, int generation = 1) {
 class ListGCSBucketTests : public ::testing::Test {
  public:
   void SetUp() override {
+    list_gcs_bucket_ = test_controller_.getProcessor<ListGCSBucketMocked>();
     gcp_credentials_node_ = test_controller_.plan->addController("GCPCredentialsControllerService", "gcp_credentials_controller_service");
     test_controller_.plan->setProperty(gcp_credentials_node_,
                                        GCPCredentialsControllerService::CredentialsLoc,
@@ -73,8 +74,8 @@ class ListGCSBucketTests : public ::testing::Test {
                                        ListGCSBucket::GCPCredentials,
                                        "gcp_credentials_controller_service");
   }
-  std::shared_ptr<ListGCSBucketMocked> list_gcs_bucket_ = std::make_shared<ListGCSBucketMocked>("ListGCSBucketMocked");
-  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{list_gcs_bucket_};
+  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{std::make_unique<ListGCSBucketMocked>("ListGCSBucketMocked")};
+  ListGCSBucketMocked* list_gcs_bucket_ = nullptr;
   std::shared_ptr<minifi::core::controller::ControllerServiceNode>  gcp_credentials_node_;
 };
 
diff --git a/extensions/gcp/tests/PutGCSObjectTests.cpp b/extensions/gcp/tests/PutGCSObjectTests.cpp
index 5907ecb49..80970b78a 100644
--- a/extensions/gcp/tests/PutGCSObjectTests.cpp
+++ b/extensions/gcp/tests/PutGCSObjectTests.cpp
@@ -52,6 +52,7 @@ REGISTER_RESOURCE(PutGCSObjectMocked, Processor);
 class PutGCSObjectTests : public ::testing::Test {
  public:
   void SetUp() override {
+    put_gcs_object_ = test_controller_.getProcessor<PutGCSObjectMocked>();
     gcp_credentials_node_ = test_controller_.plan->addController("GCPCredentialsControllerService", "gcp_credentials_controller_service");
     test_controller_.plan->setProperty(gcp_credentials_node_,
                                        GCPCredentialsControllerService::CredentialsLoc,
@@ -60,8 +61,8 @@ class PutGCSObjectTests : public ::testing::Test {
                                        PutGCSObject::GCPCredentials,
                                        "gcp_credentials_controller_service");
   }
-  std::shared_ptr<PutGCSObjectMocked> put_gcs_object_ = std::make_shared<PutGCSObjectMocked>("PutGCSObjectMocked");
-  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{put_gcs_object_};
+  PutGCSObjectMocked* put_gcs_object_ = nullptr;
+  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{std::make_unique<PutGCSObjectMocked>("PutGCSObjectMocked")};
   std::shared_ptr<minifi::core::controller::ControllerServiceNode>  gcp_credentials_node_;
 
   static auto return_upload_done(const ResumableUploadRequest& request) {
diff --git a/extensions/grafana-loki/PushGrafanaLoki.cpp b/extensions/grafana-loki/PushGrafanaLoki.cpp
index 87fc9935c..a3c14b58c 100644
--- a/extensions/grafana-loki/PushGrafanaLoki.cpp
+++ b/extensions/grafana-loki/PushGrafanaLoki.cpp
@@ -77,9 +77,9 @@ void PushGrafanaLoki::LogBatch::setStartPushTime(std::chrono::system_clock::time
 
 const core::Relationship PushGrafanaLoki::Self("__self__", "Marks the FlowFile to be owned by this processor");
 
-std::shared_ptr<minifi::controllers::SSLContextService> PushGrafanaLoki::getSSLContextService(core::ProcessContext& context) {
+std::shared_ptr<minifi::controllers::SSLContextService> PushGrafanaLoki::getSSLContextService(core::ProcessContext& context) const {
   if (auto ssl_context = context.getProperty(PushGrafanaLoki::SSLContextService)) {
-    return std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(*ssl_context));
+    return std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(*ssl_context, getUUID()));
   }
   return std::shared_ptr<minifi::controllers::SSLContextService>{};
 }
diff --git a/extensions/grafana-loki/PushGrafanaLoki.h b/extensions/grafana-loki/PushGrafanaLoki.h
index 5e6597cdd..445677d20 100644
--- a/extensions/grafana-loki/PushGrafanaLoki.h
+++ b/extensions/grafana-loki/PushGrafanaLoki.h
@@ -132,9 +132,9 @@ class PushGrafanaLoki : public core::Processor {
     std::shared_ptr<core::logging::Logger> logger_;
   };
 
-  static std::shared_ptr<minifi::controllers::SSLContextService> getSSLContextService(core::ProcessContext& context);
   static std::map<std::string, std::string> buildStreamLabelMap(core::ProcessContext& context);
 
+  std::shared_ptr<minifi::controllers::SSLContextService> getSSLContextService(core::ProcessContext& context) const;
   void processBatch(const std::vector<std::shared_ptr<core::FlowFile>>& batched_flow_files, core::ProcessSession& session);
   virtual nonstd::expected<void, std::string> submitRequest(const std::vector<std::shared_ptr<core::FlowFile>>& batched_flow_files, core::ProcessSession& session) = 0;
   void initializeHttpClient(core::ProcessContext& context);
diff --git a/extensions/grafana-loki/tests/PushGrafanaLokiGrpcTest.cpp b/extensions/grafana-loki/tests/PushGrafanaLokiGrpcTest.cpp
index 21b861e99..8b6c5e4ae 100644
--- a/extensions/grafana-loki/tests/PushGrafanaLokiGrpcTest.cpp
+++ b/extensions/grafana-loki/tests/PushGrafanaLokiGrpcTest.cpp
@@ -25,8 +25,8 @@
 namespace org::apache::nifi::minifi::extensions::grafana::loki::test {
 
 TEST_CASE("Url property is required", "[PushGrafanaLokiGrpc]") {
-  auto push_grafana_loki_grpc = std::make_shared<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_grpc);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc"));
+  auto push_grafana_loki_grpc = test_controller.getProcessor();
   test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::Url, "");
   test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::StreamLabels, "job=minifi,directory=/opt/minifi/logs/");
   test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::LogLineBatchSize, "1");
@@ -34,8 +34,8 @@ TEST_CASE("Url property is required", "[PushGrafanaLokiGrpc]") {
 }
 
 TEST_CASE("Valid stream labels need to be set", "[PushGrafanaLokiGrpc]") {
-  auto push_grafana_loki_grpc = std::make_shared<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_grpc);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc"));
+  auto push_grafana_loki_grpc = test_controller.getProcessor();
   test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::Url, "localhost:10991");
   test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::LogLineBatchSize, "1");
   SECTION("Stream labels cannot be empty") {
@@ -48,8 +48,8 @@ TEST_CASE("Valid stream labels need to be set", "[PushGrafanaLokiGrpc]") {
 }
 
 TEST_CASE("Log Line Batch Size cannot be 0", "[PushGrafanaLokiGrpc]") {
-  auto push_grafana_loki_grpc = std::make_shared<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_grpc);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc"));
+  auto push_grafana_loki_grpc = test_controller.getProcessor();
   CHECK(test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::Url, "localhost:10991"));
   CHECK(test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::StreamLabels, "job=minifi,directory=/opt/minifi/logs/"));
   test_controller.plan->setProperty(push_grafana_loki_grpc, PushGrafanaLokiGrpc::LogLineBatchSize, "0");
@@ -60,8 +60,8 @@ class PushGrafanaLokiGrpcTestFixture {
  public:
   PushGrafanaLokiGrpcTestFixture()
       : mock_loki_("10991"),
-        push_grafana_loki_grpc_(std::make_shared<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc")),
-        test_controller_(push_grafana_loki_grpc_) {
+        test_controller_(std::make_unique<PushGrafanaLokiGrpc>("PushGrafanaLokiGrpc")),
+        push_grafana_loki_grpc_(test_controller_.getProcessor<PushGrafanaLokiGrpc>()) {
     LogTestController::getInstance().setDebug<TestPlan>();
     LogTestController::getInstance().setDebug<minifi::core::Processor>();
     LogTestController::getInstance().setTrace<minifi::core::ProcessSession>();
@@ -110,8 +110,8 @@ class PushGrafanaLokiGrpcTestFixture {
 
  protected:
   MockGrafanaLokiGrpc mock_loki_;
-  std::shared_ptr<PushGrafanaLokiGrpc> push_grafana_loki_grpc_;
   minifi::test::SingleProcessorTestController test_controller_;
+  PushGrafanaLokiGrpc* push_grafana_loki_grpc_;
 };
 
 TEST_CASE_METHOD(PushGrafanaLokiGrpcTestFixture, "PushGrafanaLokiGrpc should send 1 log line to Grafana Loki in a trigger", "[PushGrafanaLokiGrpc]") {
diff --git a/extensions/grafana-loki/tests/PushGrafanaLokiRESTTest.cpp b/extensions/grafana-loki/tests/PushGrafanaLokiRESTTest.cpp
index 7cd9f0256..952eb6b0e 100644
--- a/extensions/grafana-loki/tests/PushGrafanaLokiRESTTest.cpp
+++ b/extensions/grafana-loki/tests/PushGrafanaLokiRESTTest.cpp
@@ -30,8 +30,9 @@
 namespace org::apache::nifi::minifi::extensions::grafana::loki::test {
 
 TEST_CASE("Url property is required", "[PushGrafanaLokiREST]") {
-  auto push_grafana_loki_rest = std::make_shared<PushGrafanaLokiREST>("PushGrafanaLokiREST");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_rest);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiREST>("PushGrafanaLokiREST"));
+  auto push_grafana_loki_rest = test_controller.getProcessor();
+
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::Url, "");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::StreamLabels, "job=minifi,directory=/opt/minifi/logs/");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::LogLineBatchSize, "1");
@@ -39,8 +40,8 @@ TEST_CASE("Url property is required", "[PushGrafanaLokiREST]") {
 }
 
 TEST_CASE("Valid stream labels need to be set", "[PushGrafanaLokiREST]") {
-  auto push_grafana_loki_rest = std::make_shared<PushGrafanaLokiREST>("PushGrafanaLokiREST");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_rest);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiREST>("PushGrafanaLokiREST"));
+  auto push_grafana_loki_rest = test_controller.getProcessor();
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::Url, "localhost:10990");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::LogLineBatchSize, "1");
   SECTION("Stream labels cannot be empty") {
@@ -53,8 +54,8 @@ TEST_CASE("Valid stream labels need to be set", "[PushGrafanaLokiREST]") {
 }
 
 TEST_CASE("Log Line Batch Size cannot be 0", "[PushGrafanaLokiREST]") {
-  auto push_grafana_loki_rest = std::make_shared<PushGrafanaLokiREST>("PushGrafanaLokiREST");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_rest);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiREST>("PushGrafanaLokiREST"));
+  auto push_grafana_loki_rest = test_controller.getProcessor();
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::Url, "localhost:10990");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::StreamLabels, "job=minifi,directory=/opt/minifi/logs/");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::LogLineBatchSize, "0");
@@ -65,8 +66,8 @@ class PushGrafanaLokiRESTTestFixture {
  public:
   PushGrafanaLokiRESTTestFixture()
       : mock_loki_("10990"),
-        push_grafana_loki_rest_(std::make_shared<PushGrafanaLokiREST>("PushGrafanaLokiREST")),
-        test_controller_(push_grafana_loki_rest_) {
+        test_controller_(std::make_unique<PushGrafanaLokiREST>("PushGrafanaLokiREST")),
+        push_grafana_loki_rest_(test_controller_.getProcessor<PushGrafanaLokiREST>()) {
     LogTestController::getInstance().setDebug<TestPlan>();
     LogTestController::getInstance().setDebug<minifi::core::Processor>();
     LogTestController::getInstance().setTrace<minifi::core::ProcessSession>();
@@ -159,8 +160,8 @@ class PushGrafanaLokiRESTTestFixture {
 
  protected:
   MockGrafanaLokiREST mock_loki_;
-  std::shared_ptr<PushGrafanaLokiREST> push_grafana_loki_rest_;
   minifi::test::SingleProcessorTestController test_controller_;
+  PushGrafanaLokiREST* push_grafana_loki_rest_;
 };
 
 TEST_CASE_METHOD(PushGrafanaLokiRESTTestFixture, "PushGrafanaLokiREST should send 1 log line to Grafana Loki in a trigger", "[PushGrafanaLokiREST]") {
@@ -272,8 +273,8 @@ TEST_CASE_METHOD(PushGrafanaLokiRESTTestFixture, "PushGrafanaLokiREST should wai
 }
 
 TEST_CASE("If username is set, password is also required to be set", "[PushGrafanaLokiREST]") {
-  auto push_grafana_loki_rest = std::make_shared<PushGrafanaLokiREST>("PushGrafanaLokiREST");
-  minifi::test::SingleProcessorTestController test_controller(push_grafana_loki_rest);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<PushGrafanaLokiREST>("PushGrafanaLokiREST"));
+  auto push_grafana_loki_rest = test_controller.getProcessor();
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::Url, "localhost:10990");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::StreamLabels, "job=minifi,directory=/opt/minifi/logs/");
   test_controller.plan->setProperty(push_grafana_loki_rest, PushGrafanaLokiREST::LogLineBatchSize, "1");
diff --git a/extensions/kubernetes/processors/CollectKubernetesPodMetrics.cpp b/extensions/kubernetes/processors/CollectKubernetesPodMetrics.cpp
index f431ce567..bae100bda 100644
--- a/extensions/kubernetes/processors/CollectKubernetesPodMetrics.cpp
+++ b/extensions/kubernetes/processors/CollectKubernetesPodMetrics.cpp
@@ -36,7 +36,7 @@ void CollectKubernetesPodMetrics::onSchedule(core::ProcessContext& context, core
     throw minifi::Exception{ExceptionType::PROCESS_SCHEDULE_EXCEPTION, utils::string::join_pack("Missing '", KubernetesControllerService.name, "' property")};
   }
 
-  std::shared_ptr<core::controller::ControllerService> controller_service = context.getControllerService(*controller_service_name);
+  std::shared_ptr<core::controller::ControllerService> controller_service = context.getControllerService(*controller_service_name, getUUID());
   if (!controller_service) {
     throw minifi::Exception{ExceptionType::PROCESS_SCHEDULE_EXCEPTION, utils::string::join_pack("Controller service '", *controller_service_name, "' not found")};
   }
diff --git a/extensions/libarchive/tests/FocusArchiveTests.cpp b/extensions/libarchive/tests/FocusArchiveTests.cpp
index 56c7c83df..5e7c8c576 100644
--- a/extensions/libarchive/tests/FocusArchiveTests.cpp
+++ b/extensions/libarchive/tests/FocusArchiveTests.cpp
@@ -49,13 +49,13 @@ const char* FOCUSED_CONTENT = FILE_CONTENT[0];
 
 TEST_CASE("Test Creation of FocusArchiveEntry", "[getfileCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<FocusArchiveEntry>("processorname");
+  auto processor = std::make_shared<FocusArchiveEntry>("processorname");
   REQUIRE(processor->getName() == "processorname");
 }
 
 TEST_CASE("Test Creation of UnfocusArchiveEntry", "[getfileCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<UnfocusArchiveEntry>("processorname");
+  auto processor = std::make_shared<UnfocusArchiveEntry>("processorname");
   REQUIRE(processor->getName() == "processorname");
   REQUIRE(processor->getUUID());
 }
@@ -83,20 +83,20 @@ TEST_CASE("FocusArchive", "[testFocusArchive]") {
   REQUIRE(!dir1.empty());
   REQUIRE(!dir2.empty());
   REQUIRE(!dir3.empty());
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
   plan->setProperty(getfile, GetFile::Directory, dir1.string());
   plan->setProperty(getfile, GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> fprocessor = plan->addProcessor("FocusArchiveEntry", "focusarchiveCreate", core::Relationship("success", "description"), true);
+  auto fprocessor = plan->addProcessor("FocusArchiveEntry", "focusarchiveCreate", core::Relationship("success", "description"), true);
   plan->setProperty(fprocessor, FocusArchiveEntry::Path, FOCUSED_FILE);
 
-  std::shared_ptr<core::Processor> putfile1 = plan->addProcessor("PutFile", "PutFile1", core::Relationship("success", "description"), true);
+  auto putfile1 = plan->addProcessor("PutFile", "PutFile1", core::Relationship("success", "description"), true);
   plan->setProperty(putfile1, PutFile::Directory, dir2.string());
   plan->setProperty(putfile1, PutFile::ConflictResolution, magic_enum::enum_name(PutFile::FileExistsResolutionStrategy::replace));
 
-  std::shared_ptr<core::Processor> ufprocessor = plan->addProcessor("UnfocusArchiveEntry", "unfocusarchiveCreate", core::Relationship("success", "description"), true);
+  plan->addProcessor("UnfocusArchiveEntry", "unfocusarchiveCreate", core::Relationship("success", "description"), true);
 
-  std::shared_ptr<core::Processor> putfile2 = plan->addProcessor("PutFile", "PutFile2", core::Relationship("success", "description"), true);
+  auto putfile2 = plan->addProcessor("PutFile", "PutFile2", core::Relationship("success", "description"), true);
   plan->setProperty(putfile2, PutFile::Directory, dir3.string());
   plan->setProperty(putfile2, PutFile::ConflictResolution, magic_enum::enum_name(PutFile::FileExistsResolutionStrategy::replace));
 
diff --git a/extensions/libarchive/tests/ManipulateArchiveTests.cpp b/extensions/libarchive/tests/ManipulateArchiveTests.cpp
index 67ae36b18..db8a7a4ba 100644
--- a/extensions/libarchive/tests/ManipulateArchiveTests.cpp
+++ b/extensions/libarchive/tests/ManipulateArchiveTests.cpp
@@ -70,17 +70,17 @@ bool run_archive_test(OrderedTestArchive& input_archive, const OrderedTestArchiv
   REQUIRE(!dir1.empty());
   REQUIRE(!dir2.empty());
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
   plan->setProperty(getfile, GetFile::Directory, dir1.string());
   plan->setProperty(getfile, GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> maprocessor = plan->addProcessor("ManipulateArchive", "testManipulateArchive", core::Relationship("success", "description"), true);
+  auto maprocessor = plan->addProcessor("ManipulateArchive", "testManipulateArchive", core::Relationship("success", "description"), true);
 
   for (const auto& [name, value] : properties) {
     plan->setProperty(maprocessor, name, value);
   }
 
-  std::shared_ptr<core::Processor> putfile2 = plan->addProcessor("PutFile", "PutFile2", core::Relationship("success", "description"), true);
+  auto putfile2 = plan->addProcessor("PutFile", "PutFile2", core::Relationship("success", "description"), true);
   plan->setProperty(putfile2, PutFile::Directory, dir2.string());
   plan->setProperty(putfile2, PutFile::ConflictResolution, magic_enum::enum_name(PutFile::FileExistsResolutionStrategy::replace));
 
@@ -110,7 +110,7 @@ bool run_archive_test(TAE_MAP_T input_map, TAE_MAP_T output_map, const PROP_MAP_
 
 TEST_CASE("Test creation of ManipulateArchive", "[manipulatearchiveCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<ManipulateArchive>("processorname");
+  auto processor = std::make_shared<ManipulateArchive>("processorname");
   REQUIRE(processor->getName() == "processorname");
   REQUIRE(processor->getUUID());
 }
diff --git a/extensions/libarchive/tests/MergeFileTests.cpp b/extensions/libarchive/tests/MergeFileTests.cpp
index 5a6cb5ca4..a8341552f 100644
--- a/extensions/libarchive/tests/MergeFileTests.cpp
+++ b/extensions/libarchive/tests/MergeFileTests.cpp
@@ -902,18 +902,16 @@ TEST_CASE_METHOD(MergeTestController, "Maximum Group Size is respected", "[testM
 }
 
 TEST_CASE("Empty MergeContent yields") {
-  const auto merge_content = std::make_shared<minifi::processors::MergeContent>("mergeContent");
-
-  minifi::test::SingleProcessorTestController controller{merge_content};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<minifi::processors::MergeContent>("mergeContent")};
   controller.trigger();
 
+  auto merge_content = controller.getProcessor();
   CHECK(merge_content->isYield());
 }
 
 TEST_CASE("Empty MergeContent doesnt yield when processing readybins") {
-  const auto merge_content = std::make_shared<minifi::processors::MergeContent>("mergeContent");
-
-  minifi::test::SingleProcessorTestController controller{merge_content};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<minifi::processors::MergeContent>("mergeContent")};
+  const auto merge_content = controller.getProcessor();
   controller.plan->setProperty(merge_content, minifi::processors::MergeContent::MaxBinAge, "100ms");
   controller.plan->setProperty(merge_content, minifi::processors::MergeContent::MinEntries, "2");
 
diff --git a/extensions/librdkafka/tests/PublishKafkaTests.cpp b/extensions/librdkafka/tests/PublishKafkaTests.cpp
index 8180edab6..440f4ddd2 100644
--- a/extensions/librdkafka/tests/PublishKafkaTests.cpp
+++ b/extensions/librdkafka/tests/PublishKafkaTests.cpp
@@ -25,8 +25,8 @@ namespace org::apache::nifi::minifi::test {
 TEST_CASE("Scheduling should fail when batch size is larger than the max queue message count", "[testPublishKafka]") {
   LogTestController::getInstance().setTrace<TestPlan>();
   LogTestController::getInstance().setTrace<processors::PublishKafka>();
-  const auto publish_kafka = std::make_shared<processors::PublishKafka>("PublishKafka");
-  SingleProcessorTestController test_controller(publish_kafka);
+  SingleProcessorTestController test_controller(std::make_unique<processors::PublishKafka>("PublishKafka"));
+  const auto publish_kafka = test_controller.getProcessor();
   publish_kafka->setProperty(processors::PublishKafka::ClientName, "test_client");
   publish_kafka->setProperty(processors::PublishKafka::SeedBrokers, "test_seedbroker");
   publish_kafka->setProperty(processors::PublishKafka::QueueBufferMaxMessage, "1000");
diff --git a/extensions/lua/tests/TestExecuteScriptProcessorWithLuaScript.cpp b/extensions/lua/tests/TestExecuteScriptProcessorWithLuaScript.cpp
index 88619b7af..563353e21 100644
--- a/extensions/lua/tests/TestExecuteScriptProcessorWithLuaScript.cpp
+++ b/extensions/lua/tests/TestExecuteScriptProcessorWithLuaScript.cpp
@@ -31,8 +31,8 @@
 namespace org::apache::nifi::minifi::processors::test {
 
 TEST_CASE("Lua: hello world") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
   execute_script->setProperty(ExecuteScript::ScriptBody, R"(print("Hello world!"))");
@@ -81,9 +81,8 @@ end
 }
 
 TEST_CASE("Lua: Test session get should return None if there are no flowfiles in the incoming connections") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -104,9 +103,8 @@ end
 
 TEST_CASE("Lua: Test Log", "[executescriptLuaLog]") {
   LogTestController::getInstance().reset();
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -124,9 +122,8 @@ end
 }
 
 TEST_CASE("Lua: Test Read File", "[executescriptLuaRead]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -156,9 +153,8 @@ end
 }
 
 TEST_CASE("Lua: Test Write File", "[executescriptLuaWrite]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -190,9 +186,8 @@ TEST_CASE("Lua: Test Write File", "[executescriptLuaWrite]") {
 
 TEST_CASE("Lua: Test Create", "[executescriptLuaCreate]") {
   LogTestController::getInstance().reset();
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -216,9 +211,8 @@ end
 
 TEST_CASE("Lua: Test Update Attribute", "[executescriptLuaUpdateAttribute]") {
   LogTestController::getInstance().reset();
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -280,9 +274,8 @@ TEST_CASE("Lua: Test Require", "[executescriptLuaRequire]") {
 TEST_CASE("Lua: Test Module Directory property", "[executescriptLuaModuleDirectoryProperty]") {
   using org::apache::nifi::minifi::utils::file::get_executable_dir;
 
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   const auto script_files_directory =  minifi::utils::file::FileUtils::get_executable_dir() / "resources" / "test_lua_scripts";
@@ -299,9 +292,8 @@ TEST_CASE("Lua: Test Module Directory property", "[executescriptLuaModuleDirecto
 }
 
 TEST_CASE("Lua: Non existent script file should throw", "[executescriptLuaNonExistentScriptFile]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
@@ -311,9 +303,8 @@ TEST_CASE("Lua: Non existent script file should throw", "[executescriptLuaNonExi
 }
 
 TEST_CASE("Lua can remove flowfiles", "[ExecuteScript]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
   execute_script->setProperty(ExecuteScript::ScriptBody,
@@ -329,9 +320,8 @@ TEST_CASE("Lua can remove flowfiles", "[ExecuteScript]") {
 }
 
 TEST_CASE("Lua can store states in StateManager", "[ExecuteScript]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<minifi::processors::ExecuteScript>();
   execute_script->setProperty(ExecuteScript::ScriptEngine, "lua");
   execute_script->setProperty(ExecuteScript::ScriptBody,
diff --git a/extensions/mqtt/tests/ConsumeMQTTTests.cpp b/extensions/mqtt/tests/ConsumeMQTTTests.cpp
index 84729e40f..d7cd433d2 100644
--- a/extensions/mqtt/tests/ConsumeMQTTTests.cpp
+++ b/extensions/mqtt/tests/ConsumeMQTTTests.cpp
@@ -40,7 +40,7 @@ struct Fixture {
 
   TestController testController_;
   std::shared_ptr<TestPlan> plan_;
-  std::shared_ptr<core::Processor> consumeMqttProcessor_;
+  core::Processor* consumeMqttProcessor_ = nullptr;
 };
 }  // namespace
 
diff --git a/extensions/mqtt/tests/PublishMQTTTests.cpp b/extensions/mqtt/tests/PublishMQTTTests.cpp
index 24301f490..6c5b13b4b 100644
--- a/extensions/mqtt/tests/PublishMQTTTests.cpp
+++ b/extensions/mqtt/tests/PublishMQTTTests.cpp
@@ -44,7 +44,7 @@ struct Fixture {
 
   TestController testController_;
   std::shared_ptr<TestPlan> plan_;
-  std::shared_ptr<core::Processor> publishMqttProcessor_;
+  core::Processor* publishMqttProcessor_ = nullptr;
 };
 }  // namespace
 
diff --git a/extensions/opencv/tests/CaptureRTSPFrameTest.cpp b/extensions/opencv/tests/CaptureRTSPFrameTest.cpp
index 62890f28e..97bc72f7a 100644
--- a/extensions/opencv/tests/CaptureRTSPFrameTest.cpp
+++ b/extensions/opencv/tests/CaptureRTSPFrameTest.cpp
@@ -46,7 +46,7 @@ TEST_CASE("CaptureRTSPFrame::ValidCapture", "[!mayfail]") {
     LogTestController::getInstance().setDebug<core::ProcessSession>();
 
     std::shared_ptr<TestPlan> plan = testController.createPlan();
-    std::shared_ptr<core::Processor> captureRTSP = plan->addProcessor("CaptureRTSPFrame", "CaptureRTSPFrame");
+    auto captureRTSP = plan->addProcessor("CaptureRTSPFrame", "CaptureRTSPFrame");
     // the RTSP url below comes from a public RTSP stream (hopefully still alive by the time you read this)
     // alternatively, we can set our own server using vlc.
     // vlc -vvv --loop <input video> --sout '#rtp{port=1234,sdp=rtsp://127.0.0.1:port/test}' --sout-keep
@@ -69,7 +69,7 @@ TEST_CASE("CaptureRTSPFrame::InvalidURI", "[opencvtest2]") {
   LogTestController::getInstance().setDebug<core::ProcessSession>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> captureRTSP = plan->addProcessor("CaptureRTSPFrame", "CaptureRTSPFrame");
+  auto captureRTSP = plan->addProcessor("CaptureRTSPFrame", "CaptureRTSPFrame");
 
   plan->setProperty(captureRTSP, minifi::processors::CaptureRTSPFrame::RTSPHostname, "170.93.143.139");
   plan->setProperty(captureRTSP, minifi::processors::CaptureRTSPFrame::RTSPURI, "abcd");
diff --git a/extensions/pdh/tests/PerformanceDataMonitorTests.cpp b/extensions/pdh/tests/PerformanceDataMonitorTests.cpp
index 251590904..496b5abc9 100644
--- a/extensions/pdh/tests/PerformanceDataMonitorTests.cpp
+++ b/extensions/pdh/tests/PerformanceDataMonitorTests.cpp
@@ -65,8 +65,8 @@ class PerformanceDataMonitorTester {
   TestController test_controller_;
   std::filesystem::path dir_;
   std::shared_ptr<TestPlan> plan_;
-  std::shared_ptr<core::Processor> performance_monitor_;
-  std::shared_ptr<core::Processor> putfile_;
+  core::Processor* performance_monitor_;
+  core::Processor* putfile_;
 };
 
 
diff --git a/extensions/procfs/tests/ProcFsMonitorTests.cpp b/extensions/procfs/tests/ProcFsMonitorTests.cpp
index 1e40eac4f..cf2ccb4eb 100644
--- a/extensions/procfs/tests/ProcFsMonitorTests.cpp
+++ b/extensions/procfs/tests/ProcFsMonitorTests.cpp
@@ -23,8 +23,8 @@
 namespace org::apache::nifi::minifi::extensions::procfs::tests {
 
 TEST_CASE("ProcFsMonitorTests", "[procfsmonitortests]") {
-  std::shared_ptr<ProcFsMonitor> proc_fs_monitor = std::make_shared<ProcFsMonitor>("ProcFsMonitor");
-  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{proc_fs_monitor};
+  org::apache::nifi::minifi::test::SingleProcessorTestController test_controller_{std::make_unique<ProcFsMonitor>("ProcFsMonitor")};
+  auto proc_fs_monitor = test_controller_.getProcessor();
 
   SECTION("Absolute JSON") {
     test_controller_.plan->setProperty(proc_fs_monitor, ProcFsMonitor::ResultRelativenessProperty, "Absolute");
diff --git a/extensions/python/tests/ExecutePythonProcessorTests.cpp b/extensions/python/tests/ExecutePythonProcessorTests.cpp
index 28736fbcd..7585de008 100644
--- a/extensions/python/tests/ExecutePythonProcessorTests.cpp
+++ b/extensions/python/tests/ExecutePythonProcessorTests.cpp
@@ -134,14 +134,14 @@ class SimplePythonFlowFileTransferTest : public ExecutePythonProcessorTestBase {
     }
   }
 
-  std::shared_ptr<core::Processor> addGetFileProcessorToPlan(const std::filesystem::path& dir_path) {
-    std::shared_ptr<core::Processor> getfile = plan_->addProcessor("GetFile", "getfileCreate2");
+  core::Processor* addGetFileProcessorToPlan(const std::filesystem::path& dir_path) {
+    auto getfile = plan_->addProcessor("GetFile", "getfileCreate2");
     plan_->setProperty(getfile, minifi::processors::GetFile::Directory, dir_path.string());
     plan_->setProperty(getfile, minifi::processors::GetFile::KeepSourceFile, "true");
     return getfile;
   }
 
-  std::shared_ptr<core::Processor> addExecutePythonProcessorToPlan(const std::filesystem::path& used_as_script_file, const std::string& used_as_script_body) {
+  core::Processor* addExecutePythonProcessorToPlan(const std::filesystem::path& used_as_script_file, const std::string& used_as_script_body) {
     auto executePythonProcessor = plan_->addProcessor("ExecutePythonProcessor", "executePythonProcessor", core::Relationship("success", "description"), true);
     if (!used_as_script_file.empty()) {
       plan_->setProperty(executePythonProcessor, minifi::extensions::python::processors::ExecutePythonProcessor::ScriptFile, getScriptFullPath(used_as_script_file).string());
@@ -152,8 +152,8 @@ class SimplePythonFlowFileTransferTest : public ExecutePythonProcessorTestBase {
     return executePythonProcessor;
   }
 
-  std::shared_ptr<core::Processor> addPutFileProcessorToPlan(const core::Relationship& execute_python_outbound_connection, const std::filesystem::path& dir_path) {
-    std::shared_ptr<core::Processor> putfile = plan_->addProcessor("PutFile", "putfile", execute_python_outbound_connection, true);
+  core::Processor* addPutFileProcessorToPlan(const core::Relationship& execute_python_outbound_connection, const std::filesystem::path& dir_path) {
+    auto putfile = plan_->addProcessor("PutFile", "putfile", execute_python_outbound_connection, true);
     plan_->setProperty(putfile, minifi::processors::PutFile::Directory, dir_path.string());
     return putfile;
   }
diff --git a/extensions/python/tests/TestExecuteScriptProcessorWithPythonScript.cpp b/extensions/python/tests/TestExecuteScriptProcessorWithPythonScript.cpp
index 8e0c3b456..301d124fd 100644
--- a/extensions/python/tests/TestExecuteScriptProcessorWithPythonScript.cpp
+++ b/extensions/python/tests/TestExecuteScriptProcessorWithPythonScript.cpp
@@ -30,8 +30,8 @@
 namespace org::apache::nifi::minifi::processors::test {
 
 TEST_CASE("Python: hello world") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
   execute_script->setProperty(ExecuteScript::ScriptBody, R"(print("Hello world!"))");
@@ -79,9 +79,8 @@ TEST_CASE("Test both script body and script file set", "[executescriptMisconfigu
 }
 
 TEST_CASE("Python: Test session get should return None if there are no flowfiles in the incoming connections") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -98,9 +97,8 @@ def onTrigger(context, session):
 }
 
 TEST_CASE("Python: Test Read File", "[executescriptPythonRead]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -128,9 +126,8 @@ def onTrigger(context, session):
 }
 
 TEST_CASE("Python: Test Write File", "[executescriptPythonWrite]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -155,9 +152,8 @@ def onTrigger(context, session):
 }
 
 TEST_CASE("Python: Test Create", "[executescriptPythonCreate]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -178,9 +174,8 @@ def onTrigger(context, session):
 }
 
 TEST_CASE("Python: Test Update Attribute", "[executescriptPythonUpdateAttribute]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -204,9 +199,8 @@ def onTrigger(context, session):
 }
 
 TEST_CASE("Python: Test Get Context Property", "[executescriptPythonGetContextProperty]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -226,9 +220,8 @@ def onTrigger(context, session):
 TEST_CASE("Python: Test Module Directory property", "[executescriptPythonModuleDirectoryProperty]") {
   using org::apache::nifi::minifi::utils::file::get_executable_dir;
 
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   const auto script_files_directory =  minifi::utils::file::FileUtils::get_executable_dir() / "resources" / "test_python_scripts";
@@ -245,9 +238,8 @@ TEST_CASE("Python: Test Module Directory property", "[executescriptPythonModuleD
 }
 
 TEST_CASE("Python: Non existent script file should throw", "[executescriptPythonNonExistentScriptFile]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
 
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
@@ -257,9 +249,8 @@ TEST_CASE("Python: Non existent script file should throw", "[executescriptPython
 }
 
 TEST_CASE("Python can remove flowfiles", "[ExecuteScript]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<ExecuteScript>();
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
   execute_script->setProperty(ExecuteScript::ScriptBody, R"(
@@ -272,9 +263,8 @@ def onTrigger(context, session):
 }
 
 TEST_CASE("Python can store states in StateManager", "[ExecuteScript]") {
-  const auto execute_script = std::make_shared<ExecuteScript>("ExecuteScript");
-
-  minifi::test::SingleProcessorTestController controller{execute_script};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ExecuteScript>("ExecuteScript")};
+  const auto execute_script = controller.getProcessor();
   LogTestController::getInstance().setTrace<minifi::processors::ExecuteScript>();
   execute_script->setProperty(ExecuteScript::ScriptEngine, "python");
   execute_script->setProperty(ExecuteScript::ScriptBody,
diff --git a/extensions/python/types/PyProcessContext.cpp b/extensions/python/types/PyProcessContext.cpp
index cb98bddf0..aa22fb39f 100644
--- a/extensions/python/types/PyProcessContext.cpp
+++ b/extensions/python/types/PyProcessContext.cpp
@@ -123,7 +123,7 @@ PyObject* PyProcessContext::getControllerService(PyProcessContext* self, PyObjec
     return nullptr;
   }
 
-  if (auto controller_service = context->getControllerService(controller_service_name)) {
+  if (auto controller_service = context->getControllerService(controller_service_name, context->getProcessorNode()->getUUID())) {
     std::string controller_service_type_str = controller_service_type;
     if (controller_service_type_str == "SSLContextService") {
       auto ssl_ctx_service = std::dynamic_pointer_cast<controllers::SSLContextService>(controller_service);
diff --git a/extensions/sftp/tests/FetchSFTPTests.cpp b/extensions/sftp/tests/FetchSFTPTests.cpp
index 2669a7932..588ce60c9 100644
--- a/extensions/sftp/tests/FetchSFTPTests.cpp
+++ b/extensions/sftp/tests/FetchSFTPTests.cpp
@@ -156,10 +156,10 @@ class FetchSFTPTestsFixture {
   std::filesystem::path dst_dir{testController.createTempDirectory()};
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   std::unique_ptr<SFTPTestServer> sftp_server;
-  std::shared_ptr<core::Processor> generate_flow_file;
-  std::shared_ptr<core::Processor> update_attribute;
-  std::shared_ptr<core::Processor> fetch_sftp;
-  std::shared_ptr<core::Processor> put_file;
+  core::Processor* generate_flow_file;
+  core::Processor* update_attribute;
+  core::Processor* fetch_sftp;
+  core::Processor* put_file;
 };
 
 TEST_CASE_METHOD(FetchSFTPTestsFixture, "FetchSFTP fetch one file", "[FetchSFTP][basic]") {
diff --git a/extensions/sftp/tests/ListSFTPTests.cpp b/extensions/sftp/tests/ListSFTPTests.cpp
index c6c13aeb2..8d902503d 100644
--- a/extensions/sftp/tests/ListSFTPTests.cpp
+++ b/extensions/sftp/tests/ListSFTPTests.cpp
@@ -91,8 +91,8 @@ class ListSFTPTestsFixture {
   void createPlan(const utils::Identifier* list_sftp_uuid = nullptr, const std::shared_ptr<minifi::Configure>& configuration = nullptr) {
     const auto state_dir = plan == nullptr ? testController.createTempDirectory() : plan->getStateDir();
 
-    log_attribute.reset();
-    list_sftp.reset();
+    log_attribute = nullptr;
+    list_sftp = nullptr;
     plan.reset();
 
     if (configuration) {
@@ -160,8 +160,8 @@ class ListSFTPTestsFixture {
   std::filesystem::path working_directory = testController.createTempDirectory();
   std::shared_ptr<TestPlan> plan;
   std::unique_ptr<SFTPTestServer> sftp_server;
-  std::shared_ptr<core::Processor> list_sftp;
-  std::shared_ptr<core::Processor> log_attribute;
+  core::Processor* list_sftp = nullptr;
+  core::Processor* log_attribute = nullptr;
 };
 
 class PersistentListSFTPTestsFixture : public ListSFTPTestsFixture {
diff --git a/extensions/sftp/tests/ListThenFetchSFTPTests.cpp b/extensions/sftp/tests/ListThenFetchSFTPTests.cpp
index ca72cc90b..8e38f13da 100644
--- a/extensions/sftp/tests/ListThenFetchSFTPTests.cpp
+++ b/extensions/sftp/tests/ListThenFetchSFTPTests.cpp
@@ -188,10 +188,10 @@ class ListThenFetchSFTPTestsFixture {
   std::filesystem::path dst_dir = testController.createTempDirectory();
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   std::unique_ptr<SFTPTestServer> sftp_server;
-  std::shared_ptr<core::Processor> list_sftp;
-  std::shared_ptr<core::Processor> fetch_sftp;
-  std::shared_ptr<core::Processor> log_attribute;
-  std::shared_ptr<core::Processor> put_file;
+  core::Processor* list_sftp;
+  core::Processor* fetch_sftp;
+  core::Processor* log_attribute;
+  core::Processor* put_file;
 };
 
 TEST_CASE_METHOD(ListThenFetchSFTPTestsFixture, "ListSFTP then FetchSFTP one file", "[ListThenFetchSFTP][basic]") {
diff --git a/extensions/sftp/tests/PutSFTPTests.cpp b/extensions/sftp/tests/PutSFTPTests.cpp
index 0dec1faf2..cb7c29bf6 100644
--- a/extensions/sftp/tests/PutSFTPTests.cpp
+++ b/extensions/sftp/tests/PutSFTPTests.cpp
@@ -190,8 +190,8 @@ class PutSFTPTestsFixture {
   std::filesystem::path dst_dir = testController.createTempDirectory();
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   std::unique_ptr<SFTPTestServer> sftp_server;
-  std::shared_ptr<core::Processor> get_file;
-  std::shared_ptr<core::Processor> put;
+  core::Processor* get_file;
+  core::Processor* put;
 };
 
 namespace {
diff --git a/extensions/smb/SmbConnectionControllerService.cpp b/extensions/smb/SmbConnectionControllerService.cpp
index 37996d999..ed2ac164a 100644
--- a/extensions/smb/SmbConnectionControllerService.cpp
+++ b/extensions/smb/SmbConnectionControllerService.cpp
@@ -67,7 +67,7 @@ void SmbConnectionControllerService::notifyStop() {
 gsl::not_null<std::shared_ptr<SmbConnectionControllerService>> SmbConnectionControllerService::getFromProperty(const core::ProcessContext& context, const core::PropertyReference& property) {
   std::shared_ptr<SmbConnectionControllerService> smb_connection_controller_service;
   if (auto connection_controller_name = context.getProperty(property)) {
-    smb_connection_controller_service = std::dynamic_pointer_cast<SmbConnectionControllerService>(context.getControllerService(*connection_controller_name));
+    smb_connection_controller_service = std::dynamic_pointer_cast<SmbConnectionControllerService>(context.getControllerService(*connection_controller_name, context.getProcessorNode()->getUUID()));
   }
   if (!smb_connection_controller_service) {
     throw minifi::Exception(ExceptionType::PROCESS_SCHEDULE_EXCEPTION, "Missing SMB Connection Controller Service");
diff --git a/extensions/smb/tests/FetchSmbTests.cpp b/extensions/smb/tests/FetchSmbTests.cpp
index 6afe9f7a6..8fd05c8c4 100644
--- a/extensions/smb/tests/FetchSmbTests.cpp
+++ b/extensions/smb/tests/FetchSmbTests.cpp
@@ -30,8 +30,8 @@ namespace org::apache::nifi::minifi::extensions::smb::test {
 REGISTER_RESOURCE(MockSmbConnectionControllerService, ControllerService);
 
 TEST_CASE("FetchSmb invalid network path") {
-  const auto fetch_smb = std::make_shared<FetchSmb>("FetchSmb");
-  minifi::test::SingleProcessorTestController controller{fetch_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<FetchSmb>("FetchSmb")};
+  const auto fetch_smb = controller.getProcessor();
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
   REQUIRE(controller.plan->setProperty(smb_connection_node, SmbConnectionControllerService::Hostname, utils::OsUtils::getHostName().value_or("localhost")));
   REQUIRE(controller.plan->setProperty(smb_connection_node, SmbConnectionControllerService::Share, "some_share_that_does_not_exist"));
@@ -43,8 +43,8 @@ TEST_CASE("FetchSmb invalid network path") {
 }
 
 TEST_CASE("FetchSmb tests") {
-  const auto fetch_smb = std::make_shared<FetchSmb>("FetchSmb");
-  minifi::test::SingleProcessorTestController controller{fetch_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<FetchSmb>("FetchSmb")};
+  const auto fetch_smb = controller.getProcessor();
 
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
   auto mock_smb_connection_controller_service = std::dynamic_pointer_cast<MockSmbConnectionControllerService>(smb_connection_node->getControllerServiceImplementation());
diff --git a/extensions/smb/tests/ListAndFetchSmbTests.cpp b/extensions/smb/tests/ListAndFetchSmbTests.cpp
index d4779424e..0c2abed97 100644
--- a/extensions/smb/tests/ListAndFetchSmbTests.cpp
+++ b/extensions/smb/tests/ListAndFetchSmbTests.cpp
@@ -33,10 +33,10 @@ using minifi::processors::ReadFromFlowFileTestProcessor;
 TEST_CASE("ListSmb and FetchSmb work together") {
   TestController controller;
   auto plan = controller.createPlan();
-  auto list_smb = std::dynamic_pointer_cast<ListSmb>(plan->addProcessor("ListSmb", "list_smb"));
-  auto fetch_smb = std::dynamic_pointer_cast<FetchSmb>(plan->addProcessor("FetchSmb", "fetch_smb"));
-  auto read_from_success_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
-  auto read_from_failure_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
+  auto list_smb = dynamic_cast<ListSmb*>(plan->addProcessor("ListSmb", "list_smb"));
+  auto fetch_smb = dynamic_cast<FetchSmb*>(plan->addProcessor("FetchSmb", "fetch_smb"));
+  auto read_from_success_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
+  auto read_from_failure_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
 
   plan->addConnection(list_smb, ListSmb::Success, fetch_smb);
 
diff --git a/extensions/smb/tests/ListSmbTests.cpp b/extensions/smb/tests/ListSmbTests.cpp
index 4b9d1d9bb..15120d029 100644
--- a/extensions/smb/tests/ListSmbTests.cpp
+++ b/extensions/smb/tests/ListSmbTests.cpp
@@ -31,8 +31,8 @@ namespace org::apache::nifi::minifi::extensions::smb::test {
 REGISTER_RESOURCE(MockSmbConnectionControllerService, ControllerService);
 
 TEST_CASE("ListSmb invalid network path") {
-  const auto list_smb = std::make_shared<ListSmb>("ListSmb");
-  minifi::test::SingleProcessorTestController controller{list_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ListSmb>("ListSmb")};
+  const auto list_smb = controller.getProcessor();
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
   REQUIRE(controller.plan->setProperty(smb_connection_node, SmbConnectionControllerService::Hostname, utils::OsUtils::getHostName().value_or("localhost")));
   REQUIRE(controller.plan->setProperty(smb_connection_node, SmbConnectionControllerService::Share, "some_share_that_does_not_exists"));
@@ -52,8 +52,8 @@ bool checkForFlowFileWithAttributes(const std::vector<std::shared_ptr<core::Flow
 }
 
 TEST_CASE("ListSmb tests") {
-  const auto list_smb = std::make_shared<ListSmb>("ListSmb");
-  minifi::test::SingleProcessorTestController controller{list_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<ListSmb>("ListSmb")};
+  const auto list_smb = controller.getProcessor();
 
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
   auto mock_smb_connection_controller_service = std::dynamic_pointer_cast<MockSmbConnectionControllerService>(smb_connection_node->getControllerServiceImplementation());
diff --git a/extensions/smb/tests/PutSmbTests.cpp b/extensions/smb/tests/PutSmbTests.cpp
index 3fdec6dec..a60f99e43 100644
--- a/extensions/smb/tests/PutSmbTests.cpp
+++ b/extensions/smb/tests/PutSmbTests.cpp
@@ -35,8 +35,8 @@ std::string checkFileContent(const std::filesystem::path& path) {
 }
 
 TEST_CASE("PutSmb invalid network path") {
-  const auto put_smb = std::make_shared<PutSmb>("PutSmb");
-  minifi::test::SingleProcessorTestController controller{put_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<PutSmb>("PutSmb")};
+  const auto put_smb = controller.getProcessor();
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
   REQUIRE(controller.plan->setProperty(smb_connection_node, SmbConnectionControllerService::Hostname, utils::OsUtils::getHostName().value_or("localhost")));
   REQUIRE(controller.plan->setProperty(smb_connection_node, SmbConnectionControllerService::Share, "some_share_that_does_not_exists"));
@@ -48,8 +48,8 @@ TEST_CASE("PutSmb invalid network path") {
 }
 
 TEST_CASE("PutSmb conflict resolution test") {
-  const auto put_smb = std::make_shared<PutSmb>("PutSmb");
-  minifi::test::SingleProcessorTestController controller{put_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<PutSmb>("PutSmb")};
+  const auto put_smb = controller.getProcessor();
 
   auto temp_directory = controller.createTempDirectory();
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
@@ -133,8 +133,8 @@ TEST_CASE("PutSmb conflict resolution test") {
 }
 
 TEST_CASE("PutSmb create missing dirs test") {
-  const auto put_smb = std::make_shared<PutSmb>("PutSmb");
-  minifi::test::SingleProcessorTestController controller{put_smb};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<PutSmb>("PutSmb")};
+  const auto put_smb = controller.getProcessor();
 
   auto temp_directory = controller.createTempDirectory();
   auto smb_connection_node = controller.plan->addController("MockSmbConnectionControllerService", "smb_connection_controller_service");
diff --git a/extensions/splunk/SplunkHECProcessor.cpp b/extensions/splunk/SplunkHECProcessor.cpp
index aa3d3e13b..a8ee9776e 100644
--- a/extensions/splunk/SplunkHECProcessor.cpp
+++ b/extensions/splunk/SplunkHECProcessor.cpp
@@ -44,10 +44,10 @@ std::string SplunkHECProcessor::getNetworkLocation() const {
   return hostname_ + ":" + port_;
 }
 
-std::shared_ptr<minifi::controllers::SSLContextService> SplunkHECProcessor::getSSLContextService(core::ProcessContext& context) {
+std::shared_ptr<minifi::controllers::SSLContextService> SplunkHECProcessor::getSSLContextService(core::ProcessContext& context) const {
   std::string context_name;
   if (context.getProperty(SSLContext, context_name) && !IsNullOrEmpty(context_name))
-    return std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(context_name));
+    return std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(context_name, getUUID()));
   return nullptr;
 }
 
diff --git a/extensions/splunk/SplunkHECProcessor.h b/extensions/splunk/SplunkHECProcessor.h
index 47cc902a5..7df54b9aa 100644
--- a/extensions/splunk/SplunkHECProcessor.h
+++ b/extensions/splunk/SplunkHECProcessor.h
@@ -80,7 +80,7 @@ class SplunkHECProcessor : public core::Processor {
 
  protected:
   std::string getNetworkLocation() const;
-  static std::shared_ptr<minifi::controllers::SSLContextService> getSSLContextService(core::ProcessContext& context);
+  std::shared_ptr<minifi::controllers::SSLContextService> getSSLContextService(core::ProcessContext& context) const;
   void initializeClient(http::HTTPClient& client, const std::string &url, std::shared_ptr<minifi::controllers::SSLContextService> ssl_context_service) const;
 
   std::string token_;
diff --git a/extensions/splunk/tests/PutSplunkHTTPTests.cpp b/extensions/splunk/tests/PutSplunkHTTPTests.cpp
index 2b34cbd5f..93712a34e 100644
--- a/extensions/splunk/tests/PutSplunkHTTPTests.cpp
+++ b/extensions/splunk/tests/PutSplunkHTTPTests.cpp
@@ -36,10 +36,10 @@ TEST_CASE("PutSplunkHTTP tests", "[putsplunkhttp]") {
 
   TestController test_controller;
   auto plan = test_controller.createPlan();
-  auto write_to_flow_file = std::dynamic_pointer_cast<WriteToFlowFileTestProcessor>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
-  auto put_splunk_http = std::dynamic_pointer_cast<PutSplunkHTTP>(plan->addProcessor("PutSplunkHTTP", "put_splunk_http"));
-  auto read_from_success = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success"));
-  auto read_from_failure = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure"));
+  auto write_to_flow_file = dynamic_cast<WriteToFlowFileTestProcessor*>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
+  auto put_splunk_http = dynamic_cast<PutSplunkHTTP*>(plan->addProcessor("PutSplunkHTTP", "put_splunk_http"));
+  auto read_from_success = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success"));
+  auto read_from_failure = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure"));
 
   plan->addConnection(write_to_flow_file, WriteToFlowFileTestProcessor::Success, put_splunk_http);
   plan->addConnection(put_splunk_http, PutSplunkHTTP::Success, read_from_success);
@@ -128,9 +128,9 @@ TEST_CASE("PutSplunkHTTP content type tests", "[putsplunkhttpcontenttype]") {
 
   TestController test_controller;
   auto plan = test_controller.createPlan();
-  auto write_to_flow_file = std::dynamic_pointer_cast<WriteToFlowFileTestProcessor>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
-  auto update_attribute = std::dynamic_pointer_cast<UpdateAttribute>(plan->addProcessor("UpdateAttribute", "update_attribute"));
-  auto put_splunk_http = std::dynamic_pointer_cast<PutSplunkHTTP>(plan->addProcessor("PutSplunkHTTP", "put_splunk_http"));
+  auto write_to_flow_file = dynamic_cast<WriteToFlowFileTestProcessor*>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
+  auto update_attribute = dynamic_cast<UpdateAttribute*>(plan->addProcessor("UpdateAttribute", "update_attribute"));
+  auto put_splunk_http = dynamic_cast<PutSplunkHTTP*>(plan->addProcessor("PutSplunkHTTP", "put_splunk_http"));
 
   plan->addConnection(write_to_flow_file, WriteToFlowFileTestProcessor::Success, update_attribute);
   plan->addConnection(update_attribute, UpdateAttribute::Success, put_splunk_http);
diff --git a/extensions/splunk/tests/QuerySplunkIndexingStatusTests.cpp b/extensions/splunk/tests/QuerySplunkIndexingStatusTests.cpp
index de4e7dde9..9100162e4 100644
--- a/extensions/splunk/tests/QuerySplunkIndexingStatusTests.cpp
+++ b/extensions/splunk/tests/QuerySplunkIndexingStatusTests.cpp
@@ -37,13 +37,13 @@ TEST_CASE("QuerySplunkIndexingStatus tests", "[querysplunkindexingstatus]") {
 
   TestController test_controller;
   auto plan = test_controller.createPlan();
-  auto write_to_flow_file = std::dynamic_pointer_cast<WriteToFlowFileTestProcessor>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
-  auto update_attribute = std::dynamic_pointer_cast<UpdateAttribute>(plan->addProcessor("UpdateAttribute", "update_attribute"));
-  auto query_splunk_indexing_status = std::dynamic_pointer_cast<QuerySplunkIndexingStatus>(plan->addProcessor("QuerySplunkIndexingStatus", "query_splunk_indexing_status"));
-  auto read_from_acknowledged = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_acknowledged"));
-  auto read_from_undetermined = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_undetermined"));
-  auto read_from_unacknowledged = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_unacknowledged"));
-  auto read_from_failure = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure"));
+  auto write_to_flow_file = dynamic_cast<WriteToFlowFileTestProcessor*>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
+  auto update_attribute = dynamic_cast<UpdateAttribute*>(plan->addProcessor("UpdateAttribute", "update_attribute"));
+  auto query_splunk_indexing_status = dynamic_cast<QuerySplunkIndexingStatus*>(plan->addProcessor("QuerySplunkIndexingStatus", "query_splunk_indexing_status"));
+  auto read_from_acknowledged = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_acknowledged"));
+  auto read_from_undetermined = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_undetermined"));
+  auto read_from_unacknowledged = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_unacknowledged"));
+  auto read_from_failure = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure"));
 
   plan->addConnection(write_to_flow_file, WriteToFlowFileTestProcessor::Success, update_attribute);
   plan->addConnection(update_attribute, UpdateAttribute ::Success, query_splunk_indexing_status);
diff --git a/extensions/sql/processors/SQLProcessor.cpp b/extensions/sql/processors/SQLProcessor.cpp
index 44568a558..abb8d13bf 100644
--- a/extensions/sql/processors/SQLProcessor.cpp
+++ b/extensions/sql/processors/SQLProcessor.cpp
@@ -31,7 +31,7 @@ void SQLProcessor::onSchedule(core::ProcessContext& context, core::ProcessSessio
   std::string controllerService;
   context.getProperty(DBControllerService, controllerService);
 
-  if (auto service = context.getControllerService(controllerService)) {
+  if (auto service = context.getControllerService(controllerService, getUUID())) {
     db_service_ = std::dynamic_pointer_cast<sql::controllers::DatabaseService>(service);
     if (!db_service_) {
       throw minifi::Exception(PROCESSOR_EXCEPTION, "'" + controllerService + "' is not a DatabaseService");
diff --git a/extensions/sql/tests/PutSQLTests.cpp b/extensions/sql/tests/PutSQLTests.cpp
index cbeadf74e..9ef99c154 100644
--- a/extensions/sql/tests/PutSQLTests.cpp
+++ b/extensions/sql/tests/PutSQLTests.cpp
@@ -114,7 +114,6 @@ TEST_CASE("PutSQL routes to failure on malformed content statement") {
   SQLTestController testController;
 
   auto plan = testController.createSQLPlan("PutSQL", {{"success", "d"}, {"failure", "d"}});
-  auto sql_proc = plan->getSQLProcessor();
 
   std::shared_ptr<core::FlowFile> input_file;
   SECTION("No parameters") {
diff --git a/extensions/sql/tests/SQLTestPlan.h b/extensions/sql/tests/SQLTestPlan.h
index 985a72923..aebe51b2b 100644
--- a/extensions/sql/tests/SQLTestPlan.h
+++ b/extensions/sql/tests/SQLTestPlan.h
@@ -75,7 +75,7 @@ class SQLTestPlan {
     return flow_file;
   }
 
-  std::shared_ptr<core::Processor> getSQLProcessor() {
+  core::Processor* getSQLProcessor() {
     return processor_;
   }
 
@@ -83,7 +83,7 @@ class SQLTestPlan {
     if (reschedule) {
       plan_->reset(reschedule);
     }
-    plan_->runProcessor(0);  // run the one and only sql processor
+    plan_->runProcessor(static_cast<size_t>(0));  // run the one and only sql processor
   }
 
   std::vector<std::shared_ptr<core::FlowFile>> getOutputs(const core::Relationship& relationship) {
@@ -101,7 +101,7 @@ class SQLTestPlan {
 
  private:
   std::shared_ptr<TestPlan> plan_;
-  std::shared_ptr<core::Processor> processor_;
+  core::Processor* processor_;
   minifi::Connection* input_;
   std::map<core::Relationship, minifi::Connection*> outputs_;
 };
diff --git a/extensions/standard-processors/modbus/FetchModbusTcp.cpp b/extensions/standard-processors/modbus/FetchModbusTcp.cpp
index 1f8fc0ff7..cb2a28494 100644
--- a/extensions/standard-processors/modbus/FetchModbusTcp.cpp
+++ b/extensions/standard-processors/modbus/FetchModbusTcp.cpp
@@ -34,7 +34,7 @@ namespace org::apache::nifi::minifi::modbus {
 
 void FetchModbusTcp::onSchedule(core::ProcessContext& context, core::ProcessSessionFactory&) {
   const auto record_set_writer_name = context.getProperty(RecordSetWriter);
-  record_set_writer_ = std::dynamic_pointer_cast<core::RecordSetWriter>(context.getControllerService(record_set_writer_name.value_or("")));
+  record_set_writer_ = std::dynamic_pointer_cast<core::RecordSetWriter>(context.getControllerService(record_set_writer_name.value_or(""), getUUID()));
   if (!record_set_writer_) {
     throw Exception{ExceptionType::PROCESS_SCHEDULE_EXCEPTION, "Invalid or missing RecordSetWriter"};
   }
@@ -66,7 +66,7 @@ void FetchModbusTcp::onSchedule(core::ProcessContext& context, core::ProcessSess
 
   ssl_context_.reset();
   if (const auto controller_service_name = context.getProperty(SSLContextService); controller_service_name && !IsNullOrEmpty(*controller_service_name)) {
-    if (auto controller_service = context.getControllerService(*controller_service_name)) {
+    if (auto controller_service = context.getControllerService(*controller_service_name, getUUID())) {
       if (const auto ssl_context_service = std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(controller_service)) {
         ssl_context_ = utils::net::getSslContext(*ssl_context_service);
       } else {
diff --git a/extensions/standard-processors/processors/GetTCP.cpp b/extensions/standard-processors/processors/GetTCP.cpp
index d41e34774..db4e8e175 100644
--- a/extensions/standard-processors/processors/GetTCP.cpp
+++ b/extensions/standard-processors/processors/GetTCP.cpp
@@ -70,11 +70,11 @@ char GetTCP::parseDelimiter(core::ProcessContext& context) {
   return delimiter;
 }
 
-std::optional<asio::ssl::context> GetTCP::parseSSLContext(core::ProcessContext& context) {
+std::optional<asio::ssl::context> GetTCP::parseSSLContext(core::ProcessContext& context) const {
   std::optional<asio::ssl::context> ssl_context;
   if (auto context_name = context.getProperty(SSLContextService)) {
-    if (auto controller_service = context.getControllerService(*context_name)) {
-      if (auto ssl_context_service = std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(*context_name))) {
+    if (auto controller_service = context.getControllerService(*context_name, getUUID())) {
+      if (auto ssl_context_service = std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(*context_name, getUUID()))) {
         ssl_context = utils::net::getSslContext(*ssl_context_service);
       } else {
         throw Exception(PROCESS_SCHEDULE_EXCEPTION, *context_name + " is not an SSL Context Service");
diff --git a/extensions/standard-processors/processors/GetTCP.h b/extensions/standard-processors/processors/GetTCP.h
index 59cffee84..d2782a892 100644
--- a/extensions/standard-processors/processors/GetTCP.h
+++ b/extensions/standard-processors/processors/GetTCP.h
@@ -141,7 +141,7 @@ class GetTCP : public core::Processor {
 
   std::vector<utils::net::ConnectionId> parseEndpointList(core::ProcessContext& context);
   static char parseDelimiter(core::ProcessContext& context);
-  static std::optional<asio::ssl::context> parseSSLContext(core::ProcessContext& context);
+  std::optional<asio::ssl::context> parseSSLContext(core::ProcessContext& context) const;
   static uint64_t parseMaxBatchSize(core::ProcessContext& context);
 
   class TcpClient {
diff --git a/extensions/standard-processors/processors/InvokeHTTP.cpp b/extensions/standard-processors/processors/InvokeHTTP.cpp
index 6049630ac..901102a19 100644
--- a/extensions/standard-processors/processors/InvokeHTTP.cpp
+++ b/extensions/standard-processors/processors/InvokeHTTP.cpp
@@ -111,7 +111,7 @@ void InvokeHTTP::setupMembersFromProperties(const core::ProcessContext& context)
   content_type_ = context.getProperty(InvokeHTTP::ContentType);
 
   if (auto ssl_context_name = context.getProperty(SSLContext)) {
-    if (auto service = context.getControllerService(*ssl_context_name)) {
+    if (auto service = context.getControllerService(*ssl_context_name, getUUID())) {
       ssl_context_service_ = std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(service);
       if (!ssl_context_service_)
         logger_->log_error("Controller service '{}' is not an SSLContextService", *ssl_context_name);
diff --git a/extensions/standard-processors/processors/PutTCP.cpp b/extensions/standard-processors/processors/PutTCP.cpp
index 75f6a860b..54b3d2550 100644
--- a/extensions/standard-processors/processors/PutTCP.cpp
+++ b/extensions/standard-processors/processors/PutTCP.cpp
@@ -75,8 +75,8 @@ void PutTCP::onSchedule(core::ProcessContext& context, core::ProcessSessionFacto
   std::string context_name;
   ssl_context_.reset();
   if (context.getProperty(SSLContextService, context_name) && !IsNullOrEmpty(context_name)) {
-    if (auto controller_service = context.getControllerService(context_name)) {
-      if (const auto ssl_context_service = std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(context_name))) {
+    if (auto controller_service = context.getControllerService(context_name, getUUID())) {
+      if (const auto ssl_context_service = std::dynamic_pointer_cast<minifi::controllers::SSLContextService>(context.getControllerService(context_name, getUUID()))) {
         ssl_context_ = utils::net::getSslContext(*ssl_context_service);
       } else {
         throw Exception(PROCESS_SCHEDULE_EXCEPTION, context_name + " is not an SSL Context Service");
diff --git a/extensions/standard-processors/processors/TailFile.cpp b/extensions/standard-processors/processors/TailFile.cpp
index d1fd33af8..4ecfed32b 100644
--- a/extensions/standard-processors/processors/TailFile.cpp
+++ b/extensions/standard-processors/processors/TailFile.cpp
@@ -315,7 +315,7 @@ void TailFile::parseAttributeProviderServiceProperty(core::ProcessContext& conte
     return;
   }
 
-  std::shared_ptr<core::controller::ControllerService> controller_service = context.getControllerService(*attribute_provider_service_name);
+  std::shared_ptr<core::controller::ControllerService> controller_service = context.getControllerService(*attribute_provider_service_name, getUUID());
   if (!controller_service) {
     throw minifi::Exception{ExceptionType::PROCESS_SCHEDULE_EXCEPTION, utils::string::join_pack("Controller service '", *attribute_provider_service_name, "' not found")};
   }
diff --git a/extensions/standard-processors/tests/integration/InvokeHTTPTests.cpp b/extensions/standard-processors/tests/integration/InvokeHTTPTests.cpp
index e543302fa..5b87e3b3a 100644
--- a/extensions/standard-processors/tests/integration/InvokeHTTPTests.cpp
+++ b/extensions/standard-processors/tests/integration/InvokeHTTPTests.cpp
@@ -51,8 +51,8 @@ class TestHTTPServer {
 
  private:
   TestController test_controller_;
-  std::shared_ptr<processors::ListenHTTP> listen_http_;
-  std::shared_ptr<processors::LogAttribute> log_attribute_;
+  processors::ListenHTTP* listen_http_ = nullptr;
+  processors::LogAttribute* log_attribute_ = nullptr;
   std::shared_ptr<TestPlan> test_plan_ = test_controller_.createPlan();
 };
 
@@ -60,8 +60,8 @@ TestHTTPServer::TestHTTPServer() {
   LogTestController::getInstance().setDebug<org::apache::nifi::minifi::processors::ListenHTTP>();
   LogTestController::getInstance().setDebug<org::apache::nifi::minifi::processors::LogAttribute>();
 
-  listen_http_ = std::dynamic_pointer_cast<processors::ListenHTTP>(test_plan_->addProcessor("ListenHTTP", PROCESSOR_NAME));
-  log_attribute_ = std::dynamic_pointer_cast<processors::LogAttribute>(test_plan_->addProcessor("LogAttribute", "LogAttribute", core::Relationship("success", "description"), true));
+  listen_http_ = dynamic_cast<processors::ListenHTTP*>(test_plan_->addProcessor("ListenHTTP", PROCESSOR_NAME));
+  log_attribute_ = dynamic_cast<processors::LogAttribute*>(test_plan_->addProcessor("LogAttribute", "LogAttribute", core::Relationship("success", "description"), true));
   REQUIRE(listen_http_);
   REQUIRE(log_attribute_);
   test_plan_->setProperty(listen_http_, org::apache::nifi::minifi::processors::ListenHTTP::BasePath, "testytesttest");
@@ -229,7 +229,7 @@ TEST_CASE("HTTPTestsPostNoResourceClaim", "[httptest1]") {
   LogTestController::getInstance().setDebug<org::apache::nifi::minifi::processors::InvokeHTTP>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> invokehttp = plan->addProcessor("InvokeHTTP", "invokehttp");
+  auto invokehttp = plan->addProcessor("InvokeHTTP", "invokehttp");
 
   plan->setProperty(invokehttp, org::apache::nifi::minifi::processors::InvokeHTTP::Method, "POST");
   plan->setProperty(invokehttp, org::apache::nifi::minifi::processors::InvokeHTTP::URL, TestHTTPServer::URL);
@@ -261,8 +261,8 @@ TEST_CASE("HTTPTestsPenalizeNoRetry", "[httptest1]") {
   LogTestController::getInstance().setInfo<minifi::core::ProcessSession>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> genfile = plan->addProcessor("GenerateFlowFile", "genfile");
-  std::shared_ptr<core::Processor> invokehttp = plan->addProcessor("InvokeHTTP", "invokehttp", core::Relationship("success", "description"), true);
+  plan->addProcessor("GenerateFlowFile", "genfile");
+  auto invokehttp = plan->addProcessor("InvokeHTTP", "invokehttp", core::Relationship("success", "description"), true);
 
   plan->setProperty(invokehttp, InvokeHTTP::Method, "GET");
   plan->setProperty(invokehttp, InvokeHTTP::URL, "http://localhost:8681/invalid");
@@ -288,8 +288,8 @@ TEST_CASE("InvokeHTTP fails with when flow contains invalid attribute names in H
   TestHTTPServer http_server;
 
   LogTestController::getInstance().setDebug<InvokeHTTP>();
-  auto invokehttp = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invokehttp};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invokehttp = test_controller.getProcessor();
 
   invokehttp->setProperty(InvokeHTTP::Method, "GET");
   invokehttp->setProperty(InvokeHTTP::URL, TestHTTPServer::URL);
@@ -308,8 +308,8 @@ TEST_CASE("InvokeHTTP succeeds when the flow file contains an attribute that wou
   TestHTTPServer http_server;
 
   LogTestController::getInstance().setDebug<InvokeHTTP>();
-  auto invokehttp = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invokehttp};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invokehttp = test_controller.getProcessor();
 
   invokehttp->setProperty(InvokeHTTP::Method, "GET");
   invokehttp->setProperty(InvokeHTTP::URL, TestHTTPServer::URL);
@@ -329,8 +329,8 @@ TEST_CASE("InvokeHTTP replaces invalid characters of attributes", "[httptest1]")
   using minifi::processors::InvokeHTTP;
   TestHTTPServer http_server;
 
-  auto invokehttp = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invokehttp};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invokehttp = test_controller.getProcessor();
   LogTestController::getInstance().setTrace<InvokeHTTP>();
 
   invokehttp->setProperty(InvokeHTTP::Method, "GET");
@@ -350,8 +350,8 @@ TEST_CASE("InvokeHTTP drops invalid attributes from HTTP headers", "[httptest1]"
   using minifi::processors::InvokeHTTP;
   TestHTTPServer http_server;
 
-  auto invokehttp = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invokehttp};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invokehttp = test_controller.getProcessor();
   LogTestController::getInstance().setTrace<InvokeHTTP>();
 
   invokehttp->setProperty(InvokeHTTP::Method, "GET");
@@ -372,8 +372,8 @@ TEST_CASE("InvokeHTTP empty Attributes to Send means no attributes are sent", "[
   using minifi::processors::InvokeHTTP;
   TestHTTPServer http_server;
 
-  auto invokehttp = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invokehttp};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invokehttp = test_controller.getProcessor();
   LogTestController::getInstance().setTrace<InvokeHTTP>();
 
   invokehttp->setProperty(InvokeHTTP::Method, "GET");
@@ -394,8 +394,8 @@ TEST_CASE("InvokeHTTP DateHeader", "[InvokeHTTP]") {
   using minifi::processors::InvokeHTTP;
   TestHTTPServer http_server;
 
-  auto invoke_http = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invoke_http};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invoke_http = test_controller.getProcessor();
   LogTestController::getInstance().setTrace<InvokeHTTP>();
 
   invoke_http->setProperty(InvokeHTTP::Method, "GET");
@@ -424,8 +424,8 @@ TEST_CASE("InvokeHTTP Attributes to Send uses full string matching, not substrin
   using minifi::processors::InvokeHTTP;
   TestHTTPServer http_server;
 
-  auto invokehttp = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invokehttp};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invokehttp = test_controller.getProcessor();
   LogTestController::getInstance().setTrace<InvokeHTTP>();
 
   invokehttp->setProperty(InvokeHTTP::Method, "GET");
@@ -446,8 +446,8 @@ TEST_CASE("InvokeHTTP Attributes to Send uses full string matching, not substrin
 TEST_CASE("HTTPTestsResponseBodyinAttribute", "[InvokeHTTP]") {
   using minifi::processors::InvokeHTTP;
 
-  auto invoke_http = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invoke_http};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invoke_http = test_controller.getProcessor();
 
   minifi::test::ConnectionCountingServer connection_counting_server;
 
@@ -471,8 +471,8 @@ TEST_CASE("HTTPTestsResponseBodyinAttribute", "[InvokeHTTP]") {
 TEST_CASE("HTTPTestsResponseBody", "[InvokeHTTP]") {
   using minifi::processors::InvokeHTTP;
 
-  auto invoke_http = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invoke_http};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invoke_http = test_controller.getProcessor();
 
   minifi::test::ConnectionCountingServer connection_counting_server;
 
@@ -494,8 +494,8 @@ TEST_CASE("HTTPTestsResponseBody", "[InvokeHTTP]") {
 TEST_CASE("Test Keepalive", "[InvokeHTTP]") {
   using minifi::processors::InvokeHTTP;
 
-  auto invoke_http = std::make_shared<InvokeHTTP>("InvokeHTTP");
-  test::SingleProcessorTestController test_controller{invoke_http};
+  test::SingleProcessorTestController test_controller{std::make_unique<InvokeHTTP>("InvokeHTTP")};
+  auto invoke_http = test_controller.getProcessor();
 
   minifi::test::ConnectionCountingServer connection_counting_server;
 
diff --git a/extensions/standard-processors/tests/unit/AppendHostInfoTests.cpp b/extensions/standard-processors/tests/unit/AppendHostInfoTests.cpp
index b02f00c19..896aaf7b8 100644
--- a/extensions/standard-processors/tests/unit/AppendHostInfoTests.cpp
+++ b/extensions/standard-processors/tests/unit/AppendHostInfoTests.cpp
@@ -29,9 +29,9 @@ TEST_CASE("AppendHostInfoTest", "[appendhostinfotest]") {
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   LogTestController::getInstance().setTrace<minifi::processors::AppendHostInfo>();
   LogTestController::getInstance().setTrace<minifi::processors::LogAttribute>();
-  std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
-  std::shared_ptr<core::Processor> append_host_info = plan->addProcessor("AppendHostInfo", "append_host_info", core::Relationship("success", "description"), true);
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attributes", core::Relationship("success", "description"), true);
+  plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+  plan->addProcessor("AppendHostInfo", "append_host_info", core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "log_attributes", core::Relationship("success", "description"), true);
 
   testController.runSession(plan);
 
@@ -44,9 +44,9 @@ TEST_CASE("AppendHostInfoTestWithUnmatchableRegex", "[appendhostinfotestunmatcha
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   LogTestController::getInstance().setTrace<minifi::processors::AppendHostInfo>();
   LogTestController::getInstance().setTrace<minifi::processors::LogAttribute>();
-  std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
-  std::shared_ptr<core::Processor> append_host_info = plan->addProcessor("AppendHostInfo", "append_host_info", core::Relationship("success", "description"), true);
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attributes", core::Relationship("success", "description"), true);
+  plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+  auto append_host_info = plan->addProcessor("AppendHostInfo", "append_host_info", core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "log_attributes", core::Relationship("success", "description"), true);
 
   plan->setProperty(append_host_info, AppendHostInfo::InterfaceNameFilter, "\b");
 
@@ -62,9 +62,9 @@ TEST_CASE("AppendHostInfoTestCanFilterOutLoopbackInterfacesWithRegex", "[appendh
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   LogTestController::getInstance().setTrace<minifi::processors::AppendHostInfo>();
   LogTestController::getInstance().setTrace<minifi::processors::LogAttribute>();
-  std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
-  std::shared_ptr<core::Processor> append_host_info = plan->addProcessor("AppendHostInfo", "append_host_info", core::Relationship("success", "description"), true);
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attributes", core::Relationship("success", "description"), true);
+  plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+  auto append_host_info = plan->addProcessor("AppendHostInfo", "append_host_info", core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "log_attributes", core::Relationship("success", "description"), true);
 
   plan->setProperty(append_host_info, AppendHostInfo::InterfaceNameFilter, "(?!Loopback|lo).*?");  // set up the regex to accept everything except interfaces starting with Loopback or lo
 
diff --git a/extensions/standard-processors/tests/unit/AttributeRollingWindowTests.cpp b/extensions/standard-processors/tests/unit/AttributeRollingWindowTests.cpp
index a6c71a010..45c80d1f0 100644
--- a/extensions/standard-processors/tests/unit/AttributeRollingWindowTests.cpp
+++ b/extensions/standard-processors/tests/unit/AttributeRollingWindowTests.cpp
@@ -36,8 +36,8 @@ bool checkAttributes(const std::map<std::string, std::string>& expected, const s
 }
 
 TEST_CASE("AttributeRollingWindow properly forwards properties to RollingWindow and sets attributes", "[attributerollingwindow]") {
-  const auto proc = std::make_shared<AttributeRollingWindow>("AttributeRollingWindow");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<AttributeRollingWindow>("AttributeRollingWindow")};
+  const auto proc = controller.getProcessor();
   proc->setProperty(AttributeRollingWindow::ValueToTrack, "${value}");
   proc->setProperty(AttributeRollingWindow::WindowLength, "3");
   const auto trigger_with_value_and_check_attributes = [&controller](const std::string& value, const std::map<std::string, std::string>& expected_out_attributes) {
diff --git a/extensions/standard-processors/tests/unit/AttributesToJSONTests.cpp b/extensions/standard-processors/tests/unit/AttributesToJSONTests.cpp
index 630dcb169..49c1f270e 100644
--- a/extensions/standard-processors/tests/unit/AttributesToJSONTests.cpp
+++ b/extensions/standard-processors/tests/unit/AttributesToJSONTests.cpp
@@ -109,11 +109,11 @@ class AttributesToJSONTestFixture {
   TestController test_controller_;
   std::shared_ptr<TestPlan> plan_;
   std::filesystem::path dir_;
-  std::shared_ptr<core::Processor> getfile_;
-  std::shared_ptr<core::Processor> update_attribute_;
-  std::shared_ptr<core::Processor> attribute_to_json_;
-  std::shared_ptr<core::Processor> logattribute_;
-  std::shared_ptr<core::Processor> putfile_;
+  core::Processor* getfile_ = nullptr;
+  core::Processor* update_attribute_ = nullptr;
+  core::Processor* attribute_to_json_ = nullptr;
+  core::Processor* logattribute_ = nullptr;
+  core::Processor* putfile_ = nullptr;
 };
 
 TEST_CASE_METHOD(AttributesToJSONTestFixture, "Move all attributes to a flowfile attribute", "[AttributesToJSONTests]") {
diff --git a/extensions/standard-processors/tests/unit/DefragmentTextTests.cpp b/extensions/standard-processors/tests/unit/DefragmentTextTests.cpp
index 120ed1110..86164f483 100644
--- a/extensions/standard-processors/tests/unit/DefragmentTextTests.cpp
+++ b/extensions/standard-processors/tests/unit/DefragmentTextTests.cpp
@@ -37,10 +37,10 @@ namespace defragment_text = org::apache::nifi::minifi::processors::defragment_te
 TEST_CASE("DefragmentText Single source tests", "[defragmenttextsinglesource]") {
   TestController testController;
   auto plan = testController.createPlan();
-  auto write_to_flow_file = std::dynamic_pointer_cast<WriteToFlowFileTestProcessor>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
-  auto defrag_text_flow_files = std::dynamic_pointer_cast<DefragmentText>(plan->addProcessor("DefragmentText", "defrag_text_flow_files"));
-  auto read_from_success_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
-  auto read_from_failure_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
+  auto write_to_flow_file = dynamic_cast<WriteToFlowFileTestProcessor*>(plan->addProcessor("WriteToFlowFileTestProcessor", "write_to_flow_file"));
+  auto defrag_text_flow_files = dynamic_cast<DefragmentText*>(plan->addProcessor("DefragmentText", "defrag_text_flow_files"));
+  auto read_from_success_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
+  auto read_from_failure_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
 
   plan->addConnection(write_to_flow_file, WriteToFlowFileTestProcessor::Success, defrag_text_flow_files);
 
@@ -222,13 +222,13 @@ TEST_CASE("DefragmentText Single source tests", "[defragmenttextsinglesource]")
 TEST_CASE("DefragmentTextMultipleSources", "[defragmenttextinvalidsources]") {
   TestController testController;
   auto plan = testController.createPlan();
-  auto input_1 = std::dynamic_pointer_cast<WriteToFlowFileTestProcessor>(plan->addProcessor("WriteToFlowFileTestProcessor", "input_1"));
-  auto input_2 = std::dynamic_pointer_cast<WriteToFlowFileTestProcessor>(plan->addProcessor("WriteToFlowFileTestProcessor", "input_2"));
-  auto update_ff_1 = std::dynamic_pointer_cast<UpdateAttribute>(plan->addProcessor("UpdateAttribute", "update_attribute_1"));
-  auto update_ff_2 = std::dynamic_pointer_cast<UpdateAttribute>(plan->addProcessor("UpdateAttribute", "update_attribute_2"));
-  auto defrag_text_flow_files = std::dynamic_pointer_cast<DefragmentText>(plan->addProcessor("DefragmentText", "defrag_text_flow_files"));
-  auto read_from_failure_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
-  auto read_from_success_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
+  auto input_1 = dynamic_cast<WriteToFlowFileTestProcessor*>(plan->addProcessor("WriteToFlowFileTestProcessor", "input_1"));
+  auto input_2 = dynamic_cast<WriteToFlowFileTestProcessor*>(plan->addProcessor("WriteToFlowFileTestProcessor", "input_2"));
+  auto update_ff_1 = dynamic_cast<UpdateAttribute*>(plan->addProcessor("UpdateAttribute", "update_attribute_1"));
+  auto update_ff_2 = dynamic_cast<UpdateAttribute*>(plan->addProcessor("UpdateAttribute", "update_attribute_2"));
+  auto defrag_text_flow_files = dynamic_cast<DefragmentText*>(plan->addProcessor("DefragmentText", "defrag_text_flow_files"));
+  auto read_from_failure_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
+  auto read_from_success_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
 
   plan->addConnection(input_1, WriteToFlowFileTestProcessor::Success, update_ff_1);
   plan->addConnection(input_2, WriteToFlowFileTestProcessor::Success, update_ff_2);
@@ -370,12 +370,12 @@ REGISTER_RESOURCE(FragmentGenerator, Processor);
 TEST_CASE("DefragmentText with offset attributes", "[defragmenttextoffsetattributes]") {
   TestController testController;
   auto plan = testController.createPlan();
-  auto input_1 = std::dynamic_pointer_cast<FragmentGenerator>(plan->addProcessor("FragmentGenerator", "input_1"));
-  auto input_2 = std::dynamic_pointer_cast<FragmentGenerator>(plan->addProcessor("FragmentGenerator", "input_2"));
+  auto input_1 = dynamic_cast<FragmentGenerator*>(plan->addProcessor("FragmentGenerator", "input_1"));
+  auto input_2 = dynamic_cast<FragmentGenerator*>(plan->addProcessor("FragmentGenerator", "input_2"));
 
-  auto defrag_text_flow_files = std::dynamic_pointer_cast<DefragmentText>(plan->addProcessor("DefragmentText", "defrag_text_flow_files"));
-  auto read_from_failure_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
-  auto read_from_success_relationship = std::dynamic_pointer_cast<ReadFromFlowFileTestProcessor>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
+  auto defrag_text_flow_files = dynamic_cast<DefragmentText*>(plan->addProcessor("DefragmentText", "defrag_text_flow_files"));
+  auto read_from_failure_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_failure_relationship"));
+  auto read_from_success_relationship = dynamic_cast<ReadFromFlowFileTestProcessor*>(plan->addProcessor("ReadFromFlowFileTestProcessor", "read_from_success_relationship"));
 
   plan->addConnection(input_1, FragmentGenerator::Success, defrag_text_flow_files);
   plan->addConnection(input_2, FragmentGenerator::Success, defrag_text_flow_files);
diff --git a/extensions/standard-processors/tests/unit/ExtractTextTests.cpp b/extensions/standard-processors/tests/unit/ExtractTextTests.cpp
index c99a10f87..98d55fa1e 100644
--- a/extensions/standard-processors/tests/unit/ExtractTextTests.cpp
+++ b/extensions/standard-processors/tests/unit/ExtractTextTests.cpp
@@ -47,7 +47,7 @@ const char* TEST_ATTR = "ExtractedText";
 
 TEST_CASE("Test creation of ExtractText", "[extracttextCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::ExtractText>("processorname");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::ExtractText>("processorname");
   REQUIRE(processor->getName() == "processorname");
   utils::Identifier processoruuid = processor->getUUID();
   REQUIRE(processoruuid);
@@ -69,14 +69,14 @@ TEST_CASE("Test usage of ExtractText", "[extracttextTest]") {
 
   auto temp_dir = testController.createTempDirectory();
   REQUIRE(!temp_dir.empty());
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::Directory, temp_dir.string());
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> maprocessor = plan->addProcessor("ExtractText", "testExtractText", core::Relationship("success", "description"), true);
+  auto maprocessor = plan->addProcessor("ExtractText", "testExtractText", core::Relationship("success", "description"), true);
   plan->setProperty(maprocessor, org::apache::nifi::minifi::processors::ExtractText::Attribute, TEST_ATTR);
 
-  std::shared_ptr<core::Processor> laprocessor = plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
 
   auto test_file_path = temp_dir / TEST_FILE;
 
@@ -134,17 +134,17 @@ TEST_CASE("Test usage of ExtractText in regex mode", "[extracttextRegexTest]") {
 
   auto dir = testController.createTempDirectory();
   REQUIRE(!dir.empty());
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::Directory, dir.string());
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> maprocessor = plan->addProcessor("ExtractText", "testExtractText", core::Relationship("success", "description"), true);
+  auto maprocessor = plan->addProcessor("ExtractText", "testExtractText", core::Relationship("success", "description"), true);
   plan->setProperty(maprocessor, org::apache::nifi::minifi::processors::ExtractText::RegexMode, "true");
   plan->setProperty(maprocessor, org::apache::nifi::minifi::processors::ExtractText::EnableRepeatingCaptureGroup, "true");
   plan->setDynamicProperty(maprocessor, "RegexAttr", "Speed limit ([0-9]+)");
   plan->setDynamicProperty(maprocessor, "InvalidRegex", "[Invalid)A(F)");
 
-  std::shared_ptr<core::Processor> laprocessor = plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
 
   auto test_file_path = dir / TEST_FILE;
 
@@ -211,7 +211,7 @@ TEST_CASE("Test usage of ExtractText in regex mode with large regex matches", "[
   plan->setProperty(extract_text_processor, org::apache::nifi::minifi::processors::ExtractText::IncludeCaptureGroupZero, "false");
   plan->setDynamicProperty(extract_text_processor, "RegexAttr", "Speed limit (.*)");
 
-  auto log_attribute_processor = plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
 
   std::string additional_long_string(100'000, '.');
   minifi::test::utils::putFileToDir(dir, TEST_FILE, "Speed limit 80" + additional_long_string);
diff --git a/extensions/standard-processors/tests/unit/FetchFileTests.cpp b/extensions/standard-processors/tests/unit/FetchFileTests.cpp
index ff424c879..52253758e 100644
--- a/extensions/standard-processors/tests/unit/FetchFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/FetchFileTests.cpp
@@ -45,8 +45,8 @@ class FetchFileTestFixture {
  protected:
   [[nodiscard]] std::unordered_multiset<std::string> getDirContents(const std::filesystem::path& dir_path) const;
 
-  std::shared_ptr<minifi::processors::FetchFile> fetch_file_processor_;
   std::shared_ptr<minifi::test::SingleProcessorTestController> test_controller_;
+  minifi::processors::FetchFile* fetch_file_processor_ = nullptr;
   const std::filesystem::path input_dir_;
   const std::filesystem::path permission_denied_file_name_;
   const std::filesystem::path input_file_name_;
@@ -55,8 +55,8 @@ class FetchFileTestFixture {
 };
 
 FetchFileTestFixture::FetchFileTestFixture()
-  : fetch_file_processor_(std::make_shared<minifi::processors::FetchFile>("FetchFile")),
-    test_controller_(std::make_shared<minifi::test::SingleProcessorTestController>(fetch_file_processor_)),
+  : test_controller_(std::make_shared<minifi::test::SingleProcessorTestController>(std::make_unique<minifi::processors::FetchFile>("FetchFile"))),
+    fetch_file_processor_(test_controller_->getProcessor<minifi::processors::FetchFile>()),
     input_dir_(test_controller_->createTempDirectory()),
     permission_denied_file_name_("permission_denied.txt"),
     input_file_name_("test.txt"),
diff --git a/extensions/standard-processors/tests/unit/FlowJsonTests.cpp b/extensions/standard-processors/tests/unit/FlowJsonTests.cpp
index 5cf07b868..4eb54198a 100644
--- a/extensions/standard-processors/tests/unit/FlowJsonTests.cpp
+++ b/extensions/standard-processors/tests/unit/FlowJsonTests.cpp
@@ -828,7 +828,7 @@ TEST_CASE("Test sensitive parameters in sensitive properties") {
           "name": "my_value",
           "description": "",
           "sensitive": true,
-          "value": "{}"
+          "value": "{encrypted_parameter_value}"
         }}
       ]
     }}
@@ -842,12 +842,12 @@ TEST_CASE("Test sensitive parameters in sensitive properties") {
       "schedulingStrategy": "TIMER_DRIVEN",
       "schedulingPeriod": "3 sec",
       "properties": {{
-        "Sensitive Property": "{}"
+        "Sensitive Property": "{encrypted_sensitive_property_value}"
       }}
     }}],
     "parameterContextName": "my-context"
   }}
-}})", encrypted_parameter_value, encrypted_sensitive_property_value);
+}})", fmt::arg("encrypted_parameter_value", encrypted_parameter_value), fmt::arg("encrypted_sensitive_property_value", encrypted_sensitive_property_value));
 
   std::unique_ptr<core::ProcessGroup> flow = config.getRootFromPayload(CONFIG_JSON);
   REQUIRE(flow);
@@ -879,13 +879,13 @@ TEST_CASE("Test sensitive parameters in sensitive property value sequence") {
           "name": "first_value",
           "description": "",
           "sensitive": true,
-          "value": "{}"
+          "value": "{encrypted_parameter_value_1}"
         }},
         {{
           "name": "second_value",
           "description": "",
           "sensitive": true,
-          "value": "{}"
+          "value": "{encrypted_parameter_value_2}"
         }}
       ]
     }}
@@ -900,14 +900,15 @@ TEST_CASE("Test sensitive parameters in sensitive property value sequence") {
       "schedulingPeriod": "3 sec",
       "properties": {{
         "Sensitive Property": [
-          {{"value": "{}"}},
-          {{"value": "{}"}}
+          {{"value": "{encrypted_sensitive_property_value_1}"}},
+          {{"value": "{encrypted_sensitive_property_value_2}"}}
         ]
       }}
     }}],
     "parameterContextName": "my-context"
   }}
-}})", encrypted_parameter_value_1, encrypted_parameter_value_2, encrypted_sensitive_property_value_1, encrypted_sensitive_property_value_2);
+}})", fmt::arg("encrypted_parameter_value_1", encrypted_parameter_value_1), fmt::arg("encrypted_parameter_value_2", encrypted_parameter_value_2),
+  fmt::arg("encrypted_sensitive_property_value_1", encrypted_sensitive_property_value_1), fmt::arg("encrypted_sensitive_property_value_2", encrypted_sensitive_property_value_2));
 
   std::unique_ptr<core::ProcessGroup> flow = config.getRootFromPayload(CONFIG_JSON);
   REQUIRE(flow);
@@ -1028,4 +1029,124 @@ TEST_CASE("NiFi flow json can use alternative targetUris field") {
   REQUIRE(port->getProperty("Port UUID") == "00000000-0000-0000-0000-000000000005");
 }
 
+
+TEST_CASE("Test parameters in controller services") {
+  ConfigurationTestController test_controller;
+  auto context = test_controller.getContext();
+  auto encrypted_parameter_value = minifi::utils::crypto::property_encryption::encrypt("secret1!!1!", *context.sensitive_values_encryptor);
+  auto encrypted_sensitive_property_value = minifi::utils::crypto::property_encryption::encrypt("#{my_value_1}", *context.sensitive_values_encryptor);
+  core::flow::AdaptiveConfiguration json_config(context);
+
+  static const std::string CONFIG_JSON =
+      fmt::format(R"(
+{{
+  "parameterContexts": [
+    {{
+      "identifier": "721e10b7-8e00-3188-9a27-476cca376978",
+      "name": "my-context",
+      "description": "my parameter context",
+      "parameters": [
+        {{
+          "name": "my_value_1",
+          "description": "",
+          "sensitive": true,
+          "value": "{encrypted_parameter_value}"
+        }},
+        {{
+          "name": "my_value_2",
+          "description": "",
+          "sensitive": false,
+          "value": "/opt/secrets/private-key.pem"
+        }}
+      ]
+    }}
+  ],
+  "rootGroup": {{
+    "name": "MiNiFi Flow",
+    "processors": [],
+    "controllerServices": [{{
+      "identifier": "a00f8722-2419-44ee-929c-ad68644ad557",
+      "name": "SSLContextService",
+      "type": "org.apache.nifi.minifi.controllers.SSLContextService",
+      "properties": {{
+        "Passphrase": "{encrypted_sensitive_property_value}",
+        "Private Key": "#{{my_value_2}}",
+        "Use System Cert Store": "true"
+      }}
+    }}],
+    "parameterContextName": "my-context"
+  }}
+}})", fmt::arg("encrypted_parameter_value", encrypted_parameter_value), fmt::arg("encrypted_sensitive_property_value", encrypted_sensitive_property_value));
+
+  std::unique_ptr<core::ProcessGroup> flow = json_config.getRootFromPayload(CONFIG_JSON);
+  REQUIRE(flow);
+  auto* controller = flow->findControllerService("SSLContextService");
+  REQUIRE(controller);
+  auto impl = controller->getControllerServiceImplementation();
+  CHECK(impl->getProperty("Passphrase").value() == "secret1!!1!");
+  CHECK(impl->getProperty("Private Key").value() == "/opt/secrets/private-key.pem");
+}
+
+TEST_CASE("Parameters can be used in controller services in nested process groups") {
+  ConfigurationTestController test_controller;
+  auto context = test_controller.getContext();
+  auto encrypted_parameter_value = minifi::utils::crypto::property_encryption::encrypt("secret1!!1!", *context.sensitive_values_encryptor);
+  auto encrypted_sensitive_property_value = minifi::utils::crypto::property_encryption::encrypt("#{my_value_1}", *context.sensitive_values_encryptor);
+  core::flow::AdaptiveConfiguration json_config(context);
+
+  static const std::string CONFIG_JSON =
+      fmt::format(R"(
+{{
+  "parameterContexts": [
+    {{
+      "identifier": "721e10b7-8e00-3188-9a27-476cca376978",
+      "name": "my-context",
+      "description": "my parameter context",
+      "parameters": [
+        {{
+          "name": "my_value_1",
+          "description": "",
+          "sensitive": true,
+          "value": "{encrypted_parameter_value}"
+        }},
+        {{
+          "name": "my_value_2",
+          "description": "",
+          "sensitive": false,
+          "value": "/opt/secrets/private-key.pem"
+        }}
+      ]
+    }}
+  ],
+  "rootGroup": {{
+    "name": "MiNiFi Flow",
+    "processors": [],
+    "processGroups": [{{
+      "name": "MiNiFi SubFlow",
+      "processors": [],
+      "controllerServices": [{{
+        "identifier": "a00f8722-2419-44ee-929c-ad68644ad557",
+        "name": "SSLContextService",
+        "type": "org.apache.nifi.minifi.controllers.SSLContextService",
+        "properties": {{
+          "Passphrase": "{encrypted_sensitive_property_value}",
+          "Private Key": "#{{my_value_2}}",
+          "Use System Cert Store": "true"
+        }}
+      }}],
+      "parameterContextName": "my-context"
+    }}]
+  }}
+}})", fmt::arg("encrypted_parameter_value", encrypted_parameter_value), fmt::arg("encrypted_sensitive_property_value", encrypted_sensitive_property_value));
+
+  std::unique_ptr<core::ProcessGroup> flow = json_config.getRootFromPayload(CONFIG_JSON);
+  REQUIRE(flow);
+  auto* controller = flow->findControllerService("SSLContextService", core::ProcessGroup::Traverse::IncludeChildren);
+  REQUIRE(controller);
+  auto impl = controller->getControllerServiceImplementation();
+  REQUIRE(impl);
+  CHECK(impl->getProperty("Passphrase").value() == "secret1!!1!");
+  CHECK(impl->getProperty("Private Key").value() == "/opt/secrets/private-key.pem");
+}
+
 }  // namespace org::apache::nifi::minifi::test
diff --git a/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp b/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp
index 65978048c..7a09e9c36 100644
--- a/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/GenerateFlowFileTests.cpp
@@ -37,8 +37,9 @@ TEST_CASE("GenerateFlowFileWithBinaryData") {
     is_unique = true;
   }
 
-  std::shared_ptr<GenerateFlowFile> generate_flow_file = std::make_shared<GenerateFlowFile>("GenerateFlowFile");
-  minifi::test::SingleProcessorTestController test_controller{generate_flow_file};
+
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<GenerateFlowFile>("GenerateFlowFile")};
+  auto generate_flow_file = test_controller.getProcessor();
   LogTestController::getInstance().setWarn<GenerateFlowFile>();
 
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::FileSize, "10");
@@ -66,8 +67,8 @@ TEST_CASE("GenerateFlowFileWithBinaryData") {
 }
 
 TEST_CASE("GenerateFlowFileTestEmpty") {
-  std::shared_ptr<GenerateFlowFile> generate_flow_file = std::make_shared<GenerateFlowFile>("GenerateFlowFile");
-  minifi::test::SingleProcessorTestController test_controller{generate_flow_file};
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<GenerateFlowFile>("GenerateFlowFile")};
+  auto generate_flow_file = test_controller.getProcessor();
 
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::FileSize, "0");
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::UniqueFlowFiles, "false");
@@ -80,8 +81,8 @@ TEST_CASE("GenerateFlowFileTestEmpty") {
 }
 
 TEST_CASE("GenerateFlowFileCustomTextTest") {
-  std::shared_ptr<GenerateFlowFile> generate_flow_file = std::make_shared<GenerateFlowFile>("GenerateFlowFile");
-  minifi::test::SingleProcessorTestController test_controller{generate_flow_file};
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<GenerateFlowFile>("GenerateFlowFile")};
+  auto generate_flow_file = test_controller.getProcessor();
 
   constexpr auto uuid_string_length = 36;
 
@@ -96,8 +97,8 @@ TEST_CASE("GenerateFlowFileCustomTextTest") {
 }
 
 TEST_CASE("GenerateFlowFileCustomTextEmptyTest") {
-  std::shared_ptr<GenerateFlowFile> generate_flow_file = std::make_shared<GenerateFlowFile>("GenerateFlowFile");
-  minifi::test::SingleProcessorTestController test_controller{generate_flow_file};
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<GenerateFlowFile>("GenerateFlowFile")};
+  auto generate_flow_file = test_controller.getProcessor();
 
   constexpr int32_t file_size = 10;
 
@@ -118,8 +119,8 @@ TEST_CASE("GenerateFlowFileCustomTextEmptyTest") {
 }
 
 TEST_CASE("GenerateFlowFile reevaluating CustomText") {
-  std::shared_ptr<GenerateFlowFile> generate_flow_file = std::make_shared<GenerateFlowFile>("GenerateFlowFile");
-  minifi::test::SingleProcessorTestController test_controller{generate_flow_file};
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<GenerateFlowFile>("GenerateFlowFile")};
+  auto generate_flow_file = test_controller.getProcessor();
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::DataFormat, "Text");
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::UniqueFlowFiles, "false");
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::CustomText, "${nextInt()}");
@@ -135,8 +136,8 @@ TEST_CASE("GenerateFlowFile reevaluating CustomText") {
 }
 
 TEST_CASE("GenerateFlowFile CustomText evaluates to empty string") {
-  std::shared_ptr<GenerateFlowFile> generate_flow_file = std::make_shared<GenerateFlowFile>("GenerateFlowFile");
-  minifi::test::SingleProcessorTestController test_controller{generate_flow_file};
+  minifi::test::SingleProcessorTestController test_controller{std::make_unique<GenerateFlowFile>("GenerateFlowFile")};
+  auto generate_flow_file = test_controller.getProcessor();
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::DataFormat, "Text");
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::UniqueFlowFiles, "false");
   test_controller.plan->setProperty(generate_flow_file, GenerateFlowFile::CustomText, "${invalid_variable}");
diff --git a/extensions/standard-processors/tests/unit/GetFileTests.cpp b/extensions/standard-processors/tests/unit/GetFileTests.cpp
index 90c9fdf23..7ae79bee6 100644
--- a/extensions/standard-processors/tests/unit/GetFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/GetFileTests.cpp
@@ -52,7 +52,7 @@ class GetFileTestController {
   std::filesystem::path input_file_name_;
   std::filesystem::path large_input_file_name_;
   std::filesystem::path hidden_input_file_name_;
-  std::shared_ptr<core::Processor> get_file_processor_;
+  core::Processor* get_file_processor_ = nullptr;
 };
 
 GetFileTestController::GetFileTestController()
@@ -270,9 +270,9 @@ TEST_CASE("Test if GetFile honors PollInterval property when triggered multiple
 TEST_CASE("GetFile sets attributes correctly") {
   using minifi::processors::GetFile;
 
-  const auto get_file = std::make_shared<GetFile>("GetFile");
   LogTestController::getInstance().setTrace<GetFile>();
-  minifi::test::SingleProcessorTestController test_controller(get_file);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<GetFile>("GetFile"));
+  const auto get_file = test_controller.getProcessor();
   std::filesystem::path dir = test_controller.createTempDirectory();
   get_file->setProperty(GetFile::Directory, dir.string());
   SECTION("File in subdirectory of input directory") {
@@ -303,8 +303,8 @@ TEST_CASE("GetFile can use expression language in Directory property") {
   using minifi::processors::GetFile;
   LogTestController::getInstance().setTrace<GetFile>();
 
-  const auto get_file = std::make_shared<GetFile>("GetFile");
-  minifi::test::SingleProcessorTestController test_controller(get_file);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<GetFile>("GetFile"));
+  const auto get_file = test_controller.getProcessor();
 
   std::filesystem::path base_dir = test_controller.createTempDirectory();
   auto date_str = date::format("%Y-%m-%d", std::chrono::system_clock::now());
diff --git a/extensions/standard-processors/tests/unit/GetTCPTests.cpp b/extensions/standard-processors/tests/unit/GetTCPTests.cpp
index 067492755..9fb79d70d 100644
--- a/extensions/standard-processors/tests/unit/GetTCPTests.cpp
+++ b/extensions/standard-processors/tests/unit/GetTCPTests.cpp
@@ -152,8 +152,8 @@ class TcpTestServer {
 };
 
 TEST_CASE("GetTCP test with delimiter", "[GetTCP]") {
-  const auto get_tcp = std::make_shared<GetTCP>("GetTCP");
-  SingleProcessorTestController controller{get_tcp};
+  SingleProcessorTestController controller{std::make_unique<GetTCP>("GetTCP")};
+  const auto get_tcp = controller.getProcessor();
   LogTestController::getInstance().setTrace<GetTCP>();
   REQUIRE(get_tcp->setProperty(GetTCP::MaxBatchSize, "2"));
 
@@ -183,8 +183,8 @@ TEST_CASE("GetTCP test with delimiter", "[GetTCP]") {
 }
 
 TEST_CASE("GetTCP test with too large message", "[GetTCP]") {
-  const auto get_tcp = std::make_shared<GetTCP>("GetTCP");
-  SingleProcessorTestController controller{get_tcp};
+  SingleProcessorTestController controller{std::make_unique<GetTCP>("GetTCP")};
+  const auto get_tcp = controller.getProcessor();
   LogTestController::getInstance().setTrace<GetTCP>();
   REQUIRE(get_tcp->setProperty(GetTCP::MaxBatchSize, "2"));
   REQUIRE(get_tcp->setProperty(GetTCP::MaxMessageSize, "10"));
@@ -224,8 +224,8 @@ TEST_CASE("GetTCP test with too large message", "[GetTCP]") {
 }
 
 TEST_CASE("GetTCP test multiple endpoints", "[GetTCP]") {
-  const auto get_tcp = std::make_shared<GetTCP>("GetTCP");
-  SingleProcessorTestController controller{get_tcp};
+  SingleProcessorTestController controller{std::make_unique<GetTCP>("GetTCP")};
+  const auto get_tcp = controller.getProcessor();
   LogTestController::getInstance().setTrace<GetTCP>();
   REQUIRE(get_tcp->setProperty(GetTCP::MaxBatchSize, "2"));
 
@@ -268,8 +268,8 @@ TEST_CASE("GetTCP test multiple endpoints", "[GetTCP]") {
 }
 
 TEST_CASE("GetTCP max queue and max batch size test", "[GetTCP]") {
-  const auto get_tcp = std::make_shared<GetTCP>("GetTCP");
-  SingleProcessorTestController controller{get_tcp};
+  SingleProcessorTestController controller{std::make_unique<GetTCP>("GetTCP")};
+  const auto get_tcp = controller.getProcessor();
   LogTestController::getInstance().setTrace<GetTCP>();
   REQUIRE(get_tcp->setProperty(GetTCP::MaxBatchSize, "10"));
   REQUIRE(get_tcp->setProperty(GetTCP::MaxQueueSize, "50"));
diff --git a/extensions/standard-processors/tests/unit/HashContentTest.cpp b/extensions/standard-processors/tests/unit/HashContentTest.cpp
index fd26d038c..56f6aeaba 100644
--- a/extensions/standard-processors/tests/unit/HashContentTest.cpp
+++ b/extensions/standard-processors/tests/unit/HashContentTest.cpp
@@ -50,7 +50,7 @@ namespace org::apache::nifi::minifi::processors::test {
 
 TEST_CASE("Test Creation of HashContent", "[HashContentCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::HashContent>("processorname");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::HashContent>("processorname");
   REQUIRE(processor->getName() == "processorname");
   REQUIRE(processor->getUUID());
 }
@@ -68,27 +68,26 @@ TEST_CASE("Test usage of ExtractText", "[extracttextTest]") {
   auto tempdir = testController.createTempDirectory();
   REQUIRE(!tempdir.empty());
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::Directory, tempdir.string());
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> md5processor = plan->addProcessor("HashContent", "HashContentMD5",
+  auto md5processor = plan->addProcessor("HashContent", "HashContentMD5",
       core::Relationship("success", "description"), true);
   plan->setProperty(md5processor, org::apache::nifi::minifi::processors::HashContent::HashAttribute, MD5_ATTR);
   plan->setProperty(md5processor, org::apache::nifi::minifi::processors::HashContent::HashAlgorithm, "MD5");
 
-  std::shared_ptr<core::Processor> shaprocessor = plan->addProcessor("HashContent", "HashContentSHA1",
+  auto shaprocessor = plan->addProcessor("HashContent", "HashContentSHA1",
       core::Relationship("success", "description"), true);
   plan->setProperty(shaprocessor, org::apache::nifi::minifi::processors::HashContent::HashAttribute, SHA1_ATTR);
   plan->setProperty(shaprocessor, org::apache::nifi::minifi::processors::HashContent::HashAlgorithm, "sha1");
 
-  std::shared_ptr<core::Processor> sha2processor = plan->addProcessor("HashContent", "HashContentSHA256",
+  auto sha2processor = plan->addProcessor("HashContent", "HashContentSHA256",
       core::Relationship("success", "description"), true);
   plan->setProperty(sha2processor, org::apache::nifi::minifi::processors::HashContent::HashAttribute, SHA256_ATTR);
   plan->setProperty(sha2processor, org::apache::nifi::minifi::processors::HashContent::HashAlgorithm, "sha-256");
 
-  std::shared_ptr<core::Processor> laprocessor = plan->addProcessor("LogAttribute", "outputLogAttribute",
-      core::Relationship("success", "description"), true);
+  plan->addProcessor("LogAttribute", "outputLogAttribute", core::Relationship("success", "description"), true);
 
   auto test_file_path = tempdir / TEST_FILE;
 
@@ -135,11 +134,11 @@ TEST_CASE("TestingFailOnEmptyProperty", "[HashContentPropertiesCheck]") {
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
   auto tempdir = testController.createTempDirectory();
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::Directory, tempdir.string());
   plan->setProperty(getfile, org::apache::nifi::minifi::processors::GetFile::KeepSourceFile, "true");
 
-  std::shared_ptr<core::Processor> md5processor = plan->addProcessor("HashContent", "HashContentMD5",
+  auto md5processor = plan->addProcessor("HashContent", "HashContentMD5",
                                                                      core::Relationship("success", "description"), true);
   plan->setProperty(md5processor, HashContent::HashAttribute, MD5_ATTR);
   plan->setProperty(md5processor, HashContent::HashAlgorithm, "MD5");
@@ -168,8 +167,8 @@ TEST_CASE("TestingFailOnEmptyProperty", "[HashContentPropertiesCheck]") {
 }
 
 TEST_CASE("Invalid hash algorithm throws in onSchedule", "[HashContent]") {
-  auto hash_content = std::make_shared<HashContent>("HashContent");
-  minifi::test::SingleProcessorTestController controller{hash_content};
+  minifi::test::SingleProcessorTestController controller{std::make_unique<HashContent>("HashContent")};
+  auto hash_content = controller.getProcessor();
   hash_content->setProperty(HashContent::HashAlgorithm, "My-Algo");
   REQUIRE_THROWS_WITH(controller.plan->scheduleProcessor(hash_content), "Process Schedule Operation: MYALGO is not supported, supported algorithms are: MD5, SHA1, SHA256");
 }
diff --git a/extensions/standard-processors/tests/unit/JoltTransformJSONTests.cpp b/extensions/standard-processors/tests/unit/JoltTransformJSONTests.cpp
index 84305f577..e64477b64 100644
--- a/extensions/standard-processors/tests/unit/JoltTransformJSONTests.cpp
+++ b/extensions/standard-processors/tests/unit/JoltTransformJSONTests.cpp
@@ -28,8 +28,8 @@ namespace org::apache::nifi::minifi::test {
 // NOLINTBEGIN(readability-container-size-empty)
 
 TEST_CASE("Shiftr successful case") {
-  auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+  auto proc = controller.getProcessor();
   proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
   proc->setProperty(processors::JoltTransformJSON::JoltSpecification, R"json(
     {
@@ -76,8 +76,8 @@ TEST_CASE("Shiftr successful case") {
 }
 
 TEST_CASE("Shiftr multiple destination") {
-  auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+  auto proc = controller.getProcessor();
   proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
   proc->setProperty(processors::JoltTransformJSON::JoltSpecification, R"json(
     {
@@ -128,8 +128,8 @@ TEST_CASE("Shiftr invalid reference") {
 }
 
 TEST_CASE("Shiftr matches are correctly ordered") {
-  auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+  auto proc = controller.getProcessor();
   proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
   proc->setProperty(processors::JoltTransformJSON::JoltSpecification, R"json(
     {
@@ -172,8 +172,8 @@ TEST_CASE("Shiftr matches are correctly ordered") {
 }
 
 TEST_CASE("Shiftr arrays are maps with numeric keys") {
-  auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+  auto proc = controller.getProcessor();
   proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
   proc->setProperty(processors::JoltTransformJSON::JoltSpecification, R"json(
     {
@@ -204,8 +204,8 @@ TEST_CASE("Shiftr arrays are maps with numeric keys") {
 }
 
 TEST_CASE("Shiftr put into array at index") {
-  auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+  auto proc = controller.getProcessor();
   proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
   proc->setProperty(processors::JoltTransformJSON::JoltSpecification, R"json(
     {
@@ -238,8 +238,8 @@ TEST_CASE("Shiftr put into array at index") {
 
 TEST_CASE("Shiftr multiple patterns") {
   // this is an extension, so we can escape and match on a '|' character
-  auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-  SingleProcessorTestController controller{proc};
+  SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+  auto proc = controller.getProcessor();
   proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
   proc->setProperty(processors::JoltTransformJSON::JoltSpecification, R"json(
     {
@@ -305,8 +305,8 @@ TEST_CASE("Run tests from https://github.com/bazaarvoice/jolt") {
       throw std::logic_error(fmt::format("Error in test json '{}' at {}:{} : {}", entry.string(), cursor.first, cursor.second, rapidjson::GetParseError_En(parse_res.Code())));
     }
 
-    auto proc = std::make_shared<minifi::processors::JoltTransformJSON>("JoltProc");
-    SingleProcessorTestController controller{proc};
+    SingleProcessorTestController controller{std::make_unique<minifi::processors::JoltTransformJSON>("JoltProc")};
+    auto proc = controller.getProcessor();
     LogTestController::getInstance().setTrace<minifi::processors::JoltTransformJSON>();
     proc->setProperty(processors::JoltTransformJSON::JoltTransform, magic_enum::enum_name(processors::jolt_transform_json::JoltTransform::Shift));
     proc->setProperty(processors::JoltTransformJSON::JoltSpecification, to_string(doc["spec"]));
diff --git a/extensions/standard-processors/tests/unit/ListFileTests.cpp b/extensions/standard-processors/tests/unit/ListFileTests.cpp
index 845a4d5d7..2a32026d6 100644
--- a/extensions/standard-processors/tests/unit/ListFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/ListFileTests.cpp
@@ -52,7 +52,7 @@ class ListFileTestFixture {
   TestController test_controller_;
   std::shared_ptr<TestPlan> plan_;
   const std::filesystem::path input_dir_;
-  std::shared_ptr<core::Processor> list_file_processor_;
+  core::Processor* list_file_processor_;
   std::filesystem::path hidden_file_path_;
   std::filesystem::path empty_file_abs_path_;
   std::filesystem::path standard_file_abs_path_;
@@ -227,9 +227,9 @@ TEST_CASE_METHOD(ListFileTestFixture, "Test listing hidden files", "[testListFil
 TEST_CASE("ListFile sets attributes correctly") {
   using minifi::processors::ListFile;
 
-  const auto list_file = std::make_shared<ListFile>("ListFile");
   LogTestController::getInstance().setTrace<ListFile>();
-  minifi::test::SingleProcessorTestController test_controller(list_file);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<ListFile>("ListFile"));
+  const auto list_file = test_controller.getProcessor();
   std::filesystem::path dir = test_controller.createTempDirectory();
   list_file->setProperty(ListFile::InputDirectory, dir.string());
   SECTION("File in subdirectory of input directory") {
@@ -256,8 +256,8 @@ TEST_CASE("ListFile sets attributes correctly") {
 TEST_CASE("If a second file with the same modification time shows up later, then it will get listed") {
   using minifi::processors::ListFile;
 
-  const auto list_file = std::make_shared<ListFile>("ListFile");
-  minifi::test::SingleProcessorTestController test_controller(list_file);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<ListFile>("ListFile"));
+  const auto list_file = test_controller.getProcessor();
 
   const auto input_dir = test_controller.createTempDirectory();
   list_file->setProperty(ListFile::InputDirectory, input_dir.string());
diff --git a/extensions/standard-processors/tests/unit/ListenSyslogTests.cpp b/extensions/standard-processors/tests/unit/ListenSyslogTests.cpp
index 5314a87e9..545e22d95 100644
--- a/extensions/standard-processors/tests/unit/ListenSyslogTests.cpp
+++ b/extensions/standard-processors/tests/unit/ListenSyslogTests.cpp
@@ -249,9 +249,8 @@ void check_parsed_attributes(const core::FlowFile& flow_file, const ValidRFC3164
 }
 
 TEST_CASE("ListenSyslog without parsing test", "[ListenSyslog]") {
-  const auto listen_syslog = std::make_shared<ListenSyslog>("ListenSyslog");
-
-  SingleProcessorTestController controller{listen_syslog};
+  SingleProcessorTestController controller{std::make_unique<ListenSyslog>("ListenSyslog")};
+  const auto listen_syslog = controller.getProcessor<ListenSyslog>();
   LogTestController::getInstance().setTrace<ListenSyslog>();
   REQUIRE(listen_syslog->setProperty(ListenSyslog::MaxBatchSize, "2"));
   REQUIRE(listen_syslog->setProperty(ListenSyslog::ParseMessages, "false"));
@@ -306,9 +305,8 @@ TEST_CASE("ListenSyslog without parsing test", "[ListenSyslog]") {
 }
 
 TEST_CASE("ListenSyslog with parsing test", "[ListenSyslog][NetworkListenerProcessor]") {
-  const auto listen_syslog = std::make_shared<ListenSyslog>("ListenSyslog");
-
-  SingleProcessorTestController controller{listen_syslog};
+  SingleProcessorTestController controller{std::make_unique<ListenSyslog>("ListenSyslog")};
+  const auto listen_syslog = controller.getProcessor<ListenSyslog>();
   LogTestController::getInstance().setTrace<ListenSyslog>();
   REQUIRE(listen_syslog->setProperty(ListenSyslog::MaxBatchSize, "100"));
   REQUIRE(listen_syslog->setProperty(ListenSyslog::ParseMessages, "true"));
@@ -412,8 +410,8 @@ TEST_CASE("ListenSyslog with parsing test", "[ListenSyslog][NetworkListenerProce
 }
 
 TEST_CASE("ListenSyslog can be rescheduled", "[ListenSyslog][NetworkListenerProcessor]") {
-  const auto listen_syslog = std::make_shared<ListenSyslog>("ListenSyslog");
-  SingleProcessorTestController controller{listen_syslog};
+  SingleProcessorTestController controller{std::make_unique<ListenSyslog>("ListenSyslog")};
+  const auto listen_syslog = controller.getProcessor<ListenSyslog>();
   LogTestController::getInstance().setTrace<ListenSyslog>();
   REQUIRE(listen_syslog->setProperty(ListenSyslog::Port, "0"));
   REQUIRE(listen_syslog->setProperty(ListenSyslog::MaxBatchSize, "100"));
@@ -434,9 +432,8 @@ TEST_CASE("ListenSyslog can be rescheduled", "[ListenSyslog][NetworkListenerProc
 }
 
 TEST_CASE("ListenSyslog max queue and max batch size test", "[ListenSyslog][NetworkListenerProcessor]") {
-  const auto listen_syslog = std::make_shared<ListenSyslog>("ListenSyslog");
-
-  SingleProcessorTestController controller{listen_syslog};
+  SingleProcessorTestController controller{std::make_unique<ListenSyslog>("ListenSyslog")};
+  const auto listen_syslog = controller.getProcessor<ListenSyslog>();
   REQUIRE(listen_syslog->setProperty(ListenSyslog::MaxBatchSize, "10"));
   REQUIRE(listen_syslog->setProperty(ListenSyslog::ParseMessages, "false"));
   REQUIRE(listen_syslog->setProperty(ListenSyslog::MaxQueueSize, "50"));
@@ -493,8 +490,8 @@ TEST_CASE("ListenSyslog max queue and max batch size test", "[ListenSyslog][Netw
 }
 
 TEST_CASE("Test ListenSyslog via TCP with SSL connection", "[ListenSyslog][NetworkListenerProcessor]") {
-  const auto listen_syslog = std::make_shared<ListenSyslog>("ListenSyslog");
-  SingleProcessorTestController controller{listen_syslog};
+  SingleProcessorTestController controller{std::make_unique<ListenSyslog>("ListenSyslog")};
+  const auto listen_syslog = controller.getProcessor<ListenSyslog>();
 
   auto ssl_context_service = controller.plan->addController("SSLContextService", "SSLContextService");
   const auto executable_dir = minifi::utils::file::FileUtils::get_executable_dir();
diff --git a/extensions/standard-processors/tests/unit/ListenTcpTests.cpp b/extensions/standard-processors/tests/unit/ListenTcpTests.cpp
index f63027fc6..c5e647f84 100644
--- a/extensions/standard-processors/tests/unit/ListenTcpTests.cpp
+++ b/extensions/standard-processors/tests/unit/ListenTcpTests.cpp
@@ -38,8 +38,8 @@ void check_for_attributes(core::FlowFile& flow_file, uint16_t port) {
 }
 
 TEST_CASE("ListenTCP test multiple messages", "[ListenTCP][NetworkListenerProcessor]") {
-  const auto listen_tcp = std::make_shared<ListenTCP>("ListenTCP");
-  SingleProcessorTestController controller{listen_tcp};
+  SingleProcessorTestController controller{std::make_unique<ListenTCP>("ListenTCP")};
+  const auto listen_tcp = controller.getProcessor<ListenTCP>();
   LogTestController::getInstance().setTrace<ListenTCP>();
   REQUIRE(listen_tcp->setProperty(ListenTCP::MaxBatchSize, "2"));
   auto port = utils::scheduleProcessorOnRandomPort(controller.plan, listen_tcp);
@@ -66,8 +66,8 @@ TEST_CASE("ListenTCP test multiple messages", "[ListenTCP][NetworkListenerProces
 }
 
 TEST_CASE("ListenTCP can be rescheduled", "[ListenTCP][NetworkListenerProcessor]") {
-  const auto listen_tcp = std::make_shared<ListenTCP>("ListenTCP");
-  SingleProcessorTestController controller{listen_tcp};
+  SingleProcessorTestController controller{std::make_unique<ListenTCP>("ListenTCP")};
+  const auto listen_tcp = controller.getProcessor<ListenTCP>();
   LogTestController::getInstance().setTrace<ListenTCP>();
   REQUIRE(listen_tcp->setProperty(ListenTCP::Port, "0"));
   REQUIRE(listen_tcp->setProperty(ListenTCP::MaxBatchSize, "100"));
@@ -78,8 +78,8 @@ TEST_CASE("ListenTCP can be rescheduled", "[ListenTCP][NetworkListenerProcessor]
 }
 
 TEST_CASE("ListenTCP max queue and max batch size test", "[ListenTCP][NetworkListenerProcessor]") {
-  const auto listen_tcp = std::make_shared<ListenTCP>("ListenTCP");
-  SingleProcessorTestController controller{listen_tcp};
+  SingleProcessorTestController controller{std::make_unique<ListenTCP>("ListenTCP")};
+  const auto listen_tcp = controller.getProcessor<ListenTCP>();
   LogTestController::getInstance().setTrace<ListenTCP>();
   REQUIRE(listen_tcp->setProperty(ListenTCP::MaxBatchSize, "10"));
   REQUIRE(listen_tcp->setProperty(ListenTCP::MaxQueueSize, "50"));
@@ -111,9 +111,9 @@ TEST_CASE("ListenTCP max queue and max batch size test", "[ListenTCP][NetworkLis
 }
 
 TEST_CASE("Test ListenTCP with SSL connection", "[ListenTCP][NetworkListenerProcessor]") {
-  const auto listen_tcp = std::make_shared<ListenTCP>("ListenTCP");
   uint16_t port = 0;
-  SingleProcessorTestController controller{listen_tcp};
+  SingleProcessorTestController controller{std::make_unique<ListenTCP>("ListenTCP")};
+  const auto listen_tcp = controller.getProcessor<ListenTCP>();
   auto ssl_context_service = controller.plan->addController("SSLContextService", "SSLContextService");
   LogTestController::getInstance().setTrace<ListenTCP>();
   const auto executable_dir = minifi::utils::file::FileUtils::get_executable_dir();
@@ -241,8 +241,8 @@ bool isSslMethodAvailable(asio::ssl::context::method method) {
 }  // namespace
 
 TEST_CASE("Test ListenTCP SSL/TLS compatibility", "[ListenTCP][NetworkListenerProcessor]") {
-  const auto listen_tcp = std::make_shared<ListenTCP>("ListenTCP");
-  SingleProcessorTestController controller{listen_tcp};
+  SingleProcessorTestController controller{std::make_unique<ListenTCP>("ListenTCP")};
+  const auto listen_tcp = controller.getProcessor<ListenTCP>();
   auto ssl_context_service = controller.plan->addController("SSLContextService", "SSLContextService");
   LogTestController::getInstance().setTrace<ListenTCP>();
   const auto executable_dir = minifi::utils::file::FileUtils::get_executable_dir();
@@ -288,8 +288,8 @@ TEST_CASE("Test ListenTCP SSL/TLS compatibility", "[ListenTCP][NetworkListenerPr
 }
 
 TEST_CASE("Custom delimiter", "[ListenTCP][NetworkListenerProcessor]") {
-  const auto listen_tcp = std::make_shared<ListenTCP>("ListenTCP");
-  SingleProcessorTestController controller{listen_tcp};
+  SingleProcessorTestController controller{std::make_unique<ListenTCP>("ListenTCP")};
+  const auto listen_tcp = controller.getProcessor<ListenTCP>();
   LogTestController::getInstance().setTrace<ListenTCP>();
 
   std::string delimiter = GENERATE("\n", "\\n", "foo", "💩", "foo\\nbar");
diff --git a/extensions/standard-processors/tests/unit/ListenUDPTests.cpp b/extensions/standard-processors/tests/unit/ListenUDPTests.cpp
index 0a9c6490b..dd61db83a 100644
--- a/extensions/standard-processors/tests/unit/ListenUDPTests.cpp
+++ b/extensions/standard-processors/tests/unit/ListenUDPTests.cpp
@@ -36,8 +36,8 @@ void check_for_attributes(core::FlowFile& flow_file, uint16_t port) {
 }
 
 TEST_CASE("ListenUDP test multiple messages", "[ListenUDP][NetworkListenerProcessor]") {
-  const auto listen_udp = std::make_shared<ListenUDP>("ListenUDP");
-  SingleProcessorTestController controller{listen_udp};
+  SingleProcessorTestController controller{std::make_unique<ListenUDP>("ListenUDP")};
+  const auto listen_udp = controller.getProcessor<ListenUDP>();
   LogTestController::getInstance().setTrace<ListenUDP>();
 
   REQUIRE(listen_udp->setProperty(ListenUDP::MaxBatchSize, "2"));
@@ -68,8 +68,8 @@ TEST_CASE("ListenUDP test multiple messages", "[ListenUDP][NetworkListenerProces
 }
 
 TEST_CASE("ListenUDP can be rescheduled", "[ListenUDP][NetworkListenerProcessor]") {
-  const auto listen_udp = std::make_shared<ListenUDP>("ListenUDP");
-  SingleProcessorTestController controller{listen_udp};
+  SingleProcessorTestController controller{std::make_unique<ListenUDP>("ListenUDP")};
+  const auto listen_udp = controller.getProcessor<ListenUDP>();
   LogTestController::getInstance().setTrace<ListenUDP>();
   REQUIRE(listen_udp->setProperty(ListenUDP::Port, "0"));
   REQUIRE(listen_udp->setProperty(ListenUDP::MaxBatchSize, "100"));
@@ -80,8 +80,8 @@ TEST_CASE("ListenUDP can be rescheduled", "[ListenUDP][NetworkListenerProcessor]
 }
 
 TEST_CASE("ListenUDP max queue and max batch size test", "[ListenUDP][NetworkListenerProcessor]") {
-  const auto listen_udp = std::make_shared<ListenUDP>("ListenUDP");
-  SingleProcessorTestController controller{listen_udp};
+  SingleProcessorTestController controller{std::make_unique<ListenUDP>("ListenUDP")};
+  const auto listen_udp = controller.getProcessor<ListenUDP>();
   REQUIRE(listen_udp->setProperty(ListenUDP::MaxBatchSize, "10"));
   REQUIRE(listen_udp->setProperty(ListenUDP::MaxQueueSize, "50"));
 
diff --git a/extensions/standard-processors/tests/unit/LogAttributeTests.cpp b/extensions/standard-processors/tests/unit/LogAttributeTests.cpp
index 4a3045acd..25b1037cb 100644
--- a/extensions/standard-processors/tests/unit/LogAttributeTests.cpp
+++ b/extensions/standard-processors/tests/unit/LogAttributeTests.cpp
@@ -29,8 +29,8 @@ using namespace std::literals::chrono_literals;
 namespace org::apache::nifi::minifi::test {
 
 TEST_CASE("LogAttribute logs payload", "[LogAttribute]") {
-  const auto log_attribute = std::make_shared<LogAttribute>("log_attribute");
-  SingleProcessorTestController controller{log_attribute};
+  SingleProcessorTestController controller{std::make_unique<LogAttribute>("log_attribute")};
+  const auto log_attribute = controller.getProcessor();
   LogTestController::getInstance().setTrace<LogAttribute>();
 
   const auto [hexencode_payload, expected_payload] = GENERATE(
@@ -54,8 +54,8 @@ TEST_CASE("LogAttribute logs payload", "[LogAttribute]") {
 }
 
 TEST_CASE("LogAttribute LogLevel and LogPrefix", "[LogAttribute]") {
-  const auto log_attribute = std::make_shared<LogAttribute>("log_attribute");
-  SingleProcessorTestController controller{log_attribute};
+  SingleProcessorTestController controller{std::make_unique<LogAttribute>("log_attribute")};
+  const auto log_attribute = controller.getProcessor();
   LogTestController::getInstance().setTrace<LogAttribute>();
 
   const auto [log_level, log_prefix, expected_dash] = GENERATE(
@@ -81,8 +81,8 @@ TEST_CASE("LogAttribute LogLevel and LogPrefix", "[LogAttribute]") {
 }
 
 TEST_CASE("LogAttribute filtering attributes", "[LogAttribute]") {
-  const auto log_attribute = std::make_shared<LogAttribute>("log_attribute");
-  SingleProcessorTestController controller{log_attribute};
+  SingleProcessorTestController controller{std::make_unique<LogAttribute>("log_attribute")};
+  const auto log_attribute = controller.getProcessor();
   LogTestController::getInstance().setTrace<LogAttribute>();
 
   auto attrs_to_log = "";
@@ -128,8 +128,8 @@ TEST_CASE("LogAttribute filtering attributes", "[LogAttribute]") {
 }
 
 TEST_CASE("LogAttribute batch test", "[LogAttribute]") {
-  const auto log_attribute = std::make_shared<LogAttribute>("log_attribute");
-  SingleProcessorTestController controller{log_attribute};
+  SingleProcessorTestController controller{std::make_unique<LogAttribute>("log_attribute")};
+  const auto log_attribute = controller.getProcessor();
 
   const auto [flow_files_to_log, expected_success_flow_files] = GENERATE(
     std::make_tuple("0", 3U),
diff --git a/extensions/standard-processors/tests/unit/ProcessorTests.cpp b/extensions/standard-processors/tests/unit/ProcessorTests.cpp
index bba8bbe21..70d6e88ec 100644
--- a/extensions/standard-processors/tests/unit/ProcessorTests.cpp
+++ b/extensions/standard-processors/tests/unit/ProcessorTests.cpp
@@ -53,7 +53,7 @@
 
 TEST_CASE("Test Creation of GetFile", "[getfileCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::GetFile>("processorname");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::GetFile>("processorname");
   REQUIRE(processor->getName() == "processorname");
 }
 
@@ -66,7 +66,7 @@ TEST_CASE("Test GetFileMultiple", "[getfileCreate3]") {
   auto config = std::make_shared<minifi::Configure>();
   std::shared_ptr<core::ContentRepository> content_repo = std::make_shared<core::repository::VolatileContentRepository>();
   content_repo->initialize(config);
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::GetFile>("getfileCreate2");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::GetFile>("getfileCreate2");
   processor->initialize();
   std::shared_ptr<core::Repository> test_repo = std::make_shared<TestRepository>();
   std::shared_ptr<TestRepository> repo = std::static_pointer_cast<TestRepository>(test_repo);
@@ -147,7 +147,7 @@ TEST_CASE("Test GetFile Ignore", "[getfileCreate3]") {
   TestController testController;
   LogTestController::getInstance().setDebug<minifi::processors::GetFile>();
   std::shared_ptr<core::ContentRepository> content_repo = std::make_shared<core::repository::VolatileContentRepository>();
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::GetFile>("getfileCreate2");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::GetFile>("getfileCreate2");
   processor->initialize();
 
   std::shared_ptr<core::Repository> test_repo = std::make_shared<TestRepository>();
@@ -234,7 +234,7 @@ TEST_CASE("TestConnectionFull", "[ConnectionFull]") {
   LogTestController::getInstance().setDebug<minifi::processors::GenerateFlowFile>();
   std::shared_ptr<core::ContentRepository> content_repo = std::make_shared<core::repository::VolatileContentRepository>();
   content_repo->initialize(std::make_shared<minifi::Configure>());
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::GenerateFlowFile>("GFF");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::GenerateFlowFile>("GFF");
   processor->initialize();
   processor->setProperty(minifi::processors::GenerateFlowFile::BatchSize, "10");
   processor->setProperty(minifi::processors::GenerateFlowFile::FileSize, "0");
@@ -285,7 +285,7 @@ TEST_CASE("LogAttributeTest", "[getfileCreate3]") {
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -327,7 +327,7 @@ TEST_CASE("LogAttributeTestInvalid", "[TestLogAttribute]") {
   LogTestController::getInstance().setDebug<minifi::processors::GetFile>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
   auto loggattr = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -345,7 +345,7 @@ void testMultiplesLogAttribute(int fileCount, int flowsToLog, std::string verify
   LogTestController::getInstance().setDebug<minifi::processors::GetFile>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
   auto loggattr = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -411,10 +411,9 @@ TEST_CASE("Test Find file", "[getfileCreate3]") {
   TestController testController;
   LogTestController::getInstance().setDebug<minifi::provenance::ProvenanceReporter>();
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> processor = plan->addProcessor("GetFile", "getfileCreate2");
-  std::shared_ptr<core::Processor> processorReport = std::make_shared<org::apache::nifi::minifi::core::reporting::SiteToSiteProvenanceReportingTask>(
-      std::make_shared<org::apache::nifi::minifi::Configure>());
-  plan->addProcessor(processorReport, "reporter", core::Relationship("success", "description"), false);
+  auto processor = plan->addProcessor("GetFile", "getfileCreate2");
+  auto processorReport = plan->addProcessor(std::make_unique<org::apache::nifi::minifi::core::reporting::SiteToSiteProvenanceReportingTask>(
+      std::make_shared<org::apache::nifi::minifi::Configure>()), "reporter", core::Relationship("success", "description"), false);
 
   auto dir = testController.createTempDirectory();
   plan->setProperty(processor, org::apache::nifi::minifi::processors::GetFile::Directory, dir.string());
@@ -464,8 +463,7 @@ TEST_CASE("Test Find file", "[getfileCreate3]") {
       throw std::runtime_error("Did not find record");
     }
   }
-  std::shared_ptr<org::apache::nifi::minifi::core::reporting::SiteToSiteProvenanceReportingTask> taskReport = std::static_pointer_cast<
-      org::apache::nifi::minifi::core::reporting::SiteToSiteProvenanceReportingTask>(processorReport);
+  auto taskReport = static_cast<org::apache::nifi::minifi::core::reporting::SiteToSiteProvenanceReportingTask*>(processorReport);
   taskReport->setBatchSize(1);
   std::vector<std::shared_ptr<core::SerializableComponent>> recordsReport;
   recordsReport.push_back(std::make_shared<minifi::provenance::ProvenanceEventRecord>());
@@ -519,7 +517,7 @@ TEST_CASE("TestEmptyContent", "[emptyContent]") {
   LogTestController::getInstance().setDebug<TestPlan>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("TestProcessorNoContent", "TestProcessorNoContent");
+  plan->addProcessor("TestProcessorNoContent", "TestProcessorNoContent");
 
   plan->runNextProcessor();
 
@@ -599,7 +597,7 @@ class ProcessorWithIncomingConnectionTest {
   ~ProcessorWithIncomingConnectionTest();
 
  protected:
-  std::shared_ptr<core::Processor> processor_;
+  std::shared_ptr<minifi::processors::LogAttribute> processor_;
   std::shared_ptr<minifi::Connection> incoming_connection_;
   std::shared_ptr<core::ProcessSession> session_;
 };
diff --git a/extensions/standard-processors/tests/unit/PutFileTests.cpp b/extensions/standard-processors/tests/unit/PutFileTests.cpp
index 653cc1231..425d7c4d4 100644
--- a/extensions/standard-processors/tests/unit/PutFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/PutFileTests.cpp
@@ -39,7 +39,7 @@
 
 TEST_CASE("Test Creation of PutFile", "[getfileCreate]") {
   TestController testController;
-  std::shared_ptr<core::Processor> processor = std::make_shared<org::apache::nifi::minifi::processors::PutFile>("processorname");
+  auto processor = std::make_shared<org::apache::nifi::minifi::processors::PutFile>("processorname");
   REQUIRE(processor->getName() == "processorname");
 }
 
@@ -53,9 +53,9 @@ TEST_CASE("PutFileTest", "[getfileputpfile]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -113,9 +113,9 @@ TEST_CASE("PutFileTestFileExists", "[getfileputpfile]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("failure", "description"), true);
 
@@ -172,9 +172,9 @@ TEST_CASE("PutFileTestFileExistsIgnore", "[getfileputpfile]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -234,9 +234,9 @@ TEST_CASE("PutFileTestFileExistsReplace", "[getfileputpfile]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   plan->addProcessor("LogAttribute", "logattribute", { core::Relationship("success", "d"), core::Relationship("failure", "d") }, true);
 
@@ -298,9 +298,9 @@ TEST_CASE("PutFileMaxFileCountTest", "[getfileputpfilemaxcount]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   plan->addProcessor("LogAttribute", "logattribute", { core::Relationship("success", "d"), core::Relationship("failure", "d") }, true);
 
@@ -363,9 +363,9 @@ TEST_CASE("PutFileEmptyTest", "[EmptyFilePutTest]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   const auto dir = testController.createTempDirectory();
   const auto putfiledir = testController.createTempDirectory();
@@ -396,9 +396,9 @@ TEST_CASE("TestPutFilePermissions", "[PutFilePermissions]") {
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
 
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
 
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
 
   const auto dir = testController.createTempDirectory();
   const auto putfiledir = testController.createTempDirectory() / "test_dir";
@@ -432,8 +432,8 @@ TEST_CASE("PutFileCreateDirectoryTest", "[PutFileProperties]") {
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> getfile = plan->addProcessor("GetFile", "getfileCreate2");
-  std::shared_ptr<core::Processor> putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
+  auto getfile = plan->addProcessor("GetFile", "getfileCreate2");
+  auto putfile = plan->addProcessor("PutFile", "putfile", core::Relationship("success", "description"), true);
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
   // Define Directory
diff --git a/extensions/standard-processors/tests/unit/PutTCPTests.cpp b/extensions/standard-processors/tests/unit/PutTCPTests.cpp
index b4b2ff512..c190c3c8a 100644
--- a/extensions/standard-processors/tests/unit/PutTCPTests.cpp
+++ b/extensions/standard-processors/tests/unit/PutTCPTests.cpp
@@ -97,7 +97,9 @@ utils::net::SslData createSslDataForServer() {
 
 class PutTCPTestFixture {
  public:
-  PutTCPTestFixture() {
+  PutTCPTestFixture() :
+      controller_(std::make_unique<PutTCP>("PutTCP")),
+      put_tcp_(controller_.getProcessor<PutTCP>()) {
     LogTestController::getInstance().setTrace<PutTCP>();
     LogTestController::getInstance().setInfo<core::ProcessSession>();
     LogTestController::getInstance().setTrace<utils::net::Server>();
@@ -227,8 +229,8 @@ class PutTCPTestFixture {
     return servers_.at(*port).cancellable_server.get();
   }
 
-  const std::shared_ptr<PutTCP> put_tcp_ = std::make_shared<PutTCP>("PutTCP");
-  test::SingleProcessorTestController controller_{put_tcp_};
+  test::SingleProcessorTestController controller_;
+  PutTCP* put_tcp_;
 
   class Server {
    public:
diff --git a/extensions/standard-processors/tests/unit/PutUDPTests.cpp b/extensions/standard-processors/tests/unit/PutUDPTests.cpp
index d17106fc8..e55fc07ca 100644
--- a/extensions/standard-processors/tests/unit/PutUDPTests.cpp
+++ b/extensions/standard-processors/tests/unit/PutUDPTests.cpp
@@ -46,9 +46,9 @@ std::optional<utils::net::Message> tryDequeueWithTimeout(utils::net::UdpServer&
 }  // namespace
 
 TEST_CASE("PutUDP", "[putudp]") {
-  const auto put_udp = std::make_shared<PutUDP>("PutUDP");
+  test::SingleProcessorTestController controller{std::make_unique<PutUDP>("PutUDP")};
+  const auto put_udp = controller.getProcessor();
 
-  test::SingleProcessorTestController controller{put_udp};
   LogTestController::getInstance().setTrace<PutUDP>();
   LogTestController::getInstance().setTrace<core::ProcessContext>();
   put_udp->setProperty(PutUDP::Hostname, "${literal('localhost')}");
diff --git a/extensions/standard-processors/tests/unit/ReplaceTextTests.cpp b/extensions/standard-processors/tests/unit/ReplaceTextTests.cpp
index 9092262ac..03c37a747 100644
--- a/extensions/standard-processors/tests/unit/ReplaceTextTests.cpp
+++ b/extensions/standard-processors/tests/unit/ReplaceTextTests.cpp
@@ -45,12 +45,12 @@ TEST_CASE("ReplaceText can parse its properties", "[onSchedule]") {
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   LogTestController::getInstance().setDebug<minifi::processors::ReplaceText>();
 
-  std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+  auto generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
   plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::CustomText, "One green bottle is hanging on the wall");
   plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::DataFormat, "Text");
   plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::UniqueFlowFiles, "false");
 
-  std::shared_ptr<core::Processor> replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
+  auto replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
   plan->setProperty(replace_text, minifi::processors::ReplaceText::EvaluationMode, "Entire text");
   plan->setProperty(replace_text, minifi::processors::ReplaceText::LineByLineEvaluationMode, "Except-First-Line");
   plan->setProperty(replace_text, minifi::processors::ReplaceText::ReplacementStrategy, "Substitute Variables");
@@ -184,12 +184,12 @@ TEST_CASE("Regex Replace works correctly in ReplaceText in line by line mode", "
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
-  std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+  auto generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
   plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::CustomText, "apple\n pear\n orange\n banana\n");
   plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::DataFormat, "Text");
   plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::UniqueFlowFiles, "false");
 
-  std::shared_ptr<core::Processor> replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
+  auto replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
   plan->setProperty(replace_text, minifi::processors::ReplaceText::EvaluationMode, magic_enum::enum_name(minifi::processors::EvaluationModeType::LINE_BY_LINE));
   plan->setProperty(replace_text, minifi::processors::ReplaceText::ReplacementStrategy, magic_enum::enum_name(minifi::processors::ReplacementStrategyType::REGEX_REPLACE));
   plan->setProperty(replace_text, minifi::processors::ReplaceText::SearchValue, "[aeiou]");
@@ -275,7 +275,7 @@ TEST_CASE("Regex Replace works correctly in ReplaceText in line by line mode", "
     expected_output = "fruit\r\nfruit\r\nfruit\r\nfruit";
   }
 
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attribute", minifi::processors::ReplaceText::Success, true);
+  auto log_attribute = plan->addProcessor("LogAttribute", "log_attribute", minifi::processors::ReplaceText::Success, true);
   plan->setProperty(log_attribute, minifi::processors::LogAttribute::LogPayload, "true");
 
   testController.runSession(plan);
@@ -293,15 +293,15 @@ class HandleEmptyIncomingFlowFile {
   void run() {
     LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
-    std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+    auto generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
     plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::FileSize, "0 B");
 
-    std::shared_ptr<core::Processor> replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
+    auto replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
     plan->setProperty(replace_text, minifi::processors::ReplaceText::EvaluationMode, magic_enum::enum_name(evaluation_mode_));
     plan->setProperty(replace_text, minifi::processors::ReplaceText::ReplacementStrategy, magic_enum::enum_name(replacement_strategy_));
     plan->setProperty(replace_text, minifi::processors::ReplaceText::ReplacementValue, "hippopotamus");
 
-    std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attribute", minifi::processors::ReplaceText::Success, true);
+    auto log_attribute = plan->addProcessor("LogAttribute", "log_attribute", minifi::processors::ReplaceText::Success, true);
     plan->setProperty(log_attribute, minifi::processors::LogAttribute::LogPayload, "true");
 
     testController.runSession(plan);
@@ -355,22 +355,22 @@ class UseExpressionLanguage {
   void run() {
     LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
-    std::shared_ptr<core::Processor> generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
+    auto generate_flow_file = plan->addProcessor("GenerateFlowFile", "generate_flow_file");
     plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::CustomText, "apple\n pear\n orange\n banana\n");
     plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::DataFormat, "Text");
     plan->setProperty(generate_flow_file, minifi::processors::GenerateFlowFile::UniqueFlowFiles, "false");
 
-    std::shared_ptr<core::Processor> update_attribute = plan->addProcessor("UpdateAttribute", "update_attribute", minifi::processors::GenerateFlowFile::Success, true);
+    auto update_attribute = plan->addProcessor("UpdateAttribute", "update_attribute", minifi::processors::GenerateFlowFile::Success, true);
     plan->setDynamicProperty(update_attribute, "substring", "an");
     plan->setDynamicProperty(update_attribute, "color", "blue");
 
-    std::shared_ptr<core::Processor> replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
+    auto replace_text = plan->addProcessor("ReplaceText", "replace_text", minifi::processors::GenerateFlowFile::Success, true);
     plan->setProperty(replace_text, minifi::processors::ReplaceText::EvaluationMode, magic_enum::enum_name(minifi::processors::EvaluationModeType::ENTIRE_TEXT));
     plan->setProperty(replace_text, minifi::processors::ReplaceText::ReplacementStrategy, magic_enum::enum_name(minifi::processors::ReplacementStrategyType::LITERAL_REPLACE));
     plan->setProperty(replace_text, minifi::processors::ReplaceText::SearchValue, search_value_);
     plan->setProperty(replace_text, minifi::processors::ReplaceText::ReplacementValue, replacement_value_);
 
-    std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attribute", minifi::processors::ReplaceText::Success, true);
+    auto log_attribute = plan->addProcessor("LogAttribute", "log_attribute", minifi::processors::ReplaceText::Success, true);
     plan->setProperty(log_attribute, minifi::processors::LogAttribute::LogPayload, "true");
 
     testController.runSession(plan);
diff --git a/extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp b/extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
index 53a1afc18..2a3722b36 100644
--- a/extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/RetryFlowFileTests.cpp
@@ -95,13 +95,13 @@ class RetryFlowFileTest {
     const core::Relationship failure         {RetryFlowFile::Failure};
 
     // Processors
-    std::shared_ptr<core::Processor> generate                    = plan_->addProcessor("GenerateFlowFile", "generate", {success}, false);
-    std::shared_ptr<core::Processor> update                      = plan_->addProcessor("UpdateAttribute", "update", {success}, false);
-    std::shared_ptr<core::Processor> retryflowfile               = plan_->addProcessor("RetryFlowFile", "retryflowfile", {retry, retries_exceeded, failure}, false);
-    std::shared_ptr<core::Processor> putfile_on_retry            = plan_->addProcessor("PutFile", "putfile_on_retry", {success}, false);
-    std::shared_ptr<core::Processor> putfile_on_retries_exceeded = plan_->addProcessor("PutFile", "putfile_on_retries_exceeded", {success}, false);
-    std::shared_ptr<core::Processor> putfile_on_failure          = plan_->addProcessor("PutFile", "putfile_on_failure", {success}, false);
-    std::shared_ptr<core::Processor> log_attribute               = plan_->addProcessor("LogAttribute", "log", {success}, false);
+    auto generate                    = plan_->addProcessor("GenerateFlowFile", "generate", {success}, false);
+    auto update                      = plan_->addProcessor("UpdateAttribute", "update", {success}, false);
+    auto retryflowfile               = plan_->addProcessor("RetryFlowFile", "retryflowfile", {retry, retries_exceeded, failure}, false);
+    auto putfile_on_retry            = plan_->addProcessor("PutFile", "putfile_on_retry", {success}, false);
+    auto putfile_on_retries_exceeded = plan_->addProcessor("PutFile", "putfile_on_retries_exceeded", {success}, false);
+    auto putfile_on_failure          = plan_->addProcessor("PutFile", "putfile_on_failure", {success}, false);
+    auto log_attribute               = plan_->addProcessor("LogAttribute", "log", {success}, false);
 
     retryflowfile->setPenalizationPeriod(std::chrono::milliseconds{0});
 
diff --git a/extensions/standard-processors/tests/unit/RouteTextTests.cpp b/extensions/standard-processors/tests/unit/RouteTextTests.cpp
index 3db31e44c..f5c3b1662 100644
--- a/extensions/standard-processors/tests/unit/RouteTextTests.cpp
+++ b/extensions/standard-processors/tests/unit/RouteTextTests.cpp
@@ -54,7 +54,7 @@ struct RouteTextController : public TestController {
 
   RouteTextController() {
     plan_ = createPlan();
-    plan_->addProcessor(proc_, "RouteText");
+    proc_ = plan_->addProcessor(std::make_unique<processors::RouteText>("RouteText"), "RouteText");
     input_ = plan_->addConnection(nullptr, {"success", ""}, proc_);
     createOutput(processors::RouteText::Original);
     createOutput(processors::RouteText::Unmatched);
@@ -124,7 +124,7 @@ struct RouteTextController : public TestController {
   }
 
   std::shared_ptr<TestPlan> plan_ = createPlan();
-  std::shared_ptr<core::Processor> proc_ = std::make_shared<processors::RouteText>("RouteText");
+  core::Processor* proc_ = nullptr;
   std::map<std::string, minifi::Connection*> outputs_;
   minifi::Connection* input_;
 };
diff --git a/extensions/standard-processors/tests/unit/SplitTextTests.cpp b/extensions/standard-processors/tests/unit/SplitTextTests.cpp
index 83fbf2612..e7bccc3f9 100644
--- a/extensions/standard-processors/tests/unit/SplitTextTests.cpp
+++ b/extensions/standard-processors/tests/unit/SplitTextTests.cpp
@@ -164,8 +164,8 @@ void verifySplitResults(const SingleProcessorTestController& controller, const P
 }
 
 void runSplitTextTest(const std::string& input, const std::vector<ExpectedSplitTextResult>& expected_results, const SplitTextProperties& properties) {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, std::to_string(properties.line_split_count));
   if (properties.maximum_fragment_size) {
     split_text->setProperty(processors::SplitText::MaximumFragmentSize, std::to_string(*properties.maximum_fragment_size) + " B");
@@ -188,29 +188,28 @@ void runSplitTextTest(const std::string& input, const std::vector<ExpectedSplitT
 }
 
 TEST_CASE("Line Split Count property is required") {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
   REQUIRE_THROWS_AS(controller.trigger("", {}), minifi::Exception);
 }
 
 TEST_CASE("Line Split Count property can only be 0 if Maximum Fragment Size is set") {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, "0");
   REQUIRE_THROWS_AS(controller.trigger("", {}), minifi::Exception);
 }
 
 TEST_CASE("Maximum Fragment Size cannot be set to 0") {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, "0");
   split_text->setProperty(processors::SplitText::MaximumFragmentSize, "0 B");
   REQUIRE_THROWS_AS(controller.trigger("", {}), minifi::Exception);
 }
 
 TEST_CASE("Header Line Marker Characters size cannot be equal or larger than split text buffer size") {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, "1");
   std::string header_marker_character(processors::detail::SPLIT_TEXT_BUFFER_SIZE, 'A');
   split_text->setProperty(processors::SplitText::HeaderLineMarkerCharacters, header_marker_character);
@@ -219,8 +218,8 @@ TEST_CASE("Header Line Marker Characters size cannot be equal or larger than spl
 
 
 TEST_CASE("SplitText only forwards empty flowfile") {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, "1");
   const auto trigger_results = controller.trigger("", {{std::string(core::SpecialFlowAttribute::FILENAME), "a.foo"}});
   CHECK(trigger_results.at(processors::SplitText::Splits).empty());
@@ -404,8 +403,8 @@ TEST_CASE("Endlines are trimmed when Remove Trailing Newlines is set to true and
 }
 
 TEST_CASE("If flowfile is empty after trailing new lines are removed then flow file is not emitted") {
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   SECTION("Line split count 1") {
     split_text->setProperty(processors::SplitText::LineSplitCount, "1");
   }
@@ -600,8 +599,8 @@ TEST_CASE("If the header defined by the header line count is larger than the flo
   SECTION("Header line count is one line shorter larger than the flow file") {
     input = "header line 1\nheader line 2\nthis is a new line\n";
   }
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, "1");
   split_text->setProperty(processors::SplitText::HeaderLineCount, "4");
   const auto trigger_results = controller.trigger(input, {{std::string(core::SpecialFlowAttribute::FILENAME), "a.foo"}});
@@ -614,8 +613,8 @@ TEST_CASE("If the header defined by the header line count is larger than the flo
 TEST_CASE("If the header defined by the header line count is larger than the max fragment size then the processor should fail") {
   std::string input;
   input = "header line 1\nheader line 2\nthis is a new line\n";
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::MaximumFragmentSize, "20 B");
   split_text->setProperty(processors::SplitText::HeaderLineCount, "2");
   split_text->setProperty(processors::SplitText::LineSplitCount, "0");
@@ -628,8 +627,8 @@ TEST_CASE("If the header defined by the header line count is larger than the max
 
 TEST_CASE("If header line count is the same as the flow file line count then no new flow file should be emitted") {
   std::string input = "header line 1\nheader line 2\nthis is a new line\n";
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::LineSplitCount, "1");
   split_text->setProperty(processors::SplitText::HeaderLineCount, "3");
   const auto trigger_results = controller.trigger(input, {{std::string(core::SpecialFlowAttribute::FILENAME), "a.foo"}});
@@ -807,8 +806,8 @@ TEST_CASE("If a split fragment would only consist of new lines then only the tri
 TEST_CASE("If the header defined by header marker characters is larger than the max fragments size then the processor should fail") {
   std::string input;
   input = "header line 1\nheader line 2\nthis is a new line\n";
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::MaximumFragmentSize, "20 B");
   split_text->setProperty(processors::SplitText::HeaderLineMarkerCharacters, "hea");
   split_text->setProperty(processors::SplitText::LineSplitCount, "0");
@@ -822,8 +821,8 @@ TEST_CASE("If the header defined by header marker characters is larger than the
 TEST_CASE("If the header defined by header marker characters is the only content in the flow file then the processor should not emit new flow files") {
   std::string input;
   input = "header line 1\nheader line 2\n";
-  const auto split_text = std::make_shared<processors::SplitText>("SplitText");
-  SingleProcessorTestController controller{split_text};
+  SingleProcessorTestController controller{std::make_unique<processors::SplitText>("SplitText")};
+  const auto split_text = controller.getProcessor();
   split_text->setProperty(processors::SplitText::MaximumFragmentSize, "40 B");
   split_text->setProperty(processors::SplitText::HeaderLineMarkerCharacters, "hea");
   split_text->setProperty(processors::SplitText::LineSplitCount, "0");
diff --git a/extensions/standard-processors/tests/unit/TailFileTests.cpp b/extensions/standard-processors/tests/unit/TailFileTests.cpp
index 8dd5d91e9..d20d20e98 100644
--- a/extensions/standard-processors/tests/unit/TailFileTests.cpp
+++ b/extensions/standard-processors/tests/unit/TailFileTests.cpp
@@ -85,7 +85,7 @@ TEST_CASE("TailFile reads the file until the first delimiter", "[simple]") {
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
   auto dir = testController.createTempDirectory();
@@ -120,7 +120,7 @@ TEST_CASE("TailFile picks up the second line if a delimiter is written between r
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -162,7 +162,7 @@ TEST_CASE("TailFile re-reads the file if the state is deleted between runs", "[s
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -201,7 +201,7 @@ TEST_CASE("TailFile picks up the state correctly if it is rewritten between runs
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
@@ -375,10 +375,10 @@ TEST_CASE("TailFile picks up the new File to Tail if it is changed between runs"
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tail_file = plan->addProcessor("TailFile", "tail_file");
+  auto tail_file = plan->addProcessor("TailFile", "tail_file");
   plan->setProperty(tail_file, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
 
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attribute", core::Relationship("success", "description"), true);
+  auto log_attribute = plan->addProcessor("LogAttribute", "log_attribute", core::Relationship("success", "description"), true);
   plan->setProperty(log_attribute, org::apache::nifi::minifi::processors::LogAttribute::FlowFilesToLog, "0");
 
   auto directory = testController.createTempDirectory();
@@ -417,14 +417,14 @@ TEST_CASE("TailFile picks up the new File to Tail if it is changed between runs
   auto directory = testController.createTempDirectory();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tail_file = plan->addProcessor("TailFile", "tail_file");
+  auto tail_file = plan->addProcessor("TailFile", "tail_file");
   plan->setProperty(tail_file, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
   plan->setProperty(tail_file, org::apache::nifi::minifi::processors::TailFile::TailMode, "Multiple file");
   plan->setProperty(tail_file, org::apache::nifi::minifi::processors::TailFile::BaseDirectory, directory.string());
   plan->setProperty(tail_file, org::apache::nifi::minifi::processors::TailFile::LookupFrequency, "0 sec");
   plan->setProperty(tail_file, org::apache::nifi::minifi::processors::TailFile::FileName, "first\\..*\\.log");
 
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attribute", core::Relationship("success", "description"), true);
+  auto log_attribute = plan->addProcessor("LogAttribute", "log_attribute", core::Relationship("success", "description"), true);
   plan->setProperty(log_attribute, org::apache::nifi::minifi::processors::LogAttribute::FlowFilesToLog, "0");
 
   createTempFile(directory, "first.fruit.log", "apple\n");
@@ -465,7 +465,7 @@ TEST_CASE("TailFile finds the single input file in both Single and Multiple mode
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::Delimiter, "");
 
   plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
@@ -509,14 +509,14 @@ TEST_CASE("TailFile picks up new files created between runs", "[multiple_file]")
   auto dir = testController.createTempDirectory();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfile");
+  auto tailfile = plan->addProcessor("TailFile", "tailfile");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::TailMode, "Multiple file");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::BaseDirectory, dir.string());
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::LookupFrequency, "0 sec");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::FileName, ".*\\.log");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
 
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
   plan->setProperty(logattribute, org::apache::nifi::minifi::processors::LogAttribute::FlowFilesToLog, "0");
 
   createTempFile(dir, "application.log", "line1\nline2\n");
@@ -544,14 +544,14 @@ TEST_CASE("TailFile can handle input files getting removed", "[multiple_file]")
   auto dir = testController.createTempDirectory();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfile");
+  auto tailfile = plan->addProcessor("TailFile", "tailfile");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::TailMode, "Multiple file");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::BaseDirectory, dir.string());
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::LookupFrequency, "0 sec");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::FileName, ".*\\.log");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
 
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute",
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute",
                                                                      core::Relationship("success", "description"),
                                                                      true);
   plan->setProperty(logattribute, org::apache::nifi::minifi::processors::LogAttribute::FlowFilesToLog, "0");
@@ -594,7 +594,7 @@ TEST_CASE("TailFile processes a very long line correctly", "[simple]") {
   LogTestController::getInstance().setTrace<core::ProcessSession>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
 
   auto dir = testController.createTempDirectory();
   auto temp_file_path = dir / TMP_FILE;
@@ -606,7 +606,7 @@ TEST_CASE("TailFile processes a very long line correctly", "[simple]") {
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::FileName, temp_file_path.string());
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
 
-  std::shared_ptr<core::Processor> log_attr = plan->addProcessor("LogAttribute", "Log", core::Relationship("success", "description"), true);
+  auto log_attr = plan->addProcessor("LogAttribute", "Log", core::Relationship("success", "description"), true);
   plan->setProperty(log_attr, minifi::processors::LogAttribute::FlowFilesToLog, "0");
   plan->setProperty(log_attr, minifi::processors::LogAttribute::LogPayload, "true");
   plan->setProperty(log_attr, minifi::processors::LogAttribute::HexencodePayload, "true");
@@ -671,7 +671,7 @@ TEST_CASE("TailFile processes a long line followed by multiple newlines correctl
   LogTestController::getInstance().setTrace<core::ProcessSession>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
   auto dir = testController.createTempDirectory();
   auto temp_file_path = dir / TMP_FILE;
   std::ofstream tmpfile;
@@ -682,7 +682,7 @@ TEST_CASE("TailFile processes a long line followed by multiple newlines correctl
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::FileName, temp_file_path.string());
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
 
-  std::shared_ptr<core::Processor> log_attr = plan->addProcessor("LogAttribute", "Log", core::Relationship("success", "description"), true);
+  auto log_attr = plan->addProcessor("LogAttribute", "Log", core::Relationship("success", "description"), true);
   plan->setProperty(log_attr, minifi::processors::LogAttribute::FlowFilesToLog, "0");
   plan->setProperty(log_attr, minifi::processors::LogAttribute::LogPayload, "true");
   plan->setProperty(log_attr, minifi::processors::LogAttribute::HexencodePayload, "true");
@@ -709,7 +709,7 @@ TEST_CASE("TailFile onSchedule throws if file(s) to tail cannot be determined",
   LogTestController::getInstance().setDebug<minifi::processors::TailFile>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
 
   SECTION("Single file mode by default") {
     SECTION("No FileName") {
@@ -750,7 +750,7 @@ TEST_CASE("TailFile onSchedule throws in Multiple mode if the Base Directory doe
   LogTestController::getInstance().setDebug<minifi::processors::TailFile>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
   plan->setProperty(tailfile, minifi::processors::TailFile::TailMode, "Multiple file");
   plan->setProperty(tailfile, minifi::processors::TailFile::FileName, ".*\\.log");
 
@@ -912,11 +912,11 @@ TEST_CASE("TailFile ignores old rotated files", "[rotation]") {
   auto log_file_name = dir / "test.log";
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfile");
+  auto tailfile = plan->addProcessor("TailFile", "tailfile");
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::FileName, log_file_name.string());
   plan->setProperty(tailfile, org::apache::nifi::minifi::processors::TailFile::Delimiter, "\n");
 
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute",
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute",
                                                                      core::Relationship("success", "description"),
                                                                      true);
   plan->setProperty(logattribute, org::apache::nifi::minifi::processors::LogAttribute::FlowFilesToLog, "0");
@@ -1456,7 +1456,7 @@ TEST_CASE("TailFile interprets the lookup frequency property correctly", "[multi
   SECTION("Lookup frequency not set => defaults to 10 minutes") {
     testController.runSession(plan, true);
 
-    const auto tail_file_processor = std::dynamic_pointer_cast<minifi::processors::TailFile>(tail_file);
+    const auto tail_file_processor = dynamic_cast<minifi::processors::TailFile*>(tail_file);
     REQUIRE(tail_file_processor);
     REQUIRE(tail_file_processor->getLookupFrequency() == std::chrono::minutes{10});
   }
@@ -1512,8 +1512,8 @@ TEST_CASE("TailFile reads from a single file when Initial Start Position is set"
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
   auto dir = testController.createTempDirectory();
   createTempFile(dir, ROLLED_OVER_TMP_FILE, ROLLED_OVER_TAIL_DATA);
@@ -1589,8 +1589,8 @@ TEST_CASE("TailFile reads from a single file when Initial Start Position is set
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
   auto dir = testController.createTempDirectory();
   auto temp_file_path = createTempFile(dir, TMP_FILE, NEWLINE_FILE);
@@ -1628,8 +1628,8 @@ TEST_CASE("TailFile reads multiple files when Initial Start Position is set", "[
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
   auto dir = testController.createTempDirectory();
   createTempFile(dir, ROLLED_OVER_TMP_FILE, ROLLED_OVER_TAIL_DATA);
@@ -1717,8 +1717,8 @@ TEST_CASE("Initial Start Position is set to invalid or empty value", "[initialSt
   LogTestController::getInstance().setDebug<minifi::processors::LogAttribute>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tailfile = plan->addProcessor("TailFile", "tailfileProc");
-  std::shared_ptr<core::Processor> logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
+  auto tailfile = plan->addProcessor("TailFile", "tailfileProc");
+  auto logattribute = plan->addProcessor("LogAttribute", "logattribute", core::Relationship("success", "description"), true);
 
   auto dir = testController.createTempDirectory();
   createTempFile(dir, ROLLED_OVER_TMP_FILE, ROLLED_OVER_TAIL_DATA);
@@ -1744,7 +1744,7 @@ TEST_CASE("TailFile onSchedule throws if an invalid Attribute Provider Service i
   LogTestController::getInstance().setDebug<minifi::processors::TailFile>();
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
-  std::shared_ptr<core::Processor> tail_file = plan->addProcessor("TailFile", "tailfileProc");
+  auto tail_file = plan->addProcessor("TailFile", "tailfileProc");
   plan->setProperty(tail_file, minifi::processors::TailFile::TailMode, "Multiple file");
   plan->setProperty(tail_file, minifi::processors::TailFile::BaseDirectory, "/var/logs");
   plan->setProperty(tail_file, minifi::processors::TailFile::FileName, "minifi.log");
@@ -1786,13 +1786,13 @@ TEST_CASE("TailFile can use an AttributeProviderService", "[AttributeProviderSer
 
   std::shared_ptr<TestPlan> plan = testController.createPlan();
   plan->addController("TestAttributeProviderService", "attribute_provider_service");
-  std::shared_ptr<core::Processor> tail_file = plan->addProcessor("TailFile", "tail_file");
+  auto tail_file = plan->addProcessor("TailFile", "tail_file");
   plan->setProperty(tail_file, minifi::processors::TailFile::TailMode, "Multiple file");
   plan->setProperty(tail_file, minifi::processors::TailFile::BaseDirectory, (temp_directory / "my_${color}_${fruit}_${uid}" / "${animal}").string());
   plan->setProperty(tail_file, minifi::processors::TailFile::LookupFrequency, "0 sec");
   plan->setProperty(tail_file, minifi::processors::TailFile::FileName, ".*\\.log");
   plan->setProperty(tail_file, minifi::processors::TailFile::AttributeProviderService, "attribute_provider_service");
-  std::shared_ptr<core::Processor> log_attribute = plan->addProcessor("LogAttribute", "log_attribute", core::Relationship("success", ""), true);
+  auto log_attribute = plan->addProcessor("LogAttribute", "log_attribute", core::Relationship("success", ""), true);
   plan->setProperty(log_attribute, minifi::processors::LogAttribute::FlowFilesToLog, "0");
 
   createTempFile(temp_directory / "my_red_apple_001" / "dog", "0.log", "Idared\n");
@@ -1829,8 +1829,8 @@ TEST_CASE("TailFile can use an AttributeProviderService", "[AttributeProviderSer
 TEST_CASE("TailFile honors batch size for maximum lines processed", "[batchSize]") {
   LogTestController::getInstance().setTrace<minifi::processors::TailFile>();
 
-  auto tailfile = std::make_shared<minifi::processors::TailFile>("TailFile");
-  minifi::test::SingleProcessorTestController test_controller(tailfile);
+  minifi::test::SingleProcessorTestController test_controller(std::make_unique<minifi::processors::TailFile>("TailFile"));
+  auto tailfile = test_controller.getProcessor();
 
   auto temp_file_path  = test_controller.createTempDirectory() / TMP_FILE;
 
diff --git a/extensions/standard-processors/tests/unit/YamlConfigurationTests.cpp b/extensions/standard-processors/tests/unit/YamlConfigurationTests.cpp
index bf444a0cf..e2538662b 100644
--- a/extensions/standard-processors/tests/unit/YamlConfigurationTests.cpp
+++ b/extensions/standard-processors/tests/unit/YamlConfigurationTests.cpp
@@ -1692,7 +1692,7 @@ Parameter Contexts:
     - name: my_value
       description: ''
       sensitive: true
-      value: {}
+      value: {encrypted_parameter_value}
 Processors:
 - id: b0c04f28-0158-1000-0000-000000000000
   name: DummyFlowYamlProcessor
@@ -1703,9 +1703,9 @@ Processors:
   auto-terminated relationships list: [success]
   Properties:
     Simple Property: simple
-    Sensitive Property: {}
+    Sensitive Property: {encrypted_sensitive_property_value}
 Parameter Context Name: my-context
-      )", encrypted_parameter_value, encrypted_sensitive_property_value);
+      )", fmt::arg("encrypted_parameter_value", encrypted_parameter_value), fmt::arg("encrypted_sensitive_property_value", encrypted_sensitive_property_value));
 
   std::unique_ptr<core::ProcessGroup> flow = yaml_config.getRootFromPayload(TEST_CONFIG_YAML);
   REQUIRE(flow);
@@ -1737,11 +1737,11 @@ Parameter Contexts:
     - name: my_value_1
       description: ''
       sensitive: true
-      value: {}
+      value: {encrypted_parameter_value_1}
     - name: my_value_2
       description: ''
       sensitive: true
-      value: {}
+      value: {encrypted_parameter_value_2}
 Processors:
 - id: b0c04f28-0158-1000-0000-000000000000
   name: DummyFlowYamlProcessor
@@ -1753,10 +1753,11 @@ Processors:
   Properties:
     Simple Property: simple
     Sensitive Property:
-    - value: {}
-    - value: {}
+    - value: {encrypted_sensitive_property_value_1}
+    - value: {encrypted_sensitive_property_value_2}
 Parameter Context Name: my-context
-      )", encrypted_parameter_value_1, encrypted_parameter_value_2, encrypted_sensitive_property_value_1, encrypted_sensitive_property_value_2);
+      )", fmt::arg("encrypted_parameter_value_1", encrypted_parameter_value_1), fmt::arg("encrypted_parameter_value_2", encrypted_parameter_value_2),
+          fmt::arg("encrypted_sensitive_property_value_1", encrypted_sensitive_property_value_1), fmt::arg("encrypted_sensitive_property_value_2", encrypted_sensitive_property_value_2));
 
   std::unique_ptr<core::ProcessGroup> flow = yaml_config.getRootFromPayload(TEST_CONFIG_YAML);
   REQUIRE(flow);
@@ -1769,4 +1770,110 @@ Parameter Context Name: my-context
   CHECK(values[1] == "value2");
 }
 
+TEST_CASE("Test parameters in controller services", "[YamlConfiguration]") {
+  ConfigurationTestController test_controller;
+  auto context = test_controller.getContext();
+  auto encrypted_parameter_value_1 = minifi::utils::crypto::property_encryption::encrypt("secret1!!1!", *context.sensitive_values_encryptor);
+  auto encrypted_sensitive_property_value_1 = minifi::utils::crypto::property_encryption::encrypt("#{my_value_1}", *context.sensitive_values_encryptor);
+  core::YamlConfiguration yaml_config(context);
+
+  static const std::string TEST_CONFIG_YAML =
+      fmt::format(R"(
+MiNiFi Config Version: 3
+Flow Controller:
+  name: flowconfig
+Parameter Contexts:
+  - id: 721e10b7-8e00-3188-9a27-476cca376978
+    name: my-context
+    description: my parameter context
+    Parameters:
+    - name: my_value_1
+      description: ''
+      sensitive: true
+      value: {encrypted_parameter_value_1}
+    - name: my_value_2
+      description: ''
+      sensitive: false
+      value: /opt/secrets/private-key.pem
+Processors: []
+Controller Services:
+- id: a00f8722-2419-44ee-929c-ad68644ad557
+  name: SSLContextService
+  type: org.apache.nifi.minifi.controllers.SSLContextService
+  Properties:
+    CA Certificate:
+    Client Certificate:
+    Passphrase: {encrypted_sensitive_property_value_1}
+    Private Key: "#{{my_value_2}}"
+    Use System Cert Store: 'true'
+Parameter Context Name: my-context
+      )", fmt::arg("encrypted_parameter_value_1", encrypted_parameter_value_1), fmt::arg("encrypted_sensitive_property_value_1", encrypted_sensitive_property_value_1));
+
+  std::unique_ptr<core::ProcessGroup> flow = yaml_config.getRootFromPayload(TEST_CONFIG_YAML);
+  REQUIRE(flow);
+  auto* controller = flow->findControllerService("SSLContextService");
+  REQUIRE(controller);
+  auto impl = controller->getControllerServiceImplementation();
+  CHECK(impl->getProperty("Passphrase").value() == "secret1!!1!");
+  CHECK(impl->getProperty("Private Key").value() == "/opt/secrets/private-key.pem");
+}
+
+TEST_CASE("Parameters can be used in controller services in nested process groups", "[YamlConfiguration]") {
+  ConfigurationTestController test_controller;
+  auto context = test_controller.getContext();
+  auto encrypted_parameter_value_1 = minifi::utils::crypto::property_encryption::encrypt("secret1!!1!", *context.sensitive_values_encryptor);
+  auto encrypted_sensitive_property_value_1 = minifi::utils::crypto::property_encryption::encrypt("#{my_value_1}", *context.sensitive_values_encryptor);
+  core::YamlConfiguration yaml_config(context);
+
+  static const std::string TEST_CONFIG_YAML =
+      fmt::format(R"(
+MiNiFi Config Version: 3
+Flow Controller:
+  name: Simple TailFile
+Parameter Contexts:
+  - id: 123e10b7-8e00-3188-9a27-476cca376456
+    name: sub-context
+    description: my sub context
+    Parameters:
+    - name: my_value_1
+      description: ''
+      sensitive: true
+      value: {encrypted_parameter_value_1}
+    - name: my_value_2
+      description: ''
+      sensitive: false
+      value: /opt/secrets/private-key.pem
+Processors: []
+Controller Services: []
+Input Ports: []
+Output Ports: []
+Funnels: []
+Connections: []
+Process Groups:
+  - id: 2a3aaf32-8574-4fa7-b720-84001f8dde43
+    name: Sub process group
+    Processors: []
+    Controller Services:
+    - id: a00f8722-2419-44ee-929c-ad68644ad557
+      name: SSLContextService
+      type: org.apache.nifi.minifi.controllers.SSLContextService
+      Properties:
+        CA Certificate:
+        Client Certificate:
+        Passphrase: {encrypted_sensitive_property_value_1}
+        Private Key: "#{{my_value_2}}"
+        Use System Cert Store: 'true'
+    Parameter Context Name: sub-context
+      )", fmt::arg("encrypted_parameter_value_1", encrypted_parameter_value_1), fmt::arg("encrypted_sensitive_property_value_1", encrypted_sensitive_property_value_1));
+
+  std::unique_ptr<core::ProcessGroup> flow = yaml_config.getRootFromPayload(TEST_CONFIG_YAML);
+  REQUIRE(flow);
+  auto* controller = flow->findControllerService("SSLContextService", core::ProcessGroup::Traverse::IncludeChildren);
+  REQUIRE(controller);
+  auto impl = controller->getControllerServiceImplementation();
+  REQUIRE(impl);
+  CHECK(impl->getProperty("Passphrase").value() == "secret1!!1!");
+  CHECK(impl->getProperty("Private Key").value() == "/opt/secrets/private-key.pem");
+}
+
 }  // namespace org::apache::nifi::minifi::test
diff --git a/extensions/systemd/tests/ConsumeJournaldTest.cpp b/extensions/systemd/tests/ConsumeJournaldTest.cpp
index b612a281f..3014f6431 100644
--- a/extensions/systemd/tests/ConsumeJournaldTest.cpp
+++ b/extensions/systemd/tests/ConsumeJournaldTest.cpp
@@ -160,7 +160,7 @@ TEST_CASE("ConsumeJournald", "[consumejournald]") {
       {"systemd", "Starting Rule-based Manager for Device Events and Files...", 1},
   }});
   auto* const libwrapper_observer = libwrapper.get();
-  const auto consume_journald = plan->addProcessor(std::make_shared<ConsumeJournald>("ConsumeJournald", utils::Identifier{},
+  const auto consume_journald = plan->addProcessor(std::make_unique<ConsumeJournald>("ConsumeJournald", utils::Identifier{},
       std::move(libwrapper)), "ConsumeJournald");
   REQUIRE(consume_journald->setProperty(ConsumeJournald::TimestampFormat, "ISO8601"));
   const auto get_cursor_position = [&consume_journald]() -> std::string {
diff --git a/libminifi/include/core/ProcessContext.h b/libminifi/include/core/ProcessContext.h
index 9a82a70ca..e1189e574 100644
--- a/libminifi/include/core/ProcessContext.h
+++ b/libminifi/include/core/ProcessContext.h
@@ -52,7 +52,7 @@ template<typename T>
 concept NotAFlowFile = !std::convertible_to<T &, const FlowFile &> && !std::convertible_to<T &, const std::shared_ptr<FlowFile> &>;
 }  // namespace detail
 
-class ProcessContext : public controller::ControllerServiceLookup, public core::VariableRegistry, public std::enable_shared_from_this<VariableRegistry> {
+class ProcessContext : public core::VariableRegistry, public std::enable_shared_from_this<VariableRegistry> {
  public:
   /*!
    * Create a new process context associated with the processor/controller service/state manager
@@ -193,46 +193,8 @@ class ProcessContext : public controller::ControllerServiceLookup, public core::
   ProcessContext(const ProcessContext &parent) = delete;
   ProcessContext &operator=(const ProcessContext &parent) = delete;
 
-  // controller services
-
-  /**
-   * @param identifier of controller service
-   * @return the ControllerService that is registered with the given
-   * identifier
-   */
-  std::shared_ptr<core::controller::ControllerService> getControllerService(const std::string &identifier) const override {
-    return controller_service_provider_ == nullptr ? nullptr : controller_service_provider_->getControllerService(identifier);
-  }
-
-  /**
-   * @param identifier identifier of service to check
-   * @return <code>true</code> if the Controller Service with the given
-   * identifier is enabled, <code>false</code> otherwise. If the given
-   * identifier is not known by this ControllerServiceLookup, returns
-   * <code>false</code>
-   */
-  bool isControllerServiceEnabled(const std::string &identifier) override {
-    return controller_service_provider_->isControllerServiceEnabled(identifier);
-  }
-
-  /**
-   * @param identifier identifier of service to check
-   * @return <code>true</code> if the Controller Service with the given
-   * identifier has been enabled but is still in the transitioning state,
-   * otherwise returns <code>false</code>. If the given identifier is not
-   * known by this ControllerServiceLookup, returns <code>false</code>
-   */
-  bool isControllerServiceEnabling(const std::string &identifier) override {
-    return controller_service_provider_->isControllerServiceEnabling(identifier);
-  }
-
-  /**
-   * @param identifier identifier to look up
-   * @return the name of the Controller service with the given identifier. If
-   * no service can be found with this identifier, returns {@code null}
-   */
-  const std::string getControllerServiceName(const std::string &identifier) const override {
-    return controller_service_provider_->getControllerServiceName(identifier);
+  std::shared_ptr<core::controller::ControllerService> getControllerService(const std::string &identifier, const utils::Identifier &processor_uuid) const {
+    return controller_service_provider_ == nullptr ? nullptr : controller_service_provider_->getControllerService(identifier, processor_uuid);
   }
 
   void initializeContentRepository(const std::string& home) {
diff --git a/libminifi/include/core/ProcessGroup.h b/libminifi/include/core/ProcessGroup.h
index 3acca6741..8f64ec278 100644
--- a/libminifi/include/core/ProcessGroup.h
+++ b/libminifi/include/core/ProcessGroup.h
@@ -199,7 +199,7 @@ class ProcessGroup : public CoreComponent {
    */
   void addControllerService(const std::string &nodeId, const std::shared_ptr<core::controller::ControllerServiceNode> &node);
 
-  core::controller::ControllerServiceNode* findControllerService(const std::string &nodeId) const;
+  core::controller::ControllerServiceNode* findControllerService(const std::string &nodeId, Traverse traverse = Traverse::ExcludeChildren) const;
 
   std::vector<const core::controller::ControllerServiceNode*> getAllControllerServices() const;
 
@@ -221,6 +221,10 @@ class ProcessGroup : public CoreComponent {
   void setParameterContext(ParameterContext* parameter_context);
   ParameterContext* getParameterContext() const;
 
+  const std::set<std::unique_ptr<ProcessGroup>>& getChildProcessGroups() const {
+    return child_process_groups_;
+  }
+
  protected:
   void startProcessingProcessors(TimerDrivenSchedulingAgent& timeScheduler, EventDrivenSchedulingAgent& eventScheduler, CronDrivenSchedulingAgent& cronScheduler);
 
diff --git a/libminifi/include/core/controller/ControllerServiceLookup.h b/libminifi/include/core/controller/ControllerServiceLookup.h
index 54907f60c..b84da3260 100644
--- a/libminifi/include/core/controller/ControllerServiceLookup.h
+++ b/libminifi/include/core/controller/ControllerServiceLookup.h
@@ -52,6 +52,14 @@ class ControllerServiceLookup {
    */
   virtual std::shared_ptr<ControllerService> getControllerService(const std::string &identifier) const = 0;
 
+  /**
+   * Gets the controller service in the scope of the processor via the provided identifier.
+   * @param identifier reference string for controller service.
+   * @param processor_uuid uuid of the processor
+   * @return controller service reference.
+   */
+  virtual std::shared_ptr<ControllerService> getControllerService(const std::string &identifier, const utils::Identifier &processor_uuid) const = 0;
+
   /**
    * Detects if controller service is enabled.
    * @param identifier reference string for controller service.
diff --git a/libminifi/include/core/controller/ControllerServiceNodeMap.h b/libminifi/include/core/controller/ControllerServiceNodeMap.h
index cfe5353d4..5d085ab14 100644
--- a/libminifi/include/core/controller/ControllerServiceNodeMap.h
+++ b/libminifi/include/core/controller/ControllerServiceNodeMap.h
@@ -25,7 +25,11 @@
 #include "ControllerServiceNode.h"
 #include "io/validation.h"
 
-namespace org::apache::nifi::minifi::core::controller {
+namespace org::apache::nifi::minifi::core {
+
+class ProcessGroup;
+
+namespace controller {
 
 class ControllerServiceNodeMap {
  public:
@@ -36,44 +40,20 @@ class ControllerServiceNodeMap {
   ControllerServiceNodeMap(ControllerServiceNodeMap&&) = delete;
   ControllerServiceNodeMap& operator=(ControllerServiceNodeMap&&) = delete;
 
-  ControllerServiceNode* get(const std::string &id) const {
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto exists = controller_service_nodes_.find(id);
-    if (exists != controller_service_nodes_.end())
-      return exists->second.get();
-    else
-      return nullptr;
-  }
-
-  bool put(const std::string &id, const std::shared_ptr<ControllerServiceNode> &serviceNode) {
-    if (id.empty() || serviceNode == nullptr)
-      return false;
-    std::lock_guard<std::mutex> lock(mutex_);
-    controller_service_nodes_[id] = serviceNode;
-    return true;
-  }
+  ControllerServiceNode* get(const std::string &id) const;
+  ControllerServiceNode* get(const std::string &id, const utils::Identifier &processor_uuid) const;
 
-  void clear() {
-    std::lock_guard<std::mutex> lock(mutex_);
-    for (const auto& [id, node] : controller_service_nodes_) {
-      node->disable();
-    }
-    controller_service_nodes_.clear();
-  }
+  bool put(const std::string &id, const std::shared_ptr<ControllerServiceNode> &serviceNode);
+  bool put(const std::string &id, ProcessGroup* process_group);
 
-  std::vector<std::shared_ptr<ControllerServiceNode>> getAllControllerServices() const {
-    std::lock_guard<std::mutex> lock(mutex_);
-    std::vector<std::shared_ptr<ControllerServiceNode>> services;
-    services.reserve(controller_service_nodes_.size());
-    for (const auto& [id, node] : controller_service_nodes_) {
-      services.push_back(node);
-    }
-    return services;
-  }
+  void clear();
+  std::vector<std::shared_ptr<ControllerServiceNode>> getAllControllerServices() const;
 
  protected:
   mutable std::mutex mutex_;
   std::map<std::string, std::shared_ptr<ControllerServiceNode>> controller_service_nodes_;
+  std::map<std::string, gsl::not_null<ProcessGroup*>> process_groups_;
 };
 
-}  // namespace org::apache::nifi::minifi::core::controller
+}  // namespace controller
+}  // namespace org::apache::nifi::minifi::core
diff --git a/libminifi/include/core/controller/ControllerServiceProvider.h b/libminifi/include/core/controller/ControllerServiceProvider.h
index d50ea5b90..ba9c001c6 100644
--- a/libminifi/include/core/controller/ControllerServiceProvider.h
+++ b/libminifi/include/core/controller/ControllerServiceProvider.h
@@ -66,6 +66,10 @@ class ControllerServiceProvider : public CoreComponent, public ConfigurableCompo
     return controller_map_->get(id);
   }
 
+  virtual ControllerServiceNode* getControllerServiceNode(const std::string &id, const utils::Identifier &controller_uuid) const {
+    return controller_map_->get(id, controller_uuid);
+  }
+
   virtual void clearControllerServices() = 0;
 
   virtual std::vector<std::shared_ptr<core::controller::ControllerServiceNode>> getAllControllerServices() {
@@ -73,8 +77,9 @@ class ControllerServiceProvider : public CoreComponent, public ConfigurableCompo
   }
 
   std::shared_ptr<ControllerService> getControllerService(const std::string &identifier) const override;
+  std::shared_ptr<ControllerService> getControllerService(const std::string &identifier, const utils::Identifier &processor_uuid) const override;
 
-  void putControllerServiceNode(const std::string& identifier, const std::shared_ptr<ControllerServiceNode>& controller_service_node);
+  void putControllerServiceNode(const std::string& identifier, const std::shared_ptr<ControllerServiceNode>& controller_service_node, ProcessGroup* process_group);
 
   bool isControllerServiceEnabled(const std::string &identifier) override {
     const ControllerServiceNode* const node = getControllerServiceNode(identifier);
diff --git a/libminifi/include/core/controller/ForwardingControllerServiceProvider.h b/libminifi/include/core/controller/ForwardingControllerServiceProvider.h
index 9f576fd09..ffa5cb3a1 100644
--- a/libminifi/include/core/controller/ForwardingControllerServiceProvider.h
+++ b/libminifi/include/core/controller/ForwardingControllerServiceProvider.h
@@ -39,6 +39,10 @@ class ForwardingControllerServiceProvider : public ControllerServiceProvider {
     return controller_service_provider_impl_->getControllerServiceNode(id);
   }
 
+  ControllerServiceNode* getControllerServiceNode(const std::string &id, const utils::Identifier &controller_uuid) const override {
+    return controller_service_provider_impl_->getControllerServiceNode(id, controller_uuid);
+  }
+
   void clearControllerServices() override {
     return controller_service_provider_impl_->clearControllerServices();
   }
@@ -47,6 +51,10 @@ class ForwardingControllerServiceProvider : public ControllerServiceProvider {
     return controller_service_provider_impl_->getControllerService(identifier);
   }
 
+  std::shared_ptr<ControllerService> getControllerService(const std::string &identifier, const utils::Identifier &processor_uuid) const override {
+    return controller_service_provider_impl_->getControllerService(identifier, processor_uuid);
+  }
+
   std::vector<std::shared_ptr<core::controller::ControllerServiceNode>> getAllControllerServices() override {
     return controller_service_provider_impl_->getAllControllerServices();
   }
diff --git a/libminifi/include/core/flow/StructuredConfiguration.h b/libminifi/include/core/flow/StructuredConfiguration.h
index c87d3af68..23cbf2847 100644
--- a/libminifi/include/core/flow/StructuredConfiguration.h
+++ b/libminifi/include/core/flow/StructuredConfiguration.h
@@ -109,7 +109,7 @@ class StructuredConfiguration : public FlowConfiguration {
   std::unique_ptr<core::ProcessGroup> parseRootProcessGroup(const Node& root_flow_node);
 
   void parseParameterContexts(const Node& parameter_contexts_node);
-  void parseControllerServices(const Node& controller_services_node);
+  void parseControllerServices(const Node& controller_services_node, core::ProcessGroup* parent_group);
 
   /**
    * Parses the Connections section of a configuration.
diff --git a/libminifi/src/RemoteProcessorGroupPort.cpp b/libminifi/src/RemoteProcessorGroupPort.cpp
index 73e6d4123..8b395385a 100644
--- a/libminifi/src/RemoteProcessorGroupPort.cpp
+++ b/libminifi/src/RemoteProcessorGroupPort.cpp
@@ -118,7 +118,7 @@ void RemoteProcessorGroupPort::onSchedule(core::ProcessContext& context, core::P
   if (!context.getProperty(SSLContext, context_name) || IsNullOrEmpty(context_name)) {
     context_name = RPG_SSL_CONTEXT_SERVICE_NAME;
   }
-  std::shared_ptr<core::controller::ControllerService> service = context.getControllerService(context_name);
+  std::shared_ptr<core::controller::ControllerService> service = context.getControllerService(context_name, getUUID());
   if (nullptr != service) {
     ssl_service = std::static_pointer_cast<minifi::controllers::SSLContextService>(service);
   } else {
diff --git a/libminifi/src/core/ProcessGroup.cpp b/libminifi/src/core/ProcessGroup.cpp
index 7f8fe1d27..5ed330548 100644
--- a/libminifi/src/core/ProcessGroup.cpp
+++ b/libminifi/src/core/ProcessGroup.cpp
@@ -115,11 +115,18 @@ void ProcessGroup::addProcessGroup(std::unique_ptr<ProcessGroup> child) {
 
 void ProcessGroup::startProcessingProcessors(TimerDrivenSchedulingAgent& timeScheduler,
     EventDrivenSchedulingAgent& eventScheduler, CronDrivenSchedulingAgent& cronScheduler) {
-  std::unique_lock<std::recursive_mutex> lock(mutex_);
+
+  std::set<Processor*> processors_to_schedule;
+  {
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    for (const auto& processor : failed_processors_) {
+      processors_to_schedule.insert(processor);
+    }
+  }
 
   std::set<Processor*> failed_processors;
 
-  for (const auto processor : failed_processors_) {
+  for (const auto processor : processors_to_schedule) {
     try {
       logger_->log_debug("Starting {}", processor->getName());
       processor->setScheduledState(core::ScheduledState::RUNNING);
@@ -146,9 +153,8 @@ void ProcessGroup::startProcessingProcessors(TimerDrivenSchedulingAgent& timeSch
       failed_processors.insert(processor);
     }
   }
-  failed_processors_ = std::move(failed_processors);
 
-  for (const auto processor : failed_processors_) {
+  for (const auto processor : failed_processors) {
     try {
       processor->onUnSchedule();
     } catch (const std::exception& ex) {
@@ -160,26 +166,32 @@ void ProcessGroup::startProcessingProcessors(TimerDrivenSchedulingAgent& timeSch
 
   // The admin yield duration comes from the configuration, should be equal in all three schedulers
   std::chrono::milliseconds admin_yield_duration = timeScheduler.getAdminYieldDuration();
-  if (!onScheduleTimer_ && !failed_processors_.empty() && admin_yield_duration > 0ms) {
+  if (!onScheduleTimer_ && !failed_processors.empty() && admin_yield_duration > 0ms) {
     logger_->log_info("Retrying failed processors in {}", admin_yield_duration);
     auto func = [this, eventScheduler = &eventScheduler, cronScheduler = &cronScheduler, timeScheduler = &timeScheduler]() {
       this->startProcessingProcessors(*timeScheduler, *eventScheduler, *cronScheduler);
     };
     onScheduleTimer_ = std::make_unique<utils::CallBackTimer>(admin_yield_duration, func);
     onScheduleTimer_->start();
-  } else if (failed_processors_.empty() && onScheduleTimer_) {
+  } else if (failed_processors.empty() && onScheduleTimer_) {
     onScheduleTimer_->stop();
   }
+
+  {
+    std::unique_lock<std::recursive_mutex> lock(mutex_);
+    failed_processors_ = std::move(failed_processors);
+  }
 }
 
 void ProcessGroup::startProcessing(TimerDrivenSchedulingAgent& timeScheduler, EventDrivenSchedulingAgent& eventScheduler,
                                    CronDrivenSchedulingAgent& cronScheduler) {
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
   try {
     // All processors are marked as failed.
-    for (auto& processor : processors_) {
-      failed_processors_.insert(processor.get());
+    {
+      std::lock_guard<std::recursive_mutex> lock(mutex_);
+      for (auto& processor : processors_) {
+        failed_processors_.insert(processor.get());
+      }
     }
 
     // Start all the processor node, input and output ports
@@ -200,7 +212,13 @@ void ProcessGroup::startProcessing(TimerDrivenSchedulingAgent& timeScheduler, Ev
 
 void ProcessGroup::stopProcessing(TimerDrivenSchedulingAgent& timeScheduler, EventDrivenSchedulingAgent& eventScheduler,
                                   CronDrivenSchedulingAgent& cronScheduler, const std::function<bool(const Processor*)>& filter) {
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
+  std::set<Processor*> processors;
+  {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    for (const auto &processor : processors_) {
+      processors.insert(processor.get());
+    }
+  }
 
   if (onScheduleTimer_) {
     onScheduleTimer_->stop();
@@ -210,20 +228,20 @@ void ProcessGroup::stopProcessing(TimerDrivenSchedulingAgent& timeScheduler, Eve
 
   try {
     // Stop all the processor node, input and output ports
-    for (const auto &processor : processors_) {
-      if (filter && !filter(processor.get())) {
+    for (const auto &processor : processors) {
+      if (filter && !filter(processor)) {
         continue;
       }
       logger_->log_debug("Stopping {}", processor->getName());
       switch (processor->getSchedulingStrategy()) {
         case TIMER_DRIVEN:
-          timeScheduler.unschedule(processor.get());
+          timeScheduler.unschedule(processor);
           break;
         case EVENT_DRIVEN:
-          eventScheduler.unschedule(processor.get());
+          eventScheduler.unschedule(processor);
           break;
         case CRON_DRIVEN:
-          cronScheduler.unschedule(processor.get());
+          cronScheduler.unschedule(processor);
           break;
       }
     }
@@ -261,8 +279,18 @@ void ProcessGroup::addControllerService(const std::string &nodeId, const std::sh
   controller_service_map_.put(nodeId, node);
 }
 
-core::controller::ControllerServiceNode* ProcessGroup::findControllerService(const std::string &nodeId) const {
-  return controller_service_map_.get(nodeId);
+core::controller::ControllerServiceNode* ProcessGroup::findControllerService(const std::string &nodeId, Traverse traverse) const {
+  if (auto result = controller_service_map_.get(nodeId)) {
+    return result;
+  }
+  if (traverse == Traverse::IncludeChildren) {
+    for (const auto& processGroup : child_process_groups_) {
+      if (auto controllerService = processGroup->findControllerService(nodeId, traverse)) {
+        return controllerService;
+      }
+    }
+  }
+  return nullptr;
 }
 
 std::vector<const core::controller::ControllerServiceNode*> ProcessGroup::getAllControllerServices() const {
diff --git a/libminifi/src/core/controller/ControllerServiceNodeMap.cpp b/libminifi/src/core/controller/ControllerServiceNodeMap.cpp
new file mode 100644
index 000000000..ccab6581d
--- /dev/null
+++ b/libminifi/src/core/controller/ControllerServiceNodeMap.cpp
@@ -0,0 +1,96 @@
+/**
+ *
+ * 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 "core/controller/ControllerServiceNodeMap.h"
+#include "core/ProcessGroup.h"
+
+namespace org::apache::nifi::minifi::core::controller {
+
+ControllerServiceNode* ControllerServiceNodeMap::get(const std::string &id) const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  auto exists = controller_service_nodes_.find(id);
+  if (exists != controller_service_nodes_.end())
+    return exists->second.get();
+  else
+    return nullptr;
+}
+
+ControllerServiceNode* ControllerServiceNodeMap::get(const std::string &id, const utils::Identifier& processor_uuid) const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  ControllerServiceNode* controller = nullptr;
+  auto exists = controller_service_nodes_.find(id);
+  if (exists != controller_service_nodes_.end()) {
+    controller = exists->second.get();
+  } else {
+    return nullptr;
+  }
+
+  auto process_group_of_controller_exists = process_groups_.find(id);
+  ProcessGroup* process_group = nullptr;
+  if (process_group_of_controller_exists != process_groups_.end()) {
+    process_group = process_group_of_controller_exists->second;
+  } else {
+    return nullptr;
+  }
+
+  if (process_group->findProcessorById(processor_uuid)) {
+    return controller;
+  }
+
+  if (process_group->findControllerService(processor_uuid.to_string(), ProcessGroup::Traverse::IncludeChildren)) {
+    return controller;
+  }
+
+  return nullptr;
+}
+
+bool ControllerServiceNodeMap::put(const std::string &id, const std::shared_ptr<ControllerServiceNode> &serviceNode) {
+  if (id.empty() || serviceNode == nullptr)
+    return false;
+  std::lock_guard<std::mutex> lock(mutex_);
+  controller_service_nodes_[id] = serviceNode;
+  return true;
+}
+
+bool ControllerServiceNodeMap::put(const std::string &id, ProcessGroup* process_group) {
+  if (id.empty() || process_group == nullptr)
+    return false;
+  std::lock_guard<std::mutex> lock(mutex_);
+  process_groups_.emplace(id, gsl::make_not_null(process_group));
+  return true;
+}
+
+void ControllerServiceNodeMap::clear() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  for (const auto& [id, node] : controller_service_nodes_) {
+    node->disable();
+  }
+  controller_service_nodes_.clear();
+}
+
+std::vector<std::shared_ptr<ControllerServiceNode>> ControllerServiceNodeMap::getAllControllerServices() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  std::vector<std::shared_ptr<ControllerServiceNode>> services;
+  services.reserve(controller_service_nodes_.size());
+  for (const auto& [id, node] : controller_service_nodes_) {
+    services.push_back(node);
+  }
+  return services;
+}
+
+}  // namespace org::apache::nifi::minifi::core::controller
diff --git a/libminifi/src/core/controller/ControllerServiceProvider.cpp b/libminifi/src/core/controller/ControllerServiceProvider.cpp
index 919a7b6c9..ae783a6d0 100644
--- a/libminifi/src/core/controller/ControllerServiceProvider.cpp
+++ b/libminifi/src/core/controller/ControllerServiceProvider.cpp
@@ -34,9 +34,19 @@ std::shared_ptr<ControllerService> ControllerServiceProvider::getControllerServi
   }
 }
 
-void ControllerServiceProvider::putControllerServiceNode(const std::string& identifier, const std::shared_ptr<ControllerServiceNode>& controller_service_node) {
+std::shared_ptr<ControllerService> ControllerServiceProvider::getControllerService(const std::string &identifier, const utils::Identifier &processor_uuid) const {
+  auto service = controller_map_->get(identifier, processor_uuid);
+  if (service != nullptr) {
+    return service->getControllerServiceImplementation();
+  } else {
+    return nullptr;
+  }
+}
+
+void ControllerServiceProvider::putControllerServiceNode(const std::string& identifier, const std::shared_ptr<ControllerServiceNode>& controller_service_node, ProcessGroup* process_group) {
   gsl_Expects(controller_map_);
   controller_map_->put(identifier, controller_service_node);
+  controller_map_->put(identifier, process_group);
 }
 
 }  // namespace org::apache::nifi::minifi::core::controller
diff --git a/libminifi/src/core/controller/StandardControllerServiceNode.cpp b/libminifi/src/core/controller/StandardControllerServiceNode.cpp
index 653b792fb..6bc423b15 100644
--- a/libminifi/src/core/controller/StandardControllerServiceNode.cpp
+++ b/libminifi/src/core/controller/StandardControllerServiceNode.cpp
@@ -29,7 +29,7 @@ bool StandardControllerServiceNode::enable() {
   if (getProperty(property.getName(), property)) {
     active = true;
     for (const auto& linked_service : property.getValues()) {
-      ControllerServiceNode* csNode = provider->getControllerServiceNode(linked_service);
+      ControllerServiceNode* csNode = provider->getControllerServiceNode(linked_service, controller_service_->getUUID());
       if (nullptr != csNode) {
         std::lock_guard<std::mutex> lock(mutex_);
         linked_controller_services_.push_back(csNode);
diff --git a/libminifi/src/core/flow/StructuredConfiguration.cpp b/libminifi/src/core/flow/StructuredConfiguration.cpp
index 954efb394..d79550b46 100644
--- a/libminifi/src/core/flow/StructuredConfiguration.cpp
+++ b/libminifi/src/core/flow/StructuredConfiguration.cpp
@@ -97,8 +97,10 @@ std::unique_ptr<core::ProcessGroup> StructuredConfiguration::parseProcessGroup(c
   Node remoteProcessingGroupsNode = node[schema_.remote_process_group];
   Node childProcessGroupNodeSeq = node[schema_.process_groups];
   Node parameterContextNameNode = node[schema_.parameter_context_name];
+  Node controllerServiceNode = node[schema_.controller_services];
 
   parseParameterContext(parameterContextNameNode, *group);
+  parseControllerServices(controllerServiceNode, group.get());
   parseProcessorNode(processorsNode, group.get());
   parseRemoteProcessGroup(remoteProcessingGroupsNode, group.get());
   parseFunnels(funnelsNode, group.get());
@@ -121,21 +123,13 @@ std::unique_ptr<core::ProcessGroup> StructuredConfiguration::getRootFrom(const N
     schema_ = std::move(schema);
     uuids_.clear();
     Node parameterContextsNode = root_node[schema_.parameter_contexts];
-    Node controllerServiceNode = root_node[schema_.root_group][schema_.controller_services];
     Node provenanceReportNode = root_node[schema_.provenance_reporting];
 
     parseParameterContexts(parameterContextsNode);
-    parseControllerServices(controllerServiceNode);
     // Create the root process group
     std::unique_ptr<core::ProcessGroup> root = parseRootProcessGroup(root_node);
     parseProvenanceReporting(provenanceReportNode, root.get());
 
-    // set the controller services into the root group.
-    for (const auto& controller_service : service_provider_->getAllControllerServices()) {
-      root->addControllerService(controller_service->getName(), controller_service);
-      root->addControllerService(controller_service->getUUIDStr(), controller_service);
-    }
-
     root->verify();
 
     return root;
@@ -518,7 +512,7 @@ void StructuredConfiguration::parseProvenanceReporting(const Node& node, core::P
   parent_group->addProcessor(std::move(reportTask));
 }
 
-void StructuredConfiguration::parseControllerServices(const Node& controller_services_node) {
+void StructuredConfiguration::parseControllerServices(const Node& controller_services_node, core::ProcessGroup* parent_group) {
   if (!controller_services_node || !controller_services_node.isSequence()) {
     return;
   }
@@ -546,16 +540,20 @@ void StructuredConfiguration::parseControllerServices(const Node& controller_ser
       controller_service_node->initialize();
       if (Node propertiesNode = service_node[schema_.controller_service_properties]) {
         // we should propagate properties to the node and to the implementation
-        parsePropertiesNode(propertiesNode, *controller_service_node, name, nullptr);
+        parsePropertiesNode(propertiesNode, *controller_service_node, name, parent_group->getParameterContext());
         if (auto controllerServiceImpl = controller_service_node->getControllerServiceImplementation(); controllerServiceImpl) {
-          parsePropertiesNode(propertiesNode, *controllerServiceImpl, name, nullptr);
+          parsePropertiesNode(propertiesNode, *controllerServiceImpl, name, parent_group->getParameterContext());
         }
       }
+
+      service_provider_->putControllerServiceNode(id, controller_service_node, parent_group);
+      service_provider_->putControllerServiceNode(name, controller_service_node, parent_group);
+
+      parent_group->addControllerService(controller_service_node->getName(), controller_service_node);
+      parent_group->addControllerService(controller_service_node->getUUIDStr(), controller_service_node);
     } else {
       logger_->log_debug("Could not locate {}", type);
     }
-    service_provider_->putControllerServiceNode(id, controller_service_node);
-    service_provider_->putControllerServiceNode(name, controller_service_node);
   }
 }
 
diff --git a/libminifi/src/utils/net/Ssl.cpp b/libminifi/src/utils/net/Ssl.cpp
index 28d875c5a..865dcb1e2 100644
--- a/libminifi/src/utils/net/Ssl.cpp
+++ b/libminifi/src/utils/net/Ssl.cpp
@@ -22,7 +22,7 @@ namespace org::apache::nifi::minifi::utils::net {
 std::optional<utils::net::SslData> getSslData(const core::ProcessContext& context, const core::PropertyReference& ssl_prop, const std::shared_ptr<core::logging::Logger>& logger) {
   auto getSslContextService = [&]() -> std::shared_ptr<minifi::controllers::SSLContextService> {
     if (auto ssl_service_name = context.getProperty(ssl_prop); ssl_service_name && !ssl_service_name->empty()) {
-      if (auto service = context.getControllerService(*ssl_service_name)) {
+      if (auto service = context.getControllerService(*ssl_service_name, context.getProcessorNode()->getUUID())) {
         if (auto ssl_service = std::dynamic_pointer_cast<org::apache::nifi::minifi::controllers::SSLContextService>(service)) {
           return ssl_service;
         } else {
diff --git a/libminifi/test/integration/ControllerServiceIntegrationTests.cpp b/libminifi/test/integration/ControllerServiceIntegrationTests.cpp
index d60991e1f..91b2bca49 100644
--- a/libminifi/test/integration/ControllerServiceIntegrationTests.cpp
+++ b/libminifi/test/integration/ControllerServiceIntegrationTests.cpp
@@ -77,8 +77,6 @@ TEST_CASE("ControllerServiceIntegrationTests", "[controller]") {
   });
   const auto controller = std::make_shared<minifi::FlowController>(test_repo, test_flow_repo, configuration, std::move(yaml_ptr), content_repo);
 
-  disabled = false;
-
   core::YamlConfiguration yaml_config(core::ConfigurationContext{
       .flow_file_repo = test_repo,
       .content_repo = content_repo,
@@ -89,13 +87,22 @@ TEST_CASE("ControllerServiceIntegrationTests", "[controller]") {
   });
   auto pg = yaml_config.getRoot();
 
-  auto provider = std::make_shared<core::controller::StandardControllerServiceProvider>(std::make_unique<core::controller::ControllerServiceNodeMap>(), std::make_shared<minifi::Configure>());
   auto* mockNode = pg->findControllerService("MockItLikeIts1995");
   REQUIRE(mockNode != nullptr);
   mockNode->enable();
   std::vector<core::controller::ControllerServiceNode*> linkedNodes = mockNode->getLinkedControllerServices();
   REQUIRE(linkedNodes.size() == 1);
 
+  auto* notInProcessGroup = pg->findControllerService("SubMockController");
+  REQUIRE(notInProcessGroup == nullptr);
+  REQUIRE(pg->getChildProcessGroups().size() == 1);
+  auto* cpg = pg->getChildProcessGroups().begin()->get();
+  auto subMockController = cpg->findControllerService("SubMockController");
+  REQUIRE(subMockController != nullptr);
+  subMockController->enable();
+  std::vector<core::controller::ControllerServiceNode*> subMockControllerLinkedNodes = subMockController->getLinkedControllerServices();
+  REQUIRE(subMockControllerLinkedNodes.size() == 2);
+
   core::controller::ControllerServiceNode* notexistNode = pg->findControllerService("MockItLikeItsWrong");
   REQUIRE(notexistNode == nullptr);
 
@@ -136,6 +143,8 @@ TEST_CASE("ControllerServiceIntegrationTests", "[controller]") {
 //  }
 //  REQUIRE(verifyEventHappenedInPollTime(std::chrono::seconds(2), checkCsIdEnabledMatchesDisabledFlag));
 
+  REQUIRE(verifyEventHappenedInPollTime(10s, [&] { return subprocess_controller_service_not_found_correctly.load(); }));
+  REQUIRE(verifyEventHappenedInPollTime(10s, [&] { return subprocess_controller_service_found_correctly.load(); }));
   controller->waitUnload(60s);
 }
 
diff --git a/libminifi/test/libtest/unit/ContentRepositoryDependentTests.h b/libminifi/test/libtest/unit/ContentRepositoryDependentTests.h
index 24001c3a6..245d645e4 100644
--- a/libminifi/test/libtest/unit/ContentRepositoryDependentTests.h
+++ b/libminifi/test/libtest/unit/ContentRepositoryDependentTests.h
@@ -89,7 +89,7 @@ class Fixture {
   TestController test_controller_;
 
   std::shared_ptr<TestPlan> test_plan_;
-  std::shared_ptr<core::Processor> dummy_processor_;
+  core::Processor* dummy_processor_;
   std::shared_ptr<core::ProcessContext> context_;
   std::unique_ptr<core::ProcessSession> process_session_;
 };
diff --git a/libminifi/test/libtest/unit/MockClasses.h b/libminifi/test/libtest/unit/MockClasses.h
index 54af4c46a..846dce554 100644
--- a/libminifi/test/libtest/unit/MockClasses.h
+++ b/libminifi/test/libtest/unit/MockClasses.h
@@ -31,8 +31,9 @@
 
 namespace minifi = org::apache::nifi::minifi;
 
-std::atomic<bool> disabled;
 std::mutex control_mutex;
+std::atomic<bool> subprocess_controller_service_found_correctly{false};
+std::atomic<bool> subprocess_controller_service_not_found_correctly{false};
 
 class MockControllerService : public minifi::core::controller::ControllerService {
  public:
@@ -96,8 +97,14 @@ class MockProcessor : public minifi::core::Processor {
 
   static constexpr const char* Description = "An example processor";
   static constexpr auto LinkedService = minifi::core::PropertyDefinitionBuilder<>::createProperty("linkedService").withDescription("Linked service").build();
-  static constexpr auto Properties = std::array<minifi::core::PropertyReference, 1>{LinkedService};
-  static constexpr auto Relationships = std::array<minifi::core::RelationshipDefinition, 0>{};
+  static constexpr auto InSubProcessGroup = minifi::core::PropertyDefinitionBuilder<>::createProperty("InSubProcessGroup")
+    .withPropertyType(minifi::core::StandardPropertyTypes::BOOLEAN_TYPE)
+    .withDefaultValue("false")
+    .withDescription("Is in sub process group")
+    .build();
+  static constexpr auto Properties = std::array<minifi::core::PropertyReference, 2>{LinkedService, InSubProcessGroup};
+  static constexpr auto Success = minifi::core::RelationshipDefinition{"success", "FlowFiles are routed to success relationship"};
+  static constexpr auto Relationships = std::array<minifi::core::RelationshipDefinition, 1>{Success};
   static constexpr bool SupportsDynamicProperties = false;
   static constexpr bool SupportsDynamicRelationships = false;
   static constexpr minifi::core::annotation::Input InputRequirement = minifi::core::annotation::Input::INPUT_ALLOWED;
@@ -108,22 +115,33 @@ class MockProcessor : public minifi::core::Processor {
     setSupportedProperties(Properties);
   }
 
-  void onTrigger(minifi::core::ProcessContext& context, minifi::core::ProcessSession&) override {
+  void onTrigger(minifi::core::ProcessContext& context, minifi::core::ProcessSession& session) override {
+    auto flow_file = session.get();
+    if (!flow_file) {
+      flow_file = session.create();
+    }
     std::string linked_service;
     getProperty("linkedService", linked_service);
     if (!IsNullOrEmpty(linked_service)) {
-      std::shared_ptr<minifi::core::controller::ControllerService> service = context.getControllerService(linked_service);
+      std::shared_ptr<minifi::core::controller::ControllerService> service = context.getControllerService(linked_service, getUUID());
       std::lock_guard<std::mutex> lock(control_mutex);
-      if (!disabled.load()) {
-        REQUIRE(context.isControllerServiceEnabled(linked_service));
-        REQUIRE(nullptr != service);
-        REQUIRE("pushitrealgood" == std::static_pointer_cast<MockControllerService>(service)->doSomething());
-      } else {
-        REQUIRE_FALSE(context.isControllerServiceEnabled(linked_service));
-      }
+      REQUIRE(nullptr != service);
+      REQUIRE("pushitrealgood" == std::static_pointer_cast<MockControllerService>(service)->doSomething());
       // verify we have access to the controller service
       // and verify that we can execute it.
     }
+
+    bool in_sub_process_group = false;
+    getProperty("InSubProcessGroup", in_sub_process_group);
+    auto sub_service = context.getControllerService("SubMockController", getUUID());
+    if (in_sub_process_group) {
+      REQUIRE(nullptr != sub_service);
+      subprocess_controller_service_found_correctly = true;
+    } else {
+      REQUIRE(nullptr == sub_service);
+      subprocess_controller_service_not_found_correctly = true;
+    }
+    session.transfer(flow_file, Success);
   }
 
   bool isYield() override {
diff --git a/libminifi/test/libtest/unit/RecordSetTesters.h b/libminifi/test/libtest/unit/RecordSetTesters.h
index 52bb91e6f..80b933f27 100644
--- a/libminifi/test/libtest/unit/RecordSetTesters.h
+++ b/libminifi/test/libtest/unit/RecordSetTesters.h
@@ -36,7 +36,7 @@ class RecordSetFixture {
   TestController test_controller_{};
   TestController::PlanConfig plan_config_{};
   std::shared_ptr<TestPlan> test_plan_ = test_controller_.createPlan(plan_config_);
-  std::shared_ptr<Processor> dummy_processor_ = test_plan_->addProcessor("DummyProcessor", "dummyProcessor");
+  Processor* dummy_processor_ = test_plan_->addProcessor("DummyProcessor", "dummyProcessor");
   std::shared_ptr<ProcessContext> context_ = [this] { test_plan_->runNextProcessor(); return test_plan_->getCurrentContext(); }();
   std::unique_ptr<ProcessSession> process_session_ = std::make_unique<ProcessSession>(context_);
 
diff --git a/libminifi/test/libtest/unit/SingleProcessorTestController.h b/libminifi/test/libtest/unit/SingleProcessorTestController.h
index 994544fe4..0245e3314 100644
--- a/libminifi/test/libtest/unit/SingleProcessorTestController.h
+++ b/libminifi/test/libtest/unit/SingleProcessorTestController.h
@@ -37,9 +37,18 @@ using ProcessorTriggerResult = std::unordered_map<core::Relationship, std::vecto
 
 class SingleProcessorTestController : public TestController {
  public:
-  explicit SingleProcessorTestController(const std::shared_ptr<core::Processor>& processor)
-      : processor_{plan->addProcessor(processor, processor->getName())}
-  {}
+  explicit SingleProcessorTestController(std::unique_ptr<core::Processor> processor) {
+    auto name = processor->getName();
+    processor_ = plan->addProcessor(std::move(processor), name);
+    input_ = plan->addConnection(nullptr, core::Relationship{"success", "success"}, processor_);
+    outgoing_connections_ = [this] {
+      std::unordered_map<core::Relationship, Connection*> result;
+      for (const auto& relationship: processor_->getSupportedRelationships()) {
+        result.insert_or_assign(relationship, plan->addConnection(processor_, relationship, nullptr));
+      }
+      return result;
+    }();
+  }
 
   ProcessorTriggerResult trigger();
   ProcessorTriggerResult trigger(InputFlowFileData&& input_flow_file_data);
@@ -52,25 +61,17 @@ class SingleProcessorTestController : public TestController {
 
   core::Relationship addDynamicRelationship(std::string name);
 
- private:
-  std::shared_ptr<core::FlowFile> createFlowFile(const std::string_view content, std::unordered_map<std::string, std::string> attributes);
+  template<typename T = core::Processor>
+  T* getProcessor() const { return static_cast<T*>(processor_); }
 
- public:
   std::shared_ptr<TestPlan> plan = createPlan();
 
- protected:
-  core::Processor& getProcessor() const { return *processor_; }
-
  private:
-  std::shared_ptr<core::Processor> processor_;
-  std::unordered_map<core::Relationship, Connection*> outgoing_connections_{[this] {
-    std::unordered_map<core::Relationship, Connection*> result;
-    for (const auto& relationship: processor_->getSupportedRelationships()) {
-      result.insert_or_assign(relationship, plan->addConnection(processor_, relationship, nullptr));
-    }
-    return result;
-  }()};
-  Connection* input_ = plan->addConnection(nullptr, core::Relationship{"success", "success"}, processor_);
+  std::shared_ptr<core::FlowFile> createFlowFile(const std::string_view content, std::unordered_map<std::string, std::string> attributes);
+
+  core::Processor* processor_ = nullptr;
+  std::unordered_map<core::Relationship, Connection*> outgoing_connections_;
+  Connection* input_ = nullptr;
 };
 
 }  // namespace org::apache::nifi::minifi::test
diff --git a/libminifi/test/libtest/unit/TestBase.cpp b/libminifi/test/libtest/unit/TestBase.cpp
index b83c1509c..9ddfdec73 100644
--- a/libminifi/test/libtest/unit/TestBase.cpp
+++ b/libminifi/test/libtest/unit/TestBase.cpp
@@ -37,6 +37,7 @@
 #include "utils/StringUtils.h"
 #include "utils/span.h"
 #include "LogUtils.h"
+#include "utils/GeneralUtils.h"
 
 #include "fmt/format.h"
 #include "spdlog/sinks/stdout_sinks.h"
@@ -213,6 +214,7 @@ TestPlan::TestPlan(std::shared_ptr<minifi::core::ContentRepository> content_repo
       location(-1),
       current_flowfile_(nullptr),
       flow_version_(std::move(flow_version)),
+      root_process_group_(std::make_unique<minifi::core::ProcessGroup>(minifi::core::ROOT_PROCESS_GROUP, "root", minifi::utils::IdGenerator::getIdGenerator()->generate(), 0)),
       logger_(logging::LoggerFactory<TestPlan>::getLogger()) {
   /* Inject the default state storage ahead of ProcessContext to make sure we have a unique state directory */
   if (state_dir == nullptr) {
@@ -238,7 +240,7 @@ TestPlan::~TestPlan() {
   controller_services_provider_->clearControllerServices();
 }
 
-std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::shared_ptr<minifi::core::Processor> &processor, const std::string& /*name*/,
+minifi::core::Processor* TestPlan::addProcessor(std::unique_ptr<minifi::core::Processor> processor, const std::string& /*name*/,
     const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious) {
   if (finalized) {
     return nullptr;
@@ -247,15 +249,15 @@ std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::share
   // initialize the processor
   processor->initialize();
   processor->setFlowIdentifier(flow_version_->getFlowIdentifier());
-  processor_mapping_[processor->getUUID()] = processor;
+  processor_mapping_[processor->getUUID()] = processor.get();
   if (!linkToPrevious) {
     if (!std::empty(relationships)) {
       termination_ = *(relationships.begin());
     }
   } else {
-    std::shared_ptr<minifi::core::Processor> last = processor_queue_.back();
+    auto last = processor_queue_.back();
     if (last == nullptr) {
-      last = processor;
+      last = processor.get();
       if (!std::empty(relationships)) {
         termination_ = *(relationships.begin());
       }
@@ -269,13 +271,13 @@ std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::share
       connection->addRelationship(relationship);
     }
     // link the connections so that we can test results at the end for this
-    connection->setSource(last.get());
+    connection->setSource(last);
     connection->setDestination(processor.get());
 
     connection->setSourceUUID(last->getUUID());
     connection->setDestinationUUID(processor->getUUID());
     last->addConnection(connection.get());
-    if (last != processor) {
+    if (last != processor.get()) {
       processor->addConnection(connection.get());
     }
     relationships_.push_back(std::move(connection));
@@ -288,29 +290,34 @@ std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::share
     ->withProvenanceRepository(prov_repo_)->withConfiguration(configuration_);
   auto context = contextBuilder->build(node);
   processor_contexts_.push_back(context);
-  processor_queue_.push_back(processor);
-  return processor;
+  processor_queue_.push_back(processor.get());
+  auto raw_ptr = processor.get();
+  root_process_group_->addProcessor(std::move(processor));
+  return raw_ptr;
 }
 
-std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::string &processor_name, const minifi::utils::Identifier &uuid, const std::string &name,
+minifi::core::Processor* TestPlan::addProcessor(const std::string &processor_name, const minifi::utils::Identifier &uuid, const std::string &name,
     const std::initializer_list<minifi::core::Relationship> &relationships, bool linkToPrevious) {
   if (finalized) {
     return nullptr;
   }
   std::lock_guard<std::recursive_mutex> guard(mutex);
 
-  std::shared_ptr<core::CoreComponent> ptr = minifi::core::ClassLoader::getDefaultClassLoader().instantiate(processor_name, uuid);
+  std::unique_ptr<core::CoreComponent> ptr = minifi::core::ClassLoader::getDefaultClassLoader().instantiate(processor_name, uuid);
   if (nullptr == ptr) {
     throw std::runtime_error{fmt::format("Failed to instantiate processor name: {0} uuid: {1}", processor_name, uuid.to_string().c_str())};
   }
-  std::shared_ptr<minifi::core::Processor> processor = std::static_pointer_cast<minifi::core::Processor>(ptr);
+  std::unique_ptr<minifi::core::Processor> processor = minifi::utils::dynamic_unique_cast<minifi::core::Processor>(std::move(ptr));
+  if (nullptr == processor) {
+    throw std::runtime_error{fmt::format("Failed to cast to processor with name: {0} uuid: {1}", processor_name, uuid.to_string().c_str())};
+  }
 
   processor->setName(name);
 
-  return addProcessor(processor, name, relationships, linkToPrevious);
+  return addProcessor(std::move(processor), name, relationships, linkToPrevious);
 }
 
-std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::string &processor_name, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships,
+minifi::core::Processor* TestPlan::addProcessor(const std::string &processor_name, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships,
     bool linkToPrevious) {
   if (finalized) {
     return nullptr;
@@ -319,8 +326,8 @@ std::shared_ptr<minifi::core::Processor> TestPlan::addProcessor(const std::strin
   return addProcessor(processor_name, minifi::utils::IdGenerator::getIdGenerator()->generate(), name, relationships, linkToPrevious);
 }
 
-minifi::Connection* TestPlan::addConnection(const std::shared_ptr<minifi::core::Processor>& source_proc, const minifi::core::Relationship& source_relationship,
-    const std::shared_ptr<minifi::core::Processor>& destination_proc) {
+minifi::Connection* TestPlan::addConnection(minifi::core::Processor* source_proc, const minifi::core::Relationship& source_relationship,
+    minifi::core::Processor* destination_proc) {
   std::stringstream connection_name;
   connection_name
     << (source_proc ? source_proc->getUUIDStr().c_str() : "none")
@@ -333,11 +340,11 @@ minifi::Connection* TestPlan::addConnection(const std::shared_ptr<minifi::core::
   // link the connections so that we can test results at the end for this
 
   if (source_proc) {
-    connection->setSource(source_proc.get());
+    connection->setSource(source_proc);
     connection->setSourceUUID(source_proc->getUUID());
   }
   if (destination_proc) {
-    connection->setDestination(destination_proc.get());
+    connection->setDestination(destination_proc);
     connection->setDestinationUUID(destination_proc->getUUID());
   }
   if (source_proc) {
@@ -372,10 +379,15 @@ std::shared_ptr<minifi::core::controller::ControllerServiceNode> TestPlan::addCo
   controller_service_node->setUUID(uuid);
   controller_service_node->setName(name);
 
+  controller_services_provider_->putControllerServiceNode(uuid.to_string(), controller_service_node, root_process_group_.get());
+  controller_services_provider_->putControllerServiceNode(name, controller_service_node, root_process_group_.get());
+
+  root_process_group_->addControllerService(uuid.to_string(), controller_service_node);
+
   return controller_service_node;
 }
 
-bool TestPlan::setProperty(const std::shared_ptr<minifi::core::Processor>& processor, const std::string& property, const std::string& value, bool dynamic) {
+bool TestPlan::setProperty(minifi::core::Processor* processor, const std::string& property, const std::string& value, bool dynamic) {
   std::lock_guard<std::recursive_mutex> guard(mutex);
 
   size_t i = 0;
@@ -397,15 +409,15 @@ bool TestPlan::setProperty(const std::shared_ptr<minifi::core::Processor>& proce
   }
 }
 
-bool TestPlan::setProperty(const std::shared_ptr<minifi::core::Processor>& processor, const core::PropertyReference& property, std::string_view value) {
+bool TestPlan::setProperty(minifi::core::Processor* processor, const core::PropertyReference& property, std::string_view value) {
   return setProperty(processor, std::string(property.name), std::string(value), false);
 }
 
-bool TestPlan::setProperty(const std::shared_ptr<minifi::core::Processor>& processor, std::string_view property, std::string_view value) {
+bool TestPlan::setProperty(minifi::core::Processor* processor, std::string_view property, std::string_view value) {
   return setProperty(processor, std::string(property), std::string(value), false);
 }
 
-bool TestPlan::setDynamicProperty(const std::shared_ptr<minifi::core::Processor>& processor, std::string_view property, std::string_view value) {
+bool TestPlan::setDynamicProperty(minifi::core::Processor* processor, std::string_view property, std::string_view value) {
   return setProperty(processor, std::string(property), std::string(value), true);
 }
 
@@ -447,8 +459,8 @@ void TestPlan::reset(bool reschedule) {
   }
 }
 
-std::vector<std::shared_ptr<minifi::core::Processor>>::iterator TestPlan::getProcessorItByUuid(const std::string& uuid) {
-  const auto processor_node_matches_processor = [&uuid] (const std::shared_ptr<minifi::core::Processor>& processor) {
+std::vector<minifi::core::Processor*>::iterator TestPlan::getProcessorItByUuid(const std::string& uuid) {
+  const auto processor_node_matches_processor = [&uuid] (minifi::core::Processor* processor) {
     return processor->getUUIDStr() == uuid;
   };
   auto processor_found_at = std::find_if(processor_queue_.begin(), processor_queue_.end(), processor_node_matches_processor);
@@ -458,7 +470,7 @@ std::vector<std::shared_ptr<minifi::core::Processor>>::iterator TestPlan::getPro
   return processor_found_at;
 }
 
-std::shared_ptr<minifi::core::ProcessContext> TestPlan::getProcessContextForProcessor(const std::shared_ptr<minifi::core::Processor>& processor) {
+std::shared_ptr<minifi::core::ProcessContext> TestPlan::getProcessContextForProcessor(minifi::core::Processor* processor) {
   const auto contextMatchesProcessor = [&processor] (const std::shared_ptr<minifi::core::ProcessContext>& context) {
     return context->getProcessorNode()->getUUIDStr() ==  processor->getUUIDStr();
   };
@@ -469,7 +481,7 @@ std::shared_ptr<minifi::core::ProcessContext> TestPlan::getProcessContextForProc
   return *context_found_at;
 }
 
-void TestPlan::scheduleProcessor(const std::shared_ptr<minifi::core::Processor>& processor, const std::shared_ptr<minifi::core::ProcessContext>& context) {
+void TestPlan::scheduleProcessor(minifi::core::Processor* processor, const std::shared_ptr<minifi::core::ProcessContext>& context) {
   if (std::find(configured_processors_.begin(), configured_processors_.end(), processor) == configured_processors_.end()) {
     // Ordering on factories and list of configured processors do not matter
     const auto factory = std::make_shared<minifi::core::ProcessSessionFactory>(context);
@@ -479,19 +491,19 @@ void TestPlan::scheduleProcessor(const std::shared_ptr<minifi::core::Processor>&
   }
 }
 
-void TestPlan::scheduleProcessor(const std::shared_ptr<minifi::core::Processor>& processor) {
+void TestPlan::scheduleProcessor(minifi::core::Processor* processor) {
   scheduleProcessor(processor, getProcessContextForProcessor(processor));
 }
 
 void TestPlan::scheduleProcessors() {
   for (std::size_t target_location = 0; target_location < processor_queue_.size(); ++target_location) {
-    std::shared_ptr<minifi::core::Processor> processor = processor_queue_.at(target_location);
+    auto processor = processor_queue_.at(target_location);
     std::shared_ptr<minifi::core::ProcessContext> context = processor_contexts_.at(target_location);
     scheduleProcessor(processor, context);
   }
 }
 
-bool TestPlan::runProcessor(const std::shared_ptr<minifi::core::Processor>& processor, const PreTriggerVerifier& verify) {
+bool TestPlan::runProcessor(minifi::core::Processor* processor, const PreTriggerVerifier& verify) {
   const auto processor_location = gsl::narrow<size_t>(std::distance(processor_queue_.begin(), getProcessorItByUuid(processor->getUUIDStr())));
   return runProcessor(processor_location, verify);
 }
@@ -518,7 +530,7 @@ bool TestPlan::runProcessor(size_t target_location, const PreTriggerVerifier& ve
   logger_->log_info("Running next processor {}, processor_queue_.size {}, processor_contexts_.size {}", target_location, processor_queue_.size(), processor_contexts_.size());
   std::lock_guard<std::recursive_mutex> guard(mutex);
 
-  std::shared_ptr<minifi::core::Processor> processor = processor_queue_.at(target_location);
+  auto processor = processor_queue_.at(target_location);
   std::shared_ptr<minifi::core::ProcessContext> context = processor_contexts_.at(target_location);
   scheduleProcessor(processor, context);
   current_flowfile_ = nullptr;
@@ -567,7 +579,7 @@ std::size_t TestPlan::getNumFlowFileProducedByCurrentProcessor() {
   return getNumFlowFileProducedByProcessor(processor);
 }
 
-std::size_t TestPlan::getNumFlowFileProducedByProcessor(const std::shared_ptr<minifi::core::Processor>& processor) {
+std::size_t TestPlan::getNumFlowFileProducedByProcessor(minifi::core::Processor* processor) {
   std::vector<minifi::Connection*> connections = getProcessorOutboundConnections(processor);
   std::size_t num_flow_files = 0;
   for (auto connection : connections) {
@@ -577,7 +589,7 @@ std::size_t TestPlan::getNumFlowFileProducedByProcessor(const std::shared_ptr<mi
 }
 
 std::shared_ptr<minifi::core::FlowFile> TestPlan::getFlowFileProducedByCurrentProcessor() {
-  const std::shared_ptr<minifi::core::Processor>& processor = processor_queue_.at(location);
+  minifi::core::Processor* processor = processor_queue_.at(location);
   std::vector<minifi::Connection*> connections = getProcessorOutboundConnections(processor);
   for (auto connection : connections) {
     std::set<std::shared_ptr<minifi::core::FlowFile>> expiredFlowRecords;
@@ -607,7 +619,7 @@ std::shared_ptr<minifi::core::FlowFile> TestPlan::getCurrentFlowFile() {
   return current_flowfile_;
 }
 
-std::vector<minifi::Connection*> TestPlan::getProcessorOutboundConnections(const std::shared_ptr<minifi::core::Processor>& processor) {
+std::vector<minifi::Connection*> TestPlan::getProcessorOutboundConnections(minifi::core::Processor* processor) {
   const auto is_processor_outbound_connection = [&processor] (const std::unique_ptr<minifi::Connection>& connection) {
     // A connection is outbound from a processor if its source uuid matches the processor
     return connection->getSource()->getUUIDStr() == processor->getUUIDStr();
@@ -626,7 +638,7 @@ std::shared_ptr<minifi::core::ProcessContext> TestPlan::getCurrentContext() {
   return processor_contexts_.at(location);
 }
 
-std::unique_ptr<minifi::Connection> TestPlan::buildFinalConnection(const std::shared_ptr<minifi::core::Processor>& processor, bool setDest) {
+std::unique_ptr<minifi::Connection> TestPlan::buildFinalConnection(minifi::core::Processor* processor, bool setDest) {
   gsl_Expects(termination_);
   std::stringstream connection_name;
   connection_name << processor->getUUIDStr() << "-to-" << processor->getUUIDStr();
@@ -634,9 +646,9 @@ std::unique_ptr<minifi::Connection> TestPlan::buildFinalConnection(const std::sh
   connection->addRelationship(termination_.value());
 
   // link the connections so that we can test results at the end for this
-  connection->setSource(processor.get());
+  connection->setSource(processor);
   if (setDest)
-    connection->setDestination(processor.get());
+    connection->setDestination(processor);
 
   minifi::utils::Identifier uuid_copy = processor->getUUID();
   connection->setSourceUUID(uuid_copy);
diff --git a/libminifi/test/libtest/unit/TestBase.h b/libminifi/test/libtest/unit/TestBase.h
index 05826b2b6..afc83d886 100644
--- a/libminifi/test/libtest/unit/TestBase.h
+++ b/libminifi/test/libtest/unit/TestBase.h
@@ -40,6 +40,7 @@
 #include "core/repository/VolatileContentRepository.h"
 #include "utils/file/FileUtils.h"
 #include "properties/Configuration.h"
+#include "core/Processor.h"
 
 namespace minifi = org::apache::nifi::minifi;
 namespace utils = minifi::utils;
@@ -208,25 +209,25 @@ class TestPlan {
 
   virtual ~TestPlan();
 
-  std::shared_ptr<minifi::core::Processor> addProcessor(const std::shared_ptr<minifi::core::Processor> &processor, const std::string &name,
+  minifi::core::Processor* addProcessor(std::unique_ptr<minifi::core::Processor> processor, const std::string &name,
       const minifi::core::Relationship& relationship = minifi::core::Relationship("success", "description"), bool linkToPrevious = false) {
-    return addProcessor(processor, name, { relationship }, linkToPrevious);
+    return addProcessor(std::move(processor), name, { relationship }, linkToPrevious);
   }
-  std::shared_ptr<minifi::core::Processor> addProcessor(const std::string &processor_name, const std::string &name,
+  minifi::core::Processor* addProcessor(const std::string &processor_name, const std::string &name,
       const minifi::core::Relationship& relationship = minifi::core::Relationship("success", "description"), bool linkToPrevious = false) {
     return addProcessor(processor_name, name, { relationship }, linkToPrevious);
   }
-  std::shared_ptr<minifi::core::Processor> addProcessor(const std::shared_ptr<minifi::core::Processor> &processor, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious = false); // NOLINT
-  std::shared_ptr<minifi::core::Processor> addProcessor(const std::string &processor_name, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious = false); // NOLINT
-  std::shared_ptr<minifi::core::Processor> addProcessor(const std::string &processor_name, const minifi::utils::Identifier& uuid, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious = false); // NOLINT
+  minifi::core::Processor* addProcessor(std::unique_ptr<minifi::core::Processor> processor, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious = false); // NOLINT
+  minifi::core::Processor* addProcessor(const std::string &processor_name, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious = false); // NOLINT
+  minifi::core::Processor* addProcessor(const std::string &processor_name, const minifi::utils::Identifier& uuid, const std::string &name, const std::initializer_list<minifi::core::Relationship>& relationships, bool linkToPrevious = false); // NOLINT
 
-  minifi::Connection* addConnection(const std::shared_ptr<minifi::core::Processor>& source_proc, const minifi::core::Relationship& source_relationship, const std::shared_ptr<minifi::core::Processor>& destination_proc); // NOLINT
+  minifi::Connection* addConnection(minifi::core::Processor* source_proc, const minifi::core::Relationship& source_relationship, minifi::core::Processor* destination_proc); // NOLINT
 
   std::shared_ptr<minifi::core::controller::ControllerServiceNode> addController(const std::string &controller_name, const std::string &name);
 
-  bool setProperty(const std::shared_ptr<minifi::core::Processor>& processor, const core::PropertyReference& property, std::string_view value);
-  bool setProperty(const std::shared_ptr<minifi::core::Processor>& processor, std::string_view property, std::string_view value);
-  bool setDynamicProperty(const std::shared_ptr<minifi::core::Processor>& processor, std::string_view property, std::string_view value);
+  bool setProperty(minifi::core::Processor* processor, const core::PropertyReference& property, std::string_view value);
+  bool setProperty(minifi::core::Processor* processor, std::string_view property, std::string_view value);
+  bool setDynamicProperty(minifi::core::Processor* processor, std::string_view property, std::string_view value);
 
   static bool setProperty(const std::shared_ptr<minifi::core::controller::ControllerServiceNode>& controller_service_node, const core::PropertyReference& property, std::string_view value);
   static bool setProperty(const std::shared_ptr<minifi::core::controller::ControllerServiceNode>& controller_service_node, std::string_view property, std::string_view value);
@@ -238,14 +239,14 @@ class TestPlan {
 
   using PreTriggerVerifier = std::function<void(const std::shared_ptr<minifi::core::ProcessContext>, const std::shared_ptr<minifi::core::ProcessSession>)>;
 
-  std::vector<std::shared_ptr<minifi::core::Processor>>::iterator getProcessorItByUuid(const std::string& uuid);
-  std::shared_ptr<minifi::core::ProcessContext> getProcessContextForProcessor(const std::shared_ptr<minifi::core::Processor>& processor);
+  std::vector<minifi::core::Processor*>::iterator getProcessorItByUuid(const std::string& uuid);
+  std::shared_ptr<minifi::core::ProcessContext> getProcessContextForProcessor(minifi::core::Processor* processor);
 
-  void scheduleProcessor(const std::shared_ptr<minifi::core::Processor>& processor, const std::shared_ptr<minifi::core::ProcessContext>& context);
-  void scheduleProcessor(const std::shared_ptr<minifi::core::Processor>& processor);
+  void scheduleProcessor(minifi::core::Processor* processor, const std::shared_ptr<minifi::core::ProcessContext>& context);
+  void scheduleProcessor(minifi::core::Processor* processor);
   void scheduleProcessors();
 
-  bool runProcessor(const std::shared_ptr<minifi::core::Processor>& processor, const PreTriggerVerifier& verify = nullptr);
+  bool runProcessor(minifi::core::Processor* processor, const PreTriggerVerifier& verify = nullptr);
   bool runProcessor(size_t target_location, const PreTriggerVerifier& verify = nullptr);
   bool runNextProcessor(const PreTriggerVerifier& verify = nullptr);
   bool runCurrentProcessor();
@@ -254,8 +255,8 @@ class TestPlan {
   std::set<std::shared_ptr<minifi::provenance::ProvenanceEventRecord>> getProvenanceRecords();
 
   std::shared_ptr<minifi::core::FlowFile> getCurrentFlowFile();
-  std::vector<minifi::Connection*> getProcessorOutboundConnections(const std::shared_ptr<minifi::core::Processor>& processor);
-  std::size_t getNumFlowFileProducedByProcessor(const std::shared_ptr<minifi::core::Processor>& processor);
+  std::vector<minifi::Connection*> getProcessorOutboundConnections(minifi::core::Processor* processor);
+  std::size_t getNumFlowFileProducedByProcessor(minifi::core::Processor* processor);
   std::size_t getNumFlowFileProducedByCurrentProcessor();
   std::shared_ptr<minifi::core::FlowFile> getFlowFileProducedByCurrentProcessor();
 
@@ -295,7 +296,7 @@ class TestPlan {
  protected:
   std::unique_ptr<TempDirectory> state_dir_;
 
-  std::unique_ptr<minifi::Connection> buildFinalConnection(const std::shared_ptr<minifi::core::Processor>& processor, bool setDest = false);
+  std::unique_ptr<minifi::Connection> buildFinalConnection(minifi::core::Processor* processor, bool setDest = false);
 
   std::shared_ptr<minifi::Configure> configuration_;
 
@@ -318,18 +319,19 @@ class TestPlan {
 
   std::shared_ptr<minifi::state::response::FlowVersion> flow_version_;
   std::vector<std::shared_ptr<minifi::core::controller::ControllerServiceNode>> controller_service_nodes_;
-  std::map<minifi::utils::Identifier, std::shared_ptr<minifi::core::Processor>> processor_mapping_;
-  std::vector<std::shared_ptr<minifi::core::Processor>> processor_queue_;
-  std::vector<std::shared_ptr<minifi::core::Processor>> configured_processors_;  // Do not assume ordering
+  std::map<minifi::utils::Identifier, minifi::core::Processor*> processor_mapping_;
+  std::vector<minifi::core::Processor*> processor_queue_;
+  std::vector<minifi::core::Processor*> configured_processors_;  // Do not assume ordering
   std::vector<std::shared_ptr<minifi::core::ProcessorNode>> processor_nodes_;
   std::vector<std::shared_ptr<minifi::core::ProcessContext>> processor_contexts_;
   std::vector<std::shared_ptr<minifi::core::ProcessSession>> process_sessions_;
   std::vector<std::shared_ptr<minifi::core::ProcessSessionFactory>> factories_;  // Do not assume ordering
   std::vector<std::unique_ptr<minifi::Connection>> relationships_;
   std::optional<minifi::core::Relationship> termination_;
+  std::unique_ptr<minifi::core::ProcessGroup> root_process_group_;
 
  private:
-  bool setProperty(const std::shared_ptr<minifi::core::Processor>& processor, const std::string& property, const std::string& value, bool dynamic);
+  bool setProperty(minifi::core::Processor* processor, const std::string& property, const std::string& value, bool dynamic);
   static bool setProperty(const std::shared_ptr<minifi::core::controller::ControllerServiceNode>& controller_service_node, const std::string& property, const std::string& value, bool dynamic);
 
   std::shared_ptr<logging::Logger> logger_;
diff --git a/libminifi/test/libtest/unit/TestUtils.h b/libminifi/test/libtest/unit/TestUtils.h
index 6303b1f5f..71b4bf35f 100644
--- a/libminifi/test/libtest/unit/TestUtils.h
+++ b/libminifi/test/libtest/unit/TestUtils.h
@@ -217,7 +217,7 @@ concept NetworkingProcessor = std::derived_from<T, minifi::core::Processor>
     };  // NOLINT(readability/braces)
 
 template<NetworkingProcessor T>
-uint16_t scheduleProcessorOnRandomPort(const std::shared_ptr<TestPlan>& test_plan, const std::shared_ptr<T>& processor) {
+uint16_t scheduleProcessorOnRandomPort(const std::shared_ptr<TestPlan>& test_plan, T* processor) {
   REQUIRE(processor->setProperty(T::Port, "0"));
   test_plan->scheduleProcessor(processor);
   REQUIRE(verifyEventHappenedInPollTime(250ms, [&processor] { return processor->getPort() != 0; }, 20ms));
diff --git a/libminifi/test/resources/TestControllerServices.yml b/libminifi/test/resources/TestControllerServices.yml
index d2d2a5a6a..4631a2fcf 100644
--- a/libminifi/test/resources/TestControllerServices.yml
+++ b/libminifi/test/resources/TestControllerServices.yml
@@ -17,64 +17,116 @@
 # under the License.
 #
 Flow Controller:
-    name: MiNiFi Flow
-    id: 2438e3c8-015a-1000-79ca-83af40ec1990
-    
-Processors: 
-    - name: MockProcessorIto
-      id: 1438e3c8-015a-1000-79ca-83af40ec1991
-      class: org.apache.nifi.processors.standard.MockProcessor
-      max concurrent tasks: 1
-      scheduling strategy: TIMER_DRIVEN
-      scheduling period: 1 sec
-      penalization period: 30 sec
-      yield period: 1 sec
-      run duration nanos: 0
-      auto-terminated relationships list:
-      Properties:
-        linkedService: MockItLikeIts1995
-
-Connections:
-    - name: TransferFilesToRPG
-      id: 1438e3c8-015a-1000-79ca-83af40ec1997
-      source name: MockProcessorIto
-      source id: 1438e3c8-015a-1000-79ca-83af40ec1991
-      source relationship name: success
-      destination name: MockProcessorIto
-      destination id: 1438e3c8-015a-1000-79ca-83af40ec1991
-      destination relationship name: success
-      max work queue size: 0
-      max work queue data size: 1 MB
-      flowfile expiration: 60 sec
-      
-Controller Services:
-    - name: MockItLikeIts1995
-      id: 2438e3c8-015a-1000-79ca-83af40ec1991
-      class: MockControllerService
-      Properties:
-          Linked Services: 
+  name: MiNiFi Flow
+  id: 2438e3c8-015a-1000-79ca-83af40ec1990
+Process Groups:
+  - id: 0a3aaf32-8574-4fa7-b720-84001f8dd71a
+    name: Sub Process Group
+    Processors:
+      - name: SubMockProcessor
+        id: 3458e3c8-015a-1000-79ca-83af40ec1992
+        class: org.apache.nifi.processors.standard.MockProcessor
+        max concurrent tasks: 1
+        scheduling strategy: EVENT_DRIVEN
+        penalization period: 30 sec
+        yield period: 1 sec
+        run duration nanos: 0
+        auto-terminated relationships list:
+            - success
+        Properties:
+          linkedService: ID
+          InSubProcessGroup: true
+    Input Ports:
+      - id: 012fc536-3137-4360-be65-3e3b47e05941
+        name: in
+    Controller Services:
+      - name: SubMockController
+        id: 1248e3c8-015a-1000-79ca-83af40ec1993
+        class: MockControllerService
+        Properties:
+          Linked Services:
+            - value: SubSSLClientServiceTest
             - value: ID
-    - name: SSLClientServiceTest
-      id: 2438e3c8-015a-1000-79ca-83af40ec1994
-      class: SSLContextService
-      Properties:
-        Client Certificate:
+      - name: SubSSLClientServiceTest
+        id: 2438e3c8-015a-1000-79ca-83af40ec1922
+        class: SSLContextService
+        Properties:
+          Client Certificate:
             - value: cn.crt.pem
-        Private Key:
+          Private Key:
             - value: cn.ckey.pem
-        Passphrase:
+          Passphrase:
             - value: cn.pass
-        CA Certificate:
+          CA Certificate:
             - value: nifi-cert.pem
-    - name: ID
-      id: 2438e3c8-015a-1000-79ca-83af40ec1992
-      class: MockControllerService
-      Properties:
-          Linked Services: 
-    - name: MockItLikeItsWrong
-      id: 2438e3c8-015a-1000-79ca-83af40ec1993
-      class: MockControllerSer
-      Properties:
-          Linked Services: 
-            - value: ID
-
+    Connections:
+      - name: Input/success/SubMockProcessor
+        id: 1238e3c8-015a-1000-79ca-83af40ec1997
+        source name: in
+        source id: 012fc536-3137-4360-be65-3e3b47e05941
+        source relationship name: success
+        destination name: SubMockProcessor
+        destination id: 3458e3c8-015a-1000-79ca-83af40ec1992
+        max work queue size: 0
+        max work queue data size: 1 MB
+        flowfile expiration: 60 sec
+Processors:
+  - name: MockProcessorIto
+    id: 1438e3c8-015a-1000-79ca-83af40ec1991
+    class: org.apache.nifi.processors.standard.MockProcessor
+    max concurrent tasks: 1
+    scheduling strategy: TIMER_DRIVEN
+    scheduling period: 10 sec
+    penalization period: 30 sec
+    yield period: 1 sec
+    run duration nanos: 0
+    auto-terminated relationships list: null
+    Properties:
+      linkedService: MockItLikeIts1995
+Connections:
+  - name: TransferFilesToRPG
+    id: 1438e3c8-015a-1000-79ca-83af40ec1997
+    source name: MockProcessorIto
+    source id: 1438e3c8-015a-1000-79ca-83af40ec1991
+    source relationship name: success
+    destination name: in
+    destination id: 012fc536-3137-4360-be65-3e3b47e05941
+    max work queue size: 0
+    max work queue data size: 1 MB
+    flowfile expiration: 60 sec
+Controller Services:
+  - name: MockItLikeIts1995
+    id: 2438e3c8-015a-1000-79ca-83af40ec1991
+    class: MockControllerService
+    Properties:
+      Linked Services:
+        - value: ID
+        - value: SubSSLClientServiceTest
+  - name: SSLClientServiceTest
+    id: 2438e3c8-015a-1000-79ca-83af40ec1994
+    class: SSLContextService
+    Properties:
+      Client Certificate:
+        - value: cn.crt.pem
+      Private Key:
+        - value: cn.ckey.pem
+      Passphrase:
+        - value: cn.pass
+      CA Certificate:
+        - value: nifi-cert.pem
+  - name: ID
+    id: 2438e3c8-015a-1000-79ca-83af40ec1992
+    class: MockControllerService
+    Properties:
+      Linked Services:
+  - name: MockItLikeItsWrong
+    id: 2438e3c8-015a-1000-79ca-83af40ec1993
+    class: MockControllerSer
+    Properties:
+      Linked Services:
+        - value: ID
+  - name: LinkSubService
+    id: 7538e3c8-015a-1000-79ca-83af40ec1996
+    class: MockControllerService
+    Properties:
+      linkedService: SubSSLClientServiceTest
diff --git a/libminifi/test/unit/ProcessSessionTests.cpp b/libminifi/test/unit/ProcessSessionTests.cpp
index 008c914da..1ef505c86 100644
--- a/libminifi/test/unit/ProcessSessionTests.cpp
+++ b/libminifi/test/unit/ProcessSessionTests.cpp
@@ -40,7 +40,7 @@ class Fixture {
   TestController test_controller_;
   TestController::PlanConfig plan_config_;
   std::shared_ptr<TestPlan> test_plan_ = test_controller_.createPlan(plan_config_);
-  std::shared_ptr<minifi::core::Processor> dummy_processor_ = test_plan_->addProcessor("DummyProcessor", "dummyProcessor");
+  minifi::core::Processor* dummy_processor_ = test_plan_->addProcessor("DummyProcessor", "dummyProcessor");
   std::shared_ptr<minifi::core::ProcessContext> context_ = [this] { test_plan_->runNextProcessor(); return test_plan_->getCurrentContext(); }();
   std::unique_ptr<minifi::core::ProcessSession> process_session_ = std::make_unique<core::ProcessSession>(context_);
 };