Plugin installer migration

osbenchmark/builder/installers/opensearch_installer.py

@@ -26,9 +26,10 @@ def __init__(self, provision_config_instance, executor, hook_handler_class=Boots
         self.config_applier = ConfigApplier(executor, self.template_renderer, self.path_manager)
         self.host_cleaner = HostCleaner(self.path_manager)
 
-    def install(self, host, binaries, all_node_ips):
+    # pylint: disable=arguments-differ
+    def install(self, host, binaries, all_node_ips, config_vars=None):
         node = self._create_node()
-        self._prepare_node(host, node, binaries[OpenSearchInstaller.OPENSEARCH_BINARY_KEY], all_node_ips)
+        self._prepare_node(host, node, binaries[OpenSearchInstaller.OPENSEARCH_BINARY_KEY], all_node_ips, config_vars)
 
         return node
 
@@ -50,14 +51,14 @@ def _create_node(self):
                     data_paths=None,
                     telemetry=None)
 
-    def _prepare_node(self, host, node, binary, all_node_ips):
+    def _prepare_node(self, host, node, binary, all_node_ips, config_vars):
         self._prepare_directories(host, node)
         self._extract_opensearch(host, node, binary)
         self._update_node_binary_path(node)
         self._set_node_data_paths(node)
         # we need to immediately delete the prebundled config files as plugins may copy their configuration during installation.
         self._delete_prebundled_config_files(host, node)
-        self._prepare_config_files(host, node, all_node_ips)
+        self._prepare_config_files(host, node, all_node_ips, config_vars)
 
     def _prepare_directories(self, host, node):
         directories_to_create = [node.binary_path, node.log_path, node.heap_dump_path]
@@ -79,12 +80,13 @@ def _delete_prebundled_config_files(self, host, node):
         self.logger.info("Deleting pre-bundled OpenSearch configuration at [%s]", config_path)
         self.path_manager.delete_path(host, config_path)
 
-    def _prepare_config_files(self, host, node, all_node_ips):
-        config_vars = self.get_config_vars(host, node, all_node_ips)
+    def _prepare_config_files(self, host, node, all_node_ips, config_vars):
+        if not config_vars:
+            config_vars = self.get_config_vars(host, node, all_node_ips)
         self.config_applier.apply_configs(host, node, self.provision_config_instance.config_paths, config_vars)
 
     def get_config_vars(self, host, node, all_node_ips):
