vxlan 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52225eb340f37fe90fbfc251436c8ee3311c636f11f7ed3693c9d72f2a49a87e
-  data.tar.gz: b108dd357215c64fe29ee5e2f68a6f0595fcfe0b1530fdb1731bec772c50bff8
+  metadata.gz: ec6112b96a159497c2b87ac94ef257e7a3baf710a43b9449ff450f757afe3c36
+  data.tar.gz: c8766a7269d4dab9bbacc40026a045fcaf9522fb8052145e22f7d61619919dfb
 SHA512:
-  metadata.gz: af783c1a3288bc317659d38f69143ea99b2a34b24e0fac2db6bb5269f78f3ca9231cdb064df434d546216f3aa20af776793a886949bc7a0658745cf93575f043
-  data.tar.gz: 37d06a9e9405aeb8120e4be6c8027c23a04db700a9a8cdce87f03747c24b19fbdca9c4949c9f43ae77927df6728fbbf4c93063dc483cc3af7618bd7dd4f9b956
+  metadata.gz: d40b5df068d87188cf5eda73ac5cbd4cbb70bc4133424caf641f9cc0a4a6f7bdbe0b7a1439682a0b7b54d266de4c425f712fcc13d721a017b7fefa9d2edf596a
+  data.tar.gz: c4dc37ebef89f10a0692b26510f46b74f65e54a31bf7be3f134e84732bc45327239568bdc4acbdedc85fba25d188c53ef3f4addfec8bfef6f9c522bab6acdc5c

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 Changes to the public contract are recorded here. Versions follow Semantic Versioning.
 
+## 0.2.2 (2026-10-18)
+
+### Changed
+
+- Name mutable NX-OS parsing state `CiscoNxos::ConfigurationState`; retain the former `Configuration` constant, require path, and `finish` method as compatible aliases.
+- Clarify internal method names for conflict exclusion, diagnostics, address conversion, route-map consumers, and observation collection without changing parsed record fields.
+
+### Fixed
+
+- Exclude repeated prefix-list and route-map sequence identities, including malformed payloads, without restoring them later; preserve independent entries and capture their final array paths.
+- Validate routing leaf ownership, supported address families, network prefix families, and IPv4 router IDs before accepting facts or projecting policy consumers.
+- Exclude repeated hostname, BGP process, NVE interface, and vPC domain identities without restoring them on later declarations; invalidate their original source captures.
+- Stop configured neighbor and policy projections through unsupported peer-template inheritance chains.
+- Reject bare carriage returns in runtime output while preserving CRLF and existing configuration newline handling.
+- Scan inline EVPN next hops by byte offset to avoid repeated copies of the remaining line.
+- Report explicit EVPN/NVE layer mismatches and L3 NVE members without a matching configured VRF, independently of syntax completeness; retain valid VLAN-backed L3 VNIs.
+
+## 0.2.1 (2026-10-17)
+
+- Require ctx_parser and ctx_driver 0.2.x so configuration APIs and command capture behavior resolve consistently.
+
 ## 0.2.0 (2026-10-17)
 
 ### Changed

data/README-zh.md

@@ -21,7 +21,7 @@ gem "vxlan"
 
 然后执行 `bundle install`；也可直接执行 `gem install vxlan`。Ruby 加载入口为 `vxlan`，公开命名空间为 `Vxlan`；gem 包名与 Ruby 命名空间分别维护。
 
