@imenam/self-register-proxy 1.0.46 → 1.0.48

package/routes/registration.js

@@ -1,240 +1,240 @@
-const { Router } = require('express');
-const { requireLocalOnly, requireAuth } = require('../services/auth');
-const { registry, mutex } = require('../services/registry');
-const { getNextAvailablePort, releasePort, isLocalTarget, isPortFree, findRouteForPath } = require('../services/portManager');
-const { checkServerHealth, unregisterServer } = require('../services/healthCheck');
-const { INTERNAL_PORT_START, INTERNAL_PORT_END } = require('../config');
-
-const router = Router();
-
-/**
- * Logique commune d'enregistrement (auto et manuel)
- */
-/**
- * Normalise un nom de groupe : trim, et chaîne vide => undefined (non groupé).
- */
-function normalizeGroup(group) {
-  if (typeof group !== 'string') return undefined;
-  const trimmed = group.trim();
-  return trimmed === '' ? undefined : trimmed;
-}
-
-async function registerRouteInternal({ path, name, port, target, healthCheck, group, autoAssignPort }) {
-  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-  const normalizedGroup = normalizeGroup(group);
-
-  let finalTarget = target || 'http://localhost';
-  if (!finalTarget.startsWith('http://') && !finalTarget.startsWith('https://')) {
-    finalTarget = `http://${finalTarget}`;
-  }
-  if (finalTarget.endsWith('/')) {
-    finalTarget = finalTarget.slice(0, -1);
-  }
-
-  await mutex.acquire();
-
-  let assignedPort = null;
-
-  try {
-    if (registry.routes.has(normalizedPath)) {
-      const existing = registry.routes.get(normalizedPath);
-
-      mutex.release();
-      const isAlive = await checkServerHealth(normalizedPath, existing);
-      await mutex.acquire();
-
-      if (!isAlive) {
-        console.log(`[REGISTER] Path ${normalizedPath} was occupied by a dead server. Overwriting...`);
-        registry.usedPorts.delete(existing.port);
-        registry.routes.delete(normalizedPath);
-      } else {
-        throw new Error('Path already registered');
-      }
-    }
-
-    if (!autoAssignPort) {
-      if (!port) throw new Error('Port is required for manual registration');
-      const manualPort = parseInt(port, 10);
-
-      if (registry.usedPorts.has(manualPort)) {
-        throw new Error(`Port ${manualPort} already in use`);
-      }
-      if (isLocalTarget(finalTarget) && !await isPortFree(manualPort)) {
-        throw new Error(`Port ${manualPort} is already in use by another process`);
-      }
-      assignedPort = manualPort;
-      registry.usedPorts.add(assignedPort);
-    } else {
-      assignedPort = await getNextAvailablePort(isLocalTarget(finalTarget));
-    }
-
-    registry.routes.set(normalizedPath, {
-      port: assignedPort,
-      target: finalTarget,
-      name: name || normalizedPath,
-      healthCheck: healthCheck !== undefined ? healthCheck === true || healthCheck === 'true' : true,
-      group: normalizedGroup,
-      registeredAt: new Date().toISOString()
-    });
-
-    console.log(`[REGISTER] ${normalizedPath} -> ${finalTarget}:${assignedPort} (${name || 'unnamed'}) [Health: ${healthCheck !== undefined ? healthCheck : 'default'}]${normalizedGroup ? ` [Group: ${normalizedGroup}]` : ''}`);
-
-    return {
-      success: true,
-      path: normalizedPath,
-      port: assignedPort,
-      target: finalTarget,
-      name: name || normalizedPath,
-      healthCheck: healthCheck !== undefined ? healthCheck === true || healthCheck === 'true' : true,
-      group: normalizedGroup,
-      message: `Route registered. Target: ${finalTarget}:${assignedPort}`
-    };
-
-  } catch (error) {
-    if (assignedPort !== null) {
-      if (!registry.routes.has(normalizedPath) || registry.routes.get(normalizedPath).port !== assignedPort) {
-        releasePort(assignedPort);
-      }
-    }
-    throw error;
-  } finally {
-    mutex.release();
-  }
-}
-
-/**
- * POST /proxy/register
- * Enregistrement automatique (rétro-compatibilité)
- */
-router.post('/proxy/register', requireLocalOnly, async (req, res) => {
-  const { path, name, target, healthCheck, group } = req.body;
-
-  if (!path) return res.status(400).json({ success: false, error: 'Path is required' });
-
-  try {
-    const result = await registerRouteInternal({ path, name, target, healthCheck, group, autoAssignPort: true });
-    res.json(result);
-  } catch (error) {
-    console.error('[REGISTER AUTO ERROR]', error.message);
-    const status = error.message.includes('already') ? 409 : 500;
-    res.status(status).json({ success: false, error: error.message });
-  }
-});
-
-/**
- * POST /proxy/register-manual
- * Enregistrement manuel via l'interface graphique (port obligatoire)
- */
-router.post('/proxy/register-manual', requireAuth, async (req, res) => {
-  const { path, name, port, target, healthCheck, group } = req.body;
-
-  if (!path) return res.status(400).json({ success: false, error: 'Path is required' });
-  if (!port) return res.status(400).json({ success: false, error: 'Port is required for manual registration' });
-
-  try {
-    const result = await registerRouteInternal({ path, name, port, target, healthCheck, group, autoAssignPort: false });
-    res.json(result);
-  } catch (error) {
-    console.error('[REGISTER MANUAL ERROR]', error.message);
-    const status = error.message.includes('already') ? 409 : 500;
-    res.status(status).json({ success: false, error: error.message });
-  }
-});
-
-/**
- * DELETE /proxy/unregister
- * Supprime une route
- */
-router.delete('/proxy/unregister', requireLocalOnly, 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}`;
-
-  await mutex.acquire();
-
-  try {
-    if (!registry.routes.has(normalizedPath)) {
-      return res.status(404).json({ success: false, error: 'Path not found' });
-    }
-
-    const route = registry.routes.get(normalizedPath);
-    registry.routes.delete(normalizedPath);
-    registry.usedPorts.delete(route.port);
-
-    console.log(`[UNREGISTER] ${normalizedPath} (was on port ${route.port})`);
-
-    res.json({ success: true, path: normalizedPath, freedPort: route.port });
-
-  } catch (error) {
-    console.error('[UNREGISTER ERROR]', error.message);
-    res.status(500).json({ success: false, error: error.message });
-  } finally {
-    mutex.release();
-  }
-});
-
-/**
- * GET /proxy/routes
- * Liste toutes les routes enregistrées
- */
-router.get('/proxy/routes', requireAuth, (req, res) => {
-  const routes = [];
-  registry.routes.forEach((value, path) => {
-    routes.push({
-      path,
-      port: value.port,
-      target: value.target || 'http://localhost',
-      name: value.name,
-      healthCheck: value.healthCheck,
-      group: value.group || null,
-      registeredAt: value.registeredAt,
-      fullTarget: `${value.target || 'http://localhost'}:${value.port}`
-    });
-  });
-
-  res.json({
-    count: routes.length,
-    routes,
-    availablePorts: (INTERNAL_PORT_END - INTERNAL_PORT_START) - registry.usedPorts.size
-  });
-});
-
-/**
- * POST /proxy/check
- * Déclenche manuellement un health check pour une route spécifique
- */
-router.post('/proxy/check', requireAuth, 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' });
-});
-
-module.exports = router;
+const { Router } = require('express');
+const { requireLocalOnly, requireAuth } = require('../services/auth');
+const { registry, mutex } = require('../services/registry');
+const { getNextAvailablePort, releasePort, isLocalTarget, isPortFree, findRouteForPath } = require('../services/portManager');
+const { checkServerHealth, unregisterServer } = require('../services/healthCheck');
+const { INTERNAL_PORT_START, INTERNAL_PORT_END } = require('../config');
+
+const router = Router();
+
+/**
+ * Logique commune d'enregistrement (auto et manuel)
+ */
+/**
+ * Normalise un nom de groupe : trim, et chaîne vide => undefined (non groupé).
+ */
+function normalizeGroup(group) {
+  if (typeof group !== 'string') return undefined;
+  const trimmed = group.trim();
+  return trimmed === '' ? undefined : trimmed;
+}
+
+async function registerRouteInternal({ path, name, port, target, healthCheck, group, autoAssignPort }) {
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const normalizedGroup = normalizeGroup(group);
+
+  let finalTarget = target || 'http://localhost';
+  if (!finalTarget.startsWith('http://') && !finalTarget.startsWith('https://')) {
+    finalTarget = `http://${finalTarget}`;
+  }
+  if (finalTarget.endsWith('/')) {
+    finalTarget = finalTarget.slice(0, -1);
+  }
+
+  await mutex.acquire();
+
+  let assignedPort = null;
+
+  try {
+    if (registry.routes.has(normalizedPath)) {
+      const existing = registry.routes.get(normalizedPath);
+
+      mutex.release();
+      const isAlive = await checkServerHealth(normalizedPath, existing);
+      await mutex.acquire();
+
+      if (!isAlive) {
+        console.log(`[REGISTER] Path ${normalizedPath} was occupied by a dead server. Overwriting...`);
+        registry.usedPorts.delete(existing.port);
+        registry.routes.delete(normalizedPath);
+      } else {
+        throw new Error('Path already registered');
+      }
+    }
+
+    if (!autoAssignPort) {
+      if (!port) throw new Error('Port is required for manual registration');
+      const manualPort = parseInt(port, 10);
+
+      if (registry.usedPorts.has(manualPort)) {
+        throw new Error(`Port ${manualPort} already in use`);
+      }
+      if (isLocalTarget(finalTarget) && !await isPortFree(manualPort)) {
+        throw new Error(`Port ${manualPort} is already in use by another process`);
+      }
+      assignedPort = manualPort;
+      registry.usedPorts.add(assignedPort);
+    } else {
+      assignedPort = await getNextAvailablePort(isLocalTarget(finalTarget));
+    }
+
+    registry.routes.set(normalizedPath, {
+      port: assignedPort,
+      target: finalTarget,
+      name: name || normalizedPath,
+      healthCheck: healthCheck !== undefined ? healthCheck === true || healthCheck === 'true' : true,
+      group: normalizedGroup,
+      registeredAt: new Date().toISOString()
+    });
+
+    console.log(`[REGISTER] ${normalizedPath} -> ${finalTarget}:${assignedPort} (${name || 'unnamed'}) [Health: ${healthCheck !== undefined ? healthCheck : 'default'}]${normalizedGroup ? ` [Group: ${normalizedGroup}]` : ''}`);
+
+    return {
+      success: true,
+      path: normalizedPath,
+      port: assignedPort,
+      target: finalTarget,
+      name: name || normalizedPath,
+      healthCheck: healthCheck !== undefined ? healthCheck === true || healthCheck === 'true' : true,
+      group: normalizedGroup,
+      message: `Route registered. Target: ${finalTarget}:${assignedPort}`
+    };
+
+  } catch (error) {
+    if (assignedPort !== null) {
+      if (!registry.routes.has(normalizedPath) || registry.routes.get(normalizedPath).port !== assignedPort) {
+        releasePort(assignedPort);
+      }
+    }
+    throw error;
+  } finally {
+    mutex.release();
+  }
+}
+
+/**
+ * POST /proxy/register
+ * Enregistrement automatique (rétro-compatibilité)
+ */
+router.post('/proxy/register', requireLocalOnly, async (req, res) => {
+  const { path, name, target, healthCheck, group } = req.body;
+
+  if (!path) return res.status(400).json({ success: false, error: 'Path is required' });
+
+  try {
+    const result = await registerRouteInternal({ path, name, target, healthCheck, group, autoAssignPort: true });
+    res.json(result);
+  } catch (error) {
+    console.error('[REGISTER AUTO ERROR]', error.message);
+    const status = error.message.includes('already') ? 409 : 500;
+    res.status(status).json({ success: false, error: error.message });
+  }
+});
+
+/**
+ * POST /proxy/register-manual
+ * Enregistrement manuel via l'interface graphique (port obligatoire)
+ */
+router.post('/proxy/register-manual', requireAuth, async (req, res) => {
+  const { path, name, port, target, healthCheck, group } = req.body;
+
+  if (!path) return res.status(400).json({ success: false, error: 'Path is required' });
+  if (!port) return res.status(400).json({ success: false, error: 'Port is required for manual registration' });
+
+  try {
+    const result = await registerRouteInternal({ path, name, port, target, healthCheck, group, autoAssignPort: false });
+    res.json(result);
+  } catch (error) {
+    console.error('[REGISTER MANUAL ERROR]', error.message);
+    const status = error.message.includes('already') ? 409 : 500;
+    res.status(status).json({ success: false, error: error.message });
+  }
+});
+
+/**
+ * DELETE /proxy/unregister
+ * Supprime une route
+ */
+router.delete('/proxy/unregister', requireLocalOnly, 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}`;
+
+  await mutex.acquire();
+
+  try {
+    if (!registry.routes.has(normalizedPath)) {
+      return res.status(404).json({ success: false, error: 'Path not found' });
+    }
+
+    const route = registry.routes.get(normalizedPath);
+    registry.routes.delete(normalizedPath);
+    registry.usedPorts.delete(route.port);
+
+    console.log(`[UNREGISTER] ${normalizedPath} (was on port ${route.port})`);
+
+    res.json({ success: true, path: normalizedPath, freedPort: route.port });
+
+  } catch (error) {
+    console.error('[UNREGISTER ERROR]', error.message);
+    res.status(500).json({ success: false, error: error.message });
+  } finally {
+    mutex.release();
+  }
+});
+
+/**
+ * GET /proxy/routes
+ * Liste toutes les routes enregistrées
+ */
+router.get('/proxy/routes', requireAuth, (req, res) => {
+  const routes = [];
+  registry.routes.forEach((value, path) => {
+    routes.push({
+      path,
+      port: value.port,
+      target: value.target || 'http://localhost',
+      name: value.name,
+      healthCheck: value.healthCheck,
+      group: value.group || null,
+      registeredAt: value.registeredAt,
+      fullTarget: `${value.target || 'http://localhost'}:${value.port}`
+    });
+  });
+
+  res.json({
+    count: routes.length,
+    routes,
+    availablePorts: (INTERNAL_PORT_END - INTERNAL_PORT_START) - registry.usedPorts.size
+  });
+});
+
+/**
+ * POST /proxy/check
+ * Déclenche manuellement un health check pour une route spécifique
+ */
+router.post('/proxy/check', requireAuth, 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' });
+});
+
+module.exports = router;

package/services/healthCheck.js

@@ -1,95 +1,95 @@
-// NOTE: le timeout est appliqué globalement, pas par route individuelle
-const { HEALTH_CHECK_INTERVAL, HEALTH_CHECK_TIMEOUT, HEALTH_CHECK_GRACE_PERIOD } = require('../config');
-const { registry, mutex } = require('./registry');
-
-/**
- * Vérifie la santé d'un serveur enregistré
- */
-async function checkServerHealth(path, route) {
-  const target = route.target || 'http://localhost';
-  const healthUrl = `${target}:${route.port}/proxy/health`;
-
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT);
-    const response = await fetch(healthUrl, { method: 'GET', signal: controller.signal });
-    clearTimeout(timeoutId);
-    return response.status === 200;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Désenregistre un serveur via le mutex
- */
-async function unregisterServer(path, reason = 'unhealthy') {
-  await mutex.acquire();
-  try {
-    const route = registry.routes.get(path);
-    if (route) {
-      registry.routes.delete(path);
-      registry.usedPorts.delete(route.port);
-      console.log(`[UNREGISTER] ${path} (was on port ${route.port}) - reason: ${reason}`);
-    }
-  } finally {
-    mutex.release();
-  }
-}
-
-/**
- * Vérifie si un serveur est encore dans sa période de grâce
- */
-function isInGracePeriod(route) {
-  const registeredAt = new Date(route.registeredAt).getTime();
-  return (Date.now() - registeredAt) < HEALTH_CHECK_GRACE_PERIOD;
-}
-
-/**
- * Effectue un health check sur tous les serveurs enregistrés
- */
-async function performHealthChecks() {
-  if (registry.routes.size === 0) return;
-
-  const checks = [];
-  let skippedCount = 0;
-
-  for (const [path, route] of registry.routes.entries()) {
-    if (route.healthCheck === false) continue;
-    if (isInGracePeriod(route)) { skippedCount++; continue; }
-    checks.push(
-      checkServerHealth(path, route).then(isHealthy => ({ path, route, isHealthy }))
-    );
-  }
-
-  if (checks.length === 0) {
-    if (skippedCount > 0) {
-      console.log(`[HEALTH CHECK] ${skippedCount} server(s) in grace period, skipping checks`);
-    }
-    return;
-  }
-
-  console.log(`[HEALTH CHECK] Checking ${checks.length} server(s)...${skippedCount > 0 ? ` (${skippedCount} in grace period)` : ''}`);
-
-  const results = await Promise.all(checks);
-
-  for (const { path, isHealthy } of results) {
-    if (!isHealthy) await unregisterServer(path, 'failed health check');
-  }
-
-  const healthyCount = results.filter(r => r.isHealthy).length;
-  const unhealthyCount = results.length - healthyCount;
-  if (unhealthyCount > 0) {
-    console.log(`[HEALTH CHECK] Complete: ${healthyCount} healthy, ${unhealthyCount} removed`);
-  }
-}
-
-/**
- * Démarre le polling de health check
- */
-function startHealthCheckPolling() {
-  console.log(`[HEALTH CHECK] Starting polling every ${HEALTH_CHECK_INTERVAL}ms`);
-  setInterval(performHealthChecks, HEALTH_CHECK_INTERVAL);
-}
-
-module.exports = { checkServerHealth, unregisterServer, isInGracePeriod, performHealthChecks, startHealthCheckPolling };
+// NOTE: le timeout est appliqué globalement, pas par route individuelle
+const { HEALTH_CHECK_INTERVAL, HEALTH_CHECK_TIMEOUT, HEALTH_CHECK_GRACE_PERIOD } = require('../config');
+const { registry, mutex } = require('./registry');
+
+/**
+ * Vérifie la santé d'un serveur enregistré
+ */
+async function checkServerHealth(path, route) {
+  const target = route.target || 'http://localhost';
+  const healthUrl = `${target}:${route.port}/proxy/health`;
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT);
+    const response = await fetch(healthUrl, { method: 'GET', signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response.status === 200;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Désenregistre un serveur via le mutex
+ */
+async function unregisterServer(path, reason = 'unhealthy') {
+  await mutex.acquire();
+  try {
+    const route = registry.routes.get(path);
+    if (route) {
+      registry.routes.delete(path);
+      registry.usedPorts.delete(route.port);
+      console.log(`[UNREGISTER] ${path} (was on port ${route.port}) - reason: ${reason}`);
+    }
+  } finally {
+    mutex.release();
+  }
+}
+
+/**
+ * Vérifie si un serveur est encore dans sa période de grâce
+ */
+function isInGracePeriod(route) {
+  const registeredAt = new Date(route.registeredAt).getTime();
+  return (Date.now() - registeredAt) < HEALTH_CHECK_GRACE_PERIOD;
+}
+
+/**
+ * Effectue un health check sur tous les serveurs enregistrés
+ */
+async function performHealthChecks() {
+  if (registry.routes.size === 0) return;
+
+  const checks = [];
+  let skippedCount = 0;
+
+  for (const [path, route] of registry.routes.entries()) {
+    if (route.healthCheck === false) continue;
+    if (isInGracePeriod(route)) { skippedCount++; continue; }
+    checks.push(
+      checkServerHealth(path, route).then(isHealthy => ({ path, route, isHealthy }))
+    );
+  }
+
+  if (checks.length === 0) {
+    if (skippedCount > 0) {
+      console.log(`[HEALTH CHECK] ${skippedCount} server(s) in grace period, skipping checks`);
+    }
+    return;
+  }
+
+  console.log(`[HEALTH CHECK] Checking ${checks.length} server(s)...${skippedCount > 0 ? ` (${skippedCount} in grace period)` : ''}`);
+
+  const results = await Promise.all(checks);
+
+  for (const { path, isHealthy } of results) {
+    if (!isHealthy) await unregisterServer(path, 'failed health check');
+  }
+
+  const healthyCount = results.filter(r => r.isHealthy).length;
+  const unhealthyCount = results.length - healthyCount;
+  if (unhealthyCount > 0) {
+    console.log(`[HEALTH CHECK] Complete: ${healthyCount} healthy, ${unhealthyCount} removed`);
+  }
+}
+
+/**
+ * Démarre le polling de health check
+ */
+function startHealthCheckPolling() {
+  console.log(`[HEALTH CHECK] Starting polling every ${HEALTH_CHECK_INTERVAL}ms`);
+  setInterval(performHealthChecks, HEALTH_CHECK_INTERVAL);
+}
+
+module.exports = { checkServerHealth, unregisterServer, isInGracePeriod, performHealthChecks, startHealthCheckPolling };