shipit-cli 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

shipit/generator.py

@@ -3,7 +3,15 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from shipit.providers.base import DependencySpec, Provider, ProviderPlan, DetectResult, MountSpec
+from shipit.providers.base import (
+    DependencySpec,
+    Provider,
+    ProviderPlan,
+    DetectResult,
+    MountSpec,
+    VolumeSpec,
+    CustomCommands,
+)
 from shipit.providers.registry import providers as registry_providers
 
 
@@ -12,10 +20,10 @@ def _providers() -> list[type[Provider]]:
     return registry_providers()
 
 
-def detect_provider(path: Path) -> Provider:
+def detect_provider(path: Path, custom_commands: CustomCommands) -> Provider:
     matches: list[tuple[type[Provider], DetectResult]] = []
     for provider_cls in _providers():
-        res = provider_cls.detect(path)
+        res = provider_cls.detect(path, custom_commands)
         if res:
             matches.append((provider_cls, res))
     if not matches:
@@ -69,22 +77,16 @@ def _emit_dependencies_declarations(
     return "\n".join(lines), serve_vars, build_vars
 
 
-def _render_assets(assets: Optional[Dict[str, str]]) -> Optional[str]:
-    if not assets:
-        return None
-    inner = ",\n".join([f'    "{k}": {v}' for k, v in assets.items()])
-    return f"{{\n{inner}\n  }}"
-
-
-def generate_shipit(path: Path) -> str:
-    provider_cls = detect_provider(path)
-    provider = provider_cls(path)
+def generate_shipit(path: Path, custom_commands: CustomCommands) -> str:
+    provider_cls = detect_provider(path, custom_commands)
+    provider = provider_cls(path, custom_commands)
 
     # Collect parts
     plan = ProviderPlan(
         serve_name=provider.serve_name(),
         provider=provider.provider_kind(),
         mounts=provider.mounts(),
+        volumes=provider.volumes(),
         declarations=provider.declarations(),
         dependencies=provider.dependencies(),
         build_steps=provider.build_steps(),
@@ -114,13 +116,17 @@ def generate_shipit(path: Path) -> str:
             env_lines = "{}"
         else:
             env_lines = ",\n".join([f'    "{k}": {v}' for k, v in plan.env.items()])
-    assets_block = _render_assets(plan.assets)
     mounts_block = None
+    volumes_block = None
     attach_serve_names: list[str] = []
     if plan.mounts:
         mounts = list(filter(lambda m: m.attach_to_serve, plan.mounts))
         attach_serve_names = [m.name for m in mounts]
         mounts_block = ",\n".join([f"    {m.name}" for m in mounts])
+    if plan.volumes:
+        volumes_block = ",\n".join(
+            [f"    {v.var_name or v.name}" for v in plan.volumes]
+        )
 
     out: List[str] = []
     if dep_block:
@@ -128,6 +134,9 @@ def generate_shipit(path: Path) -> str:
         out.append("")
     for m in plan.mounts:
         out.append(f"{m.name} = mount(\"{m.name}\")")
+    if plan.volumes:
+        for v in plan.volumes:
+            out.append(f"{v.var_name or v.name} = volume(\"{v.name}\", {v.serve_path})")
     if plan.services:
         for s in plan.services:
             out.append(f"{s.name} = service(\n  name=\"{s.name}\",\n  provider=\"{s.provider}\"\n)")
@@ -144,8 +153,6 @@ def generate_shipit(path: Path) -> str:
     out.append("  build=[")
     out.append(build_steps_block)
     out.append("  ],")
-    if assets_block:
-        out.append("  assets=" + assets_block + ",")
     out.append(f"  deps=[{deps_array}],")
     if plan.prepare:
         prepare_steps_block = ",\n".join([f"    {s}" for s in plan.prepare])
@@ -171,6 +178,10 @@ def generate_shipit(path: Path) -> str:
         out.append("  mounts=[")
         out.append(mounts_block)
         out.append("  ],")
+    if volumes_block:
+        out.append("  volumes=[")
+        out.append(volumes_block)
+        out.append("  ],")
     out.append(")")
     out.append("")
     return "\n".join(out)

shipit/procfile.py

@@ -0,0 +1,106 @@
+# File forked from https://github.com/nickstenning/honcho/blob/main/honcho/environ.py
+# MIT License
+import os
+import re
+from collections import defaultdict, namedtuple
+
+PROCFILE_LINE = re.compile(r'^([A-Za-z0-9_-]+):\s*(.+)$')
+
+
+class Env(object):
+
+    def __init__(self, config):
+        self._c = config
+
+    @property
+    def port(self):
+        try:
+            return int(self._c['port'])
+        except ValueError:
+            raise ValueError(f"invalid value for port: '{self._c['port']}'")
+
+    @property
+    def procfile(self):
+        return os.path.join(self._c['app_root'], self._c['procfile'])
+
+    def load_procfile(self):
+        with open(self.procfile) as f:
+            content = f.read()
+
+        return parse_procfile(content)
+
+
+class Procfile(object):
+    """A data structure representing a Procfile"""
+
+    def __init__(self):
+        self.processes = {}
+
+    @classmethod
+    def loads(cls, contents):
+        p = cls()
+        for line in contents.splitlines():
+            m = PROCFILE_LINE.match(line)
+            if m:
+                p.add_process(m.group(1), m.group(2))
+        return p
+
+    def add_process(self, name, command):
+        assert name not in self.processes, \
+            "process names must be unique within a Procfile"
+        self.processes[name] = command
+    
+    def get_start_command(self):
+        if "web" in self.processes:
+            return self.processes["web"]
+        elif "default" in self.processes:
+            return self.processes["default"]
+        elif "start" in self.processes:
+            return self.processes["start"]
+        elif len(self.processes) == 1:
+            return list(self.processes.values())[0]
+        return None
+
+
+ProcessParams = namedtuple("ProcessParams", "name cmd quiet env")
+
+
+def expand_processes(processes, concurrency=None, env=None, quiet=None, port=None):
+    """
+    Get a list of the processes that need to be started given the specified
+    list of process types, concurrency, environment, quietness, and base port
+    number.
+
+    Returns a list of ProcessParams objects, which have `name`, `cmd`, `env`,
+    and `quiet` attributes, corresponding to the parameters to the constructor
+    of `honcho.process.Process`.
+    """
+    if env is not None and env.get("PORT") is not None:
+        port = int(env.get("PORT"))
+
+    if quiet is None:
+        quiet = []
+
+    con = defaultdict(lambda: 1)
+    if concurrency is not None:
+        con.update(concurrency)
+
+    out = []
+
+    for name, cmd in processes.items():
+        for i in range(con[name]):
+            n = "{0}.{1}".format(name, i + 1)
+            c = cmd
+            q = name in quiet
+            e = {'SHIPIT_PROCESS_NAME': n}
+            if env is not None:
+                e.update(env)
+            if port is not None:
+                e['PORT'] = str(port + i)
+
+            params = ProcessParams(n, c, q, e)
+            out.append(params)
+        if port is not None:
+            port += 100
+
+    return out

shipit/providers/base.py

@@ -11,12 +11,20 @@ class DetectResult:
     score: int  # Higher score wins when multiple providers match
 
 
+@dataclass
+class CustomCommands:
+    install: Optional[str] = None
+    build: Optional[str] = None
+    start: Optional[str] = None
+    after_deploy: Optional[str] = None
+
+
 class Provider(Protocol):
     def __init__(self, path: Path): ...
     @classmethod
     def name(cls) -> str: ...
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]: ...
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]: ...
     def initialize(self) -> None: ...
     # Structured plan steps (no path args; use self.path)
     def serve_name(self) -> str: ...
