data-primals-engine 1.7.2 → 1.7.3

package/src/modules/data/data.replication.js

@@ -1,83 +1,125 @@
-// --- NOUVEAU FICHIER : src/modules/data/data.replication.js ---
-import { Event } from '../../events.js';
 import { Logger } from '../../gameObject.js';
-import { getResponsibleNodesForUser, isSelfMasterForUser } from './data.cluster.js';
+import { getReplicaNodesForUser } from './data.cluster.js';
+import process from "node:process";
 
-let logger;
+const logger = new Logger('DataReplication');
+const replicationQueue = [];
+const failedBatchesByReplica = new Map(); // Map<peerId, Array<chunk>>
+const BATCH_INTERVAL = 100; // Traiter la file toutes les 100ms
+const BATCH_SIZE_LIMIT = 50; // Envoyer un maximum de 50 opérations par requête de batch
+
+let intervalId = null;
+let engineInstance = null; // Pour stocker l'instance du moteur
 
 /**
- * Réplique une opération de données vers les nœuds répliques.
+ * Ajoute une tâche de réplication à la file d'attente.
+ * C'est le point d'entrée pour toutes les opérations de données.
  * @param {string} operation - 'insert', 'update', 'delete'
  * @param {string} modelName - Le nom du modèle.
  * @param {object} user - L'objet utilisateur.
  * @param {object} payload - Les données de l'opération.
  */
