dycw-actions 0.6.4__py3-none-any.whl → 0.7.7__py3-none-any.whl

actions/register_gitea_runner/constants.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import actions.constants
+from actions.constants import PATH_ACTIONS
+
+REGISTER_GITEA_RUNNER_SUB_CMD = "register-gitea-runner"
+REGISTER_GITEA_RUNNER_DOCSTRING = "Register a Gitea runner"
+
+
+PATH_CACHE = actions.constants.PATH_CACHE / REGISTER_GITEA_RUNNER_SUB_CMD
+PATH_CONFIGS = PATH_ACTIONS / "register_gitea_runner/configs"
+PATH_WAIT_FOR_IT = PATH_CACHE / "wait-for-it.sh"
+URL_WAIT_FOR_IT = "https://raw.githubusercontent.com/vishnubob/wait-for-it/refs/heads/master/wait-for-it.sh"
+
+
+__all__ = [
+    "PATH_CACHE",
+    "PATH_CONFIGS",
+    "PATH_WAIT_FOR_IT",
+    "REGISTER_GITEA_RUNNER_DOCSTRING",
+    "REGISTER_GITEA_RUNNER_SUB_CMD",
+    "URL_WAIT_FOR_IT",
+]

actions/register_gitea_runner/lib.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+from pathlib import Path
+from re import search
+from string import Template
+from typing import TYPE_CHECKING
+
+from requests import get
+from utilities.atomicwrites import writer
+from utilities.subprocess import chmod, run, ssh
+from utilities.text import strip_and_dedent
+
+from actions import __version__
+from actions.logging import LOGGER
+from actions.register_gitea_runner.constants import (
+    PATH_CACHE,
+    PATH_CONFIGS,
+    PATH_WAIT_FOR_IT,
+    URL_WAIT_FOR_IT,
+)
+from actions.register_gitea_runner.settings import SETTINGS
+
+if TYPE_CHECKING:
+    from utilities.types import PathLike
+
+
+def register_gitea_runner(
+    *,
+    ssh_user: str = SETTINGS.ssh_user,
+    ssh_host: str = SETTINGS.ssh_host,
+    gitea_container_user: str = SETTINGS.gitea_container_user,
+    gitea_container_name: str = SETTINGS.gitea_container_name,
+    runner_certificate: PathLike = SETTINGS.runner_certificate,
+    runner_capacity: int = SETTINGS.runner_capacity,
+    runner_container_name: str = SETTINGS.runner_container_name,
+    gitea_host: str = SETTINGS.gitea_host,
+    gitea_port: int = SETTINGS.gitea_port,
+    runner_instance_name: str = SETTINGS.runner_instance_name,
+) -> None:
+    """Register against a remote instance of Gitea."""
+    LOGGER.info(
+        strip_and_dedent("""
+            Running '%s' (version %s) with settings:
+             - ssh_user              = %s
+             - ssh_host              = %s
+             - gitea_container_user  = %s
+             - gitea_container_name  = %s
+             - runner_certificate    = %s
+             - runner_capacity       = %d
+             - runner_container_name = %s
+             - gitea_host            = %s
+             - gitea_port            = %d
+             - runner_instance_name  = %s
+        """),
+        register_gitea_runner.__name__,
+        __version__,
+        ssh_user,
+        ssh_host,
+        gitea_container_user,
+        gitea_container_name,
+        runner_certificate,
+        runner_capacity,
+        runner_container_name,
+        gitea_host,
+        gitea_port,
+        runner_instance_name,
+    )
+    token = ssh(
+        ssh_user,
+        ssh_host,
+        *_docker_exec_generate(user=gitea_container_user, name=gitea_container_name),
+        return_=True,
+    )
+    _start_runner(
+        token,
+        runner_certificate=runner_certificate,
+        runner_capacity=runner_capacity,
+        runner_container_name=runner_container_name,
+        gitea_host=gitea_host,
+        gitea_port=gitea_port,
+        runner_instance_name=runner_instance_name,
+    )
+
+
+def register_against_local(
+    *,
+    gitea_container_user: str = SETTINGS.gitea_container_user,
+    gitea_container_name: str = SETTINGS.gitea_container_name,
+    runner_certificate: PathLike = SETTINGS.runner_certificate,
+    runner_capacity: int = SETTINGS.runner_capacity,
+    runner_container_name: str = SETTINGS.runner_container_name,
+    gitea_host: str = SETTINGS.gitea_host,
+    gitea_port: int = SETTINGS.gitea_port,
+    runner_instance_name: str = SETTINGS.runner_instance_name,
+) -> None:
+    """Register against a local instance of Gitea."""
+    LOGGER.info("Registering against %s:%d...", gitea_host, gitea_port)
+    token = run(
+        *_docker_exec_generate(user=gitea_container_user, name=gitea_container_name),
+        return_=True,
+        logger=LOGGER,
+    )
+    _start_runner(
+        token,
+        runner_certificate=runner_certificate,
+        runner_capacity=runner_capacity,
+        runner_container_name=runner_container_name,
+        gitea_host=gitea_host,
+        gitea_port=gitea_port,
+        runner_instance_name=runner_instance_name,
+    )
+
+
+def _check_certificate(*, certificate: PathLike = SETTINGS.runner_certificate) -> None:
+    if not Path(certificate).is_file():
+        msg = f"Missing certificate {certificate!r}"
+        raise FileNotFoundError(msg)
+
+
+def _check_token(text: str, /) -> None:
+    if not search(r"^[A-Za-z0-9]{40}$", text):
+        msg = f"Invalid token; got {text!r}"
+        raise ValueError(msg)
+
+
+def _docker_exec_generate(
+    *,
+    user: str = SETTINGS.gitea_container_user,
+    name: str = SETTINGS.gitea_container_name,
+) -> list[str]:
+    return [
+        "docker",
+        "exec",
+        "--user",
+        user,
+        name,
+        "gitea",
+        "actions",
+        "generate-runner-token",
+    ]
+
+
+def _docker_run_act_runner_args(
+    token: str,
+    /,
+    *,
+    host: str = SETTINGS.gitea_host,
+    port: int = SETTINGS.gitea_port,
+    runner_certificate: PathLike = SETTINGS.runner_certificate,
+    instance_name: str = SETTINGS.runner_instance_name,
+    container_name: str = SETTINGS.runner_container_name,
+) -> list[str]:
+    config_host = _get_config_path(token)
+    config_cont = "/config.yml"
+    entrypoint_host = _get_entrypoint_path(host=host, port=port)
+    entrypoint_cont = Path("/usr/local/bin/entrypoint.sh")
+    return [
+        "docker",
+        "run",
+        "--detach",
+        "--entrypoint",
+        str(entrypoint_cont),
+        "--env",
+        f"CONFIG_FILE={config_cont}",
+        "--env",
+        f"GITEA_INSTANCE_URL=https://{host}:{port}",
+        "--env",
+        f"GITEA_RUNNER_NAME={instance_name}",
+        "--env",
+        f"GITEA_RUNNER_REGISTRATION_TOKEN={token}",
+        "--name",
+        container_name,
+        "--volume",
+        "/var/run/docker.sock:/var/run/docker.sock",
+        "--volume",
+        f"{PATH_WAIT_FOR_IT}:/usr/local/bin/wait-for-it.sh:ro",
+        "--volume",
+        f"{Path.cwd()}/data:/data",
+        "--volume",
+        f"{config_host}:{config_cont}:ro",
+        "--volume",
+        f"{entrypoint_host}:{entrypoint_cont}:ro",
+        "--volume",
+        f"{runner_certificate}:/etc/ssl/certs/runner-certificate.pem:ro",
+        "gitea/act_runner",
+    ]
+
+
+def _docker_stop_runner_args(
+    *, name: str = SETTINGS.runner_container_name
+) -> list[str]:
+    return ["docker", "rm", "--force", name]
+
+
+def _get_config_contents(
+    *,
+    capacity: int = SETTINGS.runner_capacity,
+    certificate: PathLike = SETTINGS.runner_certificate,
+) -> str:
+    src = PATH_CONFIGS / "config.yml"
+    return Template(src.read_text()).safe_substitute(
+        CAPACITY=capacity, CERTIFICATE=certificate
+    )
+
+
+def _get_config_path(token: str, /) -> Path:
+    return PATH_CACHE / f"configs/{token}.yml"
+
+
+def _get_entrypoint_contents(
+    *, host: str = SETTINGS.gitea_host, port: int = SETTINGS.gitea_port
+) -> str:
+    src = PATH_CONFIGS / "entrypoint.sh"
+    return Template(src.read_text()).safe_substitute(GITEA_HOST=host, GITEA_PORT=port)
+
+
+def _get_entrypoint_path(
+    *, host: str = SETTINGS.gitea_host, port: int = SETTINGS.gitea_port
+) -> Path:
+    return PATH_CACHE / f"entrypoints/{host}-{port}"
+
+
+def _start_runner(
+    token: str,
+    /,
+    *,
+    runner_certificate: PathLike = SETTINGS.runner_certificate,
+    runner_capacity: int = SETTINGS.runner_capacity,
+    runner_container_name: str = SETTINGS.runner_container_name,
+    gitea_host: str = SETTINGS.gitea_host,
+    gitea_port: int = SETTINGS.gitea_port,
+    runner_instance_name: str = SETTINGS.runner_instance_name,
+) -> None:
+    _check_certificate(certificate=runner_certificate)
+    _check_token(token)
+    _write_config(token, capacity=runner_capacity, certificate=runner_certificate)
+    _write_entrypoint(host=gitea_host, port=gitea_port)
+    _write_wait_for_it()
+    run(
+        *_docker_stop_runner_args(name=runner_container_name), print=True, logger=LOGGER
+    )
+    run(
+        *_docker_run_act_runner_args(
+            token,
+            host=gitea_host,
+            port=gitea_port,
+            runner_certificate=runner_certificate,
+            instance_name=runner_instance_name,
+            container_name=runner_container_name,
+        ),
+        print=True,
+        logger=LOGGER,
+    )
+
+
+def _write_config(
+    token: str,
+    /,
+    *,
+    capacity: int = SETTINGS.runner_capacity,
+    certificate: PathLike = SETTINGS.runner_certificate,
+) -> None:
+    dest = _get_config_path(token)
+    text = _get_config_contents(capacity=capacity, certificate=certificate)
+    with writer(dest, overwrite=True) as temp:
+        _ = temp.write_text(text)
+
+
+def _write_entrypoint(
+    *, host: str = SETTINGS.gitea_host, port: int = SETTINGS.gitea_port
+) -> None:
+    dest = _get_entrypoint_path(host=host, port=port)
+    text = _get_entrypoint_contents(host=host, port=port)
+    with writer(dest, overwrite=True) as temp:
+        _ = temp.write_text(text)
+        chmod(temp, "u=rwx,g=rx,o=rx")
+
+
+def _write_wait_for_it() -> None:
+    if PATH_WAIT_FOR_IT.is_file():
+        return
+    with writer(PATH_WAIT_FOR_IT, overwrite=True) as temp:
+        resp = get(URL_WAIT_FOR_IT, timeout=60)
+        resp.raise_for_status()
+        _ = temp.write_bytes(resp.content)
+        chmod(temp, "u=rwx,g=rx,o=rx")
+
+
+__all__ = ["register_against_local"]

