navy 6.0.0 → 7.0.0-alpha.2

package/lib/util/__tests__/https.js

@@ -0,0 +1,301 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+var _errors = require("../../errors");
+/* eslint-env mocha */
+
+describe('util/https', function () {
+  let sandbox;
+  let getConfigStub;
+  let getConfigDirStub;
+  let DEFAULT_TLS_ROOT_CA_DIR;
+  let getNavyStub;
+  let navyStub;
+  let fsStub;
+  let pkiStub;
+  let mdStub;
+  let httpsModule;
+  function loadModule() {
+    httpsModule = _proxyquire.default.noCallThru()('../https', {
+      '../config': {
+        getConfig: getConfigStub,
+        getConfigDir: getConfigDirStub,
+        DEFAULT_TLS_ROOT_CA_DIR
+      },
+      '../errors': {
+        NavyError: _errors.NavyError
+      },
+      '../navy': {
+        getNavy: getNavyStub
+      },
+      fs: fsStub,
+      'node-forge': {
+        pki: pkiStub,
+        md: mdStub
+      }
+    });
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getConfigStub = sandbox.stub().returns({});
+    getConfigDirStub = sandbox.stub().returns('/cfg');
+    DEFAULT_TLS_ROOT_CA_DIR = '/default-ca-dir';
+    navyStub = {
+      url: sandbox.stub().resolves('https://web.local')
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    fsStub = {
+      existsSync: sandbox.stub().returns(true),
+      mkdirSync: sandbox.stub(),
+      unlinkSync: sandbox.stub(),
+      readFileSync: sandbox.stub().returns('--PEM--'),
+      writeFileSync: sandbox.stub()
+    };
+    const certObj = {
+      publicKey: null,
+      serialNumber: null,
+      validity: {
+        notBefore: new Date(),
+        notAfter: new Date()
+      },
+      setSubject: sandbox.stub(),
+      setIssuer: sandbox.stub(),
+      setExtensions: sandbox.stub(),
+      sign: sandbox.stub(),
+      subject: {
+        attributes: []
+      }
+    };
+    pkiStub = {
+      rsa: {
+        generateKeyPair: sandbox.stub().returns({
+          publicKey: 'pub',
+          privateKey: 'priv'
+        })
+      },
+      createCertificate: sandbox.stub().returns(certObj),
+      privateKeyToPem: sandbox.stub().returns('priv-pem'),
+      publicKeyToPem: sandbox.stub().returns('pub-pem'),
+      certificateToPem: sandbox.stub().returns('cert-pem'),
+      privateKeyFromPem: sandbox.stub().returns('priv-key-obj'),
+      certificateFromPem: sandbox.stub().returns({
+        subject: {
+          attributes: [{
+            name: 'commonName',
+            value: 'ca'
+          }]
+        }
+      })
+    };
+    mdStub = {
+      sha256: {
+        create: sandbox.stub().returns('digest')
+      }
+    };
+    loadModule();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('getCertsPath', function () {
+    it('should return the certs path when it exists', function () {
+      fsStub.existsSync.returns(true);
+      const result = httpsModule.getCertsPath();
+      (0, _chai.expect)(result).to.contain('tls-certs');
+      (0, _chai.expect)(fsStub.mkdirSync.called).to.equal(false);
+    });
+    it('should return an empty string when path does not exist and create is false', function () {
+      fsStub.existsSync.returns(false);
+      const result = httpsModule.getCertsPath();
+      (0, _chai.expect)(result).to.equal('');
+      (0, _chai.expect)(fsStub.mkdirSync.called).to.equal(false);
+    });
+    it('should create the path when create is true and it does not exist', function () {
+      fsStub.existsSync.returns(false);
+      const result = httpsModule.getCertsPath(true);
+      (0, _chai.expect)(fsStub.mkdirSync.calledOnce).to.equal(true);
+      (0, _chai.expect)(fsStub.mkdirSync.firstCall.args[0]).to.contain('tls-certs');
+      (0, _chai.expect)(fsStub.mkdirSync.firstCall.args[1]).to.eql({
+        recursive: true
+      });
+      (0, _chai.expect)(result).to.contain('tls-certs');
+    });
+  });
+  describe('removeCert', function () {
+    it('should unlink each existing cert/key file', async function () {
+      fsStub.existsSync.callsFake(p => p === '/cfg/tls-certs' || p.endsWith('web.local.crt') || p.endsWith('web.local.key'));
+      navyStub.url.resolves('https://web.local');
+      await httpsModule.removeCert({
+        navy: 'env-1',
+        disable: 'web'
+      });
+      (0, _chai.expect)(fsStub.unlinkSync.callCount).to.equal(2);
+      const paths = fsStub.unlinkSync.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(paths.some(p => p.endsWith('web.local.crt'))).to.equal(true);
+      (0, _chai.expect)(paths.some(p => p.endsWith('web.local.key'))).to.equal(true);
+    });
+    it('should skip files that do not exist', async function () {
+      fsStub.existsSync.callsFake(p => p === '/cfg/tls-certs');
+      await httpsModule.removeCert({
+        navy: 'env-1',
+        disable: 'web'
+      });
+      (0, _chai.expect)(fsStub.unlinkSync.called).to.equal(false);
+    });
+    it('should wrap unlink errors in NavyError', async function () {
+      fsStub.existsSync.callsFake(p => p === '/cfg/tls-certs' || p.endsWith('.crt') || p.endsWith('.key'));
+      fsStub.unlinkSync.throws(new Error('permission denied'));
+      let caught;
+      try {
+        await httpsModule.removeCert({
+          navy: 'env-1',
+          disable: 'web'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+    });
+  });
+  describe('generateRootCa', function () {
+    it('should create the root CA dir when missing', async function () {
+      fsStub.existsSync.callsFake(p => {
+        if (p === '/default-ca-dir') return false;
+        return false;
+      });
+      await httpsModule.generateRootCa();
+      (0, _chai.expect)(fsStub.mkdirSync.calledWith('/default-ca-dir')).to.equal(true);
+      (0, _chai.expect)(fsStub.writeFileSync.calledThrice).to.equal(true);
+    });
+    it('should wrap mkdir errors in NavyError', async function () {
+      fsStub.existsSync.returns(false);
+      fsStub.mkdirSync.throws(new Error('permission denied'));
+      let caught;
+      try {
+        await httpsModule.generateRootCa();
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+    });
+    it('should skip generation when CA already exists', async function () {
+      fsStub.existsSync.callsFake(p => p.endsWith('ca.crt') || p.endsWith('ca.key') || p === '/default-ca-dir');
+      await httpsModule.generateRootCa();
+      (0, _chai.expect)(pkiStub.rsa.generateKeyPair.called).to.equal(false);
+      (0, _chai.expect)(fsStub.writeFileSync.called).to.equal(false);
+    });
+    it('should generate, sign, and write CA files when missing', async function () {
+      fsStub.existsSync.callsFake(p => p === '/default-ca-dir');
+      await httpsModule.generateRootCa();
+      (0, _chai.expect)(pkiStub.rsa.generateKeyPair.calledWith(2048)).to.equal(true);
+      (0, _chai.expect)(pkiStub.createCertificate.calledOnce).to.equal(true);
+      (0, _chai.expect)(fsStub.writeFileSync.calledThrice).to.equal(true);
+      const writtenPaths = fsStub.writeFileSync.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('ca.key'))).to.equal(true);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('ca.pub.key'))).to.equal(true);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('ca.crt'))).to.equal(true);
+    });
+    it('should use a custom root CA dir when supplied via config', async function () {
+      getConfigStub.returns({
+        tlsRootCaDir: '/custom-ca'
+      });
+      fsStub.existsSync.callsFake(p => p === '/custom-ca');
+      await httpsModule.generateRootCa();
+      const writtenPaths = fsStub.writeFileSync.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(writtenPaths.every(p => p.startsWith('/custom-ca/'))).to.equal(true);
+    });
+    it('should wrap signing errors in NavyError', async function () {
+      fsStub.existsSync.callsFake(p => p === '/default-ca-dir');
+      const cert = pkiStub.createCertificate();
+      cert.sign = sandbox.stub().throws(new Error('sign failure'));
+      pkiStub.createCertificate.returns(cert);
+      let caught;
+      try {
+        await httpsModule.generateRootCa();
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+    });
+  });
+  describe('createCert', function () {
+    it('should skip creation when the cert already exists', async function () {
+      fsStub.existsSync.callsFake(p => p === '/cfg/tls-certs' || p === '/cfg/tls-certs/web.local.crt');
+      await httpsModule.createCert({
+        serviceUrl: 'https://web.local'
+      });
+      (0, _chai.expect)(fsStub.writeFileSync.called).to.equal(false);
+    });
+    it('should generate, sign, and write a service cert', async function () {
+      fsStub.existsSync.callsFake(p => {
+        if (p === '/cfg/tls-certs') return true;
+        if (p === '/default-ca-dir') return true;
+        if (p === '/default-ca-dir/ca.crt' || p === '/default-ca-dir/ca.key') return true;
+        return false;
+      });
+      await httpsModule.createCert({
+        serviceUrl: 'https://web.local'
+      });
+      (0, _chai.expect)(pkiStub.privateKeyFromPem.calledOnce).to.equal(true);
+      (0, _chai.expect)(pkiStub.certificateFromPem.calledOnce).to.equal(true);
+      (0, _chai.expect)(fsStub.writeFileSync.calledTwice).to.equal(true);
+      const writtenPaths = fsStub.writeFileSync.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('web.local.key'))).to.equal(true);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('web.local.crt'))).to.equal(true);
+    });
+    it('should use opts.hostName when supplied', async function () {
+      fsStub.existsSync.callsFake(p => {
+        if (p === '/cfg/tls-certs') return true;
+        if (p === '/default-ca-dir') return true;
+        if (p === '/default-ca-dir/ca.crt' || p === '/default-ca-dir/ca.key') return true;
+        return false;
+      });
+      await httpsModule.createCert({
+        hostName: 'custom-host'
+      });
+      const writtenPaths = fsStub.writeFileSync.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('custom-host.key'))).to.equal(true);
+      (0, _chai.expect)(writtenPaths.some(p => p.endsWith('custom-host.crt'))).to.equal(true);
+    });
+    it('should use a custom tlsRootCaDir from config', async function () {
+      getConfigStub.returns({
+        tlsRootCaDir: '/custom-ca'
+      });
+      fsStub.existsSync.callsFake(p => {
+        if (p === '/cfg/tls-certs') return true;
+        if (p === '/custom-ca') return true;
+        if (p === '/custom-ca/ca.crt' || p === '/custom-ca/ca.key') return true;
+        return false;
+      });
+      await httpsModule.createCert({
+        serviceUrl: 'https://web.local'
+      });
+      const readPaths = fsStub.readFileSync.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(readPaths.some(p => p === '/custom-ca/ca.crt')).to.equal(true);
+      (0, _chai.expect)(readPaths.some(p => p === '/custom-ca/ca.key')).to.equal(true);
+    });
+    it('should wrap signing errors in NavyError', async function () {
+      fsStub.existsSync.callsFake(p => {
+        if (p === '/cfg/tls-certs') return true;
+        if (p === '/default-ca-dir') return true;
+        if (p === '/default-ca-dir/ca.crt' || p === '/default-ca-dir/ca.key') return true;
+        return false;
+      });
+      const cert = pkiStub.createCertificate();
+      cert.sign = sandbox.stub().throws(new Error('sign fail'));
+      pkiStub.createCertificate.returns(cert);
+      let caught;
+      try {
+        await httpsModule.createCert({
+          serviceUrl: 'https://web.local'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+    });
+  });
+});

