vxlan 0.4.0 → 0.4.2

data/lib/vxlan/cli/collect.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ctx_cli/collection"
 require "vxlan"
 require "ctx_runner/batch"
 require_relative "options"
@@ -17,79 +18,31 @@ module Vxlan
         @defaults = options
       end
 
-      # 先预检全部输入和凭据，再创建报告和连接；失败分类不打印原始异常正文。
+      # 公共入口编排顺序与失败收尾；以下方法是显式领域适配协议。
       def run(argv)
-        # 每次运行独立持有批次状态；预检失败不能改写上一次报告。
-        @options, @store, @progress, @devices, @batch = nil, nil, nil, [], nil
-        @options = Options.new(argv, env: @env, out: @out, **@defaults)
-        return 0 if @options.informational?
-        @options.validate_interaction!(input: @input, error: @error)
-        @options.load_environment
-        if @options.flags[:init]
-          @options.initialize_files
-          return 0
+        progress = ->(options) do
+          require "net/connector/collect/progress"
+          Net::Connector::Collect::Progress.new(io: @error, enabled: !options.flags[:quiet], verbose: options.flags[:verbose])
         end
-        return 0 if @options.missing?(input: @input, error: @error)
-        @options.load
-        require "net/connector/collect/progress"
-        @progress = Net::Connector::Collect::Progress.new(io: @error, enabled: !@options.flags[:quiet], verbose: @options.flags[:verbose])
-        @progress.notice("配置：#{@options.config}")
-        return output(@options.public_values.merge("sources" => @options.sources)) if @options.flags[:show_config]
-        @devices = devices = inventory
-        return output(devices) if @options.flags[:inventory_only]
-        if devices.empty?
-          @progress.notice("没有匹配设备，未建立连接")
-          @out.puts JSON.generate(status: :no_devices, total: 0) if @options.flags[:json]
-          return 1
-        end
-        credentials = credentials!
-        load_network unless @connector_factory && @executor
-        unless @connector_factory
-          devices.each { |device| Net::Connector::Configuration.new(host: device.fetch("host"), **credentials).validate_endpoint! }
-        end
-        unless @executor
-          require "net/connector/resources"
-          Net::Connector::Resources.prepare!(parallel: [ devices.size, @options.values.fetch("parallel") ].min)
-        end
-        @store = Report.new(@options.values.fetch("directory"), scripts: @options.flags[:scripts] == true)
-        @batch = CtxRunner::Batch.new(report: @store, progress: @progress, requested: devices)
-        outcome = @batch.run(present: ->(summary) { @out.puts JSON.pretty_generate(summary) if @options.flags[:json] }) do
-          @progress.plan(devices: devices, total: @inventory_total, parallel: @options.values.fetch("parallel"), label: "VXLAN 只读采集")
-          @progress.with_updates do
-            execute(devices) { |device| collect(device, credentials) }
-          end
-          @store.review_collected_fabric(@options.fabric_policy)
-        end
-        completion(outcome)
-      rescue Interrupt
-        diagnostic "采集已取消，已保存的设备报告保留；未保存结果见报告状态"
-        130
-      rescue SystemCallError, IOError => error
-        diagnostic "VXLAN 参数或报告错误：#{report_diagnostic(error)}"
-        2
-      rescue OptionParser::ParseError, ArgumentError, LoadError => error
-        diagnostic "VXLAN 参数、依赖或报告错误：#{error.message}；使用 --help 查看参数"
-        2
-      rescue StandardError => error
-        diagnostic "VXLAN 清单或执行失败：#{CtxDriver::Failure.code(error, :collection_failed)}（#{error.class.name}）"
-        2
+        CtxCli::Collection.new(adapter: self, options: ->(arguments) { Options.new(arguments, env: @env, out: @out, **@defaults) },
+          progress: progress, batch: CtxRunner::Batch, label: "VXLAN", report_error: Report::Error,
+          failure_code: ->(error) { CtxDriver::Failure.code(error, :collection_failed) },
+          out: @out, error: @error, input: @input).run(argv)
       end
 
