navy 5.0.0-rc.0 → 5.0.0

package/lib/cli/config/index.js

@@ -17,7 +17,8 @@ var _reconfigure = require("../util/reconfigure");
 
 const NAME_MAP = {
   'default-navy': 'defaultNavy',
-  'external-ip': 'externalIP'
+  'external-ip': 'externalIP',
+  'tlsCa-dir': 'tlsRootCaDir'
 };
 const configWhichNeedsReconfigure = ['externalIP'];
 

package/lib/cli/https.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _errors = require("../errors");
+
+var _navy = require("../navy");
+
+var _config = require("../config");
+
+var _httpProxy = require("../http-proxy");
+
+var _https = require("../util/https");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+async function _default(services, opts) {
+  const tlsRootCaDir = (0, _config.getConfig)().tlsRootCaDir || _config.DEFAULT_TLS_ROOT_CA_DIR;
+
+  const configDir = (0, _config.getConfigDir)();
+
+  if (opts.disable) {
+    await (0, _https.removeCert)(opts);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      restart: true
+    });
+    console.log();
+    console.log(_chalk.default.green(`✅ HTTPS for service ${opts.disable} is now disabled`));
+    console.log();
+    return;
+  }
+
+  if (!services || services.length === 0) {
+    if (!_fs.default.existsSync(`${configDir}/tls-certs`)) return;
+
+    const files = _fs.default.readdirSync(`${configDir}/tls-certs`);
+
+    const urls = files.filter(file => file.endsWith('.crt')).map(crt => {
+      return `https://${crt.replace('.crt', '')}`;
+    });
+
+    for (const url of urls) {
+      console.log(`${url}`);
+    }
+
+    return;
+  }
+
+  if (!_fs.default.existsSync(`${tlsRootCaDir}/ca.crt`) || !_fs.default.existsSync(`${tlsRootCaDir}/ca.key`)) {
+    await (0, _https.generateRootCa)();
+  }
+
+  const navy = await (0, _navy.getNavy)(opts.navy);
+  await navy.ensurePluginsLoaded();
+  const availableServices = await navy.getAvailableServiceNames();
+  const httpsReadyServices = [];
+
+  for (const service of services) {
+    if (!availableServices.includes(service)) {
+      console.log(`❌ ${service} not found, skipping`);
+      continue;
+    }
+
+    const serviceUrl = await navy.url(service);
+
+    try {
+      await (0, _https.createCert)({
+        serviceUrl
+      });
+      httpsReadyServices.push(service);
+    } catch (error) {
+      console.log(error);
+      throw new _errors.NavyError(`Could not generate TLS cert for ${service}`);
+    }
+  }
+
+  await (0, _httpProxy.reconfigureHTTPProxy)({
+    restart: true
+  });
+  console.log();
+  console.log(_chalk.default.green(`✅ Service(s) ${httpsReadyServices.join(', ')} now accessible via HTTPS🔒`));
+  console.log();
+}
+
+module.exports = exports.default;

package/lib/cli/program.js

@@ -176,6 +176,18 @@ _commander.default.command('use-tag <service> <tag>').option('-e, --navy [env]',
 
 _commander.default.command('reset-tag <service>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Resets any tag override on the given service').action(basicCliWrapper('resetTag'));
 
+_commander.default.command('https [services...]').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).option('-d, --disable <service>', 'disable https (deletes cert) for a given service', null).description('Prints or enables HTTPS services').action(lazyRequire('./https')).on('--help', () => console.log(`
+  Examples:
+    List urls of services that listen on https:
+    $ navy https
+
+    Enable https for mywebservice and anotherwebservice services
+    $ navy https mywebservice anotherwebservice
+
+    Disable https for mywebservice
+    $ navy https -d mywebservice
+  `));
+
 _commander.default.command('use-port <service> <internal> <external>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Uses a specific external port for the given service and internal port').action(basicCliWrapper('usePort'));
 
 _commander.default.command('reset-port <service> <internal>').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Resets a specific external port mapping set by use-port').action(basicCliWrapper('resetPort'));

package/lib/config.js

