web-dc-api 0.0.66 → 0.0.68

package/lib/common/dcutil.ts

@@ -439,8 +439,9 @@ export class DcUtil {
     const nodeConn = await libp2p.dial(nodeAddr, {
       signal: AbortSignal.timeout(dial_timeout)
     });
-    //判断是否有现成的stream,如果已经存在就直接使用
+     //判断是否有现成的stream,如果已经存在就直接使用
    const stream = await nodeConn.newStream("/dc/transfer/1.0.0")
+  try{
    const writer =  new StreamWriter(stream.sink) 
    const mParts: Uint8Array[] = [];
     let parsedMessage: { type: number; version: number; payload: Uint8Array } | null = null;
@@ -508,9 +509,15 @@ export class DcUtil {
         }
       }
     }
+  }catch(err){
+    console.error("createTransferStream error:", err);
+    throw err
+  }finally{
     stream.close()
   }
 
+  }
+
 
    private async *chunkGenerator(stream: Stream): AsyncGenerator<Uint8Array> {
     const iterator = stream.source[Symbol.asyncIterator]();

package/lib/common/service-worker.ts

@@ -6,60 +6,57 @@ import { createLogger } from "../util/logger";
 
 const logger = createLogger('ServiceWorker');
 
+
+let swMessageHandler: ((event: MessageEvent) => void) | null = null;
+
 /**
  * 注册 Service Worker 并设置消息监听器
  * @param fileOps 文件操作对象，用于处理IPFS请求
  * @returns Promise<ServiceWorkerRegistration | null>
  */
 export async function registerServiceWorker(fileOps?: IFileOperations, swUrl: string = ''): Promise<ServiceWorkerRegistration | null> {
-  if ('serviceWorker' in navigator) {
-    try {
-      // const registration = await navigator.serviceWorker.register(
-      //   new URL('/sw.js', import.meta.url).href
-      // );
-      if (window.location.protocol != 'https:' && window.location.hostname != 'localhost') {
-        logger.error('ServiceWorker 仅支持https协议');
-        return null;
-      }
-      
-      // 路径在函数内部解析，不在模块顶层
-      const swPath = typeof window !== 'undefined' 
-      ? (new URL(swUrl || '/sw.js', window.location.origin).href)
-      : '/sw.js';
-      
-      const registration = await navigator.serviceWorker.register(swPath);
-       // 让等待中的 SW 立即成为激活态
-      if (registration.waiting) {
-        registration.waiting.postMessage({ type: 'SKIP_WAITING' });
-      }
-       // 有新 SW 安装后自动接管
-      registration.addEventListener('updatefound', () => {
-        const nw = registration.installing;
-        if (!nw) return;
-        nw.addEventListener('statechange', () => {
-          if (nw.state === 'installed' && navigator.serviceWorker.controller) {
-            nw.postMessage({ type: 'SKIP_WAITING' });
-          }
-        });
-      });
-      // 设置消息监听器处理IPFS资源请求
-      navigator.serviceWorker.addEventListener('message', async (event) => {
-        if (event.data && event.data.type === 'ipfs-fetch') {
-           await handleIpfsRequest(event.data, event.ports[0]!, fileOps);
+  if (!('serviceWorker' in navigator)) return Promise.reject('Service Worker not supported');
+  if (location.protocol !== 'https:' && location.hostname !== 'localhost') {
+    logger.error('ServiceWorker 仅支持 https 或 localhost');
+    return null;
+  }
+  if (window.location.protocol != 'https:' && window.location.hostname != 'localhost') {
+      logger.error('ServiceWorker 仅支持https协议');
+      return null;
+    }
+    const swPath = new URL(swUrl || '/sw.js', location.origin).href;
+    const registration = await navigator.serviceWorker.register(swPath);
+    // 只保留一个监听器，避免重复处理同一请求
+    if (swMessageHandler) {
+      navigator.serviceWorker.removeEventListener('message', swMessageHandler);
+    }
+    swMessageHandler = async (event: MessageEvent) => {
+      if (event.data && event.data.type === 'ipfs-fetch') {
+        const port = event.ports?.[0];
+        if (!port) {
+          logger.warn('SW 未提供 MessagePort');
+          return;
         }
+        //里面回一个消息,通知已经收到请求
+        port.postMessage({ success: true, message: 'Request received' ,status: 999 });
+        try {
+          await handleIpfsRequest(event.data, port, fileOps);
+        } catch (e) {
+          logger.error('handleIpfsRequest 处理异常:', e);
+          port.postMessage({ success: false, error: String(e) });
+        }
+      }
+    };
+    navigator.serviceWorker.addEventListener('message', swMessageHandler);
+    // 确保 SW 已 active
+    await navigator.serviceWorker.ready;
+    // 确保当前页已被控制，否则等待接管
+    if (!navigator.serviceWorker.controller) {
+      await new Promise<void>((resolve) => {
+        navigator.serviceWorker.addEventListener('controllerchange', () => resolve(), { once: true });
       });
-      // 控制器变化（新 SW 接管）
-      navigator.serviceWorker.addEventListener('controllerchange', () => {
-        location.reload();
-      });
-      
-      return registration;
-    } catch (error) {
-      logger.error('ServiceWorker 注册失败:', error);
-      return null;
     }
-  }
-  return Promise.reject('Service Worker not supported');
+    return registration;
 }
 
 /**

package/lib/implements/threaddb/net/grpcClient.ts

@@ -324,7 +324,7 @@ export class DBGrpcClient {
       const responseData = await this.grpcClient.unaryCall(
         "/net.pb.Service/GetRecords",
         messageBytes,
-        30000
+        900000
       );
       
       // 解码响应

package/lib/implements/threaddb/net/net.ts

@@ -1333,31 +1333,39 @@ export class Network implements Net {
       
       // 创建记录收集器
       const recordCollector = new RecordCollector();
+        // 设置超时
+      let timeout : NodeJS.Timeout | null = null;
       //遍历节点,按顺序处理
       for (const peerId of peers) {
          try {
-             // 设置超时
-             const timeout = setTimeout(() => {
+           timeout = setTimeout(() => {
                throw new Error(`Timeout getting records from peer ${peerId}`);
-             }, 60000);
-
+             }, 900000);
             //连接到指定peerId,返回一个Client
             const [client,err] = await this.getClient(peerId);
             if (!client) {
-              clearTimeout(timeout);
               throw new Error(`Error getting records from peer ${peerId},no client,errinfo: ${err}`);
             }
+            console.log(`时间:${new Date().toLocaleString()} ,开始从 ${peerId.toString()} 获取记录...`);
             const dbClient = new DBClient(client,this.dc,this,this.logstore);
             const records = await dbClient.getRecordsFromPeer( req, serviceKey);
+            console.log(`时间:${new Date().toLocaleString()} ,从 ${peerId.toString()} 获取记录完成,记录数为:`,Object.keys(records).length);
+            console.log(`开始处理从 ${peerId.toString()} 获取的记录,记录数为:`,Object.keys(records).length);
             for (const [logId, rs] of Object.entries(records)) {
               await recordCollector.batchUpdate(logId, rs);
             }
-            clearTimeout(timeout);
+            console.log(`处理从 ${peerId.toString()} 获取的记录完成,记录数为:`,Object.keys(records).length);
+          
             if(!multiPeersFlag){
                break;
             }
           } catch (err) {
             continue;
+          }finally{
+            // 清除超时
+            if (timeout) {
+              clearTimeout(timeout);
+            }
           }
       }
       

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-dc-api",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "web相关的dcapi",
   "type": "module",
   "browser": "dist/dc.min.js",