Spaces:
Sleeping
Sleeping
Download server/sim/network_manager.py from brand0nwalls/NetOps: direct link, hf CLI and curl.
- Browser
- Download file 3.23 kB
-
https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/sim/network_manager.py
- Command line
-
hf download hf://spaces/brand0nwalls/NetOps/server/sim/network_manager.py
-
curl -L -o network_manager.py https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/sim/network_manager.py
3.23 kB
| """SimNetworkManager — drop-in replacement for NetworkManager. | |
| Uses SimEngine instead of Mininet. No kernel privileges needed. | |
| Patches time.sleep to advance the simulated clock instead of really sleeping. | |
| """ | |
| import time as _time_module | |
| from server.sim.engine import SimEngine | |
| from server.sim.node_proxy import SimNode, SimIntfProxy | |
| from server.sim.topology import Topology | |
| from server.constants import BGP_CONVERGENCE_TIMEOUT | |
| _real_sleep = _time_module.sleep | |
| _active_engine = None | |
| def _sim_sleep(seconds): | |
| if _active_engine: | |
| _active_engine.advance(seconds) | |
| else: | |
| _real_sleep(seconds) | |
| class SimNetworkManager: | |
| def __init__(self): | |
| self._engine = None | |
| self._running = False | |
| self._topo_class = None # resolved lazily in start() | |
| def net(self): | |
| return self | |
| def running(self) -> bool: | |
| return self._running | |
| def start(self) -> float: | |
| global _active_engine | |
| if self._topo_class is None: | |
| from server.network import NetOpsTopo | |
| self._topo_class = NetOpsTopo | |
| self._engine = SimEngine.from_topo_class(self._topo_class) | |
| self._engine.advance(30) | |
| self._running = True | |
| _active_engine = self._engine | |
| _time_module.sleep = _sim_sleep | |
| return 0.1 | |
| def stop(self): | |
| global _active_engine | |
| self._running = False | |
| self._engine = None | |
| _active_engine = None | |
| _time_module.sleep = _real_sleep | |
| def restart(self) -> float: | |
| self.stop() | |
| return self.start() | |
| def wait_for_bgp(self, timeout=BGP_CONVERGENCE_TIMEOUT) -> float: | |
| return 0.0 | |
| def get_router(self, name: str): | |
| if not self._engine or name not in self._engine.topo.routers: | |
| return None | |
| return SimNode(name, self._engine) | |
| def get_host(self, name: str): | |
| if not self._engine or name not in self._engine.topo.hosts: | |
| return None | |
| return SimNode(name, self._engine) | |
| def get_all_routers(self) -> list: | |
| if not self._engine: | |
| return [] | |
| return [SimNode(n, self._engine) for n in sorted(self._engine.topo.routers)] | |
| def get_all_hosts(self) -> list: | |
| if not self._engine: | |
| return [] | |
| return [SimNode(n, self._engine) for n in sorted(self._engine.topo.hosts)] | |
| def get_all_switches(self) -> list: | |
| return [] | |
| def find_link_interface(self, router_name: str, peer_name: str): | |
| if not self._engine: | |
| return None | |
| intf_name = self._engine.topo.find_link_interface(router_name, peer_name) | |
| if not intf_name: | |
| return None | |
| intf = self._engine.topo.get_interface(intf_name) | |
| return SimIntfProxy(intf) if intf else None | |
| def ping(self, src_name: str, dst_name: str, count=3, timeout=2) -> dict: | |
| if not self._engine: | |
| return {"raw": "", "loss_pct": 100} | |
| return self._engine.reachability.ping(src_name, dst_name, count=count) | |
| def traceroute(self, src_name: str, dst_name: str) -> str: | |
| if not self._engine: | |
| return "" | |
| return self._engine.reachability.traceroute(src_name, dst_name) | |