net-connector 0.7.2 → 0.8.0

data/lib/net/connector/engine/log.rb

@@ -49,9 +49,14 @@ module Net
         finish_output
         @context = @context.merge(fields).freeze
         yield
+      rescue Exception # rubocop:disable Lint/RescueException -- Preserve only failures propagating from this scope, including interrupts.
+        failed = true
+        raise
       ensure
         begin
           finish_output
+        rescue Error
+          raise unless failed
         ensure
           @context = previous
         end
@@ -98,6 +103,9 @@ module Net
                   code: ErrorMetadata.code(failure.code),
                   phase: ErrorMetadata.phase(failure.phase) || ErrorMetadata.phase(phase),
                   message: failure.message)
+      rescue Error
+        # 原始失败已由调用者保留；诊断通道故障不能替换登录、命令或业务错误。
+        nil
       end
 
       # 用户钩子可能把未登记的配置片段放进事件名、字段名或值；敏感范围统一隐藏。
@@ -163,8 +171,16 @@ module Net
         finish_output
         @transport.log_output = nil if @transport
         yield
+      rescue Exception # rubocop:disable Lint/RescueException -- Restore attachment without replacing this scope's failure or interruption.
+        failed = true
+        raise
       ensure
-        @transport.log_output = self if @transport && @writer && @attached
+        begin
+          @transport.log_output = self if @transport && @writer && @attached
+        rescue StandardError
+          # 恢复接线仍须尝试，但不能盖掉设备失败或用户中断。
+          raise unless failed
+        end
       end
 
       # 断开回显记录并关闭日志资源。

data/lib/net/connector/engine/redactor.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "expect/redactor"
+
+module Net
+  module Connector
+    # 管理连接器的秘密作用域和输出敏感性；字节过滤统一委托给 expect-pty。
+    class Redactor
+      MASK = "[REDACTED]".b.freeze
+
+      # 保存初始凭据，并建立第一版脱敏词表。
+      def initialize(*secrets)
+        unless Expect.constants(false).include?(:Redactor) && Expect::Redactor.respond_to?(:redact)
+          raise LoadError, "net-connector requires expect-pty with the public Expect::Redactor API"
+        end
+
+        @configured = secrets.compact.map(&:b).map(&:freeze).freeze
+        reset
+      end
+
+      # 重置动态词表，同时保留配置中的固定凭据。
+      def reset
+        @secrets = []
+        @patterns = nil
+        @scoped = false
+        @sensitive = false
+        @output_sensitive = false
+        @configured.each { |secret| remember(secret) }
+      end
+
+      # 临时命令响应在错误归一化期间保留，离开作用域后不进入长期会话。
+      def with_scope(reuse: false)
+        return yield if reuse && @scoped
+
+        previous = @secrets
+        previous_patterns = @patterns
+        previous_scoped = @scoped
+        previous_sensitive = @sensitive
+        previous_output_sensitive = @output_sensitive
+        @secrets = previous.dup
+        @scoped = true
+        begin
+          yield
+        ensure
+          @secrets = previous
+          @patterns = previous_patterns
+          @scoped = previous_scoped
+          @sensitive = previous_sensitive
+          @output_sensitive = previous_output_sensitive
+        end
+      end
+
+      # 敏感命令和交互的异常可能只引用秘密的一部分，不能只依赖完整词匹配。
+      def sensitive! = @sensitive = true
+
+      # 判断当前脱敏范围是否包含敏感交互。
+      def sensitive? = @sensitive
+
+      # 输出敏感时不把正文加入词表；只在当前范围内屏蔽日志和任意错误正文。
+      def output_sensitive!
+        @output_sensitive = true
+        sensitive!
+      end
+
+      # 后续查询继承输出边界，即使查询命令本身没有敏感标记。
+      def output_sensitive? = @output_sensitive
+
+      # 只维护当前作用域的注册词；匹配次序和重叠区间交给共享过滤器。
+      def remember(secret)
+        return if secret.nil? || secret.empty?
+
+        bytes = secret.b
+        return if @secrets.include?(bytes)
+
+        @secrets << bytes.freeze
+        @patterns = nil
+      end
+
+      # 一次性诊断不共享流状态；原标记作为不透明区间，避免再次展开它。
+      def call(text)
+        Expect::Redactor.redact(text.to_s.b, patterns, replacement: MASK)
+      end
+
+      # 每个日志目标独占过滤流，跨分片尾部和重叠掩码由依赖库维护。
+      def stream
+        Expect::Redactor.new(patterns, replacement: MASK)
+      end
+
+      # 临时范围恢复时，日志流可以同步恢复注册词表，不缓存配置正文。
+      def patterns
+        @patterns ||= (@secrets.empty? ? [] : (@secrets + [MASK]).uniq).freeze
+      end
+
+      # 返回脱敏器类型摘要。
+      def inspect = "#<#{self.class}>"
+    end
+  end
+end

