mayhem-cli 0.5.1__py3-none-any.whl

mayhem_cli-0.5.1.dist-info/METADATA

@@ -0,0 +1,555 @@
+Metadata-Version: 2.5
+Name: mayhem-cli
+Version: 0.5.1
+Summary: General-purpose chaos engineering and resilience-testing framework: a chaos experiment orchestration engine.
+Author: Mayhem Engineering
+License: Proprietary
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: pydantic>=2.9
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: structlog>=24.1
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# Mayhem
+
+**Chaos engineering for Docker & Podman (Kubernetes on the roadmap): discover
+your system, break it on purpose, prove it recovers — every time, with
+evidence.**
+
+Mayhem is a drill engine, not a command library. It turns your
+`docker-compose` blueprint into a live topology graph, compiles one declarative
+`kind: drill` YAML file into a frozen, safety-gated execution plan, injects
+faults through a capability-aware toolkit, and ends every run with a machine
+verdict derived from the observations it actually recorded. Steps, probes,
+criteria evaluations, and decisions all land in SQLite — nothing is "trust me,
+it worked."
+
+```
+compose blueprint ─▶ topology graph ─▶ compile drill spec ─▶ frozen plan
+                                                              │
+                        verdict ◀── machine criteria ◀── inject → observe → recover
+                                                              │
+                                                SQLite evidence + decision trace
+```
+
+**Contents**
+- [Installation](#installation)
+- [Why Mayhem](#why-mayhem)
+- [What a Run Looks Like](#what-a-run-looks-like)
+- [Quickstart](#quickstart)
+- [Authoring a Drill](#authoring-a-drill)
+- [CLI Reference](#cli-reference)
+- [Configuration](#configuration)
+- [Safety Model](#safety-model)
+- [Exit Codes](#exit-codes)
+- [Architecture](#architecture)
+- [Development](#development)
+
+---
+
+## Installation
+
+Mayhem publishes to PyPI **as `mayhem-cli`** — the bare `mayhem` name is
+taken, so you install the CLI under that name. The console commands it puts on
+your `PATH` are still `mayhem` (and `mayhem-agent`).
+
+Requires **Python 3.12+**.
+
+```bash
+pip install mayhem-cli
+```
+
+That is it — `mayhem` is now on your `PATH`:
+
+```bash
+mayhem --help
+```
+
+**Isolated installs (recommended on macOS/Linux)** — keeps the CLI out of your
+global Python:
+
+```bash
+pipx install mayhem-cli        # or: uv tool install mayhem-cli
+```
+
+**Upgrading** — each git tag (`v0.5.0` or `0.5.0`) publishes that exact version:
+
+```bash
+pip install -U mayhem-cli
+```
+
+Need the source checkout instead? See [Development](#development).
+
+---
+
+## Why Mayhem
+
+Most chaos tooling hands you a list of commands — "kill this container," "add
+latency here" — and leaves you to figure out the blast radius, the cleanup, and
+what "healthy" means. Mayhem treats a drill as a **planned, gated, evidenced
+experiment** instead.
+
+| | Hand-rolled chaos scripts | Mayhem |
+|---|---|---|
+| **Targeting** | You pick a container and hope | Faults plan against a discovered topology graph, so targets stay real |
+| **Safety** | Your discipline | Risk ceiling, `max_faults` budget, and an impact gate that re-proves every fault before anything is injected |
+| **Definition** | Throwaway shell one-liners | One `kind: drill` YAML: per-container faults, ordering, checks, success criteria, observability |
+| **Cleanup** | You remember to | Every fault ships a compensation contract; the janitor sweeps dirty leases after crashes |
+| **Verdict** | Eyeball the dashboards | `PASS`/`FAIL` from typed success criteria evaluated over recorded observations |
+| **Evidence** | Shell history | Immutable SQLite journal: steps, probes, decisions, outcome |
+
+Concretely:
+
+1. **Topology-aware planning.** Mayhem reads your compose blueprint and
+   discovers the live services, hosts, and dependencies to build a graph.
+   Faults are planned against that graph, not applied blind; compose project
+   filtering keeps unrelated stacks out.
+
+2. **Drill specs, not scripts.** One YAML file declares everything — faults,
+   cross-container ordering, checks, success criteria, observability sources —
+   and you define what "healthy" looks like *before* you break anything.
+
+3. **Machine verdicts.** Optional typed success criteria turn every run into a
+   `PASS`/`FAIL` verdict derived from the observations actually recorded — no
+   eyeballing.
+
+4. **Automatic recovery.** Every fault ships a compensation contract: an undo
+   op plus a verification probe generated from the same plan parameters, so
+   what was injected is exactly what gets removed and re-proven healthy. If a
+   round fails or the controller crashes, the janitor sweeps dirty leases and
+   reconciles the workload — no manual cleanup. The per-fault lifecycle is
+   documented in [`docs/compensation.md`](docs/compensation.md).
+
+5. **Honest evidence.** Runs persist an immutable event journal, criteria
+   evaluations, and a governing-decision trace in SQLite. No "trust me, it
+   worked."
+
+6. **Prefix-shortened CLI.** Type `mayhem r` instead of `mayhem run`;
+   `mayhem e v` means `mayhem experiment validate`. Every command abbreviates
+   to any unique prefix.
+
+---
+
+## What a Run Looks Like
+
+A clean run needs no interpretation — the verdict is one line away. Truncated
+for readability:
+
+```
+$ mayhem run mayhem.yaml --compose docker-compose.yml
+
+# Run r-process-drill-8f2a1c
+**status**: completed
+**verdict**: pass
+**success criteria**: ALL PASS
+- [PASS] status:api-up.status PASS (expected 200, got 200)
+- [PASS] latency:api-up.latency_ms PASS (31.2 <= 500.0)
+**observations**: 2/2 sources collected
+**decisions**: 5 governing decision revisions (snapshot in the run row)
+**wall**: 32.4s
+
+run r-process-drill-8f2a1c — inspect with `mayhem history r-process-drill-8f2a1c`
+```
+
+Reading the transcript, top to bottom:
+
+1. **Status** — the run's machine state: `completed` (or `failed`/`aborted`
+   with a non-zero exit and dirty-lease warnings).
+2. **Verdict** — `pass`/`fail` derived from the success criteria you declared
+   in the spec; `undecided` when a run aborts or the spec has no success block.
+3. **Success criteria** — every criterion evaluated against real observations,
+   one line each, so a failure tells you exactly what drifted.
+4. **Observations** — how many configured evidence sources actually delivered
+   data (probes, logs, metrics …).
+5. **Decisions** — the governing decision revisions that shaped this run; the
+   decision trace is queryable afterward via `mayhem history`.
+6. **Copy-paste handle** — the run id for the follow-up commands below.
+
+From there: `mayhem status` lists recent runs, `mayhem status --run <run-id>`
+shows full recorded metadata, and `mayhem history <run-id>` replays the
+complete event journal (every step, probe sample, and lease for that run).
+Add `--debug` to `mayhem run` to stream each step live as it happens (`[ok]
+injected proc.pause 10s into testcase-api`, `[ok] recovered ... (compensation
+ok)`).
+
+---
+
+## Quickstart
+
+**Prerequisites**
+
+- Python 3.12+
+- Docker with Compose v2 (or Podman, used via the `--podman` flag)
+- No host tooling required up front: `mayhem toolkit list` probes for the
+  capabilities (docker, podman, network tooling, `k6`, …) each fault needs,
+  and the impact gate refuses to run anything it cannot prove.
+
+**Install**
+
+```bash
+pip install mayhem-cli
+```
+
+> The PyPI package is **`mayhem-cli`** (`mayhem` is taken); the console command
+> remains `mayhem`. Full instructions in
+> [Installation](#installation). For a source checkout use
+> `pip install -e .` (see [Development](#development)).
+
+**Run the bundled example**
+
+A complete, self-contained example lives in `examples/testCase/` — a
+six-service compose stack (API, web, load balancer, dual download builders, and
+Postgres), its drill spec, and the fixtures it relies on.
+
+```bash
+# 0. Bring the stack up.
+cd examples/testCase
+docker compose up -d
+
+# 1. See the topology Mayhem will plan against (blueprint ─▶ live graph).
+mayhem topology discover --compose docker-compose.yml
+
+# 2. Compile the spec and run every safety gate — injects nothing.
+mayhem validate mayhem.yaml --compose docker-compose.yml
+
+# 3. Print the frozen execution plan as JSON.
+mayhem plan mayhem.yaml --compose docker-compose.yml
+
+# 4. Execute the drill and print the run summary.
+mayhem run mayhem.yaml --compose docker-compose.yml
+
+# (Variant) limit a run to ONE container — the pinned container's faults run,
+# every other container's rounds are dropped from the frozen plan.
+mayhem run mayhem.yaml --compose docker-compose.yml --ctr testcase-api
+
+# (Variant) `maniac` draws its random rounds against a single container too —
+# handy when you want to chaos-test one container without touching the others.
+mayhem maniac --compose docker-compose.yml --ctr testcase-api
+
+# 5. Replay any run's evidence.
+mayhem status --run <run-id>
+mayhem history <run-id>
+```
+
+`mayhem run` prints a copy-paste `run <run-id> — inspect with mayhem history
+<run-id>` line at the end; that id is all you need for the evidence commands.
+
+The example spec exercises **38 distinct faults** (every catalog entry that
+applies to a Docker/Podman compose service) across the `testcase-lb`
+load-balancer — CPU/memory/fd/disk pressure, load spikes, protocol abuse,
+network latency/bandwidth/packet-loss, dependency and database and DNS faults,
+TLS failure, container kill/restart/pause, HTTP error injection —
+capped at one concurrent fault (`max_faults: 1`, `risk_ceiling: critical`)
+with auto-recovery off (`recovery: false`), so the downstream checks observe
+whether the stack self-heals on its own. The remaining nine `k8s.*` catalog
+faults are exercised against a Kubernetes blueprint in
+[`examples/k8s`](examples/k8s) (planning-only until the M8 driver lands), so
+**every fault in the catalog has an example**.
+
+Omit `--compose` and Mayhem auto-detects `docker-compose.yml` (or
+`compose.yml`) in the current directory.
+
+> `validate` and `plan` work against the blueprint alone and never touch live
+> containers. `run` re-proves every fault at the impact gate against the live
+> graph and bypasses — or, without `--skip-gate`, refuses — anything it cannot
+> prove injectable.
+
+---
+
+## Authoring a Drill
+
+A drill is one `kind: drill` YAML file — the DSL reference lives in
+[`docs/drill-spec.md`](docs/drill-spec.md). The shape:
+
+```yaml
+apiVersion: "mayhem/v1"
+kind: drill
+name: checkout-recovery
+hypothesis: "checkout stays available while cart writes are throttled"
+
+config:
+  risk_ceiling: high      # refuse faults riskier than this (policy ceilings only tighten)
+  max_faults: 1           # never inject more than one fault at once
+  timeout: 30m
+
+containers:
+  cart-api:               # keys ARE compose container_name values
+    faults:
+      - fault: net.latency
+        duration: 10s
+        params: { seconds: 5s, jitter_ms: 10 }
+
+execution:
+  - parallel: [cart-api]
+  - check_spec:           # locus-aware checks
+      - id: cart-health
+        probe: { type: http, url: http://cart-api:8080/_health, expected_status: 200 }
+        execution: service
+        target: cart-api
+
+success:                  # machine verdict
+  require_all: true
+  criteria:
+    - type: status
+      source_id: cart-health.status
+      expected: 200
+    - type: latency
+      source_id: cart-health.latency_ms
+      lt_ms: 800
+
+observability:            # evidence sources
+  sources:
+    - kind: logs
+      source_id: cart-logs
+      container: cart-api
+      tail: 200
+    - kind: probe
+      source_id: cart-probe
+      probe: { type: http, url: http://cart-api:8080/_health }
+      cadence: 2s
+```
+
+Validate with `mayhem validate mayhem.yaml`; unknown parameters, out-of-range
+durations, untargetable node kinds, and capability gaps are all compile-time
+errors — before anything is injected.
+
+### Campaigns
+
+A campaign groups drill specs under one execution umbrella (ADR-0022/0023):
+experiments run sequentially in priority order, and the campaign's failure
+policy and time window govern the whole run.
+
+```bash
+mayhem campaign create black-friday \
+  --description "BFCM chaos" --hypothesis "checkout survives every single-fault failure"
+mayhem campaign add-experiment black-friday mayhem.yaml
+mayhem campaign add-experiment black-friday checkout-recovery.yaml
+mayhem campaign start black-friday                      # draft -> running
+mayhem campaign run black-friday --compose docker-compose.yml
+```
+
+A campaign is born `draft` and moves through
+`scheduled → running → paused → completed / aborted` (`archive` closes a
+finished campaign). Per-experiment results land in the observations table
+under the campaign id, and the failure policy selects the next action when
+one experiment fails:
+
+| `on_experiment_failure` | Meaning |
+|-------------------------|---------|
+| `abort_campaign` (default) | Stop the remaining experiments. |
+| `skip_and_continue` | Record the failure and run the next experiment. |
+| `retry_then_abort` | Retry the failed experiment once, then abort the campaign. |
+
+Window fields (`window_json`): `start_epoch_s` / `end_epoch_s`,
+`max_duration_s` (hard stop), and `cooldown_between_experiments_s` between
+successive experiments.
+
+---
+
+## CLI Reference
+
+Global options (accepted at any level, before or after the command):
+
+| Option | Meaning |
+|--------|---------|
+| `--db PATH` | SQLite database path (default `mayhem.db`). |
+| `--config PATH` | Path to `mayhem.yaml` (overrides auto-detection). |
+| `--profile NAME` | Configuration profile to merge. |
+| `--allow-critical` | Acknowledge `critical`-risk faults (e.g. `k8s.node_drain`). |
+| `--skip-gate` | Run even when the impact gate proved some faults inert. |
+| `--podman` | Use Podman instead of Docker. |
+| `--debug` | Re-raise errors instead of rendering them. |
+
+Commands:
+
+| Command | Description |
+|---------|-------------|
+| `mayhem topology discover` | Discover live services/hosts and the dependency edges from the blueprint. |
+| `mayhem validate SPEC` | Compile a drill spec and run every safety gate without injecting. |
+| `mayhem plan SPEC` | Compile against the topology and print the frozen plan JSON. |
+| `mayhem run SPEC` | Compile and execute a drill; print the run summary. `--ctr CONTAINER` scopes execution to one container (any `container_name:` value or runtime container name from the blueprint). |
+| `mayhem maniac SPEC` | Compile and execute a random-injection drill — draws `run_level` single-fault rounds governed by the maniac seed/level (spec `config.maniac`, falling back to the `maniac:` layer of `mayhem.yaml`). `--ctr CONTAINER` narrows every draw (and the zero-config synthesized pool) to one container. |
+| `mayhem status` | Show runs recorded in the database (`--json` supported). |
+| `mayhem history RUN_ID` | Replay steps, events, and leases recorded for one run. |
+| `mayhem recover RUN_ID` | Recover every orphaned fault lease belonging to a run. |
+| `mayhem janitor` | Sweep leases past their TTL; expire pending runs; compensate. |
+| `mayhem toolkit faults` | List the fault catalog with risk and compensatability. |
+| `mayhem toolkit list` | Probe the host for the tools/capabilities faults require. |
+| `mayhem experiment show SPEC` | Print the parsed drill spec as JSON. |
+| `mayhem experiment validate` | Alias of `validate`. |
+| `mayhem config show` / `mayhem config validate` | Inspect / validate the effective layered configuration (alias `cfg`). `show --json` also reports each section's provenance. |
+| `mayhem campaign list` | List campaigns (draft/scheduled/running/…; `--json`). |
+| `mayhem campaign create NAME` | Create a draft campaign (`--description`, `--hypothesis`). |
+| `mayhem campaign show / status / delete ID` | Inspect, poll, or delete a campaign. |
+| `mayhem campaign add-experiment ID SPEC` | Append a drill spec file to a campaign. |
+| `mayhem campaign start / abort / archive ID` | Move a campaign through its lifecycle. |
+| `mayhem campaign run ID` | Execute every experiment sequentially against the compose topology, honoring the campaign policy and window (`--no-gate` bypasses the impact gate). |
+
+Every command (and the whole tree) abbreviates to any unique prefix: `mayhem
+ex valid`, `mayhem t f`.
+
+---
+
+## Configuration
+
+Runtime policies live in `mayhem.yaml` — the *configuration* file, distinct
+from a `kind: drill` spec — auto-detected in the cwd or given with
+`--config`. The effective view is one command away: `mayhem config show`
+(alias `cfg`) prints the resolved configuration and the provenance of every
+section; `mayhem config validate` refuses unknown keys, a missing or wrong
+`apiVersion`, and out-of-range sections before anything runs.
+
+```yaml
+apiVersion: mayhem/v1        # required; anything else is rejected
+policy:
+  allow_faults: null         # null = whole catalog; set to restrict
+  deny_faults: []            # fault ids never injectable
+  risk_ceiling: null         # tightened by the drill ceiling at plan time
+  allow_critical: false      # config-side half of the critical opt-in
+blast_radius:
+  max_services_pct: 50.0
+  max_hosts: 2
+  max_concurrent_faults: 3
+  max_duration_per_fault_s: 300.0
+  forbidden_fault_pairs: []  # e.g. ["net.packet_loss", "net.bandwidth"]
+storage:
+  path: mayhem.db            # SQLite database (same default as --db)
+  artifacts_dir: .mayhem/artifacts
+toolkit:
+  binaries: {}               # pin a named tool's binary, keyed by fault backend
+runtime: docker              # docker | podman (CLI: --podman)
+target:
+  containers: []             # explicit targets when no compose file is used
+log_level: INFO              # DEBUG | INFO | WARNING | ERROR
+maniac:                      # fallback for `mayhem maniac` when the spec omits config.maniac
+  level: 2
+  run_level: 10
+  seed: null                 # null = fresh random seed each run
+```
+
+Layering, in increasing precedence: **built-in defaults → `mayhem.yaml` →
+`mayhem.{profile}.yaml` → environment variables → CLI flags**. Profile
+overlays are separate per-profile files (selected with `--profile NAME`) —
+there is no `profiles:` key inside `mayhem.yaml`. The environment layer only
+honours allowlisted variables: `MAYHEM_STORAGE_PATH`,
+`MAYHEM_ARTIFACTS_DIR`, `MAYHEM_LOG_LEVEL`.
+
+```bash
+mayhem config show            # YAML + sourced-from comments
+mayhem config show --json     # {"config": …, "sources": …}
+mayhem config validate        # exit 0 / 3 on invalid layers
+```
+
+Drill-level `config.risk_ceiling` composes with the policy ceiling and can
+only tighten it.
+
+---
+
+## Safety Model
+
+- **Risk ceilings.** Every catalog fault carries a risk level; injection is
+  refused when either the policy or the drill ceiling is exceeded.
+  `--allow-critical` is the operator-side acknowledgment.
+- **Concurrency budget.** `max_faults` caps simultaneously-injected faults;
+  a wider `parallel:` step queues into rounds.
+- **Duration caps.** Per-fault `duration` beyond the catalog maximum is a
+  compile error.
+- **Capability gating.** Faults declare the capabilities they need
+  (docker engine, net_admin, process control, …); the plan is proven against
+  the live graph by the impact gate before run — never assumed.
+- **Compensation contracts.** Reversible faults run their declared inverse;
+  irreversible ones are followed by workload reconciliation. A failed round
+  aborts-and-recovers its own faults first, then propagates.
+- **Lease hygiene.** Fault rounds hold leases with a TTL; `mayhem janitor`
+  sweeps orphaned leases and expires pending runs, `mayhem recover` repairs a
+  run's orphans on demand.
+
+---
+
+## Exit Codes
+
+Stable contract for scripts and CI (definition:
+[`src/mayhem/cli/exit_codes.py`](src/mayhem/cli/exit_codes.py)):
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | General failure |
+| 2 | Usage error (bad flags/arguments) |
+| 3 | Configuration layering/validation failed |
+| 4 | Spec/target validation failed |
+| 5 | A safety gate refused the operation |
+| 6 | Experiment ran and did not complete |
+| 7 | Recovery/janitor left dirty state behind |
+| 8 | Agent transport/runtime failure |
+| 9 | External tool invocation failed structurally |
+| 10 | Command prefix matched multiple commands |
+
+---
+
+## Architecture
+
+The pipeline is staged so everything expensive is done up front and execution
+is as small as possible:
+
+1. **Discover** — the topology provider builds a graph (services, hosts,
+   dependency edges) from the compose blueprint and live containers.
+2. **Prepare** — `mayhem config` layering (defaults → `mayhem.yaml` → profile →
+   env → flags) plus topology, drift detection, and target revalidation.
+3. **Compile & plan** — the drill spec becomes a frozen `ExecutionPlan` with
+   step sequences, per-fault compensations, success criteria, and observability
+   sources; every fault, target kind, capability, and duration is validated
+   against the catalog.
+4. **Execute** — the engine runs rounds (inject → observe → compensate) through
+   the runtime adapter, evaluates criteria, collects observability, and writes
+   step/event/lease rows with the governing-decision trace.
+5. **Recover & report** — the janitor sweeps orphaned leases; `status`,
+   `history`, and run summaries replay the evidence.
+
+### Documentation
+
+| Document | Contents |
+|----------|----------|
+| [README.md](README.md) | This file. |
+| [docs/drill-spec.md](docs/drill-spec.md) | **The drill DSL reference** — config, containers, execution, checks, success criteria, observability, and the full fault catalog. |
+| [docs/compensation.md](docs/compensation.md) | **Fault compensation lifecycle** — inject / undo / verify contracts, executor routing, marker conventions, and the per-fault template table. |
+
+### Status
+
+| Area | Status |
+|------|--------|
+| Domain models, configuration system | Complete |
+| Topology discovery (Docker/Podman) + compose project filtering + drift detection | Complete |
+| Fault catalog + registry + capability probing (`toolkit`) | Complete |
+| Drill spec DSL (config / containers / execution / checks) | Complete |
+| Deterministic + random planners, frozen plans | Complete |
+| Success criteria + machine verdict | Complete |
+| Declarative observability sources | Complete |
+| Run engine with compensation + leases + janitor + recover | Complete |
+| Safety gates + impact gate | Complete |
+| CLI with prefix abbreviation, stable exit codes | Complete |
+| SQLite persistence + restart, migrations (schema freeze) | Complete |
+| Campaigns (multi-spec runs) | Complete |
+| Tests (859 collected: 752 unit + 95 e2e + 12 integration), ruff, mypy (per-file strict) | Complete |
+| Kubernetes execution | Planned (interface-only; see [`examples/k8s`](examples/k8s)) |
+| Web UI / REST API | Planned |
+
+---
+
+## Development
+
+```bash
+# Clone, then sync the dev dependency group (requires https://docs.astral.sh/uv/):
+uv sync --group dev
+
+# Run all tests
+uv run pytest
+
+# Lint
+uv run ruff check src/
+
+# Type check (strict is configured per module)
+uv run mypy
+```

mayhem_cli-0.5.1.dist-info/RECORD

@@ -0,0 +1,107 @@
+mayhem/config.py,sha256=dJhQ4oLFL57imYs3aU2QUhcL1qhZv_gH7oFsC6yuslQ,7715
+mayhem/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mayhem/spec.py,sha256=QxhE90OzkUBJX03WGFkdBRGmN7PkO2_FzPQJb2NNLnU,1876
+mayhem/agent/__init__.py,sha256=GFXICPnXKO0n3rUtwCHDLdBa_wLlcVEBs_Aczu8jS-w,65
+mayhem/agent/cli.py,sha256=LIA6jGn-PkR3vMNZGUJXiegwYp0gHWFmKsPqJQUxLRk,1040
+mayhem/agents/__init__.py,sha256=HLHzcJE2hy4NSKvS9GL_mv5LPS-b16_RzYS2hBdf8Ro,71
+mayhem/agents/capabilities.py,sha256=bS2kF6xJSs-8EAYPuX4ctxQZS6yJteCx2YwPx8YdYG0,4045
+mayhem/agents/executors.py,sha256=I6A7j5xm00Fxnx8qc0uQ1rsnsTU9cL2lxnAJpeVsAq8,17745
+mayhem/agents/impact.py,sha256=VswHeBaUDtgaap0M1EVjWXleNXQPjemRme_cFM5JDpE,29834
+mayhem/agents/lease_client.py,sha256=G0x7PXHAaO9S1VJ8Hs_VQvVs0TywXq_Thlx_C7H4uIA,5289
+mayhem/agents/probes.py,sha256=RtLYSbcpqzNBiQQhKjM1bERZbPohvcHyFg9FIJ0Kt_E,11377
+mayhem/agents/protocol.py,sha256=0m-yevK1ymNlFfm16o3N8L2sXIA9Jqdksop0UJXtSCA,4212
+mayhem/agents/server.py,sha256=uW1Lmh7XWSItYYB3wiaJ2cyJaiW3WH-95GnJIJsigSQ,10530
+mayhem/agents/sinks.py,sha256=MmueFAXYr-h1xJ_D7CxC3atejw8_uMVnxck2FNxMi-0,1907
+mayhem/agents/transports.py,sha256=nPqvmhQd4MMAKLyvGTIoTosJp4-2bE7pWHitcjqJ6AQ,4863
+mayhem/agents/watchdog.py,sha256=15TawWyU5K7F71bI026LsPXXVJpY85fqI5dLvaMWxZM,4888
+mayhem/cli/__init__.py,sha256=8YnPhmrUa_FXrXGf_59KzLlKEu68o0AU3kD2Ogmnwus,315
+mayhem/cli/app.py,sha256=0K-pb2P1Vo5lPIBBYi0dSmRRgha1RN_U2am3_ZsJPNU,5086
+mayhem/cli/campaign.py,sha256=40AgPX1Oab9TllVSxZGd2Fje3Jobz1woOUSp3fIZl9o,18951
+mayhem/cli/config_cmd.py,sha256=slnw6gmB2wFt7tkeXNrTkqjfNGNrjG4jfjvrGRW3bOc,1567
+mayhem/cli/context.py,sha256=-rXsb6UxEH6K4GrF2InbmK6NvpbmzrTEo3e1QK2-Nxs,704
+mayhem/cli/dependency.py,sha256=U0eCPy6_M0xbzvIFhW7NgjE8iokLssCtUqcR8p1WFqc,16917
+mayhem/cli/exit_codes.py,sha256=954KstzNhKGNFPq9i3OOSra5v99poHZRRYzzQhj7RaM,1014
+mayhem/cli/experiment.py,sha256=sOEuQZt3NZTFxEdhBPyFvS_VJ9fJ0Rt-hl718XftnnM,730
+mayhem/cli/lifecycle.py,sha256=bTmd66FGjhAIjl7100x00b4i8TjNqc_Ius_AxBu3pgM,30767
+mayhem/cli/resolver.py,sha256=pJLhbiLKuAZfk5yoJMuMZjCuWVf0XwWbbcBa4POB2Rw,2783
+mayhem/cli/services.py,sha256=FqHPbraiJDVbM34bL4Luw_eypGiDNRQ0Y4tW0uBUkK0,15418
+mayhem/cli/style.py,sha256=Jb5DDvbVCQrKX-Mk61RTmWdJJOSd1x0EUPieZrM4CbA,3227
+mayhem/cli/toolkit.py,sha256=2DGjNfQyTfB-K4n_zpjEphInFZoBHpCh4UkOF65De7o,1649
+mayhem/cli/topology.py,sha256=xUXn27wR_7-2igPyT0Ksw4jymFed-djVMkuEljM9K2o,4217
+mayhem/controller/__init__.py,sha256=JV0geUIkFwcZZRgUnVi-1bd5RlBKq4yyo-aTwF8IxpM,74
+mayhem/controller/compensation.py,sha256=ZSBeLMGZbPZmEgj8jneedGCk8q1cxYsuhQokBxJPBu0,77435
+mayhem/controller/executor.py,sha256=3-eorfOLlVsnLswvpFIVD04nlBd9n-i3nKFKwARsqmU,73628
+mayhem/controller/janitor.py,sha256=rmOfOjhp6Ut_9txhS1LjLBGOLxEA8zk9UEBALZYciX4,7590
+mayhem/controller/observability_collector.py,sha256=W83v4JMyKLXLn01pHhVGGXkeZUUZdXKEkgAh8_yZibw,13331
+mayhem/controller/observations.py,sha256=lIUkUnnmxhS370433rOYDHhQpqLkTfHyqd-a4yKUa-U,3543
+mayhem/controller/planner.py,sha256=J30hm-kynaqDJeAy2PfKuFhDyP2GNqUp0BueO5DgeR0,28776
+mayhem/controller/recovery.py,sha256=pSZq2gLsUXqJT7XzXWqv7p7PLgMKKvM289VxAIVYuiw,9313
+mayhem/controller/resilience_report.py,sha256=9I3UTHY_N637bekMowQBqM2kKl2BnDV57Yx09YTSZTs,21702
+mayhem/controller/resource_manager.py,sha256=deyOrA82079-8h6HMQn-QyA6lk1t9xrYXAHIhaxKP64,18590
+mayhem/controller/safety.py,sha256=4DtQfKHthh_fpbQNoEVLE_iorRge8y4UM-SPJNcHhdk,14644
+mayhem/domain/__init__.py,sha256=RuJsWAUWymDh8uoK0cjR4FlDRsV1ERphhdM1z6Aok9Y,254
+mayhem/domain/campaigns.py,sha256=DhcIW81sIDk11Z4G8a5uw5ZMs96XKaLWW5cSSa3Yzz0,3773
+mayhem/domain/cancellation.py,sha256=HHou6pHbPZHo1x7adgWwTpQahPLc-Glv7xRjrlpzDBI,3524
+mayhem/domain/candidates.py,sha256=7g7t5s0O0vsN7aqFVQMeg_eTHN4WHxsp4TnMj0kuw_8,3172
+mayhem/domain/capabilities.py,sha256=gqVNUO0PTPy2theCuigPHPI29fYU2oTjDHrIIdEGYko,2723
+mayhem/domain/catalog.py,sha256=YqRErJLqCXmEUx4m9A8iJFsVHapi9zaOp_lKPC2BMK0,27770
+mayhem/domain/checks.py,sha256=gcU9gBfPx3rhibp112XE1W3N_8BgJvKJ9DYeKkBrA3w,4810
+mayhem/domain/common.py,sha256=j4G1OzKU4Mr4pfSU4GKaUgL2sON6PMH9VUFaoZEDAa0,3601
+mayhem/domain/coverage.py,sha256=cEJKCBVBDK5aavTyh9ealnGZ1KFfK6NT-vjR8n6ONtQ,3355
+mayhem/domain/decisions.py,sha256=IRLrrNqwVP_LucxzQYMGHnc54GkbEn8phTGFikHw3Lw,1754
+mayhem/domain/errors.py,sha256=dCaLQ5Hzc2qzjbk1n5leM8eCNAt5_nWh1k-CJk84mbU,2779
+mayhem/domain/events.py,sha256=xBGMBXfC4eFKvKBCkqY7OGwAE_R2xfNx4JkgwR5q7To,2039
+mayhem/domain/execution_context.py,sha256=GvLTYRzzaTCgia0MJc1nUmuhvdSjv1GsJ2xK7G8YeTE,4576
+mayhem/domain/execution_loci.py,sha256=zQWLUP_MRd8ik736Zk3MzFWqOhlrS43mJ5YjSRXichw,3360
+mayhem/domain/experiments.py,sha256=4sVfvcIk5deUdvIorbHopfi_7luKzMc9pEF5GGqeo44,13914
+mayhem/domain/faults.py,sha256=Ls-w8K1Gm1EM6f1dHfPXS3PURVWdfRldCrRuFZRrDmw,8308
+mayhem/domain/identity.py,sha256=G4hP-wBsi2JIzBg-qiNJe00ITB-_9_sdR48Xrv0yBXM,7540
+mayhem/domain/k8s_adapter.py,sha256=5JfhR1l8LHcHJ1JR1aGIfaAncnFS8qUs398nyh1p-D0,4919
+mayhem/domain/leases.py,sha256=uMqM9BowwrTKA8bn1T2Z-mw550jWubLiW-uFTeWfDN0,7371
+mayhem/domain/load_strategy.py,sha256=HyEBm4kPTOevS9zULeQG3_bGm04IrMzW_Bnc90o0XJ8,3461
+mayhem/domain/m5_campaign.py,sha256=7i3fsT1fNxh4EzVswqv1ssrBA6C_lt0Ncz8adaaKrTI,3740
+mayhem/domain/maniac.py,sha256=JU61KL92gcx9ZMNnlqEpptg6uO_3QvwGGWJhYTaL5o8,3548
+mayhem/domain/observability.py,sha256=8IboJIIuifCWrzyGkGYjL7_nOkAxntaZBtUmn9M1iAM,5281
+mayhem/domain/outcomes.py,sha256=K5m-NAv59Cs6We2uFXUbwvL6GYkD3eoesxu4BD9pFHo,3269
+mayhem/domain/remote_agent_interface.py,sha256=xAJbeTJWhjg2azDLwXEDDtsgsR-s1ftugSZUKxwFQoQ,2216
+mayhem/domain/resources.py,sha256=Nem2hibXe3-nfUWGsIkdD34fM7Urleg7tSpIyvJ497w,9035
+mayhem/domain/risks.py,sha256=FgkVP-tFjz2bkAECwY57PuiSXJV-CwhyGM3AQKvXGhY,1585
+mayhem/domain/run_outcome.py,sha256=ZHZCsTXvmFvkkAQxN2WMTM5N1lIVOEtKW89O1Axwv8E,4521
+mayhem/domain/runtime_adapter.py,sha256=1-TMz9nkR0RvM7Sk67nUc37mavuEJZmeQw7skfNgnRw,9003
+mayhem/domain/success.py,sha256=dlStGb1csg_QvlzvsGkyyeiOx8YEHLdrh04MCL_Q1xA,11614
+mayhem/domain/topology.py,sha256=a0F8pwi9GkE9X9h26QwxTMt-mt_NdN3MOXuLPP_O-sE,16787
+mayhem/infra/__init__.py,sha256=Jx4vcGjUyoY73TtMU3rHb10hO7ZS9zPK5pB7dnP3CqA,84
+mayhem/infra/campaign_engine.py,sha256=7TgXYxuB2-dJxEAqwE90qqL1mbS1XgKRQ8r-Wk4MrOY,8215
+mayhem/infra/candidate_gates.py,sha256=7XcwhtNXP_t-I1qf89nxfrOXEqI47v9yq83mCrmEktE,4489
+mayhem/infra/candidate_generator.py,sha256=yT_7jTRgqD2ZB40qMYqPmQrJwq9TGWqCSflKbnz1NAY,3914
+mayhem/infra/coverage_repository.py,sha256=ONOqLcTh28ZRJXOUuwiCOLYET1u3kOKOCyoa1DpUD5Y,3582
+mayhem/infra/lease_repository.py,sha256=cot8vrNQEWM0SheaMmlr_dIyjt_UK_XIzK24JgesKvw,5147
+mayhem/infra/maniac.py,sha256=RSt8H60_Vs6SEHj6OBsj_rEuOFsNK2uabdDbIXmwJns,3552
+mayhem/infra/migrations.py,sha256=kvLSq9zapCYCXI-QYr_xfN51f-e-sY757l_Zs5S6NwI,22669
+mayhem/infra/migrator.py,sha256=F5A-PPXHqEObETLqsFXpKxk2mkU-kOOLBLVFZlsK6yY,5884
+mayhem/infra/report.py,sha256=AlWvAsLmIFd8PASC3UBfa9NMkYwCuLDGrlW73uKC1xw,7709
+mayhem/infra/store.py,sha256=5zhb2s2KVAb2Ki6NIHZbBc5HYfqoErpML_g5rN1u9ao,7389
+mayhem/toolkit/__init__.py,sha256=FWrlzKn-WTsGvnWGV4dygf0HW2CVQXxumNSYQ5WsgWg,83
+mayhem/toolkit/fingerprint.py,sha256=4bK80htc7bOg5MNh7FscWyyDmcJqWpEEySVXNTGuJvk,2411
+mayhem/toolkit/hashing.py,sha256=Of2_uekYbs5D14YgScBoUv5ObCEA9h0Dw_srB_k_COI,811
+mayhem/toolkit/registry.py,sha256=5hcAldr058fTRpB_LGp5DOqc4s7XyOuOTwmIMeKcBbw,6830
+mayhem/toolkit/tool_runner.py,sha256=ZN3pFsbEs_Hac9L97ngq6tZeJu52r0IEpEia3QwR5Us,4108
+mayhem/toolkit/manifests/docker.yaml,sha256=ESmpaHX0ZEw59uCd8AQp8wTujippzttYrMPO5obnAeo,293
+mayhem/toolkit/manifests/podman.yaml,sha256=dRiqQkahxso7cOKfIqRskec1c6R58rcCWhQqw-OHwcQ,281
+mayhem/toolkit/manifests/stress-ng.yaml,sha256=kkWbIJerjV-KGMdQ6QEcoy8CGDYePKedfMAdc4wwuhY,261
+mayhem/toolkit/manifests/tc-netem.yaml,sha256=MZte3N9F3NGQQKnCl2IEga6oa4o_NCBpe9vqz9Z1cQc,258
+mayhem/toolkit/manifests/toxiproxy.yaml,sha256=FeKYlD2uSOSNzlR_XpLSftavA2wxUE9tqP6Q0e5sTqM,233
+mayhem/topology/__init__.py,sha256=Z8CgpWmlNmI6RgJC_FfuB4Kg8dvUszliBB8kXtTO-T0,355
+mayhem/topology/resolve.py,sha256=u_cuhamktbn-Iao5sVv1VeGxESaRbvDL57CVRtEbw0w,7283
+mayhem/topology/service.py,sha256=upu-9J23z_lWueJkIWf_M6dwO0Opt6R5upBjuNe5EHw,6130
+mayhem/topology/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mayhem/topology/providers/adapter_registry.py,sha256=gUxoiVNXAehhyGERzUidf474i-XFRKEsDyvuhUXoBJ0,2146
+mayhem/topology/providers/base.py,sha256=yh1sJHX8NkHZbBls59tntEXePEEMfTyQ5qJ_0_7Emko,931
+mayhem/topology/providers/compose.py,sha256=yf-SnOW1jyYycsxu2w2M57Dd7Uq3HluBjz23-tQKsBs,7341
+mayhem/topology/providers/docker_adapter.py,sha256=A829Uj8wKj4mVHwpyKiVjToPs2v02P7pwO4a3dDhjiw,9473
+mayhem/topology/providers/docker_runtime.py,sha256=g15opOT_QIchKl1_4tp6tp92noXfq3OXJaDo9aaDvRs,17183
+mayhem/topology/providers/podman_adapter.py,sha256=5yqaDaMH2ElJSgoFeIDF60ScAtgAW8ohLCk-m0ornIU,11525
+mayhem_cli-0.5.1.dist-info/METADATA,sha256=35wD1r-CzSLYES5N_iXRznzXyTXTIo-Isdsh0C9G8nU,22966
+mayhem_cli-0.5.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+mayhem_cli-0.5.1.dist-info/entry_points.txt,sha256=pCxl4SlE4VmN5Hl34n9Yyb5EFFGKGzWnSAnQb-KI9Bw,83
+mayhem_cli-0.5.1.dist-info/RECORD,,

mayhem_cli-0.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mayhem_cli-0.5.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mayhem = mayhem.cli.app:main
+mayhem-agent = mayhem.agent.cli:app