Add entrypoint script

Author: lars-petter-hauge

src/deploy/__main__.py

@@ -114,7 +114,7 @@ def build(force: bool, extra_scripts: str) -> None:
 def links() -> None:
     configpath = Path.cwd()
     config = load_config(configpath)
-    make_links(config, prefix=Args.prefix)
+    make_links(config.links, prefix=Args.prefix)
 
 
 @cli.command(help="Run tests in ./deploy_tests using pytest")
@@ -135,10 +135,10 @@ def test(args: tuple[str, ...]) -> None:
     for pkg in plist.packages.values():
         os.environ[f"{pkg.config.name}_version"] = pkg.config.version
 
-    for name, dest in plist.envs:
+    for name, dest, _ in plist.envs:
         os.environ[f"{name}_env"] = f"{Args.prefix / dest}"
 
-    for name, dest in plist.envs:
+    for name, dest, _ in plist.envs:
         pkg = plist.packages[name]
         for path in (plist.prefix / dest).glob("*/manifest"):
             if path.read_text() == pkg.manifest:

src/deploy/build.py

@@ -16,6 +16,7 @@
 from deploy.package import Package
 from deploy.package_list import PackageList
 from deploy.utils import redirect_output
+from deploy.links import make_links
 
 
 def _checkout(pkg: Package) -> None:
@@ -151,12 +152,14 @@ def _build_packages(self) -> None:
                 _build(pkg, tmp)
 
     def _build_envs(self) -> None:
-        for name, dest in self.package_list.envs:
+        for name, dest, entrypoint in self.package_list.envs:
             pkg = self.packages[name]
             path = self._get_build_path(self.package_list.prefix / dest, pkg)
             if path is None:
                 continue
             self._build_env_for_package(path, pkg)
+            self._create_default_symlinks(self.package_list.prefix / dest, path)
+            self._create_wrapper_script(dest, pkg, entrypoint)
 
     def _build_env_for_package(self, base: Path, finalpkg: Package) -> None:
         for pkg in chain([finalpkg], finalpkg.depends):
@@ -188,3 +191,39 @@ def _get_build_path(self, base: Path, finalpkg: Package) -> Path | None:
         sys.exit(
             f"Out of range while trying to find a build number for {finalpkg.config.version}"
         )
+
+    def _create_wrapper_script(
+        self, dest: str, pkg: Package, entrypoint: str | None
+    ) -> None:
+        if entrypoint is None:
+            return
+
+        bin_dir = self.package_list.prefix / "bin"
+        bin_dir.mkdir(parents=True, exist_ok=True)
+
+        wrapper_script = bin_dir / "run"
+
+        script_content = f"""#!/usr/bin/env bash
+# Auto-generated wrapper script for {pkg.config.name}
+
+VERSION="${{1:-stable}}"
+BASE_DIR="$(dirname "$(dirname "$(readlink -f "${{BASH_SOURCE[0]}}")")")"
+VERSIONS_DIR="$BASE_DIR/{dest}"
+
+ENTRY_POINT="$VERSIONS_DIR/$VERSION/{entrypoint}"
+
+if [ ! -f "$ENTRY_POINT" ]; then
+    echo "Error: Entry point not found: $ENTRY_POINT" >&2
+    exit 1
+fi
+
+exec "$ENTRY_POINT" "${{@:2}}"
+"""
+
+        wrapper_script.write_text(script_content)
+        wrapper_script.chmod(0o755)
+
+    def _create_default_symlinks(self, base: Path, target: Path) -> None:
+        rel_base = base.relative_to(self.package_list.prefix)
+        default_links = {str(rel_base): {"latest": "^", "stable": "latest"}}
+        make_links(default_links, prefix=self.package_list.prefix, force=False)

src/deploy/config.py

@@ -28,6 +28,7 @@ class BuildConfig(BaseModel):
 class EnvConfig(BaseModel):
     name: str
     dest: str
+    entrypoint: str | None = None
 
 
 class PathConfig(BaseModel):

src/deploy/links.py

@@ -3,7 +3,6 @@
 import os
 import sys
 
-from deploy.config import Config
 from pathlib import Path
 from semver import Version
 
@@ -45,12 +44,21 @@ def validate(base: Path) -> None:
             print(f"'{name}' links to '{target}' which doesn't exist!", file=sys.stderr)
 
 
-def make_links(config: Config, *, prefix: Path) -> None:
-    for subdir, links in config.links.items():
-        for source, target in links.items():
+def make_links(
+    links: dict[str, dict[str, str]],
+    prefix: Path,
+    force: bool = True,
+) -> None:
+    for subdir, link_specs in links.items():
+        for source, target in link_specs.items():
             path = prefix / subdir / source
+
+            if not force and path.exists():
+                continue
+
             if target == "^":
                 target = get_latest(prefix / subdir)
+
             path.unlink(missing_ok=True)
             path.symlink_to(target)
             print(f"Created symlink: {path} -> {target}")

src/deploy/package_list.py

@@ -46,7 +46,9 @@ def __init__(
                 [self.packages[x] for x in build.depends],
             )
 
