navy 4.1.2-rc.2 → 5.0.0

package/lib/drivers/docker-compose/client.js

@@ -1,194 +1,86 @@
-'use strict';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
-var _regenerator = require('babel-runtime/regenerator');
-
-var _regenerator2 = _interopRequireDefault(_regenerator);
-
-var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
-
-var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
-
-var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
-
-var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
-
 exports.createComposeClient = createComposeClient;
 
-var _path = require('path');
-
-var _path2 = _interopRequireDefault(_path);
-
-var _invariant = require('invariant');
-
-var _invariant2 = _interopRequireDefault(_invariant);
-
-var _fs = require('../../util/fs');
+var _path = _interopRequireDefault(require("path"));
 
-var _fs2 = _interopRequireDefault(_fs);
+var _invariant = _interopRequireDefault(require("invariant"));
 
-var _execAsync = require('../../util/exec-async');
+var _fs = _interopRequireDefault(require("../../util/fs"));
 
-var _driverLogging = require('../../driver-logging');
+var _execAsync = require("../../util/exec-async");
 
-var _state = require('../../navy/state');
+var _driverLogging = require("../../driver-logging");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _state = require("../../navy/state");
 
 function createComposeClient(navy) {
-  var client = {
-    exec: function exec(command) {
-      var _this = this;
-
-      var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
-        var composeArgs, useOriginalDockerComposeFiles, noLog, pipeLog, maxBuffer, composeOpts, composeFilePath;
-        return _regenerator2.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                composeArgs = ['-p', navy.normalisedName];
-                useOriginalDockerComposeFiles = opts.useOriginalDockerComposeFiles, noLog = opts.noLog, pipeLog = opts.pipeLog, maxBuffer = opts.maxBuffer;
-                composeOpts = {
-                  maxBuffer: maxBuffer || Infinity
-                };
-                _context.next = 5;
-                return client.getDockerComposeFilePath();
-
-              case 5:
-                composeFilePath = _context.sent;
-
-                if (!(composeFilePath && !useOriginalDockerComposeFiles)) {
-                  _context.next = 10;
-                  break;
-                }
-
-                composeArgs.push('-f', composeFilePath);
-                _context.next = 13;
-                break;
-
-              case 10:
-                _context.next = 12;
-                return client.getOriginalDockerComposeDirectory();
-
-              case 12:
-                composeOpts.cwd = _context.sent;
-
-              case 13:
-
-                composeArgs.push.apply(composeArgs, [command].concat((0, _toConsumableArray3.default)(args)));
-
-                _context.prev = 14;
-                _context.next = 17;
-                return (0, _execAsync.execAsync)('docker-compose', composeArgs, function (childProcess) {
-                  if (!noLog && !pipeLog) {
-                    childProcess.stdout.on('data', function (data) {
-                      return (0, _driverLogging.log)(data);
-                    });
-                    childProcess.stderr.on('data', function (data) {
-                      return (0, _driverLogging.log)(data);
-                    });
-                  } else if (pipeLog) {
-                    childProcess.stdout.on('data', function (data) {
-                      return process.stdout.write(data);
-                    });
-                    childProcess.stderr.on('data', function (data) {
-                      return process.stderr.write(data);
-                    });
-                  }
-                }, composeOpts);
-
-              case 17:
-                return _context.abrupt('return', _context.sent);
-
-              case 20:
-                _context.prev = 20;
-                _context.t0 = _context['catch'](14);
-
-                if (_context.t0.message && _context.t0.message.indexOf('Can\'t find a suitable configuration file') !== -1) {
-                  (0, _invariant2.default)(false, 'NO_DOCKER_COMPOSE_FILE: No docker-compose.yml (or valid Docker Compose config) found');
-                }
-
-                throw _context.t0;
-
-              case 24:
-              case 'end':
-                return _context.stop();
-            }
+  const client = {
+    async exec(command, args = [], opts = {}) {
+      const composeArgs = ['-p', navy.normalisedName];
+      const {
+        useOriginalDockerComposeFiles,
+        noLog,
+        pipeLog,
+        maxBuffer
+      } = opts;
+      const composeOpts = {
+        maxBuffer: maxBuffer || Infinity
+      };
+      const composeFilePath = await client.getDockerComposeFilePath();
+
+      if (composeFilePath && !useOriginalDockerComposeFiles) {
+        composeArgs.push('-f', composeFilePath);
+      } else {
+        composeOpts.cwd = await client.getOriginalDockerComposeDirectory();
+      }
+
+      composeArgs.push(command, ...args);
+
+      try {
+        return await (0, _execAsync.execAsync)('docker-compose', composeArgs, childProcess => {
+          if (!noLog && !pipeLog) {
+            childProcess.stdout.on('data', data => (0, _driverLogging.log)(data));
+            childProcess.stderr.on('data', data => (0, _driverLogging.log)(data));
+          } else if (pipeLog) {
+            childProcess.stdout.on('data', data => process.stdout.write(data));
+            childProcess.stderr.on('data', data => process.stderr.write(data));
           }
-        }, _callee, _this, [[14, 20]]);
-      }))();
+        }, composeOpts);
+      } catch (ex) {
+        if (ex.message && ex.message.indexOf('Can\'t find a suitable configuration file') !== -1) {
+          (0, _invariant.default)(false, "NO_DOCKER_COMPOSE_FILE: No docker-compose.yml (or valid Docker Compose config) found");
+        }
+
+        throw ex;
+      }
     },