@@ -27,9 +35,9 @@ class Provider(Protocol):
     # Prepare: list of Starlark step calls (currently only run(...))
     def prepare_steps(self) -> Optional[List[str]]: ...
     def commands(self) -> Dict[str, str]: ...
-    def assets(self) -> Optional[Dict[str, str]]: ...
     def services(self) -> List["ServiceSpec"]: ...
     def mounts(self) -> List["MountSpec"]: ...
+    def volumes(self) -> List["VolumeSpec"]: ...
     def env(self) -> Optional[Dict[str, str]]: ...
 
 
@@ -50,6 +58,14 @@ class MountSpec:
     attach_to_serve: bool = True
 
 
+@dataclass
+class VolumeSpec:
+    name: str
+    # Absolute path inside the serve/runtime environment where the volume is mounted
+    serve_path: str
+    var_name: Optional[str] = None
+
+
 @dataclass
 class ServiceSpec:
     name: str
@@ -61,13 +77,13 @@ class ProviderPlan:
     serve_name: str
     provider: str
     mounts: List[MountSpec]
+    volumes: List[VolumeSpec] = field(default_factory=list)
     declarations: Optional[str] = None
     dependencies: List[DependencySpec] = field(default_factory=list)
     build_steps: List[str] = field(default_factory=list)
     prepare: Optional[List[str]] = None
     services: List[ServiceSpec] = field(default_factory=list)
     commands: Dict[str, str] = field(default_factory=dict)
