Struct MassiveSubscriber 

pub struct MassiveSubscriber { /* private fields */ }

Massive market data subscriber: authenticates, and shares one connection per cluster among every stream it and its clones open.

One connection per cluster, shared by clones

Massive allows a key a fixed number of WebSocket connections per cluster — one on an individual plan — and past it closes the older connection. So every stream this subscriber opens on a cluster attaches to one socket to it: trades, quotes and candles, any number of markets, in as many subscribe calls as the caller likes. Pass clones of one subscriber to every stream on the key. A subscriber built separately, or another process using the key, opens a connection of its own and evicts this one. The eviction ends every stream on it, and the warning logged for the lost connection quotes Massive’s max_connections status. Streams on different clusters run side by side, one socket each.

Each subscription — a channel and a market — is sent once however many streams hold it, and unsubscribed when the last stream holding it is dropped; the socket closes once none remains.

If the connection is lost, every stream on it ends together and reconnects through the usual reconnect wrapper, sharing one new connection. Massive replays nothing, so what it published while no socket was open is not recovered.

See connection for how frames reach each stream, and MassiveAttachment for why a stream must be kept drained.

Example

use rustrade_data::exchange::massive::{MassiveCredentials, MassiveSubscriber};

// Load the key at construction time (fails fast if the variable is missing)
let subscriber = MassiveSubscriber::from_env()?;

// Or with an explicit key
let subscriber = MassiveSubscriber::new(MassiveCredentials::new("key"));

Implementations

impl MassiveSubscriber

pub fn new(credentials: MassiveCredentials) -> Self

Create a new subscriber with the provided credentials.

The subscriber opens no connection until a stream subscribes.

pub fn from_env() -> Result<Self, SocketError>

Create a new subscriber using the key in the MASSIVE_API_KEY environment variable.

Equivalent to MassiveSubscriber::new(MassiveCredentials::from_env()?).

Trait Implementations

impl Clone for MassiveSubscriber

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MassiveSubscriber

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

Formats the value using the given formatter.

impl Subscriber for MassiveSubscriber

async fn subscribe<Exchange, Instrument, Kind>( &self, subscriptions: &[Subscription<Exchange, Instrument, Kind>], ) -> Result<Subscribed<Instrument::Key, Self::Transport>, SocketError>

where Exchange: Connector + Send + Sync, Kind: SubscriptionKind + Send + Sync, Instrument: InstrumentData, Subscription<Exchange, Instrument, Kind>: Identifier<Exchange::Channel> + Identifier<Exchange::Market>,

Attach the batch to its cluster’s shared connection, subscribing whatever the connection does not already hold.

Returns once Massive confirms every requested subscription by name. One another stream already holds is not sent again, and needs no answer.

Errors

Returns SocketError::Subscribe — before connecting — if the batch is empty, asks for candles at an interval other than one second or one minute, names a market holding a comma or whitespace (as an instrument the cluster cannot spell is written), or on the options cluster names an instrument that is not an option contract. Once connected, it returns one if authentication is refused (a key without WebSocket access to the cluster among the reasons). It returns SocketError::Unacknowledged, naming the subscriptions Massive had not confirmed, if Massive refuses one (its refusal names none, so the refused one is among them), the connection is lost, or the subscription timeout passes before every subscription is confirmed. Massive does not answer a subscription to a channel the cluster does not publish, so that surfaces as the timeout.

type SubMapper = WebSocketSubMapper

type Transport = MassiveAttachment

What a successful subscribe hands the stream to read from.