log-viewer-webui: Add server implementation for submitting IR extraction jobs and serving IR files; Don't copy unnecessary files when building component.

components/log-viewer-webui/server/package.json

@@ -14,8 +14,12 @@
   "license": "Apache-2.0",
   "type": "module",
   "dependencies": {
+    "@fastify/mysql": "^4.3.0",
+    "@fastify/mongodb": "^8.0.0",
+    "@msgpack/msgpack": "^3.0.0-beta2",
     "dotenv": "^16.4.5",
     "fastify": "^4.28.0",
+    "fastify-plugin": "^4.5.1",
     "http-status-codes": "^2.3.0",
     "pino-pretty": "^11.2.1"
   },

components/log-viewer-webui/server/src/DbManager.js

@@ -0,0 +1,116 @@
+import fastifyPlugin from "fastify-plugin";
+
+import fastifyMysql from "@fastify/mysql";
+import fastifyMongo from "@fastify/mongodb";
+import msgpack from "@msgpack/msgpack";
+
+
+/**
+ * Class representing the database manager.
+ */
+class DbManager {
+    /**
+     * Creates a DbManager.
+     *
+     * @param {Object} app - The Fastify application instance
+     * @param {Object} dbConfig - The database configuration
+     * @param {Object} dbConfig.mysqlConfig - The MySQL configuration
+     * @param {Object} dbConfig.mongoConfig - The MongoDB configuration
+     */
+    constructor(app, dbConfig) {
+        this.app = app;
+        this.initMySql(dbConfig.mysqlConfig);
+        this.initMongo(dbConfig.mongoConfig);
+    }
+
+    /**
+     * Initializes MySQL connection.
+     *
+     * @param {Object} config
+     * @param {string} config.user
+     * @param {string} config.password
+     * @param {string} config.host
+     * @param {number} config.port
+     * @param {string} config.database
+     * @param {string} config.queryJobsTableName
+     */
+    initMySql(config) {
+        this.app.register(fastifyMysql, {
+            promise: true,
+            connectionString: `mysql://${config.user}:${config.password}@${config.host}:` +
+                `${config.port}/${config.database}`,
+        }).after(async (err) => {
+            if (err) {
+                throw err;
+            }
+            this.mysqlConnection = await this.app.mysql.getConnection();
+            this.queryJobsTableName = config.queryJobsTableName;
+        });
+    }
+
+    /**
+     * Initializes MongoDB connection.
+     *
+     * @param {Object} config
+     * @param {string} config.host
+     * @param {number} config.port
+     * @param {string} config.database
+     * @param {string} config.statsCollectionName
+     */
+    initMongo(config) {
+        this.app.register(fastifyMongo, {
+            forceClose: true,
+            url: `mongodb://${config.host}:${config.port}/${config.database}`,
+        }).after(err => {
+            if (err) {
+                throw err;
+            }
+            this.mongoStatsCollection = this.app.mongo.db.collection(config.statsCollectionName);
+        });
+    }
+
+    /**
+     * Inserts a decompression job into MySQL.
+     *
+     * @param {Object} jobConfig - The job configuration.
+     * @returns {Promise<Object>} The result of the insert query or null if an error occurred.
+     */
+    async insertDecompressionJob(jobConfig) {
+        return await this.mysqlConnection.query(
+            `INSERT INTO ${this.queryJobsTableName} (id, job_config)
+             VALUES (?, ?)`,
+            [1,
+                Buffer.from(msgpack.encode(jobConfig))]
+        );
+    }
+
+    /**
+     * Retrieves a decompression job from MySQL.
+     *
+     * @param {number} jobId - The ID of the job.
+     * @returns {Promise<Object>} The job configuration.
+     */
+    async getDecompressionJob(jobId) {
+        const [results] = await this.mysqlConnection.query(
+            `SELECT job_config
+             FROM ${this.queryJobsTableName}
+             WHERE id = ?`,
+            [jobId],
+        );
+
+        return msgpack.decode(results[0].job_config);
+    }
+
+    /**
+     * Retrieve statistics from MongoDB.
+     *
+     * @returns {Promise<Array>} The array of statistics documents.
+     */
+    async getStats() {
+        return await this.mongoStatsCollection.find().toArray();
+    }
+}
+
+export default fastifyPlugin(async (app, options) => {
+    await app.decorate("dbManager", new DbManager(app, options));
+});

components/log-viewer-webui/server/src/app.js

@@ -1,17 +1,38 @@
 import fastify from "fastify";
 
+import DbManager from "./DbManager.js";
 import exampleRoutes from "./routes/examples.js";
 
 
 /**
  * Creates the Fastify app with the given options.
  *
- * @param {import("fastify").FastifyServerOptions} fastifyOptions
+ * @param {Object} options - The options for creating the Fastify app.
+ * @param {import("fastify").FastifyServerOptions} options.fastifyOptions - The Fastify server options.
+ * @param {string} options.dbPass - The MySQL database password.
+ * @param {string} options.dbUser - The MySQL database user.
  * @return {Promise<import("fastify").FastifyInstance>}
  */
