driver / standard (pull_request) Successful in 18s
driver / lint (pull_request) Successful in 16s
driver / types (pull_request) Successful in 1m10s
driver / test (3.12) (pull_request) Successful in 1m9s
driver / test (3.13) (pull_request) Successful in 1m4s
driver / lowest (pull_request) Successful in 35s
driver / build (pull_request) Successful in 40s
driver / security (pull_request) Successful in 1m15s
CI / driver (pull_request) Successful in 2m53s
driver / publish (pull_request) Skipped
_exec_ssh_command returned "" on any failure (no SSH credential, a
refused login or host key, an unreachable node, a timeout), so a
getter that could not look read like one that found nothing; on
API-token-only nodes get_snmp_config answered None and the SSH-backed
getters empty lists on every poll. It now raises ConnectionException
with the cause (SshHostKeyMismatch as it is), and refuses before
connecting when there is neither a password nor a usable key.
It returned stderr when stdout was empty; output is stdout now. It
first posted every command to /nodes/{node}/execute, which runs a
batch of API calls rather than a shell; that dead round trip is gone.
The key types, the key before the password, the host-key check and the
single connect path were done in f491f9f and 6bb3035. The shared
transport is NAPALM/napalm-device-types#35.
Closes #17
225 lines
7.7 KiB
Python
225 lines
7.7 KiB
Python
# Copyright 2025 The NetOrk Project Authors. All rights reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""Routing-related NAPALM getters for Proxmox VE nodes."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from typing import Any
|
|
|
|
import napalm.base.constants as C
|
|
|
|
_JsonDict = dict[str, Any]
|
|
|
|
#: One reply in iputils' ping output, by address or by name with the address
|
|
#: in brackets: "64 bytes from dns.google (8.8.4.4): icmp_seq=1 ttl=118 time=10.5 ms".
|
|
_PING_REPLY = re.compile(r"bytes from (?:\S+ \()?([0-9a-fA-F.:]+)\)?: .*?time=([\d.]+) ms")
|
|
|
|
|
|
class ProxmoxRoutingMixin:
|
|
"""Mixin providing routing NAPALM methods (get_route_to, ping, traceroute)."""
|
|
|
|
def ping(
|
|
self,
|
|
destination: str,
|
|
source: str = C.PING_SOURCE,
|
|
ttl: int = C.PING_TTL,
|
|
timeout: int = C.PING_TIMEOUT,
|
|
size: int = C.PING_SIZE,
|
|
count: int = C.PING_COUNT,
|
|
vrf: str = C.PING_VRF,
|
|
source_interface: str = C.PING_SOURCE_INTERFACE,
|
|
) -> _JsonDict:
|
|
"""Execute ping on the Proxmox node and return results."""
|
|
cmd_parts = [
|
|
f"ping -c {count}",
|
|
f"-W {timeout}",
|
|
f"-s {size}",
|
|
f"-t {ttl}",
|
|
]
|
|
if source:
|
|
cmd_parts.append(f"-I {source}")
|
|
elif source_interface:
|
|
cmd_parts.append(f"-I {source_interface}")
|
|
cmd_parts.append(destination)
|
|
cmd = " ".join(cmd_parts)
|
|
|
|
raw = self._exec_ssh_command(f"{cmd} 2>&1 || true")
|
|
if not raw:
|
|
return {"error": "ping printed nothing on the node"}
|
|
|
|
# Detect common failure strings before parsing statistics
|
|
_error_patterns = (
|
|
"Name or service not known",
|
|
"Network is unreachable",
|
|
"connect: No route to host",
|
|
"unknown host",
|
|
)
|
|
for _pat in _error_patterns:
|
|
if _pat.lower() in raw.lower():
|
|
return {"error": raw.strip()}
|
|
|
|
# Parse statistics line: "5 packets transmitted, 5 received, 0% packet loss"
|
|
m_stat = re.search(
|
|
r"(\d+) packets transmitted,\s+(\d+) received.*?([\d.]+)% packet loss",
|
|
raw,
|
|
)
|
|
if not m_stat:
|
|
return {"error": raw.strip()}
|
|
|
|
sent = int(m_stat.group(1))
|
|
received = int(m_stat.group(2))
|
|
loss = sent - received
|
|
|
|
# RTT line: "rtt min/avg/max/mdev = 0.123/0.456/0.789/0.100 ms"
|
|
m_rtt = re.search(
|
|
r"rtt min/avg/max/mdev = ([\d.]+)/([\d.]+)/([\d.]+)/([\d.]+)",
|
|
raw,
|
|
)
|
|
rtt_min = float(m_rtt.group(1)) if m_rtt else 0.0
|
|
rtt_avg = float(m_rtt.group(2)) if m_rtt else 0.0
|
|
rtt_max = float(m_rtt.group(3)) if m_rtt else 0.0
|
|
rtt_std = float(m_rtt.group(4)) if m_rtt else 0.0
|
|
|
|
# Individual probe lines
|
|
probes = [
|
|
{"ip_address": m.group(1), "rtt": float(m.group(2))} for m in _PING_REPLY.finditer(raw)
|
|
]
|
|
|
|
return {
|
|
"success": {
|
|
"probes_sent": sent,
|
|
"packet_loss": loss,
|
|
"rtt_min": rtt_min,
|
|
"rtt_max": rtt_max,
|
|
"rtt_avg": rtt_avg,
|
|
"rtt_stddev": rtt_std,
|
|
"results": probes,
|
|
}
|
|
}
|
|
|
|
def traceroute(
|
|
self,
|
|
destination: str,
|
|
source: str = "",
|
|
ttl: int = 255,
|
|
timeout: int = 2,
|
|
vrf: str = "",
|
|
) -> _JsonDict:
|
|
"""Execute traceroute on the Proxmox node and return results."""
|
|
cmd_parts = [f"traceroute -m {ttl}", f"-w {timeout}", "-n"]
|
|
if source:
|
|
cmd_parts.append(f"-s {source}")
|
|
cmd_parts.append(destination)
|
|
raw = self._exec_ssh_command(" ".join(cmd_parts) + " 2>&1 || true")
|
|
|
|
if not raw:
|
|
return {"error": "traceroute printed nothing on the node"}
|
|
|
|
hops: _JsonDict = {}
|
|
for line in raw.splitlines():
|
|
m = re.match(
|
|
r"^\s*(\d+)\s+([\d.a-fA-F:]+|\*)\s+([\d.]+|[\d.]+\s+ms|\*)",
|
|
line,
|
|
)
|
|
if not m:
|
|
continue
|
|
hop_id = int(m.group(1))
|
|
ip_addr = m.group(2)
|
|
if ip_addr == "*":
|
|
continue
|
|
# Parse RTT probes: each hop can have up to 3
|
|
rtts = re.findall(r"([\d.]+)\s+ms", line)
|
|
probes_dict = {}
|
|
for idx, rtt in enumerate(rtts, start=1):
|
|
probes_dict[idx] = {
|
|
"rtt": float(rtt),
|
|
"ip_address": ip_addr,
|
|
"host_name": ip_addr,
|
|
}
|
|
if probes_dict:
|
|
hops[hop_id] = {"probes": probes_dict}
|
|
|
|
if not hops:
|
|
return {"error": raw.strip()}
|
|
return {"success": hops}
|
|
|
|
def get_bgp_config(self, group: str = "", neighbor: str = "") -> _JsonDict:
|
|
raise NotImplementedError("BGP configuration is not managed via Proxmox API")
|
|
|
|
def get_bgp_neighbors(self) -> _JsonDict:
|
|
raise NotImplementedError("BGP is not managed via Proxmox API")
|
|
|
|
def get_bgp_neighbors_detail(self, neighbor_address: str = "") -> _JsonDict:
|
|
raise NotImplementedError("BGP is not managed via Proxmox API")
|
|
|
|
def get_route_to(
|
|
self, destination: str = "", protocol: str = "", longer: bool = False
|
|
) -> _JsonDict:
|
|
"""Return routing table entries for the given destination."""
|
|
cmd = f"ip route show {destination} 2>/dev/null || true"
|
|
raw = self._exec_ssh_command(cmd)
|
|
routes: _JsonDict = {}
|
|
for line in raw.splitlines():
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
parts = line.split()
|
|
if not parts:
|
|
continue
|
|
prefix = parts[0]
|
|
next_hop = ""
|
|
out_iface = ""
|
|
proto = "static"
|
|
for i, tok in enumerate(parts):
|
|
if tok == "via" and i + 1 < len(parts):
|
|
next_hop = parts[i + 1]
|
|
if tok == "dev" and i + 1 < len(parts):
|
|
out_iface = parts[i + 1]
|
|
if tok == "proto" and i + 1 < len(parts):
|
|
proto = parts[i + 1]
|
|
|
|
if protocol and protocol.lower() not in proto.lower():
|
|
continue
|
|
|
|
routes.setdefault(prefix, []).append(
|
|
{
|
|
"protocol": proto,
|
|
"current_active": True,
|
|
"last_active": True,
|
|
"age": -1,
|
|
"next_hop": next_hop,
|
|
"outgoing_interface": out_iface,
|
|
"selected_next_hop": True,
|
|
"preference": 1,
|
|
"inactive_reason": "",
|
|
"routing_table": "default",
|
|
"protocol_attributes": {},
|
|
}
|
|
)
|
|
return routes
|
|
|
|
def get_optics(self) -> _JsonDict:
|
|
raise NotImplementedError("Optics not available via Proxmox API")
|
|
|
|
def get_probes_config(self) -> _JsonDict:
|
|
raise NotImplementedError
|
|
|
|
def get_probes_results(self) -> _JsonDict:
|
|
raise NotImplementedError
|
|
|
|
def get_firewall_policies(self) -> _JsonDict:
|
|
raise NotImplementedError("Use the Proxmox firewall API directly")
|