MINIFICPP-2684 Move MiNiFi controller tests to modular docker tests

Author: lordgamez

behave_framework/src/minifi_test_framework/containers/container.py

@@ -363,6 +363,7 @@ def verify_file_contents(self, directory_path: str, expected_contents: list[str]
         if not self.container:
             return False
 
+        self.container.reload()
         if self.container.status == "running":
             return self._verify_file_contents_in_running_container(directory_path, expected_contents)
 

behave_framework/src/minifi_test_framework/containers/minifi_container.py

@@ -16,12 +16,16 @@
 #
 
 import logging
+import os
+from pathlib import Path
 from OpenSSL import crypto
 
 from minifi_test_framework.core.minifi_test_context import MinifiTestContext
 from minifi_test_framework.containers.file import File
+from minifi_test_framework.containers.host_file import HostFile
 from minifi_test_framework.minifi.minifi_flow_definition import MinifiFlowDefinition
 from minifi_test_framework.core.ssl_utils import make_cert_without_extended_usage, make_client_cert, make_server_cert
+from minifi_test_framework.core.helpers import wait_for_condition, retry_check
 from .container import Container
 
 
@@ -47,6 +51,10 @@ def __init__(self, container_name: str, test_context: MinifiTestContext):
                                crypto.dump_certificate(type=crypto.FILETYPE_PEM, cert=minifi_server_cert) + crypto.dump_privatekey(type=crypto.FILETYPE_PEM, pkey=minifi_server_key)))
 
         self.is_fhs = 'MINIFI_INSTALLATION_TYPE=FHS' in str(self.client.images.get(test_context.minifi_container_image).history())
+        if self.is_fhs:
+            self.minifi_controller_path = '/usr/bin/minifi-controller'
+        else:
+            self.minifi_controller_path = '/opt/minifi/minifi-current/bin/minifi-controller'
 
         self._fill_default_properties()
         self._fill_default_log_properties()
@@ -66,7 +74,18 @@ def deploy(self) -> bool:
             self.files.append(File("/opt/minifi/minifi-current/conf/minifi-log.properties",
                                    self._get_log_properties_file_content()))
 
-        return super().deploy()
+        resource_dir = Path(__file__).resolve().parent / "resources" / "minifi-controller"
+        self.host_files.append(HostFile("/tmp/resources/minifi-controller/config.yml", os.path.join(resource_dir, "config.yml")))
+
+        if not super().deploy():
+            return False
+
+        finished_str = "MiNiFi started"
+        return wait_for_condition(
+            condition=lambda: finished_str in self.get_logs(),
+            timeout_seconds=15,
+            bail_condition=lambda: self.exited,
+            context=None)
 
     def set_property(self, key: str, value: str):
         self.properties[key] = value
@@ -111,3 +130,74 @@ def get_memory_usage(self) -> int | None:
         memory_usage_in_bytes = int(output.strip()) * 1024
         logging.info(f"MiNiFi memory usage: {memory_usage_in_bytes} bytes")
         return memory_usage_in_bytes
+
+    def set_controller_socket_properties(self):
+        self.properties["controller.socket.enable"] = "true"
+        self.properties["controller.socket.host"] = "localhost"
+        self.properties["controller.socket.port"] = "9998"
+        self.properties["controller.socket.local.any.interface"] = "false"
+
+    def update_flow_config_through_controller(self):
+        self.exec_run([self.minifi_controller_path, "--updateflow", "/tmp/resources/minifi-controller/config.yml"])
+
+    def updated_config_is_persisted(self) -> bool:
+        exit_code, output = self.exec_run(["cat", "/opt/minifi/minifi-current/conf/config.yml" if not self.is_fhs else "/etc/nifi-minifi-cpp/config.yml"])
+        if exit_code != 0:
+            logging.error("Failed to read MiNiFi config file to check if updated config is persisted")
+            return False
+        return "2f2a3b47-f5ba-49f6-82b5-bc1c86b96f38" in output
+
+    def stop_component_through_controller(self, component: str):
+        self.exec_run([self.minifi_controller_path, "--stop", component])
+
+    def start_component_through_controller(self, component: str):
+        self.exec_run([self.minifi_controller_path, "--start", component])
+
+    @retry_check(10, 1)
+    def is_component_running(self, component: str) -> bool:
+        (code, output) = self.exec_run([self.minifi_controller_path, "--list", "components"])
+        return code == 0 and component + ", running: true" in output
+
+    def get_connections(self):
+        (_, output) = self.exec_run([self.minifi_controller_path, "--list", "connections"])
+        connections = []
+        for line in output.split('\n'):
+            if not line.startswith('[') and not line.startswith('Connection Names'):
+                connections.append(line)
+        return connections
+
+    @retry_check(10, 1)
+    def connection_found_through_controller(self, connection: str) -> bool:
+        return connection in self.get_connections()
+
+    def get_full_connection_count(self) -> int:
+        (_, output) = self.exec_run([self.minifi_controller_path, "--getfull"])
+        for line in output.split('\n'):
+            if "are full" in line:
+                return int(line.split(' ')[0])
+        return -1
+
+    def get_connection_size(self, connection: str):
+        (_, output) = self.exec_run([self.minifi_controller_path, "--getsize", connection])
+        for line in output.split('\n'):
+            if "Size/Max of " + connection in line:
+                size_and_max = line.split(connection)[1].split('/')
+                return (int(size_and_max[0].strip()), int(size_and_max[1].strip()))
+        return (-1, -1)
+
+    def get_manifest(self) -> str:
+        (_, output) = self.exec_run([self.minifi_controller_path, "--manifest"])
+        manifest = ""
+        for line in output.split('\n'):
+            if not line.startswith('['):
+                manifest += line
+        return manifest
+
+    def create_debug_bundle(self) -> bool:
+        (code, _) = self.exec_run([self.minifi_controller_path, "--debug", "/tmp"])
+        if code != 0:
+            logging.error("Minifi controller debug command failed with code: %d", code)
+            return False
+
+        (code, _) = self.exec_run(["test", "-f", "/tmp/debug.tar.gz"])
+        return code == 0

