@celilo/e2e 0.1.0

package/src/container-manager.ts

@@ -0,0 +1,324 @@
+import { execSync, spawn, type ExecSyncOptions } from 'node:child_process';
+import { existsSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import type { ExecResult, NetworkConfig, NetworkHandle } from './types';
+import { generateTestComposeYaml } from './docker-compose-generator';
+import { ensureSharedInfra } from './shared-infra';
+
+/** Package root — where docker/, config/, simulators/ live */
+const PACKAGE_ROOT = join(__dirname, '..');
+
+/**
+ * Find the Celilo project root by walking up from the package directory.
+ * Looks for apps/celilo/ as the marker.
+ */
+function findCeliloRoot(): string {
+  let dir = PACKAGE_ROOT;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, 'apps', 'celilo'))) {
+      return dir;
+    }
+    const parent = resolve(dir, '..');
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error(
+    'Could not find Celilo project root (directory containing apps/celilo/).\n' +
+    'Set it explicitly: network().celilo("/path/to/infra").start()',
+  );
+}
+
+const COMPOSE_TIMEOUT = 120_000;
+
+// Track active project names so process-level cleanup can tear them down.
+const activeProjects: Set<string> = new Set();
+
+/**
+ * Process-level cleanup: tear down any active e2e resources when the
+ * process exits — whether from a clean exit, SIGTERM, SIGINT, or an
+ * unhandled error. This catches the case where a test times out and
+ * afterAll doesn't run.
+ *
+ * NOTE: only tears down per-test projects. Shared infra is managed
+ * separately (by the test runner or explicit stopSharedInfra call).
+ */
+function cleanupOnExit() {
+  for (const project of activeProjects) {
+    try {
+      execSync(
+        `docker compose -p ${project} down --volumes --remove-orphans`,
+        { timeout: 30_000, stdio: 'pipe' },
+      );
+    } catch {}
+  }
+  try { execSync('docker network prune -f', { timeout: 10_000, stdio: 'pipe' }); } catch {}
+}
+
+process.on('SIGTERM', () => { cleanupOnExit(); process.exit(1); });
+process.on('SIGINT', () => { cleanupOnExit(); process.exit(1); });
+process.on('beforeExit', () => { cleanupOnExit(); });
+
+function run(cmd: string, opts?: ExecSyncOptions): string {
+  return execSync(cmd, {
+    timeout: COMPOSE_TIMEOUT,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    ...opts,
+  }).trim();
+}
+
+const COMPOSE_FILE = 'docker-compose.test.yml';
+
+function dockerExec(projectName: string, composeDir: string, container: string, cmd: string, timeoutMs = 60_000): ExecResult {
+  try {
+    const stdout = run(
+      `docker compose -f ${COMPOSE_FILE} -p ${projectName} exec -T ${container} bash -c ${JSON.stringify(cmd)}`,
+      { cwd: composeDir, timeout: timeoutMs },
+    );
+    return { stdout, stderr: '', exitCode: 0 };
+  } catch (err: unknown) {
+    const e = err as { stdout?: string; stderr?: string; status?: number };
+    return {
+      stdout: e.stdout?.toString() ?? '',
+      stderr: e.stderr?.toString() ?? '',
+      exitCode: e.status ?? 1,
+    };
+  }
+}
+
+function dockerExecAsync(
+  projectName: string,
+  composeDir: string,
+  container: string,
+  cmd: string,
+  timeoutMs = 60_000,
+): Promise<ExecResult> {
+  return new Promise((resolve) => {
+    const args = [
+      'compose', '-f', COMPOSE_FILE, '-p', projectName,
+      'exec', '-T', container, 'bash', '-c', cmd,
+    ];
+    const child = spawn('docker', args, { cwd: composeDir });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data: Buffer) => {
+      const text = data.toString();
+      stdout += text;
+      process.stdout.write(text);
+    });
+
+    child.stderr.on('data', (data: Buffer) => {
+      const text = data.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve({ stdout, stderr: `${stderr}\ntimeout after ${timeoutMs}ms`, exitCode: 124 });
+    }, timeoutMs);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, exitCode: code ?? 1 });
+    });
+  });
+}
+
+async function waitFor(
+  check: () => Promise<boolean>,
+  timeoutMs: number,
+  label: string,
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      if (await check()) return;
+    } catch {
+      // retry
+    }
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  throw new Error(`Timeout waiting for ${label} after ${timeoutMs}ms`);
+}
+
+export async function startNetwork(config: NetworkConfig): Promise<NetworkHandle> {
+  // Pre-flight: fail if live containers are running that will compete for resources.
+  try {
+    const running = run('docker ps --format "{{.Names}}" 2>/dev/null').split('\n').filter(Boolean);
+    const heavyPatterns = ['authentik-', 'caddy-', 'build-your-own-internet-'];
+    const heavy = running.filter(name => heavyPatterns.some(p => name.startsWith(p)));
+    if (heavy.length > 0) {
+      const names = heavy.map(c => `   - ${c}`).join('\n');
+      throw new Error(
+        `\nCannot start e2e tests: ${heavy.length} live container(s) are running:\n${names}\n\n` +
+        'Live and e2e environments are mutually exclusive.\n' +
+        'Stop live containers first: ./bin/e2e-down --all\n',
+      );
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.includes('Cannot start e2e tests')) throw e;
+  }
+
+  // Ensure shared infrastructure (DNS, Pebble, apt-cache) is running.
+  // This is idempotent — if already up, it just verifies health.
+  await ensureSharedInfra();
+
+  // Clean up stale per-test containers (self-healing from prior crashes)
+  console.log('[e2e] Cleaning up stale test resources...');
+  try {
+    // Force-kill per-test containers (not shared infra)
+    try {
+      const containers = run('docker ps -aq --filter "name=celilo-e2e-1" 2>/dev/null');
+      if (containers.trim()) {
+        run(`docker rm -f ${containers.replace(/\n/g, ' ')}`, { timeout: 30_000 });
+      }
+    } catch {}
+
+    // Remove stale per-test networks
+    try {
+      const networks = run('docker network ls --format "{{.Name}}" 2>/dev/null')
+        .split('\n')
+        .filter(n => n.startsWith('celilo-e2e-1')); // per-test projects start with timestamp
+      if (networks.length > 0) {
+        const projects = [...new Set(networks.map(n => n.replace(/_[^_]+$/, '')))];
+        for (const project of projects) {
+          try { run(`docker compose -p ${project} down --volumes --remove-orphans`, { timeout: 30_000 }); } catch {}
+        }
+        for (const net of networks) {
+          try { run(`docker network rm ${net}`, { timeout: 5_000 }); } catch {}
+        }
+      }
+    } catch {}
+  } catch {}
+
+  const projectName = `celilo-e2e-${Date.now()}`;
+  activeProjects.add(projectName);
+
+  const composeDir = PACKAGE_ROOT;
+  const celiloRoot = config.celiloRoot ?? findCeliloRoot();
+
+  // Generate per-test compose (references shared infra networks as external)
+  const yaml = generateTestComposeYaml(config, celiloRoot);
+  writeFileSync(join(composeDir, COMPOSE_FILE), yaml);
+
+  // Build and start per-test containers only
+  console.log('[e2e] Building images...');
+  run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} build`, { cwd: composeDir, timeout: 300_000 });
+
+  console.log('[e2e] Starting containers...');
+  run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} up -d`, { cwd: composeDir, timeout: 120_000 });
+
+  // DNS convergence is handled by shared infra — skip it here.
+  // Just verify routing from per-test containers to shared infra.
+
+  // Optional routing verification
+  if (config.verifyRouting) {
+    console.log('[e2e] Verifying routing...');
+    await waitFor(
+      async () => {
+        const result = dockerExec(projectName, composeDir, 'management',
+          'ping -c1 -W2 100.64.0.53');
+        return result.exitCode === 0;
+      },
+      30_000,
+      'routing verification',
+    );
+  }
+
+  // Wait for all target machines to complete setup (systemd boot + routing)
+  const allMachines = [...config.dmzMachines, ...config.appMachines, ...config.secureMachines, ...config.internalMachines];
+  if (allMachines.length > 0) {
+    console.log('[e2e] Waiting for target machines...');
+  }
+  for (const machine of allMachines) {
+    await waitFor(
+      async () => {
+        const result = dockerExec(projectName, composeDir, machine.name,
+          'systemctl is-active target-setup 2>/dev/null');
+        return result.stdout.trim() === 'active';
+      },
+      30_000,
+      `${machine.name} target-setup`,
+    );
+  }
+
+  // Wait for DHCP client lease
+  if (config.dhcpClient) {
+    console.log('[e2e] Waiting for DHCP client lease...');
+    await waitFor(
+      async () => {
+        const result = dockerExec(projectName, composeDir, 'dhcp-client',
+          'test -f /var/lib/dhcp/dhclient.leases && grep -c lease /var/lib/dhcp/dhclient.leases');
+        return result.exitCode === 0 && Number.parseInt(result.stdout.trim()) > 0;
+      },
+      60_000,
+      'DHCP client lease',
+    );
+  }
+
+  // Wait for routing to Pebble (through shared infra networks)
+  if (allMachines.length > 0) {
+    await waitFor(
+      async () => {
+        const result = dockerExec(projectName, composeDir, 'management',
+          'ping -c1 -W2 100.64.0.100');
+        return result.exitCode === 0;
+      },
+      30_000,
+      'routing to Pebble',
+    );
+  }
+
+  // Initialize celilo
+  console.log('[e2e] Initializing celilo...');
+  const initResult = dockerExec(projectName, composeDir, 'management',
+    `cd /celilo/apps/celilo && bun run src/cli/index.ts system init --accept-defaults \
+      network.dmz.subnet=10.0.10.0/24 \
+      network.app.subnet=10.0.20.0/24 \
+      network.secure.subnet=10.0.30.0/24 \
+      network.internal.subnet=192.168.0.0/24 \
+      dns.primary=100.100.0.1 \
+      dns.fallback=1.0.0.1,8.8.8.8`);
+  if (initResult.exitCode !== 0) {
+    throw new Error(`Celilo init failed: ${initResult.stderr}`);
+  }
+
+  console.log(`[e2e] Network ready (project: ${projectName})`);
+
+  const handle: NetworkHandle = {
+    projectName,
+
+    celilo(cmd: string, timeoutMs = 120_000): Promise<ExecResult> {
+      return dockerExecAsync(projectName, composeDir, 'management',
+        `cd /celilo/apps/celilo && bun run src/cli/index.ts ${cmd}`, timeoutMs);
+    },
+
+    exec(container: string, cmd: string, timeoutMs = 60_000): Promise<ExecResult> {
+      return Promise.resolve(dockerExec(projectName, composeDir, container, cmd, timeoutMs));
+    },
+
+    async dig(name: string): Promise<string> {
+      const result = dockerExec(projectName, composeDir, 'management',
+        `dig +short ${name}`);
+      return result.stdout.trim();
+    },
+
+    waitFor,
+
+    async stop(): Promise<void> {
+      console.log(`[e2e] Stopping network (project: ${projectName})...`);
+      try {
+        run(`docker compose -f ${COMPOSE_FILE} -p ${projectName} down --volumes --remove-orphans`,
+          { cwd: composeDir, timeout: 60_000 });
+      } catch {
+        // Best effort cleanup
+      }
+      activeProjects.delete(projectName);
+    },
+  };
+
+  return handle;
+}