lockss-turtles 0.6.0.dev2__py3-none-any.whl → 0.6.0.dev4__py3-none-any.whl

lockss/turtles/plugin_registry.py

@@ -33,231 +33,206 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-import importlib.resources as IR
 from pathlib import Path
 import subprocess
-from typing import List, Optional, Tuple, Union
+from typing import Annotated, Any, ClassVar, Literal, Optional, Union
 
+from lockss.pybasic.errorutil import InternalError
 from lockss.pybasic.fileutil import path
+from pydantic import BaseModel, Field
 
-from . import resources as __resources__
-from .plugin import Plugin
-from .util import YamlT, load_and_validate
+from .plugin import Plugin, PluginIdentifier
+from .util import BaseModelWithRoot
 
 
-class PluginRegistryCatalog(object):
 
-    PLUGIN_REGISTRY_CATALOG_SCHEMA = 'plugin-registry-catalog-schema.json'
+PluginRegistryCatalogKind = Literal['PluginRegistryCatalog']
 
-    def __init__(self, parsed: YamlT) -> None:
-        super().__init__()
-        self._parsed: YamlT = parsed
 
-    def get_plugin_registry_files(self) -> List[str]:
-        return self._parsed['plugin-registry-files']
+class PluginRegistryCatalog(BaseModelWithRoot):
+    kind: PluginRegistryCatalogKind = Field(description="This object's kind")
+    plugin_registry_files: list[str] = Field(min_length=1, description="A non-empty list of plugin registry files", title='Plugin Registry Files', alias='plugin-registry-files')
 
-    @staticmethod
-    def from_path(plugin_registry_catalog_path: Union[Path, str]) -> PluginRegistryCatalog:
-        plugin_registry_catalog_path = path(plugin_registry_catalog_path)
-        with IR.path(__resources__, PluginRegistryCatalog.PLUGIN_REGISTRY_CATALOG_SCHEMA) as plugin_registry_catalog_schema_path:
-            parsed = load_and_validate(plugin_registry_catalog_schema_path, plugin_registry_catalog_path)
-            return PluginRegistryCatalog(parsed)
+    def get_plugin_registry_files(self) -> list[Path]:
+        return [self.get_root().joinpath(pstr) for pstr in self.plugin_registry_files]
 
 
-class PluginRegistry(ABC):
+PluginRegistryLayoutType = Literal['directory', 'rcs']
 
-    PLUGIN_REGISTRY_SCHEMA = 'plugin-registry-schema.json'
 
-    def __init__(self, parsed: YamlT):
-        super().__init__()
-        self._parsed: YamlT = parsed
+PluginRegistryLayoutFileNamingConvention = Literal['abbreviated', 'identifier', 'underscore']
 
-    def get_id(self) -> str:
-        return self._parsed['id']
 
-    def get_layer(self, layer_id) -> Optional[PluginRegistryLayer]:
-        for layer in self.get_layers():
-            if layer.get_id() == layer_id:
-                return layer
-        return None
-
-    def get_layer_ids(self) -> List[str]:
-        return [layer.get_id() for layer in self.get_layers()]
-
-    def get_layers(self) -> List[PluginRegistryLayer]:
-        return [self._make_layer(layer_elem) for layer_elem in self._parsed['layers']]
+class BasePluginRegistryLayout(BaseModel, ABC):
+    TYPE_FIELD: ClassVar[dict[str, str]] = dict(title='Plugin Registry Layout Type', description='A plugin registry layout type')
+    FILE_NAMING_CONVENTION_DEFAULT: ClassVar[PluginRegistryLayoutFileNamingConvention] = 'identifier'
+    FILE_NAMING_CONVENTION_FIELD: ClassVar[dict[str, str]] = dict(title='Plugin Registry Layout File Naming Convention', description='A file naming convention for the plugin registry layout', alias='file-naming-convention')
 
-    def get_layout_type(self) -> str:
-        return self._parsed['layout']['type']
+    _plugin_registry: Optional[PluginRegistry]
 
