network-infra-utility 0.6.0 → 0.8.3

data/service/geoquery/local.rb

@@ -0,0 +1,151 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require_relative "normalize"
+
+module GeoQuery
+  # ------------------------------------------------------------------
+  # 本地查询客户端 — 向运行中的 geo-api 服务 (geo-get 的数据源) 查询
+  # ------------------------------------------------------------------
+  # 一次拉取 /geo/country /geo/city /geo/asn 三接口:
+  #   - lookup    归一化为统一 schema (与 OnlineClient 同构, 供 ngeo 编排)
+  #   - fetch_raw 返回各接口原始响应 (bin/geo-get 的底座, 保持其输出契约)
+  # geo-api 未启动不算错误, state 标记 unavailable, 由上层 (ngeo) 决定
+  # 是否回退互联网。
+  #
+  # 状态映射 (state):
+  #   ok           三接口至少一个有数据
+  #   empty        三接口均 404 (IP 不在本地库范围)
+  #   unavailable  geo-api 服务不可达 (未启动/端口不对)
+  #   invalid      IP 参数不合法
+  class LocalClient
+    DEFAULT_BASE = "http://127.0.0.1:9292"
+    TIMEOUT = 15
+    ENDPOINTS = %i[country city asn].freeze
+
+    attr_reader :base
+
+    def initialize(base: DEFAULT_BASE, timeout: TIMEOUT)
+      @base = base.chomp("/")
+      @timeout = timeout
+    end
+
+    # 返回统一 schema (与 OnlineClient 同构):
+    #   { "ip", "state", "message", "country", "province", "city",
+    #     "isp", "asn", "asn_org", "network", "usage", "source", "ts" }
+    def lookup(ip)
+      unless valid_ip?(ip)
+        return base(ip, "invalid", "IP 不合法")
+      end
+
+      raw = fetch_raw(ip)
+      return base(ip, "unavailable", "geo-api 服务不可达 (#@base)") if raw == :unreachable
+
+      if raw.values.compact.empty?
+        return base(ip, "empty", "本地库无该 IP 归属数据")
+      end
+
+      compose(ip, raw)
+    end
+
+    # 原始接口查询 (bin/geo-get 底座):
+    #   endpoints: ENDPOINTS 的子集, 默认三接口齐查
+    # 返回:
+    #   Hash        { :country => body|nil, :city => body|nil, :asn => body|nil }
+    #               (仅含请求的接口; 404/400/非 200 → nil)
+    #   :unreachable geo-api 服务不可达 (连接失败/超时)
+    def fetch_raw(ip, endpoints: ENDPOINTS)
+      result = {}
+      endpoints.each do |ep|
+        r = fetch_endpoint(ep, ip.to_s)
+        return :unreachable if r == :unavailable
+        result[ep] = r.is_a?(Hash) ? r : nil
+      end
+      result
+    end
+
+    private
+
+    def base(ip, state, message = "")
+      {
+        "ip" => ip, "state" => state, "message" => message,
+        "country" => "", "province" => "", "city" => "",
+        "isp" => "", "asn" => "", "asn_org" => "", "network" => "",
+        "usage" => "", "source" => "geo-get(geo-api)",
+      }
+    end
+
+    # 单接口查询: 200 → body(Hash); 404 → nil; 400 → :bad;
+    # 连接失败 → :unavailable (调用方遇之立即终止, 不再请求其余接口)
+    def fetch_endpoint(endpoint, ip)
+      uri = URI("#{@base}/geo/#{endpoint}?addr=#{URI.encode_www_form_component(ip)}")
+      res = Net::HTTP.get_response(uri)
+      case res.code.to_i
+      when 200 then JSON.parse(res.body)
+      when 404 then nil
+      when 400 then :bad
+      else nil
+      end
+    rescue JSON::ParserError
+      nil
+    rescue => e
+      @last_error = "#{e.class}: #{e.message}"
+      :unavailable
+    end
+
+    # 三接口数据归一化为统一 schema (raw: fetch_raw 的结果)
+    def compose(ip, raw)
+      city     = raw[:city]
+      country  = raw[:country]
+      asn      = raw[:asn]
+      g_city   = city.is_a?(Hash)    ? (city["geoname"] || {})        : {}
+      g_country = country.is_a?(Hash) ? (country["geoname"] ||
+                                        country["registered_country"] || {}) : {}
+      rc_city  = city.is_a?(Hash)    ? (city["registered_country"] || {}) : {}
+
+      country_name = g_city["country_name"].to_s
+      country_name = g_country["country_name"].to_s if country_name.empty?
+      country_name = rc_city["country_name"].to_s if country_name.empty?
+
+      province = g_city["subdivision_1_name"].to_s
+      city_name = g_city["city_namezh"].to_s
+      city_name = g_city["city_name"].to_s if city_name.empty?
+
+      asn_num = asn.is_a?(Hash) ? asn["autonomous_system_number"].to_s : ""
+      asn_org = asn.is_a?(Hash) ? asn["autonomous_system_organization"].to_s : ""
+
+      network = [city, country, asn].map { |r| r.is_a?(Hash) ? r["network"].to_s : "" }
+                                    .find { |n| !n.empty? }.to_s
+
+      {
+        "ip" => ip,
+        "state" => "ok",
+        "message" => "",
+        "country" => country_name,
+        "province" => province,
+        "city" => city_name,
+        "isp" => Normalize.isp_from_asn(asn_org),
+        "asn" => asn_num,
+        "asn_org" => asn_org,
+        "network" => network,
+        "usage" => Normalize.usage_from_asn(asn_org),
+        "source" => "geo-get(geo-api)",
+        "ts" => Time.now.to_i,
+      }
+    end
+
+    def valid_ip?(ip)
+      ip = ip.to_s.strip
+      return false if ip.empty?
+      if ip.include?(":")
+        ip.match?(/\A[0-9A-Fa-f:]+\z/) && ip.count(":") >= 2
+      else
+        ip.match?(/\A\d{1,3}(\.\d{1,3}){3}\z/) &&
+          ip.split(".").all? { |o| o.to_i < 256 }
+      end
+    end
+  end
+end

