feat: support no-planner mode in PressureReconciler and rewire http_server

PressureReconciler now accepts planner_client=None. When no planner is
configured, the create loop sets _last_pressure to min_pressure and
blocks, while the reconcile loop maintains runners via timer-based
reconciliation using the static min_pressure value.

http_server endpoints now use RunnerManager directly instead of the
legacy RunnerScaler, building it once at startup rather than per-request.
The /runner/check response maintains backward compatibility with the
existing RunnerInfo JSON shape consumed by manager_client.py.

build_runner_manager is now public for use by both the http_server and
other callers that need a RunnerManager from ApplicationConfiguration.

Author: cbartz

docs/changelog.md

@@ -2,6 +2,11 @@
 
 This changelog documents user-relevant changes to the GitHub runner charm.
 
+## 2026-03-18
+
+- PressureReconciler now supports no-planner mode: when no planner relation is configured, it uses `base-virtual-machines` as static pressure to maintain the configured minimum runner count.
+- HTTP server endpoints (`/runner/check`, `/runner/flush`) now use `RunnerManager` directly instead of the legacy `RunnerScaler`.
+
 ## 2026-03-17
 
 - Pause pressure reconciler create loop after zero-create attempts until the next reconcile run re-syncs state and re-enables creation, reducing repeated retries during OpenStack quota and similar create failures.

github-runner-manager/pyproject.toml

@@ -3,7 +3,7 @@
 
 [project]
 name = "github-runner-manager"
-version = "0.15.1"
+version = "0.16.0"
 authors = [
     { name = "Canonical IS DevOps", email = "is-devops-team@canonical.com" },
 ]

github-runner-manager/src/github_runner_manager/cli.py

@@ -20,6 +20,7 @@
 from github_runner_manager.manager.pressure_reconciler import (
     PressureReconciler,
     build_pressure_reconciler,
+    build_runner_manager,
 )
 from github_runner_manager.reconcile_service import start_reconcile_service
 from github_runner_manager.thread_manager import ThreadManager
