navy 6.0.0 → 7.0.0-alpha.2

package/lib/errors.js

@@ -1,19 +1,15 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.NavyNotInitialisedError = exports.NavyError = void 0;
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 class NavyError {
   constructor(message) {
     this.message = message;
   }
-
   prettyPrint() {
     console.log();
     console.log(_chalk.default.bgRed(_chalk.default.bold(' ERROR ')));
@@ -21,22 +17,16 @@ class NavyError {
     console.log(' ' + this.message);
     console.log();
   }
-
 }
-
 exports.NavyError = NavyError;
-
 class NavyNotInitialisedError extends NavyError {
   constructor(navyName) {
     super('Navy "' + navyName + '" not imported');
   }
-
   prettyPrint() {
     super.prettyPrint();
     console.log(' Make sure you\'ve imported the navy with ' + _chalk.default.bold('navy import'));
     console.log();
   }
-
 }
-
 exports.NavyNotInitialisedError = NavyNotInitialisedError;

package/lib/http-proxy.js

@@ -1,39 +1,49 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.reconfigureHTTPProxy = reconfigureHTTPProxy;
-
+exports.resolveDockerSocketPath = resolveDockerSocketPath;
+exports.resolveProxyImage = resolveProxyImage;
 var _os = _interopRequireDefault(require("os"));
-
 var _path = _interopRequireDefault(require("path"));
-
 var _jsYaml = _interopRequireDefault(require("js-yaml"));
-
 var _dockerClient = _interopRequireDefault(require("./util/docker-client"));
-
 var _fs = _interopRequireDefault(require("fs"));
-
 var _https = require("./util/https");
-
 var _execAsync = require("./util/exec-async");
-
 var _driverLogging = require("./driver-logging");
-
 var _navy = require("./navy");
+const DEFAULT_PROXY_IMAGE = 'navycloud/navy-proxy';
+const DEFAULT_DOCKER_SOCKET = '/var/run/docker.sock';
+function resolveProxyImage(navyFile) {
+  return process.env.NAVY_HTTP_PROXY_IMAGE || navyFile && navyFile.httpProxyImage || DEFAULT_PROXY_IMAGE;
+}
 
-async function updateComposeConfig(navies) {
-  const networks = await _dockerClient.default.listNetworks().filter(net => net.Name.indexOf('_') !== -1) // is docker-compose network?
+// Resolve the host path to the Docker socket. The proxy container needs to
+// read events from the same daemon as the rest of navy, so we honour
+// DOCKER_HOST when it points at a unix socket (e.g. on CI where
+// `docker/setup-docker-action` puts the daemon on a custom path) and fall
+// back to the conventional `/var/run/docker.sock` otherwise.
+function resolveDockerSocketPath() {
+  const dockerHost = process.env.DOCKER_HOST;
+  if (dockerHost && dockerHost.indexOf('unix://') === 0) {
+    const socketPath = dockerHost.slice('unix://'.length);
+    if (socketPath) return socketPath;
+  }
+  return DEFAULT_DOCKER_SOCKET;
+}
+async function updateComposeConfig(navies, navyFile) {
+  const allNetworks = await _dockerClient.default.listNetworks();
+  const networks = allNetworks.filter(net => net.Name.indexOf('_') !== -1) // is docker-compose network?
   .filter(net => {
     for (const navy of navies) {
       if (net.Name.indexOf(navy + '_') === 0) {
         return true;
       }
     }
-
     return false;
   });
   const networksConfig = {};
@@ -41,22 +51,21 @@ async function updateComposeConfig(navies) {
     external: true
   });
   const ports = ['80:80'];
-  const volumes = ['/var/run/docker.sock:/tmp/docker.sock:ro']; // Enable HTTPS for services that
-  // match crt file names in tlsRootCaDir
+  const volumes = [`${resolveDockerSocketPath()}:/tmp/docker.sock:ro`];
 
+  // Enable HTTPS for services that
+  // match crt file names in tlsRootCaDir
   const certsPath = await (0, _https.getCertsPath)(true);
-
   if (certsPath) {
     ports.push('443:443');
     volumes.push(`${certsPath}:/etc/nginx/certs`);
     volumes.push(`${certsPath}:/etc/nginx/dhparam`); // to persist DH params
   }
-
   const config = {
     version: '2',
     services: {
       'nginx-proxy': {
-        image: 'navycloud/navy-proxy',
+        image: resolveProxyImage(navyFile),
         ports,
         networks: networks.map(net => net.Name),
         volumes,
@@ -65,13 +74,10 @@ async function updateComposeConfig(navies) {
     },
     networks: networksConfig
   };
-
   _fs.default.writeFileSync(_path.default.join(_os.default.tmpdir(), 'navyinternaldockercompose.yml'), _jsYaml.default.dump(config));
 }
-
 async function reconfigureHTTPProxy(opts = {}) {
   const navyInternalYamlFile = _path.default.join(_os.default.tmpdir(), 'navyinternaldockercompose.yml');
-
   if (opts.restart) {
     // proxy needs to be recreated to detect changes (deletes) in /etc/nginx/certs
     if (_fs.default.existsSync(navyInternalYamlFile)) {
@@ -79,9 +85,8 @@ async function reconfigureHTTPProxy(opts = {}) {
       await (0, _execAsync.execAsync)('docker compose', ['-f', navyInternalYamlFile, '-p', 'navyinternal', 'rm', '-s', '-f', 'nginx-proxy']);
     }
   }
-
   if (!opts.navies) opts.navies = await (0, _navy.getLaunchedNavyNames)();
-  await updateComposeConfig(opts.navies);
+  await updateComposeConfig(opts.navies, opts.navyFile);
   (0, _driverLogging.log)('Configuring HTTP proxy...');
   await (0, _execAsync.execAsync)('docker compose', ['-f', navyInternalYamlFile, '-p', 'navyinternal', 'up', '-d']);
 }

package/lib/index.js

@@ -40,17 +40,9 @@ Object.defineProperty(exports, "middlewareHelpers", {
     return _helpers.middlewareHelpers;
   }
 });
-
 var _navy = require("./navy");
-
 var _Service = _interopRequireWildcard(require("./service"));
-
 exports.Service = _Service;
-
 var _errors = require("./errors");
-
 var _helpers = require("./middleware/helpers");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }

package/lib/middleware/__tests__/add-service-proxy-config.js

@@ -0,0 +1,258 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var serviceHostModule = _interopRequireWildcard(require("../../util/service-host"));
+var httpsModule = _interopRequireWildcard(require("../../util/https"));
+var _addServiceProxyConfig = _interopRequireDefault(require("../add-service-proxy-config"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/* eslint-env mocha */
+
+function makeNavy({
+  navyFile = null,
+  externalIP = '10.0.0.1'
+} = {}) {
+  return {
+    name: 'env',
+    normalisedName: 'env',
+    getNavyFile: _sinon.default.stub().resolves(navyFile),
+    externalIP: _sinon.default.stub().resolves(externalIP)
+  };
+}
+describe('add-service-proxy-config middleware', function () {
+  let sandbox;
+  let createCertStub;
+  let createHostStub;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    createCertStub = sandbox.stub(httpsModule, 'createCert').resolves();
+    createHostStub = sandbox.stub(serviceHostModule, 'createHostForService').callsFake(async (svc, navyName) => `${svc}.${navyName}.test.local`);
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('factory', function () {
+    it('should return an async middleware function when invoked with a navy', function () {
+      const fn = (0, _addServiceProxyConfig.default)(makeNavy());
+      (0, _chai.expect)(fn).to.be.a('function');
+    });
+  });
+  describe('auto-proxy of port 80', function () {
+    it('should add VIRTUAL_HOST/VIRTUAL_PORT for services exposing port 80 by default', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const config = {
+        services: {
+          web: {
+            ports: ['80:80']
+          }
+        }
+      };
+      const result = await middleware(config, {});
+      (0, _chai.expect)(result.services.web.environment.VIRTUAL_HOST).to.equal('web.env.test.local');
+      (0, _chai.expect)(result.services.web.environment.VIRTUAL_PORT).to.equal(80);
+    });
+    it('should not auto-proxy services that do not expose port 80', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const config = {
+        services: {
+          worker: {
+            ports: ['8080:8080']
+          }
+        }
+      };
+      const result = await middleware(config, {});
+      (0, _chai.expect)(result.services.worker).to.eql({
+        ports: ['8080:8080']
+      });
+    });
+    it('should not auto-proxy services that have no ports declared', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const config = {
+        services: {
+          worker: {}
+        }
+      };
+      const result = await middleware(config, {});
+      (0, _chai.expect)(result.services.worker).to.eql({});
+    });
+  });
+  describe('explicit httpProxy config in navyFile', function () {
+    it('should use the explicit httpProxy config to set VIRTUAL_HOST and VIRTUAL_PORT', async function () {
+      const navy = makeNavy({
+        navyFile: {
+          httpProxy: {
+            api: {
+              port: 3000
+            }
+          }
+        }
+      });
+      const middleware = (0, _addServiceProxyConfig.default)(navy);
+      const result = await middleware({
+        services: {
+          api: {
+            ports: ['3000:3000']
+          }
+        }
+      }, {});
+      (0, _chai.expect)(result.services.api.environment.VIRTUAL_PORT).to.equal(3000);
+      (0, _chai.expect)(result.services.api.environment.VIRTUAL_HOST).to.equal('api.env.test.local');
+    });
+    it('should issue a TLS cert when proxyConfig.enableHttps is set', async function () {
+      const navy = makeNavy({
+        navyFile: {
+          httpProxy: {
+            api: {
+              port: 3000,
+              enableHttps: true
+            }
+          }
+        }
+      });
+      const middleware = (0, _addServiceProxyConfig.default)(navy);
+      await middleware({
+        services: {
+          api: {}
+        }
+      }, {});
+      (0, _chai.expect)(createCertStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(createCertStub.firstCall.args[0]).to.eql({
+        hostName: 'api.env.test.local'
+      });
+    });
+    it('should not issue a TLS cert when proxyConfig is implicit (no enableHttps)', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      await middleware({
+        services: {
+          web: {
+            ports: ['80:80']
+          }
+        }
+      }, {});
+      (0, _chai.expect)(createCertStub.called).to.equal(false);
+    });
+  });
+  describe('httpProxyAutoPorts navyFile config', function () {
+    it('should auto-proxy a different port when configured via httpProxyAutoPorts', async function () {
+      const navy = makeNavy({
+        navyFile: {
+          httpProxyAutoPorts: ['3000']
+        }
+      });
+      const middleware = (0, _addServiceProxyConfig.default)(navy);
+      const result = await middleware({
+        services: {
+          api: {
+            ports: ['3000:3000']
+          }
+        }
+      }, {});
+      (0, _chai.expect)(result.services.api.environment.VIRTUAL_PORT).to.equal(3000);
+    });
+    it('should fall back to ["80"] when httpProxyAutoPorts is not an array', async function () {
+      const navy = makeNavy({
+        navyFile: {
+          httpProxyAutoPorts: 'not-an-array'
+        }
+      });
+      const middleware = (0, _addServiceProxyConfig.default)(navy);
+      const result = await middleware({
+        services: {
+          web: {
+            ports: ['80:80']
+          }
+        }
+      }, {});
+      (0, _chai.expect)(result.services.web.environment.VIRTUAL_PORT).to.equal(80);
+    });
+  });
+  describe('port matching forms', function () {
+    it('should match a numeric port equal to the auto port', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const result = await middleware({
+        services: {
+          web: {
+            ports: [80]
+          }
+        }
+      }, {});
+      // eslint-disable-next-line no-unused-expressions
+      (0, _chai.expect)(result.services.web.environment).to.exist;
+    });
+    it('should match a "80/tcp" protocol-suffixed port', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const result = await middleware({
+        services: {
+          web: {
+            ports: ['80/tcp']
+          }
+        }
+      }, {});
+      // eslint-disable-next-line no-unused-expressions
+      (0, _chai.expect)(result.services.web.environment).to.exist;
+    });
+    it('should match a port object with a target field equal to the auto port', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const result = await middleware({
+        services: {
+          web: {
+            ports: [{
+              target: 80,
+              published: 8080
+            }]
+          }
+        }
+      }, {});
+      // eslint-disable-next-line no-unused-expressions
+      (0, _chai.expect)(result.services.web.environment).to.exist;
+    });
+  });
+  describe('environment merge', function () {
+    it('should not overwrite existing env vars with VIRTUAL_HOST/VIRTUAL_PORT', async function () {
+      const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+      const result = await middleware({
+        services: {
+          web: {
+            ports: ['80:80'],
+            environment: {
+              VIRTUAL_HOST: 'preset.host',
+              OTHER: 'x'
+            }
+          }
+        }
+      }, {});
+      (0, _chai.expect)(result.services.web.environment.VIRTUAL_HOST).to.equal('preset.host');
+      (0, _chai.expect)(result.services.web.environment.OTHER).to.equal('x');
+    });
+  });
+  it('should preserve other top-level config keys', async function () {
+    const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+    const result = await middleware({
+      version: '3.7',
+      services: {
+        web: {
+          ports: ['80:80']
+        }
+      },
+      networks: {
+        default: {}
+      }
+    }, {});
+    (0, _chai.expect)(result.version).to.equal('3.7');
+    (0, _chai.expect)(result.networks).to.eql({
+      default: {}
+    });
+  });
+  it('should not call externalIP/createHostForService for services without proxy config', async function () {
+    const middleware = (0, _addServiceProxyConfig.default)(makeNavy());
+    await middleware({
+      services: {
+        worker: {
+          ports: ['9000:9000']
+        }
+      }
+    }, {});
+    (0, _chai.expect)(createHostStub.called).to.equal(false);
+  });
+});

