I'm unable to create a step function's state machine through cloudformation. I'm using v0.9.6. A sample template is:

```yaml
---

AWSTemplateFormatVersion: '2010-09-09'

Description: Failing workflow template

Resources:

  TestActivity:
    Type: AWS::StepFunctions::Activity
    Properties:
      Name: "test-activity"

  FulfillmentWorkflow:
    Type: AWS::StepFunctions::StateMachine
    Properties:
      StateMachineName: TestWorkflow
      DefinitionString:
        Fn::Sub:
          - |-
            {
              "StartAt": "Say hi!",
              "States": {
                "Say hi!": {
                  "Type": "Task",
                  "Resource": "${ActivityArn}",
                  "End": true
                }
              }
            }
          - ActivityArn:
              Ref: TestActivity
      RoleArn:
        Ref: TestRole
    DependsOn: TestActivity

  TestRole:
    Type: AWS::IAM::Role
    Properties:
      Path: "/"
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - states.us-east-1.amazonaws.com
          Action:
          - sts:AssumeRole
      RoleName: "test-role"

```

The command that fails is:

```bash
$ awslocal cloudformation create-stack --stack-name workflow-test --template-body file://failing-template.yaml --capabilities CAPABILITY_NAMED_IAM

Unable to parse response (syntax error: line 1, column 54), invalid XML received:
b'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">\n<title>500 Internal Server Error</title>\n<h1>Internal Server Error</h1>\n<p>The server encountered an internal error and was unable to complete your request.  Either the server is overloaded or there is an error in the application.</p>\n'
```

I'm running localstack in docker with all services enabled. In the logs I see this error:

```
localstack_1  | botocore.exceptions.ParamValidationError: Parameter validation failed:
localstack_1  | Invalid type for parameter definition, value: {'Fn::Sub': ['{\n  "StartAt": "Say hi!",\n  "States": {\n    "Say hi!": {\n      "Type": "Task",\n      "Resource": "${ActivityArn}",\n      "End": true\n    }\n  }\n}', {}]}, type: <class 'dict'>, valid types: <class 'str'>
localstack_1  | 2019-07-22T09:39:22:DEBUG:localstack.services.cloudformation.cloudformation_listener: Error response from CloudFormation (500) POST /: b'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">\n<title>500 Internal Server Error</title>\n<h1>Internal Server Error</h1>\n<p>The server encountered an internal error and was unable to complete your request. Either the server is overloaded or there is an error in the application.</p>\n'
```

which I guess means that the definition is not being identified as a string expression. Creating a stack with the same template works against aws.

<!-- Love localstack? Please consider supporting our collective:
👉  https://opencollective.com/localstack/donate -->
env = get_environment(env)
    if not role:
        role = get_iam_role(resource, env=env)
    return role_arn(role_name=role, account_id=get_account_id())
def get_iam_role(resource, env=None):
    env = get_environment(env)
    return 'role-%s' % resource
def dynamodb_table_arn(table_name, account_id=None):
    account_id = get_account_id(account_id)
    return 'arn:aws:dynamodb:%s:%s:table/%s' % (get_local_region(), account_id, table_name)
def dynamodb_stream_arn(table_name, account_id=None):
    account_id = get_account_id(account_id)
    return ('arn:aws:dynamodb:%s:%s:table/%s/stream/%s' %
        (get_local_region(), account_id, table_name, timestamp()))
def lambda_function_arn(function_name, account_id=None):
    pattern = 'arn:aws:lambda:.*:.*:(function|layer):.*'
    if re.match(pattern, function_name):
        return function_name
    if ':' in function_name:
        raise Exception('Lambda function name should not contain a colon ":"')
    account_id = get_account_id(account_id)
    pattern = re.sub(r'\([^\|]+\|.+\)', 'function', pattern)
    return pattern.replace('.*', '%s') % (get_local_region(), account_id, function_name)
def lambda_function_name(name_or_arn):
    if ':' not in name_or_arn:
        return name_or_arn
    parts = name_or_arn.split(':')
    
    return parts[6]
def state_machine_arn(name, account_id=None):