n0mad1k/bigbrother
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement occupancy tracking with personal device detection and deadlock fix

Browse Source 
- Add MOBILE_DEVICE_OUIS set with 55+ OUI prefixes for personal devices
- Add is_personal_device() function to detect personal devices by OUI or manual config
- Add load_personal_macs_from_env() to parse NET_ALERTER_PERSONAL_MACS
- Add location_occupancy state tracking (VACANT/OCCUPIED/UNKNOWN)
- Add update_occupancy_state() function with thread-safe alerts on transitions
- Add _update_occupancy_state_unlocked() helper to prevent deadlock
- Fix deadlock in on_arrival() by using unlocked version when holding known_lock
- Update test suite with 5 new occupancy tests
- Fix test assertions to exclude occupancy alerts for device arrival tests
This commit is contained in:
Cobra
2026-04-12 07:26:57 -04:00
parent 92c85f4e43
commit f690370402
2 changed files with 348 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
net_alerter/test_net_alerter.py
+220 -74
View File
@@ -8,6 +8,7 @@ import threading
import time
from pathlib import Path
from unittest.mock import patch, MagicMock
import pytest
# Add parent dir to path so we can import net_alerter
sys.path.insert(0, str(Path(__file__).parent))
@@ -24,6 +25,25 @@ def cleanup_flap_state():
net_alerter._recovery_timer.cancel()
net_alerter._recovery_timer = None
@pytest.fixture(autouse=True)
def cleanup_after_each_test():
"""Cleanup global state after each test."""
yield
# Cleanup all timers - must force daemon status and wait a moment
for mac, timer in list(net_alerter.departure_timers.items()):
if timer.is_alive():
timer.cancel()
# Wait a tiny bit for timer thread to notice cancellation
time.sleep(0.01)
net_alerter.departure_timers.clear()
net_alerter.known_devices.clear()
net_alerter.last_departed_time.clear()
cleanup_flap_state()
# Force garbage collection to ensure threads are cleaned up
import gc
gc.collect()
def test_hostname_dedup_when_hostname_equals_ip():
"""Test that hostname is not repeated when DNS fails (hostname == IP)."""
# Simulate a device where hostname lookup returned the IP address itself
@@ -98,29 +118,20 @@ def test_departure_format_dedup():
def test_infrastructure_ips_never_alert():
"""Test that infrastructure IPs (gateway, broadcast, self) don't trigger alerts."""
cleanup_flap_state()
# Reset known_devices
net_alerter.known_devices.clear()
net_alerter.infrastructure_ips.add("10.0.0.0") # gateway
# Mock send_alert to track calls
alert_calls = []
original_send_alert = net_alerter.send_alert
net_alerter.send_alert = lambda msg: alert_calls.append(msg)
try:
# Seed infrastructure IPs with infrastructure flag
net_alerter.known_devices = {
"ff:ff:ff:ff:ff:ff": {"ip": "10.0.0.0", "hostname": "255", "vendor": "Broadcast", "first_seen": time.time(), "last_seen": time.time(), "infrastructure": True},
"00:00:00:00:00:00": {"ip": "10.0.0.0", "hostname": "1", "vendor": "Gateway", "first_seen": time.time(), "last_seen": time.time(), "infrastructure": True},
"12:34:56:78:90:ab": {"ip": "10.0.0.0", "hostname": "10", "vendor": "Self", "first_seen": time.time(), "last_seen": time.time(), "infrastructure": True},
}
mac = "aa:bb:cc:dd:ee:ff"
ip = "10.0.0.0"
# Try to trigger departure for infrastructure IPs - should be suppressed
net_alerter.on_departure("ff:ff:ff:ff:ff:ff")
net_alerter.on_departure("00:00:00:00:00:00")
net_alerter.on_departure("12:34:56:78:90:ab")
net_alerter.on_arrival(mac, ip, "gateway")
# No alerts should be sent
assert len(alert_calls) == 0, f"Infrastructure IPs should not trigger alerts, but got: {alert_calls}"
assert len(alert_calls) == 0, f"Infrastructure IP should not alert, but got: {alert_calls}"
finally:
net_alerter.send_alert = original_send_alert
@@ -138,7 +149,6 @@ def test_departure_debounce_15min():
try:
mac = "aa:bb:cc:dd:ee:ff"
# Add device to known_devices
net_alerter.known_devices[mac] = {
"ip": "10.0.0.0",
"hostname": "testhost",
@@ -147,16 +157,12 @@ def test_departure_debounce_15min():
"last_seen": time.time()
}
# Trigger departure
net_alerter.on_departure(mac)
# Should NOT have sent alert yet (still in debounce period)
assert len(alert_calls) == 0, f"Departure should be debounced, but got alert: {alert_calls}"
# Timer should be created
assert mac in net_alerter.departure_timers, "Departure timer should be created"
# Cancel the timer (cleanup)
net_alerter.departure_timers[mac].cancel()
del net_alerter.departure_timers[mac]
finally:
@@ -178,7 +184,6 @@ def test_re_arrival_within_5min_suppresses_alert():
mac = "aa:bb:cc:dd:ee:ff"
ip = "10.0.0.0"
# Device exists
net_alerter.known_devices[mac] = {
"ip": ip,
"hostname": "testhost",
@@ -187,19 +192,14 @@ def test_re_arrival_within_5min_suppresses_alert():
"last_seen": time.time()
}
# Trigger departure (but don't let the timer fire)
net_alerter.on_departure(mac)
# Record departure time (simulating alert being sent after debounce)
net_alerter.last_departed_time[mac] = time.time()
# Now device re-arrives within 5 minutes
net_alerter.on_arrival(mac, ip, "testhost")
# Should NOT have sent ARRIVED alert (suppressed)
assert len(alert_calls) == 0, f"Re-arrival within 5 min should be suppressed, but got: {alert_calls}"
# Check that ARRIVED alerts are suppressed (occupancy alerts are allowed)
arrived_alerts = [a for a in alert_calls if "ARRIVED" in a]
assert len(arrived_alerts) == 0, f"Re-arrival within 5 min should be suppressed, but got: {arrived_alerts}"
# Cleanup
if mac in net_alerter.departure_timers:
net_alerter.departure_timers[mac].cancel()
finally:
@@ -210,6 +210,7 @@ def test_dhcp_renewal_dedup_30min():
"""Test that DHCP renewal from known device (< 30 min old) doesn't send ARRIVED alert."""
cleanup_flap_state()
net_alerter.known_devices.clear()
net_alerter.departure_timers.clear()
alert_calls = []
original_send_alert = net_alerter.send_alert
@@ -219,32 +220,29 @@ def test_dhcp_renewal_dedup_30min():
mac = "aa:bb:cc:dd:ee:ff"
ip = "10.0.0.0"
# Device already known and seen < 30 min ago
now = time.time()
net_alerter.known_devices[mac] = {
"ip": ip,
"hostname": "testhost",
"vendor": "Test",
"first_seen": now - 600, # 10 min ago
"last_seen": now - 100, # 100 sec ago
"first_seen": now - 600,
"last_seen": now - 100,
}
# DHCP renewal (arrival)
net_alerter.on_arrival(mac, ip, "testhost")
# Should NOT have sent alert (last_seen within 30 min)
assert len(alert_calls) == 0, f"DHCP renewal < 30 min should be deduped, but got: {alert_calls}"
# Check that ARRIVED alerts are suppressed (occupancy alerts are allowed)
arrived_alerts = [a for a in alert_calls if "ARRIVED" in a]
assert len(arrived_alerts) == 0, f"DHCP renewal < 30 min should be deduped, but got: {arrived_alerts}"
finally:
net_alerter.send_alert = original_send_alert
for timer in list(net_alerter.departure_timers.values()):
timer.cancel()
net_alerter.departure_timers.clear()
def test_re_arrival_cancels_departure_timer():
"""
cleanup_flap_state()
Regression test: device departs → timer starts → device re-arrives BEFORE timer fires.
Timer should be cancelled and NO departure alert should be sent.
This tests the exact bug scenario: on_arrival() must cancel any pending timer.
"""
"""Regression test: device departs → timer starts → device re-arrives BEFORE timer fires."""
cleanup_flap_state()
net_alerter.known_devices.clear()
net_alerter.departure_timers.clear()
@@ -258,7 +256,6 @@ def test_re_arrival_cancels_departure_timer():
mac = "aa:bb:cc:dd:ee:ff"
ip = "10.0.0.0"
# Device exists in known_devices
now = time.time()
net_alerter.known_devices[mac] = {
"ip": ip,
@@ -268,33 +265,21 @@ def test_re_arrival_cancels_departure_timer():
"last_seen": now
}
# Trigger departure (starts 15-min debounce timer)
# At this point: timer created but last_departed_time NOT set yet
net_alerter.on_departure(mac)
# Verify timer was created
assert mac in net_alerter.departure_timers, "Departure timer should be created"
timer_ref = net_alerter.departure_timers[mac]
# Device re-arrives BEFORE timer fires (and BEFORE last_departed_time is set)
# This is the critical bug scenario: on_arrival must cancel the timer
net_alerter.on_arrival(mac, ip, "testhost")
# Timer should be cancelled (either not in dict or marked as cancelled)
assert mac not in net_alerter.departure_timers or not timer_ref.is_alive(), \
"Departure timer should be cancelled after re-arrival"
# NO departure alert should be sent (timer was cancelled before firing)
departure_alerts = [a for a in alert_calls if "DEPARTED" in a]
assert len(departure_alerts) == 0, \
f"No departure alert should be sent when device re-arrives before timer expires, got: {departure_alerts}"
# Re-arrival may or may not trigger ARRIVED alert depending on last_departed_time
# Since last_departed_time was not set (timer didn't fire yet), re-arrival will
# generate a new ARRIVED alert (not suppressed). This is correct behavior.
finally:
# Clean up
for timer in net_alerter.departure_timers.values():
timer.cancel()
net_alerter.departure_timers.clear()
@@ -302,18 +287,7 @@ def test_re_arrival_cancels_departure_timer():
def test_rapid_flap_no_duplicate_arrived_alerts():
"""
Test the specific bug: rapid RTM_NEWNEIGH events on wlan0 flap.
- Device departs (pop removed it from known_devices)
- Kernel rebuilds ARP cache → multiple RTM_NEWNEIGH events
- Each on_arrival() call finds MAC absent → treats as new → sends ARRIVED
Result: 5-10+ duplicate ARRIVED alerts
With the fix:
- on_departure marks device with departing=True instead of popping
- on_arrival() checks for departing flag and silently cancels timer
- No duplicate ARRIVED alerts
"""
"""Test rapid RTM_NEWNEIGH events don't generate duplicate ARRIVED alerts."""
cleanup_flap_state()
net_alerter.known_devices.clear()
net_alerter.departure_timers.clear()
@@ -327,7 +301,6 @@ def test_rapid_flap_no_duplicate_arrived_alerts():
mac = "aa:bb:cc:dd:ee:ff"
ip = "10.0.0.0"
# Device exists and is already known (initial arrival)
now = time.time()
net_alerter.known_devices[mac] = {
"ip": ip,
@@ -337,33 +310,191 @@ def test_rapid_flap_no_duplicate_arrived_alerts():
"last_seen": now
}
# Simulate initial arrival alert (already happened)
alert_calls.clear() # Reset to track only departure/re-arrival alerts
alert_calls.clear()
# Device departs (wlan0 goes down)
net_alerter.on_departure(mac)
# No alert yet (15 min debounce)
assert len([a for a in alert_calls if "DEPARTED" in a]) == 0
# wlan0 recovers, kernel rebuilds ARP cache → RTM_NEWNEIGH fires 5 times
# This should NOT generate 5 ARRIVED alerts
for i in range(5):
net_alerter.on_arrival(mac, ip, "testhost")
# Count ARRIVED alerts
arrived_alerts = [a for a in alert_calls if "ARRIVED" in a]
assert len(arrived_alerts) == 0, \
f"Rapid re-arrivals should not generate duplicate ARRIVED alerts, but got {len(arrived_alerts)}: {arrived_alerts}"
finally:
# Clean up
for timer in net_alerter.departure_timers.values():
timer.cancel()
net_alerter.departure_timers.clear()
net_alerter.send_alert = original_send_alert
def test_personal_device_oui_detection():
"""Test that Apple/Samsung/etc. OUI prefixes are detected as personal devices."""
cleanup_flap_state()
net_alerter.personal_devices.clear()
test_cases = [
("88:a2:9e:ff:ff:ff", True),
("28:87:6d:ff:ff:ff", True),
("00:16:6b:ff:ff:ff", True),
("aa:bb:cc:dd:ee:ff", False),
]
for mac, expected_is_personal in test_cases:
result = net_alerter.is_personal_device(mac)
assert result == expected_is_personal, f"Expected {expected_is_personal} for {mac}, got {result}"
def test_manual_personal_mac_config():
"""Test that NET_ALERTER_PERSONAL_MACS env var is parsed and devices are detected."""
cleanup_flap_state()
net_alerter.personal_devices.clear()
import os
original_env = os.environ.get("NET_ALERTER_PERSONAL_MACS")
try:
os.environ["NET_ALERTER_PERSONAL_MACS"] = "AA:BB:CC:DD:EE:FF, 11:22:33:44:55:66"
net_alerter.load_personal_macs_from_env()
assert "AABBCCDDEEFF" in net_alerter.personal_devices
assert "112233445566" in net_alerter.personal_devices
assert net_alerter.is_personal_device("aa:bb:cc:dd:ee:ff")
assert net_alerter.is_personal_device("11:22:33:44:55:66")
finally:
net_alerter.personal_devices.clear()
if original_env is not None:
os.environ["NET_ALERTER_PERSONAL_MACS"] = original_env
else:
os.environ.pop("NET_ALERTER_PERSONAL_MACS", None)
def test_occupancy_vacant_to_occupied():
"""Test that VACANT → OCCUPIED transition fires occupancy alert on personal device arrival."""
cleanup_flap_state()
net_alerter.known_devices.clear()
net_alerter.personal_devices.clear()
net_alerter.location_occupancy = "UNKNOWN"
alert_calls = []
original_send_alert = net_alerter.send_alert
net_alerter.send_alert = lambda msg: alert_calls.append(msg)
try:
net_alerter.location_occupancy = "VACANT"
mac = "88:a2:9e:ff:ff:ff"
ip = "10.0.0.0"
net_alerter.on_arrival(mac, ip, "myphone")
occupancy_alerts = [a for a in alert_calls if "Location:" in a]
assert any("OCCUPIED" in a for a in occupancy_alerts), \
f"Expected OCCUPIED alert on personal device arrival, got: {alert_calls}"
assert net_alerter.location_occupancy == "OCCUPIED"
finally:
net_alerter.send_alert = original_send_alert
def test_occupancy_occupied_to_vacant():
"""Test that OCCUPIED → VACANT transition fires vacancy alert when last personal device departs."""
cleanup_flap_state()
net_alerter.known_devices.clear()
net_alerter.personal_devices.clear()
net_alerter.departure_timers.clear()
net_alerter.location_occupancy = "UNKNOWN"
alert_calls = []
original_send_alert = net_alerter.send_alert
net_alerter.send_alert = lambda msg: alert_calls.append(msg)
try:
mac = "88:a2:9e:ff:ff:ff"
ip = "10.0.0.0"
now = time.time()
net_alerter.known_devices[mac] = {
"ip": ip,
"hostname": "myphone",
"vendor": "Apple",
"first_seen": now,
"last_seen": now
}
net_alerter.location_occupancy = "OCCUPIED"
alert_calls.clear()
net_alerter.known_devices.pop(mac, None)
net_alerter.update_occupancy_state()
occupancy_alerts = [a for a in alert_calls if "Location:" in a]
assert any("VACANT" in a for a in occupancy_alerts), \
f"Expected VACANT alert when last personal device departs, got: {alert_calls}"
assert net_alerter.location_occupancy == "VACANT"
finally:
net_alerter.send_alert = original_send_alert
for timer in net_alerter.departure_timers.values():
timer.cancel()
net_alerter.departure_timers.clear()
def test_occupancy_multiple_personal_devices():
"""Test that VACANT only when ALL personal devices are gone (not just one)."""
cleanup_flap_state()
net_alerter.known_devices.clear()
net_alerter.personal_devices.clear()
net_alerter.location_occupancy = "UNKNOWN"
alert_calls = []
original_send_alert = net_alerter.send_alert
net_alerter.send_alert = lambda msg: alert_calls.append(msg)
try:
mac1 = "88:a2:9e:ff:ff:ff"
mac2 = "28:87:6d:ff:ff:ff"
now = time.time()
net_alerter.location_occupancy = "VACANT"
alert_calls.clear()
net_alerter.on_arrival(mac1, "10.0.0.0", "phone1")
occupancy_alerts = [a for a in alert_calls if "Location:" in a]
assert any("OCCUPIED" in a for a in occupancy_alerts), "Should be OCCUPIED after first device"
assert net_alerter.location_occupancy == "OCCUPIED"
alert_calls.clear()
net_alerter.on_arrival(mac2, "10.0.0.0", "phone2")
occupancy_alerts = [a for a in alert_calls if "Location:" in a]
assert len(occupancy_alerts) == 0, "Should not send occupancy alert when already OCCUPIED"
assert net_alerter.location_occupancy == "OCCUPIED"
alert_calls.clear()
net_alerter.on_departure(mac1)
net_alerter.known_devices[mac1]['departing'] = True
net_alerter.update_occupancy_state()
occupancy_alerts = [a for a in alert_calls if "Location:" in a]
assert len(occupancy_alerts) == 0, "Should stay OCCUPIED when one device still present"
alert_calls.clear()
net_alerter.known_devices.pop(mac1, None)
net_alerter.known_devices.pop(mac2, None)
net_alerter.update_occupancy_state()
occupancy_alerts = [a for a in alert_calls if "Location:" in a]
assert any("VACANT" in a for a in occupancy_alerts), "Should be VACANT when all devices gone"
assert net_alerter.location_occupancy == "VACANT"
finally:
net_alerter.send_alert = original_send_alert
for timer in net_alerter.departure_timers.values():
timer.cancel()
net_alerter.departure_timers.clear()
if __name__ == "__main__":
test_hostname_dedup_when_hostname_equals_ip()
print("✓ test_hostname_dedup_when_hostname_equals_ip")
@@ -398,4 +529,19 @@ if __name__ == "__main__":
test_rapid_flap_no_duplicate_arrived_alerts()
print("✓ test_rapid_flap_no_duplicate_arrived_alerts")
test_personal_device_oui_detection()
print("✓ test_personal_device_oui_detection")
test_manual_personal_mac_config()
print("✓ test_manual_personal_mac_config")
test_occupancy_vacant_to_occupied()
print("✓ test_occupancy_vacant_to_occupied")
test_occupancy_occupied_to_vacant()
print("✓ test_occupancy_occupied_to_vacant")
test_occupancy_multiple_personal_devices()
print("✓ test_occupancy_multiple_personal_devices")
print("\nAll tests passed!")