-    def get_name(self) -> str:
-        return self._parsed['name']
-
-    def get_plugin_identifiers(self) -> List[str]:
-        return self._parsed['plugin-identifiers']
-
-    def has_plugin(self, plugin_id) -> bool:
-        return plugin_id in self.get_plugin_identifiers()
-
-    @abstractmethod
-    def _make_layer(self, parsed: YamlT) -> PluginRegistryLayer:
-        pass
+    def deploy_plugin(self, plugin_id: PluginIdentifier, layer: PluginRegistryLayer, src_path: Path, interactive: bool=False) -> Optional[tuple[Path, Plugin]]:
+        src_path = path(src_path)  # in case it's a string
+        dst_path = self._get_dstpath(plugin_id, layer)
+        if not self._proceed_copy(src_path, dst_path, layer, interactive=interactive):
+            return None
+        self._copy_jar(src_path, dst_path, interactive=interactive)
+        return dst_path, Plugin.from_jar(src_path)
 
-    @staticmethod
-    def from_path(plugin_registry_file_path: Union[Path, str]) -> List[PluginRegistry]:
-        plugin_registry_file_path = path(plugin_registry_file_path)
-        with IR.path(__resources__, PluginRegistry.PLUGIN_REGISTRY_SCHEMA) as plugin_registry_schema_path:
-           lst = load_and_validate(plugin_registry_schema_path, plugin_registry_file_path, multiple=True)
-           return [PluginRegistry._from_obj(parsed, plugin_registry_file_path) for parsed in lst]
-
-    @staticmethod
-    def _from_obj(parsed: YamlT, plugin_registry_file_path: Path) -> PluginRegistry:
-        typ = parsed['layout']['type']
-        if typ == DirectoryPluginRegistry.LAYOUT:
-            return DirectoryPluginRegistry(parsed)
-        elif typ == RcsPluginRegistry.LAYOUT:
-            return RcsPluginRegistry(parsed)
-        else:
-            raise RuntimeError(f'{plugin_registry_file_path!s}: unknown layout type: {typ}')
+    def get_file_for(self, plugin_id, layer: PluginRegistryLayer) -> Optional[Path]:
+        jar_path = self._get_dstpath(plugin_id, layer)
+        return jar_path if jar_path.is_file() else None
 
+    def get_file_naming_convention(self) -> PluginRegistryLayoutFileNamingConvention:
+        return getattr(self, 'file_naming_convention')
 
-class PluginRegistryLayer(ABC):
+    def get_plugin_registry(self) -> PluginRegistry:
+        if self._plugin_registry is None:
+            raise RuntimeError('Uninitialized plugin registry')
+        return self._plugin_registry
 
-    PRODUCTION = 'production'
+    def get_type(self) -> PluginRegistryLayoutType:
+        return getattr(self, 'type')
 
-    TESTING = 'testing'
+    def initialize(self, plugin_registry: PluginRegistry) -> BasePluginRegistryLayout:
+        self._plugin_registry = plugin_registry
+        return self
 
-    def __init__(self, plugin_registry: PluginRegistry, parsed: YamlT):
-        super().__init__()
-        self._parsed: YamlT = parsed
-        self._plugin_registry: PluginRegistry = plugin_registry
+    def model_post_init(self, context: Any) -> None:
+        super().model_post_init(context)
+        self._plugin_registry = None
 
     @abstractmethod
-    def deploy_plugin(self, plugin_id: str, jar_path: Path, interactive: bool=False) -> Optional[Tuple[Path, Plugin]]:
+    def _copy_jar(self, src_path: Path, dst_path: Path, interactive: bool=False) -> None:
         pass
 
-    @abstractmethod
-    def get_file_for(self, plugin_id: str) -> Optional[Path]:
-        pass
+    def _get_dstfile(self, plugin_id: PluginIdentifier) -> str:
+        if (conv := self.get_file_naming_convention()) == 'abbreviated':
+            return f'{plugin_id.split(".")[-1]}.jar'
+        elif conv == 'identifier':
+            return f'{plugin_id}.jar'
+        elif conv == 'underscore':
+            return f'{plugin_id.replace(".", "_")}.jar'
+        else:
+            raise InternalError()
 
