didericis
69db629e16
Rewire DockerBottleBackend.launch to the consolidated model, replacing the
per-bottle sidecar bundle. VALIDATED END-TO-END on real docker:
test_sandbox_escape passes all 5 attacks (egress DLP + git-gate gitleaks)
through the shared gateway.
launch now:
- mints git-gate dynamic keys (if any), then launch_consolidated() to
register the bottle + provision its git-gate state into the gateway and
get the agent's attach context (pinned source IP, gateway address);
- installs the SHARED gateway CA (gateway.ca_cert_pem) into the agent;
- renders the agent-only consolidated compose on the gateway network at the
pinned IP, proxied through the gateway;
- points the agent's git-gate insteadOf (http://<gw>:9420) and supervise
MCP (http://<gw>:9100) at the gateway (DockerBottlePlan.agent_git_gate_url
/ agent_supervise_url);
- teardown = compose down + teardown_consolidated (dereg + deprovision).
Dropped the per-bottle networks, per-bottle egress CA, and bundle service.
Fixes surfaced by the real e2e (couldn't be caught by unit mocks):
- provision_git_gate installs the bottle-agnostic pre-receive/access hooks
into the gateway (were cp'd per-bundle before);
- source-IP allocation reads the *actual* container IPs on the network
(gateway + orchestrator + agents), not just gateway + registry — the
orchestrator container sits on the network and was colliding.
Unit tests for the old bundle launch rewritten against the new collaborators.
NOTE for reviewers: the gateway/bundle image (bot-bottle-sidecars) must be
rebuilt when its flat sources change — `ensure_built` only builds-if-missing,
so a stale image silently runs the OLD single-tenant daemons. A content-hash
/ --rebuild path is a follow-up.
pyright 0 errors; pylint 9.83/10; unit suite green (1760 tests; the 13
test_sidecar_init /bin/sleep errors are pre-existing NixOS-local noise);
test_sandbox_escape green on real docker.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WBMWTEtQdJ4W5UrWuLHCck
93 lines
3.6 KiB
Python
93 lines
3.6 KiB
Python
"""Unit: consolidated launch sequence — compose the orchestrator primitives (PRD 0070)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, Mock, patch
|
|
|
|
from bot_bottle.backend.docker.consolidated_launch import (
|
|
launch_consolidated,
|
|
teardown_consolidated,
|
|
)
|
|
from bot_bottle.egress import EgressPlan, EgressRoute
|
|
from bot_bottle.git_gate import GitGatePlan
|
|
from bot_bottle.orchestrator.client import RegisteredBottle
|
|
|
|
_MOD = "bot_bottle.backend.docker.consolidated_launch"
|
|
|
|
|
|
def _egress_plan() -> EgressPlan:
|
|
return EgressPlan(
|
|
slug="demo", routes_path=Path("/x"), routes=(EgressRoute(host="api.example.com"),),
|
|
token_env_map={},
|
|
)
|
|
|
|
|
|
def _git_plan() -> GitGatePlan:
|
|
return GitGatePlan(
|
|
slug="demo", entrypoint_script=Path(), hook_script=Path(),
|
|
access_hook_script=Path(), upstreams=(),
|
|
)
|
|
|
|
|
|
def _client(*, bottles: list[dict[str, object]] | None = None) -> Mock:
|
|
c = Mock()
|
|
c.list_bottles.return_value = bottles or []
|
|
c.register_bottle.return_value = RegisteredBottle("b1", "tok")
|
|
return c
|
|
|
|
|
|
class TestLaunchConsolidated(unittest.TestCase):
|
|
def _run(self, client: Mock, provision: Mock | None = None, *, on_network=("172.18.0.2",)):
|
|
service = MagicMock()
|
|
service.ensure_running.return_value = "http://orch:8080"
|
|
with patch(f"{_MOD}._network_cidr", return_value="172.18.0.0/16"), \
|
|
patch(f"{_MOD}._container_ip", return_value="172.18.0.2"), \
|
|
patch(f"{_MOD}._network_container_ips", return_value=list(on_network)), \
|
|
patch(f"{_MOD}.OrchestratorClient", return_value=client), \
|
|
patch(f"{_MOD}.provision_git_gate", provision or Mock()):
|
|
return launch_consolidated(_egress_plan(), _git_plan(), service=service)
|
|
|
|
def test_allocates_ip_registers_and_provisions(self) -> None:
|
|
client = _client()
|
|
provision = Mock()
|
|
ctx = self._run(client, provision)
|
|
# .1 is the router, .2 is the gateway → first bottle gets .3.
|
|
self.assertEqual("172.18.0.3", ctx.source_ip)
|
|
self.assertEqual("172.18.0.2", ctx.gateway_ip)
|
|
self.assertEqual("b1", ctx.bottle_id)
|
|
self.assertEqual("tok", ctx.identity_token)
|
|
self.assertEqual("http://orch:8080", ctx.orchestrator_url)
|
|
# Registered with the source IP + the egress policy blob.
|
|
kwargs = client.register_bottle.call_args
|
|
self.assertEqual("172.18.0.3", kwargs.args[0])
|
|
self.assertIn("api.example.com", kwargs.kwargs["policy"])
|
|
provision.assert_called_once()
|
|
|
|
def test_skips_all_addresses_on_the_network(self) -> None:
|
|
# Gateway .2 + orchestrator .3 already attached -> agent gets .4.
|
|
ctx = self._run(_client(), on_network=("172.18.0.2", "172.18.0.3"))
|
|
self.assertEqual("172.18.0.4", ctx.source_ip)
|
|
|
|
def test_provision_failure_rolls_back_registration(self) -> None:
|
|
client = _client()
|
|
provision = Mock(side_effect=RuntimeError("provision boom"))
|
|
with self.assertRaises(RuntimeError):
|
|
self._run(client, provision)
|
|
client.teardown_bottle.assert_called_once_with("b1") # no orphan left
|
|
|
|
|
|
class TestTeardownConsolidated(unittest.TestCase):
|
|
def test_deregisters_and_deprovisions(self) -> None:
|
|
client = Mock()
|
|
with patch(f"{_MOD}.OrchestratorClient", return_value=client), \
|
|
patch(f"{_MOD}.deprovision_git_gate") as deprov:
|
|
teardown_consolidated("b1", orchestrator_url="http://orch:8080")
|
|
client.teardown_bottle.assert_called_once_with("b1")
|
|
deprov.assert_called_once()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|