-      private
-
       # 只在需要库存或网络执行时加载可选依赖，帮助和静态预览保持独立。
       def load_network
         require "net/connector"
       rescue LoadError
-        raise LoadError, "联网采集需要 net-connector >= 0.17.0；请在宿主 Gemfile 添加或 gem install net-connector", cause: nil
+        raise LoadError, "联网采集需要 net-connector >= 0.16.0；请在宿主 Gemfile 添加或 gem install net-connector", cause: nil
       end
 
       # YAML 静态设备或显式 Netdisco 来源二选一；所有重复地址在连接前拒绝。
-      def inventory
-        values = @options.values
-        rows = if @options.dynamic_inventory?
-          @progress.reading_inventory
-          settings = @options.netdisco_settings
+      def inventory(options, progress:)
+        values = options.values
+        rows = if options.dynamic_inventory?
+          progress.reading_inventory
+          settings = options.netdisco_settings
           Net::Connector::Netdisco::Fleet.new(settings: settings).devices.filter_map do |device|
             next unless device.ready? && device.vendor == :cisco_nxos
             { "host" => device.host, "name" => device.name || device.host, "model" => device.model }
@@ -97,89 +50,71 @@ module Vxlan
         else
           values.fetch("devices")
         end
-        targets = @options.normalize_devices(rows)
-        @inventory_total = targets.size
+        targets = options.normalize_devices(rows)
+        total = targets.size
         selection = Net::Connector::Inventory::Filters.selection(values)
-        targets.select do |device|
+        selected = targets.select do |device|
           selection.selected?(device.fetch("host"), "cisco_nxos", name: device["name"], model: device["model"])
         end
+        [ selected, total ]
       end
 
+      # 所有设备先完成凭据、端点与资源预检，再允许创建报告和连接。
+      def prepare(devices, options)
+        credentials = credentials!(options)
+        load_network unless @connector_factory && @executor
+        unless @connector_factory
+          devices.each { |device| Net::Connector::Configuration.new(host: device.fetch("host"), **credentials).validate_endpoint! }
+        end
+        unless @executor
+          require "net/connector/resources"
+          begin
+            Net::Connector::Resources.prepare!(parallel: [ devices.size, options.values.fetch("parallel") ].min)
+          rescue ArgumentError
+            raise CtxCli::Collection::Error, "本机文件描述符额度不足；请提高终端 ulimit -n 或降低 --parallel。已停止，未连接设备。", cause: nil
+          end
+        end
+        credentials
+      end
+
+      def report(options)
+        Report.new(options.values.fetch("directory"), scripts: options.flags[:scripts] == true)
+      rescue ArgumentError
+        raise CtxCli::Collection::Error, "报告目录无效；请使用真实私有目录、权限0700，并检查目录路径。", cause: nil
+      end
+      def after_collect(report, options) = report.review_collected_fabric(options.fabric_policy)
+
       # 缺失用户名时不尝试连接；密码允许省略以支持明确的 SSH key/agent。
-      def credentials!
-        username = secret("NC_CISCO_NXOS_USERNAME") || secret("NC_DEVICE_USERNAME")
-        raise ArgumentError, "请设置 NC_DEVICE_USERNAME 或 NC_CISCO_NXOS_USERNAME；密码可通过环境或 SSH key/agent 提供" unless username
-        @options.values.fetch("ssh").transform_keys(&:to_sym).merge(username: username,
-          password: secret("NC_CISCO_NXOS_PASSWORD") || secret("NC_DEVICE_PASSWORD"), enable_password: secret("NC_ENABLE_PASSWORD"))
+      def credentials!(options)
+        username = secret(options, "NC_CISCO_NXOS_USERNAME") || secret(options, "NC_DEVICE_USERNAME")
+        raise CtxCli::Collection::Error, "请设置 NC_DEVICE_USERNAME 或 NC_CISCO_NXOS_USERNAME；密码可通过环境或 SSH key/agent 提供" unless username
+        options.values.fetch("ssh").transform_keys(&:to_sym).merge(username: username,
+          password: secret(options, "NC_CISCO_NXOS_PASSWORD") || secret(options, "NC_DEVICE_PASSWORD"), enable_password: secret(options, "NC_ENABLE_PASSWORD"))
       end
 
       # 空白环境值视为缺失，不修改或回显凭据。
