dynamic-self-register-proxy 1.0.4 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamic-self-register-proxy",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "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

@@ -9,7 +9,7 @@ app.use(express.json());
 // ============================================
 // CONFIGURATION
 // ============================================
-const PROXY_PORT = process.env.PROXY_PORT || 3005;
+const PROXY_PORT = process.env.PROXY_PORT || 3000;
 const INTERNAL_PORT_START = 4000;
 const INTERNAL_PORT_END = 5000;
 const HEALTH_CHECK_INTERVAL = process.env.HEALTH_CHECK_INTERVAL || 30000; // 30 secondes par défaut
@@ -413,6 +413,52 @@ app.get('/proxy/routes', (req, res) => {
   });
 });
 
+/**
+ * POST /proxy/check
+ * Déclenche manuellement un health check pour une route spécifique
+ * Body: { path: "/myapp" }
+ */
+app.post('/proxy/check', async (req, res) => {
+  const { path } = req.body;
+
+  if (!path) {
+    return res.status(400).json({ 
+      success: false, 
+      error: 'Path is required' 
+    });
+  }
+
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const route = registry.routes.get(normalizedPath);
+
+  if (!route) {
+    return res.status(404).json({ 
+      success: false, 
+      error: 'Path not found' 
+    });
+  }
+
+  console.log(`[MANUAL HEALTH CHECK] Checking ${normalizedPath}...`);
+  const isHealthy = await checkServerHealth(normalizedPath, route);
+
+  if (!isHealthy) {
+    await unregisterServer(normalizedPath);
+    return res.json({
+      success: true,
+      path: normalizedPath,
+      healthy: false,
+      message: 'Server was unhealthy and has been removed'
+    });
+  }
+
+  res.json({
+    success: true,
+    path: normalizedPath,
+    healthy: true,
+    message: 'Server is healthy'
+  });
+});
+
 /**
  * GET /proxy/health
  * Health check du proxy
@@ -581,6 +627,40 @@ app.get('/', (req, res) => {
     .service-link:hover {
       opacity: 0.9;
     }
+    .service-actions {
+      display: flex;
+      gap: 1rem;
+      align-items: center;
+    }
+    .check-btn {
+      background: rgba(255, 255, 255, 0.1);
+      color: #e4e4e7;
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      padding: 0.5rem 1rem;
+      border-radius: 8px;
+      cursor: pointer;
+      font-size: 0.85rem;
+      font-weight: 500;
+      transition: all 0.2s;
+    }
+    .check-btn:hover {
+      background: rgba(255, 255, 255, 0.15);
+      border-color: rgba(255, 255, 255, 0.3);
+    }
+    .check-btn.loading {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+    .check-btn.healthy {
+      background: rgba(16, 185, 129, 0.2);
+      border-color: rgba(16, 185, 129, 0.4);
+      color: #10b981;
+    }
+    .check-btn.unhealthy {
+      background: rgba(239, 68, 68, 0.2);
+      border-color: rgba(239, 68, 68, 0.4);
+      color: #ef4444;
+    }
     .empty-state {
       text-align: center;
       padding: 4rem 2rem;
@@ -648,9 +728,14 @@ app.get('/', (req, res) => {
             <span>Port interne: ${route.port}</span>
             <span>Enregistré: ${new Date(route.registeredAt).toLocaleString('fr-FR')}</span>
           </div>
-          <a href="${escapeHtml(route.path)}" class="service-link">
-            Accéder au service →
-          </a>
+          <div class="service-actions">
+            <a href="${escapeHtml(route.path)}" class="service-link">
+              Accéder au service →
+            </a>
+            <button onclick="checkHealth('${escapeHtml(route.path)}', this)" class="check-btn">
+              Vérifier la santé
+            </button>
+          </div>
         </div>
       `).join('')}
     </div>
@@ -666,6 +751,51 @@ app.get('/', (req, res) => {
       <p>API: <a href="/proxy/routes">/proxy/routes</a> | <a href="/proxy/health">/proxy/health</a></p>
     </footer>
   </div>
+
+  <script>
+    async function checkHealth(path, btn) {
+      if (btn.classList.contains('loading')) return;
+      
+      const originalText = btn.innerText;
+      btn.innerText = 'Vérification...';
+      btn.classList.add('loading');
+      
+      try {
+        const response = await fetch('/proxy/check', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ path })
+        });
+        
+        const data = await response.json();
+        
+        if (data.healthy) {
+          btn.innerText = '✅ Sain';
+          btn.classList.remove('loading');
+          btn.classList.add('healthy');
+          setTimeout(() => {
+            btn.innerText = originalText;
+            btn.classList.remove('healthy');
+          }, 3000);
+        } else {
+          btn.innerText = '❌ Hors ligne';
+          btn.classList.remove('loading');
+          btn.classList.add('unhealthy');
+          
+          // Si le serveur a été supprimé, on rafraîchit la liste après un court délai
+          setTimeout(() => {
+            window.location.reload();
+          }, 2000);
+        }
+      } catch (error) {
+        btn.innerText = '⚠️ Erreur';
+        btn.classList.remove('loading');
+        setTimeout(() => {
+          btn.innerText = originalText;
+        }, 3000);
+      }
+    }
+  </script>
 </body>
 </html>
   `.trim();
@@ -688,22 +818,51 @@ 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);
+      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
@@ -711,9 +870,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,
@@ -721,45 +880,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);
 });
 
 // ============================================