Struct OpenStreamWriter 

pub struct OpenStreamWriter { /* private fields */ }

Minimal CEP-41 producer/writer.

Implementations

impl OpenStreamWriter

pub fn new(options: OpenStreamWriterOptions) -> Self

Create a new writer from explicit options.

pub fn progress_token(&self) -> &str

The stream id (stringified progressToken).

pub fn is_active(&self) -> bool

Whether the writer is still live (not yet closed/aborted).

true for any freshly-created writer; see has_started.

pub fn has_started(&self) -> bool

Whether the writer has begun streaming by publishing its start frame.

Distinct from is_active: used to tell apart writers a tool actually streams through from ones created only because the request carried a progress token (the response-deferral guard).

pub async fn start(&self) -> Result<()>

Explicitly publish the start frame (idempotent; lazy on first write).

pub async fn write(&self, data: String) -> Result<()>

Publish one ordered chunk frame, starting the stream lazily.

pub async fn ping(&self) -> Result<()>

Publish a keepalive ping carrying a fresh {token}:{n} nonce.

pub async fn pong(&self, nonce: String) -> Result<()>

Publish a pong echoing the peer’s ping nonce.

An inbound ping is proof of peer liveness (CEP-41: receipt of any valid frame resets the idle window), so this refreshes the keepalive clock before responding.

pub fn tick(&self, now: Instant) -> KeepaliveAction

Pure keepalive transition (idle → ping, probe deadline → abort), mirroring the reader-side OpenStreamSession::tick. Driven by the owning transport’s periodic sweep with Instant::now().

Returns KeepaliveAction::None when keepalive is disabled, the writer is inactive, or it has not yet started (the idle window arms at start).

pub async fn send_probe(&self, nonce: String) -> Result<()>

Publish a keepalive ping carrying a nonce already minted by tick.

Used by the transport sweep; unlike ping it does not mint a new nonce (the probe recorded by tick must match the frame on the wire so a matching pong clears it). Does not take the op lock, so a stuck app write cannot block keepalive (mirroring the TS writer’s queue bypass).

Ceiling: by skipping the op lock, this probe’s progress (shared atomic) can interleave with an in-flight write — a probe may carry a lower progress than a chunk published just before it. Harmless: relays reorder regardless and control frames aren’t chunkIndex-gap-checked. Re-serialize under the op lock only if strict monotonic publish-order is ever required (which would re-block keepalive behind a stuck write).

pub fn ack_probe(&self, nonce: &str)

Acknowledge an inbound pong matching the pending keepalive probe (CEP-41).

A matching pong clears the probe and refreshes the idle window. A pong whose nonce does not match the pending probe is not evidence of liveness (CEP-41: “A pong with an unknown … nonce MUST NOT be treated as evidence of liveness”) and is ignored.

pub fn dispose(&self)

Release writer resources without publishing a terminal frame — used on transport teardown so the writer no longer drives keepalive. Idempotent.

Only flips active to false: tick and ack_probe early-return on that flag, so an armed probe becomes inert without needing to be cleared (matching close/abort, which also leave keepalive state untouched once terminal).

pub async fn close(&self) -> Result<()>

Close the stream gracefully. Declares lastChunkIndex iff any chunks were written. Runs on_close after the frame is published (even on publish failure); propagates the publish error.

pub async fn abort(&self, reason: Option<String>) -> Result<()>

Abort the stream (terminal). Claims the terminal transition without the op lock, so it never waits on a stuck write. Runs on_abort after the frame is published (even on publish failure); propagates the publish error. Idempotent: a second abort (or one after close) is a no-op.

Trait Implementations

impl Clone for OpenStreamWriter

fn clone(&self) -> OpenStreamWriter

Returns a duplicate of the value.

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

Performs copy-assignment from source.