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

ominfra/scripts/manage.py

@@ -17,6 +17,7 @@ import base64
 import collections
 import collections.abc
 import contextlib
+import contextvars
 import ctypes as ct
 import dataclasses as dc
 import datetime
@@ -1384,7 +1385,7 @@ class MainConfig:
 
 @dc.dataclass(frozen=True)
 class DeployConfig:
-    deploy_home: ta.Optional[str] = None
+    pass
 
 
 ########################################
@@ -4905,6 +4906,10 @@ class InjectorBinding:
     key: InjectorKey
     provider: InjectorProvider
 
+    def __post_init__(self) -> None:
+        check.isinstance(self.key, InjectorKey)
+        check.isinstance(self.provider, InjectorProvider)
+
 
 class InjectorBindings(abc.ABC):
     @abc.abstractmethod
@@ -5168,6 +5173,164 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
     return pm
 
 
+###
+# scopes
+
+
+class InjectorScope(abc.ABC):  # noqa
+    def __init__(
+            self,
+            *,
+            _i: Injector,
+    ) -> None:
+        check.not_in(abc.ABC, type(self).__bases__)
+
+        super().__init__()
+
+        self._i = _i
+
+        all_seeds: ta.Iterable[_InjectorScopeSeed] = self._i.provide(InjectorKey(_InjectorScopeSeed, array=True))
+        self._sks = {s.k for s in all_seeds if s.sc is type(self)}
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class State:
+        seeds: ta.Dict[InjectorKey, ta.Any]
+        prvs: ta.Dict[InjectorKey, ta.Any] = dc.field(default_factory=dict)
+
+    def new_state(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> State:
+        vs = dict(vs)
+        check.equal(set(vs.keys()), self._sks)
+        return InjectorScope.State(vs)
+
+    #
+
+    @abc.abstractmethod
+    def state(self) -> State:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def enter(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> ta.ContextManager[None]:
+        raise NotImplementedError
+
+
+class ExclusiveInjectorScope(InjectorScope, abc.ABC):
+    _st: ta.Optional[InjectorScope.State] = None
+
+    def state(self) -> InjectorScope.State:
+        return check.not_none(self._st)
+
+    @contextlib.contextmanager
+    def enter(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> ta.Iterator[None]:
+        check.none(self._st)
+        self._st = self.new_state(vs)
+        try:
+            yield
+        finally:
+            self._st = None
+
+
+class ContextvarInjectorScope(InjectorScope, abc.ABC):
+    _cv: contextvars.ContextVar
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        check.not_in(abc.ABC, cls.__bases__)
+        check.state(not hasattr(cls, '_cv'))
+        cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
+
+    def state(self) -> InjectorScope.State:
+        return self._cv.get()
+
+    @contextlib.contextmanager
+    def enter(self, vs: ta.Mapping[InjectorKey, ta.Any]) -> ta.Iterator[None]:
+        try:
+            self._cv.get()
+        except LookupError:
+            pass
+        else:
+            raise RuntimeError(f'Scope already entered: {self}')
+        st = self.new_state(vs)
+        tok = self._cv.set(st)
+        try:
+            yield
+        finally:
+            self._cv.reset(tok)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class ScopedInjectorProvider(InjectorProvider):
+    p: InjectorProvider
+    k: InjectorKey
+    sc: ta.Type[InjectorScope]
+
+    def __post_init__(self) -> None:
+        check.isinstance(self.p, InjectorProvider)
+        check.isinstance(self.k, InjectorKey)
+        check.issubclass(self.sc, InjectorScope)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            st = i[self.sc].state()
+            try:
+                return st.prvs[self.k]
+            except KeyError:
+                pass
+            v = ufn(i)
+            st.prvs[self.k] = v
+            return v
+
+        ufn = self.p.provider_fn()
+        return pfn
+
+
+@dc.dataclass(frozen=True)
+class _ScopeSeedInjectorProvider(InjectorProvider):
+    k: InjectorKey
+    sc: ta.Type[InjectorScope]
+
+    def __post_init__(self) -> None:
+        check.isinstance(self.k, InjectorKey)
+        check.issubclass(self.sc, InjectorScope)
+
+    def provider_fn(self) -> InjectorProviderFn:
+        def pfn(i: Injector) -> ta.Any:
+            st = i[self.sc].state()
+            return st.seeds[self.k]
+        return pfn
+
+
+def bind_injector_scope(sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+    return as_injector_bindings(
+        InjectorBinder.bind(sc, singleton=True),
+    )
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class _InjectorScopeSeed:
+    sc: ta.Type['InjectorScope']
+    k: InjectorKey
+
+    def __post_init__(self) -> None:
+        check.issubclass(self.sc, InjectorScope)
+        check.isinstance(self.k, InjectorKey)
+
+
+def bind_injector_scope_seed(k: ta.Any, sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+    kk = as_injector_key(k)
+    return as_injector_bindings(
+        InjectorBinding(kk, _ScopeSeedInjectorProvider(kk, sc)),
+        InjectorBinder.bind(_InjectorScopeSeed(sc, kk), array=True),
+    )
+
+
 ###
 # inspection
 
@@ -5312,13 +5475,21 @@ _INJECTOR_EAGER_ARRAY_KEY: InjectorKey[_InjectorEager] = InjectorKey(_InjectorEa
 
 
 class _Injector(Injector):
+    _DEFAULT_BINDINGS: ta.ClassVar[ta.List[InjectorBinding]] = []
+
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
 
         self._bs = check.isinstance(bs, InjectorBindings)
         self._p: ta.Optional[Injector] = check.isinstance(p, (Injector, type(None)))
 
-        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
+        self._pfm = {
+            k: v.provider_fn()
+            for k, v in build_injector_provider_map(as_injector_bindings(
+                *self._DEFAULT_BINDINGS,
+                bs,
+            )).items()
+        }
 
         if _INJECTOR_INJECTOR_KEY in self._pfm:
             raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
@@ -5485,6 +5656,7 @@ class InjectorBinder:
             to_const: ta.Any = None,
             to_key: ta.Any = None,
 
+            in_: ta.Optional[ta.Type[InjectorScope]] = None,
             singleton: bool = False,
 
             eager: bool = False,
@@ -5494,12 +5666,12 @@ class InjectorBinder:
         if isinstance(obj, cls._BANNED_BIND_TYPES):
             raise TypeError(obj)
 
-        ##
+        #
 
         if key is not None:
             key = as_injector_key(key)
 
-        ##
+        #
 
         has_to = (
             to_fn is not None or
@@ -5529,7 +5701,7 @@ class InjectorBinder:
                 key = InjectorKey(type(obj))
         del has_to
 
-        ##
+        #
 
         if tag is not None:
             if key.tag is not None:
@@ -5539,7 +5711,7 @@ class InjectorBinder:
         if array is not None:
             key = dc.replace(key, array=array)
 
-        ##
+        #
 
         providers: ta.List[InjectorProvider] = []
         if to_fn is not None:
@@ -5554,23 +5726,34 @@ class InjectorBinder:
             raise TypeError('Must specify provider')
         if len(providers) > 1:
             raise TypeError('May not specify multiple providers')
-        provider, = providers
+        provider = check.single(providers)
 
-        ##
+        #
 
+        pws: ta.List[ta.Any] = []
+        if in_ is not None:
+            check.issubclass(in_, InjectorScope)
+            check.not_in(abc.ABC, in_.__bases__)
+            pws.append(functools.partial(ScopedInjectorProvider, k=key, sc=in_))
         if singleton:
-            provider = SingletonInjectorProvider(provider)
+            pws.append(SingletonInjectorProvider)
+        if len(pws) > 1:
+            raise TypeError('May not specify multiple provider wrappers')
+        elif pws:
+            provider = check.single(pws)(provider)
+
+        #
 
         binding = InjectorBinding(key, provider)
 
-        ##
+        #
 
         extras: ta.List[InjectorBinding] = []
 
         if eager:
             extras.append(bind_injector_eager_key(key))
 
-        ##
+        #
 
         if extras:
             return as_injector_bindings(binding, *extras)
@@ -5643,7 +5826,8 @@ def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
     return InjectorBinding(_INJECTOR_EAGER_ARRAY_KEY, ConstInjectorProvider(_InjectorEager(as_injector_key(key))))
 
 
-##
+###
+# api
 
 
 class InjectionApi:
@@ -5666,6 +5850,14 @@ class InjectionApi:
     def override(self, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
+    # scopes
+
+    def bind_scope(self, sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+        return bind_injector_scope(sc)
+
+    def bind_scope_seed(self, k: ta.Any, sc: ta.Type[InjectorScope]) -> InjectorBindingOrBindings:
+        return bind_injector_scope_seed(k, sc)
+
     # injector
 
     def create_injector(self, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
@@ -5686,6 +5878,7 @@ class InjectionApi:
             to_const: ta.Any = None,
             to_key: ta.Any = None,
 
+            in_: ta.Optional[ta.Type[InjectorScope]] = None,
             singleton: bool = False,
 
             eager: bool = False,
@@ -5702,6 +5895,7 @@ class InjectionApi:
             to_const=to_const,
             to_key=to_key,
 
+            in_=in_,
             singleton=singleton,
 
             eager=eager,
@@ -7547,6 +7741,37 @@ class LocalCommandExecutor(CommandExecutor):
         return await ce.execute(cmd)
 
 
+########################################
+# ../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
 """
@@ -7885,9 +8110,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:
@@ -8707,17 +8936,6 @@ TODO:
 
 
 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,
@@ -8884,7 +9102,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)
@@ -8892,17 +9109,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
 
@@ -9442,122 +9655,6 @@ def bind_commands(
     return inj.as_bindings(*lst)
 
 
-########################################
-# ../deploy/git.py
-"""
-TODO:
- - 'repos'?
-
-git/github.com/wrmsr/omlish <- bootstrap repo
- - shallow clone off bootstrap into /apps
-
-github.com/wrmsr/omlish@rev
-"""
-
-
-##
-
-
-class DeployGitManager(SingleDirDeployPathOwner):
-    def __init__(
-            self,
-            *,
-            deploy_home: ta.Optional[DeployHome] = None,
-            atomics: AtomicPathSwapping,
-    ) -> None:
-        super().__init__(
-            owned_dir='git',
-            deploy_home=deploy_home,
-        )
-
-        self._atomics = atomics
-
-        self._repo_dirs: ta.Dict[DeployGitRepo, DeployGitManager.RepoDir] = {}
-
-    class RepoDir:
-        def __init__(
-                self,
-                git: 'DeployGitManager',
-                repo: DeployGitRepo,
-        ) -> None:
-            super().__init__()
-
-            self._git = git
-            self._repo = repo
-            self._dir = os.path.join(
-                self._git._make_dir(),  # noqa
-                check.non_empty_str(repo.host),
-                check.non_empty_str(repo.path),
-            )
-
-        @property
-        def repo(self) -> DeployGitRepo:
-            return self._repo
-
-        @property
-        def url(self) -> str:
-            if self._repo.username is not None:
-                return f'{self._repo.username}@{self._repo.host}:{self._repo.path}'
-            else:
-                return f'https://{self._repo.host}/{self._repo.path}'
-
-        #
-
-        async def _call(self, *cmd: str) -> None:
-            await asyncio_subprocesses.check_call(
-                *cmd,
-                cwd=self._dir,
-            )
-
-        #
-
-        @async_cached_nullary
-        async def init(self) -> None:
-            os.makedirs(self._dir, exist_ok=True)
-            if os.path.exists(os.path.join(self._dir, '.git')):
-                return
-
-            await self._call('git', 'init')
-            await self._call('git', 'remote', 'add', 'origin', self.url)
-
-        async def fetch(self, rev: DeployRev) -> None:
-            await self.init()
-            await self._call('git', 'fetch', '--depth=1', 'origin', rev)
-
-        #
-
-        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
-                    'dir',
-                    dst_dir,
-                    auto_commit=True,
-                    make_dirs=True,
-            ) as dst_swap:
-                await self.fetch(spec.rev)
-
-                dst_call = functools.partial(asyncio_subprocesses.check_call, cwd=dst_swap.tmp_path)
-                await dst_call('git', 'init')
-
-                await dst_call('git', 'remote', 'add', 'local', self._dir)
-                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:
-        try:
-            return self._repo_dirs[repo]
-        except KeyError:
-            repo_dir = self._repo_dirs[repo] = DeployGitManager.RepoDir(self, repo)
-            return repo_dir
-
-    async def checkout(
-            self,
-            spec: DeployGitSpec,
-            dst_dir: str,
-    ) -> None:
-        await self.get_repo_dir(spec.repo).checkout(spec, dst_dir)
-
-
 ########################################
 # ../deploy/paths/manager.py
 
@@ -9566,12 +9663,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
@@ -9592,37 +9687,22 @@ class DeployPathsManager:
 # ../deploy/tmp.py
 
 
+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),
         )
 
 
@@ -10081,11 +10161,11 @@ class PyenvVersionInstaller:
             full_args = [
                 os.path.join(check.not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
                 *conf_args,
-                self.install_dir(),
+                await self.install_dir(),
             ]
         else:
             full_args = [
-                self._pyenv.exe(),
+                await self._pyenv.exe(),
                 'install',
                 *conf_args,
             ]
@@ -10340,6 +10420,137 @@ class SystemInterpProvider(InterpProvider):
         raise KeyError(version)
 
 
+########################################
+# ../deploy/git.py
+"""
+TODO:
+ - 'repos'?
+
+git/github.com/wrmsr/omlish <- bootstrap repo
+ - shallow clone off bootstrap into /apps
+
+github.com/wrmsr/omlish@rev
+"""
+
+
+##
+
+
+class DeployGitManager(SingleDirDeployPathOwner):
+    def __init__(
+            self,
+            *,
+            atomics: DeployHomeAtomics,
+    ) -> None:
+        super().__init__(
+            owned_dir='git',
+        )
+
+        self._atomics = atomics
+
+        self._repo_dirs: ta.Dict[DeployGitRepo, DeployGitManager.RepoDir] = {}
+
+    class RepoDir:
+        def __init__(
+                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(home),  # noqa
+                check.non_empty_str(repo.host),
+                check.non_empty_str(repo.path),
+            )
+
+        @property
+        def repo(self) -> DeployGitRepo:
+            return self._repo
+
+        @property
+        def url(self) -> str:
+            if self._repo.username is not None:
+                return f'{self._repo.username}@{self._repo.host}:{self._repo.path}'
+            else:
+                return f'https://{self._repo.host}/{self._repo.path}'
+
+        #
+
+        async def _call(self, *cmd: str) -> None:
+            await asyncio_subprocesses.check_call(
+                *cmd,
+                cwd=self._dir,
+            )
+
+        #
+
+        @async_cached_nullary
+        async def init(self) -> None:
+            os.makedirs(self._dir, exist_ok=True)
+            if os.path.exists(os.path.join(self._dir, '.git')):
+                return
+
+            await self._call('git', 'init')
+            await self._call('git', 'remote', 'add', 'origin', self.url)
+
+        async def fetch(self, rev: DeployRev) -> None:
+            await self.init()
+            await self._call('git', 'fetch', '--depth=1', 'origin', rev)
+
+        #
+
+        async def checkout(self, spec: DeployGitSpec, dst_dir: str) -> None:
+            check.state(not os.path.exists(dst_dir))
+            with self._git._atomics(self._home).begin_atomic_path_swap(  # noqa
+                    'dir',
+                    dst_dir,
+                    auto_commit=True,
+                    make_dirs=True,
+            ) as dst_swap:
+                await self.fetch(spec.rev)
+
+                dst_call = functools.partial(asyncio_subprocesses.check_call, cwd=dst_swap.tmp_path)
+                await dst_call('git', 'init')
+
+                await dst_call('git', 'remote', 'add', 'local', self._dir)
+                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,
+            home: DeployHome,
+    ) -> RepoDir:
+        try:
+            return self._repo_dirs[repo]
+        except KeyError:
+            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,
+            home,
+        ).checkout(
+            spec,
+            dst_dir,
+        )
+
+
 ########################################
 # ../deploy/paths/inject.py
 
@@ -10739,18 +10950,10 @@ TODO:
 
 
 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:
@@ -10793,16 +10996,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
@@ -10843,12 +11042,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)
@@ -10858,7 +11058,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(
@@ -10905,7 +11105,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(
@@ -10922,6 +11122,7 @@ class DeployAppManager(DeployPathOwner):
         app_git_dir = os.path.join(app_dir, 'git')
         await self._git.checkout(
             spec.git,
+            home,
             app_git_dir,
         )
 
@@ -10931,6 +11132,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,
             )
@@ -10952,56 +11154,53 @@ class DeployAppManager(DeployPathOwner):
 
 
 ########################################
-# ../deploy/deploy.py
+# ../deploy/driver.py
 
 
-DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
-
-
-DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
+class DeployDriverFactory(Func1[DeploySpec, ta.ContextManager['DeployDriver']]):
+    pass
 
 
-class DeployManager:
+class DeployDriver:
     def __init__(
             self,
             *,
-            apps: DeployAppManager,
-            paths: DeployPathsManager,
+            spec: DeploySpec,
 
-            utc_clock: ta.Optional[DeployManagerUtcClock] = None,
-    ):
+            deploys: DeployManager,
+            paths: DeployPathsManager,
+            apps: DeployAppManager,
+    ) -> None:
         super().__init__()
 
-        self._apps = apps
+        self._spec = spec
+
+        self._deploys = deploys
         self._paths = paths
+        self._apps = apps
 
-        self._utc_clock = utc_clock
+    async def drive_deploy(self) -> None:
+        self._paths.validate_deploy_paths()
 
-    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))
+        hs = check.non_empty_str(self._spec.home)
+        hs = os.path.expanduser(hs)
+        hs = os.path.realpath(hs)
+        hs = os.path.abspath(hs)
 
-    async def run_deploy(
-            self,
-            spec: DeploySpec,
-    ) -> None:
-        self._paths.validate_deploy_paths()
+        home = DeployHome(hs)
 
         #
 
         deploy_tags = DeployTagMap(
-            self._make_deploy_time(),
-            spec.key(),
+            self._deploys.make_deploy_time(),
+            self._spec.key(),
         )
 
         #
 
-        for app in spec.apps:
+        for app in self._spec.apps:
             app_tags = deploy_tags.add(
                 app.app,
                 app.key(),
@@ -11010,6 +11209,7 @@ class DeployManager:
 
             await self._apps.prepare_app(
                 app,
+                home,
                 app_tags,
             )
 
@@ -11032,12 +11232,13 @@ 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()
 
@@ -11046,6 +11247,10 @@ class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]
 # ../deploy/inject.py
 
 
+class DeployInjectorScope(ContextvarInjectorScope):
+    pass
+
+
 def bind_deploy(
         *,
         deploy_config: DeployConfig,
@@ -11077,13 +11282,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),
@@ -11091,10 +11320,6 @@ 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)
 
 
@@ -11190,8 +11415,6 @@ def main_bootstrap(bs: MainBootstrap) -> Injector:
 
 @dc.dataclass(frozen=True)
 class ManageConfig:
-    deploy_home: ta.Optional[str] = None
-
     targets: ta.Optional[ta.Mapping[str, ManageTarget]] = None
 
 
@@ -11223,8 +11446,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='*'),
@@ -11237,9 +11458,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