src/check.py

import common
import sqlite3
import os
import sys
import shutil
import re
import time
from rich import print
from rich.progress import Progress



# Collect paths of runs
def collect_runs():
    runs = set()
    api_dirs = os.scandir(f'{common.RESTGYM_BASE_DIR}/results')
    for api_dir in api_dirs:
        if api_dir.is_dir():
            tool_dirs = os.scandir(api_dir)
            for tool_dir in tool_dirs:
                if tool_dir.is_dir():
                    run_dirs = os.scandir(tool_dir)
                    for run_dir in run_dirs:
                        if run_dir.name != '.DS_Store':
                            runs.add(run_dir.path)
    return runs


# Read time budget from file
def parse_time_budget(file_path):
    with open(file_path, 'r') as f:
        content = f.read()

    # Match "Time budget: X minutes." where X is integer
    match = re.search(r'Time budget:\s*(\d+)', content)

    if match:
        minutes = int(match.group(1))
        if minutes > 0:
            return minutes
    return 60


# Count code coverage samples
def count_coverage_samples(run):
    files = os.listdir(f"{run}{common.CODE_COVERAGE_PATH}")
    exec_count = 0
    csv_count = 0
    for file in files:
        if file.endswith('.exec'):
            exec_count += 1
        elif file.endswith('.csv'):
            csv_count += 1
    return exec_count, csv_count


# Verify SQLite database integrity
def verify_database_integrity(run):
    conn = sqlite3.connect(f'{run}/{common.DB_FILENAME}')
    cursor = conn.cursor()
    cursor.execute("PRAGMA integrity_check;")
    result = cursor.fetchone()
    conn.close()
    if result[0] == "ok":
        return True
    else:
        return False


# Perform integrity analysis
def analyze():

    runs = collect_runs()
    print(f"Analyzing {len(runs)} runs.")

    analyzed = {}

    # Progress bar
    with Progress() as progress:

        verify_task = progress.add_task("Verifying run data...", total=len(runs)+1)
        progress.update(verify_task, advance=1)

        for run in runs:

            warnings = []
            errors = []

            # Get time budget for the run
            time_budget = parse_time_budget(f'{run}/time-budget.txt')

            # Verify started.txt exists
            if not os.path.exists(f'{run}/started.txt'):
                errors.append("The run did not start.")

            # Verify completed.txt exists
            if not os.path.exists(f'{run}/completed.txt'):
                errors.append("The run did not complete.")

            # Verify database exists
            if not os.path.exists(f'{run}/{common.DB_FILENAME}'):
                errors.append("The result database does not exist.")
            else:

                # Verify database integrity
                if not verify_database_integrity(run):
                    warnings.append("The database integrity check failed.")

                # Connect to the database
                conn = sqlite3.connect(f"{run}/{common.DB_FILENAME}")
                cursor = conn.cursor()

                # Verify the interaction table is the database
                if int(cursor.execute("SELECT COUNT(1) FROM sqlite_master WHERE type='table' AND name = 'interactions'").fetchone()[0]) == 0:
                    errors.append("The interaction table does not exist in the database.")
                else:

                    # Count interactions
                    interaction_count = int(cursor.execute('SELECT COUNT(1) FROM interactions').fetchone()[0])

                    # Check if any request was recoded
                    if interaction_count == 0:
                        errors.append("No requests recorded in the database.")
                    else:

                        # Verify at least 100 requests per minute (in average) have been sent
                        if interaction_count < 100 * time_budget:
                            warnings.append(f"Less than 100 requests per minute have been recorded: {interaction_count} requests in {time_budget} minutes.")

                        # Verify requests time span is at least 80% of the time budget
                        interaction_time_span = int(int(cursor.execute('SELECT MAX(request_timestamp) - MIN(request_timestamp) FROM interactions').fetchone()[0]) / 60)
                        if interaction_time_span < int(0.8 * time_budget):
                            warnings.append(f"Requests time span is of {interaction_time_span}/{time_budget} minutes.")

            # Verify code coverage dir exists
            if not os.path.exists(f"{run}{common.CODE_COVERAGE_PATH}"):
                errors.append("Code coverage directory does not exist.")
            else:

                # Verify all code coverage samples exist
                exec_count, csv_count = count_coverage_samples(run)
                if exec_count < 12 * time_budget:
                    errors.append("Missing code coverage EXEC samples.")
                if csv_count < 12 * time_budget:
                    errors.append("Missing code coverage CSV samples.")

            # Add result to returned dictionary
            analyzed[run] = {
                'errors': errors,
                'warnings': warnings
            }

            # Print if something is wrong
            if len(errors) + len(warnings) > 0:
                message = f" => Run {'/'.join(os.path.normpath(run).split(os.sep)[-3:])} => "
                if len(errors) > 0:
                    message += f"[red]ERRORS: {errors}[/red] "
                if len(warnings) > 0:
                    message += f"[yellow]WARNINGS: {warnings}[/yellow]"
                print(message)

            # If no errors, create verified.txt file no error have been encountered
            if len(errors) == 0:
                content = f"This run was verified at {time.ctime()}.\n"

                if len(warnings) > 0:
                    content += f"The verification passed with WARNINGS.\n\nWarnings: {warnings}\n"
                else:
                    content += "The verification PASSED!\n"

                with open(f'{run}/verified.txt', 'a') as f:
                    f.write(content)

            progress.update(verify_task, advance=1)

    return analyzed

# Removes runs with problems
def clean(runs):

    count = len(runs)

    for run in runs:
        shutil.rmtree(run, ignore_errors=True)
    print(f"Removed {count} runs.")

if __name__ == '__main__':
    common.welcome()
    print("This is the verify data module. It will check the integrity of experimental data of run.")
    input("Press ENTER to start or CTRL+C to cancel...")

    analyzed = analyze()

    with_errors = []
    with_warnings = []

    for run in analyzed:
        if len(analyzed[run]['errors']) > 0:
            with_errors.append(run)
        elif len(analyzed[run]['warnings']) > 0:
            with_warnings.append(run)

    if len(with_errors) + len(with_warnings) == 0:
        print(f"All {len(analyzed)} runs passed the verification.")

    else:
        to_delete = []

        print(f"Analyzed: {len(analyzed)}. [red]With errors: {len(with_errors)}.[/red] [yellow]With warnings: {len(with_warnings)}.[/yellow]")

        if input(f"Do you want to delete runs with ERRORS? (yes/no): ").strip().lower() == "yes":
            to_delete += with_errors
        if input(f"Do you want to delete runs with WARNINGS? (yes/no): ").strip().lower() == "yes":
            to_delete += with_warnings

        if len(to_delete) == 0:
            print("Nothing to delete.")
        else:
            clean(to_delete)