ominfra 0.0.0.dev176__py3-none-any.whl → 0.0.0.dev178__py3-none-any.whl

ominfra/manage/deploy/apps.py

@@ -20,16 +20,12 @@ class DeployAppManager(DeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: ta.Optional[DeployHome] = None,
-
             conf: DeployConfManager,
             git: DeployGitManager,
             venvs: DeployVenvManager,
     ) -> None:
         super().__init__()
 
-        self._deploy_home = deploy_home
-
         self._conf = conf
         self._git = git
         self._venvs = venvs
@@ -70,12 +66,13 @@ class DeployAppManager(DeployPathOwner):
     async def prepare_app(
             self,
             spec: DeployAppSpec,
+            home: DeployHome,
             tags: DeployTagMap,
     ) -> None:
-        deploy_home = check.non_empty_str(self._deploy_home)
+        check.non_empty_str(home)
 
         def build_path(pth: DeployPath) -> str:
-            return os.path.join(deploy_home, pth.render(tags))
+            return os.path.join(home, pth.render(tags))
 
         app_dir = build_path(self._APP_DIR)
         deploy_dir = build_path(self._DEPLOY_DIR)
@@ -85,7 +82,7 @@ class DeployAppManager(DeployPathOwner):
 
         os.makedirs(deploy_dir, exist_ok=True)
 
