Spaces:
Running
Running
Download server/sim/ospf.py from brand0nwalls/NetOps: direct link, hf CLI and curl.
- Browser
- Download file 9.48 kB
-
https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/sim/ospf.py
- Command line
-
hf download hf://spaces/brand0nwalls/NetOps/server/sim/ospf.py
-
curl -L -o ospf.py https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/sim/ospf.py
9.48 kB
| """OSPF simulation — timer-based neighbor state machine + Dijkstra SPF. | |
| Models hello/dead timers so neighbor state transitions happen over simulated | |
| time, matching real FRR behavior. Produces FRR-compatible JSON dicts for | |
| telemetry consumption. | |
| """ | |
| import heapq | |
| import ipaddress | |
| from dataclasses import dataclass, field | |
| from server.constants import AS_CONFIGS | |
| _DEFAULT_HELLO = 10 | |
| _DEFAULT_DEAD = 40 | |
| class OSPFAdjacency: | |
| router: str | |
| peer_router: str | |
| intf_name: str | |
| peer_intf_name: str | |
| last_hello_received: float = 0.0 | |
| established_at: float = 0.0 | |
| class OSPFEngine: | |
| def __init__(self, engine): | |
| self._engine = engine | |
| self._adjacencies: dict[tuple[str, str], OSPFAdjacency] = {} | |
| self._init_adjacencies() | |
| def _init_adjacencies(self): | |
| topo = self._engine.topo | |
| for link in topo.links: | |
| if link.igp_passive: | |
| continue | |
| a = topo.get_interface(link.intf_a) | |
| b = topo.get_interface(link.intf_b) | |
| if not a or not b: | |
| continue | |
| if a.node not in topo.routers or b.node not in topo.routers: | |
| continue | |
| ra = topo.routers[a.node] | |
| rb = topo.routers[b.node] | |
| if ra.asn != rb.asn: | |
| continue | |
| key_ab = (a.node, b.node) | |
| key_ba = (b.node, a.node) | |
| self._adjacencies[key_ab] = OSPFAdjacency( | |
| router=a.node, peer_router=b.node, | |
| intf_name=a.name, peer_intf_name=b.name, | |
| last_hello_received=0.0, established_at=0.0, | |
| ) | |
| self._adjacencies[key_ba] = OSPFAdjacency( | |
| router=b.node, peer_router=a.node, | |
| intf_name=b.name, peer_intf_name=a.name, | |
| last_hello_received=0.0, established_at=0.0, | |
| ) | |
| def neighbor_state(self, router_name: str, peer_name: str) -> str: | |
| """Compute OSPF neighbor state. Returns 'Full/DR', 'Down/-', 'ExStart/DR', 'Init/-'.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| peer = topo.routers.get(peer_name) | |
| if not router or not peer: | |
| return "Down/-" | |
| if not router.ospf_daemon_alive: | |
| return "Down/-" | |
| if not peer.ospf_daemon_alive: | |
| return self._check_dead_timer(router_name, peer_name) | |
| intf_name = topo.find_link_interface(router_name, peer_name) | |
| peer_intf_name = topo.find_link_interface(peer_name, router_name) | |
| if not intf_name or not peer_intf_name: | |
| return "Down/-" | |
| intf = topo.get_interface(intf_name) | |
| peer_intf = topo.get_interface(peer_intf_name) | |
| if not intf or not peer_intf: | |
| return "Down/-" | |
| if not intf.up or not peer_intf.up: | |
| return "Down/-" | |
| if intf.iptables_output_drop and not peer_intf.iptables_output_drop: | |
| return "Init/-" | |
| if peer_intf.iptables_output_drop and not intf.iptables_output_drop: | |
| return "Init/-" | |
| if intf.iptables_output_drop and peer_intf.iptables_output_drop: | |
| return "Down/-" | |
| for rule in intf.iptables_input_rules + peer_intf.iptables_input_rules: | |
| if "proto 89" in str(rule) or "ospf" in str(rule).lower(): | |
| return "Down/-" | |
| for rule in intf.iptables_forward_rules + peer_intf.iptables_forward_rules: | |
| if "proto 89" in str(rule) or "ospf" in str(rule).lower(): | |
| return "Down/-" | |
| area_a = router.ospf_area.get(intf_name, "0.0.0.0") | |
| area_b = peer.ospf_area.get(peer_intf_name, "0.0.0.0") | |
| if area_a != area_b: | |
| return "Down/-" | |
| if intf.mtu != peer_intf.mtu: | |
| return "ExStart/DR" | |
| hello_a = router.ospf_hello.get(intf_name, _DEFAULT_HELLO) | |
| hello_b = peer.ospf_hello.get(peer_intf_name, _DEFAULT_HELLO) | |
| dead_a = router.ospf_dead.get(intf_name, _DEFAULT_DEAD) | |
| dead_b = peer.ospf_dead.get(peer_intf_name, _DEFAULT_DEAD) | |
| if hello_a != hello_b or dead_a != dead_b: | |
| return "Down/-" | |
| return "Full/DR" | |
| def _check_dead_timer(self, router_name: str, peer_name: str) -> str: | |
| adj = self._adjacencies.get((router_name, peer_name)) | |
| if not adj: | |
| return "Down/-" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| dead = router.ospf_dead.get(adj.intf_name, _DEFAULT_DEAD) if router else _DEFAULT_DEAD | |
| elapsed = self._engine.now - adj.last_hello_received | |
| if elapsed > dead: | |
| return "Down/-" | |
| return "Full/DR" | |
| def get_intra_as_peers(self, router_name: str) -> list[str]: | |
| result = [] | |
| for (r, p) in self._adjacencies: | |
| if r == router_name: | |
| result.append(p) | |
| return result | |
| def run_spf(self, router_name: str) -> dict[str, tuple[str, int, str]]: | |
| """Dijkstra SPF from router. Returns {prefix: (next_hop_ip, cost, out_intf)}.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router or not router.ospf_daemon_alive: | |
| return {} | |
| asn = router.asn | |
| as_routers = [r for r in topo.routers.values() if r.asn == asn] | |
| adj = {} | |
| for r in as_routers: | |
| adj[r.name] = [] | |
| for peer_name in self.get_intra_as_peers(r.name): | |
| state = self.neighbor_state(r.name, peer_name) | |
| if not state.startswith("Full"): | |
| continue | |
| intf_name = topo.find_link_interface(r.name, peer_name) | |
| if not intf_name: | |
| continue | |
| cost = r.ospf_costs.get(intf_name, 10) | |
| peer_intf_name = topo.find_link_interface(peer_name, r.name) | |
| peer_intf = topo.get_interface(peer_intf_name) if peer_intf_name else None | |
| adj[r.name].append((peer_name, cost, intf_name, peer_intf.ip if peer_intf else "")) | |
| dist = {r.name: float("inf") for r in as_routers} | |
| prev = {r.name: (None, None, None) for r in as_routers} | |
| dist[router_name] = 0 | |
| heap = [(0, router_name)] | |
| while heap: | |
| d, u = heapq.heappop(heap) | |
| if d > dist[u]: | |
| continue | |
| for v, cost, intf, peer_ip in adj.get(u, []): | |
| nd = d + cost | |
| if nd < dist[v]: | |
| dist[v] = nd | |
| if u == router_name: | |
| prev[v] = (peer_ip, nd, intf) | |
| else: | |
| prev[v] = (prev[u][0], nd, prev[u][2]) | |
| heapq.heappush(heap, (nd, v)) | |
| routes = {} | |
| for r in as_routers: | |
| if r.name == router_name: | |
| continue | |
| if dist[r.name] == float("inf"): | |
| continue | |
| next_hop, cost, out_intf = prev[r.name] | |
| if not next_hop: | |
| continue | |
| lo_prefix = f"{r.loopback}/32" | |
| routes[lo_prefix] = (next_hop, int(cost), out_intf) | |
| for intf in r.interfaces.values(): | |
| subnet = intf.subnet | |
| if subnet and subnet not in routes: | |
| routes[subnet] = (next_hop, int(cost), out_intf) | |
| return routes | |
| def ospf_neighbors_dict(self, router_name: str) -> dict: | |
| """Produce FRR-compatible 'show ip ospf neighbor json' dict.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router or not router.ospf_daemon_alive: | |
| return {"neighbors": {}} | |
| neighbors = {} | |
| for peer_name in self.get_intra_as_peers(router_name): | |
| peer = topo.routers.get(peer_name) | |
| if not peer: | |
| continue | |
| state = self.neighbor_state(router_name, peer_name) | |
| if state.startswith("Down"): | |
| continue | |
| peer_intf_name = topo.find_link_interface(peer_name, router_name) | |
| peer_intf = topo.get_interface(peer_intf_name) if peer_intf_name else None | |
| intf_name = topo.find_link_interface(router_name, peer_name) | |
| dead_interval = router.ospf_dead.get(intf_name, _DEFAULT_DEAD) | |
| if state.startswith("Full"): | |
| dead_remaining_ms = int(dead_interval * 0.8 * 1000) | |
| else: | |
| dead_remaining_ms = int(dead_interval * 0.5 * 1000) | |
| nid = peer.loopback | |
| neighbors[nid] = [{ | |
| "nbrState": state, | |
| "routerDeadIntervalTimerDueMsec": dead_remaining_ms, | |
| "ifaceAddress": peer_intf.ip if peer_intf else "", | |
| }] | |
| return {"neighbors": neighbors} | |
| def ospf_interface_dict(self, router_name: str) -> dict: | |
| """Produce FRR-compatible 'show ip ospf interface json' dict.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router: | |
| return {"interfaces": {}} | |
| interfaces = {} | |
| for intf_name, intf in router.interfaces.items(): | |
| cost = router.ospf_costs.get(intf_name, 10) | |
| area = router.ospf_area.get(intf_name, "0.0.0.0") | |
| interfaces[intf_name] = { | |
| "cost": cost, | |
| "area": area, | |
| "state": "DR" if router.ospf_daemon_alive else "Down", | |
| } | |
| return {"interfaces": interfaces} | |