wifidiag 0.1.0

data/config.ru

@@ -0,0 +1,19 @@
+require 'bundler/setup'
+require 'wifidiag'
+
+config =   Wifidiag::Config.new(
+  adapter: Wifidiag::Adapters::CiscoWlc.new(
+    host: ENV.fetch('WLC_HOST'),
+    community: ENV.fetch('WLC_COMMUNITY'),
+  ),
+  reporters: [
+    ENV['WIFIDIAG_SLACK_WEBHOOK_URL'] ? Wifidiag::Reporters::Slack.new(
+      webhook_url: ENV['WIFIDIAG_SLACK_WEBHOOK_URL'],
+    ) : nil,
+  ].compact,
+  dummy_ip: ENV['WIFIDIAG_DUMMY_IP'],
+)
+
+config.collector.start_periodic_update(60)
+
+run Wifidiag.app(config)

data/lib/wifidiag.rb

@@ -0,0 +1,9 @@
+require 'wifidiag/version'
+
+require 'wifidiag/config'
+
+require 'wifidiag/adapters/cisco_wlc'
+require 'wifidiag/reporters/slack'
+
+require 'wifidiag/app'
+

data/lib/wifidiag/adapters/base.rb

@@ -0,0 +1,12 @@
+module Wifidiag
+  module Adapters
+    class Base
+      def initialize()
+      end
+
+      def collect
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/wifidiag/adapters/cisco_wlc.rb

@@ -0,0 +1,51 @@
+require 'wlc_snmp'
+
+require 'wifidiag/adapters/base'
+
+require 'wifidiag/ap_data'
+require 'wifidiag/client_data'
+
+module Wifidiag
+  module Adapters
+    class CiscoWlc
+      def initialize(host:, port: 161, community:)
+        @host = host
+        @port = port
+        @community = community
+      end
+
+      def collect
+        aps = {}
+        wlc.clients.map do |client|
+          if client.ap
+            ap = aps.fetch(client.ap_mac) do
+              aps[client.ap_mac] = ApData.new(
+                name: client.ap.name,
+                mac_address: client.ap.mac_address,
+                location: client.ap.location,
+                model: client.ap.model,
+              )
+            end
+          end
+          ClientData.new(
+            mac_address: client.mac_address,
+            ip_address: client.ip_address,
+            ap: ap,
+            wlan_profile: client.wlan_profile,
+            protocol: client.protocol,
+            ap_mac: client.ap_mac,
+            uptime: client.uptime,
+            current_rate: client.current_rate,
+            supported_data_rates: client.supported_data_rates,
+            user: client.user,
+            ssid: client.ssid,
+          )
+        end
+      end
+
+      def wlc
+        @snmp ||= WlcSnmp::Client.new(host: @host, port: @port, community: @community)
+      end
+    end
+  end
+end

data/lib/wifidiag/ap_data.rb

@@ -0,0 +1,21 @@
+module Wifidiag
+  class ApData
+    def initialize(name: , mac_address: nil, **kwargs)
+      @name = name
+      @mac_address = mac_address
+      @additional_data = kwargs
+    end
+
+    attr_reader :name, :mac_address
+    attr_reader :additional_data
+
+
+    def to_h
+      {
+        name: name,
+        mac_address: mac_address,
+        additional_data: additional_data,
+      }
+    end
+  end
+end

data/lib/wifidiag/app.rb

