Yasuke/moto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add multi region support for Events

Browse Source
This commit is contained in:
Jessie Nadler 2019-10-03 15:11:09 -04:00
parent 4fe66f521d
commit 277cec0928
4 changed files with 49 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
moto/events/__init__.py
View File

@ -1,6 +1,7 @@
from __future__ import unicode_literals
from .models import events_backend
from .models import events_backends
from ..core.models import base_decorator
events_backends = {"global": events_backend}
mock_events = events_backend.decorator
events_backend = events_backends['us-east-1']
mock_events = base_decorator(events_backends)

28
moto/events/models.py
View File

@ -1,6 +1,7 @@
import os
import re
import json
import boto3
from moto.core.exceptions import JsonRESTError
from moto.core import BaseBackend, BaseModel
@ -8,12 +9,15 @@ from moto.core import BaseBackend, BaseModel
class Rule(BaseModel):
def _generate_arn(self, name):
return 'arn:aws:events:us-west-2:111111111111:rule/' + name
def _generate_arn(self, name, region_name):
return 'arn:aws:events:{region_name}:111111111111:rule/{name}'.format(
region_name=region_name,
name=name
)
def __init__(self, name, **kwargs):
def __init__(self, name, region_name, **kwargs):
self.name = name
self.arn = kwargs.get('Arn') or self._generate_arn(name)
self.arn = kwargs.get('Arn') or self._generate_arn(name, region_name)
self.event_pattern = kwargs.get('EventPattern')
self.schedule_exp = kwargs.get('ScheduleExpression')
self.state = kwargs.get('State') or 'ENABLED'
@ -55,15 +59,20 @@ class EventsBackend(BaseBackend):
ACCOUNT_ID = re.compile(r'^(\d{1,12}|\*)$')
STATEMENT_ID = re.compile(r'^[a-zA-Z0-9-_]{1,64}$')
def __init__(self):
def __init__(self, region_name):
self.rules = {}
# This array tracks the order in which the rules have been added, since
# 2.6 doesn't have OrderedDicts.
self.rules_order = []
self.next_tokens = {}
self.region_name = region_name
self.permissions = {}
def reset(self):
region_name = self.region_name
self.__dict__ = {}
self.__init__(region_name)
def _get_rule_by_index(self, i):
return self.rules.get(self.rules_order[i])
@ -173,7 +182,7 @@ class EventsBackend(BaseBackend):
return return_obj
def put_rule(self, name, **kwargs):
rule = Rule(name, **kwargs)
rule = Rule(name, self.region_name, **kwargs)
self.rules[rule.name] = rule
self.rules_order.append(rule.name)
return rule.arn
@ -229,7 +238,7 @@ class EventsBackend(BaseBackend):
raise JsonRESTError('ResourceNotFoundException', 'StatementId not found')
def describe_event_bus(self):
arn = "arn:aws:events:us-east-1:000000000000:event-bus/default"
arn = "arn:aws:events:{0}:000000000000:event-bus/default".format(self.region_name)
statements = []
for statement_id, data in self.permissions.items():
statements.append({
@ -248,4 +257,5 @@ class EventsBackend(BaseBackend):
}
events_backend = EventsBackend()
available_regions = boto3.session.Session().get_available_regions("events")
events_backends = {region: EventsBackend(region) for region in available_regions}

40
moto/events/responses.py
View File

@ -2,11 +2,21 @@ import json
import re
from moto.core.responses import BaseResponse
from moto.events import events_backend
from moto.events import events_backends
class EventsHandler(BaseResponse):
@property
def events_backend(self):
"""
Events Backend
:return: Events Backend object
:rtype: moto.events.models.EventsBackend
"""
return events_backends[self.region]
def _generate_rule_dict(self, rule):
return {
'Name': rule.name,
@ -40,7 +50,7 @@ class EventsHandler(BaseResponse):
if not name:
return self.error('ValidationException', 'Parameter Name is required.')
events_backend.delete_rule(name)
self.events_backend.delete_rule(name)
return '', self.response_headers
@ -50,7 +60,7 @@ class EventsHandler(BaseResponse):
if not name:
return self.error('ValidationException', 'Parameter Name is required.')
rule = events_backend.describe_rule(name)
rule = self.events_backend.describe_rule(name)
if not rule:
return self.error('ResourceNotFoundException', 'Rule test does not exist.')
@ -64,7 +74,7 @@ class EventsHandler(BaseResponse):
if not name:
return self.error('ValidationException', 'Parameter Name is required.')
if not events_backend.disable_rule(name):
if not self.events_backend.disable_rule(name):
return self.error('ResourceNotFoundException', 'Rule ' + name + ' does not exist.')
return '', self.response_headers
@ -75,7 +85,7 @@ class EventsHandler(BaseResponse):
if not name:
return self.error('ValidationException', 'Parameter Name is required.')
if not events_backend.enable_rule(name):
if not self.events_backend.enable_rule(name):
return self.error('ResourceNotFoundException', 'Rule ' + name + ' does not exist.')
return '', self.response_headers
@ -91,7 +101,7 @@ class EventsHandler(BaseResponse):
if not target_arn:
return self.error('ValidationException', 'Parameter TargetArn is required.')
rule_names = events_backend.list_rule_names_by_target(
rule_names = self.events_backend.list_rule_names_by_target(
target_arn, next_token, limit)
return json.dumps(rule_names), self.response_headers
@ -101,7 +111,7 @@ class EventsHandler(BaseResponse):
next_token = self._get_param('NextToken')
limit = self._get_param('Limit')
rules = events_backend.list_rules(prefix, next_token, limit)
rules = self.events_backend.list_rules(prefix, next_token, limit)
rules_obj = {'Rules': []}
for rule in rules['Rules']:
@ -121,7 +131,7 @@ class EventsHandler(BaseResponse):
return self.error('ValidationException', 'Parameter Rule is required.')
try:
targets = events_backend.list_targets_by_rule(
targets = self.events_backend.list_targets_by_rule(
rule_name, next_token, limit)
except KeyError:
return self.error('ResourceNotFoundException', 'Rule ' + rule_name + ' does not exist.')
@ -131,7 +141,7 @@ class EventsHandler(BaseResponse):
def put_events(self):
events = self._get_param('Entries')
failed_entries = events_backend.put_events(events)
failed_entries = self.events_backend.put_events(events)
if failed_entries:
return json.dumps({
@ -165,7 +175,7 @@ class EventsHandler(BaseResponse):
re.match('^rate\(\d*\s(minute|minutes|hour|hours|day|days)\)', sched_exp)):
return self.error('ValidationException', 'Parameter ScheduleExpression is not valid.')
rule_arn = events_backend.put_rule(
rule_arn = self.events_backend.put_rule(
name,
ScheduleExpression=sched_exp,
EventPattern=event_pattern,
@ -186,7 +196,7 @@ class EventsHandler(BaseResponse):
if not targets:
return self.error('ValidationException', 'Parameter Targets is required.')
if not events_backend.put_targets(rule_name, targets):
if not self.events_backend.put_targets(rule_name, targets):
return self.error('ResourceNotFoundException', 'Rule ' + rule_name + ' does not exist.')
return '', self.response_headers
@ -201,7 +211,7 @@ class EventsHandler(BaseResponse):
if not ids:
return self.error('ValidationException', 'Parameter Ids is required.')
if not events_backend.remove_targets(rule_name, ids):
if not self.events_backend.remove_targets(rule_name, ids):
return self.error('ResourceNotFoundException', 'Rule ' + rule_name + ' does not exist.')
return '', self.response_headers
@ -214,16 +224,16 @@ class EventsHandler(BaseResponse):
principal = self._get_param('Principal')
statement_id = self._get_param('StatementId')
events_backend.put_permission(action, principal, statement_id)
self.events_backend.put_permission(action, principal, statement_id)
return ''
def remove_permission(self):
statement_id = self._get_param('StatementId')
events_backend.remove_permission(statement_id)
self.events_backend.remove_permission(statement_id)
return ''
def describe_event_bus(self):
return json.dumps(events_backend.describe_event_bus())
return json.dumps(self.events_backend.describe_event_bus())

2
tests/test_events/test_events.py
View File

@ -87,7 +87,7 @@ def test_describe_rule():
assert(response is not None)
assert(response.get('Name') == rule_name)
assert(response.get('Arn') is not None)
assert(response.get('Arn') == 'arn:aws:events:us-west-2:111111111111:rule/{0}'.format(rule_name))
@mock_events