ominfra 0.0.0.dev167__py3-none-any.whl → 0.0.0.dev169__py3-none-any.whl

ominfra/manage/deploy/apps.py

@@ -9,8 +9,8 @@ from omlish.os.paths import relative_symlink
 
 from .conf import DeployConfManager
 from .git import DeployGitManager
-from .paths import DeployPath
-from .paths import DeployPathOwner
+from .paths.owners import DeployPathOwner
+from .paths.paths import DeployPath
 from .specs import DeploySpec
 from .types import DeployAppTag
 from .types import DeployHome
@@ -51,20 +51,44 @@ class DeployAppManager(DeployPathOwner):
         self._git = git
         self._venvs = venvs
 
-    @cached_nullary
-    def _dir(self) -> str:
-        return os.path.join(check.non_empty_str(self._deploy_home), 'apps')
+    #
+
+    _APP_TAG_DIR_STR = 'tags/apps/@app/@tag/'
+    _APP_TAG_DIR = DeployPath.parse(_APP_TAG_DIR_STR)
+
+    _CONF_TAG_DIR_STR = 'tags/conf/@tag--@app/'
+    _CONF_TAG_DIR = DeployPath.parse(_CONF_TAG_DIR_STR)
+
+    _DEPLOY_DIR_STR = 'deploys/@tag--@app/'
+    _DEPLOY_DIR = DeployPath.parse(_DEPLOY_DIR_STR)
+
+    _APP_DEPLOY_LINK = DeployPath.parse(f'{_DEPLOY_DIR_STR}apps/@app')
+    _CONF_DEPLOY_LINK = DeployPath.parse(f'{_DEPLOY_DIR_STR}conf')
 
+    @cached_nullary
     def get_owned_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
         return {
-            DeployPath.parse('apps/@app/current'),
-            DeployPath.parse('apps/@app/deploying'),
+            self._APP_TAG_DIR,
+
+            self._CONF_TAG_DIR,
+
+            self._DEPLOY_DIR,
 
-            DeployPath.parse('apps/@app/tags/@tag/conf/'),
-            DeployPath.parse('apps/@app/tags/@tag/git/'),
-            DeployPath.parse('apps/@app/tags/@tag/venv/'),
+            self._APP_DEPLOY_LINK,
+            self._CONF_DEPLOY_LINK,
+
+            *[
+                DeployPath.parse(f'{self._APP_TAG_DIR_STR}{sfx}/')
+                for sfx in [
+                    'conf',
+                    'git',
+                    'venv',
+                ]
+            ],
         }
 
