Upload 10 files

backend/src/services/screenshotService.js

@@ -21,6 +21,23 @@ class ScreenshotService {
     this.playwrightPagePool = [];
     this.maxPoolSize = 3; // 最大页面池大小
     
+    // 错误容忍和重启控制
+    this.healthCheckFailures = 0;
+    this.maxHealthCheckFailures = 3; // 连续失败3次才重启
+    this.lastRestartTime = 0;
+    this.minRestartInterval = 5 * 60 * 1000; // 最小重启间隔5分钟
+    
+    // 主浏览器错误计数和故障状态
+    this.puppeteerErrorCount = 0;
+    this.maxPuppeteerErrors = 5; // 主浏览器连续错误5次后标记为故障
+    this.puppeteerFailed = false; // 主浏览器是否彻底故障
+    this.lastPuppeteerError = 0;
+    
+    // 截图缓存 - 避免重复生成
+    this.screenshotCache = new Map();
+    this.maxCacheSize = 50; // 最大缓存数量
+    this.cacheExpireTime = 10 * 60 * 1000; // 缓存10分钟过期
+    
     // 字体配置
     this.googleFonts = [
       'Noto+Sans+SC:400,700',
@@ -31,17 +48,26 @@ class ScreenshotService {
     
     // 启动时预热浏览器
     this.warmupBrowsers();
+    
+    // 启动主浏览器恢复检查
+    this.startPrimaryBrowserRecovery();
   }
   
-  // 预热浏览器实例
+  // 预热浏览器实例 - 优先启动主浏览器
   async warmupBrowsers() {
     setTimeout(async () => {
       try {
-        console.log('🔥 Warming up browser instances...');
+        console.log('🔥 Warming up primary browser (Puppeteer)...');
         await this.initPuppeteer();
-        console.log('✅ Browser warmup complete');
+        
+        if (this.puppeteerReady) {
+          console.log('✅ Primary browser warmup completed');
+        } else {
+          console.warn('⚠️ Primary browser failed to start, will use fallback when needed');
+        }
       } catch (error) {
-        console.error('❌ Browser warmup failed:', error.message);
+        console.error('❌ Primary browser warmup failed:', error.message);
+        this.puppeteerFailed = true;
       }
     }, 1000); // 延迟1秒启动，避免与服务器启动冲突
   }
@@ -226,7 +252,7 @@ class ScreenshotService {
   
   // 监控浏览器健康状态
   startBrowserMonitoring() {
-    const checkInterval = 5 * 60 * 1000; // 5分钟检查一次
+    const checkInterval = 15 * 60 * 1000; // 15分钟检查一次，减少检查频率
     
     setInterval(async () => {
       if (!this.puppeteerBrowser) return;
@@ -239,8 +265,11 @@ class ScreenshotService {
         const pages = await this.puppeteerBrowser.pages();
         console.log(`🔍 Browser health check: ${pages.length} pages open`);
         
-        // 如果页面过多，关闭多余页面
-        if (pages.length > this.maxPoolSize * 2) {
+        // 重置失败计数器
+        this.healthCheckFailures = 0;
+        
+        // 如果页面过多，关闭多余页面（提高阈值）
+        if (pages.length > this.maxPoolSize * 4) { // 从2倍提高到4倍
           console.log(`⚠️ Too many pages open (${pages.length}), cleaning up...`);
           
           // 保留页面池中的页面，关闭其他页面
@@ -254,30 +283,63 @@ class ScreenshotService {
           }
         }
       } catch (error) {
-        console.error('❌ Browser health check failed:', error.message);
+        this.healthCheckFailures++;
+        console.error(`❌ Browser health check failed (${this.healthCheckFailures}/${this.maxHealthCheckFailures}):`, error.message);
         
-        // 尝试重启浏览器
-        await this.restartBrowser();
+        // 只有连续失败多次且距离上次重启足够久才重启浏览器
+        if (this.healthCheckFailures >= this.maxHealthCheckFailures) {
+          const now = Date.now();
+          if (now - this.lastRestartTime > this.minRestartInterval) {
+            console.log('🔄 Multiple health check failures detected, attempting browser restart...');
+            await this.restartBrowser();
+          } else {
+            console.log('⏳ Browser restart skipped - too soon since last restart');
+          }
+        }
       }
     }, checkInterval);
   }
   
-  // 重启浏览器
+  // 重启浏览器 - 优先恢复主浏览器
   async restartBrowser() {
-    console.log('🔄 Attempting to restart browser...');
+    console.log('🔄 Attempting to restart primary browser...');
     
     try {
+      // 记录重启时间
+      this.lastRestartTime = Date.now();
+      
       // 清理现有资源
       await this.cleanup();
       
-      // 重新初始化
+      // 重新初始化主浏览器
       this.puppeteerReady = false;
-      this.playwrightReady = false;
+      this.puppeteerFailed = false;
+      this.puppeteerErrorCount = 0;
+      
+      // 重置失败计数器
+      this.healthCheckFailures = 0;
+      
       await this.initPuppeteer();
       
-      console.log('✅ Browser successfully restarted');
+      if (this.puppeteerReady) {
+        console.log('✅ Primary browser successfully restarted');
+        // 如果主浏览器恢复，可以关闭副浏览器以节省资源
+        if (this.playwrightBrowser) {
+          console.log('🔄 Closing secondary browser to save resources');
+          await this.playwrightBrowser.close().catch(console.error);
+          this.playwrightBrowser = null;
+          this.playwrightReady = false;
+          this.playwrightPagePool = [];
+        }
+      } else {
+        console.warn('⚠️ Primary browser restart failed, marking as failed');
+        this.puppeteerFailed = true;
+      }
     } catch (error) {
       console.error('❌ Browser restart failed:', error.message);
+      this.puppeteerFailed = true;
+      // 重启失败时也要重置计数器，避免无限重试
+      this.healthCheckFailures = 0;
     }
   }
 
@@ -408,6 +470,80 @@ class ScreenshotService {
     }
   }
 
+  // 生成缓存键
+  generateCacheKey(htmlContent, options) {
+    const { format, quality, width, height } = options;
+    // 使用内容和选项的哈希作为缓存键
+    const crypto = require('crypto');
+    const contentHash = crypto.createHash('md5').update(htmlContent).digest('hex').substring(0, 8);
+    return `${contentHash}_${width}x${height}_${format}_${quality}`;
+  }
+
+  // 清理过期缓存
+  cleanExpiredCache() {
+    const now = Date.now();
+    for (const [key, value] of this.screenshotCache.entries()) {
+      if (now - value.timestamp > this.cacheExpireTime) {
+        this.screenshotCache.delete(key);
+      }
+    }
+    
+    // 如果缓存过多，删除最旧的
+    if (this.screenshotCache.size > this.maxCacheSize) {
+      const entries = Array.from(this.screenshotCache.entries());
+      entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+      const toDelete = entries.slice(0, entries.length - this.maxCacheSize);
+      toDelete.forEach(([key]) => this.screenshotCache.delete(key));
+    }
+  }
+
+  // 主浏览器恢复检查 - 定期尝试恢复故障的主浏览器
+  startPrimaryBrowserRecovery() {
+    const recoveryInterval = 30 * 60 * 1000; // 30分钟检查一次恢复
+    
+    setInterval(async () => {
+      // 只有在主浏览器故障且副浏览器正在运行时才尝试恢复
+      if (this.puppeteerFailed && this.playwrightReady) {
+        const now = Date.now();
+        const timeSinceLastError = now - this.lastPuppeteerError;
+        
+        // 距离上次错误至少10分钟后才尝试恢复
+        if (timeSinceLastError > 10 * 60 * 1000) {
+          console.log('🔄 Attempting to recover primary browser...');
+          
+          try {
+            // 重置状态
+            this.puppeteerFailed = false;
+            this.puppeteerErrorCount = 0;
+            this.puppeteerReady = false;
+            
+            // 尝试重新初始化主浏览器
+            await this.initPuppeteer();
+            
+            if (this.puppeteerReady) {
+              console.log('✅ Primary browser successfully recovered!');
+              
+              // 关闭副浏览器以节省资源
+              if (this.playwrightBrowser) {
+                console.log('🔄 Closing secondary browser after primary recovery');
+                await this.playwrightBrowser.close().catch(console.error);
+                this.playwrightBrowser = null;
+                this.playwrightReady = false;
+                this.playwrightPagePool = [];
+              }
+            } else {
+              console.warn('⚠️ Primary browser recovery failed, will retry later');
+              this.puppeteerFailed = true;
+            }
+          } catch (error) {
+            console.error('❌ Primary browser recovery error:', error.message);
+            this.puppeteerFailed = true;
+          }
+        }
+      }
+    }, recoveryInterval);
+  }
+
   // Generate screenshot
   async generateScreenshot(htmlContent, options = {}) {
     const {
@@ -418,37 +554,88 @@ class ScreenshotService {
       timeout = 15000
     } = options;
 
+    // 检查缓存
+    const cacheKey = this.generateCacheKey(htmlContent, { format, quality, width, height });
+    const cached = this.screenshotCache.get(cacheKey);
+    
+    if (cached && (Date.now() - cached.timestamp < this.cacheExpireTime)) {
+      console.log(`📋 Using cached screenshot: ${cacheKey}`);
+      return cached.data;
+    }
+
     console.log(`📸 Generating screenshot: ${width}x${height}, ${format}@${quality}%`);
 
-    // Try Puppeteer first
-    if (!this.puppeteerReady) {
-      await this.initPuppeteer();
-    }
+    let screenshot = null;
 
-    if (this.puppeteerReady) {
-      try {
-        return await this.generateWithPuppeteer(htmlContent, { format, quality, width, height, timeout });
-      } catch (error) {
-        console.warn('Puppeteer screenshot failed, trying Playwright:', error.message);
+    // 优先使用主浏览器 (Puppeteer)
+    if (!this.puppeteerFailed) {
+      // 如果主浏览器未就绪，尝试重启（但��是每次都重启）
+      if (!this.puppeteerReady) {
+        const now = Date.now();
+        if (now - this.lastRestartTime > this.minRestartInterval) {
+          console.log('🔄 Primary browser not ready, attempting restart...');
+          await this.initPuppeteer();
+        }
       }
-    }
 
-    // Fallback to Playwright
-    if (!this.playwrightReady) {
-      await this.initPlaywright();
+      if (this.puppeteerReady) {
+        try {
+          screenshot = await this.generateWithPuppeteer(htmlContent, { format, quality, width, height, timeout });
+          // 成功时重置错误计数
+          this.puppeteerErrorCount = 0;
+        } catch (error) {
+          this.puppeteerErrorCount++;
+          this.lastPuppeteerError = Date.now();
+          
+          console.warn(`Puppeteer screenshot failed (${this.puppeteerErrorCount}/${this.maxPuppeteerErrors}):`, error.message);
+          
+          // 如果错误次数过多，标记主浏览器为故障
+          if (this.puppeteerErrorCount >= this.maxPuppeteerErrors) {
+            console.error('❌ Primary browser marked as failed after multiple errors');
+            this.puppeteerFailed = true;
+            await this.cleanup(); // 清理故障的主浏览器
+          }
+        }
+      }
     }
 
-    if (this.playwrightReady) {
-      try {
-        return await this.generateWithPlaywright(htmlContent, { format, quality, width, height, timeout });
-      } catch (error) {
-        console.warn('Playwright screenshot failed:', error.message);
+    // 只有在主浏览器故障或截图失败时才启动副浏览器
+    if (!screenshot && (this.puppeteerFailed || this.puppeteerErrorCount > 0)) {
+      console.log('🔄 Falling back to secondary browser (Playwright)...');
+      
+      if (!this.playwrightReady) {
+        await this.initPlaywright();
+      }
+
+      if (this.playwrightReady) {
+        try {
+          screenshot = await this.generateWithPlaywright(htmlContent, { format, quality, width, height, timeout });
+        } catch (error) {
+          console.warn('Playwright screenshot failed:', error.message);
+        }
       }
     }
 
     // Final fallback: generate SVG
-    console.warn('All screenshot methods failed, generating fallback SVG');
-    return this.generateFallbackImage(width, height, 'Screenshot Service', 'Browser unavailable');
+    if (!screenshot) {
+      console.warn('All screenshot methods failed, generating fallback SVG');
+      screenshot = this.generateFallbackImage(width, height, 'Screenshot Service', 'Browser unavailable');
+    }
+
+    // 缓存结果（只缓存成功的截图，不缓存fallback）
+    if (screenshot && format !== 'svg') {
+      this.screenshotCache.set(cacheKey, {
+        data: screenshot,
+        timestamp: Date.now()
+      });
+      
+      // 清理过期缓存
+      this.cleanExpiredCache();
+      
+      console.log(`💾 Cached screenshot: ${cacheKey} (cache size: ${this.screenshotCache.size})`);
+    }
+
+    return screenshot;
   }
 
   // Generate screenshot using Puppeteer with page pool optimization
@@ -531,9 +718,22 @@ class ScreenshotService {
     } finally {
       if (page) {
         if (pageFromPool && this.puppeteerPagePool.length < this.maxPoolSize) {
-          // 重置页面状态
+          // 重置页面状态并放回池中
           try {
-            await page.goto('about:blank').catch(() => {});
+            // 清理页面状态，但不导航到about:blank（减少操作）
+            await page.evaluate(() => {
+              // 清理页面内容但保持基本结构
+              if (document.body) document.body.innerHTML = '';
+              if (document.head) {
+                // 保留基本的meta标签和字体链接
+                const links = document.head.querySelectorAll('link[rel="stylesheet"]');
+                const metas = document.head.querySelectorAll('meta');
+                document.head.innerHTML = '';
+                metas.forEach(meta => document.head.appendChild(meta));
+                links.forEach(link => document.head.appendChild(link));
+              }
+            });
+            
             // 将页面放回池中
             this.puppeteerPagePool.push(page);
             console.log(`♻️ Returned Puppeteer page to pool (${this.puppeteerPagePool.length} total)`);
@@ -542,8 +742,23 @@ class ScreenshotService {
             await page.close().catch(console.error);
           }
         } else if (!pageFromPool) {
-          // 关闭非池中的页面
-          await page.close().catch(console.error);
+          // 如果池已满，尝试将新页面也加入池中（替换最旧的）
+          if (this.puppeteerPagePool.length >= this.maxPoolSize) {
+            const oldPage = this.puppeteerPagePool.shift();
+            await oldPage.close().catch(console.error);
+          }
+          
+          try {
+            // 重置新页面状态
+            await page.evaluate(() => {
+              if (document.body) document.body.innerHTML = '';
+            });
+            this.puppeteerPagePool.push(page);
+            console.log(`♻️ Added new page to pool (${this.puppeteerPagePool.length} total)`);
+          } catch (e) {
+            console.warn('⚠️ Failed to add page to pool, closing it:', e.message);
+            await page.close().catch(console.error);
+          }
         }
       }
     }