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)