ominfra 0.0.0.dev7__py3-none-any.whl

ominfra/deploy/poly/base.py

@@ -0,0 +1,179 @@
+# ruff: noqa: UP006 UP007
+import abc
+import dataclasses as dc
+import typing as ta
+
+from .configs import DeployConcernConfig  # noqa
+from .configs import DeployConfig
+from .configs import SiteConcernConfig  # noqa
+from .configs import SiteConfig
+
+
+T = ta.TypeVar('T')
+ConcernT = ta.TypeVar('ConcernT')
+ConfigT = ta.TypeVar('ConfigT')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FsItem(abc.ABC):
+    path: str
+
+    @property
+    @abc.abstractmethod
+    def is_dir(self) -> bool:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class FsFile(FsItem):
+    @property
+    def is_dir(self) -> bool:
+        return False
+
+
+@dc.dataclass(frozen=True)
+class FsDir(FsItem):
+    @property
+    def is_dir(self) -> bool:
+        return True
+
+
+##
+
+
+class Runtime(abc.ABC):
+    class Stat(ta.NamedTuple):
+        path: str
+        is_dir: bool
+
+    @abc.abstractmethod
+    def stat(self, p: str) -> ta.Optional[Stat]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def make_dirs(self, p: str, exist_ok: bool = False) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def write_file(self, p: str, c: ta.Union[str, bytes]) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def sh(self, *ss: str) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class ConcernsContainer(abc.ABC, ta.Generic[ConcernT, ConfigT]):
+    concern_cls: ta.ClassVar[type]
+
+    def __init__(
+            self,
+            config: ConfigT,
+    ) -> None:
+        super().__init__()
+        self._config = config
+
+        concern_cls_dct = self._concern_cls_by_config_cls()
+        self._concerns = [
+            concern_cls_dct[type(c)](c, self)  # type: ignore
+            for c in config.concerns  # type: ignore
+        ]
+        self._concerns_by_cls: ta.Dict[ta.Type[ConcernT], ConcernT] = {}
+        for c in self._concerns:
+            if type(c) in self._concerns_by_cls:
+                raise TypeError(f'Duplicate concern type: {c}')
+            self._concerns_by_cls[type(c)] = c
+
+    @classmethod
+    def _concern_cls_by_config_cls(cls) -> ta.Mapping[type, ta.Type[ConcernT]]:
+        return {  # noqa
+            c.Config: c  # type: ignore
+            for c in cls.concern_cls.__subclasses__()
+        }
+
+    @property
+    def config(self) -> ConfigT:
+        return self._config
+
+    @property
+    def concerns(self) -> ta.List[ConcernT]:
+        return self._concerns
+
+    def concern(self, cls: ta.Type[T]) -> T:
+        return self._concerns_by_cls[cls]  # type: ignore
+
+
+##
+
+
+SiteConcernT = ta.TypeVar('SiteConcernT', bound='SiteConcern')
+SiteConcernConfigT = ta.TypeVar('SiteConcernConfigT', bound='SiteConcernConfig')
+
+
+class SiteConcern(abc.ABC, ta.Generic[SiteConcernConfigT]):
+    def __init__(self, config: SiteConcernConfigT, site: 'Site') -> None:
+        super().__init__()
+        self._config = config
+        self._site = site
+
+    @property
+    def config(self) -> SiteConcernConfigT:
+        return self._config
+
+    @abc.abstractmethod
+    def run(self, runtime: Runtime) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class Site(ConcernsContainer[SiteConcern, SiteConfig]):
+    @abc.abstractmethod
+    def run(self, runtime: Runtime) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+DeployConcernT = ta.TypeVar('DeployConcernT', bound='DeployConcern')
+DeployConcernConfigT = ta.TypeVar('DeployConcernConfigT', bound='DeployConcernConfig')
+
+
+class DeployConcern(abc.ABC, ta.Generic[DeployConcernConfigT]):
+    def __init__(self, config: DeployConcernConfigT, deploy: 'Deploy') -> None:
+        super().__init__()
+        self._config = config
+        self._deploy = deploy
+
+    @property
+    def config(self) -> DeployConcernConfigT:
+        return self._config
+
+    def fs_items(self) -> ta.Sequence[FsItem]:
+        return []
+
+    @abc.abstractmethod
+    def run(self, runtime: Runtime) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class Deploy(ConcernsContainer[DeployConcern, DeployConfig]):
+    @property
+    @abc.abstractmethod
+    def site(self) -> Site:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def run(self, runtime: Runtime) -> None:
+        raise NotImplementedError

ominfra/deploy/poly/configs.py