-    getCompiledDockerComposePath: function getCompiledDockerComposePath() {
-      return _path2.default.join((0, _state.pathToNavy)(navy.normalisedName), 'docker-compose.tmp.yml');
-    },
-    getOriginalDockerComposeDirectory: function getOriginalDockerComposeDirectory() {
-      var _this2 = this;
-
-      return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
-        var configProvider;
-        return _regenerator2.default.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                _context2.next = 2;
-                return navy.getConfigProvider();
-
-              case 2:
-                configProvider = _context2.sent;
 
+    getCompiledDockerComposePath() {
+      return _path.default.join((0, _state.pathToNavy)(navy.normalisedName), 'docker-compose.tmp.yml');
+    },
 
-                (0, _invariant2.default)(configProvider, 'NO_CONFIG_PROVIDER: Couldn\'t determine config provider for navy %s', navy.name);
-
-                return _context2.abrupt('return', configProvider.getNavyPath());
-
-              case 5:
-              case 'end':
-                return _context2.stop();
-            }
-          }
-        }, _callee2, _this2);
-      }))();
+    async getOriginalDockerComposeDirectory() {
+      const configProvider = await navy.getConfigProvider();
+      (0, _invariant.default)(configProvider, "NO_CONFIG_PROVIDER: Couldn't determine config provider for navy %s", navy.name);
+      return configProvider.getNavyPath();
     },
-    getDockerComposeFilePath: function getDockerComposeFilePath() {
-      var _this3 = this;
-
-      return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3() {
-        var compiledComposePath;
-        return _regenerator2.default.wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                _context3.prev = 0;
-                _context3.next = 3;
-                return client.getCompiledDockerComposePath();
-
-              case 3:
-                compiledComposePath = _context3.sent;
-                _context3.next = 6;
-                return _fs2.default.statAsync(compiledComposePath);
-
-              case 6:
-                return _context3.abrupt('return', compiledComposePath);
-
-              case 9:
-                _context3.prev = 9;
-                _context3.t0 = _context3['catch'](0);
-                return _context3.abrupt('return', null);
-
-              case 12:
-              case 'end':
-                return _context3.stop();
-            }
-          }
-        }, _callee3, _this3, [[0, 9]]);
-      }))();
+
+    async getDockerComposeFilePath() {
+      try {
+        const compiledComposePath = await client.getCompiledDockerComposePath();
+        await _fs.default.statAsync(compiledComposePath);
+        return compiledComposePath;
+      } catch (ex) {
+        return null;
+      }
     }
-  };
 
+  };
   return client;
 }