patronus_fati 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 664042f58354d590c6310e4e91d2ae507b274c3e
-  data.tar.gz: 0b5d0718f1d2dbf95b8cd2881afa8fc1795902c2
+  metadata.gz: c9a7acfd177a783e5557a8e81a9dfe4eee777437
+  data.tar.gz: 5a8a3889d839f81386008de1f76e4bd68662e62a
 SHA512:
-  metadata.gz: 595d620cd4546db4e09a1f46b7626c49db070599066adf72f8c804b900aef332afd700086b87d1051d0247f295439334f49e937f206c02b5bb9fb53d292ff442
-  data.tar.gz: 834f2b21212f2c46cfe923f562891f88fdcf3c3025ece35de17443f8a6c4e7ec4761549ded6e470a2c17bdc7e9d895f1fb352dd0fb9a7baf309df6bba7b3e0a6
+  metadata.gz: 81a6b3e81d3634847fafaa5da8db3b07c3bcb41e02de0746b74e2d9b55194854302cd12d341b02d828d5a61bb1276d25632373d9147250cef9289473e995d432
+  data.tar.gz: c69f576ed4fdec47eb42560f9137cca80488b6ae0f79855b41b01800f47efdbe8a7361644693fcf9ef70c91636e88f1262016f9e150d1e32d439bb3ff19845f1

data/bin/patronus_fati

@@ -39,8 +39,16 @@ exception_logger('process') do
   connection = PatronusFati.setup(options['server'], options['port'])
   connection.connect
 
-  PatronusFati.event_handler.on(:any) do |asset_type, event_type, msg, _|
-    PatronusFati.logger.info(JSON.generate({asset_type: asset_type, event_type: event_type, data: msg, timestamp: Time.now}))
+  PatronusFati.event_handler.on(:any) do |asset_type, event_type, msg, diagnostics|
+    PatronusFati.logger.info(JSON.generate(
+      {
+        asset_type: asset_type,
+        event_type: event_type,
+        data: msg,
+        diagnostics: diagnostics,
+        timestamp: Time.now.to_i
+      }
+    ))
   end
 
   while (line = connection.read_queue.pop)

data/lib/patronus_fati/data_models/access_point.rb

@@ -3,25 +3,16 @@ module PatronusFati
     class AccessPoint
       include CommonState
 
-      attr_accessor :client_macs, :local_attributes, :presence, :ssids,
-        :sync_status
+      attr_accessor :client_macs, :local_attributes, :ssids
 
       LOCAL_ATTRIBUTE_KEYS = [ :bssid, :channel, :type ].freeze
 
-      def self.[](bssid)
-        instances[bssid] ||= new(bssid)
-      end
-
       def self.current_expiration_threshold
         Time.now.to_i - AP_EXPIRATION
       end
 
-      def self.instances
-        @instances ||= {}
-      end
-
       def active_ssids
-        ssids.select { |_, v| v.active? }.values
+        ssids.select { |_, v| v.active? } if ssids
       end
 
       def add_client(mac)
@@ -37,14 +28,16 @@ module PatronusFati
           PatronusFati.event_handler.event(
             :access_point,
             status,
-            full_state
+            full_state,
+            diagnostic_data
           )
         else
           PatronusFati.event_handler.event(
             :access_point, :offline, {
               'bssid' => local_attributes[:bssid],
               'uptime' => presence.visible_time
-            }
+            },
+            diagnostic_data
           )
 
           # We need to reset the first seen so we get fresh duration
@@ -61,34 +54,40 @@ module PatronusFati
       end
 
       def cleanup_ssids
-        return if ssids.select { |_, v| v.presence.dead? }.empty?
+        return if ssids.nil? || ssids.select { |_, v| v.presence.dead? }.empty?
 