@@ -0,0 +1,123 @@
+require 'sinatra/base'
+require 'json'
+
+require 'wifidiag/report'
+
+module Wifidiag
+  def self.app(*args)
+    App.rack(*args)
+  end
+
+  class App < Sinatra::Base
+    class Boom < StandardError; end
+
+    CONTEXT_RACK_ENV_NAME = 'wifidiag.ctx'
+
+    set :root, File.expand_path(File.join(__dir__, '..', '..', 'app'))
+
+    def self.initialize_context(config)
+      {
+        config: config,
+        revision: self.revision(),
+      }
+    end
+
+    def self.revision
+      path = File.join(__dir__, '..', '..', 'REVISION')
+      if File.exist?(path)
+        File.read(path).chomp
+      else
+        nil
+      end
+    end
+
+    def self.rack(config={})
+      klass = App
+
+      context = initialize_context(config)
+      app = lambda { |env|
+        env[CONTEXT_RACK_ENV_NAME] = context
+        klass.call(env)
+      }
+    end
+
+    helpers do
+      def context
+        request.env[CONTEXT_RACK_ENV_NAME]
+      end
+
+      def conf
+        context[:config]
+      end
+
+      def collector
+        conf.collector
+      end
+
+      def revision
+        context[:revision]
+      end
+
+      TRUSTED_IPS = /\A127\.0\.0\.1\Z|\A(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|\A::1\Z|\Afd[0-9a-f]{2}:.+|\Alocalhost\Z|\Aunix\Z|\Aunix:/i
+      def client_ip
+        return conf[:dummy_ip] if conf[:dummy_ip]
+        @client_ip ||= begin
+          remote_addrs = request.get_header('REMOTE_ADDR')&.split(/,\s*/)
+          filtered_remote_addrs = remote_addrs.grep_v(TRUSTED_IPS)
+
+          if filtered_remote_addrs.empty? && request.get_header('HTTP_X_FORWARDED_FOR')
+            forwarded_ips = request.get_header('HTTP_X_FORWARDED_FOR')&.split(/,\s*/)
+            filtered_forwarded_ips = forwarded_ips.grep_v(TRUSTED_IPS)
+
+            filtered_forwarded_ips.empty? ? forwarded_ips.first : remote_addrs.first
+          else
+            filtered_remote_addrs.first || remote_addrs.first
+          end
+        end
+      end
+
+      def data
+        begin
+          @data = JSON.parse(request.body.tap(&:rewind).read)
+        rescue JSON::ParserError
+          halt 400, '{"error": "invalid_payload"}'
+        end
+      end
+
+    end
+
+    configure do
+      enable :logging
+    end
+
+    get '/' do
+      @client = conf.collector.client_data_for_ip_address(client_ip)
+      erb :index
+    end
+
+    get '/api/self' do
+      content_type :json
+      data = conf.collector.client_data_for_ip_address(client_ip)
+      if data
+        data.to_h.to_json
+      else
+        halt 404, {error: :not_found, ip: client_ip}.to_json
+      end
+    end
+
+    post '/api/report' do
+      content_type :json
+      report = Report.new(
+        client_ip,
+        conf.collector.client_data_for_ip_address(client_ip),
+        data['data'] || {},
+      )
+
+      conf[:reporters].each do |x|
+        x.report! report
+      end
+
+      '{"status": "ok"}'
+    end
+  end
+end

data/lib/wifidiag/client_data.rb

@@ -0,0 +1,24 @@
+module Wifidiag
+  class ClientData
+    def initialize(ip_address: , mac_address: nil, ssid: nil, ap: nil, **kwargs)
+      @ip_address = ip_address
+      @mac_address = mac_address
+      @ssid = ssid
+      @additional_data = kwargs
+      @ap = ap
+    end
+
+    attr_reader :ip_address, :mac_address, :ssid, :ap
+    attr_reader :additional_data
+
+    def to_h
+      {
+        ip_address: ip_address,
+        mac_address: mac_address,
+        ssid: ssid,
+        ap: ap.to_h,
+        additional_data: additional_data,
+      }
+    end
+  end
+end

data/lib/wifidiag/collector.rb

@@ -0,0 +1,58 @@
+require 'thread'
+
+module Wifidiag
+  # Collect client and AP information from +an adapter+
+  class Collector
+    def initialize(adapter)
+      @lock = Mutex.new
+
+      @adapter = adapter
+
+      @clients = nil
+      @clients_by_ip_address = nil
+      @clients_by_mac_address = nil
+      @last_update = nil
+    end
+
+    attr_reader :adapter, :last_update
+
+    def start_periodic_update(interval) # XXX:
+      self.collect
+
+      Thread.new do
+        loop do
+          begin
+            self.collect
+            sleep interval
+          rescue Exception => e
+            $stderr.puts "Periodic update error: #{e.inspect}"
+            e.backtrace.each do |x|
+              $stderr.puts "\t#{x}"
+            end
+            sleep interval
+          end
+        end
+      end
+    end
+
+    def collect
+      @lock.synchronize do
+        clients = adapter.collect()
+        clients_by_ip_address = clients.map { |_| [_.ip_address, _] }.to_h
+        clients_by_mac_address = clients.map { |_| [_.mac_address, _] }.to_h
+        @clients = clients
+        @clients_by_ip_address = clients_by_ip_address
+        @clients_by_mac_address = clients_by_mac_address
+        @last_update = Time.now
+      end
+    end
+
+    def client_data_for_ip_address(address)
+      @clients_by_ip_address[address]
+    end
+
+    def client_data_for_mac_address(address)
+      @clients_by_mac_address[address]
+    end
+  end
+end

data/lib/wifidiag/config.rb

@@ -0,0 +1,29 @@
+require 'wifidiag/collector'
+
+module Wifidiag
+  class Config
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def [](k)
+      @hash[k]
+    end
+
+    def fetch(*args)
+      @hash.fetch(*args)
+    end
+
+    def dig(*args)
+      @hash.dig(*args)
+    end
+
+    def adapter
+      @hash.fetch(:adapter)
+    end
+
+    def collector
+      @collector ||= Collector.new(adapter)
+    end
+  end
+end

data/lib/wifidiag/report.rb

@@ -0,0 +1,19 @@
+module Wifidiag
+  class Report
+    def initialize(client_ip, client_data, advanced_data)
+      @client_ip = client_ip
+      @client_data = client_data
+      @advanced_data = advanced_data
+    end
+
+    attr_reader :client_ip, :client_data, :advanced_data
+
+    def to_h
+      {
+        client_ip: client_ip,
+        client_data: client_data.to_h,
+        advanced_data: advanced_data.to_h,
+      }
+    end
+  end
+end

data/lib/wifidiag/reporters/base.rb

@@ -0,0 +1,9 @@
+module Wifidiag
+  module Reporters
+    class Base
+      def report!(report)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/wifidiag/reporters/slack.rb

@@ -0,0 +1,68 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'wifidiag/reporters/base'
+
+module Wifidiag
+  module Reporters
+    class Slack < Base
+      def initialize(webhook_url:)
+        @webhook_url = URI.parse(webhook_url)
+      end
+
+      def report!(report)
+        Net::HTTP.post_form(
+          @webhook_url,
+          payload: {
+            text: "Wi-Fi diagnostic received!" + (report.advanced_data.dig('client', 'q') ? " (#{report.advanced_data['client']['q'].inspect})" : ''),
+            mrkdwn: true,
+            attachments: [
+              {
+                fallback: report.to_h.to_json,
+                text: "Expand to see raw JSON:\n\n\n\n\n\n```\n#{JSON.pretty_generate(report.to_h)}\n```",
+                mrkdwn_in: ['text'],
+                fields: [
+                  report.client_data&.ssid ? {
+                    title: 'SSID',
+                    value: report.client_data.ssid,
+                    short: true,
+                  } : nil,
+                  report.client_data&.ap ? {
+                    title: 'AP',
+                    value: report.client_data.ap&.name || report.client_data.ap&.mac_address || 'n/a',
+                    short: true,
+                  } : nil,
+                  {
+                    title: 'IP address',
+                    value: report.client_ip,
+                    short: true,
+                  },
+                  report.advanced_data['bandwidth']&.dig('mbps') ? {
+                    title: 'Bandwidth',
+                    value: "%.4f Mbps" % report.advanced_data['bandwidth']&.dig('mbps'),
+                    short: true,
+                  } : nil,
+                  report.advanced_data['latency'] ? {
+                    title: 'Latency',
+                    value: "pkt: ok=%d ng=%d rate=%.1f%%\nrtt: min=%.2f avg=%.2f max=%.2f mdev=%.2f time=%.2f ms" \
+                      % report.advanced_data['latency']&.values_at(
+                        'ok', 'fail', 'rate',
+                        'min', 'avg', 'max', 'mdev',
+                        'time',
+                      ).map{ |_| _ == nil ? -1 : _ },
+                    short: false,
+                  } : nil,
+                  report.advanced_data['client']['ua'] ? {
+                    title: 'User agent',
+                    value: report.advanced_data['client']['ua'],
+                    short: false,
+                  } : nil,
+                ].compact,
+              }
+            ]
+          }.to_json
+        )
+      end
+    end
+  end
+end