-        provisioner_defaults = {
+        installer_defaults = {
             "cluster_name": self.provision_config_instance.variables["cluster_name"],
             "node_name": node.name,
             "data_paths": node.data_paths[0],
@@ -103,7 +105,7 @@ def get_config_vars(self, host, node, all_node_ips):
         }
         config_vars = {}
         config_vars.update(self.provision_config_instance.variables)
-        config_vars.update(provisioner_defaults)
+        config_vars.update(installer_defaults)
         return config_vars
 
     def invoke_install_hook(self, phase, variables, env):

osbenchmark/builder/installers/plugin_installer.py

@@ -0,0 +1,50 @@
+import logging
+import os
+
+from osbenchmark.builder.installers.installer import Installer
+from osbenchmark.builder.provision_config import BootstrapHookHandler
+from osbenchmark.builder.utils.config_applier import ConfigApplier
+from osbenchmark.builder.utils.path_manager import PathManager
+from osbenchmark.builder.utils.template_renderer import TemplateRenderer
+
+
+class PluginInstaller(Installer):
+    def __init__(self, plugin, executor, hook_handler_class=BootstrapHookHandler):
+        super().__init__(executor)
+        self.logger = logging.getLogger(__name__)
+        self.plugin = plugin
+        self.hook_handler = hook_handler_class(self.plugin)
+        if self.hook_handler.can_load():
+            self.hook_handler.load()
+        self.template_renderer = TemplateRenderer()
+        self.path_manager = PathManager(executor)
+        self.config_applier = ConfigApplier(executor, self.template_renderer, self.path_manager)
+
+    # pylint: disable=arguments-differ
+    def install(self, host, binaries, all_node_ips, config_vars=None):
+        install_cmd = self._get_install_command(host, binaries)
+        self.executor.execute(host, install_cmd)
+
+        if not config_vars:
+            config_vars = self.get_config_vars()
+        self.config_applier.apply_configs(host, host.node, self.plugin.config_paths, config_vars)
+
+    def _get_install_command(self, host, binaries):
+        installer_binary_path = os.path.join(host.node.binary_path, "bin", "opensearch-plugin")
+        plugin_binary_path = binaries.get(self.plugin.name)
+
+        if plugin_binary_path:
+            self.logger.info("Installing [%s] into [%s] from [%s]", self.plugin.name, host.node.binary_path, plugin_binary_path)
+            return '%s install --batch "%s"' % (installer_binary_path, plugin_binary_path)
+        else:
+            self.logger.info("Installing [%s] into [%s]", self.plugin.name, host.node.binary_path)
+            return '%s install --batch "%s"' % (installer_binary_path, self.plugin.name)
+
+    def get_config_vars(self):
+        return self.plugin.variables
+
+    def invoke_install_hook(self, phase, variables, env):
+        self.hook_handler.invoke(phase.name, variables=variables, env=env)
+
+    def cleanup(self, host):
+        pass

tests/builder/installers/plugin_installer_test.py

@@ -0,0 +1,52 @@
+from unittest import TestCase, mock
+from unittest.mock import Mock
+
+from osbenchmark.builder.installers.plugin_installer import PluginInstaller
+from osbenchmark.builder.models.host import Host
+from osbenchmark.builder.models.node import Node
+from osbenchmark.builder.provision_config import PluginDescriptor
+
+
+class PluginInstallerTest(TestCase):
+    def setUp(self):
+        self.node = Node(binary_path="/fake_binary_path", data_paths=["/fake1", "/fake2"], name=None,
+                         pid=None, telemetry=None, port=None, root_dir=None, log_path=None, heap_dump_path=None)
+        self.host = Host(name="fake", address="10.17.22.23", metadata={}, node=self.node)
+        self.binaries = {"unit-test-plugin": "/data/builds/distributions"}
+        self.all_node_ips = []
+
+        self.executor = Mock()
+        self.plugin = PluginDescriptor(name="unit-test-plugin", config_paths=["default"], variables={"active": True})
+
+        self.plugin_installer = PluginInstaller(self.plugin, self.executor)
+        self.plugin_installer.config_applier = Mock()
+
+    def test_plugin_install_with_binary_path(self):
+        self.plugin_installer.install(self.host, self.binaries, self.all_node_ips)
+
+        self.executor.execute.assert_has_calls([
+            mock.call(self.host, "/fake_binary_path/bin/opensearch-plugin install --batch \"/data/builds/distributions\"")
+        ])
+        self.plugin_installer.config_applier.apply_configs.assert_has_calls([
+            mock.call(self.host, self.node, ["default"], {"active": True})
+        ])
+
+    def test_plugin_install_without_binary_path(self):
+        self.plugin_installer.install(self.host, {}, self.all_node_ips)
+
+        self.executor.execute.assert_has_calls([
+            mock.call(self.host, "/fake_binary_path/bin/opensearch-plugin install --batch \"unit-test-plugin\"")
+        ])
+        self.plugin_installer.config_applier.apply_configs.assert_has_calls([
+            mock.call(self.host, self.node, ["default"], {"active": True})
+        ])
+
+    def test_config_vars_override(self):
+        self.plugin_installer.install(self.host, {}, self.all_node_ips, {"my": "override"})
+
+        self.executor.execute.assert_has_calls([
+            mock.call(self.host, "/fake_binary_path/bin/opensearch-plugin install --batch \"unit-test-plugin\"")
+        ])
+        self.plugin_installer.config_applier.apply_configs.assert_has_calls([
+            mock.call(self.host, self.node, ["default"], {"my": "override"})
+        ])