ominfra 0.0.0.dev177__py3-none-any.whl → 0.0.0.dev179__py3-none-any.whl

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/deploy.py

@@ -1,18 +1,10 @@
 # ruff: noqa: UP006 UP007
 import datetime
-import os.path
 import typing as ta
 
-from omlish.lite.check import check
 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
-from .types import DeployHome
 
 
 DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
@@ -25,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:
@@ -43,42 +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()
-
-        #
-
-        hs = check.non_empty_str(spec.home)
-        hs = os.path.expanduser(hs)
-        hs = os.path.realpath(hs)
-        hs = os.path.abspath(hs)
-
-        home = DeployHome(hs)
-
-        #
-
-        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,
-                home,
-                app_tags,
-            )

ominfra/manage/deploy/driver.py

@@ -0,0 +1,62 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.typing import Func1
+
+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
+from .types import DeployHome
+
+
+class DeployDriverFactory(Func1[DeploySpec, ta.ContextManager['DeployDriver']]):
+    pass
+
+
+class DeployDriver:
+    def __init__(
+            self,
+            *,
+            spec: DeploySpec,
+            home: DeployHome,
+            time: DeployTime,
+
+            paths: DeployPathsManager,
+            apps: DeployAppManager,
+    ) -> None:
+        super().__init__()
+
+        self._spec = spec
+        self._home = home
+        self._time = time
+
+        self._paths = paths
+        self._apps = apps
+
+    async def drive_deploy(self) -> None:
+        self._paths.validate_deploy_paths()
+
+        #
+
+        deploy_tags = DeployTagMap(
+            self._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,
+                self._home,
+                app_tags,
+            )

ominfra/manage/deploy/inject.py

@@ -1,6 +1,11 @@
 # ruff: noqa: UP006 UP007
+import contextlib
+import os.path
 import typing as ta
 
+from omlish.lite.check import check
+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
@@ -12,16 +17,72 @@ 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 .tags import DeployTime
 from .tmp import DeployHomeAtomics
 from .tmp import DeployTmpManager
+from .types import DeployHome
 from .venvs import DeployVenvManager
 
 
+##
+
+
+class DeployInjectorScope(ContextvarInjectorScope):
+    pass
+
+
+def bind_deploy_scope() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_scope(DeployInjectorScope),
+        inj.bind_scope_seed(DeploySpec, DeployInjectorScope),
+
+        inj.bind(DeployDriver, in_=DeployInjectorScope),
+    ]
+
+    #
+
+    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))
+
+    #
+
+    def provide_deploy_home(deploy: DeploySpec) -> DeployHome:
+        hs = check.non_empty_str(deploy.home)
+        hs = os.path.expanduser(hs)
+        hs = os.path.realpath(hs)
+        hs = os.path.abspath(hs)
+        return DeployHome(hs)
+    lst.append(inj.bind(provide_deploy_home, in_=DeployInjectorScope))
+
+    #
+
+    def provide_deploy_time(deploys: DeployManager) -> DeployTime:
+        return deploys.make_deploy_time()
+    lst.append(inj.bind(provide_deploy_time, in_=DeployInjectorScope))
+
+    #
+
+    return inj.as_bindings(*lst)
+
+
+##
+
+
 def bind_deploy(
         *,
         deploy_config: DeployConfig,
@@ -30,6 +91,8 @@ def bind_deploy(
         inj.bind(deploy_config),
 
         bind_deploy_paths(),
+
+        bind_deploy_scope(),
     ]
 
     #

ominfra/manage/deploy/interp.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 import dataclasses as dc
 
-from omdev.interp.resolvers import DEFAULT_INTERP_RESOLVER
+from omdev.interp.default import get_default_interp_resolver
 from omdev.interp.types import InterpOpts
 from omdev.interp.types import InterpSpecifier
 from omlish.lite.check import check
@@ -28,7 +28,7 @@ class InterpCommand(Command['InterpCommand.Output']):
 class InterpCommandExecutor(CommandExecutor[InterpCommand, InterpCommand.Output]):
     async def execute(self, cmd: InterpCommand) -> InterpCommand.Output:
         i = InterpSpecifier.parse(check.not_none(cmd.spec))
-        o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=cmd.install))
+        o = check.not_none(await get_default_interp_resolver().resolve(i, install=cmd.install))
         return InterpCommand.Output(
             exe=o.exe,
             version=str(o.version.version),

ominfra/manage/deploy/venvs.py

@@ -6,7 +6,7 @@ TODO:
 """
 import os.path
 
-from omdev.interp.resolvers import DEFAULT_INTERP_RESOLVER
+from omdev.interp.default import get_default_interp_resolver
 from omdev.interp.types import InterpSpecifier
 from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.check import check
@@ -25,7 +25,7 @@ class DeployVenvManager:
     ) -> None:
         if spec.interp is not None:
             i = InterpSpecifier.parse(check.not_none(spec.interp))
-            o = check.not_none(await DEFAULT_INTERP_RESOLVER.resolve(i))
+            o = check.not_none(await get_default_interp_resolver().resolve(i))
             sys_exe = o.exe
         else:
             sys_exe = 'python3'