ctx_checker 0.1.0

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 本地成员选中状态不能从远端 LACP 记录推断。
+      class DisplayLinkAggregationVerbose < CtxChecker::Parsers::Base
+        GROUP = /\A(?:Bridge-Aggregation|Route-Aggregation|BAGG|RAGG)\d+\z/i
+        LOCAL_HEADER = /\APort\s+Status\s+Priority(?:\s+(Index))?\s+Oper-Key(?:\s+(Flag))?\z/i
+        MEMBER = /\A([A-Za-z][A-Za-z-]*\d+(?:[\/.]\d+)*)(?:\(([AMR])\))?\s+([SUI])\s+(\d+)\s+(\d+)(?:\s+(\d+))?(?:\s+(\{[A-H]*\}))?\z/
+        METADATA = /\A(?:-+|Loadsharing Type:|Port Status:|Port:|Flags:|[A-H] --|Creation Mode:|Aggregation Mode:|System ID:)/
+
+        private
+
+        # 按聚合组及声明的列布局限定各本地表的作用域。
+        def parse_output(text, complete:)
+          text = clean(text)
+          if /\AInfo:\s+No link aggregation group defined at present\.\z/i.match?(text.strip)
+            return build_result([], complete: complete, recognized: true, issues: [ { code: :aggregation_not_configured } ])
+          end
+          rows, issues, group, remote, groups, columns, tables = [], [], nil, false, {}, nil, []
+          text.each_line do |raw|
+            line = raw.strip
+            if (match = /\AAggregate Interface:\s*(.*)\z/i.match(line))
+              group, remote, columns = nil, false, nil
+              if GROUP.match?(match[1])
+                group = CtxChecker::Parsers::InterfaceNames.normalize(match[1], platform: :h3c)
+                issues << { code: :duplicate_aggregation_group, group: group } if groups.key?(group)
+                groups[group] ||= 0
+              else
+                issues << { code: :invalid_aggregation_group }
+              end
+            elsif line == "Remote:"
+              remote = true
+              columns = nil
+            elsif line == "Local:"
+              remote = false
+              columns = nil
+            elsif !remote && (match = LOCAL_HEADER.match(line))
+              columns = { indexed: !match[1].nil?, flags: !match[2].nil?, group: group, count: 0 }
+              tables << columns
+            elsif !remote && (record = local_member(line, group: group, columns: columns))
+              rows << record
+              groups[group] += 1
+              columns[:count] += 1
+            elsif !remote && line.match?(/\A[A-Za-z][A-Za-z-]*\d+(?:[\/.]\d+)*(?:\([^\s]*\))?\s/)
+              issues << { code: :invalid_aggregation_member }
+            elsif !remote && !line.empty? && !METADATA.match?(line) && !/\AManagement VLANs:\s*(?:None|\d+(?:-\d+)?(?:,\s*\d+(?:-\d+)?)*)\z/i.match?(line)
+              issues << { code: :unrecognized_aggregation_line }
+            end
+          end
+          groups.each { |name, count| issues << { code: :aggregation_members_missing, group: name } if count.zero? }
+          tables.each { |table| issues << { code: :aggregation_members_missing, group: table[:group] } if table[:count].zero? }
+          build_result(rows, complete: complete, recognized: groups.any?, issues: issues, identity: %i[group member])
+        end
+
+        # 仅在身份匹配前移除已知端口角色标记，不修改状态文本。
+        def local_member(line, group:, columns:)
+          return unless group && columns
+          match = MEMBER.match(line)
+          return unless match && columns[:indexed] == !match[6].nil? && columns[:flags] == !match[7].nil?
+
+          { group: group, member: CtxChecker::Parsers::InterfaceNames.normalize(match[1], platform: :h3c),
+            member_status: { "S" => :active, "U" => :unselected, "I" => :unselected }.fetch(match[3]), oper_status: :unknown }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 应用内存使用量必须来自同一物理内存池中经过确认的缓存调整行。
+      class DisplayMemory < CtxChecker::Parsers::Base
+        include SystemValues
+        LEGACY_FIELDS = { "System Total Memory(bytes)" => :total, "Total Used Memory(bytes)" => :used, "Used Rate" => :rate }.freeze
+
+        private
+
+        # 解析 display memory，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          return legacy_memory(source, complete: complete) if /^\s*System Total Memory\(bytes\):/.match?(source)
+
+          rows, contexts, sections = [], [], []
+          context, scope, unit, columns, current, section = nil, "physical", nil, nil, nil, nil
+          source.each_line do |raw|
+            line = raw.strip
+            if /\A(?:Container memory statistics|Memory statistics|The statistics about memory).*measured in (KB|bytes)(?:\(Available\))?:\z/i.match?(line)
+              unit = line.match(/measured in (KB|bytes)/i)[1].casecmp?("KB") ? 1024 : 1
+              scope = line.start_with?("Container") ? "container" : "physical"
+              context, columns, current = nil, nil, nil
+              sections << (section = { scope: scope, samples: 0 })
+            elsif (match = /\A((?:Chassis \d+ )?Slot \d+(?: CPU \d+)?):\z/i.match(line))
+              contexts << (context = { component: scope_name(match[1]), scope: scope, samples: 0 })
+              columns, current = nil, nil
+            elsif /\ATotal\s+Used\s+Free\b/.match?(line)
+              columns = line.split
+            elsif (match = /\AMem:\s+(\S+)\s+(\S+)\s+(\S+)(?:\s+.*)?\z/.match(line))
+              if context && unit
+                values = line.delete_prefix("Mem:").split
+                if columns.nil? || values.size != columns.size
+                  @issues << { code: :incomplete_memory_row, component: context[:component] }
+                end
+                record = memory_record(context[:component], scope, unit, match.captures)
+                rows << record
+                current = { record: record, raw: record.dup, values: (columns || []).zip(values).to_h, adjustments: 0 }
+                context[:samples] += 1
+                section[:samples] += 1 if section
+              else
+                @issues << { code: :missing_memory_scope_or_unit }
+              end
+            elsif (match = /\A-\/\+ Buffers\/Cache:\s+(\S+)\s+(\S+)\z/i.match(line))
+              adjust_cache(current, match.captures, unit)
+            elsif !line.empty? && !/\A(?:Swap:|LowMem:|HighMem:)/i.match?(line)
+              @issues << { code: :unrecognized_memory_line }
+            end
+          end
+          contexts.each do |entry|
+            @issues << { code: :missing_memory_sample, component: entry[:component], scope: entry[:scope] } if entry[:samples].zero?
+          end
+          sections.each do |entry|
+            @issues << { code: :missing_memory_section, scope: entry[:scope] } if entry[:samples].zero?
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component scope])
+        end
+
+        # 旧交换机仅报告物理内存使用量，不能证明缓存调整后的应用使用量。
+        def legacy_memory(source, complete:)
+          values, seen = {}, {}
+          source.each_line do |raw|
+            line = raw.strip
+            next if line.empty?
+
+            key, value = line.split(/:\s*/, 2)
+            field = LEGACY_FIELDS[key]
+            unless field && value
+              @issues << { code: :unrecognized_memory_line }
+              next
+            end
+            if seen[field]
+              values[field] = nil
+              @issues << { code: :duplicate_memory_field, field: field, component: "system" }
+            else
+              values[field] = if field == :rate
+                match = /\A(#{NUMBER})%\z/i.match(value)
+                measurement(match && match[1], field: :utilization, component: "system", percent: true)
+              else
+                count(value, field: :memory, component: "system")
+              end
+            end
+            seen[field] = true
+          end
+          total, used, rate = values.values_at(:total, :used, :rate)
+          valid = total && total.positive? && used && used <= total && rate && (rate - used.fdiv(total) * 100).abs < 1
+          @issues << { code: :inconsistent_memory_totals, component: "system" } unless valid
+          row = { component: "system", scope: "physical", utilization: valid ? used.fdiv(total) * 100 : nil,
+            total_bytes: total, used_bytes: used, free_bytes: nil, basis: :used_including_cache }
+          build_result([ row ], complete: complete, recognized: true, identity: %i[component scope])
+        end
+
+        # 由兼容的容量与使用量测量计算内存利用率。
+        def memory_record(component, scope, unit, values)
+          total, used, free = values.map { |value| count(value, field: :memory, component: component) }
+          valid = total && total.positive? && used && free && used <= total && free <= total && (scope == "container" || used + free == total)
+          @issues << { code: :inconsistent_memory_totals, component: component } unless valid
+          { component: component, scope: scope, utilization: valid ? used.fdiv(total) * 100 : nil,
+            total_bytes: total && total * unit, used_bytes: used && used * unit, free_bytes: scope == "physical" && free ? free * unit : nil,
+            basis: scope == "container" ? :used_total : :used_including_cache }
+        end
+
+        # 仅在平台明确报告时扣除可回收内存。
+        def adjust_cache(current, values, unit)
+          unless current && current[:record][:scope] == "physical"
+            @issues << { code: :unscoped_memory_cache_adjustment }
+            return
+          end
+          row, raw, fields = current.values_at(:record, :raw, :values)
+          current[:adjustments] += 1
+          used, free = values.map { |value| count(value, field: :memory, component: row[:component]) }
+          buffers, cached = fields.values_at("Buffers", "Cached").map { |value| count(value, field: :memory, component: row[:component]) }
+          valid = raw[:utilization] && used && free && buffers && cached && current[:adjustments] == 1 &&
+            (used + free) * unit == raw[:total_bytes] && used * unit == raw[:used_bytes] - (buffers + cached) * unit &&
+            free * unit == raw[:free_bytes] + (buffers + cached) * unit
+          unless valid
+            row.replace(raw.merge(utilization: nil, basis: :unknown))
+            @issues << { code: :invalid_memory_cache_adjustment, component: row[:component] }
+            return
+          end
+          row.merge!(used_bytes: used * unit, available_bytes: free * unit,
+            utilization: (used * unit).fdiv(raw[:total_bytes]) * 100, basis: :used_minus_cache)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 系统对等体才是同步服务器；reference ID 可能是本地时钟或 IPv6 哈希。
+      class DisplayNtpServiceStatus < CtxChecker::Parsers::Base
+        include SystemValues
+        FIELDS = { "clock status" => :synchronized, "clock stratum" => :stratum,
+          "reference clock id" => :reference, "system peer" => :peer,
+          "clock offset" => :offset_ms, "leap indicator" => :leap }.freeze
+        AUXILIARY = /\A(?:Local mode|NTP version|Clock jitter|Stability|Clock precision|Root delay|Root dispersion|Peer dispersion|Nominal frequency|Actual frequency|Reference time|System poll interval):/i
+
+        private
+
+        # 解析 display ntp service status，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          row, seen, local_sync = { component: "system" }, {}, []
+          source.each_line do |raw|
+            line = raw.strip
+            next if line.empty?
+            key, value = line.split(/:\s*/, 2)
+            field = FIELDS[key.downcase]
+            if field && value
+              if seen[field]
+                row[field] = nil
+                @issues << { code: :duplicate_ntp_field, field: field }
+              else
+                row[field] = parse_field(field, value)
+              end
+              seen[field] = true
+            elsif key.casecmp?("Sync state from NTP server to local clock")
+              local_sync << value&.downcase
+            elsif !line.empty? && !AUXILIARY.match?(line)
+              @issues << { code: :unrecognized_ntp_line }
+            end
+          end
+          @issues << { code: :missing_ntp_status } unless seen[:synchronized]
+          apply_local_sync(row, local_sync) unless local_sync.empty?
+          if local_clock?(row[:peer]) || row[:peer].nil? && local_clock?(row[:reference])
+            row[:synchronized] = false
+            @issues << { code: :local_ntp_reference }
+          end
+          build_result(seen.any? ? [ row ] : [], complete: complete, recognized: seen.any?, identity: [ :component ])
+        end
+
+        # 仅存在服务器关联不能证明设备时钟已受同步校准。
+        def apply_local_sync(row, states)
+          if states.any? { |state| [ "clock not synced", "clock unsynced" ].include?(state) }
+            row[:synchronized] = false
+            @issues << { code: :ntp_local_clock_unsynchronized }
+          elsif states != [ "clock synced" ]
+            row[:synchronized] = nil unless row[:synchronized] == false
+            @issues << { code: :unknown_ntp_local_clock_state }
+          end
+        end
+
+        # 识别本地参考时钟，避免视为已同步的外部对等体。
+        def local_clock?(value)
+          /\A(?:LOCAL\(\d+\)|LOCL|127\.127\.1\.\d+)\z/i.match?(value.to_s)
+        end
+
+        # 解释单个支持的命令字段，不丢弃其他无关事实。
+        def parse_field(field, value)
+          parsed = case field
+          when :synchronized then { "synchronized" => true, "unsynchronized" => false }[value.downcase]
+          when :stratum then value.to_i if /\A\d+\z/.match?(value) && (0..16).cover?(value.to_i)
+          when :leap then value.to_i(2) if /\A[01]{2}\z/.match?(value)
+          when :offset_ms
+            match = /\A(-?\d+(?:\.\d+)?)\s*ms\z/i.match(value)
+            measurement(match[1], field: field, component: "system") if match
+          when :reference, :peer then value unless /\A(?:none|--)\z/i.match?(value)
+          end
+          @issues << { code: :invalid_ntp_field, field: field } if parsed.nil? && !%i[reference peer].include?(field)
+          parsed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 邻居表作用域由进程和区域标题确定。
+      class DisplayOspfPeer < CtxChecker::Parsers::Base
+        private
+
+        # 解析 display ospf peer，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          text = clean(text)
+          if /\AOSPF is not configured\.\z/i.match?(text.strip)
+            return build_result([], complete: complete, recognized: true, issues: [ { code: :protocol_not_configured } ])
+          end
+          rows, issues, process, area, header = [], [], nil, nil, false
+          text.each_line do |raw|
+            line = raw.strip
+            if (match = /\AOSPF Process (\d+) with Router ID ([\d.]+)\z/i.match(line))
+              process, area = match[1], nil
+            elsif (match = /\AArea:\s*([\d.]+)\z/i.match(line))
+              area = match[1]
+            elsif /\ARouter ID\s+Address\s+Pri\s+Dead-Time\s+State\s+Interface\z/i.match?(line)
+              header = true
+            elsif (match = /\A([\d.]+)\s+([\d.]+)\s+\d+\s+\S+\s+(Down|Init|Attempt|2-Way|Exstart|Exchange|Loading|Full)(?:\/[ \t]*(DR|BDR|DROther|-))?\s+(\S+)\z/i.match(line))
+              if CtxParser::Values.valid_host?(match[1]) && CtxParser::Values.valid_host?(match[2])
+                issues << { code: :ospf_scope_missing } unless process && area
+                rows << { vrf: nil, process_id: process, area: area,
+                  interface: CtxChecker::Parsers::InterfaceNames.normalize(match[5], platform: :h3c), router_id: match[1], neighbor_address: match[2],
+                  state: match[3].downcase == "2-way" ? :two_way : match[3].downcase.to_sym,
+                  network_type: :unknown, local_role: :unknown, neighbor_role: match[4] && match[4] != "-" ? match[4].downcase.to_sym : :unknown }
+              else
+                issues << { code: :invalid_ospf_peer }
+              end
+            elsif !line.empty? && line != "Neighbor Brief Information"
+              issues << { code: :unrecognized_ospf_line }
+            end
+          end
+          build_result(rows, complete: complete, recognized: header && rows.any?, issues: issues, identity: %i[vrf process_id interface router_id])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "system_values"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 逐电源评估；电源缺失时仍需区分槽位是否应有模块。
+      class DisplayPower < CtxChecker::Parsers::Base
+        include SystemValues
+
+        private
+
+        # 解析 display power，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          source = clean(text)
+          rows, location, columns, contexts, context = [], "system", nil, [], nil
+          source.each_line do |raw|
+            line = raw.strip
+            if (match = /\A((?:Chassis \d+ )?Slot \d+|Chassis \d+)\s*:\z/i.match(line))
+              location, columns = scope_name(match[1]), nil
+              contexts << (context = { component: location, count: 0 })
+            elsif (match = /\APowerID\s+State\s+Mode\s+Current\(A\)\s+Voltage\(V\)\s+Power\(W\)(?:\s+(FanDirection))?(?:\s+(Switch))?\z/i.match(line))
+              columns = match.captures.compact.map(&:downcase)
+            elsif columns && (match = /\A(\d+)\s+(\S+)\s+(?:AC|DC|--)\s+#{NUMBER}\s+#{NUMBER}\s+(#{NUMBER})(?:\s+(\S+))?(?:\s+(\S+))?\z/i.match(line)) && match.captures.drop(3).compact.size == columns.size
+              row = power_record(location, match[1], match[2], match[3])
+              metadata = columns.zip(match.captures.drop(3).compact).to_h
+              if metadata.key?("switch") && !metadata["switch"].casecmp?("on")
+                row[:status] = :unknown if row[:status] == :ok
+                @issues << { code: :power_switch_not_on, component: row[:component] }
+              end
+              rows << row
+              context[:count] += 1 if context
+            elsif (match = /\APower\s+(\d+)\s+State:\s*(\S+)\z/i.match(line))
+              rows << power_record(location, match[1], match[2], nil)
+              context[:count] += 1 if context
+            elsif !line.empty? && !/\A(?:-+|Input Power:\s*(?:#{NUMBER}\s*(?:W|\(W\))|--|N\/?A|error))\z/i.match?(line)
+              @issues << { code: :unrecognized_power_line }
+            end
+          end
+          contexts.each do |entry|
+            @issues << { code: :missing_power_scope_records, component: entry[:component] } if entry[:count].zero?
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component kind])
+        end
+
+        # 构建包含状态与测量值的归一化电源记录。
+        def power_record(location, id, state, value)
+          component = "#{location}/power #{id}"
+          status = component_state(state, component: component)
+          watts = measurement(value, field: :watts, component: component)
+          if watts&.negative?
+            watts = nil
+            @issues << { code: :invalid_measurement, component: component, field: :watts }
+          end
+          { component: component, kind: :power_supply, status: status,
+            present: status == :absent ? false : (status == :unknown ? nil : true), watts: watts }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require_relative "../../parsers/interface_names"
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 诊断表保留各光通道及模块自身阈值。
+      class DisplayTransceiverDiagnosis < CtxChecker::Parsers::Base
+        NUMBER = /(?:-?\d+(?:\.\d+)?|N\/A|--)/i
+        ABSENT = /\A(?:The )?(?:transceiver is absent|no transceiver|transceiver is not present)\.?\z/i
+        DOM_UNSUPPORTED = /\A(?:(?:The )?transceiver does not support (?:digital diagnosis|diagnostic(?: information)?|this function)|(?:The )?diagnostic information is not supported)\.?\z/i
+        OPERATION_UNSUPPORTED = /\AThe operation is not supported\.\z/i
+
+        private
+
+        # 解析 display transceiver diagnosis，保留不完整或不支持的证据。
+        def parse_output(text, complete:)
+          text = clean(text)
+          rows, issues = [], []
+          text.split(/(?=^\S+ transceiver diagnostic information:)/i).each do |block|
+            next if block.strip.empty?
+            match = /\A(\S+) transceiver diagnostic information:/i.match(block)
+            unless match
+              issues << { code: :unrecognized_optics_block }
+              next
+            end
+            name = CtxChecker::Parsers::InterfaceNames.normalize(match[1], platform: :h3c)
+            lines = block.lines.drop(1).map(&:strip).reject(&:empty?)
+            if (state = availability(lines, name))
+              rows.concat(measurements(name, nil, nil, nil, **state))
+              next
+            end
+            samples, limits, section, mode = [], {}, nil, nil
+            lines.each do |line|
+              case line
+              when /\ACurrent diagnostic parameters:/i then section, mode = :current, nil
+              when /\AAlarm thresholds:/i then section, mode = :alarm, nil
+              when /\AWarning thresholds:/i then section, mode = :warning, nil
+              when /RX power\(dBm\)\s+TX power\(dBm\)\z/i
+                mode = line.start_with?("[channel]") ? :lanes : :single
+              else
+                if section == :current && mode == :single && (sample = /\A#{NUMBER}\s+#{NUMBER}\s+#{NUMBER}\s+(#{NUMBER})\s+(#{NUMBER})\z/i.match(line))
+                  samples << [ nil, number(sample[1], interface: name), number(sample[2], interface: name) ]
+                elsif section == :current && mode == :lanes && (sample = /\A(\d+)\s+#{NUMBER}\s+(#{NUMBER})\s+(#{NUMBER})\z/i.match(line))
+                  samples << [ sample[1].to_i, number(sample[2], interface: name), number(sample[3], interface: name) ]
+                elsif %i[alarm warning].include?(section) && mode && (limit = /\A(High|Low)\s+#{NUMBER}\s+#{NUMBER}\s+#{NUMBER}\s+(#{NUMBER})\s+(#{NUMBER})\z/i.match(line))
+                  key = "#{limit[1].downcase}_#{section}".to_sym
+                  if limits.key?(key)
+                    issues << { code: :duplicate_optics_threshold, interface: name }
+                  else
+                    limits[key] = [ number(limit[2], interface: name), number(limit[3], interface: name) ]
+                  end
+                elsif line.match?(/\A(?:High|Low)\b/) || (mode && line.match?(/\A[-\d]/))
+                  issues << { code: :invalid_optics_measurement, interface: name }
+                elsif !line.empty? && !line.match?(/\A-+\z/)
+                  issues << { code: :unrecognized_optics_field, interface: name }
+                end
+              end
+            end
+            issues << { code: :optics_measurements_missing, interface: name } if samples.empty?
+            samples.each do |lane, rx, tx|
+              measurements(name, lane, rx, tx, present: true, dom_supported: true).each_with_index do |record, index|
+                limits.each { |key, values| record[key] = values[index] }
+                rows << record
+              end
+            end
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, issues: issues, identity: %i[interface lane metric])
+        end
+
+        # 状态标记不能掩盖后续数据、重复状态或未知诊断内容。
+        def availability(lines, name)
+          absent = lines.any? { |line| ABSENT.match?(line) }
+          unsupported = lines.any? { |line| DOM_UNSUPPORTED.match?(line) }
+          operation_unsupported = lines.any? { |line| OPERATION_UNSUPPORTED.match?(line) }
+          return unless absent || unsupported || operation_unsupported
+
+          if lines.size != 1
+            @issues << { code: :ambiguous_optics_availability, interface: name }
+            return { present: nil, dom_supported: nil }
+          end
+          { present: operation_unsupported ? nil : !absent, dom_supported: absent ? nil : false }
+        end
+
+        # 解析数值测量，不将未知文本转换为零。
+        def number(value, interface:)
+          return unless value.match?(/\A-?\d+(?:\.\d+)?\z/)
+
+          number = Float(value)
+          return number if number.finite?
+
+          @issues << { code: :invalid_optics_measurement, interface: interface }
+          nil
+        end
+
+        # 提取支持的传感器值，保留测量不可用的状态。
+        def measurements(name, lane, rx, tx, present:, dom_supported:)
+          [ [ :rx_power, rx ], [ :tx_power, tx ] ].map do |metric, value|
+            { interface: name, lane: lane, metric: metric, value: value, unit: :dbm,
+              low_alarm: nil, low_warning: nil, high_warning: nil, high_alarm: nil, alarm: :unknown,
+              present: present, dom_supported: dom_supported }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CtxChecker
+  module H3c
+    module Parsers
+      # 共享 Comware 标量转换；测量缺失始终不能变成零。
+      module SystemValues
+        NUMBER = /(?:-?\d+(?:\.\d+)?|--|N\/?A|error)/i
+        COMPONENT_STATES = { "normal" => :ok, "ok" => :ok, "fault" => :failed,
+          "faulty" => :failed, "error" => :failed, "fandirectionfault" => :failed,
+          "absent" => :absent, "warning" => :warning }.freeze
+
+        private
+
+        # 解析支持的传感器测量值及回显单位。
+        def measurement(value, field:, component:, percent: false)
+          return if value.nil? || /\A(?:--|N\/?A|error)\z/i.match?(value)
+          number = Float(value, exception: false)
+          return number if number&.finite? && (!percent || (0..100).cover?(number))
+
+          @issues << { code: :invalid_measurement, field: field, component: component }
+          nil
+        end
+
+        # 解析非负计数，同时保留未知值。
+        def count(value, field:, component:)
+          return value.to_i if /\A\d+\z/.match?(value.to_s)
+
+          @issues << { code: :invalid_measurement, field: field, component: component }
+          nil
+        end
+
+        # 按平台支持的标签归一化硬件组件状态。
+        def component_state(value, component:)
+          COMPONENT_STATES.fetch(value.downcase) do
+            @issues << { code: :unrecognized_component_state, component: component }
+            :unknown
+          end
+        end
+
+        # 确定模块或路由上下文的身份。
+        def scope_name(value) = value.downcase.strip.gsub(/\s+/, " ")
+      end
+    end
+  end
+end

data/lib/ctx_checker/h3c/profile.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "ctx_parser/profile"
+require_relative "parsers/display_interface"
+require_relative "parsers/display_link_aggregation_verbose"
+require_relative "parsers/display_transceiver_diagnosis"
+require_relative "parsers/display_bgp_peer"
+require_relative "parsers/display_ospf_peer"
+
+require_relative "parsers/display_cpu_usage"
+require_relative "parsers/display_memory"
+require_relative "parsers/display_environment"
+require_relative "parsers/display_fan"
+require_relative "parsers/display_power"
+require_relative "parsers/display_clock"
+require_relative "parsers/display_ntp_service_status"
+require_relative "parsers/display_alarm_active"
+require_relative "parsers/display_counters_inbound_interface"
+require_relative "parsers/display_counters_outbound_interface"
+
+module CtxChecker
+  module H3c
+    # 声明 Comware 只读查询；BGP 明确限定为公网 IPv4 单播。
+    class Profile < CtxParser::Profile
+      CATALOG = CtxParser::CommandCatalog.new([
+        { dimensions: %i[interfaces counters], command: "display interface", parser: Parsers::DisplayInterface },
+        { dimensions: [ :counters ], command: "display counters inbound interface", parser: Parsers::DisplayCountersInboundInterface },
+        { dimensions: [ :counters ], command: "display counters outbound interface", parser: Parsers::DisplayCountersOutboundInterface },
+        { dimensions: [ :aggregation ], command: "display link-aggregation verbose", parser: Parsers::DisplayLinkAggregationVerbose },
+        { dimensions: [ :optics ], command: "display transceiver diagnosis interface", parser: Parsers::DisplayTransceiverDiagnosis },
+        { dimensions: [ :bgp ], command: "display bgp peer ipv4", parser: Parsers::DisplayBgpPeer },
+        { dimensions: [ :ospf ], command: "display ospf peer", parser: Parsers::DisplayOspfPeer },
+        { dimensions: [ :cpu ], command: "display cpu-usage", parser: Parsers::DisplayCpuUsage },
+        { dimensions: [ :memory ], command: "display memory", parser: Parsers::DisplayMemory },
+        { dimensions: [ :temperature ], command: "display environment", parser: Parsers::DisplayEnvironment },
+        { dimensions: [ :environment ], command: "display fan", parser: Parsers::DisplayFan },
+        { dimensions: [ :power ], command: "display power", parser: Parsers::DisplayPower },
+        { dimensions: [ :clock ], command: "display clock", parser: Parsers::DisplayClock },
+        { dimensions: [ :ntp ], command: "display ntp-service status", parser: Parsers::DisplayNtpServiceStatus },
+        { dimensions: [ :alarms ], command: "display alarm active", parser: Parsers::DisplayAlarmActive }
+      ], multi_command: true)
+      COMMANDS = CATALOG.commands
+      PARSERS = CATALOG.parsers
+
+      # 每个已观察接口都必须保留入站与出站两个方向的证据状态。
+      def counter_metrics = %i[in_errors out_errors].freeze
+    end
+  end
+end