Struct Stream

pub struct Stream<S: Streamable> { /* private fields */ }

Houses nats-agnostic APIs for publishing and consuming a streamable type

Examples

use fuel_streams_core::prelude::*;
use fuel_streams_macros::subject::IntoSubject;
use futures::StreamExt;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct MyStreamable {
    data: String,
}

impl StreamEncoder for MyStreamable {}

#[async_trait::async_trait]
impl Streamable for MyStreamable {
    const NAME: &'static str = "my_streamable";
    const WILDCARD_LIST: &'static [&'static str] = &["*"];
}

async fn example(client: &NatsClient) {
    let stream = Stream::<MyStreamable>::new(client).await;

    // Publish
    let subject = BlocksSubject::new().with_height(Some(23.into()));
    let payload = MyStreamable { data: "foo".into() };
    stream.publish(&subject, &payload).await.unwrap();

    // Subscribe
    let wildcard = BlocksSubject::WILDCARD;
    let mut subscription = stream.subscribe(wildcard).await.unwrap();
    while let Some(message) = subscription.next().await {
        // Process message
    }
}

TODO: Split this into two traits StreamPublisher + StreamSubscriber

Implementations

impl<S: Streamable> Stream<S>

pub async fn get_or_init(client: &NatsClient) -> Self

pub async fn new(client: &NatsClient) -> Self

pub async fn publish_many( &self, subjects: &[Box<dyn IntoSubject>], payload: &S, ) -> Result<(), StreamError>

pub async fn publish( &self, subject: &dyn IntoSubject, payload: &S, ) -> Result<usize, StreamError>

pub async fn publish_raw( &self, subject_name: &str, payload: &S, ) -> Result<usize, StreamError>

Publish with subject name with no static guarantees of the subject

pub async fn get_consumers_and_state( &self, ) -> Result<(String, Vec<String>, State), RequestErrorKind>

pub fn get_stream_name(&self) -> &str

pub async fn subscribe( &self, wildcard: &str, ) -> Result<impl Stream<Item = Option<Vec<u8>>>, StreamError>

pub async fn subscribe_consumer( &self, config: SubscribeConsumerConfig, ) -> Result<PullConsumerStream, StreamError>

pub async fn create_consumer( &self, config: PullConsumerConfig, ) -> Result<NatsConsumer<PullConsumerConfig>, StreamError>

pub async fn get_last_published( &self, wildcard: &str, ) -> Result<Option<S>, StreamError>

Trait Implementations

impl<S: Clone + Streamable> Clone for Stream<S>

fn clone(&self) -> Stream<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Streamable> Debug for Stream<S>

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

Formats the value using the given formatter.