lib.Distro, ExecContext: Add classes, refactor lib.distro

The code below lib.distro, as left behind by the previous commit, is
geared towards being directly used as a command-line API. This commit
introduces the abstract base class Distro, a proxy for
distribution-specific interactions. The proxy abstracts distro
specifics into an API with proper method prototypes, not
argparse.Namespace contents, and can thus be more easily driven by
arbitrary code.

The Distro class is initialized with a member variable of type
ExecContext, another new class introduced by this commit. It is
designed to abstract the communication channel to the distribution
instance.  Currently only one specialization exists, Local, which
interacts with the distribution and root file system it is running
in, but is planned to be subclassed to support interaction via SSH,
serial, chroot, or chains thereof.

Signed-off-by: Jan Lindemann <jan@janware.com>

make/projects-dir.mk

@@ -116,7 +116,7 @@ ifeq ($(TIME),)
 endif
 JW_PKG_PY_PROJECTS           = $(TIME) $(JW_PKG_PY) projects
 JW_PKG_PY_BUILD              = $(JW_PKG_PY_PROJECTS) build $(JW_PKG_PY_EXTRA_BUILD_OPTS)
-PKG_MANAGER                 ?= $(TIME) $(JW_PKG_PY) distro --interactive=$(INTERACTIVE)
+PKG_MANAGER                 ?= $(TIME) $(JW_PKG_PY) --interactive=$(INTERACTIVE) distro
 
 ifneq ($(origin PROJECTS_DIR_REMOTE_BASE),undefined)
   PGIT_SH                   += --remote-base $(PROJECTS_DIR_REMOTE_BASE)

make/topdir.mk

@@ -22,7 +22,7 @@ GIT_MAIN_BRANCH             ?= master
 
 OPT_JANWARE_PROJECT         ?= -j
 INTERACTIVE                 ?= auto
-PKG_MANAGER                 ?= $(JW_PKG_PY) distro --interactive=$(INTERACTIVE)
+PKG_MANAGER                 ?= $(JW_PKG_PY) --interactive=$(INTERACTIVE) distro
 
 ifeq ($(OPT_JANWARE_PROJECT),-j)
 REMOTE_GIT_FLAVOUR          ?= proj

src/python/jw/pkg/App.py

@@ -265,6 +265,13 @@ class App(Base):
                     self.__opt_interactive = sys.stdin.isatty()
         return self.__opt_interactive
 
+    @property
+    def exec_context(self) -> str:
+        if self.__exec_context is None:
+            from .lib.ec.Local import Local
+            self.__exec_context = Local(interactive=self.interactive)
+        return self.__exec_context
+
     @property
     def top_name(self):
         return self.__top_name

src/python/jw/pkg/cmds/DistroBase.py

@@ -3,6 +3,7 @@
 import re, sys
 from argparse import ArgumentParser
 
+from ..lib.Distro import Distro
 from ..App import App
 from .Cmd import Cmd as Base
 
@@ -12,7 +13,16 @@ class DistroBase(Base): # export
         self.__id = None
         super().__init__(parent, name, help)
         self._add_subcommands()
-        self.__interactive: bool|None = None
+        self.__distro: Distro|None = None
+
+    @property
+    def distro(self) -> Distro:
+        if self.__distro is None:
+            ret = Distro.instantiate(self.distro_id, ec=self.app.exec_context)
+            self.__distro = ret
+        return self.__distro
+
+    # --------------- legacy methods
 
     @property
     def distro_id(self):
@@ -28,19 +38,6 @@ class DistroBase(Base): # export
     def add_arguments(self, p: ArgumentParser) -> None:
         super().add_arguments(p)
         p.add_argument('--id', default=None, help='Distribution ID (default is taken from /etc/os-release)')
-        p.add_argument('--interactive', choices=['true', 'false', 'auto'], default='true', help="Wait for user input or try to proceed unattended")
-
-    @property
-    def interactive(self) -> bool:
-        if self.__interactive is None:
-            match self.app.args.interactive:
-                case 'true':
-                    self.__interactive = True
-                case 'false':
-                    self.__interactive = False
-                case 'auto':
-                    self.__interactive = sys.stdin.isatty()
-        return self.__interactive
 
     async def _run(self, args):
         # Missing subcommand

src/python/jw/pkg/cmds/distro/Cmd.py

