underpost 2.8.6 → 2.8.8

package/src/cli/env.js

@@ -25,18 +25,24 @@ class UnderpostRootEnv {
       delete env[key];
       writeEnv(envPath, env);
     },
-    get(key) {
+    get(key, value, options = { plain: false }) {
       const exeRootPath = `${getNpmRootPath()}/underpost`;
       const envPath = `${exeRootPath}/.env`;
-      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      if (!fs.existsSync(envPath)) {
+        logger.error(`Unable to find underpost root environment`);
+        return undefined;
+      }
       const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-      logger.info('underpost root', { [key]: env[key] });
+      options?.plain === true ? console.log(env[key]) : logger.info(`${key}(${typeof env[key]})`, env[key]);
       return env[key];
     },
     list() {
       const exeRootPath = `${getNpmRootPath()}/underpost`;
       const envPath = `${exeRootPath}/.env`;
-      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      if (!fs.existsSync(envPath)) {
+        logger.error(`Unable to find underpost root environment`);
+        return {};
+      }
       const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
       logger.info('underpost root', env);
       return env;

package/src/cli/fs.js

@@ -24,7 +24,7 @@ class UnderpostFileStorage {
     getStorageConf(options) {
       let storage, storageConf;
       if (options.deployId && typeof options.deployId === 'string') {
-        storageConf = `./engine-private/conf/${options.deployId}/storage.json`;
+        storageConf = options.storageFilePath ?? `./engine-private/conf/${options.deployId}/storage.json`;
         if (!fs.existsSync(storageConf)) fs.writeFileSync(storageConf, JSON.stringify({}), 'utf8');
         storage = JSON.parse(fs.readFileSync(storageConf, 'utf8'));
       }
@@ -35,10 +35,18 @@ class UnderpostFileStorage {
     },
     async recursiveCallback(
       path,
-      options = { rm: false, recursive: false, deployId: '', force: false, pull: false, git: false },
+      options = {
+        rm: false,
+        recursive: false,
+        deployId: '',
+        force: false,
+        pull: false,
+        git: false,
+        storageFilePath: '',
+      },
     ) {
       const { storage, storageConf } = UnderpostFileStorage.API.getStorageConf(options);
-      const deleteFiles = UnderpostRepository.API.getDeleteFiles(path);
+      const deleteFiles = options.pull === true ? [] : UnderpostRepository.API.getDeleteFiles(path);
       for (const relativePath of deleteFiles) {
         const _path = path + '/' + relativePath;
         if (_path in storage) {
@@ -46,10 +54,6 @@ class UnderpostFileStorage {
           delete storage[_path];
         }
       }
-      const files =
-        options.git === true
-          ? UnderpostRepository.API.getChangedFiles(path)
-          : await fs.readdir(path, { recursive: true });
       if (options.pull === true) {
         for (const _path of Object.keys(storage)) {
           if (!fs.existsSync(_path) || options.force === true) {
@@ -57,7 +61,11 @@ class UnderpostFileStorage {
             await UnderpostFileStorage.API.pull(_path, options);
           } else logger.warn(`Pull path already exists`, _path);
         }
-      } else
+      } else {
+        const files =
+          options.git === true
+            ? UnderpostRepository.API.getChangedFiles(path)
+            : await fs.readdir(path, { recursive: true });
         for (const relativePath of files) {
           const _path = path + '/' + relativePath;
           if (fs.statSync(_path).isDirectory()) {
@@ -68,6 +76,7 @@ class UnderpostFileStorage {
             if (storage) storage[_path] = {};
           } else logger.warn('File already exists', _path);
         }
+      }
       UnderpostFileStorage.API.writeStorageConf(storage, storageConf);
       if (options.git === true) {
         shellExec(`cd ${path} && git add .`);
@@ -84,7 +93,10 @@ class UnderpostFileStorage {
       if (options.rm === true) return await UnderpostFileStorage.API.delete(path, options);
       return await UnderpostFileStorage.API.upload(path, options);
     },
-    async upload(path, options = { rm: false, recursive: false, deployId: '', force: false, pull: false }) {
+    async upload(
+      path,
+      options = { rm: false, recursive: false, deployId: '', force: false, pull: false, storageFilePath: '' },
+    ) {
       UnderpostFileStorage.API.cloudinaryConfig();
       const { storage, storageConf } = UnderpostFileStorage.API.getStorageConf(options);
       // path = UnderpostFileStorage.API.file2Zip(path);

package/src/cli/image.js

@@ -1,145 +1,137 @@
 import fs from 'fs-extra';
-import Underpost from '../index.js';
-import { shellCd, shellExec } from '../server/process.js';
 import dotenv from 'dotenv';
-import { getNpmRootPath } from '../server/conf.js';
-import { timer } from '../client/components/core/CommonJs.js';
-import UnderpostRootEnv from './env.js';
+import { loggerFactory } from '../server/logger.js';
+import Underpost from '../index.js';
+import { getUnderpostRootPath } from '../server/conf.js';
+import { shellExec } from '../server/process.js';
 
 dotenv.config();
 
+const logger = loggerFactory(import.meta);
+
 class UnderpostImage {
   static API = {
     dockerfile: {
-      pullBaseImages() {
+      /**
+       * @method pullBaseImages
+       * @description Pulls base images and builds a 'debian-underpost' image,
+       * then loads it into the specified Kubernetes cluster type (Kind, Kubeadm, or K3s).
+       * @param {object} options - Options for pulling and loading images.
+       * @param {boolean} [options.kindLoad=false] - If true, load image into Kind cluster.
+       * @param {boolean} [options.kubeadmLoad=false] - If true, load image into Kubeadm cluster.
+       * @param {boolean} [options.k3sLoad=false] - If true, load image into K3s cluster.
+       * @param {string} [options.path=false] - Path to the Dockerfile context.
+       * @param {string} [options.version=''] - Version tag for the image.
+       */
+      pullBaseImages(
+        options = {
+          kindLoad: false,
+          kubeadmLoad: false,
+          k3sLoad: false,
+          path: false,
+          version: '',
+        },
+      ) {
         shellExec(`sudo podman pull docker.io/library/debian:buster`);
+        const IMAGE_NAME = `debian-underpost`;
+        const IMAGE_NAME_FULL = `${IMAGE_NAME}:${options.version ?? Underpost.version}`;
+        let LOAD_TYPE = '';
+        if (options.kindLoad === true) {
+          LOAD_TYPE = `--kind-load`;
+        } else if (options.kubeadmLoad === true) {
+          LOAD_TYPE = `--kubeadm-load`;
+        } else if (options.k3sLoad === true) {
+          // Handle K3s load type
+          LOAD_TYPE = `--k3s-load`;
+        }
+
+        shellExec(
+          `underpost dockerfile-image-build --podman-save --reset --image-path=. --path ${
+            options.path ?? getUnderpostRootPath()
+          } --image-name=${IMAGE_NAME_FULL} ${LOAD_TYPE}`,
+        );
       },
+      /**
+       * @method build
+       * @description Builds a Docker image using Podman, optionally saves it as a tar archive,
+       * and loads it into a specified Kubernetes cluster (Kind, Kubeadm, or K3s).
+       * @param {object} options - Options for building and loading images.
+       * @param {string} [options.path=''] - The path to the directory containing the Dockerfile.
+       * @param {string} [options.imageName=''] - The name and tag for the image (e.g., 'my-app:latest').
+       * @param {string} [options.imagePath=''] - Directory to save the image tar file.
+       * @param {string} [options.dockerfileName=''] - Name of the Dockerfile (defaults to 'Dockerfile').
+       * @param {boolean} [options.podmanSave=false] - If true, save the image as a tar archive using Podman.
+       * @param {boolean} [options.kindLoad=false] - If true, load the image archive into a Kind cluster.
+       * @param {boolean} [options.kubeadmLoad=false] - If true, load the image archive into a Kubeadm cluster (uses 'ctr').
+       * @param {boolean} [options.k3sLoad=false] - If true, load the image archive into a K3s cluster (uses 'k3s ctr').
+       * @param {boolean} [options.secrets=false] - If true, load secrets from the .env file for the build.
+       * @param {string} [options.secretsPath=''] - Custom path to the .env file for secrets.
+       * @param {boolean} [options.reset=false] - If true, perform a no-cache build.
+       */
       build(
-        deployId = 'default',
-        env = 'development',
-        path = '.',
-        options = { imageArchive: false, podmanSave: false, imageName: '', imageVersion: '' },
+        options = {
+          path: '',
+          imageName: '',
+          imagePath: '',
+          dockerfileName: '',
+          podmanSave: false,
+          kindLoad: false,
+          kubeadmLoad: false,
+          k3sLoad: false,
+          secrets: false,
+          secretsPath: '',
+          reset: false,
+        },
       ) {
-        const imgName = `${
-          options.imageName && typeof options.imageName === 'string' ? options.imageName : `${deployId}-${env}`
-        }:${
-          options.imageVersion && typeof options.imageVersions === 'string' ? options.imageVersion : Underpost.version
-        }`;
-        const podManImg = `localhost/${imgName}`;
-        const imagesStoragePath = `/images`;
-        if (!fs.existsSync(`${path}${imagesStoragePath}`))
-          fs.mkdirSync(`${path}${imagesStoragePath}`, { recursive: true });
-        const tarFile = `.${imagesStoragePath}/${imgName.replace(':', '_')}.tar`;
-
-        let secrets = ' ';
+        const {
+          path,
+          imageName,
+          imagePath,
+          dockerfileName,
+          podmanSave,
+          secrets,
+          secretsPath,
+          kindLoad,
+          kubeadmLoad,
+          k3sLoad,
+          reset,
+        } = options;
+        const podManImg = `localhost/${imageName}`;
+        if (imagePath && typeof imagePath === 'string' && !fs.existsSync(imagePath))
+          fs.mkdirSync(imagePath, { recursive: true });
+        const tarFile = `${imagePath}/${imageName.replace(':', '_')}.tar`;
+        let secretsInput = ' ';
         let secretDockerInput = '';
-
-        const envObj = dotenv.parse(fs.readFileSync(`${getNpmRootPath()}/underpost/.env`, 'utf8'));
-
-        for (const key of Object.keys(envObj)) {
-          continue;
-          secrets += ` && export ${key}="${envObj[key]}" `; // $(cat gitlab-token.txt)
-          secretDockerInput += ` --secret id=${key},env=${key} \ `;
-        }
-        // --rm --no-cache
-        if (options.imageArchive !== true) {
-          fs.copyFile(`${getNpmRootPath()}/underpost/.env`, `${path}/.env.underpost`);
-          shellExec(
-            `cd ${path}${secrets}&& sudo podman build -f ./Dockerfile -t ${imgName} --pull=never --cap-add=CAP_AUDIT_WRITE${secretDockerInput}`,
+        let cache = '';
+        if (secrets === true) {
+          const envObj = dotenv.parse(
+            fs.readFileSync(
+              secretsPath && typeof secretsPath === 'string' ? secretsPath : `${getNpmRootPath()}/underpost/.env`,
+              'utf8',
+            ),
           );
-          fs.removeSync(`${path}/.env.underpost`);
-        }
-        if (options.imageArchive !== true || options.podmanSave === true)
-          shellExec(`cd ${path} && podman save -o ${tarFile} ${podManImg}`);
-        shellExec(`cd ${path} && sudo kind load image-archive ${tarFile}`);
-      },
-      async script(deployId = 'default', env = 'development', options = { run: false, build: false }) {
-        if (deployId === 'deploy') {
-          const _deployId = UnderpostRootEnv.API.get('deploy-id');
-          const _env = UnderpostRootEnv.API.get('deploy-env');
-          const _path = UnderpostRootEnv.API.get('deploy-path');
-          if (_deployId) {
-            deployId = _deployId;
-            if (_env) env = _env;
-            if (_path) path = _path;
-          } else {
-            await timer(30 * 1000);
-            return await UnderpostImage.API.script(deployId, env, path, options);
+          for (const key of Object.keys(envObj)) {
+            secretsInput += ` && export ${key}="${envObj[key]}" `; // Example: $(cat gitlab-token.txt)
+            secretDockerInput += ` --secret id=${key},env=${key} \ `;
           }
         }
-        if (options.build === true) {
-          const buildBasePath = `/home/dd`;
-          const repoName = `engine-${deployId.split('-')[1]}`;
-          fs.mkdirSync(buildBasePath, { recursive: true });
-          shellExec(`cd ${buildBasePath} && underpost clone underpostnet/${repoName}`);
-          shellExec(`cd ${buildBasePath} && sudo mv ./${repoName} ./engine`);
-          shellExec(`cd ${buildBasePath}/engine && underpost clone underpostnet/${repoName}-private`);
-          shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
-          shellCd(`${buildBasePath}/engine`);
-          shellExec(`npm install`);
-          const itcScripts = fs.readdir('./engine-private/itc-scripts');
-          for (const itcScript of itcScripts)
-            if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
-        }
-        switch (deployId) {
-          case 'dd-lampp':
-            {
-              const lamppPublicPath = '/xampp/htdocs/online';
-              shellExec(`sudo mkdir -p ${lamppPublicPath}`);
-            }
-            break;
-
-          default:
-            {
-              {
-                const originPath = `./src/db/mongo/MongooseDB.js`;
-                fs.writeFileSync(
-                  originPath,
-                  fs.readFileSync(originPath, 'utf8').replaceAll(
-                    `connect: async (host, name) => {`,
-                    `connect: async (host, name) => {
-    host = 'mongodb://mongodb-0.mongodb-service:27017';
-        `,
-                  ),
-                  'utf8',
-                );
-              }
+        if (reset === true) cache += ' --rm --no-cache';
+        if (path && typeof path === 'string')
+          shellExec(
+            `cd ${path}${secretsInput}&& sudo podman build -f ./${
+              dockerfileName && typeof dockerfileName === 'string' ? dockerfileName : 'Dockerfile'
+            } -t ${imageName} --pull=never --cap-add=CAP_AUDIT_WRITE${cache}${secretDockerInput} --network host`,
+          );
 
-              {
-                const originPath = `./src/server/valkey.js`;
-                fs.writeFileSync(
-                  originPath,
-                  fs.readFileSync(originPath, 'utf8').replaceAll(
-                    `    // port: 6379,
-    // host: 'service-valkey.default.svc.cluster.local',`,
-                    `     port: 6379,
-    host: 'service-valkey.default.svc.cluster.local',`,
-                  ),
-                  'utf8',
-                );
-              }
-            }
-            break;
+        if (podmanSave === true) shellExec(`podman save -o ${tarFile} ${podManImg}`);
+        if (kindLoad === true) shellExec(`sudo kind load image-archive ${tarFile}`);
+        if (kubeadmLoad === true) {
+          // Use 'ctr' for Kubeadm
+          shellExec(`sudo ctr -n k8s.io images import ${tarFile}`);
         }
-        shellExec(`node bin/deploy conf ${deployId} ${env}`);
-        shellExec(`node bin/deploy build-full-client ${deployId}`);
-        if (options.run === true) {
-          const runCmd = env === 'production' ? 'run prod-img' : 'run dev-img';
-          if (fs.existsSync(`./engine-private/replica`)) {
-            const replicas = await fs.readdir(`./engine-private/replica`);
-            for (const replica of replicas) {
-              shellExec(`node bin/deploy conf ${replica} ${env}`);
-              shellExec(`npm ${runCmd} ${replica} deploy`, { async: true });
-              fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
-              const monitor = async () => {
-                await timer(1000);
-                if (fs.existsSync(`./tmp/await-deploy`)) return await monitor();
-              };
-              await monitor();
-            }
-            shellExec(`node bin/deploy conf ${deployId} ${env}`);
-          }
-          shellExec(`npm ${runCmd} ${deployId} deploy`);
+        if (k3sLoad === true) {
+          // Use 'k3s ctr' for K3s
+          shellExec(`sudo k3s ctr images import ${tarFile}`);
         }
       },
     },