dynamic-self-register-proxy 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamic-self-register-proxy",
-  "version": "1.0.7",
+  "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
@@ -852,6 +867,21 @@ const persistentProxyMiddleware = createProxyMiddleware({
       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,