<!-- 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.
schedule = data.get('ScheduleExpression')
    if schedule:
        job_func = get_scheduled_rule_func(data)
        cron = convert_schedule_to_cron(schedule)
        LOG.debug('Adding new scheduled Events rule with cron schedule %s' % cron)
        job_id = JobScheduler.instance().add_job(job_func, cron)
        region = aws_stack.get_region()
        RULE_SCHEDULED_JOBS[region] = RULE_SCHEDULED_JOBS.get(region) or {}
        RULE_SCHEDULED_JOBS[region][data['Name']] = job_id
    return True
def handle_delete_rule(rule_name):
    region = aws_stack.get_region()
    job_id = RULE_SCHEDULED_JOBS.get(region, {}).get(rule_name)
    if job_id:
        LOG.debug('Removing scheduled Events: {} | job_id: {}'.format(rule_name, job_id))
        JobScheduler.instance().cancel_job(job_id=job_id)
class ProxyListenerEvents(ProxyListener):