Struct AutoscaleController 

pub struct AutoscaleController { /* private fields */ }

Controller that connects autoscaling decisions to actual container scaling

The AutoscaleController periodically collects metrics from running containers, evaluates whether scaling is needed using the Autoscaler, and executes scaling decisions through the ServiceManager. On the same tick it runs the scale-to-zero idle reaper and the vertical right-sizing pass.

Implementations

impl AutoscaleController

pub fn new( service_manager: Arc<RwLock<ServiceManager>>, runtime: Arc<dyn Runtime + Send + Sync>, interval: Duration, ) -> Self

Create a new autoscale controller

Arguments

• service_manager - The service manager used to execute scaling operations
• runtime - The container runtime for collecting metrics and applying vertical resource updates
• interval - How often to evaluate scaling decisions

The runtime handle is retained on the controller (for the vertical apply / rolling-restart paths) and moved into the metrics stats provider, so it is cloned once here.

Example

let controller = AutoscaleController::new(
    service_manager,
    runtime,
    Duration::from_secs(10),
);

pub fn with_custom_metrics( service_manager: Arc<RwLock<ServiceManager>>, runtime: Arc<dyn Runtime + Send + Sync>, metrics: MetricsCollector, interval: Duration, ) -> Self

Create with a custom metrics collector (useful for testing).

Requires a runtime handle so the vertical-apply path is still wired in tests; pass a mock runtime when only the horizontal/scale-to-zero paths are under test.

pub fn with_extra_metrics_source(self, source: Arc<dyn MetricsSource>) -> Self

Push an additional MetricsSource into the controller’s collector.

The daemon uses this to feed real requests-per-second from the L7 proxy (wrapped in a zlayer_scheduler::metrics::ProxyRpsMetricsSource) into the same MetricsCollector that drives the horizontal pass, so zlayer_scheduler::metrics::AggregatedMetrics::total_rps is populated and RPS targets / triggers fire on live traffic.

This is a builder method that must be called before the controller is shared (the collector is still uniquely owned at construction time, so the in-place mutation always succeeds). If the collector has already been cloned, the source is dropped with a warning rather than panicking.

pub async fn register_service( &self, name: &str, spec: &ScaleSpec, initial_replicas: u32, )

Register a service for autoscaling

Only services with ScaleSpec::Adaptive will be evaluated for autoscaling. Services with Fixed or Manual scaling are ignored by the autoscaler loop.

Beyond the horizontal registration, this captures the Phase 2 / Phase 3 configuration carried on the adaptive spec: idle_window + min (for scale-to-zero) and vertical (for right-sizing). The service is seeded as freshly-active so a just-registered service is not immediately reaped.

Arguments

• name - Service name
• spec - The service’s scale specification
• initial_replicas - Current number of replicas

pub async fn set_service_template(&self, name: &str, spec: ServiceSpec)

Supply (or refresh) the full base ServiceSpec for a service.

Optional, but required for the vertical-apply rolling restart fallback (update_container_resources → Unsupported): recreating a replica needs its endpoints / env / volumes, which the ScaleSpec alone does not carry. The daemon wires this alongside AutoscaleController::register_service. Without a template, the fallback degrades to a full scale 0 → scale n bounce.

pub fn mark_active(&self, service: &str)

Mark a service as active now, resetting its scale-to-zero idle clock.

Called by the proxy activator when an inbound request wakes (or keeps awake) a service so the idle reaper does not tear it down while it is actively serving traffic. Safe to call for services that are not registered for scale-to-zero — it simply records a timestamp that the idle pass ignores.

pub async fn mark_active_async(&self, service: &str)

Async variant of AutoscaleController::mark_active for callers already inside an async context (avoids the try_write/spawn dance).

pub async fn unregister_service(&self, name: &str)

Unregister a service from autoscaling

pub async fn is_registered(&self, name: &str) -> bool

Check if a service is registered for autoscaling

pub async fn run_loop(&self) -> Result<()>

Run the autoscaling loop

This method should be spawned as a background task. It will continuously evaluate scaling decisions at the configured interval until shutdown is signaled.

Returns

Returns Ok(()) when shutdown is signaled, or an error if something goes wrong.

Example

let controller = Arc::new(AutoscaleController::new(...));
let controller_clone = controller.clone();

// Spawn the autoscale loop
let handle = tokio::spawn(async move {
    controller_clone.run_loop().await
});

// Later, shutdown
controller.shutdown();
handle.await.unwrap();

Errors

Returns an error if the autoscale loop encounters an unrecoverable error.

pub fn shutdown(&self)

Signal shutdown of the autoscale loop

pub fn interval(&self) -> Duration

Get the current evaluation interval

pub async fn registered_service_count(&self) -> usize

Get registered service count