-      def secret(name)
-        value = @options.environment[name]
+      def secret(options, name)
+        value = options.environment[name]
         value unless value.nil? || value.strip.empty?
       end
 
       # 每个任务使用独立 Collector 和会话；公共执行器负责有界并发和线程回收。
-      def execute(devices, &block)
-        parallel = @options.values.fetch("parallel")
+      def execute(devices, options, &block)
+        parallel = options.values.fetch("parallel")
         return @executor.call(devices, parallel, &block) if @executor
         Net::Connector::Parallel::Pool.new(parallel: parallel).map(devices, &block)
       end
 
       # 单台失败保留其他设备和已获得维度；报告持久化失败交由批次终止处理。
-      def collect(device, credentials)
-        credentials = credentials.merge(on_event: @progress.method(:event))
-        @batch.collect(device) do
-          connector = @connector_factory ? @connector_factory.call(device, credentials) : Connector.new(device, credentials)
-          snapshot = Vxlan::Collector.new.collect(connector: connector, target: device, fabric_key: @options.values.fetch("fabric"),
-            model: device["model"], dimensions: @options.values.fetch("dimensions").map(&:to_sym))
-          snapshot
-        end
-      end
-
-      # Runner 决定批次结论；CLI 仅呈现安全诊断并映射退出码。
-      def completion(outcome)
-        if outcome.finalization_error
-          diagnostic "VXLAN 摘要报告错误：#{outcome.finalization_error}"
-        end
-        if outcome.recovery_failed
-          diagnostic "摘要恢复未确认；请依据退出码及报告目录检查，不能将旧摘要视为本次成功。"
-        end
-        if outcome.status == :interrupted
-          diagnostic "采集已取消，已保存的设备报告保留；未保存结果见报告状态"
-        elsif (failure = outcome.failure)
-          if failure[:kind] == :report
-            diagnostic "VXLAN 参数或报告错误：#{failure[:detail]}"
-          else
-            diagnostic "VXLAN 清单或执行失败：#{failure[:error_type]}；已采集结果见批次报告"
-          end
-        end
-        { complete: 0, incomplete: 1, failed: 2, interrupted: 130 }.fetch(outcome.status)
+      def collect(device, options, context:, progress:)
+        credentials = context.merge(on_event: progress.method(:event))
+        connector = @connector_factory ? @connector_factory.call(device, credentials) : Connector.new(device, credentials)
+        snapshot = Vxlan::Collector.new.collect(connector: connector, target: device, fabric_key: options.values.fetch("fabric"),
+          model: device["model"], dimensions: options.values.fetch("dimensions").map(&:to_sym))
+        snapshot
       end
 
-      # 错误提示失败不能覆盖取消或执行退出码；已失效的进度流不再重试。
-      def diagnostic(message)
-        return if @progress&.output_error
-        @error.puts(message)
-      rescue StandardError
-        nil
-      end
-
-      # 自有发布错误消息不含正文；外部文件异常只显示类型，不打印 message/cause。
-      def report_diagnostic(error)
-        error.instance_of?(Report::Error) ? error.message : error.class.name
-      end
-
-      # 预览默认显示逐设备身份；公开配置由显式开关展示。
-      def output(value)
-        if @options.flags[:json] || value.is_a?(Hash)
-          @out.puts JSON.pretty_generate(value)
-        else
-          value.each { |device| @out.puts "#{device.fetch('host')}\t#{device.fetch('name')}\t#{device['model']}" }
-          @out.puts "设备：#{value.size} 台；未建立设备连接"
-        end
-        value.is_a?(Array) && value.empty? ? 1 : 0
-      end
+      private :load_network, :credentials!, :secret
     end
   end
 end

