Struct DataSocketConnection 

pub struct DataSocketConnection<S = LiveWebSocket> { /* private fields */ }

Typed market-data WebSocket manager.

Reconnect (manual)

Auto-reconnect is not implemented. crate::models::ws::DataSocketConfig accepts reconnect and reconnect_retry fields and they’re stored on the connection, but no internal loop consumes them — next_event returns Ok(None) on disconnect and stays closed.

To recover from a disconnect, drop the connection and build a new one:

loop {
    let mut socket = client.data_socket().connect().await?;
    socket.subscribe(&request).await?;
    while let Some(event) = socket.next_event().await? {
        // handle event
    }
    // disconnected — loop and reconnect from scratch.
    // The HSM-token resolver runs again inside subscribe(), so this
    // recovers correctly even if topic IDs have rotated.
}

Subscribe state from the previous session is held in Self::resubscribe_frames for inspection, but it’s the user-facing JSON of the original DataSubscribeRequest values, not the binary frames sent on the wire — the binary frames carry freshly resolved HSM tokens that must be re-fetched.

Implementations

impl<S> DataSocketConnection<S>

where S: Stream<Item = Result<Message, Error>> + Sink<Message, Error = Error> + Unpin,

pub fn from_stream( stream: S, client: FyersClient, config: DataSocketConfig, ) -> Result<Self>

Create a manager from an already connected stream and a client.

client must have an access token configured — its JWT payload is decoded immediately to extract the hsm_key claim used by the binary auth frame.

pub const fn config(&self) -> &DataSocketConfig

Manager configuration.

pub const fn socket(&self) -> &ManagedSocket<S, DataSocketEvent>

Underlying generic socket manager.

pub const fn socket_mut(&mut self) -> &mut ManagedSocket<S, DataSocketEvent>

Mutable access to the underlying generic socket manager.

pub async fn handshake(&mut self) -> Result<()>

Send the documented auth + mode + channel-resume handshake frames.

The mode (full vs lite) is taken from DataSocketConfig::lite_mode. Each frame is sent without waiting for the corresponding ack — acks arrive as DataSocketEvent::Connected / DataSocketEvent::Mode events the next time Self::next_event is polled.

pub async fn subscribe(&mut self, request: &DataSubscribeRequest) -> Result<()>

Subscribe to symbol or depth updates.

Resolves each symbol against /data/symbol-token, builds the binary subscribe frame, and sends it. The subscribe ack arrives later as DataSocketEvent::Subscribed.

pub async fn unsubscribe( &mut self, request: &DataUnsubscribeRequest, ) -> Result<()>

Unsubscribe from symbol or depth updates.

pub fn resubscribe_frames(&self) -> Result<Vec<String>>

Active subscribe commands, returned for resubscribe-after-reconnect flows.

These are JSON-serialized representations of the user-facing DataSubscribeRequest values, not the binary frames sent on the wire — the binary frames depend on freshly resolved HSM tokens that must be re-fetched after a reconnect.

pub async fn next_event(&mut self) -> Result<Option<DataSocketEvent>>

Receive the next typed market-data event.

pub const fn ack_count(&self) -> u32

Server-advertised ack threshold from field 2 of the auth response. Zero until the first auth ack is processed.

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

Close the socket.

Trait Implementations

impl<S: Debug> Debug for DataSocketConnection<S>

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

Formats the value using the given formatter.