Struct LighthouseEngine

pub struct LighthouseEngine {
    config: Arc<RwLock<LighthouseConfig>>,
    callbacks: LighthouseCallbacks,
    command_tx: UnboundedSender<EngineCommand>,
    command_rx: Option<UnboundedReceiver<EngineCommand>>,
    status: Arc<RwLock<EngineStatus>>,
    metrics_cache: Arc<RwLock<HashMap<ResourceId, ResourceMetrics>>>,
    cooldown_tracker: Arc<RwLock<CooldownTracker>>,
}

The main lighthouse autoscaling engine

Fields

config: Arc<RwLock<LighthouseConfig>>

callbacks: LighthouseCallbacks

command_tx: UnboundedSender<EngineCommand>

command_rx: Option<UnboundedReceiver<EngineCommand>>

status: Arc<RwLock<EngineStatus>>

metrics_cache: Arc<RwLock<HashMap<ResourceId, ResourceMetrics>>>

cooldown_tracker: Arc<RwLock<CooldownTracker>>

Implementations

impl LighthouseEngine

pub fn new(config: LighthouseConfig, callbacks: LighthouseCallbacks) -> Self

Create a new lighthouse engine

pub fn handle(&self) -> LighthouseHandle

Get a handle to send commands to the engine

pub async fn start(self) -> LighthouseResult<()>

Start the lighthouse engine (consumes self)

async fn handle_command(&self, command: EngineCommand) -> LighthouseResult<()>

Handle incoming commands

async fn update_metrics(&self, metrics: ResourceMetrics) -> LighthouseResult<()>

Update metrics for a resource

async fn update_config( &self, new_config: LighthouseConfig, ) -> LighthouseResult<()>

Update the engine configuration

async fn get_recommendation( &self, resource_id: &ResourceId, ) -> LighthouseResult<Option<ScaleAction>>

Get scaling recommendation for a specific resource

async fn evaluate_policy( &self, metrics: &ResourceMetrics, policy: &ScalingPolicy, ) -> LighthouseResult<Option<ScaleAction>>

Evaluate a scaling policy against metrics

async fn evaluate_all_resources(&self) -> LighthouseResult<()>

Evaluate all resources and execute scaling actions

async fn execute_scaling_action( &self, action: ScaleAction, ) -> LighthouseResult<()>

Execute a scaling action