underpost 3.2.30 → 3.2.80

package/scripts/disk-clean.sh

@@ -7,20 +7,20 @@ set -euo pipefail
 
 VACUUM_SIZE="200M"          # journalctl vacuum target
 LARGE_LOG_SIZE="+100M"      # threshold for truncation (find syntax)
-TMP_AGE_DAYS=3              # remove files older than this from /tmp and /var/tmp
-CACHE_AGE_DAYS=30           # remove caches older than this from /var/cache
+TMP_AGE_DAYS=1              # remove files older than this from /tmp and /var/tmp
+CACHE_AGE_DAYS=5           # remove caches older than this from /var/cache
 KEEP_KERNELS=2              # keep this many latest kernels
 REMOVE_OPT=0                # ALWAYS allow removing /opt entries (user requested)
 
 timestamp() { date +"%F %T"; }
 log() {
-  echo "$(timestamp) $*"
+    echo "$(timestamp) $*"
 }
 
 # must be root
 if [ "$EUID" -ne 0 ]; then
-  echo "This script must be run as root. Exiting."
-  exit 1
+    echo "This script must be run as root. Exiting."
+    exit 1
 fi
 
 log "=== Starting Rocky Linux 9 automated cleanup (batch mode) ==="
@@ -46,8 +46,8 @@ journalctl --vacuum-size="$VACUUM_SIZE"
 # 3) Truncate very large logs in /var/log (safer than delete)
 log "Truncating logs in /var/log larger than ${LARGE_LOG_SIZE} (keeps zero-sized file so services don't break)..."
 find /var/log -type f -size "$LARGE_LOG_SIZE" -print0 2>/dev/null | while IFS= read -r -d '' f; do
-  echo "Truncating $f"
-  : > "$f" || echo "Failed to truncate $f"
+    echo "Truncating $f"
+    : > "$f" || echo "Failed to truncate $f"
 done
 
 # 4) Clean /tmp and /var/tmp older than TMP_AGE_DAYS
