@celilo/e2e 0.1.0

package/src/shared-infra.ts

@@ -0,0 +1,163 @@
+/**
+ * Shared Infrastructure Manager
+ *
+ * Starts the shared infrastructure (DNS hierarchy, Pebble ACME, apt-cache,
+ * fw-ext) once per test suite run. Per-test containers connect to the
+ * shared networks via Docker's external network references.
+ *
+ * The shared infra project name is deterministic (celilo-e2e-shared) so
+ * it can be referenced by per-test compose files and cleaned up reliably.
+ */
+
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { generateSharedInfraYaml, SHARED_PROJECT_NAME, SHARED_NETWORKS } from './docker-compose-generator';
+
+const SHARED_COMPOSE_FILE = 'docker-compose.shared.yml';
+const COMPOSE_TIMEOUT = 120_000;
+
+function run(cmd: string, opts?: { cwd?: string; timeout?: number }): string {
+  return execSync(cmd, {
+    timeout: opts?.timeout ?? COMPOSE_TIMEOUT,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: opts?.cwd,
+  }).trim();
+}
+
+let sharedInfraRunning = false;
+
+/**
+ * Check if the shared infrastructure is already running and healthy.
+ */
+export function isSharedInfraRunning(): boolean {
+  if (!sharedInfraRunning) return false;
+  try {
+    const containers = run(
+      `docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} ps -q`,
+      { cwd: getE2eDir() },
+    );
+    return containers.trim().length > 0;
+  } catch {
+    sharedInfraRunning = false;
+    return false;
+  }
+}
+
+function getE2eDir(): string {
+  return join(__dirname, '..');
+}
+
+/**
+ * Start the shared infrastructure. Idempotent — if already running,
+ * verifies health and returns immediately.
+ */
+export async function ensureSharedInfra(): Promise<void> {
+  if (isSharedInfraRunning()) {
+    // Verify DNS is still healthy
+    try {
+      const result = run(
+        `docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} exec -T comcast-resolver dig @127.0.0.1 iamtheinternet.org NS +short +timeout=2`,
+        { cwd: getE2eDir(), timeout: 10_000 },
+      );
+      if (result.trim().length > 0) {
+        return; // Shared infra healthy, nothing to do
+      }
+    } catch {
+      // DNS check failed — restart shared infra
+      console.log('[e2e] Shared infra DNS check failed, restarting...');
+      await stopSharedInfra();
+    }
+  }
+
+  const e2eDir = getE2eDir();
+
+  // Clean up any stale shared infra resources
+  console.log('[e2e] Cleaning up stale shared infrastructure...');
+  try {
+    run(`docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} down --volumes --remove-orphans`,
+      { cwd: e2eDir, timeout: 30_000 });
+  } catch {}
+
+  // Also clean up any per-test projects that reference our networks
+  try {
+    const networks = run('docker network ls --format "{{.Name}}"')
+      .split('\n')
+      .filter(n => n.startsWith('celilo-e2e-') && !n.startsWith(`${SHARED_PROJECT_NAME}_`));
+    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 {}
+      }
+    }
+  } catch {}
+
+  try { run('docker network prune -f', { timeout: 10_000 }); } catch {}
+
+  // Generate and write compose file
+  const yaml = generateSharedInfraYaml();
+  writeFileSync(join(e2eDir, SHARED_COMPOSE_FILE), yaml);
+
+  // Build and start
+  console.log('[e2e] Building shared infrastructure images...');
+  run(`docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} build`,
+    { cwd: e2eDir, timeout: 300_000 });
+
+  console.log('[e2e] Starting shared infrastructure...');
+  run(`docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} up -d`,
+    { cwd: e2eDir, timeout: 120_000 });
+
+  // Wait for DNS convergence
+  console.log('[e2e] Waiting for DNS convergence...');
+  const start = Date.now();
+  const timeout = 60_000;
+  while (Date.now() - start < timeout) {
+    try {
+      const result = run(
+        `docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} exec -T comcast-resolver dig @127.0.0.1 iamtheinternet.org NS +short +timeout=2`,
+        { cwd: e2eDir, timeout: 10_000 },
+      );
+      if (result.trim().length > 0) {
+        sharedInfraRunning = true;
+        console.log('[e2e] Shared infrastructure ready');
+        return;
+      }
+    } catch {
+      // retry
+    }
+    await new Promise(r => setTimeout(r, 2000));
+  }
+  throw new Error('Timeout waiting for shared infrastructure DNS convergence');
+}
+
+/**
+ * Stop the shared infrastructure. Called once at the end of the test suite.
+ */
+export async function stopSharedInfra(): Promise<void> {
+  console.log('[e2e] Stopping shared infrastructure...');
+  const e2eDir = getE2eDir();
+  try {
+    run(`docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} down --volumes --remove-orphans`,
+      { cwd: e2eDir, timeout: 60_000 });
+  } catch {
+    // Best effort
+  }
+  sharedInfraRunning = false;
+}
+
+/**
+ * Execute a command in a shared infrastructure container.
+ */
+export function sharedExec(container: string, cmd: string, timeoutMs = 60_000): { stdout: string; exitCode: number } {
+  try {
+    const stdout = run(
+      `docker compose -f ${SHARED_COMPOSE_FILE} -p ${SHARED_PROJECT_NAME} exec -T ${container} bash -c ${JSON.stringify(cmd)}`,
+      { cwd: getE2eDir(), timeout: timeoutMs },
+    );
+    return { stdout, exitCode: 0 };
+  } catch (err: unknown) {
+    const e = err as { stdout?: string; status?: number };
+    return { stdout: e.stdout?.toString() ?? '', exitCode: e.status ?? 1 };
+  }
+}

