204 lines
7.4 KiB
Python
204 lines
7.4 KiB
Python
#!/usr/bin/env python3
|
|
"""Report active-fleet Repo Classification convergence from State Hub.
|
|
|
|
The repository file remains authoritative. This command compares the live
|
|
State Hub projection with each active record's registered local checkout and
|
|
separates missing owner decisions from projection failures.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
import urllib.error
|
|
import urllib.request
|
|
from pathlib import Path
|
|
from typing import Any, Callable
|
|
|
|
import yaml
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parent.parent
|
|
if str(REPO_ROOT) not in sys.path:
|
|
sys.path.insert(0, str(REPO_ROOT))
|
|
|
|
from tools.validate_repo_classification import load_allowed, validate # noqa: E402
|
|
|
|
DEFAULT_API_BASE = "http://127.0.0.1:8000"
|
|
UrlOpen = Callable[..., Any]
|
|
|
|
|
|
class FleetReadError(RuntimeError):
|
|
"""State Hub did not return a usable repository projection."""
|
|
|
|
|
|
def fetch_repositories(
|
|
api_base: str,
|
|
*,
|
|
timeout: float = 15.0,
|
|
opener: UrlOpen = urllib.request.urlopen,
|
|
) -> list[dict[str, Any]]:
|
|
url = f"{api_base.rstrip('/')}/repos/?limit=500"
|
|
request = urllib.request.Request(url, headers={"Accept": "application/json"})
|
|
try:
|
|
with opener(request, timeout=timeout) as response:
|
|
payload = json.load(response)
|
|
except (OSError, urllib.error.URLError, json.JSONDecodeError) as exc:
|
|
raise FleetReadError(f"cannot read State Hub repositories: {exc}") from exc
|
|
if not isinstance(payload, list) or any(not isinstance(item, dict) for item in payload):
|
|
raise FleetReadError("State Hub /repos response is not a list of objects")
|
|
return payload
|
|
|
|
|
|
def _source_path(record: dict[str, Any]) -> Path | None:
|
|
local_path = record.get("local_path")
|
|
if not isinstance(local_path, str) or not local_path.strip():
|
|
return None
|
|
return Path(local_path) / ".repo-classification.yaml"
|
|
|
|
|
|
def analyze_repositories(
|
|
records: list[dict[str, Any]],
|
|
*,
|
|
validate_sources: bool = True,
|
|
) -> dict[str, Any]:
|
|
active = [record for record in records if record.get("status") == "active"]
|
|
classified = [record for record in active if record.get("category") is not None]
|
|
null_records = [record for record in active if record.get("category") is None]
|
|
missing_source: list[str] = []
|
|
present_unprojected: list[str] = []
|
|
projected_without_source: list[str] = []
|
|
invalid_source: dict[str, list[str]] = {}
|
|
source_warnings: dict[str, list[str]] = {}
|
|
duplicate_slugs: list[str] = []
|
|
|
|
slug_counts: dict[str, int] = {}
|
|
allowed = load_allowed() if validate_sources else None
|
|
for record in active:
|
|
slug = str(record.get("slug") or "<missing-slug>")
|
|
slug_counts[slug] = slug_counts.get(slug, 0) + 1
|
|
path = _source_path(record)
|
|
source_present = path is not None and path.is_file()
|
|
|
|
if record.get("category") is None:
|
|
(present_unprojected if source_present else missing_source).append(slug)
|
|
elif not source_present:
|
|
projected_without_source.append(slug)
|
|
|
|
if validate_sources and source_present and path is not None:
|
|
try:
|
|
document = yaml.safe_load(path.read_text(encoding="utf-8"))
|
|
errors, warnings = validate(document, allowed)
|
|
except (OSError, yaml.YAMLError) as exc:
|
|
errors, warnings = [f"cannot read/parse source: {exc}"], []
|
|
if errors:
|
|
invalid_source[slug] = errors
|
|
if warnings:
|
|
source_warnings[slug] = warnings
|
|
|
|
duplicate_slugs = sorted(slug for slug, count in slug_counts.items() if count > 1)
|
|
missing_source.sort()
|
|
present_unprojected.sort()
|
|
projected_without_source.sort()
|
|
|
|
blocking = bool(
|
|
missing_source
|
|
or present_unprojected
|
|
or projected_without_source
|
|
or invalid_source
|
|
or duplicate_slugs
|
|
)
|
|
return {
|
|
"registered": len(records),
|
|
"active": len(active),
|
|
"active_classified": len(classified),
|
|
"active_null_category": len(null_records),
|
|
"missing_source": missing_source,
|
|
"present_unprojected": present_unprojected,
|
|
"projected_without_source": projected_without_source,
|
|
"invalid_source": dict(sorted(invalid_source.items())),
|
|
"source_warnings": dict(sorted(source_warnings.items())),
|
|
"source_warning_count": sum(len(items) for items in source_warnings.values()),
|
|
"duplicate_active_slugs": duplicate_slugs,
|
|
"converged": not blocking,
|
|
}
|
|
|
|
|
|
def render_text(report: dict[str, Any], *, show_warnings: bool = False) -> str:
|
|
lines = [
|
|
f"registered: {report['registered']}",
|
|
f"active: {report['active']}",
|
|
f"active classified: {report['active_classified']}",
|
|
f"active null category: {report['active_null_category']}",
|
|
f"missing source file: {len(report['missing_source'])}",
|
|
f"source present but unprojected: {len(report['present_unprojected'])}",
|
|
f"projected without source file: {len(report['projected_without_source'])}",
|
|
f"invalid source file: {len(report['invalid_source'])}",
|
|
f"source validation warnings: {report['source_warning_count']}",
|
|
f"duplicate active slug: {len(report['duplicate_active_slugs'])}",
|
|
f"converged: {'yes' if report['converged'] else 'no'}",
|
|
]
|
|
for key in (
|
|
"missing_source",
|
|
"present_unprojected",
|
|
"projected_without_source",
|
|
"duplicate_active_slugs",
|
|
):
|
|
if report[key]:
|
|
lines.append(f"{key}: {', '.join(report[key])}")
|
|
for slug, errors in report["invalid_source"].items():
|
|
lines.append(f"invalid_source[{slug}]: {'; '.join(errors)}")
|
|
if show_warnings:
|
|
for slug, warnings in report["source_warnings"].items():
|
|
lines.append(f"source_warnings[{slug}]: {'; '.join(warnings)}")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def build_parser() -> argparse.ArgumentParser:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument(
|
|
"--api-base",
|
|
default=os.environ.get("STATE_HUB_API_BASE", DEFAULT_API_BASE),
|
|
help="State Hub REST base URL (default: %(default)s)",
|
|
)
|
|
parser.add_argument("--timeout", type=float, default=15.0)
|
|
parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
|
|
parser.add_argument(
|
|
"--show-warnings",
|
|
action="store_true",
|
|
help="include individual non-blocking source validation warnings",
|
|
)
|
|
parser.add_argument(
|
|
"--skip-source-validation",
|
|
action="store_true",
|
|
help="only compare file presence and projection state",
|
|
)
|
|
parser.add_argument(
|
|
"--require-converged",
|
|
action="store_true",
|
|
help="exit 1 while any active classification gap remains",
|
|
)
|
|
return parser
|
|
|
|
|
|
def main(argv: list[str] | None = None) -> int:
|
|
args = build_parser().parse_args(argv)
|
|
try:
|
|
records = fetch_repositories(args.api_base, timeout=args.timeout)
|
|
report = analyze_repositories(
|
|
records,
|
|
validate_sources=not args.skip_source_validation,
|
|
)
|
|
except FleetReadError as exc:
|
|
print(f"ERROR: {exc}", file=sys.stderr)
|
|
return 2
|
|
|
|
if args.json:
|
|
print(json.dumps(report, indent=2, sort_keys=True))
|
|
else:
|
|
print(render_text(report, show_warnings=args.show_warnings))
|
|
return 1 if args.require_converged and not report["converged"] else 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|