ominfra 0.0.0.dev189__py3-none-any.whl → 0.0.0.dev191__py3-none-any.whl

ominfra/manage/deploy/deploy.py

@@ -1,10 +1,33 @@
 # ruff: noqa: UP006 UP007
 import datetime
+import os.path
 import typing as ta
 
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check
+from omlish.lite.json import json_dumps_pretty
+from omlish.lite.marshal import ObjMarshalerManager
 from omlish.lite.typing import Func0
+from omlish.lite.typing import Func1
+from omlish.os.paths import abs_real_path
+from omlish.os.paths import relative_symlink
 
+from .apps import DeployAppManager
+from .conf.manager import DeployConfManager
+from .paths.manager import DeployPathsManager
+from .paths.owners import DeployPathOwner
+from .paths.paths import DeployPath
+from .specs import DeployAppSpec
+from .specs import DeploySpec
+from .systemd import DeploySystemdManager
+from .tags import DeployApp
+from .tags import DeployTagMap
 from .tags import DeployTime
+from .tmp import DeployHomeAtomics
+from .types import DeployHome
+
+
+##
 
 
 DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
@@ -13,17 +36,65 @@ DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
 DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
 
 
-class DeployManager:
+class DeployManager(DeployPathOwner):
     def __init__(
             self,
             *,
+            atomics: DeployHomeAtomics,
 
             utc_clock: ta.Optional[DeployManagerUtcClock] = None,
     ):
         super().__init__()
 
+        self._atomics = atomics
+
         self._utc_clock = utc_clock
 
+    #
+
+    # Home current link just points to CURRENT_DEPLOY_LINK, and is intended for user convenience.
+    HOME_CURRENT_LINK = DeployPath.parse('current')
+
+    DEPLOYS_DIR = DeployPath.parse('deploys/')
+
+    # Authoritative current symlink is not in deploy-home, just to prevent accidental corruption.
+    CURRENT_DEPLOY_LINK = DeployPath.parse(f'{DEPLOYS_DIR}current')
+    DEPLOYING_DEPLOY_LINK = DeployPath.parse(f'{DEPLOYS_DIR}deploying')
+
+    DEPLOY_DIR = DeployPath.parse(f'{DEPLOYS_DIR}@time--@deploy-key/')
+    DEPLOY_SPEC_FILE = DeployPath.parse(f'{DEPLOY_DIR}spec.json')
+
+    APPS_DEPLOY_DIR = DeployPath.parse(f'{DEPLOY_DIR}apps/')
+    APP_DEPLOY_LINK = DeployPath.parse(f'{APPS_DEPLOY_DIR}@app')
+
+    CONFS_DEPLOY_DIR = DeployPath.parse(f'{DEPLOY_DIR}conf/')
+    CONF_DEPLOY_DIR = DeployPath.parse(f'{CONFS_DEPLOY_DIR}@conf/')
+
+    @cached_nullary
+    def get_owned_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
+        return {
+            self.DEPLOYS_DIR,
+
+            self.CURRENT_DEPLOY_LINK,
+            self.DEPLOYING_DEPLOY_LINK,
+
+            self.DEPLOY_DIR,
+            self.DEPLOY_SPEC_FILE,
+
+            self.APPS_DEPLOY_DIR,
+            self.APP_DEPLOY_LINK,
+
+            self.CONFS_DEPLOY_DIR,
+            self.CONF_DEPLOY_DIR,
+        }
+
+    #
+
+    def render_path(self, home: DeployHome, pth: DeployPath, tags: ta.Optional[DeployTagMap] = None) -> str:
+        return os.path.join(check.non_empty_str(home), pth.render(tags))
+
+    #
+
     def _utc_now(self) -> datetime.datetime:
         if self._utc_clock is not None:
             return self._utc_clock()  # noqa
@@ -32,3 +103,225 @@ class DeployManager:
 
     def make_deploy_time(self) -> DeployTime:
         return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
