This repository has been archived on 2026-09-14. You can view files and clone it, but cannot push or open issues or pull requests.
SpideyDetector/modules/main_runner.py

301 lines
9.4 KiB
Python
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import json
import os
import sys
import importlib
import threading
import time
from collections import deque
from modules.internal_io import global_status # , test_status, return_code_dict
"""
All modules that can be tested
Associate the arguments passed to the command line with the modules to be loaded
argparse argument : [module_name, class_name]
"""
_TEST_MODULES = {
"spidey": ["spidey_test", "SpideyTest"],
#"test_walk": ["test_template", "TestWalkTemplate"],
}
PROGRAM_VERSION = "1.0.0"
POST_RUN_ALLOWED = False
queue_lock = threading.Lock()
CLEAR_CODE = r"""
_______ _
(_______) |
_ | | _____ _____ ____
| | | || ___ (____ |/ ___)
| |_____| || ____/ ___ | |
\______)\_)_____)_____|_|
"""
INFECTED_CODE = r"""
_ ___ _
| | / __) _ | |
| |____ _| |__ _____ ____ _| |_ _____ __| |
| | _ (_ __) ___ |/ ___|_ _) ___ |/ _ |
| | | | || | | ____( (___ | |_| ____( (_| |
|_|_| |_||_| |_____)\____) \__)_____)\____|
"""
if os.name == "nt":
CLEAR_CODE = r"" + CLEAR_CODE + r""
INFECTED_CODE = r"" + INFECTED_CODE + r""
class TestRunner:
def __init__(self, args, agnpath):
"""
Main spidey runner
:param args: List of arguments
:type args: argparse.Namespace
:param agnpath: The path to the discord folder
:type agnpath: agnostic_path.AgnosticPath
"""
self.ptb = args.ptb
self.args = args
self.agnostic_path = agnpath
self.os_name = agnpath.os
self.main_path = agnpath.main_path
self.version = agnpath.version
self.is_infected = 0
self.detections = 0
self.test_run = {}
self.loaded_test_modules = {}
self.loaded_test_classes = {}
self.list_of_tests = []
self.update_module_list()
self.finished_tests = deque()
self.exec_all_tests()
def update_module_list(self):
"""
Gets the list of modules to be loaded (in accordance to the config)
:return: List of modules
:rtype: list
"""
modules = {}
classes = {}
module_name = None
try:
for module_name, values in _TEST_MODULES.items():
if self.args.all or self.args.__getattribute__(module_name):
modules[values[0]] = importlib.import_module(f"modules.{values[0]}")
classes[values[0]] = getattr(modules[values[0]], values[1])
except AttributeError as e:
print(f"The module {module_name} was not loaded because it was not specified in the config.")
print(e)
self.loaded_test_modules.update(modules)
self.loaded_test_classes.update(classes)
def exec_all_tests(self):
"""
Executes all the tests, get their result as they finishes
:return: The number of test ran, success, failures, skipped (with ran = success+failures+skip)
:rtype: (int,int,int,int) # TODO: Change this to a nametuple
"""
self.list_of_tests = []
for module_name, test_class in self.loaded_test_classes.items():
print(f"Starting test {module_name}")
tc = test_class(self.args, self.agnostic_path, None, self.finished_tests, queue_lock)
tc = threading.Thread(target=tc.run_test, args=())
tc.name = str(module_name)
tc.daemon = True
self.list_of_tests.append(tc)
tc.start()
# Launch a controller to allow the user to stop all tests
# controller = threading.Thread(target=self.test_launcher)
# Allow the user to stop the tests
tc = threading.Thread(target=self.controller_test, args=())
tc.daemon = True
tc.start()
# Await the end of the tests or the user interruption
tc = threading.Thread(target=self.post_test_runner, args=())
tc.start()
# Wait for the end of the tests
tc = threading.Thread(target=self.test_waiter, args=())
tc.daemon = True
tc.start()
return self.is_infected, self.detections, self.test_run
def controller_test(self):
"""
Kills the tests if the user press enter
"""
print("Press enter to stop the tests: ")
while True:
if input() == "":
if not self.is_infected:
global POST_RUN_ALLOWED
POST_RUN_ALLOWED = True
return
def post_test_runner(self):
"""
Runs the post test runner if all tests are finished
"""
global POST_RUN_ALLOWED
if self.args.launch:
while True:
if POST_RUN_ALLOWED:
print("Running post test runner...")
return 0
time.sleep(0.5)
return 0
def test_waiter(self):
"""
Waits for the end of the tests
:return:
"""
for t in self.list_of_tests: # Can only proceed if all tests are finished
t.join()
# When all tests are finished or the user stopped the tests, we can proceed
if not self.is_infected:
global POST_RUN_ALLOWED
POST_RUN_ALLOWED = True
def get_exit_code(self):
"""
Gets the exit code of the tests
:return: The exit code
:rtype: int
"""
global POST_RUN_ALLOWED
if POST_RUN_ALLOWED:
for t in self.list_of_tests:
if t.is_alive():
return 2 # 2 means that the user stopped the tests before the end
return self.is_infected # The user didn't stop the tests
return -1 # The program is not finished yet
def get_status(self):
"""
Gets the status of the tests
:return: The status
:rtype: str
"""
queue_lock.acquire()
nb_tests = len(self.list_of_tests)
nb_tests_success = 0
nb_tests_failure = 0
nb_tests_skipped = 0
for test in self.finished_tests:
print(f"Test {test.name} finished with status {test.status}")
if test.status == "success":
nb_tests_success += 1
elif test.status == "failure":
nb_tests_failure += 1
elif test.status == "skipped":
nb_tests_skipped += 1
elif test.status == "problem":
nb_tests_failure += 1
queue_lock.release()
nb_tests_ran = nb_tests_success + nb_tests_failure + nb_tests_skipped
nb_test_running = nb_tests - nb_tests_ran
return global_status(
tests_total=nb_tests,
tests_finished=nb_tests_ran,
test_success=nb_tests_success,
tests_failed=nb_tests_failure,
tests_running=nb_test_running,
tests_skipped=nb_tests_skipped,
tests_error=nb_tests_failure
)
def get_test_data(self):
"""
Gets the test data
:return: The test data
:rtype: dict
"""
data = {}
queue_lock.acquire()
for test in self.finished_tests:
for key, value in test.data.items():
if key not in data:
data[key] = value
else:
data[key].update(value)
# data.update(test.data)
queue_lock.release()
return data
def export_data(test_runner, data):
"""
Exports the test data
:param test_runner: The test runner
:type test_runner: TestRunner
:param data: The test data
:type data: dict
"""
main_data = {
"global":
{
"os": test_runner.os_name,
"ptb": test_runner.ptb,
"discord_version": test_runner.version,
"program_version": PROGRAM_VERSION,
},
"tests": data,
}
return main_data
def run_check(args, agnpath):
"""
Runs all operations selected in the config
:param args: List of arguments
:param agnpath: Annostic path to the discord folder
:return: None
"""
tr = TestRunner(args, agnpath) # All operation are executed in parallel and the user can stop them
print("Waiting for the end of the tests")
while tr.get_exit_code() == -1:
print(tr.get_status()) # TODO : Print status in a more readable way
time.sleep(0.5)
print("The test sequence is now finished")
status = tr.get_status()
print(status) # TODO: Print the final status, test still running are actually skipped
if status.tests_failed > 0:
print(INFECTED_CODE)
tr.is_infected = True
else:
print(CLEAR_CODE)
tr.is_infected = False
if args.gen_data:
print("Generating data...")
data = tr.get_test_data()
file_path = os.path.join(os.path.join("databases", args.gen_data[0]))
folder = os.path.dirname(file_path)
if not os.path.exists(folder):
print("Making folder...")
os.makedirs(args.gen_data)
print("Exporting data...") # TODO : Advertize where the data is exported
main_data = export_data(tr, data)
# print(main_data)
with open(file_path, "w") as f:
json.dump(main_data, f, indent=4)
print(f"Exiting in {args.timeout} seconds...")
time.sleep(args.timeout)
sys.exit(tr.get_exit_code())