def create_function(self):
try:
response = self.client.create_function(self.get_property("name"),
self.get_property("runtime"),
self.get_property("iam", "role"),
self.get_property("handler"),
self.get_property("code"),
self.get_property("environment"),
self.get_property("description"),
self.get_property("time"),
self.get_property("memory"),
self.get_property("tags"))
if response and 'FunctionArn' in response:
self.properties["function_arn"] = response['FunctionArn']
response_parser.parse_lambda_function_creation_response(response,
self.get_function_name(),
self.client.get_access_key(),
self.get_output_type())
except ClientError as ce:
error_msg = "Error initializing lambda function."
logger.error(error_msg, error_msg + ": %s" % ce)
utils.finish_failed_execution()
finally:
# Remove the files created in the operation
utils.delete_file(self.properties["zip_file_path"])
def get_api_gateway_url(self, function_name):
api_id = self.get_api_gateway_id(function_name)
if api_id is None or api_id == "":
error_msg = "Error retrieving API ID for lambda function {0}".format(function_name)
logger.error(error_msg)
utils.finish_failed_execution()
return 'https://{0}.execute-api.{1}.amazonaws.com/scar/launch'.format(api_id, self.get_property("region"))
def update_function_memory(self, function_name, memory):
try:
self.get_client().update_function_configuration(FunctionName=function_name,
MemorySize=validators.validate_memory(memory))
except ClientError as ce:
error_msg = "Error updating lambda function memory"
logger.error(error_msg, error_msg + ": %s" % ce)
utils.finish_failed_execution()
def update_function_timeout(self, function_name, timeout):
try:
self.get_client().update_function_configuration(FunctionName=function_name,
Timeout=validators.validate_time(timeout))
except ClientError as ce:
error_msg = "Error updating lambda function timeout"
logger.error(error_msg, error_msg + ": %s" % ce)
utils.finish_failed_execution()
def get_function_info(self, function_name_or_arn):
try:
# If this call works the function exists
return self.client.get_function_info(function_name_or_arn)
except ClientError as ce:
error_msg = "Error while looking for the lambda function"
logger.error(error_msg, error_msg + ": %s" % ce)
utils.finish_failed_execution()
def get_log_events_by_group_name_and_stream_name(self, log_group_name, log_stream_name):
try:
return self.get_client().get_log_events(logGroupName=log_group_name,
logStreamName=log_stream_name,
startFromHead=True)
except ClientError as ce:
logger.error("Error getting log events for log group '%s' and log stream name '%s': %s"
% (log_group_name, log_stream_name, ce))
utils.finish_failed_execution()
def parse_arguments(self):
'''Command parsing and selection'''
try:
return self.parser.parse_args()
except AttributeError as ae:
logger.error(
"Incorrect arguments: use scar -h to see the options available",
"Error parsing arguments: %s" % ae)
utils.finish_failed_execution()
def get_log_events_by_group_name(self, log_group_name, next_token=None):
try:
if next_token:
return self.get_client().filter_log_events(logGroupName=log_group_name,
nextToken=next_token)
else:
return self.get_client().filter_log_events(logGroupName=log_group_name)
except ClientError as ce:
logger.error("Error getting log events for log group '%s': %s" % (log_group_name, ce))
utils.finish_failed_execution()
def upload_file_to_S3_bucket(image_file, deployment_bucket, file_key):
if (utils.get_tree_size(scar_temporal_folder) > MAX_S3_PAYLOAD_SIZE):
error_msg = "Uncompressed image size greater than 250MB.\nPlease reduce the uncompressed image and try again."
logger.error(error_msg)
utils.finish_failed_execution()
logger.info("Uploading '%s' to the '%s' S3 bucket" %
(image_file, deployment_bucket))
file_data = utils.get_file_as_byte_array(image_file)
S3().upload_file(deployment_bucket, file_key, file_data)
def create_log_group(self, log_group_name, tags):
try:
logger.debug("Creating cloudwatch log group.")
return self.get_client().create_log_group(logGroupName=log_group_name, tags=tags)
except ClientError as ce:
if ce.response['Error']['Code'] == 'ResourceAlreadyExistsException':
logger.warning("Using existent log group '%s'" % log_group_name)
pass
else:
logger.error("Error creating log groups.",
"Error creating log groups: %s" % ce)
utils.finish_failed_execution()
def check_file_size(self, file_path):
asynch = self.get_property("asynchronous")
file_size = utils.get_file_size(file_path)
error_msg = None
if file_size > MAX_POST_BODY_SIZE:
error_msg = "Invalid request: Payload size {0:.2f} MB greater than 6 MB".format((file_size/(1024*1024)))
elif asynch and file_size > MAX_POST_BODY_SIZE_ASYNC:
error_msg = "Invalid request: Payload size {0:.2f} KB greater than 128 KB".format((file_size/(1024)))
if error_msg:
error_msg += "\nCheck AWS Lambda invocation limits in : https://docs.aws.amazon.com/lambda/latest/dg/limits.html"
logger.error(error_msg)
utils.finish_failed_execution()
def parse_error_invocation_response(response, function_name):
if "Task timed out" in response['Payload']:
# Find the timeout time
message = utils.find_expression('(Task timed out .* seconds)',
str(response['Payload']))
# Modify the error message to ease the error readability
error_msg = message.replace("Task", "Function '%s'" % function_name)
error_log = "Error in function response: %s" % error_msg
else:
error_msg = "Error in function response."
error_log = "Error in function response: %s" % response['Payload']
logger.error(error_msg, error_log)
utils.finish_failed_execution()
def find_function(self, function_name_or_arn):
validators.validate_function_name(function_name_or_arn, self.get_property("name_regex"))
try:
# If this call works the function exists
self.client.get_function_info(function_name_or_arn)
return True
except ClientError as ce:
# Function not found
if ce.response['Error']['Code'] == 'ResourceNotFoundException':
return False
else:
error_msg = "Error while looking for the lambda function"
logger.error(error_msg, error_msg + ": %s" % ce)
utils.finish_failed_execution()
def invoke_function(self, function_name, invocation_type, log_type, payload):
response = {}
try:
response = self.get_client().invoke(FunctionName=function_name,
InvocationType=invocation_type,
LogType=log_type,
Payload=payload)
except ClientError as ce:
error_msg = "Error invoking lambda function"
logger.error(error_msg, error_msg + ": %s" % ce)
utils.finish_failed_execution()
except ReadTimeout as rt:
error_msg = "Timeout reading connection pool"
logger.error(error_msg, error_msg + ": %s" % rt)
utils.finish_failed_execution()
return response
def check_function_name(self, func_name=None):
call_type = self.get_property("call_type")
if func_name:
function_name = func_name
else:
function_name = self.get_property("name")
function_found = self.find_function(function_name)
error_msg = None
if function_found and (call_type == CallType.INIT):
error_msg = "Function name '%s' already used." % function_name
elif (not function_found) and ((call_type == CallType.RM) or
(call_type == CallType.RUN) or
(call_type == CallType.INVOKE)):
error_msg = "Function '%s' doesn't exist." % function_name
if error_msg:
logger.error(error_msg)
utils.finish_failed_execution()
def payload_size_error(zip_file_path, message):
logger.error(message)
utils.delete_file(zip_file_path)
utils.finish_failed_execution()
