Struct LifecycleLauncher 

pub struct LifecycleLauncher { /* private fields */ }

Production implementation of e1’s launcher port.

Implementations

impl LifecycleLauncher

pub fn new( host_id: HostId, app_paths: AppPaths, diagnostics_root: impl Into<PathBuf>, runner_group_id: u64, timeouts: RecoveryTimeouts, retry: RetryPolicy, ports: LifecyclePorts, ) -> Self

pub fn with_preparation_turns(self, turns: Arc<Semaphore>) -> Self

Takes turns to prepare with every launcher holding turns, rather than only with itself: the targets of one host.

pub async fn recover_startup( &self, policies: &[ScalePolicy], ) -> Result<Vec<ReplacementIntent>, LifecycleError>

Reconcile the entire journal before allowing a launch. Unknown-policy attempts are left untouched rather than being acted on without an ownership proof.

pub async fn supervise( &self, policy: &ScalePolicy, ) -> Result<Vec<ReplacementIntent>, LifecycleError>

Supervise all attempts of one policy during an ordinary poll.

Trait Implementations

impl Debug for LifecycleLauncher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl RunnerLauncher for LifecycleLauncher

fn host_capacity<'life0, 'life1, 'async_trait>( &'life0 self, host: &'life1 Host, ) -> Pin<Box<dyn Future<Output = Result<NonZeroU16, HostCapacityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read this host’s current ceiling from the journal, including edits made after daemon startup. An unreadable or missing host is an error, never permission to fall back to the startup ceiling.

fn supervise<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 ScalePolicy, ) -> Pin<Box<dyn Future<Output = Result<Vec<ReplacementIntent>, LaunchFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Reconcile this policy’s existing processes before demand is read and capacity is recomputed. A concluded pre-acceptance attempt thereby becomes an ordinary allocation candidate in this same pass; replacement never bypasses the allocator.

fn attempts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<RunnerAttempt>, LaunchFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Every attempt this host holds, across every policy, terminal ones included.

fn launch<'life0, 'life1, 'async_trait>( &'life0 self, request: LaunchRequest<'life1>, ) -> Pin<Box<dyn Future<Output = Result<RunnerAttempt, LaunchFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create exactly one runtime and start one runner, and return the attempt that now exists.

fn finish_launch<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 ScalePolicy, attempt: RunnerAttempt, lock_wait: Duration, ) -> Pin<Box<dyn Future<Output = Result<RunnerAttempt, LaunchFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Bring up a runner Self::launch reserved, after the host allocation lock was released: its package, its registration and its process, none of which decides a ceiling, and all of which may take minutes.

fn clean<'life0, 'async_trait>( &'life0 self, id: AttemptId, ) -> Pin<Box<dyn Future<Output = Result<(), LaunchFailure>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Remove a terminal attempt’s runtime and mark it cleaned.