underpost 2.8.482 → 2.8.522

package/src/db/mongo/MongooseDB.js

@@ -79,7 +79,17 @@ const MongooseDB = {
               if (process.argv.includes('rocky')) {
                 // https://github.com/mongodb/mongodb-selinux
                 // https://www.mongodb.com/docs/v7.0/tutorial/install-mongodb-enterprise-on-red-hat/
-                shellExec(`sudo chown -R mongod:mongod /var/lib/mongo`);
+                // https://www.mongodb.com/docs/v6.0/tutorial/install-mongodb-on-red-hat/
+                // https://www.mongodb.com/docs/v4.4/tutorial/install-mongodb-on-red-hat/
+                // dnf install selinux-policy-devel
+                // git clone https://github.com/mongodb/mongodb-selinux
+                // cd mongodb-selinux
+                // make
+                // sudo make install
+                // yum list installed | grep mongo
+                // sudo yum erase $(rpm -qa | grep mongodb)
+                // remove service
+                // sudo systemctl reset-failed
               }
               logger.info('install legacy 4.4');
               shellExec(`wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -`);
@@ -112,9 +122,13 @@ const MongooseDB = {
           shellExec(`sudo systemctl unmask mongod`);
           shellExec(`sudo pkill -f mongod`);
           shellExec(`sudo systemctl enable mongod.service`);
+
           shellExec(`sudo chown -R mongodb:mongodb /var/lib/mongodb`);
           shellExec(`sudo chown mongodb:mongodb /tmp/mongodb-27017.sock`);
 
+          shellExec(`sudo chown -R mongod:mongod /var/lib/mongodb`);
+          shellExec(`sudo chown mongod:mongod /tmp/mongodb-27017.sock`);
+
           logger.info('run server');
           shellExec(`sudo service mongod restart`);
 

package/src/index.js

@@ -5,6 +5,7 @@
  */
 
 import UnderpostCluster from './cli/cluster.js';
+import UnderpostCron from './cli/cron.js';
 import UnderpostDB from './cli/db.js';
 import UnderpostDeploy from './cli/deploy.js';
 import UnderpostRootEnv from './cli/env.js';
@@ -26,7 +27,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.482';
+  static version = 'v2.8.522';
   /**
    * Repository cli API
    * @static
@@ -90,6 +91,13 @@ class Underpost {
    * @memberof Underpost
    */
   static deploy = UnderpostDeploy.API;
+  /**
+   * Cron cli API
+   * @static
+   * @type {UnderpostCron.API}
+   * @memberof Underpost
+   */
+  static cron = UnderpostCron.API;
 }
 
 const up = Underpost;

package/src/server/backup.js

@@ -1,120 +1,76 @@
 import fs from 'fs-extra';
 import { loggerFactory } from './logger.js';
-import { shellCd, shellExec } from './process.js';
-import { getCronBackUpFolder, getDataDeploy } from './conf.js';
+import { shellExec } from './process.js';
+import { getCronBackUpFolder } from './conf.js';
 import dotenv from 'dotenv';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function ({ deployId }) {
-    const Callback = async function () {
-      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+class BackUp {
+  static callback = async function (deployList, options = { disableKindCluster: false }) {
+    if ((!deployList || deployList === 'dd') && fs.existsSync(`./engine-private/deploy/dd.router`))
+      deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
 
-      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+    logger.info('init backups callback', deployList);
+    await logger.setUpInfo();
+    const currentDate = new Date().getTime();
+    const maxBackupRetention = 5;
 
-      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+    if (!fs.existsSync('./engine-private/cron-backups'))
+      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      if (!backups) return;
+    for (const _deployId of deployList.split(',')) {
+      const deployId = _deployId.trim();
+      if (!deployId) continue;
 
-      logger.info('init backups callback');
-      await logger.setUpInfo();
-
-      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();
+      if (options.disableKindCluster !== true) {
+        shellExec(`underpost db --export ${deployId}`);
+        continue;
+      }
 
-              switch (backupFrequency) {
-                case 'daily':
+      const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
 
-                default:
-                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                  break;
-              }
+      for (const host of Object.keys(confServer))
+        for (const path of Object.keys(confServer[host])) {
+          // retention policy
+          const { db } = confServer[host][path];
+          if (!db) continue;
+          logger.info('Init backup', { host, path, db });
 
-              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-                const removePathRetention = `${backUpPath}/${retentionPath}`;
-                logger.info('Remove backup folder', removePathRetention);
-                fs.removeSync(removePathRetention);
-              }
+          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 });
 
-              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+          const currentBackupsDirs = files
+            .map((fileObj) => parseInt(fileObj.name))
+            .sort((a, b) => a - b)
+            .reverse();
 
-              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+          for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+            const removePathRetention = `${backUpPath}/${retentionPath}`;
+            logger.info('Remove backup folder', removePathRetention);
+            fs.removeSync(removePathRetention);
+          }
 
-              if (wp) {
-                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
-                  .split('/')
-                  .pop()}.git`;
+          fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-                shellExec(
-                  `cd ${directory}` +
-                    ` && git pull ${repoUrl}` +
-                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                    ` && git push ${repoUrl}`,
-                  {
-                    disableLog: true,
-                  },
-                );
-              }
-            }
+          shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
         }
-      }
       shellExec(
         `cd ./engine-private/cron-backups` +
-          ` && git pull ${BackUpManagement.repoUrl}` +
-          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-          ` && git push ${BackUpManagement.repoUrl}`,
+          ` && underpost pull . underpostnet/cron-backups` +
+          ` && git add .` +
+          ` && underpost cmt . backup cron-job '${new Date().toLocaleDateString()}'` +
+          ` && underpost push . underpostnet/cron-backups`,
         {
           disableLog: true,
         },
       );
-    };
-    await Callback();
-    BackUpManagement.Callback = Callback;
-    return Callback;
-  },
-  Callback: async function (params) {},
-};
+    }
+  };
+}
 
-export { BackUpManagement };
+export default BackUp;

package/src/server/conf.js

@@ -19,17 +19,8 @@ import { DefaultConf } from '../../conf.js';
 import read from 'read';
 import splitFile from 'split-file';
 import axios from 'axios';
-import https from 'https';
 import { ssrFactory } from './client-formatted.js';
 
-// axios.defaults.baseURL = BASE_URL;
-
-// const httpsAgent = new https.Agent({
-//   rejectUnauthorized: false,
-// });
-
-// axios.defaults.httpsAgent = httpsAgent;
-
 colors.enable();
 
 dotenv.config();
@@ -98,6 +89,14 @@ const Config = {
 };
 
 const loadConf = (deployId, envInput, subConf) => {
+  if (deployId === 'clean') {
+    shellExec(`git checkout package.json`);
+    shellExec(`git checkout .env.production`);
+    shellExec(`git checkout .env.development`);
+    shellExec(`git checkout .env.test`);
+    shellExec(`git checkout jsdoc.json`);
+    return;
+  }
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
@@ -590,9 +589,25 @@ const cliSpinner = async (time = 5000, message0, message1, color, type = 'dots')
 const buildReplicaId = ({ deployId, replica }) => `${deployId}-${replica.slice(1)}`;
 
 const getDataDeploy = (
-  options = { buildSingleReplica: false, deployGroupId: '', deployId: '', disableSyncEnvPort: false },
+  options = {
+    buildSingleReplica: false,
+    deployGroupId: '',
+    deployId: '',
+    disableSyncEnvPort: false,
+    deployIdConcat: [],
+  },
 ) => {
-  let dataDeploy = JSON.parse(fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.json`, 'utf8'));
+  let dataDeploy =
+    options.deployGroupId === 'dd'
+      ? fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.router`, 'utf8')
+      : fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}`, 'utf8');
+
+  dataDeploy = dataDeploy
+    .split(',')
+    .map((deployId) => deployId.trim())
+    .filter((deployId) => deployId);
+
+  if (options.deployIdConcat) dataDeploy = dataDeploy.concat(options.deployIdConcat);
 
   if (options.deployId) dataDeploy = dataDeploy.filter((d) => d === options.deployId);
 