-模块运行依赖：[`ctx_parser`](https://github.com/gatework/ctx_parser), [`ctx_driver`](https://github.com/gatework/ctx_driver)。 gemspec 的运行依赖不添加版本约束；应用应提交自己的 `Gemfile.lock`，保持部署可复现。使用本库不需要启动 Rails 或配置兄弟模块的本地路径。
+模块运行依赖：[`ctx_parser`](https://github.com/gatework/ctx_parser), [`ctx_driver`](https://github.com/gatework/ctx_driver)。 共享 Gatework 依赖要求兼容的 0.2.x API；应用应提交自己的 `Gemfile.lock`，保持部署可复现。使用本库不需要启动 Rails 或配置兄弟模块的本地路径。
 
 发布产物和校验值见 [GitHub Releases](https://github.com/gatework/vxlan/releases)，已发布版本以 [RubyGems](https://rubygems.org/gems/vxlan) 为准。
 
@@ -72,10 +72,18 @@ observation.records.each { |record| p record }
 
 VLAN ID、VNI、VRF、NVE 成员是不同身份。配置审查通过 VNI 关联 VLAN 映射与 NVE 成员，不推断运行可达性。`BgpNeighbors` 枚举应用 peer-template 继承后的配置邻居，不代表已建立的 BGP 会话。`PrefixListReferences` 表达 route-map 选择器及路由使用方的引用关系，引用本身不能证明路由被接受。
 
+关联诊断包括：显式 EVPN 或 VRF 定义与 NVE 成员二层/三层角色矛盾时的 `vni_layer_conflict`，以及三层 NVE 成员没有对应 VNI 的配置 VRF 时的 `nve_l3_without_vrf`。VLAN 映射本身不能证明二层角色，支持通过 VLAN 承载的三层 VNI。这些诊断仅基于完整配置证据生成，不改变语法解析状态。
+
+路由事实保留协议及所属作用域。`network` 必须位于匹配的 IPv4/IPv6 进程或 VRF 地址族中；邻居策略映射属于邻居或 peer-template 的地址族。不支持的路由地址族及位置错误的设置保持部分证据，不生成对应策略使用方。
+
+prefix-list 或 route-map 在同种类、同名称内出现重复序号时，排除该序号的全部声明，后续声明不能恢复。独立序号仍作为部分事实保留，来源捕获路径使用最终结果索引；部分策略条目不能证明整份策略的行为。
+
 ## 开发与测试
 
 共享类按实际职责命名，平台信息放在命名空间中。直接对应设备命令的解析器保留文件名和类名。
 
+`CiscoNxos::ConfigurationState` 持有单次解析期间的可变事实，`Vxlan::Configuration` 是公开解析入口。原 `CiscoNxos::Configuration` 常量及其 `finish` 方法保留为兼容别名。内部方法名区分文本解析（`parse_next_hops`）、诊断记录（`unparsed_records`）和冲突排除（`exclude_ambiguous_records!`，移除重复身份的全部记录）。
+
 ```sh
 bundle install
 bundle exec rake

data/README.md

@@ -21,7 +21,7 @@ gem "vxlan"
 
 Then run `bundle install`, or install directly with `gem install vxlan`. The require path is `vxlan` and the public namespace is `Vxlan`; package names and Ruby namespaces are intentionally separate.
 
-Internal runtime dependencies: [`ctx_parser`](https://github.com/gatework/ctx_parser), [`ctx_driver`](https://github.com/gatework/ctx_driver). The gemspec declares runtime dependencies without version constraints. Applications should commit their own `Gemfile.lock` to make deployments reproducible. No Rails boot or sibling checkout paths are required.
+Internal runtime dependencies: [`ctx_parser`](https://github.com/gatework/ctx_parser), [`ctx_driver`](https://github.com/gatework/ctx_driver). Shared Gatework dependencies require the compatible 0.2.x API. Applications should commit their own `Gemfile.lock` to make deployments reproducible. No Rails boot or sibling checkout paths are required.
 
 Release artifacts and checksums are available from [GitHub Releases](https://github.com/gatework/vxlan/releases). Check [RubyGems](https://rubygems.org/gems/vxlan) for published versions.
 
@@ -72,10 +72,18 @@ The lifecycle connector is a host adapter exposing `open { |session| }` (and `pl
 
 VLAN IDs, VNIs, VRFs, and NVE members are separate identities. Configuration review joins VLAN mappings and NVE members by VNI; it does not infer operational reachability. `BgpNeighbors` enumerates configured neighbors after peer-template inheritance, not established BGP sessions. `PrefixListReferences` describes route-map selectors and their routing consumers; those references do not by themselves prove route acceptance.
 
+Association findings include `vni_layer_conflict` for explicit EVPN or VRF definitions that disagree with the NVE member's L2/L3 role, and `nve_l3_without_vrf` for an L3 NVE member without a configured VRF using its VNI. A VLAN mapping alone does not establish an L2 role: VLAN-backed L3 VNIs are supported. These findings are emitted only from complete configuration evidence and do not change the syntax status.
+
+Routing facts retain their protocol and owner scope. Network statements require a matching IPv4/IPv6 process or VRF address family; neighbor policy maps belong to neighbor or peer-template address families. Unsupported routing families and misplaced settings remain partial evidence and produce no corresponding policy consumer.
+
+Repeated prefix-list or route-map sequence identities are excluded within their policy name and kind, including subsequent declarations of that sequence. Independent sequences remain available as partial facts; their source capture paths use the final result indices. These partial policy entries do not establish the complete policy's behavior.
+
 ## Development and tests
 
 Name shared classes by their responsibility and use the namespace for platform context. Preserve filenames and class names that directly match device commands.
 
+`CiscoNxos::ConfigurationState` holds mutable facts during a single parse; `Vxlan::Configuration` is the public parsing entry point. The former `CiscoNxos::Configuration` constant and its `finish` method remain compatible aliases. Internal method names distinguish parsing (`parse_next_hops`), diagnostics (`unparsed_records`), and conflict exclusion (`exclude_ambiguous_records!`, which removes every record with a repeated identity).
+
 ```sh
 bundle install
 bundle exec rake

data/docs/architecture-zh.md

@@ -49,7 +49,7 @@ bundle exec rake 'motor:netstack:vxlan[456,LAB]'
 
 Cisco N9K 的具体策略位于 [`lib/vxlan/cisco_nxos`](../lib/vxlan/cisco_nxos/profile.rb)，按命令拆分为 `parsers/show_ip_ospf_neighbors.rb` 等独立文件。直接调用 `Vxlan::CiscoNxos::Parsers::ShowIpOspfNeighbors.parse(cli_output, complete: true)` 即可离线解析。`ParserRegistry.fetch(:cisco_nxos, model: device.model)` 选择平台与型号策略；命令清单和解析类统一在 `CiscoNxos::Profile` 中声明。原解析入口继续转换为 `Vxlan::Observation`。公共接口、结果对象和扩展方式见 [`../ctx_parser`](https://github.com/gatework/ctx_parser)。
 
-配置解析按职责组合：`ShowRunningConfig` 编排命令解析，`Syntax::Interfaces/Routing/Policies` 分别解释接口/NVE、路由上下文及策略语法，`CtxParser::Configuration` 管理逐行状态、嵌套来源路径与捕获，`CiscoNxos::Configuration` 在全部块解析后归约特性列表、校验 BGP 模板引用并关联 SVI/VLAN/VNI 网段。接口地址与网段使用 `CtxParser::Values.ipv4_prefix` 的同一校验。重复身份仍排除歧义记录；语法未知、引用不完整与来源行号继续进入原有 `Result`，供入库边界判断。
+配置解析按职责组合：`ShowRunningConfig` 编排命令解析，`Syntax::Interfaces/Routing/Policies` 分别解释接口/NVE、路由上下文及策略语法，`CtxParser::Configuration` 管理逐行状态、嵌套来源路径与捕获，`CiscoNxos::ConfigurationState` 持有单次解析状态（旧名 `CiscoNxos::Configuration` 保留为兼容别名），在全部块解析后归约特性列表、校验 BGP 模板引用并关联 SVI/VLAN/VNI 网段。接口地址与网段使用 `CtxParser::Values.ipv4_prefix` 的同一校验。重复身份仍排除歧义记录；语法未知、引用不完整与来源行号继续进入原有 `Result`，供入库边界判断。
 
 设备连接默认关闭旧版 SSH 算法协商。确认单台旧设备确有算法兼容需求后，可在其现有 `settings["connector"]["legacy_ssh"]` 中显式保存布尔值 `true`；省略或 `false` 保持关闭，字符串、NULL 等非布尔值会在连接前拒绝。该设置直接传给 net-connector，主机密钥仍严格核验 `storage/net_connector/known_hosts`，不启用 Telnet 回退。连接异常仅保留允许列表中的诊断码（例如 `unsupported_host_key_algorithm`），未知码归为 `connection_failed`；VXLAN 未采集维度保存该原因，不保存底层异常文案或 cause。
 

data/lib/vxlan/bgp_neighbors.rb

@@ -10,7 +10,7 @@ module Vxlan
       @bgp = bgp
     end
 
-    # 应用继承的对等体模板配置后，逐个返回实际生效的 BGP 邻居。
+    # 合并受支持的对等体模板后，逐个返回配置邻居，不推断运行会话状态。
     def each
       return enum_for(:each) unless block_given?
 
@@ -22,6 +22,9 @@ module Vxlan
           next if inherited_name && !peer_templates.key?(inherited_name)
 
           peer_template = peer_templates.fetch(inherited_name, {})
+          # 模板自身继承尚不受支持，不能把部分模板当作已解析配置。
+          next if peer_template[:inherit_peer]
+
           address_families = peer_template.fetch(:address_families, {}).merge(neighbor_configuration.fetch(:address_families, {})) do |_name, template_family, neighbor_family|
             template_family.merge(neighbor_family.compact).merge(route_maps: template_family.fetch(:route_maps, {}).merge(neighbor_family.fetch(:route_maps, {})))
           end

data/lib/vxlan/cisco_nxos/configuration.rb

@@ -1,84 +1,10 @@
 # frozen_string_literal: true
 
-require "ctx_parser/values"
+require_relative "configuration_state"
 
 module Vxlan
   module CiscoNxos
-    # 归纳 NX-OS 模板引用、功能身份及 SVI、VLAN、VNI 子网关系。
-    class Configuration
-      attr_reader :data, :issues
-
-      # 初始化单次配置解析使用的可变 NX-OS 事实容器。
-      def initialize
-        @data = { hostname: nil, features: [], disabled_features: [], breakouts: {}, interfaces: {}, vlan_vnis: {}, vrfs: {}, nve: { members: {} },
-          evpn: {}, bgp: {}, ospf: {}, vpc_domain: nil, unnumbered_addresses: {}, prefix_lists: {}, ipv6_prefix_lists: {}, route_maps: {}, acls: {}, static_routes: [] }
-        @issues = []
-      end
-
-      # 解析结束后关联跨块引用，避免声明顺序影响结果。
-      def finish
-        validate_templates
-        resolve_unnumbered
-        issues << { code: :conflicting_feature_state } if (data[:features] & data[:disabled_features]).any?
-        issues << { code: :hostname_missing } unless data[:hostname]
-        data[:features] = data[:features].uniq.sort
-        data[:disabled_features] = data[:disabled_features].uniq.sort
-        data[:segments] = segments
-        data
-      end
-
-      # 展示对象身份与状态，避免泄露原始回显或凭据。
-      def inspect = "#<#{self.class} interfaces=#{data[:interfaces].size} issues=#{issues.size}>"
-
-      private
-
-      # 借用的 IPv4 地址仅作为主机身份，不猜测链路网段。
-      def resolve_unnumbered
-        interfaces = data[:interfaces]
-        by_name = interfaces.group_by { |name, _values| name.downcase }
-        interfaces.each do |name, values|
-          next unless values[:unnumbered_interface]
-
-          sources = by_name.fetch(values[:unnumbered_interface].downcase, [])
-          source = sources.one? ? sources.first.last : nil
-          if source && source[:addresses].one? && values[:addresses].empty? &&
-              !source[:unnumbered_interface] && source.fetch(:vrf, "default") == values.fetch(:vrf, "default")
-            data[:unnumbered_addresses][name] = [ "#{source[:addresses].first.split('/').first}/32" ]
-          else
-            issues << { code: :unresolved_unnumbered_interface, interface: name }
-          end
-        end
-      end
-
-      # 报告未解析的继承模板，不虚构模板配置。
-      def validate_templates
-        bgp = data[:bgp]
-        templates = bgp.fetch(:templates, {})
-        issues << { code: :unsupported_peer_inheritance } if templates.values.any? { |settings| settings[:inherit_peer] }
-        [ bgp, *bgp.fetch(:vrfs, {}).values ].each do |scope|
-          scope.fetch(:neighbors, {}).each_value do |neighbor|
-            next unless neighbor[:inherit_peer] && !templates.key?(neighbor[:inherit_peer])
-
-            issues << { code: :missing_peer_template }
-          end
-        end
-      end
-
-      # 根据显式配置构建 VLAN 与 VNI 网段关联。
-      def segments
-        data[:interfaces].filter_map do |name, values|
-          match = /\AVlan(\d+)\z/.match(name)
-          next unless match && data[:vlan_vnis][match[1].to_i] && values[:addresses].any?
-          unless values[:addresses].one? && values[:vrf]
-            issues << { code: :unsupported_svi, interface: name }
-            next
-          end
-          source = values[:addresses].first
-          { vlan_id: match[1].to_i, vni: data[:vlan_vnis].fetch(match[1].to_i), vrf: values[:vrf],
-            prefix: CtxParser::Values.ipv4_prefix(source), gateway: source.split("/").first,
-            anycast: values[:anycast], acl_bindings: values[:acl_bindings] }
-        end
-      end
-    end
+    # 兼容既有加载路径；配置解析状态由 ConfigurationState 表达。
+    Configuration = ConfigurationState
   end
 end

data/lib/vxlan/cisco_nxos/configuration_state.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "ctx_parser/values"
+
+module Vxlan
+  module CiscoNxos
+    # 归纳 NX-OS 模板引用、功能身份及 SVI、VLAN、VNI 子网关系。
+    class ConfigurationState
+      attr_reader :data, :issues
+
+      # 初始化单次配置解析使用的可变 NX-OS 事实容器。
+      def initialize
+        @data = { hostname: nil, features: [], disabled_features: [], breakouts: {}, interfaces: {}, vlan_vnis: {}, vrfs: {}, nve: { members: {} },
+          evpn: {}, bgp: {}, ospf: {}, vpc_domain: nil, unnumbered_addresses: {}, prefix_lists: {}, ipv6_prefix_lists: {}, route_maps: {}, acls: {}, static_routes: [] }
+        @issues = []
+      end
+
+      # 解析结束后关联跨块引用，避免声明顺序影响结果。
+      def finalize_facts
+        peer_template_issues
+        resolve_unnumbered_addresses
+        issues << { code: :conflicting_feature_state } if (data[:features] & data[:disabled_features]).any?
+        issues << { code: :hostname_missing } unless data[:hostname]
+        data[:features] = data[:features].uniq.sort
+        data[:disabled_features] = data[:disabled_features].uniq.sort
+        data[:segments] = build_svi_segments
+        data
+      end
+
+      # 兼容原有解析状态的收尾入口。
+      alias finish finalize_facts
+
+      # 展示对象身份与状态，避免泄露原始回显或凭据。
+      def inspect = "#<#{self.class} interfaces=#{data[:interfaces].size} issues=#{issues.size}>"
+
+      private
+
+      # 借用的 IPv4 地址仅作为主机身份，不猜测链路网段。
+      def resolve_unnumbered_addresses
+        interfaces = data[:interfaces]
+        by_name = interfaces.group_by { |name, _values| name.downcase }
+        interfaces.each do |name, values|
+          next unless values[:unnumbered_interface]
+
+          sources = by_name.fetch(values[:unnumbered_interface].downcase, [])
+          source = sources.one? ? sources.first.last : nil
+          if source && source[:addresses].one? && values[:addresses].empty? &&
+              !source[:unnumbered_interface] && source.fetch(:vrf, "default") == values.fetch(:vrf, "default")
+            data[:unnumbered_addresses][name] = [ "#{source[:addresses].first.split('/').first}/32" ]
+          else
+            issues << { code: :unresolved_unnumbered_interface, interface: name }
+          end
+        end
+      end
+
+      # 报告未解析的继承模板，不虚构模板配置。
+      def peer_template_issues
+        bgp = data[:bgp]
+        templates = bgp.fetch(:templates, {})
+        issues << { code: :unsupported_peer_inheritance } if templates.values.any? { |settings| settings[:inherit_peer] }
+        [ bgp, *bgp.fetch(:vrfs, {}).values ].each do |scope|
+          scope.fetch(:neighbors, {}).each_value do |neighbor|
+            next unless neighbor[:inherit_peer] && !templates.key?(neighbor[:inherit_peer])
+
+            issues << { code: :missing_peer_template }
+          end
+        end
+      end
+
+      # 根据显式配置构建 VLAN 与 VNI 网段关联。
+      def build_svi_segments
+        data[:interfaces].filter_map do |name, values|
+          match = /\AVlan(\d+)\z/.match(name)
+          next unless match && data[:vlan_vnis][match[1].to_i] && values[:addresses].any?
+          unless values[:addresses].one? && values[:vrf]
+            issues << { code: :unsupported_svi, interface: name }
+            next
+          end
+          source = values[:addresses].first
+          { vlan_id: match[1].to_i, vni: data[:vlan_vnis].fetch(match[1].to_i), vrf: values[:vrf],
+            prefix: CtxParser::Values.ipv4_prefix(source), gateway: source.split("/").first,
+            anycast: values[:anycast], acl_bindings: values[:acl_bindings] }
+        end
+      end
+    end
+  end
+end

data/lib/vxlan/cisco_nxos/document.rb

@@ -15,7 +15,7 @@ module Vxlan
         @banner ||= CtxParser::Banner.new
         return :ignored if @banner.consume(line.text)
 
-        if Terminal.invalid_output?(line.raw)
+        if Terminal.invalid_output?(line.raw, allow_cr_newlines: true)
           issues << { code: :incomplete_configuration, line: line.number }
           return :ignored
         end

data/lib/vxlan/cisco_nxos/evpn_l2route.rb

@@ -11,6 +11,9 @@ module Vxlan
         "host ip" => :host_ip, "prod" => :producer, "flags" => :flags, "seq no" => :sequence,
         "next-hops" => :next_hops, "next hop (s)" => :next_hops, "next hop(s)" => :next_hops }.freeze
       HEADER = /Topology ID|Topology|Mac Address|Host IP|Prod|Flags|Seq No|Next-Hops|Next Hop \(s\)|Next Hop\(s\)/i
+      NEXT_HOP = /\G(?<hop>Ifindex\s+\d+|Local|(?:Eth(?:ernet)?|Po(?:rt-channel)?|nve|Lo(?:opback)?|Vlan|vPC)[\d\/.:-]+|[\da-f:.]+)(?:\s*\(Label:\s*(?<label>\d+)\))?(?=\s|,|\z)/i
+      NEXT_HOP_SEPARATOR = /\G(?:\s*,\s*|\s+)/
+      private_constant :NEXT_HOP, :NEXT_HOP_SEPARATOR
 
       private
 
@@ -44,11 +47,11 @@ module Vxlan
               if fields && line.match?(/\A\d+\s/)
                 values = line.split(/\s+/, fields.size)
                 raise ArgumentError unless values.size == fields.size
-                previous = route(fields.zip(values).to_h, type)
+                previous = parse_route_fields(fields.zip(values).to_h, type)
                 next_hop_index = nil
                 @rows << previous
               elsif previous && source.match?(/\A\s+/)
-                hops = next_hops(line)
+                hops = parse_next_hops(line)
                 # 首条续行建立索引，后续仅追加新下一跳；非法续行不会改动已有事实。
                 unless next_hop_index
                   previous[:next_hops].uniq!
@@ -73,8 +76,8 @@ module Vxlan
 
       # 汇总已解析记录，并报告未解决或不完整的来源状态。
       def finish(complete)
-        @totals.each { |count| mismatch(count, @rows.size) }
-        remove_duplicates(@rows, %i[topology_id mac host_ip producer])
+        @totals.each { |count| count_mismatch(count, @rows.size) }
+        exclude_ambiguous_records!(@rows, %i[topology_id mac host_ip producer])
         @issues << { code: :contradictory_empty } if @empty && @rows.any?
         @issues << { code: :missing_completeness_evidence } if @rows.empty? && !@empty && @totals != [ 0 ]
         @issues << { code: :output_incomplete } unless complete
@@ -82,47 +85,53 @@ module Vxlan
       end
 
       # 归一化单条 EVPN 路由及回显的身份字段。
-      def route(values, type)
-        values[:topology_id] = number(values[:topology_id])
+      def parse_route_fields(values, type)
+        values[:topology_id] = parse_uint32(values[:topology_id])
         raise ArgumentError unless values[:mac].match?(/\A(?:[0-9a-f]{4}(?:\.[0-9a-f]{4}){2}|(?:[0-9a-f]{2}:){5}[0-9a-f]{2})\z/i)
         values[:mac] = CtxParser::Values.mac_address(values[:mac])
-        values[:sequence] = number(values[:sequence]) if values[:sequence]
-        values[:host_ip] = ip_address(values.fetch(:host_ip)) if type == :mac_ip
-        values[:next_hops] = next_hops(values.fetch(:next_hops))
+        values[:sequence] = parse_uint32(values[:sequence]) if values[:sequence]
+        values[:host_ip] = parse_ip_address(values.fetch(:host_ip)) if type == :mac_ip
+        values[:next_hops] = parse_next_hops(values.fetch(:next_hops))
         values
       end
 
       # 归一化 EVPN 路由关联的全部下一跳。
-      def next_hops(text)
+      def parse_next_hops(text)
         result = []
-        until text.empty?
-          match = /\A(?<hop>Ifindex\s+\d+|Local|(?:Eth(?:ernet)?|Po(?:rt-channel)?|nve|Lo(?:opback)?|Vlan|vPC)[\d\/.:-]+|[\da-f:.]+)(?:\s*\(Label:\s*(?<label>\d+)\))?(?=\s|,|\z)/i.match(text)
+        # 字节视图让偏移定位保持线性；逐项扫描，不重复复制剩余长行。
+        encoding = text.encoding
+        text = text.b
+        offset = 0
+        while offset < text.bytesize
+          match = NEXT_HOP.match(text, offset)
           raise ArgumentError unless match
-          token = match[:hop]
+          token = match[:hop].force_encoding(encoding)
           value = case token
           when /\ALocal\z/i then { local: true }
-          when /\AIfindex\s+(\d+)\z/i then { ifindex: number($1) }
+          when /\AIfindex\s+(\d+)\z/i then { ifindex: parse_uint32($1) }
           when /\A(?:Eth|Po|nve|Lo|Vlan|vPC)/i then { interface: token }
-          else { address: ip_address(token) }
+          else { address: parse_ip_address(token) }
           end
-          value[:label] = number(match[:label]) if match[:label]
+          value[:label] = parse_uint32(match[:label]) if match[:label]
           result << value
-          remainder = text[match.end(0)..]
-          break if remainder.empty?
-          text = remainder.sub(/\A(?:\s*,\s*|\s+)/, "")
-          raise ArgumentError if text.empty? || text.start_with?(",")
+          offset = match.end(0)
+          break if offset == text.bytesize
+
+          separator = NEXT_HOP_SEPARATOR.match(text, offset)
+          raise ArgumentError unless separator && separator.end(0) < text.bytesize
+          offset = separator.end(0)
         end
         raise ArgumentError if result.empty?
         result
       end
 
       # 解析数值测量，不将未知文本转换为零。
-      def number(value)
+      def parse_uint32(value)
         CtxParser::Values.integer(value, max: UINT32.end)
       end
 
       # 归一化主机地址，保留 IPv4 与 IPv6 语义。
-      def ip_address(value)
+      def parse_ip_address(value)
         CtxParser::Values.ip_address(value, allow_zone: true)
       end
     end

data/lib/vxlan/cisco_nxos/parser.rb

@@ -53,7 +53,7 @@ module Vxlan
         @issues << { code: :format_unrecognized } unless @header || @empty
         @issues << { code: :contradictory_empty } if @empty && @rows.any?
         @issues << { code: :output_incomplete } unless complete
-        remove_duplicates(@rows, self.class::IDENTITY) if self.class::IDENTITY
+        exclude_ambiguous_records!(@rows, self.class::IDENTITY) if self.class::IDENTITY
         CtxParser::Result.new(status: @issues.empty? ? :complete : :partial, records: @rows, issues: @issues)
       end
 
@@ -71,7 +71,7 @@ module Vxlan
       end
 
       # 逐行提供有效表格内容，并记录明确空表证据。
-      def lines(text, separators: false)
+      def each_content_line(text, separators: false)
         text.each_line.with_index(1) do |source, number|
           line = source.strip
           next if line.empty? || (!separators && line.match?(/\A[-=+\s]+\z/))
@@ -84,12 +84,12 @@ module Vxlan
       end
 
       # 记录声明总数与实际解析数量不一致的情况。
-      def mismatch(expected, observed)
+      def count_mismatch(expected, observed)
         @issues << { code: :count_mismatch, expected: expected, observed: observed } unless expected == observed
       end
 
-      # 记录不支持或无效的行，不将其接受为完整证据。
-      def reject(number)
+      # 追加行诊断；调用方负责决定是否继续处理当前记录。
+      def unparsed_records(number)
         @issues << { code: :unparsed_row, line: number }
       end
 
@@ -98,8 +98,8 @@ module Vxlan
         CtxParser::Values.ip_address?(value, allow_zone: true)
       end
 
-      # 返回可作为权威清单的结果前，先识别身份冲突。
-      def remove_duplicates(rows, fields, &identity)
+      # 原地排除重复身份的全部记录，不选取其中任意一条。
+      def exclude_ambiguous_records!(rows, fields, &identity)
         identities = CtxParser::Records.new(rows, identity: fields, &identity)
         return unless identities.duplicates?
         rows.replace(identities.unambiguous)

data/lib/vxlan/cisco_nxos/parsers/show_bgp_l2vpn_evpn_summary.rb

@@ -20,7 +20,7 @@ module Vxlan
         # 解析命令表格行，保留数量及格式错误行诊断。
         def parse_rows(text)
           scope, prefix_columns, prefix_seen, peers = {}, nil, {}, {}
-          lines(text) do |line, number|
+          each_content_line(text) do |line, number|
             if HEADER.match?(line)
               @header = true
             elsif (match = /\ABGP summary information for VRF (\S+), address family (.+)/.match(line))
@@ -28,7 +28,7 @@ module Vxlan
               prefix_columns = nil
             elsif (match = /\ABGP router identifier (\S+), local AS number (\S+)/.match(line))
               scope.merge!(router_id: match[1].delete_suffix(","), local_as: match[2])
-              reject(number) unless ip_address?(scope[:router_id]) && scope[:local_as].match?(/\A\d+(?:\.\d+)?\z/)
+              unparsed_records(number) unless ip_address?(scope[:router_id]) && scope[:local_as].match?(/\A\d+(?:\.\d+)?\z/)
             elsif line.match?(/\ANeighbor\s+T\s+AS\s+PfxRcd\s+Type-2\s+Type-3\s+Type-4\s+Type-5(?:\s+Type-12)?\z/)
               prefix_columns = line.end_with?("Type-12") ? %i[type2 type3 type4 type5 type12] : %i[type2 type3 type4 type5]
             elsif prefix_columns
@@ -39,14 +39,14 @@ module Vxlan
                 peer[:prefixes_by_type] = prefix_columns.zip(words.drop(4).map(&:to_i)).to_h
                 prefix_seen[peer.object_id] = true
               else
-                reject(number)
+                unparsed_records(number)
               end
             elsif (match = ROW.match(line))
               row = FIELDS.zip(match.captures).to_h.merge(scope)
               INTEGERS.each { |key| row[key] = row[key].to_i }
               unless ip_address?(row[:peer_ip]) && row[:version] == 4 && (1..4_294_967_295).cover?(row[:remote_as]) &&
                 row[:state].match?(/\A(?:\d+|Idle(?: \(Admin\))?|Active|Connect|OpenSent|OpenConfirm|Shutdown)\z/i)
-                reject(number)
+                unparsed_records(number)
                 next
               end
               row[:state] = row[:state].downcase.tr(" ", "_")
@@ -56,7 +56,7 @@ module Vxlan
               # 统计表按完整作用域查找；重复邻居仍由最终身份检查整体隔离。
               peers[row.values_at(:vrf, :address_family, :peer_ip)] ||= row
             elsif !line.match?(/\A(?:BGP table version is \d+(?:, L2VPN EVPN config peers \d+, capable peers \d+)?|\d+ network entries and \d+ paths using \d+ bytes of memory|BGP attribute entries \[\d+\/\d+\], BGP AS path entries \[\d+\/\d+\]|BGP community entries \[\d+\/\d+\], BGP clusterlist entries \[\d+\/\d+\])\z/i)
-              reject(number)
+              unparsed_records(number)
             end
           end
           if prefix_columns && prefix_seen.size != @rows.size

data/lib/vxlan/cisco_nxos/parsers/show_cdp_neighbors_detail.rb

@@ -15,7 +15,7 @@ module Vxlan
         # 解析当前命令的记录，保留无法识别行的诊断。
         def parse_rows(text)
           row, scope, totals = nil, nil, []
-          lines(text, separators: true) do |line, number|
+          each_content_line(text, separators: true) do |line, number|
             if line.match?(/\A[-=+\s]+\z/)
               scope = nil
               next
@@ -33,11 +33,11 @@ module Vxlan
               next
             end
             unless row
-              reject(number)
+              unparsed_records(number)
               next
             end
             case line
-            when /\A--More--/i then reject(number)
+            when /\A--More--/i then unparsed_records(number)
             when /\ASystem Name:\s*(\S.*)\z/i then row[:neighbor_name] = $1
             when /\AInterface address\(es\):(?:\s+\d+)?\z/i then scope = :interface_addresses
             when /\AMgmt address\(es\):(?:\s+\d+)?\z/i then scope = :management_addresses
@@ -46,13 +46,13 @@ module Vxlan
               if %i[interface_addresses management_addresses].include?(scope) && ip_address?(value)
                 row[scope] << IPAddr.new(value).to_s
               else
-                reject(number)
+                unparsed_records(number)
               end
             when /\APlatform:\s*(.+?),\s*Capabilities:\s*(.+)\z/i
               row.merge!(platform: $1, capabilities: $2)
               scope = nil
             when /\AInterface:\s*(\S+),\s*Port ID \(outgoing port\):\s*(\S.*)\z/i
-              reject(number) if row.key?(:interface)
+              unparsed_records(number) if row.key?(:interface)
               row.merge!(interface: $1, neighbor_interface: $2)
               scope = nil
             when /\AHoldtime:\s*(\d+) sec\z/i then row[:holdtime] = $1.to_i
@@ -66,11 +66,11 @@ module Vxlan
               row[:attributes][$1.downcase.tr(" ", "_").to_sym] = $2
               scope = nil
             else
-              scope == :version ? row[:version] = [ row[:version], line ].reject(&:empty?).join("\n") : reject(number)
+              scope == :version ? row[:version] = [ row[:version], line ].reject(&:empty?).join("\n") : unparsed_records(number)
             end
           end
           @rows << row if row
-          totals.each { |total| mismatch(total, @rows.size) }
+          totals.each { |total| count_mismatch(total, @rows.size) }
           @empty = true if totals == [ 0 ] && @rows.empty?
           @rows.reject! do |entry|
             entry[:neighbor_name] ||= entry[:device_id].sub(/\([^)]*\)\z/, "").split(".").first

data/lib/vxlan/cisco_nxos/parsers/show_interface_brief.rb

@@ -16,7 +16,7 @@ module Vxlan
         # 解析当前命令的记录，保留无法识别行的诊断。
         def parse_rows(text)
           layout = nil
-          lines(text) do |line, number|
+          each_content_line(text) do |line, number|
             if line.match?(/\A(?:Port\s+VRF\s+Status\s+IP Address(?:\s+Speed\s+MTU)?|(?:Port|Interface)\s+Name\s+Status\s+Vlan\s+Duplex\s+Speed\s+Type|(?:Ethernet|Port-channel)\s+VLAN\s+Type\s+Mode\s+Status\s+Reason\s+Speed\s+(?:Port|Protocol)|Interface\s+Status\s+Description|Interface\s+Secondary VLAN\(Type\)\s+Status Reason|Port\s+Status Reason\s+MTU)\z/i)
               layout = line
               @header = true
@@ -26,7 +26,7 @@ module Vxlan
               words = line.split
               state = words.index { |word| %w[up down connected notconnect disabled admin-down].include?(word.downcase) }
               unless layout && state && INTERFACE.match?(words[0])
-                reject(number)
+                unparsed_records(number)
                 next
               end
               row = { interface: words[0], state: words[state].downcase, detail: words.drop(state + 1).join(" ") }
@@ -37,38 +37,38 @@ module Vxlan
                   row.merge!(vrf: words[1], ip_address: words[3])
                   row.merge!(speed: words[4], mtu: words[5].to_i) if words.size == 6
                 else
-                  reject(number)
+                  unparsed_records(number)
                   next
                 end
               when /\A(?:Ethernet|Port-channel)\s+VLAN/i
                 unless state == 4 && words.size >= 8
-                  reject(number)
+                  unparsed_records(number)
                   next
                 end
                 row.merge!(vlan: words[1], type: words[2], mode: words[3], reason: words[5...-2].join(" "), speed: words[-2])
                 row[layout.start_with?("Ethernet") ? :port_channel : :protocol] = words[-1]
               when /\AInterface\s+Status/i
                 unless state == 1
-                  reject(number)
+                  unparsed_records(number)
                   next
                 end
                 row[:description] = words.drop(2).join(" ")
               when /\AInterface\s+Secondary/i
                 unless state >= 2
-                  reject(number)
+                  unparsed_records(number)
                   next
                 end
                 row.merge!(secondary_vlan: words[1...state].join(" "), reason: words.drop(state + 1).join(" "))
               when /\APort\s+Status Reason/i
                 unless state == 1 && words.size >= 4 && words.last.match?(/\A\d+\z/)
-                  reject(number)
+                  unparsed_records(number)
                   next
                 end
                 row.merge!(reason: words[2...-1].join(" "), mtu: words.last.to_i)
               else
                 match = /\A\S+\s+(.*?)\s+(connected|notconnect|disabled|admin-down|up|down)\s+(\d+|routed|trunk|unassigned|--)\s+(full|half|a-full|a-half|auto|--)\s+(\S+)\s+(.+)\z/i.match(line)
                 unless match
-                  reject(number)
+                  unparsed_records(number)
                   next
                 end
                 row.merge!(name: match[1], state: match[2].downcase, vlan: match[3], duplex: match[4], speed: match[5], type: match[6],