Struct LocalRuntime 

pub struct LocalRuntime {
    pub detected: DetectedRuntime,
    pub docker_host: String,
}

Reachable local container daemon — the winning provider from the cascade.

Fields

detected: DetectedRuntime

docker_host: String

DOCKER_HOST value used for every docker CLI invocation against this runtime (e.g. "unix:///…" or "tcp://localhost:2375").

Implementations

impl LocalRuntime

pub async fn detect(spec: &LocalContainerSpec) -> Result<LocalRuntime, Error>

Probe providers in spec.runtime order. Auto walks the full cascade orbstack → docker-desktop → colima → podman → docker → custom; a pinned preference probes only that runtime. Each socket path is tilde-expanded and existence-checked.

pub async fn has_image(&self, image: &str) -> Result<bool, Error>

True if image is already present in the local image store. docker image inspect returns non-zero (without ‘unable to find’ on stderr) when the image is absent.

pub async fn ensure_image(&self, image: &str) -> Result<bool, Error>

Pull image only when it isn’t already cached. Returns true if a pull happened, false if the image was already present. Image refs should be tag-pinned (caddy:2.10-alpine) so this stays deterministic.

pub async fn build_image( &self, tag: &str, dockerfile: &Path, context: &Path, ) -> Result<(), Error>

Build a local image from a Dockerfile via docker build -t <tag> -f <dockerfile> <context>. Unlike ensure_image (which pulls a published ref) this compiles the component’s own image from source — the kind = "container" reconciler path (R602-T1).

dockerfile is the path to the Dockerfile; context is the build context directory. Both are passed to docker verbatim, so the caller resolves them to real paths first. Docker’s layer cache makes repeat builds of an unchanged tree cheap, so callers may build unconditionally on every reconcile without a separate freshness check.

pub async fn ensure_network(&self, name: &str) -> Result<bool, Error>

Idempotently create a docker bridge network. Returns true if a network was created, false if one already existed under name. Used by the pond per-cell bridge bring-up (R455-F1).

pub async fn remove_container(&self, name: &str) -> Result<(), Error>

Best-effort docker rm -f <name> — silent when the container is already gone. Used before run to clear orphans from a prior crash.

pub async fn run(&self, spec: &ContainerRunSpec) -> Result<(), Error>

Start a detached container per spec. Pre-clears any prior container with the same name so re-runs after a crash are idempotent.

pub async fn container_host_port( &self, name: &str, container_port: u16, ) -> Result<u16, Error>

Read the host-side port that the container mapped container_port/tcp to. Runs docker port <name> <container_port> and parses the output (0.0.0.0:XXXXX or :::XXXXX). Returns an error when the container is not running or the port is not published.

pub async fn container_state( &self, name: &str, ) -> Result<Option<ContainerState>, Error>

Fetch the container’s State.Status field (running / exited / …). Returns Ok(None) when the container doesn’t exist.

pub async fn stop_and_remove( &self, name: &str, grace: Duration, ) -> Result<(), Error>

Graceful docker stop -t <grace_seconds> followed by docker rm. No-op if the container doesn’t exist.

pub async fn list_owned(&self) -> Result<Vec<OwnedContainer>, Error>

List every container owned by this module on this runtime. Queries both yah.pond (current) and yah.local-sim (legacy, pre-R362) label keys so old-generation containers are visible during the transition.

Trait Implementations

impl Clone for LocalRuntime

fn clone(&self) -> LocalRuntime

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ContainerLauncher for LocalRuntime

fn ensure_image<'life0, 'life1, 'async_trait>( &'life0 self, image: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, LocalRuntime: 'async_trait,

Pull image unless it is already present. true when a pull happened.

fn run<'life0, 'life1, 'async_trait>( &'life0 self, spec: &'life1 ContainerRunSpec, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, LocalRuntime: 'async_trait,

Start a detached container per spec, replacing any prior container of the same name.

fn stop_and_remove<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, grace: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, LocalRuntime: 'async_trait,

Stop with grace, then remove. No-op when the container is absent.

impl Debug for LocalRuntime

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

Formats the value using the given formatter.