network-infra-utility 0.6.0 → 0.8.3

data/service/simlab/lib/simlab_router.rb

@@ -0,0 +1,330 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+# 虚拟路由器：组合 RIB + LpmTrie + StaticRoute + RIP/OSPF/BGP 实例 + 接口表。
+#
+# 每个协议实例是 support 组件的薄封装，只加邻居关系和报文收发口。
+# 对外暴露 receive_packet、announce、install_route。
+# 协议实例按接口绑定邻居。
+#
+# 用法：
+#   router = Router.new(name: "R1", interfaces: {"Gi0/0" => "10.0.0.1/24"})
+#   router.enable_ospf(router_id: "1.1.1.1")
+#   router.enable_rip
+#   router.receive_packet(port: "Gi0/0", frame: frame)
+#   router.rib_dump
+
+require_relative '../../../support/routing/rib'
+require_relative '../../../support/routing/lpm_trie'
+require_relative '../../../support/routing/static_route'
+require_relative '../../../support/routing/rip'
+require_relative '../../../support/routing/ospf'
+require_relative '../../../support/routing/bgp'
+require_relative '../../../support/basic/packet'
+
+module NetworkInfraUtility
+  module SimLab
+    module Device
+      class Router
+        attr_reader :name, :interfaces, :rib, :static_route
+        attr_reader :rip, :ospf, :bgp, :capabilities
+
+        def initialize(name:, interfaces: {}, **opts)
+          @name          = name
+          @interfaces    = {}  # port => {ip:, prefix_len:, status:}
+          @rib           = RIB.new
+          @static_route  = StaticRoute.new
+          @capabilities  = Set.new
+          @protocols     = {}
+          @current_time  = 0
+
+          # 初始化接口
+          interfaces.each do |port, cidr|
+            add_interface(port, cidr)
+          end
+        end
+
+        # 添加接口。
+        def add_interface(port, cidr)
+          ip_str, mask_str = cidr.split('/')
+          prefix_len = mask_str.to_i
+          @interfaces[port] = {
+            ip: ip_str,
+            prefix_len: prefix_len,
+            cidr: cidr,
+            status: :up
+          }
+
+          # 安装直连路由
+          network = compute_network(cidr)
+          @rib.add(
+            prefix: network,
+            next_hop: '0.0.0.0',
+            ifindex: port,
+            protocol: :connected,
+            metric: 0
+          )
+        end
+
+        # 接口 down。
+        def interface_down(port)
+          return unless @interfaces[port]
+          @interfaces[port][:status] = :down
+
+          # 移除直连路由
+          network = compute_network(@interfaces[port][:cidr])
+          @rib.delete(network, protocol: :connected)
+
+          # 通知协议
+          @protocols.each_value { |p| p.respond_to?(:remove_neighbor_by_port) && p.remove_neighbor_by_port(port) }
+        end
+
+        # 接口 up。
+        def interface_up(port)
+          return unless @interfaces[port]
+          @interfaces[port][:status] = :up
+
+          # 恢复直连路由
+          network = compute_network(@interfaces[port][:cidr])
+          @rib.add(
+            prefix: network,
+            next_hop: '0.0.0.0',
+            ifindex: port,
+            protocol: :connected,
+            metric: 0
+          )
+        end
+
+        # 启用 OSPF。
+        def enable_ospf(router_id:, area: "0.0.0.0")
+          @ospf = OSPF.new(router_id: router_id, rib: @rib, area: area)
+          @protocols[:ospf] = @ospf
+          @capabilities.add(:ospf)
+
+          # 注册直连网络
+          @interfaces.each do |port, info|
+            next if info[:status] == :down
+            network = compute_network(info[:cidr])
+            @ospf.add_connected(network, port)
+          end
+
+          @ospf
+        end
+
+        # 添加 OSPF 邻居。
+        def add_ospf_neighbor(neighbor_rid, port:, cost: 10)
+          @ospf&.add_neighbor(neighbor_rid, port: port, cost: cost)
+        end
+
+        # 启用 RIP。
+        def enable_rip(split_horizon: true, poison_reverse: false)
+          @rip = RIP.new(
+            router_id: @name,
+            rib: @rib,
+            split_horizon: split_horizon,
+            poison_reverse: poison_reverse
+          )
+          @protocols[:rip] = @rip
+          @capabilities.add(:rip)
+
+          # 注册直连网络
+          @interfaces.each do |port, info|
+            next if info[:status] == :down
+            network = compute_network(info[:cidr])
+            @rip.add_connected(network, port)
+          end
+
+          @rip
+        end
+
+        # 添加 RIP 邻居。
+        def add_rip_neighbor(neighbor_name, port:, metric: 1)
+          @rip&.add_neighbor(neighbor_name, port: port, metric: metric)
+        end
+
+        # 启用 BGP。
+        def enable_bgp(as:, router_id: nil)
+          @bgp = BGP.new(as: as, router_id: router_id || @interfaces.values.first&.dig(:ip), rib: @rib)
+          @protocols[:bgp] = @bgp
+          @capabilities.add(:bgp)
+          @bgp
+        end
+
+        # 添加 BGP 邻居。
+        def add_bgp_peer(addr, remote_as:, port: nil)
+          @bgp&.add_peer(addr, remote_as: remote_as, port: port)
+        end
+
+        # BGP 宣告网络。
+        def announce_network(prefix, **opts)
+          @bgp&.announce_network(prefix, **opts)
+        end
+
+        # 安装静态路由。
+        def install_static_route(prefix, next_hop, **opts)
+          @static_route.install(prefix, next_hop, **opts)
+          @rib.add(
+            prefix: prefix,
+            next_hop: next_hop,
+            ifindex: opts[:ifindex],
+            protocol: :static,
+            metric: opts[:distance] || 1
+          )
+        end
+
+        # 接收报文。
+        # port: 入接口
+        # payload: EthernetFrame 或协议消息
+        def receive_packet(port:, payload:)
+          return unless @interfaces[port] && @interfaces[port][:status] == :up
+
+          case payload
+          when EthernetFrame
+            handle_frame(port, payload)
+          when IPPacket
+            handle_ip_packet(port, payload)
+          when RIPUpdate
+            @rip&.receive_update(from: payload.from, port: port, routes: payload.routes)
+          when LSA
+            @ospf&.receive_lsa(port: port, lsa: payload)
+          when BGPUpdate
+            @bgp&.receive_update(from: payload.from, **{ nlri: payload.nlri, withdrawn: payload.withdrawn, attributes: payload.attributes })
+          end
+        end
+
+        # 生成要发送的协议消息。
+        # 返回 [{port:, payload:}] 列表
+        def announce
+          messages = []
+
+          if @rip
+            @rip.advertise_all.each do |neighbor, routes|
+              next if routes.empty?
+              port = @rip.neighbors.dig(neighbor, :port)
+              messages << { port: port, payload: RIPUpdate.new(from: @name, routes: routes) } if port
+            end
+          end
+
+          if @ospf && @ospf.my_lsa
+            @ospf.neighbors.each do |rid, info|
+              messages << { port: info[:port], payload: @ospf.my_lsa }
+            end
+          end
+
+          if @bgp
+            @bgp.peers.each do |addr, info|
+              next if info[:state] != :established
+              adv = @bgp.advertise(addr)
+              next unless adv
+              messages << {
+                port: info[:port],
+                payload: BGPUpdate.new(
+                  from: addr,
+                  nlri: adv[:nlri],
+                  withdrawn: [],
+                  attributes: adv[:attributes]
+                )
+              }
+            end
+          end
+
+          messages
+        end
+
+        # 由 engine 驱动的时钟推进。
+        def tick(now:)
+          @current_time = now
+          @protocols.each_value { |p| p.tick(now: now) if p.respond_to?(:tick) }
+        end
+
+        # 转发 IP 报文。
+        # 返回 [{port:, payload:}] 或 nil（丢弃）。
+        def forward_ip(ip_packet)
+          return nil if ip_packet.expired?
+
+          route = @rib.lookup(ip_packet.dst)
+          return nil unless route  # 无路由，丢弃
+
+          ip_packet.decrement_ttl
+          return nil if ip_packet.expired?
+
+          [{ port: route.ifindex, payload: ip_packet }]
+        end
+
+        # RIB 快照。
+        def rib_dump
+          @rib.to_h
+        end
+
+        # 协议表快照。
+        def protocol_dump
+          result = {}
+          result[:rip]  = @rip&.to_h
+          result[:ospf] = @ospf&.lsdb_dump
+          result[:bgp]  = @bgp&.to_h
+          result
+        end
+
+        # 能力列表。
+        def capable?(cap)
+          @capabilities.include?(cap)
+        end
+
+        # 设备信息。
+        def to_h
+          {
+            name: @name,
+            type: :router,
+            interfaces: @interfaces,
+            capabilities: @capabilities.to_a,
+            rib_size: @rib.size
+          }
+        end
+
+        # 构建（初始化后调用）。
+        def build
+          # 触发初始 LSA/路由通告
+          @protocols.each_value do |p|
+            p.originate_lsa if p.is_a?(OSPF)
+          end
+        end
+
+        private
+
+        def handle_frame(port, frame)
+          # 如果是 IP 报文，执行路由转发
+          if frame.ip?
+            handle_ip_packet(port, frame.payload)
+          elsif frame.arp?
+            # 简化：不处理 ARP
+          end
+        end
+
+        def handle_ip_packet(port, packet)
+          # 检查是否是给本设备的
+          if is_local_address?(packet.dst)
+            # 本地接收，不转发
+            return
+          end
+
+          # 转发
+          forward_ip(packet)
+        end
+
+        def is_local_address?(ip)
+          @interfaces.each_value do |info|
+            return true if info[:ip] == ip.to_s
+          end
+          false
+        end
+
+        def compute_network(cidr)
+          ip_str, mask_str = cidr.split('/')
+          ip = IPv4.new(ip_str)
+          mask = IPv4Mask.number(mask_str.to_i)
+          ip.network_with(mask).to_s + "/#{mask_str}"
+        end
+      end
+    end
+  end
+end

