ruyi 0.39.0__py3-none-any.whl

ruyi/log/__init__.py

@@ -0,0 +1,272 @@
+import abc
+import datetime
+from functools import cached_property
+import io
+import sys
+import time
+from typing import Any, TextIO, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # too heavy at package import time
+    from rich.console import Console, RenderableType
+    from rich.text import Text
+
+from ..utils.global_mode import ProvidesGlobalMode
+from ..utils.porcelain import PorcelainEntity, PorcelainEntityType, PorcelainOutput
+
+
+class PorcelainLog(PorcelainEntity):
+    t: int
+    """Timestamp of the message line in microseconds"""
+
+    lvl: str
+    """Log level of the message line (one of D, F, I, W)"""
+
+    msg: str
+    """Message content"""
+
+
+def log_time_formatter(x: datetime.datetime) -> "Text":
+    from rich.text import Text
+
+    return Text(f"debug: [{x.isoformat()}]")
+
+
+def _make_porcelain_log(
+    t: int,
+    lvl: str,
+    message: "RenderableType",
+    sep: str,
+    *objects: Any,
+) -> PorcelainLog:
+    from rich.console import Console
+
+    with io.StringIO() as buf:
+        tmp_console = Console(file=buf)
+        tmp_console.print(message, *objects, sep=sep, end="")
+        return {
+            "ty": PorcelainEntityType.LogV1,
+            "t": t,
+            "lvl": lvl,
+            "msg": buf.getvalue(),
+        }
+
+
+class RuyiLogger(metaclass=abc.ABCMeta):
+    def __init__(self) -> None:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def log_console(self) -> "Console":
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def stdout(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def D(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        _stack_offset_delta: int = 0,
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def F(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def I(  # noqa: E743 # the name intentionally mimics Android logging for brevity
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def W(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        raise NotImplementedError
+
+
+class RuyiConsoleLogger(RuyiLogger):
+    def __init__(
+        self,
+        gm: ProvidesGlobalMode,
+        stdout: TextIO = sys.stdout,
+        stderr: TextIO = sys.stderr,
+    ) -> None:
+        super().__init__()
+
+        self._gm = gm
+        self._stdout = stdout
+        self._stderr = stderr
+
+    @cached_property
+    def _stdout_console(self) -> "Console":
+        from rich.console import Console
+
+        return Console(
+            file=self._stdout,
+            highlight=False,
+            soft_wrap=True,
+        )
+
+    @cached_property
+    def _debug_console(self) -> "Console":
+        from rich.console import Console
+
+        return Console(
+            file=self._stderr,
+            log_time_format=log_time_formatter,
+            soft_wrap=True,
+        )
+
+    @cached_property
+    def _log_console(self) -> "Console":
+        from rich.console import Console
+
+        return Console(
+            file=self._stderr,
+            highlight=False,
+            soft_wrap=True,
+        )
+
+    @cached_property
+    def _porcelain_sink(self) -> PorcelainOutput:
+        return PorcelainOutput(self._stderr.buffer)
+
+    @property
+    def log_console(self) -> "Console":
+        return self._log_console
+
+    def _emit_porcelain_log(
+        self,
+        lvl: str,
+        message: "RenderableType",
+        sep: str = " ",
+        *objects: Any,
+    ) -> None:
+        t = int(time.time() * 1000000)
+        obj = _make_porcelain_log(t, lvl, message, sep, *objects)
+        self._porcelain_sink.emit(obj)
+
+    def stdout(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        return self._stdout_console.print(message, *objects, sep=sep, end=end)
+
+    def D(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        _stack_offset_delta: int = 0,
+    ) -> None:
+        if not self._gm.is_debug:
+            return
+
+        if self._gm.is_porcelain:
+            return self._emit_porcelain_log("D", message, sep, *objects)
+
+        return self._debug_console.log(
+            message,
+            *objects,
+            sep=sep,
+            end=end,
+            _stack_offset=2 + _stack_offset_delta,
+        )
+
+    def F(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        if self._gm.is_porcelain:
+            return self._emit_porcelain_log("F", message, sep, *objects)
+
+        return self.log_console.print(
+            f"[bold red]fatal error:[/] {message}",
+            *objects,
+            sep=sep,
+            end=end,
+        )
+
+    def I(  # noqa: E743 # the name intentionally mimics Android logging for brevity
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        if self._gm.is_porcelain:
+            return self._emit_porcelain_log("I", message, sep, *objects)
+
+        return self.log_console.print(
+            f"[bold green]info:[/] {message}",
+            *objects,
+            sep=sep,
+            end=end,
+        )
+
+    def W(
+        self,
+        message: "RenderableType",
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        if self._gm.is_porcelain:
+            return self._emit_porcelain_log("W", message, sep, *objects)
+
+        return self.log_console.print(
+            f"[bold yellow]warn:[/] {message}",
+            *objects,
+            sep=sep,
+            end=end,
+        )
+
+
+def humanize_list(
+    obj: list[str] | set[str],
+    *,
+    sep: str = ", ",
+    item_color: str | None = None,
+    empty_prompt: str = "(none)",
+) -> str:
+    if not obj:
+        return empty_prompt
+    if item_color is None:
+        return sep.join(obj)
+    return sep.join(f"[{item_color}]{x}[/]" for x in obj)

ruyi/mux/.gitignore

@@ -0,0 +1 @@
+!venv

ruyi/mux/runtime.py

@@ -0,0 +1,213 @@
+import atexit
+import os
+import re
+import shlex
+from typing import Final, List, NoReturn
+
+from ..config import GlobalConfig
+from ..utils.global_mode import ProvidesGlobalMode
+from .venv_cfg import RuyiVenvConfig
+
+
+def _run_exit_handlers_and_execv(
+    path: str,
+    argv: list[str],
+) -> NoReturn:
+    # run all exit handlers before execv
+    # crucially this includes our telemetry handler so we don't lose telemetry
+    # events in mux mode
+    atexit._run_exitfuncs()
+    os.execv(path, argv)
+
+
+def mux_main(
+    gm: ProvidesGlobalMode,
+    gc: GlobalConfig,
+    argv: List[str],
+) -> int | NoReturn:
+    basename = os.path.basename(gm.argv0)
+    logger = gc.logger
+    logger.D(f"mux mode: argv = {argv}, basename = {basename}")
+
+    vcfg = RuyiVenvConfig.load_from_venv(gm, logger)
+    if vcfg is None:
+        logger.F("the Ruyi toolchain mux is not configured")
+        logger.I("check out `ruyi venv` for making a virtual environment")
+        return 1
+
+    direct_symlink_target = resolve_direct_symlink_target(gm.argv0, vcfg)
+    if direct_symlink_target is not None:
+        logger.D(
+            f"detected direct symlink target: {direct_symlink_target}, overriding basename"
+        )
+        basename = direct_symlink_target
+
+    if basename == "ruyi-qemu":
+        return mux_qemu_main(gc, vcfg, argv)
+
+    # match the basename with one of the configured target tuples
+    target_tuple: str | None = None
+    binpath: str | None = None
+    toolchain_sysroot: str | None = None
+    toolchain_flags: str | None = None
+    gcc_install_dir: str | None = None
+
+    # prefer v1+ cached info which is lossless
+    if md := vcfg.resolve_cmd_metadata_with_cache(basename):
+        target_tuple = md["target_tuple"]
+        binpath = md["dest"]
+        if target_tuple:
+            tgt_data = vcfg.targets.get(target_tuple)
+            if tgt_data is None:
+                logger.F(
+                    f"internal error: no target data for tuple [yellow]{target_tuple}[/]"
+                )
+                return 1
+            toolchain_sysroot = tgt_data.get("toolchain_sysroot")
+            toolchain_flags = tgt_data.get("toolchain_flags")
+            gcc_install_dir = tgt_data.get("gcc_install_dir")
+    else:
+        toolchain_bindir: str | None = None
+        for tgt_tuple, tgt_data in vcfg.targets.items():
+            if not basename.startswith(f"{tgt_tuple}-"):
+                continue
+
+            logger.D(f"matched target '{tgt_tuple}', data {tgt_data}")
+            target_tuple = tgt_tuple
+            toolchain_bindir = tgt_data["toolchain_bindir"]
+            toolchain_sysroot = tgt_data.get("toolchain_sysroot")
+            toolchain_flags = tgt_data.get("toolchain_flags")
+            gcc_install_dir = tgt_data.get("gcc_install_dir")
+            break
+
+        if toolchain_bindir is None:
+            # should not happen
+            logger.F(
+                f"internal error: no bindir configured for target [yellow]{target_tuple}[/]"
+            )
+            return 1
+
+        binpath = os.path.join(toolchain_bindir, basename)
+
+    if target_tuple is None:
+        logger.F(f"no configured target found for command [yellow]{basename}[/]")
+        return 1
+
+    logger.D(f"binary to exec: {binpath}")
+
+    argv_to_insert: list[str] | None = None
+    if is_proxying_to_cc(basename):
+        logger.D(f"{basename} is considered a CC")
+
+        argv_to_insert = []
+
+        if is_proxying_to_clang(basename):
+            logger.D(f"adding target for clang: {target_tuple}")
+            argv_to_insert.append(f"--target={target_tuple}")
+            if gcc_install_dir is not None:
+                logger.D(f"informing clang of GCC install dir: {gcc_install_dir}")
+                argv_to_insert.append(f"--gcc-install-dir={gcc_install_dir}")
+
+        if toolchain_flags is not None:
+            argv_to_insert.extend(shlex.split(toolchain_flags))
+            logger.D(f"parsed toolchain flags: {argv_to_insert}")
+
+        if toolchain_sysroot is not None:
+            logger.D(f"adding sysroot: {toolchain_sysroot}")
+            argv_to_insert.extend(("--sysroot", toolchain_sysroot))
+
+    new_argv = [binpath]
+    if argv_to_insert:
+        new_argv.extend(argv_to_insert)
+    if len(argv) > 1:
+        new_argv.extend(argv[1:])
+
+    ensure_venv_in_path(vcfg)
+
+    logger.D(f"exec-ing with argv {new_argv}")
+    return _run_exit_handlers_and_execv(binpath, new_argv)
+
+
+# TODO: dedup with venv provision logic (into a command name parser)
+CC_ARGV0_RE: Final = re.compile(
+    r"(?:^|-)(?:g?cc|c\+\+|g\+\+|cpp|clang|clang\+\+|clang-cl|clang-cpp)(?:-[0-9.]+)?$"
+)
+
+
+def resolve_direct_symlink_target(argv0: str, vcfg: RuyiVenvConfig) -> str | None:
+    direct_symlink_target = resolve_argv0_symlink(argv0, vcfg)
+    if direct_symlink_target is not None and os.path.sep in direct_symlink_target:
+        # we're not designed to handle such indirections
+        return None
+    return direct_symlink_target
+
+
+def resolve_argv0_symlink(argv0: str, vcfg: RuyiVenvConfig) -> str | None:
+    if os.path.sep in argv0:
+        # argv[0] contains path information that we can just use
+        try:
+            return os.readlink(argv0)
+        except OSError:
+            # argv[0] is not a symlink
+            return None
+
+    # argv[0] is bare command name, in which case we expect venv root to
+    # be available, so we can just check f'{venv_root}/bin/{argv[0]}'.
+    # we're guaranteed a venv_root because of the vcfg init logic.
+    try:
+        return os.readlink(vcfg.venv_root / "bin" / argv0)
+    except OSError:
+        return None
+
+
+def is_proxying_to_cc(argv0: str) -> bool:
+    return CC_ARGV0_RE.search(argv0) is not None
+
+
+def is_proxying_to_clang(basename: str) -> bool:
+    return "clang" in basename
+
+
+def mux_qemu_main(
+    gc: GlobalConfig,
+    vcfg: RuyiVenvConfig,
+    argv: List[str],
+) -> int | NoReturn:
+    logger = gc.logger
+    binpath = vcfg.qemu_bin
+    if binpath is None:
+        logger.F("this virtual environment has no QEMU-like emulator configured")
+        return 1
+
+    if vcfg.profile_emu_env is not None:
+        logger.D(f"seeding QEMU environment with {vcfg.profile_emu_env}")
+        for k, v in vcfg.profile_emu_env.items():
+            os.environ[k] = v
+
+    logger.D(f"QEMU binary to exec: {binpath}")
+
+    new_argv = [binpath]
+    if len(argv) > 1:
+        new_argv.extend(argv[1:])
+
+    logger.D(f"exec-ing with argv {new_argv}")
+    return _run_exit_handlers_and_execv(binpath, new_argv)
+
+
+def ensure_venv_in_path(vcfg: RuyiVenvConfig) -> None:
+    venv_root = vcfg.venv_root
+    venv_bindir = venv_root / "bin"
+    venv_bindir = venv_bindir.resolve()
+
+    orig_path = os.environ.get("PATH", "")
+    for p in orig_path.split(os.pathsep):
+        try:
+            if os.path.samefile(p, venv_bindir):
+                # TODO: what if our bindir actually comes after the system ones?
+                return
+        except FileNotFoundError:
+            # maybe the PATH entry is stale
+            continue
+
+    # we're not in PATH, so prepend the bindir to PATH
+    os.environ["PATH"] = f"{venv_bindir}:{orig_path}" if orig_path else str(venv_bindir)

ruyi/mux/venv/__init__.py

@@ -0,0 +1,12 @@
+from os import PathLike
+from typing import Any, TypedDict
+
+
+class ConfiguredTargetTuple(TypedDict):
+    target: str
+    toolchain_root: PathLike[Any]
+    toolchain_sysroot: PathLike[Any] | None
+    toolchain_flags: str
+    binutils_flavor: str
+    cc_flavor: str
+    gcc_install_dir: PathLike[Any] | None

ruyi/mux/venv/emulator_cfg.py

@@ -0,0 +1,41 @@
+import os
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+from ...ruyipkg.pkg_manifest import EmulatorProgDecl
+from ...ruyipkg.profile import ProfileProxy
+
+
+class ResolvedEmulatorProg:
+    def __init__(
+        self,
+        display_name: str,
+        binfmt_misc_str: str | None,
+        env: dict[str, str] | None,
+    ) -> None:
+        self.display_name = display_name
+        self.binfmt_misc_str = binfmt_misc_str
+        self.env = env
+
+    @classmethod
+    def new(
+        cls,
+        prog: EmulatorProgDecl,
+        prog_install_root: os.PathLike[Any],
+        profile: ProfileProxy,
+        sysroot: os.PathLike[Any] | None,
+    ) -> "Self":
+        return cls(
+            get_display_name_for_emulator(prog, prog_install_root),
+            prog.get_binfmt_misc_str(prog_install_root),
+            profile.get_env_config_for_emu_flavor(prog.flavor, sysroot),
+        )
+
+
+def get_display_name_for_emulator(
+    prog: EmulatorProgDecl,
+    prog_install_root: os.PathLike[Any],
+) -> str:
+    return f"{os.path.basename(prog.relative_path)} from {prog_install_root}"