-        deploying_link = os.path.join(deploy_home, 'deploys/deploying')
+        deploying_link = os.path.join(home, 'deploys/deploying')
         if os.path.exists(deploying_link):
             os.unlink(deploying_link)
         relative_symlink(
@@ -132,7 +129,7 @@ class DeployAppManager(DeployPathOwner):
         #             else:
         #                 os.makedirs(os.path.join(dst, os.path.relpath(dp2, src)))
 
-        current_link = os.path.join(deploy_home, 'deploys/current')
+        current_link = os.path.join(home, 'deploys/current')
 
         # if os.path.exists(current_link):
         #     mirror_symlinks(
@@ -149,6 +146,7 @@ class DeployAppManager(DeployPathOwner):
         app_git_dir = os.path.join(app_dir, 'git')
         await self._git.checkout(
             spec.git,
+            home,
             app_git_dir,
         )
 
@@ -158,6 +156,7 @@ class DeployAppManager(DeployPathOwner):
             app_venv_dir = os.path.join(app_dir, 'venv')
             await self._venvs.setup_venv(
                 spec.venv,
+                home,
                 app_git_dir,
                 app_venv_dir,
             )

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 .deploy import DeployManager
+from .driver import DeployDriverFactory
 from .specs import DeploySpec
 
 
@@ -23,11 +23,12 @@ class DeployCommand(Command['DeployCommand.Output']):
 
 @dc.dataclass(frozen=True)
 class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
-    _deploy: DeployManager
+    _driver_factory: DeployDriverFactory
 
     async def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
         log.info('Deploying! %r', cmd.spec)
 
-        await self._deploy.run_deploy(cmd.spec)
+        with self._driver_factory(cmd.spec) as driver:
+            await driver.drive_deploy()
 
         return DeployCommand.Output()

ominfra/manage/deploy/conf.py

@@ -31,21 +31,9 @@ from .tags import DEPLOY_TAG_SEPARATOR
 from .tags import DeployApp
 from .tags import DeployConf
 from .tags import DeployTagMap
-from .types import DeployHome
 
 
 class DeployConfManager:
-    def __init__(
-            self,
-            *,
-            deploy_home: ta.Optional[DeployHome] = None,
-    ) -> None:
-        super().__init__()
-
-        self._deploy_home = deploy_home
-
-    #
-
     async def _write_app_conf_file(
             self,
             acf: DeployAppConfFile,

ominfra/manage/deploy/config.py

@@ -1,6 +1,5 @@
 # ruff: noqa: UP006 UP007
 import dataclasses as dc
-import typing as ta
 
 
 ##
@@ -8,4 +7,4 @@ import typing as ta
 
 @dc.dataclass(frozen=True)
 class DeployConfig:
-    deploy_home: ta.Optional[str] = None
+    pass

ominfra/manage/deploy/deploy.py

@@ -4,11 +4,6 @@ import typing as ta
 
 from omlish.lite.typing import Func0
 
-from .apps import DeployAppManager
-from .paths.manager import DeployPathsManager
-from .specs import DeploySpec
-from .tags import DeployAppRev
-from .tags import DeployTagMap
 from .tags import DeployTime
 
 
@@ -22,16 +17,11 @@ class DeployManager:
     def __init__(
             self,
             *,
-            apps: DeployAppManager,
-            paths: DeployPathsManager,
 
             utc_clock: ta.Optional[DeployManagerUtcClock] = None,
     ):
         super().__init__()
 
-        self._apps = apps
-        self._paths = paths
-
         self._utc_clock = utc_clock
 
     def _utc_now(self) -> datetime.datetime:
@@ -40,32 +30,5 @@ class DeployManager:
         else:
             return datetime.datetime.now(tz=datetime.timezone.utc)  # noqa
 
-    def _make_deploy_time(self) -> DeployTime:
+    def make_deploy_time(self) -> DeployTime:
         return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
-
-    async def run_deploy(
-            self,
-            spec: DeploySpec,
-    ) -> None:
-        self._paths.validate_deploy_paths()
-
-        #
-
-        deploy_tags = DeployTagMap(
-            self._make_deploy_time(),
-            spec.key(),
-        )
-
-        #
-
-        for app in spec.apps:
-            app_tags = deploy_tags.add(
-                app.app,
-                app.key(),
-                DeployAppRev(app.git.rev),
-            )
-
-            await self._apps.prepare_app(
-                app,
-                app_tags,
-            )

ominfra/manage/deploy/driver.py

@@ -0,0 +1,71 @@
+# ruff: noqa: UP006 UP007
+import os.path
+import typing as ta
+
+from omlish.lite.check import check
+from omlish.lite.typing import Func1
+
+from .apps import DeployAppManager
+from .deploy import DeployManager
+from .paths.manager import DeployPathsManager
+from .specs import DeploySpec
+from .tags import DeployAppRev
+from .tags import DeployTagMap
+from .types import DeployHome
+
+
+class DeployDriverFactory(Func1[DeploySpec, ta.ContextManager['DeployDriver']]):
+    pass
+
+
+class DeployDriver:
+    def __init__(
+            self,
+            *,
+            spec: DeploySpec,
+
+            deploys: DeployManager,
+            paths: DeployPathsManager,
+            apps: DeployAppManager,
+    ) -> None:
+        super().__init__()
+
+        self._spec = spec
+
+        self._deploys = deploys
+        self._paths = paths
+        self._apps = apps
+
+    async def drive_deploy(self) -> None:
+        self._paths.validate_deploy_paths()
+
+        #
+
+        hs = check.non_empty_str(self._spec.home)
+        hs = os.path.expanduser(hs)
+        hs = os.path.realpath(hs)
+        hs = os.path.abspath(hs)
+
+        home = DeployHome(hs)
+
+        #
+
+        deploy_tags = DeployTagMap(
+            self._deploys.make_deploy_time(),
+            self._spec.key(),
+        )
+
+        #
+
+        for app in self._spec.apps:
+            app_tags = deploy_tags.add(
+                app.app,
+                app.key(),
+                DeployAppRev(app.git.rev),
+            )
+
+            await self._apps.prepare_app(
+                app,
+                home,
+                app_tags,
+            )

ominfra/manage/deploy/git.py

@@ -15,11 +15,11 @@ import typing as ta
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.cached import async_cached_nullary
 from omlish.lite.check import check
-from omlish.os.atomics import AtomicPathSwapping
 
 from .paths.owners import SingleDirDeployPathOwner
 from .specs import DeployGitRepo
 from .specs import DeployGitSpec
+from .tmp import DeployHomeAtomics
 from .types import DeployHome
 from .types import DeployRev
 
@@ -31,12 +31,10 @@ class DeployGitManager(SingleDirDeployPathOwner):
     def __init__(
             self,
             *,
-            deploy_home: ta.Optional[DeployHome] = None,
-            atomics: AtomicPathSwapping,
+            atomics: DeployHomeAtomics,
     ) -> None:
         super().__init__(
             owned_dir='git',
-            deploy_home=deploy_home,
         )
 
         self._atomics = atomics
@@ -48,13 +46,15 @@ class DeployGitManager(SingleDirDeployPathOwner):
                 self,
                 git: 'DeployGitManager',
                 repo: DeployGitRepo,
+                home: DeployHome,
         ) -> None:
             super().__init__()
 
             self._git = git
             self._repo = repo
+            self._home = home
             self._dir = os.path.join(
-                self._git._make_dir(),  # noqa
+                self._git._make_dir(home),  # noqa
                 check.non_empty_str(repo.host),
                 check.non_empty_str(repo.path),
             )
@@ -97,7 +97,7 @@ class DeployGitManager(SingleDirDeployPathOwner):
 
         async def checkout(self, spec: DeployGitSpec, dst_dir: str) -> None:
             check.state(not os.path.exists(dst_dir))
-            with self._git._atomics.begin_atomic_path_swap(  # noqa
+            with self._git._atomics(self._home).begin_atomic_path_swap(  # noqa
                     'dir',
                     dst_dir,
                     auto_commit=True,
@@ -112,16 +112,31 @@ class DeployGitManager(SingleDirDeployPathOwner):
                 await dst_call('git', 'fetch', '--depth=1', 'local', spec.rev)
                 await dst_call('git', 'checkout', spec.rev, *(spec.subtrees or []))
 
-    def get_repo_dir(self, repo: DeployGitRepo) -> RepoDir:
+    def get_repo_dir(
+            self,
+            repo: DeployGitRepo,
+            home: DeployHome,
+    ) -> RepoDir:
         try:
             return self._repo_dirs[repo]
         except KeyError:
-            repo_dir = self._repo_dirs[repo] = DeployGitManager.RepoDir(self, repo)
+            repo_dir = self._repo_dirs[repo] = DeployGitManager.RepoDir(
+                self,
+                repo,
+                home,
+            )
             return repo_dir
 
     async def checkout(
             self,
             spec: DeployGitSpec,
+            home: DeployHome,
             dst_dir: str,
     ) -> None:
-        await self.get_repo_dir(spec.repo).checkout(spec, dst_dir)
+        await self.get_repo_dir(
+            spec.repo,
+            home,
+        ).checkout(
+            spec,
+            dst_dir,
+        )

ominfra/manage/deploy/inject.py

@@ -1,11 +1,12 @@
 # ruff: noqa: UP006 UP007
-import os.path
+import contextlib
 import typing as ta
 
+from omlish.lite.inject import ContextvarInjectorScope
+from omlish.lite.inject import Injector
 from omlish.lite.inject import InjectorBindingOrBindings
 from omlish.lite.inject import InjectorBindings
 from omlish.lite.inject import inj
-from omlish.os.atomics import AtomicPathSwapping
 
 from ..commands.inject import bind_command
 from .apps import DeployAppManager
@@ -14,16 +15,23 @@ from .commands import DeployCommandExecutor
 from .conf import DeployConfManager
 from .config import DeployConfig
 from .deploy import DeployManager
+from .driver import DeployDriver
+from .driver import DeployDriverFactory
 from .git import DeployGitManager
 from .interp import InterpCommand
 from .interp import InterpCommandExecutor
 from .paths.inject import bind_deploy_paths
 from .paths.owners import DeployPathOwner
+from .specs import DeploySpec
+from .tmp import DeployHomeAtomics
 from .tmp import DeployTmpManager
-from .types import DeployHome
 from .venvs import DeployVenvManager
 
 
+class DeployInjectorScope(ContextvarInjectorScope):
+    pass
+
+
 def bind_deploy(
         *,
         deploy_config: DeployConfig,
@@ -55,13 +63,37 @@ def bind_deploy(
         bind_manager(DeployManager),
 
         bind_manager(DeployTmpManager),
-        inj.bind(AtomicPathSwapping, to_key=DeployTmpManager),
 
         bind_manager(DeployVenvManager),
     ])
 
     #
 
+    def provide_deploy_home_atomics(tmp: DeployTmpManager) -> DeployHomeAtomics:
+        return DeployHomeAtomics(tmp.get_swapping)
+    lst.append(inj.bind(provide_deploy_home_atomics, singleton=True))
+
+    #
+
+    def provide_deploy_driver_factory(injector: Injector, sc: DeployInjectorScope) -> DeployDriverFactory:
+        @contextlib.contextmanager
+        def factory(spec: DeploySpec) -> ta.Iterator[DeployDriver]:
+            with sc.enter({
+                inj.as_key(DeploySpec): spec,
+            }):
+                yield injector[DeployDriver]
+        return DeployDriverFactory(factory)
+    lst.append(inj.bind(provide_deploy_driver_factory, singleton=True))
+
+    lst.extend([
+        inj.bind_scope(DeployInjectorScope),
+        inj.bind_scope_seed(DeploySpec, DeployInjectorScope),
+
+        inj.bind(DeployDriver, in_=DeployInjectorScope),
+    ])
+
+    #
+
     lst.extend([
         bind_command(DeployCommand, DeployCommandExecutor),
         bind_command(InterpCommand, InterpCommandExecutor),
@@ -69,8 +101,4 @@ def bind_deploy(
 
     #
 
-    if (dh := deploy_config.deploy_home) is not None:
-        dh = os.path.abspath(os.path.expanduser(dh))
-        lst.append(inj.bind(dh, key=DeployHome))
-
     return inj.as_bindings(*lst)

ominfra/manage/deploy/paths/manager.py

@@ -3,7 +3,6 @@ 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
@@ -14,12 +13,10 @@ 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

ominfra/manage/deploy/paths/owners.py

@@ -3,7 +3,6 @@ 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
@@ -24,7 +23,6 @@ class SingleDirDeployPathOwner(DeployPathOwner, abc.ABC):
             self,
             *args: ta.Any,
             owned_dir: str,
-            deploy_home: ta.Optional[DeployHome],
             **kwargs: ta.Any,
     ) -> None:
         super().__init__(*args, **kwargs)
@@ -32,17 +30,13 @@ class SingleDirDeployPathOwner(DeployPathOwner, abc.ABC):
         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)
+    def _dir(self, home: DeployHome) -> str:
+        return os.path.join(check.non_empty_str(home), self._owned_dir)
 
-    @cached_nullary
-    def _make_dir(self) -> str:
-        if not os.path.isdir(d := self._dir()):
+    def _make_dir(self, home: DeployHome) -> str:
+        if not os.path.isdir(d := self._dir(home)):
             os.makedirs(d, exist_ok=True)
         return d
 

ominfra/manage/deploy/specs.py

@@ -11,6 +11,7 @@ from .tags import DeployApp
 from .tags import DeployAppKey
 from .tags import DeployKey
 from .tags import KeyDeployTag  # noqa
+from .types import DeployHome
 from .types import DeployRev
 
 
@@ -153,9 +154,13 @@ class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
 
 @dc.dataclass(frozen=True)
 class DeploySpec(DeploySpecKeyed[DeployKey]):
+    home: DeployHome
+
     apps: ta.Sequence[DeployAppSpec]
 
     def __post_init__(self) -> None:
+        check.non_empty_str(self.home)
+
         seen: ta.Set[DeployApp] = set()
         for a in self.apps:
             if a.app in seen:

ominfra/manage/deploy/tmp.py

@@ -1,10 +1,6 @@
 # ruff: noqa: UP006 UP007
-import typing as ta
-
-from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
-from omlish.os.atomics import AtomicPathSwap
-from omlish.os.atomics import AtomicPathSwapKind
+from omlish.lite.typing import Func1
 from omlish.os.atomics import AtomicPathSwapping
 from omlish.os.atomics import TempDirAtomicPathSwapping
 
@@ -12,35 +8,20 @@ from .paths.owners import SingleDirDeployPathOwner
 from .types import DeployHome
 
 
+class DeployHomeAtomics(Func1[DeployHome, AtomicPathSwapping]):
+    pass
+
+
 class DeployTmpManager(
     SingleDirDeployPathOwner,
-    AtomicPathSwapping,
 ):
-    def __init__(
-            self,
-            *,
-            deploy_home: ta.Optional[DeployHome] = None,
-    ) -> None:
+    def __init__(self) -> None:
         super().__init__(
             owned_dir='tmp',
-            deploy_home=deploy_home,
         )
 
-    @cached_nullary
-    def _swapping(self) -> AtomicPathSwapping:
+    def get_swapping(self, home: DeployHome) -> AtomicPathSwapping:
         return TempDirAtomicPathSwapping(
-            temp_dir=self._make_dir(),
-            root_dir=check.non_empty_str(self._deploy_home),
-        )
-
-    def begin_atomic_path_swap(
-            self,
-            kind: AtomicPathSwapKind,
-            dst_path: str,
-            **kwargs: ta.Any,
-    ) -> AtomicPathSwap:
-        return self._swapping().begin_atomic_path_swap(
-            kind,
-            dst_path,
-            **kwargs,
+            temp_dir=self._make_dir(home),
+            root_dir=check.non_empty_str(home),
         )

ominfra/manage/deploy/venvs.py

@@ -10,24 +10,16 @@ from omdev.interp.resolvers import DEFAULT_INTERP_RESOLVER
 from omdev.interp.types import InterpSpecifier
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.check import check
-from omlish.os.atomics import AtomicPathSwapping
 
 from .specs import DeployVenvSpec
+from .types import DeployHome
 
 
 class DeployVenvManager:
-    def __init__(
-            self,
-            *,
-            atomics: AtomicPathSwapping,
-    ) -> None:
-        super().__init__()
-
-        self._atomics = atomics
-
     async def setup_venv(
             self,
             spec: DeployVenvSpec,
+            home: DeployHome,
             git_dir: str,
             venv_dir: str,
     ) -> None:

ominfra/manage/main.py

@@ -35,8 +35,6 @@ from .targets.targets import ManageTarget
 
 @dc.dataclass(frozen=True)
 class ManageConfig:
-    deploy_home: ta.Optional[str] = None
-
     targets: ta.Optional[ta.Mapping[str, ManageTarget]] = None
 
 
@@ -68,8 +66,6 @@ class MainCli(ArgparseCli):
 
         argparse_arg('--debug', action='store_true'),
 
-        argparse_arg('--deploy-home'),
-
         argparse_arg('target'),
         argparse_arg('-f', '--command-file', action='append'),
         argparse_arg('command', nargs='*'),
@@ -82,9 +78,7 @@ class MainCli(ArgparseCli):
                 debug=bool(self.args.debug),
             ),
 
-            deploy_config=DeployConfig(
-                deploy_home=self.args.deploy_home or self.config().deploy_home,
-            ),
+            deploy_config=DeployConfig(),
 
             remote_config=RemoteConfig(
                 payload_file=self.args._payload_file,  # noqa