@@ -62,87 +62,110 @@ find /var/cache -mindepth 1 -mtime +"$CACHE_AGE_DAYS" -print0 2>/dev/null | xarg
 # 6) Clean user caches (~/.cache) and Downloads older than CACHE_AGE_DAYS
 log "Cleaning user caches and old downloads (home dirs)..."
 for homedir in /home/* /root; do
-  [ -d "$homedir" ] || continue
-  usercache="$homedir/.cache"
-  userdownloads="$homedir/Downloads"
-  usertrash="$homedir/.local/share/Trash"
-
-  if [ -d "$usercache" ]; then
-    log "Removing contents of $usercache"
-    rm -rf "${usercache:?}/"* 2>/dev/null
-  fi
-  if [ -d "$userdownloads" ]; then
-    log "Removing files older than ${CACHE_AGE_DAYS} days from $userdownloads"
-    find "$userdownloads" -type f -mtime +"$CACHE_AGE_DAYS" -print0 2>/dev/null | xargs -0r rm -f -- 2>/dev/null
-  fi
-  if [ -d "$usertrash" ]; then
-    log "Emptying trash in $usertrash"
-    rm -rf "${usertrash:?}/"* 2>/dev/null
-  fi
+    [ -d "$homedir" ] || continue
+    usercache="$homedir/.cache"
+    userdownloads="$homedir/Downloads"
+    usertrash="$homedir/.local/share/Trash"
+    
+    if [ -d "$usercache" ]; then
+        log "Removing contents of $usercache"
+        rm -rf "${usercache:?}/"* 2>/dev/null
+    fi
+    if [ -d "$userdownloads" ]; then
+        log "Removing files older than ${CACHE_AGE_DAYS} days from $userdownloads"
+        find "$userdownloads" -type f -mtime +"$CACHE_AGE_DAYS" -print0 2>/dev/null | xargs -0r rm -f -- 2>/dev/null
+    fi
+    if [ -d "$usertrash" ]; then
+        log "Emptying trash in $usertrash"
+        rm -rf "${usertrash:?}/"* 2>/dev/null
+    fi
 done
 
-# 7) Docker / Podman cleanup (if present)
+# 7) Docker / Podman cleanup (if present) — this is what actually reclaims the
+#    overlay storage behind those duplicated `overlay` df lines.
 if command -v docker >/dev/null 2>&1; then
-  log "Docker detected: pruning images/containers/volumes (aggressive)..."
-  docker system df
-  docker system prune -a --volumes -f
+    log "Docker detected: pruning images/containers/volumes/build cache (aggressive)..."
+    docker system df || true
+    docker system prune -a --volumes -f || true
+    docker builder prune -a -f || true
 fi
 
 if command -v podman >/dev/null 2>&1; then
-  log "Podman detected: pruning images/containers (aggressive)..."
-  podman system df
-  podman system prune -a -f
+    log "Podman detected: pruning images/containers/volumes (aggressive)..."
+    podman system df || true
+    podman system prune -a --volumes -f || true
 fi
 
+if command -v buildah >/dev/null 2>&1; then
+    log "Buildah detected: removing leftover working containers..."
+    buildah rm --all || true
+fi
+
+# 7b) Unmount leaked container overlay 'merged' mounts. Pruning frees the data
+#     but leaves these mountpoints attached, so they keep flooding `df -h` with
+#     identical `overlay ... /merged` rows. Only unmount overlays not backing a
+#     still-existing container, so running workloads are never disturbed.
+log "Unmounting orphaned container overlay mounts..."
+if command -v podman >/dev/null 2>&1; then
+    podman umount --all >/dev/null 2>&1 || true
+fi
+active_merged="$(podman ps -aq 2>/dev/null | xargs -r -I{} podman inspect --format '{{.GraphDriver.Data.MergedDir}}' {} 2>/dev/null || true)"
+findmnt -rn -o TARGET 2>/dev/null | grep -E '/var/lib/(containers/storage|docker)/overlay.*/merged' | sort -r | while IFS= read -r m; do
+    if ! printf '%s\n' "$active_merged" | grep -qxF "$m"; then
+        echo "Unmounting orphaned overlay: $m"
+        umount -l "$m" 2>/dev/null || true
+    fi
+done
+
 # 8) Flatpak unused runtimes/apps (if present)
 if command -v flatpak >/dev/null 2>&1; then
-  log "Flatpak detected: trying to uninstall unused runtimes/apps..."
-  flatpak uninstall --unused -y || flatpak uninstall --unused
-  flatpak repair
+    log "Flatpak detected: trying to uninstall unused runtimes/apps..."
+    flatpak uninstall --unused -y || flatpak uninstall --unused
+    flatpak repair
 fi
 
 # 9) Python Pip cleanup
 if command -v pip3 >/dev/null 2>&1 || command -v pip >/dev/null 2>&1; then
-  log "Python Pip detected: cleaning cache..."
-  if command -v pip3 >/dev/null 2>&1; then
-    pip3 cache purge
-  elif command -v pip >/dev/null 2>&1; then
-    pip cache purge
-  fi
+    log "Python Pip detected: cleaning cache..."
+    if command -v pip3 >/dev/null 2>&1; then
+        pip3 cache purge
+        elif command -v pip >/dev/null 2>&1; then
+        pip cache purge
+    fi
 fi
 
 # 10) Conda cleanup
 if command -v conda >/dev/null 2>&1; then
-  log "Conda detected: cleaning all..."
-  conda clean --all -y
+    log "Conda detected: cleaning all..."
+    conda clean --all -y
 fi
 
 # 11) Remove old kernels but keep the last KEEP_KERNELS (safe)
 log "Removing old kernels, keeping the last $KEEP_KERNELS kernels..."
 OLD_KERNELS=$(dnf repoquery --installonly --latest-limit=-$KEEP_KERNELS -q 2>/dev/null)
 if [ -n "$OLD_KERNELS" ]; then