@@ -1,64 +1,28 @@
 # -*- coding: utf-8 -*-
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import os, importlib
 
 from ...lib.log import *
-from ...lib.distros.Util import Util
+
+if TYPE_CHECKING:
+    from ...lib.Distro import Distro
 
 from ..Cmd import Cmd as Base
 from ..CmdDistro import CmdDistro
 
 class Cmd(Base): # export
 
-    from ...lib.distros.Backend import Backend
-
     def __init__(self, parent: CmdDistro, name: str, help: str) -> None:
         super().__init__(parent, name, help)
-        self.__backend_path: str|None = None
+
-        self.__util: Util|None = None
+    @property
-        self.__backend: Backend|None = None
+    def distro(self) -> Distro:
+        return self.parent.distro
 
     @property
     def distro_id(self) -> str:
         return self.parent.distro_id
-
-    @property
-    def interactive(self) -> bool:
-        return self.parent.interactive
-
-    @property
-    def _backend_path(self):
-        if self.__backend_path is None:
-            backend_id = self.parent.distro_id.lower().replace('-', '_')
-            match backend_id:
-                case 'ubuntu' | 'raspbian' | 'kali':
-                    backend_id = 'debian'
-                case 'centos':
-                    backend_id = 'redhat'
-                case 'opensuse' | 'suse':
-                    backend_id = 'suse'
-            self.__backend_path = 'jw.pkg.lib.distros.' + backend_id + '.'
-        return self.__backend_path
-
-    def _instantiate(self, name: str, *args, **kwargs):
-        module_path = self._backend_path + name
-        try:
-            module = importlib.import_module(module_path)
-        except Exception as e:
-            log(ERR, f'Failed to import module {module_path} ({str(e)})')
-            raise
-        cls = getattr(module, name)
-        return cls(self, *args, **kwargs)
-
-    @property
-    def util(self) -> Util:
-        if self.__util is None:
-            self.__util = self._instantiate('Util')
-        return self.__util
-
-    @property
-    def _backend(self) -> Backend:
-        if self.__backend is None:
-            name = self.__class__.__name__[3:] # Get rid of "Cmd"
-            self.__backend = self._instantiate(name)
-        return self.__backend

src/python/jw/pkg/cmds/distro/CmdDelete.py

@@ -15,4 +15,4 @@ class CmdDelete(Cmd): # export
         parser.add_argument("names", nargs="*", help="Names of packages to be deleted")
 
     async def _run(self, args: Namespace) -> None:
-        return await self._backend.run(args)
+        return await self.distro.delete(args.names)

src/python/jw/pkg/cmds/distro/CmdDup.py

@@ -14,6 +14,5 @@ class CmdDup(Cmd): # export
         super().add_arguments(parser)
         parser.add_argument('--download-only', default=False, action='store_true',
                             help='Only download packages from the repos, don\'t install them, yet')
-
     async def _run(self, args: Namespace) -> None:
-        return await self._backend.run(args)
+        return await self.distro.dup(download_only=args.download_only)

src/python/jw/pkg/cmds/distro/CmdInstall.py

@@ -12,8 +12,8 @@ class CmdInstall(Cmd): # export
 
     def add_arguments(self, parser: ArgumentParser) -> None:
         super().add_arguments(parser)
-        parser.add_argument("packages", nargs="*", help="Packages to be installed")
+        parser.add_argument("names", nargs="*", help="Packages to be installed")
         parser.add_argument('--only-update', default=False, action='store_true', help='Only update the listed packages, don\'t install them')
 
     async def _run(self, args: Namespace) -> None:
-        return await self._backend.run(args)
+        return await self.distro.install(args.names, only_update=args.only_update)

src/python/jw/pkg/cmds/distro/CmdRebootRequired.py

@@ -15,4 +15,4 @@ class CmdRebootRequired(Cmd): # export
         parser.add_argument('--verbose', default=False, action='store_true', help='Be chatty about the check')
 
     async def _run(self, args: Namespace) -> None:
-        return await self._backend.run(args)
+        return await self.distro.reboot_required(verbose=args.verbose)

src/python/jw/pkg/cmds/distro/CmdRefresh.py

@@ -14,4 +14,4 @@ class CmdRefresh(Cmd): # export
         super().add_arguments(parser)
 
     async def _run(self, args: Namespace) -> None:
-        return await self._backend.run(args)
+        return await self.distro.ref()

src/python/jw/pkg/cmds/distro/CmdSelect.py

@@ -4,7 +4,6 @@ from argparse import Namespace, ArgumentParser
 import re
 
 from ...lib.Package import Package
-from ...lib.distros.BeSelect import BeSelect
 from ..CmdDistro import CmdDistro
 from .Cmd import Cmd
 
@@ -27,5 +26,5 @@ class CmdSelect(Cmd): # export
 
     async def _run(self, args: Namespace) -> None:
         # TODO: Semantics probably change heavily in the future
-        for p in self.filter_packages(args.filter, await self._backend.all_installed_packages):
+        for p in self.filter_packages(args.filter, await self.distro.select()):
             print(p.name)

src/python/jw/pkg/cmds/distro/pkg/Cmd.py

@@ -7,15 +7,9 @@ from ..CmdPkg import CmdPkg as Parent
 
 class Cmd(Base): # export
 
-    from ....lib.distros.Backend import Backend
-
     def __init__(self, parent: Parent, name: str, help: str) -> None:
         super().__init__(parent, name, help)
 
     def add_arguments(self, parser: ArgumentParser) -> None:
         super().add_arguments(parser)
         parser.add_argument('names', nargs='*', help='Package names')
-
-    @property
-    def _backend(self) -> Backend:
-        return self.parent._backend

src/python/jw/pkg/cmds/distro/pkg/CmdLs.py

@@ -15,4 +15,4 @@ class CmdLs(Cmd): # export
 
     async def _run(self, args: Namespace) -> None:
         for name in args.names:
-            print('\n'.join(await self._backend.files(name)))
+            print('\n'.join(await self.parent.distro.pkg_files(name)))

src/python/jw/pkg/cmds/distro/pkg/CmdMeta.py

@@ -14,10 +14,8 @@ class CmdMeta(Cmd): # export
         super().add_arguments(parser)
 
     async def _run(self, args: Namespace) -> None:
-        for name in args.names:
+        packages = await self.distro.select(args.names)
-            packages = await self._backend.meta_data([name])
+        for package in packages:
-            if packages:
+            if len(args.names) > 1:
-                assert len(packages) == 1
+                print(f'-- {name}')
-                if len(args.names) > 1:
+            print(package)
-                    print(f'-- {name}')
-                print(packages[0])

src/python/jw/pkg/lib/Distro.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import Iterable
+
+import abc, importlib
+
+from .ExecContext import ExecContext, Result
+from .Package import Package
+from .log import *
+
+class Distro(abc.ABC):
+
+    def __init__(self, ec: ExecContext):
+        assert ec is not None
+        self.__exec_context = ec
+
+    # == Load
+
+    @classmethod
+    def instantiate(cls, distro_id: str, *args, **kwargs):
+        backend_id = distro_id.lower().replace('-', '_')
+        match backend_id:
+            case 'ubuntu' | 'raspbian' | 'kali':
+                backend_id = 'debian'
+            case 'centos':
+                backend_id = 'redhat'
+            case 'opensuse' | 'suse':
+                backend_id = 'suse'
+        module_path = 'jw.pkg.lib.distros.' + backend_id + '.Distro'
+        try:
+            module = importlib.import_module(module_path)
+        except Exception as e:
+            log(ERR, f'Failed to import Distro module {module_path} ({str(e)})')
+            raise
+        cls = getattr(module, 'Distro')
+        return cls(*args, **kwargs)
+
+    # == Convenience methods
+
+    @property
+    def ctx(self) -> ExecContext:
+        return self.__exec_context
+
+    def run(self, *args, **kwargs) -> Result:
+        return self.__exec_context.run(*args, **kwargs)
+
+    def sudo(self, *args, **kwargs) -> Result:
+        return self.__exec_context.sudo(*args, **kwargs)
+
+    @property
+    def interactive(self) -> bool:
+        return self.__exec_context.interactive
+
+    # == Distribution specific methods
+
+    # -- ref
+
+    @abc.abstractmethod
+    async def _ref(self) -> None:
+        pass
+
+    async def ref(self) -> None:
+        return await self._ref()
+
+    # -- dup
+
+    @abc.abstractmethod
+    async def _dup(self, download_only: bool) -> None:
+        pass
+
+    async def dup(self, download_only: bool=False) -> None:
+        return await self._dup(download_only=download_only)
+
+    # -- reboot_required
+
+    @abc.abstractmethod
+    async def _reboot_required(self, verbose: bool) -> bool:
+        pass
+
+    async def reboot_required(self, verbose: bool=False) -> bool:
+        return await self._reboot_required(verbose=verbose)
+
+    # -- select
+
+    @abc.abstractmethod
+    async def _select(self, names: Iterable[str]) -> Iterable[Package]:
+        pass
+
+    async def select(self, names: Iterable[str] = []) -> Iterable[Package]:
+        return await self._select(names)
+
+    # -- install
+
+    @abc.abstractmethod
+    async def _install(self, names: Iterable[str], only_update: bool) -> None:
+        pass
+
+    async def install(self, names: Iterable[str], only_update: bool=False) -> None:
+        return await self._install(names, only_update=only_update)
+
+    # -- delete
+
+    @abc.abstractmethod
+    async def _delete(self, names: Iterable[str]) -> None:
+        pass
+
+    async def delete(self, names: Iterable[str]) -> None:
+        return await self._delete(names)
+
+    # -- pkg_files
+
+    @abc.abstractmethod
+    async def _pkg_files(self, name: str) -> Iterable[str]:
+        pass
+
+    async def pkg_files(self, name: str) -> Iterable[str]:
+        return await self._pkg_files(name)

