Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

3.9 KB
Raw Blame
import { isNil, tryCatch } from '@activepieces/core-utils'
import { ConsumeJobRequest } from '@activepieces/shared'
import { Worker as BullMQWorker } from 'bullmq'
import { FastifyBaseLogger } from 'fastify'
import { Socket } from 'socket.io'

const WAITER_TIMEOUT_MS = 50_000
const ERROR_RETRY_DELAY_MS = 5_000

function createQueueDispatcher(params: {
    queueName: string
    worker: BullMQWorker
    dequeue: (worker: BullMQWorker, queueName: string, log: FastifyBaseLogger) => Promise<ConsumeJobRequest | null>
    onOrphanedJob: (jobId: string, token: string, queueName: string, log: FastifyBaseLogger) => Promise<void>
    log: FastifyBaseLogger
}): QueueDispatcher {
    const { queueName, worker, dequeue, onOrphanedJob, log } = params
    const waiters: Waiter[] = []
    let loopRunning = false

    async function poll(socket?: Pick<Socket, 'connected'>): Promise<ConsumeJobRequest | null> {
        return new Promise<ConsumeJobRequest | null>((resolve) => {
            const timer = setTimeout(() => {
                const idx = waiters.findIndex(w => w.resolve === resolve)
                if (idx !== -1) {
                    waiters.splice(idx, 1)
                }
                resolve(null)
            }, WAITER_TIMEOUT_MS)

            waiters.push({ resolve, timer, socket })
            startLoop()
        })
    }

    function startLoop(): void {
        if (loopRunning) return
        loopRunning = true
        void runLoop()
    }

    async function runLoop(): Promise<void> {
        while (waiters.length > 0) {
            const { error, data: job } = await tryCatch(() => dequeue(worker, queueName, log))

            if (error) {
                log.error({ queueName, error: String(error) }, '[QueueDispatcher] dequeue error, retrying')
                await sleep(ERROR_RETRY_DELAY_MS)
                continue
            }

            if (isNil(job)) {
                if (waiters.length === 0) break
                continue
            }

            const waiter = takeConnectedWaiter()
            if (isNil(waiter)) {
                log.warn({ queueName, job: { id: job.jobId } }, '[QueueDispatcher] job dequeued but no waiter available, returning to queue')
                const { error: orphanError } = await tryCatch(() => onOrphanedJob(job.jobId, job.token, job.queueName, log))
                if (orphanError) {
                    log.error({ queueName, job: { id: job.jobId }, error: String(orphanError) }, '[QueueDispatcher] failed to return orphaned job to queue')
                }
                continue
            }

            clearTimeout(waiter.timer)
            waiter.resolve(job)
        }
        loopRunning = false
    }

    function takeConnectedWaiter(): Waiter | undefined {
        let waiter = waiters.shift()
        while (!isNil(waiter) && waiter.socket?.connected === false) {
            clearTimeout(waiter.timer)
            waiter.resolve(null)
            waiter = waiters.shift()
        }
        return waiter
    }

    function close(): void {
        for (const waiter of waiters) {
            clearTimeout(waiter.timer)
            waiter.resolve(null)
        }
        waiters.length = 0
        // Do not reset loopRunning here — the in-flight runLoop will exit
        // naturally when it sees waiters.length === 0 after dequeue returns.
    }

    function waiterCount(): number {
        return waiters.length
    }

    return { poll, close, waiterCount }
}

function sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms))
}

type Waiter = {
    resolve: (value: ConsumeJobRequest | null) => void
    timer: ReturnType<typeof setTimeout>
    socket?: Pick<Socket, 'connected'>
}

export type QueueDispatcher = {
    poll(socket?: Pick<Socket, 'connected'>): Promise<ConsumeJobRequest | null>
    close(): void
    waiterCount(): number
}

export { createQueueDispatcher, WAITER_TIMEOUT_MS, ERROR_RETRY_DELAY_MS }