package/lib/middleware/__tests__/develop.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _develop = _interopRequireDefault(require("../develop"));
+/* eslint-env mocha */
+
+describe('develop middleware', function () {
+  it('should return the service unchanged when no service state exists', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api',
+          command: 'npm start'
+        }
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _develop.default)(config, state);
+    (0, _chai.expect)(result.services.api).to.eql({
+      image: 'api',
+      command: 'npm start'
+    });
+  });
+  it('should return the service unchanged when state has no _develop entry', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api',
+          command: 'npm start'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          unrelated: true
+        }
+      }
+    };
+    const result = (0, _develop.default)(config, state);
+    (0, _chai.expect)(result.services.api).to.eql({
+      image: 'api',
+      command: 'npm start'
+    });
+  });
+  it('should set stdin_open and append _develop.mounts as volumes', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api',
+          volumes: ['./preexisting:/preexisting'],
+          command: 'npm start'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _develop: {
+            mounts: {
+              './local': '/app',
+              './node_modules': '/app/node_modules'
+            }
+          }
+        }
+      }
+    };
+    const result = (0, _develop.default)(config, state);
+    (0, _chai.expect)(result.services.api.stdin_open).to.equal(true);
+    (0, _chai.expect)(result.services.api.volumes).to.include('./preexisting:/preexisting');
+    (0, _chai.expect)(result.services.api.volumes).to.include('./local:/app');
+    (0, _chai.expect)(result.services.api.volumes).to.include('./node_modules:/app/node_modules');
+  });
+  it('should override the command when _develop.command is set', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api',
+          command: 'npm start'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _develop: {
+            mounts: {},
+            command: 'npm run dev'
+          }
+        }
+      }
+    };
+    const result = (0, _develop.default)(config, state);
+    (0, _chai.expect)(result.services.api.command).to.equal('npm run dev');
+  });
+  it('should keep the existing command when _develop.command is not set', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api',
+          command: 'npm start'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _develop: {
+            mounts: {}
+          }
+        }
+      }
+    };
+    const result = (0, _develop.default)(config, state);
+    (0, _chai.expect)(result.services.api.command).to.equal('npm start');
+  });
+});