data/lib/vxlan/cli/options.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require "ctx_cli/collection"
+require "ctx_cli/input"
 require "optparse"
+require "ctx_cli/options"
+require "ctx_cli/terminal"
+require "ctx_cli/initializer"
 require "net/connector/inventory/filters"
 require "yaml"
 require "ipaddr"
-require "fileutils"
-require "tempfile"
 
 module Vxlan
   module CLI
@@ -47,8 +50,8 @@ module Vxlan
 
       # 自动化拒绝强制问答；帮助分支无需检查终端或消费输入。
       def validate_interaction!(input:, error:)
-        if flags[:interactive] && !(input.tty? && error.tty?)
-          raise ArgumentError, "--interactive 需要交互终端；自动化请使用 --init --non-interactive"
+        if flags[:interactive] && !CtxCli::Terminal.tty?(input, error)
+          raise CtxCli::Collection::Error, "--interactive 需要交互终端；自动化请使用 --init --non-interactive"
         end
       end
 
@@ -63,7 +66,7 @@ module Vxlan
         @environment = @files.environment
         @config, @env_file = @files.config, @files.env_file
       rescue LoadError
-        raise LoadError, "采集配置需要 net-connector >= 0.17.0；读取 .env 还需要 dotenv", cause: nil
+        raise LoadError, "采集配置需要 net-connector >= 0.17.1；读取 .env 还需要 dotenv", cause: nil
       end
 
       # 公共与专用文件先合并，进程值和 CLI 最后覆盖；数组不追加设备。
@@ -90,7 +93,7 @@ module Vxlan
         @fabric_policy = nil
         if values["fabric_policy"]
           raise ArgumentError, "fabric_policy 须为路径" unless values["fabric_policy"].is_a?(String)
-          policy = YAML.safe_load(File.read(values["fabric_policy"]), aliases: false)
+          policy = YAML.safe_load(CtxCli::Input.read(path: values["fabric_policy"]), aliases: false)
           Vxlan::Fabric::Scope.new(policy)
           @fabric_policy = CtxParser::Immutable.copy(policy)
         end
@@ -150,22 +153,11 @@ module Vxlan
         end
         overrides_parallel = @overrides.key?("parallel") || parallel_source&.fetch("VXLAN_PARALLEL", nil)
         document = overrides_parallel ? values : values.reject { |key, _| key == "parallel" }
-        template = template.lines.select { |line| line.start_with?("#") }.join +
+        template = template.lines("\n").select { |line| line.start_with?("#") }.join("") +
           Net::Connector::Config.dump(document, name: "vxlan", path: config)
         { config => template, env_file => File.read(File.join(__dir__, "templates/env.example")) }.each do |path, body|
-          FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
-          begin
-            Tempfile.create([ ".vxlan-init-", ".tmp" ], File.dirname(path)) do |file|
-              file.chmod(0o600)
-              file.write(body)
-              file.flush
-              file.fsync
-              File.link(file.path, path)
-            end
-            @out.puts "已创建：#{path}"
-          rescue Errno::EEXIST
-            @out.puts "已保留：#{path}"
-          end
+          status = CtxCli::Initializer.new(prefix: ".vxlan-init-").create(path: path, contents: body)
+          @out.puts "#{status == :created ? '已创建' : '已保留'}：#{path}"
         end
         @out.puts "请检查配置及凭据后再次运行；本次未读取清单、未连接设备。"
       end
@@ -175,10 +167,10 @@ module Vxlan
         @files.load
         @config, @env_file = @files.config, @files.env_file
         return false unless @files.missing?
-        if input.tty? && error.tty? && flags[:interactive] != false
-          error.print "配置不存在：#{config}；是否创建配置与环境模板？[y/N] "
-          error.flush
-          if input.gets&.strip&.match?(/\Ay(?:es)?\z/i)
+        terminal = CtxCli::Terminal.new(input: input, out: error)
+        if terminal.tty? && flags[:interactive] != false
+          answer = terminal.question("配置不存在：#{config}；是否创建配置与环境模板？[y/N] ")
+          if answer&.match?(/\Ay(?:es)?\z/i)
             initialize_files
             return true
           end