@@ -128,10 +129,13 @@ def main(  # pylint: disable=too-many-arguments, too-many-positional-arguments
     config = ApplicationConfiguration.from_yaml_file(StringIO(config_file.read()))
     lock = Lock()
 
+    combinations = config.non_reactive_configuration.combinations
+    runner_manager = build_runner_manager(config, combinations[0])
+
     thread_manager = ThreadManager()
     http_server_args = FlaskArgs(host=host, port=port, debug=debug)
     thread_manager.add_thread(
-        target=partial(start_http_server, config, lock, http_server_args),
+        target=partial(start_http_server, runner_manager, lock, http_server_args),
         daemon=True,
     )
 

github-runner-manager/src/github_runner_manager/http_server.py

@@ -1,26 +1,21 @@
 #  Copyright 2026 Canonical Ltd.
 #  See LICENSE file for licensing details.
 
-"""The HTTP server for github-runner-manager.
+"""The HTTP server for github-runner-manager."""
 
-The HTTP server for request to the github-runner-manager.
-"""
-
-import dataclasses
 import json
 from dataclasses import dataclass
 from threading import Lock
 
 from flask import Flask, request
 from prometheus_client import generate_latest
 
-from github_runner_manager.configuration import ApplicationConfiguration
 from github_runner_manager.errors import CloudError, LockError
-from github_runner_manager.manager.runner_manager import FlushMode
-from github_runner_manager.reconcile_service import get_runner_scaler
+from github_runner_manager.manager.runner_manager import FlushMode, RunnerManager
+from github_runner_manager.platform.platform_provider import PlatformRunnerState
 
 APP_CONFIG_NAME = "app_config"
-OPENSTACK_CONFIG_NAME = "openstack_config"
+RUNNER_MANAGER_CONFIG_NAME = "runner_manager"
 
 app = Flask(__name__)
 
@@ -45,15 +40,43 @@ def check_runner() -> tuple[str, int]:
     Returns:
         Information on the runners in JSON format.
     """
-    app_config: ApplicationConfiguration = app.config[APP_CONFIG_NAME]
+    runner_manager: RunnerManager = app.config[RUNNER_MANAGER_CONFIG_NAME]
     app.logger.info("Checking runners...")
-    runner_scaler = get_runner_scaler(app_config)
     try:
-        runner_info = runner_scaler.get_runner_info()
+        runners = runner_manager.get_runners()
     except CloudError as err:
         app.logger.exception("Cloud error encountered while getting runner info")
         return (str(err), 500)
-    return (json.dumps(dataclasses.asdict(runner_info)), 200)
+
+    online = 0
+    busy = 0
+    offline = 0
+    unknown = 0
+    runner_names: list[str] = []
+    busy_runner_names: list[str] = []
+    for r in runners:
+        if r.platform_state == PlatformRunnerState.BUSY:
+            busy += 1
+            online += 1
+            runner_names.append(r.name)
+            busy_runner_names.append(r.name)
+        elif r.platform_state == PlatformRunnerState.IDLE:
+            online += 1
+            runner_names.append(r.name)
+        elif r.platform_state == PlatformRunnerState.OFFLINE:
+            offline += 1
+        else:
+            unknown += 1
+
+    runner_info = {
+        "online": online,
+        "busy": busy,
+        "offline": offline,
+        "unknown": unknown,
+        "runners": runner_names,
+        "busy_runners": busy_runner_names,
+    }
+    return (json.dumps(runner_info), 200)
 
 
 @app.route("/runner/flush", methods=["POST"])
@@ -66,7 +89,7 @@ def flush_runner() -> tuple[str, int]:
     Returns:
         A empty response.
     """
-    app_config = app.config[APP_CONFIG_NAME]
+    runner_manager: RunnerManager = app.config[RUNNER_MANAGER_CONFIG_NAME]
 
     flush_busy_str = request.args.get("flush-busy")
     flush_busy = False
@@ -76,15 +99,13 @@ def flush_runner() -> tuple[str, int]:
     lock = _get_lock()
     with lock:
         app.logger.info("Flushing runners...")
-        runner_scaler = get_runner_scaler(app_config)
         app.logger.info("Flushing busy: %s", flush_busy)
         flush_mode = FlushMode.FLUSH_BUSY if flush_busy else FlushMode.FLUSH_IDLE
         try:
-            num_flushed = runner_scaler.flush(flush_mode)
+            runner_manager.flush_runners(flush_mode)
         except CloudError as err:
             app.logger.exception("Cloud error encountered while flushing runners")
             return (str(err), 500)
-        app.logger.info("Flushed %s runners", num_flushed)
     return ("", 204)
 
 
@@ -130,22 +151,22 @@ class FlaskArgs:
 
 
 def start_http_server(
-    app_config: ApplicationConfiguration,
+    runner_manager: RunnerManager,
     lock: Lock,
     flask_args: FlaskArgs,
 ) -> None:
     """Start the HTTP server for interacting with the github-runner-manager service.
 
     Args:
-        app_config: The application configuration.
+        runner_manager: The runner manager for managing runners.
         lock: The lock representing modification access to the managed set of runners.
         flask_args: The arguments for the flask HTTP server.
     """
     app.logger.info("Starting the server...")
     # The lock is passed from the caller, hence the need to update the global variable.
     global _lock  # pylint: disable=global-statement
     _lock = lock
-    app.config[APP_CONFIG_NAME] = app_config
+    app.config[RUNNER_MANAGER_CONFIG_NAME] = runner_manager
     app.run(
         host=flask_args.host,
         port=flask_args.port,

github-runner-manager/src/github_runner_manager/manager/pressure_reconciler.py

@@ -112,7 +112,7 @@ class PressureReconciler:  # pylint: disable=too-few-public-methods,too-many-ins
     def __init__(
         self,
         manager: RunnerManager,
-        planner_client: PlannerClient,
+        planner_client: PlannerClient | None,
         config: PressureReconcilerConfig,
         lock: Lock,
     ) -> None:
@@ -122,6 +122,7 @@ def __init__(
             manager: Runner manager interface for creating, cleaning up,
                 and listing runners.
             planner_client: Client used to stream pressure updates.
+                None when no planner relation is configured.
             config: Reconciler configuration.
             lock: Shared lock to serialize operations with other reconcile loops.
         """
@@ -140,6 +141,14 @@ def start_create_loop(self) -> None:
         with self._lock:
             self._runner_count = len(self._manager.get_runners())
         logger.info("Create loop: initial sync, _runner_count=%s", self._runner_count)
+        if self._planner is None:
+            self._last_pressure = self._config.min_pressure
+            logger.info(
+                "Create loop: no planner configured, using min_pressure=%s",
+                self._config.min_pressure,
+            )
+            self._stop.wait()
+            return
         while not self._stop.is_set():
             try:
                 for update in self._planner.stream_pressure(self._config.flavor_name):
@@ -413,12 +422,15 @@ def build_pressure_reconciler(config: ApplicationConfiguration, lock: Lock) -> P
             "Cannot build PressureReconciler: no non-reactive combinations configured."
         )
     first = combinations[0]
-    manager = _build_runner_manager(config, first)
+    manager = build_runner_manager(config, first)
+    planner_client: PlannerClient | None = None
+    if config.planner_url and config.planner_token:
+        planner_client = PlannerClient(
+            PlannerConfiguration(base_url=config.planner_url, token=config.planner_token)
+        )
     return PressureReconciler(
         manager=manager,
-        planner_client=PlannerClient(
-            PlannerConfiguration(base_url=config.planner_url, token=config.planner_token)
-        ),
+        planner_client=planner_client,
         config=PressureReconcilerConfig(
             flavor_name=config.name,
             reconcile_interval=config.reconcile_interval,
@@ -429,7 +441,7 @@ def build_pressure_reconciler(config: ApplicationConfiguration, lock: Lock) -> P
     )
 
 
-def _build_runner_manager(
+def build_runner_manager(
     config: ApplicationConfiguration, combination: NonReactiveCombination
 ) -> RunnerManager:
     """Build a RunnerManager from application config and a flavor/image combination.

github-runner-manager/tests/unit/manager/test_pressure_reconciler.py

@@ -489,3 +489,81 @@ def test_timer_reconcile_emits_reconciliation_metric(monkeypatch: pytest.MonkeyP
     assert event.idle_runners == 2  # IDLE + OFFLINE+HEALTHY
     assert event.active_runners == 1
     assert event.crashed_runners == 0
+
+
+def test_create_loop_no_planner_sets_min_pressure_and_blocks(monkeypatch: pytest.MonkeyPatch):
+    """
+    arrange: A reconciler with no planner client and min_pressure=3.
+    act: Call start_create_loop.
+    assert: _last_pressure is set to min_pressure, _runner_count is synced, and stop is awaited.
+    """
+    mgr = _FakeManager(runners_count=1)
+    cfg = PressureReconcilerConfig(flavor_name="small", min_pressure=3)
+    reconciler = PressureReconciler(mgr, planner_client=None, config=cfg, lock=Lock())
+
+    wait_called = {"called": False}
+
+    def _stop_immediately() -> None:
+        """Record that wait was called, then stop."""
+        wait_called["called"] = True
+        return None
+
+    monkeypatch.setattr(reconciler._stop, "wait", lambda: _stop_immediately())
+    reconciler.start_create_loop()
+
+    assert reconciler._runner_count == 1
+    assert reconciler._last_pressure == 3
+    assert wait_called["called"]
+
+
+def test_reconcile_loop_no_planner_uses_min_pressure(monkeypatch: pytest.MonkeyPatch):
+    """
+    arrange: A reconciler with no planner, min_pressure=4, and 2 existing runners.
+    act: Run the reconcile loop once.
+    assert: Timer reconcile uses min_pressure and creates runners to reach it.
+    """
+    mgr = _FakeManager(runners_count=2)
+    cfg = PressureReconcilerConfig(flavor_name="small", min_pressure=4, reconcile_interval=60)
+    reconciler = PressureReconciler(mgr, planner_client=None, config=cfg, lock=Lock())
+    reconciler._last_pressure = 4
+    wait_calls = {"count": 0}
+
+    def _wait(_interval: int) -> bool:
+        """Return False once to enter the loop, then True to exit."""
+        wait_calls["count"] += 1
+        return wait_calls["count"] > 1
+
+    monkeypatch.setattr(reconciler._stop, "wait", _wait)
+    reconciler.start_reconcile_loop()
+
+    assert mgr.cleanup_called == 1
+    assert mgr.created_args == [2]
+
+
+def test_build_pressure_reconciler_no_planner_config(monkeypatch: pytest.MonkeyPatch):
+    """
+    arrange: An ApplicationConfiguration with planner_url=None and planner_token=None.
+    act: Call build_pressure_reconciler.
+    assert: A PressureReconciler is returned with _planner set to None.
+    """
+    from unittest.mock import MagicMock, patch
+
+    from github_runner_manager.manager.pressure_reconciler import build_pressure_reconciler
+
+    mock_config = MagicMock()
+    mock_config.planner_url = None
+    mock_config.planner_token = None
+    mock_config.name = "test"
+    mock_config.reconcile_interval = 5
+    combination = MagicMock()
+    combination.base_virtual_machines = 2
+    combination.max_total_virtual_machines = 10
+    mock_config.non_reactive_configuration.combinations = [combination]
+
+    with patch(
+        "github_runner_manager.manager.pressure_reconciler.build_runner_manager"
+    ) as mock_build:
+        mock_build.return_value = MagicMock()
+        reconciler = build_pressure_reconciler(mock_config, Lock())
+
+    assert reconciler._planner is None