wireless-rb 0.1.0

data/lib/wireless/h3c/parsers/display_wlan_statistics_client_ip_conflict.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "../parser"
+
+module Wireless
+  module H3c
+    module Parsers
+      # 解析冲突事件，不虚构设备时间戳的年份或时区。
+      class DisplayWlanStatisticsClientIpConflict < Parser
+        private
+
+        # 解释当前命令记录，保留不完整行诊断。
+        def parse_text(text, complete:)
+          records, issues = [], []
+          header = false
+          text.lines.each_with_index do |line, index|
+            row = line.strip
+            next if row.empty? || /\A[-=]+\z/.match?(row)
+            if /\AIP\s+New-MAC\/APID\s+Old-MAC\/APID\s+Time\z/i.match?(row)
+              header = true
+              next
+            end
+            begin
+              records << parse_row(row)
+            rescue ArgumentError, IPAddr::Error
+              issues << { code: :invalid_row, line: index + 1 }
+            end
+          end
+          # 本命令没有总数尾行；采集完整且只有表头时表示空表。
+          total = 0 if header && records.empty? && issues.empty?
+          Fields.result(records, issues: issues, complete: complete, total: total,
+            identity: %i[ip_address new_mac_address new_ap_id old_mac_address old_ap_id occurred_at])
+        end
+
+        # 按当前命令的身份与字段布局解析单条表格记录。
+        def parse_row(row)
+          match = /\A(\S+)\s+(\S+)\/(\d+)\s+(\S+)\/(\d+)\s+(\d{2}-\d{2} \d{2}:\d{2}:\d{2})\z/.match(row)
+          raise ArgumentError, "Invalid conflict row" unless match
+
+          month, day, hour, minute, second = match[6].split(/[- :]/).map(&:to_i)
+          raise ArgumentError, "Invalid conflict time" unless Date.valid_date?(2000, month, day) && hour < 24 && minute < 60 && second < 60
+
+          { ip_address: Fields.ip(match[1]), new_mac_address: Fields.mac(match[2]), new_ap_id: Fields.integer(match[3]).to_s,
+            old_mac_address: Fields.mac(match[4]), old_ap_id: Fields.integer(match[5]).to_s, occurred_at: match[6] }
+        end
+      end
+    end
+  end
+end

data/lib/wireless/h3c/profile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "ctx_parser/profile"
+require_relative "parsers/display_wlan_ap_all_verbose"
+require_relative "parsers/display_wlan_bss_all_verbose"
+require_relative "parsers/display_wlan_client_verbose"
+require_relative "parsers/display_current_configuration"
+require_relative "parsers/display_dot1x_connection"
+require_relative "parsers/display_mac_authentication_connection"
+require_relative "parsers/display_wlan_client_security_block_mac"
+require_relative "parsers/display_lldp_neighbor_information_verbose"
+require_relative "parsers/display_wlan_statistics_client_ip_conflict"
+require_relative "parsers/display_wlan_ap_model_all"
+
+module Wireless
+  module H3c
+    # 声明 H3C 控制器及 AP 策略，共享回显仅解析一次后再投影维度。
+    class Profile < CtxParser::Profile
+      CATALOG = CtxParser::CommandCatalog.new([
+        { dimensions: [ :client_ip_conflicts ], command: "display wlan statistics client-ip-conflict", parser: Parsers::DisplayWlanStatisticsClientIpConflict },
+        { dimensions: [ :ap_models ], command: "display wlan ap-model all", parser: Parsers::DisplayWlanApModelAll },
+        { dimensions: %i[access_points radios], command: "display wlan ap all verbose", parser: Parsers::DisplayWlanApAllVerbose },
+        { dimensions: [ :bsses ], command: "display wlan bss all verbose", parser: Parsers::DisplayWlanBssAllVerbose },
+        { dimensions: [ :clients ], command: "display wlan client verbose", parser: Parsers::DisplayWlanClientVerbose },
+        { dimensions: %i[configuration ap_groups service_templates], command: "display current-configuration", parser: Parsers::DisplayCurrentConfiguration },
+        { dimensions: [ :dot1x_connections ], command: "display dot1x connection", parser: Parsers::DisplayDot1xConnection },
+        { dimensions: [ :mab_connections ], command: "display mac-authentication connection", parser: Parsers::DisplayMacAuthenticationConnection },
+        { dimensions: [ :blocked_clients ], command: "display wlan client-security block-mac", parser: Parsers::DisplayWlanClientSecurityBlockMac },
+        { dimensions: [ :lldp ], command: "display lldp neighbor-information verbose", parser: Parsers::DisplayLldpNeighborInformationVerbose }
+      ])
+      COMMANDS = CATALOG.commands
+      PARSERS = CATALOG.parsers
+
+      private
+
+      # 从共享命令结果中提取请求维度。
+      def project(name, result)
+        return super unless %i[ap_groups service_templates].include?(name)
+
+        records = result.records.first&.fetch(name) || []
+        result.with(records: records)
+      end
+    end
+  end
+end

