nodemailer在发送邮件后似乎并未释放TCP端口

Question

正如问题所说，我对批量邮件服务器有问题。 因此，对于背景，我们的电子邮件应用程序运行在Cron工作中，每小时发送邮件。 每12个小时，我们发送最大的大部分，大约有8个不同的组，每个组的每组中的邮件都可以在需要发送的2000-4000封邮件之间。

此应用程序是在Nodejs内置的，并使用NodeMailer来处理邮件的发送。

我已经有一段时间注意到的是，服务器本质上经常会“冻结”，并且该应用程序的内存使用量将慢慢攀升。

Windows事件日志显示了最后一次批量电子邮件的目的是运行该错误，“由于正在使用的所有此类端口，全局TCP端口空间中分配短暂端口号的请求失败了。”

我已经浏览了 documentation 在NodeMailer网站上，并

1. 使用 以下更改应用了以下更改SMTP-这仍在应用程序集中的
2. MaxMessages到Infinity中 - 我已经删除了此操作，因为它似乎没有帮助
3. 将MaxConnections设置为20-也已删除，因为
4. 使用专用的队列管理器没有区别 - 这是我的最终尝试，我选择了RabbitMQ，并应用了他们的发布/订阅模型。

RabbitMQ已提高了很多性能，但仍未解决这个问题。

发布函数

const PublishMails = (mailObj) => {
    return new Promise((resolve, reject) => {
        var publishMailResult = {};

        if (mailObj.length > 0) {
            var connection = global.RabbitMQConnection;
            connection.createChannel((err, channel) => {
                if (err) {
                    publishMailResult.Result = false;
                    publishMailResult.Message = err.stack;
                    resolve(publishMailResult);
                    //return process.exit(1);
                }

                channel.assertQueue(config.RabbitMQ.Queue_EmailQueue, {
                    durable: true
                }, err => {
                    if (err) {
                        publishMailResult.Result = false;
                        publishMailResult.Message = err.stack;
                        resolve(publishMailResult);
                        //return process.exit(1);
                    }

                    var mailData = {}

                    for (var x = 0; x < mailObj.length; x++) {
                        mailData.from = '[email protected]';
                        mailData.to = mailObj[x].Email;
                        mailData.firstName = mailObj[x].FirstName;
                        mailData.login = mailObj[x].Login;
                        mailData.email = mailObj[x].Email;
                        mailData.mailID = mailObj[x].MailID;
                        mailData.sendID = mailObj[x].SendID;
                        mailData.subject = "Email Message";
                        mailData.template = 'EmailTempLate';

                        channel.sendToQueue(config.RabbitMQ.Queue_EmailQueue, 
                       Buffer.from(JSON.stringify(mailData)), {
                            persistent: true,
                            contentType: 'application/json'
                        });

                        if (x === mailObj.length - 1) {
                            channel.close();
                            publishMailResult.Result = true;
                            publishMailResult.Message = "All mails successfully published.";
                            resolve(publishMailResult);
                        }
                    }
                });
            })
        } else {
            publishMailResult.Result = false;
            publishMailResult.Message = "No mails were received - Mails Not Published.";
            resolve(publishMailResult);
        }

    });
}

订阅函数

const SubscribeMails = (mailObj) => {
    return new Promise((resolve, reject) => {
        if (mailObj.PublishMailResult.Result == true) {
            var options = {
                viewEngine: {
                    extname: '.html',
                    layoutsDir: 'views/email/',
                    defaultLayout: 'Email_Template'
                },
                viewPath: 'views/email',
                extName: '.html'
            };

            var transporter = nodemailer.createTransport(smtpTransport({
                host: 'XXX.XXX.XXX.XX',
                port: 25,
                pool: true
            }));

            transporter.use('stream', require('nodemailer-dkim').signer({
                domainName: 'XXX.com',
                keySelector: 'main',
                privateKey: 'XXXX'
            }));

            transporter.use('compile', hbs(options));

            var connection = global.RabbitMQConnection;
            connection.createChannel((err, channel) => {
                if (err) {
                    console.error(err.stack);
                    return process.exit(1);
                }

                channel.assertQueue(config.RabbitMQ.Queue_EmailQueue, {
                    durable: true
                }, err => {
                    if (err) {
                        console.error(err.stack);
                        return process.exit(1);
                    }

                    channel.prefetch(1);

                    channel.consume(config.RabbitMQ.Queue_EmailQueue, data => {

                        if (data === null) {
                            return;
                        }

                        let mail = JSON.parse(data.content.toString());
                        transporter.sendMail({
                            from: mail.from,
                            to: mail.to,
                            subject: mail.subject,
                            template: mail.template,
                            context: {
                                FirstName: mail.firstName,
                                Email: mail.email,
                                MailID: mail.mailID,
                                SendID: mail.sendID,
                            }
                        }, (err, info) => {
                            if (err) {
                                console.error(err.stack);
                                return channel.nack(data);
                            }

                            channel.ack(data);

                            channel.checkQueue(config.RabbitMQ.Queue_EmailQueue, function (checkErr, queueData) {
                                if (queueData != null) {
                                    if (queueData.messageCount == 0) {
                                        channel.close();
transporter.close(); // Added in to test if this free's up TCP ports - Didn't help
                                    }
                                }
                            });
                        });
                    });

                    resolve(true);
                });
            });
        }
    });
}

确实感觉就像我要以某种方式手动关闭这些TCP连接，但是我还没有在文档中看到任何有关此内容的内容，或者在我见过的任何示例代码上都没有看到它。

我正在添加启动此过程的Cron作业，以帮助调试此问题。

var cronPCSec = '0';
var cronPCMin = '58';
var cronPCHour = '*';
var cronPCDay = '*';
var cronPCMonth = '*';
var cronPCDayOfWeek = '0-6';
var cronPCfulltimes = "" + cronPCSec + " " + cronPCMin + " " + cronPCHour + " " + cronPCDay + " " + cronPCMonth + " " + cronPCDayOfWeek + "";


var MailerCronJob = new CronJob({
    cronTime: cronPCfulltimes,
    onTick: function () {
        let objCronJob = {};

        modelPC.GetMails().then(function (mail) {
            return mail;
        }).then(PublishMails).then(function (PublishResult) {
            objCronJob.PublishMailResult = PublishResult;
            return objCronJob;
        }).then(SubscribeMails).then(function (result) {
            console.log("Completed Successfully");
        }).catch(err => {
            console.log("Failed");
            console.log(err)
        });
    },
    start: false
});

MailerCronJob.start();

谢谢