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

ominfra/__about__.py

@@ -10,6 +10,7 @@ class Project(ProjectBase):
     dependencies = [
         f'omdev == {__version__}',
         f'omlish == {__version__}',
+        f'omserv == {__version__}',
     ]
 
     optional_dependencies = {

ominfra/manage/deploy/apps.py

@@ -1,10 +1,12 @@
 # ruff: noqa: UP006 UP007
+import dataclasses as dc
 import os.path
 import typing as ta
 
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
-from omlish.os.paths import relative_symlink
+from omlish.lite.json import json_dumps_pretty
+from omlish.lite.marshal import ObjMarshalerManager
 
 from .conf.manager import DeployConfManager
 from .git import DeployGitManager
@@ -20,39 +22,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',
@@ -63,115 +57,73 @@ class DeployAppManager(DeployPathOwner):
 
     #
 
+    @dc.dataclass(frozen=True)
+    class PreparedApp:
+        app_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)
-
-        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)
+    ) -> PreparedApp:
+        spec_json = json_dumps_pretty(self._msh.marshal_obj(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(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(
+            app_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)

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 .driver import DeployDriverFactory
+from .deploy import DeployDriverFactory
 from .specs import DeploySpec
 
 

ominfra/manage/deploy/conf/manager.py

@@ -24,6 +24,8 @@ from omlish.lite.json import json_dumps_pretty
 from omlish.lite.strings import strip_with_newline
 from omlish.os.paths import is_path_in_dir
 from omlish.os.paths import relative_symlink
+from omserv.nginx.configs import NginxConfigItems
+from omserv.nginx.configs import render_nginx_config_str
 
 from ....configs import render_ini_config
 from ..paths.paths import DeployPath
@@ -37,6 +39,7 @@ from .specs import DeployAppConfLink
 from .specs import DeployAppConfSpec
 from .specs import IniDeployAppConfContent
 from .specs import JsonDeployAppConfContent
+from .specs import NginxDeployAppConfContent
 from .specs import RawDeployAppConfContent
 
 
@@ -51,6 +54,10 @@ class DeployConfManager:
         elif isinstance(ac, IniDeployAppConfContent):
             return strip_with_newline(render_ini_config(ac.sections))
 
+        elif isinstance(ac, NginxDeployAppConfContent):
+            ni = NginxConfigItems.of(ac.items)
+            return strip_with_newline(render_nginx_config_str(ni))
+
         else:
             raise TypeError(ac)
 
@@ -69,6 +76,17 @@ class DeployConfManager:
         with open(conf_file, 'w') as f:  # noqa
             f.write(body)
 
+    async def write_app_conf(
+            self,
+            spec: DeployAppConfSpec,
+            app_conf_dir: str,
+    ) -> None:
+        for acf in spec.files or []:
+            await self._write_app_conf_file(
+                acf,
+                app_conf_dir,
+            )
+
     #
 
     class _ComputedConfLink(ta.NamedTuple):
@@ -178,23 +196,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,

ominfra/manage/deploy/conf/specs.py

@@ -44,6 +44,15 @@ class IniDeployAppConfContent(DeployAppConfContent):
     sections: IniConfigSectionSettingsMap
 
 
+#
+
+
+@register_single_field_type_obj_marshaler('items')
+@dc.dataclass(frozen=True)
+class NginxDeployAppConfContent(DeployAppConfContent):
+    items: ta.Any
+
+
 ##
 
 

ominfra/manage/deploy/deploy.py

@@ -1,10 +1,31 @@
 # ruff: noqa: UP006 UP007
 import datetime
+import os.path
 import typing as ta
 
+from omlish.lite.cached import cached_nullary
+from omlish.lite.check import check
+from omlish.lite.json import json_dumps_pretty
+from omlish.lite.marshal import ObjMarshalerManager
 from omlish.lite.typing import Func0
+from omlish.lite.typing import Func1
+from omlish.os.paths import relative_symlink
 
+from .apps import DeployAppManager
+from .conf.manager import DeployConfManager
+from .paths.manager import DeployPathsManager
+from .paths.owners import DeployPathOwner
+from .paths.paths import DeployPath
+from .specs import DeployAppSpec
+from .specs import DeploySpec
+from .systemd import DeploySystemdManager
+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'
@@ -13,17 +34,52 @@ DEPLOY_TAG_DATETIME_FMT = '%Y%m%dT%H%M%SZ'
 DeployManagerUtcClock = ta.NewType('DeployManagerUtcClock', Func0[datetime.datetime])
 
 
-class DeployManager:
+class DeployManager(DeployPathOwner):
     def __init__(
             self,
             *,
-
             utc_clock: ta.Optional[DeployManagerUtcClock] = None,
     ):
         super().__init__()
 
         self._utc_clock = utc_clock
 
+    #
+
+    DEPLOYS_DIR = DeployPath.parse('deploys/')
+
+    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 _utc_now(self) -> datetime.datetime:
         if self._utc_clock is not None:
             return self._utc_clock()  # noqa
@@ -32,3 +88,152 @@ class DeployManager:
 
     def make_deploy_time(self) -> DeployTime:
         return DeployTime(self._utc_now().strftime(DEPLOY_TAG_DATETIME_FMT))
+
+
+##
+
+
+class DeployDriverFactory(Func1[DeploySpec, ta.ContextManager['DeployDriver']]):
+    pass
+
+
+class DeployDriver:
+    def __init__(
+            self,
+            *,
+            spec: DeploySpec,
+            home: DeployHome,
+            time: DeployTime,
+
+            deploys: DeployManager,
+            paths: DeployPathsManager,
+            apps: DeployAppManager,
+            conf: DeployConfManager,
+            systemd: DeploySystemdManager,
+
+            msh: ObjMarshalerManager,
+    ) -> None:
+        super().__init__()
+
+        self._spec = spec
+        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 deploy_tags(self) -> DeployTagMap:
+        return DeployTagMap(
+            self._time,
+            self._spec.key(),
+        )
+
+    def render_deploy_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.deploy_tags))
+
+    @property
+    def deploy_dir(self) -> str:
+        return self.render_deploy_path(self._deploys.DEPLOY_DIR)
+
+    #
+
+    async def drive_deploy(self) -> None:
+        spec_json = json_dumps_pretty(self._msh.marshal_obj(self._spec))
+
+        #
+
+        self._paths.validate_deploy_paths()
+
+        #
+
+        os.makedirs(self.deploy_dir)
+
+        #
+
+        spec_file = self.render_deploy_path(self._deploys.DEPLOY_SPEC_FILE)
+        with open(spec_file, 'w') as f:  # noqa
+            f.write(spec_json)
+
+        #
+
+        deploying_link = self.render_deploy_path(self._deploys.DEPLOYING_DEPLOY_LINK)
+        if os.path.exists(deploying_link):
+            os.unlink(deploying_link)
+        relative_symlink(
+            self.deploy_dir,
+            deploying_link,
+            target_is_directory=True,
+            make_dirs=True,
+        )
+
+        #
+
+        for md in [
+            self._deploys.APPS_DEPLOY_DIR,
+            self._deploys.CONFS_DEPLOY_DIR,
+        ]:
+            os.makedirs(self.render_deploy_path(md))
+
+        #
+
+        for app in self._spec.apps:
+            await self.drive_app_deploy(app)
+
+        #
+
+        current_link = self.render_deploy_path(self._deploys.CURRENT_DEPLOY_LINK)
+        os.replace(deploying_link, current_link)
+
+        #
+
+        await self._systemd.sync_systemd(
+            self._spec.systemd,
+            self._home,
+            os.path.join(self.deploy_dir, 'conf', 'systemd'),  # FIXME
+        )
+
+    #
+
+    async def drive_app_deploy(self, app: DeployAppSpec) -> None:
+        app_tags = self.deploy_tags.add(
+            app.app,
+            app.key(),
+            DeployAppRev(app.git.rev),
+        )
+
+        #
+
+        da = await self._apps.prepare_app(
+            app,
+            self._home,
+            app_tags,
+        )
+
+        #
+
+        app_link = self.render_deploy_path(self._deploys.APP_DEPLOY_LINK, app_tags)
+        relative_symlink(
+            da.app_dir,
+            app_link,
+            target_is_directory=True,
+            make_dirs=True,
+        )
+
+        #
+
+        deploy_conf_dir = self.render_deploy_path(self._deploys.CONFS_DEPLOY_DIR)
+        if app.conf is not None:
+            await self._conf.link_app_conf(
+                app.conf,
+                app_tags,
+                check.non_empty_str(da.conf_dir),
+                deploy_conf_dir,
+            )

ominfra/manage/deploy/inject.py

@@ -16,15 +16,16 @@ from .commands import DeployCommand
 from .commands import DeployCommandExecutor
 from .conf.inject import bind_deploy_conf
 from .config import DeployConfig
+from .deploy import DeployDriver
+from .deploy import DeployDriverFactory
 from .deploy import DeployManager
-from .driver import DeployDriver
-from .driver import DeployDriverFactory
 from .git import DeployGitManager
 from .inject_ import bind_deploy_manager
 from .interp import InterpCommand
 from .interp import InterpCommandExecutor
 from .paths.inject import bind_deploy_paths
 from .specs import DeploySpec
+from .systemd import DeploySystemdManager
 from .tags import DeployTime
 from .tmp import DeployHomeAtomics
 from .tmp import DeployTmpManager
@@ -101,13 +102,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),
     ])
 

