Node.js pm2 can'；t fork nodejs包含源集群代码

我的应用程序内部使用originnodejs集群代码，由节点运行。/dist/main.js 但是当我使用pm2启动时出错。/dist/main.js

//my code

import cluster from 'cluster'
import http from 'http'

if(cluster.isMaster){
    (async()=>{
        const master = await (await import('./master'))
        async function onMsg(pid:number,type?:string,num?:number,data?:{db:any,apiName:any,args:Array<any>}){
            console.log(`master receiving message from cluster ${pid}`)
            try{
                let result = await master.publishMission(type,data)
                // console.log(`${type} finish mission and send back to koa cluster ${pid}`)
                cluster.workers[pid].send({num:num,status:true,data:result})
            }catch(err){
                cluster.workers[pid].send({num:num,err})
            }
        }
        //cluster nums
        for(let i=0;i<1;i++){
            cluster.fork()
        }
        cluster.on('message',(worker,msg)=>{
            onMsg(worker.id,...msg)
        })
        cluster.on('exit', (worker, code, signal) => {
            console.log('worker %d died (%s). restarting...',worker.process.pid, signal || code);
            cluster.fork();
          });
    })()
}else{
    (async()=>{
        const app = await (await import('./app')).app
        try{
            http.createServer(app).listen(5000)`enter code here`
            console.log("fork new koa server",process.pid)
        }catch(err){
            console.log(err)
        }
    })()
}

//我的代码
从“群集”导入群集
从“http”导入http
if（cluster.isMaster）{
（异步（）=>{
const master=await（等待导入（'./master'））
异步函数onMsg（pid:number，type？：string，num？：number，data？：{db:any，apiName:any，args:Array}）{
log（`master receiving message from cluster${pid}`）
试一试{
让结果=等待主发布（类型、数据）
//控制台.log（$${Type }完成任务，并返回到膝关节炎簇${PID }）
cluster.workers[pid].send（{num:num，状态：true，数据：result}）
}捕捉（错误）{
cluster.workers[pid].send（{num:num，err}）
}
}
//群集NUM
for（设i=0；i{
onMsg（worker.id，…msg）
})
cluster.on（'exit'，（工作者、代码、信号）=>{
console.log（'worker%d已死亡（%s）。正在重新启动…'，worker.process.pid，信号| |代码）；
cluster.fork（）；
});
})()
}否则{
（异步（）=>{
const app=await（等待导入（'./app'））.app
试一试{
http.createServer（app.listen（5000）`在这里输入代码`
控制台.log（“叉新膝关节炎”服务器，进程，PID）
}捕捉（错误）{
console.log（错误）
}
})()
}

//错误日志 TypeError:找到不可调用的@@iterator 在黄昏时分。（C:\Users\yany\project\Jmrh_Warehouse\src\main.ts:22:13） 在EventEmitter.emit（events.js:315:20） 在工人那里。（内部/cluster/master.js:174:13） 在Worker.emit（events.js:315:20） 在这个过程中。（internal/cluster/worker.js:32:12） 在ChildProcess.emit（events.js:315:20） 在发射时（内部/子进程js:903:12） 在处理和拒绝时（内部/process/task_queues.js:81:21） TypeError:找到不可调用的@@iterator 在黄昏时分。（C:\Users\yany\project\Jmrh_Warehouse\src\main.ts:22:13） 在EventEmitter.emit（events.js:315:20） 在工人那里。（内部/cluster/master.js:174:13） 在Worker.emit（events.js:315:20） 在这个过程中。（internal/cluster/worker.js:32:12） 在ChildProcess.emit（events.js:315:20） 在发射时（内部/子进程js:903:12）

---

在processTicksAndRejections（internal/process/task_queues.js:81:21）

pm2在内部实现集群

所以端口共享可能有问题

其中：

dist/main.js

是

(async()=>{
        const app = await (await import('./app')).app
        try{
            http.createServer(app).listen(5000)`enter code here`
            console.log("fork new koa server",process.pid)
        }catch(err){
            console.log(err)
        }
    })()

pm2 start dist/main.js-i max

可能有效<代码>-i以群集模式启动pm2

---

通过使用

pm2 start dist/main.js-i 1

此错误结束

因此，当使用pm2 fork时，它可能会禁用内部的集群消息转换

但是新的问题出现了

const master = await (await import('./master'))

这个代码不起作用

当我使用node dist/main.js时，这很好，但在pm2中无法工作