-        self.envs: list[tuple[str, str]] = [(e.name, e.dest) for e in config.envs]
+        self.envs: list[tuple[str, str, str | None]] = [
+            (e.name, e.dest, e.entrypoint) for e in config.envs
+        ]
 
         if check_scripts:
             self._check_scripts_exist()

src/deploy/sync.py

@@ -49,13 +49,13 @@ def __init__(
                 if not (path.parent).is_symlink()
                 if plist.packages[name].manifest == path.read_text()
             ]
-            for name, dest in plist.envs
+            for name, dest, _ in plist.envs
         }
 
         # Create symlinking script
         self._post_script = io.StringIO()
         self._post_script.write("set -euxo pipefail\n")
-        for _, dest in plist.envs:
+        for _, dest, _ in plist.envs:
             self._post_script.write(f"mkdir -p {self._dest_prefix / dest}\n")
             self._post_script.writelines(
                 f"ln -sfn {os.readlink(path)} {change_prefix(path, plist.prefix, self._dest_prefix)} \n"

tests/test_build.py

@@ -223,3 +223,24 @@ def test_clean_package_cache_on_rebuild(
             call_args[0][0][1] for call_args in mocked_subprocess.run.call_args_list
         ]
         assert "clean" in git_commands
+
+
+def test_default_symlinks_created_on_build(tmp_path, base_config):
+    (tmp_path / "build_test.sh").write_text("#!/bin/bash\nmkdir -p $out/bin\n")
+    (tmp_path / "build_test.sh").chmod(0o755)
+
+    base_config["builds"].append({"name": "test", "version": "1.0.0"})
+    base_config["envs"].append({"name": "test", "dest": "versions"})
+
+    config = Config.model_validate(base_config)
+    builder = Build(tmp_path, config, extra_scripts=tmp_path, prefix=tmp_path)
+    builder.build()
+
+    stable_link = tmp_path / "versions" / "stable"
+    latest_link = tmp_path / "versions" / "latest"
+
+    assert stable_link.is_symlink()
+    assert latest_link.is_symlink()
+    assert str(stable_link.readlink()) == "latest"
+    assert str(latest_link.readlink()) == "1.0.0-1"
+    assert stable_link.resolve() == latest_link.resolve()

tests/test_links.py

@@ -3,7 +3,6 @@
 from pathlib import Path
 
 from deploy.links import make_links
-from deploy.config import Config
 
 
 @pytest.fixture
@@ -25,47 +24,41 @@ def _setup_env(tmp_path, base_config):
 
 def test_make_links(tmp_path, base_config):
     _setup_env(tmp_path, base_config)
-    config = Config.model_validate(base_config)
-    make_links(config, prefix=tmp_path)
+    make_links(base_config["links"], prefix=tmp_path)
     assert (tmp_path / "location/symlink").exists()
 
 
 def test_make_links_fail_missing_target(tmp_path, base_config):
-    # Note the lack of setting up environment, hence no target file exists
-    config = Config.model_validate(base_config)
     with pytest.raises(FileNotFoundError, match="No such file or directory: 'target'"):
-        make_links(config, prefix=tmp_path)
+        make_links(base_config["links"], prefix=tmp_path)
 
 
 def test_make_links_on_new_package_resolves_latest(tmp_path, base_config):
     base_config["links"] = {"location": {"cool": "^"}}
-    config = Config.model_validate(base_config)
 
     (tmp_path / "location" / "1.0.0").mkdir(parents=True)
     (tmp_path / "location" / "1.0.1").mkdir(parents=True)
 
-    make_links(config, prefix=tmp_path)
+    make_links(base_config["links"], prefix=tmp_path)
     assert os.path.islink(tmp_path / "location/cool")
     assert os.path.realpath(tmp_path / "location/cool") == str(
         (tmp_path / "location" / "1.0.1")
     )
 
-    # Lets create a new version
     (tmp_path / "location" / "1.0.2").mkdir(parents=True)
-    make_links(config, prefix=tmp_path)
+    make_links(base_config["links"], prefix=tmp_path)
     assert os.path.realpath(tmp_path / "location/cool") == str(
         (tmp_path / "location" / "1.0.2")
     )
 
 
 def test_some(tmp_path, base_config):
     base_config["links"] = {"location": {"1.0": "1.0.1"}}
-    config = Config.model_validate(base_config)
 
     (tmp_path / "location" / "1.0.0").mkdir(parents=True)
     (tmp_path / "location" / "1.0.1").mkdir(parents=True)
 
-    make_links(config, prefix=tmp_path)
+    make_links(base_config["links"], prefix=tmp_path)
     assert os.path.islink(tmp_path / "location/1.0")
     assert os.path.realpath(tmp_path / "location/1.0") == str(
         (tmp_path / "location" / "1.0.1")

tests/test_sync.py

@@ -99,7 +99,7 @@ def test_successful_sync(tmp_path, base_config):
 
     builder = _deploy_config(base_config, tmp_path)
 
-    make_links(base_config, prefix=tmp_path)
+    make_links(base_config.links, prefix=tmp_path)
     pkg = builder.packages["A"]
     installed_file_path = pkg.out / "bin/a_file"
     assert installed_file_path.exists()