def list_behaviors(self): AppLogging.info("behaviors") behaviors = self.behavior_repository.get_available_behaviors() body = json.dumps(behaviors) tron_response = TronResponse(body) return tron_response
def create_database(cursor): try: cursor.execute( "CREATE DATABASE {} DEFAULT CHARACTER SET 'utf8'".format(DB_NAME)) except mysql.connector.Error as err: AppLogging.error("Failed creating database: {}".format(err)) exit(1)
def validate_config(self): errors = self.validate_json() if errors is not None and len(errors) > 0: config_file_path = self.config_file AppLogging.error('****Configuration file ' + config_file_path + ' is not valid*****') for error in errors: AppLogging.error(' ' + error) raise SystemExit
def setUp(self): AppLogging.init('info') self.http_utils = mock.Mock() self.http_utils.get_demo_http_headers.return_value = {} self.app_config = mock.Mock() self.app_config.get_delay_start_ms.return_value = 0 self.app_config.get_process_start_time.return_value = time.time() self.result = mock.Mock() self.createResponseFunc = (lambda x, y, z: self.result) self.message = MessageHandler(self.app_config, self.http_utils, repository.Repository(["SOMETHING"]), self.createResponseFunc)
def help_message(): AppLogging.info("help") body = ''' API Usage: - GET /api/validateMessage\n - GET /api/inventory\n - GET /api/inventory/<id>\n ''' tron_response = TronResponse(body) return tron_response
def setUp(self): AppLogging.init('info') self.http_utils = mock.Mock() self.http_utils.query_service.return_value = "{}" self.http_utils.get_demo_http_headers.return_value = {} self.app_config = mock.Mock() self.app_config.get_delay_start_ms.return_value = 0 self.app_config.get_process_start_time.return_value = time.time() self.result = mock.Mock() self.createResponseFunc = (lambda x,y,z: self.result) self.datastore = mock.Mock() self.all_inventory = [0,1,2,3,4,5,6,7,8,9] self.datastore.get_records.return_value = self.all_inventory self.inventory = InventoryHandler(self.app_config, self.datastore, self.http_utils, repository.Repository(["SOMETHING"]), self.createResponseFunc)
def validate_json(self): config_file_path = self.config_file s = schema.get_schema() errors = None if config_file_path is not None: with open(config_file_path) as json_file: try: instance = json.load(json_file) except: return ['file is not a JSON file'] v = Draft6Validator(s) validation_errors = sorted(v.iter_errors(instance), key=str) errors = self._parse_errors(validation_errors) return errors else: AppLogging.error('No configuration file defined') raise Exception('No configuration file defined')
def get_inventory(self): BaseHandler(self.app_config).ensure_app_is_started() AppLogging.info("get_inventory") handle_behaviors_pre(self.behavior_repository, self.http_utils.get_demo_http_headers()) data = self.datastore.get_records() tron_response = self.createResponseFunc(data, self.app_config, self.http_utils) urls = self.app_config.get_dependency_endpoint('/api/inventory') if urls is not None: for url in urls: if url is not None: downstream_response = self.http_utils.query_service(url) tron_response.append_trace(self.http_utils, downstream_response) handle_behaviors_post(self.behavior_repository, self.http_utils.get_demo_http_headers()) return tron_response
def inventory_repository_selector(app_config=None): if app_config == None: from dependency_injection_container import Container app_config = Container().app_config() database_options = app_config.get_app_config_value('database') option_values = [ database_options.get(i, '') for i in ['user', 'password', 'host', 'port', 'name'] ] # false if there exists an option with no value, true if all options have values use_database = not ('' in option_values) selection = "database" if use_database else "file" AppLogging.info(f"Using inventory repository type: {selection}") return selection
def validate(self): BaseHandler(self.app_config).ensure_app_is_started() AppLogging.info("validate_message") handle_behaviors_pre(self.behavior_repository, self.http_utils.get_demo_http_headers()) data = {"result": True} tron_response = self.createResponseFunc(data, self.app_config, self.http_utils) urls = self.app_config.get_dependency_endpoint('/api/validateMessage') if urls is not None: for url in urls: if url is not None: downstream_response = self.http_utils.query_service(url) tron_response.append_trace(self.http_utils, downstream_response) handle_behaviors_post(self.behavior_repository, self.http_utils.get_demo_http_headers()) return tron_response
def connect(self, **kwargs): try: if self.__connection == None: # if options are provided, dont use default options connect_options = kwargs if len( kwargs) > 0 else self.__connectin_info.asdict() self.__connection = mysql.connector.connect(**connect_options) return self.__connection except mysql.connector.Error as err: if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: AppLogging.error( "Something is wrong with your user name or password") elif err.errno == errorcode.ER_BAD_DB_ERROR: AppLogging.error("Database does not exist") else: AppLogging.error(err)
def lambda_handler(event, context): AppLogging.init('info') app_config = AppConfig( config_file=os.environ['config_file'] ) config = app_config.asdict() database_connection_info_func = lambda: DatabaseConnectionInfo( user=config['database']['user'], password=config['database']['password'], host=config['database']['host'], port=config['database']['port'], database=config['database']['name'] ) database_connector = MySqlConnector( connection_info=database_connection_info_func() ) database_inventory_repository = DatabaseInventoryRepository( database_connector=database_connector ) file_inventory_repository = FileInventoryRepository() inventory_repositories = { 'file': file_inventory_repository, 'database': database_inventory_repository } inventory_repository = inventory_repositories[inventory_repository_selector(app_config)] http_utils = HttpUtils( func_get_headers=lambda: (event['headers'] or dict()).items() ) def behavior_factory(name, value): if name == "throw": return ThrowException() elif name == "compute": return Compute(value) elif name == "malloc": return Malloc(value) elif name == "invalid_query": return InvalidQuery(database_inventory_repository) else: return None behavior_repository = Repository( app_id=app_config.get_app_id(), behavior_factory_func=behavior_factory ) AppLogging.init('info') if(inventory_repository_selector(app_config) == 'database'): setup_database = SetupDatabaseAction(database_connector, database_connection_info_func(), get_inventory_data()) setup_database.execute() endpoint = (event['resource'] or "").lower() if endpoint == "/": index = IndexHandler(app_config, behavior_repository) resp = index.index_message() elif endpoint == "/validatemessage": message = MessageHandler(app_config, http_utils, behavior_repository) resp = message.validate() elif endpoint == "/help": resp = help_message() elif endpoint == "/inventory": inventory = InventoryHandler(app_config, inventory_repository, http_utils, behavior_repository) resp = inventory.get_inventory() elif endpoint == "/inventory/{id+}": inventory = InventoryHandler(app_config, inventory_repository, http_utils, behavior_repository) item_id = event['pathParameters']['id'] resp = inventory.get_inventory_item(item_id) else: body = "Unsupported endpoint: " + endpoint resp = TronResponse(body, dict(), 404) return get_lambda_reponse(resp)
def handle_exception(e): message = "{}".format(e) AppLogging.error(message) return message, 500
) for k, v in tron_response.get_headers().items(): response.headers[k] = v return response if __name__ == "__main__": container = Container() app_config = container.app_config() container.config.from_dict(app_config.asdict()) container.wire(modules=[sys.modules[__name__]]) arguments = container.arguments() AppLogging.init(arguments.logging_level) if inventory_repository_selector(app_config) == 'database': container.setup_database_action().execute() database_connector = container.database_connector() http_utils = container.http_utils() inventory = container.inventory_handler() message = container.message_handler() behaviors = container.behaviors_handler() index = container.index_handler() debug_mode = arguments.debug_mode if debug_mode is not None and debug_mode == 'On': os.environ["FLASK_ENV"] = "development"
def index_message(self): AppLogging.info("index") body = self.get_message() tron_response = TronResponse(body) return tron_response
def setUp(self): AppLogging.init('info') self.app_config = mock.Mock() self.result = mock.Mock() self.behaviors = BehaviorsHandler(self.app_config, repository.Repository(["SOMETHING"]))
def execute(self): DB_NAME = self.__database_connection_info.database # remove this since we dont know if database exists yet. self.__database_connection_info.database = None cnx = self.__database_connector.connect(**self.__database_connection_info.asdict()) cursor = cnx.cursor() def create_database(cursor): try: cursor.execute( "CREATE DATABASE {} DEFAULT CHARACTER SET 'utf8'".format(DB_NAME)) except mysql.connector.Error as err: AppLogging.error("Failed creating database: {}".format(err)) exit(1) try: cursor.execute("USE {}".format(DB_NAME)) AppLogging.info("Database already exists") except mysql.connector.Error as err: AppLogging.info("Database {} does not exists.".format(DB_NAME)) if err.errno == errorcode.ER_BAD_DB_ERROR: create_database(cursor) AppLogging.info("Database {} created successfully.".format(DB_NAME)) cnx.database = DB_NAME TABLES = {} TABLES['inventory'] = ( "CREATE TABLE `inventory` (" " `id` int(11) NOT NULL AUTO_INCREMENT," " `item` varchar(14) NOT NULL," " `sku` varchar(80) NOT NULL," " `price` varchar(14) NOT NULL," " PRIMARY KEY (`id`)" ") ENGINE=InnoDB") AppLogging.info("Creating inventory table . . .") for table_name in TABLES: table_description = TABLES[table_name] try: AppLogging.info("Creating table {}: ".format(table_name)) cursor.execute(table_description) except mysql.connector.Error as err: if err.errno == errorcode.ER_TABLE_EXISTS_ERROR: AppLogging.error("table already exists.") else: AppLogging.error(err.msg) else: AppLogging.info("OK") AppLogging.info("Inserting inventory data . . .") add_inventory_item = ("INSERT INTO inventory " "(item, price, sku) " "VALUES (%(item)s, %(price)s, %(sku)s)") for item in self.__inventory_data: cursor.execute(add_inventory_item, item) cnx.commit() cursor.close() cnx.close() else: AppLogging.error(err) exit(1)