package/src/types.ts

@@ -0,0 +1,74 @@
+export type Zone = 'dmz' | 'app' | 'secure' | 'internal';
+
+export interface MachineSpec {
+  name: string;
+  ip: string;
+  zone: Zone;
+}
+
+export type TopologyPreset = 'default' | 'direct-internet';
+
+export interface NetworkConfig {
+  topology: TopologyPreset;
+  dmzMachines: MachineSpec[];
+  appMachines: MachineSpec[];
+  secureMachines: MachineSpec[];
+  internalMachines: MachineSpec[];
+  domain: string;
+  ddnsPassword: string;
+  verifyRouting: boolean;
+  /** Extra volume mounts for the management container (host:container format) */
+  managementVolumes: string[];
+  /** Include a DHCP client container on the internal network */
+  dhcpClient: boolean;
+  /**
+   * Absolute path to the Celilo project root (the directory containing apps/celilo/).
+   * Mounted into the management container at /celilo so the CLI is available.
+   * If not set, auto-detected by walking up from the package directory.
+   */
+  celiloRoot?: string;
+}
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface NetworkHandle {
+  /** Run a celilo CLI command on the management machine */
+  celilo(cmd: string, timeoutMs?: number): Promise<ExecResult>;
+
+  /** Execute an arbitrary command in any container */
+  exec(container: string, cmd: string, timeoutMs?: number): Promise<ExecResult>;
+
+  /** Resolve a DNS name from the management machine */
+  dig(name: string): Promise<string>;
+
+  /** Wait for a condition with timeout */
+  waitFor(
+    check: () => Promise<boolean>,
+    timeoutMs: number,
+    label: string,
+  ): Promise<void>;
+
+  /** Tear down the entire network */
+  stop(): Promise<void>;
+
+  /** The docker-compose project name (for debugging) */
+  projectName: string;
+}
+
+export const ZONE_GATEWAYS: Record<Zone, string> = {
+  dmz: '10.0.10.1',
+  app: '10.0.20.1',
+  secure: '10.0.30.1',
+  internal: '192.168.0.254',
+};
+
+export const ZONE_SUBNETS: Record<Zone, string> = {
+  dmz: '10.0.10.0/24',
+  app: '10.0.20.0/24',
+  secure: '10.0.30.0/24',
+  internal: '192.168.0.0/24',
+};