actions/register_gitea_runner/settings.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from typed_settings import load_settings, option, settings
+from utilities.getpass import USER
+from utilities.socket import HOSTNAME
+
+from actions.utilities import LOADER
+
+
+@settings
+class Settings:
+    ssh_user: str = option(default="user", help="SSH username")
+    ssh_host: str = option(default="gitea", help="SSH host")
+    gitea_container_user: str = option(default="git", help="Gitea container user name")
+    gitea_container_name: str = option(default="gitea", help="Gitea container name")
+    gitea_host: str = option(default="gitea", help="Gitea host")
+    gitea_port: int = option(default=3000, help="Gitea port")
+    runner_capacity: int = option(default=1, help="Runner capacity")
+    runner_instance_name: str = option(
+        default=f"{USER}--{HOSTNAME}", help="Runner instance name"
+    )
+    runner_certificate: Path = option(
+        default=Path("root.pem"), help="Runner root certificate"
+    )
+    runner_container_name: str = option(default="runner", help="Runner container name")
+
+
+SETTINGS = load_settings(Settings, [LOADER])
+
+
+__all__ = ["SETTINGS", "Settings"]

actions/run_hooks/cli.py

@@ -1,33 +1,21 @@
 from __future__ import annotations
 
-from rich.pretty import pretty_repr
 from typed_settings import click_options
 from utilities.logging import basic_config
 from utilities.os import is_pytest
