Question

我创建了一个API，该API调用get cloudWatch AWS API并返回可在我的应用程序中绘制的数据点。每个包装都有单独的路线（如下面的路线代码所示）。该API使用REST MVC方法。

所以我正在使用我的函数做几件事。

从SQLite3数据库读取EC2实例数据以进行抓取有关正在运行的实例的信息（IP，instance_id， instance_launchtime），以便可以将其放入所需的参数中来自AWS开发工具包的getMetricStatistics API。
然后将来自步骤1的此数据放入参数数组（其中3个响应3个不同的度量标准数据点）。这会循环遍历每个参数，将其插入到getMetricStatistics API中（一个接一个的getMetricStatistics不一次接受多个度量），以获取该实例的数据点并将其推送到数组。

我相信数据库是异步的，这就是为什么我对它附加了一个承诺。 当我将端点加载到浏览器中时，它将一直加载并且不会显示任何数据。但是，当我刷新页面时，它会正确显示所有结果...

这是我的API控制器：

// Return results sent from Cloud Watch API
const InsightModel = require('../models/insight.model.js');
const cloudWatch = InsightModel.cloudWatch;
const CWParams = InsightModel.CWParams;
const packageById = InsightModel.packageById;

let cpuUtilParam;
let cpuCBParam;
let cpuCUParam;
let insightParams = [];
let metricResults = [];
exports.getAnalytics = (req, res) => {
  const currentDate = new Date().toISOString();
  let promise1 = new Promise((resolve, reject) => {
    packageById(req.params.packageKey, (err, data) => {
      if (err) {
        reject(
          res.status(500).send({
            message:
              err.message ||
              'Error while getting the insight configuration data.',
          })
        );
      } else {
        cpuUtilParam = new CWParams(
          currentDate,
          'CPUUtilization',
          'AWS/EC2',
          data[0].launch_time,
          data[0].instance_id
        );
        cpuCBParam = new CWParams(
          currentDate,
          'CPUCreditBalance',
          'AWS/EC2',
          data[0].launch_time,
          data[0].instance_id
        );
        cpuCUParam = new CWParams(
          currentDate,
          'CPUCreditUsage',
          'AWS/EC2',
          data[0].launch_time,
          data[0].instance_id
        );
        insightParams = [cpuUtilParam, cpuCBParam, cpuCUParam];
          resolve(insightParams);
      }
    });
  })
  let promise2 = new Promise((resolve, reject) => {
    insightParams.forEach(metric => {
      cloudWatch.getMetricStatistics(metric, function(err, data) {
        if (err) {
          reject(
            res.status(500).send({
              messaage:
                err.message ||
                'Error occured while running cloudWatch getMetricStatistcs API: ',
            })
          );
        } else {
          metricResults.push(data);
          if (metricResults.length === insightParams.length)
            resolve(metricResults);
        }
      });
    });
  });

  Promise.all([promise1, promise2])
    .then(metricResults => {
      res.send(metricResults);
      console.log('AWS CW API successful');
    })
    .catch(err => {
      res.status(500).send({
        messaage:
          err.message ||
          'Error occured while reading in a promise from cloudWatch getMetricStatistcs API: ',
      })
    });
  metricResults = [];
};

API的模型：

// Call AWS Cost Explorer API
const AWS = require('aws-sdk');
const config = require('./AWSconfig');
const database = require('./db');

const insightdb = database.insightdb;

AWS.config.update({
  accessKeyId: config.accessKeyId,
  secretAccessKey: config.secretAccessKey,
  region: config.region,
});

//Linking AWS CloudWatch Service
var cloudWatch = new AWS.CloudWatch();

const packageById = (packageId, callback) => {
  insightdb.all(
    'SELECT * FROM ec2Instance WHERE package_id == ?',
    packageId,
    (err, rows) => {
      if (err) {
        callback(err, null);
      } else {
        callback(null, rows);
      }
    }
  );
};

