feat: implement HADRON_ISOLATED through preferences COMPASS-6065 (#3503)

- Implement `HADRON_ISOLATED` through the `networkTraffic` preference.
- Derive the value of other preferences that are shadowed by
  `networkTraffic` through a generic mechanism for doing so
  (we will also need this for `readOnly`/`enableShell`)
- Add an e2e test that runs on Linux and verifies via `strace` that
  Compass does not actually perform external network I/O when
  `--no-network-traffic` has been specified.

Author: addaleax

package-lock.json

@@ -273,7 +273,9 @@ export class Compass {
 
 interface StartCompassOptions {
   firstRun?: boolean;
+  noCloseSettingsModal?: boolean;
   extraSpawnArgs?: string[];
+  wrapBinary?: (binary: string) => Promise<string> | string;
 }
 
 let defaultUserDataDir: string | undefined;
@@ -426,6 +428,8 @@ async function startCompass(opts: StartCompassOptions = {}): Promise<Compass> {
       : 100,
   };
 
+  const maybeWrappedBinary = (await opts.wrapBinary?.(binary)) ?? binary;
+
   process.env.APP_ENV = 'webdriverio';
   process.env.DEBUG = `${process.env.DEBUG ?? ''},mongodb-compass:main:logging`;
   process.env.MONGODB_COMPASS_TEST_LOG_DIR = path.join(LOG_PATH, 'app');
@@ -436,7 +440,7 @@ async function startCompass(opts: StartCompassOptions = {}): Promise<Compass> {
       browserName: 'chrome',
       // https://chromedriver.chromium.org/capabilities#h.p_ID_106
       'goog:chromeOptions': {
-        binary,
+        binary: maybeWrappedBinary,
         args: chromeArgs,
       },
       // more chrome options
@@ -655,14 +659,14 @@ function augmentError(error: Error, stack: string) {
 }
 
 export async function beforeTests(
-  opts?: StartCompassOptions
+  opts: StartCompassOptions = {}
 ): Promise<Compass> {
   const compass = await startCompass(opts);
 
   const { browser } = compass;
 
   await browser.waitForConnectionScreen();
-  if (compass.isFirstRun) {
+  if (compass.isFirstRun && !opts.noCloseSettingsModal) {
     await browser.closeSettingsModal();
   }
 

packages/compass-e2e-tests/helpers/compass.ts

@@ -146,6 +146,28 @@ describe('Global preferences', function () {
     }
   });
 
+  it('allows setting networkTraffic: false and reflects that in the settings modal', async function () {
+    await fs.writeFile(path.join(tmpdir, 'config'), 'networkTraffic: false\n');
+    // No settings modal opened for Isolated edition
+    const compass = await beforeTests({ noCloseSettingsModal: true });
+    try {
+      const browser = compass.browser;
+      await browser.openSettingsModal();
+      const { disabled, value, bannerText } = await getCheckboxAndBannerState(
+        browser,
+        'enableMaps'
+      );
+      expect(value).to.equal('false');
+      expect(disabled).to.equal(''); // null = missing attribute, '' = set
+      expect(bannerText).to.include(
+        'This setting cannot be modified as it has been set in the global Compass configuration file.'
+      );
+    } finally {
+      await afterTest(compass, this.currentTest);
+      await afterTests(compass, this.currentTest);
+    }
+  });
+
   it('allows showing version information', async function () {
     const { stdout } = await runCompassOnce(['--version']);
     expect(stdout.trim()).to.match(/^MongoDB Compass.*\d$/);

packages/compass-e2e-tests/tests/global-preferences.test.ts

@@ -0,0 +1,111 @@
+import { beforeTests, afterTests } from '../helpers/compass';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('networkTraffic: false / Isolated Edition', function () {
+  let tmpdir: string;
+  let i = 0;
+
+  before(function () {
+    if (process.platform !== 'linux') {
+      // No strace on other platforms
+      return this.skip();
+    }
+  });
+
+  beforeEach(async function () {
+    tmpdir = path.join(
+      os.tmpdir(),
+      `compass-global-preferences-${Date.now().toString(32)}-${++i}`
+    );
+    await fs.mkdir(tmpdir, { recursive: true });
+  });
+
+  afterEach(async function () {
+    await fs.rmdir(tmpdir, { recursive: true });
+  });
+
+  it('does not attempt to perform network I/O', async function () {
+    // This is a bit of an oddball test. On Linux, we run Compass under strace(1),
+    // tracing all connect(2) calls made by Compass and its child processes.
+    // We expect a connection to the database, but otherwise no outgoing network I/O.
+
+    const outfile = path.join(tmpdir, 'strace-out.log');
+    async function wrapBinary(binary: string): Promise<string> {
+      const wrapperFile = path.join(tmpdir, 'wrap.sh');
+      await fs.writeFile(
+        wrapperFile,
+        `#!/bin/bash\nulimit -c 0; exec strace -f -e connect -qqq -o '${outfile}' '${binary}' "$@"\n`
+      );
+      await fs.chmod(wrapperFile, 0o755);
+      return wrapperFile;
+    }
+
+    const compass = await beforeTests({
+      extraSpawnArgs: ['--no-network-traffic'],
+      noCloseSettingsModal: true,
+      wrapBinary,
+    });
+    const browser = compass.browser;
+
+    {
+      // TODO: Remove this once we are including https://github.com/mongodb-js/mongosh/pull/1349
+      const exitOnDisconnectFile = path.join(tmpdir, 'exitOnDisconnect.js');
+      await fs.writeFile(
+        exitOnDisconnectFile,
+        'process.once("disconnect", () => process.exit())'
+      );
+      await browser.execute((exitOnDisconnectFile) => {
+        process.env.NODE_OPTIONS ??= '';
+        process.env.NODE_OPTIONS += ` --require "${exitOnDisconnectFile}"`;
+      }, exitOnDisconnectFile);
+    }
+
+    try {
+      await browser.connectWithConnectionString(
+        'mongodb://localhost:27091/test'
+      );
+    } finally {
+      await afterTests(compass, this.currentTest);
+    }
+
+    const straceLog = await fs.readFile(outfile, 'utf8');
+    const connectCalls = straceLog.matchAll(/\bconnect\s*\((?<args>.*)\) =/g);
+    const connectTargets = new Set<string>();
+    for (const { groups } of connectCalls) {
+      const args = groups!.args;
+      // Possible format for the address argument in 'args':
+      // sa_family=AF_UNIX, sun_path="/var/run/nscd/socket"
+      // sa_family=AF_INET, sin_port=htons(0), sin_addr=inet_addr("127.0.0.1")
+      // sa_family=AF_INET6, sin6_port=htons(80), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "2606:2800:220:1:248:1893:25c8:1946", &sin6_addr), sin6_scope_id=0
+      if (!args.includes('AF_INET')) continue;
+      const match = args.match(
+        /sa_family=AF_INET6?.*sin6?_port=htons\((?<port>\d+)\).*inet_(addr\("(?<ipv4>[^"]+)"\)|pton\(AF_INET6,\s*"(?<ipv6>[^"]+)")/
+      )?.groups;
+      if (!match) {
+        throw new Error(`Unknown traced connect() target: ${args}`);
+      }
+      connectTargets.add(
+        match.ipv4
+          ? `${match.ipv4}:${match.port}`
+          : `[${match.ipv6}]:${match.port}`
+      );
+    }
+
+    if (
+      [...connectTargets].some(
+        (target) => !/^127.0.0.1:|^\[::1\]:/.test(target)
+      )
+    ) {
+      throw new Error(`Connected to unexpected host! ${[...connectTargets]}`);
+    }
+    if (![...connectTargets].some((target) => /:27091$/.test(target))) {
+      throw new Error(
+        `Missed connection to database server in connect trace! ${[
+          ...connectTargets,
+        ]}`
+      );
+    }
+  });
+});

packages/compass-e2e-tests/tests/no-network-traffic.test.ts

@@ -57,13 +57,11 @@
     "@mongodb-js/eslint-config-compass": "^1.0.1",
     "@mongodb-js/mocha-config-compass": "^1.0.1",
     "@types/js-yaml": "^4.0.5",
-    "@types/lodash.pickby": "^4.6.7",
     "@types/yargs-parser": "21.0.0",
     "chai": "^4.3.6",
     "depcheck": "^1.4.1",
     "eslint": "^7.25.0",
     "hadron-ipc": "^3.1.0",
-    "lodash.pickby": "^4.6.0",
     "mocha": "^6.0.2"
   }
 }

packages/compass-preferences-model/package.json

@@ -16,7 +16,7 @@ describe('Global config file handling', function () {
     await fs.mkdir(tmpdir, { recursive: true });
   });
 
-  after(async function () {
+  afterEach(async function () {
     await fs.rm(tmpdir, { recursive: true });
   });
 

packages/compass-preferences-model/src/global-config.spec.ts

@@ -175,6 +175,7 @@ export interface GlobalPreferenceSources {
 export interface ParsedGlobalPreferencesResult {
   cli: Partial<GlobalPreferences>;
   global: Partial<GlobalPreferences>;
+  hardcoded?: Partial<GlobalPreferences>;
   preferenceParseErrors: string[];
 }
 
@@ -260,7 +261,9 @@ export function getHelpText(): string {
     text += formatSingleOption(key, 'cli');
   }
   text +=
-    '\n(Options marked with (*) are also configurable through the global configuration file.)\n';
+    '\nOptions marked with (*) are also configurable through the global configuration file.\n';
+  text +=
+    'Boolean options can be negated by using a `--no` prefix, e.g. `--no-networkTraffic`.\n';
   text += '\nOnly available in the global configuration file:\n\n';
   for (const key of Object.keys(
     allPreferencesProps