Registry and managed plugin integration tests

.github/workflows/tests.yml

@@ -19,15 +19,15 @@ on:
       lrr_repository:
         description: 'LANraragi repository path'
         required: true
-        default: 'difegue/LANraragi'
+        default: 'psilabs-dev/LANraragi'
       lrr_ref:
         description: 'LANraragi ref (branch, tag, or commit SHA)'
         required: true
-        default: 'dev'
+        default: 'dev-registry/backend'
 
 env:
-  LRR_REPOSITORY: ${{ github.event.inputs.lrr_repository || 'difegue/LANraragi' }}
-  LRR_REF: ${{ github.event.inputs.lrr_ref || 'dev' }}
+  LRR_REPOSITORY: ${{ github.event.inputs.lrr_repository || 'psilabs-dev/LANraragi' }}
+  LRR_REF: ${{ github.event.inputs.lrr_ref || 'dev-registry/backend' }}
 
 jobs:
 
@@ -104,7 +104,8 @@ jobs:
             --server-logs "$GITHUB_WORKSPACE/server-logs" \
             --playwright \
             --no-rate-limit \
-            --npseed 42
+            --npseed 42 \
+            --dev registry
         env:
           DOCKER_HOST: unix:///var/run/docker.sock
 
@@ -264,7 +265,8 @@ jobs:
           --server-logs "$env:GITHUB_WORKSPACE\server-logs" `
           --playwright `
           --no-rate-limit `
-          --npseed 42
+          --npseed 42 `
+          --dev registry
 
       - name: Upload server logs
         if: failure()

integration_tests/src/aio_lanraragi_tests/deployment/base.py

@@ -176,6 +176,22 @@ def redis_dir(self) -> Path:
         redis_dirname = self.resource_prefix + "redis"
         return self.staging_dir / redis_dirname
 