data/service/geoquery/merge.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "normalize"
+
+module GeoQuery
+  # ------------------------------------------------------------------
+  # 字段级合并 — 按顺位折叠: 先查的源 (base) 与后查的源 (supp) 结果叠加
+  # ------------------------------------------------------------------
+  # 综合两方准确字段得出最终结果, 重点字段: 省 (Province) / 城市 (City) /
+  # 用途 (IDC、云)。择优原则:
+  #
+  #   country / province / city / asn / asn_org : base 优先, base 空取 supp
+  #     (GeoLite2 网段级数据有值时可信度高; 实践中本地省市缺失率高,
+  #      由 ip-api.com / GEO_CACHE 补全 — 对应 ip_geo_lookup.py 的补全策略)
+  #   network : base 优先, base 空取 supp (网段 CIDR 谁有取谁;
+  #     互联网源恒为空, 实际补给来自本地库与 GEO_CACHE 缓存)
+  #   isp     : 按合并后的 asn_org 重新归一化
+  #   usage   : 两方组织名综合推断, 取第一个识别出具体用途者 (base 优先)
+  module Merge
+    module_function
+
+    FIELDS = %w[country province city asn asn_org].freeze
+
+    # base / supp 为统一 schema 的 Hash (local/online 或任意两源折叠),
+    # 返回合并后的字段 Hash (不含 ip/state/message/source/sources, 由上层组装)
+    def fields(base, supp)
+      base ||= {}
+      supp ||= {}
+
+      merged = {}
+      FIELDS.each do |f|
+        merged[f] = nz(base[f]).empty? ? nz(supp[f]) : nz(base[f])
+      end
+      # 网段: base 优先, 空取 supp (互联网源无网段, 缓存/本地有)
+      merged["network"] = nz(base["network"]).empty? ? nz(supp["network"]) : nz(base["network"])
+
+      # 运营商: 用合并后的组织名重新归一化 (长名 → 简称)
+      merged["isp"] = Normalize.isp_from_asn(merged["asn_org"])
+
+      # 用途: 两方组织名综合推断
+      merged["usage"] = Normalize.usage_of(base["asn_org"], supp["asn_org"],
+                                           base["isp"], supp["isp"])
+
+      merged
+    end
+
+    def nz(v)
+      v.nil? ? "" : v.to_s
+    end
+  end
+end

data/service/geoquery/normalize.rb

