@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/git_orchestrator/src/vds_git_orchestrator/logging_config.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+from typing import Any
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+class JsonFormatter(logging.Formatter):
+    """
+    Minimal JSON formatter suitable for async workloads.
+    """
+
+    def format(self, record: logging.LogRecord) -> str:  # pragma: no cover - simple wrapper
+        base: dict[str, Any] = {
+            "level": record.levelname,
+            "message": record.getMessage(),
+            "logger": record.name,
+        }
+        if record.exc_info:
+            base["exc_info"] = self.formatException(record.exc_info)
+        if record.__dict__.get("repo"):
+            base["repo"] = record.__dict__["repo"]
+        if record.__dict__.get("project"):
+            base["project"] = record.__dict__["project"]
+        return json.dumps(base, ensure_ascii=False)
+
+
+def configure_logging(json_log: bool = False) -> None:
+    """
+    Configure logging for both human and machine consumption.
+    """
+
+    logging.captureWarnings(True)
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+    handlers: list[logging.Handler] = []
+
+    console = Console(stderr=True)
+    handlers.append(
+        RichHandler(
+            console=console,
+            rich_tracebacks=True,
+            show_time=False,
+            show_level=True,
+            show_path=False,
+        )
+    )
+
+    if json_log or os.getenv("VDS_GIT_JSON_LOG") == "1":
+        json_handler = logging.StreamHandler(sys.stdout)
+        json_handler.setFormatter(JsonFormatter())
+        handlers.append(json_handler)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        handlers=handlers,
+        format="%(message)s",
+    )

package/tools/vds-scripts/git_orchestrator/src/vds_git_orchestrator/manifest.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from fnmatch import fnmatch
+from pathlib import Path
+
+import yaml
+
+
+@dataclass(frozen=True)
+class Repository:
+    name: str
+    path: Path
+    project: str
+    branch: str
+    tags: set[str] = field(default_factory=set)
+    hooks: dict[str, list[str]] = field(default_factory=dict)
+    _absolute_path: Path = field(repr=False, default=None)
+
+    @property
+    def absolute_path(self) -> Path:
+        return self._absolute_path or self.path
+
+
+@dataclass
+class Manifest:
+    repositories: list[Repository]
+
+    @classmethod
+    def merge(cls, manifests: Iterable[Manifest]) -> Manifest:
+        repos: list[Repository] = []
+        for manifest in manifests:
+            repos.extend(manifest.repositories)
+        seen = {}
+        for repo in repos:
+            seen[repo.name] = repo
+        return cls(repositories=list(seen.values()))
+
+    def filter(self, filters: ManifestFilters) -> list[Repository]:
+        repos = self.repositories
+        if filters.project:
+            repos = [repo for repo in repos if repo.project == filters.project]
+        if filters.name_match:
+            repos = [repo for repo in repos if fnmatch(repo.name, filters.name_match)]
+        if filters.include_tags:
+            repos = [repo for repo in repos if filters.include_tags & repo.tags]
+        if filters.exclude_tags:
+            repos = [repo for repo in repos if repo.tags.isdisjoint(filters.exclude_tags)]
+        return repos
+
+
+@dataclass
+class ManifestFilters:
+    project: str | None = None
+    name_match: str | None = None
+    include_tags: set[str] = field(default_factory=set)
+    exclude_tags: set[str] = field(default_factory=set)
+
+
+def _coerce_tags(raw: Iterable[str] | None) -> set[str]:
+    return {tag for tag in (raw or []) if tag}
+
+
+def load_manifest(path: Path) -> Manifest:
+    data = yaml.safe_load(path.read_text())
+    repos_raw = data.get("repositories", [])
+    repos: list[Repository] = []
+    base_dirs, repo_root = _candidate_base_dirs(path)
+
+    for entry in repos_raw:
+        name = entry["name"]
+        raw_path = Path(entry["path"]).expanduser()
+        project = entry.get("project", "lep")
+        branch = entry.get("branch", "release")
+        tags = _coerce_tags(entry.get("tags"))
+        hooks = entry.get("hooks", {}) or {}
+        repo_path = _resolve_repo_path(raw_path, base_dirs, repo_root)
+        repos.append(
+            Repository(
+                name=name,
+                path=raw_path,
+                project=project,
+                branch=branch,
+                tags=tags,
+                hooks={phase: list(commands) for phase, commands in hooks.items()},
+                _absolute_path=repo_path,
+            )
+        )
+
+    return Manifest(repositories=repos)
+
+
+def _candidate_base_dirs(manifest_path: Path) -> tuple[list[Path], Path]:
+    """
+    Build an ordered list of directories to resolve relative repo paths.
+
+    We walk up from the manifest directory until we find the repository root
+    (identified by the presence of a .git directory). This allows manifests
+    inside `docs-nttc/scripts/` to reference sibling directories such as
+    `INSURANCE-project/` located at the monorepo root.
+    """
+
+    dirs: list[Path] = []
+    repo_root: Path | None = None
+    manifest_dir = manifest_path.parent.resolve()
+    for candidate in [manifest_dir, *manifest_dir.parents]:
+        dirs.append(candidate)
+        if (candidate / ".git").exists():
+            repo_root = candidate
+    if not dirs:
+        dirs = [manifest_dir]
+    if repo_root is None:
+        repo_root = manifest_dir
+    return dirs, repo_root
+
+
+def _resolve_repo_path(raw_path: Path, base_dirs: list[Path], fallback_root: Path) -> Path:
+    if raw_path.is_absolute():
+        return raw_path.resolve()
+
+    for base in base_dirs:
+        candidate = (base / raw_path)
+        if candidate.exists():
+            return candidate.resolve()
+
+    # Fallback to the last candidate (typically the repo root) even if the path
+    # does not yet exist so clone operations still receive an absolute target.
+    return (fallback_root / raw_path).resolve()