network-chaos-tool 0.1.0__tar.gz

network_chaos_tool-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: network-chaos-tool
+Version: 0.1.0
+Summary: Programmable chaos engineering tool for Docker-based network topologies
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: docker>=7.0.0
+
+# Network Chaos Tool
+
+A programmable chaos engineering tool that targets Docker-based network topologies. It injects network faults, like latency, packet loss, and more, into running containers at runtime using `tc` (traffic control) via a privileged sidecar, without requiring any special capabilities inside the target containers themselves.
+
+## Goal
+
+The end goal is a full-featured chaos engineering platform for Docker networks. It will allow users to define fault scenarios (e.g., "break OSPF adjacency," "add 200ms latency + 10% packet loss on an uplink") and run them on demand against containerized infrastructure. An observability stack will monitor and record how the network recovers.
+
+## What Has Been Done So Far (Phase 1)
+
+Phase 1 is a fully functional Proof of Concept (PoC) that proves we can manipulate the Linux kernel network parameters of any Docker container to simulate disasters.
+
+### Architecture
+
+- **One-shot privileged sidecar (`chaos-sidecar`)**: A Docker image containing the injector logic. It runs with `--privileged` and `--pid=host`, mounts the Docker socket, and enters the target container's network namespace using `nsenter` to run `tc` commands directly.
+- **Host-side CLI wrapper (`chaosctl`)**: A lightweight Python script that hides the `docker run` boilerplate. It auto-builds the sidecar image if missing and forwards your arguments transparently.
+- **Effect stacking**: Latency and packet loss can be combined. Running `--action latency` then `--action loss` produces a single composite `tc` rule (`delay 500ms loss 20%`) instead of overwriting the previous effect.
+- **Idempotent recovery**: A `--action clear` command removes all `tc` rules and restores normal network behavior.
+- **Zero victim requirements**: Target containers need **no extra capabilities**, no `iproute2`, and no pre-configuration. Any running Docker container can be a target.
+
+### Supported Faults
+
+| Action    | Description                                                |
+| --------- | ---------------------------------------------------------- |
+| `latency` | Add a fixed delay (ms) to all outgoing traffic.            |
+| `loss`    | Add a random packet loss (%) to all outgoing traffic.      |
+| `clear`   | Remove all `tc` rules and restore normal network behavior. |
+
+## Prerequisites
+
+- Docker Engine running locally.
+- Python 3.10+ with [uv](https://github.com/astral-sh/uv) installed.
+- A Linux host (or VM) where `nsenter` and `tc` are available.
+
+## Quick Start
+
+### 1. Build the victim test container
+
+```bash
+docker build -t chaos-victim tests/victim
+docker run -d --name victim chaos-victim
+```
+
+### 2. Verify baseline connectivity
+
+```bash
+docker exec victim ping -c 4 8.8.8.8
+```
+
+### 3. Inject chaos via `chaosctl`
+
+```bash
+# Add 500ms latency
+uv run chaosctl --target victim --action latency --value 500
+
+# Verify the effect
+docker exec victim ping -c 4 8.8.8.8
+
+# Stack 20% packet loss on top
+uv run chaosctl --target victim --action loss --value 20
+
+# Verify both effects
+docker exec victim ping -c 20 8.8.8.8
+
+# Recover
+uv run chaosctl --target victim --action clear
+
+# Verify recovery
+docker exec victim ping -c 4 8.8.8.8
+```
+
+### 4. Force rebuild the sidecar (optional)
+
+If you modify the sidecar `Dockerfile` or the injector code:
+
+```bash
+uv run chaosctl --target victim --action clear --rebuild
+```
+
+## Project Structure
+
+```
+proj/
+├── pyproject.toml              # uv project config
+├── uv.lock                     # Locked dependency tree
+├── Dockerfile                  # Sidecar image definition
+├── README.md                   # This file
+├── injector/                   # Core chaos logic
+│   ├── cli.py                  # Runs inside sidecar (nsenter logic)
+│   ├── docker_client.py        # Resolves container name -> PID
+│   ├── network_chaos.py        # tc command builder with stacking
+│   ├── sidecar_runner.py       # Host wrapper (chaosctl entrypoint)
+│   └── __main__.py             # Entry point for `python -m injector`
+└── tests/
+    └── victim/
+        └── Dockerfile          # Minimal Alpine victim for testing
+```

network_chaos_tool-0.1.0/README.md

@@ -0,0 +1,97 @@
+# Network Chaos Tool
+
+A programmable chaos engineering tool that targets Docker-based network topologies. It injects network faults, like latency, packet loss, and more, into running containers at runtime using `tc` (traffic control) via a privileged sidecar, without requiring any special capabilities inside the target containers themselves.
+
+## Goal
+
+The end goal is a full-featured chaos engineering platform for Docker networks. It will allow users to define fault scenarios (e.g., "break OSPF adjacency," "add 200ms latency + 10% packet loss on an uplink") and run them on demand against containerized infrastructure. An observability stack will monitor and record how the network recovers.
+
+## What Has Been Done So Far (Phase 1)
+
+Phase 1 is a fully functional Proof of Concept (PoC) that proves we can manipulate the Linux kernel network parameters of any Docker container to simulate disasters.
+
+### Architecture
+
+- **One-shot privileged sidecar (`chaos-sidecar`)**: A Docker image containing the injector logic. It runs with `--privileged` and `--pid=host`, mounts the Docker socket, and enters the target container's network namespace using `nsenter` to run `tc` commands directly.
+- **Host-side CLI wrapper (`chaosctl`)**: A lightweight Python script that hides the `docker run` boilerplate. It auto-builds the sidecar image if missing and forwards your arguments transparently.
+- **Effect stacking**: Latency and packet loss can be combined. Running `--action latency` then `--action loss` produces a single composite `tc` rule (`delay 500ms loss 20%`) instead of overwriting the previous effect.
+- **Idempotent recovery**: A `--action clear` command removes all `tc` rules and restores normal network behavior.
+- **Zero victim requirements**: Target containers need **no extra capabilities**, no `iproute2`, and no pre-configuration. Any running Docker container can be a target.
+
+### Supported Faults
+
+| Action    | Description                                                |
+| --------- | ---------------------------------------------------------- |
+| `latency` | Add a fixed delay (ms) to all outgoing traffic.            |
+| `loss`    | Add a random packet loss (%) to all outgoing traffic.      |
+| `clear`   | Remove all `tc` rules and restore normal network behavior. |
+
+## Prerequisites
+
+- Docker Engine running locally.
+- Python 3.10+ with [uv](https://github.com/astral-sh/uv) installed.
+- A Linux host (or VM) where `nsenter` and `tc` are available.
+
+## Quick Start
+
+### 1. Build the victim test container
+
+```bash
+docker build -t chaos-victim tests/victim
+docker run -d --name victim chaos-victim
+```
+
+### 2. Verify baseline connectivity
+
+```bash
+docker exec victim ping -c 4 8.8.8.8
+```
+
+### 3. Inject chaos via `chaosctl`
+
+```bash
+# Add 500ms latency
+uv run chaosctl --target victim --action latency --value 500
+
+# Verify the effect
+docker exec victim ping -c 4 8.8.8.8
+
+# Stack 20% packet loss on top
+uv run chaosctl --target victim --action loss --value 20
+
+# Verify both effects
+docker exec victim ping -c 20 8.8.8.8
+
+# Recover
+uv run chaosctl --target victim --action clear
+
+# Verify recovery
+docker exec victim ping -c 4 8.8.8.8
+```
+
+### 4. Force rebuild the sidecar (optional)
+
+If you modify the sidecar `Dockerfile` or the injector code:
+
+```bash
+uv run chaosctl --target victim --action clear --rebuild
+```
+
+## Project Structure
+
+```
+proj/
+├── pyproject.toml              # uv project config
+├── uv.lock                     # Locked dependency tree
+├── Dockerfile                  # Sidecar image definition
+├── README.md                   # This file
+├── injector/                   # Core chaos logic
+│   ├── cli.py                  # Runs inside sidecar (nsenter logic)
+│   ├── docker_client.py        # Resolves container name -> PID
+│   ├── network_chaos.py        # tc command builder with stacking
+│   ├── sidecar_runner.py       # Host wrapper (chaosctl entrypoint)
+│   └── __main__.py             # Entry point for `python -m injector`
+└── tests/
+    └── victim/
+        └── Dockerfile          # Minimal Alpine victim for testing
+```

network_chaos_tool-0.1.0/injector/__main__.py

@@ -0,0 +1,4 @@
+from injector.cli import main
+
+if __name__ == "__main__":
+    main()

network_chaos_tool-0.1.0/injector/cli.py

@@ -0,0 +1,61 @@
+"""CLI entry point for the chaos injector."""
+
+import argparse
+import sys
+
+from injector.docker_client import get_container_pid
+from injector.network_chaos import add_latency, add_loss, clear_rules
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Inject network chaos into a Docker container."
+    )
+    parser.add_argument(
+        "--target",
+        "-t",
+        required=True,
+        help="Name or ID of the target container.",
+    )
+    parser.add_argument(
+        "--action",
+        "-a",
+        required=True,
+        choices=["latency", "loss", "clear"],
+        help="Chaos action to apply.",
+    )
+    parser.add_argument(
+        "--value",
+        "-v",
+        type=int,
+        help="Value for the action (ms for latency, percent for loss). Not needed for 'clear'.",
+    )
+
+    args = parser.parse_args()
+
+    if args.action in ("latency", "loss") and args.value is None:
+        parser.error(f"--value is required when action is '{args.action}'.")
+
+    try:
+        pid = get_container_pid(args.target)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        if args.action == "latency":
+            add_latency(pid, args.value)
+            print(f"Added {args.value}ms latency to container '{args.target}'.")
+        elif args.action == "loss":
+            add_loss(pid, args.value)
+            print(f"Added {args.value}% packet loss to container '{args.target}'.")
+        elif args.action == "clear":
+            clear_rules(pid)
+            print(f"Cleared all tc rules from container '{args.target}'.")
+    except RuntimeError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

network_chaos_tool-0.1.0/injector/docker_client.py

@@ -0,0 +1,50 @@
+"""Thin wrapper around the Docker SDK for container lookup."""
+
+import docker
+from docker.errors import NotFound
+
+
+def get_container(name_or_id: str):
+    """Find a running container by name or ID.
+
+    Args:
+        name_or_id: The Docker container name or short/long ID.
+
+    Returns:
+        A docker.models.containers.Container object.
+
+    Raises:
+        ValueError: If the container is not found or not running.
+    """
+    client = docker.from_env()
+
+    try:
+        container = client.containers.get(name_or_id)
+    except NotFound as exc:
+        raise ValueError(f"Container '{name_or_id}' not found.") from exc
+
+    if container.status != "running":
+        raise ValueError(
+            f"Container '{name_or_id}' is not running (status: {container.status})."
+        )
+
+    return container
+
+
+def get_container_pid(name_or_id: str) -> int:
+    """Find a running container and return its host PID.
+
+    Args:
+        name_or_id: The Docker container name or short/long ID.
+
+    Returns:
+        The host PID (int) of the container's init process.
+
+    Raises:
+        ValueError: If the container is not found or not running.
+    """
+    container = get_container(name_or_id)
+    pid = container.attrs.get("State", {}).get("Pid")
+    if not pid:
+        raise ValueError(f"Could not determine PID for container '{name_or_id}'.")
+    return pid

network_chaos_tool-0.1.0/injector/network_chaos.py

@@ -0,0 +1,139 @@
+"""Network chaos injection using tc (traffic control) via nsenter."""
+
+import re
+import subprocess
+
+
+def _exec_tc_in_netns(pid: int, command: str):
+    """Execute a tc command inside the target container's network namespace.
+
+    Args:
+        pid: Host PID of the target container's init process.
+        command: The tc sub-command (e.g. "qdisc add dev eth0 root netem delay 500ms").
+
+    Returns:
+        subprocess.CompletedProcess result.
+    """
+    full_cmd = ["nsenter", "-t", str(pid), "-n", "tc"] + command.split()
+    result = subprocess.run(
+        full_cmd,
+        capture_output=True,
+        text=True,
+    )
+    return result
+
+
+def _is_no_such_file_error(output: str) -> bool:
+    """Check if tc output indicates the qdisc does not exist."""
+    text = output.lower()
+    return (
+        "no such file" in text
+        or "cannot find device" in text
+        or "invalid argument" in text
+        or "cannot delete qdisc with handle of zero" in text
+    )
+
+
+def _get_current_netem_params(pid: int) -> dict:
+    """Inspect current netem parameters on eth0.
+
+    Returns:
+        A dict like {"delay": 500, "loss": 20} or {} if no netem qdisc exists.
+    """
+    result = _exec_tc_in_netns(pid, "qdisc show dev eth0")
+    if result.returncode != 0:
+        return {}
+
+    # Look for a line like:
+    # qdisc netem 8002: root refcnt 2 limit 1000 delay 500ms loss 20%
+    match = re.search(r"qdisc\s+netem\s+\S+:\s+root.*", result.stdout)
+    if not match:
+        return {}
+
+    line = match.group(0)
+    params = {}
+    delay_match = re.search(r"delay\s+(\d+)ms", line)
+    if delay_match:
+        params["delay"] = int(delay_match.group(1))
+    loss_match = re.search(r"loss\s+(\d+(?:\.\d+)?)%", line)
+    if loss_match:
+        params["loss"] = float(loss_match.group(1))
+    return params
+
+
+def _build_netem_command(action: str, params: dict) -> str:
+    """Build a tc qdisc command string from action and params.
+
+    Args:
+        action: Either "add" or "change".
+        params: Dict with optional keys "delay" (int, ms) and "loss" (float, percent).
+
+    Returns:
+        Full tc sub-command string (e.g. "qdisc change dev eth0 root netem delay 500ms loss 20%").
+    """
+    parts = [f"qdisc {action} dev eth0 root netem"]
+    if "delay" in params:
+        parts.append(f"delay {int(params['delay'])}ms")
+    if "loss" in params:
+        parts.append(f"loss {float(params['loss'])}%")
+    return " ".join(parts)
+
+
+def clear_rules(pid: int):
+    """Remove all tc rules on eth0 inside the container's network namespace.
+
+    This is idempotent: if no rules exist, it does not raise.
+    """
+    result = _exec_tc_in_netns(pid, "qdisc del dev eth0 root")
+    if result.returncode != 0 and not _is_no_such_file_error(result.stderr):
+        raise RuntimeError(f"Failed to clear tc rules: {result.stderr.strip()}")
+
+
+def add_latency(pid: int, ms: int):
+    """Add latency to all outgoing traffic on eth0.
+
+    If a loss rule already exists, it is preserved and merged.
+
+    Args:
+        pid: Host PID of the target container's init process.
+        ms: Latency in milliseconds.
+    """
+    if ms < 0:
+        raise ValueError("Latency must be non-negative.")
+
+    current = _get_current_netem_params(pid)
+    current["delay"] = ms
+
+    action = "change" if _has_netem_qdisc(pid) else "add"
+    cmd = _build_netem_command(action, current)
+    result = _exec_tc_in_netns(pid, cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to add latency: {result.stderr.strip()}")
+
+
+def add_loss(pid: int, percent: int):
+    """Add packet loss to all outgoing traffic on eth0.
+
+    If a latency rule already exists, it is preserved and merged.
+
+    Args:
+        pid: Host PID of the target container's init process.
+        percent: Packet loss percentage (0-100).
+    """
+    if not 0 <= percent <= 100:
+        raise ValueError("Loss percent must be between 0 and 100.")
+
+    current = _get_current_netem_params(pid)
+    current["loss"] = percent
+
+    action = "change" if _has_netem_qdisc(pid) else "add"
+    cmd = _build_netem_command(action, current)
+    result = _exec_tc_in_netns(pid, cmd)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to add loss: {result.stderr.strip()}")
+
+
+def _has_netem_qdisc(pid: int) -> bool:
+    """Check if a netem qdisc currently exists on eth0."""
+    result = _exec_tc_in_netns(pid, "qdisc show dev eth0")
+    return result.returncode == 0 and "netem" in result.stdout

network_chaos_tool-0.1.0/injector/sidecar_runner.py

@@ -0,0 +1,120 @@
+"""Host-side wrapper that launches the chaos-sidecar container."""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+SIDECAR_IMAGE = "chaos-sidecar"
+
+
+def _ensure_image():
+    """Check if the sidecar image exists locally; auto-build if missing."""
+    result = subprocess.run(
+        ["docker", "images", "-q", SIDECAR_IMAGE],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError("Docker does not seem to be running or is not installed.")
+
+    if not result.stdout.strip():
+        print(f"'{SIDECAR_IMAGE}' image not found locally. Building...")
+        _build_image()
+        print(f"'{SIDECAR_IMAGE}' built successfully.")
+
+
+def _build_image():
+    """Build the sidecar Docker image from the project root."""
+    project_root = Path(__file__).resolve().parent.parent
+    dockerfile = project_root / "Dockerfile"
+
+    if not dockerfile.exists():
+        raise RuntimeError(
+            f"Dockerfile not found at {dockerfile}. "
+            "Cannot auto-build the sidecar image."
+        )
+
+    subprocess.run(
+        ["docker", "build", "-t", SIDECAR_IMAGE, str(project_root)],
+        check=True,
+    )
+
+
+def _run_sidecar(args: argparse.Namespace):
+    """Launch the sidecar container with the requested chaos args."""
+    cmd = [
+        "docker",
+        "run",
+        "--rm",
+        "--privileged",
+        "--pid=host",
+        "-v",
+        "/var/run/docker.sock:/var/run/docker.sock",
+        SIDECAR_IMAGE,
+        "--target",
+        args.target,
+        "--action",
+        args.action,
+    ]
+
+    if args.value is not None:
+        cmd.extend(["--value", str(args.value)])
+
+    subprocess.run(cmd, check=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Inject network chaos into a Docker container (host-side wrapper)."
+    )
+    parser.add_argument(
+        "--target",
+        "-t",
+        required=True,
+        help="Name or ID of the target container.",
+    )
+    parser.add_argument(
+        "--action",
+        "-a",
+        required=True,
+        choices=["latency", "loss", "clear"],
+        help="Chaos action to apply.",
+    )
+    parser.add_argument(
+        "--value",
+        "-v",
+        type=int,
+        help="Value for the action (ms for latency, percent for loss). Not needed for 'clear'.",
+    )
+    parser.add_argument(
+        "--rebuild",
+        action="store_true",
+        help="Force rebuild of the sidecar image before running.",
+    )
+
+    args = parser.parse_args()
+
+    if args.action in ("latency", "loss") and args.value is None:
+        parser.error(f"--value is required when action is '{args.action}'.")
+
+    try:
+        if args.rebuild:
+            _build_image()
+        else:
+            _ensure_image()
+
+        _run_sidecar(args)
+    except subprocess.CalledProcessError as exc:
+        print(
+            f"Error: Command failed with exit code {exc.returncode}.", file=sys.stderr
+        )
+        sys.exit(1)
+    except RuntimeError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

network_chaos_tool-0.1.0/network_chaos_tool.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: network-chaos-tool
+Version: 0.1.0
+Summary: Programmable chaos engineering tool for Docker-based network topologies
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: docker>=7.0.0
+
+# Network Chaos Tool
+
+A programmable chaos engineering tool that targets Docker-based network topologies. It injects network faults, like latency, packet loss, and more, into running containers at runtime using `tc` (traffic control) via a privileged sidecar, without requiring any special capabilities inside the target containers themselves.
+
+## Goal
+
+The end goal is a full-featured chaos engineering platform for Docker networks. It will allow users to define fault scenarios (e.g., "break OSPF adjacency," "add 200ms latency + 10% packet loss on an uplink") and run them on demand against containerized infrastructure. An observability stack will monitor and record how the network recovers.
+
+## What Has Been Done So Far (Phase 1)
+
+Phase 1 is a fully functional Proof of Concept (PoC) that proves we can manipulate the Linux kernel network parameters of any Docker container to simulate disasters.
+
+### Architecture
+
+- **One-shot privileged sidecar (`chaos-sidecar`)**: A Docker image containing the injector logic. It runs with `--privileged` and `--pid=host`, mounts the Docker socket, and enters the target container's network namespace using `nsenter` to run `tc` commands directly.
+- **Host-side CLI wrapper (`chaosctl`)**: A lightweight Python script that hides the `docker run` boilerplate. It auto-builds the sidecar image if missing and forwards your arguments transparently.
+- **Effect stacking**: Latency and packet loss can be combined. Running `--action latency` then `--action loss` produces a single composite `tc` rule (`delay 500ms loss 20%`) instead of overwriting the previous effect.
+- **Idempotent recovery**: A `--action clear` command removes all `tc` rules and restores normal network behavior.
+- **Zero victim requirements**: Target containers need **no extra capabilities**, no `iproute2`, and no pre-configuration. Any running Docker container can be a target.
+
+### Supported Faults
+
+| Action    | Description                                                |
+| --------- | ---------------------------------------------------------- |
+| `latency` | Add a fixed delay (ms) to all outgoing traffic.            |
+| `loss`    | Add a random packet loss (%) to all outgoing traffic.      |
+| `clear`   | Remove all `tc` rules and restore normal network behavior. |
+
+## Prerequisites
+
+- Docker Engine running locally.
+- Python 3.10+ with [uv](https://github.com/astral-sh/uv) installed.
+- A Linux host (or VM) where `nsenter` and `tc` are available.
+
+## Quick Start
+
+### 1. Build the victim test container
+
+```bash
+docker build -t chaos-victim tests/victim
+docker run -d --name victim chaos-victim
+```
+
+### 2. Verify baseline connectivity
+
+```bash
+docker exec victim ping -c 4 8.8.8.8
+```
+
+### 3. Inject chaos via `chaosctl`
+
+```bash
+# Add 500ms latency
+uv run chaosctl --target victim --action latency --value 500
+
+# Verify the effect
+docker exec victim ping -c 4 8.8.8.8
+
+# Stack 20% packet loss on top
+uv run chaosctl --target victim --action loss --value 20
+
+# Verify both effects
+docker exec victim ping -c 20 8.8.8.8
+
+# Recover
+uv run chaosctl --target victim --action clear
+
+# Verify recovery
+docker exec victim ping -c 4 8.8.8.8
+```
+
+### 4. Force rebuild the sidecar (optional)
+
+If you modify the sidecar `Dockerfile` or the injector code:
+
+```bash
+uv run chaosctl --target victim --action clear --rebuild
+```
+
+## Project Structure
+
+```
+proj/
+├── pyproject.toml              # uv project config
+├── uv.lock                     # Locked dependency tree
+├── Dockerfile                  # Sidecar image definition
+├── README.md                   # This file
+├── injector/                   # Core chaos logic
+│   ├── cli.py                  # Runs inside sidecar (nsenter logic)
+│   ├── docker_client.py        # Resolves container name -> PID
+│   ├── network_chaos.py        # tc command builder with stacking
+│   ├── sidecar_runner.py       # Host wrapper (chaosctl entrypoint)
+│   └── __main__.py             # Entry point for `python -m injector`
+└── tests/
+    └── victim/
+        └── Dockerfile          # Minimal Alpine victim for testing
+```

network_chaos_tool-0.1.0/network_chaos_tool.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+injector/__init__.py
+injector/__main__.py
+injector/cli.py
+injector/docker_client.py
+injector/network_chaos.py
+injector/sidecar_runner.py
+network_chaos_tool.egg-info/PKG-INFO
+network_chaos_tool.egg-info/SOURCES.txt
+network_chaos_tool.egg-info/dependency_links.txt
+network_chaos_tool.egg-info/entry_points.txt
+network_chaos_tool.egg-info/requires.txt
+network_chaos_tool.egg-info/top_level.txt

network_chaos_tool-0.1.0/network_chaos_tool.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

network_chaos_tool-0.1.0/network_chaos_tool.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+chaos = injector.cli:main
+chaosctl = injector.sidecar_runner:main

network_chaos_tool-0.1.0/network_chaos_tool.egg-info/requires.txt

@@ -0,0 +1 @@
+docker>=7.0.0

network_chaos_tool-0.1.0/network_chaos_tool.egg-info/top_level.txt

@@ -0,0 +1 @@
+injector

network_chaos_tool-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "network-chaos-tool"
+version = "0.1.0"
+description = "Programmable chaos engineering tool for Docker-based network topologies"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "docker>=7.0.0",
+]
+
+[project.scripts]
+chaos = "injector.cli:main"
+chaosctl = "injector.sidecar_runner:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

network_chaos_tool-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+