cloud-red
Version:
Serverless Node-RED for your cloud integration needs
483 lines (465 loc) • 14.8 kB
JavaScript
module.exports = function(RED) {
'use strict';
const createNode = require('../../node.js');
const Node = createNode(RED);
var bodyParser = require('body-parser');
var aws = require('./lib/aws');
var multer = require('multer');
var cookieParser = require('cookie-parser');
var getBody = require('raw-body');
var cors = require('cors');
var onHeaders = require('on-headers');
var typer = require('content-type');
var mediaTyper = require('media-typer');
var isUtf8 = require('is-utf8');
var hashSum = require('hash-sum');
class LambdaHandler extends Node {
/**
* @typedef {Object} Rule
* @property {string} t - AWS Event's name
* @property {string} v - AWS Event's label
* @property {string} kind - Legacy. only use value: `V`
*/
/**
* AWS Lambda Handler Node
* @param {Object} props - LambdaHandler Properties
* @param {string} props.url - URLs to set up the routes
* @param {string} props.method - Method to set up the routes (for AWSHandler, only method used will be `post`)
* @param {Rule[]} props.rules - Mapping of the AWS Events to the outgoing ports.export
*
*/
constructor(props) {
super(props);
// public props
this.url = props.url;
this.method = props.method.toLowerCase();
this.rules = props.rules;
this.ports = new Array(this.rules.length);
// private props
this._maxApiRequestSize = RED.settings.apiMaxLength || '6mb';
// handlers & middleware
this.rawBodyParser = this.rawBodyParser.bind(this);
this.createResponseWrapper = this.createResponseWrapper.bind(this);
this.errorHandler = this.errorHandler.bind(this);
this.matchRoutingPortByRule = this.matchRoutingPortByRule.bind(this);
this.metricsHandler = this.metricsHandler.bind(this);
this.multipartParserHandler = this.multipartParserHandler.bind(this);
this.httpMiddleware = this.httpMiddleware.bind(this);
this.jsonParser = bodyParser.json({ limit: this._maxApiRequestSize });
this.corsHandler = this.corsHandler.bind(this);
this.urlencParser = bodyParser.urlencoded({
limit: this._maxApiRequestSize,
extended: true
});
this.callback = this.callback.bind(this);
this.configureRoutes = this.configureRoutes.bind(this);
this.handleMockMessage = this.handleMockMessage.bind(this);
// Init routes
this.configureRoutes();
// Handle direct handling of events for testing
//@ts-ignore
this.on('input', this.handleMockMessage);
//@ts-ignore
this.on('event-log', data => {
console.log(`>>>>>> event-log`, data);
});
// Handle the close (full-deployment, reload)
this.on('close', () => {
RED.httpNode._router.stack.forEach((route, i, routes) => {
if (
route.route &&
route.route.path === this.url &&
route.route.methods[this.method]
) {
routes.splice(i, 1);
}
});
});
}
corsHandler(req, res, next) {
if (RED.settings.httpNodeCors) {
this.corsHandler = cors(RED.settings.httpNodeCors);
RED.httpNode.options('*', this.corsHandler);
} else {
next();
}
}
rawBodyParser(req, res, next) {
if (req.skipRawBodyParser) {
next();
} // don't parse this if told to skip
if (req._body) {
return next();
}
req.body = '';
req._body = true;
var isText = true;
var checkUTF = false;
if (req.headers['content-type']) {
var contentType = typer.parse(req.headers['content-type']);
if (contentType.type) {
var parsedType = mediaTyper.parse(contentType.type);
if (parsedType.type === 'text') {
isText = true;
} else if (
parsedType.subtype === 'xml' ||
parsedType.suffix === 'xml'
) {
isText = true;
} else if (parsedType.type !== 'application') {
isText = false;
} else if (parsedType.subtype !== 'octet-stream') {
checkUTF = true;
} else {
isText = false;
}
}
}
getBody(
req,
{
length: req.headers['content-length'],
encoding: isText ? 'utf8' : null
},
function(err, buf) {
if (err) {
return next(err);
}
if (!isText && checkUTF && isUtf8(buf)) {
// @ts-ignore
buf = buf.toString();
}
req.body = buf;
next();
}
);
}
createResponseWrapper(res) {
var wrapper = {
_res: res
};
var toWrap = [
'append',
'attachment',
'cookie',
'clearCookie',
'download',
'end',
'format',
'get',
'json',
'jsonp',
'links',
'location',
'redirect',
'render',
'send',
'sendFile',
'sendStatus',
'set',
'status',
'type',
'vary'
];
toWrap.forEach(f => {
wrapper[f] = function() {
// node here before - pretty sure the this points ot the this of the outer function
this.warn(
RED._('httpin.errors.deprecated-call', { method: 'msg.res.' + f })
);
var result = res[f].apply(res, arguments);
if (result === res) {
return wrapper;
} else {
return result;
}
};
});
return wrapper;
}
errorHandler(err, req, res, next) {
this.status({ fill: 'red', shape: 'ring', text: 'error' });
this.error(`failed due to: ${err.toString()}`);
res.sendStatus(500);
}
matchRoutingPortByRule(rule, incomingEvent) {
this.debug(
'Rule: ' + rule + ' and event received: ' + incomingEvent + '.'
);
return (
(rule === aws.AWSEventTypes.APIGatewayEvent &&
incomingEvent === aws.AWSEventTypes.APIGatewayEvent) ||
(rule === aws.AWSEventTypes.S3Event &&
incomingEvent === aws.AWSEventTypes.S3Event) ||
(rule === aws.AWSEventTypes.SNSEvent &&
incomingEvent === aws.AWSEventTypes.SNSEvent) ||
(rule === aws.AWSEventTypes.SQSEvent &&
incomingEvent === aws.AWSEventTypes.SQSEvent) ||
(rule === aws.AWSEventTypes.DynamoDBStreamEvent &&
incomingEvent === aws.AWSEventTypes.DynamoDBStreamEvent) ||
(rule === aws.AWSEventTypes.CognitoUserPoolEvent &&
incomingEvent === aws.AWSEventTypes.S3Event) ||
(rule === aws.AWSEventTypes.ScheduledEvent &&
incomingEvent === aws.AWSEventTypes.ScheduledEvent)
);
}
metricsHandler(req, res, next) {
if (this.metric()) {
onHeaders(res, function() {
if (res._msgid) {
var startAt = process.hrtime();
var diff = process.hrtime(startAt);
var ms = diff[0] * 1e3 + diff[1] * 1e-6;
var metricResponseTime = ms.toFixed(3);
var metricContentLength = res._headers['content-length'];
//assuming that _id has been set for res._metrics in HttpOut node!
//@ts-ignore
this.metric(
'response.time.millis',
{ _msgid: res._msgid },
metricResponseTime
);
//@ts-ignore
this.metric(
'response.content-length.bytes',
{ _msgid: res._msgid },
metricContentLength
);
}
});
}
next();
}
multipartParserHandler(req, res, next) {
// @ts-ignore
if (this.upload) {
var mp = multer({ storage: multer.memoryStorage() }).any();
mp(req, res, function(err) {
req._body = true;
next(err);
});
}
next();
}
httpMiddleware(req, res, next) {
next();
}
callback(req, res) {
const AMAZON_TRACE_ID = 'x-amzn-trace-id';
// Inject the Amazon trace id as a correlation id
let msgid;
if (req.headers.hasOwnProperty(AMAZON_TRACE_ID)) {
msgid = req.headers[AMAZON_TRACE_ID];
} else {
//@ts-ignore
this.warn(
`Header: \"${AMAZON_TRACE_ID}\" not found. Generic \"msgId\" is created.`
);
msgid = RED.util.generateId();
}
res._msgid = msgid;
// Identify what type of AWS event encapsulates the incoming request
let awsEventType = aws.readTypeEvent(req);
for (let i = 0; i < this.rules.length; i += 1) {
let rule = this.rules[i];
if (this.matchRoutingPortByRule(rule.t, awsEventType)) {
if (this.method.match(/^(post|delete|put|options|patch)$/)) {
this.ports[i] = {
_msgid: msgid,
_awsEventType: awsEventType,
req: req,
res: this.createResponseWrapper(res),
payload: req.body
};
} else if (this.method === 'get') {
this.ports[i] = {
_msgid: msgid,
_awsEventType: awsEventType,
req: req,
res: this.createResponseWrapper(res),
payload: req.query
};
} else {
//@ts-ignore
this.warn(
`Received unknown http method: \"${this.method}\". Payload property will be ignored.`
);
this.ports[i] = {
_msgid: msgid,
_awsEventType: awsEventType,
req: req,
res: this.createResponseWrapper(res)
};
}
} else {
this.ports[i] = null;
}
}
if (
this.ports.every(function(elem) {
return elem === null;
})
) {
throw new Error(
'AWSEventType: "' +
awsEventType +
'" cannot be matched with any defined route.'
);
} else {
// @ts-ignore
this.status({ fill: 'green', shape: 'dot', text: 'success' });
// @ts-ignore
this.send(this.ports);
}
}
configureRoutes() {
RED.httpNode.get(
this.url,
this.httpMiddleware,
this.corsHandler,
this.metricsHandler,
this.callback,
this.errorHandler
);
RED.httpNode.post(
this.url,
this.httpMiddleware,
this.corsHandler,
this.metricsHandler,
this.jsonParser,
this.urlencParser,
this.multipartParserHandler,
this.rawBodyParser,
this.callback,
this.errorHandler
);
RED.httpNode.put(
this.url,
this.httpMiddleware,
this.corsHandler,
this.metricsHandler,
this.jsonParser,
this.urlencParser,
this.rawBodyParser,
this.callback,
this.errorHandler
);
RED.httpNode.patch(
this.url,
this.httpMiddleware,
this.corsHandler,
this.metricsHandler,
this.jsonParser,
this.urlencParser,
this.rawBodyParser,
this.callback,
this.errorHandler
);
RED.httpNode.delete(
this.url,
this.httpMiddleware,
this.corsHandler,
this.metricsHandler,
this.jsonParser,
this.urlencParser,
this.rawBodyParser,
this.callback,
this.errorHandler
);
}
handleMockMessage(msg) {
console.log(msg);
}
}
RED.nodes.registerType('lambda-handler', LambdaHandler);
/**
* Creates a Lambda Response Node
* @class LambdaResponse
* @extends {Node}
*/
class LambdaResponse extends Node {
constructor(props) {
super(props);
this.headers = props.headers || {};
this.statusCode = props.statusCode;
this.handleMessage = this.handleMessage.bind(this);
// @ts-ignore
this.on('input', this.handleMessage);
}
handleMessage(msg) {
if (msg.res) {
var headers = RED.util.cloneMessage(this.headers);
if (msg.headers) {
if (msg.headers.hasOwnProperty('x-node-red-request-node')) {
var headerHash = msg.headers['x-node-red-request-node'];
delete msg.headers['x-node-red-request-node'];
var hash = hashSum(msg.headers);
if (hash === headerHash) {
delete msg.headers;
}
}
if (msg.headers) {
for (var h in msg.headers) {
if (msg.headers.hasOwnProperty(h) && !headers.hasOwnProperty(h)) {
headers[h] = msg.headers[h];
}
}
}
}
if (Object.keys(headers).length > 0) {
msg.res._res.set(headers);
}
if (msg.cookies) {
for (var name in msg.cookies) {
if (msg.cookies.hasOwnProperty(name)) {
if (
msg.cookies[name] === null ||
msg.cookies[name].value === null
) {
if (msg.cookies[name] !== null) {
msg.res._res.clearCookie(name, msg.cookies[name]);
} else {
msg.res._res.clearCookie(name);
}
} else if (typeof msg.cookies[name] === 'object') {
msg.res._res.cookie(
name,
msg.cookies[name].value,
msg.cookies[name]
);
} else {
msg.res._res.cookie(name, msg.cookies[name]);
}
}
}
}
var statusCode = this.statusCode || msg.statusCode || 200;
if (typeof msg.payload == 'object' && !Buffer.isBuffer(msg.payload)) {
msg.res._res.status(statusCode).jsonp(msg.payload);
} else {
if (msg.res._res.get('content-length') == null) {
var len;
if (msg.payload == null) {
len = 0;
} else if (Buffer.isBuffer(msg.payload)) {
len = msg.payload.length;
} else if (typeof msg.payload == 'number') {
len = Buffer.byteLength('' + msg.payload);
} else {
len = Buffer.byteLength(msg.payload);
}
msg.res._res.set('content-length', len);
}
if (typeof msg.payload === 'number') {
msg.payload = '' + msg.payload;
}
msg.res._res.status(statusCode).send(msg.payload);
}
} else {
// @ts-ignore
this.warn(RED._('httpin.errors.no-response'));
}
}
}
RED.nodes.registerType('lambda-response', LambdaResponse);
};