Konvertieren von AWS Lambda-Funktion zu verwenden, was Sie verspricht?

Konvertieren Sie Ihre typische async-Funktion, um ein Versprechen ist ziemlich straight-forward. Ich würde eher versuchen, und zeigen, wie es zu konvertieren als den code schreiben, wie Sie lernen nicht alles aus.

In der Regel mit Knoten haben Sie etwas, das so ähnlich aussieht wie diese:

  doSomethingAsync(callback);

    function doSomethingAsync(callback){
        var err, result;
        //Do some work
        ... 

        callback(err, result);
    }
    function callback(err, result){
        if(err){
            //Handle error
        } else{
            //Success so do something with result
        }
    }

Versprechen die Verpackung eines async-Funktion in der Regel wie folgt aussieht:

var myProm = new Promise(function(resolve, reject){
     doSomethingAsync(function(err, result){       
        if(err){
            reject(err);
        } else{
            resolve(result)
        } 
     });
})
.then(function(result){
  //Success so do something with result
  console.log("Success:", result)
})
.catch(function(err){
 //Handle error
  console.log("Error: ", err);
})
.then(function(result){
   //Where's my result? - result == undefined as we didn't return anything up the chain
  console.log("I always execute but result is gone", result)
})

Übergeben das Ergebnis unten in der Kette unserer "immer dann" - Methode, die wir brauchen, um wieder ein Versprechen oder einen Wert:

var myProm = new Promise(function(resolve, reject){
         doSomethingAsync(function(err, result){       
            if(err){
                reject(err);
            } else{
                resolve(result)
            } 
         });
    })
    .then(function(result){
      //Success so do something with result
      console.log("Success:", result)
      return result;
    })
    .catch(function(err){
     //Handle error
      console.log("Error: ", err);
      return err;
    })
    .then(function(result){
      //The err/result now gets passed down the chain :)
      console.log("Oh there it is", result)
    })

Ich denke, dass mithilfe der oben genannten Muster sollten gerecht auf die meisten der asynchrone Methoden und Ereignisse in deinem code Beispiel, wenn alle, insbesondere diejenigen, die Ihnen Mühe schreiben Sie einen Kommentar und ich werde versuchen, diese spezifischen Beispiele.

Hier ist ein Versuch, konvertieren es verspricht - ich bin ziemlich müde, also entschuldige mich über alle mess-oder Fehler - auch da gibt es noch viel Aufräumen, was getan werden könnte.

Im wesentlichen, was ich getan habe, ist zu versuchen, brechen Sie den code in Aufgaben und wickeln Sie jede dieser Aufgaben ein Versprechen. Auf diese Weise können wir beheben/ablehnen und Kette Sie an.

'use strict';

var http = require('http');
var nodemailer = require('nodemailer');
var AWS = require('aws-sdk');
var s3 = new AWS.S3( { params: { Bucket: 'my-bucket' } } );

exports.handler = function (event, context, callback) {
    var lastStatus;

    var options = {
        host: event.server.host,
        port: event.server.port ? event.server.port : 80,
        path: event.server.path ? event.server.path : '',
        method: event.server.method ? event.server.method : 'HEAD',
        timeout: 5000
    };
    var transporter = nodemailer.createTransport({
        host: event.mail.host,
        port: event.mail.port ? event.mail.port : 587,
        auth: {
            user: event.mail.user,
            pass: event.mail.pass
        }
    });

    var d = new Date();
    var UTCstring = d.toUTCString();

    //email templates
    var downMail = {
        from: event.mail.from,
        to: event.mail.to,
        subject: 'Lambda DOWN alert: SITE (' + event.server.host + ') is DOWN',
        text: 'LambdaAlert DOWN:\r\nSITE (' + event.server.host + ') is DOWN as at ' + UTCstring + '.'
    };
    var upMail = {
        from: event.mail.from,
        to: event.mail.to,
        subject: 'Lambda UP alert: SITE (' + event.server.host + ') is UP',
        text: 'LambdaAlert UP:\r\nSITE (' + event.server.host + ') is UP as at ' + UTCstring + '.'
    };

    //Run async chain to ensure that S3 calls execute in proper order

    function getLastPingStatus(){
        return new Promise(function(resolve, reject){
            s3.getObject( { Key: 'lastPingStatus' }, function(err, data) {
                //get last status from S3
                if (err) {
                    lastStatus = "UP";
                    reject(lastStatus)
                } else {
                    lastStatus = data.Body.toString();
                    resolve(lastStatus);
                    console.log("Last observed status: " + lastStatus);
                }
            });
        })
    }
    getLastPingStatus()
        .then(httpRequest)
        .catch(httpRequest); //Otherwise a reject will throw an error

    function sendMail(mail, status){ //status = "up" or "down" -
        return new Promise(function(resolve, reject){
            transporter.sendMail(mail, function(error, info) {
                if (error) {
                    console.log("ERROR: " + error);
                    reject(null, "ERROR: " + error);
                } else {
                    console.log('No further details available.');
                    resolve(null, status + ' message sent');
                }
            });
        });
    }

    function saveStatus(up) {
        return new Promise(function (resolve, reject) {
            var saveOptions,
                message;
            //I didn't bother refactoring these as promises at they do the same thing regardless of outcome
            if(up){
                saveOptions = [{ Key: 'lastPingStatus', Body: 'UP', ContentType: 'text/plain' }, function(error, data) { console.log("Saved last state as UP"); }];
                message = 'Website is OK.';
            } else{
                saveOptions = [{ Key: 'lastPingStatus', Body: 'DOWN', ContentType: 'text/plain' }, function(error, data)  { console.log("Saved last state as DOWN"); }];
                message = 'Website is DOWN.';
            }
            s3.putObject.apply(this, saveOptions);
            callback(null, message);
        });
    }

    function httpRequest(lastStatus) {
        var requestOptions = options;
        return new Promise (function (resolve, reject){
            var req = http.request(requestOptions, function(res) {
                if (res.statusCode == 200) {
                    if (lastStatus == "DOWN") {
                        console.log('Email up notice sending...');
                        sendMail(upMail, "Up")
                            .then(resolve, reject) 
                            .then(saveStatus(true))
                            .then(callback)
                    }
                }
            });
            req.on('error', function(e) {
                if (lastStatus == "UP") {
                    console.log('Email down notice sending...');
                    sendmail(downMail, "Down")
                        .then(resolve, reject)
                        .then(saveStatus(false))
                        .then(callback)
                }
            });
            req.end();

        });

    }
};

InformationsquelleAutor Brian

Das AWS-SDK unterstützt native verspricht, für alle Dienste. Einige benötigen zusätzliche Parameter, um die Rückkehr richtig, wie Lambda.invoke().

Würden Sie im wesentlichen tun

s3.putObject({ Key: 'key', Bucket: 'bucket' }).promise()
    .then(data => {
        //this is the same as the data callback parameter
    })
    .catch(error => {
        //handle your error
    })

Oder, Sie könnte verwenden async/await:

const file = await s3.getObject(params).promise()
//do things with the result

Für den schnellen Zugriff auf die eigentliche Datei (nicht Metadaten):

const file = JSON.parse(await s3.getObject(params).promise().then(res => res.Body));

https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/using-promises.html

InformationsquelleAutor slaughtr