src/python/jw/pkg/lib/ExecContext.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+import abc
+from typing import NamedTuple
+
+class Result(NamedTuple):
+
+    stdout: str|None
+    stderr: str|None
+    status: int|None
+
+class ExecContext(abc.ABC):
+
+    def __init__(self, interactive: bool=True):
+        self.__interactive = interactive
+
+    @property
+    def interactive(self):
+        return self.__interactive
+
+    @abc.abstractmethod
+    async def _run(self, *args, **kwargs) -> Result:
+        pass
+
+    async def run(self, *args, **kwargs) -> Result:
+        return await self._run(*args, **kwargs)
+
+    @abc.abstractmethod
+    async def _sudo(self, cmd: list[str], mod_env: dict[str, str] = {}, opts: list[str]=[], verbose=True) -> Result:
+        pass
+
+    async def sudo(self, cmd: list[str], mod_env: dict[str, str] = {}, opts: list[str]=[], verbose=True) -> Result:
+        return await self._sudo(cmd, mod_env, opts, verbose)

src/python/jw/pkg/lib/distros/Backend.py

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from ..util import run_sudo
-
-if TYPE_CHECKING:
-    from ..Cmd import Cmd
-
-class Backend:
-
-    def __init__(self, parent: Cmd):
-        self.__parent = parent
-
-    async def _sudo(self, *args, **kwargs):
-        return await run_sudo(*args, interactive=self.interactive, **kwargs)
-
-    @property
-    def util(self):
-        return self.__parent.util
-
-    @property
-    def parent(self):
-        return self.__parent
-
-    @property
-    def interactive(self) -> bool:
-        return self.__parent.interactive

src/python/jw/pkg/lib/distros/BeDelete.py

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import abc
-from argparse import Namespace
-
-from .Backend import Backend as Base
-from ..Cmd import Cmd as Parent
-
-class BeDelete(Base):
-
-    def __init__(self, parent: Parent):
-        super().__init__(parent)
-
-    @abc.abstractmethod
-    async def run(self, args: Namespace) -> None:
-        pass

src/python/jw/pkg/lib/distros/BeDup.py

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import abc
-from argparse import Namespace
-
-from .Backend import Backend as Base
-from ..Cmd import Cmd as Parent
-
-class BeDup(Base):
-
-    def __init__(self, parent: Parent):
-        super().__init__(parent)
-
-    @abc.abstractmethod
-    async def run(self, args: Namespace) -> None:
-        pass

src/python/jw/pkg/lib/distros/BeInstall.py

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import abc
-from argparse import Namespace
-
-from .Backend import Backend as Base
-from ..Cmd import Cmd as Parent
-
-class BeInstall(Base):
-
-    def __init__(self, parent: Parent):
-        super().__init__(parent)
-
-    @abc.abstractmethod
-    async def run(self, args: Namespace) -> None:
-        pass