ominfra 0.0.0.dev190__py3-none-any.whl → 0.0.0.dev192__py3-none-any.whl

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
@@ -44,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)

ominfra/scripts/manage.py

@@ -7089,7 +7089,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
 
@@ -9268,20 +9268,63 @@ TODO:
 """
 
 
+##
+
+
 class DeployConfManager:
-    def _render_app_conf_content(self, ac: DeployAppConfContent) -> str:
+    def _process_conf_content(
+            self,
+            content: T,
+            *,
+            str_processor: ta.Optional[ta.Callable[[str], str]] = None,
+    ) -> T:
+        def rec(o):
+            if isinstance(o, str):
+                if str_processor is not None:
+                    return type(o)(str_processor(o))
+
+            elif isinstance(o, collections.abc.Mapping):
+                return type(o)([  # type: ignore
+                    (rec(k), rec(v))
+                    for k, v in o.items()
+                ])
+
+            elif isinstance(o, collections.abc.Iterable):
+                return type(o)([  # type: ignore
+                    rec(e) for e in o
+                ])
+
+            return o
+
+        return rec(content)
+
+    #
+
+    def _render_app_conf_content(
+            self,
+            ac: DeployAppConfContent,
+            *,
+            str_processor: ta.Optional[ta.Callable[[str], str]] = None,
+    ) -> str:
+        pcc = functools.partial(
+            self._process_conf_content,
+            str_processor=str_processor,
+        )
+
         if isinstance(ac, RawDeployAppConfContent):
-            return ac.body
+            return pcc(ac.body)
 
         elif isinstance(ac, JsonDeployAppConfContent):
-            return strip_with_newline(json_dumps_pretty(ac.obj))
+            json_obj = pcc(ac.obj)
+            return strip_with_newline(json_dumps_pretty(json_obj))
 
         elif isinstance(ac, IniDeployAppConfContent):
-            return strip_with_newline(render_ini_config(ac.sections))
+            ini_sections = pcc(ac.sections)
+            return strip_with_newline(render_ini_config(ini_sections))
 
         elif isinstance(ac, NginxDeployAppConfContent):
-            ni = NginxConfigItems.of(ac.items)
-            return strip_with_newline(render_nginx_config_str(ni))
+            nginx_items = NginxConfigItems.of(pcc(ac.items))
+            return strip_with_newline(render_nginx_config_str(nginx_items))
 
         else:
             raise TypeError(ac)
@@ -9290,11 +9333,16 @@ class DeployConfManager:
             self,
             acf: DeployAppConfFile,
             app_conf_dir: str,
+            *,
+            str_processor: ta.Optional[ta.Callable[[str], str]] = None,
     ) -> None:
         conf_file = os.path.join(app_conf_dir, acf.path)
         check.arg(is_path_in_dir(app_conf_dir, conf_file))
 
-        body = self._render_app_conf_content(acf.content)
+        body = self._render_app_conf_content(
+            acf.content,
+            str_processor=str_processor,
+        )
 
         os.makedirs(os.path.dirname(conf_file), exist_ok=True)
 
@@ -9305,11 +9353,21 @@ class DeployConfManager:
             self,
             spec: DeployAppConfSpec,
             app_conf_dir: str,
+            *,
+            string_ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
     ) -> None:
+        process_str: ta.Any
+        if string_ns is not None:
+            def process_str(s: str) -> str:
+                return s.format(**string_ns)
+        else:
+            process_str = None
+
         for acf in spec.files or []:
             await self._write_app_conf_file(
                 acf,
                 app_conf_dir,
+                str_processor=process_str,
             )
 
     #
@@ -9552,6 +9610,15 @@ class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
         return DeployAppKey(self._key_str())
 
 
+@dc.dataclass(frozen=True)
+class DeployAppLinksSpec:
+    apps: ta.Sequence[DeployApp] = ()
+
+    removed_apps: ta.Sequence[DeployApp] = ()
+
+    exclude_unspecified: bool = False
+
+
 ##
 
 
@@ -9570,6 +9637,8 @@ class DeploySpec(DeploySpecKeyed[DeployKey]):
 
     apps: ta.Sequence[DeployAppSpec] = ()
 
+    app_links: DeployAppLinksSpec = DeployAppLinksSpec()
+
     systemd: ta.Optional[DeploySystemdSpec] = None
 
     def __post_init__(self) -> None:
@@ -10906,7 +10975,9 @@ class DeployGitManager(SingleDirDeployPathOwner):
 
         async def fetch(self, rev: DeployRev) -> None:
             await self.init()
-            await self._call('git', 'fetch', '--depth=1', 'origin', rev)
+
+            # This fetch shouldn't be depth=1 - git doesn't reuse local data with shallow fetches.
+            await self._call('git', 'fetch', 'origin', rev)
 
         #
 
@@ -10975,31 +11046,12 @@ def bind_deploy_paths() -> InjectorBindings:
 ########################################
 # ../deploy/systemd.py
 """