-    def get_id(self) -> str:
-        return self._parsed['id']
+    def _get_dstpath(self, plugin_id: PluginIdentifier, layer: PluginRegistryLayer) -> Path:
+        return layer.get_path().joinpath(self._get_dstfile(plugin_id))
 
-    @abstractmethod
-    def get_jars(self) -> List[Path]:
-        pass
+    def _proceed_copy(self, src_path: Path, dst_path: Path, layer: PluginRegistryLayer, interactive: bool=False) -> bool:
+        if not dst_path.exists():
+            if interactive:
+                i = input(f'{dst_path} does not exist in {self.get_plugin_registry().get_id()}:{layer.get_id()} ({layer.get_name()}); create it (y/n)? [n] ').lower() or 'n'
+                if i != 'y':
+                    return False
+        return True
 
-    def get_name(self) -> str:
-        return self._parsed['name']
 
-    def get_path(self) -> Path:
-        return path(self._parsed['path'])
+class DirectoryPluginRegistryLayout(BasePluginRegistryLayout):
+    type: Literal['directory'] = Field(**BasePluginRegistryLayout.TYPE_FIELD)
+    file_naming_convention: Optional[PluginRegistryLayoutFileNamingConvention] = Field(BasePluginRegistryLayout.FILE_NAMING_CONVENTION_DEFAULT, **BasePluginRegistryLayout.FILE_NAMING_CONVENTION_FIELD)
 
-    def get_plugin_registry(self) -> PluginRegistry:
-        return self._plugin_registry
+    def _copy_jar(self, src_path: Path, dst_path: Path, interactive: bool=False) -> None:
+        basename = dst_path.name
+        subprocess.run(['cp', str(src_path), str(dst_path)], check=True, cwd=self.get_path())
+        if subprocess.run('command -v selinuxenabled > /dev/null && selinuxenabled && command -v chcon > /dev/null', shell=True).returncode == 0:
+            cmd = ['chcon', '-t', 'httpd_sys_content_t', basename]
+            subprocess.run(cmd, check=True, cwd=self.get_path())
 
 
-class DirectoryPluginRegistry(PluginRegistry):
+class RcsPluginRegistryLayout(DirectoryPluginRegistryLayout):
+    type: Literal['rcs'] = Field(**BasePluginRegistryLayout.TYPE_FIELD)
+    file_naming_convention: Optional[PluginRegistryLayoutFileNamingConvention] = Field(BasePluginRegistryLayout.FILE_NAMING_CONVENTION_DEFAULT, **BasePluginRegistryLayout.FILE_NAMING_CONVENTION_FIELD)
+
+    def _copy_jar(self, src_path: Path, dst_path: Path, interactive: bool=False) -> None:
+        basename = dst_path.name
+        plugin = Plugin.from_jar(src_path)
+        rcs_path = self.get_path().joinpath('RCS', f'{basename},v')
+        # Maybe do co -l before the parent's copy
+        if dst_path.exists() and rcs_path.is_file():
+            cmd = ['co', '-l', basename]
+            subprocess.run(cmd, check=True, cwd=self.get_path())
+        # Do the parent's copy
+        super()._copy_jar(src_path, dst_path)
+        # Do ci -u after the parent's copy
+        cmd = ['ci', '-u', f'-mVersion {plugin.get_version()}']
+        if not rcs_path.is_file():
+            cmd.append(f'-t-{plugin.get_name()}')
+        cmd.append(basename)
+        subprocess.run(cmd, check=True, cwd=self.get_path())
 
-    LAYOUT = 'directory'
 
-    FILE_NAMING_CONVENTION_ABBREVIATED = 'abbreviated'
+PluginRegistryLayout = Annotated[Union[DirectoryPluginRegistryLayout, RcsPluginRegistryLayout], Field(discriminator='type')]
 
-    FILE_NAMING_CONVENTION_IDENTIFIER = 'identifier'
 
-    FILE_NAMING_CONVENTION_UNDERSCORE = 'underscore'
+PluginRegistryLayerIdentifier = str
 