@@ -5,32 +5,42 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.DEFAULT_TLS_ROOT_CA_DIR = void 0;
 exports.getConfig = getConfig;
+exports.getConfigDir = getConfigDir;
 exports.getConfigPath = getConfigPath;
 exports.setConfig = setConfig;
 
 var _path = _interopRequireDefault(require("path"));
 
-var _bluebird = _interopRequireDefault(require("bluebird"));
-
 var _invariant = _interopRequireDefault(require("invariant"));
 
-var _fs = _interopRequireDefault(require("./util/fs"));
+var _fs = _interopRequireWildcard(require("fs"));
+
+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; }
 
+// $FlowIgnore
 const DEFAULT_ENVIRONMENT_NAME = 'dev';
+const DEFAULT_TLS_ROOT_CA_DIR = `${getConfigDir()}/tls-root-ca`;
+exports.DEFAULT_TLS_ROOT_CA_DIR = DEFAULT_TLS_ROOT_CA_DIR;
 const DEFAULT_CONFIG = {
   defaultNavy: DEFAULT_ENVIRONMENT_NAME,
-  externalIP: null
+  externalIP: null,
+  tlsRootCaDir: DEFAULT_TLS_ROOT_CA_DIR
 };
-
-const mkdirp = _bluebird.default.promisify(require('mkdirp'));
-
 let _config = null;
 
-function getConfigPath() {
+function getConfigDir() {
   const home = process.env.HOME;
   (0, _invariant.default)(home, "NO_HOME_DIRECTORY: No home directory available");
-  return _path.default.join(home, '.navy', 'config.json');
+  return _path.default.join(home, '.navy');
+}
+
+function getConfigPath() {
+  const configDir = getConfigDir();
+  return _path.default.join(configDir, 'config.json');
 }
 
 function getConfig() {
@@ -50,8 +60,10 @@ function getConfig() {
 
 async function setConfig(config) {
   if (config == null) config = DEFAULT_CONFIG;
-  await mkdirp(_path.default.dirname(getConfigPath()));
-  await _fs.default.writeFileAsync(getConfigPath(), JSON.stringify(config, null, 2)); // trash cached config
+  await _fs.promises.mkdir(_path.default.dirname(getConfigPath()), {
+    recursive: true
+  });
+  await _fs.promises.writeFile(getConfigPath(), JSON.stringify(config, null, 2)); // trash cached config
 
   _config = null;
 }

package/lib/http-proxy.js

@@ -15,7 +15,9 @@ var _jsYaml = _interopRequireDefault(require("js-yaml"));
 
 var _dockerClient = _interopRequireDefault(require("./util/docker-client"));
 
-var _fs = _interopRequireDefault(require("./util/fs"));
+var _fs = _interopRequireDefault(require("fs"));
+
+var _https = require("./util/https");
 
 var _execAsync = require("./util/exec-async");
 
@@ -38,25 +40,48 @@ async function updateComposeConfig(navies) {
   networks.forEach(net => networksConfig[net.Name] = {
     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 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',
-        ports: ['80:80'],
+        ports,
         networks: networks.map(net => net.Name),
-        volumes: ['/var/run/docker.sock:/tmp/docker.sock:ro'],
+        volumes,
         restart: 'always'
       }
     },
     networks: networksConfig
   };
-  await _fs.default.writeFileAsync(_path.default.join(_os.default.tmpdir(), 'navyinternaldockercompose.yml'), _jsYaml.default.dump(config));
+
+  _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)) {
+      (0, _driverLogging.log)('Restarting HTTP proxy...');
+      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);
   (0, _driverLogging.log)('Configuring HTTP proxy...');
-  await (0, _execAsync.execAsync)('docker-compose', ['-f', _path.default.join(_os.default.tmpdir(), 'navyinternaldockercompose.yml'), '-p', 'navyinternal', 'up', '-d']);
+  await (0, _execAsync.execAsync)('docker-compose', ['-f', navyInternalYamlFile, '-p', 'navyinternal', 'up', '-d']);
 }

package/lib/middleware/{add-virtual-hosts.js → add-service-proxy-config.js}

