def get(self): try: workers = K8sManager().get_worker_pods() except AssertionError as e: return api_error(message="Unable to get worker pods", errors=str(e), status_code=400) sync = Synchronizer() failed_workers = sync.management_update_workers(workers) if failed_workers is not None: errors = [] for failed_worker in failed_workers: errors.append( f"{failed_worker.name} - {failed_worker.ip}:{failed_worker.port}" ) return api_error(message="Some or all workers are unreachable.", errors=errors, status_code=400) return make_response( jsonify({ "message": "New hyperscan DB are updated on the workers", "status": "done" }), 200)
def get(self): db_session = DatabaseManager().get_session() sync = Synchronizer() # Check if sqlite DB is empty. redirect_rule_table_row_count = db_get_table_row_count( db_session, RedirectRule) DatabaseManager().return_session(db_session) if redirect_rule_table_row_count == 0: return api_error( message="Unable to compile new Hyperscan database", errors= f"Can't compile new Hyperscan database from no Redirect rules stored in the SQL database", status_code=400) compiler = CompilerJob(sync.util_new_hs_db_version_callback_test) compile_thread = Thread(target=compiler.run) compile_thread.start() # Metrics metric_update_rules_total() return make_response( jsonify({ "message": "New hyperscan DB are compiled for testing", "status": "done" }), 200)
def page_404(): from redirectory.libs_int.service import api_error return api_error( message="404 Page Not Found", errors="Hmm, the thing you are looking for is not here!", status_code=404)
def post(self): args = request.get_json() db_session = DatabaseManager().get_session() redirect_rule_instance = add_redirect_rule(db_session, **args) if isinstance(redirect_rule_instance, int): DatabaseManager().return_session(db_session) return api_error( message="Unable to add redirect rule", errors="A rule like this already exists" if redirect_rule_instance == 2 else "Invalid rule with rewrite! Check your path and destination fields.", status_code=400 ) if isinstance(redirect_rule_instance, RedirectRule): redirect_rule_data = db_encode_model(redirect_rule_instance, expand=True) DatabaseManager().return_session(db_session) # Metrics metric_update_rules_total() return make_response(jsonify({ "new_rule": redirect_rule_data, "status": "done" }), 200)
def post(self): args = request.get_json() db_session = DatabaseManager().get_session() updated_redirect_rule = update_redirect_rule(db_session, **args) if isinstance(updated_redirect_rule, int): DatabaseManager().return_session(db_session) metric_update_rules_total() # Metrics return api_error( message="Unable to update redirect rule", errors= f"Redirect rule with id: {args['redirect_rule_id']} does not exist" if updated_redirect_rule == 2 else "The update rules fails the validation for rewrite! Check your path and destination fields.", status_code=400) if updated_redirect_rule: serialized_updated_redirect_rule = db_encode_model( updated_redirect_rule, expand=True) DatabaseManager().return_session(db_session) metric_update_rules_total() # Metrics return make_response( jsonify({ "updated_rule": serialized_updated_redirect_rule, "status": "done" }), 200)
def get(self): hs_db_version = HsManager().database.db_version if hs_db_version: return make_response(jsonify({"hs_db_version": hs_db_version})) else: return api_error(message="Worker has no Hyperscan Database loaded", errors=[], status_code=400)
def post(self): url = request.get_json()["request_url"] host, path = self.parse_url(url) # Init managers and sessions hs_manager = HsManager() db_session = DatabaseManager().get_session() # Search try: start_search_time = time() search_data = hs_manager.search(domain=host, path=path, is_test=True) end_search_time = time() except AssertionError as e: Logger() \ .event(category="hyperscan", action="hyperscan search") \ .error(message=str(e)) \ .out(severity=Severity.ERROR) DatabaseManager().return_session(db_session) return api_error( message="Something went wrong during Hyperscan search!", errors=str(e), status_code=400) # Convert ids into models domain_rules_data = {} redirect_rules_data = {} d_r_map = search_data["domain_rule_map"] for domain_id in d_r_map.keys(): domain_rule = get_model_by_id(db_session, DomainRule, domain_id) domain_rules_data[domain_id] = db_encode_model(domain_rule) for rule_id in d_r_map[domain_id]: redirect_rule = get_model_by_id(db_session, RedirectRule, rule_id) redirect_rules_data[rule_id] = db_encode_model(redirect_rule, expand=True) # Get final result final_redirect_rule, is_ambiguous = HsManager.pick_result( db_session, list(redirect_rules_data.keys())) # Fill in test data search_data[ "final_result_id"] = final_redirect_rule.id if final_redirect_rule is not None else None search_data["is_ambiguous"] = is_ambiguous search_data["time"] = str(end_search_time - start_search_time) DatabaseManager().return_session(db_session) return make_response( jsonify({ "domain_rules": domain_rules_data, "redirect_rules": redirect_rules_data, "search_data": search_data }), 200)
def get(self): config = Configuration().values is_management = config.node_type == "management" if HsManager().database.is_loaded or is_management: return make_response(jsonify({"status": "ready"}), 200) else: return api_error(message="Not Ready", errors="Hyperscan database not loaded yet!", status_code=400)
def post(self): args = request.get_json() name = args["name"] ip = args["ip"] port = args["port"] worker_pod = WorkerPod(name=name, ip=ip, port=port) if not worker_pod.get_status_health(): message = "Unable to update worker pod." error = f"Pod with name: {worker_pod.name} and address: {worker_pod.ip}:{worker_pod.port} " \ "is unreachable" Logger() \ .event(category="request", action="request failed", dataset=message) \ .error(message=error) \ .out(severity=Severity.ERROR) return api_error(message=message, errors=error, status_code=400) sync = Synchronizer() did_sync_start = sync.management_update_worker(worker_pod) if not did_sync_start: message = "Unable to update worker pod" error = f"Pod with name: {worker_pod.name} and address: {worker_pod.ip}:{worker_pod.port} " \ f"is reachable but did not respond correctly to sync worker request" Logger() \ .event(category="synchronizer", action="synchronizer request failed", dataset=message) \ .error(message=error) \ .out(severity=Severity.ERROR) return api_error(message=message, errors=error, status_code=400) return make_response( jsonify({ "message": f"New hyperscan DB is updated on the specified worker with address: {worker_pod.ip}:{worker_pod.port}", "status": "done" }), 200)
def get(self, path=None): if path is None: path = "index.html" ui_directory = Configuration().values.directories.ui does_file_exist = os.path.isfile(os.path.join(ui_directory, path)) if does_file_exist: return send_from_directory(ui_directory, path) else: return api_error(message="Something went wrong!", errors="File not found", status_code=404)
def get(self): try: management_pod = K8sManager().get_management_pod() except AssertionError as e: return api_error(message="Unable to get management pod", errors=str(e), status_code=400) return make_response( jsonify({ "management": management_pod.get_data(), "status": "done" }), 200)
def post(self): # Gather arguments args = request.get_json() page_number = args["page_number"] page_size = args["page_size"] # Get DB session db_session = DatabaseManager().get_session() start_process_time = time() # Generate query for pages query = db_session.query(RedirectRule) # Apply filters to query if needed if "filter" in args: query = self.apply_filters(query, args["filter"]) # Get the page page: Page = paginate(query, page_number, page_size) # Check if page exists if not page.items: # Release the DB session and return an api error DatabaseManager().return_session(db_session) return api_error( message="Unable to get specified page", errors=f"Page with number: {page_number} does not exist", status_code=404) # Get the data in json data = [] for redirect_rule in page.items: data.append(db_encode_model(redirect_rule, expand=True)) end_process_time = time() # Return DB session and return response DatabaseManager().return_session(db_session) # Metrics metric_update_rules_total() return make_response( jsonify({ "data": data, "page": { "total_items": page.total, "total_pages": page.pages, "has_previous": page.has_previous, "has_next": page.has_next }, "time": str(end_process_time - start_process_time) }), 200)
def get(self): db_session = DatabaseManager().get_session() data = list_ambiguous_requests(db_session) DatabaseManager().return_session(db_session) if len(data) > 0: return make_response( jsonify({ "ambiguous_requests": data, "status": "done" }), 200) else: return api_error(message="Unable to get ambiguous request entries", errors="No ambiguous entries in the SQL db", status_code=404)
def get(self): try: workers = K8sManager().get_worker_pods() except AssertionError as e: return api_error(message="Unable to get worker pods", errors=str(e), status_code=400) workers_data = [] for worker in workers: workers_data.append(worker.get_data()) return make_response( jsonify({ "workers": workers_data, "status": "done" }), 200)
def post(self): rule_id = request.get_json()["rule_id"] db_session = DatabaseManager().get_session() redirect_instance = get_model_by_id(db_session, RedirectRule, rule_id) if redirect_instance: redirect_rule_data = db_encode_model(redirect_instance, expand=True) DatabaseManager().return_session(db_session) return make_response( jsonify({ "rule": redirect_rule_data, "status": "done" }), 200) else: DatabaseManager().return_session(db_session) return api_error(message="Unable to get redirect rule", errors=f"Redirect rule with id: {rule_id} do", status_code=404)
def get(self): sync = Synchronizer() try: zip_sync_file = sync.util_get_sync_files_as_zip() except FileNotFoundError as e: Logger() \ .event(category="sync", action="sync download failed", dataset="File not found while compressing into zip") \ .error(message=str(e)) \ .out(severity=Severity.ERROR) return api_error( message="Unable to gather needed files", errors="Some file/s needed for syncing is/are not available. " "If the error persist contact the administrator", status_code=400) return send_file(zip_sync_file, mimetype='zip', attachment_filename="sync.zip", as_attachment=True)
def post(self): new_request_url = request.get_json()["request"] db_session = DatabaseManager().get_session() # Delete the ambiguous entry and get bool if successful new_entry = add_ambiguous_request(db_session, new_request_url) # Release session DatabaseManager().return_session(db_session) if new_entry is not None: return make_response( jsonify({ "new_ambiguous_request": db_encode_model(new_entry), "status": "done" }), 200) else: return api_error( message="Unable to add new ambiguous request entry", errors=f"Ambiguous request like this already exist", status_code=400)
def post(self): args = file_upload_args.parse_args() csv_byte_file_in: FileStorage = args["csv_file"] try: csv_importer = CSVImporter(csv_byte_file_in) except AssertionError as e: return api_error( message="Failed file processing", errors=str(e), status_code=400 ) import_thread = threading.Thread(target=csv_importer.import_into_db) import_thread.start() # Metrics metric_update_rules_total() return make_response(jsonify({ "status": "Import has been started. Rules will appear in DB when the import is complete." }), 200)
def post(self): rule_id = request.get_json()["rule_id"] db_session = DatabaseManager().get_session() # Delete the rule and get bool if successful is_deleted = delete_redirect_rule(db_session, rule_id) # Release session DatabaseManager().return_session(db_session) # Metrics metric_update_rules_total() if is_deleted: return make_response(jsonify({ "status": "done" }), 200) else: return api_error( message="Unable to delete redirect rule", errors=f"Redirect rule with id: {rule_id} does not exist", status_code=404 )