data/lib/net/connector/engine/response_reader.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "expect/pty"
+require_relative "dialogue"
+
+module Net
+  module Connector
+    # 在传输层上执行有界对话；收到字节或分页标记不会重置截止时间。
+    class ResponseReader
+      # 保存会话引用，以便读取器使用传输、配置和脱敏上下文。
+      def initialize(session)
+        @session = session
+      end
+
+      # 读取到结束提示、失败模式或超时，并处理交互响应和输出上限。
+      def read(prompt:, interactions:, phase:, timeout: nil, deadline: nil, command: nil, failures: {})
+        deadline ||= Expect.monotonic + timeout
+        patterns = [*failures.keys, *interactions.map(&:pattern), prompt]
+        raw = []
+        output = []
+        counts = Hash.new(0)
+        bytes = 0
+        loop do
+          event = read_event(patterns, deadline)
+          raw << event.before unless event.before.empty?
+          output << event.before unless event.before.empty?
+          bytes += event.before.bytesize + event.match.bytesize
+          validate_event!(event, bytes, raw, phase, command)
+
+          if event.index == patterns.size
+            raw << event.match
+            output << event.match
+          elsif event.index == patterns.size - 1
+            return finish_response(event.match, raw, output, phase, command)
+          elsif event.index < failures.size
+            raise build_connection_error(failures.values.fetch(event.index), phase, command), cause: nil
+          else
+            reply = interactions.fetch(event.index - failures.size)
+            raw << event.match
+            output << event.match if reply.capture?
+            respond(reply, event.match, counts, deadline, phase, command)
+          end
+          next if Expect.monotonic < deadline
+
+          raise build_read_error(nil, phase, command, raw.join), cause: nil
+        end
+      end
+
+      private
+
+      # 分页和流式输出只消耗剩余时间，不为下一次读取重新计时。
+      def read_event(patterns, deadline)
+        @session.transport.read(patterns, timeout: [deadline - Expect.monotonic, 0].max)
+      end
+
+      # 连接失败模式携带稳定错误码，供连接级恢复规则选择处理方式。
+      def build_connection_error(failure, phase, command)
+        klass, code = failure
+        @session.build_error(klass, "device connection failed (#{code})", phase: phase, code: code, command: command)
+      end
+
+      # 先限制原始字节数，再处理传输失败，避免错误输出绕过总量限制。
+      def validate_event!(event, bytes, raw, phase, command)
+        if bytes > @session.configuration.max_output_bytes
+          raise @session.build_error(OutputLimitExceeded, "device output exceeded max_output_bytes",
+                                     phase: phase, command: command, output: (raw + [event.match]).join), cause: nil
+        end
+        raise build_read_error(event, phase, command, raw.join), cause: nil unless event.matched?
+      end
+
+      # 完整提示符必须消费字节；交互标记可从业务输出排除，但原始响应始终保留。
+      def finish_response(prompt, raw, output, phase, command)
+        if prompt.empty?
+          raise @session.build_error(PromptError, "prompt pattern did not consume any output",
+                                     phase: phase, command: command, output: raw.join), cause: nil
+        end
+
+        raw << prompt
+        output << prompt
+        raw_text = raw.join
+        Response.new(raw: raw_text, output: (output == raw) ? raw_text : output.join, prompt: prompt)
+      end
+
+      # 重复提示和缺失应答必须在写入前失败；所有应答共用读取操作的截止时间。
+      def respond(reply, prompt, counts, deadline, phase, command)
+        counts[reply] += 1
+        if prompt.empty? || (reply.limit && counts[reply] > reply.limit)
+          raise build_interaction_error("response rejected or repeated", phase, command), cause: nil
+        end
+
+        value = interaction_response(reply, prompt, phase, command)
+        raise build_interaction_error("response unavailable", phase, command), cause: nil unless value.is_a?(String)
+
+        @session.redactor.remember(value.chomp) if reply.sensitive?
+        @session.write(value, deadline: deadline, phase: phase, command: command)
+      end
+
+      # 动态口令尚未返回时无法加入词表，须在敏感范围内先归一化回调异常。
+      # 成功后由调用方登记响应，临时敏感标记不会影响后续普通命令的诊断。
+      def interaction_response(reply, prompt, phase, command)
+        return reply.response(prompt) unless reply.sensitive?
+
+        @session.redactor.with_scope(reuse: true) do
+          @session.redactor.sensitive!
+          reply.response(prompt)
+        rescue => error
+          raise @session.normalize_error(error, phase: phase, command: command), cause: nil
+        end
+      end
+
+      # 将交互拒绝或响应缺失转换为认证或脚本错误。
+      def build_interaction_error(message, phase, command)
+        authenticating = %i[login enable].include?(phase)
+        klass = authenticating ? AuthenticationError : ScriptError
+        label = authenticating ? "authentication" : "command interaction"
+        @session.build_error(klass, "#{label} #{message}", phase: phase, command: command)
+      end
+
+      # 根据 EOF、提示符、阶段和底层异常选择具体读取错误类型。
+      def build_read_error(event, phase, command, output)
+        if event&.error.is_a?(Exception)
+          return @session.build_error(TransportError, "transport read failed", phase: phase, command: command,
+                                      underlying: event.error, output: output)
+        end
+        klass = if event&.error == :eof
+                  ConnectionClosed
+                elsif command&.prompt
+                  PromptError
+                elsif %i[login enable].include?(phase)
+                  LoginTimeout
+                else
+                  CommandTimeout
+                end
+        @session.build_error(klass, "device response #{event&.error || :timeout}", phase: phase,
+                             command: command, output: output)
+      end
+    end
+  end
+end