@@ -9,6 +9,8 @@ var _lodash = require("lodash");
 
 var _serviceHost = require("../util/service-host");
 
+var _https = require("../util/https");
+
 const getServiceHTTPProxyConfig = (serviceName, navyFile) => {
   if (navyFile && navyFile.httpProxy && navyFile.httpProxy[serviceName]) {
     return navyFile.httpProxy[serviceName];
@@ -50,9 +52,13 @@ var _default = navy => async (config, state) => {
     }
 
     if (proxyConfig) {
+      const hostName = await (0, _serviceHost.createHostForService)(serviceName, navy.normalisedName, externalIP);
+      if (proxyConfig.enableHttps) await (0, _https.createCert)({
+        hostName
+      });
       return services[serviceName] = { ...service,
         environment: {
-          'VIRTUAL_HOST': await (0, _serviceHost.createHostForService)(serviceName, navy.normalisedName, externalIP),
+          'VIRTUAL_HOST': hostName,
           'VIRTUAL_PORT': proxyConfig.port,
           ...service.environment
         }

package/lib/navy/default-middleware.js

@@ -13,7 +13,7 @@ var _tagOverride = _interopRequireDefault(require("../middleware/tag-override"))
 
 var _portOverride = _interopRequireDefault(require("../middleware/port-override"));
 
-var _addVirtualHosts = _interopRequireDefault(require("../middleware/add-virtual-hosts"));
+var _addServiceProxyConfig = _interopRequireDefault(require("../middleware/add-service-proxy-config"));
 
 var _setEnvVars = _interopRequireDefault(require("../middleware/set-env-vars"));
 
@@ -21,7 +21,7 @@ var _setLoggingDriver = _interopRequireDefault(require("../middleware/set-loggin
 
 var _setImage = _interopRequireDefault(require("../middleware/set-image"));
 
-var _default = navy => [_develop.default, _tagOverride.default, _portOverride.default, _setEnvVars.default, _setLoggingDriver.default, _setImage.default, (0, _addVirtualHosts.default)(navy)];
+var _default = navy => [_develop.default, _tagOverride.default, _portOverride.default, _setEnvVars.default, _setLoggingDriver.default, _setImage.default, (0, _addServiceProxyConfig.default)(navy)];
 
 exports.default = _default;
 module.exports = exports.default;

package/lib/util/https.js

@@ -0,0 +1,213 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCert = createCert;
+exports.generateRootCa = generateRootCa;
+exports.getCertsPath = getCertsPath;
+exports.removeCert = removeCert;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _config = require("../config");
+
+var _errors = require("../errors");
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _nodeForge = require("node-forge");
+
+var _navy = require("../navy");
+
+const debug = require('debug')('navy:https');
+
+function getCertsPath(create = false) {
+  const certsPath = _path.default.join((0, _config.getConfigDir)(), 'tls-certs');
+
+  if (!_fs.default.existsSync(certsPath)) {
+    if (create) {
+      debug(`Create ${certsPath} dir`); // $FlowIgnore
+
+      _fs.default.mkdirSync(certsPath, {
+        recursive: true
+      });
+    } else {
+      return '';
+    }
+  }
+
+  return certsPath;
+}
+
+async function removeCert(opts) {
+  const certsPath = getCertsPath();
+  const navy = await (0, _navy.getNavy)(opts.navy);
+  const serviceUrl = await navy.url(opts.disable);
+  const baseName = serviceUrl.split('//')[1];
+  const extensions = ['crt', 'key'];
+
+  for (const ext of extensions) {
+    const file = `${certsPath}/${baseName}.${ext}`;
+
+    if (_fs.default.existsSync(file)) {
+      try {
+        await _fs.default.unlinkSync(file);
+        debug(`File ${file} removed.`);
+      } catch (err) {
+        throw new _errors.NavyError(err);
+      }
+    }
+  }
+}
+
+async function generateRootCa() {
+  const tlsRootCaDir = (0, _config.getConfig)().tlsRootCaDir || _config.DEFAULT_TLS_ROOT_CA_DIR;
+
+  if (!_fs.default.existsSync(tlsRootCaDir)) {
+    debug(`Creating ${tlsRootCaDir} Root CA dir`);
+
+    try {
+      // $FlowIgnore
+      _fs.default.mkdirSync(tlsRootCaDir, {
+        recursive: true
+      });
+    } catch (err) {
+      throw new _errors.NavyError(err);
+    }
+  }
+
+  if (_fs.default.existsSync(`${tlsRootCaDir}/ca.crt`) && _fs.default.existsSync(`${tlsRootCaDir}/ca.key`)) {
+    debug(`Root CA already exists, skipping generation`);
+    return;
+  }
+
+  debug('Generating Root CA');
+  debug('Generating 2048-bit key-pair...');
+
+  const keys = _nodeForge.pki.rsa.generateKeyPair(2048);
+
+  debug('Creating self-signed certificate...');
+
+  const cert = _nodeForge.pki.createCertificate();
+
+  cert.publicKey = keys.publicKey;
+  cert.serialNumber = '01';
+  cert.validity.notBefore = new Date();
+  cert.validity.notAfter = new Date();
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 5);
+  const attrs = [{
+    name: 'commonName',
+    value: 'navy-dev-ca.local'
+  }, {
+    name: 'organizationName',
+    value: 'navy-dev'
+  }];
+  cert.setSubject(attrs);
+  cert.setIssuer(attrs);
+  cert.setExtensions([{
+    name: 'basicConstraints',
+    cA: true
+  }, {
+    name: 'subjectKeyIdentifier'
+  }, {
+    name: 'authorityKeyIdentifier'
+  }]);
+
+  try {
+    // self-sign certificate
+    cert.sign(keys.privateKey, _nodeForge.md.sha256.create()); // PEM-format keys and cert
+
+    const pem = {
+      privateKey: _nodeForge.pki.privateKeyToPem(keys.privateKey),
+      publicKey: _nodeForge.pki.publicKeyToPem(keys.publicKey),
+      certificate: _nodeForge.pki.certificateToPem(cert)
+    };
+
+    _fs.default.writeFileSync(tlsRootCaDir + '/ca.key', pem.privateKey, {
+      mode: 0o400
+    });
+
+    _fs.default.writeFileSync(tlsRootCaDir + '/ca.pub.key', pem.publicKey, {
+      mode: 0o640
+    });
+
+    _fs.default.writeFileSync(tlsRootCaDir + '/ca.crt', pem.certificate, {
+      mode: 0o640
+    });
+
+    console.log(_chalk.default.green(`✅ CA Certificate created at ${tlsRootCaDir}/ca.crt`));
+    console.log(_chalk.default.yellow(`⚠️  Importing a self-signed CA into a browser/truststore/keychain is not advisable ⚠️`));
+  } catch (e) {
+    throw new _errors.NavyError(e);
+  }
+}
+
+async function createCert(opts) {
+  const tlsRootCaDir = (0, _config.getConfig)().tlsRootCaDir || _config.DEFAULT_TLS_ROOT_CA_DIR;
+
+  const certName = opts.hostName || opts.serviceUrl.split('//')[1];
+  const certsPath = getCertsPath(true);
+
+  if (_fs.default.existsSync(`${certsPath}/${certName}.crt`)) {
+    debug(`Certificate for ${certName} already exists, skipping generation`);
+    return;
+  }
+
+  await generateRootCa();
+
+  const caCertString = _fs.default.readFileSync(`${tlsRootCaDir}/ca.crt`, 'utf8');
+
+  const caKeyString = _fs.default.readFileSync(`${tlsRootCaDir}/ca.key`, 'utf8');
+
+  debug(`Generating cert for ${certName} in ${certsPath}`);
+
+  const privateCAKey = _nodeForge.pki.privateKeyFromPem(caKeyString);
+
+  const keys = _nodeForge.pki.rsa.generateKeyPair(2048);
+
+  const cert = _nodeForge.pki.createCertificate();
+
+  const caCert = _nodeForge.pki.certificateFromPem(caCertString);
+
+  cert.publicKey = keys.publicKey;
+  cert.serialNumber = Math.floor(Math.random() * (99 - 2) + 2).toString();
+  cert.validity.notBefore = new Date();
+  cert.validity.notBefore.setDate(cert.validity.notBefore.getDate() - 1);
+  cert.validity.notAfter = new Date();
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 2);
+  const attrs = [{
+    name: 'commonName',
+    value: certName
+  }, {
+    name: 'organizationName',
+    value: 'navy-dev'
+  }];
+
+  try {
+    cert.setSubject(attrs);
+    cert.setIssuer(caCert.subject.attributes);
+    cert.setExtensions([{
+      name: 'extKeyUsage',
+      serverAuth: true
+    }]);
+    cert.sign(privateCAKey, _nodeForge.md.sha256.create()); // PEM-format keys and cert
+
+    const pem = {
+      privateKey: _nodeForge.pki.privateKeyToPem(keys.privateKey),
+      certificate: _nodeForge.pki.certificateToPem(cert) // publicKey: pki.publicKeyToPem(keys.publicKey),
+
+    };
+
+    _fs.default.writeFileSync(`${certsPath}/${certName}.key`, pem.privateKey);
+
+    _fs.default.writeFileSync(`${certsPath}/${certName}.crt`, pem.certificate); // fs.writeFileSync(`${certsPath}/${certName}.pub.key`, pem.publicKey)
+
+  } catch (e) {
+    throw new _errors.NavyError(e);
+  }
+}

package/lib/util/service-host.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,6 +9,11 @@ exports.createHostForService = createHostForService;
 exports.createUrlForService = createUrlForService;
 exports.getNIPSubdomain = getNIPSubdomain;
 exports.getUrlFromService = getUrlFromService;
+
+var _https = require("./https");
+
+var _fs = _interopRequireDefault(require("fs"));
+
 const BASE = 'nip.io';
 
 function isValidIpv4Addr(ip) {
@@ -27,7 +34,15 @@ async function createHostForService(service, navyNormalisedName, externalIP) {
 }
 
 async function createUrlForService(service, navyNormalisedName, externalIP) {
-  return `http://${await createHostForService(service, navyNormalisedName, externalIP)}`;
+  const certsPath = (0, _https.getCertsPath)();
+  let proto = 'http';
+  const baseUrl = await createHostForService(service, navyNormalisedName, externalIP);
+
+  if (_fs.default.existsSync(`${certsPath}/${baseUrl}.crt`)) {
+    proto = 'https';
+  }
+
+  return `${proto}://${await createHostForService(service, navyNormalisedName, externalIP)}`;
 }
 
 function getUrlFromService(service) {
@@ -36,10 +51,17 @@ function getUrlFromService(service) {
   }
 
   const env = service.raw.Config.Env;
+  const certsPath = (0, _https.getCertsPath)();
 
   for (const envVar of env) {
     if (envVar.indexOf('VIRTUAL_HOST=') === 0) {
-      return 'http://' + envVar.substring('VIRTUAL_HOST='.length);
+      let proto = 'http';
+
+      if (_fs.default.existsSync(`${certsPath}/${envVar.substring('VIRTUAL_HOST='.length)}.crt`)) {
+        proto = 'https';
+      }
+
+      return proto + '://' + envVar.substring('VIRTUAL_HOST='.length);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navy",
-  "version": "5.0.0-rc.0",
+  "version": "5.0.0",
   "description": "Quick and powerful development environments using Docker and Docker Compose",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -38,6 +38,7 @@
     "js-yaml": "^3.14.1",
     "lodash": "^4.17.21",
     "mkdirp": "^0.5.5",
+    "node-forge": "^0.10.0",
     "opn": "^5.5.0",
     "pad": "^3.2.0",
     "promise-retry": "^1.1.1",
@@ -45,6 +46,5 @@
     "rimraf": "^2.7.1",
     "simple-docker-registry-client": "^1.1.2",
     "strip-ansi": "^3.0.1"
-  },
-  "gitHead": "93290babe5871ade8c29f1ae1dcc9ab202aef477"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 Momentum Financial Technology Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.