271 lines
10 KiB
Python
271 lines
10 KiB
Python
import os
|
|
import threading
|
|
|
|
from watchdog.events import FileSystemEventHandler
|
|
from watchdog.observers import Observer
|
|
|
|
from db_py import reset_by_file_id_and_device
|
|
from scanner import (
|
|
full_scan,
|
|
parse_deleted_result_dir_name,
|
|
process_result_dir,
|
|
_is_unc_path,
|
|
_normalize_input_path,
|
|
)
|
|
from sse_py import broadcast
|
|
|
|
_target_observer = None
|
|
_results_observers = []
|
|
_scan_timer = None
|
|
_scan_lock = threading.Lock()
|
|
|
|
|
|
def _path_exists(path):
|
|
"""Check if path exists, handling UNC paths."""
|
|
if _is_unc_path(path):
|
|
try:
|
|
import smbclient
|
|
return smbclient.path.isdir(path)
|
|
except Exception:
|
|
return False
|
|
return os.path.isdir(path)
|
|
|
|
|
|
def _normalize_watcher_path(path):
|
|
"""Normalize path for watcher comparison, handling UNC paths."""
|
|
normalized = _normalize_input_path(path)
|
|
if not _is_unc_path(normalized):
|
|
normalized = os.path.normcase(os.path.abspath(normalized))
|
|
return normalized
|
|
|
|
|
|
def _schedule_full_scan(target_dir, results_dir, delay_seconds=1.0):
|
|
global _scan_timer
|
|
with _scan_lock:
|
|
if _scan_timer:
|
|
_scan_timer.cancel()
|
|
|
|
def run_scan():
|
|
try:
|
|
full_scan(target_dir, results_dir)
|
|
broadcast({"type": "update"})
|
|
except Exception as exc:
|
|
print(f"[watcher] fullScan error: {exc}")
|
|
|
|
_scan_timer = threading.Timer(delay_seconds, run_scan)
|
|
_scan_timer.daemon = True
|
|
_scan_timer.start()
|
|
|
|
|
|
class _TargetHandler(FileSystemEventHandler):
|
|
def __init__(self, target_dir, results_dir):
|
|
self.target_dir = os.path.normcase(os.path.abspath(target_dir))
|
|
self.results_dir = results_dir
|
|
|
|
def _is_target_test_file(self, path):
|
|
normalized = os.path.normcase(os.path.abspath(path))
|
|
relative = os.path.relpath(normalized, self.target_dir)
|
|
parts = relative.split(os.sep)
|
|
if len(parts) != 2:
|
|
return False
|
|
|
|
filename = parts[-1]
|
|
return filename.endswith(".ini") and not filename.startswith("GLOBAL")
|
|
|
|
def on_created(self, event):
|
|
if not event.is_directory and self._is_target_test_file(event.src_path):
|
|
_schedule_full_scan(self.target_dir, self.results_dir)
|
|
|
|
def on_deleted(self, event):
|
|
if not event.is_directory and self._is_target_test_file(event.src_path):
|
|
_schedule_full_scan(self.target_dir, self.results_dir)
|
|
|
|
def on_moved(self, event):
|
|
if event.is_directory:
|
|
return
|
|
|
|
# On Windows, create/delete in Explorer can show up as move/rename events.
|
|
if self._is_target_test_file(event.src_path) or self._is_target_test_file(event.dest_path):
|
|
_schedule_full_scan(self.target_dir, self.results_dir)
|
|
|
|
|
|
class _ResultsHandler(FileSystemEventHandler):
|
|
def __init__(self, results_dir):
|
|
self.results_dir = _normalize_watcher_path(results_dir)
|
|
|
|
def _is_direct_child_dir(self, path):
|
|
try:
|
|
if _is_unc_path(path):
|
|
parent = _normalize_watcher_path(os.path.dirname(path))
|
|
else:
|
|
parent = os.path.normcase(os.path.abspath(os.path.dirname(path)))
|
|
return parent == self.results_dir
|
|
except Exception:
|
|
return False
|
|
|
|
def _is_file_under_result_child(self, path):
|
|
try:
|
|
if _is_unc_path(path):
|
|
parent_dir = _normalize_watcher_path(os.path.dirname(path))
|
|
grandparent = _normalize_watcher_path(os.path.dirname(parent_dir))
|
|
else:
|
|
parent_dir = os.path.normcase(os.path.abspath(os.path.dirname(path)))
|
|
grandparent = os.path.normcase(os.path.abspath(os.path.dirname(parent_dir)))
|
|
return grandparent == self.results_dir
|
|
except Exception:
|
|
return False
|
|
|
|
def _result_child_name_for_file(self, path):
|
|
return os.path.basename(os.path.dirname(path))
|
|
|
|
def _result_child_name_for_dir(self, path):
|
|
return os.path.basename(path)
|
|
|
|
def on_created(self, event):
|
|
# On Windows, is_directory may be False even for directories (timing issue),
|
|
# so check _is_direct_child_dir regardless of the flag.
|
|
if self._is_direct_child_dir(event.src_path):
|
|
dir_name = self._result_child_name_for_dir(event.src_path)
|
|
process_result_dir(self.results_dir, dir_name)
|
|
broadcast({"type": "update"})
|
|
return
|
|
|
|
if self._is_file_under_result_child(event.src_path):
|
|
dir_name = self._result_child_name_for_file(event.src_path)
|
|
process_result_dir(self.results_dir, dir_name)
|
|
broadcast({"type": "update"})
|
|
|
|
def on_deleted(self, event):
|
|
# On Windows, when a directory is deleted watchdog may report is_directory=False
|
|
# because os.path.isdir() returns False by the time the event is processed.
|
|
# Check _is_direct_child_dir first regardless of the is_directory flag.
|
|
if self._is_direct_child_dir(event.src_path):
|
|
dir_name = self._result_child_name_for_dir(event.src_path)
|
|
test_id, device = parse_deleted_result_dir_name(dir_name)
|
|
if test_id:
|
|
reset_by_file_id_and_device(test_id, device)
|
|
broadcast({"type": "update"})
|
|
return
|
|
|
|
if self._is_file_under_result_child(event.src_path):
|
|
dir_name = self._result_child_name_for_file(event.src_path)
|
|
process_result_dir(self.results_dir, dir_name)
|
|
broadcast({"type": "update"})
|
|
|
|
def on_moved(self, event):
|
|
src_in_root = self._is_direct_child_dir(event.src_path)
|
|
dst_in_root = self._is_direct_child_dir(event.dest_path)
|
|
|
|
# Handle directory-level moves regardless of is_directory flag (Windows timing issue).
|
|
if src_in_root or dst_in_root:
|
|
# Result directory moved out (includes Recycle Bin delete on Windows).
|
|
if src_in_root and not dst_in_root:
|
|
old_name = self._result_child_name_for_dir(event.src_path)
|
|
test_id, device = parse_deleted_result_dir_name(old_name)
|
|
if test_id:
|
|
reset_by_file_id_and_device(test_id, device)
|
|
broadcast({"type": "update"})
|
|
return
|
|
|
|
# Result directory moved in.
|
|
if dst_in_root and not src_in_root:
|
|
new_name = self._result_child_name_for_dir(event.dest_path)
|
|
process_result_dir(self.results_dir, new_name)
|
|
broadcast({"type": "update"})
|
|
return
|
|
|
|
# Result directory renamed within root.
|
|
if src_in_root and dst_in_root:
|
|
old_name = self._result_child_name_for_dir(event.src_path)
|
|
new_name = self._result_child_name_for_dir(event.dest_path)
|
|
test_id, device = parse_deleted_result_dir_name(old_name)
|
|
if test_id:
|
|
reset_by_file_id_and_device(test_id, device)
|
|
process_result_dir(self.results_dir, new_name)
|
|
broadcast({"type": "update"})
|
|
return
|
|
|
|
src_file_in_result = self._is_file_under_result_child(event.src_path)
|
|
dst_file_in_result = self._is_file_under_result_child(event.dest_path)
|
|
|
|
if src_file_in_result:
|
|
src_name = self._result_child_name_for_file(event.src_path)
|
|
process_result_dir(self.results_dir, src_name)
|
|
|
|
if dst_file_in_result:
|
|
dst_name = self._result_child_name_for_file(event.dest_path)
|
|
if not src_file_in_result or src_name != dst_name:
|
|
process_result_dir(self.results_dir, dst_name)
|
|
|
|
if src_file_in_result or dst_file_in_result:
|
|
broadcast({"type": "update"})
|
|
|
|
|
|
def stop_watching():
|
|
global _target_observer, _results_observers, _scan_timer
|
|
|
|
if _scan_timer:
|
|
_scan_timer.cancel()
|
|
_scan_timer = None
|
|
|
|
if _target_observer:
|
|
_target_observer.stop()
|
|
_target_observer.join(timeout=2)
|
|
_target_observer = None
|
|
|
|
for obs in _results_observers:
|
|
try:
|
|
obs.stop()
|
|
obs.join(timeout=2)
|
|
except Exception as e:
|
|
print(f"[watcher] error stopping results observer: {e}")
|
|
_results_observers.clear()
|
|
|
|
|
|
def start_watching(target_dir, results_dir, results_dir_ref=None):
|
|
global _target_observer, _results_observers
|
|
|
|
stop_watching()
|
|
if not target_dir or not results_dir:
|
|
print("[watcher] target_dir/results_dir not configured; watcher disabled.")
|
|
return
|
|
|
|
if not _path_exists(target_dir):
|
|
print(f"[watcher] target_dir does not exist or is not accessible: {target_dir}")
|
|
print("[watcher] watcher disabled until valid paths are configured.")
|
|
return
|
|
|
|
if not _path_exists(results_dir):
|
|
print(f"[watcher] results_dir does not exist or is not accessible: {results_dir}")
|
|
print("[watcher] watcher disabled until valid paths are configured.")
|
|
return
|
|
|
|
try:
|
|
_target_observer = Observer()
|
|
_target_observer.schedule(_TargetHandler(target_dir, results_dir), target_dir, recursive=True)
|
|
_target_observer.daemon = True
|
|
_target_observer.start()
|
|
print(f"[watcher] target observer started for: {target_dir}")
|
|
|
|
# Watch primary results directory
|
|
results_obs = Observer()
|
|
results_obs.schedule(_ResultsHandler(results_dir), results_dir, recursive=True)
|
|
results_obs.daemon = True
|
|
results_obs.start()
|
|
_results_observers.append(results_obs)
|
|
print(f"[watcher] results observer started for: {results_dir}")
|
|
|
|
# Watch reference results directory if provided and different
|
|
if results_dir_ref and results_dir_ref != results_dir and _path_exists(results_dir_ref):
|
|
ref_obs = Observer()
|
|
ref_obs.schedule(_ResultsHandler(results_dir_ref), results_dir_ref, recursive=True)
|
|
ref_obs.daemon = True
|
|
ref_obs.start()
|
|
_results_observers.append(ref_obs)
|
|
print(f"[watcher] results observer started for reference: {results_dir_ref}")
|
|
elif results_dir_ref and results_dir_ref != results_dir:
|
|
print(f"[watcher] reference results_dir does not exist or is not accessible: {results_dir_ref}")
|
|
except Exception as exc:
|
|
print(f"[watcher] failed to start watchers: {exc}")
|
|
stop_watching()
|