deploy.sh 0.2.0 → 2.0.0

package/index.js

@@ -1,70 +1,69 @@
-const Async = require('async');
-const mongoose = require('mongoose');
-const ora = require('ora');
+import ora from "ora";
+import mongoose from "mongoose";
 
-const spinner = ora('Starting up deploy.sh server').start();
-const { start, stop } = require('./lib/models/deployment');
+import Deployment from "./lib/models/deployment.js";
 
 let running = true;
 
 mongoose.Promise = global.Promise;
 
-process.on('unhandledRejection', (err, p) => {
-  console.log('An unhandledRejection occurred'); // eslint-disable-line
-  console.log(`Rejected Promise: ${p}`); // eslint-disable-line
-  console.log(`Rejection: ${err}`); // eslint-disable-line
-});
+export default async function (cli, spinner) {
+  try {
+    spinner.text = "Starting up deploy.sh server";
 
-Async.waterfall([
-  function(callback) {
-    spinner.text = 'Connecting to mongo';
+    spinner.text = "Connecting to mongo";
+    await mongoose.connect(cli.mongo);
 
-    mongoose.connect('mongodb://localhost/deploy-sh', { useMongoClient: true })
-      .then(() => callback())
-      .catch(err => callback(err));
-  },
-  function(callback) {
-    spinner.text = 'Starting existing applications';
-    start({})
-     .then((deployments) => callback(null, deployments))
-     .catch((ex) => callback(ex));
-  }
-], (error, deployments) => {
-  if(error) {
-    spinner.fail(`
-      Error on startup:
-      ${error}
-    `);
-  } else {
-    spinner.succeed(`Started ${deployments.length} deployment(s) successfully`);
+    spinner.text = "Starting existing applications";
+    const deployments = await Deployment.start({});
+
+    spinner.succeed(
+      `Started ${
+        deployments ? deployments.length : 0
+      } deployment(s) successfully`
+    );
+
+    const { default: importServerCommand } = await import("./lib/server.js");
+    return importServerCommand;
+  } catch (ex) {
+    if (
+      ex.message.indexOf("HTTP code 304") > -1 ||
+      ex.message.indexOf("(HTTP code 404) no such container") > -1
+    ) {
+      spinner.warn(`Services already started`);
+
+      const { default: importServerCommand } = await import("./lib/server.js");
+      return importServerCommand;
+    }
+    throw new Error(ex);
   }
-  return require('./lib/server');
-});
+}
 
-function shutdown() {
-  if(!running) return;
+async function shutdown() {
+  if (!running) return;
   running = false;
-  const spinner = ora('Shutting down up deploy.sh server').start();
 
-  Async.waterfall([
-    function(callback) {
-      spinner.text = 'Stopping deployments';
-      stop({})
-        .then((deployments) => callback(null, deployments))
-        .catch((error) => callback(error));
-    }
-  ], (error, deployments) => {
-    if(error) {
-      spinner.fail(`
-        Error on shutdown:
-        ${error}
-      `);
-    } else {
-      spinner.succeed(`Shutdown ${deployments.length} deployment(s) successfully`);
-    }
+  const spinner = ora("Shutting down up deploy.sh server").start();
+
+  try {
+    spinner.text = "Stopping deployments";
+    const deployments = await Deployment.stop({});
+
+    spinner.succeed(
+      `Shutdown ${
+        deployments ? deployments.length : 0
+      } deployment(s) successfully`
+    );
+
     process.exit(0);
-  });
+  } catch (ex) {
+    spinner.fail(`
+      Error on shutdown:
+      ${ex}
+    `);
+    process.exit(1);
+  }
 }
 
-process.on('SIGTERM', shutdown);
-process.on('SIGINT', shutdown);
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);

package/jsdoc.json

@@ -3,7 +3,7 @@
         "allowUnknownTags": false
     },
     "source": {
-        "include": ["./lib", "README.md"],
+        "include": ["./lib"],
         "includePattern": ".js$",
         "excludePattern": "(node_modules/|docs)"
     },
@@ -15,10 +15,13 @@
         "destination": "docs/code",
         "recurse": true,
         "verbose": true,
-        "template": "./node_modules/minami"
+        "template": "node_modules/minami"
     },
     "templates": {
         "cleverLinks": true,
-        "monospaceLinks": false
+        "monospaceLinks": false,
+        "default": {
+            "includeDate": false
+        }
     }
 }

package/lib/classifier.js

@@ -1,7 +1,10 @@
-const fs = require('fs');
-const path = require('path');
+import fs from "fs";
+import path from "path";
+import { promisify } from "util";
 
-const { contains } = require('./helpers/util');
+import { contains } from "./helpers/util.js";
+
+const readFile = promisify(fs.readFile);
 
 /**
  * classifies what type of deployment is needed for a certain directory
@@ -9,22 +12,24 @@ const { contains } = require('./helpers/util');
  * @param  {String}   directory - the directory of which to classify
  * @return {Object}   the configuration needed to deploy
  */
