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

ominfra/scripts/manage.py

@@ -6635,6 +6635,7 @@ class AtomicPathSwapping(abc.ABC):
             *,
             name_hint: ta.Optional[str] = None,
             make_dirs: bool = False,
+            skip_root_dir_check: bool = False,
             **kwargs: ta.Any,
     ) -> AtomicPathSwap:
         raise NotImplementedError
@@ -6698,10 +6699,15 @@ class TempDirAtomicPathSwapping(AtomicPathSwapping):
             *,
             name_hint: ta.Optional[str] = None,
             make_dirs: bool = False,
+            skip_root_dir_check: bool = False,
             **kwargs: ta.Any,
     ) -> AtomicPathSwap:
         dst_path = os.path.abspath(dst_path)
-        if self._root_dir is not None and not dst_path.startswith(check.non_empty_str(self._root_dir)):
+        if (
+                not skip_root_dir_check and
+                self._root_dir is not None and
+                not dst_path.startswith(check.non_empty_str(self._root_dir))
+        ):
             raise RuntimeError(f'Atomic path swap dst must be in root dir: {dst_path}, {self._root_dir}')
 
         dst_dir = os.path.dirname(dst_path)
@@ -6726,6 +6732,54 @@ class TempDirAtomicPathSwapping(AtomicPathSwapping):
         )
 
 
