v0.4.0

Node 4 support (promises, arrow functions, etc)
Removed polling for delete event callback
Added support for API Gateway’s lambda proxy mode
Significantly improved unit tests

Author: rferreira

lib/index.js

@@ -1,5 +1,4 @@
-var VERSION = '0.3.1';
-var util = require('util');
+var VERSION = '0.4.0';
 var assert = require('assert');
 var aws = require('aws-sdk');
 var s3 = new aws.S3({apiVersion: '2006-03-01'});
@@ -9,41 +8,35 @@ var crypto = require('crypto');
 
 // replace below with your credentials in the form key:secret
 // to create your key go to https://scanii.com/account/settings/keys
-var SCANII_CREDS = 'CHANGE';
+var SCANII_CREDS = 'CHANGE:ME';
 // replace with the URL of your callback lambda function
-var CALLBACK_URL = 'ME';
-
-
-onFindings = function (bucket, key, result, context) {
-  console.log('RESULT:', internalId(bucket, key), 'has findings', result.findings);
-  var pending = true;
-
-  // sample code that delete objects with findings from S3:
-  var req = s3.deleteObject({Bucket: bucket, Key: key});
-  req.on('success', function (response) {
-    console.log('file', internalId(bucket, key), 'deleted');
-    context.succeed(util.format('callback for file %s completed successful', result.id));
-    pending = false;
-
-  }).on('error', function (response) {
-    console.log('error while deleting', internalId(bucket, key));
-    context.fail(response);
-    pending = false;
+var CALLBACK_URL = 'CHANGE_ME';
+
+var onFindings = function (bucket, key, result) {
+  return new Promise((resolve, reject) => {
+    "use strict";
+    console.log('RESULT:', internalId(bucket, key), 'has findings', result.findings);
+
+    // sample code that delete objects with findings from S3:
+    s3.deleteObject({Bucket: bucket, Key: key}, (error, data) => {
+      if (error) {
+        console.error(error, error.stack); // an error occurred
+        reject(`error while deleting: ${internalId(bucket, key)} please see logs for details`);
+      } else {
+        console.log('file', internalId(bucket, key), 'deleted');
+        resolve(true);
+      }
+    });
   });
-  req.send();
-  var waitWhilePending = function () {
-    if (pending) {
-      console.log('waiting');
-      setTimeout(waitWhilePending, 100);
-    }
-  };
-  setTimeout(waitWhilePending, 100);
-
 };
 
-onNoFindings = function (bucket, key, result, context) {
-  console.log('RESULT:', internalId(bucket, key), 'has no findings');
-  context.succeed(util.format('callback for file %s completed successful', result.id));
+var onNoFindings = function (bucket, key, result) {
+  return new Promise((resolve, reject) => {
+    "use strict";
+    console.log('RESULT:', internalId(bucket, key), 'has no findings');
+    console.log(`callback for file ${result.id} completed successful`);
+    resolve(true);
+  });
 
 };
 
@@ -57,29 +50,36 @@ if (process.env.SCANII_CREDS !== undefined) {
 }
 
 const API_ENDPOINT = '/v2.1/files/';
-
-console.log('loading function v', VERSION);
-
-var KEY = SCANII_CREDS.split(':')[0];
-var SECRET = SCANII_CREDS.split(':')[1];
-console.log('using key', KEY);
+const KEY = SCANII_CREDS.split(':')[0];
+const SECRET = SCANII_CREDS.split(':')[1];
 
 var internalId = function (bucket, key) {
-  return util.format('s3://%s/%s', bucket, key);
+  return `s3://${bucket}/${key}`;
 };
 
+/**
+ * Generates a HMAC-SHA1 digital signature for a bucket/key combination using the SECRET as the key
+ * @param bucket the bucket name
+ * @param key the key name
+ * @returns {string} the digitally signed bucket+key combination
+ */
 var generateSignature = function (bucket, key) {
   return crypto.createHmac('sha1', SECRET).update(internalId(bucket, key)).digest('hex');
 };
 
 /**
  * Handles HTTP result callback
+ * @param {Object} event the API gateway event to be processed
+ * @param callback the lambda flow control callback
  */
-var handleCallback = function (event, context) {
+var handleApiGatewayEvent = (event, callback) => {
   console.log('handling callback event');
 
   var r = event;
-  //console.log('response:', JSON.stringify(r, null, 2));
+  if (event.body !== undefined) {
+    // if this is proxy request we yank the actual body from the payload
+    r = JSON.parse(event.body);
+  }
   console.log("metadata:", r.metadata);
 
   // callback sanity checks
@@ -93,28 +93,56 @@ var handleCallback = function (event, context) {
   assert.ok(r.metadata.signature == generateSignature(r.metadata.bucket, r.metadata.key), "invalid signature");
   console.log('signature check passed for signature', r.metadata.signature);
 
-  if (r.findings !== undefined) {
-    if (r.findings.length > 0) {
-      onFindings(r.metadata.bucket, r.metadata.key, r, context);
+  var handler;
+
+  if (r.findings !== undefined && r.findings.length > 0) {
+    console.log("processing callback with findings ", r.findings);
+
+    // if in test mode we really don't dispatch this call
+    if (process.env.MOCK_EXTERNAL_SERVICES !== undefined) {
+      handler = Promise.resolve(true);
     } else {
-      onNoFindings(r.metadata.bucket, r.metadata.key, r, context);
+      handler = onFindings(r.metadata.bucket, r.metadata.key, r);
     }
+  } else {
+    handler = onNoFindings(r.metadata.bucket, r.metadata.key, r);
   }
 
-};
+  handler.then((result)=> {
+    "use strict";
+    if (result === true) {
+      // returns a API gateway lambda proxy confirming response:
+      callback(null, {
+        "statusCode": 200,
+        "headers": {
+          "Content-Type": "application/json"
+        },
+        "body": JSON.stringify({status: "OK"}, null, 2)
+      });
+    }
+  }).catch((error)=> {
+    "use strict";
+    console.error(error);
+    callback(error);
+  });
 
+};
 
 /**
- * Handles S3 event and submits content for processing
+ * Handles events from S3 and submits object for processing
+ * @param event {Object} S3 event to be processed
+ * @param callback the lambda flow control callback
  */
-var handleS3Event = function (event, context) {
-  console.log('handling S3 event');
-
+var handleS3Event = (event, callback) => {
   // Get the object from the event and show its content type
   var bucket = event.Records[0].s3.bucket.name;
   // see https://forums.aws.amazon.com/thread.jspa?threadID=215813
   var key = Object.keys(qs.decode(event.Records[0].s3.object.key))[0];
 
+  // sanity checks
+  assert(bucket !== undefined, "bucket not present in s3 event");
+  assert(key !== undefined, "key not present in s3 event");
+
   console.log('processing ' + internalId(bucket, key));
 
   // creating signed url for processing
@@ -148,40 +176,66 @@ var handleS3Event = function (event, context) {
     headers: {
       'Content-Type': 'application/x-www-form-urlencoded',
       'Content-Length': payload.length,
-      'User-Agent': 'scanii-lambda/v' + VERSION
+      'User-Agent': 'scanii-lambda-v' + VERSION
     }
   };
-  console.log(payload);
-  // calling scanii API v2.1 (http://docs.scanii.com/v2.1/resources.html):
-  var req = http.request(options, function (res) {
-    console.log("headers: ", res.headers);
-
-    res.on('data', function (data) {
-      var serviceResponse = JSON.parse(data);
-      if (res.statusCode == 202) {
-        console.log('file id:', serviceResponse.id);
-        context.succeed(serviceResponse.id);
-      } else {
-        console.log(serviceResponse);
-        context.fail(util.format("Error: invalid response from server, message [%s] and http code: %d", serviceResponse.body, res.statusCode));
-      }
-    });
-    res.on('error', function (error) {
-      context.fail(error);
+
+  var processResponse = (res, data) => {
+    "use strict";
+    var serviceResponse = JSON.parse(data);
+    if (res.statusCode == 202) {
+      console.log('file id:', serviceResponse.id);
+      callback(null, serviceResponse.id);
+    } else {
+      console.log(serviceResponse);
+      callback(`Error: invalid response from server, message [${serviceResponse.body}] and http code: ${res.statusCode}`);
+    }
+  };
+
+  // check whether we should return a canned response (used during testing)
+  if (process.env.MOCK_EXTERNAL_SERVICES !== undefined) {
+    processResponse(event._mock.response, event._mock.data);
+  } else {
+    // calling scanii API v2.1 (http://docs.scanii.com/v2.1/resources.html):
+    var req = http.request(options, function (res) {
+      console.log("headers: ", res.headers);
+      res.on('data', function (data) {
+        processResponse(res, data);
+      });
+      res.on('error', function (error) {
+        callback(error);
+      });
     });
-  });
 
-  req.write(payload);
-  req.end();
+    req.write(payload);
+    req.end();
 
+  }
 };
 
-exports.handler = function (event, context) {
-  console.log('received event:', JSON.stringify(event, null, 2));
-  if (event.Records !== undefined) {
-    handleS3Event(event, context);
-  } else {
-    handleCallback(event, context);
+/**
+ * lambda entry point function
+ * @param event event to be processed
+ * @param context lambda environmental context object
+ * @param callback the lambda flow control callback
+ */
+exports.handler = (event, context, callback) => {
+  console.log(">> starting");
+  console.log(`>> using key [${KEY}] and function scanii-lambda/v${VERSION}`);
+  if (process.env.MOCK_EXTERNAL_SERVICES !== undefined) {
+    console.log(">> mocking external calls!");
+  }
+  console.log('>> received event:', JSON.stringify(event, null, 2));
+
+  try {
+    if (event.Records !== undefined) {
+      handleS3Event(event, callback);
+    } else {
+      handleApiGatewayEvent(event, callback);
+    }
+  } catch (error) {
+    console.error(error, error.stack); // an error occurred
+    callback(error);
   }
 };
 

package.json

@@ -1,6 +1,6 @@
 {
-  "name": "scanii-mu",
-  "version": "0.3.1",
+  "name": "scanii-lambda",
+  "version": "0.4.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -9,10 +9,8 @@
   "author": "",
   "license": "Apache-2.0",
   "dependencies": {
-    "aws-lambda-mock-context": "^0.2.0",
-    "aws-sdk": "^2.2.5",
-    "chai": "^3.4.1",
-    "consoleplusplus": "^1.3.0",
+    "aws-lambda-mock-context": "^3.0.0",
+    "aws-sdk": "^2.6.3",
     "mocha": "^2.3.3"
   }
 }