aap-demo 2.0.0.dev0__py3-none-any.whl

aap_demo/__init__.py

@@ -0,0 +1,6 @@
+"""aap-demo — deploy Ansible Automation Platform 2.7 to OpenShift Local."""
+
+# Development release published from the v2 branch. pip ignores ``.dev`` versions.
+__version__ = "2.0.0.dev0"
+
+__all__ = ["__version__"]

aap_demo/__main__.py

@@ -0,0 +1,10 @@
+"""``python -m aap_demo`` — the same code path as the ``aap-demo`` console script."""
+
+from __future__ import annotations
+
+import sys
+
+from aap_demo.cli.main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

aap_demo/cli/_schema_args.py

@@ -0,0 +1,137 @@
+"""Generate argparse arguments from a JSON Schema document (design §9.3).
+
+Three deliberate omissions, each with a reason:
+
+* ``minimum``/``maximum`` are not turned into argparse type-checkers. The merged
+  result is validated by ``jsonschema`` immediately afterwards, and a second
+  range check in a second place is exactly the drift this mechanism exists to
+  prevent — argparse handles *parsing*, jsonschema handles *validity*.
+* ``required`` is not enforced here: a value may arrive from config or an env
+  var, so requiredness is a property of the resolved document.
+* Nested objects are not flattened into dotted flags. A nested section gets its
+  own document and its own ``add_schema_arguments`` call against the same
+  parser, which is how ``crc.*`` and ``deploy.*`` both land on ``aap-demo create``.
+"""
+
+from __future__ import annotations
+
+import argparse
+from typing import Any, Dict, Mapping, Optional
+
+from aap_demo.core import schema
+
+_TYPES = {"string": str, "integer": int, "number": float}
+
+#: Options that may be hand-written because they are verbs or output modifiers,
+#: not settings — they have no config or GUI analogue. ``test_schema_parity``
+#: fails on any optional argument outside this list that is not schema-derived.
+#: The design's §3.1 allowlist is the first group; the rest are per-command
+#: modifiers of the same kind (a flag that changes what a command *does*, not a
+#: value it persists).
+CLI_ONLY_OPTIONS = frozenset(
+    {
+        # §3.1's explicit allowlist
+        "--output",
+        "--quiet",
+        "-q",
+        "--yes",
+        "-y",
+        "--config",
+        "--verbose",
+        "-v",
+        "-h",
+        "--help",
+        # global, CLI-shaped: they select a target or an escape hatch, not a setting
+        "--kubeconfig",
+        "--context",
+        "--force",
+        "--set",
+        "--version",
+        "-V",
+        # per-command verb modifiers
+        "--reset",
+        "--ai",
+        "--all",
+        "--dry-run",
+        "--check",
+        "--purge-creds",
+        "--refresh-catalog",
+        "--extra-vars",
+        "-e",
+        "--stdin",
+    }
+)
+
+
+def _dest_for(section_name: str, key: str) -> str:
+    return f"{section_name}__{key}"
+
+
+def add_schema_arguments(
+    parser: argparse.ArgumentParser,
+    section_name: str,
+    *,
+    resolved: Optional[Mapping[str, Any]] = None,
+    doc: Optional[Dict[str, Any]] = None,
+    suppress: bool = False,
+) -> None:
+    """Add one argparse argument per property in a schema section.
+
+    ``resolved`` is the post-config-resolution value map, so ``--help`` shows the
+    *effective* default rather than the schema default. ``suppress`` builds the
+    same parser with ``SUPPRESS`` defaults, which is how ``cli/main.py`` learns
+    which values the user actually typed and which merely defaulted.
+    """
+    document = doc if doc is not None else schema.section(section_name)
+    values = resolved or {}
+
+    properties = document.get("properties", {})
+    for key, prop in sorted(properties.items(), key=lambda kv: kv[1].get("x-order", 1000)):
+        flags = schema.cli_flag(prop, key)
+        if flags is None:
+            continue
+
+        default = values.get(key, prop.get("default"))
+        kwargs: Dict[str, Any] = {
+            "dest": _dest_for(section_name, key),
+            "help": prop.get("description"),
+            "default": argparse.SUPPRESS if suppress else default,
+        }
+
+        prop_type = prop.get("type")
+        if prop_type == "boolean":
+            kwargs["action"] = "store_true" if not default else "store_false"
+        elif prop_type in _TYPES:
+            kwargs["type"] = _TYPES[prop_type]
+            if "enum" in prop:
+                # No metavar for an enum: argparse then renders the choices
+                # themselves in --help, which is the useful thing to show. A
+                # metavar would replace them with the widget name.
+                kwargs["choices"] = prop["enum"]
+            else:
+                kwargs["metavar"] = prop.get("x-gui", {}).get("widget", key).upper()
+        else:
+            raise ValueError(
+                f"{section_name}.{key}: type {prop_type!r} has no argparse mapping; "
+                "mark it 'x-cli: false' or give it a scalar type"
+            )
+
+        parser.add_argument(*flags, **kwargs)
+
+
+def collect_overrides(namespace: argparse.Namespace) -> Dict[str, Dict[str, Any]]:
+    """Pull schema-derived values back out of a parsed namespace.
+
+    Only values the user actually supplied should override config, so callers
+    pass the *supplied* namespace produced by a second parse with suppressed
+    defaults; see ``cli/main.py``.
+    """
+    overrides: Dict[str, Dict[str, Any]] = {}
+    for dest, value in vars(namespace).items():
+        if "__" not in dest:
+            continue
+        section_name, _, key = dest.partition("__")
+        if section_name not in schema.sections():
+            continue
+        overrides.setdefault(section_name, {})[key] = value
+    return overrides