-const app = async (fastifyOptions = {}) => {
-    const server = fastify(fastifyOptions);
+const app = async (options = {}) => {
+    console.log(options)
+    const server = fastify(options.fastifyOptions);
     await server.register(exampleRoutes);
+    await server.register(DbManager, {
+        mysqlConfig: {
+            host: "127.0.0.1",
+            database: "clp-db",
+            user: options.dbUser,
+            password: options.dbPass,
+            port: 3306,
+            queryJobsTableName: "query_jobs",
+        },
+        mongoConfig: {
+            host: "127.0.0.1",
+            port: 27017,
+            database: "clp-search",
+            statsCollectionName: "stats",
+        },
+    });
 
     return server;
 };

components/log-viewer-webui/server/src/app.test.js

@@ -2,25 +2,48 @@ import httpStatusCodes from "http-status-codes";
 import {test} from "tap";
 
 import app from "./app.js";
+import {parseEnvVars} from "./utils.js";
 
 
 test("Tests the example routes", async (t) => {
-    const server = await app();
+    const envVars = parseEnvVars();
+    const server = await app(
+        {
+            fastifyOptions: {
+                logger: false,
+            },
+            dbUser: envVars.CLP_DB_USER,
+            dbPass: envVars.CLP_DB_PASS,
+        },
+    );
     t.teardown(() => server.close());
 
     let resp = await server.inject({
-        method: "GET",
-        url: "/examples/get/Alice",
+        method: "POST",
+        url: "/decompression_job",
+        payload: {
+            jobId: 1,
+            status: "pending",
+        },
     });
 
     t.equal(resp.statusCode, httpStatusCodes.OK);
-    t.match(JSON.parse(resp.body), {msg: String});
 
     resp = await server.inject({
-        method: "POST",
-        url: "/examples/post",
-        payload: {name: "Bob"},
+        method: "GET",
+        url: "/decompression_job/1",
+    });
+    t.equal(resp.statusCode, httpStatusCodes.OK);
+    t.match(JSON.parse(resp.body), {
+        jobId: 1,
+        status: "pending",
+    });
+
+    resp = await server.inject({
+        method: "GET",
+        url: "/stats",
     });
     t.equal(resp.statusCode, httpStatusCodes.OK);
-    t.match(JSON.parse(resp.body), {msg: String});
+    console.log(JSON.parse(resp.body));
+    t.match(JSON.parse(resp.body), []);
 });

components/log-viewer-webui/server/src/main.js

@@ -1,37 +1,9 @@
-import dotenv from "dotenv";
 import process from "node:process";
 
 import app from "./app.js";
+import {parseEnvVars} from "./utils.js";
 
 
-/**
- * Parses environment variables into config values for the application.
- *
- * @return {{PORT: string, HOST: string}}
- * @throws {Error} if any required environment variable is undefined.
- */
-const parseEnvVars = () => {
-    dotenv.config({
-        path: ".env",
-    });
-
-    const {
-        HOST, PORT,
-    } = process.env;
-    const envVars = {
-        HOST, PORT,
-    };
-
-    // Check for mandatory environment variables
-    for (const [key, value] of Object.entries(envVars)) {
-        if ("undefined" === typeof value) {
-            throw new Error(`Environment variable ${key} must be defined.`);
-        }
-    }
-
-    return envVars;
-};
-
 /**
  * Sets up and runs the server.
  */
@@ -45,12 +17,17 @@ const main = async () => {
         production: true,
         test: false,
     };
+
+    const envVars = parseEnvVars();
     const server = await app({
-        logger: envToLogger[process.env.NODE_ENV] ?? true,
+        fastifyOptions: {
+            logger: envToLogger[process.env.NODE_ENV] ?? true
+        },
+        dbUser: envVars.CLP_DB_USER,
+        dbPass: envVars.CLP_DB_PASS,
     });
 
     try {
-        const envVars = parseEnvVars();
         await server.listen({host: envVars.HOST, port: Number(envVars.PORT)});
     } catch (e) {
         server.log.error(e);

components/log-viewer-webui/server/src/routes/examples.js

@@ -6,12 +6,20 @@
  * @return {Promise<void>}
  */
 const routes = async (fastify, options) => {
-    fastify.get("/examples/get/:name", async (req, resp) => {
-        return {msg: `Hello, ${req.params.name}!`};
+    fastify.get("/decompression_job/:jobId", async (req, resp) => {
+        const result = await fastify.dbManager.getDecompressionJob(req.params.jobId);
+        resp.send(result);
     });
 
-    fastify.post("/examples/post", async (req, resp) => {
-        return {msg: `Goodbye, ${req.body.name}!`};
+    fastify.post("/decompression_job", async (req, resp) => {
+        const result = await fastify.dbManager.insertDecompressionJob(req.body);
+        resp.send(result);
+    });
+
+    fastify.get("/stats", async (req, resp) => {
+        const result = await fastify.dbManager.getStats();
+        console.log(result);
+        resp.send(result);
     });
 };
 

components/log-viewer-webui/server/src/utils.js

@@ -0,0 +1,32 @@
+import dotenv from "dotenv";
+
+
+/**
+ * Parses environment variables into config values for the application.
+ *
+ * @return {{HOST: string, PORT: string, CLP_DB_USER: string, CLP_DB_PASS: string}}
+ * @throws {Error} if any required environment variable is undefined.
+ */
+const parseEnvVars = () => {
+    dotenv.config({
+        path: ".env",
+    });
+
+    const {
+        HOST, PORT, CLP_DB_USER, CLP_DB_PASS
+    } = process.env;
+    const envVars = {
+        HOST, PORT, CLP_DB_USER, CLP_DB_PASS
+    };
+
+    // Check for mandatory environment variables
+    for (const [key, value] of Object.entries(envVars)) {
+        if ("undefined" === typeof value) {
+            throw new Error(`Environment variable ${key} must be defined.`);
+        }
+    }
+
+    return envVars;
+};
+
+export {parseEnvVars};