Gruntfile.js

// Generated on 2016-08-09 using generator-angular-fullstack 2.1.1
"use strict";

// jshint ignore: start
module.exports = function(grunt) {
  let localConfig;
  try {
    localConfig = require("./server/config/local.env");
  } catch (e) {
    localConfig = {};
  }

  // Load grunt tasks automatically, when needed
  require("jit-grunt")(grunt, {
    express: "grunt-express-server"
  });

  // Time how long tasks take. Can help when optimizing build times
  require("time-grunt")(grunt);

  grunt.task.loadTasks("./tasks");

  // Define the configuration for all the tasks
  grunt.initConfig({
    // Project settings
    pkg: grunt.file.readJSON("package.json"),
    express: {
      options: {
        port: process.env.PORT || 9000
      },
      dev: {
        options: {
          script: "server/app.js",
          debug: true
        }
      },
      prod: {
        options: {
          script: "dist/server/app.js"
        }
      }
    },

    // Make sure code styles are up to par and there are no obvious mistakes
    jshint: {
      options: {
        reporter: require("jshint-stylish")
      },
      server: {
        options: {
          jshintrc: "server/.jshintrc"
        },
        src: ["server/**/*.js", "!server/**/*.spec.js"]
      },
      serverTest: {
        options: {
          jshintrc: "server/.jshintrc"
        },
        src: ["server/**/*.spec.js"]
      },
      ci_server: {
        options: {
          jshintrc: "server/.jshintrc",
          reporter: require("jshint-jenkins-checkstyle-reporter"),
          reporterOutput: "reports/server/linting/jshint-server.xml"
        },
        src: ["server/**/*.js", "server/**/*.spec.js"]
      }
      // bm_server: {
      //   options: {
      //     jshintrc: 'server/.jshintrc',
      //     reporter: require('jshint-junit-reporter'),
      //     reporterOutput: 'reports/server/linting/jshint-junit-server.xml'
      //   },
      //   src: [
      //     'server/**/*.js',
      //     'server/**/*.spec.js'
      //   ]
      // }
    },

    // Empties folders to start fresh
    clean: {
      server: ".tmp",
      mochareports: "reports/server/mocha/**",
      lint: "reports/{server}/linting/**",
      coverage: "reports/coverage/**"
    },

    // Use nodemon to run server in debug mode with an initial breakpoint
    nodemon: {
      debug: {
        script: "server/app.js",
        options: {
          nodeArgs: ["--debug-brk"],
          env: {
            PORT: process.env.PORT || 9000
          },
          callback: function(nodemon) {
            nodemon.on("log", function(event) {
              console.log(event.colour);
            });

            // opens browser on initial server start
            nodemon.on("config:update", function() {
              setTimeout(function() {
                require("open")("http:https://localhost:8080/debug?port=5858");
              }, 500);
            });
          }
        }
      }
    },

    // Run some tasks in parallel to speed up the build process
    concurrent: {
      server: [],
      test: [],
      debug: {
        tasks: ["nodemon"],
        options: {
          logConcurrentOutput: true
        }
      },
      dist: []
    },

    mochaTest: {
      terminal: {
        options: {
          reporter: "spec",
          require: "tasks/blanket"
        },
        src: ["server/**/*.spec.js"]
      },
      junit: {
        options: {
          reporter: "mocha-junit-reporter",
          // require: require("blanket"),
          require: "tasks/blanket"
        },
        src: ["server/**/*.spec.js"]
      },
      html: {
        options: {
          // reporters are  ['html-cov', 'json-cov', 'travis-cov', 'mocha-lcov-reporter', 'mocha-cobertura-reporter'],
          reporter: "html-cov",
          quiet: true,
          captureFile: "reports/server/coverage/cobertura-report.html"
        },
        src: ["server/**/*.spec.js"]
      },
      cobertura: {
        options: {
          reporter: "mocha-cobertura-reporter",
          // use the quiet flag to suppress the mocha console output
          quiet: true,
          // specify a destination file to capture the mocha
          // output (the quiet option does not suppress this)
          captureFile: "reports/server/coverage/cobertura-report.xml"
        },
        src: ["server/**/*.spec.js"]
      },
      travis: {
        options: {
          reporter: "travis-cov",
          quiet: false
        },
        src: ["server/**/*.spec.js"]
      }
    },

    env: {
      test: {
        NODE_ENV: "test"
      },
      dev: {
        NODE_ENV: "development"
      },
      ci: {
        NODE_ENV: "ci"
      },
      si: {
        NODE_ENV: "si"
      },
      prod: {
        NODE_ENV: "production"
      },
      jenkins: {
        MOCHA_FILE: "reports/server/mocha/test-results.xml"
      },
      all: localConfig
    }
  });

  // Used for delaying livereload until after server has restarted
  grunt.registerTask("wait", function() {
    grunt.log.ok("Waiting for server reload...");

    const done = this.async();

    setTimeout(function() {
      grunt.log.writeln("Done waiting!");
      done();
    }, 1500);
  });

  grunt.registerTask("express-keepalive", "Keep grunt running", function() {
    this.async();
  });

  grunt.registerTask("build-image", "Build the image", function(imageId) {
    const shell = require("shelljs");
    grunt.log.ok("BUILDING IMAGE");
    if (!imageId) {
      grunt.fail.warn("must supply an imageId to build");
    }
    const rc = shell.exec(
      "docker build -t todolist:" + imageId + " -f ./dist/Dockerfile ./dist"
    ).code;
    if (rc > 0) {
      grunt.fail.warn("DOCKER FAILURE");
    }
  });

  grunt.registerTask(
    "deploy",
    "deploy the node js app to a docker container and start it in the correct mode",
    function(target_env, build_tag) {
      grunt.log.ok(
        "this task must run on a host that has the Docker Daemon running on it"
      );
      const ports = {
        ci: "9001",
        si: "9002",
        production: "80"
      };

      if (target_env === undefined || build_tag === undefined) {
        grunt.fail.warn(
          "Required param not set - use grunt deploy:<target>:<tag>"
        );
      } else {
        const shell = require("shelljs");
        grunt.log.ok("STOPPING AND REMOVING EXISTING CONTAINERS");
        shell.exec(
          "docker stop todolist-" +
            target_env +
            " && docker rm todolist-" +
            target_env
        );

        grunt.log.ok("DEPLOYING " + target_env + " CONTAINER");
        if (target_env === "ci") {
          const rc = shell.exec(
            "docker run -t -d --name todolist-" +
              target_env +
              " -p " +
              ports[target_env] +
              ":" +
              ports[target_env] +
              " --env NODE_ENV=" +
              target_env +
              " todolist:" +
              build_tag
          );
          if (rc > 0) {
            grunt.fail.warn("DOCKER FAILURE");
          }
        } else {
          // ensure mongo is up
          const isMongo = shell.exec("docker ps | grep devops-mongo").code;
          if (isMongo > 0) {
            grunt.log.ok("DEPLOYING Mongodb CONTAINER FIRST");
            shell.exec(
              "docker run --name devops-mongo -p 27017:27017 -d mongo"
            );
          }
          const rc = shell.exec(
            "docker run -t -d --name todolist-" +
              target_env +
              " --link devops-mongo:mongo.server -p " +
              ports[target_env] +
              ":" +
              ports[target_env] +
              " --env NODE_ENV=" +
              target_env +
              " todolist:" +
              build_tag
          ).code;
          if (rc > 0) {
            grunt.fail.warn("DOCKER FAILURE");
          }
        }
      }
    }
  );

  grunt.registerTask("serve", function(target) {
    if (target === "dist") {
      return grunt.task.run([
        "build",
        "env:all",
        "env:prod",
        "express:prod",
        "wait",
        "express-keepalive"
      ]);
    }

    if (target === "debug") {
      return grunt.task.run([
        "clean:server",
        "env:all",
        "concurrent:server",
        "concurrent:debug"
      ]);
    }

    grunt.task.run([
      "clean:server",
      "env:all",
      "env:" + (target || "dev"),
      "express:dev",
      "wait",
      "express-keepalive"
    ]);
  });

  grunt.registerTask("test", function(target, environ) {
    environ = environ !== undefined ? environ : "test";
    let reporter = "terminal";
    let coverage = "travis";
    if (target === "server-jenkins") {
      target = "server";
      reporter = "junit";
      coverage = "cobertura";
      grunt.task.run(["env:jenkins"]);
    }
    if (target === "server") {
      return grunt.task.run([
        "clean:mochareports",
        "clean:coverage",
        "env:all",
        "env:" + environ,
        "mochaTest:" + reporter,
        "mochaTest:" + "html",
        "mochaTest:" + coverage
      ]);
    } else grunt.task.run(["test:server"]);
  });

  grunt.registerTask("build", [
    "clean",
    "concurrent:dist",
    "newer:jshint",
    "test"
  ]);

  grunt.registerTask("default", ["newer:jshint", "test", "build"]);
};