data/lib/net/connector/engine/session.rb

@@ -3,6 +3,8 @@
 require "English"
 require_relative "authentication"
 require_relative "log"
+require_relative "redactor"
+require_relative "response_reader"
 require_relative "recovery"
 require_relative "transport"
 
@@ -45,12 +47,14 @@ module Net
           started = Expect.monotonic
           @log.log_event("operation_start", level: :debug, phase: :script)
           result = yield
-          log_operation_completion(started, result.is_a?(Result) ? result.error : nil, steps: steps.size)
-          result
         rescue => error
           failure = normalize_error(error, phase: :script)
           log_operation_completion(started, failure, steps: steps.size)
           raise failure, cause: nil
+        else
+          # 完成事件只发送一次；观察者失败由外层保留业务结果，不再次调用同一观察者。
+          log_operation_completion(started, result.is_a?(Result) ? result.error : nil, steps: steps.size)
+          result
         end
       end
 

data/lib/net/connector/netdisco/backup_run.rb

@@ -2,6 +2,12 @@
 
 require "json"
 require "socket"
+require_relative "cli/options"
+require_relative "connection"
+require_relative "fleet"
+require_relative "progress"
+require_relative "report/files"
+require_relative "../storage/batch_directory"
 
 module Net
   module Connector
@@ -38,8 +44,9 @@ module Net
 
           Storage::PrivateFile.write(File.join(batch_directory, "plan.json"), JSON.pretty_generate(preview))
           report = execute(fleet, settings, plan, batch_directory, progress, success_policy, server_root)
+          report = record_progress_error(report, progress)
           report = Report::Files.write(report, directory: batch_directory, plan: plan, concurrency: settings.concurrency)
-          finish(report, progress, options, batch_directory)
+          finish(report, progress, options, batch_directory, plan, settings.concurrency)
         rescue ArgumentError, Client::Error => exception
           @error.puts "备份参数或清单错误：#{exception.message}"
           2
@@ -95,10 +102,16 @@ module Net
           end
         end
 