@@ -827,7 +842,7 @@ const deployRun = async (dataDeploy, currentAttempt = 1) => {
   if (failed.length > 0) {
     for (const deploy of failed) logger.error(deploy.deployId, Cmd.run(deploy.deployId));
     if (currentAttempt === maxAttempts) return logger.error(`max deploy attempts exceeded`);
-    if (process.argv.includes('manual')) await read({ prompt: 'Press enter to retry failed processes\n' });
+    await read({ prompt: 'Press enter to retry failed processes\n' });
     currentAttempt++;
     await deployRun(failed, currentAttempt);
   } else logger.info(`Deploy process successfully`);
@@ -973,15 +988,15 @@ const getPathsSSR = (conf) => {
 
 const Cmd = {
   delete: (deployId) => `pm2 delete ${deployId}`,
-  run: (deployId) => `node bin/deploy run ${deployId}`,
+  run: () => `npm start`,
   build: (deployId) => `node bin/deploy build-full-client ${deployId}${process.argv.includes('l') ? ' l' : ''}`,
   conf: (deployId, env) => `node bin/deploy conf ${deployId} ${env ? env : 'production'}`,
   replica: (deployId, host, path) => `node bin/deploy build-single-replica ${deployId} ${host} ${path}`,
   syncPorts: (deployGroupId) => `node bin/deploy sync-env-port ${deployGroupId}`,
-  cron: (deployId, job, expression) => {
-    shellExec(Cmd.delete(`${deployId}-${job}`));
-    return `env-cmd -f .env.production pm2 start bin/cron.js --no-autorestart --instances 1 --cron "${expression}" --name ${deployId}-${job} -- ${job} ${deployId}`;
-  },
+  cron: (deployList, jobList, name, expression, options) =>
+    `pm2 start ./bin/index.js --no-autorestart --instances 1 --cron "${expression}" --name ${name} -- cron ${
+      options?.disableKindCluster ? `--disable-kind-cluster ` : ''
+    }${deployList} ${jobList}`,
 };
 
 const fixDependencies = async () => {
@@ -1048,7 +1063,7 @@ const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   shellExec(`node bin/deploy valkey-service`);
   const proxyDeployId = fs.readFileSync(`./engine-private/deploy/${deployGroupId}.proxy`, 'utf8').trim();
   shellExec(`node bin/deploy conf ${proxyDeployId} production`);
-  shellExec(`node bin/deploy run ${proxyDeployId} maintenance`);
+  shellExec(`npm start ${proxyDeployId} maintenance`);
 };
 
 const getNpmRootPath = () =>

package/src/server/dns.js

@@ -1,26 +1,17 @@
 import axios from 'axios';
 import dotenv from 'dotenv';
 import fs from 'fs';
-import https from 'https';
 import validator from 'validator';
 import { ip } from './network.js';
 import { loggerFactory } from './logger.js';
-import { shellExec } from './process.js';
-
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
-
-axios.defaults.httpsAgent = httpsAgent;
+import UnderpostRootEnv from '../cli/env.js';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-const Dns = {
-  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_DNS_REPO}.git`,
-  callback: () => null,
-  InitIpDaemon: async function ({ deployId }) {
+class Dns {
+  static callback = async function (deployList) {
     // NAT-VPS modem/router device configuration:
     // LAN --> [NAT-VPS] --> WAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
@@ -30,25 +21,24 @@ const Dns = {
     // 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'));
 
-    const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
-
-    const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-    let confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
-    if (confCronData.ipDaemon.disabled) return;
-    Dns.ip = confCronData.ipDaemon.ip;
-    logger.info(`Current ip`, Dns.ip);
-    const callback = async () => {
-      logger.info('init dns ip callback');
-      await logger.setUpInfo();
       let testIp;
+
       try {
         testIp = await ip.public.ipv4();
       } catch (error) {
         logger.error(error, { testIp, stack: error.stack });
       }
-      if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && Dns.ip !== testIp) {
-        logger.info(`New ip`, testIp);
+
+      const currentIp = UnderpostRootEnv.API.get('ip');
+
+      if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && currentIp !== testIp) {
+        logger.info(`new ip`, testIp);
         for (const recordType of Object.keys(confCronData.records)) {
           switch (recordType) {
             case 'A':
@@ -66,20 +56,20 @@ const Dns = {
           const ipUrlTest = `https://${process.env.DEFAULT_DEPLOY_HOST}`;
           const response = await axios.get(ipUrlTest);
           const verifyIp = response.request.socket.remoteAddress;
-          logger.info(ipUrlTest + ' IP', verifyIp);
+          logger.info(ipUrlTest + ' verify ip', verifyIp);
           if (verifyIp === testIp) {
-            await this.saveIp(confCronPath, confCronData, testIp);
-          } else logger.error('ip not updated');
+            logger.info('ip updated successfully', testIp);
+            UnderpostRootEnv.API.set('ip', testIp);
+          } else logger.error('ip not updated', testIp);
         } catch (error) {
-          logger.error(error), 'ip not updated';
+          logger.error(error, error.stack);
+          logger.error('ip not updated', testIp);
         }
       }
