Struct RunningWorkload 

pub struct RunningWorkload {
    pub kind: String,
    pub slot: String,
    pub dev_url: Option<String>,
    pub public_url: Option<String>,
    pub console_url: Option<String>,
    pub log_buffer: Option<LogBuffer>,
    pub notes: Vec<String>,
    /* private fields */
}

Handle to a workload that’s been brought up. Owns the lifecycle: drop or call RunningWorkload::shutdown to take it back down.

Fields

kind: String

Workload kind that was reconciled (e.g. "mesofact-static").

slot: String

Slot role this workload occupies on the mirror (e.g. "static").

dev_url: Option<String>

Local URL the workload exposes, when applicable. None for workloads that publish to a non-local artifact store (e.g. R2).

public_url: Option<String>

Notional URL of the deployed artifact in the production case (e.g. https://yah.dev). None until Cloudflare/R2 wiring lands.

console_url: Option<String>

Secondary local UI console, if the workload exposes one (e.g. MinIO console on a pond tier). Surfaced as a separate chip in the Services matrix next to dev_url.

log_buffer: Option<LogBuffer>

Ring buffer for stdout/stderr from the workload’s child process. None for workloads that don’t capture stdio (e.g. container-backed).

notes: Vec<String>

R546-B12: human-readable lines the reconciler wants the operator to see on THIS run — what it actually did, not what is configured. A clean static-asset reconcile used to print nothing at all, so a successful publish and a successful no-op were indistinguishable at the apply surface, and the one view that would have disambiguated them (yah cloud status) was itself blind.

Deliberately NOT on RunningWorkloadSummary: that type is serialized across the process boundary to the desktop UI, and this is per-run console output, not state the UI should cache.

Implementations

impl RunningWorkload

pub fn adopted( kind: impl Into<String>, slot: impl Into<String>, dev_url: Option<String>, ) -> Self

Create a handle for a workload that’s already running externally (e.g. embedded in yah-camp). No subprocess is owned; shutdown is a no-op so the caller can call shutdown() uniformly.

pub fn with_teardown<F, Fut>(self, teardown: F) -> Self

where F: FnOnce() -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Attach an explicit teardown to a handle for an externally-running workload (R714-B1).

adopted() alone gives a handle whose shutdown() is a documented no-op. That is right for workloads another process owns and will keep re-asserting (pond containers under camp’s yubaba), and wrong for ones this process started and nobody else will ever stop — for those the ■ button reported success while the container kept running.

teardown runs on shutdown() and NOT on Drop; see Self::teardown.

pub fn with_notes(self, notes: Vec<String>) -> Self

Attach per-run operator-facing lines (R546-B12). See Self::notes.

pub fn with_public_url(self, url: impl Into<String>) -> Self

Set the public URL for a published workload (e.g. "https://yah.dev").

pub fn with_console_url(self, url: impl Into<String>) -> Self

Set the console URL for a workload that exposes a secondary local UI (e.g. MinIO console on a pond tier).

pub async fn shutdown(self) -> Result<()>

Gracefully tear down: signal the supervisor, await its exit, then run any explicit teardown hook.

The hook runs LAST and its error propagates. A stop that could not tear the workload down must surface as an error, never as a silent success — that silence is the whole of R714-B1.

Trait Implementations

impl Debug for RunningWorkload

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

Formats the value using the given formatter.

impl Drop for RunningWorkload

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl From<&RunningWorkload> for RunningWorkloadSummary

fn from(r: &RunningWorkload) -> Self

Converts to this type from the input type.