Spaces:
Running
Running
Download server/sim/bgp.py from brand0nwalls/NetOps: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/sim/bgp.py
- Command line
-
hf download hf://spaces/brand0nwalls/NetOps/server/sim/bgp.py
-
curl -L -o bgp.py https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/sim/bgp.py
11.5 kB
| """BGP simulation — session state, route advertisement, best-path selection. | |
| Models iBGP (full mesh within AS) and eBGP (between ASes). Produces | |
| FRR-compatible JSON dicts for telemetry consumption. | |
| """ | |
| from dataclasses import dataclass, field | |
| class BGPRoute: | |
| prefix: str | |
| next_hop: str | |
| as_path: list[int] = field(default_factory=list) | |
| local_pref: int = 100 | |
| origin: str = "igp" | |
| communities: list[str] = field(default_factory=list) | |
| source_router: str = "" | |
| class BGPEngine: | |
| def __init__(self, engine): | |
| self._engine = engine | |
| self._session_down_until: dict[tuple[str, str], float] = {} | |
| def force_session_down(self, router: str, peer_ip: str, duration: float): | |
| """Latch a BGP session down for duration seconds (simulated time).""" | |
| self._session_down_until[(router, peer_ip)] = self._engine.now + duration | |
| def session_state(self, router_name: str, peer_ip: str) -> str: | |
| """BGP session state: Established, Active, Idle, Connect.""" | |
| key = (router_name, peer_ip) | |
| if key in self._session_down_until: | |
| if self._engine.now < self._session_down_until[key]: | |
| return "Active" | |
| else: | |
| del self._session_down_until[key] | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router: | |
| return "Idle" | |
| if not router.bgp_daemon_alive: | |
| return "Idle" | |
| peer_node = topo.ip_to_node(peer_ip) | |
| if not peer_node: | |
| return "Active" | |
| peer = topo.routers.get(peer_node) | |
| if not peer: | |
| return "Active" | |
| if not peer.bgp_daemon_alive: | |
| return "Active" | |
| intf_name = topo.find_link_interface(router_name, peer_node) | |
| if not intf_name: | |
| return "Active" | |
| intf = topo.get_interface(intf_name) | |
| peer_intf_name = topo.find_link_interface(peer_node, router_name) | |
| peer_intf = topo.get_interface(peer_intf_name) if peer_intf_name else None | |
| if not intf or not peer_intf: | |
| return "Active" | |
| if not intf.up or not peer_intf.up: | |
| return "Active" | |
| if self._tcp179_blocked(router, intf) or self._tcp179_blocked(peer, peer_intf): | |
| return "Active" | |
| if router.cpu_exhausted or peer.cpu_exhausted: | |
| return "Active" | |
| return "Established" | |
| def _tcp179_blocked(self, router, intf) -> bool: | |
| for rule in intf.iptables_input_rules: | |
| if "dport 179" in str(rule) or "tcp" in str(rule) and "179" in str(rule): | |
| return True | |
| for rule in intf.iptables_forward_rules: | |
| if "dport 179" in str(rule): | |
| return True | |
| return False | |
| def advertised_routes(self, router_name: str) -> list[BGPRoute]: | |
| """Routes this router originates/advertises to peers.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router or not router.bgp_daemon_alive: | |
| return [] | |
| routes = [] | |
| ospf_engine = self._engine.ospf | |
| if router.bgp_redistribute_connected: | |
| for intf in router.interfaces.values(): | |
| if intf.ip and intf.up: | |
| routes.append(BGPRoute( | |
| prefix=intf.subnet, next_hop="0.0.0.0", | |
| as_path=[router.asn], origin="igp", | |
| source_router=router_name, | |
| )) | |
| if router.loopback: | |
| routes.append(BGPRoute( | |
| prefix=f"{router.loopback}/32", next_hop="0.0.0.0", | |
| as_path=[router.asn], origin="igp", | |
| source_router=router_name, | |
| )) | |
| if router.bgp_redistribute_ospf: | |
| ospf_routes = ospf_engine.run_spf(router_name) | |
| for prefix in ospf_routes: | |
| if not any(r.prefix == prefix for r in routes): | |
| routes.append(BGPRoute( | |
| prefix=prefix, next_hop="0.0.0.0", | |
| as_path=[router.asn], origin="igp", | |
| source_router=router_name, | |
| )) | |
| if router.bgp_redistribute_static: | |
| for prefix, nh in router.static_routes.items(): | |
| routes.append(BGPRoute( | |
| prefix=prefix, next_hop=nh if nh != "blackhole" else "0.0.0.0", | |
| as_path=[router.asn], origin="incomplete", | |
| source_router=router_name, | |
| )) | |
| for prefix in router.bgp_networks: | |
| if not any(r.prefix == prefix for r in routes): | |
| routes.append(BGPRoute( | |
| prefix=prefix, next_hop="0.0.0.0", | |
| as_path=[router.asn], origin="igp", | |
| source_router=router_name, | |
| )) | |
| return routes | |
| def received_routes(self, router_name: str, peer_ip: str) -> list[BGPRoute]: | |
| """Routes received from a specific peer, after inbound policy.""" | |
| return self._received_routes_inner(router_name, peer_ip, 0) | |
| def _received_routes_inner(self, router_name: str, peer_ip: str, _depth: int) -> list[BGPRoute]: | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router: | |
| return [] | |
| if self.session_state(router_name, peer_ip) != "Established": | |
| return [] | |
| peer_node = topo.ip_to_node(peer_ip) | |
| if not peer_node: | |
| return [] | |
| peer = topo.routers.get(peer_node) | |
| if not peer: | |
| return [] | |
| peer_cfg = router.bgp_peer_config.get(peer_ip, {}) | |
| if peer_cfg.get("prefix_list_in") == "BLOCK_ALL": | |
| return [] | |
| peer_routes = self._collect_peer_advertisements(peer_node, router_name, _depth) | |
| result = [] | |
| is_ebgp = router.asn != peer.asn | |
| local_pref_override = peer_cfg.get("local_pref_in") | |
| for route in peer_routes: | |
| as_path = route.as_path.copy() | |
| if is_ebgp and peer.asn not in as_path: | |
| as_path = [peer.asn] + as_path | |
| r = BGPRoute( | |
| prefix=route.prefix, | |
| next_hop=peer_ip, | |
| as_path=as_path, | |
| local_pref=local_pref_override if local_pref_override else (100 if is_ebgp else route.local_pref), | |
| origin=route.origin, | |
| communities=route.communities.copy(), | |
| source_router=route.source_router, | |
| ) | |
| if is_ebgp and router.asn in r.as_path: | |
| continue | |
| result.append(r) | |
| return result | |
| def _collect_peer_advertisements(self, peer_name: str, to_router: str, _depth: int = 0) -> list[BGPRoute]: | |
| """What the peer would advertise to us, after outbound policy.""" | |
| topo = self._engine.topo | |
| peer = topo.routers.get(peer_name) | |
| if not peer: | |
| return [] | |
| to_router_obj = topo.routers.get(to_router) | |
| is_ebgp_session = peer.asn != to_router_obj.asn if to_router_obj else True | |
| own_routes = self.advertised_routes(peer_name) | |
| if _depth < 2: | |
| for other_peer_ip, other_cfg in peer.bgp_peer_config.items(): | |
| other_node = topo.ip_to_node(other_peer_ip) | |
| if not other_node or other_node == to_router or other_node == peer_name: | |
| continue | |
| other_router = topo.routers.get(other_node) | |
| if not other_router: | |
| continue | |
| other_is_ebgp = peer.asn != other_router.asn | |
| if not is_ebgp_session and not other_is_ebgp: | |
| continue | |
| other_routes = self._received_routes_inner(peer_name, other_peer_ip, _depth + 1) | |
| for r in other_routes: | |
| if "no-export" not in r.communities: | |
| if not any(er.prefix == r.prefix for er in own_routes): | |
| own_routes.append(r) | |
| intf_name = topo.find_link_interface(peer_name, to_router) | |
| peer_cfg = {} | |
| if intf_name: | |
| peer_intf = topo.get_peer_interface(intf_name) | |
| if peer_intf: | |
| peer_cfg = peer.bgp_peer_config.get(peer_intf.ip, {}) | |
| prepend_count = peer_cfg.get("prepend_out", 0) | |
| community_out = peer_cfg.get("community_out") | |
| result = [] | |
| for route in own_routes: | |
| r = BGPRoute( | |
| prefix=route.prefix, | |
| next_hop=route.next_hop, | |
| as_path=route.as_path.copy(), | |
| local_pref=route.local_pref, | |
| origin=route.origin, | |
| communities=route.communities.copy(), | |
| source_router=route.source_router, | |
| ) | |
| if prepend_count > 0: | |
| r.as_path = [peer.asn] * prepend_count + r.as_path | |
| if community_out: | |
| r.communities.append(community_out) | |
| result.append(r) | |
| return result | |
| def best_path(self, router_name: str) -> dict[str, BGPRoute]: | |
| """BGP best path selection for all received prefixes.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router or not router.bgp_daemon_alive: | |
| return {} | |
| candidates: dict[str, list[BGPRoute]] = {} | |
| for peer_ip in router.bgp_peer_config: | |
| for route in self.received_routes(router_name, peer_ip): | |
| candidates.setdefault(route.prefix, []).append(route) | |
| best = {} | |
| for prefix, routes in candidates.items(): | |
| selected = self._select_best(routes) | |
| if selected: | |
| best[prefix] = selected | |
| return best | |
| def _select_best(self, routes: list[BGPRoute]) -> BGPRoute | None: | |
| if not routes: | |
| return None | |
| def sort_key(r): | |
| return (-r.local_pref, len(r.as_path), {"igp": 0, "egp": 1, "incomplete": 2}.get(r.origin, 3), r.next_hop) | |
| return sorted(routes, key=sort_key)[0] | |
| def bgp_summary_dict(self, router_name: str) -> dict: | |
| """Produce FRR-compatible 'show bgp summary json' dict.""" | |
| topo = self._engine.topo | |
| router = topo.routers.get(router_name) | |
| if not router: | |
| return {"ipv4Unicast": {"routerId": "", "as": 0, "peers": {}}} | |
| peers = {} | |
| for peer_ip, cfg in router.bgp_peer_config.items(): | |
| state = self.session_state(router_name, peer_ip) | |
| pfx_rcvd = len(self.received_routes(router_name, peer_ip)) if state == "Established" else 0 | |
| peer_node = topo.ip_to_node(peer_ip) | |
| pfx_sent = 0 | |
| if state == "Established" and peer_node: | |
| pfx_sent = len(self._collect_peer_advertisements(router_name, peer_node)) | |
| remote_as = cfg.get("remote_as", 0) | |
| uptime_ms = int(self._engine.now * 1000) if state == "Established" else 0 | |
| peers[peer_ip] = { | |
| "remoteAs": remote_as, | |
| "state": state, | |
| "pfxRcd": pfx_rcvd, | |
| "pfxSnt": pfx_sent, | |
| "peerUptimeMsec": uptime_ms, | |
| "peerUptime": f"{int(self._engine.now)}s", | |
| } | |
| return { | |
| "ipv4Unicast": { | |
| "routerId": router.loopback, | |
| "as": router.asn, | |
| "peers": peers, | |
| } | |
| } | |