cyberia 3.2.5 → 3.2.9

package/scripts/nat-iptables.sh

@@ -1,26 +1,111 @@
 #!/bin/bash
 set -euo pipefail
 
-# Disable firewalld
-sudo systemctl disable --now iptables
-sudo systemctl disable --now ufw
-sudo systemctl disable --now firewalld
+echo "[INFO] Enabling firewalld..."
+sudo systemctl enable --now firewalld
 
+echo "[INFO] Configuring kernel networking..."
 
-# Remove any existing entries, then append exactly one
-sudo sed -i '/^net.ipv4.ip_forward/d' /etc/sysctl.conf
-sudo sed -i '/^net.ipv6.conf.all.forwarding/d' /etc/sysctl.conf
-echo "net.ipv4.ip_forward = 1"               | sudo tee -a /etc/sysctl.conf
-echo "net.ipv6.conf.all.forwarding = 1"       | sudo tee -a /etc/sysctl.conf
-# ---
+sudo tee /etc/sysctl.d/99-kubernetes.conf >/dev/null <<'EOF'
+# Kubernetes networking
+net.ipv4.ip_forward = 1
+net.ipv6.conf.all.forwarding = 1
 
-sudo sysctl -p
+# Required for Kubernetes iptables
+net.bridge.bridge-nf-call-iptables = 1
+net.bridge.bridge-nf-call-ip6tables = 1
 
-# Accept all traffic
-sudo iptables -P INPUT ACCEPT
-sudo iptables -P FORWARD ACCEPT
-sudo iptables -P OUTPUT ACCEPT
+# Better conntrack handling
+net.netfilter.nf_conntrack_max = 131072
+EOF
 
-# List iptables rules and forwarding flag
-sudo iptables -L -n
-sysctl net.ipv4.ip_forward net.ipv6.conf.all.forwarding
+# Load br_netfilter immediately
+sudo modprobe br_netfilter
+
+# Apply sysctl
+sudo sysctl --system
+
+echo "[INFO] Opening common WAN/public services..."
+
+# Public services
+sudo firewall-cmd --permanent --zone=public --add-service=ssh
+sudo firewall-cmd --permanent --zone=public --add-service=http
+sudo firewall-cmd --permanent --zone=public --add-service=https
+
+echo "[INFO] Opening Kubernetes control plane ports..."
+
+# Kubernetes API Server
+sudo firewall-cmd --permanent --zone=public --add-port=6443/tcp
+
+# etcd
+sudo firewall-cmd --permanent --zone=public --add-port=2379-2380/tcp
+
+# kubelet API
+sudo firewall-cmd --permanent --zone=public --add-port=10250/tcp
+
+# kube-scheduler
+sudo firewall-cmd --permanent --zone=public --add-port=10259/tcp
+
+# kube-controller-manager
+sudo firewall-cmd --permanent --zone=public --add-port=10257/tcp
+
+echo "[INFO] Opening Kubernetes networking ports..."
+
+# CoreDNS
+sudo firewall-cmd --permanent --zone=public --add-port=53/tcp
+sudo firewall-cmd --permanent --zone=public --add-port=53/udp
+
+# NodePort Services
+sudo firewall-cmd --permanent --zone=public --add-port=30000-32767/tcp
+sudo firewall-cmd --permanent --zone=public --add-port=30000-32767/udp
+
+# Calico VXLAN
+sudo firewall-cmd --permanent --zone=public --add-port=4789/udp
+
+# Calico BGP
+sudo firewall-cmd --permanent --zone=public --add-port=179/tcp
+
+# Calico Typha (required for multi-node Calico deployments)
+sudo firewall-cmd --permanent --zone=public --add-port=5473/tcp
+
+# Calico WireGuard (optional encrypted overlay)
+sudo firewall-cmd --permanent --zone=public --add-port=51820/udp
+sudo firewall-cmd --permanent --zone=public --add-port=51821/udp
+
+# Flannel VXLAN (UDP, required if using Flannel CNI)
+sudo firewall-cmd --permanent --zone=public --add-port=8472/udp
+
+# kube-proxy healthz
+sudo firewall-cmd --permanent --zone=public --add-port=10256/tcp
+
+# metrics-server
+sudo firewall-cmd --permanent --zone=public --add-port=4443/tcp
+
+echo "[INFO] Configuring trusted zone for inter-node pod/service CIDRs..."
+# Allow all traffic from the default pod CIDR and service CIDR so that
+# cross-node pod-to-pod and service routing works without explicit per-port rules.
+sudo firewall-cmd --permanent --zone=trusted --add-source=192.168.0.0/16
+sudo firewall-cmd --permanent --zone=trusted --add-source=10.96.0.0/12
+
+echo "[INFO] Enabling masquerade and forwarding..."
+
+sudo firewall-cmd --permanent --zone=public --add-masquerade
+
+echo "[INFO] Reloading firewall..."
+
+sudo firewall-cmd --reload
+
+echo
+echo "[INFO] Sysctl status:"
+sudo sysctl \
+  net.ipv4.ip_forward \
+  net.ipv6.conf.all.forwarding \
+  net.bridge.bridge-nf-call-iptables \
+  net.bridge.bridge-nf-call-ip6tables
+
+echo
+echo "[INFO] Firewall status:"
+sudo firewall-cmd --zone=public --list-all
+
+echo
+echo "[INFO] Kubernetes firewall configuration completed."

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.controller.js

