Saas 1975 wait container logger (#23)

Author: yaroslav-codefresh

lib/logger.js

@@ -20,7 +20,7 @@ class Logger {
         findExistingContainers,
         logSizeLimit
     }) {
-        this.state                  = { status: 'init' };
+        this.state                  = { status: 'init', lastLogsDate: Date.now() };
         this.taskLoggerConfig       = taskLoggerConfig;
         this.loggerId               = loggerId;
         this.findExistingContainers = findExistingContainers === 'true';
@@ -104,9 +104,9 @@ class Logger {
 
     /**
      * will write updates about the attached containers and initial state to a file for future read from isReady.sh script
-     * @param state
+     * @param disableLog
      */
-    _writeNewState() {
+    _writeNewState(disableLog = false) {
         const filePath     = `${__dirname}/state.json`;
         const currentState = JSON.stringify(this.state);
         fs.writeFile(filePath, currentState, (err) => {
@@ -116,7 +116,7 @@ class Logger {
                     message: 'failed to write state to file'
                 });
                 logger.error(error.toString());
-            } else {
+            } else if (!disableLog) {
                 logger.info(`State: ${currentState} updated and written to file: ${filePath}`);
             }
         });
@@ -214,6 +214,7 @@ class Logger {
         });
         this.containerLoggers.push(containerLogger);
         containerLogger.on('message.logged', this._updateTotalLogSize.bind(this));
+        containerLogger.on('message.logged', this._updateLastLoggingDate.bind(this));
 
         containerLogger.start()
             .done(() => {
@@ -234,6 +235,11 @@ class Logger {
         this.taskLogger.setLogSize(this.logSize);
     }
 
+    _updateLastLoggingDate() {
+        this.state.lastLogsDate = Date.now();
+        this._writeNewState(true);
+    }
+
     /**
      * Will check if a container was already handled (no matter what the handling status is)
      * @param containerId

lib/waitUntilFinish.js

@@ -0,0 +1,71 @@
+
+const fs = require('fs');
+const path = require('path');
+const Q = require('q');
+
+class Waiter {
+
+    constructor(timeout, filepath, lastLogsDate) {
+        this.timeout = timeout;
+        this.filepath = filepath;
+        this.lastLogsDate = lastLogsDate;
+        this.finished = false;
+    }
+
+    _stateListener(currentFileState) {
+        this.lastLogsDate = currentFileState.mtimeMs;
+    }
+
+
+    _finishOnTimeout() {
+        const diff = Date.now() - this.lastLogsDate;
+
+        const date = new Date(this.lastLogsDate);
+        console.log('Last logs date:', date);
+        console.log('Current date:', new Date());
+
+        if (diff > this.timeout) {
+            console.log(`Logs haven't been written for the last ${this.timeout} millis. Finishing waiter...`);
+            this._unwatchState();
+            this.finished = true;
+            this.deferred.resolve();
+        }
+    }
+
+    _checkTimeout() {
+        this._finishOnTimeout();
+        if (!this.finished) {
+            setTimeout(this._checkTimeout.bind(this), 100);
+        }
+    }
+
+    run() {
+        this.deferred = Q.defer();
+        console.log(`Logs waiting timeout: ${this.timeout} millis`);
+        this._checkTimeout();
+        this._watchState();
+
+        return this.deferred.promise;
+    }
+
+    _watchState() {
+        fs.watchFile(this.filepath, { persistent: false, interval: 100 }, this._stateListener.bind(this));
+    }
+
+    _unwatchState() {
+        fs.unwatchFile(this.filepath);
+    }
+
+    static wait(timeout, filepath) {
+        const state = JSON.parse(fs.readFileSync(filepath, 'utf8'));
+        return new Waiter(timeout, filepath, state.lastLogsDate).run();
+    }
+}
+
+if (require.main === module) {
+    const timeout = Number.parseInt(process.argv[process.argv.length - 1]);
+    const filepath = path.resolve(__dirname, 'state.json');
+    Waiter.wait(timeout, filepath);
+} else {
+    module.exports = Waiter;
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cf-container-logger",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "codefresh container logger",
   "keywords": [
     "cf-container-logger"

test/waitUntilFinish.spec.js

@@ -0,0 +1,55 @@
+/* jshint ignore:start */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const Q = require('q');
+
+const chai       = require('chai');
+const expect     = chai.expect;
+const sinon      = require('sinon');
+const sinonChai  = require('sinon-chai');
+chai.use(sinonChai);
+
+const Waiter = require('../lib/waitUntilFinish');
+sinon.spy(Waiter.prototype, '_finishOnTimeout');
+sinon.spy(Waiter.prototype, '_checkTimeout');
+
+const statePath = path.resolve(os.tmpdir(), 'state.json');
+const writeDate = (date = Date.now()) => {
+    console.log(new Date(date));
+    fs.writeFileSync(statePath, JSON.stringify({ lastLogsDate: date }));
+};
+
+
+describe('waitUntilFinish script test', () => {
+    beforeEach(() => {
+        writeDate();
+        Waiter.prototype._finishOnTimeout.resetHistory();
+        Waiter.prototype._checkTimeout.resetHistory();
+    });
+
+    it('should finish immediately if now - lastLogsDate > timeout', async () => {
+        writeDate(Date.now() - 2000);
+        await Waiter.wait(1000, statePath);
+        expect(Waiter.prototype._finishOnTimeout).to.have.been.calledOnce;
+        expect(Waiter.prototype._checkTimeout).to.have.been.calledOnce;
+    });
+
+    it('should wait until now - lastLogsDate > timeout', async () => {
+        await Waiter.wait(1000, statePath);
+        expect(Waiter.prototype._finishOnTimeout.getCalls().length).to.be.approximately(11, 1);
+        expect(Waiter.prototype._checkTimeout.getCalls().length).to.be.approximately(11, 1);
+    });
+
+    it('should wait until now - lastLogsDate > timeout in case when lastLogsDate was updated', async () => {
+        const promise = Waiter.wait(1000, statePath);
+        await Q.delay(500);
+        writeDate();
+        await promise;
+        expect(Waiter.prototype._finishOnTimeout.getCalls().length).to.be.approximately(15, 1);
+        expect(Waiter.prototype._checkTimeout.getCalls().length).to.be.approximately(15, 1);
+    });
+});