in source/code/handlers/event_handler_base.py [0:0]
def handle_request(self, use_custom_select=True):
"""
Handled the cloudwatch rule timer event
:return: Started tasks, if any, information
"""
try:
self._logger.info("Handling CloudWatch event {}", safe_json(self._event, indent=3))
result = []
start = datetime.now()
dt = self._event_time()
config_task = None
source_resource_tags = None
try:
# for all events tasks in configuration
for config_task in TaskConfiguration(context=self._context, logger=self._logger).get_tasks():
self._logger.debug_enabled = config_task.get(handlers.TASK_DEBUG, False)
if not self._event_triggers_task(task=config_task):
continue
# tasks that can react to events with a wider resource scope than the actual resource causing the event may
# have a filter that can is used to filter based on the tags of the resource
event_source_tag_filter = config_task.get(handlers.TASK_EVENT_SOURCE_TAG_FILTER, None)
if event_source_tag_filter is not None:
if source_resource_tags is None:
# get the tags for the source resource of the event
session = services.get_session(self._role_executing_triggered_task, logger=self._logger)
if session is None:
self._logger.error(ERR_NO_SESSION_FOR_GETTING_TAGS)
continue
try:
source_resource_tags = self._source_resource_tags(session, config_task)
except Exception as ex:
self._logger.error(ERR_GETTING_EVENT_SOURCE_RESOURCE_TAGS, ex)
continue
self._logger.debug("Tags for event source resource are {}", source_resource_tags)
# apply filter to source resource tags
if not TagFilterExpression(event_source_tag_filter).is_match(source_resource_tags):
self._logger.debug("Tags of source resource do not match tag filter {}", event_source_tag_filter)
continue
task_name = config_task[handlers.TASK_NAME]
result.append(task_name)
select_parameters = self._select_parameters(self._event_name(), config_task)
if select_parameters is None:
continue
self._logger.debug(DEBUG_EVENT, task_name, self._event_name(), select_parameters,
self._event_account(), self._event_region(), safe_json(config_task, indent=3))
# create an event for lambda function that scans for resources for this task
lambda_event = {
handlers.HANDLER_EVENT_ACTION: handlers.HANDLER_ACTION_SELECT_RESOURCES,
handlers.HANDLER_EVENT_CUSTOM_SELECT: use_custom_select,
handlers.HANDLER_SELECT_ARGUMENTS: {
handlers.HANDLER_EVENT_REGIONS: [self._event_region()],
handlers.HANDLER_EVENT_ACCOUNT: self._event_account(),
handlers.HANDLER_EVENT_RESOURCE_NAME: config_task[handlers.TASK_RESOURCE_TYPE],
},
handlers.HANDLER_EVENT_SOURCE: "{}:{}:{}".format(self._handled_event_source, self._handled_detail_type,
self._event_name()),
handlers.HANDLER_EVENT_TASK: config_task,
handlers.HANDLER_EVENT_TASK_DT: dt
}
for i in select_parameters:
lambda_event[handlers.HANDLER_SELECT_ARGUMENTS][i] = select_parameters[i]
if self._event_resources() is not None:
self._logger.debug(DEBUG_EVENT_RESOURCES, safe_json(self._event_resources(), indent=3))
lambda_event[handlers.HANDLER_SELECT_RESOURCES] = self._event_resources()
if not handlers.running_local(self._context):
# start lambda function to scan for task resources
payload = str.encode(safe_json(lambda_event))
client = get_client_with_retries("lambda", ["invoke"],
context=self._context,
logger=self._logger)
client.invoke_with_retries(FunctionName=self._context.function_name,
InvocationType="Event",
LogType="None",
Payload=payload)
else:
# or if not running in lambda environment pass event to main task handler
lambda_handler(lambda_event, None)
return safe_dict({
"datetime": datetime.now().isoformat(),
"running-time": (datetime.now() - start).total_seconds(),
"event-datetime": dt,
"started-tasks": result
})
except ValueError as ex:
self._logger.error(ERR_HANDLING_EVENT_IN_BASE_HANDLER, ex, safe_json(config_task, indent=2))
finally:
self._logger.flush()