data/lib/wireless/h3c/session_parser.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "verbose_parser"
+
+module Wireless
+  module H3c
+    # 复用详细会话边界，各命令独立声明其字段结构。
+    class SessionParser < VerboseParser
+      COMMON_FIELDS = { "ap name" => :ap_name, "ap id" => :ap_id, "radio id" => :radio_id,
+        "ssid" => :ssid, "bssid" => :bssid, "vlan id" => :vlan, "service vlan id" => :vlan }.freeze
+      DETAILS = [].freeze
+
+      private
+
+      # 解释当前命令记录，保留不完整行诊断。
+      def parse_text(text, complete:)
+        issues, records = [], []
+        fields = tokens(text, issues)
+        start = start_label(fields)
+        current = nil
+        fields.each do |label, raw, line|
+          if start ? label == start : self.class::MAPPING[label] == self.class::IDENTITY.first
+            current = {}
+            records << current
+          end
+          unless current
+            issues << { code: :missing_identity, line: line }
+            next
+          end
+          assign_session_field(current, label, raw, issues, line)
+        end
+        records.reject! do |record|
+          invalid = !valid_identity?(record)
+          issues << { code: :invalid_identity } if invalid
+          invalid
+        end
+        Fields.result(records, issues: issues, complete: complete, total: count(text, self.class::COUNT), identity: self.class::IDENTITY)
+      end
+
+      # 返回当前命令格式中用于开始新记录的字段。
+      def start_label(fields)
+        nil
+      end
+
+      # 要求具备关联当前记录所需的稳定身份字段。
+      def valid_identity?(record)
+        value = record[self.class::IDENTITY.first]
+        value && !value.strip.empty?
+      end
+
+      # 将单个认证会话字段归一化到目标记录。
+      def assign_session_field(record, label, raw, issues, line)
+        details = self.class::DETAILS.include?(label) ? record : nil
+        assign_field(record, self.class::MAPPING, label, raw, issues, line, details: details)
+      end
+    end
+  end
+end