import * as cl from 'child_process'
import {EventEmitter} from 'events'

const event = new EventEmitter()
const autoReboot = false
var count = 0

console.log("fine")

interface masterStore{
    [typeOfChild:string]:{
        childGroup?:Array<cl.ChildProcess>,
        workIndex:number,
        maxNum?:number,
    }
}

var master:masterStore={}

//child process of database
master['mongodb'] = {
    childGroup:[],
    workIndex:0,
    maxNum:1
}

for(let i =0;i<master['mongodb'].maxNum;i++){
    forkNewDB()
}

function forkNewDB(){
    var db = cl.fork(`${__dirname}/data/index.js`)
    master['mongodb'].childGroup.push(db)
    db.on('exit',(signal)=>{
        console.log(`db process ${db.pid} exit with code ${signal}`)
        let index = master['mongodb'].childGroup.findIndex(el=>el.pid==db.pid)
        master['mongodb'].childGroup.splice(index,1)
        if(autoReboot){
            forkNewDB()
        }
    })
    db.on('message',async (msg:{des:string,type:string,ev:string,result?:any,err?:any,data?:any,num?:any})=>{
        if(msg.des=="res"){
            event.emit(msg.ev,{msg})
        }else{
            try{
                let result = await publishMission(msg.type,msg.data)
                db.send({des:"res",num:msg.num,status:true,data:result})
            }catch(err){
                db.send({des:"res",num:msg.num,err})
            }
            
        }
    })
}

//child process of rabbitmq
master['rabbitmq'] = {
    childGroup:[],
    workIndex:0,
    maxNum:1
}

function forkNewMQ(){
    var mq = cl.fork(`${__dirname}/mq/index.js`)
    master['rabbitmq'].childGroup.push(mq)
    mq.on('exit',(signal)=>{
        console.log(`mq process ${mq.pid} exit with code ${signal}`)
        master['rabbitmq'].childGroup.splice(0,1)
        if(autoReboot){
            forkNewMQ()
        }
    })
    mq.on('message',async (msg:{des:string,type:string,ev:string,result?:any,err?:any,data?:any,num?:any})=>{
        if(msg.des=="res"){
            event.emit(msg.ev,{msg})
        }else{
            try{
                let result = await publishMission(msg.type,msg.data)
                mq.send({des:"res",num:msg.num,status:true,data:result})
            }catch(err){
                mq.send({des:"res",num:msg.num,err})
            }
            
        }
    })
}

forkNewMQ()


//child process of redis
master['redis'] = {
    childGroup:[],
    workIndex:0,
    maxNum:1
}

function forkNewRedis(){
    var redis = cl.fork(`${__dirname}/redis/index.js`)
    master['redis'].childGroup.push(redis)
    redis.on('exit',(signal)=>{
        console.log(`redis process ${redis.pid} exit with code ${signal}`)
        let index = master['redis'].childGroup.findIndex(el=>el.pid==redis.pid)
        master['redis'].childGroup.splice(index,1)
        if(autoReboot){
            forkNewRedis()
        }
    })
    redis.on('message',async (msg:{des:string,type:string,ev:string,result?:any,err?:any,data?:any,num?:any})=>{
        if(msg.des=="res"){
            event.emit(msg.ev,{msg})
        }else{
            try{
                let result = await publishMission(msg.type,msg.data)
                redis.send({des:"res",num:msg.num,status:true,data:result})
            }catch(err){
                redis.send({des:"res",num:msg.num,err})
            }
            
        }
    })
}

forkNewRedis()

//init message publish
function publishMission(type?:string,data?:{db:any,apiName:any,args:Array<any>}):Promise<any>{
    return new Promise(async (res,rej)=>{
        try{
            let tmp = master[type].workIndex
            master[type].workIndex++
            master[type].workIndex=master[type].workIndex%master[type].maxNum
            let ev = count+""
            // console.log(`master publish mission to ${type}`)
            master[type].childGroup[tmp].send({data,ev,des:"req"})
            count++
            event.once(ev,(result)=>{
                if(!result.msg.err){
                    res(result.msg.result)
                }else{
                    rej(result.msg.err)
                }
                event.removeListener(ev,()=>{})
            })
        }catch(err){
            rej(err)
        }
    })
}


export{publishMission}

fine
child process 10116 rabbitmq is ready
fork new koa server 15948
child process 10008 create DB thread 1