@@ -0,0 +1,38 @@
+# ruff: noqa: UP006
+import abc
+import dataclasses as dc
+import typing as ta
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SiteConcernConfig(abc.ABC):  # noqa
+    pass
+
+
+@dc.dataclass(frozen=True)
+class SiteConfig:
+    user = 'omlish'
+
+    root_dir: str = '~/deploy'
+
+    concerns: ta.List[SiteConcernConfig] = dc.field(default_factory=list)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployConcernConfig(abc.ABC):  # noqa
+    pass
+
+
+@dc.dataclass(frozen=True)
+class DeployConfig:
+    site: SiteConfig
+
+    name: str
+
+    concerns: ta.List[DeployConcernConfig] = dc.field(default_factory=list)

ominfra/deploy/poly/deploy.py

@@ -0,0 +1,25 @@
+from .base import Deploy
+from .base import DeployConcern
+from .base import Runtime
+from .base import Site
+from .configs import DeployConfig
+
+
+class DeployImpl(Deploy):
+    concern_cls = DeployConcern
+
+    def __init__(
+            self,
+            config: DeployConfig,
+            site: Site,
+    ) -> None:
+        super().__init__(config)
+        self._site = site
+
+    @property
+    def site(self) -> Site:
+        return self._site
+
+    def run(self, runtime: Runtime) -> None:
+        for c in self._concerns:
+            c.run(runtime)

ominfra/deploy/poly/main.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# @omdev-amalg ./_main.py
+from .deploy import DeployImpl  # noqa
+from .nginx import NginxDeployConcern  # noqa
+from .nginx import NginxSiteConcern  # noqa
+from .repo import RepoDeployConcern  # noqa
+from .runtime import RuntimeImpl  # noqa
+from .site import SiteImpl  # noqa
+from .supervisor import SupervisorDeployConcern  # noqa
+from .venv import VenvDeployConcern  # noqa
+
+
+def _main() -> None:
+    pass
+
+
+if __name__ == '__main__':
+    _main()

ominfra/deploy/poly/nginx.py