@@ -232,10 +224,14 @@ module Vxlan
       def parser
         OptionParser.new do |p|
           p.banner = "用法：#{@command} [选项]（只读 VXLAN 采集）"
-          p.on("--config FILE", "最高优先级 YAML，叠加系统/用户/脚本/工作目录配置") { |v| @explicit_config = File.expand_path(v) }
-          p.on("--env-file FILE", "最高优先级环境文件；进程环境仍优先") { |v| @explicit_env_file = File.expand_path(v) }
-          p.on("-p", "--parallel N", Integer, "设备并发 1～500；继承 NC_PARALLEL，未配置时 4") { |v| @overrides["parallel"] = v }
-          p.on("--directory DIR", "按设备保存报告的目录") { |v| @overrides["directory"] = File.expand_path(v) }
+          CtxCli::Options.configuration(p, parallel_help: "设备并发 1～500；继承 NC_PARALLEL，未配置时 4") do |key, value|
+            case key
+            when :config then @explicit_config = File.expand_path(value, Dir.pwd)
+            when :env_file then @explicit_env_file = File.expand_path(value, Dir.pwd)
+            when :directory then @overrides["directory"] = File.expand_path(value, Dir.pwd)
+            when :parallel then @overrides["parallel"] = value
+            end
+          end
           p.on("--fabric-policy FILE", "显式 Fabric/Leaf/Border/Spine 清单 YAML") { |v| @overrides["fabric_policy"] = File.expand_path(v) }
           p.on("--fabric NAME", "采集所属 Fabric 身份") { |v| @overrides["fabric"] = v }
           p.on("--dimensions LIST", "逗号分隔维度；--help 查看支持项") { |v| @overrides["dimensions"] = list(v) }
@@ -246,29 +242,19 @@ module Vxlan
               @overrides[key] = value
             end
           end
-          p.on("--init", "创建缺失配置和环境模板后退出；已有文件不覆盖") { flags[:init] = true }
-          p.on("--interactive", "缺少配置时询问是否创建；要求真实终端") { flags[:interactive] = true }
-          p.on("--non-interactive", "禁用问答；创建文件须同时指定 --init") { flags[:interactive] = false }
+          CtxCli::Options.initialization(p, flags)
           p.on("--plan", "--inventory-only", "预览筛选清单，不连接设备") { flags[:inventory_only] = true }
           p.on("--show-config", "查看公开有效配置") { flags[:show_config] = true }
-          p.on("--json", "stdout 输出 JSON；默认显示可读摘要") { flags[:json] = true }
-          p.on("--quiet", "--no-progress", "关闭 stderr 进度，可配合 --json") { flags[:quiet] = true }
+          CtxCli::Options.output(p, flags)
           p.on("--[no-]scripts", "可选导出配置建议，默认仅诊断") { |value| flags[:scripts] = value }
-          p.on("--verbose", "显示逐台结果及安全命令事件") { flags[:verbose] = true }
-          p.on("-h", "--help", "查看选项帮助") { flags[:help] = true }
-          p.on("--help-all", "查看全部选项、路径与环境约定") { flags[:help_all] = true }
-          p.on("--examples", "查看常用命令范例，不执行任务") { flags[:examples] = true }
+          CtxCli::Options.information(p, flags)
           p.separator "维度：#{Vxlan::Collector::COMMANDS.keys.join(', ')}"
           p.separator "优先级：CLI > 进程环境 > YAML > .env > 内置默认值。退出码：0 完整/预览；1 未完成/无目标；2 参数/持久化错误；130 取消。"
         end
       end
 
       # 列表中的空项属于输入错误，不能被静默删掉。
-      def list(value)
-        values = value.split(",", -1).map(&:strip)
-        raise ArgumentError, "列表不能有空项" if values.any?(&:empty?)
-        values
-      end
+      def list(value) = CtxCli::Options.list(value)
 
       # 先验证整批策略，避免在前面设备连接后才发现后面的非法配置。
       def validate!

