Vito Sansevero
f6df8a39b3
GET /system/diagnostics builds the report on the server, off the event loop and under a registry lease (409 busy while a restore runs): the project and Viewer.js versions, Python and the platform, the four legacy checks (one helper, legacy_checks, that GET /diagnostics also calls), public database info, source counts, the log configuration and statistics, the last health summary and the config.json-only keys from an explicit list. The CivitAI key is reported only as has_civitai_api_key; every path is relative to ComfyUI or reads "outside ComfyUI". A scrub replaces anything still absolute, the key or the home folder and counts it in redacted (0 for a correct build). The version parser moves unchanged to utils/version.py. (#329)
230 lines
8.8 KiB
Python
230 lines
8.8 KiB
Python
"""The shareable diagnostic report (#329 System S12).
|
|
|
|
``GET /prompt_manager/system/diagnostics`` answers a report built on the
|
|
server from an explicit list of fields: the project and Viewer.js versions,
|
|
Python and the platform, the four checks of the legacy ``GET /diagnostics``
|
|
(one helper, ``admin.legacy_checks``), the database's public info, source
|
|
counts, the log configuration and statistics, the last health summary and
|
|
the configuration keys that only ``config.json`` holds. It never copies
|
|
``PromptManagerConfig.get_config()``: no path leaf is listed, and the CivitAI
|
|
key is reported only as ``has_civitai_api_key``.
|
|
|
|
Every path in the report goes through ``report_path``: relative to ComfyUI
|
|
(or another public anchor), else ``"outside ComfyUI"``, never a basename
|
|
that could be a user name. As a backstop, ``scrub`` replaces any string that
|
|
still looks like an absolute path, holds the saved key or the home folder,
|
|
and counts each replacement in ``redacted`` (0 for a correct builder).
|
|
|
|
The report opens the database, so it takes a registry lease: it is refused
|
|
(409 ``busy``) while an ``exclusive`` job (a restore) runs, and a restore
|
|
waits for it. It is built off the event loop.
|
|
"""
|
|
|
|
import datetime
|
|
import json
|
|
import ntpath
|
|
import os
|
|
import platform
|
|
import posixpath
|
|
import re
|
|
from pathlib import Path
|
|
|
|
from aiohttp import web
|
|
|
|
from . import admin as _admin
|
|
from .job_routes import busy_response
|
|
from .jobs import JobBusy
|
|
from .system import health_summary
|
|
|
|
try:
|
|
from ...utils.version import project_version
|
|
except ImportError: # loaded as the top-level ``py`` package (tests)
|
|
from utils.version import project_version
|
|
|
|
DIAGNOSTICS_LEASE = "Diagnostics"
|
|
_ROOT = Path(__file__).resolve().parents[2]
|
|
VIEWERJS_PROVENANCE = str(_ROOT / "web" / "lib" / "viewerjs" / "provenance.json")
|
|
OUTSIDE = "outside ComfyUI"
|
|
REMOVED = "[removed]"
|
|
# The CivitAI key is searched for only when it is long enough to be a key.
|
|
MIN_KEY_LENGTH = 8
|
|
_WINDOWS_ABSOLUTE = re.compile(r"^[A-Za-z]:[\\/]")
|
|
|
|
|
|
def report_path(path):
|
|
"""``path`` relative to a public anchor (POSIX style), else ``outside ComfyUI``."""
|
|
if not path:
|
|
return ""
|
|
from ..config import GalleryConfig
|
|
|
|
try:
|
|
canonical = Path(os.path.normcase(os.path.realpath(str(path))))
|
|
except (OSError, ValueError):
|
|
return OUTSIDE
|
|
for anchor in GalleryConfig.path_anchors():
|
|
if canonical.is_relative_to(Path(anchor)):
|
|
return canonical.relative_to(Path(anchor)).as_posix() or "."
|
|
return OUTSIDE
|
|
|
|
|
|
def _looks_absolute(text):
|
|
return (
|
|
posixpath.isabs(text)
|
|
or ntpath.isabs(text)
|
|
or _WINDOWS_ABSOLUTE.match(text) is not None
|
|
or text.startswith("\\\\")
|
|
)
|
|
|
|
|
|
def _home_spellings():
|
|
"""The home folder as it may be spelled in a string (never ``/`` itself)."""
|
|
home = os.path.expanduser("~")
|
|
if not home or len(home) < 4 or home in ("/", "\\"):
|
|
return ()
|
|
return tuple({home, home.replace("\\", "/")})
|
|
|
|
|
|
def scrub(report, key):
|
|
"""``report`` with leaked paths and the key replaced, counted in ``redacted``."""
|
|
key = key if isinstance(key, str) and len(key) >= MIN_KEY_LENGTH else None
|
|
homes = _home_spellings()
|
|
count = 0
|
|
|
|
def clean(value):
|
|
nonlocal count
|
|
if isinstance(value, str):
|
|
if (
|
|
_looks_absolute(value)
|
|
or (key and key in value)
|
|
or any(home in value for home in homes)
|
|
):
|
|
count += 1
|
|
return REMOVED
|
|
return value
|
|
if isinstance(value, dict):
|
|
return {name: clean(item) for name, item in value.items()}
|
|
if isinstance(value, (list, tuple)):
|
|
return [clean(item) for item in value]
|
|
return value
|
|
|
|
cleaned = clean(report)
|
|
cleaned["redacted"] = int(cleaned.get("redacted") or 0) + count
|
|
return cleaned
|
|
|
|
|
|
def viewerjs_version(path=None):
|
|
"""The pinned Viewer.js version from its provenance file, or ``unknown``."""
|
|
try:
|
|
with open(path or VIEWERJS_PROVENANCE, encoding="utf-8") as handle:
|
|
version = json.load(handle).get("version")
|
|
except (OSError, ValueError, AttributeError):
|
|
return "unknown"
|
|
return version if isinstance(version, str) and version else "unknown"
|
|
|
|
|
|
def public_config():
|
|
"""The configuration keys only ``config.json`` holds, from an explicit list."""
|
|
from ..config import GalleryConfig, IntegrationConfig, PromptManagerConfig
|
|
|
|
return {
|
|
"database": {
|
|
"enable_duplicate_detection": (
|
|
PromptManagerConfig.ENABLE_DUPLICATE_DETECTION
|
|
),
|
|
"enable_auto_save": PromptManagerConfig.ENABLE_AUTO_SAVE,
|
|
},
|
|
"web_ui": {
|
|
"result_timeout": PromptManagerConfig.RESULT_TIMEOUT,
|
|
"show_test_button": PromptManagerConfig.SHOW_TEST_BUTTON,
|
|
"webui_display_mode": PromptManagerConfig.WEBUI_DISPLAY_MODE,
|
|
"infinite_scroll": PromptManagerConfig.INFINITE_SCROLL,
|
|
},
|
|
"performance": {
|
|
"max_search_results": PromptManagerConfig.MAX_SEARCH_RESULTS,
|
|
"enable_fuzzy_search": PromptManagerConfig.ENABLE_FUZZY_SEARCH,
|
|
"auto_backup_interval": PromptManagerConfig.AUTO_BACKUP_INTERVAL,
|
|
"worker_threads": PromptManagerConfig.WORKER_THREADS,
|
|
},
|
|
"gallery": {
|
|
"processing_delay": GalleryConfig.PROCESSING_DELAY,
|
|
"prompt_timeout": GalleryConfig.PROMPT_TIMEOUT,
|
|
"cleanup_interval": GalleryConfig.CLEANUP_INTERVAL,
|
|
"auto_cleanup_missing_files": GalleryConfig.AUTO_CLEANUP_MISSING_FILES,
|
|
"max_image_age_days": GalleryConfig.MAX_IMAGE_AGE_DAYS,
|
|
"max_concurrent_processing": GalleryConfig.MAX_CONCURRENT_PROCESSING,
|
|
"metadata_extraction_timeout": GalleryConfig.METADATA_EXTRACTION_TIMEOUT,
|
|
},
|
|
"integrations": {
|
|
"lora_manager_enabled": bool(IntegrationConfig.LORA_MANAGER_ENABLED),
|
|
"has_civitai_api_key": bool(IntegrationConfig.CIVITAI_API_KEY),
|
|
},
|
|
}
|
|
|
|
|
|
def _source_counts(sources):
|
|
configured = sources.get("configured") or []
|
|
effective = sources.get("effective") or []
|
|
return {
|
|
"configured": len(configured),
|
|
"effective": len(effective),
|
|
"watching": sum(1 for row in effective if row.get("watch") == "watching"),
|
|
"unavailable": sum(1 for row in configured if row.get("valid") is False),
|
|
}
|
|
|
|
|
|
class DiagnosticsReportMixin:
|
|
"""Mixin providing ``GET /prompt_manager/system/diagnostics``."""
|
|
|
|
def _register_diagnostics_report_routes(self, routes):
|
|
@routes.get("/prompt_manager/system/diagnostics")
|
|
async def diagnostics_report_route(request):
|
|
return await self.get_diagnostics_report(request)
|
|
|
|
async def get_diagnostics_report(self, request):
|
|
"""The report, built off the loop under a lease (409 ``busy`` in a restore)."""
|
|
from ..config import IntegrationConfig
|
|
|
|
try:
|
|
async with self._jobs.lease(DIAGNOSTICS_LEASE):
|
|
report = await self._run_in_executor(self.build_report)
|
|
except JobBusy as busy:
|
|
return busy_response(busy)
|
|
except Exception:
|
|
self.logger.exception("The diagnostic report could not be built")
|
|
return web.json_response(
|
|
{
|
|
"success": False,
|
|
"code": None,
|
|
"error": "The diagnostic report could not be built.",
|
|
},
|
|
status=500,
|
|
)
|
|
report = scrub(report, IntegrationConfig.CIVITAI_API_KEY)
|
|
return web.json_response(report, headers={"Cache-Control": "no-store"})
|
|
|
|
def build_report(self):
|
|
"""The report's fields (blocking: reads the database and the log folder)."""
|
|
db = self.db
|
|
manager = self._get_logger_manager()
|
|
stats = dict(manager.get_log_stats())
|
|
stats["log_directory"] = report_path(stats.get("log_directory"))
|
|
info = dict(db.model.get_database_info() or {})
|
|
if "database_path" in info:
|
|
info["database_path"] = report_path(info["database_path"])
|
|
sources, _monitor = self._source_status()
|
|
return {
|
|
"success": True,
|
|
"generated_at": datetime.datetime.now().replace(microsecond=0).isoformat(),
|
|
"version": project_version(_ROOT),
|
|
"python": platform.python_version(),
|
|
"platform": {"system": platform.system(), "release": platform.release()},
|
|
"viewerjs": viewerjs_version(VIEWERJS_PROVENANCE),
|
|
"checks": _admin.legacy_checks(db.model.db_path, report_path),
|
|
"database_info": info,
|
|
"sources": _source_counts(sources),
|
|
"logging": {"config": dict(manager.get_config()), "stats": stats},
|
|
"health": health_summary(self._current_health_report()),
|
|
"config": public_config(),
|
|
"redacted": 0,
|
|
}
|