aap_demo/cli/addons.py

@@ -0,0 +1,21 @@
+"""Addon commands — phase 0 stubs (the addon platform lands in phase 5+6)."""
+
+from __future__ import annotations
+
+import argparse
+
+from aap_demo.core.context import AppContext
+from aap_demo.core.errors import NotImplementedYetError
+
+
+def enable(ctx: AppContext, args: argparse.Namespace) -> int:
+    raise NotImplementedYetError("enable")
+
+
+def disable(ctx: AppContext, args: argparse.Namespace) -> int:
+    raise NotImplementedYetError("disable")
+
+
+def addon(ctx: AppContext, args: argparse.Namespace) -> int:
+    action = getattr(args, "addon_action", None) or "addon"
+    raise NotImplementedYetError(f"addon {action}".strip())

aap_demo/cli/completion.py

@@ -0,0 +1,16 @@
+"""``aap-demo completion`` — phase 0 stub.
+
+bash/zsh completion is backed by argcomplete over the argparse parser; fish and
+PowerShell get hand-written scripts shipped as package data (design §3.1).
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from aap_demo.core.context import AppContext
+from aap_demo.core.errors import NotImplementedYetError
+
+
+def completion(ctx: AppContext, args: argparse.Namespace) -> int:
+    raise NotImplementedYetError("completion")

aap_demo/cli/day2.py

@@ -0,0 +1,17 @@
+"""Day-2 playbook commands — phase 0 stubs (the day2 package lands in phase 6b).
+
+Named ``day2`` rather than ``playbooks`` because ``cli/ops.py`` already carries
+idle/ssh/config; the user-facing noun everywhere is still "playbooks".
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from aap_demo.core.context import AppContext
+from aap_demo.core.errors import NotImplementedYetError
+
+
+def playbooks(ctx: AppContext, args: argparse.Namespace) -> int:
+    action = getattr(args, "playbooks_action", None) or ""
+    raise NotImplementedYetError(f"playbooks {action}".strip())

aap_demo/cli/gui.py

@@ -0,0 +1,12 @@
+"""``aap-demo gui`` — phase 0 stub (the GUI lands in phase 7)."""
+
+from __future__ import annotations
+
+import argparse
+
+from aap_demo.core.context import AppContext
+from aap_demo.core.errors import NotImplementedYetError
+
+
+def gui(ctx: AppContext, args: argparse.Namespace) -> int:
+    raise NotImplementedYetError("gui")

aap_demo/cli/lifecycle.py