-from utilities.text import strip_and_dedent
 
-from actions import __version__
 from actions.logging import LOGGER
 from actions.run_hooks.lib import run_hooks
 from actions.run_hooks.settings import Settings
 from actions.utilities import LOADER
 
 
-@click_options(Settings, [LOADER], show_envvars_in_help=True, argname="hooks")
-def run_hooks_sub_cmd(*, hooks: Settings) -> None:
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def run_hooks_sub_cmd(settings: Settings, /) -> None:
     if is_pytest():
         return
     basic_config(obj=LOGGER)
-    LOGGER.info(
-        strip_and_dedent("""
-            Running '%s' (version %s) with settings:
-            %s
-        """),
-        run_hooks.__name__,
-        __version__,
-        pretty_repr(hooks),
-    )
-    run_hooks(repos=hooks.repos, hooks=hooks.hooks, sleep=hooks.sleep)
+    run_hooks(repos=settings.repos, hooks=settings.hooks, sleep=settings.sleep)
 
 
 __all__ = ["run_hooks_sub_cmd"]

actions/run_hooks/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+RUN_HOOKS_DOCSTRING = "Run 'pre-commit' hooks"
+RUN_HOOKS_SUB_CMD = "run-hooks"
+
+
+__all__ = ["RUN_HOOKS_DOCSTRING", "RUN_HOOKS_SUB_CMD"]

