ctx_checker 0.1.0

data/lib/ctx_checker/hillstone/parsers/show_clock.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # StoneOS 命名时区可能由用户自定义，不能用于确定 UTC 偏移。
+      class ShowClock < CtxChecker::Parsers::Base
+        private
+
+        # 保留已识别的设备本地时间，不猜测时区或同步状态。
+        def parse_output(text, complete:)
+          source = clean(text)
+          zones, clocks = [], []
+          source.each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            next if line.empty?
+
+            if (match = /\ACurrent time zone:\s*(\S+)\z/i.match(line))
+              zones << match[1]
+            elsif (match = /\A(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})\s+(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)\z/.match(line))
+              clocks << match.captures
+            else
+              @issues << { code: :unrecognized_clock_line, line: number }
+            end
+          end
+          @issues << { code: :ambiguous_clock_time, count: clocks.size } unless clocks.one?
+          @issues << { code: :ambiguous_clock_timezone, count: zones.size } unless zones.one?
+          instant = normalize_time(clocks.first, zones.first) if clocks.one? && zones.one?
+          rows = clocks.any? ? [ { component: "system", time: instant, source: "system_clock", synchronized: nil } ] : []
+          build_result(rows, complete: complete, recognized: clocks.any?, identity: [ :component ])
+        end
+
+        # 仅明确数字偏移或 UTC 标签允许计算时钟偏差。
+        def normalize_time(parts, zone)
+          date, clock, weekday = parts
+          parsed_date = Date.iso8601(date)
+          unless Date::DAYNAMES[parsed_date.wday] == weekday && clock.split(":").map(&:to_i).zip([ 24, 60, 60 ]).all? { |value, limit| value < limit }
+            @issues << { code: :invalid_clock_time }
+            return
+          end
+          offset = zone_offset(zone)
+          unless offset
+            @issues << { code: :clock_offset_unknown }
+            return
+          end
+          Time.iso8601("#{date}T#{clock}#{offset}").iso8601
+        rescue ArgumentError
+          @issues << { code: :invalid_clock_time }
+          nil
+        end
+
+        # 用户自定义时区名称不能替代实际偏移值。
+        def zone_offset(zone)
+          return "+00:00" if %w[UTC GMT Z].include?(zone)
+
+          match = /\A(?:UTC|GMT)?([+-])(\d{2}):?(\d{2})\z/.match(zone)
+          return unless match && match[2].to_i < 24 && match[3].to_i < 60
+
+          "#{match[1]}#{match[2]}:#{match[3]}"
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/hillstone/parsers/show_cpu.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # 保留设备报告的时间窗，不为整体平均值虚构周期。
+      class ShowCpu < CtxChecker::Parsers::Base
+        WINDOWS = { "1 minute" => 60, "5 minutes" => 300, "15 minutes" => 900 }.freeze
+
+        private
+
+        # 要求当前采样及回显声明的各标准采样时间窗均有证据。
+        def parse_output(text, complete:)
+          rows = []
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if (match = /\A(Average|Current) cpu utilization\s*:\s*(\S+)\s*\z/i.match(line))
+              rows << sample(match[2], scope: match[1].casecmp?("average") ? "system_average" : "system", seconds: nil)
+            elsif (match = /\ALast (1 minute|5 minutes|15 minutes)\s*:\s*(\S+)\s*\z/i.match(line))
+              rows << sample(match[2], scope: "system", seconds: WINDOWS.fetch(match[1].downcase))
+            elsif !line.empty?
+              @issues << { code: :unrecognized_cpu_line, line: number }
+            end
+          end
+          windows = rows.select { |row| row[:scope] == "system" }.map { |row| row[:window_seconds] }
+          missing = [ nil, *WINDOWS.values ] - windows
+          @issues << { code: :missing_cpu_windows, count: missing.size } if missing.any?
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component scope window_seconds])
+        end
+
+        # 无效百分比保持不可用，避免导致观测记录校验失败。
+        def sample(text, scope:, seconds:)
+          match = /\A(\d+(?:\.\d+)?)%\z/.match(text)
+          value = match && Float(match[1], exception: false)
+          valid = value&.finite? && value.between?(0, 100)
+          @issues << { code: :invalid_cpu_measurement, scope: scope, window_seconds: seconds } unless valid
+          { component: "system", scope: scope, window_seconds: seconds, utilization: valid ? value : nil }
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/hillstone/parsers/show_cpu_cntr.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # 命名 CPU 端口与队列分别保留计数器，不叠加可能重叠的值。
+      class ShowCpuCntr < CtxChecker::Parsers::Base
+        ERROR_FIELDS = %w[InBadOctets InBadPkts InMACRcvErrors InCRCAlignErrors].freeze
+        INFORMATIONAL_FIELDS = %w[InGoodOctets InGoodPkts InUnicastPkts InBroadcastPkts InMulticastPkts InControlPkts
+          InOver1518Pkts OutGoodOctets OutGoodPkts OutUnicastPkts OutBroadcastPkts OutMulticastPkts OutControlPkts
+          Pkts64Octets Pkts65to127Octets Pkts128to255Octets Pkts256to511Octets Pkts512to1023Octets Pkts1024toMaxOctets].freeze
+        UNKNOWN_FIELDS = %w[InUndersizePkts InOversizePkts InFragments InJabbers DropEvents Collisions OutDropDeferrals
+          SingleCollisions MultipleCollisions ExcessiveCollisions LateCollisions].freeze
+        FIELDS = (ERROR_FIELDS + INFORMATIONAL_FIELDS + UNKNOWN_FIELDS).freeze
+        CELL = /\G\s*([A-Za-z][A-Za-z0-9]*):\s*(\S+)(?=\s|\z)/
+
+        private
+
+        # 顶部流量汇总包含歧义拼接列，不据此生成健康事实。
+        def parse_output(text, complete:)
+          records, contexts = [], []
+          context, queue, summary = nil, nil, false
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if /\Acpu Port Send\s+Rev Counter:\z/i.match?(line)
+              summary = true
+            elsif (match = /\A([A-Za-z][A-Za-z0-9_\/.-]*), physical port (\d+):\z/i.match(line))
+              context = { component: "cpu/#{match[1]}/physical_port_#{match[2]}", fields: [], queues: [] }
+              contexts << context
+              queue, summary = nil, false
+            elsif context && (match = /\A(\d+) (RX|TX) Queue\(s\):\z/i.match(line))
+              queue = { direction: match[2].downcase, count: match[1].to_i, ids: [], headers: 0 }
+              context[:queues] << queue
+            elsif line.empty? || /\A[-=]+\z/.match?(line)
+              next
+            elsif summary && /\A(?:Port\s+Receive\s+Send|port-\d+(?:\s+\d+){1,2})\z/i.match?(line)
+              next
+            elsif context && queue
+              parse_queue(line, number, context, queue, records)
+            elsif context
+              parse_fields(line, number, context, records)
+            else
+              @issues << { code: :unrecognized_cpu_counter_row, line: number }
+            end
+          end
+          contexts.each { |entry| validate_context(entry) }
+          build_result(records, complete: complete, recognized: contexts.any?, identity: %i[component metric])
+        end
+
+        # 独立解析每个带标签字段，保留指标语义未知的状态。
+        def parse_fields(line, number, context, records)
+          position = 0
+          until /\A\s*\z/.match?(line[position..])
+            match = CELL.match(line, position)
+            unless match
+              @issues << { code: :unrecognized_cpu_counter_row, line: number }
+              break
+            end
+            field, raw = match.captures
+            context[:fields] << field
+            unless FIELDS.include?(field)
+              @issues << { code: :unrecognized_cpu_counter_field, line: number }
+            end
+            value = /\A\d+\z/.match?(raw) ? Integer(raw, 10) : nil
+            @issues << { code: :invalid_cpu_counter_value, line: number } unless value
+            category = ERROR_FIELDS.include?(field) ? :error : INFORMATIONAL_FIELDS.include?(field) ? :informational : :unknown
+            metric = field.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+            records << counter(context[:component], metric, category, value)
+            position = match.end(0)
+          end
+        end
+
+        # 队列错误作为独立观测，不叠加到硬件端口总数。
+        def parse_queue(line, number, context, queue, records)
+          direction = queue[:direction] == "rx" ? "In" : "Out"
+          if /\AQueue ID\s+#{direction} Pkts\s+#{direction} Bytes\s+Errors\z/i.match?(line)
+            queue[:headers] += 1
+          elsif queue[:headers].positive? && (match = /\A(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\z/.match(line))
+            id, packets, bytes, errors = match.captures.map { |value| Integer(value, 10) }
+            queue[:ids] << id
+            component = "#{context[:component]}/#{queue[:direction]}_queue_#{id}"
+            records << counter(component, "packets", :informational, packets)
+            records << counter(component, "bytes", :informational, bytes)
+            records << counter(component, "errors", :error, errors)
+          else
+            @issues << { code: :unrecognized_cpu_queue_row, line: number }
+          end
+        end
+
+        # 使用显式字段与队列数量识别截断或重复的组件块。
+        def validate_context(context)
+          missing = FIELDS - context[:fields]
+          @issues << { code: :cpu_counter_fields_missing, component: context[:component], count: missing.size } if missing.any?
+          directions = context[:queues].map { |queue| queue[:direction] }
+          unless directions.sort == %w[rx tx]
+            @issues << { code: :cpu_counter_queue_sections_incomplete, component: context[:component] }
+          end
+          context[:queues].each do |queue|
+            unless queue[:headers] == 1 && queue[:ids].size == queue[:count] && queue[:ids].uniq.size == queue[:count]
+              @issues << { code: :cpu_counter_queue_count_mismatch, component: context[:component], scope: queue[:direction] }
+            end
+          end
+        end
+
+        # 本命令计数器未提供运行时长或重置时间点。
+        def counter(component, metric, category, value)
+          { component: component, metric: metric, category: category, value: value, discontinuity: nil }
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/hillstone/parsers/show_environment.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require "ctx_parser/result_set"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # 分离传感器视图，避免单个硬件章节格式错误抹除其他结果。
+      class ShowEnvironment < CtxChecker::Parsers::Base
+        SECTIONS = { "Temperature information(C)" => :temperature, "Fan information" => :environment, "Power information" => :power }.freeze
+        HEADERS = { temperature: /\ADescription\s+Temperature\s+Range\z/, environment: /\ADescription\s+Status\z/,
+          power: /\ADescription\s+Status\z/ }.freeze
+        STATES = { "fine" => :ok, "normal" => :ok, "ok" => :ok, "failed" => :failed, "fault" => :failed,
+          "faulty" => :failed, "error" => :failed, "warning" => :warning, "absent" => :absent }.freeze
+        NUMBER = /-?\d+(?:\.\d+)?/
+
+        private
+
+        # 跟踪各已声明章节，并分别要求其具备表头与测量值。
+        def parse_output(text, complete:)
+          rows = { temperature: [], environment: [], power: [] }
+          issues = rows.transform_values { [] }
+          contexts, section, header = [], nil, false
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if (match = /\A(.+ information(?:\(C\))?):\z/.match(line))
+              section, header = SECTIONS[match[1]], false
+              contexts << { section: section, rows: 0, headers: 0 } if section
+              issues.each_value { |items| items << { code: :unrecognized_environment_section, line: number } } unless section
+            elsif section && HEADERS.fetch(section).match?(line)
+              header = true
+              contexts.last[:headers] += 1
+            elsif line.empty? || /\A[-=]+\z/.match?(line)
+              next
+            elsif section && header
+              record = section == :temperature ? temperature(line, issues[section]) : hardware(line, section, issues[section])
+              if record
+                rows[section] << record
+                contexts.last[:rows] += 1
+              else
+                issues[section] << { code: :unrecognized_environment_row, line: number }
+              end
+            elsif section
+              issues[section] << { code: :environment_header_missing, line: number }
+            else
+              issues.each_value { |items| items << { code: :unrecognized_environment_row, line: number } }
+            end
+          end
+          contexts.each do |context|
+            if context[:rows].zero? || context[:headers] != 1
+              issues[context[:section]] << { code: :incomplete_environment_section }
+            end
+          end
+          CtxParser::ResultSet.new(results: rows.to_h do |dimension, records|
+            identity = dimension == :temperature ? [ :component ] : %i[component kind]
+            [ dimension, build_result(records, complete: complete, recognized: records.any?, issues: issues[dimension], identity: identity) ]
+          end)
+        end
+
+        # 保留设备给出的范围，不推测边界相等时是否触发告警。
+        def temperature(line, issues)
+          match = /\A(\S+)\s+(\S+)\s+(#{NUMBER})\s*-\s*(#{NUMBER})\z/.match(line)
+          return unless match
+          component, raw, low, high = match.captures
+          value = /\A#{NUMBER}\z/.match?(raw) ? Float(raw, exception: false) : nil
+          low, high = Float(low), Float(high)
+          valid = value&.finite? && low.finite? && high.finite? && low <= high
+          issues << { code: :invalid_temperature_measurement, component: component } unless valid
+          { component: component, value: valid ? value : nil, low_alarm: low.finite? ? low : nil,
+            high_alarm: high.finite? ? high : nil, high_comparison: nil, status: :unknown }
+        end
+
+        # 仅明确状态词才能证明风扇和电源正常。
+        def hardware(line, dimension, issues)
+          match = /\A(\S+)\s+(\S+(?:\s+\S+)*)\z/.match(line)
+          return unless match
+          component, text = match.captures
+          state = STATES.fetch(text.downcase, :unknown)
+          issues << { code: :unrecognized_component_state, component: component } if state == :unknown
+          if dimension == :power
+            { component: component, kind: :power_supply, status: state, present: state == :absent ? false : (state == :unknown ? nil : true) }
+          else
+            { component: component, kind: :fan, status: state }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/hillstone/parsers/show_interface.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # StoneOS 分别展示物理、管理、链路与 IP 协议状态。
+      class ShowInterface < CtxChecker::Parsers::Base
+        NAME = /(?:x?ethernet|cellular)\d+(?:\/\d+)+(?:\.\d+)?|(?:ha|mgt|aggregate|redundant|bgroup|vswitchif|vlan|loopback|tunnel)\d+(?:\.\d+)?/i
+        HEADER = /\AInterface name\s+IP address\/mask\s+Zone name\s+H\s+A\s+L\s+P\s+MAC address(?:\s+Description)?\z/i
+        LEGEND = /\AH:physical state;\s*A:admin state;\s*L:link state;\s*P:protocol state;\s*U:up;\s*D:down(?:;\s*K:ha keep up)?(?:;\s*C:lacp down)?\z/i
+        ROW = /\A(#{NAME})\s+(\S+)\s+\S+\s+(\S)\s+(\S)\s+(\S)\s+(\S)\s+(?:[\da-f]{4}\.){2}[\da-f]{4}(?:\s+.*)?\z/i
+
+        private
+
+        # 识别无地址链路时，仍保留 IP 协议 down 状态。
+        def parse_output(text, complete:)
+          rows, issues, header = [], [], false
+          clean(text).each_line do |raw|
+            line = raw.strip
+            next if line.empty? || /\A[-=]+\z/.match?(line) || LEGEND.match?(line)
+
+            if HEADER.match?(line)
+              issues << { code: :duplicate_interface_header } if header
+              header = true
+            elsif header && (match = ROW.match(line))
+              row = interface_record(match, issues)
+              rows << row if row
+            else
+              issues << { code: :unrecognized_interface_line }
+            end
+          end
+          issues << { code: :interface_records_missing } if header && rows.empty?
+          interfaces = build_result(rows, complete: complete, recognized: header, issues: issues, identity: [ :name ])
+          groups = interfaces.records.select { |row| row[:kind] == :aggregate }.map do |row|
+            { group: row[:name], member: nil, member_status: :unknown, oper_status: row[:oper_status] }
+          end
+          missing_members = groups.map { |group| { code: :aggregation_members_unavailable, group: group[:group] } }
+          CtxParser::ResultSet.new(results: {
+            interfaces: interfaces,
+            aggregation: build_result(groups, complete: complete, recognized: header,
+              issues: interfaces.issues + missing_members, identity: %i[group member])
+          })
+        end
+
+        # 仅当前一单元格具有地址形式时，才解释相邻状态列。
+        def interface_record(match, issues)
+          name = CtxChecker::Parsers::InterfaceNames.normalize(match[1], platform: :hillstone)
+          unless /\A[\da-f:.]+\/\d+\z/i.match?(match[2]) && IPAddr.new(match[2])
+            issues << { code: :invalid_interface_address, interface: name }
+            return
+          end
+          flags = match.captures[2, 4].map(&:upcase)
+          unless flags.all? { |flag| %w[U D C].include?(flag) }
+            issues << { code: :unknown_interface_state, interface: name }
+          end
+          if flags[2] == "U" && flags.first(2).include?("D")
+            issues << { code: :inconsistent_interface_state, interface: name }
+          end
+          { name: name, kind: CtxChecker::Parsers::InterfaceNames.kind(name),
+            admin_status: state(flags[1]), oper_status: state(flags[2]), protocol_status: state(flags[3]),
+            protocol_applicable: !%w[0.0.0.0/0 ::/0].include?(match[2]),
+            parent: name.include?(".") ? name.split(".").first : nil }
+        rescue IPAddr::InvalidAddressError, IPAddr::InvalidPrefixError
+          issues << { code: :invalid_interface_address, interface: name }
+          nil
+        end
+
+        # HA keep-up 不能证明接口可转发普通流量。
+        def state(flag)
+          case flag
+          when "U" then :up
+          when "D", "C" then :down
+          else :unknown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/hillstone/parsers/show_interface_counter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # StoneOS 仅列出在线接口的累计丢弃量，不提供 CRC 或错误总数。
+      class ShowInterfaceCounter < CtxChecker::Parsers::Base
+        HEADER = /\Ainterface\s+in frames\s+in octets\s+out frames\s+out octets\s+in discard\s+out discard\z/i
+        ROW = /\A([a-z][\w\/.-]*)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\z/i
+
+        private
+
+        # 解释计数器前先校验列顺序；缺少采样时保留 nil。
+        def parse_output(text, complete:)
+          rows, issues, header, count = [], [], false, 0
+          clean(text).each_line do |raw|
+            line = raw.strip
+            next if line.empty? || /\A[-=]+\z/.match?(line)
+
+            if HEADER.match?(line)
+              issues << { code: :duplicate_counter_header } if header
+              header = true
+            elsif /\Ainterface\b/i.match?(line)
+              header = false
+              issues << { code: :unrecognized_counter_header }
+            elsif header && (match = ROW.match(line))
+              count += 1
+              name = CtxChecker::Parsers::InterfaceNames.normalize(match[1], platform: :hillstone)
+              if CtxChecker::Parsers::InterfaceNames.kind(name) == :unknown
+                issues << { code: :unknown_counter_interface, interface: name }
+              end
+              unless match.captures[1, 4].all? { |value| /\A\d+\z/.match?(value) }
+                issues << { code: :invalid_traffic_counter, interface: name }
+              end
+              %i[in_discards out_discards].zip(match.captures.last(2)).each do |metric, value|
+                issues << { code: :invalid_counter_value, interface: name, metric: metric } unless /\A\d+\z/.match?(value)
+                rows << { interface: name, metric: metric, value: /\A\d+\z/.match?(value) ? Integer(value, 10) : nil,
+                  discontinuity: nil }
+              end
+            else
+              issues << { code: :unrecognized_counter_line }
+            end
+          end
+          issues << { code: :empty_counter_table } if header && count.zero?
+          build_result(rows, complete: complete, recognized: header || rows.any?, issues: issues,
+            identity: %i[interface metric])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # BGP 配置为空属于明确证据，但不能证明所有 VRouter 均健康。
+      class ShowIpBgpSummary < CtxChecker::Parsers::Base
+        private
+
+        # 仅支持已观察到的 StoneOS 格式，不假设使用 Cisco 表格语法。
+        def parse_output(text, complete:)
+          lines = clean(text).lines.map(&:strip).reject(&:empty?)
+          recognized = lines == [ "No IPv4 neighbor is configured" ]
+          issues = [ { code: recognized ? :protocol_not_configured : :unrecognized_bgp_output } ]
+          build_result([], complete: complete, recognized: recognized, issues: issues)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # StoneOS 的 OSPF 正文可能为空，但这不能证明邻居或进程覆盖完整。
+      class ShowIpOspfNeighbor < CtxChecker::Parsers::Base
+        private
+
+        # 在取得真实或文档明确的邻居表前保留未知状态。
+        def parse_output(text, complete:)
+          source = clean(text)
+          issue = source.strip.empty? ? :ospf_neighbor_state_unavailable : :unrecognized_ospf_output
+          build_result([], complete: complete, recognized: false, issues: [ { code: issue } ])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/hillstone/parsers/show_memory.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module Hillstone
+    module Parsers
+      # 使用当前总量计算使用率，不将历史曲线分桶作为当前采样。
+      class ShowMemory < CtxChecker::Parsers::Base
+        HISTORY_SAMPLES = { "60 seconds" => 60, "60 minutes" => 60, "24 hours" => 24, "7 days" => 168 }.freeze
+
+        private
+
+        # 检查历史数据结构，但仅保留当前物理内存池的测量值。
+        def parse_output(text, complete:)
+          percentages, totals, histories = [], [], []
+          header_count, history = 0, nil
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if (match = /\AThe percentage of memory utilization:\s*(\S+)\s*%\z/i.match(line))
+              percentages << percentage(match[1])
+              history = nil
+            elsif /\Atotal\(KB\)\s+used\(KB\)\s+free\(KB\)\z/i.match?(line)
+              header_count += 1
+              history = nil
+            elsif (match = /\AMemory utilization in last (60 seconds|60 minutes|24 hours|7 days)\(%\):\z/i.match(line))
+              history = { section: match[1].downcase, indices: [], header: 0 }
+              histories << history
+            elsif history && line == "memoryutil"
+              history[:header] += 1
+            elsif history && (match = /\A(\d+)\s*:\s*(\S+)\z/.match(line))
+              history[:indices] << match[1].to_i
+              @issues << { code: :invalid_memory_history_value, section: history[:section] } unless percentage(match[2])
+            elsif !history && header_count.positive? && (match = /\A(\d+)\s+(\d+)\s+(\d+)\z/.match(line))
+              totals << match.captures.map(&:to_i)
+            elsif !line.empty?
+              @issues << { code: :unrecognized_memory_line, line: number }
+            end
+          end
+          validate_histories(histories)
+          row = current_record(percentages, totals, header_count)
+          build_result(row ? [ row ] : [], complete: complete, recognized: percentages.any? || header_count.positive?, identity: %i[component scope])
+        end
+
+        # 仅接受有限且在设备合理范围内的百分比。
+        def percentage(text)
+          return unless /\A\d+(?:\.\d+)?\z/.match?(text)
+          value = Float(text, exception: false)
+          value if value&.finite? && value.between?(0, 100)
+        end
+
+        # 重复、缺失或截断的时间桶不能掩盖证据丢失。
+        def validate_histories(histories)
+          sections = histories.map { |history| history[:section] }
+          missing = HISTORY_SAMPLES.keys - sections
+          @issues << { code: :missing_memory_history_sections, count: missing.size } if histories.any? && missing.any?
+          histories.each do |history|
+            expected = (0...HISTORY_SAMPLES.fetch(history[:section])).to_a
+            unless history[:header] == 1 && history[:indices].sort == expected
+              @issues << { code: :incomplete_memory_history, section: history[:section] }
+            end
+          end
+          if sections.uniq.size != histories.size
+            @issues << { code: :duplicate_memory_history }
+          end
+        end
+
+        # 整数汇总百分比可因截断，与已校验的总量及使用量比值相差不足一个百分点。
+        def current_record(percentages, totals, header_count)
+          unless totals.one? && percentages.size == 1 && header_count == 1
+            @issues << { code: :missing_or_ambiguous_memory_sample }
+            return
+          end
+          total, used, free = totals.first
+          valid = total.positive? && used + free == total && percentages.first
+          utilization = total.positive? ? used.fdiv(total) * 100 : nil
+          valid &&= utilization && (utilization - percentages.first).abs < 1
+          @issues << { code: :inconsistent_memory_totals } unless valid
+          { component: "system", scope: "physical", total_bytes: total * 1024, used_bytes: used * 1024,
+            free_bytes: free * 1024, utilization: valid ? utilization : nil, basis: valid ? :used_total : :unknown }
+        end
+      end
+    end
+  end
+end