+########################################
+# ../../../omlish/text/indent.py
+
+
+class IndentWriter:
+    DEFAULT_INDENT = ' ' * 4
+
+    def __init__(
+            self,
+            *,
+            buf: ta.Optional[io.StringIO] = None,
+            indent: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        self._buf = buf if buf is not None else io.StringIO()
+        self._indent = check.isinstance(indent, str) if indent is not None else self.DEFAULT_INDENT
+        self._level = 0
+        self._has_indented = False
+
+    @contextlib.contextmanager
+    def indent(self, num: int = 1) -> ta.Iterator[None]:
+        self._level += num
+        try:
+            yield
+        finally:
+            self._level -= num
+
+    def write(self, s: str) -> None:
+        indent = self._indent * self._level
+        i = 0
+        while i < len(s):
+            if not self._has_indented:
+                self._buf.write(indent)
+                self._has_indented = True
+            try:
+                n = s.index('\n', i)
+            except ValueError:
+                self._buf.write(s[i:])
+                break
+            self._buf.write(s[i:n + 1])
+            self._has_indented = False
+            i = n + 2
+
+    def getvalue(self) -> str:
+        return self._buf.getvalue()
+
+
 ########################################
 # ../../../omdev/interp/types.py
 
@@ -7035,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
 
@@ -7784,6 +7838,78 @@ class AbstractAsyncSubprocesses(BaseSubprocesses):
             return ret.decode().strip()
 
 
+########################################
+# ../../../omserv/nginx/configs.py
+"""
+TODO:
+ - omnibus/jmespath
+
+https://nginx.org/en/docs/dev/development_guide.html
+https://nginx.org/en/docs/dev/development_guide.html#config_directives
+https://nginx.org/en/docs/example.html
+
+https://github.com/yandex/gixy
+"""
+
+
+@dc.dataclass()
+class NginxConfigItems:
+    lst: ta.List['NginxConfigItem']
+
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'NginxConfigItems':
+        if isinstance(obj, NginxConfigItems):
+            return obj
+        return cls([NginxConfigItem.of(e) for e in check.isinstance(obj, list)])
+
+
+@dc.dataclass()
+class NginxConfigItem:
+    name: str
+    args: ta.Optional[ta.List[str]] = None
+    block: ta.Optional[NginxConfigItems] = None
+
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'NginxConfigItem':
+        if isinstance(obj, NginxConfigItem):
+            return obj
+        args = check.isinstance(check.not_isinstance(obj, str), collections.abc.Sequence)
+        name, args = check.isinstance(args[0], str), args[1:]
+        if args and not isinstance(args[-1], str):
+            block, args = NginxConfigItems.of(args[-1]), args[:-1]
+        else:
+            block = None
+        return NginxConfigItem(name, [check.isinstance(e, str) for e in args], block=block)
+
+
+def render_nginx_config(wr: IndentWriter, obj: ta.Any) -> None:
+    if isinstance(obj, NginxConfigItem):
+        wr.write(obj.name)
+        for e in obj.args or ():
+            wr.write(' ')
+            wr.write(e)
+        if obj.block:
+            wr.write(' {\n')
+            with wr.indent():
+                render_nginx_config(wr, obj.block)
+            wr.write('}\n')
+        else:
+            wr.write(';\n')
+
+    elif isinstance(obj, NginxConfigItems):
+        for e2 in obj.lst:
+            render_nginx_config(wr, e2)
+
+    else:
+        raise TypeError(obj)
+
+
+def render_nginx_config_str(obj: ta.Any) -> str:
+    iw = IndentWriter()
+    render_nginx_config(iw, obj)
+    return iw.getvalue()
+
+
 ########################################
 # ../../../omdev/interp/providers/base.py
 """
@@ -7900,6 +8026,15 @@ class IniDeployAppConfContent(DeployAppConfContent):
     sections: IniConfigSectionSettingsMap
 
 
+#
+
+
+@register_single_field_type_obj_marshaler('items')
+@dc.dataclass(frozen=True)
+class NginxDeployAppConfContent(DeployAppConfContent):
+    items: ta.Any
+
+
 ##
 
 
@@ -7951,37 +8086,6 @@ class DeployAppConfSpec:
                 seen.add(f.path)
 
 
-########################################
-# ../deploy/deploy.py
-
-
-DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
-
-
-DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
-
-
-class DeployManager:
-    def __init__(
-            self,
-            *,
-
-            utc_clock: ta.Optional[DeployManagerUtcClock] = None,
-    ):
-        super().__init__()
-
-        self._utc_clock = utc_clock
-
-    def _utc_now(self) -> datetime.datetime:
-        if self._utc_clock is not None:
-            return self._utc_clock()  # noqa
-        else:
-            return datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
-
-    def make_deploy_time(self) -> DeployTime:
-        return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
-
-
 ########################################
 # ../deploy/paths/paths.py
 """
@@ -8003,6 +8107,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
@@ -8144,7 +8252,7 @@ class FileDeployPathPart(DeployPathPart):
 
 
 @dc.dataclass(frozen=True)
-class DeployPath:
+class DeployPath(DeployPathRenderable):
     parts: ta.Sequence[DeployPathPart]
 
     @property
@@ -9160,16 +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):
+            nginx_items = NginxConfigItems.of(pcc(ac.items))
+            return strip_with_newline(render_nginx_config_str(nginx_items))
 
         else:
             raise TypeError(ac)
@@ -9178,17 +9333,37 @@ 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)
 
         with open(conf_file, 'w') as f:  # noqa
             f.write(body)
 
+    async def write_app_conf(
+            self,
+            spec: DeployAppConfSpec,
+            app_conf_dir: str,
+    ) -> None:
+        def process_str(s: str) -> str:
+            return s
+
+        for acf in spec.files or []:
+            await self._write_app_conf_file(
+                acf,
+                app_conf_dir,
+                str_processor=process_str,
+            )
+
     #
 
     class _ComputedConfLink(ta.NamedTuple):
@@ -9298,23 +9473,13 @@ class DeployConfManager:
             make_dirs=True,
         )
 
-    #
-
-    async def write_app_conf(
+    async def link_app_conf(
             self,
             spec: DeployAppConfSpec,
             tags: DeployTagMap,
             app_conf_dir: str,
             conf_link_dir: str,
-    ) -> None:
-        for acf in spec.files or []:
-            await self._write_app_conf_file(
-                acf,
-                app_conf_dir,
-            )
-
-        #
-
+    ):
         for link in spec.links or []:
             await self._make_app_conf_link(
                 link,
@@ -9439,6 +9604,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
+
+
 ##
 
 
@@ -9446,7 +9627,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)
@@ -10848,6 +11033,128 @@ def bind_deploy_paths() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../deploy/systemd.py
+"""
+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
+"""
+
+
+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()
+
+
 ########################################
 # ../remote/inject.py
 
