mirror of
https://github.com/basnijholt/compose-farm.git
synced 2026-02-03 14:13:26 +00:00
6fbc7430cb
* perf: Optimize stray detection to use 1 SSH call per host
Previously, stray detection checked each stack on each host individually,
resulting in (stacks * hosts) SSH calls. For 50 stacks across 4 hosts,
this meant ~200 parallel SSH connections, causing "Connection lost" errors.
Now queries each host once for all running compose projects using:
docker ps --format '{{.Label "com.docker.compose.project"}}' | sort -u
This reduces SSH calls from ~200 to just 4 (one per host).
Changes:
- Add get_running_stacks_on_host() in executor.py
- Add discover_all_stacks_on_all_hosts() in operations.py
- Update _discover_stacks_full() to use the batch approach
* Remove unused function and add tests
- Remove discover_stack_on_all_hosts() which is no longer used
- Add tests for get_running_stacks_on_host()
- Add tests for discover_all_stacks_on_all_hosts()
- Verifies it returns correct StackDiscoveryResult
- Verifies stray detection works
- Verifies it makes only 1 call per host (not per stack)
271 lines
8.9 KiB
Python
271 lines
8.9 KiB
Python
"""Tests for executor module."""
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from compose_farm.config import Config, Host
|
|
from compose_farm.executor import (
|
|
CommandResult,
|
|
_run_local_command,
|
|
check_networks_exist,
|
|
check_paths_exist,
|
|
get_running_stacks_on_host,
|
|
is_local,
|
|
run_command,
|
|
run_compose,
|
|
run_on_stacks,
|
|
)
|
|
|
|
# These tests run actual shell commands that only work on Linux
|
|
linux_only = pytest.mark.skipif(sys.platform != "linux", reason="Linux-only shell commands")
|
|
|
|
|
|
class TestIsLocal:
|
|
"""Tests for is_local function."""
|
|
|
|
@pytest.mark.parametrize(
|
|
"address",
|
|
["local", "localhost", "127.0.0.1", "::1", "LOCAL", "LOCALHOST"],
|
|
)
|
|
def test_local_addresses(self, address: str) -> None:
|
|
host = Host(address=address)
|
|
assert is_local(host) is True
|
|
|
|
@pytest.mark.parametrize(
|
|
"address",
|
|
["192.168.1.10", "nas01.local", "10.0.0.1", "example.com"],
|
|
)
|
|
def test_remote_addresses(self, address: str) -> None:
|
|
host = Host(address=address)
|
|
assert is_local(host) is False
|
|
|
|
|
|
class TestRunLocalCommand:
|
|
"""Tests for local command execution."""
|
|
|
|
async def test_run_local_command_success(self) -> None:
|
|
result = await _run_local_command("echo hello", "test-service")
|
|
assert result.success is True
|
|
assert result.exit_code == 0
|
|
assert result.stack == "test-service"
|
|
|
|
async def test_run_local_command_failure(self) -> None:
|
|
result = await _run_local_command("exit 1", "test-service")
|
|
assert result.success is False
|
|
assert result.exit_code == 1
|
|
|
|
async def test_run_local_command_not_found(self) -> None:
|
|
result = await _run_local_command("nonexistent_command_xyz", "test-service")
|
|
assert result.success is False
|
|
assert result.exit_code != 0
|
|
|
|
async def test_run_local_command_captures_output(self) -> None:
|
|
result = await _run_local_command("echo hello", "test-service", stream=False)
|
|
assert "hello" in result.stdout
|
|
|
|
|
|
class TestRunCommand:
|
|
"""Tests for run_command dispatcher."""
|
|
|
|
async def test_run_command_local(self) -> None:
|
|
host = Host(address="localhost")
|
|
result = await run_command(host, "echo test", "test-service")
|
|
assert result.success is True
|
|
|
|
async def test_run_command_result_structure(self) -> None:
|
|
host = Host(address="local")
|
|
result = await run_command(host, "true", "my-service")
|
|
assert isinstance(result, CommandResult)
|
|
assert result.stack == "my-service"
|
|
assert result.exit_code == 0
|
|
assert result.success is True
|
|
|
|
|
|
class TestRunCompose:
|
|
"""Tests for compose command execution."""
|
|
|
|
async def test_run_compose_builds_correct_command(self, tmp_path: Path) -> None:
|
|
# Create a minimal compose file
|
|
compose_dir = tmp_path / "compose"
|
|
stack_dir = compose_dir / "test-service"
|
|
stack_dir.mkdir(parents=True)
|
|
compose_file = stack_dir / "docker-compose.yml"
|
|
compose_file.write_text("services: {}")
|
|
|
|
config = Config(
|
|
compose_dir=compose_dir,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={"test-service": "local"},
|
|
)
|
|
|
|
# This will fail because docker compose isn't running,
|
|
# but we can verify the command structure works
|
|
result = await run_compose(config, "test-service", "config", stream=False)
|
|
# Command may fail due to no docker, but structure is correct
|
|
assert result.stack == "test-service"
|
|
|
|
|
|
class TestRunOnStacks:
|
|
"""Tests for parallel stack execution."""
|
|
|
|
async def test_run_on_stacks_parallel(self) -> None:
|
|
config = Config(
|
|
compose_dir=Path("/tmp"),
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={"svc1": "local", "svc2": "local"},
|
|
)
|
|
|
|
# Use a simple command that will work without docker
|
|
# We'll test the parallelism structure
|
|
results = await run_on_stacks(config, ["svc1", "svc2"], "version", stream=False)
|
|
assert len(results) == 2
|
|
assert results[0].stack == "svc1"
|
|
assert results[1].stack == "svc2"
|
|
|
|
|
|
@linux_only
|
|
class TestCheckPathsExist:
|
|
"""Tests for check_paths_exist function (uses 'test -e' shell command)."""
|
|
|
|
async def test_check_existing_paths(self, tmp_path: Path) -> None:
|
|
"""Check paths that exist."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
# Create test paths
|
|
(tmp_path / "dir1").mkdir()
|
|
(tmp_path / "file1").touch()
|
|
|
|
result = await check_paths_exist(
|
|
config, "local", [str(tmp_path / "dir1"), str(tmp_path / "file1")]
|
|
)
|
|
|
|
assert result[str(tmp_path / "dir1")] is True
|
|
assert result[str(tmp_path / "file1")] is True
|
|
|
|
async def test_check_missing_paths(self, tmp_path: Path) -> None:
|
|
"""Check paths that don't exist."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await check_paths_exist(
|
|
config, "local", [str(tmp_path / "missing1"), str(tmp_path / "missing2")]
|
|
)
|
|
|
|
assert result[str(tmp_path / "missing1")] is False
|
|
assert result[str(tmp_path / "missing2")] is False
|
|
|
|
async def test_check_mixed_paths(self, tmp_path: Path) -> None:
|
|
"""Check mix of existing and missing paths."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
(tmp_path / "exists").mkdir()
|
|
|
|
result = await check_paths_exist(
|
|
config, "local", [str(tmp_path / "exists"), str(tmp_path / "missing")]
|
|
)
|
|
|
|
assert result[str(tmp_path / "exists")] is True
|
|
assert result[str(tmp_path / "missing")] is False
|
|
|
|
async def test_check_empty_paths(self, tmp_path: Path) -> None:
|
|
"""Empty path list returns empty dict."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await check_paths_exist(config, "local", [])
|
|
assert result == {}
|
|
|
|
|
|
@linux_only
|
|
class TestCheckNetworksExist:
|
|
"""Tests for check_networks_exist function (requires Docker)."""
|
|
|
|
async def test_check_bridge_network_exists(self, tmp_path: Path) -> None:
|
|
"""The 'bridge' network always exists on Docker hosts."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await check_networks_exist(config, "local", ["bridge"])
|
|
assert result["bridge"] is True
|
|
|
|
async def test_check_nonexistent_network(self, tmp_path: Path) -> None:
|
|
"""Check a network that doesn't exist."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await check_networks_exist(config, "local", ["nonexistent_network_xyz_123"])
|
|
assert result["nonexistent_network_xyz_123"] is False
|
|
|
|
async def test_check_mixed_networks(self, tmp_path: Path) -> None:
|
|
"""Check mix of existing and non-existing networks."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await check_networks_exist(
|
|
config, "local", ["bridge", "nonexistent_network_xyz_123"]
|
|
)
|
|
assert result["bridge"] is True
|
|
assert result["nonexistent_network_xyz_123"] is False
|
|
|
|
async def test_check_empty_networks(self, tmp_path: Path) -> None:
|
|
"""Empty network list returns empty dict."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await check_networks_exist(config, "local", [])
|
|
assert result == {}
|
|
|
|
|
|
@linux_only
|
|
class TestGetRunningStacksOnHost:
|
|
"""Tests for get_running_stacks_on_host function (requires Docker)."""
|
|
|
|
async def test_returns_set_of_stacks(self, tmp_path: Path) -> None:
|
|
"""Function returns a set of stack names."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
result = await get_running_stacks_on_host(config, "local")
|
|
assert isinstance(result, set)
|
|
|
|
async def test_filters_empty_lines(self, tmp_path: Path) -> None:
|
|
"""Empty project names are filtered out."""
|
|
config = Config(
|
|
compose_dir=tmp_path,
|
|
hosts={"local": Host(address="localhost")},
|
|
stacks={},
|
|
)
|
|
|
|
# Result should not contain empty strings
|
|
result = await get_running_stacks_on_host(config, "local")
|
|
assert "" not in result
|