-    assets: Optional[Dict[str, str]] = None
     env: Optional[Dict[str, str]] = None
 
 

shipit/providers/gatsby.py

@@ -3,18 +3,30 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency, MountSpec, ServiceSpec
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    _has_dependency,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+)
 
 
 class GatsbyProvider:
-    def __init__(self, path: Path):
+    def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path
+        self.custom_commands = custom_commands
+
     @classmethod
     def name(cls) -> str:
         return "gatsby"
 
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         pkg = path / "package.json"
         if not pkg.exists():
             return None
@@ -62,12 +74,12 @@ class GatsbyProvider:
     def commands(self) -> Dict[str, str]:
         return {"start": '"static-web-server --root /app"'}
 
-    def assets(self) -> Optional[Dict[str, str]]:
-        return None
-
     def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
+    def volumes(self) -> list[VolumeSpec]:
+        return []
+
     def env(self) -> Optional[Dict[str, str]]:
         return None
     

shipit/providers/hugo.py

@@ -3,16 +3,17 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, ServiceSpec
+from .base import DetectResult, DependencySpec, Provider, _exists, ServiceSpec, VolumeSpec, CustomCommands
 from .staticfile import StaticFileProvider
 
 class HugoProvider(StaticFileProvider):
+
     @classmethod
     def name(cls) -> str:
         return "hugo"
 
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         if _exists(path, "hugo.toml", "hugo.json", "hugo.yaml", "hugo.yml"):
             return DetectResult(cls.name(), 80)
         if (
@@ -48,3 +49,6 @@ class HugoProvider(StaticFileProvider):
     
     def services(self) -> list[ServiceSpec]:
         return []
+
+    def volumes(self) -> list[VolumeSpec]:
+        return []

shipit/providers/laravel.py

@@ -3,18 +3,29 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+)
 
 
 class LaravelProvider:
-    def __init__(self, path: Path):
+    def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path
+        self.custom_commands = custom_commands
+
     @classmethod
     def name(cls) -> str:
         return "laravel"
 
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         if _exists(path, "artisan") and _exists(path, "composer.json"):
             return DetectResult(cls.name(), 95)
         return None
@@ -73,12 +84,12 @@ class LaravelProvider:
             "after_deploy": '"php artisan migrate"',
         }
 
-    def assets(self) -> Optional[Dict[str, str]]:
-        return None
-
     def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
+    def volumes(self) -> list[VolumeSpec]:
+        return []
+
     def env(self) -> Optional[Dict[str, str]]:
         return None
     

shipit/providers/mkdocs.py

@@ -3,22 +3,31 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+)
 from .staticfile import StaticFileProvider
 from .python import PythonProvider
 
 
 class MkdocsProvider(StaticFileProvider):
-    def __init__(self, path: Path):
+    def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path
-        self.python_provider = PythonProvider(path, only_build=True, extra_dependencies={"mkdocs"})
+        self.python_provider = PythonProvider(path, custom_commands, only_build=True, extra_dependencies={"mkdocs"})
 
     @classmethod
     def name(cls) -> str:
         return "mkdocs"
 
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
             return DetectResult(cls.name(), 85)
         return None
@@ -50,12 +59,12 @@ class MkdocsProvider(StaticFileProvider):
     def prepare_steps(self) -> Optional[list[str]]:
         return self.python_provider.prepare_steps()
 
