Node.js Lambda中的NodeJS Async不会运行所有条目

我有一个NodeJs10 Lambda函数来解析数据库中的条目，并将它们保存回数据库。当我在本地运行它时，它会解析所有条目。当我在Lambda函数中运行它时，它只解析3-4个条目。我最好的猜测是Lambda以不同的方式处理异步调用，并认为所有条目都已解析

如何使Lambda函数在关闭之前运行所有条目

我的代码全局如下所示：

'use strict';

// Packages
var Mercury = require('@postlight/mercury-parser');
var Mysql = require('mysql');

// All necessery sql Queries
var sqlSelect = "Select some stuff";
var sqlUpdateText = "Update some stuff";

exports.handler = async function(event, context) {
    // Define the database used in pools
    var pool = Mysql.createPool({
    });

    // Promise where the links and id's are fetched from the database
    let fetchLink = new Promise((resolve, reject) => {
        pool.getConnection((err, connection) => {   // Connection with the database
        });
    });

    // After getting the links and id's, parse the text from the links and put them in a JSON object
    return fetchLink.then(async function (dbresult) {
        if (dbresult.length > 0) {
            await parser();
        }
        return textObj;
    })
    // After parsing
        .then(function (textObj) {
            if (Object.getOwnPropertyNames(textObj).length !== 0) {
                pool.getConnection((err, connection) => {
                    if (err) throw err;
                    for (let id in textObj) {
                        // Do some db stuff
                    }
                    connection.release();
                    pool.end();
                });
            } else {
                pool.end();
            }
        })
        // Catch the error message's
        .catch(function (err) {
            console.log(err);
            pool.end();
        });
};

---

当您不使用Wait anywhere时，处理程序函数不需要是异步的。如果您返回promise，它无论如何都是异步的。我不确定

fetchLink

promise的具体外观，但这里它什么也不解决/拒绝，所以函数可能在超时时完成。米比，你需要像这样修理它

    let fetchLink = new Promise((resolve, reject) => {
        pool.getConnection((err, connection) => {   // Connection with the database
            if(err) reject(err);
            resolve(connection);
        });
    });

另外，若您想确保处理程序函数在释放连接和结束池后完成，那个么在解析和捕获错误之后也最好返回承诺

    .then(function (textObj) {
        return new Promise((resolve, reject) => {
            if (Object.getOwnPropertyNames(textObj).length !== 0) {
                pool.getConnection((err, connection) => {
                    if (err) return reject(err);
                    for (let id in textObj) {
                        // Do some db stuff
                    }
                    connection.release();
                    pool.end();
                    resolve();
                });
            } else {
                pool.end();
                resolve();
            }
        }    
    })

---

如果

connection.release（）

和

pool.end（）

函数是承诺或有回调，也应该绑定在承诺中并等待。Lambda不会等待

fetchLink.then（）

完成。在您的情况下，在

fetchLink之前添加
wait
。然后（）

将完成此工作

// After getting the links and id's, parse the text from the links and put them in a JSON object
    return await fetchLink.then(async function (dbresult) {
        if (dbresult.length > 0) {
            await parser();
        }
        return textObj;
    })

如果上述解决方案仍然不能解决您的问题。检查调用异步api的回调是否已正确处理

// After parsing
        .then(function (textObj) {
            if (Object.getOwnPropertyNames(textObj).length !== 0) {
                // HANDLE THIS ASYNC OR IT WILL NOT BE WAITED BY LAMBDA
                pool.getConnection((err, connection) => {
                    if (err) throw err;
                    for (let id in textObj) {
                        // Do some db stuff
                    }
                    connection.release();
                    pool.end();
                });
            } else {
                pool.end();
            }
        })

文件：