…n/resources/minifi-controller/config.yml …s/resources/minifi-controller/config.ymldocker/test/integration/resources/minifi-controller/config.yml renamed to behave_framework/src/minifi_test_framework/containers/resources/minifi-controller/config.yml docker/test/integration/resources/minifi-controller/config.yml renamed to behave_framework/src/minifi_test_framework/containers/resources/minifi-controller/config.yml

@@ -273,9 +273,6 @@ def set_yaml_in_minifi(self):
     def set_json_in_minifi(self):
         self.minifi_options.config_format = "json"
 
-    def set_controller_socket_properties_in_minifi(self):
-        self.minifi_options.enable_controller_socket = True
-
     def enable_log_metrics_publisher_in_minifi(self):
         self.minifi_options.enable_log_metrics_publisher = True
 

docker/test/integration/cluster/ContainerStore.py

@@ -54,6 +54,7 @@ def get_app_log_from_docker_container(self, container_name):
             logging.warning('Container segfaulted: %s', container.name)
             self.segfault = True
 
+        container.reload()
         return container.status, container.logs()
 
     def __put_archive(self, container_name, path, data):

docker/test/integration/cluster/DockerCommunicator.py

@@ -15,22 +15,16 @@
 import logging
 import time
 import re
-import tarfile
-import tempfile
-import os
-import gzip
-import shutil
 
 from .LogSource import LogSource
 from .ContainerStore import ContainerStore
 from .DockerCommunicator import DockerCommunicator
-from .MinifiControllerExecutor import MinifiControllerExecutor
 from .checkers.AzureChecker import AzureChecker
 from .checkers.PostgresChecker import PostgresChecker
 from .checkers.PrometheusChecker import PrometheusChecker
 from .checkers.ModbusChecker import ModbusChecker
 from .checkers.MqttHelper import MqttHelper
-from utils import get_peak_memory_usage, get_minifi_pid, get_memory_usage, retry_check
+from utils import get_peak_memory_usage, get_minifi_pid, get_memory_usage
 
 
 class DockerTestCluster:
@@ -42,7 +36,6 @@ def __init__(self, context, feature_id):
         self.azure_checker = AzureChecker(self.container_communicator)
         self.postgres_checker = PostgresChecker(self.container_communicator)
         self.prometheus_checker = PrometheusChecker()
-        self.minifi_controller_executor = MinifiControllerExecutor(self.container_communicator)
         self.modbus_checker = ModbusChecker(self.container_communicator)
         self.mqtt_helper = MqttHelper()
 
@@ -124,9 +117,6 @@ def set_yaml_in_minifi(self):
     def set_json_in_minifi(self):
         self.container_store.set_json_in_minifi()
 
-    def set_controller_socket_properties_in_minifi(self):
-        self.container_store.set_controller_socket_properties_in_minifi()
-
     def enable_log_metrics_publisher_in_minifi(self):
         self.container_store.enable_log_metrics_publisher_in_minifi()
 
