shipit-cli 0.19.0__tar.gz → 0.19.1__tar.gz

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.19.0
+Version: 0.19.1
 Summary: Shipit CLI is the best way to build, serve and deploy your projects anywhere.
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.19.0"
+version = "0.19.1"
 description = "Shipit CLI is the best way to build, serve and deploy your projects anywhere."
 readme = "README.md"
 requires-python = ">=3.10"

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/src/shipit/assets/wordpress/install.sh

@@ -19,7 +19,9 @@ mkdir -p wp-content/plugins
 mkdir -p wp-content/upgrade
 
 if [ -n "${WPCONTENT_BASE_PATH:-}" ] && [ -d "${WPCONTENT_BASE_PATH}" ]; then
-  cp -R "${WPCONTENT_BASE_PATH}/." /app/wp-content/
+  shopt -s dotglob nullglob
+  cp -R "${WPCONTENT_BASE_PATH}"/* /app/wp-content
+  shopt -u dotglob nullglob
 fi
 
 echo "Installing WordPress core"

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/src/shipit/cli.py

@@ -36,6 +36,7 @@ from shipit.shipit_types import (
 )
 from shipit.ui import console
 from shipit.version import version as shipit_version
+from shipit.volumes import build_volumes, load_volume_mappings
 
 app = typer.Typer(invoke_without_command=True)
 
@@ -720,7 +721,7 @@ def serve(
             raise RuntimeError("--wasmer-deploy requires the Wasmer runner")
         runner.deploy(app_owner=wasmer_app_owner, app_name=wasmer_app_name)
     elif commands_to_run:
-        run_serve_commands(runner, commands_to_run)
+        run_serve_commands(path, runner, commands_to_run)
 
 
 @app.command(name="plan")
@@ -1073,6 +1074,7 @@ def build(
 
     # Build and serve
     build_backend.build(serve.name, env, serve.mounts or [], build_steps)
+    build_volumes(path, serve)
     runner.build(serve)
     if serve.prepare and not skip_prepare:
         runner.prepare(env, serve.prepare)
@@ -1105,11 +1107,12 @@ def resolve_run_commands(
     return commands
 
 
-def run_serve_commands(runner: Runner, commands: List[str]) -> None:
+def run_serve_commands(path: Path, runner: Runner, commands: List[str]) -> None:
+    volume_mappings = load_volume_mappings(path)
     for command in commands:
         if command in OPTIONAL_RUN_COMMANDS and not runner.has_serve_command(command):
             continue
-        runner.run_serve_command(command)
+        runner.run_serve_command(command, volume_mappings=volume_mappings)
 
 
 def main() -> None:

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/src/shipit/runners/base.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Dict, List, Protocol, TYPE_CHECKING
+from typing import Dict, List, Optional, Protocol, TYPE_CHECKING
 
 from shipit.builders.base import BuildBackend
 
@@ -15,5 +15,9 @@ class Runner(Protocol):
     def build(self, serve: "Serve") -> None: ...
     def prepare(self, env: Dict[str, str], prepare: List["PrepareStep"]) -> None: ...
     def has_serve_command(self, command: str) -> bool: ...
-    def run_serve_command(self, command: str) -> None: ...
+    def run_serve_command(
+        self,
+        command: str,
+        volume_mappings: Optional[Dict[str, str]] = None,
+    ) -> None: ...
     def get_serve_mount_path(self, name: str) -> Path: ...

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/src/shipit/runners/local.py

@@ -1,6 +1,6 @@
 import shutil
 from pathlib import Path
-from typing import Dict, List, TYPE_CHECKING
+from typing import Dict, List, Optional, TYPE_CHECKING
 
 import sh
 from rich import box
@@ -37,30 +37,6 @@ class LocalRunner:
         self.build_prepare(serve)
         self.build_serve(serve)
 
-    def _prepare_volumes(self, serve: Serve) -> None:
-        for volume in serve.volumes or []:
-            source = volume.path.absolute()
-            target = volume.serve_path
-
-            source.mkdir(parents=True, exist_ok=True)
-
-            if target.is_symlink():
-                if target.resolve(strict=False) == source.resolve():
-                    continue
-                target.unlink()
-            elif target.exists():
-                if target.is_dir():
-                    if not any(source.iterdir()):
-                        shutil.copytree(target, source, dirs_exist_ok=True)
-                    shutil.rmtree(target)
-                else:
-                    if not any(source.iterdir()):
-                        shutil.copy2(target, source / target.name)
-                    target.unlink()
-
-            target.parent.mkdir(parents=True, exist_ok=True)
-            target.symlink_to(source, target_is_directory=True)
-
     def build_prepare(self, serve: Serve) -> None:
         if not serve.prepare:
             return
@@ -93,7 +69,6 @@ class LocalRunner:
 
     def build_serve(self, serve: Serve) -> None:
         console.print("\n[bold]Building serve[/bold]")
-        self._prepare_volumes(serve)
         shutil.rmtree(self.serve_bin_path.parent, ignore_errors=True)
         self.serve_bin_path.mkdir(parents=True, exist_ok=True)
         runtime_path = self.build_backend.get_runtime_path() or ""
@@ -133,7 +108,11 @@ class LocalRunner:
     def has_serve_command(self, command: str) -> bool:
         return (self.serve_bin_path / command).is_file()
 
-    def run_serve_command(self, command: str) -> None:
+    def run_serve_command(
+        self,
+        command: str,
+        volume_mappings: Optional[Dict[str, str]] = None,
+    ) -> None:
         console.print(f"\n[bold]Running {command} command[/bold]")
         command_path = self.serve_bin_path / command
         sh.Command(str(command_path))(_out=write_stdout, _err=write_stderr)

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/src/shipit/runners/wasmer.py

@@ -20,6 +20,7 @@ from shipit.runners.base import Runner
 from shipit.shipit_types import EnvStep, Package, PrepareStep, Serve, UseStep
 from shipit.ui import console
 from shipit.version import version as shipit_version
+from shipit.volumes import load_volume_mappings, volume_mapdir_args
 
 if TYPE_CHECKING:
     from shipit.shipit_types import Step
@@ -213,7 +214,6 @@ class WasmerRunner:
         self.wasmer_token = token
         self.bin = bin or "wasmer"
         self.provider_config: Any = None
-        self.current_serve: Optional[Serve] = None
 
     def get_serve_mount_path(self, name: str) -> Path:
         if name == "app":
@@ -262,25 +262,9 @@ class WasmerRunner:
         return new_build_steps
 
     def build(self, serve: Serve) -> None:
-        self.current_serve = serve
-        self._ensure_volume_directories(serve)
         self.build_prepare(serve)
         self.build_serve(serve)
 
-    def _ensure_volume_directories(self, serve: Serve) -> None:
-        for volume in serve.volumes or []:
-            volume.path.mkdir(parents=True, exist_ok=True)
-
-    def _volume_mapdir_args(self) -> List[str]:
-        if not self.current_serve:
-            return []
-
-        self._ensure_volume_directories(self.current_serve)
-        return [
-            f"--mapdir={volume.serve_path}:{volume.path.absolute()}"
-            for volume in self.current_serve.volumes or []
-        ]
-
     def build_prepare(self, serve: Serve) -> None:
         if not serve.prepare:
             return
@@ -332,6 +316,7 @@ class WasmerRunner:
         prepare_dir = self.wasmer_dir_path / "prepare"
         self.run_serve_command(
             "bash",
+            volume_mappings=load_volume_mappings(self.src_dir),
             extra_args=[
                 f"--mapdir=/prepare:{prepare_dir}",
                 "--",
@@ -351,8 +336,6 @@ class WasmerRunner:
         return None
 
     def build_serve(self, serve: Serve) -> None:
-        self.current_serve = serve
-        self._ensure_volume_directories(serve)
         doc = document()
         doc.add(comment(f"Wasmer manifest generated with Shipit v{shipit_version}"))
         package = table()
@@ -620,7 +603,10 @@ class WasmerRunner:
         (self.wasmer_dir_path / "app.yaml").write_text(app_yaml)
 
     def run_serve_command(
-        self, command: str, extra_args: Optional[List[str]] = None
+        self,
+        command: str,
+        volume_mappings: Optional[Dict[str, str]] = None,
+        extra_args: Optional[List[str]] = None,
     ) -> None:
         console.print(f"\n[bold]Serving site[/bold]: running {command} command")
         extra_args = extra_args or []
@@ -635,7 +621,10 @@ class WasmerRunner:
                 "--net",
                 "--forward-host-env",
                 f"--command={command}",
-                *self._volume_mapdir_args(),
+                *volume_mapdir_args(
+                    self.build_backend,
+                    volume_mappings or {},
+                ),
                 *extra_args,
             ],
             env=os.environ,

shipit_cli-0.19.1/src/shipit/version.py

@@ -0,0 +1,5 @@
+__all__ = ["version", "version_info"]
+
+
+version = "0.19.1"
+version_info = (0, 19, 1, "final", 0)

shipit_cli-0.19.1/src/shipit/volumes.py

@@ -0,0 +1,90 @@
+import json
+import shutil
+from pathlib import Path
+from typing import Dict
+
+from shipit.builders.base import BuildBackend
+from shipit.shipit_types import Serve, Volume
+
+
+def get_volumes_dir(src_dir: Path) -> Path:
+    return src_dir / ".shipit" / "volumes"
+
+
+def get_volume_mappings_path(src_dir: Path) -> Path:
+    return get_volumes_dir(src_dir) / "mappings.json"
+
+
+def build_volumes(src_dir: Path, serve: Serve) -> Dict[str, str]:
+    volumes_dir = get_volumes_dir(src_dir)
+    volumes_dir.mkdir(parents=True, exist_ok=True)
+
+    mappings = {
+        volume.name: str(volume.serve_path)
+        for volume in serve.volumes or []
+    }
+    for volume in serve.volumes or []:
+        volume.path.mkdir(parents=True, exist_ok=True)
+        if _should_link_local_volume(src_dir, volume):
+            _link_local_volume(volume)
+
+    get_volume_mappings_path(src_dir).write_text(
+        json.dumps(mappings, indent=2, sort_keys=True) + "\n"
+    )
+    return mappings
+
+
+def load_volume_mappings(src_dir: Path) -> Dict[str, str]:
+    mappings_path = get_volume_mappings_path(src_dir)
+    if not mappings_path.is_file():
+        return {}
+
+    mappings = json.loads(mappings_path.read_text())
+    if not isinstance(mappings, dict):
+        raise ValueError("Volume mappings must be a dictionary")
+
+    return {
+        str(name): str(guest_path)
+        for name, guest_path in mappings.items()
+    }
+
+
+def volume_mapdir_args(
+    build_backend: BuildBackend,
+    volume_mappings: Dict[str, str],
+) -> list[str]:
+    args: list[str] = []
+    for name, guest_path in volume_mappings.items():
+        host_path = build_backend.get_volume_path(name).absolute()
+        host_path.mkdir(parents=True, exist_ok=True)
+        args.append(f"--mapdir={guest_path}:{host_path}")
+    return args
+
+
+def _should_link_local_volume(src_dir: Path, volume: Volume) -> bool:
+    shipit_dir = (src_dir / ".shipit").absolute()
+    return volume.serve_path.is_absolute() and volume.serve_path.is_relative_to(
+        shipit_dir
+    )
+
+
+def _link_local_volume(volume: Volume) -> None:
+    source = volume.path.absolute()
+    target = volume.serve_path
+
+    if target.is_symlink():
+        if target.resolve(strict=False) == source.resolve():
+            return
+        target.unlink()
+    elif target.exists():
+        if target.is_dir():
+            if not any(source.iterdir()):
+                shutil.copytree(target, source, dirs_exist_ok=True)
+            shutil.rmtree(target)
+        else:
+            if not any(source.iterdir()):
+                shutil.copy2(target, source / target.name)
+            target.unlink()
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.symlink_to(source, target_is_directory=True)

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/tests/test_cli_after_deploy.py

@@ -16,6 +16,7 @@ class FakeRunner:
     def __init__(self, *args, **kwargs) -> None:
         self.calls: list[str] = []
         self.checked: list[str] = []
+        self.volume_mappings: list[dict[str, str] | None] = []
         self.available_commands = set(type(self).available_commands)
         type(self).instances.append(self)
 
@@ -23,8 +24,13 @@ class FakeRunner:
         self.checked.append(command)
         return command in self.available_commands
 
-    def run_serve_command(self, command: str) -> None:
+    def run_serve_command(
+        self,
+        command: str,
+        volume_mappings: dict[str, str] | None = None,
+    ) -> None:
         self.calls.append(command)
+        self.volume_mappings.append(volume_mappings)
 
 
 runner = CliRunner()
@@ -44,6 +50,7 @@ def test_serve_runs_after_deploy_before_start(
     assert result.exit_code == 0, result.output
     assert FakeRunner.instances[-1].calls == ["after_deploy", "start"]
     assert FakeRunner.instances[-1].checked == ["after_deploy", "start"]
+    assert FakeRunner.instances[-1].volume_mappings == [{}, {}]
 
 
 def test_serve_skips_after_deploy_when_missing(
@@ -60,6 +67,7 @@ def test_serve_skips_after_deploy_when_missing(
     assert result.exit_code == 0, result.output
     assert FakeRunner.instances[-1].calls == ["start"]
     assert FakeRunner.instances[-1].checked == ["after_deploy", "start"]
+    assert FakeRunner.instances[-1].volume_mappings == [{}]
 
 
 def test_serve_runs_custom_commands_without_existence_checks(
@@ -79,6 +87,30 @@ def test_serve_runs_custom_commands_without_existence_checks(
     assert result.exit_code == 0, result.output
     assert FakeRunner.instances[-1].calls == ["prepare-db", "warm-cache"]
     assert FakeRunner.instances[-1].checked == []
+    assert FakeRunner.instances[-1].volume_mappings == [{}, {}]
+
+
+def test_serve_loads_volume_mappings_from_json(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    FakeRunner.instances.clear()
+    FakeRunner.available_commands = {"start"}
+    mappings_dir = tmp_path / ".shipit" / "volumes"
+    mappings_dir.mkdir(parents=True)
+    (mappings_dir / "mappings.json").write_text(
+        '{\n  "wp-content": "/app/wp-content"\n}\n'
+    )
+    monkeypatch.setattr(cli, "LocalBuildBackend", FakeBuildBackend)
+    monkeypatch.setattr(cli, "LocalRunner", FakeRunner)
+
+    result = runner.invoke(cli.app, ["serve", str(tmp_path)])
+
+    assert result.exit_code == 0, result.output
+    assert FakeRunner.instances[-1].calls == ["start"]
+    assert FakeRunner.instances[-1].volume_mappings == [
+        {"wp-content": "/app/wp-content"}
+    ]
 
 
 def test_auto_passes_after_deploy_to_serve(

{shipit_cli-0.19.0 → shipit_cli-0.19.1}/tests/test_volumes.py

@@ -7,6 +7,7 @@ from shipit.cli import Ctx
 from shipit.runners.local import LocalRunner
 from shipit.runners.wasmer import WasmerRunner
 from shipit.shipit_types import Package, Serve, Volume
+from shipit.volumes import build_volumes, load_volume_mappings
 
 
 class DummyBuildBackend:
@@ -47,13 +48,12 @@ def test_ctx_volume_uses_shipit_volume_directory(tmp_path: Path) -> None:
     assert not volume.path.exists()
 
 
-def test_local_runner_links_runtime_volume_to_host_directory(
+def test_build_volumes_links_runtime_volume_to_host_directory(
     tmp_path: Path,
 ) -> None:
     assets_path = tmp_path / "assets"
     assets_path.mkdir()
     build_backend = LocalBuildBackend(tmp_path, assets_path)
-    runner = LocalRunner(build_backend, tmp_path)
 
     target = build_backend.get_artifact_mount_path("app") / "wp-content"
     target.mkdir(parents=True, exist_ok=True)
@@ -73,12 +73,14 @@ def test_local_runner_links_runtime_volume_to_host_directory(
         volumes=[volume],
     )
 
-    runner.build_serve(serve)
+    mappings = build_volumes(tmp_path, serve)
 
     assert volume.path.is_dir()
     assert (volume.path / "seed.txt").read_text() == "hello"
     assert target.is_symlink()
     assert target.resolve(strict=False) == volume.path.resolve()
+    assert mappings == {"wp-content": str(target)}
+    assert load_volume_mappings(tmp_path) == {"wp-content": str(target)}
 
 
 def test_wasmer_runner_mounts_volume_paths_into_wasmer_run(
@@ -105,8 +107,6 @@ def test_wasmer_runner_mounts_volume_paths_into_wasmer_run(
         ],
     )
 
-    runner.build_serve(serve)
-
     captured: dict[str, object] = {}
 
     def fake_run_command(
@@ -120,7 +120,11 @@ def test_wasmer_runner_mounts_volume_paths_into_wasmer_run(
 
     monkeypatch.setattr(runner, "run_command", fake_run_command)
 
-    runner.run_serve_command("start")
+    build_volumes(src_dir, serve)
+    runner.run_serve_command(
+        "start",
+        volume_mappings=load_volume_mappings(src_dir),
+    )
 
     assert volume_path.is_dir()
     assert captured["command"] == "wasmer"

shipit_cli-0.19.0/src/shipit/version.py

@@ -1,5 +0,0 @@
-__all__ = ["version", "version_info"]
-
-
-version = "0.19.0"
-version_info = (0, 19, 0, "final", 0)