@@ -0,0 +1,102 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+# GeoQuery — IP 归属综合查询服务 (本地 geo-api + 互联网 ip-api.com)
+#
+# 命令行入口: bin/gen-get (纯互联网) / bin/ngeo-get (本地+互联网综合)
+# 详见同目录 GeoQuery.md。
+module GeoQuery
+  # ------------------------------------------------------------------
+  # 公共: IP 合法性校验 (含 ":" 按 IPv6, 否则按 IPv4)
+  # ------------------------------------------------------------------
+  module_function
+
+  def valid_ip?(ip)
+    ip = ip.to_s.strip
+    return false if ip.empty?
+    if ip.include?(":")
+      ip.match?(/\A[0-9A-Fa-f:]+\z/) && ip.count(":") >= 2
+    else
+      ip.match?(/\A\d{1,3}(\.\d{1,3}){3}\z/) &&
+        ip.split(".").all? { |o| o.to_i < 256 }
+    end
+  end
+
+  # ------------------------------------------------------------------
+  # 归一化: 运营商 / 用途
+  # ------------------------------------------------------------------
+  # 移植自 ip_geo_lookup.py 的 _isp_from_asn, 并扩展用途 (usage) 推断:
+  #   usage 值域: 云 / IDC / CDN / 教育网 / 运营商 / 企业 / 未知
+  module Normalize
+    module_function
+
+    # ASN 组织名 → 运营商/机构简称 (中文优先; /x 允许多行书写)
+    ISP_RULES = [
+      # 三大运营商
+      [/chinanet|china[\s-]?telecom|chinatelecom|电信/ix,       "电信"],
+      [/china[\s-]?unicom|unicom|联通/ix,                       "联通"],
+      [/china[\s-]?mobile|移动|(?:^|\b)cmcc\b/ix,               "移动"],
+      [/china[\s-]?radio(?:\s|&)?tv|crtc|广电/ix,                "广电"],
+      # 教育 / 鹏博士
+      [/cernet|教育/ix,                                          "教育网"],
+      [/dr[\s.]?peng|鹏博士|great\s?wall\s?broadband/ix,        "鹏博士"],
+      # 云厂商 (先于企业判定)
+      [/tencent/ix,                                              "腾讯云"],
+      [/alibaba|aliyun/ix,                                       "阿里云"],
+      [/huawei/ix,                                               "华为云"],
+      [/baidu/ix,                                                "百度云"],
+      [/jd[\s-]?cloud|jingdong|京东/ix,                          "京东云"],
+      [/volcengine|bytedance|字节|火山/ix,                        "火山引擎"],
+      [/ucloud/ix,                                               "UCloud"],
+      [/kingsoft|金山/ix,                                        "金山云"],
+      [/(?:^|\b)aws\b|amazon/ix,                                 "AWS"],
+      [/microsoft|azure/ix,                                      "Azure"],
+      [/(?:^|\b)gcp\b|google\s?cloud|google\s?llc|(?:^|\b)google\b/ix,    "谷歌云"],
+      [/oracle/ix,                                               "Oracle云"],
+      # CDN
+      [/cloudflare/ix,                                           "Cloudflare"],
+      [/akamai/ix,                                               "Akamai"],
+      [/fastly/ix,                                               "Fastly"],
+      [/wangsu|网宿|chinacache/ix,                               "网宿CDN"],
+    ].freeze
+
+    # ASN 组织名 → 用途类别
+    # (正则加 /x: 多行书写时忽略模式空白, 行首缩进不参与匹配)
+    USAGE_RULES = [
+      [/tencent|alibaba|aliyun|huawei|baidu|jd[\s-]?cloud|jingdong|京东|
+        volcengine|bytedance|字节|火山|ucloud|kingsoft|金山|
+        (?:^|\b)aws\b|amazon|microsoft|azure|(?:^|\b)gcp\b|google|oracle/ix, "云"],
+      [/idc|data[\s-]?cent|数据中心/ix,                                      "IDC"],
+      [/cloudflare|akamai|fastly|wangsu|网宿|chinacache|cdn/ix,              "CDN"],
+      [/cernet|教育/ix,                                                       "教育网"],
+      [/chinanet|china[\s-]?telecom|chinatelecom|电信|china[\s-]?unicom|unicom|联通|
+        china[\s-]?mobile|(?:^|\b)cmcc\b|移动|china[\s-]?radio|crtc|广电|
+        dr[\s.]?peng|鹏博士/ix,                                              "运营商"],
+      [/apple|microsoft|oracle|ibm|intel|cisco|ford|toyota|bank|inc\.?\z/ix,  "企业"],
+    ].freeze
+
+    # 从 ASN 组织名推断运营商简称; 无法识别返回原文, 空输入返回空串。
+    def isp_from_asn(org)
+      return "" if org.to_s.empty?
+      ISP_RULES.each { |re, name| return name if org =~ re }
+      org.to_s
+    end
+
+    # 从 ASN 组织名推断用途类别 (云 / IDC / CDN / 教育网 / 运营商 / 企业 / 未知)
+    def usage_from_asn(org)
+      return "未知" if org.to_s.empty?
+      USAGE_RULES.each { |re, usage| return usage if org =~ re }
+      "未知"
+    end
+
+    # 综合推断: 依次尝试本地与互联网两方的组织名/ISP 描述,
+    # 取第一个能识别出非"未知"用途的结果 (本地优先, 组织名优先)。
+    def usage_of(*candidates)
+      candidates.each do |c|
+        usage = usage_from_asn(c.to_s)
+        return usage if usage != "未知"
+      end
+      "未知"
+    end
+  end
+end