// Parameter class to feed into the CloudWatch getMetricStatistics function
const CWParams = function(reqDate, metricName,service,launchTime,instanceId) {
  (this.EndTime = reqDate) /* required */,
    (this.MetricName = metricName) /* required */,
    (this.Namespace = service) /* required */,
    (this.Period = 3600) /* required */,
    (this.StartTime = launchTime) /* ${createDate}`, required */,
    (this.Dimensions = [
      {
        Name: 'InstanceId' /* required */,
        Value: instanceId /* required */,
      },
    ]),
    (this.Statistics = ['Maximum']);
};

//Exports variables to the controller (so they can be re-used)
module.exports = { cloudWatch, CWParams, packageById };

API的路由：

module.exports = app => {
  const insight = require('../controllers/insight.controller.js');
  app.get('/insights/aws/:packageKey', insight.getAnalytics);
};

Answer 1

就目前而言，在第二个Promise构造函数中，由于insightParams = [.....]在异步调用的回调中，因此可以保证InsightParams尚未编写。因此，程序流程需要确保所有“ promise2”内容仅在满足“ promise1”之后才会发生。

如果异步函数以尽可能低的级别“承诺”，那么在更高级别的代码中事情将变得简单得多。在模型中做两件事：

承诺cloudWatch.getMetricStatistics()
编写packageById（）返回Promise而不是接受回调。

模型因此变为：

const AWS = require('aws-sdk'); // no change
const config = require('./AWSconfig'); // no change
const database = require('./db'); // no change

const insightdb = database.insightdb; // no change

AWS.config.update({
    accessKeyId: config.accessKeyId,
    secretAccessKey: config.secretAccessKey,
    region: config.region
}); // no change

var cloudWatch = new AWS.CloudWatch(); // no change

// Promisify cloudWatch.getMetricStatistics() as  cloudWatch.getMetricStatisticsAsync().
cloudWatch.getMetricStatisticsAsync = (metric) => {
    return new Promise((resolve, reject) => {
        cloudWatch.getMetricStatistics(metric, function(err, data) {
            if (err) {
                if(!err.message) { // Probably not necessary but here goes ...
                    err.message = 'Error occured while running cloudWatch getMetricStatistcs API: ';
                }
                reject(err); // (very necessary)
            } else {
                resolve(data);
            }
        });
    });
};

// Ensure that packageById() returns Promise rather than accepting a callback.
const packageById = (packageId) => {
    return new Promise((resolve, reject) => {
        insightdb.all('SELECT * FROM ec2Instance WHERE package_id == ?', packageId, (err, rows) => {
            if (err) {
                reject(err);
            } else {
                resolve(rows);
            }
        });
    });
};

现在getAnalytics()可以这样写：

exports.getAnalytics = (req, res) => {
    packageById(req.params.packageKey)
    .then(data => {
        const currentDate = new Date().toISOString();
        let insightParams = [
            new CWParams(currentDate, 'CPUUtilization', 'AWS/EC2', data[0].launch_time, data[0].instance_id),
            new CWParams(currentDate, 'CPUCreditBalance', 'AWS/EC2', data[0].launch_time, data[0].instance_id),
            new CWParams(currentDate, 'CPUCreditUsage', 'AWS/EC2', data[0].launch_time, data[0].instance_id)
        ];
        // Composition of `insightParams` is synchronous so you can continue 
        // with the `cloudWatch.getMetricStatisticsAsync()` stuff inside the same .then().
        return Promise.all(insightParams.map(metric => cloudWatch.getMetricStatisticsAsync(metric))); // Simple because of the Promisification above.
    }, err => {
        // This callback handles error from packageById() only,
        // and is probably unnecessary but here goes ...
        if(!err.message) {
            err.message = 'Error while getting the insight configuration data.';
        }
        throw err;
    })
    .then(metricResults => {
        res.send(metricResults);
        console.log('AWS CW API successful');
    })
    .catch(err => {
        // Any async error arising above will drop through to here.
        res.status(500).send({
            'message': err.message
        }));
    });
};

请注意，每个res.status(500).send()都不需要多个捕获。沿Promise链传播的错误允许单个终端.catch()

兑现承诺不适用于AWS开发工具包

1 个答案: