feat(secrets): use precise address in updateMasks()

Author: masontikhonov

.eslintrc

@@ -78,7 +78,6 @@
     "quote-props": ["error", "consistent"],
 
     "promise/catch-or-return": ["error", { "allowThen": true }],
-    "promise/no-native": "error",
 
     "mocha/no-exclusive-tests": "error",
 

lib/addNewMask.js

@@ -1,18 +1,18 @@
 const rp = require('request-promise');
+const { secretsServerAddress } = require('./logger');
 
 function updateMasks(secret) {
-    const port = process.env.PORT || 8080;
-    const host = process.env.HOST || '0.0.0.0';
-
-    const opt = {
-        uri: `http://${host}:${port}/secrets`,
-        method: 'POST',
-        json: true,
-        body: secret,
-        resolveWithFullResponse: true,
-    };
-
-    rp(opt)
+    secretsServerAddress
+        .then((address) => {
+            const opts = {
+                uri: `${address}/secrets`,
+                method: 'POST',
+                json: true,
+                body: secret,
+                resolveWithFullResponse: true,
+            };
+            return rp(opts);
+        })
         .then((res) => {
             if (res.statusCode >= 400) {
                 console.log(`could not create mask for secret: ${secret.key}, because server responded with: ${res.statusCode}\n\n${res.body}`);

lib/helpers.js

@@ -1,7 +1,7 @@
-const Q = require('q');
 const { stat } = require('fs/promises');
 const path = require('path');
 const logger = require('cf-logs').Logger('codefresh:containerLogger');
+const getPromiseWithResolvers = require('core-js-pure/es/promise/with-resolvers');
 const { BuildFinishedSignalFilename } = require('./enums');
 
 const checkFileInterval = 1000;
@@ -27,13 +27,18 @@ function _watchForBuildFinishedSignal(deferred) {
 }
 
 function watchForBuildFinishedSignal() {
-    const deferred = Q.defer();
+    const deferred = getPromiseWithResolvers();
 
     _watchForBuildFinishedSignal(deferred);
 
     return deferred.promise;
 }
 
 module.exports = {
+    /**
+     * Polyfill of `Promise.withResolvers`, TC39 Stage 4 proposal.
+     * @see https://github.com/tc39/proposal-promise-with-resolvers
+     */
+    getPromiseWithResolvers,
     watchForBuildFinishedSignal,
 };

lib/index.js

@@ -12,7 +12,7 @@ const loggerOptions = {
 };
 cflogs.init(loggerOptions);
 
-const Logger = require('./logger');
+const { Logger } = require('./logger');
 const { watchForBuildFinishedSignal } = require('./helpers');
 
 const taskLoggerConfig = JSON.parse(process.env.TASK_LOGGER_CONFIG);

lib/logger.js

@@ -1,7 +1,6 @@
 const fs = require('fs');
 const { EventEmitter } = require('events');
 const _ = require('lodash');
-const Q = require('q');
 const Docker = require('dockerode');
 const DockerEvents = require('docker-events');
 const CFError = require('cf-errors');
@@ -12,11 +11,14 @@ const { ContainerStatus } = require('./enums');
 const { LoggerStrategy } = require('./enums');
 const { ContainerHandlingStatus } = require('./enums');
 const ContainerLogger = require('./ContainerLogger');
+const { getPromiseWithResolvers } = require('./helpers');
 
 const initialState = {
     pid: process.pid, status: 'init', lastLogsDate: new Date(), failedHealthChecks: [], restartCounter: 0, containers: {}
 };
 
+const deferredServerAddress = getPromiseWithResolvers();
+
 class Logger {
 
     constructor({
@@ -34,7 +36,7 @@ class Logger {
         this.containerLoggers = [];
         this.totalLogSize = 0;
         this.taskLogger = undefined;
-        this.buildFinishedPromise = buildFinishedPromise || Q.resolve();
+        this.buildFinishedPromise = buildFinishedPromise || Promise.resolve();
         this.finishedContainers = 0;
         this.finishedContainersEmitter = new EventEmitter();
         this.showProgress = showProgress;
@@ -350,38 +352,45 @@ class Logger {
     }
 
     async _listenForEngineUpdates() {
-        const port = +(process.env.PORT || 8080);
-        const host = process.env.HOST || '0.0.0.0';
-
-        const secretsServer = fastify();
-        const secretsOptions = {
-            schema: {
-                body: {
-                    type: 'object',
-                    required: ['key', 'value'],
-                    properties: {
-                        key: { type: 'string' },
-                        value: { type: 'string' },
+        try {
+            const port = +(process.env.PORT || 8080);
+            const host = process.env.HOST || '0.0.0.0';
+
+            const server = fastify();
+            const secretsOptions = {
+                schema: {
+                    body: {
+                        type: 'object',
+                        required: ['key', 'value'],
+                        properties: {
+                            key: { type: 'string' },
+                            value: { type: 'string' },
+                        },
                     },
                 },
-            },
-        };
-        secretsServer.post('/secrets', secretsOptions, async (request, reply) => {
-            try {
-                const { body: secret } = request;
-                logger.info(`got request to add new mask: ${JSON.stringify(secret)}`);
-                this.taskLogger.addNewMask(secret);
-                reply.code(201);
-                return 'secret added';
-            } catch (err) {
-                logger.info(`could not create new mask due to error: ${err}`);
-                reply.code(500);
-                throw err;
-            }
-        });
+            };
+            server.post('/secrets', secretsOptions, async (request, reply) => {
+                try {
+                    const { body: secret } = request;
+                    logger.info(`got request to add new mask: ${JSON.stringify(secret)}`);
+                    this.taskLogger.addNewMask(secret);
+                    reply.code(201);
+                    return 'secret added';
+                } catch (err) {
+                    logger.info(`could not create new mask due to error: ${err}`);
+                    reply.code(500);
+                    throw err;
+                }
+            });
 
-        const address = await secretsServer.listen({ host, port });
-        logger.info(`listening for engine updates on ${address}`);
+            const address = await server.listen({ host, port });
+            deferredServerAddress.resolve(address);
+            logger.info(`listening for engine updates on ${address}`);
+        } catch (error) {
+            logger.error(`could not start server for engine updates due to error: ${error}`);
+            deferredServerAddress.reject(error);
+            throw error;
+        }
     }
 
     _handleContainerStreamEnd(containerId) {
@@ -392,7 +401,7 @@ class Logger {
 
     // do not call before build is finished
     _awaitAllStreamsClosed() {
-        const deferred = Q.defer();
+        const deferred = getPromiseWithResolvers();
         this._checkAllStreamsClosed(deferred);
         this.finishedContainersEmitter.on('end', this._checkAllStreamsClosed.bind(this, deferred));
         return deferred.promise;
@@ -423,4 +432,7 @@ class Logger {
     }
 }
 
-module.exports = Logger;
+module.exports = {
+    Logger,
+    secretsServerAddress: deferredServerAddress.promise,
+};

package.json

@@ -13,6 +13,7 @@
     "@codefresh-io/task-logger": "^1.12.3",
     "cf-errors": "^0.1.16",
     "cf-logs": "^1.1.25",
+    "core-js-pure": "^3.37.1",
     "docker-events": "0.0.2",
     "dockerode": "^2.5.8",
     "fastify": "^4.28.1",

test/addNewMask.unit.spec.js

@@ -1,12 +1,11 @@
 /* jshint ignore:start */
 
-'use strict';
-const Q = require('q');
-
+const timers = require('node:timers/promises');
 const chai       = require('chai');
 const expect     = chai.expect;
 const sinon      = require('sinon');
 const sinonChai  = require('sinon-chai');
+const { getPromiseWithResolvers } = require('../lib/helpers');
 const proxyquire = require('proxyquire').noCallThru();
 chai.use(sinonChai);
 
@@ -27,52 +26,56 @@ describe('addNewMask', () => {
 
     describe('positive', () => {
         it('should send a request to add a secret', async () => {
-            const rpSpy = sinon.spy(() => Q.resolve({ statusCode: 201 }));
+            const rpSpy = sinon.spy(async () => ({ statusCode: 201 }));
+            const deferredAddress = getPromiseWithResolvers();
             const addNewMask = proxyquire('../lib/addNewMask', {
-                'request-promise': rpSpy
+                'request-promise': rpSpy,
+                './logger': {
+                    secretsServerAddress: deferredAddress.promise,
+                },
             });
-
-            process.env.PORT = 1337;
-            process.env.HOST = '127.0.0.1';
 
             const secret = {
                 key: '123',
                 value: 'ABC',
             };
 
+            deferredAddress.resolve('http://127.0.0.1:1337');
             addNewMask(secret);
 
+            await timers.setTimeout(10);
             expect(rpSpy).to.have.been.calledOnceWith({
                 uri: `http://127.0.0.1:1337/secrets`,
                 method: 'POST',
                 json: true,
                 body: secret,
                 resolveWithFullResponse: true,
             });
-            await Q.delay(10);
+            await timers.setTimeout(10);
             expect(process.exit).to.have.been.calledOnceWith(0);
         });
     });
 
     describe('negative', () => {
         it('should send a request to add a secret', async () => {
-            const rpSpy = sinon.spy(() => Q.reject('could not send request'));
+            const rpSpy = sinon.spy(async () => { throw 'could not send request';});
+            deferredAddress = getPromiseWithResolvers();
             const addNewMask = proxyquire('../lib/addNewMask', {
-                'request-promise': rpSpy
+                'request-promise': rpSpy,
+                './logger': {
+                    secretsServerAddress: deferredAddress.promise,
+                },
             });
-
-            process.env.PORT = 1337;
-            process.env.HOST = '127.0.0.1';
 
             const secret = {
                 key: '123',
                 value: 'ABC',
             };
 
+            deferredAddress.resolve('http://127.0.0.1:1337');
             addNewMask(secret);
-            await Q.delay(10);
+            await timers.setTimeout(10);
             expect(process.exit).to.have.been.calledOnceWith(1);
         });
     });
 });
-