navy 6.0.0 → 7.0.0-alpha.2

package/lib/navy/state.js

@@ -1,7 +1,6 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -12,64 +11,53 @@ exports.pathToNavyRoot = pathToNavyRoot;
 exports.pathToNavys = pathToNavys;
 exports.pathToState = pathToState;
 exports.saveState = saveState;
-
 var _path = _interopRequireDefault(require("path"));
-
 var _invariant = _interopRequireDefault(require("invariant"));
-
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
-var _fs = _interopRequireDefault(require("../util/fs"));
-
+var _fs = require("fs");
+var _fs2 = _interopRequireDefault(require("../util/fs"));
 const debug = require('debug')('navy:state');
-
-const mkdirp = _bluebird.default.promisify(require('mkdirp'));
-
-const rimraf = _bluebird.default.promisify(require('rimraf'));
-
 function pathToNavyRoot() {
   const home = process.env.HOME;
   (0, _invariant.default)(home, "NO_HOME_DIRECTORY: No home directory available");
   return _path.default.join(home, '.navy');
 }
-
 function pathToNavys() {
   return _path.default.join(pathToNavyRoot(), 'navies');
 }
-
 function pathToNavy(normalisedEnvName) {
   return _path.default.join(pathToNavys(), normalisedEnvName);
 }
-
 function pathToState(normalisedEnvName) {
   return _path.default.join(pathToNavy(normalisedEnvName), 'state.json');
 }
 /* eslint-disable no-use-before-define */
-
-
 async function getState(normalisedEnvName) {
   /* eslint-enable no-use-before-define */
   try {
     const statePath = pathToState(normalisedEnvName);
-    const file = (await _fs.default.readFileAsync(statePath)).toString();
+    const file = (await _fs2.default.readFileAsync(statePath)).toString();
     debug('Got raw state for env ' + normalisedEnvName, statePath, file);
     return JSON.parse(file);
   } catch (ex) {
     return null;
   }
 }
-
 async function saveState(normalisedEnvName, state) {
   const statePath = pathToState(normalisedEnvName);
-  await mkdirp(_path.default.dirname(statePath));
+  await _fs.promises.mkdir(_path.default.dirname(statePath), {
+    recursive: true
+  });
   debug('Writing state for env ' + normalisedEnvName, statePath, state);
-  await _fs.default.writeFileAsync(statePath, JSON.stringify(state, null, 2));
+  await _fs2.default.writeFileAsync(statePath, JSON.stringify(state, null, 2));
 }
-
 async function deleteState(normalisedEnvName) {
   debug('Deleting state for env ' + normalisedEnvName);
-  await rimraf(_path.default.dirname(pathToState(normalisedEnvName)));
+  await _fs.promises.rm(_path.default.dirname(pathToState(normalisedEnvName)), {
+    recursive: true,
+    force: true
+  });
 }
