Update central/src/index.js

central/src/index.js

@@ -11,13 +11,9 @@ const PQueue = require('p-queue').default;
 const os = require('os');
 const winston = require('winston');
 
-// Charger settings.json (chemin relatif à ce fichier)
-const settingsPath = path.join(__dirname, '../settings.json');
-const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+const settings = JSON.parse(fs.readFileSync(path.join(__dirname, '../settings.json'), 'utf8'));
 
-// ──────────────────────────────────────────────
-// Logger
-// ──────────────────────────────────────────────
+// Logger configuration
 const logger = winston.createLogger({
   level: 'info',
   format: winston.format.combine(
@@ -30,65 +26,31 @@ const logger = winston.createLogger({
   ]
 });
 
-// ──────────────────────────────────────────────
-// Métriques & État
-// ──────────────────────────────────────────────
+// Metrics storage
 const metrics = {
-  requests: [],
+  requests: [], // { timestamp, ip, duration, sourceLang, targetLang, inputText, outputText }
   cpuHistory: [],
   ramHistory: [],
-  workers: new Map()
+  workers: new Map() // workerId -> { id, ws, cpu, ram, lastHeartbeat, jobsActive }
 };
 
+// Job queue (local processing + worker dispatch)
 const localQueue = new PQueue({ concurrency: settings.maxLocalJobs });
-const workerQueue = new PQueue({ concurrency: 10 });
-const pendingJobs = new Map();
-
-// ──────────────────────────────────────────────
-// Helpers CPU / RAM (Machine complète)
-// ──────────────────────────────────────────────
-function getSystemCpuPercent() {
-  // Utilise load average 1min normalisé par nb cœurs (non-bloquant, pas besoin de double mesure)
-  const cpus = os.cpus();
-  const load1 = os.loadavg()[0];
-  return Math.min(100, (load1 / cpus.length) * 100);
-}
-
-function getSystemRamUsed() {
-  return os.totalmem() - os.freemem();
-}
-
-// ──────────────────────────────────────────────
-// Collecte métriques (1s)
-// ──────────────────────────────────────────────
-setInterval(() => {
-  const now = Date.now();
-  const cpu = getSystemCpuPercent();
-  const ramUsed = getSystemRamUsed();
+const workerQueue = new PQueue({ concurrency: 10 }); // dispatch to workers
 
-  metrics.cpuHistory.push({ timestamp: now, cpu: Math.round(cpu * 10) / 10 });
-  metrics.ramHistory.push({ timestamp: now, used: ramUsed, total: os.totalmem() });
-
-  const cutoff = now - settings.metricsWindowSeconds * 1000;
-  metrics.cpuHistory = metrics.cpuHistory.filter(m => m.timestamp > cutoff);
-  metrics.ramHistory = metrics.ramHistory.filter(m => m.timestamp > cutoff);
-  metrics.requests = metrics.requests.filter(m => m.timestamp > cutoff);
-}, 1000);
-
-// ──────────────────────────────────────────────
-// Express + WS
-// ──────────────────────────────────────────────
+// Express app
 const app = express();
 const server = http.createServer(app);
-const wss = new WebSocketServer({ server });
 
-const ADMIN_CODE = process.env.ADMIN_ACCESS_CODE;
-if (!ADMIN_CODE) logger.warn('⚠️ ADMIN_ACCESS_CODE non défini dans .env');
+// WebSocket server for workers
+const wss = new WebSocketServer({ server });
 
+// Middleware
 app.use(cors());
 app.use(express.json({ limit: '10mb' }));
 app.use(express.static(path.join(__dirname, '../../public')));
 
+// Rate limiting
 const limiter = rateLimit({
   windowMs: settings.rateLimit.windowMs,
   max: settings.rateLimit.maxRequestsPerMinutePerIP,
@@ -99,31 +61,52 @@ const limiter = rateLimit({
 });
 app.use('/translate', limiter);
 
+// Admin authentication middleware
 const adminAuth = (req, res, next) => {
+  const adminCode = process.env.ADMIN_ACCESS_CODE;
   const providedCode = req.headers['x-admin-code'] || req.query.admin_code;
-  if (!ADMIN_CODE || providedCode !== ADMIN_CODE) {
+  if (!adminCode || providedCode !== adminCode) {
     return res.status(401).json({ error: 'Code admin invalide' });
   }
   next();
 };
 
-// ──────────────────────────────────────────────
-// Traduction
-// ──────────────────────────────────────────────
-const translate = require('@vitalets/google-translate-api').default;
+// Load translation function
+const translate = require('@vitalets/google-translate-api');
 
-async function translateText(text, source, target) {
-  const res = await translate(text, { from: source, to: target });
-  return res.text;
-}
+// Metrics collection
+setInterval(() => {
+  const cpuUsage = process.cpuUsage();
+  const memUsage = process.memoryUsage();
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+  
+  metrics.cpuHistory.push({ timestamp: Date.now(), cpu: cpuUsage.user + cpuUsage.system });
+  metrics.ramHistory.push({ timestamp: Date.now(), used: totalMem - freeMem, total: totalMem });
+  
+  // Keep only last metricsWindowSeconds
+  const cutoff = Date.now() - settings.metricsWindowSeconds * 1000;
+  metrics.cpuHistory = metrics.cpuHistory.filter(m => m.timestamp > cutoff);
+  metrics.ramHistory = metrics.ramHistory.filter(m => m.timestamp > cutoff);
+  metrics.requests = metrics.requests.filter(m => m.timestamp > cutoff);
+}, 1000);
 
-// ──────────────────────────────────────────────
-// WebSocket Workers
-// ──────────────────────────────────────────────
+// Clean up inactive workers
+setInterval(() => {
+  const now = Date.now();
+  for (const [id, worker] of metrics.workers) {
+    if (now - worker.lastHeartbeat > 15000) {
+      logger.info(`Worker ${id} disconnected (timeout)`);
+      metrics.workers.delete(id);
+    }
+  }
+}, 5000);
+
+// WebSocket handling for workers
 wss.on('connection', (ws, req) => {
   const workerId = uuidv4();
-  logger.info(`Worker connecté: ${workerId}`);
-
+  logger.info(`Worker connected: ${workerId}`);
+  
   const worker = {
     id: workerId,
     ws,
@@ -131,144 +114,107 @@ wss.on('connection', (ws, req) => {
     ram: 0,
     lastHeartbeat: Date.now(),
     jobsActive: 0,
-    maxJobs: settings.workerMaxJobs || 2
+    maxJobs: 2
   };
   metrics.workers.set(workerId, worker);
-
-  ws.send(JSON.stringify({
-    type: 'welcome',
-    workerId,
-    maxConcurrentJobs: worker.maxJobs
-  }));
-
+  
   ws.on('message', (data) => {
     try {
       const msg = JSON.parse(data);
       handleWorkerMessage(workerId, msg);
     } catch (e) {
-      logger.error('Message worker invalide', { workerId, error: e.message });
+      logger.error('Invalid worker message', e);
     }
   });
-
-  const cleanup = () => {
-    // Réveiller les jobs en attente pour qu'ils basculent en local
-    for (const [jobId, pending] of pendingJobs) {
-      if (pending.workerId === workerId) {
-        clearTimeout(pending.timeout);
-        pending.reject(new Error('Worker déconnecté'));
-        pendingJobs.delete(jobId);
-      }
-    }
+  
+  ws.on('close', () => {
+    logger.info(`Worker disconnected: ${workerId}`);
     metrics.workers.delete(workerId);
-    logger.info(`Worker déconnecté: ${workerId}`);
-  };
-
-  ws.on('close', cleanup);
+  });
+  
   ws.on('error', (err) => {
-    logger.error(`Erreur worker ${workerId}`, err);
-    cleanup();
+    logger.error(`Worker ${workerId} error`, err);
   });
+  
+  // Send welcome message with config
+  ws.send(JSON.stringify({
+    type: 'welcome',
+    workerId,
+    maxConcurrentJobs: 2
+  }));
 });
 
 function handleWorkerMessage(workerId, msg) {
   const worker = metrics.workers.get(workerId);
   if (!worker) return;
-
+  
   switch (msg.type) {
     case 'heartbeat':
       worker.lastHeartbeat = Date.now();
-      worker.cpu = msg.cpu ?? 0;
-      worker.ram = msg.ram ?? 0;
-      worker.jobsActive = msg.jobsActive ?? 0;
+      worker.cpu = msg.cpu || 0;
+      worker.ram = msg.ram || 0;
+      worker.jobsActive = msg.jobsActive || 0;
       break;
-
     case 'result':
+      // Job completed by worker
       if (msg.jobId) {
+        // Find and resolve the waiting promise
         const pending = pendingJobs.get(msg.jobId);
         if (pending) {
-          clearTimeout(pending.timeout);
           pending.resolve(msg.result);
-          pendingJobs.delete(jobId);
+          pendingJobs.delete(msg.jobId);
         }
-        worker.jobsActive = Math.max(0, worker.jobsActive - 1);
       }
+      worker.jobsActive = Math.max(0, worker.jobsActive - 1);
       break;
-
     case 'log':
-      logger.info(`[Worker ${workerId.substring(0,8)}] ${msg.message}`);
+      logger.info(`Worker ${workerId} log: ${msg.message}`);
       break;
   }
 }
 
-// ──────────────────────────────────────────────
-// Dispatch vers worker
-// ──────────────────────────────────────────────
-function findAvailableWorker() {
-  for (const [, worker] of metrics.workers) {
-    if (worker.ws.readyState === 1 && worker.jobsActive < worker.maxJobs) {
-      return worker;
-    }
-  }
-  return null;
-}
-
-function dispatchToWorker(worker, job) {
-  return new Promise((resolve, reject) => {
-    const jobId = uuidv4();
-    const timeout = setTimeout(() => {
-      pendingJobs.delete(jobId);
-      worker.jobsActive = Math.max(0, worker.jobsActive - 1);
-      reject(new Error('Worker timeout (30s)'));
-    }, 30000);
+// Pending jobs waiting for worker results
+const pendingJobs = new Map();
 
-    pendingJobs.set(jobId, { resolve, reject, timeout, workerId: worker.id });
+// API Routes
 
-    worker.ws.send(JSON.stringify({
-      type: 'translate',
-      jobId,
-      ...job
-    }));
-    worker.jobsActive++;
-  });
-}
-
-// ──────────────────────────────────────────────
-// Routes API
-// ──────────────────────────────────────────────
+// Health check
 app.get('/api/health', (req, res) => {
   res.json({ status: 'ok', uptime: process.uptime() });
 });
 
+// Translate endpoint
 app.post('/translate', async (req, res) => {
   const startTime = Date.now();
   const { text, source = 'auto', target = 'fr' } = req.body;
   const ip = req.ip;
-
+  
   if (!text || typeof text !== 'string') {
     return res.status(400).json({ error: 'Texte requis' });
   }
+  
   if (text.length > 5000) {
     return res.status(400).json({ error: 'Texte trop long (max 5000 caractères)' });
   }
-
+  
   try {
-    let translatedText;
-    const worker = findAvailableWorker();
-
-    if (worker) {
-      try {
-        const result = await dispatchToWorker(worker, { text, source, target });
-        translatedText = result.translatedText ?? result;
-      } catch (workerErr) {
-        logger.warn(`Worker échoué, fallback local: ${workerErr.message}`);
-        translatedText = await localQueue.add(() => translateText(text, source, target));
-      }
+    // Try to dispatch to available worker first
+    let result;
+    const availableWorker = findAvailableWorker();
+    
+    if (availableWorker) {
+      result = await dispatchToWorker(availableWorker, { text, source, target });
     } else {
-      translatedText = await localQueue.add(() => translateText(text, source, target));
+      // Process locally
+      result = await localQueue.add(() => translateText(text, source, target));
     }
-
+    
     const duration = Date.now() - startTime;
-
+    
+    // Extract translated text from worker result object if needed
+    const translatedText = result.translatedText || result;
+    
+    // Log request
     metrics.requests.push({
       timestamp: Date.now(),
       ip,
@@ -278,18 +224,46 @@ app.post('/translate', async (req, res) => {
       inputText: text.substring(0, 100),
       outputText: translatedText.substring(0, 100)
     });
-
+    
     res.json({ translatedText, source, target, duration });
   } catch (error) {
-    logger.error('Erreur traduction', { error: error.message, stack: error.stack });
+    logger.error('Translation error', error);
     res.status(500).json({ error: 'Erreur de traduction' });
   }
 });
 
-// ──────────────────────────────────────────────
-// Admin API — FORMAT COMPATIBLE FRONTEND
-// ──────────────────────────────────────────────
-app.get('/admin', (req, res) => {
+function translateText(text, source, target) {
+  return translate(text, { from: source, to: target }).then(res => res.text);
+}
+
+function findAvailableWorker() {
+  for (const [id, worker] of metrics.workers) {
+    if (worker.jobsActive < worker.maxJobs && worker.ws.readyState === 1) {
+      return worker;
+    }
+  }
+  return null;
+}
+
+function dispatchToWorker(worker, job) {
+  return new Promise((resolve, reject) => {
+    const jobId = uuidv4();
+    pendingJobs.set(jobId, { resolve, reject, timeout: setTimeout(() => {
+      pendingJobs.delete(jobId);
+      reject(new Error('Worker timeout'));
+    }, 30000) });
+    
+    worker.ws.send(JSON.stringify({
+      type: 'translate',
+      jobId,
+      ...job
+    }));
+    worker.jobsActive++;
+  });
+}
+
+// Admin dashboard routes
+app.get('/admin', adminAuth, (req, res) => {
   res.sendFile(path.join(__dirname, '../../public/admin.html'));
 });
 
@@ -305,24 +279,18 @@ app.get('/api/admin/metrics', adminAuth, (req, res) => {
       lastHeartbeat: w.lastHeartbeat
     });
   }
-
-  // Point "maintenant" pour les graphiques (évite le trou de 1s)
-  const currentCpu = getSystemCpuPercent();
-  const currentRam = getSystemRamUsed();
-
+  
   res.json({
     workers,
     cpuHistory: metrics.cpuHistory,
     ramHistory: metrics.ramHistory,
-    requests: metrics.requests.slice(-200),
-    requestRate: calculateRequestRate(),
-    // Requis par le frontend pour courbes fluides
-    currentCpu: Math.round(currentCpu * 10) / 10,
-    currentRam: currentRam
+    requests: metrics.requests.slice(-200), // Last 200 requests
+    requestRate: calculateRequestRate()
   });
 });
 
 app.get('/api/admin/logs', adminAuth, (req, res) => {
+  // Return recent logs from metrics.requests
   const logs = metrics.requests.slice(-100).map(r => ({
     timestamp: r.timestamp,
     ip: r.ip,
@@ -337,33 +305,25 @@ app.get('/api/admin/logs', adminAuth, (req, res) => {
 
 function calculateRequestRate() {
   const now = Date.now();
-  return metrics.requests.filter(r => r.timestamp > now - 120000).length;
+  const windowMs = 120000; // 2 minutes
+  const recent = metrics.requests.filter(r => r.timestamp > now - windowMs);
+  return recent.length;
 }
 
-// ──────────────────────────────────────────────
-// Pages statiques
-// ──────────────────────────────────────────────
-app.get('/', (req, res) => res.sendFile(path.join(__dirname, '../../public/index.html')));
-app.get('/wiki', (req, res) => res.sendFile(path.join(__dirname, '../../public/wiki.html')));
+// Main page
+app.get('/', (req, res) => {
+  res.sendFile(path.join(__dirname, '../../public/index.html'));
+});
 
-// ──────────────────────────────────────────────
-// Nettoyage workers inactifs (5s)
-// ──────────────────────────────────────────────
-setInterval(() => {
-  const now = Date.now();
-  for (const [id, worker] of metrics.workers) {
-    if (now - worker.lastHeartbeat > 15000) {
-      worker.ws.close(); // Déclenchera l'event 'close' et cleanup()
-    }
-  }
-}, 5000);
+// Wiki page
+app.get('/wiki', (req, res) => {
+  res.sendFile(path.join(__dirname, '../../public/wiki.html'));
+});
 
-// ──────────────────────────────────────────────
-// Start
-// ──────────────────────────────────────────────
+// Start server
 const PORT = process.env.PORT || settings.port;
 server.listen(PORT, '0.0.0.0', () => {
-  logger.info(`🚀 Serveur central sur port ${PORT}`);
-  logger.info(`📊 Admin: http://localhost:${PORT}/admin`);
-  logger.info(`🔧 API: http://localhost:${PORT}/translate`);
+  logger.info(`Central server running on port ${PORT}`);
+  logger.info(`Admin panel: http://localhost:${PORT}/admin`);
+  logger.info(`API: http://localhost:${PORT}/translate`);
 });