omdev 0.0.0.dev212__py3-none-any.whl → 0.0.0.dev214__py3-none-any.whl

omdev/ci/compose.py

@@ -1,5 +1,4 @@
 # ruff: noqa: UP006 UP007
-# @omlish-lite
 """
 TODO:
  - fix rmi - only when not referenced anymore
@@ -11,15 +10,16 @@ import os.path
 import shlex
 import typing as ta
 
+from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.cached import cached_nullary
 from omlish.lite.check import check
-from omlish.lite.contextmanagers import ExitStacked
+from omlish.lite.contextmanagers import AsyncExitStacked
+from omlish.lite.contextmanagers import adefer
 from omlish.lite.contextmanagers import defer
 from omlish.lite.json import json_dumps_pretty
-from omlish.subprocesses import subprocesses
+from omlish.os.temp import make_temp_file
 
 from .shell import ShellCmd
-from .utils import make_temp_file
 from .utils import read_yaml_file
 
 
@@ -46,7 +46,7 @@ def get_compose_service_dependencies(
 ##
 
 
-class DockerComposeRun(ExitStacked):
+class DockerComposeRun(AsyncExitStacked):
     @dc.dataclass(frozen=True)
     class Config:
         compose_file: str
@@ -64,6 +64,7 @@ class DockerComposeRun(ExitStacked):
 
         #
 
+        no_dependencies: bool = False
         no_dependency_cleanup: bool = False
 
         #
@@ -82,40 +83,6 @@ class DockerComposeRun(ExitStacked):
 
     #
 
-    @property
-    def image_tag(self) -> str:
-        pfx = 'sha256:'
-        if (image := self._cfg.image).startswith(pfx):
-            image = image[len(pfx):]
-
-        return f'{self._cfg.service}:{image}'
-
-    @cached_nullary
-    def tag_image(self) -> str:
-        image_tag = self.image_tag
-
-        subprocesses.check_call(
-            'docker',
-            'tag',
-            self._cfg.image,
-            image_tag,
-            **self._subprocess_kwargs,
-        )
-
-        def delete_tag() -> None:
-            subprocesses.check_call(
-                'docker',
-                'rmi',
-                image_tag,
-                **self._subprocess_kwargs,
-            )
-
-        self._enter_context(defer(delete_tag))  # noqa
-
-        return image_tag
-
-    #
-
     def _rewrite_compose_dct(self, in_dct: ta.Dict[str, ta.Any]) -> ta.Dict[str, ta.Any]:
         out = dict(in_dct)
 
@@ -129,29 +96,28 @@ class DockerComposeRun(ExitStacked):
         in_service: dict = in_services[self._cfg.service]
         out_services[self._cfg.service] = out_service = dict(in_service)
 
-        out_service['image'] = self.image_tag
+        out_service['image'] = self._cfg.image
 
         for k in ['build', 'platform']:
             if k in out_service:
                 del out_service[k]
 
-        out_service['links'] = [
-            f'{l}:{l}' if ':' not in l else l
-            for l in out_service.get('links', [])
-        ]
-
         #
 
-        depends_on = in_service.get('depends_on', [])
+        if not self._cfg.no_dependencies:
+            depends_on = in_service.get('depends_on', [])
 
-        for dep_service, in_dep_service_dct in list(in_services.items()):
-            if dep_service not in depends_on:
-                continue
+            for dep_service, in_dep_service_dct in list(in_services.items()):
+                if dep_service not in depends_on:
+                    continue
 
-            out_dep_service: dict = dict(in_dep_service_dct)
-            out_services[dep_service] = out_dep_service
+                out_dep_service: dict = dict(in_dep_service_dct)
+                out_services[dep_service] = out_dep_service
 
-            out_dep_service['ports'] = []
+                out_dep_service['ports'] = []
+
+        else:
+            out_service['depends_on'] = []
 
         #
 
@@ -177,22 +143,20 @@ class DockerComposeRun(ExitStacked):
 
     #
 
-    def _cleanup_dependencies(self) -> None:
-        subprocesses.check_call(
+    async def _cleanup_dependencies(self) -> None:
+        await asyncio_subprocesses.check_call(
             'docker',
             'compose',
             '-f', self.rewrite_compose_file(),
             'down',
         )
 
-    def run(self) -> None:
-        self.tag_image()
-
+    async def run(self) -> None:
         compose_file = self.rewrite_compose_file()
 
-        with contextlib.ExitStack() as es:
-            if not self._cfg.no_dependency_cleanup:
-                es.enter_context(defer(self._cleanup_dependencies))  # noqa
+        async with contextlib.AsyncExitStack() as es:
+            if not (self._cfg.no_dependencies or self._cfg.no_dependency_cleanup):
+                await es.enter_async_context(adefer(self._cleanup_dependencies))  # noqa
 
             sh_cmd = ' '.join([
                 'docker',
@@ -211,7 +175,7 @@ class DockerComposeRun(ExitStacked):
 
             run_cmd = dc.replace(self._cfg.cmd, s=sh_cmd)
 
-            run_cmd.run(
-                subprocesses.check_call,
+            await run_cmd.run(
+                asyncio_subprocesses.check_call,
                 **self._subprocess_kwargs,
             )

omdev/ci/consts.py

@@ -0,0 +1 @@
+CI_CACHE_VERSION = 1

omdev/ci/docker.py

@@ -1,5 +1,4 @@
 # ruff: noqa: UP006 UP007
-# @omlish-lite
 """
 TODO:
  - some less stupid Dockerfile hash
@@ -13,12 +12,11 @@ import shlex
 import tarfile
 import typing as ta
 
+from omlish.asyncs.asyncio.subprocesses import asyncio_subprocesses
 from omlish.lite.check import check
-from omlish.lite.contextmanagers import defer
-from omlish.subprocesses import subprocesses
+from omlish.os.temp import temp_file_context
 
 from .shell import ShellCmd
-from .utils import make_temp_file
 from .utils import sha256_str
 
 
@@ -60,8 +58,8 @@ def read_docker_tar_image_id(tar_file: str) -> str:
 ##
 
 
-def is_docker_image_present(image: str) -> bool:
-    out = subprocesses.check_output(
+async def is_docker_image_present(image: str) -> bool:
+    out = await asyncio_subprocesses.check_output(
         'docker',
         'images',
         '--format', 'json',
@@ -76,55 +74,74 @@ def is_docker_image_present(image: str) -> bool:
     return True
 
 
-def pull_docker_image(
+async def pull_docker_image(
         image: str,
 ) -> None:
-    subprocesses.check_call(
+    await asyncio_subprocesses.check_call(
         'docker',
         'pull',
         image,
     )
 
 
-def build_docker_image(
+async def build_docker_image(
         docker_file: str,
         *,
+        tag: ta.Optional[str] = None,
         cwd: ta.Optional[str] = None,
+        run_options: ta.Optional[ta.Sequence[str]] = None,
 ) -> str:
-    id_file = make_temp_file()
-    with defer(lambda: os.unlink(id_file)):
-        subprocesses.check_call(
+    with temp_file_context() as id_file:
+        await asyncio_subprocesses.check_call(
             'docker',
             'build',
             '-f', os.path.abspath(docker_file),
             '--iidfile', id_file,
-            '--squash',
+            *(['--tag', tag] if tag is not None else []),
+            *(run_options or []),
             '.',
             **(dict(cwd=cwd) if cwd is not None else {}),
         )
 
-        with open(id_file) as f:
+        with open(id_file) as f:  # noqa
             image_id = check.single(f.read().strip().splitlines()).strip()
 
     return image_id
 
 
+async def tag_docker_image(image: str, tag: str) -> None:
+    await asyncio_subprocesses.check_call(
+        'docker',
+        'tag',
+        image,
+        tag,
+    )
+
+
+async def delete_docker_tag(tag: str) -> None:
+    await asyncio_subprocesses.check_call(
+        'docker',
+        'rmi',
+        tag,
+    )
+
+
 ##
 
 
-def save_docker_tar_cmd(
+async def save_docker_tar_cmd(
         image: str,
         output_cmd: ShellCmd,
 ) -> None:
     cmd = dc.replace(output_cmd, s=f'docker save {image} | {output_cmd.s}')
-    cmd.run(subprocesses.check_call)
+    await cmd.run(asyncio_subprocesses.check_call)
 
 
-def save_docker_tar(
+async def save_docker_tar(
         image: str,
         tar_file: str,
 ) -> None:
-    return save_docker_tar_cmd(
+    return await save_docker_tar_cmd(
         image,
         ShellCmd(f'cat > {shlex.quote(tar_file)}'),
     )
@@ -133,19 +150,19 @@ def save_docker_tar(
 #
 
 
-def load_docker_tar_cmd(
+async def load_docker_tar_cmd(
         input_cmd: ShellCmd,
 ) -> str:
     cmd = dc.replace(input_cmd, s=f'{input_cmd.s} | docker load')
 
-    out = cmd.run(subprocesses.check_output).decode()
+    out = (await cmd.run(asyncio_subprocesses.check_output)).decode()
 
     line = check.single(out.strip().splitlines())
     loaded = line.partition(':')[2].strip()
     return loaded
 
 
-def load_docker_tar(
+async def load_docker_tar(
         tar_file: str,
 ) -> str:
-    return load_docker_tar_cmd(ShellCmd(f'cat {shlex.quote(tar_file)}'))
+    return await load_docker_tar_cmd(ShellCmd(f'cat {shlex.quote(tar_file)}'))

omdev/ci/github/{cacheapi.py → api.py}

@@ -1,5 +1,4 @@
 # ruff: noqa: UP006 UP007
-# @omlish-lite
 """
 export FILE_SIZE=$(stat --format="%s" $FILE)
 
@@ -93,7 +92,7 @@ class GithubCacheServiceV1:
     @dc.dataclass(frozen=True)
     class ReserveCacheRequest:
         key: str
-        cache_size: ta.Optional[int]
+        cache_size: ta.Optional[int] = None
         version: ta.Optional[str] = None
 
     @dc.dataclass(frozen=True)

omdev/ci/github/bootstrap.py

@@ -1,5 +1,4 @@
 # ruff: noqa: UP006 UP007
-# @omlish-lite
 """
 sudo rm -rf \
     /usr/local/.ghcup \
@@ -9,3 +8,11 @@ sudo rm -rf \
 /opt/hostedtoolcache    8.0G, 14843980 files
 /usr/local/lib/android  6.4G, 17251667 files
 """
+from .env import register_github_env_var
+
+
+GITHUB_ACTIONS_ENV_VAR = register_github_env_var('GITHUB_ACTIONS')
+
+
+def is_in_github_actions() -> bool:
+    return GITHUB_ACTIONS_ENV_VAR() is not None