Implement server-side host search in the Livestatus query

CMK-35350

Change-Id: Ia8831abc20635a77d472719954ecaa4c38aebd33

Author: makanakoeln

cmk/gui/monitor/hosts/_api/_list_hosts.py

@@ -127,16 +127,18 @@ def list_hosts(limit: Limit = 1000, sort: Sort = ApiOmitted(), q: Search = "") -
     """List hosts to be consumed by the all host monitoring page."""
     user.need_permission("general.see_all")
 
-    # ``sort`` and ``q`` are validated to expose the parameters in the API spec; applying them is
-    # done by the host handlers and wired up there separately.
+    # ``sort`` is validated to expose the parameter in the API spec; applying it is done by the
+    # host handlers and wired up there separately.
     host_repo = LiveStatusHostRepository(connection=sites.live())
 
-    return _handle_list_hosts(host_repo, limit=limit)
+    return _handle_list_hosts(host_repo, limit=limit, search_query=q)
 
 
-def _handle_list_hosts(host_repo: HostRepository, *, limit: int) -> HostsResponse:
-    hosts = host_repo.fetch(limit=limit)
-    host_total = host_repo.count()
+def _handle_list_hosts(
+    host_repo: HostRepository, *, limit: int, search_query: str = ""
+) -> HostsResponse:
+    hosts = host_repo.fetch(limit=limit, search_query=search_query)
+    host_total = host_repo.count(search_query=search_query)
 
     return HostsResponse(
         hosts=[HostEntry.from_domain(host) for host in hosts],

cmk/gui/monitor/hosts/_impl.py

@@ -13,17 +13,31 @@
 from collections.abc import Sequence
 
 from cmk.livestatus_client import MultiSiteConnection
+from cmk.livestatus_client.expressions import NothingExpression, Or, QueryExpression
 from cmk.livestatus_client.queries import detailed_connection, Query
 from cmk.livestatus_client.tables import Hosts, Status
 
 from ._models import Host, HostState, ServiceCounts
 
+_SEARCHABLE_COLUMNS = (Hosts.name, Hosts.alias, Hosts.address)
+
+
+def _search_filter(search_query: str) -> QueryExpression:
+    """Build an OR-combined case-insensitive "contains" filter over the searchable columns.
+
+    ``search_query`` is expected to be already whitespace-stripped. An empty value yields a no-op
+    filter, so the resulting query is identical to one without a search.
+    """
+    if not search_query:
+        return NothingExpression()
+    return Or(*(column.contains(search_query, ignore_case=True) for column in _SEARCHABLE_COLUMNS))
+
 
 class LiveStatusHostRepository:
     def __init__(self, *, connection: MultiSiteConnection) -> None:
         self._connection = connection
 
-    def fetch(self, *, limit: int) -> Sequence[Host]:
+    def fetch(self, *, limit: int, search_query: str = "") -> Sequence[Host]:
         q = Query(
             [
                 Hosts.name,
@@ -37,6 +51,7 @@ def fetch(self, *, limit: int) -> Sequence[Host]:
                 Hosts.num_services_unknown,
                 Hosts.num_services_pending,
             ],
+            _search_filter(search_query),
             extra_headers=[
                 f"Limit: {limit}",
             ],
@@ -62,8 +77,17 @@ def fetch(self, *, limit: int) -> Sequence[Host]:
                 for row in q.iterate(conn)
             ]
 
-    def count(self) -> int:
-        q = Query([Status.num_hosts])
+    def count(self, *, search_query: str = "") -> int:
+        if not search_query:
+            q = Query([Status.num_hosts])
+            with detailed_connection(self._connection) as conn:
+                return sum(row["num_hosts"] for row in q.iterate(conn))
 
-        with detailed_connection(self._connection) as conn:
-            return sum(row["num_hosts"] for row in q.iterate(conn))
+        # A filtered total can't be read from the ``status`` table. Count the matches server-side
+        # via ``Stats`` instead of transferring and counting every matching row. The ``Query`` class
+        # can't emit ``Stats`` headers yet, so the query is assembled by hand from the shared filter.
+        # The ``Stats`` count is the trailing column of each returned row; summing it across rows
+        # adds up the per-site counts.
+        filter_lines = (": ".join(line) for line in _search_filter(search_query).render())
+        stats_query = "\n".join([f"GET {Hosts.__tablename__}", "Stats: state >= 0", *filter_lines])
+        return sum(int(row[-1]) for row in self._connection.query(stats_query))

cmk/gui/monitor/hosts/_repositories.py

@@ -17,10 +17,18 @@
 
 
 class HostRepository(Protocol):
-    def fetch(self, *, limit: int) -> Sequence[Host]:
-        """Fetch hosts based on filter criteria."""
+    def fetch(self, *, limit: int, search_query: str = "") -> Sequence[Host]:
+        """Fetch hosts based on filter criteria.
+
+        ``search_query`` is an already whitespace-stripped free-text search. When empty, no search
+        filter is applied.
+        """
         ...
 
-    def count(self) -> int:
-        """Count the total number of hosts."""
+    def count(self, *, search_query: str = "") -> int:
+        """Count the hosts matching the given criteria.
+
+        ``search_query`` is an already whitespace-stripped free-text search. When empty, the total
+        number of hosts is returned.
+        """
         ...

tests/openapi/test_openapi_monitor_all_hosts.py

@@ -173,7 +173,6 @@ def test_blank_search_is_treated_as_no_filter(
         assert len(resp.json["hosts"]) == 3
         assert resp.json["meta"]["total"] == 3
 
-    @pytest.mark.xfail(strict=True, reason="server-side host search is wired up in CMK-35350")
     def test_search_filters_hosts_and_total(
         self,
         clients: ClientRegistry,
@@ -187,7 +186,6 @@ def test_search_filters_hosts_and_total(
         assert [host["name"] for host in resp.json["hosts"]] == ["heute"]
         assert resp.json["meta"]["total"] == 1
 
-    @pytest.mark.xfail(strict=True, reason="server-side host search is wired up in CMK-35350")
     def test_search_with_no_matches(
         self,
         clients: ClientRegistry,
@@ -221,7 +219,7 @@ def _setup_search(self, mock_livestatus: MockLiveStatusConnection, *, query: str
         mock_livestatus.expect_query(
             [
                 "GET hosts",
-                "Columns: name",
+                "Stats: state >= 0",
                 *search_filter,
             ]
         )

tests/unit/cmk/gui/monitor/hosts/test_list_hosts.py

@@ -21,11 +21,23 @@ class HostFakeRepository:
         def __init__(self) -> None:
             self._hosts = [HostFactory.build() for _ in range(n_hosts)]
 
-        def fetch(self, *, limit: int) -> Sequence[Host]:
-            return self._hosts[:limit]
-
-        def count(self) -> int:
-            return len(self._hosts)
+        def fetch(self, *, limit: int, search_query: str = "") -> Sequence[Host]:
+            return self._matching(search_query)[:limit]
+
+        def count(self, *, search_query: str = "") -> int:
+            return len(self._matching(search_query))
+
+        def _matching(self, search_query: str) -> list[Host]:
+            if not search_query:
+                return self._hosts
+            needle = search_query.lower()
+            return [
+                host
+                for host in self._hosts
+                if needle in host.name.lower()
+                or needle in host.alias.lower()
+                or needle in host.ip.lower()
+            ]
 
     return HostFakeRepository()
 
@@ -45,3 +57,20 @@ def test_handle_list_hosts_state_label_conversion() -> None:
     host_states = [host.state for host in response.hosts]
 
     assert all(state in {"UP", "DOWN", "UNREACHABLE"} for state in host_states)
+
+
+def test_handle_list_hosts_forwards_search_query_to_repository() -> None:
+    calls: dict[str, str] = {}
+
+    class RecordingRepository:
+        def fetch(self, *, limit: int, search_query: str = "") -> Sequence[Host]:
+            calls["fetch"] = search_query
+            return []
+
+        def count(self, *, search_query: str = "") -> int:
+            calls["count"] = search_query
+            return 0
+
+    _handle_list_hosts(RecordingRepository(), limit=10, search_query="web")
+
+    assert calls == {"fetch": "web", "count": "web"}