wu-framework 1.0.0

package/src/core/wu-sandbox-pool.js

@@ -0,0 +1,390 @@
+/**
+ * 🏊 WU-SANDBOX-POOL: VIRTUAL SANDBOX POOL
+ *
+ * Object Pool pattern para reutilizar sandboxes:
+ * - Reduce memory usage
+ * - Reduce GC pressure
+ * - Mejora performance de mount/unmount
+ * - Auto-cleanup de sandboxes inactivos
+ */
+
+export class WuSandboxPool {
+  constructor(core) {
+    this.core = core;
+
+    // Pool configuration
+    this.config = {
+      minSize: 2,           // Mínimo de sandboxes en pool
+      maxSize: 10,          // Máximo de sandboxes en pool
+      idleTimeout: 30000,   // Tiempo antes de limpiar sandbox (30s)
+      warmupOnInit: true    // Crear sandboxes al inicializar
+    };
+
+    // Pool state
+    this.available = [];   // Sandboxes disponibles
+    this.inUse = new Map(); // Sandboxes en uso: appName -> sandbox
+    this.totalCreated = 0;
+    this.totalReused = 0;
+
+    // Cleanup timer
+    this.cleanupTimer = null;
+
+    console.log('[WuSandboxPool] 🏊 Sandbox pool initialized');
+  }
+
+  /**
+   * 🚀 INIT: Inicializar pool
+   */
+  async init() {
+    if (this.config.warmupOnInit) {
+      await this.warmup();
+    }
+
+    // Iniciar cleanup periódico
+    this.startCleanupTimer();
+
+    console.log('[WuSandboxPool] Pool ready');
+  }
+
+  /**
+   * 🔥 WARMUP: Pre-crear sandboxes
+   */
+  async warmup() {
+    console.log(`[WuSandboxPool] Warming up pool with ${this.config.minSize} sandboxes`);
+
+    for (let i = 0; i < this.config.minSize; i++) {
+      const sandbox = this.createSandbox();
+      this.available.push(sandbox);
+    }
+
+    console.log(`[WuSandboxPool] ✅ Pool warmed up with ${this.available.length} sandboxes`);
+  }
+
+  /**
+   * 🎯 CREATE SANDBOX: Crear nuevo sandbox
+   * @returns {Object} Sandbox instance
+   */
+  createSandbox() {
+    // Crear container temporal
+    const container = document.createElement('div');
+    container.className = 'wu-sandbox-container';
+    container.style.display = 'none';
+
+    // Crear shadow root
+    const shadowRoot = container.attachShadow({ mode: 'open' });
+
+    // Crear mount point dentro del shadow
+    const mountPoint = document.createElement('div');
+    mountPoint.className = 'wu-mount-point';
+    shadowRoot.appendChild(mountPoint);
+
+    const sandbox = {
+      id: `sandbox_${this.totalCreated++}`,
+      container,
+      shadowRoot,
+      mountPoint,
+      createdAt: Date.now(),
+      lastUsed: Date.now(),
+      timesUsed: 0,
+      currentApp: null
+    };
+
+    console.log(`[WuSandboxPool] Created sandbox: ${sandbox.id}`);
+
+    return sandbox;
+  }
+
+  /**
+   * 🔓 ACQUIRE: Obtener sandbox del pool
+   * @param {string} appName - Nombre de la app
+   * @returns {Object} Sandbox instance
+   */
+  acquire(appName) {
+    // Verificar si ya tiene un sandbox
+    if (this.inUse.has(appName)) {
+      console.warn(`[WuSandboxPool] App "${appName}" already has a sandbox`);
+      return this.inUse.get(appName);
+    }
+
+    let sandbox;
+
+    // Intentar reutilizar sandbox disponible
+    if (this.available.length > 0) {
+      sandbox = this.available.pop();
+      this.totalReused++;
+
+      console.log(`[WuSandboxPool] ♻️ Reusing sandbox ${sandbox.id} for ${appName}`);
+    }
+    // Si no hay disponibles y no excedemos máximo, crear nuevo
+    else if (this.inUse.size < this.config.maxSize) {
+      sandbox = this.createSandbox();
+
+      console.log(`[WuSandboxPool] 🆕 Creating new sandbox ${sandbox.id} for ${appName}`);
+    }
+    // Si excedemos máximo, crear temporal (no pooleable)
+    else {
+      sandbox = this.createSandbox();
+      sandbox.temporary = true;
+
+      console.warn(`[WuSandboxPool] ⚠️ Pool exhausted, creating temporary sandbox for ${appName}`);
+    }
+
+    // Preparar sandbox para uso
+    this.prepareSandbox(sandbox, appName);
+
+    // Marcar como en uso
+    sandbox.currentApp = appName;
+    sandbox.lastUsed = Date.now();
+    sandbox.timesUsed++;
+
+    this.inUse.set(appName, sandbox);
+
+    return sandbox;
+  }
+
+  /**
+   * 🔒 RELEASE: Liberar sandbox al pool
+   * @param {string} appName - Nombre de la app
+   */
+  release(appName) {
+    const sandbox = this.inUse.get(appName);
+
+    if (!sandbox) {
+      console.warn(`[WuSandboxPool] App "${appName}" has no sandbox to release`);
+      return;
+    }
+
+    // Limpiar sandbox
+    this.cleanSandbox(sandbox);
+
+    // Remover de uso
+    this.inUse.delete(appName);
+    sandbox.currentApp = null;
+    sandbox.lastUsed = Date.now();
+
+    // Si es temporal, destruir
+    if (sandbox.temporary) {
+      this.destroySandbox(sandbox);
+      console.log(`[WuSandboxPool] 🗑️ Destroyed temporary sandbox ${sandbox.id}`);
+      return;
+    }
+
+    // Si pool no está lleno, devolver al pool
+    if (this.available.length < this.config.maxSize) {
+      this.available.push(sandbox);
+      console.log(`[WuSandboxPool] ✅ Released sandbox ${sandbox.id} back to pool`);
+    }
+    // Si pool está lleno, destruir
+    else {
+      this.destroySandbox(sandbox);
+      console.log(`[WuSandboxPool] 🗑️ Pool full, destroyed sandbox ${sandbox.id}`);
+    }
+  }
+
+  /**
+   * 🔧 PREPARE SANDBOX: Preparar sandbox para uso
+   * @param {Object} sandbox - Sandbox instance
+   * @param {string} appName - Nombre de la app
+   */
+  prepareSandbox(sandbox, appName) {
+    // Mostrar container
+    sandbox.container.style.display = 'block';
+
+    // Agregar identificador de app
+    sandbox.container.setAttribute('data-wu-app', appName);
+
+    console.log(`[WuSandboxPool] Prepared sandbox ${sandbox.id} for ${appName}`);
+  }
+
+  /**
+   * 🧹 CLEAN SANDBOX: Limpiar sandbox para reutilización
+   * @param {Object} sandbox - Sandbox instance
+   */
+  cleanSandbox(sandbox) {
+    // Limpiar contenido del mount point
+    if (sandbox.mountPoint) {
+      sandbox.mountPoint.innerHTML = '';
+    }
+
+    // Limpiar estilos del shadow root
+    if (sandbox.shadowRoot) {
+      const styles = sandbox.shadowRoot.querySelectorAll('style');
+      styles.forEach(style => style.remove());
+    }
+
+    // Ocultar container
+    sandbox.container.style.display = 'none';
+
+    // Remover identificador de app
+    sandbox.container.removeAttribute('data-wu-app');
+
+    console.log(`[WuSandboxPool] Cleaned sandbox ${sandbox.id}`);
+  }
+
+  /**
+   * 💥 DESTROY SANDBOX: Destruir sandbox completamente
+   * @param {Object} sandbox - Sandbox instance
+   */
+  destroySandbox(sandbox) {
+    // Limpiar contenido
+    this.cleanSandbox(sandbox);
+
+    // Remover del DOM si está adjuntado
+    if (sandbox.container.parentNode) {
+      sandbox.container.parentNode.removeChild(sandbox.container);
+    }
+
+    // Limpiar referencias
+    sandbox.shadowRoot = null;
+    sandbox.mountPoint = null;
+    sandbox.container = null;
+
+    console.log(`[WuSandboxPool] Destroyed sandbox ${sandbox.id}`);
+  }
+
+  /**
+   * ⏰ START CLEANUP TIMER: Iniciar limpieza periódica
+   */
+  startCleanupTimer() {
+    // Limpiar timer anterior si existe
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+    }
+
+    // Limpiar cada minuto
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupIdleSandboxes();
+    }, 60000);
+  }
+
+  /**
+   * 🧹 CLEANUP IDLE SANDBOXES: Limpiar sandboxes inactivos
+   */
+  cleanupIdleSandboxes() {
+    const now = Date.now();
+    const threshold = now - this.config.idleTimeout;
+
+    // Filtrar sandboxes que no han sido usados recientemente
+    const toKeep = [];
+    const toDestroy = [];
+
+    this.available.forEach(sandbox => {
+      if (sandbox.lastUsed < threshold && this.available.length > this.config.minSize) {
+        toDestroy.push(sandbox);
+      } else {
+        toKeep.push(sandbox);
+      }
+    });
+
+    // Destruir sandboxes idle
+    toDestroy.forEach(sandbox => {
+      this.destroySandbox(sandbox);
+    });
+
+    this.available = toKeep;
+
+    if (toDestroy.length > 0) {
+      console.log(`[WuSandboxPool] 🧹 Cleaned up ${toDestroy.length} idle sandboxes`);
+    }
+
+    // Si quedamos por debajo del mínimo, crear nuevos
+    if (this.available.length < this.config.minSize) {
+      const needed = this.config.minSize - this.available.length;
+      console.log(`[WuSandboxPool] Creating ${needed} sandboxes to maintain minimum`);
+
+      for (let i = 0; i < needed; i++) {
+        this.available.push(this.createSandbox());
+      }
+    }
+  }
+
+  /**
+   * ⚙️ CONFIGURE: Configurar pool
+   * @param {Object} config - Nueva configuración
+   */
+  configure(config) {
+    const oldMinSize = this.config.minSize;
+
+    this.config = {
+      ...this.config,
+      ...config
+    };
+
+    // Si aumentó el minSize, crear más sandboxes
+    if (this.config.minSize > oldMinSize) {
+      const needed = this.config.minSize - this.available.length;
+      if (needed > 0) {
+        console.log(`[WuSandboxPool] Creating ${needed} sandboxes for new minSize`);
+        for (let i = 0; i < needed; i++) {
+          this.available.push(this.createSandbox());
+        }
+      }
+    }
+
+    // Si disminuyó el minSize o maxSize, limpiar exceso
+    if (this.available.length > this.config.maxSize) {
+      const excess = this.available.length - this.config.maxSize;
+      const toDestroy = this.available.splice(this.config.maxSize, excess);
+      toDestroy.forEach(sandbox => this.destroySandbox(sandbox));
+
+      console.log(`[WuSandboxPool] Destroyed ${excess} excess sandboxes`);
+    }
+
+    console.log('[WuSandboxPool] Configuration updated:', this.config);
+  }
+
+  /**
+   * 📊 GET STATS: Estadísticas del pool
+   * @returns {Object}
+   */
+  getStats() {
+    const totalSandboxes = this.available.length + this.inUse.size;
+    const utilization = totalSandboxes > 0
+      ? ((this.inUse.size / totalSandboxes) * 100).toFixed(1)
+      : 0;
+
+    const avgTimesUsed = totalSandboxes > 0
+      ? [...this.available, ...this.inUse.values()]
+          .reduce((sum, s) => sum + s.timesUsed, 0) / totalSandboxes
+      : 0;
+
+    return {
+      available: this.available.length,
+      inUse: this.inUse.size,
+      totalSandboxes,
+      utilization: `${utilization}%`,
+      totalCreated: this.totalCreated,
+      totalReused: this.totalReused,
+      reuseRate: this.totalCreated > 0
+        ? `${((this.totalReused / this.totalCreated) * 100).toFixed(1)}%`
+        : '0%',
+      avgTimesUsed: avgTimesUsed.toFixed(1),
+      config: this.config,
+      appsInUse: Array.from(this.inUse.keys())
+    };
+  }
+
+  /**
+   * 🧹 CLEANUP: Limpiar todo el pool
+   */
+  cleanup() {
+    // Detener cleanup timer
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+
+    // Destruir todos los sandboxes disponibles
+    this.available.forEach(sandbox => this.destroySandbox(sandbox));
+    this.available = [];
+
+    // Destruir sandboxes en uso (forzado)
+    this.inUse.forEach((sandbox, appName) => {
+      console.warn(`[WuSandboxPool] Force destroying sandbox for active app: ${appName}`);
+      this.destroySandbox(sandbox);
+    });
+    this.inUse.clear();
+
+    console.log('[WuSandboxPool] 🧹 Pool cleaned up');
+  }
+}