Module session 

The in-VM client, with the reqwest backend and the sockets.

Modules

complete

Run one command to exactly one result: Session::run_to_completion.

exec

The exec handle and the cursor-driven stream, with the production exec id.

files

File and tar transfer. Four routes, opaque bodies, one query type.

forward

A local TCP listener that forwards HTTP and WebSocket traffic to one guest port.

http

The HTTP seam and the production backend.

keepalive

Keeping a VM awake from outside while work runs inside it.

proxy

The two-header proxy auth and the mint schedule, on tokio’s clock in production.

serve

The serving loops behind microvm tunnel and microvm port-forward, and behind the SDKs’ tunnel and port-forward handles (#263).

shell

The client half of microvm shell: a real PTY carried over the endpoint’s shell WebSocket. Issue #69, Option B — a thin client over the platform’s session, not a line-mode wrapper over exec.

split

One exec’s output as two byte channels, stdout and stderr.

sse

Incremental Server-Sent Events parsing, and the typed events the daemon emits.

tunnel

The client half of the TCP relay: a local TCP connection carried over a WebSocket.

Structs

ClientDeadline

What the client did when its own deadline expired (BIND-9, BIND-10).

CompletionOptions

The knobs of a run-to-completion call.

CompletionPlan

A validated run-to-completion call, separable from the start request it was planned for.

ExecHandle

One exec, addressed by its caller-minted id.

ExecResult

An exec’s phase and, once it has one, its outcome.

ForwardClient

The HTTP client a forwarder’s hops go through.

ForwardSpec

Where the forwarder listens and what it forwards to.

Frame

One complete SSE frame: its event name and its raw data: text.

GapLog

The gaps a split drive has recorded so far, shared with the drive.

HttpRequest

One request, already fully addressed: absolute URL, every header, whole body.

HttpResponse

One response, body already collected.

KeepAwake

A keepalive’s policy. Build with KeepAwake::new, check with KeepAwake::validate.

KeepAwakeReport

What a finished keepalive did.

KeepAwakeTask

A keepalive running as a background task. Dropping it stops the task.

LaunchMetrics

Measurements observed by this client’s launch, in Unix seconds for timestamps. Absent timestamps mean that phase has not been observed by this client.

OutputGap

One byte range the daemon couldn’t replay, under GapPolicy::Event.

ProxyAuth

Mints, caches, and refreshes the proxy token for one MicroVM and one port.

ProxyToken

The minted token, as the control plane returns it: a map of header name to value.

ReqwestBackend

The production backend: one pooled reqwest client.

Session

The control API of one running MicroVM.

SessionBuilder

Builds a Session. See Session::builder.

Split

One exec’s output as two channels, and the drive that fills them.

SseParser

Feed bytes, get whole frames out. Holds a partial frame across feeds.

StreamEnd

Why a stream stopped, and where a resume would pick up.

StreamOptions

How a stream should behave. See ExecHandle::stream_with.

TokioClock

The production clock: tokio’s monotonic clock and the system’s wall clock.

Transport

The transport: a backend, the agent token, and the proxy auth every request needs.

Enums

EndReason

The three ways a stream ends without an error.

ExecEvent

One decoded stream event.

ForwardEvent

What the forwarder did, for a caller that wants to report progress.

GapPolicy

What a split drive does when the daemon reports evicted output. See the module docs.

KeepAwakeEnd

Why a keepalive ended without an error.

KillAnswer

The daemon’s answer to the kill the client sent when its deadline expired.

TunnelEnd

What ended a tunnel, and whether the caller should treat it as a failure.

Constants

DEFAULT_AGENT_PORT

Compatibility alias for the shared daemon listener default.

DEFAULT_BIND

Where a tunnel or port-forward listens by default: loopback, on a port the OS picks. Loopback keeps the VM’s credentials from being exposed to remote connections.

DEFAULT_BOOTSTRAP_TIMEOUT

How long to wait for a daemon to report bootstrapped, once its VM is RUNNING: the wait crate::sandbox::Sandbox::run makes after the RUNNING one, and Session::wait_until_ready’s default in the bindings.

DEFAULT_CLIENT_GRACE

The default CompletionOptions::client_grace: how long past the daemon’s own deadline the client waits before it kills, and how long it then waits for the killed exec’s result.

DEFAULT_EXCHANGE_TIMEOUT

The limit for the response head and for each read of a proxied response body.

DEFAULT_EXEC_WAIT

The deadline the bindings pass to ExecHandle::wait, ExecHandle::wait_and_ack and a one-shot Session::run_sync when their caller names none: five minutes, the Python client’s figure. Those methods take a deadline, so core itself never reads this; it’s here so both bindings default to one figure.

DEFAULT_READY_TIMEOUTDeprecated

The old name of DEFAULT_BOOTSTRAP_TIMEOUT, kept for one release.

DEFAULT_REFRESH_AFTER

When to re-mint: half MAX_TOKEN_LIFETIME. See the module docs for why not fifty-nine minutes.

DEFAULT_REQUEST_TIMEOUT

How long one non-streaming request may take.

MAX_TOKEN_LIFETIME

The ceiling the service enforces on a proxy token’s life. Not a choice.

NO_TIMEOUT_CEILING

The client deadline of a request with no timeout_sec: the longest a MicroVM can live (MAX_DURATION_SEC), since no command outlives the VM it runs in.

PROXY_AUTH_HEADER

The header carrying the minted JWE. One of the two keys read out of the authToken map.

PROXY_PORT_HEADER

The header naming which of the token’s allowed ports this request targets.

TIMED_OUT_EXIT_CODE

The exit code GNU timeout(1) reports for a command its deadline ended, and the one ExecResult::posix_exit_code reports for a deadline (BIND-6).

TUNNEL_CHUNK_BYTES

Bytes read from the local connection per relayed frame.

WS_AUTH_SUBPROTOCOL_PREFIX

The prefix the JWE rides behind in a WebSocket handshake.

WS_PORT_SUBPROTOCOL_PREFIX

The prefix the target port rides behind in a WebSocket handshake.

WS_SUBPROTOCOL

The base subprotocol every MicroVM WebSocket handshake offers first.

Traits

ChunkSource

A body arriving in pieces.

Clock

The clock a refresh boundary is measured on. It’s the crate’s one Clock, and the production one is tokio’s (TokioClock, in microvms-edges): a token timed on std::time::Instant would never re-mint inside a simulation. Time, injectable so a wait or a refresh boundary is a test rather than a wait.

HttpBackend

The seam. Production and simulated transports implement this.

TokenMinter

Mints a proxy token. One method, so a test needs no AWS.

Functions

exec_id_at

A fresh exec id for the wall time unix, since the epoch: x- plus 16 hex characters, the Python client’s shape.

explain_close

A sentence for a close code, or None when the code explains nothing.

forwards_request_header

Whether a header from the local client is forwarded upstream.

mint_exec_id

A fresh exec id from the production clock: x- plus 16 hex characters.

refusal_explanation

The 403-vs-502 sentence, or None for a status that needs no explaining.

relay_connection

Opens a tunnel to guest_port and relays local over it until either side closes.

tunnel_url

The wss:// URL for a tunnel to guest_port.

upstream_url

The absolute URL a proxied request targets, given the endpoint and the request target.

Type Aliases

OpenStream

A streaming response: the head, and the body still to arrive.

OutputFlow

What an OutputSink answers: a boxed future of continue-or-stop, named so a caller needs no futures crate to spell it.

OutputSink

A callback for output. Only ExecEvent::Output is delivered; the result carries the exit status. Answering std::ops::ControlFlow::Break stops delivery, and the call still waits for and acks the exec, so nothing is left running unobserved (BIND-8).

RunningGate

Whether the VM behind a keepalive is still one it may poll. See the module docs.

SharedBackend

A backend behind an Arc, which is what a crate::session::Session holds.

SplitItem

What a channel carries: a chunk of one side’s bytes, or the error that ended it.