@@ -11202,7 +11509,6 @@ class DeployVenvManager:
     async def setup_venv(
             self,
             spec: DeployVenvSpec,
-            home: DeployHome,
             git_dir: str,
             venv_dir: str,
     ) -> None:
@@ -11229,12 +11535,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)
 
 
 ########################################
@@ -11245,39 +11554,31 @@ class DeployAppManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            conf: DeployConfManager,
             git: DeployGitManager,
             venvs: DeployVenvManager,
+            conf: DeployConfManager,
+
+            msh: ObjMarshalerManager,
     ) -> None:
         super().__init__()
 
-        self._conf = conf
         self._git = git
         self._venvs = venvs
+        self._conf = conf
 
-    #
-
-    _APP_DIR_STR = 'apps/@app/@time--@app-rev--@app-key/'
-    _APP_DIR = DeployPath.parse(_APP_DIR_STR)
+        self._msh = msh
 
-    _DEPLOY_DIR_STR = 'deploys/@time--@deploy-key/'
-    _DEPLOY_DIR = DeployPath.parse(_DEPLOY_DIR_STR)
+    #
 
-    _APP_DEPLOY_LINK = DeployPath.parse(f'{_DEPLOY_DIR_STR}apps/@app')
-    _CONF_DEPLOY_DIR = DeployPath.parse(f'{_DEPLOY_DIR_STR}conf/@conf/')
+    APP_DIR = DeployPath.parse('apps/@app/@time--@app-rev--@app-key/')
 
     @cached_nullary
     def get_owned_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
