ctx_checker 0.1.0

data/lib/ctx_checker/finding.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "observation"
+
+module CtxChecker
+  # 单条检查结果包含原因说明；严重级别不能代替实际结果状态。
+  Finding = Data.define(:id, :dimension, :entity, :status, :severity, :reason, :actual, :expected) do
+    # 独立校验并冻结检查结果及其说明，不由严重级别推断状态。
+    def initialize(id:, dimension:, entity: nil, status:, severity: :info, reason:, actual: nil, expected: nil)
+      raise ArgumentError, "Invalid finding dimension" unless Observation::NAMES.include?(dimension) || dimension == :collection
+      raise ArgumentError, "Invalid finding status" unless %i[pass fail unknown not_applicable].include?(status)
+      raise ArgumentError, "Invalid finding severity" unless %i[info warning critical].include?(severity)
+      unless id.is_a?(String) && /\A[a-z][a-z0-9_.]*\z/.match?(id) && reason.is_a?(Symbol) && /\A[a-z][a-z0-9_]*\z/.match?(reason.to_s)
+        raise ArgumentError, "Findings require an ID and reason code"
+      end
+      super(**CtxParser::Immutable.copy(id: id, dimension: dimension, entity: entity, status: status, severity: severity, reason: reason, actual: actual, expected: expected))
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/counters_table.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 入站、出站查询使用相同包计数表；仅 Err 列表示错误计数。
+      module CountersTable
+        private
+
+        # 按来源标签归一化支持的接口或设备计数器。
+        def parse_counters(text, complete:, metric:)
+          source = clean(text)
+          rows, sections, section = [], [], nil
+          source.each_line do |raw|
+            line = raw.strip
+            if /\AInterface\s+Total\s*\(pkts?\)\s+Broadcast\s*\(pkts?\)\s+Multicast\s*\(pkts?\)\s+Err\s*\(pkts?\)\z/i.match?(line)
+              sections << (section = { count: 0 })
+            elsif (match = /\A([A-Za-z][A-Za-z-]*\d+(?:[\/.]\d+)*)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\z/.match(line))
+              unless section
+                @issues << { code: :missing_counter_header }
+                next
+              end
+              name = CtxChecker::Parsers::InterfaceNames.normalize(match[1], platform: :h3c)
+              traffic = match.captures[1, 3]
+              unless traffic.all? { |value| /\A(?:\d+|Overflow|--)\z/i.match?(value) }
+                @issues << { code: :invalid_traffic_counter, interface: name }
+              end
+              rows << { interface: name, metric: metric, value: error_count(match[5], name, metric), discontinuity: nil }
+              section[:count] += 1
+            elsif !line.empty? && !/\A(?:-+|Overflow:\s*More than \d+ (?:decimal )?digits.*|--:\s*Not supported\.?)\z/i.match?(line)
+              @issues << { code: :unrecognized_counter_line }
+            end
+          end
+          @issues << { code: :empty_counter_table } if sections.any? { |entry| entry[:count].zero? }
+          build_result(rows, complete: complete, recognized: sections.any? && rows.any?, identity: %i[interface metric])
+        end
+
+        # 提取错误计数器，不将缺少证据替换为零。
+        def error_count(value, interface, metric)
+          return value.to_i if /\A\d+\z/.match?(value)
+
+          code = case value.downcase
+          when "overflow" then :counter_overflow
+          when "--" then :counter_unavailable
+          else :invalid_counter_value
+          end
+          @issues << { code: code, interface: interface, metric: metric }
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_alarm_active.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 保留当前告警身份与严重级别，不复制设备自由文本消息。
+      class DisplayAlarmActive < CtxChecker::Parsers::Base
+        SEVERITIES = { "critical" => :critical, "major" => :critical, "minor" => :warning,
+          "error" => :critical, "warning" => :warning, "notice" => :info, "info" => :info }.freeze
+
+        private
+
+        # 解析 display alarm active，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          rows, header, empty = [], false, false
+          source.each_line do |raw|
+            line = raw.strip
+            if /\ASeq\s+Level\s+Time\s+Info\z/i.match?(line)
+              header = true
+            elsif (match = /\A(\d+)\s+(\S+)\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\s+.+\z/.match(line))
+              severity = SEVERITIES.fetch(match[2].downcase, :unknown)
+              @issues << { code: :unrecognized_alarm_severity } if severity == :unknown
+              rows << { component: "system", alarm_id: match[1], severity: severity, active: true, count: 1 }
+            elsif /\ANo active alarms\.?\z/i.match?(line)
+              empty = true
+            elsif !line.empty? && !/\A-+\z/.match?(line)
+              @issues << { code: :unrecognized_alarm_line }
+            end
+          end
+          if empty && rows.empty?
+            rows << { component: "system", alarm_id: "summary", severity: :info, active: false, count: 0 }
+          elsif empty
+            @issues << { code: :contradictory_alarm_summary }
+          end
+          build_result(rows, complete: complete, recognized: (header && rows.any?) || empty, identity: %i[component alarm_id])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_bgp_peer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 公网 IPv4 单播查询具有明确的地址族作用域。
+      class DisplayBgpPeer < CtxChecker::Parsers::Base
+        STATES = %w[idle connect active opensent openconfirm established idle(admin)].freeze
+
+        private
+
+        # 解析 display bgp peer，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          text = clean(text)
+          rows, issues, total, header = [], [], nil, false
+          text.each_line do |raw|
+            line = raw.strip
+            if (match = /\ATotal number of peers:\s*(\d+)\z/i.match(line))
+              issues << { code: :duplicate_peer_count } unless total.nil?
+              total = Integer(match[1], 10)
+            elsif /\APeer\s+AS\s+MsgRcvd\s+MsgSent\s+OutQ\s+PrefRcv\s+Up\/Down\s+State\z/i.match?(line)
+              header = true
+            elsif (match = /\A\*?\s*([\d.]+)\s+(\d+)\s+\d+\s+\d+\s+\d+\s+(\d+)\s+\S+\s+(.+)\z/.match(line))
+              state = match[4].downcase.delete(" ")
+              if CtxParser::Values.valid_host?(match[1]) && STATES.include?(state) && (1..4_294_967_295).cover?(match[2].to_i)
+                rows << { vrf: "default", afi_safi: "ipv4_unicast", peer: match[1], state: state == "idle(admin)" ? :shutdown : state.to_sym,
+                  received_prefixes: match[3].to_i, remote_as: match[2].to_i }
+              else
+                issues << { code: :invalid_bgp_peer }
+              end
+            elsif !line.empty? && !line.match?(/\A(?:BGP local router ID:|Local AS number:|\* - Dynamically created peer)/i)
+              issues << { code: :unrecognized_bgp_line }
+            end
+          end
+          issues << { code: :count_mismatch, expected: total, observed: rows.size } if total && total != rows.size
+          build_result(rows, complete: complete, recognized: header && (rows.any? || total == 0), issues: issues,
+            identity: %i[vrf afi_safi peer], covered_scopes: [ { vrf: "default", afi_safi: "ipv4_unicast" } ])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_clock.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 转换 UTC 需要明确的数字时区偏移，不猜测时区名称。
+      class DisplayClock < CtxChecker::Parsers::Base
+        private
+
+        # 解析 display clock，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          timestamps, zones, summer = [], [], false
+          source.each_line do |raw|
+            line = raw.strip
+            if (match = /\A(\d{1,2}:\d{2}:\d{2}(?:\.\d+)?)\s+(\S+)\s+[A-Za-z]{3}\s+(\d{2})\/(\d{2})\/(\d{4})\z/.match(line))
+              timestamps << match.captures
+            elsif (match = /\ATime Zone\s*:\s*(\S+)\s+(add|minus)\s+(\d{2}):(\d{2}):(\d{2})\z/i.match(line))
+              zones << match.captures
+            elsif /\ASummer Time\s*:/i.match?(line)
+              summer = true
+            elsif !line.empty?
+              @issues << { code: :unrecognized_clock_line }
+            end
+          end
+          if timestamps.size == 1
+            instant = normalize_time(timestamps.first, zones, summer)
+            rows = [ { component: "system", time: instant, source: nil, synchronized: nil } ]
+          else
+            rows = []
+            @issues << { code: :ambiguous_clock_time, count: timestamps.size }
+          end
+          build_result(rows, complete: complete, recognized: timestamps.any?, identity: [ :component ])
+        end
+
+        # 归一化时间戳，同时保留显式声明的时区语义。
+        def normalize_time(parts, zones, summer)
+          clock, zone, month, day, year = parts
+          if summer || zones.size > 1
+            @issues << { code: summer ? :ambiguous_daylight_saving_time : :duplicate_clock_timezone }
+            return
+          end
+          offset = zone.casecmp?("UTC") && zones.empty? ? 0 : zone_offset(zone, zones.first)
+          if offset.nil?
+            @issues << { code: :unknown_clock_timezone }
+            return
+          end
+          hours, minutes, fraction = clock.split(":")
+          hours, minutes, seconds = hours.to_i, minutes.to_i, Rational(fraction)
+          unless Date.valid_date?(year.to_i, month.to_i, day.to_i) && (0...24).cover?(hours) && (0...60).cover?(minutes) && (0...60).cover?(seconds)
+            @issues << { code: :invalid_clock_time }
+            return
+          end
+          (Time.utc(year.to_i, month.to_i, day.to_i, hours, minutes, seconds) - offset).iso8601(3)
+        end
+
+        # 解析支持的时区偏移，不猜测有歧义的时区标签。
+        def zone_offset(zone, settings)
+          return unless settings && settings.first == zone
+          _name, sign, hours, minutes, seconds = settings
+          return unless (0...24).cover?(hours.to_i) && (0...60).cover?(minutes.to_i) && (0...60).cover?(seconds.to_i)
+
+          (hours.to_i * 3600 + minutes.to_i * 60 + seconds.to_i) * (sign.casecmp?("minus") ? -1 : 1)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_counters_inbound_interface.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "counters_table"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 解析接收错误包数量，避免把正常流量计入错误。
+      class DisplayCountersInboundInterface < CtxChecker::Parsers::Base
+        include CountersTable
+
+        private
+
+        # 解析 display counters inbound interface，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          parse_counters(text, complete: complete, metric: :in_errors)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_counters_outbound_interface.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "counters_table"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 解析发送错误包数量；CRC 与丢弃量需要独立证据。
+      class DisplayCountersOutboundInterface < CtxChecker::Parsers::Base
+        include CountersTable
+
+        private
+
+        # 解析 display counters outbound interface，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          parse_counters(text, complete: complete, metric: :out_errors)
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_cpu_usage.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 保留每个 CPU 及其采样周期，不对机框成员取平均。
+      class DisplayCpuUsage < CtxChecker::Parsers::Base
+        include SystemValues
+
+        private
+
+        # 解析 display cpu usage，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          rows, components, current, table = [], [], nil, nil
+          source.each_line do |raw|
+            line = raw.strip
+            if (match = /\A((?:Chassis \d+ )?Slot \d+(?: CPU \d+(?: Core \d+)?)?) CPU usage:\z/i.match(line))
+              current = scope_name(match[1])
+              components << current
+            elsif /\A(?:Chassis\s+)?Slot\s+CPU\s+Last 5 sec\s+Last 1 min\s+Last 5 min\z/i.match?(line)
+              table = line.start_with?("Chassis") ? 3 : 2
+            elsif table && (match = /\A(\d+(?:\s+\d+){1,2})\s+(#{NUMBER})%?\s+(#{NUMBER})%?\s+(#{NUMBER})%?\z/i.match(line))
+              identifiers = match[1].split
+              if identifiers.size == table
+                current = identifiers.zip(table == 3 ? %w[chassis slot cpu] : %w[slot cpu]).map { |id, kind| "#{kind} #{id}" }.join(" ")
+                components << current
+                rows.concat([ 5, 60, 300 ].zip(match.captures.drop(1)).map { |seconds, value| sample(current, seconds, value) })
+              else
+                @issues << { code: :missing_cpu_scope }
+              end
+            elsif (match = /\A(#{NUMBER})%? in last (5 seconds|1 minute|5 minutes)\z/i.match(line))
+              if current
+                seconds = { "5 seconds" => 5, "1 minute" => 60, "5 minutes" => 300 }.fetch(match[2].downcase)
+                rows << sample(current, seconds, match[1])
+              else
+                @issues << { code: :missing_cpu_scope }
+              end
+            elsif line.empty?
+              next
+            else
+              @issues << { code: :unrecognized_cpu_line }
+            end
+          end
+          components.each do |component|
+            missing = [ 5, 60, 300 ] - rows.select { |row| row[:component] == component }.map { |row| row[:window_seconds] }
+            @issues << { code: :missing_cpu_windows, component: component, count: missing.size } if missing.any?
+          end
+          build_result(rows, complete: complete, recognized: components.any?, identity: %i[component scope window_seconds])
+        end
+
+        # 构建包含采样上下文的归一化测量记录。
+        def sample(component, seconds, value)
+          utilization = measurement(value, field: :utilization, component: component, percent: true)
+          @issues << { code: :missing_cpu_measurement, component: component, window_seconds: seconds } if utilization.nil?
+          { component: component, scope: "system", window_seconds: seconds, utilization: utilization }
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_environment.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 传感器阈值取自各板卡，不使用统一猜测的温度限制。
+      class DisplayEnvironment < CtxChecker::Parsers::Base
+        include SystemValues
+        SENSOR_ROW = /\A(?:(\d+)\s+)?(\d+|Vent)\s+((?:hotspot|inflow|outflow)\s+\d+(?:\(sub\d+\))?)\s+(#{NUMBER})\s+(#{NUMBER})\s+(#{NUMBER})\s+(#{NUMBER})(?:\s+#{NUMBER})?\z/i
+        HOTSPOT_ROW = /\A(\d+)\s+hotspot(\d+)\s+[A-Za-z][A-Za-z0-9_-]*(?:[ \t]+\d+-\d+)?\s+(#{NUMBER})\s+(#{NUMBER})\s+(#{NUMBER})\s+(#{NUMBER})\s+#{NUMBER}\z/i
+
+        private
+
+        # 解析 display environment，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          rows, chassis, header, auxiliary, contexts, context = [], nil, nil, nil, [], nil
+          source.each_line do |raw|
+            line = raw.strip
+            if (match = /\AChassis (\d+):\z/i.match(line))
+              chassis = "chassis #{match[1]} "
+              contexts << (context = { component: chassis.strip, count: 0 })
+              header, auxiliary = nil, nil
+            elsif (match = /\A(Chassis\s+)?Slot\s+Sensor\s+Temperature\s+Lower(?:Limit)?\s+Warning(?:Limit)?\s+Alarm(?:Limit)?(?:\s+Shutdown(?:Limit)?)?\z/i.match(line))
+              header, auxiliary = match[1] ? :chassis : :slot, nil
+            elsif /\ASlotNo\s+Temperature\s+Lower limit\s+Upper limit\z/i.match?(line)
+              header, auxiliary = :legacy, nil
+            elsif /\ASlot\s+Hotspot\s+(?:Sensor|Name)\s+Temperature\s+Lower\s+Warning\s+Alarm\s+Shutdown\z/i.match?(line)
+              header, auxiliary = :hotspot, nil
+            elsif header == :hotspot && (match = HOTSPOT_ROW.match(line))
+              component = "#{chassis}slot #{match[1]}/hotspot #{match[2]}"
+              values = match.captures.drop(2).map { |value| measurement(value, field: :temperature, component: component) }
+              rows << temperature_record(component, values[0], low_warning: values[1], high_warning: values[2], high_alarm: values[3])
+              context[:count] += 1 if context
+            elsif %i[chassis slot].include?(header) && (match = SENSOR_ROW.match(line)) && (header == :chassis) == !match[1].nil?
+              prefix = match[1] ? "chassis #{match[1]} " : chassis
+              component = "#{prefix}#{match[2].casecmp?("vent") ? 'vent' : "slot #{match[2]}"}/#{scope_name(match[3])}"
+              values = match.captures.drop(3).map { |value| measurement(value, field: :temperature, component: component) }
+              rows << temperature_record(component, values[0], low_warning: values[1], high_warning: values[2], high_alarm: values[3])
+              context[:count] += 1 if context
+            elsif header == :legacy && (match = /\A(\d+)\s+(#{NUMBER})\s+#{NUMBER}\s+#{NUMBER}\z/i.match(line))
+              component = "#{chassis}slot #{match[1]}"
+              rows << temperature_record(component, measurement(match[2], field: :temperature, component: component))
+              # 旧版表列不能区分警告与告警级别。
+              @issues << { code: :temperature_threshold_semantics_unknown, component: component }
+              context[:count] += 1 if context
+            elsif (match = /\A(Fan|Power) temperature information:\z/i.match(line))
+              header, auxiliary = nil, match[1].downcase
+            elsif chassis && auxiliary && (match = /\A(Fan|Power) (\d+):\s*(#{NUMBER})\z/i.match(line)) && match[1].casecmp?(auxiliary)
+              component = "#{chassis.strip}/#{auxiliary} #{match[2]}"
+              rows << temperature_record(component, measurement(match[3], field: :temperature, component: component))
+              context[:count] += 1 if context
+            elsif !line.empty? && !/\A(?:-+|System temperature information \(degree centigrade\):)\z/i.match?(line)
+              @issues << { code: :unrecognized_temperature_line }
+            end
+          end
+          contexts.each do |entry|
+            @issues << { code: :missing_temperature_scope_records, component: entry[:component] } if entry[:count].zero?
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, identity: [ :component ])
+        end
+
+        # 能读取但无设备阈值的传感器仅提供测量值，不据此判定健康。
+        def temperature_record(component, value, **limits)
+          @issues << { code: :missing_temperature_measurement, component: component } if value.nil?
+          { component: component, value: value, high_comparison: :gte, status: :unknown, **limits }
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_fan.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 风扇托盘保留机框与槽位身份；空槽位不直接判为故障。
+      class DisplayFan < CtxChecker::Parsers::Base
+        include SystemValues
+
+        private
+
+        # 解析 display fan，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          rows, location, current, table, seen, contexts, context, fanless = [], "system", nil, false, {}, [], nil, {}
+          source.each_line do |raw|
+            line = raw.strip
+            if (match = /\A((?:Chassis \d+ )?Slot \d+|Chassis \d+)\s*:\z/i.match(line))
+              location, current, table = scope_name(match[1]), nil, false
+              contexts << (context = { component: location, count: 0 })
+            elsif context && line.casecmp?("Fan-less")
+              row = { component: "#{location}/fan", kind: :fan, status: :absent }
+              rows << row
+              fanless[location] = row
+              context[:count] += 1
+              current, table = nil, false
+            elsif (match = /\AFan(?: Frame)?\s+(\d+)(?:\s*:\s*|\s+)(?:State\s*:\s*(\S+))?\z/i.match(line))
+              current = { component: "#{location}/fan #{match[1]}", kind: :fan, status: :unknown }
+              rows << current
+              context[:count] += 1 if context
+              if match[2]
+                current[:status] = component_state(match[2], component: current[:component])
+                seen[current.object_id] = true
+              end
+            elsif (match = /\AState\s*:\s*(\S+)\z/i.match(line)) && current
+              if seen[current.object_id]
+                current[:status] = :unknown
+                @issues << { code: :duplicate_component_state, component: current[:component] }
+              else
+                current[:status] = component_state(match[1], component: current[:component])
+              end
+              seen[current.object_id] = true
+            elsif /\AFan No\.\s+State\s+Speed(?:\s+Description)?\z/i.match?(line)
+              table = true
+            elsif table && (match = /\A(\d+)\s+(\S+)\s+(?:\d+|--)(?:\s+\S+)?\z/.match(line))
+              component = "#{location}/fan #{match[1]}"
+              rows << { component: component, kind: :fan, status: component_state(match[2], component: component) }
+              context[:count] += 1 if context
+            elsif !line.empty? && !/\A(?:-+|(?:Prefer )?Airflow Direction:.*)\z/i.match?(line)
+              @issues << { code: :unrecognized_fan_line }
+            end
+          end
+          contexts.each do |entry|
+            @issues << { code: :missing_fan_scope_records, component: entry[:component] } if entry[:count].zero?
+          end
+          # 同一作用域已有实际风扇托盘时，fanless 声明不能覆盖它。
+          fanless.each do |scope, row|
+            next unless rows.any? { |entry| entry[:component].start_with?("#{scope}/fan ") }
+
+            row[:status] = :unknown
+            @issues << { code: :conflicting_fan_presence, component: row[:component] }
+          end
+          @issues << { code: :missing_component_state } if rows.any? { |row| row[:status] == :unknown }
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component kind])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/parsers/display_interface.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # Comware 接口块分别产生状态与计数器观测。
+      class DisplayInterface < CtxChecker::Parsers::Base
+        INTERFACE = /(?:[A-Za-z][A-Za-z-]*[\d\/.:]+|NULL\d+)/
+        COUNTERS = {
+          crc_errors: /(?<![\w.+-])(\d+) CRC\b/i,
+          in_discards: /^[ \t]*(?:Input:[ \t]*\d+ packets?|\d+ packets? input),[ \t]*\d+ bytes?,[ \t]*(\d+) drops?[ \t]*$/i,
+          out_discards: /^[ \t]*(?:Output:[ \t]*\d+ packets?|\d+ packets? output),[ \t]*\d+ bytes?,[ \t]*(\d+) drops?[ \t]*$/i
+        }.freeze
+        DISCARD_LABELS = { in_discards: /^[ \t]*(?:Input:|[^,\n]+ packets? input,).*\bdrops?\b/i, out_discards: /^[ \t]*(?:Output:|[^,\n]+ packets? output,).*\bdrops?\b/i }.freeze
+        DETAILS = /\A(?:Current state:|Line protocol (?:current )?state:|Description:|Bandwidth:|Maximum |Allow jumbo|Broadcast |Multicast |Unicast |Known[ -]unicast |Internet |IP(?:v[46])? |Loopback |Media type |Port |[\w.-]+-speed mode|Link speed |Flow-control |The Maximum |Last |Current system time:|Peak |Input\b|Output\b|PVID:|MDI type:|Tagged VLANs:|UnTagged VLANs:|(?:\d+|-) (?:CRC|ignored|unicasts|aborts|lost carrier))/i
+        NON_METRIC_DETAILS = /\A(?:Trunk port encapsulation:\s*IEEE 802\.1q|Physical:\s*(?:InLoopBack|Loopback|Unknown)|Physical(?:\s+is|:)\s*NULL DEV(?:, baudrate:\s*\d+ kbps)?)\z/i
+        COUNTER_DETAILS = /\A(?:(?:\d+|-) (?:broadcasts,[ \t]*(?:\d+|-) multicasts(?:,[ \t]*(?:\d+|-) pauses)?|carrier,[ \t]*(?:\d+|-) no carrier|frame,[ \t]*(?:\d+|-) overruns,[ \t]*(?:\d+|-) aborts,[ \t]*(?:\d+|-) ignored,[ \t]*(?:\d+|-) parity errors)|\d+ packets? (?:input|output),[ \t]*\d+ bytes?,[ \t]*\d+ drops?)\z/i
+
+        private
+
+        # 接口状态独立于各配置块提供的计数器进行投影。
+        def parse_output(text, complete:)
+          text = clean(text)
+          interfaces, counters, interface_issues, counter_issues = [], [], [], []
+          sections = text.split(/(?=^[ \t]*#{INTERFACE}(?:[ \t]+current state[ \t]*:.*)?[ \t]*$)/i)
+          sections.each do |section|
+            header = /\A[ \t]*(#{INTERFACE})(?:[ \t]+current state[ \t]*:[ \t]*([^\n]+))?[ \t]*\n/i.match(section)
+            next if section.strip.empty?
+            unless header
+              interface_issues << { code: :unrecognized_interface_block }
+              next
+            end
+            name = CtxChecker::Parsers::InterfaceNames.normalize(header[1], platform: :h3c)
+            unless known_details?(section)
+              interface_issues << { code: :unrecognized_interface_field, interface: name }
+            end
+            states = [ header[2], *section.scan(/^[ \t]*Current state\s*:\s*(.+)$/i).flatten ].compact
+            protocols = section.scan(/^[ \t]*Line protocol (?:current )?state\s*:\s*(.+)$/i).flatten
+            if states.size > 1 || protocols.size > 1
+              interface_issues << { code: :duplicate_interface_state, interface: name }
+            end
+            state = states.one? ? states.first : nil
+            protocol = protocols.one? ? protocols.first : nil
+            admin, oper = state_values(state)
+            protocol = status(protocol)
+            interface_issues << { code: :interface_state_missing, interface: name } if oper == :unknown || protocol == :unknown
+            interfaces << { name: name, kind: CtxChecker::Parsers::InterfaceNames.kind(name), admin_status: admin,
+              oper_status: oper, protocol_status: protocol, parent: name.include?(".") ? name.split(".").first : nil }
+            # Never 或相对时间都不能证明跨重启的计数连续性。
+            discontinuity = nil
+            section_counters = []
+            counter_source = section.lines.reject { |line| /\A\s*Description:/i.match?(line) }.join
+            COUNTERS.each do |metric, pattern|
+              values = counter_source.scan(pattern).flatten
+              if DISCARD_LABELS.key?(metric) && values.size != counter_source.scan(DISCARD_LABELS.fetch(metric)).size
+                counter_issues << { code: :invalid_counter_value, interface: name, metric: metric }
+                section_counters << { interface: name, metric: metric, value: nil, discontinuity: discontinuity }
+                next
+              end
+              if values.one?
+                section_counters << { interface: name, metric: metric, value: Integer(values.first, 10), discontinuity: discontinuity }
+              elsif values.any?
+                counter_issues << { code: :duplicate_counter, interface: name, metric: metric }
+              end
+            end
+            if interfaces.last[:kind] == :physical
+              missing = %i[in_discards out_discards crc_errors] - section_counters.map { |row| row[:metric] }
+              missing.each { |metric| section_counters << { interface: name, metric: metric, value: nil, discontinuity: nil } }
+              counter_issues << { code: :missing_counter_metrics, interface: name, metrics: missing } if missing.any?
+            end
+            counters.concat(section_counters)
+          end
+          CtxParser::ResultSet.new(results: {
+            interfaces: build_result(interfaces, complete: complete, recognized: interfaces.any?, issues: interface_issues, identity: [ :name ]),
+            counters: build_result(counters, complete: complete, recognized: counters.any?, issues: counter_issues + interface_issues, identity: %i[interface metric])
+          })
+        end
+
+        # 换行 VLAN 列表仅在紧接前一列表时作为元数据处理。
+        def known_details?(section)
+          vlan_list = false
+          section.lines.drop(1).all? do |raw|
+            line = raw.strip
+            if (match = /\A(?:VLAN (?:Passing|permitted)|(?:Tagged|Untagged)\s+VLAN ID)\s*:\s*(.+)\z/i.match(line))
+              vlan_list = valid_vlan_list?(match[1])
+            elsif vlan_list && /\A\s+\d/.match?(raw)
+              valid_vlan_list?(line)
+            else
+              vlan_list = false
+              line.empty? || DETAILS.match?(line) || NON_METRIC_DETAILS.match?(line) || COUNTER_DETAILS.match?(line)
+            end
+          end
+        end
+
+        # 校验 VLAN 元数据，避免任意数字尾行掩盖截断。
+        def valid_vlan_list?(value)
+          return true if value.casecmp?("none")
+
+          value.split(/,\s*/, -1).all? do |token|
+            match = /\A(\d+)(?:-(\d+))?(?:\(default vlan\))?\z/i.match(token)
+            next false unless match
+            first = match[1].to_i
+            last = (match[2] || match[1]).to_i
+            first.between?(1, 4094) && last.between?(first, 4094)
+          end
+        end
+
+        # 区分主动管理关闭与已启用链路故障。
+        def state_values(value)
+          return [ :down, :down ] if value&.match?(/\AAdministratively\s+DOWN\b/i)
+          observed = status(value)
+          [ observed == :unknown ? :unknown : :up, observed ]
+        end
+
+        # 新出现或格式错误的状态文本明确保持未解析。
+        def status(value)
+          return :up if value&.match?(/\AUP(?:\s|\(|$)/i)
+          return :down if value&.match?(/\A(?:DOWN|Administratively\s+DOWN|Link-Flap DOWN|mac-address moving down|MAD ShutDown|OFP DOWN|Storm-Constrain|STP DOWN|M-LAG MAD Shutdown)(?:\s|\(|$)/i)
+          :unknown
+        end
+      end
+    end
+  end
+end