417 lines
15 KiB
Python
417 lines
15 KiB
Python
import csv
|
|
import re
|
|
import threading
|
|
import time
|
|
from dataclasses import asdict, dataclass, field
|
|
from typing import Callable, Optional
|
|
|
|
from core.Function.common import popen_hidden, validate_host
|
|
|
|
|
|
OutputCallback = Callable[[str, Optional[str]], None]
|
|
DoneCallback = Callable[[], None]
|
|
StatusCallback = Callable[[dict], None]
|
|
ResultCallback = Callable[[dict], None]
|
|
|
|
|
|
TRACE_STATUS = {
|
|
"ok": "正常",
|
|
"timeout": "超时",
|
|
"high_latency": "高延迟",
|
|
"jitter": "波动大",
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class TraceOptions:
|
|
max_hops: int = 20
|
|
timeout_ms: int = 800
|
|
address_family: str = "自动"
|
|
resolve_names: bool = False
|
|
mode: str = "单次"
|
|
repeat_count: int = 1
|
|
interval_ms: int = 1000
|
|
high_latency_ms: int = 100
|
|
|
|
|
|
@dataclass
|
|
class TraceHop:
|
|
run: int
|
|
hop: int
|
|
probe1: str
|
|
probe2: str
|
|
probe3: str
|
|
avg_ms: float
|
|
jitter_ms: float
|
|
host: str
|
|
ip: str
|
|
status: str
|
|
status_text: str
|
|
raw_line: str
|
|
checked_at: str = field(default_factory=lambda: time.strftime("%Y-%m-%d %H:%M:%S"))
|
|
|
|
def to_dict(self) -> dict:
|
|
data = asdict(self)
|
|
data["avg_ms"] = round(self.avg_ms, 1)
|
|
data["jitter_ms"] = round(self.jitter_ms, 1)
|
|
return data
|
|
|
|
|
|
@dataclass
|
|
class TraceStats:
|
|
total_runs: int = 1
|
|
current_run: int = 0
|
|
max_hops: int = 20
|
|
current_hop: int = 0
|
|
timeout_hops: int = 0
|
|
high_latency_hops: int = 0
|
|
jitter_hops: int = 0
|
|
max_latency_ms: float = 0.0
|
|
avg_latency_ms: float = 0.0
|
|
samples: list[float] = field(default_factory=list)
|
|
started_at: float = field(default_factory=time.perf_counter)
|
|
|
|
def record(self, hop: TraceHop) -> None:
|
|
self.current_hop = max(self.current_hop, hop.hop)
|
|
if hop.status == "timeout":
|
|
self.timeout_hops += 1
|
|
elif hop.status == "high_latency":
|
|
self.high_latency_hops += 1
|
|
elif hop.status == "jitter":
|
|
self.jitter_hops += 1
|
|
if hop.avg_ms:
|
|
self.samples.append(hop.avg_ms)
|
|
self.max_latency_ms = max(self.max_latency_ms, hop.avg_ms)
|
|
self.avg_latency_ms = sum(self.samples) / len(self.samples)
|
|
|
|
def snapshot(self, state: str) -> dict:
|
|
return {
|
|
"state": state,
|
|
"current_run": self.current_run,
|
|
"total_runs": self.total_runs,
|
|
"current_hop": self.current_hop,
|
|
"max_hops": self.max_hops,
|
|
"timeout_hops": self.timeout_hops,
|
|
"high_latency_hops": self.high_latency_hops,
|
|
"jitter_hops": self.jitter_hops,
|
|
"max_latency_ms": self.max_latency_ms,
|
|
"avg_latency_ms": self.avg_latency_ms,
|
|
"elapsed": time.perf_counter() - self.started_at,
|
|
}
|
|
|
|
|
|
class TracertFun:
|
|
def __init__(
|
|
self,
|
|
output: OutputCallback,
|
|
done: Optional[DoneCallback] = None,
|
|
status: Optional[StatusCallback] = None,
|
|
result: Optional[ResultCallback] = None,
|
|
):
|
|
self.output = output
|
|
self.done = done or (lambda: None)
|
|
self.status = status or (lambda _stats: None)
|
|
self.result = result or (lambda _row: None)
|
|
self.process = None
|
|
self.stop_event = threading.Event()
|
|
self.worker = None
|
|
self.last_results: list[dict] = []
|
|
self.last_summary = ""
|
|
|
|
def start_tracert(self, target: str, max_hops: int = 20, timeout_ms: int = 800, options: Optional[dict] = None) -> None:
|
|
target = validate_host(target)
|
|
trace_options = self.normalize_options(options or {})
|
|
trace_options.max_hops = clamp_int(max_hops, 1, 64, "最大跳数")
|
|
trace_options.timeout_ms = clamp_int(timeout_ms, 100, 60000, "单跳超时")
|
|
|
|
if self.is_running():
|
|
raise RuntimeError("路由追踪正在运行，请先停止当前任务")
|
|
|
|
self.stop_event.clear()
|
|
self.last_results = []
|
|
self.last_summary = ""
|
|
total_runs = 0 if trace_options.mode == "持续" else trace_options.repeat_count
|
|
stats = TraceStats(total_runs=total_runs, max_hops=trace_options.max_hops)
|
|
self.status(stats.snapshot("运行中"))
|
|
self.output(f"开始路由追踪: {target}\n", "muted")
|
|
self.output(self.describe_options(trace_options), "muted")
|
|
self.worker = threading.Thread(target=self._run_loop, args=(target, trace_options, stats), daemon=True)
|
|
self.worker.start()
|
|
|
|
def _run_loop(self, target: str, options: TraceOptions, stats: TraceStats) -> None:
|
|
run = 0
|
|
max_runs = None if options.mode == "持续" else options.repeat_count
|
|
try:
|
|
while not self.stop_event.is_set() and (max_runs is None or run < max_runs):
|
|
run += 1
|
|
stats.current_run = run
|
|
stats.current_hop = 0
|
|
self.output(f"\n==== 第 {run} 次追踪 ====\n", "muted")
|
|
self.status(stats.snapshot("运行中"))
|
|
self._run_once(target, options, stats, run)
|
|
if self.stop_event.is_set() or (max_runs is not None and run >= max_runs):
|
|
break
|
|
self.stop_event.wait(options.interval_ms / 1000)
|
|
finally:
|
|
state = "已停止" if self.stop_event.is_set() else "已完成"
|
|
self.status(stats.snapshot(state))
|
|
self._write_overall_summary(state)
|
|
self.done()
|
|
|
|
def _run_once(self, target: str, options: TraceOptions, stats: TraceStats, run: int) -> None:
|
|
command = self.build_command(target, options)
|
|
run_results = []
|
|
try:
|
|
self.process = popen_hidden(command)
|
|
if not self.process.stdout:
|
|
return
|
|
for raw_line in self.process.stdout:
|
|
if self.stop_event.is_set():
|
|
break
|
|
line = raw_line.rstrip()
|
|
self.output(raw_line, None)
|
|
hop = parse_trace_line(line, run, options.high_latency_ms)
|
|
if not hop:
|
|
continue
|
|
row = hop.to_dict()
|
|
self.last_results.append(row)
|
|
run_results.append(row)
|
|
stats.record(hop)
|
|
self.result(row)
|
|
self.status(stats.snapshot("运行中"))
|
|
except Exception as exc:
|
|
self.output(f"\n路由追踪失败: {exc}\n", "error")
|
|
finally:
|
|
if self.process:
|
|
try:
|
|
if self.stop_event.is_set():
|
|
self.process.terminate()
|
|
else:
|
|
self.process.wait(timeout=1)
|
|
except Exception:
|
|
pass
|
|
self.process = None
|
|
self._write_run_summary(run_results, run)
|
|
|
|
def build_command(self, target: str, options: TraceOptions) -> list[str]:
|
|
command = ["tracert"]
|
|
if not options.resolve_names:
|
|
command.append("-d")
|
|
if options.address_family == "IPv4":
|
|
command.append("-4")
|
|
elif options.address_family == "IPv6":
|
|
command.append("-6")
|
|
command += ["-w", str(options.timeout_ms), "-h", str(options.max_hops), target]
|
|
return command
|
|
|
|
def describe_options(self, options: TraceOptions) -> str:
|
|
runs = "持续" if options.mode == "持续" else f"{options.repeat_count} 次"
|
|
names = "开启" if options.resolve_names else "关闭"
|
|
return (
|
|
f"模式: {options.mode}({runs}) 地址族: {options.address_family} 最大跳数: {options.max_hops} "
|
|
f"单跳超时: {options.timeout_ms}ms 间隔: {options.interval_ms}ms "
|
|
f"解析主机名: {names} 高延迟阈值: {options.high_latency_ms}ms\n"
|
|
)
|
|
|
|
def stop_tracert(self) -> None:
|
|
if not self.is_running():
|
|
raise RuntimeError("当前没有正在运行的路由追踪")
|
|
self.stop_event.set()
|
|
if self.process:
|
|
try:
|
|
self.process.terminate()
|
|
except Exception:
|
|
pass
|
|
self.output("\n正在停止路由追踪...\n", "warning")
|
|
|
|
def export_results(self, path: str) -> None:
|
|
if not self.last_results:
|
|
raise RuntimeError("还没有可导出的路由追踪结果")
|
|
fields = [
|
|
"run",
|
|
"hop",
|
|
"probe1",
|
|
"probe2",
|
|
"probe3",
|
|
"avg_ms",
|
|
"jitter_ms",
|
|
"host",
|
|
"ip",
|
|
"status",
|
|
"status_text",
|
|
"raw_line",
|
|
"checked_at",
|
|
]
|
|
with open(path, "w", newline="", encoding="utf-8-sig") as file:
|
|
writer = csv.DictWriter(file, fieldnames=fields)
|
|
writer.writeheader()
|
|
for row in self.last_results:
|
|
writer.writerow({field: row.get(field, "") for field in fields})
|
|
|
|
def copy_summary(self) -> str:
|
|
return self.last_summary
|
|
|
|
def normalize_options(self, options: dict) -> TraceOptions:
|
|
mode = options.get("mode", "单次")
|
|
if mode not in {"单次", "指定次数", "持续"}:
|
|
mode = "单次"
|
|
repeat_count = 1 if mode == "单次" else clamp_int(options.get("repeat_count", 3), 1, 1000, "追踪次数")
|
|
address_family = options.get("address_family", "自动")
|
|
if address_family not in {"自动", "IPv4", "IPv6"}:
|
|
address_family = "自动"
|
|
return TraceOptions(
|
|
address_family=address_family,
|
|
resolve_names=bool(options.get("resolve_names", False)),
|
|
mode=mode,
|
|
repeat_count=repeat_count,
|
|
interval_ms=clamp_int(options.get("interval_ms", 1000), 0, 60000, "追踪间隔"),
|
|
high_latency_ms=clamp_int(options.get("high_latency_ms", 100), 1, 10000, "高延迟阈值"),
|
|
)
|
|
|
|
def _write_run_summary(self, rows: list[dict], run: int) -> None:
|
|
if not rows:
|
|
return
|
|
summary = build_diagnosis(rows)
|
|
self.last_summary = summary
|
|
self.output(f"\n==== 第 {run} 次诊断摘要 ====\n{summary}\n", "success" if "整体正常" in summary else "warning")
|
|
|
|
def _write_overall_summary(self, state: str) -> None:
|
|
if self.stop_event.is_set():
|
|
self.output("\n路由追踪已停止\n", "warning")
|
|
self.last_summary = "路由追踪已停止。"
|
|
return
|
|
if not self.last_results:
|
|
self.output("\n路由追踪完成，但没有解析到跳点结果\n", "warning")
|
|
self.last_summary = "路由追踪完成，但没有解析到跳点结果。"
|
|
return
|
|
self.last_summary = build_diagnosis(self.last_results)
|
|
self.output(f"\n路由追踪{state}\n", "success")
|
|
|
|
def is_running(self) -> bool:
|
|
return bool(self.worker and self.worker.is_alive())
|
|
|
|
|
|
def parse_trace_line(line: str, run: int = 1, high_latency_ms: int = 100) -> Optional[TraceHop]:
|
|
match = re.match(r"^\s*(\d+)\s+(.+)$", line)
|
|
if not match:
|
|
return None
|
|
|
|
hop = int(match.group(1))
|
|
rest = match.group(2)
|
|
probe_matches = list(re.finditer(r"\*|<\s*\d+\s*(?:ms|毫秒)|\d+\s*(?:ms|毫秒)", rest, flags=re.IGNORECASE))
|
|
if not probe_matches:
|
|
return None
|
|
|
|
probes = []
|
|
values = []
|
|
for probe_match in probe_matches[:3]:
|
|
raw = normalize_probe_text(probe_match.group(0))
|
|
probes.append(raw)
|
|
value = probe_to_ms(raw)
|
|
if value is not None:
|
|
values.append(value)
|
|
while len(probes) < 3:
|
|
probes.append("*")
|
|
|
|
endpoint = rest[probe_matches[min(len(probe_matches), 3) - 1].end() :].strip()
|
|
host, ip = parse_endpoint(endpoint)
|
|
avg_ms = sum(values) / len(values) if values else 0.0
|
|
jitter_ms = max(values) - min(values) if len(values) > 1 else 0.0
|
|
status = classify_hop(values, avg_ms, jitter_ms, high_latency_ms)
|
|
return TraceHop(
|
|
run=run,
|
|
hop=hop,
|
|
probe1=probes[0],
|
|
probe2=probes[1],
|
|
probe3=probes[2],
|
|
avg_ms=avg_ms,
|
|
jitter_ms=jitter_ms,
|
|
host=host,
|
|
ip=ip,
|
|
status=status,
|
|
status_text=TRACE_STATUS[status],
|
|
raw_line=line,
|
|
)
|
|
|
|
|
|
def normalize_probe_text(text: str) -> str:
|
|
text = re.sub(r"\s+", "", text.strip())
|
|
text = text.replace("毫秒", "ms")
|
|
return text.replace("MS", "ms").replace("Ms", "ms")
|
|
|
|
|
|
def probe_to_ms(text: str) -> Optional[float]:
|
|
if text == "*":
|
|
return None
|
|
if text.startswith("<"):
|
|
return 1.0
|
|
match = re.search(r"\d+(?:\.\d+)?", text)
|
|
return float(match.group(0)) if match else None
|
|
|
|
|
|
def parse_endpoint(endpoint: str) -> tuple[str, str]:
|
|
cleaned = endpoint.strip()
|
|
if not cleaned or re.search(r"请求超时|request timed out", cleaned, re.IGNORECASE):
|
|
return "", ""
|
|
bracket_match = re.match(r"(.+?)\s+\[([^\]]+)\]$", cleaned)
|
|
if bracket_match:
|
|
return bracket_match.group(1).strip(), bracket_match.group(2).strip()
|
|
return "", cleaned
|
|
|
|
|
|
def classify_hop(values: list[float], avg_ms: float, jitter_ms: float, high_latency_ms: int) -> str:
|
|
if not values:
|
|
return "timeout"
|
|
if avg_ms >= high_latency_ms:
|
|
return "high_latency"
|
|
if jitter_ms >= max(30, high_latency_ms * 0.5):
|
|
return "jitter"
|
|
return "ok"
|
|
|
|
|
|
def build_diagnosis(rows: list[dict]) -> str:
|
|
if not rows:
|
|
return "没有解析到可诊断的跳点。"
|
|
|
|
latest_run = max(int(row.get("run") or 1) for row in rows)
|
|
latest = [row for row in rows if int(row.get("run") or 1) == latest_run]
|
|
latest.sort(key=lambda row: int(row.get("hop") or 0))
|
|
|
|
timeout_hops = [row for row in latest if row.get("status") == "timeout"]
|
|
high_hops = [row for row in latest if row.get("status") == "high_latency"]
|
|
jitter_hops = [row for row in latest if row.get("status") == "jitter"]
|
|
ok_after_timeout = False
|
|
for index, row in enumerate(latest):
|
|
if row.get("status") == "timeout" and any(next_row.get("status") != "timeout" for next_row in latest[index + 1 :]):
|
|
ok_after_timeout = True
|
|
break
|
|
|
|
lines = [
|
|
f"本次共解析 {len(latest)} 跳，超时 {len(timeout_hops)} 跳，高延迟 {len(high_hops)} 跳，波动 {len(jitter_hops)} 跳。"
|
|
]
|
|
if latest and latest[0].get("status") == "timeout":
|
|
lines.append("第一跳无响应，优先检查本机网关、防火墙或本地网络。")
|
|
if ok_after_timeout:
|
|
lines.append("中间跳点超时但后续恢复，通常是中间路由器限制 ICMP，不一定代表链路故障。")
|
|
if len(latest) >= 2 and latest[-1].get("status") == "timeout" and latest[-2].get("status") == "timeout":
|
|
lines.append("末段连续超时，目标侧网络、跨网链路或目标防火墙可能存在限制。")
|
|
if high_hops:
|
|
detail = ", ".join(f"第 {row['hop']} 跳 {row.get('avg_ms', 0):.1f}ms" for row in high_hops[:5])
|
|
lines.append(f"发现高延迟跳点: {detail}。")
|
|
if jitter_hops:
|
|
detail = ", ".join(f"第 {row['hop']} 跳抖动 {row.get('jitter_ms', 0):.1f}ms" for row in jitter_hops[:5])
|
|
lines.append(f"发现延迟波动: {detail}。")
|
|
if not timeout_hops and not high_hops and not jitter_hops:
|
|
lines.append("整体正常，未发现明显超时、高延迟或波动。")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def clamp_int(value, min_value: int, max_value: int, label: str) -> int:
|
|
try:
|
|
number = int(str(value).strip())
|
|
except ValueError as exc:
|
|
raise ValueError(f"{label}必须是整数") from exc
|
|
if number < min_value or number > max_value:
|
|
raise ValueError(f"{label}必须在 {min_value}-{max_value} 之间")
|
|
return number
|