+
+    #
+
+    def make_home_current_link(self, home: DeployHome) -> None:
+        home_current_link = os.path.join(check.non_empty_str(home), self.HOME_CURRENT_LINK.render())
+        current_deploy_link = os.path.join(check.non_empty_str(home), self.CURRENT_DEPLOY_LINK.render())
+        with self._atomics(home).begin_atomic_path_swap(  # noqa
+                'file',
+                home_current_link,
+                auto_commit=True,
+        ) as dst_swap:
+            os.unlink(dst_swap.tmp_path)
+            os.symlink(
+                os.path.relpath(current_deploy_link, os.path.dirname(dst_swap.dst_path)),
+                dst_swap.tmp_path,
+            )
+
+
+##
+
+
+class DeployDriverFactory(Func1[DeploySpec, ta.ContextManager['DeployDriver']]):
+    pass
+
+
+class DeployDriver:
+    def __init__(
+            self,
+            *,
+            spec: DeploySpec,
+            home: DeployHome,
+            time: DeployTime,
+
+            deploys: DeployManager,
+            paths: DeployPathsManager,
+            apps: DeployAppManager,
+            conf: DeployConfManager,
+            systemd: DeploySystemdManager,
+
+            msh: ObjMarshalerManager,
+    ) -> None:
+        super().__init__()
+
+        self._spec = spec
+        self._home = home
+        self._time = time
+
+        self._deploys = deploys
+        self._paths = paths
+        self._apps = apps
+        self._conf = conf
+        self._systemd = systemd
+
+        self._msh = msh
+
+    #
+
+    @property
+    def tags(self) -> DeployTagMap:
+        return DeployTagMap(
+            self._time,
+            self._spec.key(),
+        )
+
+    def render_path(self, pth: DeployPath, tags: ta.Optional[DeployTagMap] = None) -> str:
+        return os.path.join(self._home, pth.render(tags if tags is not None else self.tags))
+
+    @property
+    def dir(self) -> str:
+        return self.render_path(self._deploys.DEPLOY_DIR)
+
+    #
+
+    async def drive_deploy(self) -> None:
+        spec_json = json_dumps_pretty(self._msh.marshal_obj(self._spec))
+
+        #
+
+        das: ta.Set[DeployApp] = {a.app for a in self._spec.apps}
+        las: ta.Set[DeployApp] = set(self._spec.app_links.apps)
+        if (ras := das & las):
+            raise RuntimeError(f'Must not specify apps as both deploy and link: {sorted(a.s for a in ras)}')
+
+        #
+
+        self._paths.validate_deploy_paths()
+
+        #
+
+        os.makedirs(self.dir)
+
+        #
+
+        spec_file = self.render_path(self._deploys.DEPLOY_SPEC_FILE)
+        with open(spec_file, 'w') as f:  # noqa
+            f.write(spec_json)
+
+        #
+
+        deploying_link = self.render_path(self._deploys.DEPLOYING_DEPLOY_LINK)
+        current_link = self.render_path(self._deploys.CURRENT_DEPLOY_LINK)
+
+        #
+
+        if os.path.exists(deploying_link):
+            os.unlink(deploying_link)
+        relative_symlink(
+            self.dir,
+            deploying_link,
+            target_is_directory=True,
+            make_dirs=True,
+        )
+
+        #
+
+        for md in [
+            self._deploys.APPS_DEPLOY_DIR,
+            self._deploys.CONFS_DEPLOY_DIR,
+        ]:
+            os.makedirs(self.render_path(md))
+
+        #
+
+        if not self._spec.app_links.exclude_unspecified:
+            cad = abs_real_path(os.path.join(current_link, 'apps'))
+            if os.path.exists(cad):
+                for d in os.listdir(cad):
+                    if (da := DeployApp(d)) not in das:
+                        las.add(da)
+
+        for la in self._spec.app_links.apps:
+            await self._drive_app_link(
+                la,
+                current_link,
+            )
+
+        for app in self._spec.apps:
+            await self._drive_app_deploy(
+                app,
+            )
+
+        #
+
+        os.replace(deploying_link, current_link)
+
+        #
+
+        await self._systemd.sync_systemd(
+            self._spec.systemd,
+            self._home,
+            os.path.join(self.dir, 'conf', 'systemd'),  # FIXME
+        )
+
+        #
+
+        self._deploys.make_home_current_link(self._home)
+
+    #
+
+    async def _drive_app_deploy(self, app: DeployAppSpec) -> None:
+        pa = await self._apps.prepare_app(
+            app,
+            self._home,
+            self.tags,
+        )
+
+        #
+
+        app_link = self.render_path(self._deploys.APP_DEPLOY_LINK, pa.tags)
+        relative_symlink(
+            pa.dir,
+            app_link,
+            target_is_directory=True,
+            make_dirs=True,
+        )
+
+        #
+
+        await self._drive_app_configure(pa)
+
+    async def _drive_app_link(
+            self,
+            app: DeployApp,
+            current_link: str,
+    ) -> None:
+        app_link = os.path.join(abs_real_path(current_link), 'apps', app.s)
+        check.state(os.path.islink(app_link))
+
+        app_dir = abs_real_path(app_link)
+        check.state(os.path.isdir(app_dir))
+
+        #
+
+        pa = await self._apps.prepare_app_link(
+            self.tags,
+            app_dir,
+        )
+
+        #
+
+        relative_symlink(
+            app_dir,
+            os.path.join(self.dir, 'apps', app.s),
+            target_is_directory=True,
+        )
+
+        #
+
+        await self._drive_app_configure(pa)
+
+    async def _drive_app_configure(
+            self,
+            pa: DeployAppManager.PreparedApp,
+    ) -> None:
+        deploy_conf_dir = self.render_path(self._deploys.CONFS_DEPLOY_DIR)
+        if pa.spec.conf is not None:
+            await self._conf.link_app_conf(
+                pa.spec.conf,
+                pa.tags,
+                check.non_empty_str(pa.conf_dir),
+                deploy_conf_dir,
+            )