+    #
+
     async def prepare_app(
             self,
             spec: DeploySpec,
@@ -73,26 +97,52 @@ class DeployAppManager(DeployPathOwner):
 
         #
 
-        app_dir = os.path.join(self._dir(), spec.app)
-        os.makedirs(app_dir, exist_ok=True)
+        deploy_home = check.non_empty_str(self._deploy_home)
+
+        def build_path(pth: DeployPath) -> str:
+            return os.path.join(deploy_home, pth.render(app_tag.placeholders()))
+
+        app_tag_dir = build_path(self._APP_TAG_DIR)
+        conf_tag_dir = build_path(self._CONF_TAG_DIR)
+        deploy_dir = build_path(self._DEPLOY_DIR)
+        app_deploy_link = build_path(self._APP_DEPLOY_LINK)
+        conf_deploy_link_file = build_path(self._CONF_DEPLOY_LINK)
 
         #
 
-        tag_dir = os.path.join(app_dir, 'tags', app_tag.tag)
-        os.makedirs(tag_dir)
+        os.makedirs(deploy_dir)
+
+        deploying_link = os.path.join(deploy_home, 'deploys/deploying')
+        relative_symlink(
+            deploy_dir,
+            deploying_link,
+            target_is_directory=True,
+            make_dirs=True,
+        )
 
         #
 
-        deploying_file = os.path.join(app_dir, 'deploying')
-        current_file = os.path.join(app_dir, 'current')
+        os.makedirs(app_tag_dir)
+        relative_symlink(
+            app_tag_dir,
+            app_deploy_link,
+            target_is_directory=True,
+            make_dirs=True,
+        )
+
+        #
 
-        if os.path.exists(deploying_file):
-            os.unlink(deploying_file)
-        relative_symlink(tag_dir, deploying_file, target_is_directory=True)
+        os.makedirs(conf_tag_dir)
+        relative_symlink(
+            conf_tag_dir,
+            conf_deploy_link_file,
+            target_is_directory=True,
+            make_dirs=True,
+        )
 
         #
 
-        git_dir = os.path.join(tag_dir, 'git')
+        git_dir = os.path.join(app_tag_dir, 'git')
         await self._git.checkout(
             spec.git,
             git_dir,
@@ -101,7 +151,7 @@ class DeployAppManager(DeployPathOwner):
         #
 
         if spec.venv is not None:
-            venv_dir = os.path.join(tag_dir, 'venv')
+            venv_dir = os.path.join(app_tag_dir, 'venv')
             await self._venvs.setup_venv(
                 spec.venv,
                 git_dir,
@@ -111,15 +161,15 @@ class DeployAppManager(DeployPathOwner):
         #
 
         if spec.conf is not None:
-            conf_dir = os.path.join(tag_dir, 'conf')
-            conf_link_dir = os.path.join(current_file, 'conf')
+            conf_dir = os.path.join(app_tag_dir, 'conf')
             await self._conf.write_conf(
                 spec.conf,
-                conf_dir,
                 app_tag,
-                conf_link_dir,
+                conf_dir,
+                conf_tag_dir,
             )
 
         #
 
-        os.replace(deploying_file, current_file)
+        current_link = os.path.join(deploy_home, 'deploys/current')
+        os.replace(deploying_link, current_link)

ominfra/manage/deploy/commands.py

@@ -5,7 +5,7 @@ from omlish.lite.logs import log
 
 from ..commands.base import Command
 from ..commands.base import CommandExecutor
-from .apps import DeployAppManager
+from .deploy import DeployManager
 from .specs import DeploySpec
 
 
@@ -23,11 +23,11 @@ class DeployCommand(Command['DeployCommand.Output']):
 
 @dc.dataclass(frozen=True)
 class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
-    _apps: DeployAppManager
+    _deploy: DeployManager
 
     async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
         log.info('Deploying! %r', cmd.spec)
 
-        await self._apps.prepare_app(cmd.spec)
+        await self._deploy.run_deploy(cmd.spec)
 
         return DeployCommand.Output()

ominfra/manage/deploy/conf.py

@@ -23,7 +23,7 @@ from omlish.lite.check import check
 from omlish.os.paths import is_path_in_dir
 from omlish.os.paths import relative_symlink
 
-from .paths import SingleDirDeployPathOwner
+from .paths.paths import DEPLOY_PATH_PLACEHOLDER_SEPARATOR
 from .specs import AppDeployConfLink
 from .specs import DeployConfFile
 from .specs import DeployConfLink
@@ -33,16 +33,17 @@ from .types import DeployAppTag
 from .types import DeployHome
 
 
-class DeployConfManager(SingleDirDeployPathOwner):
+class DeployConfManager:
     def __init__(
             self,
             *,
             deploy_home: ta.Optional[DeployHome] = None,
     ) -> None:
-        super().__init__(
-            owned_dir='conf',
-            deploy_home=deploy_home,
-        )
+        super().__init__()
+
+        self._deploy_home = deploy_home
+
+    #
 
     async def _write_conf_file(
             self,
@@ -57,32 +58,40 @@ class DeployConfManager(SingleDirDeployPathOwner):
         with open(conf_file, 'w') as f:  # noqa
             f.write(cf.body)
 
-    async def _make_conf_link(
+    #
+
+    class _ComputedConfLink(ta.NamedTuple):
+        is_dir: bool
+        link_src: str
+        link_dst: str
+
+    def _compute_conf_link_dst(
             self,
             link: DeployConfLink,
-            conf_dir: str,
             app_tag: DeployAppTag,
+            conf_dir: str,
             link_dir: str,
-    ) -> None:
+    ) -> _ComputedConfLink:
         link_src = os.path.join(conf_dir, link.src)
         check.arg(is_path_in_dir(conf_dir, link_src))
 
-        is_link_dir = link.src.endswith('/')
-        if is_link_dir:
+        #
+
+        if (is_dir := link.src.endswith('/')):
+            # @conf/ - links a directory in root of app conf dir to conf/@conf/@dst/
             check.arg(link.src.count('/') == 1)
-            check.arg(os.path.isdir(link_src))
             link_dst_pfx = link.src
             link_dst_sfx = ''
 
         elif '/' in link.src:
-            check.arg(os.path.isfile(link_src))
+            # @conf/file - links a single file in a single subdir to conf/@conf/@dst--file
             d, f = os.path.split(link.src)
             # TODO: check filename :|
             link_dst_pfx = d + '/'
-            link_dst_sfx = '-' + f
+            link_dst_sfx = DEPLOY_PATH_PLACEHOLDER_SEPARATOR + f
 
-        else:
-            check.arg(os.path.isfile(link_src))
+        else:  # noqa
+            # @conf(.ext)* - links a single file in root of app conf dir to conf/@conf/@dst(.ext)*
             if '.' in link.src:
                 l, _, r = link.src.partition('.')
                 link_dst_pfx = l + '/'
@@ -91,41 +100,72 @@ class DeployConfManager(SingleDirDeployPathOwner):
                 link_dst_pfx = link.src + '/'
                 link_dst_sfx = ''
 
+        #
+
         if isinstance(link, AppDeployConfLink):
             link_dst_mid = str(app_tag.app)
-            sym_root = link_dir
         elif isinstance(link, TagDeployConfLink):
-            link_dst_mid = '-'.join([app_tag.app, app_tag.tag])
-            sym_root = conf_dir
+            link_dst_mid = DEPLOY_PATH_PLACEHOLDER_SEPARATOR.join([app_tag.app, app_tag.tag])
         else:
             raise TypeError(link)
 
-        link_dst = ''.join([
+        #
+
+        link_dst_name = ''.join([
             link_dst_pfx,
             link_dst_mid,
             link_dst_sfx,
         ])
+        link_dst = os.path.join(link_dir, link_dst_name)
 
-        root_conf_dir = self._make_dir()
-        sym_src = os.path.join(sym_root, link.src)
-        sym_dst = os.path.join(root_conf_dir, link_dst)
-        check.arg(is_path_in_dir(root_conf_dir, sym_dst))
-
-        os.makedirs(os.path.dirname(sym_dst), exist_ok=True)
-        relative_symlink(sym_src, sym_dst, target_is_directory=is_link_dir)
+        return DeployConfManager._ComputedConfLink(
+            is_dir=is_dir,
+            link_src=link_src,
+            link_dst=link_dst,
+        )
 
-    async def write_conf(
+    async def _make_conf_link(
             self,
-            spec: DeployConfSpec,
-            conf_dir: str,
+            link: DeployConfLink,
             app_tag: DeployAppTag,
+            conf_dir: str,
             link_dir: str,
     ) -> None:
-        conf_dir = os.path.abspath(conf_dir)
-        os.makedirs(conf_dir)
+        comp = self._compute_conf_link_dst(
+            link,
+            app_tag,
+            conf_dir,
+            link_dir,
+        )
 
         #
 
+        check.arg(is_path_in_dir(conf_dir, comp.link_src))
+        check.arg(is_path_in_dir(link_dir, comp.link_dst))
+
+        if comp.is_dir:
+            check.arg(os.path.isdir(comp.link_src))
+        else:
+            check.arg(os.path.isfile(comp.link_src))
+
+        #
+
+        relative_symlink(  # noqa
+            comp.link_src,
+            comp.link_dst,
+            target_is_directory=comp.is_dir,
+            make_dirs=True,
+        )
+
+    #
+
+    async def write_conf(
+            self,
+            spec: DeployConfSpec,
+            app_tag: DeployAppTag,
+            conf_dir: str,
+            link_dir: str,
+    ) -> None:
         for cf in spec.files or []:
             await self._write_conf_file(
                 cf,
@@ -137,7 +177,7 @@ class DeployConfManager(SingleDirDeployPathOwner):
         for link in spec.links or []:
             await self._make_conf_link(
                 link,
-                conf_dir,
                 app_tag,
+                conf_dir,
                 link_dir,
             )

ominfra/manage/deploy/deploy.py

@@ -0,0 +1,27 @@
+# ruff: noqa: UP006 UP007
+from .apps import DeployAppManager
+from .paths.manager import DeployPathsManager
+from .specs import DeploySpec
+
+
+class DeployManager:
+    def __init__(
+            self,
+            *,
+            apps: DeployAppManager,
+            paths: DeployPathsManager,
+    ):
+        super().__init__()
+
+        self._apps = apps
+        self._paths = paths
+
+    async def run_deploy(
+            self,
+            spec: DeploySpec,
+    ) -> None:
+        self._paths.validate_deploy_paths()
+
+        #
+
+        await self._apps.prepare_app(spec)

ominfra/manage/deploy/git.py

@@ -17,7 +17,7 @@ from omlish.lite.cached import async_cached_nullary
 from omlish.lite.check import check
 from omlish.os.atomics import AtomicPathSwapping
 
-from .paths import SingleDirDeployPathOwner
+from .paths.owners import SingleDirDeployPathOwner
 from .specs import DeployGitRepo
 from .specs import DeployGitSpec
 from .types import DeployHome

ominfra/manage/deploy/inject.py

@@ -13,11 +13,12 @@ from .commands import DeployCommand
 from .commands import DeployCommandExecutor
 from .conf import DeployConfManager
 from .config import DeployConfig
+from .deploy import DeployManager
 from .git import DeployGitManager
 from .interp import InterpCommand
 from .interp import InterpCommandExecutor
-from .paths import DeployPathOwner
-from .paths import DeployPathOwners
+from .paths.inject import bind_deploy_paths
+from .paths.owners import DeployPathOwner
 from .tmp import DeployTmpManager
 from .types import DeployHome
 from .venvs import DeployVenvManager
@@ -29,6 +30,8 @@ def bind_deploy(
 ) -> InjectorBindings:
     lst: ta.List[InjectorBindingOrBindings] = [
         inj.bind(deploy_config),
+
+        bind_deploy_paths(),
     ]
 
     #
@@ -40,11 +43,6 @@ def bind_deploy(
             *([inj.bind(DeployPathOwner, to_key=cls, array=True)] if issubclass(cls, DeployPathOwner) else []),
         )
 
-    lst.extend([
-        inj.bind_array(DeployPathOwner),
-        inj.bind_array_type(DeployPathOwner, DeployPathOwners),
-    ])
-
     #
 
     lst.extend([
@@ -54,6 +52,8 @@ def bind_deploy(
 
         bind_manager(DeployGitManager),
 
+        bind_manager(DeployManager),
+
         bind_manager(DeployTmpManager),
         inj.bind(AtomicPathSwapping, to_key=DeployTmpManager),
 

ominfra/manage/deploy/paths/inject.py

@@ -0,0 +1,21 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+from .manager import DeployPathsManager
+from .owners import DeployPathOwner
+from .owners import DeployPathOwners
+
+
+def bind_deploy_paths() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(DeployPathOwner),
+        inj.bind_array_type(DeployPathOwner, DeployPathOwners),
+
+        inj.bind(DeployPathsManager, singleton=True),
+    ]
+
+    return inj.as_bindings(*lst)

ominfra/manage/deploy/paths/manager.py

@@ -0,0 +1,36 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from ..types import DeployHome
+from .owners import DeployPathOwner
+from .owners import DeployPathOwners
+from .paths import DeployPath
+from .paths import DeployPathError
+
+
+class DeployPathsManager:
+    def __init__(
+            self,
+            *,
+            deploy_home: ta.Optional[DeployHome],
+            deploy_path_owners: DeployPathOwners,
+    ) -> None:
+        super().__init__()
+
+        self._deploy_home = deploy_home
+        self._deploy_path_owners = deploy_path_owners
+
+    @cached_nullary
+    def owners_by_path(self) -> ta.Mapping[DeployPath, DeployPathOwner]:
+        dct: ta.Dict[DeployPath, DeployPathOwner] = {}
+        for o in self._deploy_path_owners:
+            for p in o.get_owned_deploy_paths():
+                if p in dct:
+                    raise DeployPathError(f'Duplicate deploy path owner: {p}')
+                dct[p] = o
+        return dct
+
+    def validate_deploy_paths(self) -> None:
+        self.owners_by_path()

ominfra/manage/deploy/paths/owners.py

@@ -0,0 +1,50 @@
+# ruff: noqa: UP006 UP007
+import abc
+import os.path
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check
+
+from ..types import DeployHome
+from .paths import DeployPath
+
+
+class DeployPathOwner(abc.ABC):
+    @abc.abstractmethod
+    def get_owned_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
+        raise NotImplementedError
+
+
+DeployPathOwners = ta.NewType('DeployPathOwners', ta.Sequence[DeployPathOwner])
+
+
+class SingleDirDeployPathOwner(DeployPathOwner, abc.ABC):
+    def __init__(
+            self,
+            *args: ta.Any,
+            owned_dir: str,
+            deploy_home: ta.Optional[DeployHome],
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        check.not_in('/', owned_dir)
+        self._owned_dir: str = check.non_empty_str(owned_dir)
+
+        self._deploy_home = deploy_home
+
+        self._owned_deploy_paths = frozenset([DeployPath.parse(self._owned_dir + '/')])
+
+    @cached_nullary
+    def _dir(self) -> str:
+        return os.path.join(check.non_empty_str(self._deploy_home), self._owned_dir)
+
+    @cached_nullary
+    def _make_dir(self) -> str:
+        if not os.path.isdir(d := self._dir()):
+            os.makedirs(d, exist_ok=True)
+        return d
+
+    def get_owned_deploy_paths(self) -> ta.AbstractSet[DeployPath]:
+        return self._owned_deploy_paths