Time Elapsed
-
+
{fmt(elapsedSeconds) ?? '—'}
@@ -43,8 +61,8 @@ export default function TimeDisplay({ elapsedSeconds, estimatedRemainingSeconds,
{estimatedRemainingSeconds != null ? fmt(estimatedRemainingSeconds) : '—'}
- {days && (
-
{days}
+ {daysLabel && (
+
{daysLabel}
)}
{completionDate && (
diff --git a/server/app.py b/server/app.py
index be1fd88..a360072 100644
--- a/server/app.py
+++ b/server/app.py
@@ -5,7 +5,7 @@ from flask import Flask, Response, jsonify, request, send_from_directory
from flask_cors import CORS
from db_py import count_tests, del_config, get_all_tests, get_config, set_config
-from scanner import full_scan
+from scanner import full_scan, scan_results_only
from sse_py import broadcast, stream_events
from watcher import start_watching
@@ -13,9 +13,13 @@ PORT = int(os.getenv("PORT", "3001"))
ALLOWED_KEYS = {
"target_dir",
"results_dir",
+ "results_dir_ref",
"avg_time_coe",
"avg_time_p2p",
"avg_time_p3p",
+ "smb_username",
+ "smb_password",
+ "smb_domain",
}
BASE_DIR = Path(__file__).resolve().parent
@@ -25,10 +29,25 @@ app = Flask(__name__, static_folder=str(DIST_DIR), static_url_path="")
CORS(app)
+def _apply_smb_env_from_config():
+ mapping = {
+ "SMB_USERNAME": get_config("smb_username"),
+ "SMB_PASSWORD": get_config("smb_password"),
+ "SMB_DOMAIN": get_config("smb_domain"),
+ }
+
+ for env_key, value in mapping.items():
+ if value in (None, ""):
+ os.environ.pop(env_key, None)
+ else:
+ os.environ[env_key] = str(value)
+
+
@app.get("/api/tests")
def get_tests_route():
completed = request.args.get("completed")
interference = request.args.get("interference")
+ throttled = request.args.get("throttled")
device = request.args.get("device")
rotation = request.args.get("rotation")
test_point = request.args.get("testPoint")
@@ -46,6 +65,8 @@ def get_tests_route():
tests = [t for t in tests if t.get("completed") == completed_value]
if interference:
tests = [t for t in tests if t.get("interference") == interference]
+ if throttled:
+ tests = [t for t in tests if t.get("throttled") == throttled]
if device:
tests = [t for t in tests if t.get("device") == device]
if rotation:
@@ -72,6 +93,7 @@ def get_tests_route():
@app.get("/api/stats")
def get_stats_route():
tests = get_all_tests()
+ types = ["COE", "P2P", "P3P"]
total_completed = sum(1 for t in tests if t.get("completed"))
overall = {
@@ -87,10 +109,21 @@ def get_stats_route():
continue
if name not in device_map:
- device_map[name] = {"total": 0, "completed": 0}
+ device_map[name] = {
+ "total": 0,
+ "completed": 0,
+ "byType": {t: {"total": 0, "completed": 0} for t in types},
+ }
device_map[name]["total"] += 1
+
+ interference = test.get("interference")
+ if interference in device_map[name]["byType"]:
+ device_map[name]["byType"][interference]["total"] += 1
+
if test.get("completed"):
device_map[name]["completed"] += 1
+ if interference in device_map[name]["byType"]:
+ device_map[name]["byType"][interference]["completed"] += 1
devices = []
for name in sorted(device_map.keys()):
@@ -101,6 +134,7 @@ def get_stats_route():
"total": stats["total"],
"completed": stats["completed"],
"completionRate": (stats["completed"] / stats["total"]) if stats["total"] else 0,
+ "byType": stats["byType"],
}
)
@@ -110,7 +144,6 @@ def get_stats_route():
if test.get("completed") and duration is not None:
elapsed_seconds += duration
- types = ["COE", "P2P", "P3P"]
by_type = {}
estimate_possible = True
estimated_remaining_seconds = 0
@@ -189,14 +222,16 @@ def set_config_route():
else:
set_config(key, str(value))
- if key in {"target_dir", "results_dir"}:
+ if key in {"target_dir", "results_dir", "results_dir_ref"}:
dirs_changed = True
if dirs_changed:
+ _apply_smb_env_from_config()
target_dir = get_config("target_dir")
results_dir = get_config("results_dir")
+ results_dir_ref = get_config("results_dir_ref")
try:
- full_scan(target_dir, results_dir)
+ full_scan(target_dir, results_dir, results_dir_ref)
start_watching(target_dir, results_dir)
except Exception as exc:
print(f"[config] fullScan error: {exc}")
@@ -208,18 +243,21 @@ def set_config_route():
broadcast({"type": "update"})
return jsonify({"ok": True, "testCount": len(tests), "completedCount": completed})
+ broadcast({"type": "update"})
return jsonify({"ok": True, "testCount": None, "completedCount": None})
@app.post("/api/config/rescan")
def rescan_route():
+ _apply_smb_env_from_config()
target_dir = get_config("target_dir")
results_dir = get_config("results_dir")
+ results_dir_ref = get_config("results_dir_ref")
if not target_dir or not results_dir:
return jsonify({"error": "Directories not configured"}), 400
try:
- full_scan(target_dir, results_dir)
+ full_scan(target_dir, results_dir, results_dir_ref)
start_watching(target_dir, results_dir)
except Exception as exc:
print(f"[config] rescan error: {exc}")
@@ -232,8 +270,37 @@ def rescan_route():
return jsonify({"ok": True, "testCount": len(tests), "completedCount": completed})
+@app.post("/api/config/rescan-results")
+def rescan_results_route():
+ _apply_smb_env_from_config()
+ results_dir = get_config("results_dir")
+ results_dir_ref = get_config("results_dir_ref")
+ if not results_dir:
+ return jsonify({"error": "Results directory not configured"}), 400
+
+ try:
+ scan_results_only(results_dir, results_dir_ref)
+ except Exception as exc:
+ print(f"[config] rescan-results error: {exc}")
+ return jsonify({"error": f"Scan failed: {exc}"}), 500
+
+ tests = get_all_tests()
+ completed = len([t for t in tests if t.get("completed")])
+ print(f"[config] Results rescan complete -> {len(tests)} tests, {completed} completed")
+ broadcast({"type": "update"})
+ return jsonify({"ok": True, "testCount": len(tests), "completedCount": completed})
+
+
@app.get("/api/browse")
def browse_route():
+ def _normalize_request_path(path):
+ if not path:
+ return path
+ p = path.strip()
+ if os.name == "nt":
+ p = p.replace("/", "\\")
+ return p
+
def _configured_roots():
raw = os.getenv("BROWSE_ROOTS", "").strip()
if not raw:
@@ -261,7 +328,7 @@ def browse_route():
return False
roots = _configured_roots()
- req_path = request.args.get("path")
+ req_path = _normalize_request_path(request.args.get("path"))
if not req_path:
if roots:
@@ -329,8 +396,10 @@ def static_or_spa(path=""):
def bootstrap():
+ _apply_smb_env_from_config()
target_dir = get_config("target_dir")
results_dir = get_config("results_dir")
+ results_dir_ref = get_config("results_dir_ref")
if target_dir and results_dir:
existing = count_tests()
@@ -338,7 +407,7 @@ def bootstrap():
print(f"[server] Resuming from DB -> {existing} tests already loaded.")
else:
print("[server] No cached data, scanning directories...")
- full_scan(target_dir, results_dir)
+ full_scan(target_dir, results_dir, results_dir_ref)
tests = get_all_tests()
completed = len([t for t in tests if t.get("completed")])
print(f"[server] Scan complete -> {len(tests)} tests found, {completed} completed")
diff --git a/server/dashboard.db b/server/dashboard.db
index f937ecf..5d734f6 100644
Binary files a/server/dashboard.db and b/server/dashboard.db differ
diff --git a/server/dashboard.db-shm b/server/dashboard.db-shm
index 46874e5..73f4f32 100644
Binary files a/server/dashboard.db-shm and b/server/dashboard.db-shm differ
diff --git a/server/dashboard.db-wal b/server/dashboard.db-wal
index b9000fd..fb2f5c5 100644
Binary files a/server/dashboard.db-wal and b/server/dashboard.db-wal differ
diff --git a/server/db_py.py b/server/db_py.py
index 9f6dbba..dd3abcb 100644
--- a/server/db_py.py
+++ b/server/db_py.py
@@ -64,6 +64,9 @@ def _init_db():
"dl_rssi_dbm REAL",
"ul_rssi_dbm REAL",
"tput_results TEXT",
+ "throttled TEXT",
+ "coe_pair TEXT",
+ "p3p_pair TEXT",
]:
try:
_conn.execute(f"ALTER TABLE tests ADD COLUMN {col_def}")
@@ -96,10 +99,10 @@ def upsert_test(test):
"""
INSERT INTO tests
(id, test_id, parent_dir, filename, interference, device, rotation,
- test_point, station, band, channel, bandwidth, rssi, direction)
+ test_point, station, band, channel, bandwidth, rssi, direction, throttled)
VALUES
(:id, :test_id, :parent_dir, :filename, :interference, :device, :rotation,
- :test_point, :station, :band, :channel, :bandwidth, :rssi, :direction)
+ :test_point, :station, :band, :channel, :bandwidth, :rssi, :direction, :throttled)
ON CONFLICT(id) DO UPDATE SET
test_id = excluded.test_id,
parent_dir = excluded.parent_dir,
@@ -113,7 +116,8 @@ def upsert_test(test):
channel = excluded.channel,
bandwidth = excluded.bandwidth,
rssi = excluded.rssi,
- direction = excluded.direction
+ direction = excluded.direction,
+ throttled = excluded.throttled
""",
test,
)
@@ -136,6 +140,32 @@ def mark_completed(test_id, device, completed_at, duration_seconds, tput_results
)
+def set_coe_pair(test_row_id, coe_pair):
+ json_value = json.dumps(coe_pair or [])
+ with _tx():
+ _conn.execute(
+ """
+ UPDATE tests
+ SET coe_pair = ?
+ WHERE id = ?
+ """,
+ (json_value, test_row_id),
+ )
+
+
+def set_p3p_pair(test_row_id, p3p_pair):
+ json_value = json.dumps(p3p_pair or [])
+ with _tx():
+ _conn.execute(
+ """
+ UPDATE tests
+ SET p3p_pair = ?
+ WHERE id = ?
+ """,
+ (json_value, test_row_id),
+ )
+
+
def get_station_for_test(test_id, device):
with _lock:
row = _conn.execute(
diff --git a/server/parser.py b/server/parser.py
index f243938..76a8b36 100644
--- a/server/parser.py
+++ b/server/parser.py
@@ -11,6 +11,11 @@ def parse_target_filename(filename, parent_dir):
test_identifier = f"{parent_dir}/{base_name}"
interference = segments[0] if segments and segments[0] in INTERFERENCE_TYPES else None
test_id = next((s for s in segments if re.match(r"^R\d+[A-Z0-9]+$", s, re.IGNORECASE)), None)
+ throttled = None
+ if interference == "P3P" and test_id:
+ # P3P test_id carries throttle marker: TH = throttled, otherwise UT.
+ throttled = "TH" if "TH" in test_id.upper() else "UT"
+
device = segments[1] if len(segments) > 1 else None
test_point = next((s for s in segments if re.match(r"^TPT\w+$", s)), None)
rssi = next((s for s in segments if re.match(r"^RSSI\d+$", s)), None)
@@ -39,6 +44,7 @@ def parse_target_filename(filename, parent_dir):
"bandwidth": bandwidth,
"direction": direction,
"rotation": rotation,
+ "throttled": throttled,
}
diff --git a/server/requirements.txt b/server/requirements.txt
index 5227761..3be0ebb 100644
--- a/server/requirements.txt
+++ b/server/requirements.txt
@@ -1,3 +1,4 @@
Flask>=3.0.0,<4.0.0
Flask-Cors>=4.0.1,<5.0.0
watchdog>=4.0.1,<5.0.0
+smbprotocol>=1.13.0,<2.0.0
diff --git a/server/scanner.py b/server/scanner.py
index 8cd16de..65051de 100644
--- a/server/scanner.py
+++ b/server/scanner.py
@@ -1,7 +1,15 @@
import os
import re
+import smbclient
-from db_py import clear_tests, mark_completed, upsert_test
+from db_py import (
+ clear_tests,
+ get_all_tests,
+ mark_completed,
+ set_coe_pair,
+ set_p3p_pair,
+ upsert_test,
+)
from parser import (
parse_elapsed_time,
parse_result_filename,
@@ -11,24 +19,231 @@ from parser import (
)
-def full_scan(target_dir, results_dir):
+_SMB_SESSIONS = set()
+
+
+def _normalize_input_path(path_value):
+ if not path_value:
+ return path_value
+
+ path = str(path_value).strip()
+
+ # Accept //server/share style and normalize to UNC for smbclient.
+ if path.startswith("//"):
+ return "\\\\" + path.lstrip("/").replace("/", "\\")
+
+ # Accept /
//... and normalize to UNC for Linux-hosted inputs.
+ if re.match(r"^/\d{1,3}(?:\.\d{1,3}){3}/[^/]+", path):
+ return "\\\\" + path.lstrip("/").replace("/", "\\")
+
+ return path
+
+
+def _is_unc_path(path):
+ return isinstance(path, str) and path.startswith("\\\\")
+
+
+def _extract_unc_server(path):
+ if not _is_unc_path(path):
+ return None
+ rest = path[2:]
+ return rest.split("\\", 1)[0] if rest else None
+
+
+def _register_smb_session_if_needed(path):
+ if not _is_unc_path(path):
+ return
+
+ server = _extract_unc_server(path)
+ if not server or server in _SMB_SESSIONS:
+ return
+
+ username = os.getenv("SMB_USERNAME", "").strip()
+ password = os.getenv("SMB_PASSWORD", "")
+ domain = os.getenv("SMB_DOMAIN", "").strip()
+
+ if username and domain and "\\" not in username and "@" not in username:
+ username = f"{domain}\\{username}"
+
+ if username:
+ smbclient.register_session(server, username=username, password=password)
+ else:
+ smbclient.register_session(server)
+
+ _SMB_SESSIONS.add(server)
+
+
+def _iter_dir_entries(path):
+ path = _normalize_input_path(path)
+ if _is_unc_path(path):
+ _register_smb_session_if_needed(path)
+ return list(smbclient.scandir(path))
+ return list(os.scandir(path))
+
+
+def _join_path(path, name):
+ if _is_unc_path(path):
+ base = path.rstrip("\\")
+ return f"{base}\\{name}"
+ return os.path.join(path, name)
+
+
+def _read_text_lines(path):
+ path = _normalize_input_path(path)
+ if _is_unc_path(path):
+ _register_smb_session_if_needed(path)
+ with smbclient.open_file(path, mode="r", encoding="utf-8", errors="ignore") as fh:
+ for line in fh:
+ yield line
+ return
+
+ with open(path, "r", encoding="utf-8", errors="ignore") as fh:
+ for line in fh:
+ yield line
+
+
+def scan_results_only(results_dir, results_dir_ref=None):
+ """Re-scan only the results directories without clearing or re-scanning targets."""
+ results_dir = _normalize_input_path(results_dir)
+ results_dir_ref = _normalize_input_path(results_dir_ref)
+
+ if not results_dir:
+ return
+
+ print(f"[scanner] results-only scan dir : {results_dir}")
+ if results_dir_ref:
+ print(f"[scanner] results-only scan dir ref : {results_dir_ref}")
+
+ scan_results(results_dir)
+ if results_dir_ref:
+ scan_results(results_dir_ref)
+ update_p2p_coe_pairs()
+ update_p3p_throttle_pairs()
+
+
+def full_scan(target_dir, results_dir, results_dir_ref=None):
+ target_dir = _normalize_input_path(target_dir)
+ results_dir = _normalize_input_path(results_dir)
+ results_dir_ref = _normalize_input_path(results_dir_ref)
+
clear_tests()
if not target_dir or not results_dir:
return
- print(f"[scanner] target dir : {target_dir}")
- print(f"[scanner] results dir: {results_dir}")
+ print(f"[scanner] target dir : {target_dir}")
+ print(f"[scanner] results dir : {results_dir}")
+ if results_dir_ref:
+ print(f"[scanner] results dir ref : {results_dir_ref}")
scan_targets(target_dir)
scan_results(results_dir)
+ if results_dir_ref:
+ scan_results(results_dir_ref)
+ update_p2p_coe_pairs()
+ update_p3p_throttle_pairs()
+
+
+def update_p2p_coe_pairs():
+ pair_fields = [
+ "device",
+ "rotation",
+ "test_point",
+ "rssi",
+ "station",
+ "band",
+ "channel",
+ "bandwidth",
+ "direction",
+ ]
+
+ tests = get_all_tests()
+ coe_by_key = {}
+
+ for test in tests:
+ if test.get("interference") != "COE":
+ continue
+
+ key = tuple(test.get(field) for field in pair_fields)
+ device = test.get("device")
+ test_id = test.get("test_id")
+ if not device or not test_id:
+ continue
+
+ coe_by_key.setdefault(key, []).append(f"{device}_{test_id}")
+
+ updated = 0
+ for test in tests:
+ if test.get("interference") != "P2P":
+ continue
+
+ key = tuple(test.get(field) for field in pair_fields)
+ pairs = sorted(set(coe_by_key.get(key, [])))
+ set_coe_pair(test.get("id"), pairs)
+ updated += 1
+
+ print(f"[scanner] coe_pair updated for {updated} P2P test(s)")
+
+def update_p3p_throttle_pairs():
+ tests = get_all_tests()
+
+ p3p_lookup = {}
+ for test in tests:
+ if test.get("interference") != "P3P":
+ continue
+
+ device = test.get("device")
+ test_id = test.get("test_id")
+ if not device or not test_id:
+ continue
+
+ p3p_lookup.setdefault(f"{str(device).upper()}_{str(test_id).upper()}", []).append(test)
+
+ def _pair_test_id(test_id, throttled):
+ if not test_id or not throttled:
+ return None
+
+ upper_id = str(test_id).upper()
+ upper_throttled = str(throttled).upper()
+
+ if upper_throttled == "TH":
+ return re.sub("TH", "UT", upper_id, count=1)
+ if upper_throttled == "UT":
+ return re.sub("UT", "TH", upper_id, count=1)
+ return None
+
+ updated = 0
+ for test in tests:
+ if test.get("interference") != "P3P":
+ continue
+
+ device = test.get("device")
+ test_id = test.get("test_id")
+ pair_test_id = _pair_test_id(test_id, test.get("throttled"))
+
+ pairs = []
+ if device and pair_test_id:
+ lookup_key = f"{str(device).upper()}_{str(pair_test_id).upper()}"
+ matches = p3p_lookup.get(lookup_key, [])
+ for match in matches:
+ match_device = match.get("device")
+ match_test_id = match.get("test_id")
+ if match_device and match_test_id:
+ pairs.append(f"{match_device}_{match_test_id}")
+
+ set_p3p_pair(test.get("id"), sorted(set(pairs)))
+ updated += 1
+
+ print(f"[scanner] p3p_pair updated for {updated} P3P test(s)")
def scan_targets(target_dir):
+ target_dir = _normalize_input_path(target_dir)
+
try:
parent_entries = [
- name
- for name in os.listdir(target_dir)
- if os.path.isdir(os.path.join(target_dir, name))
+ entry.name
+ for entry in _iter_dir_entries(target_dir)
+ if entry.is_dir()
]
except OSError as exc:
print(f"[scanner] Cannot read target dir: {exc}")
@@ -37,14 +252,14 @@ def scan_targets(target_dir):
print(f"[scanner] subdirectories found: {len(parent_entries)}")
for parent_name in parent_entries:
- parent_path = os.path.join(target_dir, parent_name)
+ parent_path = _join_path(target_dir, parent_name)
try:
files = [
- name
- for name in os.listdir(parent_path)
- if os.path.isfile(os.path.join(parent_path, name))
- and not name.startswith("GLOBAL")
- and name.endswith(".ini")
+ entry.name
+ for entry in _iter_dir_entries(parent_path)
+ if entry.is_file()
+ and not entry.name.startswith("GLOBAL")
+ and entry.name.endswith(".ini")
]
except OSError as exc:
print(f"[scanner] Cannot read parent dir {parent_name}: {exc}")
@@ -77,16 +292,19 @@ def scan_targets(target_dir):
"bandwidth": parsed["bandwidth"],
"rssi": parsed["rssi"],
"direction": parsed["direction"],
+ "throttled": parsed["throttled"],
}
)
def scan_results(results_dir):
+ results_dir = _normalize_input_path(results_dir)
+
try:
entries = [
- name
- for name in os.listdir(results_dir)
- if os.path.isdir(os.path.join(results_dir, name))
+ entry.name
+ for entry in _iter_dir_entries(results_dir)
+ if entry.is_dir()
]
except OSError as exc:
print(f"[scanner] Cannot read results dir: {exc}")
@@ -98,21 +316,23 @@ def scan_results(results_dir):
def process_result_dir(results_dir, result_dir_name):
+ results_dir = _normalize_input_path(results_dir)
+
parsed = parse_result_filename(result_dir_name)
test_id = parsed["test_id"]
device = parsed["device"]
if not test_id or not device:
return
- result_dir_path = os.path.join(results_dir, result_dir_name)
+ result_dir_path = _join_path(results_dir, result_dir_name)
try:
log_files = [
- name
- for name in os.listdir(result_dir_path)
- if os.path.isfile(os.path.join(result_dir_path, name))
- and name.endswith(".txt")
- and test_id in name
+ entry.name
+ for entry in _iter_dir_entries(result_dir_path)
+ if entry.is_file()
+ and entry.name.endswith(".txt")
+ and test_id in entry.name
]
except OSError as exc:
print(f"[scanner] Cannot read result dir {result_dir_name}: {exc}")
@@ -124,7 +344,7 @@ def process_result_dir(results_dir, result_dir_name):
return
latest_log = sorted(log_files)[-1]
- log_path = os.path.join(result_dir_path, latest_log)
+ log_path = _join_path(result_dir_path, latest_log)
completed_at = parse_timestamp(latest_log)
data = extract_log_data(log_path)
@@ -156,17 +376,16 @@ def extract_log_data(log_file_path):
result = {"duration_seconds": None, "tputResults": []}
try:
- with open(log_file_path, "r", encoding="utf-8", errors="ignore") as fh:
- for line in fh:
- time_match = elapsed_regex.search(line)
- if time_match:
- result["duration_seconds"] = parse_elapsed_time(time_match.group(1))
- continue
+ for line in _read_text_lines(log_file_path):
+ time_match = elapsed_regex.search(line)
+ if time_match:
+ result["duration_seconds"] = parse_elapsed_time(time_match.group(1))
+ continue
- if tput_regex.search(line):
- parsed = parse_tput_rssi(line)
- if parsed:
- result["tputResults"].append(parsed)
+ if tput_regex.search(line):
+ parsed = parse_tput_rssi(line)
+ if parsed:
+ result["tputResults"].append(parsed)
except OSError as exc:
print(f"[scanner] Cannot read log file {log_file_path}: {exc}")