-    };
-    await callback();
-    this.callback = callback;
-    return callback;
-  },
-  services: {
+    }
+  };
+
+  static services = {
     updateIp: {
       dondominio: (options) => {
         const { user, api_key, host, dns, ip } = options;
@@ -100,21 +90,7 @@ const Dns = {
         });
       },
     },
-  },
-  saveIp: async (confCronPath, confCronData, ip) => {
-    Dns.ip = ip;
-    confCronData.ipDaemon.ip = ip;
-    fs.writeFileSync(confCronPath, JSON.stringify(confCronData, null, 4), 'utf8');
-    shellExec(
-      `cd ./engine-private` +
-        ` && git pull ${Dns.repoUrl}` +
-        ` && git add . && git commit -m "update ip ${new Date().toLocaleDateString()}"` +
-        ` && git push ${Dns.repoUrl}`,
-      {
-        disableLog: true,
-      },
-    );
-  },
-};
+  };
+}
 
-export { Dns };
+export default Dns;

package/src/server/downloader.js

@@ -2,16 +2,8 @@ import axios from 'axios';
 import fs from 'fs';
 import { loggerFactory } from './logger.js';
 import dotenv from 'dotenv';
-import https from 'https';
-
 dotenv.config();
 
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
-
-axios.defaults.httpsAgent = httpsAgent;
-
 const logger = loggerFactory(import.meta);
 
 const Downloader = (url, fullPath, options = { method: 'get', responseType: 'stream' }) =>

