Events Store — Persistent Pub/Sub

ctx := context.Background()
client, err := kubemq.NewClient(ctx,
    kubemq.WithAddress("localhost", 50000),
)
if err != nil {
    log.Fatal(err)
}
defer client.Close()

result, err := client.SendEventStore(ctx, kubemq.NewEvent().
    SetChannel("orders.events").
    SetBody([]byte(`{"action":"order.created","orderId":"ORD-1001"}`)),
)
if err != nil {
    log.Fatal(err)
}
log.Printf("Event stored: ID=%s, Sent=%v", result.EventID, result.Sent)

from kubemq import PubSubClient, EventStoreMessage

with PubSubClient(address="localhost:50000") as client:
    result = client.publish_event_store(
        EventStoreMessage(
            channel="orders.events",
            body=b'{"action":"order.created","orderId":"ORD-1001"}',
        )
    )
    print(f"Event stored: ID={result.id}, Sent={result.sent}")

import { KubeMQClient, createEventStoreMessage } from 'kubemq-js';

const client = await KubeMQClient.create({ address: 'localhost:50000' });

const result = await client.sendEventStore(
  createEventStoreMessage({
    channel: 'orders.events',
    body: '{"action":"order.created","orderId":"ORD-1001"}',
  })
);

console.log(`Event stored: ID=${result.id}, Sent=${result.sent}`);

PubSubClient client = PubSubClient.builder()
    .address("localhost:50000")
    .clientId("order-publisher")
    .build();

EventSendResult result = client.sendEventsStoreMessage(
    EventStoreMessage.builder()
        .channel("orders.events")
        .body("{\"action\":\"order.created\",\"orderId\":\"ORD-1001\"}".getBytes())
        .build());

System.out.println("Event stored: " + result.getId());
client.close();

await using var client = new KubeMQClient(new KubeMQClientOptions());
await client.ConnectAsync();

var result = await client.SendEventStoreAsync(new EventStoreMessage
{
    Channel = "orders.events",
    Body = Encoding.UTF8.GetBytes(
        "{\"action\":\"order.created\",\"orderId\":\"ORD-1001\"}")
});

Console.WriteLine($"Event stored: ID={result.Id}, Sent={result.Sent}");

val client = KubeMQClient.pubSub {
    address = "localhost:50000"
    clientId = "order-publisher"
}

client.use {
    val result = client.sendEventStore(eventStoreMessage {
        channel = "orders.events"
        body = """{"action":"order.created","orderId":"ORD-1001"}""".toByteArray()
    })
    println("Event stored: ID=${result.id}, Sent=${result.sent}")
}

kubemq::ClientOptions options;
options.set_address("localhost", 50000);
options.set_client_id("order-publisher");

auto client = kubemq::Client::Create(options).value();

kubemq::EventStoreMessage msg;
msg.set_channel("orders.events");
msg.set_body(R"({"action":"order.created","orderId":"ORD-1001"})");

auto result = client->SendEventStore(msg);
if (result.ok()) {
    std::cout << "Event stored: " << result->id() << std::endl;
}

use kubemq::prelude::*;
use kubemq::EventStoreBuilder;

#[tokio::main]
async fn main() -> kubemq::Result<()> {
    let client = KubemqClient::builder()
        .host("localhost")
        .port(50000)
        .build()
        .await?;

    let event = EventStoreBuilder::new()
        .channel("orders.events")
        .body(br#"{"action":"order.created","orderId":"ORD-1001"}"#.to_vec())
        .build();

    let result = client.send_event_store(event).await?;
    println!("Event stored: id={}, sent={}", result.id, result.sent);

    client.close().await?;
    Ok(())
}

require 'kubemq'

client = KubeMQ::PubSubClient.new(address: 'localhost:50000', client_id: 'order-publisher')

msg = KubeMQ::PubSub::EventStoreMessage.new(
  channel: 'orders.events',
  body: '{"action":"order.created","orderId":"ORD-1001"}'
)
result = client.send_event_store(msg)
puts "Event stored: id=#{result.id}, sent=#{result.sent}"

client.close

{:ok, client} = KubeMQ.Client.start_link(address: "localhost:50000", client_id: "order-publisher")

event =
  KubeMQ.EventStore.new(
    channel: "orders.events",
    body: ~s({"action":"order.created","orderId":"ORD-1001"})
  )

{:ok, result} = KubeMQ.Client.send_event_store(client, event)
IO.puts("Event stored: sent=#{result.sent}")

KubeMQ.Client.close(client)