ominfra/manage/deploy/inject.py

@@ -16,15 +16,16 @@ from .commands import DeployCommand
 from .commands import DeployCommandExecutor
 from .conf.inject import bind_deploy_conf
 from .config import DeployConfig
+from .deploy import DeployDriver
+from .deploy import DeployDriverFactory
 from .deploy import DeployManager
-from .driver import DeployDriver
-from .driver import DeployDriverFactory
 from .git import DeployGitManager
 from .inject_ import bind_deploy_manager
 from .interp import InterpCommand
 from .interp import InterpCommandExecutor
 from .paths.inject import bind_deploy_paths
 from .specs import DeploySpec
+from .systemd import DeploySystemdManager
 from .tags import DeployTime
 from .tmp import DeployHomeAtomics
 from .tmp import DeployTmpManager
@@ -101,13 +102,10 @@ def bind_deploy(
 
     lst.extend([
         bind_deploy_manager(DeployAppManager),
-
         bind_deploy_manager(DeployGitManager),
-
         bind_deploy_manager(DeployManager),
-
+        bind_deploy_manager(DeploySystemdManager),
         bind_deploy_manager(DeployTmpManager),
-
         bind_deploy_manager(DeployVenvManager),
     ])
 

ominfra/manage/deploy/nginx.py

@@ -0,0 +1,8 @@
+# ruff: noqa: UP006 UP007
+"""
+verify - nginx -t
+"""
+
+
+class DeployNginxManager:
+    pass

ominfra/manage/deploy/paths/paths.py

@@ -33,6 +33,10 @@ class DeployPathError(Exception):
 
 
 class DeployPathRenderable(abc.ABC):
+    @cached_nullary
+    def __str__(self) -> str:
+        return self.render(None)
+
     @abc.abstractmethod
     def render(self, tags: ta.Optional[DeployTagMap] = None) -> str:
         raise NotImplementedError
@@ -174,7 +178,7 @@ class FileDeployPathPart(DeployPathPart):
 
 
 @dc.dataclass(frozen=True)
-class DeployPath:
+class DeployPath(DeployPathRenderable):
     parts: ta.Sequence[DeployPathPart]
 
     @property

ominfra/manage/deploy/specs.py

@@ -91,6 +91,22 @@ class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
         return DeployAppKey(self._key_str())
 
 
+@dc.dataclass(frozen=True)
+class DeployAppLinksSpec:
+    apps: ta.Sequence[DeployApp] = ()
+
+    exclude_unspecified: bool = False
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeploySystemdSpec:
+    # ~/.config/systemd/user/
+    unit_dir: ta.Optional[str] = None
+
+
 ##
 
 
@@ -98,7 +114,11 @@ class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
 class DeploySpec(DeploySpecKeyed[DeployKey]):
     home: DeployHome
 
-    apps: ta.Sequence[DeployAppSpec]
+    apps: ta.Sequence[DeployAppSpec] = ()
+
+    app_links: DeployAppLinksSpec = DeployAppLinksSpec()
+
+    systemd: ta.Optional[DeploySystemdSpec] = None
 
     def __post_init__(self) -> None:
         check.non_empty_str(self.home)

ominfra/manage/deploy/systemd.py

@@ -0,0 +1,131 @@
+# ruff: noqa: UP006 UP007
+"""
+TODO:
+ - verify - systemd-analyze
+ - sudo loginctl enable-linger "$USER"
+ - idemp kill services that shouldn't be running, start ones that should
+  - ideally only those defined by links to deploy home
+  - ominfra.systemd / x.sd_orphans
+"""
+import os.path
+import sys
+import typing as ta
+
+from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
+from omlish.lite.check import check
+from omlish.os.paths import abs_real_path
+from omlish.os.paths import is_path_in_dir
+
+from .specs import DeploySystemdSpec
+from .tmp import DeployHomeAtomics
+from .types import DeployHome
+
+
+class DeploySystemdManager:
+    def __init__(
+            self,
+            *,
+            atomics: DeployHomeAtomics,
+    ) -> None:
+        super().__init__()
+
+        self._atomics = atomics
+
+    def _scan_link_dir(
+            self,
+            d: str,
+            *,
+            strict: bool = False,
+    ) -> ta.Dict[str, str]:
+        o: ta.Dict[str, str] = {}
+        for f in os.listdir(d):
+            fp = os.path.join(d, f)
+            if strict:
+                check.state(os.path.islink(fp))
+            o[f] = abs_real_path(fp)
+        return o
+
+    async def sync_systemd(
+            self,
+            spec: ta.Optional[DeploySystemdSpec],
+            home: DeployHome,
+            conf_dir: str,
+    ) -> None:
+        check.non_empty_str(home)
+
+        if not spec:
+            return
+
+        #
+
+        if not (ud := spec.unit_dir):
+            return
+
+        ud = abs_real_path(os.path.expanduser(ud))
+
+        os.makedirs(ud, exist_ok=True)
+
+        #
+
+        uld = {
+            n: p
+            for n, p in self._scan_link_dir(ud).items()
+            if is_path_in_dir(home, p)
+        }
+
+        if os.path.exists(conf_dir):
+            cld = self._scan_link_dir(conf_dir, strict=True)
+        else:
+            cld = {}
+
+        #
+
+        ns = sorted(set(uld) | set(cld))
+
+        for n in ns:
+            cl = cld.get(n)
+            if cl is None:
+                os.unlink(os.path.join(ud, n))
+            else:
+                with self._atomics(home).begin_atomic_path_swap(  # noqa
+                        'file',
+                        os.path.join(ud, n),
+                        auto_commit=True,
+                        skip_root_dir_check=True,
+                ) as dst_swap:
+                    os.unlink(dst_swap.tmp_path)
+                    os.symlink(
+                        os.path.relpath(cl, os.path.dirname(dst_swap.dst_path)),
+                        dst_swap.tmp_path,
+                    )
+
+        #
+
+        if sys.platform == 'linux':
+            async def reload() -> None:
+                await asyncio_subprocesses.check_call('systemctl', '--user', 'daemon-reload')
+
+            await reload()
+
+            num_deleted = 0
+            for n in ns:
+                if n.endswith('.service'):
+                    cl = cld.get(n)
+                    ul = uld.get(n)
+                    if cl is not None:
+                        if ul is None:
+                            cs = ['enable', 'start']
+                        else:
+                            cs = ['restart']
+                    else:  # noqa
+                        if ul is not None:
+                            cs = ['stop']
+                            num_deleted += 1
+                        else:
+                            cs = []
+
+                    for c in cs:
+                        await asyncio_subprocesses.check_call('systemctl', '--user', c, n)
+
+            if num_deleted:
+                await reload()

ominfra/manage/deploy/tags.py

@@ -29,7 +29,7 @@ DEPLOY_TAG_ILLEGAL_STRS: ta.AbstractSet[str] = frozenset([
 ##
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, order=True)
 class DeployTag(abc.ABC):  # noqa
     s: str
 

ominfra/manage/deploy/venvs.py

@@ -5,6 +5,7 @@ TODO:
  - share more code with pyproject?
 """
 import os.path
+import shutil
 
 from omdev.interp.default import get_default_interp_resolver
 from omdev.interp.types import InterpSpecifier
@@ -12,14 +13,12 @@ from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.check import check
 
 from .specs import DeployVenvSpec
-from .types import DeployHome
 
 
 class DeployVenvManager:
     async def setup_venv(
             self,
             spec: DeployVenvSpec,
-            home: DeployHome,
             git_dir: str,
             venv_dir: str,
     ) -> None:
@@ -46,9 +45,12 @@ class DeployVenvManager:
 
         if os.path.isfile(reqs_txt):
             if spec.use_uv:
-                await asyncio_subprocesses.check_call(venv_exe, '-m', 'pip', 'install', 'uv')
-                pip_cmd = ['-m', 'uv', 'pip']
+                if shutil.which('uv') is not None:
+                    pip_cmd = ['uv', 'pip']
+                else:
+                    await asyncio_subprocesses.check_call(venv_exe, '-m', 'pip', 'install', 'uv')
+                    pip_cmd = [venv_exe, '-m', 'uv', 'pip']
             else:
-                pip_cmd = ['-m', 'pip']
+                pip_cmd = [venv_exe, '-m', 'pip']
 
-            await asyncio_subprocesses.check_call(venv_exe, *pip_cmd,'install', '-r', reqs_txt)
+            await asyncio_subprocesses.check_call(*pip_cmd, 'install', '-r', reqs_txt, cwd=venv_dir)