package/test/api.test.js

@@ -2,7 +2,6 @@
 
 import axios from 'axios';
 import dotenv from 'dotenv';
-import https from 'https';
 
 import { expect } from 'chai';
 import { loggerFactory } from '../src/server/logger.js';
@@ -20,13 +19,6 @@ const BASE_URL =
     ? `http://localhost:${PORT}/${process.env.BASE_API}`
     : `https://www.nexodev.org/api`;
 
-axios.defaults.baseURL = BASE_URL;
-
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
-axios.defaults.httpsAgent = httpsAgent;
-
 describe(`GET 'Test' API Request `, async () => {
   {
     const url = `${BASE_URL}/test/youtube-id/?url=https://www.youtube.com/watch?v=o4f42SbyDMk`;

package/manifests/core/kustomization.yaml

@@ -1,11 +0,0 @@
----
-# kubectl apply -k core/.
-apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-resources:
-  - underpost-engine-pv-pvc.yaml
-  - underpost-engine-headless-service.yaml
-  - underpost-engine-statefulset.yaml
-  - underpost-engine-backup-pv-pvc.yaml
-  - underpost-engine-mongodb-backup-cronjob.yaml
-  - underpost-engine-backup-access.yaml

package/manifests/core/underpost-engine-backup-access.yaml

@@ -1,16 +0,0 @@
-apiVersion: v1
-kind: Pod
-metadata:
-  name: backup-access
-spec:
-  containers:
-    - name: busybox
-      image: busybox
-      command: ['sh', '-c', 'sleep 3600']
-      volumeMounts:
-        - name: backup-storage
-          mountPath: /backup
-  volumes:
-    - name: backup-storage
-      persistentVolumeClaim:
-        claimName: backup-pvc

package/manifests/core/underpost-engine-backup-pv-pvc.yaml

@@ -1,22 +0,0 @@
-apiVersion: v1
-kind: PersistentVolume
-metadata:
-  name: backup-pv
-spec:
-  capacity:
-    storage: 5Gi
-  accessModes:
-    - ReadWriteOnce
-  hostPath:
-    path: /mnt/backup
----
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata:
-  name: backup-pvc
-spec:
-  accessModes:
-    - ReadWriteOnce
-  resources:
-    requests:
-      storage: 5Gi

package/manifests/core/underpost-engine-headless-service.yaml

@@ -1,10 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: mongodb-service
-spec:
-  clusterIP: None
-  selector:
-    app: mongodb
-  ports:
-    - port: 27017

package/manifests/core/underpost-engine-mongodb-backup-cronjob.yaml

@@ -1,40 +0,0 @@
-apiVersion: batch/v1
-kind: CronJob
-metadata:
-  name: mongodb-backup
-spec:
-  schedule: '*/5 * * * *' # Runs backup every five minutes
-  jobTemplate:
-    spec:
-      template:
-        spec:
-          containers:
-            - name: mongodump
-              image: docker.io/library/mongo:latest
-              command:
-                - sh
-                - -c
-                - |
-                  # Perform backup
-                  mongodump -u $MONGO_INITDB_ROOT_USERNAME -p $MONGO_INITDB_ROOT_PASSWORD --host=mongodb-service --port=27017 --out=/backup/$(date +\%Y-\%m-\%dT\%H-\%M-\%S)
-                  # Remove backups older than 7 days
-                  find /backup -type d -mtime +7 -exec rm -rf {} +
-              volumeMounts:
-                - name: backup-storage
-                  mountPath: /backup
-              env:
-                - name: MONGO_INITDB_ROOT_USERNAME
-                  valueFrom:
-                    secretKeyRef:
-                      name: mongodb-secret
-                      key: username
-                - name: MONGO_INITDB_ROOT_PASSWORD
-                  valueFrom:
-                    secretKeyRef:
-                      name: mongodb-secret
-                      key: password
-          restartPolicy: Never
-          volumes:
-            - name: backup-storage
-              persistentVolumeClaim:
-                claimName: backup-pvc

package/manifests/core/underpost-engine-mongodb-configmap.yaml

@@ -1,26 +0,0 @@
-# origin conf: /etc/mongod.conf
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: mongodb-config-file
-  namespace: default
-data:
-  mongod.conf: |
-    storage:
-      dbPath: /data/db
-    systemLog:
-      destination: file
-      logAppend: true
-      path: /var/log/mongodb/mongod.log
-    replication:
-      replSetName: rs0
-    net:
-      bindIp: 127.0.0.1
-      port: 27017
-    processManagement:
-      fork: true
-    setParameter:
-      enableLocalhostAuthBypass: false
-    security:
-      authorization: enabled
-      keyFile: /etc/mongodb-keyfile

package/manifests/core/underpost-engine-pv-pvc.yaml

@@ -1,23 +0,0 @@
-apiVersion: v1
-kind: PersistentVolume
-metadata:
-  name: mongodb-pv
-spec:
-  capacity:
-    storage: 5Gi
-  accessModes:
-    - ReadWriteOnce
-  hostPath:
-    path: /data/mongodb
----
-apiVersion: v1
-kind: PersistentVolumeClaim
-metadata:
-  name: mongodb-pvc
-spec:
-  storageClassName: ''
-  accessModes:
-    - ReadWriteOnce
-  resources:
-    requests:
-      storage: 5Gi