-        def finish(report, progress, options, batch_directory)
+        def finish(report, progress, options, batch_directory, plan, concurrency)
           progress.finish(report)
           progress.location(report.report_location) if report.report_location
-          @error.puts "文本报告：#{File.join(batch_directory, "summary.txt")}" if @env.fetch("NC_PROGRESS", "1") != "0" && File.file?(File.join(batch_directory, "summary.txt"))
+          summary_path = File.join(batch_directory, "summary.txt")
+          progress.location(summary_path, label: "文本报告") if File.file?(summary_path)
+          updated = record_progress_error(report, progress)
+          unless updated.equal?(report)
+            # 末尾显示也可能首次失败，只补写诊断，不重复设备任务或事件。
+            report = Report::Files.write(updated, directory: batch_directory, plan: plan, concurrency: concurrency)
+          end
           if options[:json]
             @output.puts JSON.generate(directory: batch_directory, counts: report.counts,
                                        tasks_succeeded: report.policy_success?, success: report.policy_success?,
@@ -108,6 +121,12 @@ module Net
           report.policy_success? ? 0 : 1
         end
 
+        def record_progress_error(report, progress)
+          return report unless progress.output_error && !report.callback_errors.include?(progress.output_error)
+
+          report.with(callback_errors: [*report.callback_errors, progress.output_error].freeze)
+        end
+
         def tftp_root(settings, options)
           server = settings.tftp_server || (raise ArgumentError, "TFTP_HOST or YAML tftp.server is required")
           return options[:tftp_root] || @env["TFTP_ROOT"] if options[:tftp_root] || @env["TFTP_ROOT"]

data/lib/net/connector/netdisco/cli/options.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "optparse"
+require_relative "../settings"
+require_relative "../planner"
+require_relative "../config_file"
 
 module Net
   module Connector

data/lib/net/connector/netdisco/cli.rb

@@ -3,6 +3,9 @@
 require "json"
 require "ipaddr"
 require "optparse"
+require_relative "../version"
+require_relative "fleet"
+require_relative "cli/options"
 
 module Net
   module Connector
@@ -46,23 +49,23 @@ module Net
             return 0
           end
 
-          batch = backup(fleet, plan, settings, options)
-          summary = batch.summary
+          report = backup(fleet, plan, settings, options)
+          summary = report.summary
           @output.puts JSON.pretty_generate(summary)
-          batch.policy_success? ? 0 : 1
+          report.policy_success? ? 0 : 1
         rescue Storage::PrivateFile::WriteError => exception
           message = Storage::PrivateFile.receipt_error?(exception) ? exception.message : exception.class.name
-          @error.puts "net-connector-backup: #{message}"
+          @error.puts "net-backup: #{message}"
           2
         rescue OptionParser::ParseError
-          @error.puts "net-connector-backup: 参数无效；使用 --help 查看参数"
+          @error.puts "net-backup: 参数无效；使用 --help 查看参数"
           2
         rescue ArgumentError, KeyError, Errno::ENOENT,
           Psych::Exception, JSON::ParserError, Client::Error => exception
-          @error.puts "net-connector-backup: #{exception.message}"
+          @error.puts "net-backup: #{exception.message}"
           2
         rescue StandardError => exception
-          @error.puts "net-connector-backup 失败（#{exception.class}）"
+          @error.puts "net-backup 失败（#{exception.class}）"
           2
         end
 
@@ -113,7 +116,7 @@ module Net
         def parse_options
           options = { environment: {} }
           parser = OptionParser.new do |args|
-            args.banner = "用法：net-connector-backup [--config FILE] [--plan | --show-config | --export IP] [--tftp]"
+            args.banner = "用法：net-backup [--config FILE] [--plan | --show-config | --export IP] [--tftp]"
             Options.add_settings(args, options)
             Options.add_execution(args, options)
             args.on("--source SOURCE", %w[http postgres], "清单来源：http（默认）或 postgres") { |value| options[:source] = value }

data/lib/net/connector/netdisco/connection.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "client"
 
 # 清单连接与设备凭据来源；业务入口负责规划和执行备份。
 module Net

data/lib/net/connector/netdisco/database_client.rb

@@ -48,8 +48,10 @@ module Net
           connected = false
           begin
             Timeout.timeout(budget.remaining, Client::InventoryTimeout) do
-              # 从握手开始持有连接；PG.connect 尚未返回时被超时中断，调用方无法负责关闭它。
-              connection = PG::Connection.connect_start(@connection_options)
+              # 先取得连接句柄再交付超时，确保异常到达时 ensure 能显式关闭连接。
+              Thread.handle_interrupt(Client::InventoryTimeout => :never) do
+                connection = PG::Connection.connect_start(@connection_options)
+              end
               # PostgreSQL NOTICE 可能包含 SQL 或数据，不交给 libpq 默认的 stderr 输出器。
               connection.set_notice_processor { |_notice| nil }
               wait_for_connection(connection, budget)

data/lib/net/connector/netdisco/device.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "ipaddr"
+require_relative "../../connector"
 require_relative "../storage/saved_config"
+require_relative "client"
 
 module Net
   module Connector

data/lib/net/connector/netdisco/diagnostic.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "../engine/error_metadata"
+require_relative "../engine/errors"
+require_relative "../device/local_backup"
+require_relative "../device/tftp/receipt"
+require_relative "../storage/private_file"
 
 module Net
   module Connector

data/lib/net/connector/netdisco/fleet.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "digest"
+require_relative "../storage"
+require_relative "client"
+require_relative "settings"
+require_relative "device"
+require_relative "worker"
+require_relative "result_store"
+require_relative "planner"
+require_relative "report"
+require_relative "tftp_verification"
+require_relative "tftp_archive"
 
 module Net
   module Connector

data/lib/net/connector/netdisco/plan.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "ipaddr"
+require_relative "device"
+require_relative "batch"
+
 module Net
   module Connector
     module Netdisco
@@ -27,6 +31,7 @@ module Net
           unless inventory.all?(Device) && outcomes.size == inventory.size
             raise ArgumentError, "plan inventory and outcomes must have the same device slots"
           end
+          validate_duplicate_hosts!
 
           selected_indices = {}
           selected_filenames = {}
@@ -65,6 +70,14 @@ module Net
 
         private
 
+        # 外部快照也遵守清单入口的地址唯一性；采样不能把重复设备重新变为可执行。
+        def validate_duplicate_hosts!
+          groups = inventory.group_by { |device| device.host && IPAddr.new(device.host).to_s }
+          return unless groups.any? { |host, devices| host && devices.size > 1 && devices.any? { |device| device.issue != :duplicate_host } }
+
+          raise ArgumentError, "plan duplicate hosts must be marked as duplicate_host"
+        end
+
         # 跳过结果不携带执行产物；文件冲突必须有本批次实际执行的目标作为依据。
         def valid_skipped_outcome?(result, device, selected_filenames)
           return false unless result.is_a?(Outcome) && result.device.equal?(device) && result.backup.nil? &&

data/lib/net/connector/netdisco/planner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "plan"
+require_relative "batch"
 
 module Net
   module Connector
@@ -20,7 +21,7 @@ module Net
           end
           selected_tasks = if limit_per_vendor
                              ready_tasks.group_by { |_index, device| device.vendor }.values.flat_map do |tasks|
-                               tasks.sort_by { |_index, device| device.host }.first(limit_per_vendor)
+                               tasks.min_by(limit_per_vendor) { |_index, device| device.host }
                              end
                            else
                              ready_tasks

data/lib/net/connector/netdisco/progress.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require "io/console"
+require_relative "../engine/error_metadata"
+require_relative "../engine/log/event"
 
 module Net
   module Connector
     module Netdisco
       # 共享一个实例接收并发会话事件和任务回调；人类进度不混入 JSON 输出。
       class Progress
+        attr_reader :output_error
+
         def initialize(io: $stderr, enabled: true, verbose: false)
           @io, @enabled, @verbose = io, enabled, verbose
           @tty = io.respond_to?(:tty?) && io.tty?
@@ -101,7 +105,9 @@ module Net
         end
 
         def finish(report)
-          summary = report.summary
+          return unless @enabled
+
+          summary = report.statistics
           failures = report.outcomes.reject { |item| item.success? || %i[filtered sample_limit].include?(item.status) }
                            .group_by { |item| item.error_code || item.status }.transform_values(&:size)
           unless failures.empty?
@@ -146,8 +152,8 @@ module Net
           @mutex.synchronize { refresh(force: true) }
         end
 
-        def location(path)
-          write(nil, "报告：#{path}")
+        def location(path, label: "报告")
+          write(nil, "#{label}：#{path}")
         end
 
         private
@@ -207,9 +213,7 @@ module Net
 
           clear_refresh
           @last_status = lines
-          @io.write(lines.join("\n"))
-          @io.flush
-          @refreshing = true
+          @refreshing = write_output(lines.join("\n"))
         end
 
         # 留一列避免终端自动换行，窄窗口也不会留下旧进度行。
@@ -229,7 +233,7 @@ module Net
         def clear_refresh
           return unless @refreshing
 
-          @io.write("\r\e[2K" + ("\e[1A\r\e[2K" * (@last_status.length - 1)))
+          write_output("\r\e[2K" + ("\e[1A\r\e[2K" * (@last_status.length - 1)))
           @refreshing = false
         end
 
@@ -244,8 +248,21 @@ module Net
           clear_refresh
           line = "[#{Time.now.strftime("%H:%M:%S")}] [#{@completed}/#{@total}#{percent} 执行中 #{@active}] [#{host || "批次"}] #{message}"
           line = "[#{Time.now.strftime("%H:%M:%S")}] #{host ? "#{host}  " : ""}#{message}" unless @verbose
-          @io.write(line.gsub(/[[:cntrl:]]/, " ") + "\n")
+          write_output(line.gsub(/[[:cntrl:]]/, " ") + "\n")
+        end
+
+        # 显示失败只停用进度输出；批次仍保存回执和事件，并记录一次受控回调诊断。
+        # 所有调用均持有 @mutex，心跳与设备线程不会重复访问已失败的输出。
+        def write_output(text)
+          return false unless @enabled
+
+          @io.write(text)
           @io.flush
+          true
+        rescue IOError, SystemCallError => error
+          @output_error = { host: nil, error_type: ErrorMetadata.type(error.class.name) }.freeze
+          @enabled = false
+          false
         end
       end
     end

data/lib/net/connector/netdisco/report/files.rb

@@ -16,16 +16,16 @@ module Net
             Storage::PrivateFile.write(destination, JSON.pretty_generate(finalized.summary))
             finalized
           rescue StandardError => error
-            location = if Storage::PrivateFile.receipt_error?(error) && error.receipt.committed? && error.receipt.path == destination
-                         destination
-                       end
-            failed = report.with_report_error(error, location: location)
+            location = committed_location(error, destination) || report.report_location
+            # 更新已有诊断时仍保留首次报告故障，以及之前已提交的报告位置。
+            failed = report.report_error ? report.with(report_location: location) : report.with_report_error(error, location: location)
             begin
               saved = failed.with(report_location: destination)
               Storage::PrivateFile.write(destination, JSON.pretty_generate(saved.summary))
               failed = saved
-            rescue StandardError
-              # JSON 仍无法保存时，返回带有已知提交位置的失败报告。
+            rescue StandardError => persistence_error
+              # 补写也可能在替换后失败；保留位置，但不覆盖首次报告故障。
+              failed = saved if committed_location(persistence_error, destination)
             end
             begin
               Text.write(directory: directory, report: failed, plan: plan, concurrency: concurrency)
@@ -34,6 +34,11 @@ module Net
             end
             failed
           end
+
+          def self.committed_location(error, destination)
+            destination if Storage::PrivateFile.receipt_error?(error) && error.receipt.committed? && error.receipt.path == File.expand_path(destination)
+          end
+          private_class_method :committed_location
         end
       end
     end

data/lib/net/connector/netdisco/report/text.rb

@@ -10,7 +10,7 @@ module Net
         # 将批次结果写为人类可读的文本摘要。
         class Text
           def self.write(directory:, report:, plan:, concurrency:)
-            summary = report.summary
+            summary = report.statistics
             failed = report.outcomes.reject { |item| item.success? || %i[filtered sample_limit].include?(item.status) }
             groups = failed.group_by { |item| item.error_code || item.status }
             lines = ["网络设备备份报告", "=" * 72,