<!-- Love localstack? Please consider supporting our collective:
👉  https://opencollective.com/localstack/donate -->

# Type of request: This is a ...

[ ] bug report
[x] feature request

# Detailed description

Deploying a Cloudformation stack with a `Type: AWS::Events::Rule` resource doesn't deploy the rule.

## Expected behavior

Deploying the stack with `Type: AWS::Events::Rule` deploys a Cloudwatch events rule correctly

## Actual behavior

The rule doesn't get created. In the logs I see:

```
2020-04-27T10:51:35:WARNING:localstack.utils.cloudformation.template_deployer: Unable to extract name for resource type "Events::Rule"
2020-04-27T10:51:35:WARNING:localstack.utils.cloudformation.template_deployer: Unable to extract name for resource type "Events::Rule"
```

Based on this warning I've marked this a feature request as opposed to a bug report, though it could also be seen as a bug in that the deployed template doesn't perform correctly.


# Steps to reproduce

## Command used to start LocalStack

`localstack start`

## Client code (AWS SDK code snippet, or sequence of "awslocal" commands)

template-scheduled.yaml:

<details>
  <summary>Click to expand</summary>

```yaml
AWSTemplateFormatVersion: '2010-09-09'
Description: Workflow for testing scheduling state machines

Resources:
  # IAM role to use for the step function
  TestStateMachineExecutionRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
        - Effect: "Allow"
          Principal:
            Service: !Sub states.${AWS::Region}.amazonaws.com
          Action: "sts:AssumeRole"
      Policies:
      - PolicyName: InvokeLambdas
        PolicyDocument:
          Version: "2012-10-17"
          Statement:
          - Effect: Allow
            Action: "lambda:InvokeFunction"
            Resource: "*"

  # Step function describing the workflow
  TestStateMachine:
    Type: "AWS::StepFunctions::StateMachine"
    Properties:
      RoleArn: !GetAtt TestStateMachineExecutionRole.Arn
      DefinitionString: 
        !Sub
        - |-
            {
              "Comment": "A Hello World example of the Amazon States Language using Pass states",
              "StartAt": "Hello",
              "States": {
                "Hello": {
                  "Type": "Pass",
                  "Result": "Hello",
                  "Next": "World"
                },
                "World": {
                  "Type": "Pass",
                  "Result": "World",
                  "End": true
                }
              }
            }
        - {}

  # IAM role to use to invoke the step function
  TestStateMachineScheduleTargetRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
        - Effect: "Allow"
          Principal:
            Service: events.amazonaws.com
          Action: "sts:AssumeRole"
      Policies:
      - PolicyName: InvokeTestStateMachine
        PolicyDocument:
          Version: "2012-10-17"
          Statement:
          - Effect: Allow
            Action: "states:StartExecution"
            Resource: !Ref TestStateMachine

  # Cloudwatch events rule to schedule the step function
  TestStateMachineSchedule:
    Type: AWS::Events::Rule
    Properties:
      ScheduleExpression: "cron(0/1 * * * ? *)"
      State: "ENABLED"
      Targets: 
        - Arn: !Ref TestStateMachine
          Id: "TestStateMachine"
          RoleArn: !GetAtt TestStateMachineScheduleTargetRole.Arn
```
</details>

```bash
$ awslocal cloudformation create-stack --stack-name test-scheduled-state-machine --template-body file://template-scheduled.yaml --capabilities CAPABILITY_IAM
{
    "StackId": "arn:aws:cloudformation:us-east-1:000000000000:stack/test-scheduled-state-machine/7defb145-dd75-4979-a315-46011d1ab663"
}

$ awslocal events list-rules
{
    "Rules": []
}
```

Note no rule has been created, although one exists in the template.
if EVENTS_TMP_DIR not in TMP_FILES:
        mkdir(EVENTS_TMP_DIR)
        TMP_FILES.append(EVENTS_TMP_DIR)
def _dump_events_to_files(events_with_added_uuid):
    current_time_millis = int(round(time.time() * 1000))
    for event in events_with_added_uuid:
        save_file(
            os.path.join(EVENTS_TMP_DIR, '%s_%s' % (current_time_millis, event['uuid'])),
            json.dumps(event['event'])
        )
def get_scheduled_rule_func(data):
    def func(*args):
        rule_name = data.get('Name')
        client = aws_stack.connect_to_service('events')
        targets = client.list_targets_by_rule(Rule=rule_name)['Targets']
        if targets:
            LOG.debug('Notifying %s targets in response to triggered Events rule %s' % (len(targets), rule_name))
        for target in targets:
            arn = target.get('Arn')
            event = json.loads(target.get('Input') or '{}')
            if ':lambda:' in arn:
                lambda_api.run_lambda(event=event, context={}, func_arn=arn)
            elif ':sns:' in arn:
                sns_client = aws_stack.connect_to_service('sns')
                sns_client.publish(TopicArn=arn, Message=json.dumps(event))
            else:
                LOG.info('Unsupported Events rule target ARN "%s"' % arn)
    return func
def convert_schedule_to_cron(schedule):