Struct MdCore 

pub struct MdCore { /* private fields */ }

Sans-io market data core of the BCS market data WebSocket.

It turns inbound frames into [Event]s (order books, quotes, trades, candles), tracks which subscriptions the broker has confirmed, and after a reconnect tells the consumer that the order books are void (Event::Resync with [ResyncReason::SubscriptionReset]). It does no I/O.

Examples

Ask for an order book subscription and read the message the core wants to send:

use std::time::Instant;
use brokapi_bcs::{MdCore, core::SubState};
use brokapi_core::{InstrumentId, InstrumentKey, NativeId, SubscriptionId};
use brokapi_sansio::{
    BrokerCore, DesiredSubscription, EventSink, Outbound, SubscriptionKind, SubscriptionSet,
};

let sber = InstrumentId::new(
    InstrumentKey::new("SBER", "TQBR"),
    NativeId::TickerClass { ticker: "SBER".into(), class_code: "TQBR".into() },
);
let sub = SubscriptionId::new(1);
let mut core = MdCore::new();
core.apply(&SubscriptionSet::with_subscriptions(vec![DesiredSubscription {
    id: sub,
    kind: SubscriptionKind::OrderBook { instrument: sber, depth: 10 },
}]));

let Some(Outbound::WsText(text)) = core.poll_transmit() else { panic!("a subscribe message") };
assert!(text.contains("\"subscribeType\":0"));
// Waiting for the broker's confirmation.
assert_eq!(core.actual_state(sub), Some(SubState::Pending));

// A subscribe error from the broker fails the subscriptions that wait.
let mut out = EventSink::new();
core.feed_raw(r#"{"errors":[{"message":"unknown instrument"}]}"#, Instant::now(), &mut out);
assert_eq!(core.actual_state(sub), Some(SubState::Failed));

Implementations

impl MdCore

pub fn new() -> MdCore

Creates a core with no subscriptions.

pub fn notifier(&self) -> Arc<Notify>

The signal that is given whenever a subscription is confirmed or refused. A connector waits on it (with [brokapi_runtime::wait_ack]) to hold subscribe_* until the broker has answered.

pub fn failure(&self, id: SubscriptionId) -> Option<&str>

Why subscription id failed, in the words of the broker, if it did.

pub fn desired(&self) -> &SubscriptionSet

Subscriptions the connector asked for (input of the last apply).

pub fn actual_state(&self, id: SubscriptionId) -> Option<SubState>

The state of subscription id, or None if the core does not know it (never applied, or already unsubscribed).

pub fn feed_raw(&mut self, text: &str, now: Instant, out: &mut EventSink)

Feeds one raw text frame of the market data WebSocket.

A frame with an errors array is a subscribe error: the pending subscription it is about becomes SubState::Failed (all pending ones if the frame does not say which, see fail_pending) and no event is pushed. Any other frame is parsed and handled like on_frame does. A frame that cannot be parsed is skipped, there is no error to return.

Trait Implementations

impl BrokerCore for MdCore

type Frame = IncomingMessage

The inbound frame type: for example String for WebSocket text, or a decoded message.

fn on_frame( &mut self, frame: <MdCore as BrokerCore>::Frame, now: Instant, out: &mut EventSink, )

Handles one inbound transport frame received at now.

fn poll_transmit(&mut self) -> Option<Outbound>

Takes the next outbound wire message, if any. Call it until it returns None.

fn poll_timeout(&self) -> Option<Instant>

When the core wants on_timeout to be called next, or None if it has no timer pending.

fn on_timeout(&mut self, _now: Instant, _out: &mut EventSink)

Handles a timer that fired. now is the time the timer was due.

fn apply(&mut self, desired: &SubscriptionSet)

Tells the core the full set of subscriptions the consumer wants now.

impl Debug for MdCore

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

Formats the value using the given formatter.

impl Default for MdCore

fn default() -> MdCore

Returns the “default value” for a type.