underpost 2.6.2

package/src/server/runtime.js

@@ -0,0 +1,393 @@
+import fs from 'fs';
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import fileUpload from 'express-fileupload';
+import swaggerUi from 'swagger-ui-express';
+import * as promClient from 'prom-client';
+import compression from 'compression';
+
+import { createServer } from 'http';
+import { getRootDirectory } from './process.js';
+import { network, listenPortController, saveRuntimeRouter, logRuntimeRouter, listenServerFactory } from './network.js';
+import { loggerFactory, loggerMiddleware } from './logger.js';
+import { newInstance } from '../client/components/core/CommonJs.js';
+import { Xampp } from '../runtime/xampp/Xampp.js';
+import { MailerProvider } from '../mailer/MailerProvider.js';
+import { DataBaseProvider } from '../db/DataBaseProvider.js';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import { createPeerServer } from './peer.js';
+import { Lampp } from '../runtime/lampp/Lampp.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const buildRuntime = async () => {
+  const deployId = `${process.argv[3] ? process.argv[3] : 'default'}`;
+
+  const collectDefaultMetrics = promClient.collectDefaultMetrics;
+  collectDefaultMetrics();
+
+  const promCounterOption = {
+    name: `${deployId.replaceAll('-', '_')}_http_requests_total`,
+    help: 'Total number of HTTP requests',
+    labelNames: ['instance', 'method', 'status_code'],
+  };
+
+  // logger.info('promCounterOption', promCounterOption);
+
+  const requestCounter = new promClient.Counter(promCounterOption);
+
+  const ipInstance = ''; // await ip.public.ipv4();
+  const initPort = parseInt(process.env.PORT) + 1;
+  let currentPort = initPort;
+  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
+  const singleReplicaHosts = [];
+  for (const host of Object.keys(confServer)) {
+    if (singleReplicaHosts.length > 0 && !singleReplicaHosts.includes(host)) {
+      currentPort += singleReplicaHosts.reduce((accumulator, currentValue) => accumulator + currentValue.replicas, 0);
+    }
+    const rootHostPath = `/public/${host}`;
+    for (const path of Object.keys(confServer[host])) {
+      confServer[host][path].port = newInstance(currentPort);
+      const {
+        runtime,
+        port,
+        client,
+        apis,
+        origins,
+        directory,
+        ws,
+        mailer,
+        db,
+        redirect,
+        peer,
+        singleReplica,
+        replicas,
+      } = confServer[host][path];
+
+      if (singleReplica && replicas && replicas.length > 0 && !singleReplicaHosts.includes(host)) {
+        singleReplicaHosts.push({
+          host,
+          replicas: replicas.length,
+        });
+        continue;
+      }
+
+      const runningData = {
+        host,
+        path,
+        runtime,
+        client,
+        meta: import.meta,
+      };
+
+      let redirectUrl;
+      let redirectTarget;
+      if (redirect) {
+        redirectUrl = new URL(redirect);
+        redirectTarget = redirect[redirect.length - 1] === '/' ? redirect.slice(0, -1) : redirect;
+      }
+
+      logger.info('Build runtime', `${host}${path}`);
+
+      switch (runtime) {
+        case 'lampp':
+          if (!Lampp.enabled()) continue;
+          if (!Lampp.ports.includes(port)) Lampp.ports.push(port);
+          if (currentPort === initPort) Lampp.removeRouter();
+          Lampp.appendRouter(`
+            
+        Listen ${port}
+
+        <VirtualHost *:${port}>    
+            DocumentRoot "${directory ? directory.replace(path, '/') : `${getRootDirectory()}${rootHostPath}`}"
+            ServerName ${host}:${port}
+
+            <Directory "${directory ? directory.replace(path, '/') : `${getRootDirectory()}${rootHostPath}`}">
+              Options Indexes FollowSymLinks MultiViews
+              AllowOverride All
+              Require all granted
+            </Directory>
+
+              ${
+                redirect
+                  ? `
+                  RewriteEngine on
+                  
+                  RewriteCond %{REQUEST_URI} !^/.well-known/acme-challenge
+                  RewriteRule ^(.*)$ ${redirectTarget}%{REQUEST_URI} [R=302,L]
+              `
+                  : ''
+              }
+
+          </VirtualHost>
+            
+                          `);
+          // ERR too many redirects:
+          // Check: SELECT * FROM database.wp_options where option_name = 'siteurl' or option_name = 'home';
+          // Check: wp-config.php
+          // if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
+          //   $_SERVER['HTTPS'] = 'on';
+          // }
+
+          // ErrorDocument 404 /custom_404.html
+          // ErrorDocument 500 /custom_50x.html
+          // ErrorDocument 502 /custom_50x.html
+          // ErrorDocument 503 /custom_50x.html
+          // ErrorDocument 504 /custom_50x.html
+
+          // Respond When Error Pages are Directly Requested
+
+          // <Files "custom_404.html">
+          //     <If "-z %{ENV:REDIRECT_STATUS}">
+          //         RedirectMatch 404 ^/custom_404.html$
+          //     </If>
+          // </Files>
+
+          // <Files "custom_50x.html">
+          //     <If "-z %{ENV:REDIRECT_STATUS}">
+          //         RedirectMatch 404 ^/custom_50x.html$
+          //     </If>
+          // </Files>
+          await listenPortController(listenServerFactory(), port, runningData);
+          break;
+        case 'xampp':
+          if (!Xampp.enabled()) continue;
+          if (!Xampp.ports.includes(port)) Xampp.ports.push(port);
+          if (currentPort === initPort) Xampp.removeRouter();
+          Xampp.appendRouter(`
+            
+        Listen ${port}
+
+        <VirtualHost *:${port}>    
+            DocumentRoot "${directory ? directory.replace(path, '/') : `${getRootDirectory()}${rootHostPath}`}"
+            ServerName ${host}:${port}
+
+            <Directory "${directory ? directory.replace(path, '/') : `${getRootDirectory()}${rootHostPath}`}">
+              Options Indexes FollowSymLinks MultiViews
+              AllowOverride All
+              Require all granted
+            </Directory>
+
+            ${
+              redirect
+                ? `
+                RewriteEngine on
+                
+                RewriteCond %{REQUEST_URI} !^/.well-known/acme-challenge
+                RewriteRule ^(.*)$ ${redirectTarget}%{REQUEST_URI} [R=302,L]
+            `
+                : ''
+            }
+
+          </VirtualHost>
+            
+                          `);
+          // ERR too many redirects:
+          // Check: SELECT * FROM database.wp_options where option_name = 'siteurl' or option_name = 'home';
+          // Check: wp-config.php
+          // if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
+          //   $_SERVER['HTTPS'] = 'on';
+          // }
+          await listenPortController(listenServerFactory(), port, runningData);
+          break;
+        case 'nodejs':
+          const app = express();
+
+          app.use((req, res, next) => {
+            // const info = `${req.headers.host}${req.url}`;
+            return next();
+          });
+
+          // https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus.yml
+          // https://github.com/grafana/grafana/tree/main/conf
+          // https://medium.com/@diego.coder/monitoreo-de-aplicaciones-con-node-js-grafana-y-prometheus-afd2b33e3f91
+          // for grafana prometheus server: host.docker.internal:9090
+
+          app.use((req, res, next) => {
+            requestCounter.inc({
+              instance: `${host}:${port}${path}`,
+              method: req.method,
+              status_code: res.statusCode,
+            });
+            // decodeURIComponent(req.url)
+            return next();
+          });
+
+          app.get(`${path === '/' ? '' : path}/metrics`, async (req, res) => {
+            res.set('Content-Type', promClient.register.contentType);
+            return res.end(await promClient.register.metrics());
+          });
+
+          // set logger
+          app.use(loggerMiddleware(import.meta));
+
+          // instance public static
+          app.use('/', express.static(directory ? directory : `.${rootHostPath}`));
+
+          // js src compression
+          app.use(compression({ filter: shouldCompress }));
+          function shouldCompress(req, res) {
+            if (req.headers['x-no-compression']) {
+              // don't compress responses with this request header
+              return false;
+            }
+
+            // fallback to standard filter function
+            return compression.filter(req, res);
+          }
+
+          // parse requests of content-type - application/json
+          app.use(express.json({ limit: '100MB' }));
+
+          // parse requests of content-type - application/x-www-form-urlencoded
+          app.use(express.urlencoded({ extended: true, limit: '20MB' }));
+
+          // file upload middleware
+          app.use(fileUpload());
+
+          // json formatted response
+          app.set('json spaces', 2);
+
+          // lang handling middleware
+          app.use(function (req, res, next) {
+            const lang = req.headers['accept-language'] || 'en';
+            if (typeof lang === 'string' && lang.toLowerCase().match('es')) {
+              req.lang = 'es';
+            } else req.lang = 'en';
+            return next();
+          });
+
+          // cors
+          app.use(cors({ origin: origins }));
+
+          if (redirect) {
+            app.use(function (req = express.Request, res = express.Response, next = express.NextFunction) {
+              if (process.env.NODE_ENV === 'production' && !req.url.startsWith(`/.well-known/acme-challenge`))
+                return res.status(302).redirect(redirectTarget + req.url);
+              // if (!req.url.startsWith(`/.well-known/acme-challenge`)) return res.status(302).redirect(redirect);
+              return next();
+            });
+            // app.use(
+            //   '*',
+            //   createProxyMiddleware({
+            //     target: redirect,
+            //     changeOrigin: true,
+            //   }),
+            // );
+            await network.port.portClean(port);
+            await listenPortController(app, port, runningData);
+            break;
+          }
+
+          const swaggerJsonPath = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
+          if (fs.existsSync(swaggerJsonPath)) {
+            // logger.info('Build swagger serve', swaggerJsonPath);
+
+            const swaggerInstance =
+              (swaggerDoc) =>
+              (...args) =>
+                swaggerUi.setup(swaggerDoc)(...args);
+
+            const swaggerDoc = JSON.parse(fs.readFileSync(swaggerJsonPath, 'utf8'));
+
+            app.use(`${path === '/' ? `/api-docs` : `${path}/api-docs`}`, swaggerUi.serve, swaggerInstance(swaggerDoc));
+          }
+
+          if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
+
+          if (mailer)
+            await MailerProvider.load({
+              id: `${host}${path}`,
+              meta: `mailer-${host}${path}`,
+              host,
+              path,
+              ...mailer,
+            });
+
+          if (apis) {
+            const apiPath = `${path === '/' ? '' : path}/${process.env.BASE_API}`;
+            for (const api of apis)
+              await (async () => {
+                const { ApiRouter } = await import(`../api/${api}/${api}.router.js`);
+                const router = ApiRouter({ host, path, apiPath, mailer, db });
+                // router.use(cors({ origin: origins }));
+                // logger.info('Load api router', { host, path: apiPath, api });
+                app.use(`${apiPath}/${api}`, router);
+              })();
+          }
+
+          app.use(function (req, res, next) {
+            res.status(404).send('Sorry cant find that!');
+          });
+
+          app.use(function (err, req, res, next) {
+            logger.error(err, err.stack);
+            res.status(500).send('Something broke!');
+          });
+
+          // instance server
+          const server = createServer({}, app);
+
+          if (ws)
+            await (async () => {
+              const { createIoServer } = await import(`../ws/${ws}/${ws}.ws.server.js`);
+              // logger.info('Load socket.io ws router', { host, ws });
+              // start socket.io
+              const { options, meta } = await createIoServer(server, {
+                host,
+                path,
+                db,
+                port,
+                origins,
+              });
+              await listenPortController(listenServerFactory(), port, {
+                runtime: 'nodejs',
+                client: null,
+                host,
+                path: options.path,
+                meta,
+              });
+            })();
+
+          if (peer) {
+            currentPort++;
+            const peerPort = newInstance(currentPort);
+            const { options, meta, peerServer } = await createPeerServer({
+              port: peerPort,
+              devPort: port,
+              origins,
+              host,
+              path,
+            });
+            await network.port.portClean(peerPort);
+            await listenPortController(peerServer, peerPort, {
+              runtime: 'nodejs',
+              client: null,
+              host,
+              path: options.path,
+              meta,
+            });
+          }
+
+          await network.port.portClean(port);
+          await listenPortController(server, port, runningData);
+
+          break;
+        default:
+          break;
+      }
+      currentPort++;
+    }
+  }
+
+  if (Xampp.enabled() && Xampp.router) await Xampp.initService({ daemon: true });
+  if (Lampp.enabled() && Lampp.router) await Lampp.initService({ daemon: true });
+
+  saveRuntimeRouter();
+  logRuntimeRouter();
+};
+
+export { buildRuntime };

package/src/server/ssl.js

@@ -0,0 +1,107 @@
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import https from 'https';
+import { loggerFactory } from './logger.js';
+import { range } from '../client/components/core/CommonJs.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const buildSSL = async (host) => {
+  const sslPath = process.env.CERTBOT_LIVE_PATH;
+
+  const files = await fs.readdir(sslPath);
+
+  for (const folderHost of files)
+    if (folderHost.match(host.split('/')[0])) {
+      for (const i of [''].concat(range(1, 10))) {
+        const privateKeyPath = `${sslPath}/${folderHost}/privkey${i}.pem`;
+        const certificatePath = `${sslPath}/${folderHost}/cert${i}.pem`;
+        const caPath = `${sslPath}/${folderHost}/chain${i}.pem`;
+        const caFullPath = `${sslPath}/${folderHost}/fullchain${i}.pem`;
+
+        if (
+          fs.existsSync(privateKeyPath) &&
+          fs.existsSync(certificatePath) &&
+          fs.existsSync(caPath) &&
+          fs.existsSync(caFullPath)
+        ) {
+          const privateKey = fs.readFileSync(privateKeyPath, 'utf8');
+          const certificate = fs.readFileSync(certificatePath, 'utf8');
+          const ca = fs.readFileSync(caPath, 'utf8');
+          const caFull = fs.readFileSync(caFullPath, 'utf8');
+
+          logger.info(`SSL files update`, {
+            privateKey,
+            certificate,
+            ca,
+            caFull,
+          });
+
+          if (!fs.existsSync(`./engine-private/ssl/${host}`))
+            fs.mkdirSync(`./engine-private/ssl/${host}`, { recursive: true });
+
+          fs.writeFileSync(`./engine-private/ssl/${host}/key.key`, privateKey, 'utf8');
+          fs.writeFileSync(`./engine-private/ssl/${host}/crt.crt`, certificate, 'utf8');
+          fs.writeFileSync(`./engine-private/ssl/${host}/ca_bundle.crt`, caFull, 'utf8');
+
+          fs.writeFileSync(`./engine-private/ssl/${host}/_ca_bundle.crt`, ca, 'utf8');
+          fs.writeFileSync(`./engine-private/ssl/${host}/_ca_full_bundle.crt`, caFull, 'utf8');
+
+          fs.removeSync(`${sslPath}/${folderHost}`);
+          return true;
+        }
+      }
+    }
+  return false;
+};
+
+const validateSecureContext = (host) => {
+  return (
+    fs.existsSync(`./engine-private/ssl/${host}/key.key`) &&
+    fs.existsSync(`./engine-private/ssl/${host}/crt.crt`) &&
+    fs.existsSync(`./engine-private/ssl/${host}/ca_bundle.crt`)
+  );
+};
+
+const buildSecureContext = (host) => {
+  return {
+    key: fs.readFileSync(`./engine-private/ssl/${host}/key.key`, 'utf8'),
+    cert: fs.readFileSync(`./engine-private/ssl/${host}/crt.crt`, 'utf8'),
+    ca: fs.readFileSync(`./engine-private/ssl/${host}/ca_bundle.crt`, 'utf8'),
+  };
+};
+
+const createSslServer = async (app, hosts) => {
+  let ServerSSL;
+  for (const host of Object.keys(hosts)) {
+    // const { redirect } = hosts[host];
+    const [hostSSL, path = ''] = host.split('/');
+    await buildSSL(host);
+    const validSSL = validateSecureContext(hostSSL);
+    if (validSSL) {
+      if (!ServerSSL) ServerSSL = https.createServer(buildSecureContext(hostSSL), app);
+      else ServerSSL.addContext(hostSSL, buildSecureContext(hostSSL));
+    } else logger.error('Invalid SSL context', { host, ...hosts[host] });
+  }
+  return { ServerSSL };
+};
+
+const sslRedirectMiddleware = (req, res, port, proxyRouter) => {
+  const sslRedirectUrl = `https://${req.headers.host}${req.url}`;
+  if (
+    process.env.NODE_ENV === 'production' &&
+    port !== 443 &&
+    !req.secure &&
+    !req.url.startsWith(`/.well-known/acme-challenge`) &&
+    proxyRouter[443] &&
+    Object.keys(proxyRouter[443]).find((host) => {
+      const [hostSSL, path = ''] = host.split('/');
+      return sslRedirectUrl.match(hostSSL) && validateSecureContext(hostSSL);
+    })
+  )
+    return res.status(302).redirect(sslRedirectUrl);
+};
+
+export { buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };

package/src/server.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+import { buildClient } from './server/client-build.js';
+import { buildRuntime } from './server/runtime.js';
+import { ProcessController } from './server/process.js';
+import { Config } from './server/conf.js';
+
+dotenv.config();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+await buildClient();
+
+await buildRuntime();
+
+ProcessController.init(logger);

package/src/ws/IoInterface.js

@@ -0,0 +1,45 @@
+import { loggerFactory } from '../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const IoCreateChannel = (
+  IoInterface = {
+    channel: '',
+    connection: (socket = {}, client = {}, wsManagementId = '') => {},
+    controller: (socket = {}, client = {}, args = '', wsManagementId = '') => {},
+    disconnect: (socket = {}, client = {}, reason = '', wsManagementId = '') => {},
+    stream: false,
+  },
+) => {
+  return {
+    channel: IoInterface.channel,
+    client: {},
+    connection: async function (socket, wsManagementId) {
+      try {
+        this.client[socket.id] = socket;
+        socket.on(IoInterface.channel, (...args) => this.controller(socket, args, wsManagementId));
+        await IoInterface.connection(socket, this.client, wsManagementId);
+      } catch (error) {
+        logger.error(error, { channel: IoInterface.channel, wsManagementId, stack: error.stack });
+      }
+    },
+    controller: async function (socket, args, wsManagementId) {
+      try {
+        const payload = IoInterface.stream ? args[0] : JSON.parse(args[0]);
+        await IoInterface.controller(socket, this.client, payload, wsManagementId, args);
+      } catch (error) {
+        logger.error(error, { channel: IoInterface.channel, wsManagementId, args, stack: error.stack });
+      }
+    },
+    disconnect: async function (socket, reason, wsManagementId) {
+      try {
+        await IoInterface.disconnect(socket, this.client, reason, wsManagementId);
+        delete this.client[socket.id];
+      } catch (error) {
+        logger.error(error, { channel: IoInterface.channel, wsManagementId, reason, stack: error.stack });
+      }
+    },
+  };
+};
+
+export { IoCreateChannel };

package/src/ws/IoServer.js

@@ -0,0 +1,39 @@
+'use strict';
+
+import { Server } from 'socket.io';
+import { loggerFactory } from '../server/logger.js';
+
+// https://socket.io/docs/v3/
+
+const logger = loggerFactory(import.meta);
+
+const IoServer = (httpServer, options = {}, Connection = () => {}) => {
+  const wsOptions = {
+    cors: {
+      // origin: `http://localhost:${options.port}`,
+      origins: options.origins,
+      methods: ['GET', 'POST', 'DELETE', 'PUT'],
+      allowedHeaders: [
+        'Access-Control-Allow-Headers',
+        'Access-Control-Allow-Origin',
+        'X-Requested-With',
+        'X-Access-Token',
+        'Content-Type',
+        'Host',
+        'Accept',
+        'Connection',
+        'Cache-Control',
+        'Authorization',
+      ],
+      credentials: true,
+    },
+    path: options.path !== '/' ? `${options.path}/socket.io/` : '/socket.io',
+  };
+  return {
+    options: wsOptions,
+    meta: import.meta,
+    ioServer: new Server(httpServer, wsOptions).on('connection', Connection),
+  };
+};
+
+export { IoServer };

package/src/ws/core/channels/core.ws.chat.js

@@ -0,0 +1,23 @@
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsEmit } from '../core.ws.emit.js';
+
+const channel = 'chat';
+const logger = loggerFactory(import.meta);
+
+const CoreWsChatController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    for (const socketId of Object.keys(client)) {
+      if (socketId !== socket.id) {
+        CoreWsEmit(channel, client[socketId], { id: socket.id, ...payload });
+      }
+    }
+  },
+  connection: function (socket, client, wsManagementId) {},
+  disconnect: function (socket, client, reason, wsManagementId) {},
+};
+
+const CoreWsChatChannel = IoCreateChannel(CoreWsChatController);
+
+export { CoreWsChatChannel, CoreWsChatController };

package/src/ws/core/channels/core.ws.mailer.js

@@ -0,0 +1,35 @@
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsMailerManagement } from '../management/core.ws.mailer.js';
+
+const channel = 'mailer';
+const logger = loggerFactory(import.meta);
+
+const CoreWsMailerController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    switch (payload.status) {
+      case 'register-user':
+        CoreWsMailerManagement.element[wsManagementId][socket.id] = {
+          model: {
+            user: payload.user,
+          },
+        };
+        break;
+      case 'unregister-user':
+        delete CoreWsMailerManagement.element[wsManagementId][socket.id];
+        break;
+
+      default:
+        break;
+    }
+  },
+  connection: function (socket, client, wsManagementId) {},
+  disconnect: function (socket, client, reason, wsManagementId) {
+    delete CoreWsMailerManagement.element[wsManagementId][socket.id];
+  },
+};
+
+const CoreWsMailerChannel = IoCreateChannel(CoreWsMailerController);
+
+export { CoreWsMailerChannel, CoreWsMailerController };