-        # When an AP is offline we don't care about it's SSIDs
-        # expiring
-        set_sync_flag(:dirtyChildren) if active? && !status_dirty?
-        ssids.reject { |_, v| v.presence.dead? }
+        # When an AP is offline we don't care about announcing that it's SSIDs
+        # have expired, but we do want to remove them.
+        set_sync_flag(:dirtyChildren) if active?
+
+        ssids.reject! { |_, v| v.presence.dead? }
+      end
+
+      def diagnostic_data
+        dd = super
+        dd.merge!(ssids: Hash[ssids.map { |k, s| [k, s.diagnostic_data] }]) if ssids
+        dd
       end
 
       def full_state
-        local_attributes.merge({
+        state = local_attributes.merge({
           active: active?,
           connected_clients: client_macs,
-          ssids: active_ssids.map(&:local_attributes),
           vendor: vendor
         })
+        state[:ssids] = active_ssids.values.map(&:local_attributes) if ssids
+        state
       end
 
       def initialize(bssid)
+        super
         self.local_attributes = { bssid: bssid }
         self.client_macs = []
-        self.presence = Presence.new
-        self.ssids = {}
-        self.sync_status = 0
       end
 
       def mark_synced
         super
-        ssids.each { |_, v| v.mark_synced }
+        ssids.each { |_, v| v.mark_synced } if ssids
       end
 
       def remove_client(mac)
@@ -96,6 +95,7 @@ module PatronusFati
       end
 
       def track_ssid(ssid_data)
+        self.ssids ||= {}
         ssids[ssid_data[:essid]] ||= DataModels::Ssid.new(ssid_data[:essid])
 
         ssid = ssids[ssid_data[:essid]]

data/lib/patronus_fati/data_models/client.rb

@@ -3,25 +3,16 @@ module PatronusFati
     class Client
       include CommonState
 
-      attr_accessor :access_point_bssids, :local_attributes, :presence,
-        :probes, :sync_status
+      attr_accessor :access_point_bssids, :local_attributes, :probes
 
       LOCAL_ATTRIBUTE_KEYS = [ :mac, :channel ].freeze
 
-      def self.[](mac)
-        instances[mac] ||= new(mac)
-      end
-
       def self.current_expiration_threshold
         Time.now.to_i - CLIENT_EXPIRATION
       end
 
-      def self.exists?(mac)
-        instances.key?(mac)
-      end
-
-      def self.instances
-        @instances ||= {}
+      def add_access_point(bssid)
+        access_point_bssids << bssid unless access_point_bssids.include?(bssid)
       end
 
       def announce_changes
@@ -29,13 +20,14 @@ module PatronusFati
 
         if active?
           status = new? ? :new : :changed
-          PatronusFati.event_handler.event(:client, status, full_state)
+          PatronusFati.event_handler.event(:client, status, full_state, diagnostic_data)
         else
           PatronusFati.event_handler.event(
             :client, :offline, {
               'bssid' => local_attributes[:mac],
               'uptime' => presence.visible_time
-            }
+            },
+            diagnostic_data
           )
 
           # We need to reset the first seen so we get fresh duration information
@@ -50,15 +42,13 @@ module PatronusFati
         mark_synced
       end
 
-      def add_access_point(bssid)
-        access_point_bssids << bssid unless access_point_bssids.include?(bssid)
-      end
-
+      # Probes don't have an explicit visibility window so this will only
+      # remove probes that haven't been seen in the entire duration of the time
+      # we track any visibility.
       def cleanup_probes
-        return if probes.select { |_, v| v.presence.dead? }.empty?
-
+        return if probes.select { |_, pres| pres.dead? }.empty?
         set_sync_flag(:dirtyChildren)
-        probes.reject { |_, v| v.presence.dead? }
+        probes.reject! { |_, pres| pres.dead? }
       end
 
       def full_state
@@ -73,11 +63,10 @@ module PatronusFati
       end
 
       def initialize(mac)
+        super
         self.access_point_bssids = []
         self.local_attributes = { mac: mac }
-        self.presence = Presence.new
         self.probes = {}
-        self.sync_status = 0
       end
 
       def remove_access_point(bssid)

data/lib/patronus_fati/data_models/common_state.rb

@@ -1,6 +1,27 @@
 module PatronusFati
   module DataModels
     module CommonState
+      module KlassMethods
+        def [](key)
+          instances[key] ||= new(key)
+        end
+
+        def exists?(mac)
+          instances.key?(mac)
+        end
+
+        def instances
+          @instances ||= {}
+        end
+      end
+
+      def self.included(klass)
+        klass.extend(KlassMethods)
+        klass.class_eval do
+          attr_accessor :presence, :sync_status
+        end
+      end
+
       def active?
         presence.visible_since?(self.class.current_expiration_threshold)
       end
@@ -9,12 +30,22 @@ module PatronusFati
         sync_flag?(:dirtyAttributes) || sync_flag?(:dirtyChildren)
       end
 
+      def diagnostic_data
+        {
+          sync_status: sync_status,
+          presence_bit_offset: presence.current_bit_offset,
+          current_presence: presence.current_presence.bits,
+          last_presence: presence.last_presence.bits
+        }
+      end
+
       def dirty?
         new? || data_dirty? || status_dirty?
       end
 
-      def new?
-        sync_status == SYNC_FLAGS[:unsynced]
+      def initialize(*_args)
+        self.presence = Presence.new
+        self.sync_status = 0
       end
 
       def mark_synced
@@ -22,6 +53,10 @@ module PatronusFati
         self.sync_status = SYNC_FLAGS[flag]
       end
 
+      def new?
+        !(sync_flag?(:syncedOnline) || sync_flag?(:syncedOffline))
+      end
+
       def set_sync_flag(flag)
         self.sync_status |= SYNC_FLAGS[flag]
       end

data/lib/patronus_fati/data_models/connection.rb

@@ -3,7 +3,7 @@ module PatronusFati
     class Connection
       include CommonState
 
-      attr_accessor :bssid, :link_lost, :mac, :presence, :sync_status
+      attr_accessor :bssid, :link_lost, :mac
 
       def self.[](key)
         bssid, mac = key.split('^')
@@ -14,16 +14,12 @@ module PatronusFati
         Time.now.to_i - CONNECTION_EXPIRATION
       end
 
-      def self.instances
-        @instances ||= {}
-      end
-
       def announce_changes
         return unless dirty? && DataModels::AccessPoint[bssid].valid? &&
           DataModels::Client[mac].valid?
 
         state = active? ? :connect : :disconnect
-        PatronusFati.event_handler.event(:connection, state, full_state)
+        PatronusFati.event_handler.event(:connection, state, full_state, diagnostic_data)
 
         # We need to reset the first seen so we get fresh duration information
         presence.first_seen = nil
@@ -41,11 +37,10 @@ module PatronusFati
       end
 
       def initialize(bssid, mac)
+        super
         self.bssid = bssid
         self.link_lost = false
         self.mac = mac
-        self.presence = Presence.new
-        self.sync_status = 0
       end
 
       def full_state

data/lib/patronus_fati/data_models/ssid.rb

@@ -3,7 +3,7 @@ module PatronusFati
     class Ssid
       include CommonState
 
-      attr_accessor :local_attributes, :presence, :sync_status
+      attr_accessor :local_attributes
 
       LOCAL_ATTRIBUTE_KEYS = [
         :beacon_info, :beacon_rate, :cloaked, :crypt_set, :essid, :max_rate
@@ -14,9 +14,11 @@ module PatronusFati
       end
 
       def initialize(essid)
-        self.local_attributes = { essid: essid }
-        self.presence = PatronusFati::Presence.new
-        self.sync_status = 0
+        super
+        self.local_attributes = {
+          cloaked: essid.nil? || essid.empty?,
+          essid: essid
+        }
       end
 
       def update(attrs)

data/lib/patronus_fati/message_processor.rb

@@ -34,6 +34,7 @@ module PatronusFati
 
     def self.offline_clients
       DataModels::Client.instances.each do |_, client|
+        client.cleanup_probes
         client.announce_changes
       end
 
@@ -106,13 +107,13 @@ module PatronusFati
 
         PatronusFati::DataModels::AccessPoint.instances.each do |bssid, access_point|
           next unless access_point.active?
-          PatronusFati.event_handler.event(:access_point, :sync, access_point.full_state)
+          PatronusFati.event_handler.event(:access_point, :sync, access_point.full_state, access_point.diagnostic_data)
           access_points << bssid
         end
 
         PatronusFati::DataModels::Client.instances.each do |mac, client|
           next unless client.active?
-          PatronusFati.event_handler.event(:client, :sync, client.full_state)
+          PatronusFati.event_handler.event(:client, :sync, client.full_state, client.diagnostic_data)
           clients << mac
         end
 

data/lib/patronus_fati/presence.rb

@@ -116,9 +116,13 @@ module PatronusFati
     end
 
     # Returns the duration in seconds of how long the specific object was
-    # absolutely seen.
+    # absolutely seen. One additional interval duration is added to this length
+    # as we consider to have seen the tracked object for the entire duration of
+    # the interval not the length from the start of one interval to the start
+    # of the last interval, which makes logical sense (1 bit set is 1 interval
+    # duration, not zero seconds).
     def visible_time
-      last_visible - first_seen if first_seen
+      (last_visible + INTERVAL_DURATION) - first_seen if first_seen
     end
   end
 end

data/lib/patronus_fati/version.rb

@@ -1,3 +1,3 @@
 module PatronusFati
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end

data/spec/patronus_fati/data_models/access_point_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+RSpec.describe(PatronusFati::DataModels::AccessPoint) do
+  subject { described_class.new('66:77:88:99:aa:bb') }
+
+  it_behaves_like 'a common stateful model'
+
+  context '#active_ssids' do
+    it 'should return a hash when ssids have been populated' do
+      subject.track_ssid(essid: 'test')
+      expect(subject.active_ssids).to be_kind_of(Hash)
+    end
+
+    it 'should not include inactive SSIDs' do
+      ssid = double(PatronusFati::DataModels::Ssid)
+      expect(ssid).to receive(:active?).and_return(false)
+
+      subject.ssids = { tmp: ssid }
+      expect(subject.active_ssids.values).to_not include(ssid)
+    end
+
+    it 'should include active SSIDs' do
+      ssid = double(PatronusFati::DataModels::Ssid)
+      expect(ssid).to receive(:active?).and_return(true)
+
+      subject.ssids = { tmp: ssid }
+      expect(subject.active_ssids.values).to include(ssid)
+    end
+  end
+
+  context '#add_client' do
+    it 'should not add a client more than once' do
+      sample_mac = 'cc:bb:cc:bb:cc:bb'
+      subject.client_macs = [ sample_mac ]
+
+      expect { subject.add_client(sample_mac) }
+        .to_not change { subject.client_macs }
+    end
+
+    it 'should add a client if it\'s not presently in the list' do
+      sample_mac = 'ac:db:fc:4b:8c:0b'
+      subject.client_macs = []
+
+      expect { subject.add_client(sample_mac) }
+        .to change { subject.client_macs }.from([]).to([sample_mac])
+    end
+  end
+
+  # TODO:
+  context '#announce_changes'
+
+  context '#cleanup_ssids' do
+    it 'should not set the dirty children flag if there is nothing to change' do
+      subject.track_ssid(essid: 'test')
+
+      expect { subject.cleanup_ssids }.to_not change { subject.sync_status }
+    end
+
+    it 'should not set the dirty children flag when the AP is offline' do
+      allow(subject).to receive(:active?).and_return(false)
+
+      # Create a 'dead' SSID
+      subject.track_ssid(essid: 'test')
+      subject.mark_synced
+      subject.ssids['test'].presence = PatronusFati::Presence.new
+
+      expect { subject.cleanup_ssids }.to_not change { subject.sync_status }
+    end
+
+    it 'should remove dead SSIDs from the SSID list' do
+      allow(subject).to receive(:active?).and_return(true)
+
+      # Create a 'dead' SSID
+      subject.track_ssid(essid: 'test')
+      subject.mark_synced
+      subject.ssids['test'].presence = PatronusFati::Presence.new
+
+      expect(subject.ssids).to_not be_empty
+      subject.cleanup_ssids
+      expect(subject.ssids).to be_empty
+    end
+
+    it 'should set the dirty children flag when SSIDs have been removed while the AP is active' do
+      allow(subject).to receive(:active?).and_return(true)
+
+      # Create a 'dead' SSID
+      subject.track_ssid(essid: 'test')
+      subject.mark_synced
+      subject.ssids['test'].presence = PatronusFati::Presence.new
+
+      expect { subject.cleanup_ssids }.to change { subject.sync_status }
+    end
+  end
+
+  context '#diagnostic_data' do
+    it 'should include all SSID diagnostic data' do
+      ssid_dbl = double(PatronusFati::DataModels::Ssid)
+      expect(ssid_dbl).to receive(:diagnostic_data).and_return(:datum)
+      subject.ssids = { tmp: ssid_dbl }
+      expect(subject.diagnostic_data[:ssids]).to eql({tmp: :datum})
+    end
+  end
+
+  context '#full_state' do
+    it 'should return a hash' do
+      expect(subject.full_state).to be_kind_of(Hash)
+    end
+
+    it 'should include the keys expected by pulse' do
+      subject.track_ssid(essid: 'test')
+      subject.update(channel: 45, type: 'adhoc')
+
+      [:active, :bssid, :channel, :connected_clients, :ssids, :type, :vendor].each do |k|
+        expect(subject.full_state.key?(k)).to be_truthy
+      end
+    end
+
+    it 'should include the attributes of active ssids' do
+      subject.ssids = {}
+      ssid_dbl = double(PatronusFati::DataModels::Ssid)
+      expect(subject).to receive(:active_ssids).and_return({ pnt: ssid_dbl })
+      expect(ssid_dbl).to receive(:local_attributes).and_return('data')
+      expect(subject.full_state[:ssids]).to eql(['data'])
+    end
+  end
+
+  context '#initialize' do
+    it 'should set the local attributes to an appropriate hash' do
+      subject = described_class.new('12:23:34:45:56:67')
+      expect(subject.local_attributes).to eql(bssid: '12:23:34:45:56:67')
+    end
+
+    it 'should initialize client_macs to an empty array' do
+      expect(subject.client_macs).to be_kind_of(Array)
+      expect(subject.client_macs).to be_empty
+    end
+  end
+
+  context '#mark_synced' do
+    it 'should clear dirty flags' do
+      subject.update(channel: 8)
+      expect(subject.data_dirty?).to be_truthy
+      expect { subject.mark_synced }
+        .to change { subject.data_dirty? }.from(true).to(false)
+    end
+
+    it 'should call mark_synced on each SSID as well' do
+      dbl = double(PatronusFati::DataModels::Ssid)
+      subject.ssids = { test: dbl }
+
+      expect(dbl).to receive(:mark_synced)
+      subject.mark_synced
+    end
+  end
+
+  context '#remove_client' do
+    it 'should make no changes if the provided mac isn\'t present' do
+      subject.client_macs = [ 'one' ]
+      expect { subject.remove_client('test') }.to_not change { subject.client_macs }
+    end
+
+    it 'should remove only the provided mac if other macs are present' do
+      subject.client_macs = [ 'a', 'b', 'c' ]
+      subject.remove_client('b')
+
+      expect(subject.client_macs).to eql(['a', 'c'])
+    end
+  end
+
+  context '#track_ssid' do
+    let(:valid_ssid_data) { { essid: 'test' } }
+
+    it 'should create a new SSID instance if one doesn\'t already exist' do
+      expect(subject.ssids).to be_nil
+      expect { subject.track_ssid(valid_ssid_data) }.to change { subject.ssids }
+    end
+
+    it 'should mark the SSID as visible' do
+      ssid_dbl = double(PatronusFati::DataModels::Ssid)
+      pres_dbl = double(PatronusFati::Presence)
+
+      subject.ssids = { 'test' => ssid_dbl }
+
+      allow(ssid_dbl).to receive(:dirty?)
+      allow(ssid_dbl).to receive(:update)
+      expect(ssid_dbl).to receive(:presence).and_return(pres_dbl)
+      expect(pres_dbl).to receive(:mark_visible)
+
+      subject.track_ssid(valid_ssid_data)
+    end
+
+    it 'should update the SSID with the attributes provided' do
+      subject.track_ssid(valid_ssid_data)
+      expect(subject.ssids['test'].presence).to receive(:mark_visible)
+      subject.track_ssid(valid_ssid_data)
+    end
+
+    it 'should set the dirty children attribute if the SSID changed' do
+      expect(subject.sync_flag?(:dirtyChildren)).to be_falsey
+      subject.track_ssid(max_rate: 100)
+      expect(subject.sync_flag?(:dirtyChildren)).to be_truthy
+    end
+
+    it 'should not set the dirty children attribute if the SSID info didn\'t change' do
+      subject.track_ssid(valid_ssid_data)
+      subject.mark_synced
+
+      expect(subject.sync_flag?(:dirtyChildren)).to be_falsey
+      subject.track_ssid(valid_ssid_data)
+      expect(subject.sync_flag?(:dirtyChildren)).to be_falsey
+    end
+  end
+
+  context '#update' do
+    it 'should not set invalid keys' do
+      expect { subject.update(bad: 'key') }
+        .to_not change { subject.local_attributes }
+    end
+
+    it 'shouldn\'t modify the sync flags on invalid keys' do
+      expect { subject.update(other: 'key') }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'shouldn\'t modify the sync flags if the values haven\'t changed' do
+      expect { subject.update(subject.local_attributes) }
+        .to_not change { subject.sync_status }
+    end
+
+    it 'should set the dirty attribute flag when a value has changed' do
+      expect { subject.update(channel: 9) }
+        .to change { subject.sync_status }
+      expect(subject.sync_flag?(:dirtyAttributes)).to be_truthy
+    end
+  end
+
+  context '#valid?' do
+    it 'should be true when all required attributes are set' do
+      subject.local_attributes = { bssid: 'something', channel: 4, type: 'adhoc' }
+      expect(subject).to be_valid
+    end
+
+    it 'should not be valid when the channel is 0' do
+      subject.local_attributes = { bssid: 'something', channel: 0, type: 'adhoc' }
+      expect(subject).to_not be_valid
+    end
+
+    it 'should be false when missing a required attribute' do
+      subject.local_attributes = { bssid: 'something', channel: 4 }
+      expect(subject).to_not be_valid
+    end
+  end
+
+  context '#vendor' do
+    it 'should short circuit if no BSSID is available' do
+      expect(Louis).to_not receive(:lookup)
+
+      subject.update(bssid: nil)
+      subject.vendor
+    end
+
+    it 'should use the Louis gem to perform it\'s lookup' do
+      inst = 'test string'
+      subject.update(bssid: inst)
+
+      expect(Louis).to receive(:lookup).with(inst).and_return({})
+      subject.vendor
+    end
+
+    it 'should default the long vendor name if it\'s available' do
+      result = { 'long_vendor' => 'correct', 'short_vendor' => 'bad' }
+      expect(Louis).to receive(:lookup).and_return(result)
+      expect(subject.vendor).to eql('correct')
+    end
+
+    it 'should fallback on the short vendor name if long isn\'t available' do
+      result = { 'short_vendor' => 'short' }
+      expect(Louis).to receive(:lookup).and_return(result)
+      expect(subject.vendor).to eql('short')
+    end
+  end
+end