actions/run_hooks/lib.py

@@ -14,7 +14,7 @@ from yaml import safe_load
 from actions import __version__
 from actions.logging import LOGGER
 from actions.run_hooks.settings import SETTINGS
-from actions.utilities import log_run
+from actions.utilities import logged_run
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -77,7 +77,7 @@ def _yield_repo_hooks(repo: dict[str, Any], /) -> Iterator[str]:
 def _run_hook(hook: str, /, *, sleep: int = SETTINGS.sleep) -> bool:
     LOGGER.info("Running '%s'...", hook)
     try:
-        log_run("pre-commit", "run", "--verbose", "--all-files", hook, print=True)
+        logged_run("pre-commit", "run", "--verbose", "--all-files", hook, print=True)
     except CalledProcessError:
         is_success = False
     else:

actions/setup_cronjob/cli.py

@@ -1,12 +1,9 @@
 from __future__ import annotations
 
-from rich.pretty import pretty_repr
 from typed_settings import click_options
 from utilities.logging import basic_config
 from utilities.os import is_pytest
-from utilities.text import strip_and_dedent
 
-from actions import __version__
 from actions.logging import LOGGER
 from actions.setup_cronjob.lib import setup_cronjob
 from actions.setup_cronjob.settings import Settings
@@ -18,15 +15,6 @@ def setup_cronjob_sub_cmd(settings: Settings, /) -> None:
     if is_pytest():
         return
     basic_config(obj=LOGGER)