-            self._APP_DIR,
-
-            self._DEPLOY_DIR,
-
-            self._APP_DEPLOY_LINK,
-            self._CONF_DEPLOY_DIR,
+            self.APP_DIR,
 
             *[
-                DeployPath.parse(f'{self._APP_DIR_STR}{sfx}/')
+                DeployPath.parse(f'{self.APP_DIR}{sfx}/')
                 for sfx in [
                     'conf',
                     'git',
@@ -11288,122 +11589,244 @@ 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:
+        spec: DeployAppSpec
+        tags: DeployTagMap
+
+        dir: str
+
+        git_dir: ta.Optional[str] = None
+        venv_dir: ta.Optional[str] = None
+        conf_dir: ta.Optional[str] = None
+
     async def prepare_app(
             self,
             spec: DeployAppSpec,
             home: DeployHome,
             tags: DeployTagMap,
-    ) -> None:
-        check.non_empty_str(home)
+    ) -> PreparedApp:
+        spec_json = json_dumps_pretty(self._msh.marshal_obj(spec))
 
-        def build_path(pth: DeployPath) -> str:
-            return os.path.join(home, pth.render(tags))
+        #
 
-        app_dir = build_path(self._APP_DIR)
-        deploy_dir = build_path(self._DEPLOY_DIR)
-        app_deploy_link = build_path(self._APP_DEPLOY_LINK)
+        app_tags = tags.add(*self._make_tags(spec))
 
         #
 
-        os.makedirs(deploy_dir, exist_ok=True)
-
-        deploying_link = os.path.join(home, 'deploys/deploying')
-        if os.path.exists(deploying_link):
-            os.unlink(deploying_link)
-        relative_symlink(
-            deploy_dir,
-            deploying_link,
-            target_is_directory=True,
-            make_dirs=True,
-        )
+        check.non_empty_str(home)
 
-        #
+        app_dir = os.path.join(home, self.APP_DIR.render(app_tags))
 
-        os.makedirs(app_dir)
-        relative_symlink(
-            app_dir,
-            app_deploy_link,
-            target_is_directory=True,
-            make_dirs=True,
-        )
+        os.makedirs(app_dir, exist_ok=True)
 
         #
 
-        deploy_conf_dir = os.path.join(deploy_dir, 'conf')
-        os.makedirs(deploy_conf_dir, exist_ok=True)
+        rkw: ta.Dict[str, ta.Any] = dict(
+            spec=spec,
+            tags=app_tags,
 
-        #
+            dir=app_dir,
+        )
 
-        # def mirror_symlinks(src: str, dst: str) -> None:
-        #     def mirror_link(lp: str) -> None:
-        #         check.state(os.path.islink(lp))
-        #         shutil.copy2(
-        #             lp,
-        #             os.path.join(dst, os.path.relpath(lp, src)),
-        #             follow_symlinks=False,
-        #         )
-        #
-        #     for dp, dns, fns in os.walk(src, followlinks=False):
-        #         for fn in fns:
-        #             mirror_link(os.path.join(dp, fn))
         #
-        #         for dn in dns:
-        #             dp2 = os.path.join(dp, dn)
-        #             if os.path.islink(dp2):
-        #                 mirror_link(dp2)
-        #             else:
-        #                 os.makedirs(os.path.join(dst, os.path.relpath(dp2, src)))
-
-        current_link = os.path.join(home, 'deploys/current')
-
-        # if os.path.exists(current_link):
-        #     mirror_symlinks(
-        #         os.path.join(current_link, 'conf'),
-        #         conf_tag_dir,
-        #     )
-        #     mirror_symlinks(
-        #         os.path.join(current_link, 'apps'),
-        #         os.path.join(deploy_dir, 'apps'),
-        #     )
+
+        spec_file = os.path.join(app_dir, 'spec.json')
+        with open(spec_file, 'w') as f:  # noqa
+            f.write(spec_json)
 
         #
 
-        app_git_dir = os.path.join(app_dir, 'git')
+        git_dir = os.path.join(app_dir, 'git')
+        rkw.update(git_dir=git_dir)
         await self._git.checkout(
             spec.git,
             home,
-            app_git_dir,
+            git_dir,
         )
 
         #
 
         if spec.venv is not None:
-            app_venv_dir = os.path.join(app_dir, 'venv')
+            venv_dir = os.path.join(app_dir, 'venv')
+            rkw.update(venv_dir=venv_dir)
             await self._venvs.setup_venv(
                 spec.venv,
-                home,
-                app_git_dir,
-                app_venv_dir,
+                git_dir,
+                venv_dir,
             )
 
         #
 
         if spec.conf is not None:
-            app_conf_dir = os.path.join(app_dir, 'conf')
+            conf_dir = os.path.join(app_dir, 'conf')
+            rkw.update(conf_dir=conf_dir)
             await self._conf.write_app_conf(
                 spec.conf,
-                tags,
-                app_conf_dir,
-                deploy_conf_dir,
+                conf_dir,
             )
 
         #
 
-        os.replace(deploying_link, current_link)
+        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/driver.py
+# ../deploy/deploy.py
+
+
+##
+
+
+DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
+
+
+DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
+
+
+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
+        else:
+            return datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
+
+    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']]):
@@ -11418,8 +11841,13 @@ class DeployDriver:
             home: DeployHome,
             time: DeployTime,
 
+            deploys: DeployManager,
             paths: DeployPathsManager,
             apps: DeployAppManager,
+            conf: DeployConfManager,
+            systemd: DeploySystemdManager,
+
+            msh: ObjMarshalerManager,
     ) -> None:
         super().__init__()
 
@@ -11427,32 +11855,180 @@ class DeployDriver:
         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()
 
         #
 
-        deploy_tags = DeployTagMap(
-            self._time,
-            self._spec.key(),
+        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 app in self._spec.apps:
-            app_tags = deploy_tags.add(
-                app.app,
-                app.key(),
-                DeployAppRev(app.git.rev),
+        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,
             )
 
-            await self._apps.prepare_app(
+        for app in self._spec.apps:
+            await self._drive_app_deploy(
                 app,
-                self._home,
-                app_tags,
+            )
+
+        #
+
+        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,
             )
 
 
@@ -11558,13 +12134,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),
     ])