-  log "Old kernels to remove: $OLD_KERNELS"
-  dnf -y remove $OLD_KERNELS
+    log "Old kernels to remove: $OLD_KERNELS"
+    dnf -y remove $OLD_KERNELS
 else
-  log "No old kernels found by DNF repoquery. Only $KEEP_KERNELS or fewer are currently installed."
+    log "No old kernels found by DNF repoquery. Only $KEEP_KERNELS or fewer are currently installed."
 fi
 
 # 12) /opt review and removal (ON by default now)
 if [ -d /opt ]; then
-  log "/opt usage (top entries):"
-  du -sh /opt/* 2>/dev/null | sort -h | head -n 20
-
-  if [ "$REMOVE_OPT" = "1" ]; then
-    OPT_TARGETS=(/opt/local-path-provisioner)
-    for t in "${OPT_TARGETS[@]}"; do
-      if [ -d "$t" ]; then
-        log "Removing $t as REMOVE_OPT=1"
-        rm -rf "$t"
-      fi
-    done
-  else
-    log "Automatic /opt removals disabled (set REMOVE_OPT=1 to enable)."
-  fi
+    log "/opt usage (top entries):"
+    du -sh /opt/* 2>/dev/null | sort -h | head -n 20
+    
+    if [ "$REMOVE_OPT" = "1" ]; then
+        OPT_TARGETS=(/opt/local-path-provisioner)
+        for t in "${OPT_TARGETS[@]}"; do
+            if [ -d "$t" ]; then
+                log "Removing $t as REMOVE_OPT=1"
+                rm -rf "$t"
+            fi
+        done
+    else
+        log "Automatic /opt removals disabled (set REMOVE_OPT=1 to enable)."
+    fi
 fi
 
 # 13) Find large files > 100MB (report only)
@@ -150,8 +173,10 @@ log "Listing files larger than 100MB (report only):"
 find / -xdev -type f -size +100M -printf '%s\t%p\n' 2>/dev/null | sort -nr | head -n 50 | awk '{printf "%.1fMB\t%s\n",$1/1024/1024,$2}'
 
 # Final disk usage
-log "Disk usage after cleanup:"
+log "Disk usage cleanup:"
 df -h
+log "Top-level usage ( / ):"
+du -xh --max-depth=1 / | sort -rh | head -n 20
 
 log "=== Cleanup finished ==="
 exit 0

package/scripts/test-monitor.sh

@@ -24,7 +24,7 @@ MODE=runtime                                  # runtime | instance
 ENV=development                               # development | production
 DEPLOY_ID=dd-test                             # deploy id (instance mode: parent of conf.instances.json)
 INSTANCE_IDS=                                 # instance mode: csv of ids (default: all in conf.instances.json)
-IMAGE=underpost/wp:v3.2.30                    # runtime mode image (instance mode reads image from conf)
+IMAGE=underpost/wp:v3.2.80                    # runtime mode image (instance mode reads image from conf)
 VERSIONS=green                                # csv of blue/green versions
 REPLICAS=1                                    # replicas per deployment
 NAMESPACE=default                             # k8s namespace

package/src/api/core/core.controller.js

@@ -1,69 +1,8 @@
-import { loggerFactory } from '../../server/logger.js';
+import { buildCrudController, serviceHandler } from '../../server/middlewares.js';
 import { CoreService } from './core.service.js';
 
-const logger = loggerFactory(import.meta);
-
-class CoreController {
-  static post = async (req, res, options) => {
-    try {
-      const result = await CoreService.post(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      const result = await CoreService.put(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static put = async (req, res, options) => {
-    try {
-      const result = await CoreService.get(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await CoreService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-}
+const CoreController = buildCrudController(CoreService, {
+  get: serviceHandler(CoreService.get),
+});
 
 export { CoreController };

package/src/api/core/core.router.js

@@ -1,9 +1,7 @@
+import express from 'express';
+import { registerCrudRoutes } from '../../server/middlewares.js';
 import { adminGuard } from '../../server/auth.js';
-import { loggerFactory } from '../../server/logger.js';
 import { CoreController } from './core.controller.js';
-import express from 'express';
-
-const logger = loggerFactory(import.meta);
 
 class CoreRouter {
   /**
@@ -11,16 +9,12 @@ class CoreRouter {
    * @returns {import('express').Router}
    */
   static router(options) {
-    const router = express.Router();
-    router.post(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-    router.post(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.post(req, res, options));
-    router.get(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-    router.get(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.get(req, res, options));
-    router.put(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-    router.put(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.put(req, res, options));
-    router.delete(`/:id`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-    router.delete(`/`, options.authMiddleware, adminGuard, async (req, res) => await CoreController.delete(req, res, options));
-    return router;
+    const adminOnly = [options.authMiddleware, adminGuard];
+    return registerCrudRoutes(express.Router(), CoreController, options, {
+      readGuards: adminOnly,
+      writeGuards: adminOnly,
+      deleteAllGuards: adminOnly,
+    });
   }
 }
 

package/src/api/default/default.controller.js

@@ -1,74 +1,6 @@
-import { loggerFactory } from '../../server/logger.js';
+import { buildCrudController } from '../../server/middlewares.js';
 import { DefaultService } from './default.service.js';
 
-const logger = loggerFactory(import.meta);
-
-class DefaultController {
-  static post = async (req, res, options) => {
-    try {
-      const result = await DefaultService.post(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      const { page, limit } = req.query;
-      const result = await DefaultService.get(
-        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
-        res,
-        options,
-      );
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static put = async (req, res, options) => {
-    try {
-      const result = await DefaultService.put(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await DefaultService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-}
+const DefaultController = buildCrudController(DefaultService);
 
 export { DefaultController };

package/src/api/default/default.router.js

@@ -1,8 +1,6 @@
-import { loggerFactory } from '../../server/logger.js';
-import { DefaultController } from './default.controller.js';
 import express from 'express';
-
-const logger = loggerFactory(import.meta);
+import { registerCrudRoutes } from '../../server/middlewares.js';
+import { DefaultController } from './default.controller.js';
 
 class DefaultRouter {
   /**
@@ -10,19 +8,11 @@ class DefaultRouter {
    * @returns {import('express').Router}
    */
   static router(options) {
-    const router = express.Router();
-    router.post(`/:id`, async (req, res) => await DefaultController.post(req, res, options));
-    router.post(`/`, async (req, res) => await DefaultController.post(req, res, options));
-    router.get(`/:id`,
-      // options.authMiddleware,
-      async (req, res) => await DefaultController.get(req, res, options),
-    );
-    router.get(`/`, async (req, res) => await DefaultController.get(req, res, options));
-    router.put(`/:id`, async (req, res) => await DefaultController.put(req, res, options));
-    router.put(`/`, async (req, res) => await DefaultController.put(req, res, options));
-    router.delete(`/:id`, async (req, res) => await DefaultController.delete(req, res, options));
-    router.delete(`/`, async (req, res) => await DefaultController.delete(req, res, options));
-    return router;
+    // Fully unguarded (matches prior behavior).
+    return registerCrudRoutes(express.Router(), DefaultController, options, {
+      writeGuards: [],
+      deleteAllGuards: [],
+    });
   }
 }
 

package/src/api/document/document.controller.js

@@ -1,81 +1,9 @@
-import { loggerFactory } from '../../server/logger.js';
+import { buildCrudController, serviceHandler } from '../../server/middlewares.js';
 import { DocumentService } from './document.service.js';
-const logger = loggerFactory(import.meta);
 
-class DocumentController {
-  static post = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await DocumentService.post(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await DocumentService.get(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await DocumentService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static put = async (req, res, options) => {
-    try {
-      const result = await DocumentService.put(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static patch = async (req, res, options) => {
-    try {
-      const result = await DocumentService.patch(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-}
+const DocumentController = buildCrudController(DocumentService, {
+  get: serviceHandler(DocumentService.get),
+  patch: serviceHandler(DocumentService.patch),
+});
 
 export { DocumentController };

package/src/api/document/document.router.js

@@ -1,8 +1,6 @@
-import { loggerFactory } from '../../server/logger.js';
-import { DocumentController } from './document.controller.js';
 import express from 'express';
-
-const logger = loggerFactory(import.meta);
+import { registerCrudRoutes } from '../../server/middlewares.js';
+import { DocumentController } from './document.controller.js';
 
 class DocumentRouter {
   /**
@@ -11,23 +9,21 @@ class DocumentRouter {
    */
   static router(options) {
     const router = express.Router();
-    router.post(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
-    router.post(`/`, options.authMiddleware, async (req, res) => await DocumentController.post(req, res, options));
+    const authOnly = [options.authMiddleware];
+    // Public listings — must come before the guarded generic /:id routes.
     router.get(`/public/high`, async (req, res) => await DocumentController.get(req, res, options));
     router.get(`/public`, async (req, res) => await DocumentController.get(req, res, options));
-    router.get(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
-    router.get(`/`, options.authMiddleware, async (req, res) => await DocumentController.get(req, res, options));
-    router.put(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
-    router.put(`/`, options.authMiddleware, async (req, res) => await DocumentController.put(req, res, options));
     router.patch(`/:id/copy-share-link`, async (req, res) => await DocumentController.patch(req, res, options));
     router.patch(
       `/:id/toggle-public`,
       options.authMiddleware,
       async (req, res) => await DocumentController.patch(req, res, options),
     );
-    router.delete(`/:id`, options.authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
-    router.delete(`/`, options.authMiddleware, async (req, res) => await DocumentController.delete(req, res, options));
-    return router;
+    return registerCrudRoutes(router, DocumentController, options, {
+      readGuards: authOnly,
+      writeGuards: authOnly,
+      deleteAllGuards: authOnly,
+    });
   }
 }
 

package/src/api/file/file.controller.js

@@ -1,59 +1,15 @@
-import { loggerFactory } from '../../server/logger.js';
+import { controllerHandler, sendSuccess, serviceHandler, setCrossOriginHeaders } from '../../server/middlewares.js';
 import { FileService } from './file.service.js';
-const logger = loggerFactory(import.meta);
 
 class FileController {
-  static post = async (req, res, options) => {
-    try {
-      return res.status(200).json({
-        status: 'success',
-        data: await FileService.post(req, res, options),
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static get = async (req, res, options) => {
-    try {
-      if (req && req.headers && req.headers.origin) {
-        res.set('Access-Control-Allow-Origin', req.headers.origin);
-      } else res.setHeader('Access-Control-Allow-Origin', '*');
-      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
-      const result = await FileService.get(req, res, options);
-      if (result instanceof Buffer) {
-        return res.status(200).end(result);
-      }
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
-  static delete = async (req, res, options) => {
-    try {
-      const result = await FileService.delete(req, res, options);
-      return res.status(200).json({
-        status: 'success',
-        data: result,
-      });
-    } catch (error) {
-      logger.error(error, error.stack);
-      return res.status(400).json({
-        status: 'error',
-        message: error.message,
-      });
-    }
-  };
+  static post = serviceHandler(FileService.post);
+  static get = controllerHandler(async (req, res, options) => {
+    setCrossOriginHeaders(req, res);
+    const result = await FileService.get(req, res, options);
+    if (result instanceof Buffer) return res.status(200).end(result);
+    return sendSuccess(res, result);
+  });
+  static delete = serviceHandler(FileService.delete);
 }
 
 export { FileController };