+    @property
+    def shared_dir(self) -> Path:
+        """
+        Host directory bind-mounted into LRR, for test fixtures that LRR must be
+        able to read. Contents are visible to LRR at
+        ``lrr_mount_path``.
+        """
+        return self.staging_dir / (self.resource_prefix + "shared")
+
+    @abc.abstractmethod
+    def lrr_mount_path(self, host_path: Path) -> str:
+        """
+        Map a host path under ``shared_dir`` to the path at which LRR reads it
+        (a container path under Docker, the host path itself on native runs).
+        """
+
     @property
     def redis_client(self) -> redis.Redis:
         """

integration_tests/src/aio_lanraragi_tests/deployment/container.py

@@ -35,6 +35,7 @@
 from aio_lanraragi_tests.utils.docker import set_pdeathsig
 
 DEFAULT_LANRARAGI_DOCKER_TAG = "difegue/lanraragi"
+LRR_SHARED_CONTAINER_PATH = "/srv/shared"
 
 LOGGER = logging.getLogger(__name__)
 
@@ -223,6 +224,26 @@ def plugins_root_dir(self) -> Path:
         dirname = self.resource_prefix + "plugins"
         return self.staging_dir / dirname
 
+    @property
+    def plugin_managed_dir(self) -> Path:
+        """
+        Bind mount for LRR container:/home/koyomi/lanraragi/lib/LANraragi/Plugin/Managed.
+        """
+        dirname = self.resource_prefix + "plugin_managed"
+        return self.staging_dir / dirname
+
+    @property
+    def plugin_sideloaded_dir(self) -> Path:
+        """
+        Bind mount for LRR container:/home/koyomi/lanraragi/lib/LANraragi/Plugin/Sideloaded.
+        """
+        dirname = self.resource_prefix + "plugin_sideloaded"
+        return self.staging_dir / dirname
+
+    def lrr_mount_path(self, host_path: Path) -> str:
+        rel = Path(host_path).relative_to(self.shared_dir)
+        return f"{LRR_SHARED_CONTAINER_PATH}/{rel.as_posix()}"
+
     @property
     def docker_client(self) -> docker.DockerClient:
         return self._docker_client
@@ -516,6 +537,9 @@ def setup(
         thumb_dir = self.thumb_dir
         logs_dir = self.logs_dir
         redis_dir = self.redis_dir
+        plugin_managed_dir = self.plugin_managed_dir
+        plugin_sideloaded_dir = self.plugin_sideloaded_dir
+        shared_dir = self.shared_dir
         if contents_dir.exists():
             self.logger.debug(f"Contents directory exists: {contents_dir}")
         else:
@@ -541,6 +565,27 @@ def setup(
             # newly created directory before it is used as a bind mount source.
             if sys.platform == "darwin":
                 time.sleep(1)
+        if plugin_managed_dir.exists():
+            self.logger.debug(f"Plugin managed directory exists: {plugin_managed_dir}")
+        else:
+            self.logger.debug(f"Creating plugin managed dir: {plugin_managed_dir}")
+            plugin_managed_dir.mkdir(parents=True, exist_ok=False)
+            if sys.platform == "darwin":
+                time.sleep(1)
+        if plugin_sideloaded_dir.exists():
+            self.logger.debug(f"Plugin sideloaded directory exists: {plugin_sideloaded_dir}")
+        else:
+            self.logger.debug(f"Creating plugin sideloaded dir: {plugin_sideloaded_dir}")
+            plugin_sideloaded_dir.mkdir(parents=True, exist_ok=False)
+            if sys.platform == "darwin":
+                time.sleep(1)
+        if shared_dir.exists():
+            self.logger.debug(f"Shared directory exists: {shared_dir}")
+        else:
+            self.logger.debug(f"Creating shared dir: {shared_dir}")
+            shared_dir.mkdir(parents=True, exist_ok=False)
+            if sys.platform == "darwin":
+                time.sleep(1)
 
         # log the setup resource allocations for user to see
         # the docker image is not included, haven't decided how to classify it yet.
@@ -716,6 +761,9 @@ def setup(
                 str(contents_dir): {"bind": "/home/koyomi/lanraragi/content", "mode": "rw"},
                 str(thumb_dir): {"bind": "/home/koyomi/lanraragi/thumb", "mode": "rw"},
                 str(logs_dir): {"bind": "/home/koyomi/lanraragi/log", "mode": "rw"},
+                str(plugin_managed_dir): {"bind": "/home/koyomi/lanraragi/lib/LANraragi/Plugin/Managed", "mode": "rw"},
+                str(plugin_sideloaded_dir): {"bind": "/home/koyomi/lanraragi/lib/LANraragi/Plugin/Sideloaded", "mode": "rw"},
+                str(self.shared_dir): {"bind": LRR_SHARED_CONTAINER_PATH, "mode": "ro"},
             }
             lrr_volumes.update(plugin_volumes)
             self.lrr_container = self.docker_client.containers.create(
@@ -910,6 +958,8 @@ def _reset_test_env(self, remove_data: bool=False):
                 self.lrr_container.exec_run(["sh", "-c", 'rm -rf /home/koyomi/lanraragi/content/*'], user='root')
                 self.lrr_container.exec_run(["sh", "-c", 'rm -rf /home/koyomi/lanraragi/thumb/*'], user='root')
                 self.lrr_container.exec_run(["sh", "-c", 'rm -rf /home/koyomi/lanraragi/log/*'], user='root')
+                self.lrr_container.exec_run(["sh", "-c", 'rm -rf /home/koyomi/lanraragi/lib/LANraragi/Plugin/Managed/*'], user='root')
+                self.lrr_container.exec_run(["sh", "-c", 'rm -rf /home/koyomi/lanraragi/lib/LANraragi/Plugin/Sideloaded/*'], user='root')
             else:
                 self.logger.info(f"Container not running with status {status} (no teardown commands run): {self.lrr_container_name}")
         if self.lrr_container:
@@ -948,6 +998,15 @@ def _reset_test_env(self, remove_data: bool=False):
             if self.plugins_root_dir.exists():
                 shutil.rmtree(self.plugins_root_dir)
                 self.logger.debug(f"Removed plugins directory: {self.plugins_root_dir}")
+            if self.plugin_managed_dir.exists():
+                shutil.rmtree(self.plugin_managed_dir)
+                self.logger.debug(f"Removed plugin managed directory: {self.plugin_managed_dir}")
+            if self.plugin_sideloaded_dir.exists():
+                shutil.rmtree(self.plugin_sideloaded_dir)
+                self.logger.debug(f"Removed plugin sideloaded directory: {self.plugin_sideloaded_dir}")
+            if self.shared_dir.exists():
+                shutil.rmtree(self.shared_dir)
+                self.logger.debug(f"Removed shared directory: {self.shared_dir}")
             redis_conf_staging = self.staging_dir / (self.resource_prefix + "redis.conf")
             if redis_conf_staging.exists():
                 redis_conf_staging.unlink()

integration_tests/src/aio_lanraragi_tests/deployment/windows.py

@@ -168,6 +168,17 @@ def lrr_lanraragi_path(self) -> Path:
     def lrr_plugin_dir(self) -> Path:
         return self.windist_dir / "lib" / "LANraragi" / "Plugin"
 
+    @property
+    def plugin_managed_dir(self) -> Path:
+        return self.lrr_plugin_dir / "Managed"
+
+    @property
+    def plugin_sideloaded_dir(self) -> Path:
+        return self.lrr_plugin_dir / "Sideloaded"
+
+    def lrr_mount_path(self, host_path: Path) -> str:
+        return str(host_path)
+
     def __init__(
         self, windist_path: str, staging_directory: str, resource_prefix: str, port_offset: int,
         logger: logging.Logger | None=None
@@ -244,6 +255,7 @@ def setup(
         log_dir = self.logs_dir
         pid_dir = self.pid_dir
         redis_dir = self.redis_dir
+        shared_dir = self.shared_dir
         if contents_dir.exists():
             self.logger.debug(f"Contents directory exists: {contents_dir}")
         else:
@@ -274,6 +286,11 @@ def setup(
         else:
             self.logger.debug(f"Creating Redis directory: {redis_dir}")
             redis_dir.mkdir(parents=True, exist_ok=False)
+        if shared_dir.exists():
+            self.logger.debug(f"Shared directory exists: {shared_dir}")
+        else:
+            self.logger.debug(f"Creating shared directory: {shared_dir}")
+            shared_dir.mkdir(parents=True, exist_ok=False)
 
         # we need to handle cases where existing services are running.
         # Unlike docker, we have no idea whether we can skip recreation of
@@ -391,6 +408,7 @@ def teardown(self, remove_data: bool=False):
         windist_dir = self.windist_dir
         redis_dir = self.redis_dir
         temp_dir = self.temp_dir
+        shared_dir = self.shared_dir
         self.stop()
         if hasattr(self, "_redis_client") and self._redis_client is not None:
             self._redis_client.close()
@@ -419,6 +437,10 @@ def teardown(self, remove_data: bool=False):
                 self._remove_ro(temp_dir)
                 shutil.rmtree(temp_dir)
                 self.logger.debug(f"Removed temp directory: {temp_dir}")
+            if shared_dir.exists():
+                self._remove_ro(shared_dir)
+                shutil.rmtree(shared_dir)
+                self.logger.debug(f"Removed shared directory: {shared_dir}")
 
     @override
     def start_lrr(self):

integration_tests/src/aio_lanraragi_tests/registries/__init__.py

@@ -0,0 +1,3 @@
+"""
+Module for registry data structures, APIs, and utilities.
+"""

integration_tests/src/aio_lanraragi_tests/registries/base.py

@@ -0,0 +1,80 @@
+
+import abc
+import hashlib
+
+REGISTRY_SCHEMA_VERSION = 1
+
+
+class AbstractRegistry(abc.ABC):
+
+    def __init__(self, generated_at: str = "2026-01-01T00:00:00Z"):
+        self._generated_at = generated_at
+        # namespace -> {"type": str, "versions": {version: version_record}}
+        self._plugins: dict[str, dict] = {}
+        # (namespace, version) -> artifact bytes staged for generate_manifest()
+        self._artifacts: dict[tuple[str, str], bytes] = {}
+
+    def add_plugin(
+        self,
+        namespace: str,
+        plugin_type: str,
+        version: str,
+        *,
+        name: str,
+        author: str,
+        description: str,
+        artifact_content: bytes | str | None = None,
+        artifact_relpath: str | None = None,
+        published_at: str | None = None,
+        sha256: str | None = None,
+    ) -> None:
+        artifact = artifact_relpath or f"artifacts/{namespace}/{version}/{namespace}.pm"
+        if artifact_content is not None:
+            content = artifact_content.encode("utf-8") if isinstance(artifact_content, str) else artifact_content
+            self._artifacts[(namespace, version)] = content
+            if sha256 is None:
+                sha256 = hashlib.sha256(content).hexdigest()
+        elif sha256 is None:
+            raise ValueError("sha256 must be provided when artifact_content is None")
+
+        record = self._plugins.setdefault(namespace, {"type": plugin_type, "versions": {}})
+        record["type"] = plugin_type
+        record["versions"][version] = {
+            "version": version,
+            "name": name,
+            "author": author,
+            "description": description,
+            "artifact": artifact,
+            "sha256": sha256,
+            "published_at": published_at or self._generated_at,
+        }
+
+    def remove_plugin(self, namespace: str, version: str | None = None) -> None:
+        if namespace not in self._plugins:
+            return
+        if version is None:
+            del self._plugins[namespace]
+            self._artifacts = {k: v for k, v in self._artifacts.items() if k[0] != namespace}
+            return
+        self._plugins[namespace]["versions"].pop(version, None)
+        self._artifacts.pop((namespace, version), None)
+        if not self._plugins[namespace]["versions"]:
+            del self._plugins[namespace]
+
+    def manifest(self) -> dict:
+        return {
+            "version": REGISTRY_SCHEMA_VERSION,
+            "generated_at": self._generated_at,
+            "plugins": {
+                namespace: {
+                    "namespace": namespace,
+                    "type": record["type"],
+                    "versions": record["versions"],
+                }
+                for namespace, record in self._plugins.items()
+            },
+        }
+
+    @abc.abstractmethod
+    def generate_manifest(self) -> None:
+        """Flush the manifest and any staged artifacts to the registry's backing store."""

integration_tests/src/aio_lanraragi_tests/registries/local_registry.py

@@ -0,0 +1,30 @@
+
+import json
+from pathlib import Path
+
+from aio_lanraragi_tests.registries.base import AbstractRegistry
+
+
+class LocalRegistry(AbstractRegistry):
+
+    def __init__(self, name: str, root: Path):
+        super().__init__()
+        self.name = name
+        self._root = Path(root)
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    @property
+    def registry_json_path(self) -> Path:
+        return self._root / "registry.json"
+
+    def generate_manifest(self) -> None:
+        self._root.mkdir(parents=True, exist_ok=True)
+        for (namespace, version), content in self._artifacts.items():
+            relpath = self._plugins[namespace]["versions"][version]["artifact"]
+            artifact_path = self._root / relpath
+            artifact_path.parent.mkdir(parents=True, exist_ok=True)
+            artifact_path.write_bytes(content)
+        self.registry_json_path.write_text(json.dumps(self.manifest()), encoding="utf-8")