underpost 2.8.6 → 2.8.8

package/src/index.js

@@ -4,6 +4,7 @@
  * @namespace Underpost
  */
 
+import UnderpostBaremetal from './cli/baremetal.js';
 import UnderpostCluster from './cli/cluster.js';
 import UnderpostCron from './cli/cron.js';
 import UnderpostDB from './cli/db.js';
@@ -11,10 +12,13 @@ import UnderpostDeploy from './cli/deploy.js';
 import UnderpostRootEnv from './cli/env.js';
 import UnderpostFileStorage from './cli/fs.js';
 import UnderpostImage from './cli/image.js';
+import UnderpostLxd from './cli/lxd.js';
+import UnderpostMonitor from './cli/monitor.js';
 import UnderpostRepository from './cli/repository.js';
 import UnderpostScript from './cli/script.js';
 import UnderpostSecret from './cli/secrets.js';
 import UnderpostTest from './cli/test.js';
+import UnderpostStartUp from './server/start.js';
 
 /**
  * Underpost main module methods
@@ -28,7 +32,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.6';
+  static version = 'v2.8.8';
   /**
    * Repository cli API
    * @static
@@ -50,6 +54,13 @@ class Underpost {
    * @memberof Underpost
    */
   static test = UnderpostTest.API;
+  /**
+   * Underpost Start Up cli API
+   * @static
+   * @type {UnderpostStartUp.API}
+   * @memberof Underpost
+   */
+  static start = UnderpostStartUp.API;
   /**
    * Cluster cli API
    * @static
@@ -103,9 +114,30 @@ class Underpost {
    * File Storage cli API
    * @static
    * @type {UnderpostFileStorage.API}
-   * @memberof UnderpostFileStorage
+   * @memberof Underpost
    */
   static fs = UnderpostFileStorage.API;
+  /**
+   * Monitor cli API
+   * @static
+   * @type {UnderpostMonitor.API}
+   * @memberof Underpost
+   */
+  static monitor = UnderpostMonitor.API;
+  /**
+   * LXD cli API
+   * @static
+   * @type {UnderpostLxd.API}
+   * @memberof Underpost
+   */
+  static lxd = UnderpostLxd.API;
+  /**
+   * Baremetal cli API
+   * @static
+   * @type {UnderpostBaremetal.API}
+   * @memberof Underpost
+   */
+  static baremetal = UnderpostBaremetal.API;
 }
 
 const up = Underpost;

package/src/mailer/MailerProvider.js

@@ -32,6 +32,9 @@ const MailerProvider = {
     },
   ) {
     try {
+      options.transport.tls = {
+        rejectUnauthorized: false,
+      };
       const { id } = options;
       // Generate test SMTP service account from ethereal.email
       // Only needed if you don't have a real mail account for testing

package/src/runtime/lampp/Dockerfile

@@ -0,0 +1,65 @@
+ARG BASE_DEBIAN=buster
+
+# USER root
+
+FROM debian:${BASE_DEBIAN}
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Set root password to root, format is 'user:password'.
+RUN echo 'root:root' | chpasswd
+
+RUN apt-get update --fix-missing
+RUN apt-get upgrade -y
+# install sudo
+RUN apt-get -y install sudo
+# net-tools provides netstat commands
+RUN apt-get -y install curl net-tools
+RUN apt-get -yq install openssh-server supervisor
+# Few handy utilities which are nice to have
+RUN apt-get -y install nano vim less --no-install-recommends
+RUN apt-get clean
+
+# install ssh
+RUN mkdir -p /var/run/sshd
+# Allow root login via password
+RUN sed -ri 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/g' /etc/ssh/sshd_config
+
+# install open ssl git and others tools
+RUN apt-get install -yq --no-install-recommends libssl-dev curl wget git gnupg
+
+# install lampp
+RUN curl -Lo xampp-linux-installer.run https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/7.4.33/xampp-linux-x64-7.4.33-0-installer.run?from_af=true
+RUN chmod +x xampp-linux-installer.run
+RUN bash -c './xampp-linux-installer.run'
+RUN ln -sf /opt/lampp/lampp /usr/bin/lampp
+# Enable XAMPP web interface(remove security checks)
+RUN sed -i.bak s'/Require local/Require all granted/g' /opt/lampp/etc/extra/httpd-xampp.conf
+# Enable error display in php
+RUN sed -i.bak s'/display_errors=Off/display_errors=On/g' /opt/lampp/etc/php.ini
+# Enable includes of several configuration files
+RUN mkdir /opt/lampp/apache2/conf.d
+RUN echo "IncludeOptional /opt/lampp/apache2/conf.d/*.conf" >>/opt/lampp/etc/httpd.conf
+# Create a /www folder and a symbolic link to it in /opt/lampp/htdocs. It'll be accessible via http://localhost:[port]/www/
+# This is convenient because it doesn't interfere with xampp, phpmyadmin or other tools in /opt/lampp/htdocs
+# /opt/lampp/etc/httpd.conf
+RUN mkdir /www
+RUN ln -s /www /opt/lampp/htdocs
+
+# install nodejs https://github.com/nodesource/distributions/blob/master/README.md#deb
+RUN curl -fsSL https://deb.nodesource.com/setup_23.x | bash -
+RUN apt-get install -y nodejs build-essential
+RUN node --version
+RUN npm --version
+
+WORKDIR /home/dd
+
+EXPOSE 22
+
+EXPOSE 80
+
+EXPOSE 443
+
+EXPOSE 3000-3100
+
+EXPOSE 4000-4100

package/src/server/client-build.js

@@ -683,6 +683,19 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
 root file where the route starts, such as index.js, app.js, routes.js, etc ... */
 
         await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
+
+        const htmlFiles = await fs.readdir(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}`);
+        for (const htmlFile of htmlFiles) {
+          if (htmlFile.match('.html')) {
+            fs.writeFileSync(
+              `./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`,
+              fs
+                .readFileSync(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`, 'utf8')
+                .replaceAll('Tutorials', 'References'),
+              'utf8',
+            );
+          }
+        }
       }
 
       if (client) {

package/src/server/conf.js

@@ -499,6 +499,40 @@ const buildProxyRouter = () => {
   return proxyRouter;
 };
 
+const pathPortAssignmentFactory = (router, confServer) => {
+  const pathPortAssignmentData = {};
+  for (const host of Object.keys(confServer)) {
+    const pathPortAssignment = [];
+    for (const path of Object.keys(confServer[host])) {
+      const { peer } = confServer[host][path];
+      if (!router[`${host}${path === '/' ? '' : path}`]) continue;
+      const port = parseInt(router[`${host}${path === '/' ? '' : path}`].split(':')[2]);
+      // logger.info('', { host, port, path });
+      pathPortAssignment.push({
+        port,
+        path,
+      });
+
+      if (peer) {
+        //  logger.info('', { host, port: port + 1, path: '/peer' });
+        pathPortAssignment.push({
+          port: port + 1,
+          path: '/peer',
+        });
+      }
+    }
+    pathPortAssignmentData[host] = pathPortAssignment;
+  }
+  return pathPortAssignmentData;
+};
+
+const deployRangePortFactory = (router) => {
+  const ports = Object.values(router).map((p) => parseInt(p.split(':')[2]));
+  const fromPort = Math.min(...ports);
+  const toPort = Math.max(...ports);
+  return { ports, fromPort, toPort };
+};
+
 const buildKindPorts = (from, to) =>
   range(parseInt(from), parseInt(to))
     .map(
@@ -729,7 +763,7 @@ const validateTemplatePath = (absolutePath = '') => {
   return true;
 };
 
-const deployTest = async (dataDeploy) => {
+const deployTest = async (dataDeploy = [{ deployId: 'default' }]) => {
   const failed = [];
   for (const deploy of dataDeploy) {
     const deployServerConfPath = fs.existsSync(`./engine-private/replica/${deploy.deployId}/conf.server.json`)
@@ -773,6 +807,12 @@ const deployTest = async (dataDeploy) => {
   return { failed };
 };
 
+const awaitDeployMonitor = async (init = false, deltaMs = 1000) => {
+  if (init) fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
+  await timer(deltaMs);
+  if (fs.existsSync(`./tmp/await-deploy`)) return await awaitDeployMonitor();
+};
+
 const getDeployGroupId = () => {
   const deployGroupIndexArg = process.argv.findIndex((a) => a.match(`deploy-group:`));
   if (deployGroupIndexArg > -1) return process.argv[deployGroupIndexArg].split(':')[1].trim();
@@ -883,6 +923,53 @@ const mergeFile = async (parts = [], outputFilePath) => {
   });
 };
 
+const rebuildConfFactory = ({ deployId, valkey, mongo }) => {
+  const confServer = loadReplicas(
+    JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+  );
+  const hosts = {};
+  for (const host of Object.keys(confServer)) {
+    hosts[host] = {};
+    for (const path of Object.keys(confServer[host])) {
+      if (!confServer[host][path].db) continue;
+      const { singleReplica, replicas, db } = confServer[host][path];
+      const { provider } = db;
+      if (singleReplica) {
+        for (const replica of replicas) {
+          const deployIdReplica = buildReplicaId({ replica, deployId });
+          const confServerReplica = JSON.parse(
+            fs.readFileSync(`./engine-private/replica/${deployIdReplica}/conf.server.json`, 'utf8'),
+          );
+          for (const _host of Object.keys(confServerReplica)) {
+            for (const _path of Object.keys(confServerReplica[_host])) {
+              hosts[host][_path] = { replica: { host, path } };
+              confServerReplica[_host][_path].valkey = valkey;
+              switch (provider) {
+                case 'mongoose':
+                  confServerReplica[_host][_path].db.host = mongo.host;
+                  break;
+              }
+            }
+          }
+          fs.writeFileSync(
+            `./engine-private/replica/${deployIdReplica}/conf.server.json`,
+            JSON.stringify(confServerReplica, null, 4),
+            'utf8',
+          );
+        }
+      } else hosts[host][path] = {};
+      confServer[host][path].valkey = valkey;
+      switch (provider) {
+        case 'mongoose':
+          confServer[host][path].db.host = mongo.host;
+          break;
+      }
+    }
+  }
+  fs.writeFileSync(`./engine-private/conf/${deployId}/conf.server.json`, JSON.stringify(confServer, null, 4), 'utf8');
+  return { hosts };
+};
+
 const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deployId: '' }) => {
   const { host, path, conf, deployId } = options;
   const { runtime, db, git, directory } = conf[host][path];
@@ -1084,6 +1171,63 @@ const writeEnv = (envPath, envObj) =>
     'utf8',
   );
 
+const buildCliDoc = (program) => {
+  let md = shellExec(`node bin help`, { silent: true, stdout: true }).split('Options:');
+  const baseOptions =
+    `## ${md[0].split(`\n`)[2]}
+
+### Usage: ` +
+    '`' +
+    md[0].split(`\n`)[0].split('Usage: ')[1] +
+    '`' +
+    `
+  ` +
+    '```\n Options:' +
+    md[1] +
+    ' \n```';
+  md =
+    baseOptions +
+    `
+
+## Commands:
+    `;
+  program.commands.map((o) => {
+    md +=
+      `
+
+` +
+      '### `' +
+      o._name +
+      '` :' +
+      `
+` +
+      '```\n ' +
+      shellExec(`node bin help ${o._name}`, { silent: true, stdout: true }) +
+      ' \n```' +
+      `
+  `;
+  });
+  fs.writeFileSync(`./src/client/public/nexodev/docs/references/Command Line Interface.md`, md, 'utf8');
+  fs.writeFileSync(`./cli.md`, md, 'utf8');
+  const readmeSplit = `pwa-microservices-template</a>`;
+  const readme = fs.readFileSync(`./README.md`, 'utf8').split(readmeSplit);
+  fs.writeFileSync(
+    './README.md',
+    readme[0] +
+      readmeSplit +
+      `
+
+` +
+      baseOptions +
+      `
+      
+<a target="_top" href="https://github.com/underpostnet/pwa-microservices-template/blob/master/cli.md">See complete CLI Docs here.</a>
+      
+`,
+    'utf8',
+  );
+};
+
 export {
   Cmd,
   Config,
@@ -1122,4 +1266,10 @@ export {
   getNpmRootPath,
   getUnderpostRootPath,
   writeEnv,
+  deployTest,
+  pathPortAssignmentFactory,
+  deployRangePortFactory,
+  awaitDeployMonitor,
+  rebuildConfFactory,
+  buildCliDoc,
 };

package/src/server/dns.js

@@ -2,43 +2,78 @@ import axios from 'axios';
 import dotenv from 'dotenv';
 import fs from 'fs';
 import validator from 'validator';
-import { ip } from './network.js';
+import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
 import { loggerFactory } from './logger.js';
 import UnderpostRootEnv from '../cli/env.js';
+import dns from 'node:dns';
+import os from 'node:os';
+import { shellExec } from './process.js';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
+const ip = {
+  public: {
+    get: async () => await publicIp(), // => 'fe80::200:f8ff:fe21:67cf'
+    ipv4: async () => await publicIpv4(), // => '46.5.21.123'
+    ipv6: async () => await publicIpv6(), // => 'fe80::200:f8ff:fe21:67cf'
+  },
+};
+
+const isInternetConnection = (domain = 'google.com') =>
+  new Promise((resolve) => dns.lookup(domain, {}, (err) => resolve(err ? false : true)));
+
+// export INTERFACE=$(ip route | grep default | cut -d ' ' -f 5)
+// export IP_ADDRESS=$(ip -4 addr show dev $INTERFACE | grep -oP '(?<=inet\s)\d+(\.\d+){3}')
+const getLocalIPv4Address = () =>
+  os.networkInterfaces()[
+    shellExec(`ip route | grep default | cut -d ' ' -f 5`, {
+      stdout: true,
+      silent: true,
+      disableLog: true,
+    }).trim()
+  ].find((i) => i.family === 'IPv4').address;
+
 class Dns {
   static callback = async function (deployList) {
     // Network topology configuration:
     // LAN -> [NAT-VPS](modem/router device) -> WAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
-    // disabled local red DHCP
+
+    // Enabling DHCP
+    // Navigate to Subnets > VLAN > Configure DHCP.
+    // Select the appropriate DHCP options (Managed or Relay).
+    // Save and apply changes.
+
     // verify inet ip proxy server address
     // DHCP (Dynamic Host Configuration Protocol) LAN reserver IP -> MAC ID
     // LAN server or device's local servers port ->  3000-3100 (2999-3101)
     // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [public-ip]
     // Forward the router's TCP/UDP ports to the LAN device's IP address
-    for (const _deployId of deployList.split(',')) {
-      const deployId = _deployId.trim();
-      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
-      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-      const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
-
-      let testIp;
-
-      try {
-        testIp = await ip.public.ipv4();
-      } catch (error) {
-        logger.error(error, { testIp, stack: error.stack });
-      }
+    const isOnline = await isInternetConnection();
 
-      const currentIp = UnderpostRootEnv.API.get('ip');
+    if (!isOnline) return;
 
-      if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && currentIp !== testIp) {
-        logger.info(`new ip`, testIp);
+    let testIp;
+
+    try {
+      testIp = await ip.public.ipv4();
+    } catch (error) {
+      logger.error(error, { testIp, stack: error.stack });
+    }
+
+    const currentIp = UnderpostRootEnv.API.get('ip');
+
+    if (validator.isIP(testIp) && currentIp !== testIp) {
+      logger.info(`new ip`, testIp);
+      UnderpostRootEnv.API.set('monitor-input', 'pause');
+
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+        const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+        const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
         for (const recordType of Object.keys(confCronData.records)) {
           switch (recordType) {
             case 'A':
@@ -60,6 +95,7 @@ class Dns {
           if (verifyIp === testIp) {
             logger.info('ip updated successfully', testIp);
             UnderpostRootEnv.API.set('ip', testIp);
+            UnderpostRootEnv.API.delete('monitor-input');
           } else logger.error('ip not updated', testIp);
         } catch (error) {
           logger.error(error, error.stack);
@@ -94,3 +130,5 @@ class Dns {
 }
 
 export default Dns;
+
+export { Dns, ip, isInternetConnection, getLocalIPv4Address };

package/src/server/json-schema.js

@@ -0,0 +1,77 @@
+function isPlainObject(obj) {
+  return obj ? typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype : false;
+}
+
+const supportType = ['string', 'number', 'array', 'object', 'boolean', 'integer'];
+
+function getType(type) {
+  if (!type) type = 'string';
+  if (supportType.indexOf(type) !== -1) {
+    return type;
+  }
+  return typeof type;
+}
+
+function isSchema(object) {
+  if (supportType.indexOf(object.type) !== -1) {
+    return true;
+  }
+  return false;
+}
+
+function handleSchema(json, schema) {
+  Object.assign(schema, json);
+  if (schema.type === 'object') {
+    delete schema.properties;
+    parse(json.properties, schema);
+  }
+  if (schema.type === 'array') {
+    delete schema.items;
+    schema.items = {};
+    parse(json.items, schema.items);
+  }
+}
+
+function handleArray(arr, schema) {
+  schema.type = 'array';
+  let props = (schema.items = {});
+  parse(arr[0], props);
+}
+
+function handleObject(json, schema) {
+  if (isSchema(json)) {
+    return handleSchema(json, schema);
+  }
+  schema.type = 'object';
+  schema.required = [];
+  let props = (schema.properties = {});
+  for (let key in json) {
+    let item = json[key];
+    let curSchema = (props[key] = {});
+    if (key[0] === '*') {
+      delete props[key];
+      key = key.substr(1);
+      schema.required.push(key);
+      curSchema = props[key] = {};
+    }
+    parse(item, curSchema);
+  }
+}
+
+function parse(json, schema) {
+  if (Array.isArray(json)) {
+    handleArray(json, schema);
+  } else if (isPlainObject(json)) {
+    handleObject(json, schema);
+  } else {
+    schema.type = getType(json);
+  }
+}
+
+function ejs(data) {
+  let JsonSchema = {};
+  parse(data, JsonSchema);
+  return JsonSchema;
+}
+
+export { ejs };

package/src/server/logger.js

@@ -176,7 +176,7 @@ const loggerMiddleware = (meta = { url: '' }) => {
   );
 };
 
-const underpostASCI = () => `
+const underpostASCII = () => `
 
 ██╗░░░██╗███╗░░██╗██████╗░███████╗██████╗░██████╗░░█████╗░░██████╗████████╗
 ██║░░░██║████╗░██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
@@ -188,10 +188,10 @@ const underpostASCI = () => `
 
 const actionInitLog = () =>
   console.log(
-    underpostASCI() +
+    underpostASCII() +
       `
     https://www.nexodev.org/docs
 `,
   );
 
-export { loggerFactory, loggerMiddleware, setUpInfo, underpostASCI, actionInitLog };
+export { loggerFactory, loggerMiddleware, setUpInfo, underpostASCII, actionInitLog };