mirror of
https://github.com/hansjone/netx.git
synced 2026-10-11 08:00:49 +08:00
oliver
1f70f7fc25
ARP binds show running-config if-intf to enrich vrf; identical aux commands reuse session cache. Co-authored-by: Cursor <cursoragent@cursor.com>
113 lines
3.6 KiB
Python
113 lines
3.6 KiB
Python
"""ZTE: show running-config if-intf → interface / VRF map.
|
|
|
|
Pipeline: TextFSM ``zte_zxros_show_running_config_if_intf`` first; hand fallback.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from typing import Any, Mapping
|
|
|
|
from ....lldp_shared import resolve_vendor_key
|
|
from ....ntc_parse import apply_rules, resolve_cli_platform, row_get
|
|
from ..common.pipeline import prefer_fsm
|
|
|
|
RULE_KEYS = ("zte_zxros_show_running_config_if_intf",)
|
|
|
|
_IFACE_RE = re.compile(r"^\s*interface\s+(\S+)\s*$", re.I)
|
|
_VRF_RE = re.compile(r"^\s*ip\s+vrf\s+forwarding\s+(\S+)\s*$", re.I)
|
|
|
|
|
|
def _map_fsm_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
|
out: list[dict[str, Any]] = []
|
|
seen: set[str] = set()
|
|
for r in rows:
|
|
iface = row_get(r, "INTERFACE", "interface")
|
|
vrf = row_get(r, "VRF", "vrf")
|
|
if not iface or not vrf or iface in seen:
|
|
continue
|
|
seen.add(iface)
|
|
out.append({"interface": iface[:128], "vrf": vrf[:128]})
|
|
return out
|
|
|
|
|
|
def _hand_parse(*, raw_text: str, **_kw: Any) -> list[dict[str, Any]]:
|
|
out: list[dict[str, Any]] = []
|
|
seen: set[str] = set()
|
|
cur = ""
|
|
cur_vrf = ""
|
|
for raw in str(raw_text or "").splitlines():
|
|
line = raw.rstrip()
|
|
m_if = _IFACE_RE.match(line)
|
|
if m_if:
|
|
if cur and cur_vrf and cur not in seen:
|
|
seen.add(cur)
|
|
out.append({"interface": cur[:128], "vrf": cur_vrf[:128]})
|
|
cur = m_if.group(1).strip()
|
|
cur_vrf = ""
|
|
continue
|
|
if line.strip() == "$":
|
|
if cur and cur_vrf and cur not in seen:
|
|
seen.add(cur)
|
|
out.append({"interface": cur[:128], "vrf": cur_vrf[:128]})
|
|
cur = ""
|
|
cur_vrf = ""
|
|
continue
|
|
m_vrf = _VRF_RE.match(line)
|
|
if m_vrf and cur:
|
|
cur_vrf = m_vrf.group(1).strip()
|
|
if cur and cur_vrf and cur not in seen:
|
|
out.append({"interface": cur[:128], "vrf": cur_vrf[:128]})
|
|
return out
|
|
|
|
|
|
def parse_if_intf_vrf_map(raw_text: str = "", *, rows: list[dict[str, Any]] | None = None) -> dict[str, str]:
|
|
"""Build interface → vrf from metric rows or raw if-intf text."""
|
|
if rows is None:
|
|
rows = _hand_parse(raw_text=raw_text)
|
|
out: dict[str, str] = {}
|
|
for r in rows or []:
|
|
iface = str((r or {}).get("interface") or "").strip()
|
|
vrf = str((r or {}).get("vrf") or "").strip()
|
|
if iface and vrf:
|
|
out[iface] = vrf
|
|
return out
|
|
|
|
|
|
def normalize_if_intf(
|
|
*,
|
|
raw_text: str,
|
|
fsm_tables: Mapping[str, list[dict[str, Any]]] | None = None,
|
|
vendor: str = "",
|
|
device_type: str = "",
|
|
command: str = "",
|
|
params: dict[str, str] | None = None,
|
|
raws: Mapping[str, str] | None = None,
|
|
aux_records: Mapping[str, list[dict[str, Any]]] | None = None,
|
|
) -> list[dict[str, Any]]:
|
|
_ = (params, raws, aux_records)
|
|
tables = dict(fsm_tables or {})
|
|
if not any(tables.get(k) for k in RULE_KEYS):
|
|
platform = resolve_cli_platform(
|
|
vendor=vendor,
|
|
device_type=device_type,
|
|
vendor_key=resolve_vendor_key(vendor, device_type),
|
|
)
|
|
cmd = str(command or "show running-config if-intf").strip()
|
|
if platform:
|
|
tables = apply_rules(
|
|
platform=platform, text=raw_text, rule_keys=RULE_KEYS, command=cmd
|
|
)
|
|
return prefer_fsm(
|
|
tables,
|
|
RULE_KEYS,
|
|
_map_fsm_rows,
|
|
_hand_parse,
|
|
raw_text=raw_text,
|
|
vendor=vendor,
|
|
device_type=device_type,
|
|
command=command,
|
|
)
|
|
|
|
|
|
normalize_if_intf.RULE_KEYS = RULE_KEYS
|