data/service/simlab/lib/simlab_scenario.rb

@@ -0,0 +1,200 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+# 场景加载器：YAML DSL 描述拓扑 + 协议启用 + 流量计划，输出可执行场景对象。
+#
+# YAML 格式示例：
+#   ---
+#   topology:
+#     routers:
+#       R1:
+#         interfaces:
+#           Gi0/0: 10.0.0.1/24
+#           Gi0/1: 10.0.1.1/24
+#         ospf:
+#           router_id: 1.1.1.1
+#       R2:
+#         interfaces:
+#           Gi0/0: 10.0.0.2/24
+#           Gi0/1: 10.0.2.1/24
+#         ospf:
+#           router_id: 2.2.2.2
+#     switches:
+#       S1:
+#         ports: [Gi0/1, Gi0/2, Gi0/3]
+#     links:
+#       - [R1:Gi0/0, R2:Gi0/0, {bandwidth: 100000, delay: 10}]
+#       - [R1:Gi0/1, S1:Gi0/1]
+#     hosts:
+#       H1:
+#         ip: 10.0.2.2/24
+#         gateway: 10.0.2.1
+#   traffic:
+#     - type: ping
+#       from: R1
+#       to: 10.0.0.2
+#       at: 10
+#     - type: link_down
+#       device: R1
+#       port: Gi0/0
+#       at: 50
+#   expect:
+#     - rib_converged: [R1, R2]
+#     - no_loss: true
+
+require 'yaml'
+
+module NetworkInfraUtility
+  module SimLab
+    class Scenario
+      attr_reader :config
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      # 从 YAML 文件加载。
+      def self.load(file_path)
+        content = File.read(file_path)
+        config = YAML.safe_load(content, permitted_classes: [Symbol])
+        new(config)
+      end
+
+      # 从 Hash 构建。
+      def self.from_hash(config)
+        new(config)
+      end
+
+      # 将场景应用到仿真对象。
+      def apply_to(simulation)
+        build_topology(simulation)
+        build_traffic(simulation)
+        build_expectations(simulation)
+      end
+
+      private
+
+      def build_topology(simulation)
+        topo = simulation.topology
+
+        # 路由器
+        config.dig('topology', 'routers')&.each do |name, props|
+          router = topo.add_router(name, interfaces: props['interfaces'] || {})
+
+          if props['ospf']
+            router.enable_ospf(router_id: props['ospf']['router_id'])
+          end
+
+          if props['rip']
+            router.enable_rip
+          end
+
+          if props['bgp']
+            router.enable_bgp(as: props['bgp']['as'], router_id: props['bgp']['router_id'])
+          end
+
+          # 静态路由
+          props['static_routes']&.each do |sr|
+            router.install_static_route(sr['prefix'], sr['next_hop'])
+          end
+        end
+
+        # 交换机
+        config.dig('topology', 'switches')&.each do |name, props|
+          sw = topo.add_switch(name, ports: props['ports'] || [])
+
+          if props['access_ports']
+            props['access_ports'].each do |port, pvid|
+              sw.add_access_port(port, pvid: pvid)
+            end
+          end
+
+          if props['trunk_ports']
+            props['trunk_ports'].each do |port, cfg|
+              sw.add_trunk_port(port, allowed: cfg['allowed'], native: cfg['native'])
+            end
+          end
+
+          if props['stp']
+            sw.enable_stp(bridge_id: props['stp']['bridge_id'])
+          end
+        end
+
+        # 主机
+        config.dig('topology', 'hosts')&.each do |name, props|
+          topo.add_host(name, ip: props['ip'], gateway: props['gateway'])
+        end
+
+        # 链路
+        config.dig('topology', 'links')&.each do |link|
+          ep_a, ep_b, opts = link
+          opts ||= {}
+          topo.add_link(ep_a, ep_b,
+            bandwidth: opts['bandwidth'] || 1_000_000,
+            delay: opts['delay'] || 0,
+            cost: opts['cost'] || 10
+          )
+        end
+
+        # 协议邻居配置
+        config.dig('protocols')&.each do |proto_name, proto_cfg|
+          case proto_name
+          when 'ospf'
+            proto_cfg['neighbors']&.each do |nb|
+              router = topo.devices[nb['router']]
+              next unless router && router.capable?(:ospf)
+              router.add_ospf_neighbor(nb['neighbor_rid'], port: nb['port'], cost: nb['cost'] || 10)
+            end
+          when 'rip'
+            proto_cfg['neighbors']&.each do |nb|
+              router = topo.devices[nb['router']]
+              next unless router && router.capable?(:rip)
+              router.add_rip_neighbor(nb['neighbor'], port: nb['port'])
+            end
+          when 'bgp'
+            proto_cfg['peers']&.each do |peer|
+              router = topo.devices[peer['router']]
+              next unless router && router.capable?(:bgp)
+              router.add_bgp_peer(peer['addr'], remote_as: peer['remote_as'], port: peer['port'])
+            end
+          end
+        end
+      end
+
+      def build_traffic(simulation)
+        traffic = Traffic.new
+
+        config['traffic']&.each do |event|
+          case event['type']
+          when 'ping'
+            traffic.ping(simulation.engine, simulation.topology,
+              from: event['from'], to: event['to'],
+              at: event['at'], count: event['count'] || 1)
+          when 'link_down'
+            traffic.link_down(simulation.engine, simulation.topology,
+              event['device'], event['port'], at: event['at'])
+          when 'link_up'
+            traffic.link_up(simulation.engine, simulation.topology,
+              event['device'], event['port'], at: event['at'])
+          when 'node_down'
+            traffic.node_down(simulation.engine, simulation.topology,
+              event['device'], at: event['at'])
+          end
+        end
+
+        # 周期性协议交换
+        interval = config.dig('simulation', 'protocol_interval') || 10
+        until_time = config.dig('simulation', 'until') || 100
+        traffic.periodic_exchange(simulation.engine, simulation.topology,
+          interval: interval, until_time: until_time)
+      end
+
+      def build_expectations(simulation)
+        # 预期断言（简化：记录到 simulation）
+        @expectations = config['expect'] || []
+      end
+
+      attr_reader :expectations
+    end
+  end
+end

