underpost 2.8.646 → 2.8.652

package/src/cli/monitor.js

@@ -4,13 +4,32 @@ import UnderpostDeploy from './deploy.js';
 import axios from 'axios';
 import UnderpostRootEnv from './env.js';
 import fs from 'fs-extra';
+import { shellExec } from '../server/process.js';
 
 const logger = loggerFactory(import.meta);
 
 class UnderpostMonitor {
   static API = {
-    async callback(deployId, env = 'development', options = { now: false, single: false, msInterval: '' }) {
-      const router = await UnderpostDeploy.API.routerFactory(deployId, env);
+    async callback(
+      deployId,
+      env = 'development',
+      options = { now: false, single: false, msInterval: '', type: '' },
+      commanderOptions,
+      auxRouter,
+    ) {
+      if (deployId === 'dd' && fs.existsSync(`./engine-private/deploy/dd.router`)) {
+        for (const _deployId of fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(','))
+          UnderpostMonitor.API.callback(
+            _deployId.trim(),
+            env,
+            options,
+            commanderOptions,
+            await UnderpostDeploy.API.routerFactory(_deployId, env),
+          );
+        return;
+      }
+
+      const router = auxRouter ?? (await UnderpostDeploy.API.routerFactory(deployId, env));
 
       const confServer = loadReplicas(
         JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
@@ -19,20 +38,30 @@ class UnderpostMonitor {
 
       const pathPortAssignmentData = pathPortAssignmentFactory(router, confServer);
 
-      logger.info('', pathPortAssignmentData);
+      logger.info(`${deployId} ${env}`, pathPortAssignmentData);
 
-      const errorPayloads = [];
+      let errorPayloads = [];
+      let traffic = 'blue';
       const maxAttempts = Object.keys(pathPortAssignmentData)
         .map((host) => pathPortAssignmentData[host].length)
         .reduce((accumulator, value) => accumulator + value, 0);
 
       const monitor = async (reject) => {
-        logger.info('Check server health');
+        logger.info(`[${deployId}-${env}] Check server health`);
         for (const host of Object.keys(pathPortAssignmentData)) {
           for (const instance of pathPortAssignmentData[host]) {
             const { port, path } = instance;
             if (path.match('peer') || path.match('socket')) continue;
-            const urlTest = `http://localhost:${port}${path}`;
+            let urlTest = `http://localhost:${port}${path}`;
+            switch (options.type) {
+              case 'remote':
+              case 'blue-green':
+                urlTest = `https://${host}${path}`;
+                break;
+
+              default:
+                break;
+            }
             // logger.info('Test instance', urlTest);
             await axios.get(urlTest, { timeout: 10000 }).catch((error) => {
               // console.log(error);
@@ -50,8 +79,42 @@ class UnderpostMonitor {
                 errorPayloads.push(errorPayload);
                 if (errorPayloads.length >= maxAttempts) {
                   const message = JSON.stringify(errorPayloads, null, 4);
-                  if (reject) reject(message);
-                  else throw new Error(message);
+                  logger.error(
+                    `Deployment ${deployId} ${env} has been reached max attempts error payloads`,
+                    errorPayloads,
+                  );
+                  switch (options.type) {
+                    case 'blue-green':
+                      {
+                        const confServer = JSON.parse(
+                          fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
+                        );
+
+                        for (const host of Object.keys(confServer)) {
+                          shellExec(`sudo kubectl delete HTTPProxy ${host}`);
+                        }
+                        shellExec(`sudo kubectl rollout restart deployment/${deployId}-${env}-${traffic}`);
+
+                        if (traffic === 'blue') traffic = 'green';
+                        else traffic = 'blue';
+
+                        shellExec(
+                          `node bin deploy --info-router --build-manifest --traffic ${traffic} ${deployId} ${env}`,
+                        );
+
+                        shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml`);
+                      }
+
+                      break;
+
+                    case 'remote':
+                      break;
+
+                    default:
+                      if (reject) reject(message);
+                      else throw new Error(message);
+                  }
+                  errorPayloads = [];
                 }
                 logger.error('Error accumulator', errorPayloads.length);
               }
@@ -63,11 +126,47 @@ class UnderpostMonitor {
       if (options.single === true) return;
       let optionsMsTimeout = parseInt(options.msInterval);
       if (isNaN(optionsMsTimeout)) optionsMsTimeout = 30000;
+      let monitorTrafficName;
+      let monitorPodName;
       const monitorCallBack = (resolve, reject) => {
-        const envMsTimeout = UnderpostRootEnv.API.get('monitor-ms');
+        const envMsTimeout = UnderpostRootEnv.API.get(`${deployId}-${env}-monitor-ms`);
         setTimeout(
           async () => {
-            switch (UnderpostRootEnv.API.get('monitor-input')) {
+            switch (options.type) {
+              case 'blue-green':
+                {
+                  if (monitorTrafficName !== traffic) {
+                    monitorTrafficName = undefined;
+                    monitorPodName = undefined;
+                  }
+                  const cmd = `underpost config get container-status`;
+                  const checkDeploymentReadyStatus = () => {
+                    const pods = UnderpostDeploy.API.get(`${deployId}-${env}-${traffic}`);
+                    if (pods && pods[0]) {
+                      const { NAME } = pods[0];
+                      if (
+                        shellExec(`sudo kubectl exec -i ${NAME} -- sh -c "${cmd}"`, { stdout: true }).match(
+                          `${deployId}-${env}-running-deployment`,
+                        )
+                      ) {
+                        monitorPodName = NAME;
+                        monitorTrafficName = `${traffic}`;
+                      }
+                    }
+                  };
+                  if (!monitorPodName) {
+                    checkDeploymentReadyStatus();
+                    monitorCallBack(resolve, reject);
+                    return;
+                  }
+                }
+
+                break;
+
+              default:
+                break;
+            }
+            switch (UnderpostRootEnv.API.get(`${deployId}-${env}-monitor-input`)) {
               case 'pause':
                 monitorCallBack(resolve, reject);
                 return;
@@ -84,7 +183,7 @@ class UnderpostMonitor {
           !isNaN(envMsTimeout) ? envMsTimeout : optionsMsTimeout,
         );
       };
-      return await new Promise((...args) => monitorCallBack(...args));
+      return new Promise((...args) => monitorCallBack(...args));
     },
   };
 }

package/src/client/components/core/Account.js

@@ -204,7 +204,7 @@ const Account = {
             disabled: false,
             extension: async () =>
               html`${await BtnIcon.Render({
-                class: `wfa btn-input-extension btn-account-update-username`,
+                class: `in wfa btn-input-extension btn-account-update-username`,
                 type: 'button',
                 style: 'text-align: left',
                 label: html`${Translate.Render(`update`)}`,
@@ -223,7 +223,7 @@ const Account = {
             extension: !(options && options.disabled && options.disabled.includes('emailConfirm'))
               ? async () => html`<div class="in verify-email-status"></div>
                   ${await BtnIcon.Render({
-                    class: `wfa btn-input-extension btn-confirm-email`,
+                    class: `in wfa btn-input-extension btn-confirm-email`,
                     type: 'button',
                     style: 'text-align: left',
                     label: html`<div class="in">
@@ -246,7 +246,7 @@ const Account = {
             disabledEye: true,
             extension: async () =>
               html`${await BtnIcon.Render({
-                class: `wfa btn-input-extension btn-account-change-password`,
+                class: `in wfa btn-input-extension btn-account-change-password`,
                 type: 'button',
                 style: 'text-align: left',
                 label: html`${Translate.Render(`change-password`)}`,

package/src/client/components/core/Css.js

@@ -761,7 +761,6 @@ const renderWave = ({ id }) => {
 const cssTokensEffect = {};
 const cssTokensContainer = {};
 const cssEffect = async (containerSelector, event) => {
-  return;
   // Array.from(event.target.classList)
   let offsetX, offsetY;
   if (Array.from(event.srcElement.classList).includes('ripple') && cssTokensContainer[containerSelector]) {

package/src/client/components/core/CssCore.js

@@ -524,6 +524,7 @@ const CssCoreDark = {
           margin: 5px 0 0 0;
           padding: 5px;
           font-size: 16px;
+          min-height: 40px;
         }
         .btn-input-extension:hover {
         }
@@ -843,6 +844,7 @@ const CssCoreLight = {
           margin: 5px 0 0 0;
           padding: 5px;
           font-size: 16px;
+          min-height: 40px;
         }
         .btn-input-extension:hover {
         }

package/src/client/components/core/EventsUI.js

@@ -12,7 +12,7 @@ const EventsUI = {
     if (!s(id)) return;
     let complete = true;
     s(id)[type] = async function (e) {
-      cssEffect(id, e);
+      if (options.clickEffect) cssEffect(id, e);
       if (complete) {
         complete = false;
         await LoadingAnimation.spinner.play(loadingContainer ? loadingContainer : id);

package/src/client/components/core/RichText.js

@@ -7,28 +7,18 @@ const RichText = {
   Render: async function (options = { id: '', parentIdModal: '' }) {
     const id = options?.id ? options.id : getId(this.Tokens, 'rich-text-');
     this.Tokens[id] = {};
-    let top, height;
     setTimeout(() => {
       const easyMDE = new EasyMDE({
         element: s(`.${id}`),
+        hideIcons: ['fullscreen', 'side-by-side'],
         onToggleFullScreen: (onFs) => {
           if (onFs) {
             if (options.parentIdModal) {
-              s(`.btn-bar-modal-container-${options.parentIdModal}`).classList.add('hide');
-              top = newInstance(s(`.${options.parentIdModal}`).style.top);
-              height = newInstance(s(`.${options.parentIdModal}`).style.height);
-              s(`.${options.parentIdModal}`).style.top = '0px';
-              s(`.${options.parentIdModal}`).style.height = `${window.innerHeight}px`;
             }
             // Modal.cleanUI();
-            if (s(`.slide-menu-top-bar`)) s(`.slide-menu-top-bar`).classList.add('hide');
           } else {
             if (options.parentIdModal) {
-              s(`.btn-bar-modal-container-${options.parentIdModal}`).classList.remove('hide');
-              s(`.${options.parentIdModal}`).style.top = top;
-              s(`.${options.parentIdModal}`).style.height = height;
             }
-            if (s(`.slide-menu-top-bar`)) s(`.slide-menu-top-bar`).classList.add('remove');
             // Modal.restoreUI();
           }
         },

package/src/index.js

@@ -30,7 +30,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.646';
+  static version = 'v2.8.652';
   /**
    * Repository cli API
    * @static

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/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

@@ -923,6 +923,49 @@ 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')),
+  );
+  for (const host of Object.keys(confServer)) {
+    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])) {
+              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',
+          );
+        }
+      }
+      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');
+};
+
 const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deployId: '' }) => {
   const { host, path, conf, deployId } = options;
   const { runtime, db, git, directory } = conf[host][path];
@@ -1166,4 +1209,5 @@ export {
   pathPortAssignmentFactory,
   deployRangePortFactory,
   awaitDeployMonitor,
+  rebuildConfFactory,
 };

package/src/server/runtime.js

@@ -21,6 +21,7 @@ import { Lampp } from '../runtime/lampp/Lampp.js';
 import { getDeployId } from './conf.js';
 import { JSONweb, ssrFactory } from './client-formatted.js';
 import Underpost from '../index.js';
+import { createValkeyConnection } from './valkey.js';
 
 dotenv.config();
 
@@ -67,6 +68,7 @@ const buildRuntime = async () => {
         peer,
         singleReplica,
         replicas,
+        valkey,
       } = confServer[host][path];
 
       if (singleReplica && replicas && replicas.length > 0 && !singleReplicaHosts.includes(host)) {
@@ -361,6 +363,9 @@ const buildRuntime = async () => {
 
           if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
 
+          // valkey server
+          await createValkeyConnection({ host, path }, valkey);
+
           if (mailer) {
             const mailerSsrConf = confSSR[getCapVariableName(client)];
             await MailerProvider.load({

package/src/server/start.js

@@ -4,6 +4,7 @@ import fs from 'fs-extra';
 import { awaitDeployMonitor } from './conf.js';
 import { actionInitLog, loggerFactory } from './logger.js';
 import { shellCd, shellExec } from './process.js';
+import UnderpostRootEnv from '../cli/env.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -20,14 +21,20 @@ class UnderpostStartUp {
     },
     listenServerFactory: (logic = async () => {}) => {
       return {
-        listen: async (...args) => (
-          setTimeout(() => {
-            const message = 'Listen server factory timeout';
-            logger.error(message);
-            throw new Error(message);
-          }, 80000000), // ~ 55 days
-          (logic ? await logic(...args) : undefined, args[1]())
-        ),
+        listen: async (...args) => {
+          const msDelta = 1000;
+          const msMax = 30 * 24 * 60 * 60 * 1000; // ~ 1 month
+          let msCount = 0;
+          setInterval(() => {
+            msCount += msDelta;
+            if (msCount >= msMax) {
+              const message = 'Listen server factory timeout';
+              logger.error(message);
+              throw new Error(message);
+            }
+          }, msDelta);
+          return logic ? await logic(...args) : undefined, args[1]();
+        },
       };
     },
     listenPortController: async (server, port, metadata) =>
@@ -108,7 +115,7 @@ class UnderpostStartUp {
       shellExec(`node bin/deploy conf ${deployId} ${env}`);
       shellExec(`npm ${runCmd} deploy deploy-id:${deployId}`, { async: true });
       await awaitDeployMonitor(true);
-      return await UnderpostMonitor.API.callback(deployId, env);
+      UnderpostRootEnv.API.set('container-status', `${deployId}-${env}-running-deployment`);
     },
   };
 }

package/src/server/valkey.js

@@ -5,12 +5,24 @@ import { loggerFactory } from './logger.js';
 
 const logger = loggerFactory(import.meta);
 
+const ValkeyInstances = {};
+
 let valkeyEnabled = true;
 
 const disableValkeyErrorMessage = 'valkey is not enabled';
 
 const isValkeyEnable = () => valkeyEnabled;
 
+const createValkeyConnection = async (
+  instance = { host: '', port: 0 },
+  valkeyServerConnectionOptions = { host: '', port: 0 },
+) => {
+  ValkeyInstances[`${instance.host}${instance.path}`] = await ValkeyAPI.valkeyClientFactory(
+    valkeyServerConnectionOptions,
+  );
+  return ValkeyInstances[`${instance.host}${instance.path}`];
+};
+
 const selectDtoFactory = (payload, select) => {
   const result = {};
   for (const key of Object.keys(select)) {
@@ -19,10 +31,12 @@ const selectDtoFactory = (payload, select) => {
   return result;
 };
 
-const valkeyClientFactory = async () => {
+const valkeyClientFactory = async (options) => {
   const valkey = new Valkey({
     // port: 6379,
     // host: 'service-valkey.default.svc.cluster.local',
+    port: options?.port ? options.port : undefined,
+    host: options?.port ? options.host : undefined,
     retryStrategy: (attempt) => {
       if (attempt === 1) {
         valkey.disconnect();
@@ -46,12 +60,12 @@ const valkeyClientFactory = async () => {
   return valkey;
 };
 
-const getValkeyObject = async (key = '') => {
+const getValkeyObject = async (options = { host: '', port: 0 }, key = '') => {
   if (!valkeyEnabled) {
     logger.warn(disableValkeyErrorMessage + ' get', key);
     return null;
   }
-  const object = await valkey.get(key);
+  const object = await ValkeyInstances[`${options.host}${options.path}`].get(key);
   try {
     return JSON.parse(object);
   } catch (error) {
@@ -60,19 +74,19 @@ const getValkeyObject = async (key = '') => {
   }
 };
 
-const setValkeyObject = async (key = '', payload = {}) => {
+const setValkeyObject = async (options = { host: '', port: 0 }, key = '', payload = {}) => {
   if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
-  return await valkey.set(key, JSON.stringify(payload));
+  return await ValkeyInstances[`${options.host}${options.path}`].set(key, JSON.stringify(payload));
 };
 
-const updateValkeyObject = async (key = '', payload = {}) => {
+const updateValkeyObject = async (options = { host: '', port: 0 }, key = '', payload = {}) => {
   if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
-  const object = await getValkeyObject(key, valkey);
+  const object = await getValkeyObject(key);
   object.updatedAt = new Date().toISOString();
-  return await valkey.set(key, JSON.stringify({ ...object, ...payload }));
+  return await ValkeyInstances[`${options.host}${options.path}`].set(key, JSON.stringify({ ...object, ...payload }));
 };
 
-const valkeyObjectFactory = async (module = '', options = { host: 'localhost', object: {} }) => {
+const valkeyObjectFactory = async (options = { host: 'localhost', object: {} }, module = '') => {
   if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
   const idoDate = new Date().toISOString();
   options.object = options.object || {};
@@ -112,10 +126,9 @@ const ValkeyAPI = {
   setValkeyObject,
   valkeyObjectFactory,
   updateValkeyObject,
+  createValkeyConnection,
 };
 
-const valkey = await ValkeyAPI.valkeyClientFactory();
-
 export {
   valkeyClientFactory,
   selectDtoFactory,
@@ -124,5 +137,6 @@ export {
   valkeyObjectFactory,
   updateValkeyObject,
   isValkeyEnable,
+  createValkeyConnection,
   ValkeyAPI,
 };