encapsulate ix-plugin provisioning in JailCommandExecution events

Author: gronke

iocage/cli/provision.py

@@ -95,6 +95,7 @@ def _provision(
             )
         except iocage.lib.errors.IocageException:
             exit(1)
+
         try:
             print_function(_execute_provisioner(jail))
         except iocage.lib.errors.IocageException:
@@ -118,6 +119,7 @@ def _execute_provisioner(
     jail: 'iocage.lib.Jail.JailsGenerator'
 ) -> typing.Generator['iocage.lib.events.IocageEvent', None, None]:
     for event in jail.provisioner.provision():
-        if isinstance(event, iocage.lib.events.JailLaunch) and event.done:
-            print(event.stdout)
         yield event
+        if isinstance(event, iocage.lib.events.JailCommandExecution):
+            if event.done is True:
+                print(event.stdout)

iocage/lib/Jail.py

@@ -52,7 +52,6 @@
 import iocage.lib.Config.Jail.Properties.ResourceLimit
 import iocage.lib.ResourceSelector
 import iocage.lib.Config.Jail.File.Fstab
-import iocage.lib.Provisioning
 
 
 class JailResource(
@@ -377,6 +376,7 @@ def provisioner(self) -> 'iocage.lib.Provisioning.prototype.Provisioner':
         except AttributeError:
             pass
 
+        import iocage.lib.Provisioning
         self._provisioner = iocage.lib.Provisioning.Provisioner(jail=self)
         return self._provisioner
 
@@ -1299,14 +1299,20 @@ def exec(  # noqa: T484
         """
         command = ["/usr/sbin/jexec", str(self.jid)] + command
 
-        child, stdout, stderr = iocage.lib.helpers.exec(
+        command_env = self.env
+        if "env" in kwargs:
+            for env_key, env_value in kwargs["env"].items():
+                command_env[env_key] = env_value
+            del kwargs["env"]
+
+        stdout, stderr, returncode = iocage.lib.helpers.exec(
             command,
             logger=self.logger,
-            env=self.env,
+            env=command_env,
             **kwargs  # noqa: T484
         )
 
-        return child, stdout, stderr
+        return stdout, stderr, returncode
 
     def passthru(
         self,

iocage/lib/Provisioning/ix.py

@@ -23,6 +23,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 """iocage provisioner for ix-plugins."""
 import typing
+import os.path
 import json
 import urllib.error
 import urllib.request
@@ -35,6 +36,24 @@
 import iocage.lib.Provisioning
 
 
+class PackageUpdateEvent(iocage.lib.events.JailCommandExecution):
+    """IocageEvent for package update fetching."""
+
+    pass
+
+
+class PackageInstallEvent(iocage.lib.events.JailCommandExecution):
+    """IocageEvent for package installation."""
+
+    pass
+
+
+class PostInstallExecutionEvent(iocage.lib.events.JailCommandExecution):
+    """IocageEvent for post_install.sh execution."""
+
+    pass
+
+
 class PluginDefinition(dict):
     """ix-iocage-plugin definition."""
 
@@ -110,13 +129,24 @@ def provision(
         jail=self.jail,
         event_scope=event_scope
     )
+    yield jailProvisioningEvent.begin()
     _scope = jailProvisioningEvent.scope
-    jailProvisioningAssetDownloadEvent = events.JailProvisioningAssetDownload(
+    event_kargs = dict(
         jail=self.jail,
         event_scope=_scope
     )
-
-    yield jailProvisioningEvent.begin()
+    jailProvisioningAssetDownloadEvent = events.JailProvisioningAssetDownload(
+        **event_kargs
+    )
+    packageUpdateEvent = PackageUpdateEvent(
+        **event_kargs
+    )
+    packageInstallEvent = PackageInstallEvent(
+        **event_kargs
+    )
+    postInstallExecutionEvent = PostInstallExecutionEvent(
+        **event_kargs
+    )
 
     # download provisioning assets
     try:
@@ -148,19 +178,52 @@ def provision(
     self.jail.fstab.save()
 
     if "pkgs" in pluginDefinition.keys():
-        pkg_packages = " ".join(pluginDefinition["pkgs"])
+        pkg_packages = list(pluginDefinition["pkgs"])
     else:
-        pkg_packages = pluginDefinition.name
+        pkg_packages = [pluginDefinition.name]
 
-    commands = [
-        "ASSUME_ALWAYS_YES=true pkg update",
-        f"ASSUME_ALWAYS_YES=true pkg install -y {pkg_packages}",
-        "./ix-plugin/post_install.sh"
-    ]
-
-    for event in self.jail.fork_exec("\n".join(commands)):
+    for event in self.jail.start():
         yield event
 
+    try:
+        yield packageUpdateEvent.begin()
+        try:
+            stdout, stderr, returncode = self.jail.exec(
+                ["pkg", "update"],
+                env=dict(ASSUME_ALWAYS_YES="true")
+            )
+            yield packageUpdateEvent.end(stdout=stdout)
+        except iocage.lib.errors.IocageException as e:
+            yield packageUpdateEvent.fail(e)
+            raise e
+
+        yield packageInstallEvent.begin()
+        try:
+            stdout, stderr, returncode = self.jail.exec(
+                ["pkg", "install", "-y"] + pkg_packages,
+                env=dict(ASSUME_ALWAYS_YES="true")
+            )
+            yield packageInstallEvent.end(stdout=stdout)
+        except iocage.lib.errors.IocageException as e:
+            yield packageInstallEvent.fail(e)
+            raise e
+
+        yield postInstallExecutionEvent.begin()
+        try:
+            if os.path.isfile(f"{plugin_dataset.mountpoint}/post_install.sh"):
+                stdout, stderr, returncode = self.jail.exec(
+                    ["/.ix-plugin/post_install.sh"]
+                )
+                yield postInstallExecutionEvent.end(stdout=stdout)
+            else:
+                yield postInstallExecutionEvent.skip()
+        except iocage.lib.errors.IocageException as e:
+            yield postInstallExecutionEvent.fail(e)
+            raise e
+    finally:
+        for event in self.jail.stop(force=True):
+            yield event
+
     yield jailProvisioningEvent.end()
 
 
@@ -170,6 +233,7 @@ def __get_empty_dataset(
 ) -> libzfs.ZFSDataset:
     try:
         dataset = zfs.get_dataset(dataset_name)
+        dataset.umount()
         zfs.delete_dataset_recursive(dataset)
     except libzfs.ZFSException:
         pass

iocage/lib/events.py

@@ -892,3 +892,22 @@ def __init__(  # noqa: T484
     ) -> None:
 
         JailEvent.__init__(self, jail, **kwargs)
+
+
+class JailCommandExecution(JailEvent):
+    """Run command in a jail."""
+
+    stdout: typing.Optional[str]
+
+    def __init__(  # noqa: T484
+        self,
+        jail: 'iocage.lib.Jail.JailGenerator',
+        **kwargs
+    ) -> None:
+        self.stdout = None
+        JailEvent.__init__(self, jail, **kwargs)
+
+    def end(self, stdout, **kwargs) -> 'IocageEvent':  # noqa: T484
+        """Successfully finish an event."""
+        self.stdout = stdout
+        return IocageEvent.end(self, **kwargs)