-~/.config/systemd/user/
-
-verify - systemd-analyze
-
-sudo loginctl enable-linger "$USER"
-
-cat ~/.config/systemd/user/sleep-infinity.service
-    [Unit]
-    Description=User-specific service to run 'sleep infinity'
-    After=default.target
-
-    [Service]
-    ExecStart=/bin/sleep infinity
-    Restart=always
-    RestartSec=5
-
-    [Install]
-    WantedBy=default.target
-
-systemctl --user daemon-reload
-
-systemctl --user enable sleep-infinity.service
-systemctl --user start sleep-infinity.service
-
-systemctl --user status sleep-infinity.service
+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
 """
 
 
@@ -11038,6 +11090,8 @@ class DeploySystemdManager:
         if not spec:
             return
 
+        #
+
         if not (ud := spec.unit_dir):
             return
 
@@ -11045,6 +11099,8 @@ class DeploySystemdManager:
 
         os.makedirs(ud, exist_ok=True)
 
+        #
+
         uld = {
             n: p
             for n, p in self._scan_link_dir(ud).items()
@@ -11056,8 +11112,11 @@ class DeploySystemdManager:
         else:
             cld = {}
 
-        for n in sorted(set(uld) | set(cld)):
-            ul = uld.get(n)  # noqa
+        #
+
+        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))
@@ -11074,6 +11133,37 @@ class DeploySystemdManager:
                         dst_swap.tmp_path,
                     )
 
+        #
+
+        if sys.platform == 'linux' and shutil.which('systemctl') is not None:
+            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()
+
 
 ########################################
 # ../remote/inject.py
@@ -11455,12 +11545,15 @@ 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)
 
 
 ########################################
@@ -11506,9 +11599,21 @@ class DeployAppManager(DeployPathOwner):
 
     #
 
+    def _make_tags(self, spec: DeployAppSpec) -> DeployTagMap:
+        return DeployTagMap(
+            spec.app,
+            spec.key(),
+            DeployAppRev(spec.git.rev),
+        )
+
+    #
+
     @dc.dataclass(frozen=True)
     class PreparedApp:
-        app_dir: str
+        spec: DeployAppSpec
+        tags: DeployTagMap
+
+        dir: str
 
         git_dir: ta.Optional[str] = None
         venv_dir: ta.Optional[str] = None
@@ -11519,21 +11624,30 @@ class DeployAppManager(DeployPathOwner):
             spec: DeployAppSpec,
             home: DeployHome,
             tags: DeployTagMap,
+            *,
+            conf_string_ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
     ) -> PreparedApp:
         spec_json = json_dumps_pretty(self._msh.marshal_obj(spec))
 
         #
 
+        app_tags = tags.add(*self._make_tags(spec))
+
+        #
+
         check.non_empty_str(home)
 
-        app_dir = os.path.join(home, self.APP_DIR.render(tags))
+        app_dir = os.path.join(home, self.APP_DIR.render(app_tags))
 
         os.makedirs(app_dir, exist_ok=True)
 
         #
 
         rkw: ta.Dict[str, ta.Any] = dict(
-            app_dir=app_dir,
+            spec=spec,
+            tags=app_tags,
+
+            dir=app_dir,
         )
 
         #
@@ -11568,15 +11682,71 @@ class DeployAppManager(DeployPathOwner):
         if spec.conf is not None:
             conf_dir = os.path.join(app_dir, 'conf')
             rkw.update(conf_dir=conf_dir)
+
+            conf_ns: ta.Dict[str, ta.Any] = dict(
+                **(conf_string_ns or {}),
+                app=spec.app.s,
+                app_dir=app_dir.rstrip('/'),
+            )
+
             await self._conf.write_app_conf(
                 spec.conf,
                 conf_dir,
+                string_ns=conf_ns,
             )
 
         #
 
         return DeployAppManager.PreparedApp(**rkw)
 
+    async def prepare_app_link(
+            self,
+            tags: DeployTagMap,
+            app_dir: str,
+    ) -> PreparedApp:
+        spec_file = os.path.join(app_dir, 'spec.json')
+        with open(spec_file) as f:  # noqa
+            spec_json = f.read()
+
+        spec: DeployAppSpec = self._msh.unmarshal_obj(json.loads(spec_json), DeployAppSpec)
+
+        #
+
+        app_tags = tags.add(*self._make_tags(spec))
+
+        #
+
+        rkw: ta.Dict[str, ta.Any] = dict(
+            spec=spec,
+            tags=app_tags,
+
+            dir=app_dir,
+        )
+
+        #
+
+        git_dir = os.path.join(app_dir, 'git')
+        check.state(os.path.isdir(git_dir))
+        rkw.update(git_dir=git_dir)
+
+        #
+
+        if spec.venv is not None:
+            venv_dir = os.path.join(app_dir, 'venv')
+            check.state(os.path.isdir(venv_dir))
+            rkw.update(venv_dir=venv_dir)
+
+        #
+
+        if spec.conf is not None:
+            conf_dir = os.path.join(app_dir, 'conf')
+            check.state(os.path.isdir(conf_dir))
+            rkw.update(conf_dir=conf_dir)
+
+        #
+
+        return DeployAppManager.PreparedApp(**rkw)
+
 
 ########################################
 # ../deploy/deploy.py
@@ -11585,7 +11755,7 @@ class DeployAppManager(DeployPathOwner):
 ##
 
 
-DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
+DEPLOY_TAG_DATETIME_FMT = '%Y-%m-%d-T-%H-%M-%S-%f-Z'
 
 
 DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
@@ -11595,16 +11765,24 @@ 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')
 
@@ -11637,6 +11815,11 @@ class DeployManager(DeployPathOwner):
 
     #
 
+    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
@@ -11646,6 +11829,22 @@ class DeployManager(DeployPathOwner):
     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,
+            )
+
 
 ##
 
@@ -11687,18 +11886,18 @@ class DeployDriver:
     #
 
     @property
-    def deploy_tags(self) -> DeployTagMap:
+    def tags(self) -> DeployTagMap:
         return DeployTagMap(
             self._time,
             self._spec.key(),
         )
 
-    def render_deploy_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.deploy_tags))
+    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 deploy_dir(self) -> str:
-        return self.render_deploy_path(self._deploys.DEPLOY_DIR)
+    def dir(self) -> str:
+        return self.render_path(self._deploys.DEPLOY_DIR)
 
     #
 
@@ -11707,25 +11906,37 @@ class DeployDriver:
 
         #
 
+        das: ta.Set[DeployApp] = {a.app for a in self._spec.apps}
+        las: ta.Set[DeployApp] = set(self._spec.app_links.apps)
+        ras: ta.Set[DeployApp] = set(self._spec.app_links.removed_apps)
+        check.empty(das & (las | ras))
+        check.empty(las & ras)
+
+        #
+
         self._paths.validate_deploy_paths()
 
         #
 
-        os.makedirs(self.deploy_dir)
+        os.makedirs(self.dir)
 
         #
 
-        spec_file = self.render_deploy_path(self._deploys.DEPLOY_SPEC_FILE)
+        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_deploy_path(self._deploys.DEPLOYING_DEPLOY_LINK)
+        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.deploy_dir,
+            self.dir,
             deploying_link,
             target_is_directory=True,
             make_dirs=True,
@@ -11737,16 +11948,30 @@ class DeployDriver:
             self._deploys.APPS_DEPLOY_DIR,
             self._deploys.CONFS_DEPLOY_DIR,
         ]:
-            os.makedirs(self.render_deploy_path(md))
+            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 and da not in ras:
+                        las.add(da)
+
+        for la in las:
+            await self._drive_app_link(
+                la,
+                current_link,
+            )
+
         for app in self._spec.apps:
-            await self.drive_app_deploy(app)
+            await self._drive_app_deploy(
+                app,
+            )
 
         #
 
-        current_link = self.render_deploy_path(self._deploys.CURRENT_DEPLOY_LINK)
         os.replace(deploying_link, current_link)
 
         #
@@ -11754,31 +11979,33 @@ class DeployDriver:
         await self._systemd.sync_systemd(
             self._spec.systemd,
             self._home,
-            os.path.join(self.deploy_dir, 'conf', 'systemd'),  # FIXME
+            os.path.join(self.dir, 'conf', 'systemd'),  # FIXME
         )
 
-    #
+        #
 
-    async def drive_app_deploy(self, app: DeployAppSpec) -> None:
-        app_tags = self.deploy_tags.add(
-            app.app,
-            app.key(),
-            DeployAppRev(app.git.rev),
-        )
+        self._deploys.make_home_current_link(self._home)
 
-        #
+    #
+
+    async def _drive_app_deploy(self, app: DeployAppSpec) -> None:
+        current_deploy_link = os.path.join(self._home, self._deploys.CURRENT_DEPLOY_LINK.render())
 
-        da = await self._apps.prepare_app(
+        pa = await self._apps.prepare_app(
             app,
             self._home,
-            app_tags,
+            self.tags,
+            conf_string_ns=dict(
+                deploy_home=self._home,
+                current_deploy_link=current_deploy_link,
+            ),
         )
 
         #
 
-        app_link = self.render_deploy_path(self._deploys.APP_DEPLOY_LINK, app_tags)
+        app_link = self.render_path(self._deploys.APP_DEPLOY_LINK, pa.tags)
         relative_symlink(
-            da.app_dir,
+            pa.dir,
             app_link,
             target_is_directory=True,
             make_dirs=True,
@@ -11786,12 +12013,48 @@ class DeployDriver:
 
         #
 
-        deploy_conf_dir = self.render_deploy_path(self._deploys.CONFS_DEPLOY_DIR)
-        if app.conf is not None:
+        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(
-                app.conf,
-                app_tags,
-                check.non_empty_str(da.conf_dir),
+                pa.spec.conf,
+                pa.tags,
+                check.non_empty_str(pa.conf_dir),
                 deploy_conf_dir,
             )