**Refactor FirstAvailable LB**

- Extract shared provider‑acquisition loop into a new `_run_fa` helper. - Add configurable `redis_keys_prefix` argument (default `"fa_"`). - Simplify `FirstAvailableOptimStrategy` to inherit from `FirstAvailableStrategy` and delegate to the new helper with host‑reuse enabled.

Author: Paweł Kędzia

llm_router_api/base/lb/first_available.py

@@ -63,6 +63,7 @@ def __init__(
  check_interval: float = 0.1,
  clear_buffers: bool = True,
  logger: Optional[logging.Logger] = None,
+ redis_keys_prefix: Optional[str] = "fa_",
  ) -> None:
  """
  Initialize the FirstAvailableStrategy.
@@ -96,7 +97,7 @@ def __init__(
  check_interval=check_interval,
  clear_buffers=clear_buffers,
  logger=logger,
- redis_keys_prefix="fa_",
+ redis_keys_prefix=redis_keys_prefix or "fa_",
  )
 
  def get_provider(
@@ -156,41 +157,48 @@ def get_provider(
 
  # self._print_provider_status(redis_key, providers)
 
- start_time = time.time()
+ return self._run_fa(
+ model_name=model_name,
+ redis_key=redis_key,
+ is_random=is_random,
+ set_last_host=False,
+ )
+
+ def _run_fa(
+ self, model_name: str, redis_key: str, is_random: bool, set_last_host: bool
+ ):
+ start = time.time()
  while True:
- _providers = self.monitor.get_providers(
+ active = self.monitor.get_providers(
  model_name=model_name, only_active=True
  )
-
- if not len(_providers):
+ if not active:
+  # No active providers – wait a bit and retry
  time.sleep(self.check_interval)
 
- if time.time() - start_time > self.timeout:
+ if time.time() - start > self.timeout:
  raise TimeoutError(
- f"No available provider found for model '{model_name}' "
- f"within {self.timeout} seconds"
+ f"No available provider for model '{model_name}' after "
+ f"{self.timeout} seconds."
  )
 
  if is_random:
- provider = self._try_acquire_random(
- redis_key=redis_key, providers=_providers
- )
- if provider:
- provider_field = self._provider_field(provider)
- provider["__chosen_field"] = provider_field
- return provider
+ chosen = self._try_acquire_random(redis_key, active)
+ if chosen:
+ # Remember the host that just served the model
+ if set_last_host:
+ host_name = chosen.get("host") or chosen.get("server")
+ if host_name:
+ self._set_last_host(redis_key, host_name)
+ return chosen
  else:
- for provider in _providers:
- provider_field = self._provider_field(provider)
- try:
- ok = int(
- self.lock_manager.acquire_script(
- keys=[redis_key], args=[provider_field]
- )
- )
- if ok == 1:
- provider["__chosen_field"] = provider_field
- return provider
- except Exception:
- pass
+ chosen = self._try_acquire_deterministic(redis_key, active)
+ if chosen:
+ if set_last_host:
+ host_name = chosen.get("host") or chosen.get("server")
+ if host_name:
+ self._set_last_host(redis_key, host_name)
+ return chosen
+
+ # Back‑off before the next attempt
  time.sleep(self.check_interval)

llm_router_api/base/lb/first_available_optim.py

@@ -1,13 +1,61 @@
 from __future__ import annotations
 
-import time
+import logging
 
 from typing import Any, Dict, List, Optional
 
-from llm_router_api.base.lb.redis_strategy_i import RedisBasedStrategyI
+from llm_router_api.base.constants import REDIS_PORT, REDIS_HOST
+from llm_router_api.base.lb.first_available import FirstAvailableStrategy
 
 
-class FirstAvailableOptimStrategy(RedisBasedStrategyI):
+class FirstAvailableOptimStrategy(FirstAvailableStrategy):
+ def __init__(
+ self,
+ models_config_path: str,
+ redis_host: str = REDIS_HOST,
+ redis_port: int = REDIS_PORT,
+ redis_db: int = 0,
+ timeout: int = 60,
+ check_interval: float = 0.1,
+ clear_buffers: bool = True,
+ logger: Optional[logging.Logger] = None,
+ redis_keys_prefix: Optional[str] = "fa_optim_",
+ ) -> None:
+ """
+ Initialize the FirstAvailableStrategy.
+
+ Parameters
+ ----------
+ models_config_path : str
+ Path to the models configuration file.
+ redis_host : str, optional
+ Redis server host. Default is ``"192.168.100.67"``.
+ redis_port : int, optional
+ Redis server port. Default is ``6379``.
+ redis_db : int, optional
+ Redis database number. Default is ``0``.
+ timeout : int, optional
+ Maximum time (in seconds) to wait for an available provider.
+ Default is ``60``.
+ check_interval : float, optional
+ Time to sleep between checks for available providers (in seconds).
+ Default is ``0.1``.
+ clear_buffers:
+ Whether to clear all buffers when starting. Default is ``True``.
+ """
+
+ super().__init__(
+ models_config_path=models_config_path,
+ redis_host=redis_host,
+ redis_port=redis_port,
+ redis_db=redis_db,
+ timeout=timeout,
+ check_interval=check_interval,
+ clear_buffers=clear_buffers,
+ logger=logger,
+ redis_keys_prefix=redis_keys_prefix or "fa_optim_",
+ )
+
  # ------------------------------------------------------------------- #
  # Public API – provider acquisition / release
  # ------------------------------------------------------------------- #
@@ -60,36 +108,9 @@ def get_provider(
  # Host lock failed – release provider lock
  self.lock_manager.release_provider(redis_key, field)
 
- start = time.time()
- while True:
- active = self.monitor.get_providers(
- model_name=model_name, only_active=True
- )
- if not active:
- # No active providers – wait a bit and retry
- time.sleep(self.check_interval)
-
- if time.time() - start > self.timeout:
- raise TimeoutError(
- f"No available provider for model '{model_name}' after "
- f"{self.timeout} seconds."
- )
-
- if is_random:
- chosen = self._try_acquire_random(redis_key, active)
- if chosen:
- # Remember the host that just served the model
- host_name = chosen.get("host") or chosen.get("server")
- if host_name:
- self._set_last_host(redis_key, host_name)
- return chosen
- else:
- chosen = self._try_acquire_deterministic(redis_key, active)
- if chosen:
- host_name = chosen.get("host") or chosen.get("server")
- if host_name:
- self._set_last_host(redis_key, host_name)
- return chosen
-
- # Back‑off before the next attempt
- time.sleep(self.check_interval)
+ return self._run_fa(
+ model_name=model_name,
+ redis_key=redis_key,
+ is_random=is_random,
+ set_last_host=True,
+ )