dynamic-self-register-proxy 1.0.5 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamic-self-register-proxy",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "description": "Dynamic reverse proxy with self-registration API - applications can register themselves and receive an automatically assigned port",
   "main": "proxy-client.js",
   "bin": {

package/proxy.js

@@ -148,19 +148,20 @@ async function checkServerHealth(path, route) {
 }
 
 /**
- * Désenregistre un serveur (utilisé par le health check)
+ * Désenregistre un serveur
  * Utilise le mutex pour éviter les conflits avec les inscriptions
  * @param {string} path - Le chemin à désenregistrer
+ * @param {string} reason - La raison du désenregistrement (pour les logs)
  * @returns {Promise<void>}
  */
-async function unregisterServer(path) {
+async function unregisterServer(path, reason = 'unhealthy') {
   await registrationMutex.acquire();
   try {
     const route = registry.routes.get(path);
     if (route) {
       registry.routes.delete(path);
       registry.usedPorts.delete(route.port);
-      console.log(`[HEALTH CHECK] Unregistered ${path} (was on port ${route.port}) - server unhealthy`);
+      console.log(`[UNREGISTER] ${path} (was on port ${route.port}) - reason: ${reason}`);
     }
   } finally {
     registrationMutex.release();
@@ -220,7 +221,7 @@ async function performHealthChecks() {
   
   for (const { path, isHealthy } of results) {
     if (!isHealthy) {
-      await unregisterServer(path);
+      await unregisterServer(path, 'failed health check');
     }
   }
   
@@ -275,15 +276,29 @@ app.post('/proxy/register', async (req, res) => {
     // Vérifie si le path existe déjà
     if (registry.routes.has(normalizedPath)) {
       const existing = registry.routes.get(normalizedPath);
-      return res.status(409).json({ 
-        success: false, 
-        error: 'Path already registered',
-        existing: {
-          path: normalizedPath,
-          port: existing.port,
-          name: existing.name
-        }
-      });
+      
+      // On vérifie si le serveur existant est réellement encore en vie
+      // On relâche temporairement le mutex pour ne pas bloquer tout le proxy pendant le fetch
+      registrationMutex.release();
+      const isAlive = await checkServerHealth(normalizedPath, existing);
+      await registrationMutex.acquire();
+
+      // Si le serveur est mort, on l'écrase sans erreur
+      if (!isAlive) {
+        console.log(`[REGISTER] Path ${normalizedPath} was occupied by a dead server. Overwriting...`);
+        registry.usedPorts.delete(existing.port);
+        registry.routes.delete(normalizedPath);
+      } else {
+        return res.status(409).json({ 
+          success: false, 
+          error: 'Path already registered',
+          existing: {
+            path: normalizedPath,
+            port: existing.port,
+            name: existing.name
+          }
+        });
+      }
     }
 
     // Attribution du port
@@ -818,22 +833,66 @@ function escapeHtml(text) {
 }
 
 // ============================================
-// PROXY MIDDLEWARE
+// PROXY MIDDLEWARE (PERSISTENT)
 // ============================================
 
 /**
- * Router dynamique - détermine la cible en fonction de la requête
+ * Middleware de proxy persistant pour éviter les fuites de mémoire (EventEmitter MaxListenersExceededWarning)
+ * Créé une seule fois et réutilisé pour toutes les requêtes.
  */
-const dynamicRouter = (req) => {
-  const route = findRouteForPath(req.path);
-  if (route) {
-    return `http://localhost:${route.port}`;
+const persistentProxyMiddleware = createProxyMiddleware({
+  target: 'http://localhost', // Cible par défaut (sera surchargée par router)
+  router: (req) => req.proxyTarget,
+  changeOrigin: true,
+  pathRewrite: (path, req) => {
+    const routePath = req.proxyRoutePath;
+    if (routePath && path.startsWith(routePath)) {
+      return path.slice(routePath.length) || '/';
+    }
+    return path;
+  },
+  on: {
+    proxyReq: (proxyReq, req) => {
+      // Ré-écriture du body si présent (nécessaire car express.json() a consommé le stream)
+      if (req.body && typeof req.body === 'object' && Object.keys(req.body).length > 0) {
+        const bodyData = JSON.stringify(req.body);
+        proxyReq.setHeader('Content-Type', 'application/json');
+        proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
+        proxyReq.write(bodyData);
+      }
+      console.log(`[PROXY] ${req.method} ${req.path} -> ${req.proxyTarget}`);
+    },
+    error: (err, req, res) => {
+      // Si la réponse a déjà été envoyée, on ne fait rien
+      if (res.headersSent) return;
+      
+      console.error(`[PROXY ERROR] ${req.path}:`, err.message);
+
+      // Si la connexion est refusée, le serveur est probablement mort.
+      // On le désenregistre immédiatement pour éviter d'autres erreurs.
+      if (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT') {
+        const route = findRouteForPath(req.path);
+        if (route) {
+          const routePath = [...registry.routes.entries()]
+            .find(([, v]) => v === route)?.[0];
+          if (routePath) {
+            unregisterServer(routePath, `connection error (${err.code})`).catch(() => {});
+            console.log(`[PROXY] Auto-unregistered ${routePath} due to connection error`);
+          }
+        }
+      }
+
+      res.status(502).json({
+        error: 'Proxy error',
+        message: err.message,
+        target: req.proxyTarget
+      });
+    }
   }
-  return null;
-};
+});
 
 /**
- * Middleware de proxy pour toutes les autres requêtes
+ * Middleware principal qui gère le routage vers le proxy
  */
 app.use((req, res, next) => {
   // Ignore les routes de l'API proxy
@@ -841,9 +900,9 @@ app.use((req, res, next) => {
     return next();
   }
 
-  const target = dynamicRouter(req);
+  const route = findRouteForPath(req.path);
   
-  if (!target) {
+  if (!route) {
     return res.status(404).json({
       error: 'No route registered for this path',
       path: req.path,
@@ -851,45 +910,15 @@ app.use((req, res, next) => {
     });
   }
 
+  // Stocke les informations de la route dans l'objet req pour le middleware persistant
+  req.proxyTarget = `http://localhost:${route.port}`;
+  
   // Trouve le path de la route pour le pathRewrite
-  const route = findRouteForPath(req.path);
-  const routePath = [...registry.routes.entries()]
+  req.proxyRoutePath = [...registry.routes.entries()]
     .find(([, v]) => v === route)?.[0];
 
-  const proxyMiddleware = createProxyMiddleware({
-    target,
-    changeOrigin: true,
-    pathRewrite: (path) => {
-      // Retire le préfixe de la route du path
-      if (routePath && path.startsWith(routePath)) {
-        const newPath = path.slice(routePath.length) || '/';
-        return newPath;
-      }
-      return path;
-    },
-    on: {
-      proxyReq: (proxyReq, req) => {
-        // Ré-écriture du body si présent (nécessaire car express.json() a consommé le stream)
-        if (req.body && Object.keys(req.body).length > 0) {
-          const bodyData = JSON.stringify(req.body);
-          proxyReq.setHeader('Content-Type', 'application/json');
-          proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
-          proxyReq.write(bodyData);
-        }
-        console.log(`[PROXY] ${req.method} ${req.path} -> ${target}`);
-      },
-      error: (err, req, res) => {
-        console.error(`[PROXY ERROR] ${req.path}:`, err.message);
-        res.status(502).json({
-          error: 'Proxy error',
-          message: err.message,
-          target
-        });
-      }
-    }
-  });
-
-  proxyMiddleware(req, res, next);
+  // Délègue au middleware de proxy persistant
+  persistentProxyMiddleware(req, res, next);
 });
 
 // ============================================