data/lib/vxlan/cli/parse.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require "optparse"
+require "ctx_cli/command"
+require "ctx_cli/options"
+require "ctx_cli/input"
+require "ctx_cli/output"
 require "json"
 require "time"
 require "vxlan"
@@ -12,45 +15,40 @@ module Vxlan
       # 注入标准流，便于在宿主测试中验证无需网络的行为。
       def initialize(out: $stdout, error: $stderr, input: $stdin, command: "vxlan parse")
         @out, @error, @input, @command = out, error, input, command
+        @output = CtxCli::Output.new(out: out, error: error)
       end
 
       # 参数错误与部分证据分开返回；默认只显示元数据，JSON 显式导出事实。
       def run(argv)
-        options = { dimension: :configuration, complete: false }
-        parser = OptionParser.new do |p|
-          p.banner = "用法：#{@command} [选项]（离线文件或 stdin）"
+        command = CtxCli::Command.new(banner: "用法：#{@command} [选项]（离线文件或 stdin）", defaults: { dimension: :configuration, complete: false }, out: @out) do |p, options|
           p.on("--file FILE", "读取文件，默认 stdin") { |v| options[:file] = v }
           p.on("--dimension NAME", "configuration 或运行维度") { |v| options[:dimension] = v.to_sym }
           p.on("--model NAME", "设备型号") { |v| options[:model] = v }
           p.on("--complete", "声明输入已完整采集，仍保留解析缺失诊断") { options[:complete] = true }
           p.on("--json", "输出事实 JSON，可能包含配置敏感信息") { options[:json] = true }
-          p.on("-h", "--help", "查看帮助") { options[:help] = true }
-          p.on("--help-all", "查看全部选项") { options[:help] = true }
-          p.on("--examples", "查看示例") { options[:examples] = true }
+          CtxCli::Options.information(p, options)
           p.separator "维度：#{Vxlan::Collector::COMMANDS.keys.join(', ')}"
         end
-        rest = parser.parse(argv.dup)
-        raise ArgumentError, "不接受位置参数" unless rest.empty?
-        return @out.puts(parser) || 0 if options[:help]
-        return @out.puts("#{@command} --file running.cfg --complete\ncat nve.txt | #{@command} --dimension nve_peers --complete --json") || 0 if options[:examples]
+        options = command.parse(argv)
+        return 0 if command.informational?(examples: "#{@command} --file running.cfg --complete\ncat nve.txt | #{@command} --dimension nve_peers --complete --json")
         raise ArgumentError, "未知维度" unless Vxlan::Collector::COMMANDS.key?(options[:dimension])
 
-        body = options[:file] ? File.read(options[:file]) : @input.read
+        body = CtxCli::Input.read(path: options[:file], input: @input)
         observation = if options[:dimension] == :configuration
           Vxlan::Config.new(model: options[:model]).parse(body, complete: options[:complete])
         else
           Vxlan::RuntimeParser.new(model: options[:model]).parse(options[:dimension], body, complete: options[:complete])
         end
         if options[:json]
-          @out.puts JSON.pretty_generate(observation.to_h)
+          @output.json(observation.to_h)
         else
           @out.puts "维度：#{observation.name}；证据：#{observation.status}；记录：#{observation.records.size}"
           @out.puts "诊断：#{observation.issues.map { |issue| issue[:code] }.uniq.join(', ')}" unless observation.issues.empty?
           @out.puts "证据完整性不代表 Fabric 健康。"
         end
         observation.complete? ? 0 : 1
-      rescue OptionParser::ParseError, ArgumentError, SystemCallError => error
-        @error.puts "离线解析参数或文件错误（#{error.class.name}）；使用 --help 查看参数"
+      rescue OptionParser::ParseError, ArgumentError, SystemCallError, IOError => error
+        @output.diagnostic("离线解析参数或文件错误；使用 --help 查看参数", exception: error)
         2
       end
     end

data/lib/vxlan/cli/report.rb

@@ -3,6 +3,7 @@
 require "json"
 require "time"
 require "ctx_runner/report"