@@ -0,0 +1,60 @@
+import dataclasses as dc
+import os.path
+import textwrap
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from .base import DeployConcern
+from .base import FsFile
+from .base import FsItem
+from .base import Runtime
+from .base import SiteConcern
+from .configs import DeployConcernConfig
+from .configs import SiteConcernConfig
+
+
+class NginxSiteConcern(SiteConcern['NginxSiteConcern.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(SiteConcernConfig):
+        global_conf_file: str = '/etc/nginx/sites-enabled/omlish.conf'
+
+    @cached_nullary
+    def confs_dir(self) -> str:
+        return os.path.join(self._site.config.root_dir, 'conf', 'nginx')
+
+    def run(self, runtime: Runtime) -> None:
+        if runtime.stat(self._config.global_conf_file) is None:
+            runtime.write_file(
+                self._config.global_conf_file,
+                f'include {self.confs_dir()}/*.conf;\n',
+            )
+
+
+class NginxDeployConcern(DeployConcern['NginxDeployConcern.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(DeployConcernConfig):
+        listen_port: int = 80
+        proxy_port: int = 8000
+
+    @cached_nullary
+    def conf_file(self) -> str:
+        return os.path.join(self._deploy.site.concern(NginxSiteConcern).confs_dir(), self._deploy.config.name + '.conf')
+
+    @cached_nullary
+    def fs_items(self) -> ta.Sequence[FsItem]:
+        return [FsFile(self.conf_file())]
+
+    def run(self, runtime: Runtime) -> None:
+        runtime.make_dirs(os.path.dirname(self.conf_file()))
+
+        conf = textwrap.dedent(f"""
+            server {{
+                listen {self._config.listen_port};
+                location / {{
+                    proxy_pass http://127.0.0.1:{self._config.proxy_port}/;
+                }}
+            }}
+        """)
+
+        runtime.write_file(self.conf_file(), conf)

ominfra/deploy/poly/repo.py

@@ -0,0 +1,41 @@
+import dataclasses as dc
+import os.path
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from .base import DeployConcern
+from .base import FsDir
+from .base import FsItem
+from .base import Runtime
+from .configs import DeployConcernConfig
+
+
+class RepoDeployConcern(DeployConcern['RepoDeployConcern.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(DeployConcernConfig):
+        url: str
+        revision: str = 'master'
+        init_submodules: bool = False
+
+    @cached_nullary
+    def repo_dir(self) -> str:
+        return os.path.join(self._deploy.site.config.root_dir, 'repos', self._deploy.config.name)
+
+    @cached_nullary
+    def fs_items(self) -> ta.Sequence[FsItem]:
+        return [FsDir(self.repo_dir())]
+
+    def run(self, runtime: Runtime) -> None:
+        runtime.make_dirs(self.repo_dir())
+
+        runtime.sh(
+            f'cd {self.repo_dir()}',
+            'git init',
+            f'git remote add origin {self._config.url}',
+            f'git fetch --depth 1 origin {self._config.revision}',
+            'git checkout FETCH_HEAD',
+            *([
+                'git submodule update --init',
+            ] if self._config.init_submodules else []),
+        )

ominfra/deploy/poly/runtime.py

@@ -0,0 +1,39 @@
+# ruff: noqa: UP007
+import os.path
+import stat
+import typing as ta
+
+from omlish.lite.logs import log
+from omlish.lite.subprocesses import subprocess_check_call
+
+from .base import Runtime
+
+
+class RuntimeImpl(Runtime):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def stat(self, p: str) -> ta.Optional[Runtime.Stat]:
+        try:
+            st = os.stat(p)
+        except FileNotFoundError:
+            return None
+        else:
+            return Runtime.Stat(
+                path=p,
+                is_dir=bool(st.st_mode & stat.S_IFDIR),
+            )
+
+    def make_dirs(self, p: str, exist_ok: bool = False) -> None:
+        os.makedirs(p, exist_ok=exist_ok)
+
+    def write_file(self, p: str, c: ta.Union[str, bytes]) -> None:
+        if os.path.exists(p):
+            raise RuntimeError(f'Path exists: {p}')
+        with open(p, 'w' if isinstance(c, str) else 'wb') as f:
+            f.write(c)
+
+    def sh(self, *ss: str) -> None:
+        s = ' && '.join(ss)
+        log.info('Executing: %s', s)
+        subprocess_check_call(s, shell=True)

ominfra/deploy/poly/site.py

@@ -0,0 +1,11 @@
+from .base import Runtime
+from .base import Site
+from .base import SiteConcern
+
+
+class SiteImpl(Site):
+    concern_cls = SiteConcern
+
+    def run(self, runtime: Runtime) -> None:
+        for c in self._concerns:
+            c.run(runtime)

ominfra/deploy/poly/supervisor.py

@@ -0,0 +1,64 @@
+import dataclasses as dc
+import os.path
+import textwrap
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from .base import DeployConcern
+from .base import FsFile
+from .base import FsItem
+from .base import Runtime
+from .configs import DeployConcernConfig
+from .repo import RepoDeployConcern
+from .venv import VenvDeployConcern
+
+
+# class SupervisorSiteConcern(SiteConcern['SupervisorSiteConcern.Config']):
+#     @dc.dataclass(frozen=True)
+#     class Config(DeployConcern.Config):
+#         global_conf_file: str = '/etc/supervisor/conf.d/supervisord.conf'
+#
+#     def run(self) -> None:
+#         sup_conf_dir = os.path.join(self._d.home_dir(), 'conf/supervisor')
+#         with open(self._d.host_cfg.global_supervisor_conf_file_path) as f:
+#             glo_sup_conf = f.read()
+#         if sup_conf_dir not in glo_sup_conf:
+#             log.info('Updating global supervisor conf at %s', self._d.host_cfg.global_supervisor_conf_file_path)  # noqa
+#             glo_sup_conf += textwrap.dedent(f"""
+#                 [include]
+#                 files = {self._d.home_dir()}/conf/supervisor/*.conf
+#             """)
+#             with open(self._d.host_cfg.global_supervisor_conf_file_path, 'w') as f:
+#                 f.write(glo_sup_conf)
+
+
+class SupervisorDeployConcern(DeployConcern['SupervisorDeployConcern.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(DeployConcernConfig):
+        entrypoint: str
+
+    @cached_nullary
+    def conf_file(self) -> str:
+        return os.path.join(self._deploy.site.config.root_dir, 'conf', 'supervisor', self._deploy.config.name + '.conf')
+
+    @cached_nullary
+    def fs_items(self) -> ta.Sequence[FsItem]:
+        return [FsFile(self.conf_file())]
+
+    def run(self, runtime: Runtime) -> None:
+        runtime.make_dirs(os.path.dirname(self.conf_file()))
+
+        rd = self._deploy.concern(RepoDeployConcern).repo_dir()
+        vx = self._deploy.concern(VenvDeployConcern).exe()
+
+        conf = textwrap.dedent(f"""
+            [program:{self._deploy.config.name}]
+            command={vx} -m {self._config.entrypoint}
+            directory={rd}
+            user={self._deploy.site.config.user}
+            autostart=true
+            autorestart=true
+        """)
+
+        runtime.write_file(self.conf_file(), conf)

ominfra/deploy/poly/venv.py

@@ -0,0 +1,52 @@
+import dataclasses as dc
+import os.path
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from .base import DeployConcern
+from .base import FsDir
+from .base import FsItem
+from .base import Runtime
+from .configs import DeployConcernConfig
+from .repo import RepoDeployConcern
+
+
+class VenvDeployConcern(DeployConcern['VenvDeployConcern.Config']):
+    @dc.dataclass(frozen=True)
+    class Config(DeployConcernConfig):
+        interp_version: str
+        requirements_txt: str = 'requirements.txt'
+
+    @cached_nullary
+    def venv_dir(self) -> str:
+        return os.path.join(self._deploy.site.config.root_dir, 'venvs', self._deploy.config.name)
+
+    @cached_nullary
+    def fs_items(self) -> ta.Sequence[FsItem]:
+        return [FsDir(self.venv_dir())]
+
+    @cached_nullary
+    def exe(self) -> str:
+        return os.path.join(self.venv_dir(), 'bin', 'python')
+
+    def run(self, runtime: Runtime) -> None:
+        runtime.make_dirs(self.venv_dir())
+
+        rd = self._deploy.concern(RepoDeployConcern).repo_dir()
+
+        l, r = os.path.split(self.venv_dir())
+
+        # FIXME: lol
+        py_exe = 'python3'
+
+        runtime.sh(
+            f'cd {l}',
+            f'{py_exe} -mvenv {r}',
+
+            # https://stackoverflow.com/questions/77364550/attributeerror-module-pkgutil-has-no-attribute-impimporter-did-you-mean
+            f'{self.exe()} -m ensurepip',
+            f'{self.exe()} -mpip install --upgrade setuptools pip',
+
+            f'{self.exe()} -mpip install -r {rd}/{self._config.requirements_txt}',  # noqa
+        )

ominfra/deploy/remote.py

@@ -0,0 +1,91 @@
+"""
+lookit:
+ - piku, obviously
+ - https://github.com/mitogen-hq/mitogen/
+
+git init
+git remote add local ~/src/wrmsr/omlish/.git
+git fetch --depth=1 local master
+git remote add origin https://github.com/wrmsr/omlish
+git fetch --depth=1 origin master
+git checkout origin/master
+
+{base_path}/{deploys}/
+  current ->
+  previous ->
+  20240522T120000_{rev}
+"""
+import asyncio
+import itertools
+import os.path
+import shlex
+import tempfile
+
+from omlish import check
+
+from .. import cmds
+
+
+def render_script(*cs: list[str] | tuple[str, ...]) -> str:
+    return ' '.join(itertools.chain.from_iterable(
+        [
+            *(['&&'] if i > 0 else []),
+            shlex.join(check.not_isinstance(l, str)),
+        ]
+        for i, l in enumerate(cs)
+    ))
+
+
+async def do_remote_deploy(
+        cr: cmds.CommandRunner,
+        rev: str = 'master',
+        *,
+        local_repo_path: str | None = None,
+        skip_submodules: bool = False,
+) -> None:
+    clone_script = [
+        ['git', 'init'],
+
+        *([
+            ['git', 'remote', 'add', 'local', local_repo_path],
+            ['git', 'fetch', '--depth=1', 'local', rev],
+        ] if local_repo_path is not None else ()),
+
+        ['git', 'remote', 'add', 'origin', 'https://github.com/wrmsr/omlish'],
+        ['git', 'fetch', '--depth=1', 'origin', rev],
+        ['git', 'checkout', f'origin/{rev}'],
+
+        *([['git', 'submodule', 'update', '--init']] if not skip_submodules else ()),
+
+        ['make', 'venv-deploy'],
+    ]
+
+    res = await cr.run_command(cr.Command([
+        'sh', '-c', render_script(
+            ['mkdir', 'omlish'],
+            ['cd', 'omlish'],
+            *clone_script,
+        ),
+    ]))
+    res.check()
+
+
+async def _a_main():
+    cwd = tempfile.mkdtemp()
+    print(cwd)
+
+    bootstrap_git_path = os.path.join(os.getcwd(), '.git')
+    check.state(os.path.isdir(bootstrap_git_path))
+
+    cr: cmds.CommandRunner = cmds.LocalCommandRunner(cmds.LocalCommandRunner.Config(
+        cwd=cwd,
+    ))
+
+    await do_remote_deploy(
+        cr,
+        local_repo_path=os.path.expanduser('~/src/wrmsr/omlish/.git'),
+    )
+
+
+if __name__ == '__main__':
+    asyncio.run(_a_main())