forked from kenzuya/unshackle
api-only/remote-only serve now authenticates every serve.users key (str-coerced), not just api_secret, so per-user service allowlists apply. RemoteClient tries X-Secret-Key then X-Api-Key on 401 (sticky winner); remote_services.auth_headers prepends extra header names to the defaults.
340 lines
13 KiB
Python
340 lines
13 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
import re
|
|
from pathlib import Path
|
|
|
|
import click
|
|
|
|
from unshackle.core.config import config
|
|
from unshackle.core.service import Service
|
|
from unshackle.core.service_repo import DirtyServiceRepo, is_repo_spec, resolve_service_repo
|
|
from unshackle.core.utilities import import_module_by_path
|
|
from unshackle.core.utils.redact import redact_path
|
|
|
|
log = logging.getLogger("services")
|
|
|
|
_raw = config.directories.services
|
|
if not isinstance(_raw, list):
|
|
_raw = [_raw]
|
|
# resolve in config order — priority IS list order: the first source to define a tag is the source,
|
|
# later sources (local or repo) with the same tag are shadowed. List local last to make it a fallback.
|
|
_service_dirs: list[Path] = []
|
|
DIRTY_REPOS: list[str] = []
|
|
for _entry in _raw:
|
|
if isinstance(_entry, str) and is_repo_spec(_entry):
|
|
try:
|
|
_resolved = resolve_service_repo(_entry)
|
|
except DirtyServiceRepo as e:
|
|
# local edits in the clone — record it and let check_load_errors() exit cleanly
|
|
DIRTY_REPOS.append(redact_path(str(e.path)))
|
|
_resolved = None
|
|
if _resolved:
|
|
_service_dirs.append(_resolved)
|
|
else:
|
|
_service_dirs.append(Path(_entry))
|
|
|
|
# dedupe by tag honoring list order (first wins); track shadows for the load summary
|
|
_seen: dict[str, Path] = {}
|
|
SHADOWED: list[str] = []
|
|
for _dir in _service_dirs:
|
|
for _path in _dir.glob("*/__init__.py"):
|
|
tag = _path.parent.stem
|
|
if tag in _seen:
|
|
SHADOWED.append(
|
|
f"{tag}: using {redact_path(str(_seen[tag]))}, ignoring duplicate {redact_path(str(_path))}"
|
|
)
|
|
else:
|
|
_seen[tag] = _path
|
|
_SERVICES = sorted(_seen.values(), key=lambda x: x.parent.stem)
|
|
|
|
|
|
def load_service(path: Path) -> object:
|
|
"""Load one Service module, returning its tag-named class.
|
|
|
|
Raises a concise, single-line error naming the Service and the real cause so
|
|
a broken Service never surfaces as a raw traceback pointing at the loader.
|
|
"""
|
|
tag = path.parent.stem
|
|
try:
|
|
module = import_module_by_path(path)
|
|
except Exception as e:
|
|
raise RuntimeError(f"{tag}: failed to import — {type(e).__name__}: {e} ({path})") from e
|
|
try:
|
|
return getattr(module, tag)
|
|
except AttributeError as e:
|
|
raise RuntimeError(
|
|
f"{tag}: no class named '{tag}' found in {path} — the class name must match the directory name"
|
|
) from e
|
|
|
|
|
|
def load_services(paths: list[Path]) -> tuple[dict[str, object], list[str]]:
|
|
"""Load every Service, returning the good ones plus a list of load errors.
|
|
|
|
Importing this module must never raise: it is imported by several commands,
|
|
and a failed import is not cached by Python, so raising here would re-run and
|
|
re-report for every command. Instead we collect failures and let the caller
|
|
surface them once, cleanly, at the point services are actually used.
|
|
"""
|
|
modules: dict[str, object] = {}
|
|
errors: list[str] = []
|
|
for path in paths:
|
|
try:
|
|
modules[path.parent.stem] = load_service(path)
|
|
except Exception as e:
|
|
errors.append(str(e))
|
|
return modules, errors
|
|
|
|
|
|
_MODULES, LOAD_ERRORS = load_services(_SERVICES)
|
|
|
|
_ALIASES = {tag: getattr(module, "ALIASES", ()) for tag, module in _MODULES.items()}
|
|
|
|
|
|
_SUMMARY_LOGGED = False
|
|
|
|
|
|
def check_load_errors() -> None:
|
|
"""Log a one-line load summary (once) and raise a single clean error on failures.
|
|
|
|
Called when services are actually needed (listing/resolving) so the message
|
|
is rendered once by Click, without a traceback and without cascading through
|
|
every command that imports this module. Duplicate services (a tag also served by an
|
|
earlier, higher-priority source, which is ignored) are summarised here; the full
|
|
list — naming the path used and the duplicate ignored — is debug-only.
|
|
"""
|
|
if DIRTY_REPOS:
|
|
joined = "\n".join(f" - {p}" for p in DIRTY_REPOS)
|
|
raise click.ClickException(
|
|
"Service repo has local changes — refusing to refresh so your edits are not lost.\n"
|
|
"Commit and push them to the upstream repo (or revert them), then retry:\n" + joined
|
|
)
|
|
global _SUMMARY_LOGGED
|
|
if not _SUMMARY_LOGGED:
|
|
_SUMMARY_LOGGED = True
|
|
summary = f"Loaded {len(_MODULES)} services"
|
|
if SHADOWED:
|
|
summary += f" ({len(SHADOWED)} duplicate(s) ignored)"
|
|
log.info(summary)
|
|
for shadow in SHADOWED:
|
|
log.debug("%s", shadow)
|
|
if LOAD_ERRORS:
|
|
joined = "\n".join(f" - {err}" for err in LOAD_ERRORS)
|
|
raise click.ClickException(f"Failed to load {len(LOAD_ERRORS)} service(s):\n{joined}")
|
|
|
|
|
|
class Services(click.Group):
|
|
"""Lazy-loaded command group of project services."""
|
|
|
|
_remote_services_cache: list[dict] | None = None
|
|
|
|
# Click-specific methods
|
|
|
|
def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
|
|
"""Preprocess --slow to support optional range value before Click parses args."""
|
|
processed = []
|
|
i = 0
|
|
while i < len(args):
|
|
if args[i] == "--slow":
|
|
if i + 1 < len(args) and re.match(r"^\d+-\d+$", args[i + 1]):
|
|
processed.append(f"--slow={args[i + 1]}")
|
|
i += 2
|
|
else:
|
|
processed.append("--slow=60-120")
|
|
i += 1
|
|
else:
|
|
processed.append(args[i])
|
|
i += 1
|
|
return super().parse_args(ctx, processed)
|
|
|
|
def list_commands(self, ctx: click.Context) -> list[str]:
|
|
"""Returns a list of all available Services as command names for Click.
|
|
|
|
In remote mode, fetches the service list from the remote server
|
|
so the user sees exactly what's available remotely.
|
|
"""
|
|
remote = ctx.params.get("remote") or (ctx.parent and ctx.parent.params.get("remote"))
|
|
if remote:
|
|
remote_services = Services._fetch_remote_services(ctx)
|
|
if remote_services is not None:
|
|
return [s["tag"] for s in remote_services]
|
|
tags = Services.get_tags()
|
|
for svc_cfg in config.remote_services.values():
|
|
for remote_tag in svc_cfg.get("services", {}).keys():
|
|
if remote_tag not in tags:
|
|
tags.append(remote_tag)
|
|
return tags
|
|
check_load_errors()
|
|
return Services.get_tags()
|
|
|
|
def get_command(self, ctx: click.Context, name: str) -> click.Command:
|
|
"""Load the Service and return the Click CLI method."""
|
|
check_load_errors()
|
|
tag = Services.get_tag(name)
|
|
|
|
import_file = ctx.params.get("import_file") or (ctx.parent and ctx.parent.params.get("import_file"))
|
|
if import_file:
|
|
return Services._make_import_command(tag, ctx)
|
|
|
|
remote = ctx.params.get("remote") or (ctx.parent and ctx.parent.params.get("remote"))
|
|
if remote:
|
|
return Services._make_remote_command(tag, ctx)
|
|
|
|
try:
|
|
service = Services.load(tag)
|
|
except KeyError as e:
|
|
available_services = self.list_commands(ctx)
|
|
if not available_services:
|
|
raise click.ClickException(
|
|
f"There are no Services added yet, therefore the '{name}' Service could not be found."
|
|
)
|
|
raise click.ClickException(f"{e}. Available Services: {', '.join(available_services)}")
|
|
|
|
if hasattr(service, "cli"):
|
|
return service.cli
|
|
|
|
raise click.ClickException(f"Service '{tag}' has no 'cli' method configured.")
|
|
|
|
@staticmethod
|
|
def _fetch_remote_services(ctx: click.Context) -> list[dict] | None:
|
|
"""Fetch the service list from the remote server (cached per process)."""
|
|
if Services._remote_services_cache is not None:
|
|
return Services._remote_services_cache
|
|
try:
|
|
from unshackle.core.remote_service import RemoteClient, resolve_server
|
|
|
|
server_name = ctx.params.get("server")
|
|
server_url, api_key, services_config = resolve_server(server_name)
|
|
client = RemoteClient(server_url, api_key, services_config.get("_auth_headers"))
|
|
result = client.get("/api/services")
|
|
Services._remote_services_cache = result.get("services", [])
|
|
return Services._remote_services_cache
|
|
except Exception:
|
|
return None
|
|
|
|
@staticmethod
|
|
def _make_remote_command(tag: str, ctx: click.Context) -> click.Command:
|
|
"""Create a Click command for a remote service with server-provided options."""
|
|
svc_info = Services._fetch_remote_service_info(tag, ctx)
|
|
short_help = svc_info.get("url") if svc_info else None
|
|
cli_params = svc_info.get("cli_params") if svc_info else None
|
|
|
|
@click.command(name=tag, short_help=short_help)
|
|
@click.argument("title", type=str)
|
|
@click.pass_context
|
|
def remote_cli(ctx: click.Context, title: str, **kwargs: object) -> object:
|
|
from unshackle.core.remote_service import RemoteService, resolve_server
|
|
|
|
server_name = ctx.parent.params.get("server") if ctx.parent else None
|
|
server_url, api_key, services_config = resolve_server(server_name)
|
|
service_params = {k: v for k, v in kwargs.items() if v is not None and v is not False}
|
|
return RemoteService(ctx, tag, title, server_url, api_key, services_config, service_params=service_params)
|
|
|
|
if cli_params:
|
|
for param in cli_params:
|
|
if param.get("kind") == "option":
|
|
opts = param.get("opts", [f"--{param['name']}"])
|
|
kwargs: dict = {}
|
|
if param.get("is_flag"):
|
|
kwargs["is_flag"] = True
|
|
kwargs["default"] = param.get("default", False)
|
|
else:
|
|
kwargs["default"] = param.get("default")
|
|
kwargs["type"] = str
|
|
if param.get("help"):
|
|
kwargs["help"] = param["help"]
|
|
remote_cli = click.option(*opts, **kwargs)(remote_cli)
|
|
|
|
return remote_cli
|
|
|
|
@staticmethod
|
|
def _make_import_command(tag: str, ctx: click.Context) -> click.Command:
|
|
"""Create a synthetic command that yields an ImportService from an export JSON.
|
|
|
|
Mirrors how remote services are wired so dl.py's result() runs unchanged.
|
|
"""
|
|
|
|
@click.command(name=tag, short_help="Reconstruct a download from an export JSON.")
|
|
@click.argument("title", type=str, required=False, default="")
|
|
@click.pass_context
|
|
def import_cli(ctx: click.Context, title: str, **kwargs: object) -> object:
|
|
from unshackle.core.import_service import ImportService
|
|
|
|
import_file = ctx.params.get("import_file") or (ctx.parent and ctx.parent.params.get("import_file"))
|
|
return ImportService(ctx, tag, title, import_file)
|
|
|
|
return import_cli
|
|
|
|
@staticmethod
|
|
def _fetch_remote_service_info(tag: str, ctx: click.Context) -> dict | None:
|
|
"""Fetch service info for a specific service from the remote server."""
|
|
try:
|
|
services = Services._fetch_remote_services(ctx)
|
|
if services:
|
|
for svc in services:
|
|
if svc.get("tag") == tag:
|
|
return svc
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
# Methods intended to be used anywhere
|
|
|
|
@staticmethod
|
|
def get_tags() -> list[str]:
|
|
"""Returns a list of service tags from all available Services."""
|
|
return [x.parent.stem for x in _SERVICES]
|
|
|
|
@staticmethod
|
|
def get_path(name: str) -> Path:
|
|
"""Get the directory path of a command."""
|
|
tag = Services.get_tag(name)
|
|
|
|
for service in _SERVICES:
|
|
if service.parent.stem == tag:
|
|
return service.parent
|
|
raise KeyError(f"There is no Service added by the Tag '{name}'")
|
|
|
|
@staticmethod
|
|
def get_tag(value: str) -> str:
|
|
"""
|
|
Get the Service Tag (the name of the service's directory, not one of its aliases) by an Alias.
|
|
Input value can be of any case-sensitivity.
|
|
Original input value is returned if it did not match a service tag.
|
|
"""
|
|
original_value = value
|
|
value = value.lower()
|
|
|
|
for path in _SERVICES:
|
|
tag = path.parent.stem
|
|
if value in (tag.lower(), *_ALIASES.get(tag, [])):
|
|
return tag
|
|
|
|
return original_value
|
|
|
|
@staticmethod
|
|
def load(tag: str) -> Service:
|
|
"""Load a Service module by Service tag."""
|
|
module = _MODULES.get(tag)
|
|
if module:
|
|
return module
|
|
|
|
raise KeyError(f"There is no Service added by the Tag '{tag}'")
|
|
|
|
@staticmethod
|
|
def get_vault_tag(name: str) -> str:
|
|
"""Resolve the key-vault namespace tag for a service.
|
|
|
|
Returns the service's VAULT_TAG override when set, otherwise its own tag.
|
|
Falls back to the resolved tag for non-local services (remote/import).
|
|
"""
|
|
tag = Services.get_tag(name)
|
|
try:
|
|
service = Services.load(tag)
|
|
except KeyError:
|
|
return tag
|
|
return getattr(service, "VAULT_TAG", None) or tag
|
|
|
|
|
|
__all__ = ("Services",)
|