-    DEFAULT_FILE_NAMING_CONVENTION = FILE_NAMING_CONVENTION_IDENTIFIER
 
-    def __init__(self, parsed: YamlT) -> None:
-        super().__init__(parsed)
+class PluginRegistryLayer(BaseModel, ABC):
+    PRODUCTION: ClassVar[str] = 'production'
+    TESTING: ClassVar[str] = 'testing'
 
-    def _make_layer(self, parsed) -> PluginRegistryLayer:
-        return DirectoryPluginRegistryLayer(self, parsed)
+    id: PluginRegistryLayerIdentifier = Field(title='Plugin Registry Layer Identifier', description='An identifier for the plugin registry layer')
+    name: str = Field(title='Plugin Registry Layer Name', description='A name for the plugin registry layer')
+    path: str = Field(title='Plugin Registry Layer Path', description='A root path for the plugin registry layer')
 
+    def get_id(self) -> PluginRegistryLayerIdentifier:
+        return self.id
 
-class DirectoryPluginRegistryLayer(PluginRegistryLayer):
+    def get_jars(self) -> list[Path]:
+        return sorted(self.get_path().glob('*.jar'))
 
-    def __init__(self, plugin_registry: PluginRegistry, parsed: YamlT):
-        super().__init__(plugin_registry, parsed)
+    def get_name(self) -> str:
+        return self.name
 
-    def deploy_plugin(self, plugin_id: str, src_path: Path, interactive: bool=False) -> Optional[Tuple[Path, Plugin]]:
-        src_path = path(src_path)  # in case it's a string
-        dst_path = self._get_dstpath(plugin_id)
-        if not self._proceed_copy(src_path, dst_path, interactive=interactive):
-            return None
-        self._copy_jar(src_path, dst_path, interactive=interactive)
-        return dst_path, Plugin.from_jar(src_path)
+    def get_path(self) -> Path:
+        return path(self.path)
 
-    def get_file_for(self, plugin_id) -> Optional[Path]:
-        jar_path = self._get_dstpath(plugin_id)
-        return jar_path if jar_path.is_file() else None
 
-    def get_file_naming_convention(self) -> str:
-        return self.get_plugin_registry()._parsed['layout'].get('file-naming-convention', DirectoryPluginRegistry.DEFAULT_FILE_NAMING_CONVENTION)
+PluginRegistryKind = Literal['PluginRegistry']
 
-    def get_jars(self) -> List[Path]:
-        return sorted(self.get_path().glob('*.jar'))
 
-    def _copy_jar(self, src_path: Path, dst_path: Path, interactive: bool=False) -> None:
-        basename = dst_path.name
-        subprocess.run(['cp', str(src_path), str(dst_path)], check=True, cwd=self.get_path())
-        if subprocess.run('command -v selinuxenabled > /dev/null && selinuxenabled && command -v chcon > /dev/null', shell=True).returncode == 0:
-            cmd = ['chcon', '-t', 'httpd_sys_content_t', basename]
-            subprocess.run(cmd, check=True, cwd=self.get_path())
+PluginRegistryIdentifier = str
 
-    def _get_dstpath(self, plugin_id: str) -> Path:
-        return self.get_path().joinpath(self._get_dstfile(plugin_id))
 
