dynamic-self-register-proxy 1.0.1 → 1.0.3

package/package.json

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

@@ -24,8 +24,55 @@ const registry = {
   nextPort: INTERNAL_PORT_START
 };
 
+// ============================================
+// MUTEX POUR L'ATTRIBUTION DES PORTS
+// ============================================
+/**
+ * Simple mutex pour sérialiser les opérations critiques
+ * Évite les race conditions lors d'inscriptions simultanées
+ */
+class Mutex {
+  constructor() {
+    this._locked = false;
+    this._queue = [];
+  }
+
+  /**
+   * Acquiert le verrou (attend si nécessaire)
+   * @returns {Promise<void>}
+   */
+  async acquire() {
+    if (!this._locked) {
+      this._locked = true;
+      return;
+    }
+
+    // Attend que le verrou soit libéré
+    return new Promise(resolve => {
+      this._queue.push(resolve);
+    });
+  }
+
+  /**
+   * Libère le verrou
+   */
+  release() {
+    if (this._queue.length > 0) {
+      // Donne le verrou au prochain en attente
+      const next = this._queue.shift();
+      next();
+    } else {
+      this._locked = false;
+    }
+  }
+}
+
+const registrationMutex = new Mutex();
+
 /**
- * Trouve le prochain port disponible
+ * Trouve le prochain port disponible et le réserve atomiquement
+ * DOIT être appelé avec le mutex acquis
+ * @returns {number} Le port réservé
  */
 function getNextAvailablePort() {
   while (registry.usedPorts.has(registry.nextPort)) {
@@ -39,10 +86,20 @@ function getNextAvailablePort() {
     }
   }
   const port = registry.nextPort;
+  // Réservation atomique du port
+  registry.usedPorts.add(port);
   registry.nextPort++;
   return port;
 }
 
+/**
+ * Libère un port réservé (en cas d'échec d'enregistrement)
+ * @param {number} port - Le port à libérer
+ */
+function releasePort(port) {
+  registry.usedPorts.delete(port);
+}
+
 /**
  * Trouve la route correspondant à un chemin de requête
  */
@@ -91,14 +148,21 @@ async function checkServerHealth(path, route) {
 
 /**
  * Désenregistre un serveur (utilisé par le health check)
+ * Utilise le mutex pour éviter les conflits avec les inscriptions
  * @param {string} path - Le chemin à désenregistrer
+ * @returns {Promise<void>}
  */
-function unregisterServer(path) {
-  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`);
+async function unregisterServer(path) {
+  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`);
+    }
+  } finally {
+    registrationMutex.release();
   }
 }
 
