Struct DynamicSubscribers 

pub struct DynamicSubscribers { /* private fields */ }

The subscribers DynamicStreams cannot build for itself.

Most venues are served by a stateless WebSocketSubscriber, which DynamicStreams constructs on its own. A venue whose subscriber carries credentials — or shares one connection among its streams — needs one built by the caller and supplied here, through DynamicStreams::init_with. A subscription to such a venue with no subscriber supplied fails with DataError::SubscriberRequired.

Venues that need one:

• Alpaca (alpaca feature): AlpacaCrypto, AlpacaIex and AlpacaSip.
• London Strategic Edge (lse feature): every Lse* dataset.
• Massive (massive feature): MassiveStocks, MassiveCrypto, MassiveForex and MassiveOptions.

Example

use rustrade_data::exchange::lse::live::LseSubscriber;
use rustrade_data::streams::builder::dynamic::{DynamicStreams, DynamicSubscribers};
use rustrade_data::subscription::SubKind;
use rustrade_instrument::{
    exchange::ExchangeId, instrument::market_data::kind::MarketDataInstrumentKind,
};

let subscribers = DynamicSubscribers::default().with_lse(LseSubscriber::from_env()?);

// Two datasets and both kinds: four streams, one connection.
let streams = DynamicStreams::init_with(&subscribers, [[
    (ExchangeId::LseCrypto, "btc", "usd", MarketDataInstrumentKind::Spot, SubKind::PublicTrades),
    (ExchangeId::LseCrypto, "btc", "usd", MarketDataInstrumentKind::Spot, SubKind::OrderBooksL1),
    (ExchangeId::LseEquities, "aapl", "usd", MarketDataInstrumentKind::Spot, SubKind::PublicTrades),
    (ExchangeId::LseEquities, "aapl", "usd", MarketDataInstrumentKind::Spot, SubKind::OrderBooksL1),
]])
.await?;

Implementations

impl DynamicSubscribers

pub fn with_alpaca(self, subscriber: AlpacaSubscriber) -> Self

Serve every Alpaca subscription — any feed, either kind — from clones of subscriber.

Alpaca allows an account one market data connection per feed and refuses a second on the same feed with connection limit exceeded. Clones of one subscriber share one connection per feed, so every Alpaca* group of every batch on a feed attaches to the same socket, and the crypto, IEX and SIP feeds each get one of their own. Any other stream the caller opens on the same account should take a clone of this subscriber too, rather than one built separately.

Quotes arrive as OrderBookL1: SubKind::OrderBooksL1 reads Alpaca’s quotes channel, and a side quoted at a zero price is None. SubKind::Quotes is not served here; the typed Streams builder serves it. A confirmed crypto subscription may stay silent for minutes: Alpaca publishes a crypto quote only when the top of book changes. See exchange::alpaca.

The (channel, symbol) pairs every stream on a feed holds count together against Alpaca’s per-connection cap — 30 on the free IEX plan, as last measured. Trades and L1 on one symbol are two pairs.

pub fn with_lse(self, subscriber: LseSubscriber) -> Self

Serve every London Strategic Edge subscription — any dataset, either kind — from clones of subscriber.

Clones share the subscriber’s one connection, which is the only way several streams can coexist on this provider: it allows a key a single WebSocket and refuses a second with TOO_MANY_CONNECTIONS. So every Lse* group of every batch attaches to the same socket, and so should any other stream the caller opens for the same key — pass it a clone of this subscriber rather than building another.

Resumption

Configure it with LseSubscriber::with_resume before passing it here to resume every London Strategic Edge stream this call opens; the one state then serves them all. Streams are keyed by dataset, symbol and kind, and DynamicStreams::init_with removes duplicates only within a batch — so repeating one subscription across two batches opens two streams sharing one watermark, which LseSubscriber::with_resume warns against.

⚠️ The data is not redistributable

London Strategic Edge permits use for your own research, trading and model training, but prohibits redistributing the data it serves. See exchange::lse and https://londonstrategicedge.com/terms.

pub fn with_massive(self, subscriber: MassiveSubscriber) -> Self

Serve every Massive subscription — any cluster, any kind — from clones of subscriber.

Massive allows a key a fixed number of WebSocket connections per cluster, one on an individual plan, and past it does not refuse the new connection: it closes the older one. Clones of one subscriber share one connection per cluster, so every Massive* group of every batch on a cluster attaches to the same socket, and the stocks, crypto, forex and options clusters each get one of their own. Any other stream the caller opens on the same key should take a clone of this subscriber too: one built separately evicts this one’s connection, and the warning logged for the lost connection quotes Massive’s max_connections status.

What each cluster serves:

• SubKind::PublicTrades on every cluster but forex, which publishes no trades.
• SubKind::OrderBooksL1, read from the cluster’s quote channel. A side quoted at a zero price is None, and a forex quote carries no sizes, so its amounts are zero. SubKind::Quotes is not served here; the typed Streams builder serves it.
• SubKind::Candles at CandleInterval::Sec1 and Min1, the only intervals Massive aggregates at. Forex candles report no volume. Both intervals on one cluster arrive on its one candle stream; see DynamicStreams::select_candles.

MassiveOptions takes option contracts only and has never been run against the live feed, which needs an options subscription. An instrument given as MarketInstrumentData is subscribed by its name_exchange as given, so that must be the cluster’s own spelling: AAPL, BTC-USD, EUR/USD or O:AAPL251219C00150000. See exchange::massive.

⚠️ The data is not redistributable

Massive’s terms prohibit redistributing the data it serves. See https://massive.com/legal/market-data-terms-of-service (§5(c)).

Trait Implementations

impl Clone for DynamicSubscribers

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 DynamicSubscribers

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

Formats the value using the given formatter.

impl Default for DynamicSubscribers

fn default() -> Self

Returns the “default value” for a type.