ctx_checker 0.1.0

data/lib/ctx_checker/radware_alteon/parsers/info_sys_fan.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 保留厂商对关键与非关键风扇的区分。
+      class InfoSysFan < CtxChecker::Parsers::Base
+        private
+
+        # 校验每条风扇记录，并按厂商关键性定义确定故障严重级别。
+        def parse_output(text, complete:)
+          rows, tables, headers = [], 0, 0
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if line == "Fans table:"
+              tables += 1
+            elsif /\AFan-Number\s+Type\s+Status\s+Speed\z/.match?(line)
+              headers += 1
+            elsif (match = /\A(\d+)\s+(Critical|Non-critical)\s+(\S+)\s+(\S+)\z/i.match(line))
+              type, state, speed = match[2].downcase, match[3].downcase, match[4]
+              value = /\A\d+(?:\.\d+)?%\z/.match?(speed) ? Float(speed.delete_suffix("%"), exception: false) : nil
+              valid = value&.finite? && value.between?(0, 100)
+              @issues << { code: :invalid_fan_speed, line: number } unless valid
+              status = case state
+              when "operational" then :ok
+              when "failed" then type == "critical" ? :critical : :warning
+              else :unknown
+              end
+              @issues << { code: :unrecognized_fan_state, line: number } if status == :unknown
+              if status == :ok && (!valid || value.zero?)
+                status = :unknown
+                @issues << { code: :fan_measurements_inconsistent, line: number }
+              end
+              rows << { component: "fan#{match[1]}", kind: :fan, status: status }
+            elsif !line.empty? && !/\A[-\s]+\z/.match?(line)
+              @issues << { code: :unrecognized_fan_row, line: number }
+            end
+          end
+          @issues << { code: :fan_header_invalid } unless tables == 1 && headers == 1
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component kind])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/info_sys_general.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 通用信息提供设备本地时间及其明确的 GMT 偏移。
+      class InfoSysGeneral < CtxChecker::Parsers::Base
+        private
+
+        # 仅投影当前时钟，不使用启动、应用或保存时间戳。
+        def parse_output(text, complete:)
+          lines = clean(text).lines.map(&:strip)
+          clocks = lines.grep(/\ASystem Information at\b/)
+          zones = lines.grep(/\ATime zone:/)
+          @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
+
+        # 计算偏差前，要求日期、星期、时钟与数字偏移均有效。
+        def normalize_time(clock_line, zone_line)
+          clock = /\ASystem Information at (\d{2}:\d{2}:\d{2}) (Sun|Mon|Tue|Wed|Thu|Fri|Sat) ([A-Z][a-z]{2}) (\d{1,2}), (\d{4})\z/.match(clock_line)
+          offset = /\ATime zone:\s*.+\(GMT offset ([+-])(\d{2}):(\d{2})\)\z/.match(zone_line)
+          unless offset && offset[2].to_i < 24 && offset[3].to_i < 60
+            @issues << { code: :clock_offset_unknown }
+            return
+          end
+          unless clock && clock[1].split(":").map(&:to_i).zip([ 24, 60, 60 ]).all? { |value, limit| value < limit }
+            raise ArgumentError, "Invalid clock"
+          end
+          date = Date.strptime("#{clock[3]} #{clock[4]} #{clock[5]}", "%b %d %Y")
+          raise ArgumentError, "Invalid clock weekday" unless Date::ABBR_DAYNAMES[date.wday] == clock[2]
+
+          Time.iso8601("#{date.iso8601}T#{clock[1]}#{offset[1]}#{offset[2]}:#{offset[3]}").iso8601
+        rescue ArgumentError
+          @issues << { code: :invalid_clock_time }
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/info_sys_ps.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 报告声明的供电组合，不虚构单个电源模块身份。
+      class InfoSysPs < CtxChecker::Parsers::Base
+        STATES = { "ok" => :ok, "failed" => :failed, "failure" => :failed, "warning" => :warning }.freeze
+
+        private
+
+        # 未识别的汇总状态保持不可用，不推定冗余供电正常。
+        def parse_output(text, complete:)
+          rows = []
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if (match = /\A(Single|Dual) Power Supply Status:\s*(.+)\z/i.match(line))
+              state = STATES.fetch(match[2].downcase, :unknown)
+              @issues << { code: :unrecognized_power_state, line: number } if state == :unknown
+              rows << { component: "#{match[1].downcase}_power_supply_system", kind: :power_supply, status: state, present: nil }
+            elsif !line.empty?
+              @issues << { code: :unrecognized_power_line, line: number }
+            end
+          end
+          @issues << { code: :conflicting_power_arrangements } if rows.map { |row| row[:component] }.uniq.size > 1
+          rows = [] if rows.map { |row| row[:component] }.uniq.size > 1
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component kind])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/info_sys_temp.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 读取同一命令报告的传感器值及阈值语义。
+      class InfoSysTemp < CtxChecker::Parsers::Base
+        NUMBER = /-?\d+(?:\.\d+)?/
+        STATES = { "ok" => :ok, "high" => :warning, "warning" => :warning, "critical" => :critical }.freeze
+
+        private
+
+        # 阈值缺失时保留未知，拒绝矛盾的汇总或范围证据。
+        def parse_output(text, complete:)
+          rows, highs, criticals, summaries = [], [], [], []
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if (match = /\ASensor (\d+) has (\S+) degree Celsius\z/.match(line))
+              value = /\A#{NUMBER}\z/.match?(match[2]) ? Float(match[2], exception: false) : nil
+              @issues << { code: :invalid_temperature_measurement, line: number } unless value&.finite?
+              rows << { component: "sensor#{match[1]}", value: value&.finite? ? value : nil, status: :unknown }
+            elsif (match = /\ACurrent device temperature is (.+)\z/.match(line))
+              summaries << STATES.fetch(match[1].downcase, :unknown)
+            elsif (match = /\AHigh temperature is (#{NUMBER})-(#{NUMBER}) degree Celsius\z/.match(line))
+              highs << match.captures.map { |value| Float(value) }
+            elsif (match = /\ACritical temperature (#{NUMBER}) and above degree Celsius\z/.match(line))
+              criticals << Float(match[1])
+            elsif !line.empty? && ![ "Note:", "System will shutdown if it reaches Critical temperature" ].include?(line)
+              @issues << { code: :unrecognized_temperature_line, line: number }
+            end
+          end
+          valid_bounds = highs.one? && criticals.one? && highs.first.all?(&:finite?) && criticals.first.finite? &&
+            highs.first.first < criticals.first && highs.first.last == criticals.first
+          if valid_bounds
+            rows.each { |row| row.merge!(high_warning: highs.first.first, high_alarm: criticals.first, high_comparison: :gte) }
+          elsif highs.any? || criticals.any?
+            @issues << { code: :temperature_thresholds_invalid }
+          end
+          state = summaries.one? ? summaries.first : :unknown
+          @issues << { code: :temperature_summary_unavailable } if state == :unknown
+          if %i[warning critical].include?(state)
+            rows << { component: "device_temperature", value: nil, status: state }
+          elsif state == :ok && valid_bounds && rows.any? { |row| row[:value] && row[:value] >= highs.first.first }
+            @issues << { code: :temperature_state_disagreement }
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, identity: [ :component ])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/info_transceiver.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 模块只有测量值而无阈值时，不能证明光学健康。
+      class InfoTransceiver < CtxChecker::Parsers::Base
+        HEADER = /\APort\s+Temperature\s+Voltage\s+Current\s+Optical\s+Optical\s+Vendor Name\s+Vendor PN\s+VendorRev\s+VendorsN\s+VendorDateCode\z/i
+        LABELS = /\A\(Celsius\)\s+\(Volts\)\s+\(mA\)\s+Tx Power\s+Rx Power\s+\(yymmdd\)\z/i
+        UNITS = /\A\(dBm\)\s+\(dBm\)\z/i
+        ROW = /\A(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+\S+(?:\s+\S+){4,}\z/
+        NUMBER = /\A[+-]?\d+(?:\.\d+)?\z/
+
+        private
+
+        # 指定光学方向或单位前，先校验多行表头。
+        def parse_output(text, complete:)
+          rows, issues, headings = [], [], []
+          clean(text).each_line do |raw|
+            line = raw.strip
+            next if line.empty? || /\A[-\s]+\z/.match?(line)
+
+            if HEADER.match?(line) || LABELS.match?(line) || UNITS.match?(line)
+              heading = HEADER.match?(line) ? :header : LABELS.match?(line) ? :labels : :units
+              issues << { code: :duplicate_optics_header } if headings.include?(heading)
+              headings << heading
+            elsif headings == %i[header labels units] && (match = /\A(\d+)\s+NA\z/i.match(line)) && match[1].to_i.positive?
+              rows.concat(measurements(match[1], nil, nil))
+            elsif headings == %i[header labels units] && (match = ROW.match(line)) && match[1].to_i.positive?
+              values = match.captures[1, 5]
+              unless values.all? { |value| value.casecmp?("NA") || !number(value).nil? }
+                issues << { code: :invalid_optics_value, interface: "port#{Integer(match[1], 10)}" }
+              end
+              rows.concat(measurements(match[1], number(values[3]), number(values[4])))
+            else
+              issues << { code: :unrecognized_optics_line }
+              headings = [] if /\APort\b|\A\(|Optical|Power/.match?(line)
+            end
+          end
+          issues << { code: :optics_header_missing } unless headings == %i[header labels units]
+          issues << { code: :optics_measurements_missing } if rows.empty?
+          build_result(rows, complete: complete, recognized: headings.include?(:header), issues: issues,
+            identity: %i[interface lane metric])
+        end
+
+        # 长、短 NA 行均保留模块是否存在及 DOM 是否支持的未知状态。
+        def measurements(port, tx, rx)
+          measured = !tx.nil? || !rx.nil?
+          %i[tx_power rx_power].zip([ tx, rx ]).map do |metric, value|
+            { interface: "port#{Integer(port, 10)}", lane: nil, metric: metric, value: value, unit: :dbm,
+              low_alarm: nil, low_warning: nil, high_warning: nil, high_alarm: nil, alarm: :unknown,
+              present: measured ? true : nil, dom_supported: measured ? true : nil, applicable: nil }
+          end
+        end
+
+        # 保留有限 dBm 值，不将不可用单元格视为零。
+        def number(value)
+          return unless NUMBER.match?(value)
+
+          parsed = Float(value)
+          parsed if parsed.finite?
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/stats_mp_cpu.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 区分管理处理器与业务处理器的利用率采样。
+      class StatsMpCpu < CtxChecker::Parsers::Base
+        WINDOWS = [ 1, 4, 64 ].freeze
+
+        private
+
+        # 要求各文档规定的 MP 时间窗完整，无效读数保持未知。
+        def parse_output(text, complete:)
+          rows, headers = [], 0
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if line == "CPU utilization:"
+              headers += 1
+            elsif (match = /\AcpuUtil(\d+)Seconds? \(time base\):\s*(\S+)\z/.match(line))
+              seconds = match[1].to_i
+              value = /\A\d+(?:\.\d+)?%\z/.match?(match[2]) ? Float(match[2].delete_suffix("%"), exception: false) : nil
+              valid = WINDOWS.include?(seconds) && value&.finite? && value.between?(0, 100)
+              @issues << { code: :invalid_cpu_measurement, line: number } unless valid
+              rows << { component: "MP", scope: "management_plane", window_seconds: seconds, utilization: valid ? value : nil }
+            elsif !line.empty? && !/\A-+\z/.match?(line)
+              @issues << { code: :unrecognized_cpu_line, line: number }
+            end
+          end
+          @issues << { code: :cpu_header_invalid } unless headers == 1
+          missing = WINDOWS - rows.map { |row| row[:window_seconds] }
+          @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
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/stats_mp_mem.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 设备 RAM 与进程虚拟内存、RSS 属于不同内存作用域。
+      class StatsMpMem < CtxChecker::Parsers::Base
+        LABELS = { "Total device" => :total, "Free device" => :free, "Cached (Linux)" => :cached,
+          "MP Virtual Memory" => :virtual, "MP Resident(RSS Linux) Memory" => :rss }.freeze
+        UNITS = { "KB" => 1024, "MB" => 1024**2, "GB" => 1024**3 }.freeze
+
+        private
+
+        # 扣除明确报告的 Linux 缓存；原始进程数值仅作为来源证据保留。
+        def parse_output(text, complete:)
+          values, headers = Hash.new { |hash, key| hash[key] = [] }, 0
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if line == "Memory stats:"
+              headers += 1
+            elsif (match = /\A(.+?):\s*(\S+)\s+(\S+)\z/.match(line))
+              label = LABELS[match[1].gsub(/\s+/, " ")]
+              unless label
+                @issues << { code: :unrecognized_memory_line, line: number }
+                next
+              end
+              value = /\A\d+(?:\.\d+)?\z/.match?(match[2]) ? Float(match[2], exception: false) : nil
+              multiplier = UNITS[match[3]]
+              amount = value && multiplier && value * multiplier
+              valid = amount&.finite?
+              @issues << { code: :invalid_memory_measurement, field: label } unless valid
+              values[label] << (valid ? amount.round : nil)
+            elsif !line.empty? && !/\A-+\z/.match?(line)
+              @issues << { code: :unrecognized_memory_line, line: number }
+            end
+          end
+          @issues << { code: :memory_header_invalid } unless headers == 1
+          duplicates = values.count { |_name, readings| readings.size > 1 }
+          @issues << { code: :duplicate_memory_measurement, count: duplicates } if duplicates.positive?
+          total, free, cached = %i[total free cached].map { |key| values[key].one? ? values[key].first : nil }
+          valid = total&.positive? && free && cached && free + cached <= total
+          @issues << { code: :memory_available_unknown } unless valid
+          rows = if %i[total free cached].any? { |key| values[key].any? }
+            [ { component: "system", scope: "physical", total_bytes: total, free_bytes: free,
+              used_bytes: valid ? total - free - cached : nil, available_bytes: valid ? free + cached : nil,
+              utilization: valid ? (total - free - cached).fdiv(total) * 100 : nil,
+              basis: valid ? :used_minus_cache : :unknown } ]
+          else
+            []
+          end
+          build_result(rows, complete: complete, recognized: rows.any?, identity: %i[component scope])
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/stats_port_ether.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "../port_counter_parser"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 以太网子计数器与接口错误总数分别保留。
+      class StatsPortEther < CtxChecker::RadwareAlteon::PortCounterParser
+        HEADER = /\AEthernet statistics for port (\d+):\z/i
+        METRICS = { "dot3StatsFCSErrors" => :crc_errors, "dot3StatsCarrierSenseErrors" => :out_carrier_errors }.freeze
+        CONTEXT = %w[dot3StatsAlignmentErrors dot3StatsSingleCollisionFrames dot3StatsMultipleCollisionFrames
+          dot3StatsSQETestErrors dot3StatsDeferredTransmissions dot3StatsLateCollisions dot3StatsExcessiveCollisions
+          dot3StatsInternalMacTransmitErrors dot3StatsFrameTooLongs dot3StatsInternalMacReceiveErrors].freeze
+
+        private
+
+        # 将各 IEEE 计数器绑定到其明确的数据端口标题。
+        def parse_output(text, complete:)
+          blocks, issues, current = [], [], nil
+          clean(text).each_line do |raw|
+            line = raw.strip
+            next if line.empty? || /\A-+\z/.match?(line)
+
+            if (match = HEADER.match(line)) && match[1].to_i.positive?
+              current = { interface: "port#{Integer(match[1], 10)}", values: {}, seen: Hash.new(0) }
+              blocks << current
+            elsif current && (match = /\A(dot3\w+):\s+(\S+)\z/.match(line)) && (METRICS.key?(match[1]) || CONTEXT.include?(match[1]))
+              record_value(current, match, issues)
+            elsif current && /\Adot3CollFrequencies \[1-15\]:\s+NA\z/.match?(line)
+              next
+            else
+              issues << { code: :unrecognized_counter_line }
+              current = nil if /statistics/i.match?(line)
+            end
+          end
+          rows = blocks.flat_map { |block| counter_records(block, issues) }
+          build_port_result(rows, complete: complete, recognized: blocks.any?, issues: issues)
+        end
+
+        # 保留精确整数采样，重复测量使对应指标失效。
+        def record_value(block, match, issues)
+          value = match[2]
+          issues << { code: :invalid_counter_value, interface: block[:interface] } unless /\A(?:\d+|NA)\z/.match?(value)
+          return unless (metric = METRICS[match[1]])
+
+          block[:seen][metric] += 1
+          if block[:seen][metric] > 1
+            block[:values][metric] = nil
+            issues << { code: :duplicate_counter_value, interface: block[:interface], metric: metric }
+          else
+            block[:values][metric] = /\A\d+\z/.match?(value) ? Integer(value, 10) : nil
+          end
+        end
+
+        # 不能根据无关的零计数推断缺失的 FCS 或载波错误。
+        def counter_records(block, issues)
+          METRICS.values.map do |metric|
+            issues << { code: :counter_value_missing, interface: block[:interface], metric: metric } unless block[:seen][metric].positive?
+            { interface: block[:interface], metric: metric, value: block[:values][metric], discontinuity: nil,
+              unit: metric == :out_carrier_errors ? :events : :packets, scope: :mac }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/stats_port_if.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../port_counter_parser"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 接口累计计数与后续每秒速率表属于独立事实。
+      class StatsPortIf < CtxChecker::RadwareAlteon::PortCounterParser
+        HEADER = /\AInterface statistics for port (\d+):\z/i
+        COLUMNS = /\AifHCIn Counters\s+ifHCOut Counters\z/i
+        ROW = /\A(Octets|UcastPkts|BroadcastPkts|MulticastPkts|Discards|Errors):\s+(\S+)\s+(\S+)\z/i
+        METRICS = { "discards" => %i[in_discards out_discards], "errors" => %i[in_errors out_errors] }.freeze
+
+        private
+
+        # 解释方向性测量前，要求存在带标签的累计计数列。
+        def parse_output(text, complete:)
+          blocks, issues, current, section = [], [], nil, nil
+          clean(text).each_line do |raw|
+            line = raw.strip
+            next if line.empty? || /\A-+\z/.match?(line)
+
+            if (match = HEADER.match(line)) && match[1].to_i.positive?
+              current = { interface: "port#{Integer(match[1], 10)}", values: {}, seen: Hash.new(0) }
+              blocks << current
+              section = :header
+            elsif current && section == :header && COLUMNS.match?(line)
+              section = :cumulative
+            elsif current && section == :cumulative && line.casecmp?("Per second Interface statistics:")
+              section = :rate
+            elsif current && %i[cumulative rate].include?(section) && (match = ROW.match(line))
+              record_values(current, match, section, issues)
+            else
+              issues << { code: :unrecognized_counter_line }
+              current = nil if /statistics|Counters/i.match?(line)
+            end
+          end
+          rows = blocks.flat_map { |block| counter_records(block, issues) }
+          build_port_result(rows, complete: complete, recognized: blocks.any?, issues: issues)
+        end
+
+        # 缺失或重复采样保持不可用；速率不能替代累计值。
+        def record_values(block, match, section, issues)
+          values = match.captures.last(2)
+          unless values.all? { |value| /\A(?:\d+|NA)\z/i.match?(value) }
+            issues << { code: :invalid_counter_value, interface: block[:interface] }
+          end
+          return unless section == :cumulative && (metrics = METRICS[match[1].downcase])
+
+          metrics.zip(values).each do |metric, value|
+            block[:seen][metric] += 1
+            if block[:seen][metric] > 1
+              block[:values][metric] = nil
+              issues << { code: :duplicate_counter_value, interface: block[:interface], metric: metric }
+            else
+              block[:values][metric] = /\A\d+\z/.match?(value) ? Integer(value, 10) : nil
+            end
+          end
+        end
+
+        # 输出所有请求方向的指标，包括明确不可用的单元格。
+        def counter_records(block, issues)
+          METRICS.values.flatten.map do |metric|
+            unless block[:seen][metric].positive?
+              issues << { code: :counter_value_missing, interface: block[:interface], metric: metric }
+            end
+            { interface: block[:interface], metric: metric, value: block[:values][metric], discontinuity: nil }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ctx_checker/radware_alteon/parsers/stats_sp_allutils.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "../../parsers/base"
+require "ctx_parser/result_set"
+
+module CtxChecker
+  module RadwareAlteon
+    module Parsers
+      # 各 SP 时间窗与内存章节独立保留覆盖诊断。
+      class StatsSpAllutils < CtxChecker::Parsers::Base
+        private
+
+        # 校验回显的 SP 数量及汇总图，不混用 CPU 和内存数据。
+        def parse_output(text, complete:)
+          rows = { cpu: [], memory: [] }
+          issues = rows.transform_values { [] }
+          sections, current = [], nil
+          clean(text).each_line.with_index(1) do |raw, number|
+            line = raw.strip
+            if (match = /\ASPs CPU utilization percentage for (\d+) sec sampling\s*:\z/.match(line))
+              current = section(:cpu, match[1].to_i)
+              sections << current
+            elsif line == "SPs memory percentage:"
+              current = section(:memory, nil)
+              sections << current
+            elsif line.empty? || /\A-+\z/.match?(line)
+              next
+            elsif current
+              parse_section_line(line, number, current, rows, issues)
+            else
+              issues.each_value { |items| items << { code: :unrecognized_sp_line, line: number } }
+            end
+          end
+          sections.each { |item| validate_section(item, issues.fetch(item[:dimension])) }
+          validate_sections(sections, issues)
+          CtxParser::ResultSet.new(results: rows.to_h do |dimension, records|
+            identity = dimension == :cpu ? %i[component scope window_seconds] : %i[component scope]
+            [ dimension, build_result(records, complete: complete, recognized: records.any?, issues: issues.fetch(dimension), identity: identity) ]
+          end)
+        end
+
+        # 分别跟踪各章节，不用单个命令成功标志代替全部章节状态。
+        def section(dimension, seconds)
+          { dimension: dimension, seconds: seconds, ids: [], summaries: [], graphs: [] }
+        end
+
+        # 柱状图仅作展示上下文，明确百分比字段才是数值来源。
+        def parse_section_line(line, number, current, rows, issues)
+          errors = issues.fetch(current[:dimension])
+          if (match = /\ASP\s+(\d+)\s*:\s*\[[#.]+\]\s+(\S+)\z/.match(line))
+            id = match[1].to_i
+            value = percentage(match[2], errors, number)
+            current[:ids] << id
+            errors << { code: :invalid_sp_identity, line: number } if id.zero?
+            base = { component: "SP#{id}", scope: "service_plane", utilization: id.positive? ? value : nil }
+            record = current[:dimension] == :cpu ? base.merge(window_seconds: current[:seconds]) : base.merge(basis: :used_total)
+            rows.fetch(current[:dimension]) << record
+          elsif (match = /\AAverage\s*:\s*(\S+)\s+\(total (\d+) sp's\)\z/.match(line))
+            current[:summaries] << { value: percentage(match[1], errors, number), count: match[2].to_i }
+          elsif (match = /\A\[[#.]+\]\s+(\S+)\z/.match(line))
+            current[:graphs] << percentage(match[1], errors, number)
+          else
+            errors << { code: :unrecognized_sp_line, line: number }
+          end
+        end
+
+        # 数值缺失、非有限值或超过 100 的百分比不能变成零。
+        def percentage(text, issues, number)
+          value = /\A\d+(?:\.\d+)?%\z/.match?(text) ? Float(text.delete_suffix("%"), exception: false) : nil
+          return value if value&.finite? && value.between?(0, 100)
+          issues << { code: :invalid_sp_measurement, line: number }
+          nil
+        end
+
+        # 要求汇总完整，且所有声明的 SP 身份均存在且不重复。
+        def validate_section(item, issues)
+          valid = item[:summaries].one? && item[:graphs].one?
+          summary = item[:summaries].first
+          valid &&= summary[:value] && summary[:count].positive? && summary[:count] == item[:ids].uniq.size &&
+            item[:ids].uniq.size == item[:ids].size && summary[:value] == item[:graphs].first
+          issues << { code: :incomplete_sp_section, window_seconds: item[:seconds] } unless valid
+        end
+
+        # CPU 时间窗或内存表缺失仅影响其各自结果视图。
+        def validate_sections(sections, issues)
+          cpu = sections.select { |item| item[:dimension] == :cpu }
+          memory = sections.select { |item| item[:dimension] == :memory }
+          unless cpu.map { |item| item[:seconds] }.sort == [ 4, 64 ]
+            issues[:cpu] << { code: :incomplete_sp_cpu_windows }
+          end
+          issues[:memory] << { code: :incomplete_sp_memory_sections } unless memory.one?
+          cpu.each_cons(2) do |first, last|
+            issues[:cpu] << { code: :inconsistent_sp_identities } unless first[:ids].sort == last[:ids].sort
+          end
+        end
+      end
+    end
+  end
+end