[][src]Crate fluvio

The Rust client library for writing streaming applications with Fluvio

Fluvio is a high performance, low latency data streaming platform built for developers.

When writing streaming applications, two of your core behaviors are producing messages and consuming messages. When you produce a message, you send it to a Fluvio cluster where it is recorded and saved for later usage. When you consume a message, you are reading a previously-stored message from that same Fluvio cluster. Let's get started with a quick example where we produce and consume some messages.

Prerequisites

Install Fluvio

Fluvio Echo

The easiest way to see Fluvio in action is to produce some messages and to consume them right away. In this sense, we can use Fluvio to make an "echo service".

All messages in Fluvio are sent in a sort of category called a Topic. You can think of a Topic as a named folder where you want to store some files, which would be your messages. If you're familiar with relational databases, you can think of a Topic as being similar to a database table, but for streaming.

As the application developer, you get to decide what Topics you create and which messages you send to them. We need to set up a Topic before running our code. For the echo example, we'll call our topic echo.

Example

The easiest way to create a Fluvio Topic is by using the Fluvio CLI.

$ fluvio topic create echo
topic "echo" created

There are convenience methods that let you get up-and-started quickly using default configurations. Later if you want to customize your setup, you can directly use the Fluvio client object.

use std::time::Duration;
use fluvio::{Offset, FluvioError};
use futures::StreamExt;

async_std::task::spawn(produce_records());
if let Err(e) = async_std::task::block_on(consume_records()) {
    println!("Error: {}", e);
}

async fn produce_records() -> Result<(), FluvioError> {
    let producer = fluvio::producer("echo").await?;
    for i in 0..10u8 {
        producer.send_record(format!("Hello, Fluvio {}!", i), 0).await?;
        async_std::task::sleep(Duration::from_secs(1)).await;
    }
    Ok(())
}

async fn consume_records() -> Result<(), FluvioError> {
    let consumer = fluvio::consumer("echo", 0).await?;
    let mut stream = consumer.stream(Offset::beginning()).await?;

    while let Some(Ok(record)) = stream.next().await {
        if let Some(bytes) = record.try_into_bytes() {
            let string = String::from_utf8_lossy(&bytes);
            println!("Got record: {}", string);
        }
    }
    Ok(())
}

Modules

config
dataplane
metadata

re-export metadata from sc-api

Structs

ConsumerConfig

Configures the behavior of consumer fetching and streaming

Fluvio

An interface for interacting with Fluvio streaming

FluvioAdmin

An interface for managing a Fluvio cluster

FluvioConfig

Public configuration for Fluvio.

Offset

Describes the location of an event stored in a Fluvio partition

PartitionConsumer

An interface for consuming events from a particular partition

TopicProducer

An interface for producing events to a particular topic

Enums

FluvioError

Possible errors that may arise when using Fluvio

Functions

consumer

Creates a producer that receives events from the given topic and partition

producer

Creates a producer that sends events to the named topic