vxlan 0.1.0

data/lib/vxlan/cisco_nxos/configuration_parsing/policies.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Vxlan
+  module CiscoNxos
+    module ConfigurationParsing
+      # 前缀列表与路由映射保留地址族及引用选择器。
+      module Policies
+        private
+
+        # 解析有序 IP 前缀列表条目及匹配边界。
+        def prefix_list(block, lists, family:)
+          return ignore(block) if /\A(?:ip|ipv6) prefix-list \S+ description .+\z/.match?(block.text)
+          match = /\A(?:ip|ipv6) prefix-list (\S+) seq (\d+) (permit|deny) (\S+)(?: ge (\d+))?(?: le (\d+))?\z/.match(block.text)
+          raise ArgumentError unless match
+          subnet = network_prefix(match[4], family: family)
+          length, width = IPAddr.new(subnet).prefix, family == "ipv6" ? 128 : 32
+          ge, le = match[5]&.to_i, match[6]&.to_i
+          raise ArgumentError if (ge && !(length..width).cover?(ge)) || (le && !((ge || length)..width).cover?(le))
+          entries = (lists[match[1]] ||= [])
+          sequence = integer(match[2], 1..4_294_967_295)
+          raise ArgumentError if entries.any? { |entry| entry[:sequence] == sequence }
+          entries << { sequence: sequence, action: match[3], prefix: subnet, ge: ge, le: le }
+          collection = family == "ipv6" ? :ipv6_prefix_lists : :prefix_lists
+          capture(block, entries.last, [ collection, match[1], entries.size - 1 ])
+        end
+
+        # 解析有序 route-map 条目及策略引用。
+        def route_map(block)
+          values = { prefix_lists: [], additional_matches: [], sets: [] }
+          analyze_children(block) do |child|
+            case child.text
+            when /\Amatch (ip|ipv6) (address|next-hop|route-source) prefix-list (.+)\z/
+              family, selector, names = $1 == "ip" ? "ipv4" : "ipv6", $2, $3.split
+              values[:prefix_lists].concat(names) if family == "ipv4" && selector == "address"
+              (values[:prefix_list_matches] ||= []) << { address_family: family, selector: selector, names: names }
+            when /\Amatch / then values[:additional_matches] << child.text
+            when /\Aset / then values[:sets] << child.text
+            when /\Adescription / then ignore(child)
+            else issue(child)
+            end
+          end
+          values
+        end
+
+        # 归一化已配置的网络前缀及所属地址族。
+        def network_prefix(value, family: nil)
+          unless value.is_a?(String) && /\A[0-9a-f:.]+\/\d+\z/i.match?(value)
+            raise ArgumentError, "A network prefix is required"
+          end
+          network = IPAddr.new(value)
+          raise ArgumentError if family == "ipv4" && !network.ipv4? || family == "ipv6" && !network.ipv6?
+
+          "#{network}/#{network.prefix}"
+        end
+      end
+    end
+  end
+end

