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
)
