lockss-turtles 0.6.0.dev2__tar.gz → 0.6.0.dev4__tar.gz

{lockss_turtles-0.6.0.dev2 → lockss_turtles-0.6.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lockss-turtles
-Version: 0.6.0.dev2
+Version: 0.6.0.dev4
 Summary: Library and command line tool to manage LOCKSS plugin sets and LOCKSS plugin registries
 License: BSD-3-Clause
 Author: Thib Guicherd-Callin
@@ -19,9 +19,8 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Utilities
 Requires-Dist: java-manifest (>=1.1.0,<1.2.0)
-Requires-Dist: jsonschema (>=4.24.0,<4.25.0)
 Requires-Dist: lockss-pybasic (>=0.1.0,<0.2.0)
-Requires-Dist: pydantic (>=2.11.7,<3.0.0)
+Requires-Dist: pydantic (>=2.11.0,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.0,<6.1.0)
 Requires-Dist: xdg (>=6.0.0,<6.1.0)
 Project-URL: Documentation, https://docs.lockss.org/en/latest/software/turtles

{lockss_turtles-0.6.0.dev2 → lockss_turtles-0.6.0.dev4}/pyproject.toml

@@ -28,7 +28,7 @@
 
 [project]
 name = "lockss-turtles"
-version = "0.6.0-dev2" # Always change in __init__.py, and at release time in README.rst and CHANGELOG.rst
+version = "0.6.0-dev4" # Always change in __init__.py, and at release time in README.rst and CHANGELOG.rst
 description = "Library and command line tool to manage LOCKSS plugin sets and LOCKSS plugin registries"
 license = { text = "BSD-3-Clause" }
 readme = "README.rst"
@@ -41,11 +41,10 @@ maintainers = [
 ]
 dependencies = [
     "java-manifest (>=1.1.0,<1.2.0)",
-    "jsonschema (>=4.24.0,<4.25.0)",
     "lockss-pybasic (>=0.1.0,<0.2.0)",
     "pyyaml (>=6.0.0,<6.1.0)",
     "xdg (>=6.0.0,<6.1.0)",
-    "pydantic (>=2.11.7,<3.0.0)",
+    "pydantic (>=2.11.0,<3.0.0)",
 ]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -74,7 +73,8 @@ include = [
     "README.rst",
 ]
 packages = [
-    { include = "lockss", from = "src" }
+    { include = "lockss", from = "src" },
+    { include = "unittest", from = "tests" },
 ]
 
 [tool.poetry.scripts]

{lockss_turtles-0.6.0.dev2 → lockss_turtles-0.6.0.dev4}/src/lockss/turtles/__init__.py

@@ -5,7 +5,7 @@ Library and command line tool to manage LOCKSS plugin sets and LOCKSS plugin
 registries.
 """
 
-__version__ = '0.6.0-dev2'
+__version__ = '0.6.0-dev4'
 
 __copyright__ = '''
 Copyright (c) 2000-2025, Board of Trustees of Leland Stanford Jr. University

lockss_turtles-0.6.0.dev4/src/lockss/turtles/app.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2000-2025, Board of Trustees of Leland Stanford Jr. University
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+# Remove in Python 3.14
+# See https://stackoverflow.com/questions/33533148/how-do-i-type-hint-a-method-with-the-type-of-the-enclosing-class/33533514#33533514
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from pathlib import Path
+from typing import ClassVar, Literal, Optional, Union
+
+import yaml
+from lockss.pybasic.fileutil import path
+from pydantic import BaseModel, Field
+import xdg
+
+from .plugin import Plugin, PluginIdentifier
+from .plugin_registry import PluginRegistry, PluginRegistryCatalog, PluginRegistryCatalogKind, PluginRegistryKind, PluginRegistryLayerIdentifier
+from .plugin_set import PluginSet, PluginSetCatalog, PluginSetCatalogKind, PluginSetKind
+from .util import BaseModelWithRoot, PathOrStr
+
+
+
+PluginSigningCredentialsKind = Literal['PluginSigningCredentials']
+
+
+class PluginSigningCredentials(BaseModelWithRoot):
+    kind: PluginSigningCredentialsKind = Field(description="This object's kind")
+    plugin_signing_keystore: str = Field(title='Plugin Signing Keystore', description='A path to the plugin signing keystore')
+    plugin_signing_alias: str = Field(title='Plugin Signing Alias', description='The plugin signing alias to use')
+
+    def get_plugin_signing_alias(self) -> str:
+        return self.plugin_signing_alias
+
+    def get_plugin_signing_keystore(self) -> Path:
+        return self.get_root().joinpath(self.plugin_signing_keystore)
+
+
+class TurtlesApp(object):
+
+    CONFIG_DIR_NAME: ClassVar[str] = 'lockss-turtles'
+
+    XDG_CONFIG_DIR: ClassVar[Path] = Path(xdg.xdg_config_home(), CONFIG_DIR_NAME)
+
+    USR_CONFIG_DIR: ClassVar[Path] = Path('/usr/local/share', CONFIG_DIR_NAME)
+
+    ETC_CONFIG_DIR: ClassVar[Path] = Path('/etc', CONFIG_DIR_NAME)
+
+    CONFIG_DIRS: ClassVar[tuple[Path, ...]] = (XDG_CONFIG_DIR, USR_CONFIG_DIR, ETC_CONFIG_DIR)
+
+    PLUGIN_REGISTRY_CATALOG: ClassVar[str] = 'plugin-registry-catalog.yaml'
+
+    PLUGIN_SET_CATALOG: ClassVar[str] = 'plugin-set-catalog.yaml'
+
+    PLUGIN_SIGNING_CREDENTIALS: ClassVar[str] = 'plugin-signing-credentials.yaml'
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._password: Optional[Callable[[], str]] = None
+        self._plugin_registries: list[PluginRegistry] = list()
+        self._plugin_registry_catalogs: list[PluginRegistryCatalog] = list()
+        self._plugin_set_catalogs: list[PluginSetCatalog] = list()
+        self._plugin_sets: list[PluginSet] = list()
+        self._plugin_signing_credentials: Optional[PluginSigningCredentials] = None
+
+    def build_plugin(self, plugin_ids: list[PluginIdentifier]) -> dict[str, tuple[str, Path, Plugin]]:
+        return {plugin_id: self._build_one_plugin(plugin_id) for plugin_id in plugin_ids}
+
+    def deploy_plugin(self, src_paths: list[Path], layer_ids: list[PluginRegistryLayerIdentifier], interactive: bool=False) -> dict[tuple[Path, str], list[tuple[str, str, Optional[Path], Optional[Plugin]]]]:
+        plugin_ids = [Plugin.id_from_jar(src_path) for src_path in src_paths]
+        return {(src_path, plugin_id): self._deploy_one_plugin(src_path,
+                                                               plugin_id,
+                                                               layer_ids,
+                                                               interactive=interactive) for src_path, plugin_id in zip(src_paths, plugin_ids)}
+
+    def load_plugin_registries(self, plugin_registry_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_registry_path = path(plugin_registry_path_or_str)
+        if plugin_registry_path in map(lambda pr: pr.get_root(), self._plugin_registries):
+            raise ValueError(f'Plugin registries already loaded from: {plugin_registry_path!s}')
+        with plugin_registry_path.open('r') as fpr:
+            for yaml_obj in yaml.safe_load_all(fpr):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginRegistryKind.__args__:
+                    plugin_registry = PluginRegistry(**yaml_obj).initialize(plugin_registry_path)
+                    self._plugin_registries.append(plugin_registry)
+        return self
+
+    def load_plugin_registry_catalogs(self, plugin_registry_catalog_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_registry_catalog_path = path(plugin_registry_catalog_path_or_str)
+        if plugin_registry_catalog_path in map(lambda prc: prc.get_root(), self._plugin_registry_catalogs):
+            raise ValueError(f'Plugin registry catalogs already loaded from: {plugin_registry_catalog_path!s}')
+        with plugin_registry_catalog_path.open('r') as fprc:
+            for yaml_obj in yaml.safe_load_all(fprc):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginRegistryCatalogKind.__args__:
+                    plugin_registry_catalog = PluginRegistryCatalog(**yaml_obj).initialize(plugin_registry_catalog_path)
+                    self._plugin_registry_catalogs.append(plugin_registry_catalog)
+                    for plugin_registry_file in plugin_registry_catalog.get_plugin_registry_files():
+                        self.load_plugin_registries(plugin_registry_catalog_path.joinpath(plugin_registry_file))
+        return self
+
+    def load_plugin_set_catalogs(self, plugin_set_catalog_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_set_catalog_path = path(plugin_set_catalog_path_or_str)
+        if plugin_set_catalog_path in map(lambda psc: psc.get_root(), self._plugin_set_catalogs):
+            raise ValueError(f'Plugin set catalogs already loaded from: {plugin_set_catalog_path!s}')
+        with plugin_set_catalog_path.open('r') as fpsc:
+            for yaml_obj in yaml.safe_load_all(fpsc):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginSetCatalogKind.__args__:
+                    plugin_set_catalog = PluginSetCatalog(**yaml_obj).initialize(plugin_set_catalog_path)
+                    self._plugin_set_catalogs.append(plugin_set_catalog)
+                    for plugin_set_file in plugin_set_catalog.get_plugin_set_files():
+                        self.load_plugin_sets(plugin_set_catalog_path.joinpath(plugin_set_file))
+        return self
+
+    def load_plugin_sets(self, plugin_set_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_set_path = path(plugin_set_path_or_str)
+        if plugin_set_path in map(lambda ps: ps.get_root(), self._plugin_sets):
+            raise ValueError(f'Plugin sets already loaded from: {plugin_set_path!s}')
+        with plugin_set_path.open('r') as fps:
+            for yaml_obj in yaml.safe_load_all(fps):
+                if isinstance(yaml_obj, dict) and yaml_obj.get('kind') in PluginSetKind.__args__:
+                    plugin_set = PluginSet(**yaml_obj).initialize(plugin_set_path)
+                    self._plugin_sets.append(plugin_set)
+        return self
+
+    def load_plugin_signing_credentials(self, plugin_signing_credentials_path_or_str: PathOrStr) -> TurtlesApp:
+        plugin_signing_credentials_path = path(plugin_signing_credentials_path_or_str)
+        if self._plugin_signing_credentials:
+            raise ValueError(f'Plugin signing credentials already loaded from: {self._plugin_signing_credentials.get_root()!s}')
+        with plugin_signing_credentials_path.open('r') as fpsc:
+            self._plugin_signing_credentials = PluginSigningCredentials(**yaml.safe_load(fpsc)).initialize(plugin_signing_credentials_path)
+        return self
+
+    def release_plugin(self, plugin_ids: list[PluginIdentifier], layer_ids: list[PluginRegistryLayerIdentifier], interactive: bool=False) -> dict[str, list[tuple[str, str, Path, Plugin]]]:
+        # ... plugin_id -> (set_id, jar_path, plugin)
+        ret1 = self.build_plugin(plugin_ids)
+        jar_paths = [jar_path for set_id, jar_path, plugin in ret1.values()]
+        # ... (src_path, plugin_id) -> list of (registry_id, layer_id, dst_path, plugin)
+        ret2 = self.deploy_plugin(jar_paths,
+                                  layer_ids,
+                                  interactive=interactive)
+        return {plugin_id: val for (jar_path, plugin_id), val in ret2.items()}
+
+    def set_password(self, pw: Union[Callable[[], str], str]) -> None:
+        self._password = pw if callable(pw) else lambda: pw
+
+    def _build_one_plugin(self, plugin_id: str) -> tuple[str, Optional[Path], Optional[Plugin]]:
+        for plugin_set in self._plugin_sets:
+            if plugin_set.has_plugin(plugin_id):
+                bp = plugin_set.build_plugin(plugin_id,
+                                             self._get_plugin_signing_keystore(),
+                                             self._get_plugin_signing_alias(),
+                                             self._get_plugin_signing_password())
+                return plugin_set.get_id(), bp[0] if bp else None, bp[1] if bp else None
+        raise Exception(f'{plugin_id}: not found in any plugin set')
+
+    def _deploy_one_plugin(self, src_jar: Path, plugin_id: PluginIdentifier, layer_ids: list[PluginRegistryLayerIdentifier], interactive: bool=False) -> list[tuple[str, str, Optional[Path], Optional[Plugin]]]:
+        ret = list()
+        for plugin_registry in self._plugin_registries:
+            if plugin_registry.has_plugin(plugin_id):
+                for layer_id in layer_ids:
+                    layer = plugin_registry.get_layer(layer_id)
+                    if layer is not None:
+                        dp = layer.deploy_plugin(plugin_id,
+                                                 src_jar,
+                                                 interactive=interactive)
+                        ret.append((plugin_registry.get_id(),
+                                    layer.get_id(),
+                                    dp[0] if dp else None,
+                                    dp[1] if dp else None))
+        if len(ret) == 0:
+            raise Exception(f'{src_jar}: {plugin_id} not declared in any plugin registry')
+        return ret
+
+    def _get_password(self) -> Optional[str]:
+        return self._password() if self._password else None
+
+    def _get_plugin_signing_alias(self) -> str:
+        return self._plugin_signing_credentials.get_plugin_signing_alias()
+
+    def _get_plugin_signing_keystore(self) -> Path:
+        return self._plugin_signing_credentials.get_plugin_signing_keystore()
+
+    def _get_plugin_signing_password(self) -> str:
+        return self._get_password()
+
+    @staticmethod
+    def default_plugin_registry_catalog_choices() -> tuple[Path, ...]:
+        return TurtlesApp._default_files(TurtlesApp.PLUGIN_REGISTRY_CATALOG)
+
+    @staticmethod
+    def default_plugin_set_catalog_choices() -> tuple[Path, ...]:
+        return TurtlesApp._default_files(TurtlesApp.PLUGIN_SET_CATALOG)
+
+    @staticmethod
+    def default_plugin_signing_credentials_choices() -> tuple[Path, ...]:
+        return TurtlesApp._default_files(TurtlesApp.PLUGIN_SIGNING_CREDENTIALS)
+
+    @staticmethod
+    def select_default_plugin_registry_catalog() -> Optional[Path]:
+        return TurtlesApp._select_file(TurtlesApp.default_plugin_registry_catalog_choices())
+
+    @staticmethod
+    def select_default_plugin_set_catalog() -> Optional[Path]:
+        return TurtlesApp._select_file(TurtlesApp.default_plugin_set_catalog_choices())
+
+    @staticmethod
+    def select_default_plugin_signing_credentials() -> Optional[Path]:
+        return TurtlesApp._select_file(TurtlesApp.default_plugin_signing_credentials_choices())
+
+    @staticmethod
+    def _default_files(file_str) -> tuple[Path, ...]:
+        return tuple(dir_path.joinpath(file_str) for dir_path in TurtlesApp.CONFIG_DIRS)
+
+    @staticmethod
+    def _select_file(choices: Iterable[Path]) -> Optional[Path]:
+        for p in choices:
+            if p.is_file():
+                return p
+        return None

{lockss_turtles-0.6.0.dev2 → lockss_turtles-0.6.0.dev4}/src/lockss/turtles/cli.py

@@ -41,73 +41,104 @@ from lockss.pybasic.outpututil import OutputFormatOptions
 from pydantic.v1 import BaseModel, Field, FilePath
 from pydantic.v1.class_validators import validator
 import tabulate
-from typing import List, Optional
+from typing import Optional
 
 from . import __copyright__, __license__, __version__
 from .app import TurtlesApp
+from .plugin_registry import PluginRegistryLayerIdentifier
+from .util import file_or
 
 
 class PluginBuildingOptions(BaseModel):
-    plugin_set_catalog: Optional[FilePath] = Field(aliases=['-s'], description=f'(plugin set catalog) load the plugin set catalog from the given file, or if none, from {" or ".join(map(str, TurtlesApp.default_plugin_set_catalogs()))}')
-    plugin_signing_credentials: Optional[FilePath] = Field(aliases=['-c'], description=f'(plugin signing credentials) load the plugin signing credentials from the given file, or if none, from {" or ".join(map(str, TurtlesApp.default_plugin_signing_credentials()))}')
+    plugin_set: Optional[list[FilePath]] = Field(aliases=['-s'], description=f'(plugin sets) add one or more plugin sets to the loaded plugin sets')
+    plugin_set_catalog: Optional[list[FilePath]] = Field(aliases=['-S'], description=f'(plugin sets) add one or more plugin set catalogs to the loaded plugin set catalogs; if no plugin set catalogs or plugin sets are specified, load {file_or(TurtlesApp.default_plugin_set_catalog_choices())}')
+    plugin_signing_credentials: Optional[FilePath] = Field(aliases=['-c'], description=f'(plugin signing credentials) load the plugin signing credentials from the given file, or if none, from {file_or(TurtlesApp.default_plugin_signing_credentials_choices())}')
     plugin_signing_password: Optional[str] = Field(description='(plugin signing credentials) set the plugin signing password, or if none, prompt interactively')
 
+    def get_plugin_sets(self) -> list[Path]:
+        return [path(p) for p in self.plugin_set or []]
+
+    def get_plugin_set_catalogs(self) -> list[Path]:
+        if self.plugin_set or self.plugin_set_catalog:
+            return [path(p) for p in self.plugin_set_catalog or []]
+        if single := TurtlesApp.select_default_plugin_set_catalog():
+            return [single]
+        raise FileNotFoundError(file_or(TurtlesApp.default_plugin_set_catalog_choices()))
+
+    def get_plugin_signing_credentials(self) -> Path:
+        if self.plugin_signing_credentials:
+            return path(self.plugin_signing_credentials)
+        if ret := TurtlesApp.select_default_plugin_signing_credentials():
+            return ret
+        raise FileNotFoundError(file_or(TurtlesApp.default_plugin_signing_credentials_choices()))
+
 
 class PluginDeploymentOptions(BaseModel):
-    plugin_registry_catalog: Optional[FilePath] = Field(aliases=['-r'], description=f'(plugin registry catalog) load the plugin registry catalog from the given file, or if none, from {" or ".join(map(str, TurtlesApp.default_plugin_registry_catalogs()))}')
-    plugin_registry_layer: Optional[List[str]] = Field(aliases=['-l'], description='(plugin registry layers) add one or more plugin registry layers to the set of plugin registry layers to process')
-    plugin_registry_layers: Optional[List[FilePath]] = Field(aliases=['-L'], description='(plugin registry layers) add the plugin registry layers listed in one or more files to the set of plugin registry layers to process')
+    plugin_registry: Optional[list[FilePath]] = Field(aliases=['-r'], description=f'(plugin registry) add one or more plugin registries to the loaded plugin registries')
+    plugin_registry_catalog: Optional[list[FilePath]] = Field(aliases=['-R'], description=f'(plugin registry) add one or more plugin registry catalogs to the loaded plugin registry catalogs; if no plugin registry catalogs or plugin registries are specified, load {file_or(TurtlesApp.default_plugin_registry_catalog_choices())}')
+    plugin_registry_layer: Optional[list[str]] = Field(aliases=['-l'], description='(plugin registry layers) add one or more plugin registry layers to the set of plugin registry layers to process')
+    plugin_registry_layers: Optional[list[FilePath]] = Field(aliases=['-L'], description='(plugin registry layers) add the plugin registry layers listed in one or more files to the set of plugin registry layers to process')
     testing: Optional[bool] = Field(False, aliases=['-t'], description='(plugin registry layers) synonym for --plugin-registry-layer testing (i.e. add "testing" to the list of plugin registry layers to process)')
     production: Optional[bool] = Field(False, aliases=['-p'], description='(plugin registry layers) synonym for --plugin-registry-layer production (i.e. add "production" to the list of plugin registry layers to process)')
 
     @validator('plugin_registry_layers', each_item=True, pre=True)
-    def _expand_each_plugin_registry_layers_path(cls, v: Path):
+    def _expand_each_plugin_registry_layers_path(cls, v: Path) -> Path:
         return path(v)
 
-    def get_plugin_registry_layers(self):
-        ret = [*self.plugin_registry_layer[:], *[file_lines(file_path) for file_path in self.plugin_registry_layers]]
+    def get_plugin_registries(self) -> list[Path]:
+        return [path(p) for p in self.plugin_registry or []]
+
+    def get_plugin_registry_catalogs(self) -> list[Path]:
+        if self.plugin_registry or self.plugin_registry_catalog:
+            return [path(p) for p in self.plugin_registry_catalog or []]
+        if single := TurtlesApp.select_default_plugin_registry_catalog():
+            return [single]
+        raise FileNotFoundError(file_or(TurtlesApp.default_plugin_set_catalog_choices()))
+
+    def get_plugin_registry_layers(self) -> list[PluginRegistryLayerIdentifier]:
+        ret = [*(self.plugin_registry_layer or []), *[file_lines(file_path) for file_path in self.plugin_registry_layers or []]]
         for layer in reversed(['testing', 'production']):
             if getattr(self, layer, False):
                 ret.insert(0, layer)
-        if len(ret) == 0:
-            raise RuntimeError('empty list of plugin registry layers')
-        return ret
+        if ret:
+            return ret
+        raise ValueError('Empty list of plugin registry layers')
 
 
 class PluginIdentifierOptions(BaseModel):
     """
     The --identifier/-i and --identifiers/-I options.
     """
-    plugin_identifier: Optional[List[str]] = Field([], aliases=['-i'], description='(plugin identifiers) add one or more plugin identifiers to the set of plugin identifiers to process')
-    plugin_identifiers: Optional[List[FilePath]] = Field([], aliases=['-I'], description='(plugin identifiers) add the plugin identifiers listed in one or more files to the set of plugin identifiers to process')
+    plugin_identifier: Optional[list[str]] = Field(aliases=['-i'], description='(plugin identifiers) add one or more plugin identifiers to the set of plugin identifiers to process')
+    plugin_identifiers: Optional[list[FilePath]] = Field(aliases=['-I'], description='(plugin identifiers) add the plugin identifiers listed in one or more files to the set of plugin identifiers to process')
 
     @validator('plugin_identifiers', each_item=True, pre=True)
-    def _expand_each_plugin_identifiers_path(cls, v: Path):
+    def _expand_each_plugin_identifiers_path(cls, v: Path) -> Path:
         return path(v)
 
-    def get_plugin_identifiers(self) -> List[str]:
-        ret = [*self.plugin_identifier[:], *[file_lines(file_path) for file_path in self.plugin_identifiers]]
-        if len(ret) == 0:
-            raise RuntimeError('empty list of plugin identifiers')
-        return ret
+    def get_plugin_identifiers(self) -> list[str]:
+        ret = [*(self.plugin_identifier or []), *[file_lines(file_path) for file_path in self.plugin_identifiers or []]]
+        if ret:
+            return ret
+        raise ValueError('Empty list of plugin identifiers')
 
 
 class PluginJarOptions(BaseModel):
     """
     The --plugin-jar/-j and --plugin-jars/-J options.
     """
-    plugin_jar: Optional[List[FilePath]] = Field([], aliases=['-j'], description='(plugin JARs) add one or more plugin JARs to the set of plugin JARs to process')
-    plugin_jars: Optional[List[FilePath]] = Field([], aliases=['-J'], description='(plugin JARs) add the plugin JARs listed in one or more files to the set of plugin JARs to process')
+    plugin_jar: Optional[list[FilePath]] = Field(aliases=['-j'], description='(plugin JARs) add one or more plugin JARs to the set of plugin JARs to process')
+    plugin_jars: Optional[list[FilePath]] = Field(aliases=['-J'], description='(plugin JARs) add the plugin JARs listed in one or more files to the set of plugin JARs to process')
 
     @validator('plugin_jar', 'plugin_jars', each_item=True, pre=True)
-    def _expand_each_plugin_jars_path(cls, v: Path):
+    def _expand_each_plugin_jars_path(cls, v: Path) -> Path:
         return path(v)
 
     def get_plugin_jars(self):
-        ret = [*self.plugin_jar[:], *[file_lines(file_path) for file_path in self.plugin_jars]]
-        if len(ret) == 0:
-            raise RuntimeError('empty list of plugin JARs')
-        return ret
+        ret = [*(self.plugin_jar or []), *[file_lines(file_path) for file_path in self.plugin_jars or []]]
+        if len(ret):
+            return ret
+        raise ValueError('Empty list of plugin JARs')
 
 
 class NonInteractiveOptions(BaseModel):
@@ -208,10 +239,12 @@ class TurtlesCli(BaseCli[TurtlesCommand]):
         return self._build_plugin(build_plugin_command)
 
     def _build_plugin(self, build_plugin_command: BuildPluginCommand) -> None:
-        # Prerequisites
-        self._app.load_plugin_sets(build_plugin_command.plugin_set_catalog)
-        self._app.load_plugin_signing_credentials(build_plugin_command.plugin_signing_credentials)
-        self._obtain_password(build_plugin_command)
+        for psc in build_plugin_command.get_plugin_set_catalogs():
+            self._app.load_plugin_set_catalogs(psc)
+        for ps in build_plugin_command.get_plugin_sets():
+            self._app.load_plugin_sets(ps)
+        self._app.load_plugin_signing_credentials(build_plugin_command.get_plugin_signing_credentials())
+        self._obtain_password(build_plugin_command, non_interactive=build_plugin_command.non_interactive)
         # Action
         # ... plugin_id -> (set_id, jar_path, plugin)
         ret = self._app.build_plugin(build_plugin_command.get_plugin_identifiers())
@@ -224,8 +257,10 @@ class TurtlesCli(BaseCli[TurtlesCommand]):
         self._do_string_command(string_command)
 
     def _deploy_plugin(self, deploy_plugin_command: DeployPluginCommand) -> None:
-        # Prerequisites
-        self._app.load_plugin_registries(deploy_plugin_command.plugin_registry_catalog)
+        for prc in deploy_plugin_command.get_plugin_registry_catalogs():
+            self._app.load_plugin_registry_catalogs(prc)
+        for pr in deploy_plugin_command.get_plugin_registries():
+            self._app.load_plugin_registries(pr)
         # Action
         # ... (src_path, plugin_id) -> list of (registry_id, layer_id, dst_path, plugin)
         ret = self._app.deploy_plugin(deploy_plugin_command.get_plugin_jars(),
@@ -245,21 +280,26 @@ class TurtlesCli(BaseCli[TurtlesCommand]):
     def _license(self, string_command: StringCommand) -> None:
         self._do_string_command(string_command)
 
-    def _obtain_password(self, non_interactive_options: NonInteractiveOptions) -> None:
-        if non_interactive_options.plugin_signing_password is not None:
-            _p = non_interactive_options.plugin_signing_password
-        elif non_interactive_options.non_interactive:
+    def _obtain_password(self, plugin_building_options: PluginBuildingOptions, non_interactive: bool=False) -> None:
+        if plugin_building_options.plugin_signing_password:
+            _p = plugin_building_options.plugin_signing_password
+        elif not non_interactive:
             _p = getpass('Plugin signing password: ')
         else:
             self._parser.error('no plugin signing password specified while in non-interactive mode')
         self._app.set_password(lambda: _p)
 
     def _release_plugin(self, release_plugin_command: ReleasePluginCommand) -> None:
-        # Prerequisites
-        self._app.load_plugin_sets(release_plugin_command.plugin_set_catalog)
-        self._app.load_plugin_registries(release_plugin_command.plugin_registry_catalog)
-        self._app.load_plugin_signing_credentials(release_plugin_command.plugin_signing_credentials)
-        self._obtain_password(release_plugin_command)
+        for psc in release_plugin_command.get_plugin_set_catalogs():
+            self._app.load_plugin_set_catalogs(psc)
+        for ps in release_plugin_command.get_plugin_sets():
+            self._app.load_plugin_sets(ps)
+        for prc in release_plugin_command.get_plugin_registry_catalogs():
+            self._app.load_plugin_registry_catalogs(prc)
+        for pr in release_plugin_command.get_plugin_registries():
+            self._app.load_plugin_registries(pr)
+        self._app.load_plugin_signing_credentials(release_plugin_command.get_plugin_signing_credentials())
+        self._obtain_password(release_plugin_command, non_interactive=release_plugin_command.non_interactive)
         # Action
         # ... plugin_id -> list of (registry_id, layer_id, dst_path, plugin)
         ret = self._app.release_plugin(release_plugin_command.get_plugin_identifiers(),

{lockss_turtles-0.6.0.dev2 → lockss_turtles-0.6.0.dev4}/src/lockss/turtles/plugin.py

@@ -37,14 +37,19 @@ Library to represent a LOCKSS plugin.
 from __future__ import annotations
 
 from collections.abc import Callable
-from pathlib import Path, PurePath
-from typing import Any, List, Optional, Union
+from pathlib import Path
+from typing import Any, Optional
 import xml.etree.ElementTree as ET
 from zipfile import ZipFile
 
-import java_manifest as JM
+import java_manifest
 from lockss.pybasic.fileutil import path
 
+from .util import PathOrStr
+
+
+PluginIdentifier = str
+
 
 class Plugin(object):
 
@@ -56,7 +61,7 @@ class Plugin(object):
         if tag != 'map':
             raise RuntimeError(f'{plugin_path!s}: invalid root element: {tag}')
 
-    def get_aux_packages(self) -> List[str]:
+    def get_aux_packages(self) -> list[str]:
         key = 'plugin_aux_packages'
         lst = [x[1] for x in self._parsed.findall('entry') if x[0].tag == 'string' and x[0].text == key]
         if lst is None or len(lst) < 1:
@@ -65,13 +70,13 @@ class Plugin(object):
             raise ValueError(f'plugin declares {len(lst)} entries for {key}')
         return [x.text for x in lst[0].findall('string')]
 
-    def get_identifier(self) -> Optional[str]:
+    def get_identifier(self) -> Optional[PluginIdentifier]:
         return self._only_one('plugin_identifier')
 
     def get_name(self) -> Optional[str]:
         return self._only_one('plugin_name')
 
-    def get_parent_identifier(self) -> Optional[str]:
+    def get_parent_identifier(self) -> Optional[PluginIdentifier]:
         return self._only_one('plugin_parent')
 
     def get_parent_version(self) -> Optional[int]:
@@ -89,7 +94,7 @@ class Plugin(object):
         return result(lst[0])
 
     @staticmethod
-    def from_jar(jar_path: Union[PurePath, str]) -> Plugin:
+    def from_jar(jar_path: PathOrStr) -> Plugin:
         jar_path = path(jar_path)  # in case it's a string
         plugin_id = Plugin.id_from_jar(jar_path)
         plugin_fstr = str(Plugin.id_to_file(plugin_id))
@@ -98,19 +103,19 @@ class Plugin(object):
                 return Plugin(plugin_file, plugin_fstr)
 
     @staticmethod
-    def from_path(fpath: Union[PurePath, str]) -> Plugin:
+    def from_path(fpath: PathOrStr) -> Plugin:
         fpath = path(fpath)  # in case it's a string
         with open(fpath, 'r') as input_file:
             return Plugin(input_file, fpath)
 
     @staticmethod
-    def file_to_id(plugin_fstr: str) -> str:
+    def file_to_id(plugin_fstr: str) -> PluginIdentifier:
         return plugin_fstr.replace('/', '.')[:-4]  # 4 is len('.xml')
 
     @staticmethod
-    def id_from_jar(jar_path: Union[PurePath, str]) -> str:
+    def id_from_jar(jar_path: PathOrStr) -> PluginIdentifier:
         jar_path = path(jar_path)  # in case it's a string
-        manifest = JM.from_jar(jar_path)
+        manifest = java_manifest.from_jar(jar_path)
         for entry in manifest:
             if entry.get('Lockss-Plugin') == 'true':
                 name = entry.get('Name')
@@ -121,9 +126,9 @@ class Plugin(object):
             raise Exception(f'{jar_path!s}: no Lockss-Plugin entry in META-INF/MANIFEST.MF')
 
     @staticmethod
-    def id_to_dir(plugin_id: str) -> Path:
+    def id_to_dir(plugin_id: PluginIdentifier) -> Path:
         return Plugin.id_to_file(plugin_id).parent
 
     @staticmethod
-    def id_to_file(plugin_id: str) -> Path:
+    def id_to_file(plugin_id: PluginIdentifier) -> Path:
         return Path(f'{plugin_id.replace(".", "/")}.xml')