ctx_checker 0.1.0

data/lib/ctx_checker/cisco_ios/parsers/show_interfaces.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+require "ctx_parser/result_set"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # 同一接口详细回显分别提供状态与计数器观测。
+      class ShowInterfaces < CtxChecker::Parsers::Base
+        PLATFORM = :cisco_ios
+        HEADER = /\A(\S+) is (administratively down|up|down|reset|deleted)(?:, line protocol is (up|down)(?: \([^)]*\))?)?(?:\s*\([^)]*\))?(?:\s*,\s*Autostate (?:Enabled|Disabled))?\s*\z/i
+        COUNTERS = { in_errors: /(?<!\S)(\d+) input errors?\b/i, out_errors: /(?<!\S)(\d+) output errors?\b/i,
+          crc_errors: /(?<!\S)(\d+) CRC(?:\/FCS)?\b/i, in_discards: /(?<!\S)(\d+) input discards?\b/i,
+          out_discards: /(?<!\S)(\d+) output discards?\b/i }.freeze
+        COUNTER_LABELS = { in_errors: /\binput errors?\b/i, out_errors: /\boutput errors?\b/i,
+          crc_errors: /\bCRC(?:\/FCS)?\b/i, in_discards: /\binput discards?\b/i, out_discards: /\boutput discards?\b/i }.freeze
+        AUXILIARY = /\A(?:Hardware[: ]|Description:|Internet address|MTU |reliability |Encapsulation |Keepalive |Full-duplex|Half-duplex|full-duplex|half-duplex|Auto-duplex|auto-duplex|Input flow-control|Output flow-control|ARP type:|Last input |Last clearing |Input queue:|Output queue:|Queueing strategy:|[\d ]+(?:second|minute) (?:input|output) rate|[\d ]+(?:packets input|packets output|bytes|no buffer|broadcasts|multicasts|runts|giants|watchdog|output buffer|lost carrier|unknown protocol drops|interface resets|carrier transitions|collisions|babbles|underruns)|Received |Output feature|L2 Switched:|L3 in Switched:|L3 out Switched:|Port mode is |Beacon is |Auto-Negotiation is |FEC mode is |Flowcontrol|Switchport monitor|EtherType is |Members in this channel:|Last link flapped |Last link change |Last input change |[\d ]+interface resets|Load-Interval |Input rate |Output rate |RX\z|TX\z|[\d ]+(?:unicast packets|input packets|output packets|jumbo packets|Rx pause|Tx pause|storm suppression)|Tunnel |tunnel |Transport |Destination |Source |DTR is |[\d ]+packets,|BW |Mode is |IP address is |Port-channel is |admin state is |[\d ]+bad etype drop|Last clearing of)/i
+
+        private
+
+        # 分别跟踪覆盖率；有效状态头不能证明计数器已采集。
+        def parse_output(text, complete:)
+          text = clean(text)
+          interfaces, counters, state_issues, counter_issues = [], [], [], []
+          current = nil
+          text.each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty?
+
+            if (match = interface_header(line))
+              current = interface_record(match)
+              interfaces << current
+            elsif (match = /\A(\S+) is /.match(line)) && CtxChecker::Parsers::InterfaceNames.kind(normalize_name(match[1])) != :unknown
+              current = nil
+              state_issues << { code: :unparsed_interface_header, line: number }
+            elsif current && (match = /\Aadmin state is (up|down)\b/i.match(line))
+              current[:admin_status] = match[1].downcase.to_sym
+            elsif current && (match = /\ALine protocol is (up|down)\b/i.match(line))
+              current[:protocol_status] = match[1].downcase.to_sym
+            elsif current && (match = /\ALast clearing of "show interfaces?" counters\s+(.+)\z/i.match(line))
+              # 相对清零时长不能证明两个采样间的计数器连续性。
+              current[:discontinuity] = nil
+            elsif current && /\ADescription:/i.match?(line)
+              next
+            elsif current && counter_line?(line)
+              found = counter_patterns.flat_map do |metric, pattern|
+                source = counter_source(line, metric)
+                values = source.scan(pattern).flatten
+                if values.size != source.scan(counter_labels.fetch(metric)).size
+                  counter_issues << { code: :invalid_counter_value, metric: metric, line: number }
+                end
+                values.map { |value| { interface: current[:name], metric: metric, value: Integer(value, 10), discontinuity: nil } }
+              end
+              output_drops = line.scan(/\bTotal output drops:\s*(\d+)(?=\s*(?:;|\z))/i).flatten
+              output_drops.each do |value|
+                # IOS-XE 此处可能显示字节数或包数，取决于平台配置。
+                found << { interface: current[:name], metric: :out_discards, value: Integer(value, 10), discontinuity: nil,
+                  unit: :unknown, scope: :queue }
+              end
+              if output_drops.size != line.scan(/\bTotal output drops:/i).size
+                counter_issues << { code: :invalid_counter_value, metric: :out_discards, line: number }
+              end
+              if (match = /\AInput queue:\s*\d+\/\d+\/(\d+)(?:\/\d+)?\s+\(size\/max\/drops(?:\/flushes)?\)/i.match(line))
+                found << { interface: current[:name], metric: :in_discards, value: Integer(match[1], 10), discontinuity: nil,
+                  unit: :packets, scope: :queue }
+              elsif line.match?(/\AInput queue:.*drops/i)
+                counter_issues << { code: :invalid_counter_value, metric: :in_discards, line: number }
+              end
+              counters.concat(found)
+              counter_issues << { code: :unparsed_counter, line: number } if found.empty?
+            elsif current && interface_detail(current, line)
+              next
+            elsif current && auxiliary?(line)
+              next
+            else
+              state_issues << { code: :unparsed_row, line: number }
+            end
+          end
+          discontinuities = interfaces.to_h { |record| [ record[:name], record.delete(:discontinuity) ] }
+          counters.each { |record| record[:discontinuity] = discontinuities[record[:interface]] }
+          counters_by_interface = counters.group_by { |counter| counter[:interface] }
+          interfaces.select { |record| record[:kind] == :physical }.each do |record|
+            counters.concat(complete_counter_coverage(record, counters_by_interface.fetch(record[:name], []), counter_issues))
+          end
+          CtxParser::ResultSet.new(results: {
+            interfaces: build_result(interfaces, complete: complete, recognized: interfaces.any?, issues: state_issues, identity: [ :name ]),
+            counters: build_result(counters, complete: complete, recognized: counters.any?, issues: state_issues + counter_issues,
+              identity: %i[interface metric])
+          })
+        end
+
+        # 按计数器标签匹配，不误取总包数，并保留格式错误的指标行。
+        def counter_line?(line)
+          line.match?(/\b(?:input errors?|output errors?|CRC(?:\/FCS)?|input discards?|output discards?|Total output drops)\b/i) ||
+            line.match?(/\AInput queue:.*drops/i)
+        end
+
+        # 将接口别名归一化为平台标准身份。
+        def normalize_name(name) = CtxChecker::Parsers::InterfaceNames.normalize(name, platform: self.class::PLATFORM)
+
+        # 平台语法覆盖独立于公共计数器提取逻辑。
+        def interface_header(line) = HEADER.match(line)
+        # 将平台特有的详细行留给子类扩展点处理。
+        def interface_detail(_record, _line) = false
+        # 识别说明性回显，不将其作为数据记录。
+        def auxiliary?(line)
+          AUXILIARY.match?(line) || /\AOutput \d+ broadcasts \(\d+ (?:IP )?multicasts\)\z/i.match?(line) ||
+            /\AUnknown, Unknown, link type is \S+, media type is \S+\z/i.match?(line) || /\AFec is \S+\z/i.match?(line)
+        end
+        # 声明当前平台支持的接口错误与丢弃计数模式。
+        def counter_patterns = COUNTERS
+        # 将平台计数器标签映射到归一化指标名称。
+        def counter_labels = COUNTER_LABELS
+        # 标记这些计数测量来自哪个命令视图。
+        def counter_source(line, _metric) = line
+
+        # 物理端口健康需要明确的错误包与 CRC 测量证据。
+        def complete_counter_coverage(record, counters, issues)
+          missing = %i[in_errors out_errors crc_errors] - counters.map { |counter| counter[:metric] }
+          issues << { code: :counter_fields_missing, interface: record[:name], metrics: missing } if missing.any?
+          []
+        end
+
+        # 复用接口头字段及子接口身份，不虚构协议状态。
+        def interface_record(match)
+          name = normalize_name(match[1])
+          record = { name: name, kind: CtxChecker::Parsers::InterfaceNames.kind(name),
+            admin_status: match[2].casecmp?("administratively down") ? :down : :unknown,
+            oper_status: match[2].casecmp?("up") ? :up : :down,
+            protocol_status: match[3]&.downcase&.to_sym || :unknown, parent: nil }
+          record[:admin_status] = :up if self.class::PLATFORM == :cisco_ios && record[:admin_status] != :down
+          record[:parent] = name.split(".", 2).first if record[:kind] == :subinterface
+          record
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/show_interfaces_transceiver_detail.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # IOS DOM 按指标分表展示端口，其阈值顺序不同于 NX-OS。
+      class ShowInterfacesTransceiverDetail < CtxChecker::Parsers::Base
+        NUMBER = /(?:[+-]?\d+(?:\.\d+)?|N\/A|NA|--)/i
+        MARKERS = { "++" => :high_alarm, "+" => :high_warning, "--" => :low_alarm, "-" => :low_warning }.freeze
+
+        private
+
+        # 解析 show interfaces transceiver detail，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          text = clean(text)
+          rows, issues, ports = [], [], []
+          metric, header, lane_column = nil, false, false
+          text.each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty? || line.match?(/\A[-= ]+\z/)
+
+            if line.match?(/\bTransmit Power\b/i)
+              metric, header = :tx_power, false
+            elsif line.match?(/\bReceive Power\b/i)
+              metric, header = :rx_power, false
+            elsif line.match?(/\A(?:Temperature|Voltage|Current)\s+Threshold/i)
+              metric, header = :other, false
+            elsif line.match?(/\APort\s+(?:Lane\s+)?\(/i)
+              header = true
+              lane_column = line.match?(/\APort\s+Lane\s/i)
+            elsif interface_row?(line)
+              name = CtxChecker::Parsers::InterfaceNames.normalize(line.split.first, platform: :cisco_ios)
+              ports << name
+              if metric && header
+                next if metric == :other
+
+                row = measurement(line, metric, lane_column)
+                row ? rows << row : issues << { code: :unparsed_optical_measurement, line: number }
+              else
+                issues << { code: :missing_optical_header, line: number }
+              end
+            elsif auxiliary?(line)
+              next
+            else
+              issues << { code: :unparsed_row, line: number }
+            end
+          end
+          identities = rows.map { |row| row.values_at(:interface, :lane) }
+          identities.concat((ports.uniq - rows.map { |row| row[:interface] }).map { |name| [ name, nil ] })
+          identities.uniq.each do |name, lane|
+            %i[tx_power rx_power].each do |expected|
+              next if rows.any? { |row| row.values_at(:interface, :lane, :metric) == [ name, lane, expected ] }
+
+              issues << { code: :optical_measurement_missing, interface: name, lane: lane, metric: expected }
+            end
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, issues: issues, identity: %i[interface lane metric])
+        end
+
+        # 解析支持的传感器测量值及回显单位。
+        def measurement(line, metric, lane_column)
+          # 括号内 A2D 读数属于独立校准证据，不作为阈值。
+          normalized = line.gsub(/\(\s*#{NUMBER}\s*\)/i, "")
+          columns = normalized.split
+          name = CtxChecker::Parsers::InterfaceNames.normalize(columns.shift, platform: :cisco_ios)
+          lane = lane_column ? columns.shift : nil
+          lane = nil if lane && /\AN\/?A\z/i.match?(lane)
+          return if lane && !lane.match?(/\A\d+\z/)
+
+          current = columns.shift
+          marker = columns.shift if MARKERS.key?(columns.first)
+          return unless current&.match?(/\A#{NUMBER}\z/) && columns.size == 4 && columns.all? { |value| value.match?(/\A#{NUMBER}\z/) }
+
+          high_alarm, high_warning, low_warning, low_alarm = columns.map { |value| decimal(value) }
+          { interface: name, lane: lane && Integer(lane, 10), metric: metric, value: decimal(current), unit: :dbm,
+            low_alarm: low_alarm, low_warning: low_warning, high_warning: high_warning, high_alarm: high_alarm,
+            alarm: marker ? MARKERS.fetch(marker) : :normal, present: true, dom_supported: true }
+        end
+
+        # 区分接口数据行与表格标题。
+        def interface_row?(line)
+          name = CtxChecker::Parsers::InterfaceNames.normalize(line.split.first, platform: :cisco_ios)
+          CtxChecker::Parsers::InterfaceNames.kind(name) == :physical
+        end
+
+        # 解析有限小数，不将占位符转换为零。
+        def decimal(value)
+          return unless value.match?(/\A[+-]?\d+(?:\.\d+)?\z/)
+
+          parsed = Float(value)
+          return parsed if parsed.finite?
+
+          @issues << { code: :invalid_optical_value }
+          nil
+        end
+
+        # 识别说明性回显，不将其作为数据记录。
+        def auxiliary?(line)
+          line.match?(/\A(?:mA: |\+\+\s*:|A2D readouts |The threshold values |(?:Optical\s+)?High Alarm\s+High Warn\s+Low Warn\s+Low Alarm\z|Optical\z|ITU Channel |Transceiver is |Transceiver monitoring is |Wavelength |(?:Temperature|Voltage|Current)\s+Threshold)/i)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/show_ip_bgp_summary.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require "ctx_parser/values"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # 仅以 BGP 汇总表声明的最后一列作为权威会话状态。
+      class ShowIpBgpSummary < CtxChecker::Parsers::Base
+        ADDRESS_FAMILY = "ipv4_unicast".freeze
+        HEADER = /\ANeighbor\s+V\s+AS\s+MsgRcvd\s+MsgSent\s+TblVer\s+InQ\s+OutQ\s+Up\/Down\s+State\/PfxRcd\z/i
+        STATES = { "idle" => :idle, "active" => :active, "connect" => :connect, "opensent" => :opensent,
+          "openconfirm" => :openconfirm, "established" => :established, "shutdown" => :shutdown,
+          "idle (admin)" => :shutdown }.freeze
+
+        private
+
+        # 使用作用域与行身份，避免不同地址族或 VRF 相互覆盖。
+        def parse_output(text, complete:)
+          text = clean(text).gsub(/State\/\s*\n\s*PfxRcd/, "State/PfxRcd")
+          rows, issues = [], []
+          scope = { vrf: "default", afi_safi: self.class::ADDRESS_FAMILY }
+          sections = []
+          section = { header: false, empty: false, count: 0, scope_fields: [], scope: scope }
+          sections << section
+          pending = nil
+          text.each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty? || line.match?(/\A[-= ]+\z/)
+
+            if HEADER.match?(line)
+              section[:header] = true
+            elsif (change = parse_scope(line, scope, issues, number))
+              issues << { code: :truncated_peer } if pending
+              pending = nil
+              next_scope, declared_fields = change
+              if section[:header] || section[:empty] || section[:count].positive? || (section[:scope_fields] & declared_fields).any?
+                section = { header: false, empty: false, count: 0, scope_fields: [] }
+                sections << section
+              end
+              section[:scope_fields] |= declared_fields
+              scope = next_scope
+              section[:scope] = scope
+            elsif line.match?(/\A(?:No (?:BGP )?neighbors(?: found)?\.?|0 (?:BGP )?neighbors)\z/i)
+              section[:empty] = true
+            elsif parse_statistics(line, section, scope, issues, number)
+              next
+            elsif CtxParser::Values.valid_host?(line)
+              issues << { code: :unparsed_row, line: number - 1 } if pending
+              pending = line
+            elsif peer_row?(line) || (pending && line.match?(/\A4\s/))
+              line = "#{pending} #{line}" if pending
+              pending = nil
+              row = parse_peer(line, scope)
+              if row
+                rows << row
+                section[:count] += 1
+                issues << { code: :missing_neighbor_header, line: number } unless section[:header]
+              else
+                issues << { code: :unparsed_peer, line: number }
+              end
+            elsif auxiliary?(line)
+              next
+            else
+              issues << { code: :unparsed_row, line: number }
+            end
+          end
+          issues << { code: :truncated_peer } if pending
+          sections.each { |entry| validate_section(entry, issues) }
+          recognized = sections.any? { |entry| section_empty?(entry) || entry[:header] && entry[:count].positive? }
+          scopes = sections.filter_map do |entry|
+            entry[:scope] if section_empty?(entry) || entry[:header] && entry[:count].positive?
+          end
+          build_result(rows, complete: complete, recognized: recognized, issues: issues,
+            identity: %i[vrf afi_safi peer], covered_scopes: scopes)
+        end
+
+        # 识别协议对等体记录，排除摘要和表头。
+        def peer_row?(line) = CtxParser::Values.valid_host?(line.split.first.to_s)
+
+        # 解析单个路由作用域，不合并无关的 VRF 证据。
+        def parse_scope(line, scope, issues, number)
+          if (match = /\ABGP summary information for VRF (\S+), address family (.+)\z/i.match(line))
+            scope = scope.merge(vrf: match[1])
+            family = match[2]
+            declared_fields = %i[vrf afi_safi]
+          elsif (match = /\A(?:For address family:|Address family:)\s*(.+)\z/i.match(line))
+            family = match[1]
+            declared_fields = [ :afi_safi ]
+          elsif (match = /\A(?:BGP VRF|VRF:)\s+(\S+?)(?:,.*)?\z/i.match(line))
+            return [ scope.merge(vrf: match[1]), [ :vrf ] ]
+          elsif line.match?(/\A(?:BGP summary information\b|BGP VRF\b|VRF:|For address family:|Address family:)/i)
+            issues << { code: :invalid_protocol_scope, line: number }
+            return [ { vrf: nil, afi_safi: nil }, %i[vrf afi_safi] ]
+          else
+            return
+          end
+          normalized = address_family(family)
+          issues << { code: :unknown_address_family, line: number } unless normalized
+          [ scope.merge(afi_safi: normalized), declared_fields ]
+        end
+
+        # 允许平台扩展读取统计信息，但不放宽对等体行校验。
+        def parse_statistics(_line, _section, _scope, _issues, _number) = false
+
+        # 未采集到邻居记录时，仅明确空表声明足以证明为空。
+        def section_empty?(section) = section[:empty]
+
+        # 每张表都必须独立核对记录行与空表声明。
+        def validate_section(section, issues)
+          issues << { code: :contradictory_empty } if section_empty?(section) && section[:count].positive?
+          if (section[:header] || section[:scope_fields].any?) && section[:count].zero? && !section_empty?(section)
+            issues << { code: :neighbor_count_unavailable }
+          end
+        end
+
+        # 仅归一化支持的地址族；未知作用域保留为 nil。
+        def address_family(value)
+          { "ipv4 unicast" => "ipv4_unicast", "ipv6 unicast" => "ipv6_unicast",
+            "l2vpn evpn" => "l2vpn_evpn" }[value.downcase.split.join(" ")]
+        end
+
+        # 归一化单个路由对等体及其协议状态。
+        def parse_peer(line, scope)
+          match = /\A(\S+)\s+4\s+(\d+(?:\.\d+)?)\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\S+\s+(.+)\z/.match(line)
+          return unless match && CtxParser::Values.valid_host?(match[1])
+
+          remote_as = as_number(match[2])
+          return unless remote_as
+
+          state, prefixes = peer_state(match[3])
+          return unless state
+
+          scope.merge(peer: CtxParser::Values.host(match[1]), state: state, received_prefixes: prefixes, remote_as: remote_as)
+        end
+
+        # 仅在不存在平台附加标记时，末列数字才能证明会话已建立。
+        def peer_state(text)
+          raw_state = text.downcase
+          prefixes = Integer(raw_state, 10) if raw_state.match?(/\A\d+\z/)
+          [ prefixes ? :established : STATES[raw_state], prefixes ]
+        end
+
+        # 解析支持展示格式的 BGP 自治系统号。
+        def as_number(text)
+          parts = text.split(".").map { |value| Integer(value, 10) }
+          return if parts.size == 2 && parts.any? { |value| value > 65_535 }
+
+          value = parts.size == 2 ? parts[0] * 65_536 + parts[1] : parts.first
+          value if (1..4_294_967_295).cover?(value)
+        end
+
+        # 识别说明性回显，不将其作为数据记录。
+        def auxiliary?(line)
+          return true if /\A\d+\/\d+ BGP path\/bestpath attribute entries using \d+ bytes of memory\z/i.match?(line)
+          return true if /\A\d+ (?:BGP extended community entries using \d+ bytes of memory|received paths for inbound soft reconfiguration|networks peaked at .+)\z/i.match?(line)
+
+          line.match?(/\A(?:BGP router identifier |BGP table version |[\d ]+(?:network entries|path entries|BGP path attribute entries|BGP AS-PATH entries|BGP community entries|BGP route-map cache entries|BGP filter-list cache entries|paths using)|BGP using |BGP activity |BGP attribute entries |BGP community entries |BGP AS path entries |Neighbor sessions:|Memory used by BGP |BGP scan interval |Scan interval )/i)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/show_ip_ospf_neighbor.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+require "ctx_parser/values"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # OSPF 身份包含进程、VRF、接口和路由器 ID；未知作用域保留为 nil。
+      class ShowIpOspfNeighbor < CtxChecker::Parsers::Base
+        PLATFORM = :cisco_ios
+        STATES = { "FULL" => :full, "2WAY" => :two_way, "2-WAY" => :two_way, "DOWN" => :down,
+          "ATTEMPT" => :attempt, "INIT" => :init, "EXSTART" => :exstart, "EXCHANGE" => :exchange,
+          "LOADING" => :loading }.freeze
+
+        private
+
+        # 解析 show ip ospf neighbor，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          text = clean(text)
+          rows, issues = [], []
+          scope = { vrf: "default", process_id: nil, area: nil }
+          sections = []
+          section = { header: false, empty: false, count: 0, totals: [], declared: false, scope: scope }
+          sections << section
+          text.each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty? || line.match?(/\A[-= ]+\z/)
+
+            if line.match?(/\ANeighbor ID\s+Pri\s+State\s+(?:Dead Time|Up Time)\s+Address\s+Interface\z/i)
+              section[:header] = true
+            elsif (match = /\AOSPF\s+Process\s+ID\s+(\S+)\s+VRF\s+(\S+)\z/i.match(line))
+              scope = { vrf: match[2], process_id: match[1], area: nil }
+              section = { header: false, empty: false, count: 0, totals: [], declared: true, scope: scope }
+              sections << section
+            elsif (match = /\A(?:Process ID|OSPF Process(?!\s+ID\b))\s*:?\s*(\S+)(?:,?\s+VRF\s+(\S+))?\z/i.match(line))
+              scope = { vrf: match[2] || "default", process_id: match[1], area: nil }
+              section = { header: false, empty: false, count: 0, totals: [], declared: true, scope: scope }
+              sections << section
+            elsif line.match?(/\A(?:OSPF\s+Process\b|Process ID\b)/i)
+              issues << { code: :invalid_protocol_scope, line: number }
+              scope = { vrf: nil, process_id: nil, area: nil }
+              section = { header: false, empty: false, count: 0, totals: [], declared: true, scope: scope }
+              sections << section
+            elsif (match = /\ATotal number of neighbors:\s*(\d+)\z/i.match(line))
+              section[:totals] << Integer(match[1], 10)
+            elsif line.match?(/\A(?:No (?:OSPF )?neighbors(?: found)?\.?|0 (?:OSPF )?neighbors)\z/i)
+              section[:empty] = true
+            elsif (row = parse_neighbor(line, scope))
+              rows << row
+              section[:count] += 1
+            else
+              issues << { code: :unparsed_row, line: number }
+            end
+          end
+          sections.each do |entry|
+            entry[:totals].each do |total|
+              issues << { code: :count_mismatch, expected: total, observed: entry[:count] } unless total == entry[:count]
+            end
+            issues << { code: :contradictory_empty } if entry[:empty] && entry[:count].positive?
+            if entry[:count].positive? && !entry[:header]
+              issues << { code: :missing_neighbor_header }
+            elsif (entry[:header] || entry[:declared]) && entry[:count].zero? && !entry[:empty] && !entry[:totals].include?(0)
+              issues << { code: :neighbor_count_unavailable }
+            end
+          end
+          recognized = sections.any? { |entry| entry[:empty] || entry[:totals].include?(0) || entry[:header] && entry[:count].positive? }
+          scopes = sections.filter_map do |entry|
+            value = entry[:scope].slice(:vrf, :process_id)
+            value if value.values.none?(&:nil?) && (entry[:empty] || entry[:totals].include?(0) || entry[:header] && entry[:count].positive?)
+          end
+          build_result(rows, complete: complete, recognized: recognized, issues: issues,
+            identity: %i[vrf process_id interface router_id], covered_scopes: scopes)
+        end
+
+        # 解析协议邻居行的状态及稳定身份。
+        def parse_neighbor(line, scope)
+          match = /\A(\S+)\s+(\d+)\s+(FULL|2WAY|2-WAY|DOWN|ATTEMPT|INIT|EXSTART|EXCHANGE|LOADING)\/(?:\s*)(DR|BDR|DROTHER|-)\s+\S+\s+(\S+)\s+(\S+)\z/i.match(line)
+          return unless match && (0..255).cover?(Integer(match[2], 10)) &&
+            ipv4_address?(match[1]) && ipv4_address?(match[5])
+
+          scope.merge(interface: CtxChecker::Parsers::InterfaceNames.normalize(match[6], platform: self.class::PLATFORM),
+            router_id: CtxParser::Values.host(match[1]), neighbor_address: CtxParser::Values.host(match[5]),
+            state: STATES.fetch(match[3].upcase), network_type: :unknown, local_role: :unknown,
+            neighbor_role: match[4] == "-" ? :unknown : match[4].downcase.to_sym)
+        end
+
+        # OSPFv2 路由器 ID 与接口地址必须是 IPv4 主机地址。
+        def ipv4_address?(text)
+          text.match?(/\A\d+(?:\.\d+){3}\z/) && CtxParser::Values.valid_host?(text)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/show_ip_traffic.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # IP 协议栈计数为累计值，与 ASIC 和接口计数区分处理。
+      class ShowIpTraffic < CtxChecker::Parsers::Base
+        METRICS = {
+          "format errors" => [ "format_errors", :error ], "checksum errors" => [ "checksum_errors", :error ],
+          "bad hop count" => [ "bad_ttl", :error ], "unknown protocol" => [ "unknown_protocol", :error ],
+          "not a gateway" => [ "not_a_gateway", :discard ], "security failures" => [ "security_failures", :policy ],
+          "bad options" => [ "bad_options", :error ], "encapsulation failed" => [ "encapsulation_failed", :discard ],
+          "unresolved" => [ "unresolved", :discard ], "no adjacency" => [ "no_adjacency", :discard ],
+          "no route" => [ "no_route", :discard ], "unicast RPF" => [ "unicast_rpf", :policy ],
+          "forced drop" => [ "forced_drop", :discard ], "options denied" => [ "options_denied", :policy ],
+          "source IP address zero" => [ "source_address_zero", :discard ],
+          "ignored" => [ "options_ignored", :policy ], "invalid hole" => [ "invalid_hole", :error ],
+          "unsupported-addr" => [ "unsupported_address", :discard ],
+          "timeouts" => [ "reassembly_timeouts", :error ], "couldn't reassemble" => [ "reassembly_failed", :error ],
+          "couldn't fragment" => [ "fragmentation_failed", :error ]
+        }.freeze
+        INFORMATIONAL = /\A\d+ (?:total|local destination|with options|end|nop|basic security|loose source route|timestamp|extended security|record route|stream ID|strict source route|alert|cipso|ump|other|reassembled|fragmented|fragments|received|sent|generated|forwarded)\z/i
+        REQUIRED_METRICS = %w[format_errors checksum_errors bad_ttl unknown_protocol encapsulation_failed no_route].freeze
+
+        private
+
+        # 解析 show ip traffic，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          records, issues = [], []
+          active = false
+          recognized = false
+          clean(text).each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty?
+            if line == "IP statistics:"
+              active = recognized = true
+              next
+            end
+            if /\A\S+ statistics:/.match?(line)
+              active = false
+              next
+            end
+            next unless active
+
+            line.sub(/\A(?:Rcvd|Opts|Frags|Bcast|Mcast|Sent|Drop):\s*/, "").split(/,\s*/).each do |cell|
+              match = /\A(\d+) (.+)\z/.match(cell)
+              definition = match && METRICS[match[2]]
+              if definition
+                records << { component: "ipv4/control_plane", metric: definition[0], category: definition[1],
+                  value: Integer(match[1], 10), discontinuity: nil }
+              elsif !INFORMATIONAL.match?(cell)
+                issues << { code: :unparsed_counter, line: number }
+              end
+            end
+          end
+          missing = REQUIRED_METRICS - records.map { |record| record[:metric] }
+          issues << { code: :counter_fields_missing, count: missing.size } if recognized && missing.any?
+          build_result(records, complete: complete, recognized: recognized, issues: issues, identity: %i[component metric])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/show_memory_statistics.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # 分别保留 IOS 各内存分配池，并使用精确字节数核算。
+      class ShowMemoryStatistics < CtxChecker::Parsers::Base
+        private
+
+        # 解析 show memory statistics，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          records, issues = [], []
+          clean(text).each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty? || /\AHead\s+Total\(b\)/.match?(line) || /\ATracekey\s*:\s*[\da-f#]+\z/i.match?(line)
+
+            match = /\A(.+?)\s+Pool\s+Total:\s*(\d+)\s+Used:\s*(\d+)\s+Free:\s*(\d+)\z/i.match(line) ||
+              /\A(.+?)\s+[0-9a-f]+\s+(\d+)\s+(\d+)\s+(\d+)\s+\d+\s+\d+\z/i.match(line)
+            unless match
+              issues << { code: :unparsed_row, line: number }
+              next
+            end
+            total, used, free = match.captures.drop(1).map { |value| Integer(value, 10) }
+            consistent = total.positive? && used + free == total
+            issues << { code: :inconsistent_memory_totals, line: number } unless consistent
+            records << { component: match[1], scope: "ios_memory_pool", total_bytes: total, used_bytes: used,
+              free_bytes: free, available_bytes: nil, utilization: consistent ? used.fdiv(total) * 100 : nil, basis: :used_total }
+          end
+          build_result(records, complete: complete, recognized: records.any?, issues: issues, identity: %i[component scope])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/cisco_ios/parsers/show_ntp_status.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module CiscoIos
+    module Parsers
+      # IOS 显式报告系统同步状态，并使用毫秒表示偏移。
+      class ShowNtpStatus < CtxChecker::Parsers::Base
+        include SystemValues
+        AUXILIARY = /\A(?:nominal freq|reference time|root dispersion|loopfilter state|system poll interval|ntp uptime|system time|leap time|leap direction|root delay|time resolution)/i
+
+        private
+
+        # 解析 show ntp status，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          records, issues = [], []
+          clean(text).each_line.with_index(1) do |source, number|
+            line = source.strip
+            next if line.empty?
+
+            if (match = /\AClock is (synchronized|unsynchronized), stratum (\d+)(?:, reference assoc id \d+)?(?:, reference is (\S+))?\z/i.match(line))
+              stratum = Integer(match[2], 10)
+              issues << { code: :invalid_ntp_stratum, line: number } unless stratum.between?(0, 16)
+              records << { component: "system", synchronized: match[1].casecmp?("synchronized"),
+                stratum: stratum.between?(0, 16) ? stratum : nil, reference: match[3], peer: nil, offset_ms: nil, leap: nil }
+            elsif (match = /\Aclock offset is (#{NUMBER}) msec(?:,|\z)/i.match(line)) && records.one?
+              issues << { code: :duplicate_ntp_offset, line: number } if records.first[:offset_ms]
+              records.first[:offset_ms] = checked_number(match[1], issues: issues, component: "system")
+            elsif /\A%?NTP is not enabled\.?\z/i.match?(line)
+              records << { component: "system", synchronized: false, stratum: nil, reference: nil, peer: nil, offset_ms: nil, leap: nil }
+            elsif AUXILIARY.match?(line)
+              next
+            else
+              issues << unparsed(number)
+            end
+          end
+          build_result(records, complete: complete, recognized: records.any?, issues: issues, identity: [ :component ])
+        end
+      end
+    end
+  end
+end