Method processQueue

src/node/services/idleCompactionService.ts:184–239

()

  }

  private async processQueue(): Promise<void> {
    if (this.isProcessingQueue || this.stopped) {
      return;
    }

    this.isProcessingQueue = true;

    try {
      while (this.queue.length > 0) {
        if (this.stopped) {
          return;
        }

        const next = this.queue.shift();
        if (!next) {
          continue;
        }

        const { workspaceId, thresholdMs } = next;
        this.queuedWorkspaceIds.delete(workspaceId);
        this.activeWorkspaceIds.add(workspaceId);

        try {
          // Re-check eligibility right before execution to avoid stale queue decisions.
          const eligibility = await this.checkEligibility(workspaceId, thresholdMs, Date.now());
          if (!eligibility.eligible) {
            log.info("Skipped queued idle compaction because workspace became ineligible", {
              workspaceId,
              reason: eligibility.reason,
            });
            continue;
          }

          log.info("Executing idle compaction", {
            workspaceId,
            idleHours: thresholdMs / HOURS_TO_MS,
            remainingQueued: this.queue.length,
          });

          await this.executeIdleCompaction(workspaceId);
        } catch (error) {
          log.error("Idle compaction execution failed", { workspaceId, error });
        } finally {
          this.activeWorkspaceIds.delete(workspaceId);
        }
      }
    } finally {
      this.isProcessingQueue = false;

      // If work arrived after we exited the loop and service is still running,
      // kick processing again.
      if (!this.stopped && this.queue.length > 0) {
        void this.processQueue();
      }
    }
  }

  /**