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.

Implementations

impl AutoscaleController

pub fn new( service_manager: Arc<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
• interval - How often to evaluate scaling decisions

Example

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

pub fn with_custom_metrics( service_manager: Arc<ServiceManager>, metrics: MetricsCollector, interval: Duration, ) -> Self

Create with a custom metrics collector (useful for testing)

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.

Arguments

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

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