package/lib/util/__tests__/navyrc.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("../fs"));
+var _navyrc = _interopRequireDefault(require("../navyrc"));
+/* eslint-env mocha */
+
+describe('navyrc', function () {
+  describe('getNavyRc', function () {
+    let sandbox;
+    beforeEach(function () {
+      sandbox = _sinon.default.createSandbox();
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    it('should read and parse the .navyrc JSON file from the given directory', async function () {
+      const config = {
+        services: ['api', 'web'],
+        plugins: ['nodejs']
+      };
+      const readStub = sandbox.stub(_fs.default, 'readFileAsync').resolves(JSON.stringify(config));
+      const result = await (0, _navyrc.default)('/some/dir');
+      (0, _chai.expect)(result).to.eql(config);
+      (0, _chai.expect)(readStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(readStub.firstCall.args[0]).to.equal(_path.default.join('/some/dir', '.navyrc'));
+    });
+    it('should return null when the file cannot be read', async function () {
+      const err = Object.assign(new Error('not found'), {
+        code: 'ENOENT'
+      });
+      sandbox.stub(_fs.default, 'readFileAsync').rejects(err);
+      const result = await (0, _navyrc.default)('/missing/dir');
+      (0, _chai.expect)(result).to.equal(null);
+    });
+    it('should return null when the file content is not valid JSON', async function () {
+      sandbox.stub(_fs.default, 'readFileAsync').resolves('not json {{{');
+      const result = await (0, _navyrc.default)('/dir');
+      (0, _chai.expect)(result).to.equal(null);
+    });
+  });
+});

package/lib/util/__tests__/service-host.js

@@ -1,11 +1,30 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _chai = require("chai");
-
+var _sinon = _interopRequireDefault(require("sinon"));
+var _fs = _interopRequireDefault(require("fs"));
+var httpsModule = _interopRequireWildcard(require("../https"));
 var _serviceHost = require("../service-host");
-
+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 */
+
 describe('service-host', function () {
+  let sandbox;
+  const originalSubdomain = process.env.NAVY_EXTERNAL_SUBDOMAIN;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    sandbox.stub(httpsModule, 'getCertsPath').returns('/fake/certs');
+    sandbox.stub(_fs.default, 'existsSync').returns(false);
+  });
+  afterEach(function () {
+    sandbox.restore();
+    if (originalSubdomain === undefined) {
+      delete process.env.NAVY_EXTERNAL_SUBDOMAIN;
+    } else {
+      process.env.NAVY_EXTERNAL_SUBDOMAIN = originalSubdomain;
+    }
+  });
   describe('getNIPSubdomain', function () {
     it('should return an nip.io domain with the correct IP address', async function () {
       (0, _chai.expect)(await (0, _serviceHost.getNIPSubdomain)('192.168.1.10')).to.equal('192.168.1.10.nip.io');
@@ -13,6 +32,10 @@ describe('service-host', function () {
     it('should fallback to localhost when a hostname is passed instead of an IP address', async function () {
       process.env.NAVY_EXTERNAL_IP = 'somehostname';
       (0, _chai.expect)(await (0, _serviceHost.getNIPSubdomain)('somehostname')).to.equal('127.0.0.1.nip.io');
+      delete process.env.NAVY_EXTERNAL_IP;
+    });
+    it('should treat malformed IPs (out-of-range octets) as invalid', async function () {
+      (0, _chai.expect)(await (0, _serviceHost.getNIPSubdomain)('999.0.0.1')).to.equal('127.0.0.1.nip.io');
     });
   });
   describe('createHostForService', function () {
@@ -20,11 +43,20 @@ describe('service-host', function () {
       (0, _chai.expect)(await (0, _serviceHost.createHostForService)('someservice', 'mynavy', '127.0.0.1')).to.equal('someservice.mynavy.127.0.0.1.nip.io');
       (0, _chai.expect)(await (0, _serviceHost.createHostForService)('someservice', 'mynavy', '192.168.1.10')).to.equal('someservice.mynavy.192.168.1.10.nip.io');
     });
+    it('should use NAVY_EXTERNAL_SUBDOMAIN when set, in preference to nip.io', async function () {
+      process.env.NAVY_EXTERNAL_SUBDOMAIN = 'dev.example.com';
+      (0, _chai.expect)(await (0, _serviceHost.createHostForService)('api', 'env', '10.0.0.1')).to.equal('api.env.dev.example.com');
+    });
   });
   describe('createUrlForService', function () {
-    it('should return the correct url for a service', async function () {
+    it('should return an http URL when no certificate exists', async function () {
       (0, _chai.expect)(await (0, _serviceHost.createUrlForService)('someservice', 'mynavy', '192.168.99.100')).to.equal('http://someservice.mynavy.192.168.99.100.nip.io');
     });
+    it('should return an https URL when a matching .crt exists in the certs path', async function () {
+      _fs.default.existsSync.restore();
+      sandbox.stub(_fs.default, 'existsSync').callsFake(filePath => filePath === '/fake/certs/someservice.mynavy.192.168.99.100.nip.io.crt');
+      (0, _chai.expect)(await (0, _serviceHost.createUrlForService)('someservice', 'mynavy', '192.168.99.100')).to.equal('https://someservice.mynavy.192.168.99.100.nip.io');
+    });
   });
   describe('getUrlFromService', function () {
     it('should extract the host from service ENV config', function () {
@@ -37,14 +69,40 @@ describe('service-host', function () {
       };
       (0, _chai.expect)((0, _serviceHost.getUrlFromService)(service)).to.equal('http://myservice.coolnavy.127.0.0.1.nip.io');
     });
-    it('should return null when the service object is not valid', function () {
+    it('should return https when a certificate exists for the VIRTUAL_HOST', function () {
+      _fs.default.existsSync.restore();
+      sandbox.stub(_fs.default, 'existsSync').callsFake(filePath => filePath === '/fake/certs/myservice.coolnavy.127.0.0.1.nip.io.crt');
       const service = {
         raw: {
-          Config: {}
+          Config: {
+            Env: ['OTHER=value', 'VIRTUAL_HOST=myservice.coolnavy.127.0.0.1.nip.io']
+          }
+        }
+      };
+      (0, _chai.expect)((0, _serviceHost.getUrlFromService)(service)).to.equal('https://myservice.coolnavy.127.0.0.1.nip.io');
+    });
+    it('should return null when env contains no VIRTUAL_HOST entry', function () {
+      const service = {
+        raw: {
+          Config: {
+            Env: ['FOO=bar', 'BAZ=qux']
+          }
         }
       };
       (0, _chai.expect)((0, _serviceHost.getUrlFromService)(service)).to.equal(null);
+    });
+    it('should return null when the service object is not valid', function () {
+      (0, _chai.expect)((0, _serviceHost.getUrlFromService)({
+        raw: {
+          Config: {}
+        }
+      })).to.equal(null);
+      (0, _chai.expect)((0, _serviceHost.getUrlFromService)({
+        raw: {}
+      })).to.equal(null);
+      (0, _chai.expect)((0, _serviceHost.getUrlFromService)({})).to.equal(null);
       (0, _chai.expect)((0, _serviceHost.getUrlFromService)(undefined)).to.equal(null);
+      (0, _chai.expect)((0, _serviceHost.getUrlFromService)(null)).to.equal(null);
     });
   });
 });

package/lib/util/__tests__/table.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _stripAnsi = _interopRequireDefault(require("strip-ansi"));
+var _table = _interopRequireDefault(require("../table"));
+/* eslint-env mocha */
+
+describe('table', function () {
+  it('should return an empty string when given no rows', function () {
+    (0, _chai.expect)((0, _table.default)([])).to.equal('');
+  });
+  it('should render a single-row table padded by 2 spaces', function () {
+    const result = (0, _table.default)([['a', 'bb']]);
+    (0, _chai.expect)(result).to.equal('a  bb  ');
+  });
+  it('should pad each column to the longest value in that column plus 2', function () {
+    const result = (0, _table.default)([['name', 'status'], ['api', 'running'], ['web', 'stopped']]);
+    const lines = result.split('\n');
+    (0, _chai.expect)(lines).to.have.lengthOf(3);
+    (0, _chai.expect)(lines[0]).to.equal('name  status   ');
+    (0, _chai.expect)(lines[1]).to.equal('api   running  ');
+    (0, _chai.expect)(lines[2]).to.equal('web   stopped  ');
+  });
+  it('should treat null/undefined cells in the header as empty strings when sizing', function () {
+    const result = (0, _table.default)([[null, 'b'], ['xx', 'yyy']]);
+    const lines = result.split('\n');
+    (0, _chai.expect)(lines[0]).to.equal('    b    ');
+    (0, _chai.expect)(lines[1]).to.equal('xx  yyy  ');
+  });
+  it('should only render the cells that exist on each row (shorter rows are not back-padded)', function () {
+    const result = (0, _table.default)([['a', 'b'], ['x']]);
+    const lines = result.split('\n');
+    (0, _chai.expect)(lines[0]).to.equal('a  b  ');
+    (0, _chai.expect)(lines[1]).to.equal('x  ');
+  });
+  it('should size columns by visible (ANSI-stripped) length', function () {
+    const ansiCell = '\u001b[31mhello\u001b[0m';
+    const result = (0, _table.default)([['col1'], [ansiCell]]);
+    const lines = result.split('\n');
+    (0, _chai.expect)((0, _stripAnsi.default)(lines[0])).to.equal('col1   ');
+    (0, _chai.expect)((0, _stripAnsi.default)(lines[1])).to.equal('hello  ');
+  });
+});

package/lib/util/docker-client.js

@@ -1,19 +1,11 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _dockerode = _interopRequireDefault(require("dockerode"));
-
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
-const dockerClient = new _dockerode.default({
-  Promise: _bluebird.default
-});
-var _default = dockerClient;
-exports.default = _default;
+const dockerClient = new _dockerode.default();
+var _default = exports.default = dockerClient;
 module.exports = exports.default;

package/lib/util/exec-async.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.execAsync = execAsync;
-
 var _child_process = require("child_process");
-
 const debug = require('debug')('navy:exec');
-
 function execAsync(command, args = [], callback, opts) {
   return new Promise((resolve, reject) => {
     const cmd = command + ' ' + args.join(' ');
@@ -22,7 +19,6 @@ function execAsync(command, args = [], callback, opts) {
     });
     childProcess.stdout.on('data', line => debug('out: ' + line.toString()));
     childProcess.stderr.on('data', line => debug('err: ' + line.toString()));
-
     if (callback) {
       callback(childProcess);
     }

package/lib/util/external-ip.js

@@ -1,20 +1,18 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.dnsLookup = dnsLookup;
 exports.getExternalIP = getExternalIP;
-
 var _dns = _interopRequireDefault(require("dns"));
-
 const IPV4_FAMILY = 4;
-
 async function dnsLookup(hostname) {
   return await new Promise((resolve, reject) => {
-    _dns.default.lookup(hostname, null, (err, ip, ipFamily) => {
+    _dns.default.lookup(hostname, {
+      family: IPV4_FAMILY
+    }, (err, ip, ipFamily) => {
       if (err || ipFamily !== IPV4_FAMILY) {
         reject(new Error('Failed to lookup hostname "' + hostname + '"'));
       } else {
@@ -23,34 +21,32 @@ async function dnsLookup(hostname) {
     });
   });
 }
-
 async function getExternalIP(ipInConfig) {
-  const dockerHost = process.env.DOCKER_HOST; // DEPRECATED use NAVY_EXTERNAL_IP instead
+  const dockerHost = process.env.DOCKER_HOST;
 
+  // DEPRECATED use NAVY_EXTERNAL_IP instead
   if (process.env.NAVY_HOST) {
     return process.env.NAVY_HOST;
   }
-
   if (process.env.NAVY_EXTERNAL_IP) {
     // Custom external IP
     return process.env.NAVY_EXTERNAL_IP;
   }
-
   if (ipInConfig) {
     return await dnsLookup(ipInConfig);
   }
-
   if (dockerHost && dockerHost.indexOf('tcp://') !== -1) {
     // OSX with docker-machine, or a remote docker
     // dockerHost will be formatted like:
     // tcp://_._._._:_
     // We only care about the IP address
+
     let ip = dockerHost.substring('tcp://'.length);
     ip = ip.substring(0, ip.lastIndexOf(':')).trim();
     ip = await dnsLookup(ip);
     return ip;
-  } // No custom docker host, assume localhost
-
+  }
 
+  // No custom docker host, assume localhost
   return '127.0.0.1';
 }

package/lib/util/fs.js

@@ -1,15 +1,10 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _bluebird = _interopRequireDefault(require("bluebird"));
-
-var _default = _bluebird.default.promisifyAll(require('fs'));
-
-exports.default = _default;
+var _default = exports.default = _bluebird.default.promisifyAll(require('fs'));
 module.exports = exports.default;

package/lib/util/get-lan-ip.js

@@ -1,23 +1,18 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getLANIP = getLANIP;
-
 var _dns = _interopRequireDefault(require("dns"));
-
 var _os = _interopRequireDefault(require("os"));
-
 async function getLANIP() {
   return await new Promise((resolve, reject) => {
     _dns.default.lookup(_os.default.hostname(), null, (err, addr) => {
       if (err) {
         return reject(err);
       }
-
       return resolve(addr);
     });
   });