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()