data/lib/wireless/h3c/verbose_parser.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+
+module Wireless
+  module H3c
+    # 为 H3C 详细命令回显共享词元切分与类型化字段处理。
+    class VerboseParser < Parser
+      private
+
+      # 切分含引号的命令值，不将其作为 Ruby 代码解释。
+      def tokens(text, issues)
+        text.lines.each_with_index.each_with_object([]) do |(line, index), fields|
+          row = line.strip
+          next if row.empty? || /\A[-=]+\z/.match?(row)
+          if (match = /\A([^:]+?)\s*:\s*(.*)\z/.match(row))
+            label = match[1].downcase.gsub(/\s+/, " ")
+            next if /\A(?:total|number of aps|connected|remaining|maximum|current number|(?:local|server|sync) ap licenses|(?:current|max|bound) bss number)\b/.match?(label)
+            fields << [ label, Fields.value(match[2]), index + 1 ]
+          elsif (match = /\A:\s*(\S.*)\z/.match(row)) && fields.last&.first == "poe status"
+            fields.last[1] = [ fields.last[1], match[1] ].compact.join("\n")
+          elsif /\A(?:NSS\d+\s+[\d, ]+|TID \d+\s+(?:In|Out|Both)|[\d., ]+(?:Mbps)?)\z/.match?(row)
+            next
+          else
+            issues << { code: :unrecognized_line, line: index + 1 }
+          end
+        end
+      end
+
+      # 更新当前记录前，先应用字段专用转换。
+      def assign_field(record, mapping, label, raw, issues, line, details:)
+        if record && (field = mapping[label])
+          safely(issues, line) do
+            # 优先使用运行带宽；80+80MHz 等歧义值保持原义，不截断为单个数值。
+            if field == :channel_width
+              (record[:details] ||= {})[label.tr(" ", "_").to_sym] = raw
+              return if label == "channel bandwidth" && record[:details].key?(:operating_bandwidth)
+            end
+            record[field] = convert(field, raw)
+          end
+        elsif details
+          (details[:details] ||= {})[label.tr(" -", "__").to_sym] = label.end_with?("url") ? !raw.nil? && !raw.strip.empty? : raw
+        else
+          issues << { code: :unrecognized_field, line: line }
+        end
+      end
+
+      # 按声明的归一化规则转换已知字段。
+      def convert(field, raw)
+        case field
+        when :mac_address, :client_mac, :bssid then Fields.mac(raw)
+        when :management_ip, :client_ip, :client_ipv6, :ip_address, :ipv6_address then Fields.ip(raw)
+        when :ap_id, :radio_id then Fields.integer(raw)&.to_s
+        when :client_count, :online_seconds, :uptime_seconds
+          %i[online_seconds uptime_seconds].include?(field) ? Fields.duration(raw) : Fields.integer(raw)
+        when :vlan, :initial_vlan_id, :authorized_vlan_id then Fields.integer(raw, max: 4094)
+        when :channel then Fields.channel(raw)
+        when :channel_width then Fields.width(raw)
+        when :band then Fields.band(raw)
+        when :noise_dbm then Fields.number(raw, unit: "dBm")&.then { |number| number if number.negative? }
+        when :utilization
+          number = Fields.number(raw, unit: "%")
+          raise ArgumentError, "Invalid wireless utilization" if number && !(0..100).cover?(number)
+          number&.round
+        else raw
+        end
+      end
+
+      # 解析非负计数，同时保留未知值。
+      def count(text, noun)
+        /(?:Total(?: number of)?\s+(?:#{noun})|Total|Current BSS number)\s*:\s*(\d+)\s*$/i.match(text)&.[](1)&.to_i
+      end
+
+      # 隔离单个格式错误字段，同时保留无关记录数据。
+      def safely(issues, line)
+        yield
+      rescue ArgumentError, IPAddr::InvalidAddressError
+        issues << { code: :invalid_field, line: line }
+      end
+    end
+  end
+end

data/lib/wireless/h3c_runtime.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "runtime_parser"
+
+module Wireless
+  # 保留 H3C 公共入口，具体 CLI 语法由独立命令类负责。
+  class H3cRuntime
+    # 绑定 H3C 运行解析器，并保留既有公共入口。
+    def initialize(model: nil)
+      @parser = RuntimeParser.new(model: model)
+    end
+
+    # 将单个 H3C 运行维度委派给共享无线解析入口。
+    def parse(name, text, complete:)
+      @parser.parse(name, text, platform: :h3c, complete: complete)
+    end
+  end
+end

data/lib/wireless/huawei_runtime.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "fields"
+require_relative "observation"
+
+module Wireless
+  # 仅支持有证据的 Huawei 表格格式，区分不支持维度与空清单。
+  class HuaweiRuntime
+    # 解析支持的 Huawei AP 或客户端汇总，其余维度标记为不支持。
+    def parse(name, text, complete:)
+      unless %i[access_points clients].include?(name)
+        return Observation.new(name: name, status: :unsupported, issues: [ { code: :unsupported_platform_dimension } ])
+      end
+      records, issues = [], []
+      header = false
+      total = nil
+      text.lines.each_with_index do |line, index|
+        row = line.strip
+        next if row.empty? || /\A[-=]+\z/.match?(row)
+        if (match = /\ATotal\s*:\s*(\d+)\z/i.match(row))
+          total = match[1].to_i
+        elsif name == :access_points ? /\AID\s+MAC\s+Name\s+Group\s+IP\s+Type\s+State\s+STA\s+Uptime\b/i.match?(row) : /\ASTA MAC\s+AP ID\s+Ap name\s+Rf\/WLAN\b/i.match?(row)
+          header = true
+        elsif /\ATotal AP information:|\A(?:nor|fault|idle|stdby)\s*:/i.match?(row)
+          next
+        elsif !header
+          issues << { code: :missing_header, line: index + 1 }
+        else
+          begin
+            records << (name == :access_points ? ap(row.split) : client(row.split))
+          rescue ArgumentError, IPAddr::InvalidAddressError
+            issues << { code: :invalid_row, line: index + 1 }
+          end
+        end
+      end
+      issues << { code: :missing_header } unless header
+      result = Fields.result(records, issues: issues, complete: complete, total: total, identity: [ name == :access_points ? :name : :client_mac ])
+      Observation.new(name: name, **result.to_h)
+    end
+
+    private
+
+    # 归一化控制器报告的单条 AP 记录。
+    def ap(columns)
+      raise ArgumentError, "Invalid AP row" unless columns.size == 9
+      id, mac, name, group, ip, model, state, clients, uptime = columns
+      { ap_id: Fields.integer(id).to_s, mac_address: Fields.mac(mac), name: name, group_name: group,
+        management_ip: Fields.ip(Fields.value(ip)), model: model, operational_status: Fields.online_status(state),
+        client_count: Fields.integer(clients), uptime_seconds: Fields.duration(Fields.value(uptime)) }
+    end
+
+    # 归一化控制器报告的单条无线客户端记录。
+    def client(columns)
+      raise ArgumentError, "Invalid station row" unless columns.size == 15
+      mac, ap_id, ap_name, radio_wlan, band, protocol, rates, rssi, vlan, ip, ssid, state, ipv6, _ac_id, uptime = columns
+      raise ArgumentError, "Invalid station identity" unless /\A\d+\/\d+\z/.match?(radio_wlan)
+      rx, tx = Fields.rates(rates)
+      signal = Fields.number(Fields.value(rssi), unit: "dBm")
+      { client_mac: Fields.mac(mac), ap_id: Fields.integer(ap_id).to_s, ap_name: ap_name, radio_id: radio_wlan.split("/").first,
+        band: Fields.band(band), protocol: protocol, rx_rate_mbps: rx, tx_rate_mbps: tx, signal_dbm: signal == 0 ? nil : signal,
+        vlan: Fields.integer(vlan, max: 4094), client_ip: Fields.ip(Fields.value(ip)), ssid: ssid, operational_status: state,
+        client_ipv6: Fields.ip(Fields.value(ipv6)), uptime_seconds: Fields.duration(Fields.value(uptime)) }
+    end
+  end
+end

data/lib/wireless/neighbor_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "parser_registry"
+require_relative "observation"
+
+module Wireless
+  # AP 身份由采集上下文提供；LLDP 解析器只读取响应报告的端点。
+  class NeighborParser
+    # 按 AP 型号选择邻居回显解析器。
+    def initialize(platform: :h3c, model: nil)
+      @profile = ParserRegistry.fetch(platform, model: model)
+    end
+
+    # 解析 LLDP 端点，并关联采集上下文提供的 AP 身份。
+    def parse(content, ap_name:, complete: false)
+      raise ArgumentError, "Missing AP name" unless ap_name.is_a?(String) && !ap_name.strip.empty?
+
+      result = @profile.parse(:lldp, content, complete: complete)
+      records = result.records.map { |record| record.merge(ap_name: ap_name) }
+      Observation.new(name: :lldp, **result.to_h.merge(records: records))
+    rescue ArgumentError
+      Observation.new(name: :lldp, status: :failed, issues: [ { code: :invalid_output } ])
+    end
+  end
+end

data/lib/wireless/observation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "ctx_parser/immutable"
+
+module Wireless
+  # 保存单个维度的事实与安全诊断；默认检查不展示记录正文。
+  Observation = Data.define(:name, :status, :records, :issues, :evidence, :started_at, :completed_at) do
+    # 冻结单个维度的记录、状态及诊断元数据。
+    def initialize(name:, status:, records: [], issues: [], evidence: [], started_at: nil, completed_at: nil)
+      raise ArgumentError, "Invalid wireless observation status" unless %i[complete partial failed unsupported not_requested].include?(status)
+      raise ArgumentError, "Wireless records must be hashes" unless records.is_a?(Array) && records.all? { |record| record.is_a?(Hash) }
+      raise ArgumentError, "Unavailable wireless observation has records" if %i[failed unsupported not_requested].include?(status) && records.any?
+
+      super(name: name, status: status, records: CtxParser::Immutable.copy(records),
+        issues: CtxParser::Immutable.copy(issues), evidence: CtxParser::Immutable.copy(evidence),
+        started_at: started_at&.dup&.freeze, completed_at: completed_at&.dup&.freeze)
+    end
+
+    # 判断所有已选事实是否都有完整证据支持。
+    def complete? = status == :complete
+    # 判断证据不完整时是否仍保留可用事实。
+    def partial? = status == :partial
+    # 判断当前观测是否包含完整或部分可用证据。
+    def available? = complete? || partial?
+    # 展示对象身份与状态，避免泄露原始回显或凭据。
+    def inspect = "#<#{self.class.name} name=#{name} status=#{status} records=#{records.size}>"
+  end
+end

data/lib/wireless/parser_registry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "ctx_parser/registry"
+require_relative "h3c/profile"
+
+module Wireless
+  # 将 h3c_wireless 视为 H3C 无线平台策略的连接器别名。
+  ParserRegistry = CtxParser::Registry.new(profiles: { h3c: H3c::Profile }, aliases: { h3c_wireless: :h3c })
+end

data/lib/wireless/projection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "ctx_parser/immutable"
+
+module Wireless
+  # 资产应用具有独立结果；父对象缺失不使已采集事实失效。
+  Projection = Data.define(:dimensions) do
+    # 冻结各维度的资产应用结果。
+    def initialize(dimensions: {})
+      super(dimensions: CtxParser::Immutable.copy(dimensions))
+    end
+
+    # 判断所有请求的资产投影是否均已完成。
+    def complete? = dimensions.values.all? { |entry| entry.fetch(:status) == :complete }
+  end
+end

data/lib/wireless/runtime_parser.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "parser_registry"
+require_relative "fields"
+require_relative "huawei_runtime"
+require_relative "observation"
+
+module Wireless
+  # 将平台解析结果映射为无线维度，同时保留 Huawei 解析入口。
+  class RuntimeParser
+    # 保留型号选择信息，供每次解析所选平台使用。
+    def initialize(model: nil)
+      @model = model
+    end
+
+    # 使用传入平台及保留的型号选择解析单个无线维度。
+    def parse(name, content, platform: "h3c", complete: false)
+      parse_many([ name ], content, platform: platform, complete: complete).fetch(name)
+    end
+
+    # 共享命令仅解析一次，再投影各请求维度。
+    def parse_many(names, content, platform: "h3c", complete: false)
+      text = Fields.text(content)
+      if H3c::Parser::UNSUPPORTED.match?(text)
+        return unavailable(names, :unsupported, :unsupported_command)
+      end
+      if platform.to_s == "huawei"
+        return names.to_h { |name| [ name, HuaweiRuntime.new.parse(name, text, complete: complete) ] }
+      end
+
+      profile = ParserRegistry.fetch(platform, model: @model)
+      supported, unsupported = names.partition { |name| profile.commands.key?(name) }
+      results = supported.empty? ? {} : profile.parse_many(supported, text, complete: complete)
+      observations = results.to_h { |name, result| [ name, Observation.new(name: name, **result.to_h) ] }
+      observations.merge(unavailable(unsupported, :unsupported, :unsupported_platform_dimension))
+    rescue ArgumentError, IPAddr::InvalidAddressError
+      unavailable(names, :failed, :invalid_output)
+    end
+
+    private
+
+    # 构建明确不可用的观测，不虚构成功的空结果。
+    def unavailable(names, status, code)
+      names.to_h { |name| [ name, Observation.new(name: name, status: status, issues: [ { code: code } ]) ] }
+    end
+  end
+end

data/lib/wireless/snapshot.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "ctx_parser/immutable"
+require_relative "observation"
+
+module Wireless
+  # 携带调用方提供的设备身份，不引入独立资产模型。
+  Snapshot = Data.define(:target, :dimensions, :observed_at) do
+    DIMENSIONS = %i[access_points radios bsses clients configuration ap_groups service_templates
+      dot1x_connections mab_connections blocked_clients client_ip_conflicts ap_models lldp collection].freeze
+
+    # 冻结设备身份、观测结果与采样时间。
+    def initialize(target:, dimensions:, observed_at: Time.now.utc)
+      unless target.is_a?(Hash) && dimensions.is_a?(Hash) && dimensions.any? &&
+          dimensions.all? { |name, value| DIMENSIONS.include?(name) && value.is_a?(Observation) && value.name == name } &&
+          observed_at.is_a?(Time)
+        raise ArgumentError, "Invalid wireless snapshot"
+      end
+      super(target: CtxParser::Immutable.copy(target), dimensions: dimensions.dup.freeze,
+        observed_at: observed_at.dup.freeze)
+    end
+
+    # 返回所选观测，或明确的未请求占位结果。
+    def dimension(name) = dimensions.fetch(name) { Observation.new(name: name, status: :not_requested) }
+    # 返回请求观测维度的记录。
+    def records(name) = dimension(name).records
+
+    # 判断所有已选事实是否都有完整证据支持。
+    def complete?
+      selected = dimensions.values.reject { |value| value.status == :not_requested }
+      selected.any? && selected.all?(&:complete?)
+    end
+
+    # 展示对象身份与状态，避免泄露原始回显或凭据。
+    def inspect = "#<#{self.class.name} complete=#{complete?}>"
+  end
+end

data/lib/wireless/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Wireless
+  # 公开包版本，供 RubyGems 元数据和运行时调用方共用。
+  VERSION = "0.1.0"
+end

data/lib/wireless.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "wireless/version"
+
+module Wireless
+end
+
+require_relative "wireless/fields"
+require_relative "wireless/observation"
+require_relative "wireless/snapshot"
+require_relative "wireless/projection"
+require_relative "wireless/coverage"
+require_relative "wireless/configuration"
+require_relative "wireless/runtime_parser"
+require_relative "wireless/h3c_runtime"
+require_relative "wireless/neighbor_parser"
+require_relative "wireless/ap_session"
+require_relative "wireless/collector"

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: wireless-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gatework contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ctx_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ctx_driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: date
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-connector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: time
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Wireless configuration, access point, radio, client and neighbor observations
+  with independent command and nested-session failure handling.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README-zh.md
+- README.md
+- docs/architecture-zh.md
+- docs/release.md
+- examples/offline.rb
+- lib/wireless.rb
+- lib/wireless/ap_session.rb
+- lib/wireless/collector.rb
+- lib/wireless/configuration.rb
+- lib/wireless/coverage.rb
+- lib/wireless/fields.rb
+- lib/wireless/h3c/authentication_parser.rb
+- lib/wireless/h3c/command_output.rb
+- lib/wireless/h3c/configuration.rb
+- lib/wireless/h3c/parser.rb
+- lib/wireless/h3c/parsers/display_current_configuration.rb
+- lib/wireless/h3c/parsers/display_dot1x_connection.rb
+- lib/wireless/h3c/parsers/display_lldp_neighbor_information_verbose.rb
+- lib/wireless/h3c/parsers/display_mac_authentication_connection.rb
+- lib/wireless/h3c/parsers/display_wlan_ap_all_verbose.rb
+- lib/wireless/h3c/parsers/display_wlan_ap_model_all.rb
+- lib/wireless/h3c/parsers/display_wlan_bss_all_verbose.rb
+- lib/wireless/h3c/parsers/display_wlan_client_security_block_mac.rb
+- lib/wireless/h3c/parsers/display_wlan_client_verbose.rb
+- lib/wireless/h3c/parsers/display_wlan_statistics_client_ip_conflict.rb
+- lib/wireless/h3c/profile.rb
+- lib/wireless/h3c/session_parser.rb
+- lib/wireless/h3c/verbose_parser.rb
+- lib/wireless/h3c_runtime.rb
+- lib/wireless/huawei_runtime.rb
+- lib/wireless/neighbor_parser.rb
+- lib/wireless/observation.rb
+- lib/wireless/parser_registry.rb
+- lib/wireless/projection.rb
+- lib/wireless/runtime_parser.rb
+- lib/wireless/snapshot.rb
+- lib/wireless/version.rb
+homepage: https://github.com/gatework/wireless-rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/gatework/wireless-rb
+  bug_tracker_uri: https://github.com/gatework/wireless-rb/issues
+  changelog_uri: https://github.com/gatework/wireless-rb/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/gatework/wireless-rb#readme
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Parse and collect wireless controller inventories.
+test_files: []