def auth_request(event, context):
get_logger().info("Event: {}".format(event))
auth_response_dict = AuthenticatorService().request_auth(event)
get_logger().info("auth_response_dict: {}".format(auth_response_dict))
return auth_response_dict
def token_auth(self, event):
auth_type = 'TOKEN'
api_key = None
method_arn = ''
principal_id = 'user'
api_gateway_arn_tmp = ''
if 'type' in event:
auth_type = event['type']
if 'methodArn' in event:
method_arn = event['methodArn']
tmp = event['methodArn'].split(':')
api_gateway_arn_tmp = tmp[5].split('/')
if 'authorizationToken' in event:
api_key = event['authorizationToken']
get_logger().info("Event: {}".format(event))
auth_request = AuthRequest(auth_type=auth_type,
token=api_key,
method_arn=method_arn)
is_api_key_valid = self.validate_api_key(api_key)
access_allowed = is_api_key_valid
if access_allowed:
verb = api_gateway_arn_tmp[2] if len(
api_gateway_arn_tmp) > 2 else '*'
resource = api_gateway_arn_tmp[3] if len(
api_gateway_arn_tmp) > 3 else '*'
auth_response = AuthResponse(
routes=[AuthRoute("/" + resource, [verb])],
principal_id=principal_id)
else:
auth_response = AuthResponse(routes=[], principal_id=principal_id)
auth_response_dict = auth_response.to_dict(auth_request)
# deny resources
if not access_allowed:
self.deny_resources(auth_response_dict)
# new! -- add additional key-value pairs associated with the authenticated principal
# these are made available by APIGW like so: $context.authorizer.<key>
# additional context is cached
auth_response_dict['context'] = {
'key': api_key # $context.authorizer.key -> value
}
return auth_response_dict
def convert_to_int(str_value):
"""
Essa função foi criada para ser usada em loops funcionais z = [x for x in y]
:param str_value:
:return:
:rtype: int
"""
value = 0
try:
value = int(str_value)
except Exception as err:
get_logger().error(err)
return value
def setUpClass(cls):
cls.CONFIG = get_config()
cls.CONFIG.SQS_ENDPOINT = cls.SQS_LOCALSTACK
# fixture
if cls.EXECUTE_FIXTURE:
logger = get_logger()
queue_url = cls.CONFIG.APP_QUEUE
queue_name = SQSHelper.get_queue_name(queue_url)
deleted = SQSHelper.delete_queue(queue_url)
if deleted:
logger.info(f'Deleting queue name: {queue_name}')
attributes = {'DelaySeconds': '1'}
result = SQSHelper.create_queue(queue_url, attributes)
if result is not None:
logger.info(f'queue {queue_name} created')
else:
logger.error(f'queue {queue_name} not created')
event = get_sqs_event_sample()[0]
SQSHelper.create_message(event)
json_list = get_json_sqs_event_exemplo()[0]
for json_exemplo in json_list:
SQSHelper.create_message(json.loads(json_exemplo))
logger.info('created message: {}'.format(event))
def __init__(self, logger=None, config=None):
# logger
self.logger = logger if logger is not None else get_logger()
# configurations
self.config = config if config is not None else get_config()
# last_exception
self.exception = None
def __init__(self, logger=None, config=None, connection=None):
# logger
self.logger = logger if logger is not None else get_logger()
# configurations
self.config = config if config is not None else get_config()
# database connection
if self.NOSQL:
self.connection = connection if connection is not None else nosql_get_connection(
)
if self.DEBUG:
self._repository = self.NOSQL_REPOSITORY(
self.connection, self.config.DYNAMODB_TABLE_NAME, logger)
else:
self._repository = self.NOSQL_REPOSITORY(
self.connection, self.config.DYNAMODB_TABLE_NAME)
else:
self.connection = connection if connection is not None else get_connection(
)
if self.DEBUG:
self._repository = self.REPOSITORY(self.connection,
self.TABLE_NAME, logger)
else:
self._repository = self.REPOSITORY(self.connection,
self.TABLE_NAME)
def __init__(self, logger=None, redis_connection=None):
# logger
self.logger = logger if logger is not None else get_logger()
# database connection
self.redis_connection = redis_connection if redis_connection is not None else get_connection(
)
self.total = 0
self.where = None
def __init__(self, logger=None):
# logger
self.logger = logger if logger is not None else get_logger()
self.method = None
self.url = None
self.body = None
self.headers = {}
self.accepted_codes = (200, )
def __init__(self, logger=None):
"""
# This cant import get_config
:param logger:
"""
# logger
self.logger = logger if logger is not None else get_logger()
# last_exception
self.exception = None
def get_internal_logger():
try:
from chalicelib.logging import get_logger
logger = get_logger()
except Exception as err:
print('load_env: Unable to load logger: {}'.format(err))
import logging
log_name = APP_NAME
logger = logging.getLogger(log_name)
return logger
def get_doc(fn):
logger = get_logger()
doc_yml = ''
try:
fn_doc = fn.__doc__
fn_doc = fn_doc.split('---')[-1]
doc_yml = yaml.safe_load(fn_doc)
except Exception as err:
logger.error(err)
return doc_yml
def load_env(env='dev', force=False):
global _LOADED
if not _LOADED or force:
try:
from chalicelib.logging import get_logger
get_logger().info('Test - Loading env: {}'.format(env))
except:
print('load_env: Unable to load logger')
chalice_config_path = current_path + '.chalice/config.json'
if os.path.isfile(chalice_config_path):
file = open(chalice_config_path, 'r')
data = file.read()
configs = json.loads(data)
env_vars = configs['stages'][env]['environment_variables']
for k, v in env_vars.items():
os.environ[k] = v
else:
exit('unable to load config')
_LOADED = True
else:
pass
def setUpClass(cls):
cls.CONFIG = get_config()
cls.CONFIG.SQS_ENDPOINT = cls.SQS_LOCALSTACK
# fixture
if cls.EXECUTE_FIXTURE:
logger = get_logger()
queue_url = cls.CONFIG.APP_QUEUE
queue_name = SQSHelper.get_queue_name(queue_url)
deleted = SQSHelper.delete_queue(queue_url)
if deleted:
logger.info(f'Deleting queue name: {queue_name}')
result = SQSHelper.create_queue(queue_url)
if result is not None:
logger.info(f'queue {queue_name} created')
else:
logger.error(f'queue {queue_name} not created')
def __init__(self, logger=None, config=None, connection=None):
# logger
self.logger = logger if logger is not None else get_logger()
# configurations
self.config = config if config is not None else get_config()
# database connection
self.connection = connection if connection is not None else get_connection(
)
if self.DEBUG:
self._repository = self.REPOSITORY(self.connection,
self.config.DYNAMODB_TABLE_NAME,
logger)
else:
self._repository = self.REPOSITORY(self.connection,
self.config.DYNAMODB_TABLE_NAME)
self.data_list = []
self.updates = []
self.queue = Queue()
self.responses = []
def setUpClass(cls):
cls.CONFIG = get_config()
# fixture
if cls.EXECUTE_FIXTURE:
logger = get_logger()
table_name = get_config().DYNAMODB_TABLE_NAME
DynamoDBHelper.drop_table(connection=get_connection(), table_name=table_name)
logger.info(f'table {table_name}')
file_name = ROOT_DIR + '/tests/datasets/nosql/create.table.standard-update-checker-dynamodb-StandardUpdatesTable.json'
DynamoDBHelper.create_table(connection=get_connection(),
table_name=table_name,
file_name=file_name)
logger.info(f'table {table_name} created')
file_name = ROOT_DIR + '/tests/datasets/seeders/seeder.standard-update-checker-dynamodb-StandardUpdatesTable.json'
DynamoDBHelper.sow_table(connection=get_connection(), table_name=table_name,
file_name=file_name)
logger.info(f'table {table_name} populated')
def __init__(self, logger=None):
# logger
self.logger = logger if logger is not None else get_logger()
from chalicelib.exceptions import ApiException
from chalicelib.http_resources.request import ApiRequest
from chalicelib.http_resources.response import ApiResponse
from chalicelib.services.v1.update_checker_service import UpdateCheckerService
from chalicelib.config import get_config
from chalicelib.logging import get_logger, get_log_level
from chalicelib import APP_NAME, helper, http_helper, APP_VERSION
from chalice import Chalice
# config
config = get_config()
# debug
debug = helper.debug_mode()
# logger
logger = get_logger()
# chalice app
app = Chalice(app_name=APP_NAME, debug=debug)
# override the log configs
if not debug:
# override to the level desired
logger.level = get_log_level()
# override the log instance
app.log = logger
@app.route('/', cors=True)
def index():
body = {"app": '%s:%s' % (APP_NAME, APP_VERSION)}
return http_helper.create_response(body=body, status_code=200)