-async function replicateOperation(operation, modelName, user, payload) {
-    if (!isSelfMasterForUser(user.username)) {
-        // Seul le nœud maître est autorisé à initier une réplication.
+export function queueReplication(operation, modelName, user, payload) {
+    replicationQueue.push({ operation, modelName, user, payload, timestamp: new Date() });
+}
+
+/**
+ * Tente de renvoyer les lots qui ont précédemment échoué pour chaque réplique.
+ */
+async function retryFailedBatches() {
+    if (failedBatchesByReplica.size === 0) {
+        return;
+    }
+
+    logger.debug(`[ReplicationRetry] Checking ${failedBatchesByReplica.size} replica(s) for failed batches to retry.`);
+
+    for (const [peerId, batches] of failedBatchesByReplica.entries()) {
+        if (batches.length > 0) {
+            const batchToRetry = batches.shift(); // On prend le plus ancien lot en échec
+            logger.info(`[ReplicationRetry] Retrying to send batch of ${batchToRetry.length} operations to replica peer ${peerId}`);
+
+            try {
+                await engineInstance.sendToPeer(peerId, '/api/internal/replicate', { operations: batchToRetry });
+                // Si l'envoi réussit, le lot est retiré de la file. Sinon, il reste pour le prochain essai.
+            } catch (error) {
+                logger.error(`[ReplicationRetry] Retry failed for peer ${peerId}: ${error.message}. Re-queuing batch.`);
+                batches.unshift(batchToRetry); // On le remet au début pour réessayer plus tard
+            }
+        }
+    }
+}
+/**
+ * Traite la file d'attente, groupe les opérations par réplique et les envoie en lots.
+ */
+async function processReplicationQueue() {
+    // Si les instances partagent la même base de données, la réplication est inutile.
+    if (process.env.CLUSTER_SHARED_DATABASE === 'true') {
+        if (replicationQueue.length > 0) replicationQueue.length = 0;
         return;
     }
 
-    const nodes = getResponsibleNodesForUser(user.username);
-    const replicas = nodes.slice(1); // Tous les nœuds sauf le premier (le maître)
+    // D'abord, on essaie de vider les anciennes tâches en échec
+    await retryFailedBatches();
 
-    if (replicas.length === 0) {
-        return; // Pas de répliques à notifier.
+    if (replicationQueue.length === 0) {
+        return;
     }
 
-    logger.debug(`[Replication] Replicating '${operation}' on model '${modelName}' for user '${user.username}' to replicas: ${replicas.join(', ')}`);
-
-    const replicationPayload = {
-        operation,
-        modelName,
-        user: { username: user.username, _user: user._user }, // Envoyer juste l'essentiel
-        payload
-    };
-
-    const promises = replicas.map(replicaUrl => {
-        const targetUrl = `${replicaUrl}/api/internal/replicate`;
-        const authToken = process.env.INTERNAL_CLUSTER_TOKEN ? `Bearer ${process.env.INTERNAL_CLUSTER_TOKEN}` : null;
-
-        return fetch(targetUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': authToken
-            },
-            body: JSON.stringify(replicationPayload)
-        }).catch(err => {
-            logger.error(`[Replication] Failed to replicate to ${replicaUrl}: ${err.message}`);
-        });
-    });
-
-    // On ne bloque pas la réponse à l'utilisateur, la réplication est asynchrone.
-    Promise.allSettled(promises);
+    const itemsToProcess = replicationQueue.splice(0, replicationQueue.length);
+    logger.debug(`[ReplicationQueue] Processing ${itemsToProcess.length} items.`);
+
+    // Regrouper les opérations par ID de nœud de réplique
+    const batchesByReplica = new Map();
+
+    for (const item of itemsToProcess) {
+        // Pour chaque opération, on trouve les nœuds de réplique responsables
+        const replicaNodes = getReplicaNodesForUser(item.user.username);
+
+        for (const replica of replicaNodes) {
+            if (!batchesByReplica.has(replica.id)) {
+                batchesByReplica.set(replica.id, []);
+            }
+            batchesByReplica.get(replica.id).push(item);
+        }
+    }
+
+    // Envoyer les lots à chaque réplique concernée
+    for (const [peerId, operations] of batchesByReplica.entries()) {
+        for (let i = 0; i < operations.length; i += BATCH_SIZE_LIMIT) {
+            const chunk = operations.slice(i, i + BATCH_SIZE_LIMIT);
+
+            logger.info(`[ReplicationBatch] Sending batch of ${chunk.length} operations to replica peer ${peerId}`);
+
+            try {
+                await engineInstance.sendToPeer(peerId, '/api/internal/replicate', { operations: chunk });
+            } catch (error) {
+                logger.error(`[ReplicationBatch] Failed to send batch to replica peer ${peerId}: ${error.message}. Queueing for retry.`);
+                // En cas d'échec, on ajoute le lot à la file d'attente des échecs pour cette réplique
+                if (!failedBatchesByReplica.has(peerId)) failedBatchesByReplica.set(peerId, []);
+                failedBatchesByReplica.get(peerId).push(chunk);
+            }
+        }
+    }
 }
 
+/**
+ * Démarre le processeur de la file d'attente de réplication.
+ * @param {object} engine - L'instance du moteur.
+ */
 export function onInit(engine) {
-    logger = engine.getComponent(Logger);
-
-    // Écouter les événements de modification de données
-    Event.Listen("OnDataAdded", (eng, { modelName, insertedDocs, user }) => {
-        replicateOperation('insert', modelName, user, { data: insertedDocs });
-    }, "event", "system");
-
-    Event.Listen("OnDataEdited", (eng, { modelName, user, after }) => {
-        // Pour une mise à jour, on a besoin du filtre et des données modifiées.
-        // C'est un peu plus complexe car l'événement ne fournit pas le filtre original.
-        // Pour une réplication simple, on peut envoyer l'ID et le payload de mise à jour.
-        after.forEach(doc => {
-            replicateOperation('update', modelName, user, {
-                filter: { _id: doc._id.toString() },
-                data: doc // Envoyer le document complet est plus simple pour la réplique.
-            });
-        });
-    }, "event", "system");
-
-    Event.Listen("OnDataDeleted", (eng, { modelName, user, before }) => {
-        const idsToDelete = before.map(doc => doc._id.toString());
-        replicateOperation('delete', modelName, user, { ids: idsToDelete });
-    }, "event", "system");
-
-    logger.info("Replication module initialized and listening for data events.");
+    engineInstance = engine; // Stocker l'instance du moteur
+    if (engineInstance.peers.length > 1) {
+        intervalId = setInterval(processReplicationQueue, BATCH_INTERVAL);
+        logger.info(`Replication Queue processor started with a ${BATCH_INTERVAL}ms interval.`);
+    }
+}
+
+/**
+ * Arrête le processeur de la file d'attente.
+ */
+export function stopReplicationQueue() {
+    if (intervalId) {
+        clearInterval(intervalId);
+        logger.info('Replication Queue processor stopped.');
+    }
 }

package/src/modules/data/data.routes.js

@@ -3,10 +3,9 @@ import {ObjectId} from "mongodb";
 import * as util from 'node:util';
 import {setTimeoutMiddleware} from '../../middlewares/timeout.js';
 import {isDemoUser, isLocalUser} from "../../data.js";
-import {
-    getHost, 
+import { 
+    getHost,
     install,
-    clusterPeers, // Importer la configuration du cluster
     maxBytesPerSecondThrottleData,
     maxMagnetsDataPerModel,
     maxMagnetsModels,
@@ -28,7 +27,7 @@ import {tutorialsConfig} from "../../../client/src/tutorials.js";
 import {getResource, handleDemoInitialization} from "./data.js";
 import process from "node:process"; 
 import {throttleMiddleware} from "../../middlewares/throttle.js";
-import {modelsCache} from "./data.core.js";
+import {modelsCache, runImportExportWorker} from "./data.core.js";
 import {validateModelData, validateModelStructure} from "./data.validation.js";
 import {
     deleteData,
@@ -45,8 +44,8 @@ import {
 } from "./data.operations.js";
 import { dumpUserData, loadFromDump } from "./data.backup.js";
 import { invalidateModelCache } from "./data.operations.js";
-import { findFirstAvailableProvider, getAIProvider } from "../assistant/providers.js";
-import { isProxiedRequest, proxyRequest } from './data.cluster.js';
+import { findFirstAvailableProvider, getAIProvider } from '../assistant/providers.js';
+import { isProxiedRequest, proxyRequest, onInit as clusterInit } from './data.cluster.js';
 import {providers} from "../assistant/constants.js";
 
 let logger, engine;
@@ -442,6 +441,8 @@ export async function registerRoutes(defaultEngine){
     engine = defaultEngine;
     logger = engine.getComponent(Logger);
 
+    clusterInit(engine);
+
     // NOUVEAU : Initialisation du scaling SSE (via MongoDB Change Streams)
     initializeSseScaling();
 
@@ -460,66 +461,61 @@ export async function registerRoutes(defaultEngine){
     };
 
     engine.post('/api/internal/replicate', [internalAuth], async (req, res) => {
-        const { operation, modelName, user, payload } = req.fields;
-        logger.info(`[Replication] Received replication job: ${operation} on ${modelName} for ${user.username}`);
+        const { operations } = req.fields; // Le corps contient maintenant un tableau d'opérations
+        if (!Array.isArray(operations)) {
+            return res.status(400).json({ success: false, error: 'Expected an array of operations.' });
+        }
 
-        try {
-            // IMPORTANT: Le dernier paramètre `false` désactive le déclenchement de workflow
-            // pour éviter une boucle de réplication infinie.
-            const collection = await getCollectionForUser(user);
-
-            switch (operation) {
-            case 'insert':
-                // --- LWW: On ne fait l'insert que si le document n'existe pas déjà ---
-                // On vérifie si un document avec le même hash existe déjà.
-                const incomingDoc = payload.data[0];
-                const existingDoc = await collection.findOne({ _hash: incomingDoc._hash, _model: modelName, _user: user.username });
-                const incomingTimestampInsert = new Date(incomingDoc._lastModifiedAt);
-
-                if (existingDoc && new Date(existingDoc._lastModifiedAt) >= incomingTimestampInsert) {
-                    // Une version plus récente ou identique existe déjà, on ignore l'insert.
-                    logger.warn(`[Replication-LWW] Stale insert for ${modelName} with hash ${incomingDoc._hash} ignored. Local: ${existingDoc._lastModifiedAt.toISOString()}, Incoming: ${incomingTimestampInsert.toISOString()}`);
-                } else if (existingDoc) {
-                    // Une version plus ancienne existe, on la remplace.
-                    await collection.replaceOne({ _id: existingDoc._id }, incomingDoc);
-                } else {
-                    await collection.insertOne(incomingDoc);
+        logger.info(`[Replication] Received batch of ${operations.length} replication jobs.`);
+
+        for (const { operation, modelName, user, payload } of operations) {
+            try {
+                const collection = await getCollectionForUser(user);
+
+                switch (operation) {
+                case 'insert': {
+                    const incomingDoc = Array.isArray(payload.data) ? payload.data[0] : payload.data;
+                    if (!incomingDoc) continue;
+                    const existingDoc = await collection.findOne({ _hash: incomingDoc._hash, _model: modelName, _user: user.username });
+                    const incomingTimestampInsert = new Date(incomingDoc._lastModifiedAt);
+
+                    if (existingDoc && new Date(existingDoc._lastModifiedAt) >= incomingTimestampInsert) {
+                        logger.warn(`[Replication-LWW] Stale insert for ${modelName} with hash ${incomingDoc._hash} ignored. Local: ${existingDoc._lastModifiedAt.toISOString()}, Incoming: ${incomingTimestampInsert.toISOString()}`);
+                    } else if (existingDoc) {
+                        await collection.replaceOne({ _id: existingDoc._id }, incomingDoc);
+                    } else {
+                        await collection.insertOne(incomingDoc);
+                    }
+                    break;
                 }
-                break;
-            case 'update':
-                // --- LWW: Logique de comparaison des timestamps ---
-                const docToUpdate = await collection.findOne(payload.filter);
-                const incomingTimestamp = new Date(payload.data._lastModifiedAt);
-
-                if (!docToUpdate) {
-                    // Si le document n'existe pas localement, on le crée.
-                    // Cela peut arriver si des réplications arrivent dans le désordre.
-                    logger.info(`[Replication-LWW] Document ${payload.filter._id} not found locally. Inserting replicated version.`);
-                    await pushDataUnsecure([payload.data], modelName, user, {});
-                } else if (docToUpdate._lastModifiedAt && new Date(docToUpdate._lastModifiedAt) >= incomingTimestamp) {
-                    // La version locale est plus récente ou identique. On ignore la réplication.
-                    logger.warn(`[Replication-LWW] Stale update for ${modelName}:${payload.filter._id} ignored. Local: ${docToUpdate._lastModifiedAt.toISOString()}, Incoming: ${incomingTimestamp.toISOString()}`);
-                } else {
-                    // La version entrante est plus récente. On applique la mise à jour.
-                    // On utilise une opération de bas niveau pour éviter de redéclancher toute la logique de editData.
-                    await collection.replaceOne(payload.filter, payload.data);
+                case 'update': {
+                    const docToUpdate = await collection.findOne(payload.filter);
+                    const incomingTimestamp = new Date(payload.data._lastModifiedAt);
+
+                    if (!docToUpdate) {
+                        logger.info(`[Replication-LWW] Document for update not found locally. Inserting replicated version.`);
+                        await collection.insertOne(payload.data);
+                    } else if (docToUpdate._lastModifiedAt && new Date(docToUpdate._lastModifiedAt) >= incomingTimestamp) {
+                        logger.warn(`[Replication-LWW] Stale update for ${modelName}:${payload.filter._id} ignored. Local: ${docToUpdate._lastModifiedAt.toISOString()}, Incoming: ${incomingTimestamp.toISOString()}`);
+                    } else {
+                        await collection.replaceOne(payload.filter, payload.data);
+                    }
+                    break;
+                }
+                case 'delete':
+                    // La suppression l'emporte toujours.
+                    await deleteData(modelName, payload.ids, user, false, false);
+                    break;
+                default:
+                    logger.error(`[Replication] Unknown replication operation in batch: ${operation}`);
                 }
-                break;
-            case 'delete':
-                // --- LWW: Pour la suppression, on peut la considérer comme l'état final ---
-                // Si un document a été supprimé sur le maître, il doit l'être partout,
-                // même si une réplique a une version "plus récente" (ce qui serait un état incohérent).
-                // La suppression l'emporte.
-                await deleteData(modelName, payload.ids, user, false, false);
-                break;
-            default:
-                throw new Error(`Unknown replication operation: ${operation}`);
+            } catch (error) {
+                logger.error(`[Replication] Failed to apply one job from batch: ${operation} on ${modelName}. Error: ${error.message}`);
+                // On continue avec les autres opérations du lot.
             }
-            res.status(200).json({ success: true });
-        } catch (error) {
-            logger.error(`[Replication] Failed to apply replication job: ${error.message}`, error.stack);
-            res.status(500).json({ success: false, error: error.message });
         }
+
+        res.status(200).json({ success: true, message: 'Batch processed.' });
     });
 
     // NOUVEL ENDPOINT : Invalidation de cache interne au cluster
@@ -807,6 +803,33 @@ export async function registerRoutes(defaultEngine){
         });
     });
 
+    engine.delete('/api/import/job/:jobId', [middlewareAuthenticator], async (req, res) => {
+        const { jobId } = req.params;
+        const user = req.me;
+
+        if (!isObjectId(jobId)) {
+            return res.status(400).json({ success: false, error: 'Invalid Job ID format.' });
+        }
+
+        try {
+            const importJobsCollection = getCollection('import_jobs');
+            const result = await importJobsCollection.deleteOne({
+                _id: new ObjectId(jobId),
+                userId: user.username // Security check: user can only delete their own jobs
+            });
+
+            if (result.deletedCount === 1) {
+                res.status(200).json({ success: true, message: 'Job deleted successfully.' });
+            } else {
+                res.status(404).json({ success: false, error: 'Job not found or you do not have permission to delete it.' });
+            }
+        } catch (error) {
+            logger.error(`[DELETE /api/import/job] Error deleting job ${jobId}:`, error);
+            res.status(500).json({ success: false, error: 'An internal server error occurred.' });
+        }
+    });
+
+
     engine.get('/api/alerts/subscribe', [middlewareAuthenticator], (req, res) => {
         const user = req.me;
 
@@ -833,9 +856,9 @@ export async function registerRoutes(defaultEngine){
     engine.post('/api/data/import', [middlewareAuthenticator, userInitiator, ...userMiddlewares, setTimeoutMiddleware(60000)], async (req, res) => {
         // ... (vérifications de permissions existantes) ...
         const result = await importData(req.fields, req.files, req.me);
-        if( result.success ){
-            res.status(202).json(result);
-        }else{
+        if (result.success) {
+            res.status(200).json(result); // Changed from 202 to 200
+        } else {
             res.status(500).json(result);
         }
     });

package/src/modules/data/data.scheduling.js

@@ -5,7 +5,7 @@ import {ObjectId} from "mongodb";
 import {getSmtpConfig} from "../user.js";
 import {runScheduledJobWithDbLock, substituteVariables} from "../workflow.js";
 import i18n from "../../i18n.js";
-import {sendEmail} from "../../email.js";
+import {changeLanguage, sendEmail} from "../../email.js";
 import {sendSseToUser} from "./data.routes.js";
 
 import {searchData} from "./data.operations.js";
@@ -101,6 +101,7 @@ export async function runStatefulAlertJob(alertId) {
                             });
                         }
 
+                        await changeLanguage(userLang);
                         await sendEmail(
                             user.email,
                             {