data/service/geoquery/online.rb

@@ -0,0 +1,136 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require_relative "normalize"
+
+module GeoQuery
+  # ------------------------------------------------------------------
+  # 互联网查询客户端 (gen-get 核心) — 免费 ip-api.com 接口
+  # ------------------------------------------------------------------
+  # 接口与参数沿用 ip_geo_lookup.py 的默认配置:
+  #   http://ip-api.com/json/{ip}?lang=zh-CN&fields=status,message,country,regionName,city,isp,as,query
+  #   (免费版无需 Key, 限 45 req/min; message 字段为诊断扩展, 不影响归属字段)
+  #
+  # 状态映射 (state):
+  #   ok           status:success          互联网查询成功
+  #   empty        status:fail             互联网确认无归属 (如私有/保留地址)
+  #   unreachable  网络/HTTP 异常          互联网查询不可达 (不缓存, 下次重试)
+  #   invalid      IP 参数不合法
+  class OnlineClient
+    DEFAULT_API = "http://ip-api.com/json/{ip}?lang=zh-CN&fields=status,message,country,regionName,city,isp,as,query"
+    MIN_INTERVAL = 1.4  # 两次请求最小间隔 (秒), 对齐 45 req/min 免费限额
+
+    attr_reader :api
+
+    def initialize(api: DEFAULT_API, timeout: 10)
+      @api = api || DEFAULT_API
+      @timeout = timeout || 10
+      @lock = Mutex.new
+      @last_ts = 0.0
+    end
+
+    # 查询单个 IP, 返回统一 schema:
+    #   { "ip", "state", "message", "country", "province", "city",
+    #     "isp", "asn", "asn_org", "network", "usage", "source", "ts" }
+    def lookup(ip)
+      unless valid_ip?(ip)
+        return base(ip, "invalid", "IP 不合法")
+      end
+
+      raw = fetch(ip)
+      case raw[:state]
+      when :unreachable
+        base(ip, "unreachable", raw[:message]).merge("ts" => Time.now.to_i)
+      when :empty
+        base(ip, "empty", raw[:message]).merge("ts" => Time.now.to_i)
+      else
+        parse_success(ip, raw[:body])
+      end
+    end
+
+    private
+
+    def base(ip, state, message = "")
+      {
+        "ip" => ip, "state" => state, "message" => message,
+        "country" => "", "province" => "", "city" => "",
+        "isp" => "", "asn" => "", "asn_org" => "", "network" => "",
+        "usage" => "", "source" => "gen-get(ip-api.com)",
+      }
+    end
+
+    # 发请求并做状态归类, 返回 {state: :ok/:empty/:unreachable, body:, message:}
+    def fetch(ip)
+      throttle!
+      uri = URI(@api.sub("{ip}", URI.encode_www_form_component(ip)))
+      res = Net::HTTP.start(uri.hostname, uri.port,
+                            open_timeout: @timeout, read_timeout: @timeout) do |http|
+        http.get(uri.request_uri)
+      end
+      case res.code.to_i
+      when 200
+        body = JSON.parse(res.body)
+        if body["status"] == "success"
+          { state: :ok, body: body }
+        else
+          { state: :empty, message: body["message"].to_s }
+        end
+      when 429
+        { state: :unreachable, message: "ip-api.com 限速 (HTTP 429), 稍后重试" }
+      else
+        { state: :unreachable, message: "ip-api.com 返回 HTTP #{res.code}" }
+      end
+    rescue => e
+      { state: :unreachable, message: "#{e.class}: #{e.message}" }
+    end
+
+    # 全局最小间隔限速 (进程内), 多线程调用也保持 45 req/min 以内
+    def throttle!
+      @lock.synchronize do
+        wait = MIN_INTERVAL - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @last_ts)
+        sleep(wait) if wait > 0
+        @last_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+
+    def parse_success(ip, d)
+      # as 字段格式: "AS4134 Chinanet"
+      asn = ""
+      asn_org = d["as"].to_s
+      if (m = asn_org.match(/\AAS(\d+)\s+(.*)\z/))
+        asn = m[1]
+        asn_org = m[2]
+      end
+      isp_raw = [asn_org, d["isp"]].reject { |s| s.to_s.empty? }.first.to_s
+      {
+        "ip" => ip,
+        "state" => "ok",
+        "message" => "",
+        "country" => d["country"].to_s,
+        "province" => d["regionName"].to_s,
+        "city" => d["city"].to_s,
+        "isp" => Normalize.isp_from_asn(isp_raw),
+        "asn" => asn,
+        "asn_org" => asn_org,
+        "network" => "",
+        "usage" => Normalize.usage_from_asn(asn_org),
+        "source" => "gen-get(ip-api.com)",
+        "ts" => Time.now.to_i,
+      }
+    end
+
+    def valid_ip?(ip)
+      ip = ip.to_s.strip
+      return false if ip.empty?
+      if ip.include?(":")
+        ip.match?(/\A[0-9A-Fa-f:]+\z/) && ip.count(":") >= 2
+      else
+        ip.match?(/\A\d{1,3}(\.\d{1,3}){3}\z/) &&
+          ip.split(".").all? { |o| o.to_i < 256 }
+      end
+    end
+  end
+end

