@celilo/e2e 0.19.2 → 0.20.0

package/src/exit-cleanup.test.ts

@@ -15,7 +15,7 @@ import { expect, test } from 'bun:test';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { projectTeardownCommands } from './container-manager';
+import { networkContainersInspectCommand, projectTeardownCommands } from './container-manager';
 
 const SRC = readFileSync(
   join(dirname(fileURLToPath(import.meta.url)), 'container-manager.ts'),
@@ -68,6 +68,64 @@ test('teardown removes volumes, not just containers and networks', () => {
   expect(cmds.listVolumes).not.toContain('docker compose');
 });
 
+// A sim-created LXC guest is named celilo-e2e-lxc-<vmid>, which neither the
+// per-test name filters (`celilo-e2e-1<ts>` in the startNetwork pre-sweep nor
+// `celilo-e2e-<ts>` in forceRemoveProject) can match. A guest left running
+// holds its zone network's endpoint: compose down fails that network with
+// "has active endpoints", the error is swallowed as best-effort, and the
+// subnet stays allocated. Every later suite in the run then dies in ~2s
+// creating that network — 44 of 54 suites in one --all run (celilo#1247).
+test('project teardown lists sim-created guests by label, not only by name (celilo#1247)', () => {
+  const cmds = projectTeardownCommands('celilo-e2e-1788449289917');
+  expect(cmds.listGuests).toContain('docker ps -aq --filter label=celilo-e2e.project=');
+  expect(cmds.listGuests).toContain('celilo-e2e-1788449289917');
+  expect(cmds.listGuests).not.toContain('docker compose');
+});
+
+test('forceRemoveProject unions the guest listing into its container sweep (celilo#1247)', () => {
+  // The name-only sweep is what let the guest survive: the network rm that
+  // follows ran against an endpoint that was still attached. The union must
+  // come BEFORE the network removal in the same function.
+  const body = SRC.slice(
+    SRC.indexOf('function forceRemoveProject'),
+    SRC.indexOf('function cleanupOnExit'),
+  );
+  expect(body).toContain('listGuests');
+  expect(body.indexOf('listGuests')).toBeLessThan(body.indexOf('listNetworks'));
+});
+
+test('handle.stop kills sim guests BEFORE compose down (celilo#1247)', () => {
+  // With the guest alive, compose down fails the network ("has active
+  // endpoints") AND the ssh-keys volume (in use), both swallowed. Removing
+  // the guest first is what makes the normal teardown path complete.
+  const stop = SRC.slice(
+    SRC.indexOf('async stop(): Promise<void>'),
+    SRC.indexOf('export async function startNetwork'),
+  );
+  expect(stop).toContain('listGuests');
+  expect(stop.indexOf('listGuests')).toBeLessThan(stop.indexOf('docker compose -f'));
+});
+
+test('startNetwork pre-sweep sweeps guests of ANY project by label (celilo#1247)', () => {
+  // The crash-recovery backstop must not depend on a network surviving for
+  // the project derivation to find the guest: a guest whose network is
+  // already gone is debris all the same. The label carries no project value
+  // here — only the provisioner ever sets it, and the run-lock guarantees no
+  // concurrent run owns any of them.
+  //
+  // The sweep lives in sweepStaleTestResources() since ce-yuzi extracted it
+  // out of startNetwork for testability; startNetwork calls it. Assert both
+  // halves: the function carries the label filter, startNetwork invokes it.
+  const sweep = SRC.slice(
+    SRC.indexOf('export function sweepStaleTestResources'),
+    SRC.indexOf('Remove stale per-test networks'),
+  );
+  expect(sweep).toContain('docker ps -aq --filter label=${GUEST_PROJECT_LABEL}`');
+  expect(SRC.slice(SRC.indexOf('export async function startNetwork'))).toContain(
+    'sweepStaleTestResources()',
+  );
+});
+
 test('teardown cannot match the shared project', () => {
   // Per-test projects carry a timestamp; `celilo-e2e-shared` does not, so a
   // name filter for one can never match the other. Shared infra must survive —
@@ -79,6 +137,30 @@ test('teardown cannot match the shared project', () => {
   }
 });
 
+test('teardown removes a Proxmox guest blocking a network before removing the network', () => {
+  // ce-ywix: a guest is named celilo-e2e-lxc-<vmid> and carries NO project
+  // name, so the project-scoped container sweep never removes it. A live guest
+  // keeps `docker network rm` failing forever, and the leaked network held the
+  // sim's subnet — every later run then died at compose up with "Pool
+  // overlaps". The network loop must inspect each network and remove the e2e
+  // containers attached to it BEFORE the network rm.
+  const cmd = networkContainersInspectCommand('celilo-e2e-1788615872911_dmz');
+  expect(cmd).toContain('docker network inspect');
+  expect(cmd).toContain('celilo-e2e-1788615872911_dmz');
+
+  const teardown = SRC.slice(
+    SRC.indexOf('function forceRemoveProject'),
+    SRC.indexOf('function cleanupOnExit'),
+  );
+  expect(teardown).toContain('networkContainersInspectCommand');
+  expect(teardown).toContain('CONTAINER_PREFIX');
+  const inspectAt = teardown.indexOf('networkContainersInspectCommand');
+  const rmAt = teardown.indexOf('`docker network rm ${net}`');
+  expect(inspectAt).toBeGreaterThan(-1);
+  expect(rmAt).toBeGreaterThan(-1);
+  expect(inspectAt).toBeLessThan(rmAt);
+});
+
 test("the premise holds: process.exit() fires 'exit' but NOT 'beforeExit'", async () => {
   // The whole fix rests on this runtime behavior. If it ever changes, the
   // reasoning above is void and this should fail loudly rather than silently

package/src/fleet-nameserver-gate.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'bun:test';
+import { fleetNameserverProblems } from './container-manager';
+
+// Recurrence gate for celilo#1290: a nameserver the sim cannot route
+// blackholes the lookups ansible's Gathering Facts performs, and the failure
+// used to surface as an unrelated 600s command timeout. This gate fails at
+// init instead, naming the address.
+
+test('accepts the sim-hosted primary with no fallback set', () => {
+  const out = ['dns.primary = 203.0.113.1', 'System config key not found: dns.fallback'].join('\n');
+  expect(fleetNameserverProblems(out)).toEqual([]);
+});
+
+test('accepts nameservers in every simulated subnet', () => {
+  const out = ['dns.primary = 203.0.113.1', 'dns.fallback = 100.64.0.64,10.226.10.10'].join('\n');
+  expect(fleetNameserverProblems(out)).toEqual([]);
+});
+
+test('rejects the unroutable public resolvers celilo#1290 shipped', () => {
+  const out = ['dns.primary = 203.0.113.1', 'dns.fallback = 1.0.0.1,8.8.8.8'].join('\n');
+  const problems = fleetNameserverProblems(out);
+  expect(problems).toHaveLength(2);
+  expect(problems[0]).toContain('1.0.0.1');
+  expect(problems[0]).toContain('no simulated subnet');
+  expect(problems[1]).toContain('8.8.8.8');
+});
+
+test('rejects core discovery last-resort 1.1.1.1', () => {
+  const out = ['dns.primary = 203.0.113.1', 'dns.fallback = 1.1.1.1'].join('\n');
+  expect(fleetNameserverProblems(out)).toHaveLength(1);
+});
+
+test('flags a missing primary — the birth list would be empty', () => {
+  const out = 'No system configuration set';
+  const problems = fleetNameserverProblems(out);
+  expect(problems).toHaveLength(1);
+  expect(problems[0]).toContain('dns.primary is not set');
+});
+
+test('flags a non-IP entry instead of silently passing it', () => {
+  const out = 'dns.primary = not-an-ip';
+  const problems = fleetNameserverProblems(out);
+  expect(problems).toHaveLength(1);
+  expect(problems[0]).toContain('not an IPv4 address');
+});

package/src/host-vm.test.ts

@@ -0,0 +1,156 @@
+/**
+ * The host-VM policy, with each rule broken deliberately.
+ *
+ * Per Rule 7.6 a gate nobody has seen fail is not a gate, so every assertion
+ * here is written against the out-of-policy state. The happy cases exist only
+ * to prove the rules do not fire on a VM that is fine — a check that warns
+ * about everything teaches people to ignore it, which is the same outcome as
+ * having no check.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  type HostFacts,
+  type HostVmFacts,
+  evaluateHostVm,
+  parseLimaConfig,
+  parseLimaMemory,
+  readHostVmFacts,
+  recommendedBudget,
+} from './host-vm';
+
+const M1_PRO: HostFacts = { cpus: 10, memoryGiB: 32 };
+
+function vm(overrides: Partial<HostVmFacts> = {}): HostVmFacts {
+  return {
+    profile: 'default',
+    cpus: 8,
+    memoryGiB: 12,
+    mountType: 'virtiofs',
+    vmType: 'vz',
+    ...overrides,
+  };
+}
+
+describe('recommendedBudget', () => {
+  test('leaves the host two cores and about a third of its memory', () => {
+    expect(recommendedBudget(M1_PRO, 'vz')).toEqual({
+      cpus: 8,
+      memoryGiB: 12,
+      mountType: 'virtiofs',
+    });
+  });
+
+  test('scales to a small laptop rather than encoding one machine', () => {
+    expect(recommendedBudget({ cpus: 4, memoryGiB: 16 }, 'vz')).toEqual({
+      cpus: 2,
+      memoryGiB: 6,
+      mountType: 'virtiofs',
+    });
+  });
+
+  test('caps memory on a large host — the guest has no use for 48 GiB of page cache', () => {
+    expect(recommendedBudget({ cpus: 32, memoryGiB: 128 }, 'vz').memoryGiB).toBe(16);
+  });
+
+  test('never proposes fewer than two CPUs', () => {
+    expect(recommendedBudget({ cpus: 2, memoryGiB: 8 }, 'vz').cpus).toBe(2);
+  });
+
+  test('qemu cannot have virtiofs, so it is not asked for it', () => {
+    expect(recommendedBudget(M1_PRO, 'qemu').mountType).toBe('sshfs');
+  });
+});
+
+describe('parseLimaMemory', () => {
+  test('reads the form lima actually writes', () => {
+    expect(parseLimaMemory('12288MiB')).toBe(12);
+  });
+
+  test('reads GiB and raw byte counts too', () => {
+    expect(parseLimaMemory('24GiB')).toBe(24);
+    expect(parseLimaMemory(12 * 1024 ** 3)).toBe(12);
+  });
+
+  test('an unreadable value is 0, not a guess', () => {
+    expect(parseLimaMemory('lots')).toBe(0);
+    expect(parseLimaMemory(undefined)).toBe(0);
+  });
+});
+
+describe('evaluateHostVm', () => {
+  const budget = recommendedBudget(M1_PRO, 'vz');
+
+  test('a VM inside the policy has nothing to say', () => {
+    expect(evaluateHostVm(vm(), M1_PRO, budget)).toEqual({ problems: [], needsRecreate: false });
+  });
+
+  test('24 of 32 GiB is flagged — the measured state that had the host swapping 21.9 GiB', () => {
+    const verdict = evaluateHostVm(vm({ memoryGiB: 24 }), M1_PRO, budget);
+    expect(verdict.problems).toHaveLength(1);
+    expect(verdict.problems[0]).toContain('24 GiB');
+    // Memory takes on a restart, so this must not demand the destructive path.
+    expect(verdict.needsRecreate).toBe(false);
+  });
+
+  test('exactly half the host is allowed — the line is above it, not at it', () => {
+    expect(evaluateHostVm(vm({ memoryGiB: 16 }), M1_PRO, budget).problems).toEqual([]);
+  });
+
+  test('sshfs is flagged AND demands a recreate, because colima discards the change', () => {
+    const verdict = evaluateHostVm(vm({ mountType: 'sshfs' }), M1_PRO, budget);
+    expect(verdict.problems[0]).toContain('sshfs');
+    expect(verdict.needsRecreate).toBe(true);
+  });
+
+  test('an empty mount type reads as unknown rather than as a missing sentence', () => {
+    expect(evaluateHostVm(vm({ mountType: '' }), M1_PRO, budget).problems[0]).toContain(
+      'an unknown transport',
+    );
+  });
+
+  test('overcommitted CPUs are flagged', () => {
+    expect(evaluateHostVm(vm({ cpus: 16 }), M1_PRO, budget).problems[0]).toContain('16 CPUs');
+  });
+
+  test('several problems are all reported, not just the first', () => {
+    const verdict = evaluateHostVm(vm({ memoryGiB: 24, mountType: 'sshfs', cpus: 16 }), M1_PRO, {
+      ...budget,
+    });
+    expect(verdict.problems).toHaveLength(3);
+  });
+});
+
+describe('parseLimaConfig', () => {
+  test("normalizes lima's reverse-sshfs to the name colima's own flag uses", () => {
+    // Reading lima's config rather than colima's saved profile is load-bearing:
+    // colima accepts `--mount-type` on an existing VM, warns that it discarded
+    // it, and rewrites its own profile — so the profile records the request and
+    // lima records what happened. The two disagreed while this was written.
+    expect(
+      parseLimaConfig('vmType: vz\ncpus: 8\nmemory: 12288MiB\nmountType: reverse-sshfs\n', 'probe'),
+    ).toEqual({
+      profile: 'probe',
+      cpus: 8,
+      memoryGiB: 12,
+      mountType: 'sshfs',
+      vmType: 'vz',
+    });
+  });
+
+  test('missing fields read as absent rather than as a plausible default', () => {
+    expect(parseLimaConfig('vmType: vz\n', 'probe')).toEqual({
+      profile: 'probe',
+      cpus: 0,
+      memoryGiB: 0,
+      mountType: '',
+      vmType: 'vz',
+    });
+  });
+});
+
+describe('readHostVmFacts', () => {
+  test('no lima instance means no VM to shape, not an error', () => {
+    expect(readHostVmFacts('a-profile-that-does-not-exist')).toBeNull();
+  });
+});

package/src/host-vm.ts

@@ -0,0 +1,230 @@
+/**
+ * The rig's contract with the Docker host it runs on.
+ *
+ * On Linux, docker runs on the host kernel and there is no contract to state.
+ * On macOS it runs inside a virtual machine, and two of that VM's settings
+ * dominate how long a run takes. Both were measured on 2026-09-05, on an M1 Pro
+ * with 32 GiB, while a suite was running:
+ *
+ * **Memory.** The VM held 24 GiB of the host's 32. It used 1.9 GiB and filled
+ * the rest with page cache, which is what a Linux guest is supposed to do. But
+ * the guest's idea of "cached in RAM" is the host's idea of "anonymous memory I
+ * may compress or swap", so the host sat at 21.9 GiB of swap used with
+ * `kernel_task` (the memory compressor) at 60% of a core, and every image-layer
+ * read the guest thought was free became a host decompress or an SSD read. The
+ * guest cannot give the memory back — there is no balloon driver — so the only
+ * lever is not to hand it over in the first place.
+ *
+ * **Mount type.** The celilo checkout is bind-mounted into the management
+ * container. Under colima's default `sshfs` every file operation crosses FUSE,
+ * an SSH channel, a userspace TCP stack on the host, an ssh multiplexer and
+ * `sftp-server`. `virtiofs` is a shared-memory transport with none of that
+ * chain.
+ *
+ * The two costs had to be separated, because measuring them together
+ * attributed nearly all of it to the wrong one. Same probe, same image, three
+ * VM configurations:
+ *
+ *   | VM                                  | CLI on image disk | CLI over mount |
+ *   |-------------------------------------|-------------------|----------------|
+ *   | 24 GiB sshfs (host swapping 21.9 G) |             0.27s |          2.50s |
+ *   | 12 GiB sshfs                        |             0.16s |          0.56s |
+ *   | 12 GiB virtiofs                     |             0.14s |          0.31s |
+ *
+ * So the 2.3-second gap in the first row was about 1.9s of host swap and 0.4s
+ * of transport. Memory is the big lever; the mount is real but secondary, and
+ * shows up most on bulk reads — reading 200 source files took 0.24s on sshfs
+ * and 0.073s on virtiofs, a factor of 3.3.
+ *
+ * Nothing here can fix either one — colima refuses to change a VM's mount type
+ * after creation, and shrinking memory needs a restart. So this module's job is
+ * to READ what the VM is actually running and say plainly when it disagrees
+ * with the policy, which is what `cele2e doctor` and `cele2e host` do with it.
+ *
+ * It reads lima's own instance config rather than colima's saved profile,
+ * because those two can disagree and only one of them is the running VM. They
+ * disagreed while this was being written: colima accepts `--mount-type` on the
+ * command line, prints `'volume mount type' cannot be updated after initial
+ * setup, discarded`, and rewrites its saved profile back — so the profile is a
+ * record of what was asked for, and lima's is a record of what happened.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { cpus, homedir, totalmem } from 'node:os';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+
+/** What the VM is actually running, read from lima's instance config. */
+export interface HostVmFacts {
+  /** colima profile name, e.g. `default`. */
+  profile: string;
+  cpus: number;
+  memoryGiB: number;
+  /** Normalized: lima's `reverse-sshfs` is colima's `sshfs`. */
+  mountType: string;
+  /** `vz` (Apple Virtualization) or `qemu`. virtiofs requires `vz`. */
+  vmType: string;
+}
+
+/** The host the VM is carved out of. */
+export interface HostFacts {
+  cpus: number;
+  memoryGiB: number;
+}
+
+/** What the VM should be given. */
+export interface HostVmBudget {
+  cpus: number;
+  memoryGiB: number;
+  mountType: 'virtiofs' | 'sshfs';
+}
+
+/**
+ * The share of host RAM above which the host starts paying for the guest's
+ * page cache in swap. Not a tuning knob so much as a line: at 24 of 32 GiB
+ * (75%) the host swapped 21.9 GiB; the policy below lands at 37.5%, which
+ * leaves the guest more than it uses and the host its own working set.
+ */
+export const MAX_HOST_MEMORY_SHARE = 0.5;
+const TARGET_HOST_MEMORY_SHARE = 0.375;
+
+/** Floor and ceiling on the VM's memory, in GiB. */
+const MIN_VM_MEMORY_GIB = 4;
+const MAX_VM_MEMORY_GIB = 16;
+
+/** Cores left to the host, so the Mac stays usable while a suite runs. */
+const HOST_RESERVED_CPUS = 2;
+
+/**
+ * The VM settings this rig wants on a given host.
+ *
+ * Pure, and expressed as a fraction rather than a constant, so it says
+ * something true on a 16 GiB laptop and a 64 GiB desktop rather than encoding
+ * one machine's answer.
+ */
+export function recommendedBudget(host: HostFacts, vmType: string): HostVmBudget {
+  const memoryGiB = Math.min(
+    MAX_VM_MEMORY_GIB,
+    Math.max(MIN_VM_MEMORY_GIB, Math.floor(host.memoryGiB * TARGET_HOST_MEMORY_SHARE)),
+  );
+  return {
+    cpus: Math.max(2, host.cpus - HOST_RESERVED_CPUS),
+    memoryGiB,
+    // virtiofs is an Apple Virtualization feature; a qemu VM cannot have it.
+    mountType: vmType === 'vz' ? 'virtiofs' : 'sshfs',
+  };
+}
+
+export function readHostFacts(): HostFacts {
+  return { cpus: cpus().length, memoryGiB: Math.round(totalmem() / 1024 ** 3) };
+}
+
+/** colima's lima instance directory: `colima` for the default profile, `colima-<p>` otherwise. */
+export function limaInstanceDir(profile: string): string {
+  const instance = profile === 'default' ? 'colima' : `colima-${profile}`;
+  return join(homedir(), '.colima', '_lima', instance);
+}
+
+export function activeProfile(): string {
+  return process.env.COLIMA_PROFILE || 'default';
+}
+
+/** `12288MiB` / `12GiB` / `12884901888` → GiB. */
+export function parseLimaMemory(raw: unknown): number {
+  if (typeof raw === 'number') return Math.round(raw / 1024 ** 3);
+  if (typeof raw !== 'string') return 0;
+  const match = raw.trim().match(/^([\d.]+)\s*([KMGT]i?B)?$/i);
+  if (!match) return 0;
+  const value = Number.parseFloat(match[1]);
+  const unit = (match[2] ?? 'B').toUpperCase();
+  const scale: Record<string, number> = {
+    B: 1,
+    KB: 1024,
+    KIB: 1024,
+    MB: 1024 ** 2,
+    MIB: 1024 ** 2,
+    GB: 1024 ** 3,
+    GIB: 1024 ** 3,
+    TB: 1024 ** 4,
+    TIB: 1024 ** 4,
+  };
+  return Math.round((value * (scale[unit] ?? 1)) / 1024 ** 3);
+}
+
+/** Parse a lima instance config. Pure, so the normalization is testable without a VM. */
+export function parseLimaConfig(yamlText: string, profile: string): HostVmFacts | null {
+  try {
+    const parsed = parseYaml(yamlText) as {
+      cpus?: number;
+      memory?: string | number;
+      mountType?: string;
+      vmType?: string;
+    };
+    if (!parsed || typeof parsed !== 'object') return null;
+    return {
+      profile,
+      cpus: parsed.cpus ?? 0,
+      memoryGiB: parseLimaMemory(parsed.memory),
+      // lima calls it reverse-sshfs; colima's flag and its docs call it sshfs.
+      mountType: (parsed.mountType ?? '').replace(/^reverse-/, ''),
+      vmType: parsed.vmType ?? '',
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * What the VM is running, or null when this host has no colima VM — which is
+ * the normal case on Linux and in CI, and means there is no policy to enforce.
+ */
+export function readHostVmFacts(profile = activeProfile()): HostVmFacts | null {
+  const limaYaml = join(limaInstanceDir(profile), 'lima.yaml');
+  if (!existsSync(limaYaml)) return null;
+  try {
+    return parseLimaConfig(readFileSync(limaYaml, 'utf-8'), profile);
+  } catch {
+    return null;
+  }
+}
+
+export interface HostVmVerdict {
+  /** Every way the VM disagrees with the budget, in plain sentences. */
+  problems: string[];
+  /** True when a fix requires destroying and recreating the VM. */
+  needsRecreate: boolean;
+}
+
+/**
+ * Compare the running VM against the budget.
+ *
+ * Pure, so each rule is testable with the condition deliberately broken —
+ * a check nobody has seen fail is not a check (Rule 7.6).
+ */
+export function evaluateHostVm(
+  facts: HostVmFacts,
+  host: HostFacts,
+  budget: HostVmBudget,
+): HostVmVerdict {
+  const problems: string[] = [];
+  let needsRecreate = false;
+
+  if (facts.memoryGiB > host.memoryGiB * MAX_HOST_MEMORY_SHARE) {
+    problems.push(
+      `VM memory is ${facts.memoryGiB} GiB of the host's ${host.memoryGiB} GiB — the guest fills the surplus with page cache the host then compresses or swaps, so every image read becomes host I/O. Recommended: ${budget.memoryGiB} GiB.`,
+    );
+  }
+  if (facts.mountType !== budget.mountType) {
+    problems.push(
+      `VM mounts the host filesystem over ${facts.mountType || 'an unknown transport'}; ${budget.mountType} is a shared-memory transport with no SSH hop. Measured on the mounted checkout: reading 200 source files took 0.24s over sshfs and 0.073s over virtiofs.`,
+    );
+    // colima discards a mount-type change on an existing VM.
+    needsRecreate = true;
+  }
+  if (facts.cpus > host.cpus) {
+    problems.push(
+      `VM is configured with ${facts.cpus} CPUs but the host has ${host.cpus}. Recommended: ${budget.cpus}.`,
+    );
+  }
+  return { problems, needsRecreate };
+}

package/src/index.ts

@@ -30,6 +30,17 @@ export { reconnectNetwork } from './container-manager';
 // Progress reporting (emit signals the test runner displays)
 export { progress } from './progress';
 
+// Staged-suite mechanism: cascade-skip later stages after a failure OR a
+// timeout (celilo#1272)
+export { createStageGuard, createStages } from './stages';
+export type { StageGuard, Stages } from './stages';
+
+// Block-timing: static cap extraction shared with the e2e-timeout-cap gate
+// (scripts/e2e-timeout-cap.test.ts), so the manifest and the runner read
+// budgets through one parser
+export { declaredBlockCaps, declaredCapEntries, tightBlocks } from './block-timing';
+export type { BlockTiming, DeclaredCapEntry, TightBlock } from './block-timing';
+
 // Types
 export type {
   NetworkConfig,