data/service/simlab/lib/simlab_switch.rb

@@ -0,0 +1,182 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+# 虚拟交换机：组合 MACTable + Forward + VLAN + STP。
+#
+# 数据平面逐帧处理流水线：
+# 入端口 → VLAN 处理 → MAC 学习 → STP 状态检查 → 转发决策
+#
+# 与 router 的区别：router 跑控制平面协议，switch 默认只转发。
+#
+# 用法：
+#   sw = Switch.new(name: "S1", ports: ["Gi0/1", "Gi0/2", "Gi0/3"])
+#   sw.add_access_port("Gi0/1", pvid: 10)
+#   sw.add_trunk_port("Gi0/24", allowed: [10, 20], native: 1)
+#   sw.receive_frame(port: "Gi0/1", frame: frame)
+
+require_relative '../../../support/switching/mac_table'
+require_relative '../../../support/switching/frame_forward'
+require_relative '../../../support/switching/vlan'
+require_relative '../../../support/switching/stp'
+require_relative '../../../support/basic/packet'
+
+module NetworkInfraUtility
+  module SimLab
+    module Device
+      class Switch
+        attr_reader :name, :ports, :mac_table, :vlan, :stp, :forward
+
+        def initialize(name:, ports: [], **opts)
+          @name      = name
+          @ports     = {}  # port_name => {status:}
+          @mac_table = MACTable.new(aging_time: opts[:aging_time] || 300)
+          @forward   = Forward.new
+          @vlan      = VLAN.new
+          @stp       = nil
+          @current_time = 0
+
+          ports.each { |p| add_port(p) }
+        end
+
+        # 添加端口。
+        def add_port(port)
+          @ports[port] = { status: :up }
+        end
+
+        # 端口 down。
+        def port_down(port)
+          return unless @ports[port]
+          @ports[port][:status] = :down
+          @mac_table.remove_by_port(port)
+          @stp&.remove_port(port) if @stp
+        end
+
+        # 端口 up。
+        def port_up(port)
+          return unless @ports[port]
+          @ports[port][:status] = :up
+          @stp&.add_port(port) if @stp
+        end
+
+        # 添加 access 端口。
+        def add_access_port(port, pvid:)
+          add_port(port) unless @ports[port]
+          @vlan.add_access_port(port, pvid: pvid)
+        end
+
+        # 添加 trunk 端口。
+        def add_trunk_port(port, allowed:, native: nil)
+          add_port(port) unless @ports[port]
+          @vlan.add_trunk_port(port, allowed: allowed, native: native)
+        end
+
+        # 启用 STP。
+        def enable_stp(bridge_id:, bridge_priority: STP::DEFAULT_PRIORITY)
+          @stp = STP.new(bridge_id: bridge_id, bridge_priority: bridge_priority)
+          @ports.each_key { |p| @stp.add_port(p, cost: 20000) }
+          @stp
+        end
+
+        # 添加 STP 端口。
+        def add_stp_port(port, cost: 20000)
+          @stp&.add_port(port, cost: cost)
+        end
+
+        # 接收帧。
+        # port: 入端口
+        # frame: EthernetFrame
+        # 返回 [{port:, frame:}] 列表（需要从哪些端口发出什么帧）
+        def receive_frame(port:, frame:)
+          return [] unless @ports[port] && @ports[port][:status] == :up
+
+          # STP 状态检查
+          if @stp
+            port_state = @stp.states[port]
+            # Blocking 状态不处理数据帧
+            return [] if port_state == :blocking
+          end
+
+          # VLAN 入口处理
+          tagged_frame = @vlan.ingress(frame, port: port)
+          return [] unless tagged_frame  # VLAN 检查失败，丢弃
+
+          # MAC 学习
+          @mac_table.learn(frame.src_mac, port: port, now: @current_time)
+
+          # 获取同 VLAN 端口列表
+          vlan_id = tagged_frame.vlan_id
+          vlan_ports = @vlan.ports_for_vlan(vlan_id)
+
+          # 转发决策
+          decision = @forward.decide(
+            tagged_frame,
+            in_port: port,
+            mac_table: @mac_table,
+            vlan_ports: vlan_ports
+          )
+
+          case decision.action
+          when :forward, :flood
+            decision.ports.map do |out_port|
+              next unless @ports[out_port] && @ports[out_port][:status] == :up
+              # STP 检查：非指定端口/根端口不转发（简化：只检查 forwarding 状态）
+              if @stp && @stp.states[out_port] != :forwarding
+                next
+              end
+
+              # VLAN 出口处理
+              out_frame = @vlan.egress(tagged_frame, port: out_port)
+              next unless out_frame
+
+              { port: out_port, frame: out_frame }
+            end.compact
+          when :drop
+            []
+          end
+        end
+
+        # 由 engine 驱动的时钟推进。
+        def tick(now:)
+          @current_time = now
+
+          # MAC 表老化
+          @mac_table.age_out(now: now)
+
+          # STP 状态机推进
+          @stp&.tick(now: now)
+        end
+
+        # MAC 表快照。
+        def mac_dump
+          @mac_table.to_h
+        end
+
+        # VLAN 配置快照。
+        def vlan_dump
+          @vlan.to_h
+        end
+
+        # STP 快照。
+        def stp_dump
+          @stp&.to_h
+        end
+
+        # 设备信息。
+        def to_h
+          {
+            name: @name,
+            type: :switch,
+            ports: @ports.keys,
+            mac_entries: @mac_table.size,
+            stp_enabled: !@stp.nil?
+          }
+        end
+
+        # 构建。
+        def build
+          @stp&.recompute_roles
+        end
+      end
+    end
+  end
+end