Merge pull request #8 from madeiramadeirabr/equiparacao_lambda_sqs

Equiparacao lambda sqs com lambda api

Author: andersoncontreira

examples/lambda_api/app.py

@@ -43,9 +43,6 @@
 @app.route('/')
 def index():
     body = {"app": '%s:%s' % (APP_NAME, APP_VERSION)}
-    # logger.info('Env: {} App Info: {}'.format(config.APP_ENV, body))
-    # Temporário para debug
-    # logger.info('Env Vars: {}'.format(config.to_dict()))
     return http_helper.create_response(body=body, status_code=200)
 
 

examples/lambda_api/lambda_app/aws/secrets.py

@@ -7,7 +7,7 @@
 
 
 class Secrets:
-    def __init__(self, logger=None):
+    def __init__(self, logger=None, profile=None, session=None):
         """
         # This cant import get_config
         :param logger:
@@ -16,24 +16,34 @@ def __init__(self, logger=None):
         self.logger = logger if logger is not None else get_logger()
         # last_exception
         self.exception = None
+        # profile
+        self.profile = profile if profile is not None else \
+            os.environ['AWS_PROFILE'] if 'AWS_PROFILE' in os.environ else None
+        # session
+        self.session = session if session is not None else \
+            boto3.session.Session(profile_name=self.profile)
 
     def connect(self):
         connection = None
         try:
-            profile = os.environ['AWS_PROFILE'] if 'AWS_PROFILE' in os.environ else None
             region_name = os.environ['AWS_REGION'] if 'AWS_REGION' in os.environ else None
+
             # region validation
             if region_name is None:
                 region_name = os.environ['REGION_NAME'] if 'REGION_NAME' in os.environ else 'us-east-2'
 
-            self.logger.info('profile: {}'.format(profile))
-            if profile:
-                session = boto3.session.Session(profile_name=profile)
+            self.logger.info('Secrets - profile: {}'.format(self.profile))
+            self.logger.info('Secrets - self.config.REGION_NAME: {}'.format(region_name))
+
+            if self.profile:
+                session = self.session
+                # todo avaliar troca para session.resource
                 connection = session.client(
                     service_name='secretsmanager',
                     region_name=region_name
                 )
             else:
+                # todo avaliar troca para boto3.resource
                 connection = boto3.client(
                     service_name='secretsmanager',
                     region_name=region_name

examples/lambda_api/lambda_app/events/aws/sqs.py renamed to examples/lambda_api/lambda_app/aws/sqs.py

@@ -31,12 +31,18 @@ def connect(self, retry=False):
         connection = None
         try:
             endpoint_url = self.config.SQS_ENDPOINT
+            region_name = self.config.REGION_NAME
+
+            # region validation
+            if region_name is None:
+                region_name = os.environ['REGION_NAME'] if 'REGION_NAME' in os.environ else 'us-east-2'
 
             queue_name = os.path.basename(os.environ['APP_QUEUE']) if 'APP_QUEUE' in os.environ else None
+
             self.logger.info('SQSEvents - profile: {}'.format(self.profile))
             self.logger.info('SQSEvents - endpoint_url: {}'.format(endpoint_url))
             self.logger.info('SQSEvents - queue_name: {}'.format(queue_name))
-            self.logger.info('SQSEvents - self.config.REGION_NAME: {}'.format(self.config.REGION_NAME))
+            self.logger.info('SQSEvents - self.config.REGION_NAME: {}'.format(region_name))
 
             if self.profile:
                 session = self.session

examples/lambda_api/lambda_app/database/dynamodb.py

@@ -3,7 +3,7 @@
 
 import boto3
 
-from chalicelib.logging import get_logger
+from lambda_app.logging import get_logger
 
 logger = get_logger()
 
@@ -17,6 +17,7 @@ def reset():
     _CONNECTION = False
 
 
+# TODO aplicar class aos moldes da pasta aws
 def get_connection(connect=True, retry=False):
     global _CONNECTION, _RETRY_COUNT, _MAX_RETRY_ATTEMPTS
     if not _CONNECTION:

examples/lambda_api/lambda_app/database/mysql.py

@@ -16,6 +16,7 @@ def reset():
     _CONNECTION = False
 
 
+# TODO aplicar class aos moldes da pasta aws
 def get_connection(config=None, connect=True, retry=False):
     global _CONNECTION, _RETRY_COUNT, _MAX_RETRY_ATTEMPTS
     if not _CONNECTION:

examples/lambda_api/lambda_app/database/redis.py

@@ -17,6 +17,7 @@ def reset():
     _CONNECTION = False
 
 
+# TODO aplicar class aos moldes da pasta aws
 def get_connection(config=None, retry=False):
     global _CONNECTION, _RETRY_COUNT, _MAX_RETRY_ATTEMPTS
     if not _CONNECTION:

examples/lambda_api/lambda_app/services/event_manager.py

@@ -6,6 +6,7 @@
 from lambda_app.exceptions import ApiException
 from lambda_app.helper import generate_hash
 from lambda_app.logging import get_logger
+from lambda_app.services.v1.ocoren_event_service import OcorenEventService
 from lambda_app.vos.events import EventVO
 
 
@@ -28,7 +29,7 @@ def __init__(self, event_service=None, logger=None, config=None, redis_connectio
         self.config = config if config is not None else get_config()
         # database connection
         self.redis_connection = redis_connection if redis_connection is not None else get_connection()
-        self.event_service = event_service if event_service is not None else None
+        self.event_service = event_service if event_service is not None else OcorenEventService(self.logger)
         self.event_tracker = event_tracker if event_tracker is not None else EventTracker(self.logger)
         self.exception = None
 

examples/lambda_api/lambda_app/services/v1/healthcheck/resources.py

@@ -5,7 +5,7 @@
 from lambda_app.services.v1.healthcheck import AbstractHealthCheck, HealthCheckResult
 from lambda_app.database.mysql import get_connection
 from lambda_app.database.redis import get_connection as redis_get_connection
-from lambda_app.events.aws.sqs import SQSEvents
+from lambda_app.aws.sqs import SQSEvents
 
 
 class SelfConnectionHealthCheck(AbstractHealthCheck):

examples/lambda_api/lambda_app/services/v1/ocoren_event_service.py

@@ -1,5 +1,5 @@
 from lambda_app.config import get_config
-from lambda_app.events.aws.sqs import SQSEvents
+from lambda_app.aws.sqs import SQSEvents
 from lambda_app.logging import get_logger
 from lambda_app.vos.events import EventVO
 

examples/lambda_api/scripts/migrations/mysql/migrate.py

@@ -0,0 +1,241 @@
+import sys
+import re
+import os
+import logging
+
+os.environ["LOG_LEVEL"] = logging.getLevelName(logging.INFO)
+
+if __package__:
+    current_path = os.path.abspath(os.path.dirname(__file__)).replace('/' + str(__package__), '', 1)
+else:
+    current_path = os.path.abspath(os.path.dirname(__file__))
+
+if not current_path[-1] == '/':
+    current_path += '/'
+
+ROOT_DIR = current_path.replace('scripts/migrations/mysql/', '')
+
+_REGISTERED_PATHS = False
+
+
+def register_paths():
+    global _REGISTERED_PATHS
+    if not _REGISTERED_PATHS:
+        # path fixes, define the priority of the modules search
+        sys.path.insert(0, ROOT_DIR)
+        sys.path.insert(0, ROOT_DIR + 'venv/')
+        sys.path.insert(1, ROOT_DIR + 'chalicelib/')
+        sys.path.insert(1, ROOT_DIR + 'flask_app/')
+        sys.path.insert(1, ROOT_DIR + 'lambda_app/')
+        sys.path.insert(2, ROOT_DIR + 'vendor/')
+        _REGISTERED_PATHS = True
+    pass
+
+
+# register the paths
+register_paths()
+
+from lambda_app.logging import get_logger
+from lambda_app.boot import reset, load_dot_env, load_env
+from lambda_app.config import reset as reset_config, get_config
+from lambda_app.database.mysql import get_connection
+
+logger = get_logger()
+logger.info("ROOT_DIR " + ROOT_DIR)
+
+
+if __package__:
+    current_path = os.path.abspath(os.path.dirname(__file__)).replace('/' + str(__package__), '', 1)
+else:
+    current_path = os.path.abspath(os.path.dirname(__file__))
+
+if not current_path[-1] == '/':
+    current_path += '/'
+
+
+class ConnectionHelper:
+    @staticmethod
+    def get_mysql_local_connection():
+        return get_connection()
+
+
+class MySQLHelper:
+
+    @staticmethod
+    def get_connection():
+        """
+        :return:
+        """
+        return ConnectionHelper.get_mysql_local_connection()
+
+    @staticmethod
+    def drop_table(connection, table_name):
+        result = True
+        try:
+            # connection = MySQLHelper.get_connection()
+            connection.connect()
+
+            content = "DROP TABLE IF EXISTS " + table_name
+            print(f"Deleting {table_name}...")
+            with connection.cursor() as cursor:
+                cursor.execute(content)
+                print(f"{table_name} deleted")
+
+        except Exception as err:
+            print(f"{table_name} not exists")
+        try:
+            connection.close()
+        except Exception as err:
+            pass
+        return result
+
+    @staticmethod
+    def sow_table(connection, table_name, file_name):
+        result = False
+        cnt = 0
+        seeder_file = None
+        try:
+            connection.connect()
+            seeder_file = open(file_name, 'r')
+            line = seeder_file.readline().strip().replace(';', '')
+            cnt = 0
+            try:
+                while line:
+                    cnt += 1
+                    with connection.cursor() as cursor:
+                        if line != '':
+                            cursor.execute(line,)
+                    line = seeder_file.readline().strip().replace(';', '')
+
+                connection.commit()
+                result = True
+            except Exception as ex:
+                result = False
+                connection.rollback()
+                print(ex)
+        except Exception as ex:
+            result = False
+            print(ex)
+        finally:
+            if seeder_file is not None:
+                seeder_file.close()
+
+        print("Total of rows affected: %d" % cnt)
+        try:
+            connection.close()
+        except Exception as err:
+            pass
+        return result
+
+    @staticmethod
+    def create_table(connection, table_name, file_name):
+        result = False
+
+        connection.connect()
+        try:
+            sql = 'SELECT table_name FROM information_schema.tables WHERE table_schema = %s'
+            with connection.cursor() as cursor:
+                cursor.execute(sql, (table_name,))
+                table_exists = cursor.fetchone()
+        except Exception as err:
+             table_exists = False
+
+        if not table_exists:
+            sql_file = open(file_name, 'r')
+            create_table = sql_file.read()
+            sql_file.close()
+
+            try:
+                with connection.cursor() as cursor:
+                    result = cursor.execute(create_table)
+                    print(f"Creating {table_name}...")
+            except Exception as err:
+                result = False
+                print(f"Not created {table_name}...")
+        else:
+            print(f'Table {table_name} already exists')
+        try:
+            connection.close()
+        except Exception as err:
+            pass
+        return result
+
+
+command = None
+sql_file = None
+try:
+    sql_file = sys.argv[1]
+except IndexError as err:
+    logger.error(err)
+    exit('Filename required')
+
+try:
+    logger.info("Load configuration")
+    # reset config and env
+    reset()
+    reset_config()
+    # load integration
+    APP_TYPE = os.environ['APP_TYPE']
+    if APP_TYPE == 'Flask':
+        load_dot_env()
+    else:
+        load_env()
+    config = get_config()
+except IndexError as err:
+    logger.error(err)
+    exit('Filename required')
+
+
+class Command:
+    CREATE_TABLE = 'CREATE_TABLE'
+    INSERT_INTO = 'INSERT_INTO'
+
+
+def get_commnad(line):
+    command = None
+    if "CREATE TABLE" in line:
+        command = Command.CREATE_TABLE
+    if "INSERT INTO" in line:
+        command = Command.INSERT_INTO
+    return command
+
+
+def get_table_name(content, only_table=False):
+    table_name = None
+    rx = re.search("CREATE TABLE (IF NOT EXISTS )?([\w.]+)", content)
+    if not rx:
+        rx = re.search("INSERT INTO ([\w.]+)", content)
+    if rx:
+        groups = rx.groups()
+        if len(groups) > 0:
+            table_name = groups[len(groups)-1]
+
+        if table_name and only_table:
+            table_name_parts = table_name.split('.')
+            table_name = table_name_parts[len(table_name_parts)-1]
+    return table_name
+
+
+try:
+    connection = MySQLHelper.get_connection()
+    with open(ROOT_DIR + sql_file, 'r') as f:
+        content = f.read()
+        f.close()
+
+    command = get_commnad(content)
+    file_name = ROOT_DIR + sql_file
+    if command == Command.CREATE_TABLE:
+        table_name = get_table_name(content)
+        created = MySQLHelper.create_table(connection, table_name, file_name)
+        if created is not False:
+            logger.info("Table created")
+    if command == Command.INSERT_INTO:
+        table_name = get_table_name(content)
+        sow = MySQLHelper.sow_table(connection, table_name, file_name)
+        if sow is not False:
+            logger.info("Table sow")
+
+
+except Exception as err:
+    logger.error(err)
+    exit('File not found')