Struct EventSource 

pub struct EventSource { /* private fields */ }

A reconnecting stream of Server-Sent Events.

Implementations

impl EventSource

pub fn new(req: RequestBuilder) -> Self

Creates a new EventSource from the given request with default configurations.

pub fn builder(req: RequestBuilder) -> EventSourceBuilder

Creates a builder to customize the EventSource before connecting.

pub fn close(&mut self)

Closes the underlying SSE connection.

This method terminates the active HTTP request, effectively dropping the inner stream. Calling close is idempotent; if the connection is already closed, this does nothing and is perfectly safe to call multiple times.

While this halts all incoming events and stops the automatic reconnection loop, it does not consume the EventSource. You can manually restart the stream and initiate a fresh connection at any time by calling force_reconnect().

Example

let client = reqwest::Client::new();
let mut stream = client.get("https://api.example.com/stream").into_event_source();

// ... later, to gracefully stop listening to events (e.g., app goes to background):
stream.close();
assert_eq!(stream.ready_state(), ReadyState::Closed);

// The stream will now yield None
assert!(stream.next().await.is_none());

pub fn ready_state(&self) -> ReadyState

Returns the current connection state.

pub fn last_event_id(&self) -> Option<&Arc<str>>

Returns the most recently received Last-Event-ID, if any.

pub fn force_reconnect(&mut self)

Terminates the current connection and immediately attempts to reconnect.

Because EventSource automatically handles network drops and reconnections, you typically do not need to call this manually. However, it is useful in specific scenarios, such as:

• Bypassing Backoff: The server state has heavily desynced, and you want to bypass the current exponential backoff timer to reconnect instantly.
• Manual Revival: You previously called close() to pause the stream, and now want to resume listening for events.

This method resets the connection attempt counter, meaning the next connection attempt will happen immediately without any retry delay. And will continue with the exponential backoff reset.

Example

let client = reqwest::Client::new();
let mut stream = client.get("https://api.example.com/stream").into_event_source();

// If your application detects via the OS that network connectivity was restored,
// you can manually trigger an immediate reconnect to bypass active backoff delays.
stream.force_reconnect();
assert_eq!(stream.ready_state(), ReadyState::Connecting);

pub fn force_reconnect_with_id(&mut self, id: Option<Arc<str>>)

Terminates the current connection and immediately attempts to reconnect, explicitly overriding the Last-Event-ID sent to the server.

This is useful if your application state has desynced and you need to force the server to rewind or fast-forward to a specific point in the stream.

See force_reconnect() for more info.

Trait Implementations

impl Debug for EventSource

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

Formats the value using the given formatter.

impl Stream for EventSource

type Item = Result<SseEvent, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.