-    def assets(self) -> Optional[Dict[str, str]]:
-        return None
-
     def mounts(self) -> list[MountSpec]:
         return [MountSpec("app"), *self.python_provider.mounts()]
 
+    def volumes(self) -> list[VolumeSpec]:
+        return []
+
     def env(self) -> Optional[Dict[str, str]]:
         return self.python_provider.env()
     

shipit/providers/node_static.py

@@ -3,18 +3,30 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, _has_dependency, MountSpec, ServiceSpec
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    _has_dependency,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+)
 
 
 class NodeStaticProvider:
-    def __init__(self, path: Path):
+    def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path
+        self.custom_commands = custom_commands
+
     @classmethod
     def name(cls) -> str:
         return "node-static"
 
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         pkg = path / "package.json"
         if not pkg.exists():
             return None
@@ -63,12 +75,12 @@ class NodeStaticProvider:
         output_dir = "dist" if (self.path / "dist").exists() else "public"
         return {"start": f'"static-web-server --root /app/{output_dir}"'}
 
-    def assets(self) -> Optional[Dict[str, str]]:
-        return None
-
     def mounts(self) -> list[MountSpec]:
         return [MountSpec("app")]
 
+    def volumes(self) -> list[VolumeSpec]:
+        return []
+
     def env(self) -> Optional[Dict[str, str]]:
         return None
     

shipit/providers/php.py

@@ -1,24 +1,38 @@
 from __future__ import annotations
 
+import json
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, MountSpec, ServiceSpec
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+)
 
 
 class PhpProvider:
-    def __init__(self, path: Path):
+    def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path
+        self.custom_commands = custom_commands
+    
     @classmethod
     def name(cls) -> str:
         return "php"
 
     @classmethod
-    def detect(cls, path: Path) -> Optional[DetectResult]:
+    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         if _exists(path, "composer.json") and _exists(path, "public/index.php"):
             return DetectResult(cls.name(), 60)
         if _exists(path, "index.php") and not _exists(path, "composer.json"):
             return DetectResult(cls.name(), 10)
+        if custom_commands.start and custom_commands.start.startswith("php "):
+            return DetectResult(cls.name(), 70)
         return None
 
     def initialize(self) -> None:
@@ -49,12 +63,16 @@ class PhpProvider:
         return deps
 
     def declarations(self) -> Optional[str]:
-        return "HOME = getenv(\"HOME\")"
+        return "HOME = getenv(\"HOME\")\n"
 
     def build_steps(self) -> list[str]:
         steps = [
             "workdir(app[\"build\"])",
         ]
+        if _exists(self.path, "php.ini"):
+            steps.append('copy("php.ini", "{}/php.ini".format(assets["build"]))')
+        else:
+            steps.append('copy("php/php.ini", "{}/php.ini".format(assets["build"]), base="assets")')
 
         if self.has_composer():
             steps.append("env(HOME=HOME, COMPOSER_FUND=\"0\")")
@@ -67,19 +85,30 @@ class PhpProvider:
         return None
 
     def commands(self) -> Dict[str, str]:
+        commands = self.base_commands()
+        if self.custom_commands.start:
+            commands["start"] = json.dumps(self.custom_commands.start)
+        return commands
+
+    def base_commands(self) -> Dict[str, str]:
         if _exists(self.path, "public/index.php"):
             return {"start": '"php -S localhost:8080 -t public"'}
         elif _exists(self.path, "index.php"):
-            return {"start": '"php -S localhost:8080" -t .'}
-
-    def assets(self) -> Optional[Dict[str, str]]:
-        return {"php.ini": "get_asset(\"php/php.ini\")"}
+            return {"start": '"php -S localhost:8080 -t ."'}
 
     def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
+        return [
+            MountSpec("app"),
+            MountSpec("assets"),
+        ]
+
+    def volumes(self) -> list[VolumeSpec]:
+        return []
 
     def env(self) -> Optional[Dict[str, str]]:
-        return None
+        return {
+            "PHP_INI_SCAN_DIR": '"{}".format(assets["serve"])',
+        }
     
     def services(self) -> list[ServiceSpec]:
         return []