Feat: Docker and Fn::GetAtt support

- Added support for running emulator in Docker
- Resolves Fn::GetAtt in Task type reference

Author: ceecko

README.md

@@ -6,9 +6,8 @@ This is a plugin for the [Serverless Framework](https://serverless.com/).  It us
 ## Requirements
 
 - The [serverless-offline](https://www.npmjs.com/package/serverless-offline) plugin
-- The [serverless-offline-lambda](https://www.npmjs.com/package/serverless-offline-lambda) plugin
 - The [serverless-step-functions](https://www.npmjs.com/package/serverless-step-functions) plugin
-- Java Runtime Engine (JRE) version 6.x or newer
+- (optional) Java Runtime Engine (JRE) version 6.x or newer if you don't run your own AWS Step Functions emulator
 
 ## Install
 
@@ -52,6 +51,8 @@ It also adds an environment variable for each created state machine that contain
 - `lambdaEndpoint` (defaults to `http://localhost:4000`) the endpoint for the lambda service
 - `path` (defaults to `./.step-functions-local`) the path to store the downloaded step function executables
 - `TaskResourceMapping` allows for Resource ARNs to be configured differently for local development
+- `startStepFunctionsLocalApp` (default: true) starts AWS step function emulator. Set to false if it's running already. It needs to run on port 8083.  
+
 
 ### Full Config Example
 
@@ -76,6 +77,7 @@ custom:
     TaskResourceMapping:
       FirstState: arn:aws:lambda:us-east-1:101010101010:function:hello
       FinalState: arn:aws:lambda:us-east-1:101010101010:function:hello
+    startStepFunctionsLocalApp: true
 
 functions:
   hello:
@@ -101,3 +103,13 @@ stepFunctions:
             Resource: Fn::GetAtt: [hello, Arn]
             End: true
 ```
+
+### Running AWS Step functions emulator in Docker
+```bash
+$ docker run \
+    -p 8083:8083 \
+    -e "AWS_ACCOUNT_ID=101010101010" \
+    -e "AWS_DEFAULT_REGION=us-east-1" \
+    -e "LAMBDA_ENDPOINT=http://localhost:3002" \
+    amazon/aws-stepfunctions-local
+```

index.js

@@ -30,19 +30,28 @@ class ServerlessStepFunctionsLocal {
       this.config.path = './.step-functions-local';
     }
 
+    if (this.config.startStepFunctionsLocalApp === undefined) {
+      this.config.startStepFunctionsLocalApp = true
+    }
+
     this.stepfunctionsServer = new StepFunctionsLocal(this.config);
 
     this.stepfunctionsAPI = new AWS.StepFunctions({endpoint: 'http://localhost:8083', region: this.config.region});
 
     this.hooks = {
       'offline:start:init': async () => {
-        await this.installStepFunctions();
+        if (this.config.startStepFunctionsLocalApp) {
+          await this.installStepFunctions();
+        }
+
         await this.startStepFunctions();
         await this.getStepFunctionsFromConfig();
         await this.createEndpoints();
       },
       'before:offline:start:end': async () => {
-        await this.stopStepFunctions();
+        if (this.config.startStepFunctionsLocalApp) {
+          await this.stopStepFunctions();
+        }
       }
     };
   }
@@ -52,15 +61,20 @@ class ServerlessStepFunctionsLocal {
   }
 
   async startStepFunctions() {
-    this.stepfunctionsServer.start({
-      account: this.config.accountId.toString(),
-      lambdaEndpoint: this.config.lambdaEndpoint
-    }).on('data', data => {
-      console.log(chalk.blue('[Serverless Step Functions Local]'), data.toString());
-    });
+    if (this.config.startStepFunctionsLocalApp) {
+      this.stepfunctionsServer.start({
+        account: this.config.accountId.toString(),
+        lambdaEndpoint: this.config.lambdaEndpoint
+      }).on('data', data => {
+        console.log(chalk.blue('[Serverless Step Functions Local]'), data.toString());
+      });
+    } else {
+      console.log(chalk.blue('[Serverless Step Functions Local]'), 'Waiting for AWS Step Functions emulator on port 8083');
+    }
 
     // Wait for server to start
     await tcpPortUsed.waitUntilUsed(8083, 200, 10000);
+    console.log(chalk.blue('[Serverless Step Functions Local]'), 'AWS Step Functions emulator detected on 8083');
   }
 
   stopStepFunctions() {
@@ -80,6 +94,19 @@ class ServerlessStepFunctionsLocal {
 
     this.stateMachines = parsed.stepFunctions.stateMachines;
 
+    // replace Fn::GetAtt
+    Object.keys(this.stateMachines).map(stateMachineName => {
+      const machine = this.stateMachines[stateMachineName]
+      Object.keys(machine.definition.States).map(stateName => {
+        const state = machine.definition.States[stateName]
+        if(state.Type === 'Task') {
+          if(state.Resource && state.Resource['Fn::GetAtt'] && Array.isArray(state.Resource['Fn::GetAtt'])) {
+            state.Resource = `arn:aws:lambda:${this.config.region}:${this.config.accountId}:function:${this.service.service}-${this.serverless.stage ? this.serverless.stage : 'dev'}-${state.Resource['Fn::GetAtt'][0]}`
+          }
+        }
+      })
+    })
+    
     if (parsed.custom 
       && parsed.custom.stepFunctionsLocal
       && parsed.custom.stepFunctionsLocal.TaskResourceMapping) {
@@ -104,6 +131,51 @@ class ServerlessStepFunctionsLocal {
   }
 
   async createEndpoints() {
+    // Delete existing state machines
+    const EMPTY = Symbol('empty')
+    let nextToken = EMPTY
+    const knownStateMachines = Object.keys(this.stateMachines)
+    // A state machine is eventually deleted.
+    // We need to wait until it's actually deleted because otherwise
+    // the new state machine created later is deleted as well and is not
+    // available.
+    while (true) {
+      let hasRunningMachine = false
+      while (nextToken) {
+        const data = await this.stepfunctionsAPI.listStateMachines({
+          nextToken: (nextToken === EMPTY ? undefined : nextToken)
+        }).promise()
+  
+        nextToken = data.nextToken
+        for (const machine of data.stateMachines) {
+          if(!knownStateMachines.includes(machine.name)) {
+            continue
+          }
+          hasRunningMachine = true
+  
+          await this.stepfunctionsAPI.deleteStateMachine({
+            stateMachineArn: machine.stateMachineArn
+          })
+          .promise()
+          .catch(err => {
+            // state machine was not found
+            if(err && err.code === 400) {
+              return
+            }
+  
+            throw err
+          })
+        }
+      }
+
+      if(!hasRunningMachine) {
+        break
+      }
+
+      await new Promise(resolve => setTimeout(resolve, 1000))
+      console.log(chalk.blue('[Serverless Step Functions Local]'), 'Retrying old state machine removal');
+    }
+
     const endpoints = await Promise.all(Object.keys(this.stateMachines).map(stateMachineName => this.stepfunctionsAPI.createStateMachine({
       definition: JSON.stringify(this.stateMachines[stateMachineName].definition),
       name: stateMachineName,