Merge pull request #14 from HyperBrain/issue-#7-event-support

Fixes #7 event support

Author: HyperBrain

README.md

@@ -72,7 +72,8 @@ A valid use is to forward the alias name as environment variable to the lambdas
 and use it there for tagging of log messages. Then you see immediately which
 aliased lambda is the origin.
 
-Any other use is strongly discouraged.
+Any other use with the further exception of lambda event subscriptions (see below)
+is strongly discouraged.
 
 ## Log groups (not yet finished)
 
@@ -104,6 +105,85 @@ that they have to update their configuration too - most likely, they updated it
 already, because normally you rebase or merge your upstream and get the changes
 automatically.
 
+## Event subscriptions
+
+Event subscriptions that are defined for a lambda function will be deployed per
+alias, i.e. the event will trigger the correct deployed aliased function.
+
+### Use with global resources
+
+Event subscriptions can reference resources that are available throughout all
+aliases if they reference the same resource id. That means that an event will
+trigger all aliases that are deployed with the subscription defined.
+
+Example:
+
+```
+functions:
+  testfct1:
+    description: 'My test function'
+    handler: handlers/testfct1/handler.handle
+    events:
+      - stream:
+          type: kinesis
+          arn: "arn:aws:kinesis:${self:provider.region}:XXXXXX:stream/my-kinesis"
+      - http:
+          method: GET
+          path: /func1
+resources:
+  Resources:
+	  myKinesis:
+		  Type: AWS::Kinesis::Stream
+			Properties:
+			  Name: my-kinesis
+			  ShardCount: 1
+```
+
+When a function is deployed to an alias it will now also listen to the *my-kinesis*
+stream events. This is useful, if you want to test new implementations with an
+existing resource.
+
+### Use with per alias resources
+
+There might be cases where you want to test with your private resources first,
+before you deploy changes to the master alias. Or you just want to create separate
+resources and event subscriptions per alias.
+
+The solution here is to make the resource id dependent on the alias name, so that
+the alias effectively owns the resource and the event subscription is bound to it.
+
+Example:
+
+```
+functions:
+  testfct1:
+    description: 'My test function'
+    handler: handlers/testfct1/handler.handle
+    events:
+      - stream:
+          type: kinesis
+          arn: "arn:aws:kinesis:${self:provider.region}:XXXXXX:stream/my-kinesis-${self.provider.alias}"
+      - http:
+          method: GET
+          path: /func1
+resources:
+  Resources:
+	  myKinesis${self:provider.alias}:
+		  Type: AWS::Kinesis::Stream
+			Properties:
+			  Name: my-kinesis-${self.provider.alias}
+			  ShardCount: 1
+```
+
+### Named streams
+
+The examples above use named streams. I know that this is not perfect as changes
+that require replacement are not possible. The reason for the named resources is,
+that Serverless currently only supports event arns that are strings.
+The change is already in the pipeline there. Afterwards you just can reference
+the event arns with CF functions like "Fn::GetAtt" or "Ref". I will update
+the examples as soon as it is fixed there and publicly available.
+
 ## Serverless info integration
 
 The plugin integrates with the Serverless info command. It will extend the information

lib/aliasRestructureStack.js

@@ -11,6 +11,7 @@
 
 const BbPromise = require('bluebird');
 const _ = require('lodash');
+const utils = require('./utils');
 
 /**
  * Merge template definitions that are still in use into the new template
@@ -419,6 +420,37 @@ module.exports = {
 		return BbPromise.resolve([ currentTemplate, aliasStackTemplates ]);
 	},
 
+	aliasHandleEvents(currentTemplate, aliasStackTemplates) {
+
+		const stageStack = this._serverless.service.provider.compiledCloudFormationTemplate;
+		const aliasStack = this._serverless.service.provider.compiledCloudFormationAliasTemplate;
+
+		const subscriptions = _.assign({}, _.pickBy(_.get(stageStack, 'Resources', {}), [ 'Type', 'AWS::Lambda::EventSourceMapping' ]));
+
+		_.forOwn(subscriptions, (subscription, name) => {
+			// Reference alias as FunctionName
+			const functionNameRef = utils.findAllReferences(_.get(subscription, 'Properties.FunctionName'));
+			const functionName = _.get(functionNameRef, '[0].ref', '').replace(/LambdaFunction$/, '');
+			if (_.isEmpty(functionName)) {
+				// FIXME: Can this happen at all?
+				this._serverless.cli.log(`Strange thing: No function name defined for ${name}`);
+				return;
+			}
+
+			subscription.Properties.FunctionName = { Ref: `${functionName}Alias` };
+			subscription.DependsOn = [ `${functionName}Alias` ];
+
+			// Remove mapping from stage stack
+			delete stageStack.Resources[name];
+		});
+
+		// Move event subscriptions to alias stack
+		_.defaults(aliasStack.Resources, subscriptions);
+
+		// Forward inputs to the promise chain
+		return BbPromise.resolve([ currentTemplate, aliasStackTemplates ]);
+	},
+
 	aliasRestructureStack(currentTemplate, aliasStackTemplates) {
 
 		this._serverless.cli.log('Preparing aliase ...');
@@ -432,6 +464,7 @@ module.exports = {
 		.spread(this.aliasHandleLambdaRole)
 		.spread(this.aliasHandleFunctions)
 		.spread(this.aliasHandleApiGateway)
+		.spread(this.aliasHandleEvents)
 		.then(() => BbPromise.resolve());
 	}
 

lib/removeAlias.js

@@ -111,6 +111,7 @@ module.exports = {
 			const obsoleteRefs = _.concat(obsoleteFuncResources, obsoleteResources);
 
 			// Remove all obsolete resource references from the IAM policy statements
+			const emptyStatements = [];
 			const statementResources = utils.findReferences(currentRolePolicyStatements, obsoleteRefs);
 			_.forEach(statementResources, resourcePath => {
 				const indices = /.*?\[([0-9]+)\].*?\[([0-9]+)\]/.exec(resourcePath);
@@ -119,9 +120,12 @@ module.exports = {
 					const resourceIndex = indices[2];
 
 					_.pullAt(currentRolePolicyStatements[statementIndex].Resource, resourceIndex);
-					_.pull(currentRolePolicyStatements[statementIndex], statement => _.isEmpty(statement.Resource));
+					if (_.isEmpty(currentRolePolicyStatements[statementIndex].Resource)) {
+						emptyStatements.push(statementIndex);
+					}
 				}
 			});
+			_.pullAt(currentRolePolicyStatements, emptyStatements);
 
 			// Set references to obsoleted resources in fct env to "REMOVED" in case
 			// the alias that is removed was the last deployment of the stage.