-    LOGGER.info(
-        strip_and_dedent("""
-            Running '%s' (version %s) with settings:
-            %s
-        """),
-        setup_cronjob.__name__,
-        __version__,
-        pretty_repr(settings),
-    )
     setup_cronjob(
         name=settings.name,
         prepend_path=settings.prepend_path,

actions/setup_cronjob/constants.py

@@ -5,4 +5,8 @@ from actions.constants import PATH_ACTIONS
 PATH_CONFIGS = PATH_ACTIONS / "setup_cronjob/configs"
 
 
-__all__ = ["PATH_CONFIGS"]
+SETUP_CRONJOB_SUB_CMD = "setup-cronjob"
+SETUP_CRONJOB_DOCSTRING = "Setup a cronjob"
+
+
+__all__ = ["PATH_CONFIGS", "SETUP_CRONJOB_DOCSTRING", "SETUP_CRONJOB_SUB_CMD"]

actions/tag_commit/cli.py

@@ -1,38 +1,26 @@
 from __future__ import annotations
 
-from rich.pretty import pretty_repr
 from typed_settings import click_options
 from utilities.logging import basic_config
 from utilities.os import is_pytest
-from utilities.text import strip_and_dedent
 
-from actions import __version__
 from actions.logging import LOGGER
 from actions.tag_commit.lib import tag_commit
 from actions.tag_commit.settings import Settings
 from actions.utilities import LOADER
 
 
-@click_options(Settings, [LOADER], show_envvars_in_help=True, argname="tag")
-def tag_commit_sub_cmd(*, tag: Settings) -> None:
+@click_options(Settings, [LOADER], show_envvars_in_help=True)
+def tag_commit_sub_cmd(settings: Settings, /) -> None:
     if is_pytest():
         return
     basic_config(obj=LOGGER)
-    LOGGER.info(
-        strip_and_dedent("""
-            Running '%s' (version %s) with settings:
-            %s
-        """),
-        tag_commit.__name__,
-        __version__,
-        pretty_repr(tag),
-    )
     tag_commit(
-        user_name=tag.user_name,
-        user_email=tag.user_email,
-        major_minor=tag.major_minor,
-        major=tag.major,
-        latest=tag.latest,
+        user_name=settings.user_name,
+        user_email=settings.user_email,
+        major_minor=settings.major_minor,
+        major=settings.major,
+        latest=settings.latest,
     )
 
 

actions/tag_commit/constants.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+TAG_COMMIT_DOCSTRING = "Tag the latest commit"
+TAG_COMMIT_SUB_CMD = "tag-commit"
+
+
+__all__ = ["TAG_COMMIT_DOCSTRING", "TAG_COMMIT_SUB_CMD"]

actions/tag_commit/lib.py

@@ -9,7 +9,7 @@ from utilities.version import parse_version
 from actions import __version__
 from actions.logging import LOGGER
 from actions.tag_commit.settings import SETTINGS
-from actions.utilities import log_run
+from actions.utilities import logged_run
 
 
 def tag_commit(
@@ -37,10 +37,10 @@ def tag_commit(
         major,
         latest,
     )
-    log_run("git", "config", "--global", "user.name", user_name)
-    log_run("git", "config", "--global", "user.email", user_email)
+    logged_run("git", "config", "--global", "user.name", user_name)
+    logged_run("git", "config", "--global", "user.email", user_email)
     version = parse_version(
-        log_run("bump-my-version", "show", "current_version", return_=True)
+        logged_run("bump-my-version", "show", "current_version", return_=True)
     )
     _tag(str(version))
     if major_minor:
@@ -53,11 +53,11 @@ def tag_commit(
 
 def _tag(version: str, /) -> None:
     with suppress(CalledProcessError):
-        log_run("git", "tag", "--delete", version)
+        logged_run("git", "tag", "--delete", version)
     with suppress(CalledProcessError):
-        log_run("git", "push", "--delete", "origin", version)
-    log_run("git", "tag", "-a", version, "HEAD", "-m", version)
-    log_run("git", "push", "--tags", "--force", "--set-upstream", "origin")
+        logged_run("git", "push", "--delete", "origin", version)
+    logged_run("git", "tag", "-a", version, "HEAD", "-m", version)
+    logged_run("git", "push", "--tags", "--force", "--set-upstream", "origin")
 
 
 __all__ = ["tag_commit"]

actions/types.py

@@ -1,18 +1,21 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from tomlkit.items import Array, Table
 from typed_settings import Secret
+from utilities.packaging import Requirement
 
 if TYPE_CHECKING:
     from tomlkit.container import Container
 
 
+type FuncRequirement = Callable[[Requirement], Requirement]
 type HasAppend = Array | list[Any]
 type HasSetDefault = Container | StrDict | Table
 type SecretLike = str | Secret[str]
 type StrDict = dict[str, Any]
 
 
-__all__ = ["HasAppend", "HasSetDefault", "SecretLike", "StrDict"]
+__all__ = ["FuncRequirement", "HasAppend", "HasSetDefault", "SecretLike", "StrDict"]