Stop trying to cache mac addresses from house and cabin in the same

[python_utils.git] / arper.py

diff --git a/arper.py b/arper.py
index bdd97ac2c93b8109fcfb187f5bc7b455fad7a009..3b308ca038ad405d1d37671f4c558343d84e4593 100644 (file)
--- a/arper.py
+++ b/arper.py
@@ -28,10 +28,16 @@ cfg = config.add_commandline_args(
 )
 cfg.add_argument(
     '--arper_cache_location',
-    default=f'{os.environ["HOME"]}/cache/.arp_table_cache',
+    default=site_config.get_config().arper_cache_file,
     metavar='FILENAME',
     help='Where to cache the kernel ARP table',
 )
+cfg.add_argument(
+    '--arper_supplimental_cache_location',
+    default=site_config.get_config(site_config.other_location()).arper_cache_file,
+    metavar='FILENAME',
+    help='Where someone else is caching the kernel ARP table',
+)
 cfg.add_argument(
     '--arper_cache_max_staleness',
     type=argparse_utils.valid_duration,
@@ -49,17 +55,27 @@ cfg.add_argument(
 
 @persistent.persistent_autoloaded_singleton()  # type: ignore
 class Arper(persistent.Persistent):
-    def __init__(self, cached_state: Optional[BiDict] = None) -> None:
+    def __init__(
+        self,
+        cached_local_state: Optional[BiDict] = None,
+        cached_supplimental_state: Optional[BiDict] = None,
+    ) -> None:
         self.state = BiDict()
-        if cached_state is not None:
-            logger.debug('Loading Arper map from cached state.')
-            self.state = cached_state
+        if cached_local_state is not None:
+            logger.debug('Loading Arper map from cached local state.')
+            self.state = cached_local_state
         else:
             logger.debug('No usable cached state; calling /usr/sbin/arp')
             self.update_from_arp_scan()
             self.update_from_arp()
         if len(self.state) < config.config['arper_min_entries_to_be_valid']:
             raise Exception(f'Arper didn\'t find enough entries; only got {len(self.state)}.')
+        if cached_supplimental_state is not None:
+            logger.debug(f'Also added {len(cached_supplimental_state)} supplimental entries.')
+            for mac, ip in cached_supplimental_state.items():
+                self.state[mac] = ip
+        for mac, ip in self.state.items():
+            logger.debug(f'{mac} <-> {ip}')
 
     def update_from_arp_scan(self):
         network_spec = site_config.get_config().network
@@ -101,15 +117,16 @@ class Arper(persistent.Persistent):
         return self.state.inverse.get(ip, None)
 
     @classmethod
-    @overrides
-    def load(cls) -> Any:
-        cache_file = config.config['arper_cache_location']
+    def load_state(cls, cache_file: str, freshness_threshold_sec: int, state: BiDict):
+        if not file_utils.file_is_readable(cache_file):
+            logger.debug(f'Can\'t read {cache_file}')
+            return None
         if persistent.was_file_written_within_n_seconds(
             cache_file,
-            config.config['arper_cache_max_staleness'].total_seconds(),
+            freshness_threshold_sec,
         ):
             logger.debug(f'Loading state from {cache_file}')
-            cached_state = BiDict()
+            count = 0
             with open(cache_file, 'r') as rf:
                 contents = rf.readlines()
                 for line in contents:
@@ -119,15 +136,38 @@ class Arper(persistent.Persistent):
                     mac = mac.strip()
                     mac = mac.lower()
                     ip = ip.strip()
-                    cached_state[mac] = ip
-            if len(cached_state) > config.config['arper_min_entries_to_be_valid']:
-                return cls(cached_state)
-            else:
-                msg = f'{cache_file} is invalid: only {len(cached_state)} entries.  Deleting it.'
-                logger.warning(msg)
-                warnings.warn(msg, stacklevel=2)
+                    state[mac] = ip
+                    count += 1
+        else:
+            logger.debug(f'{cache_file} is too stale.')
+
+    @classmethod
+    @overrides
+    def load(cls) -> Any:
+        local_state = BiDict()
+        cache_file = config.config['arper_cache_location']
+        max_staleness = config.config['arper_cache_max_staleness'].total_seconds()
+        logger.debug(f'Trying to load main arper cache from {cache_file}...')
+        cls.load_state(cache_file, max_staleness, local_state)
+        if len(local_state) <= config.config['arper_min_entries_to_be_valid']:
+            msg = f'{cache_file} is invalid: only {len(local_state)} entries.  Deleting it.'
+            logger.warning(msg)
+            warnings.warn(msg, stacklevel=2)
+            try:
                 os.remove(cache_file)
-        logger.debug('No usable saved state found')
+            except Exception:
+                pass
+
+        supplimental_state = BiDict()
+        cache_file = config.config['arper_supplimental_cache_location']
+        max_staleness = config.config['arper_cache_max_staleness'].total_seconds()
+        logger.debug(f'Trying to suppliment arper state from {cache_file}...')
+        cls.load_state(cache_file, max_staleness, supplimental_state)
+        if len(supplimental_state) == 0:
+            supplimental_state = None
+
+        if len(local_state) > 0:
+            return cls(local_state, supplimental_state)
         return None
 
     @overrides