ominfra/manage/deploy/nginx.py

@@ -0,0 +1,8 @@
+# ruff: noqa: UP006 UP007
+"""
+verify - nginx -t
+"""
+
+
+class DeployNginxManager:
+    pass

ominfra/manage/deploy/paths/paths.py

@@ -33,6 +33,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
@@ -174,7 +178,7 @@ class FileDeployPathPart(DeployPathPart):
 
 
 @dc.dataclass(frozen=True)
-class DeployPath:
+class DeployPath(DeployPathRenderable):
     parts: ta.Sequence[DeployPathPart]
 
     @property

ominfra/manage/deploy/specs.py

@@ -94,11 +94,22 @@ class DeployAppSpec(DeploySpecKeyed[DeployAppKey]):
 ##
 
 
+@dc.dataclass(frozen=True)
+class DeploySystemdSpec:
+    # ~/.config/systemd/user/
+    unit_dir: ta.Optional[str] = None
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class DeploySpec(DeploySpecKeyed[DeployKey]):
     home: DeployHome
 
-    apps: ta.Sequence[DeployAppSpec]
+    apps: ta.Sequence[DeployAppSpec] = ()
+
+    systemd: ta.Optional[DeploySystemdSpec] = None
 
     def __post_init__(self) -> None:
         check.non_empty_str(self.home)