@@ -0,0 +1,156 @@
+"""Cluster and AAP lifecycle commands (design §12.4).
+
+``deploy``, ``clean``, ``redeploy``, ``setup``, ``create`` and ``destroy`` are
+implemented. ``redeploy-all``, ``start``, ``stop`` and ``repair`` stay stubs.
+The command functions are thin: every decision lives in ``cluster/``, which
+is what lets the GUI reach the same behavior without importing ``cli/`` (§2.2).
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+from typing import Callable
+
+from aap_demo.cluster import aap as aap_mod
+from aap_demo.cluster import bootstrap as bootstrap_mod
+from aap_demo.cluster import deploy as deploy_mod
+from aap_demo.cluster import runtime as runtime_mod
+from aap_demo.cluster import status as status_mod
+from aap_demo.core import prompts
+from aap_demo.core.context import AppContext
+from aap_demo.core.errors import NotImplementedYetError
+from aap_demo.core.output import is_structured, render
+from aap_demo.infra import crc as infra_crc
+
+#: ``read -t 10`` before the destructive clean (aap-demo.sh:748).
+CLEAN_CONFIRM_SECONDS = 10
+
+
+def create(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``aap-demo create`` for the MicroShift preset."""
+    del args
+    bootstrap_mod.create(ctx)
+    return 0
+
+
+def deploy(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_deploy`` (aap-demo.sh:2018).
+
+    Exit status follows bash: reaching the CR and then timing out in
+    ``watch_aap`` is a failure (bash's ``return 1``), while the
+    already-exists short-circuit is a success.
+    """
+    deploy_mod.ensure_cluster_running(ctx)
+    result = deploy_mod.run(ctx, cr_name=getattr(args, "deploy__cr", None) or None)
+    if is_structured(ctx.output):
+        render(ctx.console, result.as_dict(), output=ctx.output)
+    return 0 if (result.ready or result.skipped_existing) else 1
+
+
+def redeploy(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_redeploy`` (aap-demo.sh:1902): clean, pause, deploy."""
+    _clean(ctx)
+    time.sleep(2)
+    ctx.console.out("")
+    ctx.console.out("Redeploying AAP...")
+    ctx.console.out("")
+    result = deploy_mod.run(ctx, cr_name=getattr(args, "deploy__cr", None) or None)
+    if is_structured(ctx.output):
+        render(ctx.console, result.as_dict(), output=ctx.output)
+    return 0 if result.ready else 1
+
+
+def redeploy_all(ctx: AppContext, args: argparse.Namespace) -> int:
+    raise NotImplementedYetError("redeploy-all")
+
+
+def setup(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_setup`` (aap-demo.sh:2013), which is one ``echo`` and nothing else.
+
+    The help text still advertises "Run setup only (storage, coredns, mkcert)",
+    but that work moved into ``crc-create.sh`` long ago and the command has
+    been a pointer ever since. Porting the *advertised* behavior instead of
+    the actual behavior would invent a command that has never existed.
+    """
+    ctx.console.out("CRC setup is handled during 'aap-demo create'")
+    return 0
+
+
+def start(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_start``."""
+    del args
+    runtime_mod.start(ctx)
+    return 0
+
+
+def stop(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_stop``."""
+    del args
+    runtime_mod.stop(ctx)
+    return 0
+
+
+def destroy(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_destroy``. ``--reset`` clears the YAML config file."""
+    bootstrap_mod.destroy(ctx, reset=bool(getattr(args, "reset", False)))
+    return 0
+
+
+def clean(ctx: AppContext, args: argparse.Namespace) -> int:
+    _clean(ctx)
+    return 0
+
+
+def repair(ctx: AppContext, args: argparse.Namespace) -> int:
+    """Ports ``cmd_repair``."""
+    del args
+    runtime_mod.repair(ctx)
+    return 0
+
+
+def _clean(ctx: AppContext, *, wait: Callable[[float], None] = None) -> None:  # type: ignore[assignment]
+    """Ports ``_clean_operator``'s warning banner plus ``cluster/aap.py::teardown``."""
+    ns = ctx.namespace
+
+    from aap_demo.exec import kubectl
+
+    if not kubectl.exists(ctx.runner, "namespace", ns):
+        ctx.console.out(f"Namespace {ns} not found - nothing to clean")
+        return
+
+    ctx.console.out("")
+    ctx.console.out("WARNING: AAP CLEANUP - DESTRUCTIVE OPERATION!")
+    ctx.console.out("")
+    status_mod.show_cluster_info(ctx)
+    ctx.console.out("")
+
+    listing = ctx.runner.run(
+        ["kubectl", "get", "aap", "-n", ns, "--no-headers", "--request-timeout=2s"]
+    )
+    names = [line.split()[0] for line in (listing.stdout or "").splitlines() if line.strip()]
+    if names:
+        ctx.console.out("  AAP resources that will be DELETED:")
+        for name in names:
+            ctx.console.out(f"    - {name}")
+        ctx.console.out("")
+
+    ctx.console.out(f"This will DELETE the namespace '{ns}' and all resources within it!")
+    ctx.console.out("")
+    prompts.timed_continue(ctx.console, seconds=CLEAN_CONFIRM_SECONDS, quiet=ctx.quiet, wait=wait)
+
+    import shutil
+
+    steps = ["Deleting the AAP instance", "Deleting the namespace", "Pruning unused images"]
+    if shutil.which("operator-sdk") is not None:
+        steps.insert(0, "Cleaning up OLM")
+    ctx.console.tasks(steps)
+    if not aap_mod.teardown(ctx, namespace=ns):
+        return
+    ctx.console.step("Pruning unused images")
+    pruned = infra_crc.prune_images(ctx)
+    if pruned:
+        ctx.console.checkpoint(f"Pruned {pruned} unused images")
+    else:
+        ctx.console.checkpoint("No unused images to prune")
+    ctx.console.success("AAP operator deployment removed")