Merge pull request #1 from AS213151:upstream-prs/357-354-347-344

cherry-pick upstream PRs thatmattlove#357, thatmattlove#354, thatmattlove#347, thatmattlove#344

Author: chriselsen

hyperglass/execution/drivers/ssh_netmiko.py

@@ -52,7 +52,10 @@ async def collect(self, host: str = None, port: int = None) -> Iterable:
 
         global_args = netmiko_device_globals.get(self.device.platform, {})
 
-        send_args = netmiko_device_send_args.get(self.device.platform, {})
+        send_args = {
+            "read_timeout": params.request_timeout,
+            **netmiko_device_send_args.get(self.device.platform, {}),
+        }
 
         driver_kwargs = {
             "host": host or self.device._target,

hyperglass/main.py

@@ -28,7 +28,6 @@
 
 
 # Local
-from .util import cpu_count
 from .state import use_state
 from .settings import Settings
 
@@ -151,13 +150,7 @@ def run(workers: int = None):
                 host=state.params.logging.syslog.host,
                 port=state.params.logging.syslog.port,
             )
-        _workers = workers
-
-        if workers is None:
-            if Settings.debug:
-                _workers = 1
-            else:
-                _workers = cpu_count(2)
+        _workers = workers if workers is not None else Settings.workers
 
         log.bind(
             version=__version__,

hyperglass/models/parsing/arista_eos.py

@@ -130,7 +130,7 @@ def bgp_table(self: "AristaBGPTable") -> "BGPRouteTable":
                 # block. Therefore, we must verify it exists before including its data.
                 communities = []
                 if route.route_detail is not None:
-                    communities = route.route_detail.community_list
+                    communities = route.route_detail.community_list + route.route_detail.large_community_list
 
                 # iBGP paths contain an empty AS_PATH array. If the AS_PATH is empty, we
                 # set the source_as to the router's local-as.

hyperglass/models/parsing/frr.py

@@ -31,9 +31,9 @@ class FRRNextHop(_FRRBase):
 
     ip: str
     afi: str
-    metric: int
+    metric: int = 0
     accessible: bool
-    used: bool
+    used: bool = False
 
 
 class FRRPeer(_FRRBase):
@@ -65,7 +65,12 @@ class FRRPath(_FRRBase):
     def validate_path(cls, values):
         """Extract meaningful data from FRR response."""
         new = values.copy()
-        new["aspath"] = values["aspath"]["segments"][0]["list"]
+        # Local prefixes (i.e. those in the same ASN) usually have
+        # no AS_PATH. Set AS_PATH to AS0 for now.
+        if values["aspath"]["length"] != 0:
+            new["aspath"] = values["aspath"]["segments"][0]["list"]
+        else:
+            new["aspath"] = [0]
         community = values.get("community", {"list": []})
         new["community"] = community["list"]
         new["lastUpdate"] = values["lastUpdate"]["epoch"]

hyperglass/models/system.py

@@ -50,6 +50,7 @@ class HyperglassSettings(BaseSettings):
     port: int = 8001
     ca_cert: t.Optional[FilePath] = None
     container: bool = False
+    workers: t.Optional[int] = None
 
     def __init__(self, **kwargs) -> None:
         """Create hyperglass Settings instance."""
@@ -78,6 +79,7 @@ def __rich_console__(self, console: "Console", options: "ConsoleOptions") -> "Re
                 "redis_dsn",
                 "host",
                 "port",
+                "workers",
             )
         )
         for attr in params:
@@ -135,12 +137,22 @@ def log_level(self: "HyperglassSettings") -> str:
             return "DEBUG"
         return "WARNING"
 
-    @property
-    def workers(self: "HyperglassSettings") -> int:
-        """Get worker count, inferred from debug mode."""
-        if self.debug:
+    @field_validator("workers", mode="after")
+    def validate_workers(
+        cls: "HyperglassSettings", value: t.Optional[int], info: ValidationInfo
+    ) -> int:
+        """Resolve worker count.
+
+        Precedence: explicit override (``HYPERGLASS_WORKERS`` / kwarg) > debug
+        mode (1) > auto-detected ``cpu_count(2)`` capped at 8.
+        """
+        if value is not None:
+            if value < 1:
+                raise ValueError("workers must be at least 1")
+            return value
+        if info.data.get("debug") is True:
             return 1
