One system for your events, state and work.

# one terminal
felixctl sub orders

# another
felixctl pub orders 'hello'
felixctl cache put users alice 'online'
felixctl cache get users alice
felixctl topology orders

use felix_client::{AckMode, Client, ClientConfig};
use std::net::SocketAddr;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let quinn = quinn::ClientConfig::with_platform_verifier();
    let config = ClientConfig::optimized_defaults(quinn);
    let addr: SocketAddr = "127.0.0.1:5000".parse()?;
    let client = Client::connect(addr, "localhost", config).await?;

    let publisher = client.publisher().await?;
    publisher
        .publish("acme", "prod", "events", b"Hello Felix".to_vec(), AckMode::None)
        .await?;

    let mut subscription = client.subscribe("acme", "prod", "events").await?;
    while let Some(event) = subscription.next_event().await? {
        println!("Received: {:?}", event.payload);
    }
    Ok(())
}

import os
import felix

with felix.Client(
    "127.0.0.1:5000", tenant_id="acme", token=os.environ["FELIX_TOKEN"]
) as client:
    with client.subscribe("acme", "prod", "events") as events:
        client.publish("acme", "prod", "events", b"Hello Felix")
        for event in events:
            print("Received:", event.payload)

import { Client } from "felix-client";

const client = await Client.connect("127.0.0.1:5000", "acme", process.env.FELIX_TOKEN!);
const events = await client.subscribe("acme", "prod", "events");
await client.publish("acme", "prod", "events", Buffer.from("Hello Felix"));

for (;;) {
  const event = await events.nextEvent();
  if (event === null) break;
  console.log("Received:", event.payload.toString());
}