+
 /**
  * A "state" object of the current services, and other internal Navy state.
  * This can be used to hang "state" off services which can then be used by middleware at runtime to modify the

package/lib/navy/util.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.normaliseNavyName = normaliseNavyName;
-
 function normaliseNavyName(envName) {
   return envName.replace(/\W/g, '');
 }

package/lib/service.js

@@ -4,8 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Status = void 0;
-const Status = {
+const Status = exports.Status = {
   RUNNING: 'running',
   EXITED: 'exited'
-};
-exports.Status = Status;
+};

package/lib/util/__tests__/exec-async.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _events = require("events");
+var _child_process = _interopRequireDefault(require("child_process"));
+var _execAsync = require("../exec-async");
+/* eslint-env mocha */
+
+function createFakeChild() {
+  const child = new _events.EventEmitter();
+  child.stdout = new _events.EventEmitter();
+  child.stderr = new _events.EventEmitter();
+  return child;
+}
+describe('exec-async', function () {
+  describe('execAsync', function () {
+    let sandbox;
+    let execStub;
+    let fakeChild;
+    beforeEach(function () {
+      sandbox = _sinon.default.createSandbox();
+      fakeChild = createFakeChild();
+      execStub = sandbox.stub(_child_process.default, 'exec').callsFake((cmd, opts, cb) => {
+        process.nextTick(() => {
+          fakeChild.stdout.emit('data', Buffer.from('hello'));
+          fakeChild.stderr.emit('data', Buffer.from('warn'));
+          cb(null, 'hello world', '');
+        });
+        return fakeChild;
+      });
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    it('should resolve with stdout when the command succeeds', async function () {
+      const result = await (0, _execAsync.execAsync)('echo', ['hello', 'world']);
+      (0, _chai.expect)(result).to.equal('hello world');
+      (0, _chai.expect)(execStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(execStub.firstCall.args[0]).to.equal('echo hello world');
+    });
+    it('should default args to an empty array when not provided', async function () {
+      const result = await (0, _execAsync.execAsync)('echo');
+      (0, _chai.expect)(result).to.equal('hello world');
+      (0, _chai.expect)(execStub.firstCall.args[0]).to.equal('echo ');
+    });
+    it('should pass opts through to child_process.exec', async function () {
+      const opts = {
+        cwd: '/tmp',
+        env: {
+          FOO: 'bar'
+        }
+      };
+      await (0, _execAsync.execAsync)('ls', ['-la'], null, opts);
+      (0, _chai.expect)(execStub.firstCall.args[1]).to.equal(opts);
+    });
+    it('should invoke the callback with the spawned child process', async function () {
+      const callback = _sinon.default.spy();
+      await (0, _execAsync.execAsync)('echo', ['hi'], callback);
+      (0, _chai.expect)(callback.calledOnce).to.equal(true);
+      (0, _chai.expect)(callback.firstCall.args[0]).to.equal(fakeChild);
+    });
+    it('should not invoke the callback when none is supplied', async function () {
+      await (0, _execAsync.execAsync)('echo', ['hi']);
+    });
+    it('should reject when the command fails', async function () {
+      execStub.restore();
+      const failure = new Error('boom');
+      execStub = sandbox.stub(_child_process.default, 'exec').callsFake((cmd, opts, cb) => {
+        process.nextTick(() => cb(failure));
+        return fakeChild;
+      });
+      let caught;
+      try {
+        await (0, _execAsync.execAsync)('false');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.equal(failure);
+    });
+  });
+});

package/lib/util/__tests__/external-ip.js

@@ -1,10 +1,12 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 var _chai = require("chai");
-
+var _sinon = _interopRequireDefault(require("sinon"));
+var _dns = _interopRequireDefault(require("dns"));
 var _externalIp = require("../external-ip");
-
 /* eslint-env mocha */
+
 describe('getExternalIP', function () {
   it('should return NAVY_EXTERNAL_IP if set', async function () {
     process.env.NAVY_EXTERNAL_IP = '192.168.1.10';
@@ -23,4 +25,97 @@ describe('getExternalIP', function () {
     (0, _chai.expect)(await (0, _externalIp.getExternalIP)()).to.equal('192.168.1.13');
     delete process.env.DOCKER_HOST;
   });
+});
+describe('external-ip (mocked)', function () {
+  let sandbox;
+  let originalEnv;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    originalEnv = {
+      DOCKER_HOST: process.env.DOCKER_HOST,
+      NAVY_HOST: process.env.NAVY_HOST,
+      NAVY_EXTERNAL_IP: process.env.NAVY_EXTERNAL_IP
+    };
+    delete process.env.DOCKER_HOST;
+    delete process.env.NAVY_HOST;
+    delete process.env.NAVY_EXTERNAL_IP;
+  });
+  afterEach(function () {
+    sandbox.restore();
+    for (const [name, value] of Object.entries(originalEnv)) {
+      if (value === undefined) {
+        delete process.env[name];
+      } else {
+        process.env[name] = value;
+      }
+    }
+  });
+  describe('dnsLookup', function () {
+    it('should resolve with the IPv4 address when dns returns family 4', async function () {
+      sandbox.stub(_dns.default, 'lookup').callsFake((hostname, opts, cb) => {
+        cb(null, '10.20.30.40', 4);
+      });
+      const ip = await (0, _externalIp.dnsLookup)('example.com');
+      (0, _chai.expect)(ip).to.equal('10.20.30.40');
+    });
+    it('should reject when dns.lookup returns an error', async function () {
+      sandbox.stub(_dns.default, 'lookup').callsFake((hostname, opts, cb) => {
+        cb(new Error('ENOTFOUND'));
+      });
+      let caught;
+      try {
+        await (0, _externalIp.dnsLookup)('does-not-exist');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.equal('Failed to lookup hostname "does-not-exist"');
+    });
+    it('should reject when dns.lookup returns a non-ipv4 family', async function () {
+      sandbox.stub(_dns.default, 'lookup').callsFake((hostname, opts, cb) => {
+        cb(null, '::1', 6);
+      });
+      let caught;
+      try {
+        await (0, _externalIp.dnsLookup)('ipv6-only.example');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.equal('Failed to lookup hostname "ipv6-only.example"');
+    });
+  });
+  describe('getExternalIP (additional branches)', function () {
+    it('should return NAVY_HOST (deprecated) when set', async function () {
+      process.env.NAVY_HOST = 'legacy.host';
+      (0, _chai.expect)(await (0, _externalIp.getExternalIP)()).to.equal('legacy.host');
+    });
+    it('should give NAVY_HOST precedence over NAVY_EXTERNAL_IP', async function () {
+      process.env.NAVY_HOST = 'legacy.host';
+      process.env.NAVY_EXTERNAL_IP = '1.2.3.4';
+      (0, _chai.expect)(await (0, _externalIp.getExternalIP)()).to.equal('legacy.host');
+    });
+    it('should DNS-resolve ipInConfig when provided', async function () {
+      sandbox.stub(_dns.default, 'lookup').callsFake((hostname, opts, cb) => {
+        (0, _chai.expect)(hostname).to.equal('docker.internal');
+        cb(null, '172.16.0.5', 4);
+      });
+      (0, _chai.expect)(await (0, _externalIp.getExternalIP)('docker.internal')).to.equal('172.16.0.5');
+    });
+    it('should resolve a hostname embedded in DOCKER_HOST tcp:// using DNS', async function () {
+      process.env.DOCKER_HOST = 'tcp://my-docker-host.example:2375';
+      sandbox.stub(_dns.default, 'lookup').callsFake((hostname, opts, cb) => {
+        (0, _chai.expect)(hostname).to.equal('my-docker-host.example');
+        cb(null, '203.0.113.7', 4);
+      });
+      (0, _chai.expect)(await (0, _externalIp.getExternalIP)()).to.equal('203.0.113.7');
+    });
+    it('should fall back to 127.0.0.1 when no env vars or config are set', async function () {
+      (0, _chai.expect)(await (0, _externalIp.getExternalIP)()).to.equal('127.0.0.1');
+    });
+    it('should fall back to 127.0.0.1 when DOCKER_HOST is set without tcp://', async function () {
+      process.env.DOCKER_HOST = 'unix:///var/run/docker.sock';
+      (0, _chai.expect)(await (0, _externalIp.getExternalIP)()).to.equal('127.0.0.1');
+    });
+  });
 });

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

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _dns = _interopRequireDefault(require("dns"));
+var _os = _interopRequireDefault(require("os"));
+var _getLanIp = require("../get-lan-ip");
+/* eslint-env mocha */
+
+describe('get-lan-ip', function () {
+  describe('getLANIP', function () {
+    let sandbox;
+    beforeEach(function () {
+      sandbox = _sinon.default.createSandbox();
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    it('should resolve with the looked-up address for the host name', async function () {
+      sandbox.stub(_os.default, 'hostname').returns('my-laptop.local');
+      const dnsStub = sandbox.stub(_dns.default, 'lookup').callsFake((host, opts, cb) => {
+        cb(null, '10.0.0.42');
+      });
+      const result = await (0, _getLanIp.getLANIP)();
+      (0, _chai.expect)(result).to.equal('10.0.0.42');
+      (0, _chai.expect)(dnsStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(dnsStub.firstCall.args[0]).to.equal('my-laptop.local');
+      (0, _chai.expect)(dnsStub.firstCall.args[1]).to.equal(null);
+    });
+    it('should reject if dns.lookup fails', async function () {
+      sandbox.stub(_os.default, 'hostname').returns('unknown.local');
+      const lookupError = new Error('lookup failed');
+      sandbox.stub(_dns.default, 'lookup').callsFake((host, opts, cb) => {
+        cb(lookupError);
+      });
+      let caught;
+      try {
+        await (0, _getLanIp.getLANIP)();
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.equal(lookupError);
+    });
+  });
+});

package/lib/util/__tests__/has-update.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+// NOTE: hasUpdate has a defect at line 17 in `../has-update`: when the
+// supplied navyFile is null/undefined or has no
+// `ignoreUnauthorizedRequestsForRegistries` array, `R.includes(registry,
+// undefined)` throws (in current ramda). The tests below provide a valid
+// navyFile shape to exercise the supported call patterns.
+function withMocks({
+  inspect,
+  getFatManifest = _sinon.default.stub()
+}) {
+  const docker = {
+    getImage: _sinon.default.stub().returns({
+      inspect
+    })
+  };
+  const stubs = {
+    './docker-client': docker,
+    '../client/registry/get-fat-manifest': getFatManifest
+  };
+  return {
+    docker,
+    getFatManifest,
+    hasUpdate: _proxyquire.default.noCallThru()('../has-update', stubs)
+  };
+}
+describe('has-update', function () {
+  it('should return false when the remote digest matches one of the local RepoDigests', async function () {
+    const inspect = _sinon.default.stub().resolves({
+      RepoDigests: ['library/node@sha256:abc', 'library/node@sha256:other']
+    });
+    const {
+      hasUpdate
+    } = withMocks({
+      inspect,
+      getFatManifest: _sinon.default.stub().resolves({
+        tag: 'sha256:abc'
+      })
+    });
+    const result = await hasUpdate('library/node:lts', 'image-id', {
+      ignoreUnauthorizedRequestsForRegistries: []
+    });
+    (0, _chai.expect)(result).to.equal(false);
+  });
+  it('should return true when the remote digest is not in the local RepoDigests', async function () {
+    const inspect = _sinon.default.stub().resolves({
+      RepoDigests: ['library/node@sha256:old']
+    });
+    const {
+      hasUpdate
+    } = withMocks({
+      inspect,
+      getFatManifest: _sinon.default.stub().resolves({
+        tag: 'sha256:new'
+      })
+    });
+    const result = await hasUpdate('library/node:lts', 'image-id', {
+      ignoreUnauthorizedRequestsForRegistries: []
+    });
+    (0, _chai.expect)(result).to.equal(true);
+  });
+  it('should return "INVALID_REMOTE" when getFatManifest fails', async function () {
+    const inspect = _sinon.default.stub().resolves({
+      RepoDigests: []
+    });
+    const {
+      hasUpdate
+    } = withMocks({
+      inspect,
+      getFatManifest: _sinon.default.stub().rejects(new Error('boom'))
+    });
+    const result = await hasUpdate('library/node:lts', 'image-id', {
+      ignoreUnauthorizedRequestsForRegistries: []
+    });
+    (0, _chai.expect)(result).to.equal('INVALID_REMOTE');
+  });
+  it('should return "INVALID_REMOTE" when docker.getImage().inspect() fails', async function () {
+    const inspect = _sinon.default.stub().rejects(new Error('no such image'));
+    const {
+      hasUpdate
+    } = withMocks({
+      inspect
+    });
+    const result = await hasUpdate('library/node:lts', 'image-id', {
+      ignoreUnauthorizedRequestsForRegistries: []
+    });
+    (0, _chai.expect)(result).to.equal('INVALID_REMOTE');
+  });
+  it('should pass allowUnauthorizedRequest=true when navyFile lists the registry as ignored', async function () {
+    const inspect = _sinon.default.stub().resolves({
+      RepoDigests: ['someregistry.com/some/image@sha256:abc']
+    });
+    const getFatManifest = _sinon.default.stub().resolves({
+      tag: 'sha256:abc'
+    });
+    const {
+      hasUpdate
+    } = withMocks({
+      inspect,
+      getFatManifest
+    });
+    await hasUpdate('someregistry.com/some/image:1', 'image-id', {
+      ignoreUnauthorizedRequestsForRegistries: ['someregistry.com']
+    });
+    (0, _chai.expect)(getFatManifest.firstCall.args[0]).to.eql({
+      allowUnauthorizedRequest: true,
+      registry: 'someregistry.com',
+      repository: 'some/image',
+      tag: '1'
+    });
+  });
+  it('should pass allowUnauthorizedRequest=false when registry is not in the ignore list', async function () {
+    const inspect = _sinon.default.stub().resolves({
+      RepoDigests: []
+    });
+    const getFatManifest = _sinon.default.stub().resolves({
+      tag: 'sha256:abc'
+    });
+    const {
+      hasUpdate
+    } = withMocks({
+      inspect,
+      getFatManifest
+    });
+    await hasUpdate('someregistry.com/some/image:1', 'image-id', {
+      ignoreUnauthorizedRequestsForRegistries: ['otherregistry.com']
+    });
+    (0, _chai.expect)(getFatManifest.firstCall.args[0].allowUnauthorizedRequest).to.equal(false);
+  });
+});