data/service/simlab/SimLab.md

@@ -0,0 +1,140 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+=begin HELP
+SimLab - 路由交换模拟仿真
+
+= 概述
+
+SimLab 是 network-infra-utility 的路由交换仿真子系统，
+位于 service/simlab/ 下。它将 support 层的路由/交换原子能力
+组合成可运行的虚拟网络，并提供场景加载、事件驱动、观测导出等功能。
+
+= 架构分层
+
+  support/                     ← 原子原理层（纯内存，无 IO）
+    basic/packet.rb             ← EthernetFrame / IPPacket / ARP / ICMP
+    routing/
+      prefix.rb                 ← CIDR 前缀解析/比较
+      lpm_trie.rb               ← 最长前缀匹配 Trie
+      rib.rb                    ← 路由信息库 RIB
+      static_route.rb           ← 静态路由
+      rip.rb                    ← 距离矢量协议 RIP
+      ospf.rb                   ← 链路状态协议 OSPF
+      bgp.rb                    ← 路径矢量协议 BGP
+    switching/
+      mac_table.rb             ← MAC 地址表
+      frame_forward.rb          ← 帧转发决策
+      vlan.rb                   ← 802.1Q VLAN
+      stp.rb                   ← 生成树协议
+
+  service/simlab/               ← 仿真服务层（编排+IO）
+    lib/simlab.rb                ← 组合根入口
+    lib/simlab_topology.rb       ← 拓扑模型
+    lib/simlab_engine.rb         ← 离散事件引擎
+    lib/simlab_router.rb         ← 虚拟路由器
+    lib/simlab_switch.rb         ← 虚拟交换机
+    lib/simlab_traffic.rb        ← 流量注入
+    lib/simlab_observer.rb       ← 观测导出
+    lib/simlab_scenario.rb       ← YAML 场景加载
+    bin/simctl                   ← Thor CLI
+
+= 分层纪律
+
+1. support 层：纯内存、无 IO、无 Time.now、无全局状态
+2. service 层：负责编排、生命周期、事件调度、文件/CLI
+3. 协议出口唯一：所有协议通过 RIB#add 安装路由
+4. 组件通过 tick(now) 被动推进，不自己计时
+5. device 间不直接互调，由 engine 按链路投递
+
+= 快速开始
+
+  # 运行场景
+  ruby service/simlab/bin/simctl simulate example/simlab/ospf_basic.yml
+
+  # 导出 RIB
+  ruby service/simlab/bin/simctl dump --rib R1 example/simlab/ospf_basic.yml
+
+  # 路径追踪
+  ruby service/simlab/bin/simctl trace --from R1 --to 192.168.2.1 example/simlab/ospf_basic.yml
+
+  # 列出场景
+  ruby service/simlab/bin/simctl list example/simlab/ospf_basic.yml
+
+= 场景 YAML 格式
+
+  ---
+  topology:
+    routers:
+      R1:
+        interfaces: {Gi0/0: 10.0.0.1/24}
+        ospf: {router_id: 1.1.1.1}
+    switches:
+      S1:
+        ports: [Gi0/1, Gi0/2]
+        access_ports: {Gi0/1: 10}
+    links:
+      - [R1:Gi0/0, R2:Gi0/0, {bandwidth: 100000, delay: 10}]
+    hosts:
+      H1: {ip: 192.168.1.2/24, gateway: 192.168.1.1}
+  protocols:
+    ospf:
+      neighbors:
+        - {router: R1, neighbor_rid: 2.2.2.2, port: Gi0/0, cost: 10}
+  simulation:
+    until: 100
+    protocol_interval: 10
+  traffic:
+    - {type: ping, from: R1, to: 192.168.2.1, at: 50}
+    - {type: link_down, device: R1, port: Gi0/0, at: 80}
+  expect:
+    - rib_converged: [R1, R2]
+
+= 已实现功能清单
+
+== Support 路由层
+- [x] CIDR 前缀解析/规范化/包含比较
+- [x] 最长前缀匹配 Trie (IPv4/IPv6)
+- [x] RIB 路由信息库（多协议共存/优选排序）
+- [x] 静态路由（增删/递归解析）
+- [x] RIP 距离矢量（Bellman-Ford/水平分割/毒性反转/hold-down）
+- [x] OSPF 链路状态（LSA 泛洪/Dijkstra SPF）
+- [x] BGP 路径矢量（AS_PATH 防环/LOCAL_PREF/MED 优选/policy 钩子）
+
+== Support 交换层
+- [x] MAC 地址表（学习/老化/静态表项）
+- [x] 帧转发决策（泛洪/转发/丢弃/hairpin 过滤/ACL 钩子）
+- [x] 802.1Q VLAN（access/trunk 端口/native VLAN/白名单）
+- [x] STP 生成树（BPDU/根桥选举/端口角色/状态机）
+
+== Service 仿真层
+- [x] 拓扑模型（节点/链路/邻接关系）
+- [x] 离散事件引擎（虚拟时钟/事件队列/延迟事件）
+- [x] 虚拟路由器（RIB+LPM+Static+RIP/OSPF/BGP 组合）
+- [x] 虚拟交换机（MAC+Forward+VLAN+STP 流水线）
+- [x] 流量注入（ping/链路故障/节点故障/协议交换）
+- [x] 观测导出（RIB/MAC/trace/收敛检测）
+- [x] YAML 场景加载器
+- [x] Thor CLI (simctl)
+
+= 扩展路线（文档已设计，待实现）
+
+  support/
+    routing/isis.rb             ← IS-IS 链路状态 IGP
+    mpls/                       ← MPLS 标签/LDP/RSVP-TE/VRF/L3VPN
+    segment/                    ← SR/SRv6 SID
+    evpn/                       ← EVPN NLRI/VXLAN
+    te/                         ← TED/CSPF/TE Tunnel
+    flexe/                      ← FlexE 时隙化 shim
+    vpdn/                       ← L2TP/PPP/VPDN 会话
+  service/simlab/
+    capability.rb               ← 设备能力声明
+    profile.rb                  ← 节点 profile
+    pipeline.rb                 ← 统一转发流水线
+    service_model.rb             ← L3VPN/L2VPN/EVPN 业务实例
+    segment_policy.rb           ← SR/SRv6 policy
+    telemetry.rb                ← 额外观测
+    scenario_schema.rb          ← YAML DSL 扩展
+=end
+
+> AI生成