-        return cpu_count(2)
+        return min(cpu_count(2), 8)
 
     @property
     def redis(self: "HyperglassSettings") -> t.Dict[str, t.Union[None, int, str]]:
@@ -158,7 +170,7 @@ def redis(self: "HyperglassSettings") -> t.Dict[str, t.Union[None, int, str]]:
     @property
     def redis_connection_pool(self: "HyperglassSettings") -> t.Dict[str, t.Any]:
         """Get Redis ConnectionPool keyword arguments."""
-        return {"url": str(self.redis_dsn), "max_connections": at_least(8, cpu_count(2))}
+        return {"url": str(self.redis_dsn), "max_connections": at_least(8, self.workers)}
 
     @property
     def dev_url(self: "HyperglassSettings") -> str:

hyperglass/plugins/_builtin/bgp_route_frr.py

@@ -36,6 +36,10 @@ def parse_frr(output: t.Sequence[str]) -> "OutputDataModel":
 
             _log.debug("Pre-parsed data", data=parsed)
 
+            # If empty (i.e. no route found), skip
+            if not parsed:
+                continue
+
             validated = FRRBGPTable(**parsed)
             bgp_table = validated.bgp_table()
 

hyperglass/util/system_info.py

@@ -60,15 +60,35 @@ def get_node_version() -> t.Tuple[int, int, int]:
     return tuple((int(v) for v in version.split(".")))
 
 
-def cpu_count(multiplier: int = 0) -> int:
-    """Get server's CPU core count.
+def cpu_count(multiplier: int = 1) -> int:
+    """Get the process-allowed CPU core count.
 
-    Used to determine the number of web server workers.
+    Prefers cgroup- and affinity-aware APIs so deployments inside
+    containers or under cpuset constraints see the real allowed CPU
+    count rather than the host's logical core count.
     """
-    # Standard Library
-    import multiprocessing
+    n: t.Optional[int] = None
+
+    # Python 3.13+: respects cgroup cpu.max and sched_getaffinity.
+    process_cpu_count = getattr(os, "process_cpu_count", None)
+    if callable(process_cpu_count):
+        n = process_cpu_count()
+
+    # Fallback for Python 3.12 and earlier on Linux.
+    if n is None and hasattr(os, "sched_getaffinity"):
+        try:
+            n = len(os.sched_getaffinity(0))
+        except OSError:
+            pass
+
+    # Final fallback for non-Linux platforms.
+    if n is None:
+        # Standard Library
+        import multiprocessing
+
+        n = multiprocessing.cpu_count()
 
-    return multiprocessing.cpu_count() * multiplier
+    return max(n * multiplier, 1)
 
 
 def check_python() -> str:

hyperglass/util/tests/test_system_info.py

@@ -0,0 +1,49 @@
+"""Tests for cgroup/affinity-aware system info utilities."""
+
+# Standard Library
+import os
+
+# Third Party
+import pytest
+
+# Local
+from ..system_info import cpu_count
+
+
+def test_cpu_count_default_multiplier_returns_at_least_one():
+    """cpu_count() with no args returns >=1 on any platform."""
+    assert cpu_count() >= 1
+
+
+def test_cpu_count_multiplier_scales():
+    """cpu_count(N) scales the detected count."""
+    base = cpu_count()
+    assert cpu_count(2) == base * 2
+
+
+def test_cpu_count_floor_is_one():
+    """cpu_count(0) returns at least 1, never 0."""
+    assert cpu_count(0) == 1
+
+
+@pytest.mark.skipif(
+    not hasattr(os, "sched_getaffinity"),
+    reason="sched_getaffinity is Linux-only",
+)
+def test_cpu_count_respects_sched_getaffinity(monkeypatch):
+    """When process_cpu_count is unavailable, falls back to sched_getaffinity."""
+    monkeypatch.delattr(os, "process_cpu_count", raising=False)
+    monkeypatch.setattr(os, "sched_getaffinity", lambda _pid: {0, 1, 2})
+    assert cpu_count() == 3
+
+
+def test_cpu_count_falls_back_to_multiprocessing(monkeypatch):
+    """When neither cgroup-aware API works, falls back to multiprocessing."""
+    monkeypatch.delattr(os, "process_cpu_count", raising=False)
+    monkeypatch.delattr(os, "sched_getaffinity", raising=False)
+
+    # Standard Library
+    import multiprocessing
+
+    monkeypatch.setattr(multiprocessing, "cpu_count", lambda: 7)
+    assert cpu_count() == 7