Struct AlpacaSubscriber 

pub struct AlpacaSubscriber { /* private fields */ }

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

One connection per feed, shared by clones

Alpaca allows an account one market data connection per feed — crypto, IEX and SIP count separately — and refuses a second on the same feed with connection limit exceeded. So every stream this subscriber opens on a feed attaches to one socket to it: trades and quotes, any number of symbols, in as many subscribe calls as the caller likes. Pass clones of one subscriber to every stream on the account. A subscriber built separately opens a connection of its own, and Alpaca refuses it once another is open on that feed. Streams on different feeds run side by side, one socket each.

Each (channel, symbol) pair is subscribed once however many streams hold it, and unsubscribed when the last stream holding it is dropped; the socket closes once none remains. Alpaca caps the pairs one connection holds — 30 on the free IEX plan, as last measured — and a subscribe that would pass the cap fails naming it. The cap counts what every stream on the feed holds.

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

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

Example

use rustrade_data::exchange::alpaca::{AlpacaCredentials, AlpacaSubscriber};

// Load credentials at construction time (fails fast if env vars missing)
let subscriber = AlpacaSubscriber::from_env()?;

// Or with explicit credentials
let subscriber = AlpacaSubscriber::new(AlpacaCredentials::new("key", "secret"));

Implementations

impl AlpacaSubscriber

pub fn new(credentials: AlpacaCredentials) -> 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 credentials from environment variables.

Equivalent to AlpacaSubscriber::new(AlpacaCredentials::from_env()?). See AlpacaCredentials::from_env for the variables read and error conditions.

Trait Implementations

impl Clone for AlpacaSubscriber

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 AlpacaSubscriber

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

Formats the value using the given formatter.

impl Subscriber for AlpacaSubscriber

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 feed’s shared connection, subscribing whatever the connection does not already hold.

Returns once Alpaca reports holding every requested (channel, symbol) pair. A pair another stream already holds is not sent again, and needs no answer.

Errors

Returns SocketError::Subscribe if the batch is empty, authentication is refused — by the credentials, or because another connection holds the feed — Alpaca refuses the subscribe (the connection’s pair cap among the reasons), or the subscription timeout passes before every pair is confirmed.

type SubMapper = WebSocketSubMapper

type Transport = AlpacaAttachment

What a successful subscribe hands the stream to read from.