def __init__(self, event, context):
"""
Initializes helper setup class
:param event:
:param context:
"""
CustomResource.__init__(self, event, context)
self.arguments = copy(self.resource_properties)
self.arguments = {a: self.resource_properties[a] for a in self.resource_properties if a not in ["ServiceToken",
"Timeout"]}
self.configuration_bucket = os.getenv(configuration.ENV_CONFIG_BUCKET, None)
self.automator_role_arn = self.arguments.get("OpsAutomatorLambdaRole")
self.events_forward_role = self.arguments.get("EventForwardLambdaRole")
self.ops_automator_topic_arn = self.arguments.get("OpsAutomatorTopicArn")
self.use_ecs = TaskConfiguration.as_boolean(self.arguments.get("UseEcs", False))
self.optimize_cross_account_template = TaskConfiguration.as_boolean(
(self.arguments.get("OptimizeCrossAccountTemplate", False)))
self.account = os.getenv(handlers.ENV_OPS_AUTOMATOR_ACCOUNT)
self.stack_version = self.arguments["StackVersion"]
# setup logging
dt = datetime.utcnow()
classname = self.__class__.__name__
logstream = LOG_STREAM.format(classname, dt.year, dt.month, dt.day)
self._logger = QueuedLogger(logstream=logstream, context=context, buffersize=50)
def __init__(self, event, context):
"""
Initializes the instance.
:param event: event to handle
:param context: CLambda context
"""
self._context = context
self._event = event
self._table = None
# Setup logging
classname = self.__class__.__name__
dt = datetime.utcnow()
logstream = LOG_STREAM.format(classname, dt.year, dt.month, dt.day)
self._logger = QueuedLogger(logstream=logstream,
buffersize=50,
context=context)
self.configuration_update = ScheduleHandler.is_config_update(
self._event)
if self.configuration_update:
if "OldImage" in self._event["Records"][0]["dynamodb"]:
self.updated_task = self._event["Records"][0]["dynamodb"][
"OldImage"][configuration.CONFIG_TASK_NAME]["S"]
else:
self.updated_task = self._event["Records"][0]["dynamodb"][
"NewImage"][configuration.CONFIG_TASK_NAME]["S"]
self.execute_task_request = self.is_execute_event(self._event)
self.executed_task_name = event.get(
handlers.HANDLER_EVENT_TASK_NAME,
"") if self.execute_task_request else None
def __init__(self, event, context):
"""
Initializes the instance.
:param event: Handled event
:param context: Context if running in Lambda
"""
self._context = context
self._event = event
self._tracking_table = None
self._concurrency_table = None
self.started_tasks = 0
self.started_waiting_tasks = 0
self.waiting_for_execution_tasks = 0
self.started_completion_checks = 0
self.finished_concurrency_tasks = 0
self.done_work = False
self.invoked_lambda_functions = []
self.events_client = None
self._s3_client = None
self._db_client = None
# setup logging
classname = self.__class__.__name__
dt = datetime.utcnow()
logstream = LOG_STREAM.format(classname, dt.year, dt.month, dt.day)
self._logger = QueuedLogger(logstream=logstream,
context=self._context,
buffersize=20,
debug=os.getenv(
ENV_DEBUG_TASK_TACKING_HANDLER,
"false").lower() == "true")
def __init__(self, event, context):
"""
Initializes handle instance
:param event: event to handle
:param context: lambda context
"""
self._event = event
self._context = context
self._logger = None
self.additional_parameters = {}
self.commands = {
"describe-tasks":
"get_tasks" if self.parameters.get("name") is None else "get_task",
"start-task":
"start_task"
}
self.attribute_transformations = {}
self.result_transformations = {}
# Setup logging
classname = self.__class__.__name__
dt = datetime.utcnow()
logstream = LOG_STREAM.format(classname, dt.year, dt.month, dt.day)
self._logger = QueuedLogger(logstream=logstream,
buffersize=20,
context=self._context)
def _logger(self):
if self.__logger is None:
# setup logging
if self.execution_log_stream is None:
if callable(
getattr(self._action_class, "action_logging_subject",
None)):
# noinspection PyBroadException
try:
action_subject = self._action_class.action_logging_subject(
self._action_arguments, self.action_parameters)
self.execution_log_stream = "{}-{}".format(
self._event[handlers.TASK_TR_NAME], action_subject)
except Exception as ex:
print((ERR_BUILDING_SUBJECT_FOR_LOG_STREAM,
str(self._action_class), ex))
action_subject = "unknown-"
self.execution_log_stream = LOG_STREAM.format(
self._event[handlers.TASK_TR_NAME], action_subject,
actions.log_stream_datetime(),
self._action_arguments.get(handlers.TASK_TR_ID,
"None"))
else:
self.execution_log_stream = self.execution_log_stream
self.__logger = QueuedLogger(logstream=self.execution_log_stream,
buffersize=50 if self.debug else 20,
context=self._context,
debug=self.debug)
return self.__logger
def _get_logger(class_name, context, account=None, region=None):
dt = datetime.utcnow()
log_stream = LOG_STREAM.format(
class_name, account + "-" if account is not None else "",
region + "-" if region is not None else "", dt.year, dt.month,
dt.day)
return QueuedLogger(logstream=log_stream,
buffersize=20,
context=context)
def __init__(self, event, context):
"""
Initializes the instance.
:param event: event to handle
:param context: Lambda context
"""
self._context = context
self._event = event
self._table = None
# Setup logging
classname = self.__class__.__name__
dt = datetime.utcnow()
logstream = LOG_STREAM.format(classname, dt.year, dt.month, dt.day)
self._logger = QueuedLogger(logstream=logstream, buffersize=20, context=context)
def __init__(self, event, context):
CustomResource.__init__(self, event, context)
self.arguments = copy(self.resource_properties)
self.arguments = {
a: self.resource_properties[a]
for a in self.resource_properties
if a not in ["ServiceToken", "Timeout"]
}
# setup logging
dt = datetime.utcnow()
classname = self.__class__.__name__
logstream = LOG_STREAM.format(classname, dt.year, dt.month, dt.day)
self._logger = QueuedLogger(logstream=logstream,
context=context,
buffersize=20)
def __init__(self, event, context, logger=None, tracking_store=None):
def log_stream_name():
classname = self.__class__.__name__
dt = datetime.utcnow()
account = self._event.get(handlers.HANDLER_SELECT_ARGUMENTS,
{}).get(handlers.HANDLER_EVENT_ACCOUNT,
"")
regions = self._event.get(handlers.HANDLER_SELECT_ARGUMENTS,
{}).get(handlers.HANDLER_EVENT_REGIONS,
[])
if account is not None and len(regions) > 0:
account_and_region = "-".join([account, regions[0]]) + "-"
else:
region = ""
if self.sub_task is not None:
account = ""
if self._this_account:
if len(self._accounts) == 0:
account = os.getenv(
handlers.ENV_OPS_AUTOMATOR_ACCOUNT)
elif len(self._accounts) == 1:
account = self._accounts[0]
region = self._regions[0] if len(
self._regions) == 1 else ""
if account != "":
if region not in ["", None]:
account_and_region = "-".join([account, region]) + "-"
else:
account_and_region = account
else:
account_and_region = ""
return LOG_STREAM.format(classname, self.task[handlers.TASK_NAME],
account_and_region, dt.year, dt.month,
dt.day)
self._context = context
self._event = event
self.task = event[handlers.HANDLER_EVENT_TASK]
self.sub_task = event.get(handlers.HANDLER_EVENT_SUB_TASK, None)
self.use_custom_select = event.get(
handlers.HANDLER_EVENT_CUSTOM_SELECT, True)
# the job id is used to correlate all generated tasks for the selected resources
self.task_group = self._event.get(handlers.HANDLER_EVENT_TASK_GROUP,
None)
if self.task_group is None:
self.task_group = str(uuid.uuid4())
debug = event[handlers.HANDLER_EVENT_TASK].get(handlers.TASK_DEBUG,
False)
if logger is None:
self._logger = QueuedLogger(logstream=log_stream_name(),
context=context,
buffersize=50 if debug else 20,
debug=debug)
else:
self._logger = logger
self._sts = None
self.select_args = event.get(handlers.HANDLER_SELECT_ARGUMENTS, {})
self.task_dt = event[handlers.HANDLER_EVENT_TASK_DT]
self.action_properties = actions.get_action_properties(
self.task[handlers.TASK_ACTION])
self.action_class = actions.get_action_class(
self.task[handlers.TASK_ACTION])
self.task_parameters = self.task.get(handlers.TASK_PARAMETERS, {})
self.metrics = self.task.get(handlers.TASK_METRICS, False)
self.service = self.action_properties[actions.ACTION_SERVICE]
self.keep_tags = self.action_properties.get(
actions.ACTION_KEEP_RESOURCE_TAGS, True)
self.source = self._event.get(handlers.HANDLER_EVENT_SOURCE,
handlers.UNKNOWN_SOURCE)
self.run_local = handlers.running_local(self._context)
self._timer = None
self._timeout_event = self._timeout_event = threading.Event()
self.aggregation_level = self.action_properties.get(
actions.ACTION_AGGREGATION, actions.ACTION_AGGREGATION_RESOURCE)
if self.aggregation_level is not None and isinstance(
self.aggregation_level, types.FunctionType):
self.aggregation_level = self.aggregation_level(
self.task_parameters)
self.batch_size = self.action_properties.get(actions.ACTION_BATCH_SIZE)
if self.batch_size is not None and isinstance(self.batch_size,
types.FunctionType):
self.batch_size = self.batch_size(self.task_parameters)
self.actions_tracking = TaskTrackingTable(
self._context,
logger=self._logger) if tracking_store is None else tracking_store
def _get_logger(context):
dt = datetime.utcnow()
logstream = LOG_STREAM.format(dt.year, dt.month, dt.day)
return QueuedLogger(logstream=logstream, buffersize=10, context=context)