-    def _get_dstfile(self, plugin_id: str) -> str:
-        conv = self.get_file_naming_convention()
-        if conv == DirectoryPluginRegistry.FILE_NAMING_CONVENTION_IDENTIFIER:
-            return f'{plugin_id}.jar'
-        elif conv == DirectoryPluginRegistry.FILE_NAMING_CONVENTION_UNDERSCORE:
-            return f'{plugin_id.replace(".", "_")}.jar'
-        elif conv == DirectoryPluginRegistry.FILE_NAMING_CONVENTION_ABBREVIATED:
-            return f'{plugin_id.split(".")[-1]}.jar'
-        else:
-            raise RuntimeError(f'{self.get_plugin_registry().get_id()}: unknown file naming convention: {conv}')
+class PluginRegistry(BaseModelWithRoot):
+    kind: PluginRegistryKind = Field(description="This object's kind")
+    id: PluginRegistryIdentifier = Field(title='Plugin Registry Identifier', description='An identifier for the plugin set')
+    name: str = Field(title='Plugin Registry Name', description='A name for the plugin set')
+    layout: PluginRegistryLayout = Field(title='Plugin Registry Layout', description='A layout for the plugin registry')
+    layers: list[PluginRegistryLayer] = Field(min_length=1, title='Plugin Registry Layers', description="A non-empty list of plugin registry layers", alias='plugin-registry-layers')
+    plugin_identifiers: list[PluginIdentifier] = Field(min_length=1, title='Plugin Identifiers', description="A non-empty list of plugin identifiers", alias='plugin-identifiers')
+    suppressed_plugin_identifiers: list[PluginIdentifier] = Field([], title='Suppressed Plugin Identifiers', description="A list of suppressed plugin identifiers", alias='suppressed-plugin-identifiers')
 
-    def _proceed_copy(self, src_path: Path, dst_path: Path, interactive: bool=False) -> bool:
-        if not dst_path.exists():
-            if interactive:
-                i = input(f'{dst_path} does not exist in {self.get_plugin_registry().get_id()}:{self.get_id()} ({self.get_name()}); create it (y/n)? [n] ').lower() or 'n'
-                if i != 'y':
-                    return False
-        return True
+    def get_id(self) -> PluginRegistryIdentifier:
+        return self.id
 
+    def get_layer(self, layer_id: PluginRegistryLayerIdentifier) -> Optional[PluginRegistryLayer]:
+        for layer in self.get_layers():
+            if layer.get_id() == layer_id:
+                return layer
+        return None
 
-class RcsPluginRegistry(DirectoryPluginRegistry):
+    def get_layer_ids(self) -> list[PluginRegistryLayerIdentifier]:
+        return [layer.get_id() for layer in self.get_layers()]
 
-    LAYOUT = 'rcs'
+    def get_layers(self) -> list[PluginRegistryLayer]:
+        return self.layers
 
-    def __init__(self, parsed: YamlT) -> None:
-        super().__init__(parsed)
+    def get_layout(self) -> BasePluginRegistryLayout:
+        return self.layout
 
-    def _make_layer(self, parsed: YamlT) -> PluginRegistryLayer:
-        return RcsPluginRegistryLayer(self, parsed)
+    def get_name(self) -> str:
+        return self.name
 
+    def get_plugin_identifiers(self) -> list[PluginIdentifier]:
+        return self.plugin_identifiers
 
-class RcsPluginRegistryLayer(DirectoryPluginRegistryLayer):
+    def get_suppressed_plugin_identifiers(self) -> list[PluginIdentifier]:
+        return self.suppressed_plugin_identifiers
 
-    def __init__(self, plugin_registry: PluginRegistry, parsed: YamlT) -> None:
-        super().__init__(plugin_registry, parsed)
+    def has_plugin(self, plugin_id: PluginIdentifier) -> bool:
+        return plugin_id in self.get_plugin_identifiers()
 
-    def _copy_jar(self, src_path: Path, dst_path: Path, interactive: bool=False) -> None:
-        basename = dst_path.name
-        plugin = Plugin.from_jar(src_path)
-        rcs_path = self.get_path().joinpath('RCS', f'{basename},v')
-        # Maybe do co -l before the parent's copy
-        if dst_path.exists() and rcs_path.is_file():
-            cmd = ['co', '-l', basename]
-            subprocess.run(cmd, check=True, cwd=self.get_path())
-        # Do the parent's copy
-        super()._copy_jar(src_path, dst_path)
-        # Do ci -u after the parent's copy
-        cmd = ['ci', '-u', f'-mVersion {plugin.get_version()}']
-        if not rcs_path.is_file():
-            cmd.append(f'-t-{plugin.get_name()}')
-        cmd.append(basename)
-        subprocess.run(cmd, check=True, cwd=self.get_path())
+    def model_post_init(self, context: Any) -> None:
+        super().model_post_init(context)
+        self.get_layout().initialize(self)