@@ -3,8 +3,8 @@ import { AtlasSpriteSheetService } from './atlas-sprite-sheet.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const AtlasSpriteSheetController = {
-  blob: async (req, res, options) => {
+class AtlasSpriteSheetController {
+  static blob = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -23,8 +23,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  generate: async (req, res, options) => {
+  };
+  static generate = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.generate(req, res, options);
       return res.status(200).json({
@@ -38,8 +38,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  deleteByObjectLayerId: async (req, res, options) => {
+  };
+  static deleteByObjectLayerId = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.deleteByObjectLayerId(req, res, options);
       return res.status(200).json({
@@ -53,8 +53,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  post: async (req, res, options) => {
+  };
+  static post = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.post(req, res, options);
       return res.status(200).json({
@@ -68,8 +68,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -92,8 +92,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.put(req, res, options);
       return res.status(200).json({
@@ -107,8 +107,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await AtlasSpriteSheetService.delete(req, res, options);
       return res.status(200).json({
@@ -122,8 +122,8 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-  getMetadata: async (req, res, options) => {
+  };
+  static getMetadata = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -146,7 +146,7 @@ const AtlasSpriteSheetController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { AtlasSpriteSheetController };

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.model.js

@@ -3,9 +3,7 @@
  * @module src/api/atlas-sprite-sheet/atlas-sprite-sheet.model.js
  * @namespace CyberiaAtlasSpriteSheetModel
  */
-
 import { Schema, model, Types } from 'mongoose';
-
 /**
  * @typedef {Object} FrameMetadata
  * @property {number} x - X position in the atlas
@@ -25,7 +23,6 @@ const FrameMetadataSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} DirectionFrames
  * @property {FrameMetadata[]} up_idle - Up idle animation frames
@@ -71,7 +68,6 @@ const DirectionFramesSchema = new Schema(
   },
   { _id: false },
 );
-
 /**
  * @typedef {Object} AtlasSpriteSheet
  * @property {Types.ObjectId} fileId - Reference to File document (consolidated PNG)
@@ -81,6 +77,7 @@ const DirectionFramesSchema = new Schema(
  * @property {number} metadata.atlasWidth - Total atlas width in pixels
  * @property {number} metadata.atlasHeight - Total atlas height in pixels
  * @property {number} metadata.cellPixelDim - Pixel dimension of each cell
+ * @property {number} metadata.frame_duration - Duration of each frame in milliseconds
  * @property {DirectionFrames} metadata.frames - Frame positions in atlas by direction
  * @property {Date} createdAt - When the document was created
  * @property {Date} updatedAt - When the document was last updated
@@ -103,6 +100,7 @@ const AtlasSpriteSheetSchema = new Schema(
       atlasWidth: { type: Number, required: true, min: 1 },
       atlasHeight: { type: Number, required: true, min: 1 },
       cellPixelDim: { type: Number, required: true, min: 1, default: 20 },
+      frame_duration: { type: Number, min: 0, default: 100 },
       frames: { type: DirectionFramesSchema, required: true },
     },
   },
@@ -112,24 +110,19 @@ const AtlasSpriteSheetSchema = new Schema(
     toObject: { virtuals: true },
   },
 );
-
 // Indexes for efficient querying
 AtlasSpriteSheetSchema.index({ 'metadata.itemKey': 1 }, { unique: true });
 AtlasSpriteSheetSchema.index({ fileId: 1 });
-
 // Pre-save validation
 AtlasSpriteSheetSchema.pre('save', function () {
   if (!this.fileId || !this.metadata) {
     throw new Error('AtlasSpriteSheet missing required fields: fileId or metadata');
   }
 });
-
 const AtlasSpriteSheetModel = model('AtlasSpriteSheet', AtlasSpriteSheetSchema);
-
 const ProviderSchema = AtlasSpriteSheetSchema;
-
-const AtlasSpriteSheetDto = {
-  select: {
+class AtlasSpriteSheetDto {
+  static select = {
     get: () => {
       return {
         _id: 1,
@@ -151,12 +144,12 @@ const AtlasSpriteSheetDto = {
         'metadata.atlasWidth': 1,
         'metadata.atlasHeight': 1,
         'metadata.cellPixelDim': 1,
+        'metadata.frame_duration': 1,
         'metadata.frames': 1,
         createdAt: 1,
         updatedAt: 1,
       };
     },
-  },
-};
-
+  };
+}
 export { AtlasSpriteSheetSchema, AtlasSpriteSheetModel, ProviderSchema, AtlasSpriteSheetDto };

package/src/api/atlas-sprite-sheet/atlas-sprite-sheet.service.js

@@ -8,9 +8,51 @@ import { IpfsClient } from '../../server/ipfs-client.js';
 import { createPinRecord, removePinRecordsAndUnpin } from '../ipfs/ipfs.service.js';
 
 const logger = loggerFactory(import.meta);
-
-const AtlasSpriteSheetService = {
-  blob: async (req, res, options) => {
+const DEFAULT_ATLAS_FRAME_DURATION = 100;
+
+function parseAtlasFrameDuration(value) {
+  const frameDuration = Number(value);
+  return Number.isFinite(frameDuration) ? frameDuration : null;
+}
+
+async function resolveAtlasFrameDuration(ObjectLayer, itemKey) {
+  if (!itemKey) return DEFAULT_ATLAS_FRAME_DURATION;
+
+  const objectLayer = await ObjectLayer.findOne({ 'data.item.id': itemKey })
+    .select({ _id: 1, objectLayerRenderFramesId: 1 })
+    .populate('objectLayerRenderFramesId', { _id: 1, frame_duration: 1 })
+    .lean();
+
+  return (
+    parseAtlasFrameDuration(objectLayer?.objectLayerRenderFramesId?.frame_duration) || DEFAULT_ATLAS_FRAME_DURATION
+  );
+}
+
+async function withResolvedAtlasFrameDuration(doc, ObjectLayer) {
+  if (!doc?.metadata) return doc;
+
+  const frameDuration = parseAtlasFrameDuration(doc.metadata.frame_duration);
+  if (frameDuration !== null) {
+    return {
+      ...doc,
+      metadata: {
+        ...doc.metadata,
+        frame_duration: frameDuration,
+      },
+    };
+  }
+
+  return {
+    ...doc,
+    metadata: {
+      ...doc.metadata,
+      frame_duration: await resolveAtlasFrameDuration(ObjectLayer, doc.metadata.itemKey),
+    },
+  };
+}
+
+class AtlasSpriteSheetService {
+  static blob = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
@@ -25,8 +67,8 @@ const AtlasSpriteSheetService = {
     if (!fileDoc || !fileDoc.data) throw new Error(`File not found for atlas itemKey: ${itemKey}`);
 
     return { buffer: Buffer.from(fileDoc.data), mimetype: fileDoc.mimetype || 'image/png', name: fileDoc.name };
-  },
-  generate: async (req, res, options, generateOptions = {}) => {
+  };
+  static generate = async (req, res, options, generateOptions = {}) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
     /** @type {import('../file/file.model.js').FileModel} */
@@ -150,8 +192,8 @@ const AtlasSpriteSheetService = {
     await objectLayer.save();
 
     return atlasDoc;
-  },
-  deleteByObjectLayerId: async (req, res, options) => {
+  };
+  static deleteByObjectLayerId = async (req, res, options) => {
     /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
     const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
     /** @type {import('../file/file.model.js').FileModel} */
@@ -209,14 +251,14 @@ const AtlasSpriteSheetService = {
     }
 
     return { success: true };
-  },
-  post: async (req, res, options) => {
+  };
+  static post = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
     return await new AtlasSpriteSheet(req.body).save();
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
@@ -240,10 +282,12 @@ const AtlasSpriteSheetService = {
 
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
+  };
   // Returns atlas metadata (layout + frames) for the client.
   // Client fetches this once per itemKey, caches it, then fetches the PNG blob.
-  getMetadata: async (req, res, options) => {
+  static getMetadata = async (req, res, options) => {
+    /** @type {import('../object-layer/object-layer.model.js').ObjectLayerModel} */
+    const ObjectLayer = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.ObjectLayer;
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
@@ -253,7 +297,7 @@ const AtlasSpriteSheetService = {
         .select(AtlasSpriteSheetDto.select.getMetadataOnly())
         .lean();
       if (!doc) throw new Error(`Atlas not found for itemKey: ${req.params.itemKey}`);
-      return doc;
+      return await withResolvedAtlasFrameDuration(doc, ObjectLayer);
     }
 
     const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
@@ -269,15 +313,26 @@ const AtlasSpriteSheetService = {
     ]);
 
     const totalPages = Math.ceil(total / limit);
-    return { data, total, page, totalPages };
-  },
-  put: async (req, res, options) => {
+    return {
+      data: data.map((doc) => ({
+        ...doc,
+        metadata: {
+          ...doc.metadata,
+          frame_duration: parseAtlasFrameDuration(doc?.metadata?.frame_duration) || DEFAULT_ATLAS_FRAME_DURATION,
+        },
+      })),
+      total,
+      page,
+      totalPages,
+    };
+  };
+  static put = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
     return await AtlasSpriteSheet.findByIdAndUpdate(req.params.id, req.body);
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     /** @type {import('./atlas-sprite-sheet.model.js').AtlasSpriteSheetModel} */
     const AtlasSpriteSheet =
       DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.AtlasSpriteSheet;
@@ -329,7 +384,7 @@ const AtlasSpriteSheetService = {
       }
       return await AtlasSpriteSheet.deleteMany();
     }
-  },
-};
+  };
+}
 
 export { AtlasSpriteSheetService };

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

@@ -3,8 +3,8 @@ import { CoreService } from './core.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const CoreController = {
-  post: async (req, res, options) => {
+class CoreController {
+  static post = async (req, res, options) => {
     try {
       const result = await CoreService.post(req, res, options);
       return res.status(200).json({
@@ -18,8 +18,8 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       const result = await CoreService.put(req, res, options);
       return res.status(200).json({
@@ -33,8 +33,8 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await CoreService.get(req, res, options);
       return res.status(200).json({
@@ -48,8 +48,8 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await CoreService.delete(req, res, options);
       return res.status(200).json({
@@ -63,7 +63,7 @@ const CoreController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { CoreController };

package/src/api/core/core.service.js

@@ -4,27 +4,27 @@ import { shellExec } from '../../server/process.js';
 
 const logger = loggerFactory(import.meta);
 
-const CoreService = {
-  post: async (req, res, options) => {
+class CoreService {
+  static post = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
     const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
     return await new Core(req.body).save();
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
     const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
     return await Core.findById(req.params.id);
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
     const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
     return await Core.findByIdAndUpdate(req.params.id, req.body);
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     /** @type {import('./core.model.js').CoreModel} */
     const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
     return await Core.findByIdAndDelete(req.params.id);
-  },
-};
+  };
+}
 
 export { CoreService };

package/src/api/crypto/crypto.controller.js

@@ -2,8 +2,8 @@ import { loggerFactory } from '../../server/logger.js';
 import { CryptoService } from './crypto.service.js';
 const logger = loggerFactory(import.meta);
 
-const CryptoController = {
-  post: async (req, res, options) => {
+class CryptoController {
+  static post = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -16,8 +16,8 @@ const CryptoController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -30,8 +30,8 @@ const CryptoController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await CryptoService.delete(req, res, options);
       return res.status(200).json({
@@ -45,7 +45,7 @@ const CryptoController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { CryptoController };

package/src/api/crypto/crypto.service.js

@@ -3,8 +3,8 @@ import crypto from 'crypto';
 import { DataBaseProvider } from '../../db/DataBaseProvider.js';
 const logger = loggerFactory(import.meta);
 
-const CryptoService = {
-  post: async (req, res, options) => {
+class CryptoService {
+  static post = async (req, res, options) => {
     /** @type {import('./crypto.model.js').CryptoModel} */
     const Crypto = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Crypto;
     /** @type {import('../user/user.model.js').UserModel} */
@@ -48,17 +48,17 @@ const CryptoService = {
         return publicKey;
       }
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     switch (req.params.id) {
       default:
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     switch (req.params.id) {
       default:
     }
-  },
-};
+  };
+}
 
 export { CryptoService };