feat: add http server module

Author: vasil-cf

lib/http-server/index.ts

@@ -0,0 +1,102 @@
+import fastify from 'fastify';
+
+// @ts-expect-error it's a js library
+import cfLogs from 'cf-logs';
+
+import { saveServerAddress } from '../helpers';
+import deprecatedImagesCollector from '../metric/deprecated-images/deprecated-images.collector';
+
+const logger = cfLogs.Logger('codefresh:containerLogger');
+
+export class HttpServer {
+
+    private readonly host;
+    private readonly port;
+    private readonly server;
+
+    constructor(private taskLogger: any) {
+        try {
+            this.host = process.env.HOST || '0.0.0.0';
+            this.port = +(process.env.PORT || 8080);
+            this.server = fastify();
+
+            this.initSecrets();
+            this.initDeprecatedImages();
+        } catch (error) {
+            logger.error(`could not initialize server for engine's requests due to error: ${error}`);
+            throw error;
+        }
+    }
+
+    private initSecrets() {
+        const secretsOptions = {
+            schema: {
+                body: {
+                    type: 'object',
+                    required: ['key', 'value'],
+                    properties: {
+                        key: { type: 'string' },
+                        value: { type: 'string' },
+                    },
+                },
+            },
+        };
+
+        this.server.post('/secrets', secretsOptions, async (request, reply) => {
+            try {
+                const { body }: { body: any } = request;
+                const { secret } = body;
+                logger.info(`got request to add new mask: ${secret.key}`);
+                this.taskLogger.addNewMask(secret);
+                reply.code(201);
+                return 'secret added';
+            } catch (err) {
+                logger.info(`could not create new mask for due to error: ${err}`);
+                reply.code(500);
+                throw err;
+            }
+        });
+    }
+
+    private initDeprecatedImages() {
+        this.server.get('/deprecated-images', async () => {
+            logger.info(`got request to retrieve deprecated images`);
+            return deprecatedImagesCollector.consumeAll();
+        });
+
+        this.server.post<{ Body: { count: number } }>('/deprecated-images/ack', async (request, reply) => {
+            const { count } = request.body;
+
+            if (typeof count !== 'number' || count < 1) {
+                return reply.status(400).send({ error: 'You must provide a valid count (positive integer).' });
+            }
+
+            deprecatedImagesCollector.destroyConsumed(count);
+
+            return reply.status(200).send({ count });
+        });
+    }
+
+    async start() {
+        let address: string;
+        try {
+            address = await this.server.listen({
+                host: this.host,
+                port: this.port,
+            });
+
+            logger.info(`listening for engine's requests on ${address}`);
+        } catch (error) {
+            logger.error(`could not start server for engine updates due to error: ${error}`);
+            throw error;
+        }
+
+        try {
+            await saveServerAddress(address);
+        } catch (error) {
+            logger.error(`could not save server address due to error: ${error}`);
+            throw error;
+        }
+    }
+
+}

lib/logger.js

@@ -6,12 +6,14 @@ const DockerEvents = require('docker-events');
 const CFError = require('cf-errors');
 const logger = require('cf-logs').Logger('codefresh:containerLogger');
 const { TaskLogger } = require('@codefresh-io/task-logger');
-const fastify = require('fastify');
 const { ContainerStatus } = require('./enums');
 const { LoggerStrategy } = require('./enums');
 const { ContainerHandlingStatus } = require('./enums');
 const ContainerLogger = require('./ContainerLogger');
-const { getPromiseWithResolvers, saveServerAddress } = require('./helpers');
+const { getPromiseWithResolvers } = require('./helpers');
+
+// eslint-disable-next-line import/no-unresolved,import/extensions
+const { HttpServer } = require('./http-server');
 
 const initialState = {
     pid: process.pid, status: 'init', lastLogsDate: new Date(), failedHealthChecks: [], restartCounter: 0, containers: {}
@@ -38,6 +40,7 @@ class Logger {
         this.finishedContainers = 0;
         this.finishedContainersEmitter = new EventEmitter();
         this.showProgress = showProgress;
+        this.httpServer = new HttpServer();
 
         let dockerSockPath;
         if (process.platform === 'win32') {
@@ -123,7 +126,7 @@ class Logger {
 
             });
 
-        await this._listenForEngineUpdates();
+        await this._listenForEngineRequests();
     }
 
     _readState() {
@@ -351,45 +354,8 @@ class Logger {
         });
     }
 
-    async _listenForEngineUpdates() {
-        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' },
-                        },
-                    },
-                },
-            };
-            server.post('/secrets', secretsOptions, async (request, reply) => {
-                try {
-                    const { body: secret } = request;
-                    logger.info(`got request to add new mask: ${secret.key}`);
-                    this.taskLogger.addNewMask(secret);
-                    reply.code(201);
-                    return 'secret added';
-                } catch (err) {
-                    logger.info(`could not create new mask for due to error: ${err}`);
-                    reply.code(500);
-                    throw err;
-                }
-            });
-
-            const address = await server.listen({ host, port });
-            await saveServerAddress(address);
-            logger.info(`listening for engine updates on ${address}`);
-        } catch (error) {
-            logger.error(`could not start server for engine updates due to error: ${error}`);
-            throw error;
-        }
+    async _listenForEngineRequests() {
+        await this.httpServer.start();
     }
 
     _handleContainerStreamEnd(containerId) {

lib/metric/deprecated-images/deprecated-image.dto.ts

@@ -0,0 +1,3 @@
+export interface DeprecatedImageDto {
+    image: string;
+}

lib/metric/deprecated-images/deprecated-images.collector.ts

@@ -0,0 +1,20 @@
+import { DeprecatedImageDto } from './deprecated-image.dto';
+
+class DeprecatedImagesCollector {
+
+    private list: DeprecatedImageDto[] = [];
+
+    push(deprecatedImageDto: DeprecatedImageDto) {
+        this.list.push(deprecatedImageDto);
+    }
+
+    consumeAll() {
+        return this.list;
+    }
+
+    destroyConsumed(consumedNumber: number) {
+        this.list = this.list.slice(consumedNumber);
+    }
+}
+
+export default new DeprecatedImagesCollector();