Spaces:
Sleeping
Sleeping
Download server/environment.py from brand0nwalls/NetOps: direct link, hf CLI and curl.
- Browser
- Download file 24.7 kB
-
https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/environment.py
- Command line
-
hf download hf://spaces/brand0nwalls/NetOps/server/environment.py
-
curl -L -o environment.py https://huggingface.co/spaces/brand0nwalls/NetOps/resolve/main/server/environment.py
24.7 kB
| import logging | |
| import os | |
| import time | |
| from typing import Optional | |
| from uuid import uuid4 | |
| from openenv.core.env_server.interfaces import Environment | |
| from models import NetOpsAction, NetOpsObservation, NetOpsState | |
| from server.constants import GroundTruth, MAX_EPISODE_STEPS, set_topology_scale, router_to_asn | |
| if os.environ.get("NETOPS_SIM") == "1": | |
| from server.sim.network_manager import SimNetworkManager as NetworkManager | |
| from server.sim.fault_injector_sim import SimFaultInjector as _FaultInjector | |
| else: | |
| from server.network import NetworkManager | |
| _FaultInjector = None | |
| from server.telemetry import ( | |
| read_bgp_summary, read_ospf_neighbors, read_ospf_interface, | |
| read_routes, read_interfaces, read_queue_stats, | |
| read_protocol_counters, read_all_router_telemetry, | |
| read_iptables, read_cpu_status, read_bgp_detail, | |
| ) | |
| from server.renderer import ( | |
| render_routing_view, render_traffic_view, render_device_view, | |
| render_topology_view, render_events_view, | |
| render_ping_result, render_traceroute_result, | |
| ) | |
| if _FaultInjector is None: | |
| from server.fault_injector import FaultInjector | |
| else: | |
| FaultInjector = _FaultInjector | |
| from server.health_checker import HealthChecker, HealthReport | |
| from server.fault_verifier import verify_all_faults_fixed | |
| from server.reward import Diagnosis, ActionLog, compute_reward, compute_potential | |
| from server.scenarios import ( | |
| generate_scenario, make_alert, Scenario, | |
| ALL_ACTIONS, INVESTIGATION_ACTIONS, DIAGNOSIS_ACTIONS, REMEDIATION_ACTIONS, | |
| TERMINAL_ACTIONS, | |
| ) | |
| logger = logging.getLogger(__name__) | |
| CONVERGENCE_WAIT = 0 if os.environ.get("NETOPS_SIM") == "1" else 5 | |
| class NetOpsEnvironment(Environment): | |
| SUPPORTS_CONCURRENT_SESSIONS: bool = False | |
| def __init__(self): | |
| self._net_mgr: Optional[NetworkManager] = None | |
| self._injector: Optional[FaultInjector] = None | |
| self._health: Optional[HealthChecker] = None | |
| self._scenario: Optional[Scenario] = None | |
| self._health_before: Optional[HealthReport] = None | |
| self._action_log = ActionLog() | |
| self._diagnosis: Optional[Diagnosis] = None | |
| self._step_count = 0 | |
| self._event_snapshots: list[dict] = [] | |
| self._state = NetOpsState(episode_id=str(uuid4()), step_count=0) | |
| self._prev_potential = 0.0 | |
| self._unique_query_types: set = set() | |
| self._phase = 0.0 | |
| def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, | |
| difficulty: str = "easy", fault_type: str = None, | |
| routers_per_as: int = 3, num_ases: int = 3, | |
| **kwargs) -> NetOpsObservation: | |
| logger.info("reset() called — difficulty=%s scale=%dx%d", | |
| difficulty, routers_per_as, num_ases) | |
| if routers_per_as != 3 or num_ases != 3: | |
| set_topology_scale(routers_per_as, num_ases) | |
| if self._net_mgr and self._net_mgr.running: | |
| if self._injector: | |
| self._injector.undo_all() | |
| if hasattr(self._net_mgr, 'restart'): | |
| self._net_mgr.restart() | |
| self._injector = FaultInjector(self._net_mgr) | |
| self._health = HealthChecker(self._net_mgr) | |
| else: | |
| self._net_mgr = NetworkManager() | |
| t = self._net_mgr.start() | |
| logger.info("Network started in %.1fs", t) | |
| self._injector = FaultInjector(self._net_mgr) | |
| self._health = HealthChecker(self._net_mgr) | |
| self._injector.clear() | |
| if hasattr(self._net_mgr, '_engine') and self._net_mgr._engine: | |
| self._net_mgr._engine.topo.reset_all_counters() | |
| scenario = generate_scenario(difficulty=difficulty, fault_type=fault_type, seed=seed) | |
| gt = self._injector.inject_random(difficulty=difficulty, fault_type=scenario.fault_type) | |
| scenario.ground_truth = gt | |
| scenario.alert = make_alert(gt) | |
| time.sleep(CONVERGENCE_WAIT) | |
| self._scenario = scenario | |
| self._health_before = self._health.check_network_health() | |
| self._action_log = ActionLog() | |
| self._diagnosis = None | |
| self._step_count = 0 | |
| self._event_snapshots = [] | |
| # Take initial snapshot so query_events has a baseline on first call | |
| initial_snap = {} | |
| for r in self._net_mgr.get_all_routers(): | |
| initial_snap[r.name] = read_all_router_telemetry(r) | |
| initial_snap["_ts"] = time.time() | |
| self._event_snapshots.append(initial_snap) | |
| self._prev_potential = 0.0 | |
| self._unique_query_types = set() | |
| self._phase = 0.0 | |
| eid = episode_id or str(uuid4()) | |
| self._state = NetOpsState( | |
| episode_id=eid, | |
| step_count=0, | |
| fault_type=gt.fault_type, | |
| component=gt.component, | |
| difficulty=difficulty, | |
| ) | |
| logger.info("Episode %s: fault=%s component=%s", eid, gt.fault_type, gt.component) | |
| return NetOpsObservation( | |
| alert=scenario.alert, | |
| observation=( | |
| "Network anomaly detected. You are the on-call network engineer.\n" | |
| "Investigate using query commands, submit a diagnosis, then remediate.\n" | |
| "Available commands: " + ", ".join(ALL_ACTIONS) | |
| ), | |
| available_actions=ALL_ACTIONS, | |
| steps_taken=0, | |
| max_steps=scenario.max_steps, | |
| difficulty=difficulty, | |
| done=False, | |
| reward=0.0, | |
| ) | |
| def step(self, action: NetOpsAction, timeout_s: Optional[float] = None, | |
| **kwargs) -> NetOpsObservation: | |
| self._step_count += 1 | |
| self._state.step_count = self._step_count | |
| self._action_log.actions.append(f"{action.command}({action.args})") | |
| cmd = action.command.strip() | |
| args = action.args | |
| logger.info("Step %d/%d: %s %s", self._step_count, self._scenario.max_steps, | |
| cmd, args) | |
| try: | |
| if cmd in INVESTIGATION_ACTIONS: | |
| obs_text = self._handle_investigation(cmd, args) | |
| elif cmd in DIAGNOSIS_ACTIONS: | |
| obs_text = self._handle_diagnosis(args) | |
| elif cmd in REMEDIATION_ACTIONS: | |
| obs_text = self._handle_remediation(cmd, args) | |
| elif cmd in TERMINAL_ACTIONS: | |
| obs_text = self._handle_confirm_fix() | |
| else: | |
| obs_text = f"Unknown command: {cmd}. Available: {', '.join(ALL_ACTIONS)}" | |
| except Exception as e: | |
| logger.error("Action %s failed: %s", cmd, e, exc_info=True) | |
| obs_text = f"Error executing {cmd}: {e}" | |
| if cmd in INVESTIGATION_ACTIONS: | |
| self._unique_query_types.add(cmd) | |
| self._phase = max(self._phase, 0.30 if len(self._unique_query_types) >= 2 else 0.15) | |
| elif cmd in DIAGNOSIS_ACTIONS: | |
| self._phase = max(self._phase, 0.60) | |
| elif cmd in REMEDIATION_ACTIONS: | |
| if self._diagnosis is not None: | |
| self._phase = max(self._phase, 0.80) | |
| else: | |
| self._phase = max(self._phase, 0.40) | |
| current_health = self._health.check_network_health().score | |
| if self._phase >= 0.80 and current_health > self._health_before.score: | |
| self._phase = 1.0 | |
| info_div = min(1.0, len(self._unique_query_types) / 3.0) | |
| current_potential = compute_potential(self._phase, current_health, info_div) | |
| shaping_reward = current_potential - self._prev_potential | |
| self._prev_potential = current_potential | |
| done = False | |
| reward = shaping_reward | |
| if cmd in TERMINAL_ACTIONS or self._step_count >= self._scenario.max_steps: | |
| done = True | |
| if done: | |
| health_after = self._health.check_network_health() | |
| verification = verify_all_faults_fixed( | |
| self._injector.ground_truths, self._net_mgr | |
| ) | |
| diagnosis = self._diagnosis or Diagnosis("unknown", "unknown", "no diagnosis submitted") | |
| reward_result = compute_reward( | |
| diagnosis=diagnosis, | |
| ground_truth=self._scenario.ground_truth, | |
| health_before=self._health_before, | |
| health_after=health_after, | |
| steps_used=self._step_count, | |
| max_steps=self._scenario.max_steps, | |
| action_log=self._action_log, | |
| fault_fixed=verification.fixed, | |
| fault_fix_partial=verification.partial_score, | |
| ) | |
| reward = reward_result["total"] - self._prev_potential | |
| self._state.cumulative_reward = reward | |
| self._state.is_resolved = verification.fixed and self._diagnosis is not None | |
| self._state.health_score = health_after.score | |
| self._state.diagnosis_submitted = self._diagnosis is not None | |
| self._state.remediation_attempted = self._action_log.remediation_count > 0 | |
| obs_text += f"\n\n--- EPISODE COMPLETE ---\n" | |
| obs_text += f"Reward: {reward:.2f}\n" | |
| for k, v in reward_result.items(): | |
| if k != "total": | |
| obs_text += f" {k}: {v:.2f}\n" | |
| obs_text += f"Health: {health_after.score:.2f}\n" | |
| obs_text += f"Fault fixed: {verification.fixed}\n" | |
| if verification.failures: | |
| obs_text += f"Unfixed: {', '.join(verification.failures[:3])}\n" | |
| if health_after.issues: | |
| obs_text += f"Remaining issues: {len(health_after.issues)}\n" | |
| logger.info("EPISODE DONE: resolved=%s fault_fixed=%s reward=%.2f health=%.2f", | |
| self._state.is_resolved, verification.fixed, reward, health_after.score) | |
| return NetOpsObservation( | |
| alert=self._scenario.alert, | |
| observation=obs_text, | |
| available_actions=[] if done else ALL_ACTIONS, | |
| steps_taken=self._step_count, | |
| max_steps=self._scenario.max_steps, | |
| difficulty=self._scenario.difficulty, | |
| done=done, | |
| reward=reward, | |
| ) | |
| def state(self) -> NetOpsState: | |
| return self._state | |
| def close(self) -> None: | |
| if self._injector: | |
| self._injector.undo_all() | |
| if self._net_mgr and self._net_mgr.running: | |
| self._net_mgr.stop() | |
| logger.info("Network stopped") | |
| # ---- Investigation handlers ---- | |
| def _handle_investigation(self, cmd: str, args: dict) -> str: | |
| as_filter = args.get("as_filter", None) | |
| if as_filter is not None: | |
| as_filter = int(as_filter) | |
| if cmd == "query_routing": | |
| return self._query_routing(args.get("router", "r1")) | |
| elif cmd == "query_traffic": | |
| return self._query_traffic(as_filter=as_filter) | |
| elif cmd == "query_device": | |
| return self._query_device(args.get("router", "r1")) | |
| elif cmd == "query_events": | |
| return self._query_events(as_filter=as_filter) | |
| elif cmd == "query_topology": | |
| return self._query_topology(as_filter=as_filter) | |
| elif cmd == "traceroute": | |
| return self._do_traceroute(args.get("src", "h1"), args.get("dst", "h5")) | |
| elif cmd == "ping": | |
| return self._do_ping(args.get("src", "h1"), args.get("dst", "h5")) | |
| return f"Unknown investigation command: {cmd}" | |
| def _query_routing(self, router_name: str) -> str: | |
| router = self._net_mgr.get_router(router_name) | |
| bgp = read_bgp_summary(router) | |
| ospf = read_ospf_neighbors(router) | |
| ospf_intf = read_ospf_interface(router) | |
| routes = read_routes(router) | |
| bgp_det = read_bgp_detail(router) | |
| return render_routing_view(router_name, bgp, ospf, ospf_intf, routes, | |
| bgp_detail=bgp_det) | |
| def _query_traffic(self, as_filter: int | None = None) -> str: | |
| all_intf = {} | |
| all_queues = {} | |
| for r in self._net_mgr.get_all_routers(): | |
| name = r.name | |
| if as_filter and router_to_asn(name) != as_filter: | |
| continue | |
| intfs = read_interfaces(r) | |
| all_intf[name] = intfs | |
| queues = {} | |
| for intf_data in intfs: | |
| intf_name = intf_data.get("ifname", "") | |
| if intf_name and intf_name != "lo": | |
| queues[intf_name] = read_queue_stats(r, intf_name) | |
| all_queues[name] = queues | |
| return render_traffic_view(all_intf, all_queues, as_filter=as_filter) | |
| def _query_device(self, router_name: str) -> str: | |
| router = self._net_mgr.get_router(router_name) | |
| intfs = read_interfaces(router) | |
| proto = read_protocol_counters(router) | |
| queues = {} | |
| for intf_data in intfs: | |
| intf_name = intf_data.get("ifname", "") | |
| if intf_name and intf_name != "lo": | |
| queues[intf_name] = read_queue_stats(router, intf_name) | |
| iptables_out = read_iptables(router) | |
| cpu = read_cpu_status(router) | |
| if hasattr(self._net_mgr, '_engine') and self._net_mgr._engine: | |
| sim_router = self._net_mgr._engine.topo.routers.get(router_name) | |
| if sim_router and sim_router.recent_cpu_spike: | |
| cpu["recent_cpu_spike"] = True | |
| return render_device_view(router_name, intfs, proto, queues, | |
| iptables=iptables_out, cpu=cpu) | |
| def _query_events(self, as_filter: int | None = None) -> str: | |
| snapshot = {} | |
| for r in self._net_mgr.get_all_routers(): | |
| snapshot[r.name] = read_all_router_telemetry(r) | |
| snapshot["_ts"] = time.time() | |
| self._event_snapshots.append(snapshot) | |
| return render_events_view(self._event_snapshots, as_filter=as_filter) | |
| def _query_topology(self, as_filter: int | None = None) -> str: | |
| all_bgp = {} | |
| all_ospf = {} | |
| all_intf = {} | |
| for r in self._net_mgr.get_all_routers(): | |
| name = r.name | |
| if as_filter and router_to_asn(name) != as_filter: | |
| continue | |
| all_bgp[name] = read_bgp_summary(r) | |
| all_ospf[name] = read_ospf_neighbors(r) | |
| all_intf[name] = read_interfaces(r) | |
| return render_topology_view(all_bgp, all_ospf, all_intf, as_filter=as_filter) | |
| def _do_traceroute(self, src: str, dst: str) -> str: | |
| raw = self._net_mgr.traceroute(src, dst) | |
| return render_traceroute_result(src, dst, raw) | |
| def _do_ping(self, src: str, dst: str) -> str: | |
| result = self._net_mgr.ping(src, dst) | |
| return render_ping_result(src, dst, result) | |
| # ---- Diagnosis handler ---- | |
| def _handle_diagnosis(self, args: dict) -> str: | |
| ft = args.get("fault_type", "unknown") | |
| comp = args.get("component", "unknown") | |
| expl = args.get("explanation", "") | |
| self._diagnosis = Diagnosis(fault_type=ft, component=comp, explanation=expl) | |
| self._state.diagnosis_submitted = True | |
| return ( | |
| f"Diagnosis recorded:\n" | |
| f" Fault type: {ft}\n" | |
| f" Component: {comp}\n" | |
| f" Explanation: {expl}\n" | |
| f"Proceed with remediation or submit more investigation queries." | |
| ) | |
| # ---- Remediation handlers ---- | |
| def _handle_remediation(self, cmd: str, args: dict) -> str: | |
| self._state.remediation_attempted = True | |
| result = self._execute_remediation(cmd, args) | |
| time.sleep(CONVERGENCE_WAIT) | |
| health_now = self._health.check_network_health() | |
| self._state.health_score = health_now.score | |
| return ( | |
| f"{result}\n\n" | |
| f"Network health after action: {health_now.score:.2f}\n" | |
| f"Issues: {len(health_now.issues)}" | |
| ) | |
| def _execute_remediation(self, cmd: str, args: dict) -> str: | |
| net = self._net_mgr | |
| if cmd == "restore_link": | |
| r1, r2 = args.get("router1", ""), args.get("router2", "") | |
| if not r1 or not r2: | |
| return "Error: restore_link requires router1 and router2" | |
| node1 = net.get_router(r1) | |
| node2 = net.get_router(r2) | |
| intf1 = net.find_link_interface(r1, r2) | |
| intf2 = net.find_link_interface(r2, r1) | |
| if intf1: | |
| node1.cmd(f"ip link set {getattr(intf1, 'name', intf1)} up") | |
| if intf2: | |
| node2.cmd(f"ip link set {getattr(intf2, 'name', intf2)} up") | |
| return f"Link {r1}<->{r2} restored (interfaces brought up)" | |
| elif cmd == "restart_daemon": | |
| router = args.get("router", "") | |
| daemon = args.get("daemon", "") | |
| if not router or not daemon: | |
| return "Error: restart_daemon requires router and daemon" | |
| node = net.get_router(router) | |
| pid = FaultInjector._find_daemon_pid(node, daemon) | |
| if pid: | |
| node.cmd(f"kill {pid}") | |
| time.sleep(1) | |
| node.cmd(f"/usr/lib/frr/{daemon}") | |
| return f"Daemon {daemon} restarted on {router}" | |
| elif cmd == "adjust_cost": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| cost = args.get("cost", 10) | |
| if not router or not intf: | |
| return "Error: adjust_cost requires router and interface" | |
| node = net.get_router(router) | |
| node.cmd(f'vtysh -c "conf t" -c "interface {intf}" -c "ip ospf cost {cost}"') | |
| return f"OSPF cost on {router}/{intf} set to {cost}" | |
| elif cmd == "rate_limit": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| bw = args.get("bandwidth", "10mbit") | |
| if not router or not intf: | |
| return "Error: rate_limit requires router and interface" | |
| node = net.get_router(router) | |
| node.cmd(f"tc qdisc replace dev {intf} root tbf rate {bw} burst 32kbit latency 50ms") | |
| return f"Rate limit {bw} applied to {router}/{intf}" | |
| elif cmd == "remove_tc": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| if not router or not intf: | |
| return "Error: remove_tc requires router and interface" | |
| node = net.get_router(router) | |
| node.cmd(f"tc qdisc del dev {intf} root 2>/dev/null") | |
| return f"TC rules removed from {router}/{intf}" | |
| elif cmd == "remove_iptables": | |
| router = args.get("router", "") | |
| if not router: | |
| return "Error: remove_iptables requires router" | |
| node = net.get_router(router) | |
| node.cmd("iptables -F") | |
| return f"iptables flushed on {router}" | |
| elif cmd == "restore_mtu": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| mtu = args.get("mtu", 1500) | |
| if not router or not intf: | |
| return "Error: restore_mtu requires router and interface" | |
| node = net.get_router(router) | |
| node.cmd(f"ip link set {intf} mtu {mtu}") | |
| return f"MTU on {router}/{intf} restored to {mtu}" | |
| elif cmd == "restore_ospf_timers": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| if not router or not intf: | |
| return "Error: restore_ospf_timers requires router and interface" | |
| node = net.get_router(router) | |
| node.cmd(f'vtysh -c "conf t" -c "interface {intf}" ' | |
| f'-c "ip ospf hello-interval 10" -c "ip ospf dead-interval 40"') | |
| return f"OSPF timers on {router}/{intf} restored to defaults (hello=10, dead=40)" | |
| elif cmd == "restore_ospf_area": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| if not router or not intf: | |
| return "Error: restore_ospf_area requires router and interface" | |
| node = net.get_router(router) | |
| ip_out = node.cmd(f"ip -4 addr show {intf}").strip() | |
| subnet = "" | |
| for line in ip_out.split("\n"): | |
| if "inet " in line: | |
| subnet = line.strip().split()[1] | |
| break | |
| if subnet: | |
| node.cmd(f'vtysh -c "conf t" -c "router ospf" -c "network {subnet} area 0.0.0.0"') | |
| return f"OSPF area on {router}/{intf} restored to area 0" | |
| elif cmd == "remove_route": | |
| router = args.get("router", "") | |
| prefix = args.get("prefix", "") | |
| if not router or not prefix: | |
| return "Error: remove_route requires router and prefix" | |
| node = net.get_router(router) | |
| node.cmd(f"ip route del {prefix} 2>/dev/null") | |
| node.cmd(f"ip route del blackhole {prefix} 2>/dev/null") | |
| return f"Route to {prefix} removed on {router}" | |
| elif cmd == "remove_bgp_config": | |
| router = args.get("router", "") | |
| config_cmd = args.get("config", "") | |
| if not router or not config_cmd: | |
| return "Error: remove_bgp_config requires router and config" | |
| node = net.get_router(router) | |
| node.cmd(f'vtysh -c "conf t" -c "{config_cmd}"') | |
| return f"BGP config applied on {router}: {config_cmd}" | |
| elif cmd == "kill_traffic": | |
| router = args.get("router", "") | |
| if not router: | |
| return "Error: kill_traffic requires router" | |
| node = net.get_router(router) | |
| node.cmd("pkill -f iperf 2>/dev/null") | |
| return f"Background traffic killed on {router}" | |
| elif cmd == "remove_cpu_hog": | |
| router = args.get("router", "") | |
| if not router: | |
| return "Error: remove_cpu_hog requires router" | |
| node = net.get_router(router) | |
| node.cmd("pkill -f 'dd if=/dev/zero' 2>/dev/null") | |
| node.cmd("pkill -f 'yes' 2>/dev/null") | |
| return f"CPU hog processes killed on {router}" | |
| elif cmd == "restore_all_intfs": | |
| router = args.get("router", "") | |
| if not router: | |
| return "Error: restore_all_intfs requires router" | |
| node = net.get_router(router) | |
| brought_up = [] | |
| for intf_proxy in node.intfList(): | |
| iname = getattr(intf_proxy, 'name', intf_proxy) | |
| if iname != "lo": | |
| node.cmd(f"ip link set {iname} up") | |
| brought_up.append(iname) | |
| return f"All interfaces on {router} brought up: {', '.join(brought_up)}" | |
| elif cmd == "restore_drain": | |
| router = args.get("router", "") | |
| if not router: | |
| return "Error: restore_drain requires router" | |
| node = net.get_router(router) | |
| for intf_proxy in node.intfList(): | |
| iname = getattr(intf_proxy, 'name', intf_proxy) | |
| if iname != "lo": | |
| node.cmd(f'vtysh -c "conf t" -c "interface {iname}" -c "ip ospf cost 10"') | |
| return f"All OSPF costs on {router} restored to 10" | |
| elif cmd == "remove_bgp_flood": | |
| router = args.get("router", "") | |
| num = int(args.get("num_prefixes", 50)) | |
| if not router: | |
| return "Error: remove_bgp_flood requires router" | |
| node = net.get_router(router) | |
| asn = self._injector._router_asn(router) | |
| for i in range(num): | |
| prefix = f"10.{100 + i // 256}.{i % 256}.0/24" | |
| node.cmd( | |
| f'vtysh -c "conf t" -c "router bgp {asn}" ' | |
| f'-c "no network {prefix}" -c "end"' | |
| ) | |
| node.cmd(f"ip route del blackhole {prefix} 2>/dev/null") | |
| return f"Removed {num} flood prefixes from {router}" | |
| elif cmd == "stop_flapping": | |
| router = args.get("router", "") | |
| intf = args.get("interface", "") | |
| if not router or not intf: | |
| return "Error: stop_flapping requires router and interface" | |
| node = net.get_router(router) | |
| node.cmd(f"pkill -f 'ip link set {intf}' 2>/dev/null") | |
| time.sleep(0.5) | |
| node.cmd(f"ip link set {intf} up") | |
| return f"Flapping stopped on {router}/{intf}, interface brought up" | |
| elif cmd == "noop": | |
| return "No action taken." | |
| return f"Unknown remediation command: {cmd}" | |
| def _handle_confirm_fix(self) -> str: | |
| """Agent asserts the fault is fixed. Triggers verification and ends the episode.""" | |
| return "Fix confirmed by agent. Verifying..." | |