data/lib/vxlan/cisco_nxos/configuration_parsing/routing.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Vxlan
+  module CiscoNxos
+    module ConfigurationParsing
+      # 路由作用域保留邻居、模板、VRF 与地址族的归属。
+      module Routing
+        private
+
+        # 解析支持的路由作用域及协议关系。
+        def routing(block, protocol)
+          values = { vrfs: {}, neighbors: {}, templates: {}, address_families: {}, redistribute: [] }
+          analyze_children(block) do |child|
+            case child.text
+            when /\Avrf (\S+)\z/ then store(values[:vrfs], $1, child, path: @source_path + [ :vrfs, $1 ]) { routing(child, protocol) }
+            when /\Atemplate peer (\S+)\z/ then store(values[:templates], $1, child, path: @source_path + [ :templates, $1 ]) { routing(child, protocol) }
+            when /\Aneighbor (\S+)\z/ then store(values[:neighbors], $1, child, path: @source_path + [ :neighbors, $1 ]) { routing(child, protocol) }
+            when /\Aaddress-family (.+)\z/ then store(values[:address_families], $1, child, path: @source_path + [ :address_families, $1 ]) { routing(child, protocol) }
+            when /\Arouter-id (\S+)\z/ then values[:router_id] = address($1)
+            when /\Aremote-as (\S+)\z/
+              value = $1
+              integer(value, 1..4_294_967_295) unless %w[internal external].include?(value)
+              values[:remote_as] = value
+            when /\Ainherit peer (\S+)\z/ then values[:inherit_peer] = $1
+            when /\Aupdate-source (\S+)\z/ then values[:update_source] = $1
+            when /\Adescription (.+)\z/ then values[:description] = $1
+            when /\Aroute-map (\S+) (in|out)\z/
+              name, direction = $1, $2.to_sym
+              maps = (values[:route_maps] ||= {})
+              raise ArgumentError if maps.key?(direction)
+
+              maps[direction] = name
+            when /\A(no )?next-hop-self( all)?\z/
+              values[:next_hop_self], values[:next_hop_self_all] = $1.nil?, $1.nil? && !$2.nil?
+            when /\A(no )?(bfd|route-reflector-client|advertise-pip|advertise l2vpn evpn)\z/
+              enabled, setting = $1.nil?, $2
+              key = { "bfd" => :bfd, "route-reflector-client" => :route_reflector_client,
+                "advertise-pip" => :advertise_pip, "advertise l2vpn evpn" => :advertise_l2vpn_evpn }.fetch(setting)
+              values[key] = enabled
+            when /\A(no )?send-community(?: (extended|both))?\z/
+              enabled, kind = $1.nil?, $2
+              values[:standard_community] = enabled unless kind == "extended"
+              values[:extended_community] = enabled if kind
+            when /\Anetwork (\S+)(?: route-map (\S+))?\z/
+              subnet, route_map = $1, $2
+              raise ArgumentError unless protocol == :bgp
+
+              (values[:networks] ||= []) << { prefix: network_prefix(subnet), route_map: route_map }.compact
+            when /\Aredistribute (\S+)(?: (?!route-map\b)(\S+))?(?: route-map (\S+))?\z/
+              values[:redistribute] << { protocol: $1, process: $2, route_map: $3 }.compact
+            when /\Aretain route-target (all|route-map \S+)\z/ then values[:retain_route_target] = $1
+            when /\A(?:no )?(?:log-neighbor-changes|log-adjacency-changes|soft-reconfiguration inbound|passive-interface)\b/,
+              /\A(?:maximum-paths|default-information originate|auto-cost reference-bandwidth)\b/ then ignore(child)
+            else issue(child)
+            end
+          end
+          values
+        end
+      end
+    end
+  end
+end

