graceful shutdown and typescript gulpfile

Author: localyost3000

gulpfile.js renamed to gulpfile.ts

@@ -1,12 +1,15 @@
-const {src, dest, series, watch, parallel} = require('gulp');
-const {join} = require('path');
-const {spawn} = require('child_process');
-const webpack = require('webpack');
-const browserSync = require('browser-sync-webpack-plugin');
-const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+import {src, dest, series, watch, parallel} from 'gulp';
+import {join} from 'path';
+import {spawn, ChildProcess} from 'child_process';
+import {BundleAnalyzerPlugin} from 'webpack-bundle-analyzer';
+import {createProject} from 'gulp-typescript';
+import * as webpack from 'webpack';
+
+const  browserSync = require('browser-sync-webpack-plugin');
+
 const webpackConfig = require('./webpack.config');
-const ts_project = require('gulp-typescript').createProject('./src/server/tsconfig.json');
-let server_proc;
+const ts_project= createProject('./src/server/tsconfig.json');
+let server_proc: ChildProcess;
 
 function compileNode() {
     return src('./src/server/**/*.ts')
@@ -16,14 +19,21 @@ function compileNode() {
 
 function startServer(cb) {
     if (server_proc) {
-        server_proc.kill();
-        server_proc = undefined;
+        server_proc.kill('SIGTERM');
+        server_proc.once('exit', (code, signal) => {
+            server_proc = spawn('node', ['--inspect=5858', 'dist/server/app.js'], {
+                cwd: __dirname,
+                stdio: [0, 1, 2, 'ipc']
+            });
+            return cb();
+        });
+    } else {
+        server_proc = spawn('node', ['--inspect=5858', 'dist/server/app.js'], {
+            cwd: __dirname,
+            stdio: [0, 1, 2, 'ipc']
+        });
+        return cb();
     }
-    server_proc = spawn('node', ['--inspect=5858', 'dist/server/app.js'], {
-        cwd: __dirname,
-        stdio: [0, 1, 2, 'ipc']
-    });
-    return cb();
 }
 
 function watchServer() {
@@ -118,11 +128,13 @@ function watchWebpack(done) {
 }
 
 const build = parallel(compileNode, runWebpack);
+const devServer = series(compileNode, startServer, watchServer);
 
 exports.compileNode = compileNode;
 exports.startServer = series(compileNode, startServer);
 exports.webpack = runWebpack;
 exports.analyze = analyzeWebpack;
 exports.build = build;
-exports.watch = parallel(watchWebpack, series(compileNode, startServer, watchServer));
+exports.devServer = devServer;
+exports.watch = parallel(watchWebpack, devServer);
 exports.default = build;

karma.conf.js

@@ -21,15 +21,16 @@ module.exports = function(config) {
         // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
         preprocessors: {
             'src/client/tests/index.ts': ['webpack', 'sourcemap'],
+            // 'src/client/**/*.ts': ['coverage']
         },
         proxies: {
             '/assets': '/base/src/client/assets',
         },
         webpack: require('./webpack.config.test'),
-        coverageIstanbulReporter: {
-            reports: [ 'lcov', 'text-summary' ],
-            dir: 'reports/client/coverage',
-            fixWebpackSourcePaths: true,
+        coverageReporter: {
+            type : 'lcov',
+            dir : 'reports/client/coverage',
+            includeAllSources: true
         },
         webpackMiddleware: {
             noInfo: true,
@@ -40,7 +41,7 @@ module.exports = function(config) {
         // test results reporter to use
         // possible values: 'dots', 'progress'
         // available reporters: https://npmjs.org/browse/keyword/karma-reporter
-        reporters: ['mocha', 'coverage-istanbul'],
+        reporters: ['mocha', 'coverage'],
         // web server port
         port: 9876,
         // enable / disable colors in the output (reporters and logs)

package-lock.json

@@ -16,8 +16,10 @@
     "start": "node dist/server/app.js",
     "prebuild": "rimraf dist",
     "predev": "rimraf dist",
+    "predev-server": "rimraf dist/server",
     "build": "gulp",
     "dev": "gulp watch",
+    "dev-server": "gulp devServer",
     "clean": "rimraf dist",
     "karma": "karma",
     "test": "concurrently npm:test-client npm:test-server",
@@ -89,6 +91,7 @@
     "istanbul-instrumenter-loader": "3.0.1",
     "karma": "6.1.0",
     "karma-chrome-launcher": "3.1.0",
+    "karma-coverage": "2.0.3",
     "karma-coverage-istanbul-reporter": "3.0.3",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",

package.json

@@ -1,5 +1,5 @@
 import {join} from 'path';
-import {createServer} from 'http';
+import {createServer, Server} from 'http';
 import {cpus} from 'os';
 import * as cluster from 'cluster';
 import * as spdy from 'spdy';
@@ -17,67 +17,59 @@ import {SessionManager} from './services/session';
 import {HelpersService} from './services/helpers';
 import {LoggingService} from './services/logger';
 import {AuthService} from './services/auth';
+import { HealthService } from './services/health';
+
+dotenv.config({});
+const loggingService = new LoggingService();
 
-dotenv.config({
-    debug: false // enable to see logs for set vars
-});
 const APP_CONFIG: Config = {
     environment: process.env.ENVIRONMENT || 'dev',
     cookie_name: process.env.COOKIE_NAME || '__cookie_name',
-    cookie_secret: process.env.COOKIE_SECRET || 'cookie_secret',
     port: (+process.env.NODE_PORT) || 3000,
     log_level: process.env.MORGAN_LOG_LEVEL || 'short',
     client_root: process.env.CLIENT_ROOT || join(__dirname, '../client/'),
     max_workers: +(process.env.MAX_WORKERS || cpus().length),
+    logger: loggingService,
+    healthService: new HealthService(loggingService),
 };
 
+APP_CONFIG.healthService.init();
+
+
 if (cluster.isMaster) {
     const numCPUs = Math.max(2, Math.min(cpus().length, APP_CONFIG.max_workers));
-    const workers: cluster.Worker[] = [];
-    console.log('[ master ]: App starting on port', APP_CONFIG.port);
-    console.log(`[ master ]: Spinning up ${numCPUs - 1} workers`);
-    for (let i=1; i < numCPUs; i++) {
+    loggingService.log('[ master ]: App starting on port', APP_CONFIG.port);
+    loggingService.log(`[ master ]: Spinning up ${numCPUs - 1} workers`);
+    for (let i = 1; i < numCPUs; i++) {
         const worker = HelpersService.forkWorker();
-        workers.push(worker);
     }
 
-    cluster.on('listening', (worker) => {
-        console.log(`[ worker ${worker.id} ]: Ready and listening!`);
-    });
-
-    cluster.on('message', (worker, messages, handle) => {
-        if (Array.isArray(messages) && messages.shift() === 'console') {
-            console.log(`[ worker ${worker.id} ]:`, ...messages);
-        }
-    });
-
     cluster.on('exit', (worker, code, signal) => {
-        const deadIndex = workers.findIndex(w => w.id === worker.id);
-        if (deadIndex >= 0) {
-            workers.splice(deadIndex, 1);
-        }
+        APP_CONFIG.healthService.checkClusterHealth();
         if (!worker.exitedAfterDisconnect) {
-            console.log(`[ master ]: replacing crashed worker ${worker.id}`);
+            loggingService.log(`[ master ]: replacing crashed worker ${worker.id}`);
             const newWorker = HelpersService.forkWorker();
-            workers.push(newWorker);
         }
     });
 
-    process.on('exit', () => {
-        console.log('[ master ]: killing workers');
-        workers.forEach((worker) => worker.kill());
+    cluster.on('listening', (worker) => {
+        loggingService.log(`[ worker ${worker.id} ]: Ready and Listening`);
+        APP_CONFIG.healthService.setHealthy(true);
     });
 
-} else {
-    const loggingService = new LoggingService();
-    APP_CONFIG.logger = loggingService;
 
+    // process.on('exit', () => {
+    //     console.log('[ master ]: killing workers');
+    //     workers.forEach((worker) => worker.kill());
+    // });
+
+} else {
     const app = express();
     app.use(compress());
     app.use(userAgent.express());
     app.use(bodyParser.json({limit: '100mb'}));
     app.use(bodyParser.urlencoded({limit: '50mb', extended: true}));
-    app.use(cookieParser(APP_CONFIG.cookie_secret));
+    app.use(cookieParser(process.env.COOKIE_SECRET || 'cookie_secret'));
     app.use(
         morgan(
             APP_CONFIG.log_level || ((tokens, req, res) => LoggingService.customLogger(tokens, req, res)),
@@ -87,6 +79,13 @@ if (cluster.isMaster) {
         )
     );
 
+    app.use((req, res, next) => {
+        if (!APP_CONFIG.healthService.isHealthy()) {
+            res.set('connection', 'close');
+        }
+        return next();
+    })
+
     // redirect http to https
     app.use(require('./middleware/httpredir')(APP_CONFIG));
 
@@ -101,7 +100,8 @@ if (cluster.isMaster) {
         return next();
     });
 
-    let server;
+    let server: Server;
+    let redir;
     if (process.env.HTTPS) {
         let ssl_config = {
             key: (process.env.SSLKEY ? HelpersService.tryLoad(process.env.SSLKEY) : undefined),
@@ -110,21 +110,25 @@ if (cluster.isMaster) {
             pfx: (process.env.SSLPFX ? HelpersService.tryLoad(process.env.SSLPFX) : undefined)
         };
         server = spdy.createServer(ssl_config, app);
-        let redir = express();
-        redir.get('*', (req, res, next) => {
-        let httpshost = `https://${req.headers.host}${req.url}`;
-        return res.redirect(httpshost);
+        const redirApp = express();
+        redirApp.get('*', (req, res, next) => {
+            let httpshost = `https://${req.headers.host}${req.url}`;
+            return res.redirect(httpshost);
         });
-        redir.listen(80);
+        APP_CONFIG.healthService.registerServer(redir);
+        redir = redirApp.listen(80);
     } else {
         server = createServer(app);
     }
 
     /*-------- Services --------*/
     const db = new DatabaseService();
     APP_CONFIG.db = db;
+    APP_CONFIG.healthService.registerService(db);
+
     const sessionManager = new SessionManager(db);
     APP_CONFIG.sessionManager = sessionManager;
+
     const authService = new AuthService(db, loggingService);
     APP_CONFIG.authService = authService;
 
@@ -151,9 +155,8 @@ if (cluster.isMaster) {
         return res.status(404).send({Message: '404 UNKNOWN ROUTE'});
     });
 
-    server.listen(APP_CONFIG.port);
-
-    if (cluster.isMaster) {
-        console.log('APP LISTENING ON PORT', APP_CONFIG.port);
-    }
+    APP_CONFIG.healthService.registerServer(server);
+    server.listen(APP_CONFIG.port, () => {
+        APP_CONFIG.healthService.setHealthy(true);
+    });
 }

src/server/app.ts

@@ -28,7 +28,7 @@ module.exports = (APP_CONFIG: Config) => {
                 sig = authParts[1];
             }
             if (body.length && sig.length) {
-                const hmac = createHmac('sha512', APP_CONFIG.cookie_secret);
+                const hmac = createHmac('sha512', process.env.COOKIE_SECRET || 'cookie_secret');
                 const sigCompare = hmac.update(body).digest('base64');
                 if (sigCompare === sig) {
                     accessToken = body;

src/server/middleware/auth.ts

@@ -2,16 +2,17 @@ import {DatabaseService} from '../services/db';
 import {SessionManager} from '../services/session';
 import {LoggingService} from '../services/logger';
 import {AuthService} from '../services/auth';
+import { HealthService } from '../services/health';
 
 export interface Config {
     environment: string;
     cookie_name: string;
-    cookie_secret: string;
     port: number;
     log_level: string;
     client_root: string;
     max_workers: number;
     logger?: LoggingService;
+    healthService: HealthService;
     db?: DatabaseService;
     sessionManager?: SessionManager;
     authService?: AuthService;