ominfra 0.0.0.dev189__tar.gz → 0.0.0.dev191__tar.gz

{ominfra-0.0.0.dev189/ominfra.egg-info → ominfra-0.0.0.dev191}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ominfra
-Version: 0.0.0.dev189
+Version: 0.0.0.dev191
 Summary: ominfra
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,8 +12,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev189
-Requires-Dist: omlish==0.0.0.dev189
+Requires-Dist: omdev==0.0.0.dev191
+Requires-Dist: omlish==0.0.0.dev191
+Requires-Dist: omserv==0.0.0.dev191
 Provides-Extra: all
 Requires-Dist: paramiko~=3.5; extra == "all"
 Requires-Dist: asyncssh~=2.18; extra == "all"

{ominfra-0.0.0.dev189 → ominfra-0.0.0.dev191}/ominfra/__about__.py

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

ominfra-0.0.0.dev191/ominfra/manage/deploy/apps.py

@@ -0,0 +1,198 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import json
+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 .conf.manager import DeployConfManager
+from .git import DeployGitManager
+from .paths.owners import DeployPathOwner
+from .paths.paths import DeployPath
+from .specs import DeployAppSpec
+from .tags import DeployAppRev
+from .tags import DeployTagMap
+from .types import DeployHome
+from .venvs import DeployVenvManager
+
+
+class DeployAppManager(DeployPathOwner):
+    def __init__(
+            self,
+            *,
+            git: DeployGitManager,
+            venvs: DeployVenvManager,
+            conf: DeployConfManager,
+
+            msh: ObjMarshalerManager,
+    ) -> None:
+        super().__init__()
+
+        self._git = git
+        self._venvs = venvs
+        self._conf = conf
+
+        self._msh = msh
+
+    #
+
+    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,
+
+            *[
+                DeployPath.parse(f'{self.APP_DIR}{sfx}/')
+                for sfx in [
+                    'conf',
+                    'git',
+                    'venv',
+                ]
+            ],
+        }
+
+    #
+
+    def _make_tags(self, spec: DeployAppSpec) -> DeployTagMap:
+        return DeployTagMap(
+            spec.app,
+            spec.key(),
+            DeployAppRev(spec.git.rev),
+        )
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class PreparedApp:
+        spec: DeployAppSpec
+        tags: DeployTagMap
+
+        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,
+    ) -> PreparedApp:
+        spec_json = json_dumps_pretty(self._msh.marshal_obj(spec))
+
+        #
+
+        app_tags = tags.add(*self._make_tags(spec))
+
+        #
+
+        check.non_empty_str(home)
+
+        app_dir = os.path.join(home, self.APP_DIR.render(app_tags))
+
+        os.makedirs(app_dir, exist_ok=True)
+
+        #
+
+        rkw: ta.Dict[str, ta.Any] = dict(
+            spec=spec,
+            tags=app_tags,
+
+            dir=app_dir,
+        )
+
+        #
+
+        spec_file = os.path.join(app_dir, 'spec.json')
+        with open(spec_file, 'w') as f:  # noqa
+            f.write(spec_json)
+
+        #
+
+        git_dir = os.path.join(app_dir, 'git')
+        rkw.update(git_dir=git_dir)
+        await self._git.checkout(
+            spec.git,
+            home,
+            git_dir,
+        )
+
+        #
+
+        if spec.venv is not None:
+            venv_dir = os.path.join(app_dir, 'venv')
+            rkw.update(venv_dir=venv_dir)
+            await self._venvs.setup_venv(
+                spec.venv,
+                git_dir,
+                venv_dir,
+            )
+
+        #
+
+        if spec.conf is not None:
+            conf_dir = os.path.join(app_dir, 'conf')
+            rkw.update(conf_dir=conf_dir)
+            await self._conf.write_app_conf(
+                spec.conf,
+                conf_dir,
+            )
+
+        #
+
+        return DeployAppManager.PreparedApp(**rkw)
+
+    async def prepare_app_link(
+            self,
+            tags: DeployTagMap,
+            app_dir: str,
+    ) -> PreparedApp:
+        spec_file = os.path.join(app_dir, 'spec.json')
+        with open(spec_file) as f:  # noqa
+            spec_json = f.read()
+
+        spec: DeployAppSpec = self._msh.unmarshal_obj(json.loads(spec_json), DeployAppSpec)
+
+        #
+
+        app_tags = tags.add(*self._make_tags(spec))
+
+        #
+
+        rkw: ta.Dict[str, ta.Any] = dict(
+            spec=spec,
+            tags=app_tags,
+
+            dir=app_dir,
+        )
+
+        #
+
+        git_dir = os.path.join(app_dir, 'git')
+        check.state(os.path.isdir(git_dir))
+        rkw.update(git_dir=git_dir)
+
+        #
+
+        if spec.venv is not None:
+            venv_dir = os.path.join(app_dir, 'venv')
+            check.state(os.path.isdir(venv_dir))
+            rkw.update(venv_dir=venv_dir)
+
+        #
+
+        if spec.conf is not None:
+            conf_dir = os.path.join(app_dir, 'conf')
+            check.state(os.path.isdir(conf_dir))
+            rkw.update(conf_dir=conf_dir)
+
+        #
+
+        return DeployAppManager.PreparedApp(**rkw)

