@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

package/src/core/RequestQueue.ts

@@ -1,47 +1,21 @@
-import { type Deferred, createDeferred } from '@onekeyfe/hd-shared';
-
 import { LoggerNames, getLogger } from '../utils';
 
+import type { Deferred } from '@onekeyfe/hd-shared';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
-const OPERATION_PRE_CANCEL_TTL_MS = 30_000;
-const DEFAULT_BACKGROUND_PREEMPT_TIMEOUT_MS = 5_500;
-
 export type RequestTask = {
   id: number;
   method: BaseMethod;
   callPromise?: Deferred<any> | undefined;
   abortController?: AbortController;
-  settled: Deferred<void>;
-  released: Deferred<void>;
-};
-
-export type RequestAdmission =
-  | { status: 'reserved'; task: RequestTask }
-  | { status: 'busy'; blockingTask?: RequestTask };
-
-export type RequestAdmissionOptions = {
-  backgroundPreemptTimeoutMs?: number;
 };
 
 export default class RequestQueue {
   private requestQueue = new Map<number, RequestTask>();
 
-  private operationRequestIds = new Map<string, number>();
-
-  private pendingOperationCancellations = new Map<string, number>();
-
   private pendingCallbackTasks = new Map<string, Deferred<void>>();
 
-  private prunePendingOperationCancellations(now = Date.now()) {
-    this.pendingOperationCancellations.forEach((expiresAt, operationId) => {
-      if (expiresAt <= now) {
-        this.pendingOperationCancellations.delete(operationId);
-      }
-    });
-  }
-
   // 生成唯一请求ID
   public generateRequestId = (method?: BaseMethod) => {
     if (method && method.responseID != null) {
@@ -56,94 +30,11 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
-    method.abortSignal = abortController.signal;
-    const task = {
-      id: requestId,
-      method,
-      abortController,
-      settled: createDeferred<void>(),
-      released: createDeferred<void>(),
-    };
+    const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
-    const operationId = method.payload?.operationId;
-    if (typeof operationId === 'string' && operationId) {
-      this.operationRequestIds.set(operationId, requestId);
-      this.prunePendingOperationCancellations();
-      if (this.pendingOperationCancellations.delete(operationId)) {
-        abortController.abort();
-      }
-    }
     return task;
   }
 
-  public async admitTask(
-    method: BaseMethod,
-    options: RequestAdmissionOptions = {}
-  ): Promise<RequestAdmission> {
-    const activeTasks = Array.from(this.requestQueue.values()).filter(
-      task => task.method.connectId === method.connectId
-    );
-
-    if (method.executionPriority === 'background') {
-      if (activeTasks.length) {
-        Log.debug(
-          `Reject background method ${method.name}: device is occupied by ${activeTasks[0].method.name}`
-        );
-        return { status: 'busy', blockingTask: activeTasks[0] };
-      }
-      return { status: 'reserved', task: this.createTask(method) };
-    }
-
-    const backgroundTasks = activeTasks.filter(
-      task => task.method.executionPriority === 'background'
-    );
-    if (!backgroundTasks.length) {
-      return { status: 'reserved', task: this.createTask(method) };
-    }
-
-    Log.debug(
-      `Preempt ${backgroundTasks.length} background request(s) for user method ${method.name}`
-    );
-    backgroundTasks.forEach(task => task.abortController?.abort());
-    const timeoutMs =
-      options.backgroundPreemptTimeoutMs ??
-      Math.max(
-        DEFAULT_BACKGROUND_PREEMPT_TIMEOUT_MS,
-        ...backgroundTasks.map(task => task.method.maxAbortLatencyMs ?? 0)
-      );
-    const released = await this.waitForTasksReleased(backgroundTasks, timeoutMs);
-    if (!released) {
-      Log.warn(`Background request cleanup timed out before user method ${method.name}`);
-      return { status: 'busy', blockingTask: backgroundTasks[0] };
-    }
-
-    return { status: 'reserved', task: this.createTask(method) };
-  }
-
-  private async waitForTasksReleased(tasks: RequestTask[], timeoutMs: number) {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const timeoutPromise = new Promise<false>(resolve => {
-      timer = setTimeout(() => resolve(false), timeoutMs);
-    });
-    const releasedPromise = Promise.all(tasks.map(task => task.released.promise)).then(() => true);
-    const released = await Promise.race([releasedPromise, timeoutPromise]);
-    if (timer) {
-      clearTimeout(timer);
-    }
-    return released;
-  }
-
-  public abortOperation(operationId: string) {
-    const requestId = this.operationRequestIds.get(operationId);
-    if (requestId !== undefined) {
-      return this.abortRequest(requestId);
-    }
-    const now = Date.now();
-    this.prunePendingOperationCancellations(now);
-    this.pendingOperationCancellations.set(operationId, now + OPERATION_PRE_CANCEL_TTL_MS);
-    return false;
-  }
-
   public getTask(requestId: number): RequestTask | undefined {
     return this.requestQueue.get(requestId);
   }
@@ -186,7 +77,6 @@ export default class RequestQueue {
         count++;
       }
     });
-    this.pendingOperationCancellations.clear();
     return count;
   }
 
@@ -200,8 +90,8 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.resolve(response);
-      request.settled.resolve();
     }
+    this.releaseTask(requestId);
   }
 
   // 拒绝请求
@@ -209,22 +99,12 @@ export default class RequestQueue {
     const request = this.requestQueue.get(requestId);
     if (request) {
       request.callPromise?.reject(error);
-      request.settled.resolve();
     }
+    this.releaseTask(requestId);
   }
 
   // 删除请求
   public releaseTask(requestId: number) {
-    const task = this.requestQueue.get(requestId);
-    const operationId = task?.method.payload?.operationId;
-    if (
-      typeof operationId === 'string' &&
-      this.operationRequestIds.get(operationId) === requestId
-    ) {
-      this.operationRequestIds.delete(operationId);
-    }
-    task?.settled.resolve();
-    task?.released.resolve();
     this.requestQueue.delete(requestId);
   }