lenso-runner 0.2.0

Native Tokio Runtime Driver and Runner for Lenso vNext.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use std::fmt;

use lenso_kernel::{RuntimeFailure, ShutdownOutcome};

/// A native Runner startup or lane-lifecycle failure.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ReplicatedRunnerError {
    /// The immutable Plan failed validation before any lane started.
    InvalidPlan { detail: String },
    /// One lane could not construct or start its Kernel replica.
    LaneStartup { lane: String, detail: String },
    /// A generated request Capability was not registered with the native transfer catalog.
    MissingCrossLaneRequestTransfer { capability: String },
    /// A generated stream Capability was not registered with the native transfer catalog.
    MissingCrossLaneStreamTransfer { capability: String },
    /// A generated Event Capability was not registered with the native transfer catalog.
    MissingCrossLaneEventTransfer { capability: String },
    /// A lane stopped accepting Runner commands unexpectedly.
    LaneUnavailable { lane: String },
    /// A lane thread panicked while starting, running, or stopping.
    LanePanicked { lane: String },
    /// One Kernel replica reached a terminal runtime failure.
    LaneRuntimeFailure { lane: String, error: RuntimeFailure },
    /// One Kernel replica did not stop cleanly.
    LaneShutdown {
        lane: String,
        outcome: ShutdownOutcome,
    },
}

impl fmt::Display for ReplicatedRunnerError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidPlan { detail } => {
                write!(formatter, "invalid Resolved App Plan: {detail}")
            }
            Self::LaneStartup { lane, detail } => {
                write!(
                    formatter,
                    "Execution Lane `{lane}` failed to start: {detail}"
                )
            }
            Self::MissingCrossLaneRequestTransfer { capability } => write!(
                formatter,
                "Capability `{capability}` has no registered native cross-lane request transfer"
            ),
            Self::MissingCrossLaneStreamTransfer { capability } => write!(
                formatter,
                "Capability `{capability}` has no registered native cross-lane stream transfer"
            ),
            Self::MissingCrossLaneEventTransfer { capability } => write!(
                formatter,
                "Capability `{capability}` has no registered native cross-lane Event transfer"
            ),
            Self::LaneUnavailable { lane } => {
                write!(formatter, "Execution Lane `{lane}` is unavailable")
            }
            Self::LanePanicked { lane } => write!(formatter, "Execution Lane `{lane}` panicked"),
            Self::LaneRuntimeFailure { lane, error } => write!(
                formatter,
                "Execution Lane `{lane}` reached a terminal runtime failure: {error:?}"
            ),
            Self::LaneShutdown { lane, outcome } => write!(
                formatter,
                "Execution Lane `{lane}` stopped with {outcome:?}"
            ),
        }
    }
}

impl std::error::Error for ReplicatedRunnerError {}