-module.exports = function classifier(directory) {
+async function classifier(directory) {
   const files = fs.readdirSync(directory);
-  
-  if(contains(files, ['Dockerfile'])) {
-    let build = fs.readFileSync(path.resolve(directory, 'Dockerfile')).toString('utf8');
+
+  if (contains(files, ["Dockerfile"])) {
+    let build = (
+      await readFile(path.resolve(directory, "Dockerfile"))
+    ).toString("utf8");
     build = build.replace(/\$\{directory\}/, directory);
 
     return {
-      type: 'docker',
-      build
+      type: "docker",
+      build,
     };
   }
 
-  if(contains(files, ['package.json'])) {
+  if (contains(files, ["package.json"])) {
     return {
-      type: 'node',
+      type: "node",
       build: `
         FROM mhart/alpine-node:8
         WORKDIR ${directory}
@@ -33,24 +38,26 @@ module.exports = function classifier(directory) {
         RUN npm install
 
         CMD ["npm", "start"]
-      `
+      `,
     };
   }
 
-  if(contains(files, ['index.html', '!Dockerfile', '!package.json'])) {
+  if (contains(files, ["index.html", "!Dockerfile", "!package.json"])) {
     return {
-      type: 'static',
+      type: "static",
       build: `
         FROM mhart/alpine-node:base-8
         WORKDIR ${directory}
         ADD . .
 
         CMD ["node", "index.js"]
-      `
+      `,
     };
   }
 
   return {
-    type: 'unknown'
+    type: "unknown",
   };
-};
+}
+
+export default classifier;

package/lib/deploy.js

@@ -1,13 +1,14 @@
-const Async = require('async');
-const tar = require('tar');
-const path = require('path');
-const fs = require('fs');
-const mkdirp = require('mkdirp');
+import tar from "tar";
+import path from "path";
+import fs from "fs";
+import { promisify } from "util";
 
-const classifer = require('./classifier');
+const writeFile = promisify(fs.writeFile);
+const readFile = promisify(fs.readFile);
 
-const { getPort } = require('./helpers/util');
-const { get, build, remove } = require('./models/deployment');
+import classifer from "./classifier.js";
+import { getPort, mk } from "./helpers/util.js";
+import Deployment from "./models/deployment.js";
 
 /**
  * handles the deployment of an application tar
@@ -18,61 +19,52 @@ const { get, build, remove } = require('./models/deployment');
  * @param {String} option.token      - token associated with the user that want to deploy the application
  * @param {String} option.username   - username of the user the token is associated too
  */
-module.exports = function deploy({ name, bundlePath, token, username }) {
-  return new Promise(function(resolve, reject) {
-    get({ username, token, name, create: true })
-      .then((deployment) => {
-        const outputDir = path.resolve(__dirname, '..', 'tmp', deployment.subdomain);
-        mkdirp.sync(outputDir);
+export default async function deploy({ name, bundlePath, token, username }) {
+  const deployment = await Deployment.get({
+    username,
+    token,
+    name,
+    create: true,
+  });
+  const outputDir = `${process.cwd()}/tmp/${deployment.subdomain}`;
+
+  // makes the directory recursively
+  await mk(outputDir);
+
+  await tar.x({
+    file: bundlePath,
+    cwd: outputDir,
+  });
+
+  await Deployment.remove({
+    token,
+    username,
+    subdomain: deployment.subdomain,
+  });
+
+  const config = await classifer(outputDir);
+
+  if (config.type === "unknown") {
+    throw new Error("deployment not supported");
+  }
+
+  if (config.type === "static") {
+    await writeFile(
+      path.resolve(outputDir, "index.js"),
+      (
+        await readFile(new URL("static", "static-server.js", import.meta.url))
+      ).toString("utf8")
+    );
+  }
+
+  await writeFile(path.resolve(outputDir, "Dockerfile"), config.build);
 
-        tar.x({
-            file: bundlePath,
-            cwd: outputDir
-          }).then(() => {
-            Async.waterfall([
-              (callback) => {
-                remove({
-                  token,
-                  username,
-                  name: deployment.subdomain
-                })
-                  .then(() => callback())
-                  .catch((ex) => callback(ex));
-              },
-              (callback) => {
-                const config = classifer(outputDir);
-                if (config.type === 'unknown') {
-                  callback('deployment not supported', null);
-                }
-                if (config.type === 'static') {
-                  fs.writeFileSync(path.resolve(outputDir, 'index.js'), fs.readFileSync(path.resolve(__dirname, 'helpers', 'static-server.js')));
-                }
-                callback(null, config.build);
-              },
-              (config, callback) => {
-                fs.writeFile(path.resolve(outputDir, 'Dockerfile'), config, callback);
-              },
-              (callback) => {
-                getPort(callback);
-              },
-              (port, callback) => {
-                build({
-                  name,
-                  token,
-                  username,
-                  subdomain: deployment.subdomain,
-                  port,
-                  directory: outputDir
-                })
-                  .then((deployment) => callback(null, deployment))
-                  .catch((ex) => callback(ex));
-              }
-            ], (err, result) => {
-              if (err) return reject(err);
-              resolve(result);
-            });
-          })
-          .catch((ex) => reject(ex));
-      });
+  return await Deployment.build({
+    name,
+    token,
+    username,
+    subdomain: deployment.subdomain,
+    port: await getPort(),
+    directory: outputDir,
   });
-};
+}