| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219 |
- """Read every profile's enabled plugins in config order for the shared union.
- Plugin admission owns writes; discovery never edits a profile's selection.
- """
- from __future__ import annotations
- from pathlib import Path
- from typing import Any, Optional
- import logging
- LOG = logging.getLogger(__name__)
- # plugins.<RECORD> maps each plugin an update disabled to {enabled, reason}: what to undo once it fits.
- RECORD = "disabled_by_update"
- def _profiles_root() -> Path:
- # Plugin discovery and dependency publication must use the same home root.
- from pm.environments import dependency_home_root
- return dependency_home_root() / "profiles"
- def _selection_readers(config_path: Path):
- """``(version(path), read(path))`` for a home's selection. PM's dependency runtime reads the
- LOCAL file it publishes to and compare-and-swaps (``pm.publication``): it has neither the
- remote config backend's client nor the plane credential, so a remote deployment never fails
- PM closed there. Every other process reads through the selected config backend; a file
- deployment never asks whether this is PM's runtime (the selector is all it needs)."""
- import os
- from hermes_cli import config_backend
- if os.environ.get(config_backend.BACKEND_ENV, "").strip().lower() in ("", "file"):
- return config_backend.config_version, config_backend.read_config_doc
- from pm.package import InstallError
- from pm.runtime import is_runtime
- try:
- in_runtime = is_runtime()
- except InstallError: # an application process whose packaged PM runtime is damaged: not PM's runtime
- in_runtime = False
- if not in_runtime:
- return config_backend.config_version, config_backend.read_config_doc
- backend, home = config_backend.local_file_layer(config_path)
- return (lambda _path: backend.version(home)), (lambda _path: backend.read_user_doc(home))
- def read_home_selection(home: Path) -> Optional[dict[str, Any]]:
- """The plugin/memory selection a home's config.yaml declares (None: no config yet).
- The public reader for anything that must agree with what PM installs for that home.
- An unreadable selection raises rather than shrinking the next dependency generation;
- empty YAML is an explicit empty configuration, as in the CLI loader.
- """
- config_path = home / "config.yaml"
- config_version, read_config_doc = _selection_readers(config_path)
- # Stat before the YAML stack: a home without config needs none (PM's own runtime tree has none).
- # Only a missing file means "no config"; a symlink loop or permission error still refuses.
- try:
- config_version(config_path)
- except FileNotFoundError:
- return None
- except OSError as exc:
- raise ValueError(f"could not read plugin selection: {config_path}") from exc
- # Missing YAML support is a broken runtime, not an empty plugin selection.
- from ruamel.yaml.error import YAMLError
- try:
- config = read_config_doc(config_path)
- except FileNotFoundError:
- return None
- except (OSError, UnicodeError) as exc:
- raise ValueError(f"could not read plugin selection: {config_path}") from exc
- except YAMLError as exc:
- raise ValueError(f"could not parse plugin selection: {config_path}") from exc
- if config is None:
- return {}
- if not isinstance(config, dict):
- raise ValueError(f"configuration must be a mapping: {config_path}")
- for section in ("plugins", "memory"):
- if config.get(section) is not None and not isinstance(config[section], dict):
- raise ValueError(f"{section} must be a mapping: {config_path}")
- plugins = config.get("plugins") or {}
- for key in ("enabled", "disabled"):
- names = plugins.get(key)
- if names is not None and (not isinstance(names, list)
- or any(not isinstance(name, str) for name in names)):
- raise ValueError(f"plugins.{key} must be a list of names: {config_path}")
- provider = (config.get("memory") or {}).get("provider")
- if provider is not None and not isinstance(provider, str):
- raise ValueError(f"memory.provider must be a name: {config_path}")
- return config
- def _enabled_from_config(config: dict[str, Any]) -> list[str]:
- """plugins.enabled from an already-parsed config, ORDER-PRESERVING."""
- plugins_cfg = config.get("plugins")
- if not isinstance(plugins_cfg, dict):
- return []
- enabled = plugins_cfg.get("enabled")
- if not isinstance(enabled, list):
- return []
- disabled = plugins_cfg.get("disabled", [])
- disabled = set(disabled) if isinstance(disabled, list) else set()
- out: list[str] = []
- for name in enabled:
- if (isinstance(name, str) and name and name not in out
- and name not in disabled and name.rsplit("/", 1)[-1] not in disabled):
- out.append(name)
- return out
- def _is_directory(path: Path) -> bool:
- import stat
- try:
- return stat.S_ISDIR(path.stat().st_mode)
- except FileNotFoundError:
- return False
- except OSError as exc:
- raise ValueError(f"could not inspect plugin directory: {path}") from exc
- def dependency_homes() -> list[Path]:
- """Every home whose selection feeds the shared venv: the default home plus each LIVE profile.
- Enumerates the complete union or refuses; a partial scan cannot remove members.
- Live means what ``hermes profile`` lists (hermes_constants): a valid id carrying an identity
- marker and no tombstone. Staging dirs (``.work.staging-*``), deleted profiles and stray
- marker-less dirs must not put plugins into the shared environment.
- """
- from hermes_constants import PROFILE_ID_RE, named_profile_is_live
- from pm.environments import dependency_home_root
- homes = [dependency_home_root()]
- root = _profiles_root()
- try:
- profiles = sorted(root.iterdir(), key=str)
- except FileNotFoundError:
- return homes
- except OSError as exc:
- raise ValueError(f"could not enumerate profiles: {root}") from exc
- homes.extend(profile for profile in profiles
- if _is_directory(profile) and profile.name != "default"
- and PROFILE_ID_RE.match(profile.name) and named_profile_is_live(profile))
- return homes
- def enabled_plugins_ordered(*, proposed_home=None, enabled=None, disabled=None,
- installing: Path | None = None,
- skip_invalid_secondary: bool = False) -> dict[Path, list[str]]:
- """plugins_dir → ordered enabled list, per home. Keyed by the
- PLUGINS DIR (where the member dirs live), not the home itself.
- The ACTIVE MEMORY PROVIDER joins its home's list: providers install
- via ``memory.provider`` (mnemosyne's documented path), not via
- plugins.enabled — without this, a provider's dep plugin never joins
- the union. Admission refuses a conflicting candidate without changing
- the active environment or disabling an existing provider."""
- out: dict[Path, list[str]] = {}
- homes = dependency_homes()
- for home in homes:
- # ONE parse per home feeds both queries (enabled + provider).
- try:
- config = read_home_selection(home)
- except ValueError as exc:
- if not skip_invalid_secondary or home == homes[0]:
- raise
- LOG.warning("Skipping broken secondary profile %s during dependency verification: %s", home, exc)
- continue
- config = config or {}
- if proposed_home is not None and home.resolve() == Path(proposed_home).resolve():
- config = {**config, "plugins": {"enabled": list(enabled or ()), "disabled": list(disabled or ())}}
- names = _enabled_from_config(config)
- provider = _provider_from_config(home, config, installing=installing)
- if provider and provider not in names:
- names.append(provider)
- if names:
- out[home / "plugins"] = names
- return out
- def _provider_from_config(home: Path, config: dict[str, Any], *, installing: Path | None = None) -> Optional[str]:
- """The ``memory.provider`` key of an already-parsed config, when its
- plugin dir exists (no dir = not a member) and plugins.disabled does not park it."""
- provider = (config.get("memory") or {}).get("provider")
- if not provider or not provider.strip():
- return None
- name = provider.strip()
- plugin_dir = home / "plugins" / name
- if installing is not None and plugin_dir.resolve() == installing.resolve():
- return name
- if not _is_directory(plugin_dir) or _parked(plugin_dir, config):
- return None
- return name
- def _parked(plugin_dir: Path, config: dict[str, Any]) -> bool:
- """Whether plugins.disabled names this provider plugin. The provider loader honours the same
- spellings (plugins.memory._explicitly_disabled), so a parked provider is never loaded and
- installing its dependencies could only fail the generation for nothing."""
- disabled = (config.get("plugins") or {}).get("disabled") or []
- return bool(plugin_spellings(plugin_dir) & set(disabled))
- def plugin_spellings(plugin_dir: Path, key: str | None = None) -> set[str]:
- """Every name a plugins list may use for this plugin: the selection key and its bare leaf, the
- directory name and the manifest ``name:``. Read from the plugin itself, so it holds in any home."""
- from pm.plugin_declarations import native_manifest_file, read_native_manifest
- names = {plugin_dir.name} | ({key, key.rsplit("/", 1)[-1]} if key else set())
- try:
- manifest_file = native_manifest_file(plugin_dir)
- if manifest_file is not None:
- names.add(str(read_native_manifest(manifest_file).get("name") or ""))
- except ValueError:
- pass # no readable manifest: the other spellings still hold
- names.discard("")
- return names
|