+require "ctx_runner/document"
 require_relative "review/report"
 require_relative "review/fabric"
 
@@ -36,9 +37,9 @@ module Vxlan
         name = self.class.device_basename(device)
         # 保存状态属于批次宿主；不能让正在发布的文件预先声明自身已保存。
         body = result.reject { |key, _| key == :report_saved }.merge(snapshot: snapshot && snapshot.to_h)
-        document = JSON.parse(JSON.generate(serializable(body)))
+        document = CtxRunner::Document.call(body)
         advice = report_advice(Recommendations.new(document).call)
-        document["recommendations"] = advice
+        document = document.merge("recommendations" => advice)
         json = JSON.pretty_generate(document) + "\n"
         prepare_directory(File.join(directory, "evidence"))
         publish("evidence/#{name}.json", json)
@@ -71,7 +72,6 @@ module Vxlan
       # 保持领域呈现接口，事务与恢复状态仅在公共报告中实现。
       def prepare_directory(path) = @report.prepare_directory(path)
       def publish(relative, body) = @report.publish(relative, body)
-      def serializable(value) = @report.serializable(value)
       def checkpoint(relative, value) = @report.checkpoint(relative, value)
       def finalize(relative, summary, checkpoint:) = @report.finalize(relative, summary, checkpoint: checkpoint)
     end

data/lib/vxlan/cli/review/fabric.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "ctx_cli/input"
+require "ctx_runner/fingerprint"
 require_relative "../../fabric/review"
 
 module Vxlan
@@ -51,7 +53,7 @@ module Vxlan
               value = row.key?(:value) ? row[:value] : row.reject { |key, _| %i[host name vlan entries semantics].include?(key) }
               value = value.reject { |key, _| key == :entries } if value.is_a?(Hash)
               if row[:semantics]
-                policy = row[:policy] ? "规则与依赖版本 #{ChangePlan.fingerprint(row[:policy])[0, 12]}" : "依赖对象未验证"
+                policy = row[:policy] ? "规则与依赖版本 #{CtxRunner::Fingerprint.call(row[:policy])[0, 12]}" : "依赖对象未验证"
                 value = "#{row[:entries].size} 条规则，#{policy}"
               end
               [ row[:vlan] || row[:interface] || "公共", display_fabric_value(value) ]
@@ -91,7 +93,7 @@ module Vxlan
         # 实时收尾读取已经保存的事实；审查摘要交给采集摘要一起发布，避免相互覆盖。
         def review_collected_fabric(policy)
           sources = Dir[File.join(directory, "evidence", "*.json")].sort.map do |path|
-            body = File.read(path)
+            body = CtxCli::Input.read(path: path)
             [ File.expand_path(path), body, JSON.parse(body) ]
           end
           build_review(sources, policy: policy, standalone: false) unless sources.empty?

data/lib/vxlan/cli/review/report.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "digest"
+require "ctx_runner/fingerprint"
 require_relative "../../recommendations"
 require_relative "../../change_plan"
 
@@ -39,8 +40,8 @@ module Vxlan
             plan = ChangePlan.candidate(item[:change], config: config)
             next unless plan
             change = plan.to_h
-            id = [ basename, change["kind"], "vlan#{change['vlan']}", change["direction"], ChangePlan.fingerprint(change)[0, 12] ].compact.join("--")
-            config_sha256 ||= ChangePlan.fingerprint(config)
+            id = [ basename, change["kind"], "vlan#{change['vlan']}", change["direction"], CtxRunner::Fingerprint.call(change)[0, 12] ].compact.join("--")
+            config_sha256 ||= CtxRunner::Fingerprint.call(config)
             entry[:changes][id] = { schema_version: 1, platform: "cisco_nxos", device: document.fetch("device"), expected_config_sha256: config_sha256,
               source: source, source_sha256: source_sha256, change: change, commands: plan.commands, rollback: plan.rollback,
               scope: item[:scope], title: item[:title], prerequisites: item[:prerequisites], impact: item[:impact], verify: item[:verify] }