tests: Embed test framework within OCL repository

Signed-off-by: Robert Baldyga <robert.baldyga@intel.com>

test/functional/test-framework/internal_plugins/__init__.py

@@ -0,0 +1,4 @@
+#
+# Copyright(c) 2019-2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+#

test/functional/test-framework/internal_plugins/example_plugin/__init__.py

@@ -0,0 +1,22 @@
+#
+# Copyright(c) 2020-2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+
+class ExamplePlugin:
+    def __init__(self, params, config):
+        self.params = params
+        print(f"Example plugin initialized with params {self.params}")
+
+    def pre_setup(self):
+        print("Example plugin pre setup")
+
+    def post_setup(self):
+        print("Example plugin post setup")
+
+    def teardown(self):
+        print("Example plugin teardown")
+
+
+plugin_class = ExamplePlugin

test/functional/test-framework/internal_plugins/power_control_libvirt/__init__.py

@@ -0,0 +1,48 @@
+#
+# Copyright(c) 2020-2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+#
+from datetime import timedelta
+
+from connection.local_executor import LocalExecutor
+from connection.ssh_executor import SshExecutor
+from core.test_run import TestRun
+
+
+class PowerControlPlugin:
+    def __init__(self, params, config):
+        print("Power Control LibVirt Plugin initialization")
+        try:
+            self.ip = config['ip']
+            self.user = config['user']
+        except Exception:
+            raise Exception("Missing fields in config! ('ip' and 'user' required)")
+
+    def pre_setup(self):
+        print("Power Control LibVirt Plugin pre setup")
+        if self.config['connection_type'] == 'ssh':
+            self.executor = SshExecutor(
+                self.ip,
+                self.user,
+                self.config.get('port', 22)
+            )
+        else:
+            self.executor = LocalExecutor()
+
+    def post_setup(self):
+        pass
+
+    def teardown(self):
+        pass
+
+    def power_cycle(self):
+        self.executor.run(f"virsh reset {self.config['domain']}")
+        TestRun.executor.wait_for_connection_loss()
+        timeout = TestRun.config.get('reboot_timeout')
+        if timeout:
+            TestRun.executor.wait_for_connection(timedelta(seconds=int(timeout)))
+        else:
+            TestRun.executor.wait_for_connection()
+
+
+plugin_class = PowerControlPlugin

test/functional/test-framework/internal_plugins/scsi_debug/__init__.py

@@ -0,0 +1,39 @@
+#
+# Copyright(c) 2020-2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+#
+from time import sleep
+
+from core.test_run_utils import TestRun
+from storage_devices.device import Device
+from test_utils import os_utils
+from test_utils.output import CmdException
+
+
+class ScsiDebug:
+    def __init__(self, params, config):
+        self.params = params
+        self.module_name = "scsi_debug"
+
+    def pre_setup(self):
+        pass
+
+    def post_setup(self):
+        self.reload()
+
+    def reload(self):
+        self.teardown()
+        sleep(1)
+        load_output = os_utils.load_kernel_module(self.module_name, self.params)
+        if load_output.exit_code != 0:
+            raise CmdException(f"Failed to load {self.module_name} module", load_output)
+        TestRun.LOGGER.info(f"{self.module_name} loaded successfully.")
+        sleep(10)
+        TestRun.scsi_debug_devices = Device.get_scsi_debug_devices()
+
+    def teardown(self):
+        if os_utils.is_kernel_module_loaded(self.module_name):
+            os_utils.unload_kernel_module(self.module_name)
+
+
+plugin_class = ScsiDebug

test/functional/test-framework/internal_plugins/vdbench/__init__.py

@@ -0,0 +1,97 @@
+#
+# Copyright(c) 2020-2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import time
+import posixpath
+
+from datetime import timedelta
+from core.test_run import TestRun
+from test_tools import fs_utils
+
+
+class Vdbench:
+    def __init__(self, params, config):
+        print("VDBench plugin initialization")
+        self.run_time = timedelta(seconds=60)
+
+        try:
+            self.working_dir = config["working_dir"]
+            self.reinstall = config["reinstall"]
+            self.source_dir = config["source_dir"]
+        except Exception:
+            raise Exception("Missing fields in config! ('working_dir', 'source_dir' and "
+                            "'reinstall' required)")
+
+        self.result_dir = posixpath.join(self.working_dir, 'result.tod')
+
+    def pre_setup(self):
+        pass
+
+    def post_setup(self):
+        print("VDBench plugin post setup")
+        if not self.reinstall and fs_utils.check_if_directory_exists(self.working_dir):
+            return
+
+        if fs_utils.check_if_directory_exists(self.working_dir):
+            fs_utils.remove(self.working_dir, True, True)
+
+        fs_utils.create_directory(self.working_dir)
+        TestRun.LOGGER.info("Copying vdbench to working dir.")
+        fs_utils.copy(posixpath.join(self.source_dir, "*"), self.working_dir,
+                      True, True)
+        pass
+
+    def teardown(self):
+        pass
+
+    def create_config(self, config, run_time: timedelta):
+        self.run_time = run_time
+        if config[-1] != ",":
+            config += ","
+        config += f"elapsed={int(run_time.total_seconds())}"
+        TestRun.LOGGER.info(f"Vdbench config:\n{config}")
+        fs_utils.write_file(posixpath.join(self.working_dir, "param.ini"), config)
+
+    def run(self):
+        cmd = f"{posixpath.join(self.working_dir, 'vdbench')} " \
+              f"-f {posixpath.join(self.working_dir, 'param.ini')} " \
+              f"-vr -o {self.result_dir}"
+        full_cmd = f"screen -dmS vdbench {cmd}"
+        TestRun.executor.run(full_cmd)
+        start_time = time.time()
+
+        timeout = self.run_time * 1.5
+
+        while True:
+            if not TestRun.executor.run(f"ps aux | grep '{cmd}' | grep -v grep").exit_code == 0:
+                return self.analyze_log()
+
+            if time.time() - start_time > timeout.total_seconds():
+                TestRun.LOGGER.error("Vdbench timeout.")
+                return False
+            time.sleep(1)
+
+    def analyze_log(self):
+        output = TestRun.executor.run(
+            f"ls -1td {self.result_dir[0:len(self.result_dir) - 3]}* | head -1")
+        log_path = posixpath.join(output.stdout if output.exit_code == 0 else self.result_dir,
+                                "logfile.html")
+
+        log_file = fs_utils.read_file(log_path)
+
+        if "Vdbench execution completed successfully" in log_file:
+            TestRun.LOGGER.info("Vdbench execution completed successfully.")
+            return True
+
+        if "Data Validation error" in log_file or "data_errors=1" in log_file:
+            TestRun.LOGGER.error("Data corruption occurred!")
+        elif "Heartbeat monitor:" in log_file:
+            TestRun.LOGGER.error("Vdbench: heartbeat.")
+        else:
+            TestRun.LOGGER.error("Vdbench unknown result.")
+        return False
+
+
+plugin_class = Vdbench