179 lines
4.6 KiB
Python
179 lines
4.6 KiB
Python
"""Execute and parse multi-packet fping probes without shell interpolation."""
|
|
|
|
import asyncio
|
|
from dataclasses import dataclass
|
|
import re
|
|
from typing import Iterable
|
|
|
|
|
|
FPING_RESULT_PATTERN = re.compile(r"^\s*(\S+)\s+:\s*(.*?)\s*$")
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class ProbeResult:
|
|
"""Aggregate result for one IP in one monitoring round."""
|
|
|
|
ip: str
|
|
sent_count: int
|
|
received_count: int
|
|
average_rtt_ms: float | None
|
|
is_valid: bool
|
|
failure_reason: str | None = None
|
|
|
|
@property
|
|
def packet_loss_percent(self) -> float:
|
|
"""Return packet loss as a percentage of the attempted probes."""
|
|
if self.sent_count <= 0:
|
|
return 0.0
|
|
return (
|
|
(self.sent_count - self.received_count)
|
|
/ self.sent_count
|
|
* 100.0
|
|
)
|
|
|
|
|
|
def _invalid_result(
|
|
ip: str,
|
|
packets_per_round: int,
|
|
reason: str,
|
|
) -> ProbeResult:
|
|
"""Build an invalid aggregate that cannot resemble measured packet loss."""
|
|
return ProbeResult(
|
|
ip=ip,
|
|
sent_count=packets_per_round,
|
|
received_count=0,
|
|
average_rtt_ms=None,
|
|
is_valid=False,
|
|
failure_reason=reason,
|
|
)
|
|
|
|
|
|
def parse_fping_count_output(
|
|
output: str,
|
|
expected_ips: set[str],
|
|
packets_per_round: int,
|
|
) -> dict[str, ProbeResult]:
|
|
"""Parse ``fping -C`` reply tokens for every expected IP.
|
|
|
|
A numeric token is a measured RTT and ``-`` is packet loss. Missing,
|
|
duplicated, or malformed lines are represented as invalid aggregates.
|
|
"""
|
|
if packets_per_round <= 0:
|
|
raise ValueError("packets_per_round must be positive")
|
|
|
|
parsed_lines: dict[str, list[str]] = {}
|
|
duplicate_ips: set[str] = set()
|
|
for line in output.splitlines():
|
|
match = FPING_RESULT_PATTERN.match(line)
|
|
if match is None:
|
|
continue
|
|
ip, replies = match.groups()
|
|
if ip not in expected_ips:
|
|
continue
|
|
if ip in parsed_lines:
|
|
duplicate_ips.add(ip)
|
|
continue
|
|
parsed_lines[ip] = replies.split()
|
|
|
|
results: dict[str, ProbeResult] = {}
|
|
for ip in expected_ips:
|
|
tokens = parsed_lines.get(ip)
|
|
if tokens is None:
|
|
results[ip] = _invalid_result(
|
|
ip,
|
|
packets_per_round,
|
|
"missing fping output",
|
|
)
|
|
continue
|
|
if ip in duplicate_ips or len(tokens) != packets_per_round:
|
|
results[ip] = _invalid_result(
|
|
ip,
|
|
packets_per_round,
|
|
"malformed fping replies",
|
|
)
|
|
continue
|
|
|
|
reply_times: list[float] = []
|
|
malformed = False
|
|
for token in tokens:
|
|
if token == "-":
|
|
continue
|
|
try:
|
|
reply_time = float(token)
|
|
except ValueError:
|
|
malformed = True
|
|
break
|
|
if reply_time < 0:
|
|
malformed = True
|
|
break
|
|
reply_times.append(reply_time)
|
|
|
|
if malformed:
|
|
results[ip] = _invalid_result(
|
|
ip,
|
|
packets_per_round,
|
|
"malformed fping replies",
|
|
)
|
|
continue
|
|
|
|
average_rtt_ms = (
|
|
sum(reply_times) / len(reply_times)
|
|
if reply_times
|
|
else None
|
|
)
|
|
results[ip] = ProbeResult(
|
|
ip=ip,
|
|
sent_count=packets_per_round,
|
|
received_count=len(reply_times),
|
|
average_rtt_ms=average_rtt_ms,
|
|
is_valid=True,
|
|
)
|
|
|
|
return results
|
|
|
|
|
|
async def run_fping_count(
|
|
ips: Iterable[str],
|
|
packets_per_round: int,
|
|
timeout_ms: int,
|
|
executable: str,
|
|
) -> dict[str, ProbeResult]:
|
|
"""Run one fping count probe and return an aggregate for every IP."""
|
|
ip_list = list(ips)
|
|
if not ip_list:
|
|
return {}
|
|
|
|
command = [
|
|
executable,
|
|
"-C",
|
|
str(packets_per_round),
|
|
"-q",
|
|
"-t",
|
|
str(timeout_ms),
|
|
*ip_list,
|
|
]
|
|
try:
|
|
process = await asyncio.create_subprocess_exec(
|
|
*command,
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE,
|
|
)
|
|
stdout, stderr = await process.communicate()
|
|
except Exception as error:
|
|
reason = f"fping execution failed: {type(error).__name__}"
|
|
return {
|
|
ip: _invalid_result(ip, packets_per_round, reason)
|
|
for ip in ip_list
|
|
}
|
|
|
|
output = "\n".join(
|
|
stream.decode("utf-8", errors="replace")
|
|
for stream in (stdout, stderr)
|
|
if stream
|
|
)
|
|
return parse_fping_count_output(
|
|
output,
|
|
set(ip_list),
|
|
packets_per_round,
|
|
)
|