@@ -283,78 +273,6 @@ def wait_for_memory_usage_to_drop_below(self, max_memory_usage: int, timeout_sec
         logging.warning(f"Memory usage ({current_memory_usage}) is more than the maximum asserted memory usage ({max_memory_usage})")
         return False
 
-    def update_flow_config_through_controller(self, container_name: str):
-        self.minifi_controller_executor.update_flow(container_name)
-
-    @retry_check(10, 1)
-    def check_minifi_controller_updated_config_is_persisted(self, container_name: str) -> bool:
-        return self.minifi_controller_executor.updated_config_is_persisted(container_name)
-
-    def stop_component_through_controller(self, component: str, container_name: str):
-        self.minifi_controller_executor.stop_component(component, container_name)
-
-    def start_component_through_controller(self, component: str, container_name: str):
-        self.minifi_controller_executor.start_component(component, container_name)
-
-    @retry_check(10, 1)
-    def check_component_not_running_through_controller(self, component: str, container_name: str) -> bool:
-        return not self.minifi_controller_executor.is_component_running(component, container_name)
-
-    @retry_check(10, 1)
-    def check_component_running_through_controller(self, component: str, container_name: str) -> bool:
-        return self.minifi_controller_executor.is_component_running(component, container_name)
-
-    @retry_check(10, 1)
-    def connection_found_through_controller(self, connection: str, container_name: str) -> bool:
-        return connection in self.minifi_controller_executor.get_connections(container_name)
-
-    @retry_check(10, 1)
-    def check_connections_full_through_controller(self, connection_count: int, container_name: str) -> bool:
-        return self.minifi_controller_executor.get_full_connection_count(container_name) == connection_count
-
-    @retry_check(10, 1)
-    def check_connection_size_through_controller(self, connection: str, size: int, max_size: int, container_name: str) -> bool:
-        return self.minifi_controller_executor.get_connection_size(connection, container_name) == (size, max_size)
-
-    @retry_check(10, 1)
-    def manifest_can_be_retrieved_through_minifi_controller(self, container_name: str) -> bool:
-        manifest = self.minifi_controller_executor.get_manifest(container_name)
-        return '"agentManifest": {' in manifest and '"componentManifest": {' in manifest and '"agentType": "cpp"' in manifest
-
-    @retry_check(10, 1)
-    def debug_bundle_can_be_retrieved_through_minifi_controller(self, container_name: str) -> bool:
-        with tempfile.TemporaryDirectory() as td:
-            result = self.minifi_controller_executor.get_debug_bundle(container_name, td)
-            if not result:
-                logging.error("Failed to get debug bundle")
-                return False
-
-            with tarfile.open(os.path.join(td, "debug.tar.gz")) as file:
-                file.extractall(td)
-
-            if not os.path.exists(os.path.join(td, "config.yml")):
-                logging.error("config.yml file was not found in debug bundle")
-                return False
-
-            if not os.path.exists(os.path.join(td, "minifi.properties")):
-                logging.error("minifi.properties file was not found in debug bundle")
-                return False
-
-            if not os.path.exists(os.path.join(td, "minifi.log.gz")):
-                logging.error("minifi.log.gz file was not found in debug bundle")
-                return False
-
-            with gzip.open(os.path.join(td, "minifi.log.gz"), 'rb') as f_in:
-                with open(os.path.join(td, "minifi.log"), 'wb') as f_out:
-                    shutil.copyfileobj(f_in, f_out)
-
-            with open(os.path.join(td, "minifi.log")) as f:
-                if 'MiNiFi started' not in f.read():
-                    logging.error("'MiNiFi started' log entry was not found in minifi.log file")
-                    return False
-
-            return True
-
     def set_value_on_plc_with_modbus(self, container_name, modbus_cmd):
         return self.modbus_checker.set_value_on_plc_with_modbus(container_name, modbus_cmd)
 

docker/test/integration/cluster/DockerTestCluster.py

@@ -41,7 +41,6 @@ def __init__(self):
         self.config_format = "json"
         self.use_flow_config_from_url = False
         self.set_ssl_context_properties = False
-        self.enable_controller_socket = False
         self.enable_log_metrics_publisher = False
         self.enable_example_minifi_python_processors = False
         if "true" in os.environ['MINIFI_FIPS']:
@@ -186,12 +185,6 @@ def _create_properties(self):
             if self.options.use_flow_config_from_url:
                 f.write(f"nifi.c2.flow.url=http://minifi-c2-server-{self.feature_context.id}:10090/c2/config?class=minifi-test-class\n")
 
-            if self.options.enable_controller_socket:
-                f.write("controller.socket.enable=true\n")
-                f.write("controller.socket.host=localhost\n")
-                f.write("controller.socket.port=9998\n")
-                f.write("controller.socket.local.any.interface=false\n")
-
             if self.options.use_nifi_python_processors_with_virtualenv or self.options.remove_python_requirements_txt or self.options.use_nifi_python_processors_without_dependencies:
                 f.write("nifi.python.virtualenv.directory={minifi_python_venv_parent}/venv\n".format(minifi_python_venv_parent=MinifiContainer.MINIFI_LOCATIONS.minifi_python_venv_parent))
             elif self.options.use_nifi_python_processors_with_virtualenv_packages_installed: