@underpostnet/underpost 2.7.82

package/src/server/backup.js

@@ -0,0 +1,108 @@
+import fs from 'fs-extra';
+import { loggerFactory } from './logger.js';
+import { shellCd, shellExec } from './process.js';
+import { getCronBackUpFolder, getDataDeploy } from './conf.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const BackUpManagement = {
+  repoUrl: `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${process.env.GITHUB_BACKUP_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
+  Init: async function () {
+    await this.Callback();
+    return this.Callback;
+  },
+  Callback: async function () {
+    const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
+
+    const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+
+    const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+
+    if (!backups) return;
+
+    const currentDate = new Date().getTime();
+
+    if (!fs.existsSync('./engine-private/cron-backups'))
+      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
+
+    for (const deployGroupData of backups) {
+      const { deployGroupId } = deployGroupData;
+      const dataDeploy = getDataDeploy({ deployGroupId });
+
+      for (const deployObj of dataDeploy) {
+        const { deployId, replicaHost } = deployObj;
+
+        if (replicaHost) continue;
+
+        const confServer = JSON.parse(
+          fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
+            ? fs.readFileSync(`./engine-private/replica/${deployId}/conf.server.json`, 'utf8')
+            : 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])) {
+            // retention policy
+            let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } = confServer[host][path];
+
+            if (!db || singleReplica) continue;
+
+            if (!backupFrequency) backupFrequency = 'daily';
+            if (!maxBackupRetention) maxBackupRetention = 5;
+
+            const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
+            if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
+            // .isDirectory()
+            const files = await fs.readdir(backUpPath, { withFileTypes: true });
+
+            const currentBackupsDirs = files
+              .map((fileObj) => parseInt(fileObj.name))
+              .sort((a, b) => a - b)
+              .reverse();
+
+            switch (backupFrequency) {
+              case 'daily':
+
+              default:
+                // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
+                break;
+            }
+
+            for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+              const removePathRetention = `${backUpPath}/${retentionPath}`;
+              logger.info('Remove backup folder', removePathRetention);
+              fs.removeSync(removePathRetention);
+            }
+
+            fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+
+            shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+
+            if (wp) {
+              const repoUrl = `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${
+                process.env.GITHUB_BACKUP_USERNAME
+              }/${git.split('/').pop()}.git`;
+
+              shellExec(
+                `cd ${directory}` +
+                  ` && git pull ${repoUrl}` +
+                  ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+                  ` && git push ${repoUrl}`,
+              );
+            }
+          }
+      }
+    }
+    shellExec(
+      `cd ./engine-private/cron-backups` +
+        ` && git pull ${BackUpManagement.repoUrl}` +
+        ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+        ` && git push ${BackUpManagement.repoUrl}`,
+    );
+  },
+};
+
+export { BackUpManagement };

package/src/server/client-build-live.js

@@ -0,0 +1,98 @@
+import fs from 'fs-extra';
+import { Config, loadConf } from './conf.js';
+import { loggerFactory } from './logger.js';
+import { buildClient } from './client-build.js';
+
+const logger = loggerFactory(import.meta);
+
+const clientLiveBuild = async () => {
+  if (fs.existsSync(`./tmp/client.build.json`)) {
+    const deployId = process.argv[2];
+
+    let clientId = 'default';
+    let host = 'default.net';
+    let path = '/';
+    let baseHost = `${host}${path === '/' ? '' : path}`;
+    let views = Config.default.client[clientId].views;
+
+    if (
+      deployId &&
+      (fs.existsSync(`./engine-private/conf/${deployId}`) || fs.existsSync(`./engine-private/replica/${deployId}`))
+    ) {
+      loadConf(deployId);
+      const confClient = JSON.parse(
+        fs.readFileSync(
+          fs.existsSync(`./engine-private/replica/${deployId}`)
+            ? `./engine-private/replica/${deployId}/conf.client.json`
+            : fs.existsSync(`./engine-private/conf/${deployId}/conf.client.json`)
+            ? `./engine-private/conf/${deployId}/conf.client.json`
+            : `./conf/conf.client.json`,
+          'utf8',
+        ),
+      );
+      const confServer = JSON.parse(
+        fs.readFileSync(
+          fs.existsSync(`./engine-private/replica/${deployId}`)
+            ? `./engine-private/replica/${deployId}/conf.server.json`
+            : fs.existsSync(`./engine-private/conf/${deployId}/conf.server.json`)
+            ? `./engine-private/conf/${deployId}/conf.server.json`
+            : `./conf/conf.server.json`,
+          'utf8',
+        ),
+      );
+      host = process.argv[3];
+      path = process.argv[4];
+      clientId = confServer[host][path].client;
+      views = confClient[clientId].views;
+      baseHost = `${host}${path === '/' ? '' : path}`;
+    }
+
+    logger.info('Live build config', {
+      deployId,
+      host,
+      path,
+      clientId,
+      baseHost,
+      views: views.length,
+    });
+
+    const updates = JSON.parse(fs.readFileSync(`./tmp/client.build.json`, 'utf8'));
+    const liveClientBuildPaths = [];
+    for (let srcPath of updates) {
+      srcPath = srcPath.replaceAll('/', `\\`); // linux case
+
+      const srcBuildPath = `./src${srcPath.split('src')[1].replace(/\\/g, '/')}`;
+      if (
+        srcPath.split('src')[1].startsWith(`\\client\\components`) ||
+        srcPath.split('src')[1].startsWith(`\\client\\services`)
+      ) {
+        const publicBuildPath = `./public/${baseHost}/${srcPath.split('src')[1].slice(8)}`.replace(/\\/g, '/');
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (srcPath.split('src')[1].startsWith(`\\client\\sw`)) {
+        const publicBuildPath = `./public/${baseHost}/sw.js`;
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (
+        srcPath.split('src')[1].startsWith(`\\client\\offline`) &&
+        srcPath.split('src')[1].startsWith(`index.js`)
+      ) {
+        const publicBuildPath = `./public/${baseHost}/offline.js`;
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (srcPath.split('src')[1].startsWith(`\\client`) && srcPath.slice(-9) === '.index.js') {
+        for (const view of views) {
+          const publicBuildPath = `./public/${baseHost}${view.path === '/' ? '' : view.path}/${clientId}.index.js`;
+          liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+        }
+      } else if (srcPath.split('src')[1].startsWith(`\\client\\ssr`)) {
+        for (const view of views) {
+          const publicBuildPath = `./public/${baseHost}${view.path === '/' ? '' : view.path}/index.html`;
+          liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+        }
+      }
+    }
+    logger.info('liveClientBuildPaths', liveClientBuildPaths);
+    await buildClient({ liveClientBuildPaths, instances: [{ host, path }] });
+    fs.removeSync(`./tmp/client.build.json`);
+  }
+};
+
+export { clientLiveBuild };