{ominfra-0.0.0.dev189 → ominfra-0.0.0.dev191}/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-0.0.0.dev189 → ominfra-0.0.0.dev191}/ominfra/manage/deploy/conf/manager.py

@@ -16,6 +16,8 @@ TODO:
   - some things (venvs) cannot be moved, thus the /deploy/venvs dir
   - ** ensure (enforce) equivalent relpath nesting
 """
+import collections.abc
+import functools
 import os.path
 import typing as ta
 
@@ -24,6 +26,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,19 +41,70 @@ from .specs import DeployAppConfLink
 from .specs import DeployAppConfSpec
 from .specs import IniDeployAppConfContent
 from .specs import JsonDeployAppConfContent
+from .specs import NginxDeployAppConfContent
 from .specs import RawDeployAppConfContent
 
 
+T = ta.TypeVar('T')
+
+
+##
+
+
 class DeployConfManager:
-    def _render_app_conf_content(self, ac: DeployAppConfContent) -> str:
+    def _process_conf_content(
+            self,
+            content: T,
+            *,
+            str_processor: ta.Optional[ta.Callable[[str], str]] = None,
+    ) -> T:
+        def rec(o):
+            if isinstance(o, str):
+                if str_processor is not None:
+                    return type(o)(str_processor(o))
+
+            elif isinstance(o, collections.abc.Mapping):
+                return type(o)([  # type: ignore
+                    (rec(k), rec(v))
+                    for k, v in o.items()
+                ])
+
+            elif isinstance(o, collections.abc.Iterable):
+                return type(o)([  # type: ignore
+                    rec(e) for e in o
+                ])
+
+            return o
+
+        return rec(content)
+
+    #
+
+    def _render_app_conf_content(
+            self,
+            ac: DeployAppConfContent,
+            *,
+            str_processor: ta.Optional[ta.Callable[[str], str]] = None,
+    ) -> str:
+        pcc = functools.partial(
+            self._process_conf_content,
+            str_processor=str_processor,
+        )
+
         if isinstance(ac, RawDeployAppConfContent):
-            return ac.body
+            return pcc(ac.body)
 
         elif isinstance(ac, JsonDeployAppConfContent):
-            return strip_with_newline(json_dumps_pretty(ac.obj))
+            json_obj = pcc(ac.obj)
+            return strip_with_newline(json_dumps_pretty(json_obj))
 
         elif isinstance(ac, IniDeployAppConfContent):
-            return strip_with_newline(render_ini_config(ac.sections))
+            ini_sections = pcc(ac.sections)
+            return strip_with_newline(render_ini_config(ini_sections))
+
+        elif isinstance(ac, NginxDeployAppConfContent):
+            nginx_items = NginxConfigItems.of(pcc(ac.items))
+            return strip_with_newline(render_nginx_config_str(nginx_items))
 
         else:
             raise TypeError(ac)
@@ -58,17 +113,37 @@ class DeployConfManager:
             self,
             acf: DeployAppConfFile,
             app_conf_dir: str,
+            *,
+            str_processor: ta.Optional[ta.Callable[[str], str]] = None,
     ) -> None:
         conf_file = os.path.join(app_conf_dir, acf.path)
         check.arg(is_path_in_dir(app_conf_dir, conf_file))
 
-        body = self._render_app_conf_content(acf.content)
+        body = self._render_app_conf_content(
+            acf.content,
+            str_processor=str_processor,
+        )
 
         os.makedirs(os.path.dirname(conf_file), exist_ok=True)
 
         with open(conf_file, 'w') as f:  # noqa
             f.write(body)
 
+    async def write_app_conf(
+            self,
+            spec: DeployAppConfSpec,
+            app_conf_dir: str,
+    ) -> None:
+        def process_str(s: str) -> str:
+            return s
+
+        for acf in spec.files or []:
+            await self._write_app_conf_file(
+                acf,
+                app_conf_dir,
+                str_processor=process_str,
+            )
+
     #
 
     class _ComputedConfLink(ta.NamedTuple):
@@ -178,23 +253,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-0.0.0.dev189 → ominfra-0.0.0.dev191}/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
+
+
 ##