@@ -128,7 +192,7 @@ async function performHealthChecks() {
   
   for (const { path, isHealthy } of results) {
     if (!isHealthy) {
-      unregisterServer(path);
+      await unregisterServer(path);
     }
   }
   
@@ -157,21 +221,29 @@ function startHealthCheckPolling() {
  * Enregistre une nouvelle route
  * Body: { path: "/myapp", name: "My Application", port?: 4001 }
  * Response: { success: true, path: "/myapp", port: 4001 }
+ * 
+ * Utilise un mutex pour éviter les race conditions lors d'inscriptions simultanées
  */
-app.post('/proxy/register', (req, res) => {
-  try {
-    const { path, name, port: requestedPort } = req.body;
+app.post('/proxy/register', async (req, res) => {
+  // Validation préliminaire (avant d'acquérir le mutex)
+  const { path, name, port: requestedPort } = req.body;
 
-    if (!path) {
-      return res.status(400).json({ 
-        success: false, 
-        error: 'Path is required' 
-      });
-    }
+  if (!path) {
+    return res.status(400).json({ 
+      success: false, 
+      error: 'Path is required' 
+    });
+  }
+
+  // Normalise le path (doit commencer par /)
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
 
-    // Normalise le path (doit commencer par /)
-    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  // Acquiert le mutex pour la section critique
+  await registrationMutex.acquire();
+  
+  let port = null;
 
+  try {
     // Vérifie si le path existe déjà
     if (registry.routes.has(normalizedPath)) {
       const existing = registry.routes.get(normalizedPath);
@@ -187,7 +259,6 @@ app.post('/proxy/register', (req, res) => {
     }
 
     // Attribution du port
-    let port;
     if (requestedPort) {
       // Port spécifique demandé
       if (registry.usedPorts.has(requestedPort)) {
@@ -197,18 +268,18 @@ app.post('/proxy/register', (req, res) => {
         });
       }
       port = requestedPort;
+      registry.usedPorts.add(port);
     } else {
-      // Attribution automatique
+      // Attribution automatique (le port est réservé atomiquement)
       port = getNextAvailablePort();
     }
 
-    // Enregistrement
+    // Enregistrement de la route
     registry.routes.set(normalizedPath, {
       port,
       name: name || normalizedPath,
       registeredAt: new Date().toISOString()
     });
-    registry.usedPorts.add(port);
 
     console.log(`[REGISTER] ${normalizedPath} -> localhost:${port} (${name || 'unnamed'})`);
 
@@ -221,11 +292,19 @@ app.post('/proxy/register', (req, res) => {
     });
 
   } catch (error) {
+    // En cas d'erreur, libère le port s'il a été réservé
+    if (port !== null) {
+      releasePort(port);
+    }
+    
     console.error('[REGISTER ERROR]', error.message);
     res.status(500).json({ 
       success: false, 
       error: error.message 
     });
+  } finally {
+    // Libère toujours le mutex
+    registrationMutex.release();
   }
 });
 
@@ -233,20 +312,25 @@ app.post('/proxy/register', (req, res) => {
  * DELETE /proxy/unregister
  * Supprime une route
  * Body: { path: "/myapp" }
+ * 
+ * Utilise un mutex pour éviter les conflits avec les inscriptions simultanées
  */
-app.delete('/proxy/unregister', (req, res) => {
-  try {
-    const { path } = req.body;
+app.delete('/proxy/unregister', async (req, res) => {
+  const { path } = req.body;
 
-    if (!path) {
-      return res.status(400).json({ 
-        success: false, 
-        error: 'Path is required' 
-      });
-    }
+  if (!path) {
+    return res.status(400).json({ 
+      success: false, 
+      error: 'Path is required' 
+    });
+  }
+
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
 
-    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  // Acquiert le mutex pour la section critique
+  await registrationMutex.acquire();
 
+  try {
     if (!registry.routes.has(normalizedPath)) {
       return res.status(404).json({ 
         success: false, 
@@ -272,6 +356,9 @@ app.delete('/proxy/unregister', (req, res) => {
       success: false, 
       error: error.message 
     });
+  } finally {
+    // Libère toujours le mutex
+    registrationMutex.release();
   }
 });
 
@@ -311,6 +398,267 @@ app.get('/proxy/health', (req, res) => {
   });
 });
 
+/**
+ * GET /
+ * Page d'accueil listant tous les serveurs disponibles
+ * Retourne du JSON si le client l'accepte (API), sinon du HTML (navigateur)
+ */
+app.get('/', (req, res) => {
+  const routes = [];
+  registry.routes.forEach((value, path) => {
+    routes.push({
+      path,
+      port: value.port,
+      name: value.name,
+      registeredAt: value.registeredAt,
+      target: `http://localhost:${value.port}`
+    });
+  });
+
+  // Tri par nom
+  routes.sort((a, b) => a.name.localeCompare(b.name));
+
+  // Si le client accepte JSON (et pas spécifiquement HTML), retourne du JSON
+  const acceptHeader = req.get('Accept') || '';
+  const wantsJson = acceptHeader.includes('application/json') || 
+                    (acceptHeader.includes('*/*') && !acceptHeader.includes('text/html'));
+  
+  if (wantsJson) {
+    return res.json({
+      status: 'healthy',
+      uptime: process.uptime(),
+      count: routes.length,
+      routes,
+      availablePorts: (INTERNAL_PORT_END - INTERNAL_PORT_START) - registry.usedPorts.size
+    });
+  }
+
+  const html = `
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Proxy Server - Services disponibles</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+      min-height: 100vh;
+      color: #e4e4e7;
+      padding: 2rem;
+    }
+    .container {
+      max-width: 800px;
+      margin: 0 auto;
+    }
+    header {
+      text-align: center;
+      margin-bottom: 3rem;
+    }
+    h1 {
+      font-size: 2.5rem;
+      background: linear-gradient(90deg, #6366f1, #8b5cf6);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+      margin-bottom: 0.5rem;
+    }
+    .subtitle {
+      color: #a1a1aa;
+      font-size: 1.1rem;
+    }
+    .stats {
+      display: flex;
+      justify-content: center;
+      gap: 2rem;
+      margin-top: 1.5rem;
+    }
+    .stat {
+      background: rgba(255, 255, 255, 0.05);
+      padding: 1rem 1.5rem;
+      border-radius: 12px;
+      text-align: center;
+    }
+    .stat-value {
+      font-size: 1.5rem;
+      font-weight: bold;
+      color: #8b5cf6;
+    }
+    .stat-label {
+      font-size: 0.85rem;
+      color: #71717a;
+      margin-top: 0.25rem;
+    }
+    .services-list {
+      display: flex;
+      flex-direction: column;
+      gap: 1rem;
+    }
+    .service-card {
+      background: rgba(255, 255, 255, 0.05);
+      border: 1px solid rgba(255, 255, 255, 0.1);
+      border-radius: 12px;
+      padding: 1.5rem;
+      transition: all 0.2s ease;
+    }
+    .service-card:hover {
+      background: rgba(255, 255, 255, 0.08);
+      border-color: rgba(139, 92, 246, 0.5);
+      transform: translateY(-2px);
+    }
+    .service-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 0.75rem;
+    }
+    .service-name {
+      font-size: 1.25rem;
+      font-weight: 600;
+      color: #f4f4f5;
+    }
+    .service-path {
+      font-family: 'SF Mono', 'Fira Code', monospace;
+      font-size: 0.9rem;
+      color: #8b5cf6;
+      background: rgba(139, 92, 246, 0.15);
+      padding: 0.25rem 0.75rem;
+      border-radius: 6px;
+    }
+    .service-meta {
+      display: flex;
+      gap: 1.5rem;
+      color: #71717a;
+      font-size: 0.85rem;
+      margin-bottom: 1rem;
+    }
+    .service-link {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      background: linear-gradient(90deg, #6366f1, #8b5cf6);
+      color: white;
+      text-decoration: none;
+      padding: 0.5rem 1rem;
+      border-radius: 8px;
+      font-weight: 500;
+      transition: opacity 0.2s;
+    }
+    .service-link:hover {
+      opacity: 0.9;
+    }
+    .empty-state {
+      text-align: center;
+      padding: 4rem 2rem;
+      background: rgba(255, 255, 255, 0.03);
+      border-radius: 12px;
+      border: 1px dashed rgba(255, 255, 255, 0.1);
+    }
+    .empty-state h2 {
+      color: #a1a1aa;
+      font-size: 1.25rem;
+      margin-bottom: 1rem;
+    }
+    .empty-state p {
+      color: #71717a;
+      margin-bottom: 0.5rem;
+    }
+    .code {
+      font-family: 'SF Mono', 'Fira Code', monospace;
+      background: rgba(0, 0, 0, 0.3);
+      padding: 0.2rem 0.5rem;
+      border-radius: 4px;
+      font-size: 0.9rem;
+    }
+    footer {
+      margin-top: 3rem;
+      text-align: center;
+      color: #52525b;
+      font-size: 0.85rem;
+    }
+    footer a {
+      color: #8b5cf6;
+      text-decoration: none;
+    }
+    footer a:hover {
+      text-decoration: underline;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>🚀 Proxy Server</h1>
+      <p class="subtitle">Services disponibles sur ce serveur</p>
+      <div class="stats">
+        <div class="stat">
+          <div class="stat-value">${routes.length}</div>
+          <div class="stat-label">Services actifs</div>
+        </div>
+        <div class="stat">
+          <div class="stat-value">${(INTERNAL_PORT_END - INTERNAL_PORT_START) - registry.usedPorts.size}</div>
+          <div class="stat-label">Ports disponibles</div>
+        </div>
+      </div>
+    </header>
+
+    ${routes.length > 0 ? `
+    <div class="services-list">
+      ${routes.map(route => `
+        <div class="service-card">
+          <div class="service-header">
+            <span class="service-name">${escapeHtml(route.name)}</span>
+            <span class="service-path">${escapeHtml(route.path)}</span>
+          </div>
+          <div class="service-meta">
+            <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>
+      `).join('')}
+    </div>
+    ` : `
+    <div class="empty-state">
+      <h2>Aucun service enregistré</h2>
+      <p>Enregistrez un service avec l'API:</p>
+      <p><span class="code">POST /proxy/register</span></p>
+    </div>
+    `}
+
+    <footer>
+      <p>API: <a href="/proxy/routes">/proxy/routes</a> | <a href="/proxy/health">/proxy/health</a></p>
+    </footer>
+  </div>
+</body>
+</html>
+  `.trim();
+
+  res.type('html').send(html);
+});
+
+/**
+ * Échappe les caractères HTML pour éviter les injections XSS
+ */
+function escapeHtml(text) {
+  const map = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#039;'
+  };
+  return String(text).replace(/[&<>"']/g, char => map[char]);
+}
+
 // ============================================
 // PROXY MIDDLEWARE
 // ============================================