data/lib/vxlan/cisco_nxos/evpn_l2route.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+
+module Vxlan
+  module CiscoNxos
+    # 按声明列解析 MAC、MAC-IP 行，仅将续行关联到已确认的前一条路由。
+    class EvpnL2route < Parser
+      UINT32 = 0..4_294_967_295
+      LABELS = { "topology" => :topology_id, "topology id" => :topology_id, "mac address" => :mac,
+        "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
+
+      private
+
+      # 解析命令表格行，保留数量及格式错误行诊断。
+      def parse_rows(text)
+        type = self.class::TYPE
+        @totals = []
+        fields = previous = nil
+        text.each_line.with_index(1) do |source, number|
+          line = source.strip
+          next if line.empty? || line.match?(/\A[-=\s]+\z/) || line.match?(/\A(?:Flags\s*-\s*)?(?:\([A-Za-z0-9]+\):[A-Za-z0-9 ,\/-]+\s*)+\z/)
+          if line.match?(/\ATopology\b/i)
+            labels = line.gsub(/\s+/, " ").scan(HEADER)
+            fields = labels.map { |label| LABELS.fetch(label.downcase) }
+            required = %i[topology_id mac producer next_hops] + (type == :mac_ip ? [ :host_ip ] : [])
+            unless line.gsub(/\s+/, " ").gsub(HEADER, "").strip.empty? && fields.uniq == fields &&
+              (required - fields).empty? && (fields - required - %i[flags sequence]).empty? &&
+              fields.first(2) == %i[topology_id mac] && fields.last == :next_hops
+              fields = nil
+              @issues << { code: :unknown_header, line: number }
+            end
+            previous = nil
+          elsif line.match?(/\ANo (?:MAC(?:-IP)? )?(?:routes|entries)(?: found)?\.?\z/i)
+            @empty = true
+            previous = nil
+          elsif (match = /\ATotal (?:number of )?(?:MAC(?:-IP)? )?(?:routes|entries)(?: displayed)?\s*:\s*(\d+)\z/i.match(line))
+            @totals << match[1].to_i
+            previous = nil
+          else
+            begin
+              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)
+                @rows << previous
+              elsif previous && source.match?(/\A\s+/)
+                previous[:next_hops] = (previous[:next_hops] + next_hops(line)).uniq
+              else
+                raise ArgumentError
+              end
+            rescue ArgumentError, IPAddr::Error
+              previous = nil
+              @issues << { code: :unparsed_row, line: number }
+            end
+          end
+        end
+      end
+
+      # 汇总已解析记录，并报告未解决或不完整的来源状态。
+      def finish(complete)
+        @totals.each { |count| mismatch(count, @rows.size) }
+        remove_duplicates(@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
+        CtxParser::Result.new(status: @issues.empty? ? :complete : :partial, records: @rows, issues: @issues)
+      end
+
+      # 归一化单条 EVPN 路由及回显的身份字段。
+      def route(values, type)
+        values[:topology_id] = number(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(values[:mac])
+        values[:sequence] = number(values[:sequence]) if values[:sequence]
+        values[:host_ip] = host(values.fetch(:host_ip)) if type == :mac_ip
+        values[:next_hops] = next_hops(values.fetch(:next_hops))
+        values
+      end
+
+      # 归一化 EVPN 路由关联的全部下一跳。
+      def 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)
+          raise ArgumentError unless match
+          token = match[:hop]
+          value = case token
+          when /\ALocal\z/i then { local: true }
+          when /\AIfindex\s+(\d+)\z/i then { ifindex: number($1) }
+          when /\A(?:Eth|Po|nve|Lo|Vlan|vPC)/i then { interface: token }
+          else { address: host(token) }
+          end
+          value[:label] = number(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?(",")
+        end
+        raise ArgumentError if result.empty?
+        result
+      end
+
+      # 解析数值测量，不将未知文本转换为零。
+      def number(value)
+        CtxParser::Values.integer(value, max: UINT32.end)
+      end
+
+      # 归一化主机地址，保留 IPv4 与 IPv6 语义。
+      def host(value)
+        CtxParser::Values.host(value, allow_zone: true)
+      end
+    end
+  end
+end

data/lib/vxlan/cisco_nxos/parser.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "ctx_parser/parser"
+require "ctx_parser/records"
+require "ctx_parser/input"
+require "ctx_parser/values"
+
+module Vxlan
+  module CiscoNxos
+    # NX-OS 清单完整要求格式、空表证据与采集完整性均经过校验。
+    class Parser < CtxParser::Parser
+      EMPTY = nil
+      IDENTITY = nil
+      BOUNDARY = nil
+      UNSUPPORTED = /^\s*(?:%\s*)?(?:Invalid (?:command|input)\b.*|(?:This command is )?not supported\.?|(?:ERROR:\s*)?Feature\b.*not enabled\.?)\s*$/i
+
+      private
+
+      # 解释当前命令回显，保留不支持或格式错误的证据。
+      def parse_output(text, complete:)
+        begin
+          text = CtxParser::Input.text(text, allow_nul: true)
+        rescue EncodingError
+          return CtxParser::Result.new(status: :partial, issues: [ { code: :invalid_encoding } ])
+        end
+        if self.class::UNSUPPORTED&.match?(text)
+          return CtxParser::Result.new(status: :unsupported, issues: [ { code: :command_unsupported } ])
+        end
+
+        @issues, @rows, @empty, @header = [], [], false, false
+        parse_content(normalize(text), complete: complete)
+        finish(complete)
+      end
+
+      # 解析 NX-OS 表格前，先归一化终端回车符。
+      def normalize(text) = CtxParser::Input.text(text, newlines: :delete_cr, allow_nul: true)
+
+      # 分别解析各路由作用域，或分派单个命令表。
+      def parse_content(text, complete:)
+        return if self.class::BOUNDARY && parse_scopes(text, complete: complete)
+
+        parse_rows(text)
+      end
+
+      # 汇总已解析记录，并报告未解决或不完整的来源状态。
+      def finish(complete)
+        @issues << { code: :missing_completeness_evidence } if @rows.empty? && !@empty
+        @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
+        CtxParser::Result.new(status: @issues.empty? ? :complete : :partial, records: @rows, issues: @issues)
+      end
+
+      # 逐 VRF、进程独立检查，避免完整表掩盖同级表截断。
+      def parse_scopes(text, complete:)
+        blocks = text.split(/(?=#{self.class::BOUNDARY})/).reject { |block| block.strip.empty? }
+        return false unless blocks.size > 1
+
+        results = blocks.map { |block| self.class.parse(block, complete: complete) }
+        @rows = results.flat_map(&:records)
+        @issues = results.flat_map(&:issues)
+        @header = results.all?(&:complete?) || @rows.any?
+        @empty = results.all? { |result| result.complete? && result.records.empty? }
+        true
+      end
+
+      # 逐行提供有效表格内容，并记录明确空表证据。
+      def lines(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/))
+          if self.class::EMPTY && line.match?(/\A(?:No #{self.class::EMPTY}(?: found)?|0 #{self.class::EMPTY})\.?\z/i)
+            @empty = true
+            next
+          end
+          yield line, number
+        end
+      end
+
+      # 记录声明总数与实际解析数量不一致的情况。
+      def mismatch(expected, observed)
+        @issues << { code: :count_mismatch, expected: expected, observed: observed } unless expected == observed
+      end
+
+      # 记录不支持或无效的行，不将其接受为完整证据。
+      def reject(number)
+        @issues << { code: :unparsed_row, line: number }
+      end
+
+      # 校验主机地址有效性，不让格式错误值继续传播。
+      def valid_host?(value)
+        CtxParser::Values.valid_host?(value, allow_zone: true)
+      end
+
+      # 返回可作为权威清单的结果前，先识别身份冲突。
+      def remove_duplicates(rows, fields, &identity)
+        identities = CtxParser::Records.new(rows, identity: fields, &identity)
+        return unless identities.duplicates?
+        rows.replace(identities.unambiguous)
+        @issues << { code: :duplicate_identity, count: identities.duplicate_identity_count }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Vxlan
+  module CiscoNxos
+    module Parsers
+      # 从 BGP 汇总解析 EVPN 邻居状态及可选路由类型统计。
+      class ShowBgpL2vpnEvpnSummary < Parser
+        EMPTY = "(?:BGP )?neighbors"
+        IDENTITY = %i[vrf address_family peer_ip].freeze
+        BOUNDARY = /^\s*BGP summary information for VRF /
+        HEADER = /\ANeighbor\s+V\s+AS\s+MsgRcvd\s+MsgSent\s+TblVer\s+InQ\s+OutQ\s+Up\/Down\s+State\/PfxRcd\z/i
+        ROW = /\A([\da-f:.]+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+)\z/i
+        FIELDS = %i[peer_ip version remote_as messages_received messages_sent table_version input_queue output_queue uptime state].freeze
+        INTEGERS = %i[version remote_as messages_received messages_sent table_version input_queue output_queue].freeze
+
+        private
+
+        # 解析命令表格行，保留数量及格式错误行诊断。
+        def parse_rows(text)
+          scope, prefix_columns, prefix_seen = {}, nil, []
+          lines(text) do |line, number|
+            if HEADER.match?(line)
+              @header = true
+            elsif (match = /\ABGP summary information for VRF (\S+), address family (.+)/.match(line))
+              scope = { vrf: match[1], address_family: match[2] }
+              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 valid_host?(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
+              words = line.split
+              peer = @rows.find { |row| row[:peer_ip] == words[0] && row[:vrf] == scope[:vrf] }
+              if words.size == prefix_columns.size + 4 && %w[I E].include?(words[1]) && words.drop(2).all? { |word| word.match?(/\A\d+\z/) } &&
+                peer && !prefix_seen.include?(peer.object_id) && peer[:remote_as] == words[2].to_i && peer[:prefixes_received] == words[3].to_i
+                peer[:prefixes_by_type] = prefix_columns.zip(words.drop(4).map(&:to_i)).to_h
+                prefix_seen << peer.object_id
+              else
+                reject(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 valid_host?(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)
+                next
+              end
+              row[:state] = row[:state].downcase.tr(" ", "_")
+              row[:prefixes_received] = row[:state].match?(/\A\d+\z/) ? row[:state].to_i : nil
+              row[:state] = "established" if row[:prefixes_received]
+              @rows << 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)
+            end
+          end
+          if prefix_columns && prefix_seen.size != @rows.size
+            @issues << { code: :missing_prefix_statistics, expected: @rows.size, observed: prefix_seen.size }
+          end
+        end
+
+        # 归一化平台值，同时保留未知或不支持的状态。
+        def normalize(text)
+          output = []
+          super.each_line do |line|
+            if output.last&.strip&.end_with?("State/") && line.strip == "PfxRcd"
+              output[-1] = output.last.rstrip + line.strip + "\n"
+            else
+              output << line
+            end
+          end
+          output.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Vxlan
+  module CiscoNxos
+    module Parsers
+      # 在所属邻居记录内解释 CDP 详细字段。
+      class ShowCdpNeighborsDetail < Parser
+        EMPTY = "(?:CDP neighbors|CDP entries|neighbors|entries)".freeze
+        IDENTITY = %i[device_id interface neighbor_interface].freeze
+
+        private
+
+        # 解析当前命令的记录，保留无法识别行的诊断。
+        def parse_rows(text)
+          row, scope, totals = nil, nil, []
+          lines(text, separators: true) do |line, number|
+            if line.match?(/\A[-=+\s]+\z/)
+              scope = nil
+              next
+            end
+            if (match = /\ATotal (?:entries|cdp entries) displayed\s*:\s*(\d+)\z/i.match(line))
+              totals << match[1].to_i
+              scope = nil
+              next
+            end
+            if (match = /\ADevice ID:\s*(\S.*)\z/i.match(line))
+              @rows << row if row
+              row = { device_id: match[1], interface_addresses: [], management_addresses: [], attributes: {} }
+              scope = nil
+              @header = true
+              next
+            end
+            unless row
+              reject(number)
+              next
+            end
+            case line
+            when /\A--More--/i then reject(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
+            when /\AIP(?:v[46])? Address:\s*(\S+)\z/i
+              value = $1
+              if %i[interface_addresses management_addresses].include?(scope) && valid_host?(value)
+                row[scope] << IPAddr.new(value).to_s
+              else
+                reject(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)
+              row.merge!(interface: $1, neighbor_interface: $2)
+              scope = nil
+            when /\AHoldtime:\s*(\d+) sec\z/i then row[:holdtime] = $1.to_i
+            when /\AVersion:\z/i
+              scope = :version
+              row[:version] = ""
+            when /\A((?:Local|Remote) Interface MAC):\s*([\da-f]{2}(?::[\da-f]{2}){5})\z/i
+              row[:attributes][$1.downcase.tr(" ", "_").to_sym] = $2.downcase
+              scope = nil
+            when /\A(Advertisement Version|Duplex|MTU|Native VLAN|VTP Management Domain|Physical Location|DC_UUID):\s*(.+)\z/i
+              row[:attributes][$1.downcase.tr(" ", "_").to_sym] = $2
+              scope = nil
+            else
+              scope == :version ? row[:version] = [ row[:version], line ].reject(&:empty?).join("\n") : reject(number)
+            end
+          end
+          @rows << row if row
+          totals.each { |total| 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
+            if entry.values_at(:neighbor_name, :interface, :neighbor_interface).any? { |value| value.nil? || value.empty? }
+              @issues << { code: :incomplete_cdp_neighbor }
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Vxlan
+  module CiscoNxos
+    module Parsers
+      # 根据响应表头解释接口汇总列。
+      class ShowInterfaceBrief < Parser
+        EMPTY = "interfaces".freeze
+        IDENTITY = %i[interface].freeze
+        INTERFACE = /\A(?:mgmt\d+|Eth(?:ernet)?\d[\w\/.-]*|Po\d+|port-channel\d+|Vlan\d+|Lo\d+|loopback\d+|nve\d+)\z/i
+
+        private
+
+        # 解析当前命令的记录，保留无法识别行的诊断。
+        def parse_rows(text)
+          layout = nil
+          lines(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
+            elsif line.match?(/\AInterface(?:\s+Ch #)?\z/i)
+              next
+            else
+              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)
+                next
+              end
+              row = { interface: words[0], state: words[state].downcase, detail: words.drop(state + 1).join(" ") }
+              case layout
+              when /\APort\s+VRF/i
+                if state == 2 && [ 4, 6 ].include?(words.size) && (words.size == 4 || words[5].match?(/\A\d+\z/)) &&
+                  (words[3] == "--" || valid_host?(words[3]))
+                  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)
+                  next
+                end
+              when /\A(?:Ethernet|Port-channel)\s+VLAN/i
+                unless state == 4 && words.size >= 8
+                  reject(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)
+                  next
+                end
+                row[:description] = words.drop(2).join(" ")
+              when /\AInterface\s+Secondary/i
+                unless state >= 2
+                  reject(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)
+                  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)
+                  next
+                end
+                row.merge!(name: match[1], state: match[2].downcase, vlan: match[3], duplex: match[4], speed: match[5], type: match[6],
+                  detail: match.captures.drop(2).join(" "))
+              end
+              @rows << row
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Vxlan
+  module CiscoNxos
+    module Parsers
+      # 逐进程、VRF 独立核对 OSPF 邻居总数。
+      class ShowIpOspfNeighbors < Parser
+        EMPTY = "(?:OSPF )?neighbors"
+        IDENTITY = %i[process vrf neighbor_id interface].freeze
+        BOUNDARY = /^\s*OSPF Process ID /
+        HEADER = /\ANeighbor ID\s+Pri\s+State\s+Up Time\s+Address\s+Interface\z/i
+        ROW = /\A([\d.]+)\s+(\d+)\s+(\S+(?:\/\s*\S+)?)\s+(\S+)\s+([\d.]+)\s+(\S+)\z/
+        FIELDS = %i[neighbor_id priority state uptime address interface].freeze
+
+        private
+
+        # 解析命令表格行，保留数量及格式错误行诊断。
+        def parse_rows(text)
+          scope, totals = {}, []
+          lines(text) do |line, number|
+            if HEADER.match?(line)
+              @header = true
+            elsif (match = /\AOSPF Process ID (\S+) VRF (\S+)\z/i.match(line))
+              scope = { process: match[1], vrf: match[2] }
+            elsif (match = /\ATotal number of neighbors:\s*(\d+)\z/i.match(line))
+              totals << match[1].to_i
+            elsif (match = ROW.match(line))
+              row = FIELDS.zip(match.captures).to_h.merge(scope)
+              row[:priority] = row[:priority].to_i
+              unless valid_host?(row[:neighbor_id]) && valid_host?(row[:address]) && (0..255).cover?(row[:priority]) &&
+                row[:state].match?(/\A(?:DOWN|ATTEMPT|INIT|2WAY|EXSTART|EXCHANGE|LOADING|FULL)\/(?:\s*(?:DR|BDR|DROTHER|-))\z/i)
+                reject(number)
+                next
+              end
+              @rows << row.merge(state: row[:state].downcase.delete(" "))
+            else
+              reject(number)
+            end
+          end
+          totals.each { |count| mismatch(count, @rows.size) }
+          @empty = true if @rows.empty? && totals == [ 0 ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../evpn_l2route"
+
+module Vxlan
+  module CiscoNxos
+    module Parsers
+      # 解析 show l2route evpn mac all 的 CLI 回显。
+      class ShowL2routeEvpnMacAll < EvpnL2route
+        TYPE = :mac
+      end
+    end
+  end
+end