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

5.0 KB
Raw Blame
import { isNil } from '@activepieces/core-utils'
import { ApEdition, createRpcServer, PrincipalType, WebsocketServerEvent, WorkerMachineHealthcheckRequest, WorkerToApiContract } from '@activepieces/shared'
import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod'
import { StatusCodes } from 'http-status-codes'
import { z } from 'zod'
import { securityAccess } from '../../core/security/authorization/fastify-security'
import { websocketService } from '../../core/websockets.service'
import { system } from '../../helper/system/system'
import { QueueName } from '../job'
import { jobBroker } from '../job-queue/job-broker'
import { jobQueue } from '../job-queue/job-queue'
import { createHandlers } from '../rpc/worker-rpc-service'
import { workerGroupQueues } from '../worker-groups/worker-group-queues'
import { machineService } from './machine-service'

export const workerMachineController: FastifyPluginAsyncZod = async (app) => {

    websocketService.addListener(PrincipalType.WORKER, WebsocketServerEvent.FETCH_WORKER_SETTINGS, (socket) => {
        return async (request: WorkerMachineHealthcheckRequest, _principal, _projectId, callback?: (data: unknown) => void) => {
            const rawWorkerGroupValue = socket.handshake.auth?.workerGroupId
            // AP_PROJECT_WORKER is deprecated in favor of AP_WORKER_GROUP_SCOPE but kept for backward compatibility.
            const projectWorker = socket.handshake.auth?.projectWorker === true
            const rawWorkerGroupScope = socket.handshake.auth?.workerGroupScope
            const scope = workerGroupQueues.resolveScope({
                projectWorker,
                scope: typeof rawWorkerGroupScope === 'string' ? rawWorkerGroupScope : undefined,
            })
            const assignment = workerGroupQueues.parseWorkerGroupValue({
                value: typeof rawWorkerGroupValue === 'string' ? rawWorkerGroupValue : undefined,
                scope,
            })
            const response = await machineService(app.log).onConnection(request, assignment)
            callback?.(response)
            createRpcServer<WorkerToApiContract>(socket, createHandlers(app.log, assignment, socket), app.log)
        }
    })

    websocketService.addListener(PrincipalType.WORKER, WebsocketServerEvent.DISCONNECT, (socket) => {
        return async (_request: unknown, _principal) => {
            // Return jobs dispatched to THIS connection that it never reported done — they sit
            // orphaned in BullMQ `active` otherwise (graceful drain can't reach a job the worker never
            // received), which inflated active past concurrency during deploys. Scoped to socket.id,
            // not the stable workerId: a late disconnect for an old socket must not reclaim the jobs a
            // reconnected socket (same workerId) has already polled.
            await jobBroker(app.log).releaseConnectionJobs(socket.id)
            await machineService(app.log).onDisconnect({ workerId: socket.handshake.auth.workerId })
        }
    })

    app.get('/', ListWorkersParams, async (request) => {
        return machineService(app.log).list(request.principal.platform.id)
    })

    app.get('/queue-metrics', QueueMetricsParams, async () => {
        const allQueues = jobQueue(app.log).getAllQueues()
        const counts = await Promise.all(
            allQueues.map(async (queue) => {
                const jobCounts = await queue.getJobCounts('waiting', 'active', 'prioritized')
                return { name: queue.name, waiting: jobCounts.waiting + jobCounts.prioritized, active: jobCounts.active }
            }),
        )
        return { queues: counts }
    })

    if (system.getEdition() !== ApEdition.CLOUD) {
        app.get('/queue-metrics/prometheus/:queueName?', PrometheusQueueMetricsParams, async (request, reply) => {
            const queue = jobQueue(app.log).getAllQueues().find((q) => q.name === request.params.queueName)
            if (isNil(queue)) {
                return reply.status(StatusCodes.NOT_FOUND).send({ message: 'Queue not found' })
            }
            return reply.type('text/plain').send(await queue.exportPrometheusMetrics())
        })
    }
}


const ListWorkersParams = {
    config: {
        security: securityAccess.platformAdminOnly([PrincipalType.USER, PrincipalType.SERVICE]),
    },
}

const QueueMetricsParams = {
    config: {
        security: securityAccess.platformAdminOnly([PrincipalType.USER, PrincipalType.SERVICE]),
    },
    schema: {
        tags: ['worker-machines'],
        response: {
            200: z.object({
                queues: z.array(z.object({
                    name: z.string(),
                    waiting: z.number(),
                    active: z.number(),
                })),
            }),
        },
    },
}

const PrometheusQueueMetricsParams = {
    config: {
        security: securityAccess.platformAdminOnly([PrincipalType.USER, PrincipalType.SERVICE]),
    },
    schema: {
        params: z.object({
            queueName: z.string().default(QueueName.WORKER_JOBS),
        }),
    },
}