<!-- 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.
self.events_client.put_events(
            Entries=[{
                'EventBusName': TEST_EVENT_BUS_NAME,
                'Source': TEST_EVENT_PATTERN['Source'],
                'DetailType': TEST_EVENT_PATTERN['DetailType'],
                'Detail': TEST_EVENT_PATTERN['Detail']
            }]
        )
        
        events = get_lambda_log_events(function_name)
        self.assertEqual(len(events), 1)
        self.assertDictEqual(events[0], json.loads(TEST_EVENT_PATTERN['Detail']))
        
        testutil.delete_lambda_function(function_name)
        self.events_client.remove_targets(
            Rule=rule_name,
            EventBusName=TEST_EVENT_BUS_NAME,
            Ids=[target_id],
            Force=True
        )
        self.events_client.delete_rule(
            Name=rule_name,
            EventBusName=TEST_EVENT_BUS_NAME,
            Force=True
        )
        self.events_client.delete_event_bus(
            Name=TEST_EVENT_BUS_NAME
        )
    def test_schedule_expression_event_with_http_endpoint(self):
        class HttpEndpointListener(ProxyListener):