Struct ZmqQueuePublish 

pub struct ZmqQueuePublish;

The publish policy for ZmqQueuePublisher.

Examples

A handler that splits each order into picks and pushes them to the pickers’ queue, bound at the mount site:

use std::error::Error;

use ruststream_zeromq::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Order {
    id: u64,
    lines: Vec<u64>,
}

#[derive(Serialize, Outgoing)]
#[outgoing(name = "picks")]
struct Pick {
    order: u64,
    item: u64,
}

#[subscriber("orders")]
async fn split(
    order: &Order,
    Out(picks): Out<impl Publisher>,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    for &item in &order.lines {
        picks.message(&Pick { order: order.id, item }).publish().await?;
    }
    Ok(())
}

#[ruststream::app]
fn app() -> impl App {
    let pickers = ZmqQueue::new(ZmqEndpoint::connect("tcp://pickers:5556")).bindable();
    let to_pickers = pickers.bind(ZmqQueuePublish);
    RustStream::new(AppInfo::new("splitter", "0.1.0"))
        .with_broker(ZmqQueue::new(ZmqEndpoint::bind("tcp://0.0.0.0:5555")), |b| {
            b.include(split).out(DefaultSlot, to_pickers).build();
        })
        .register_broker(pickers)
}

Trait Implementations

impl Clone for ZmqQueuePublish

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ZmqQueuePublish

impl Debug for ZmqQueuePublish

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

Formats the value using the given formatter.

impl Default for ZmqQueuePublish

fn default() -> Self

Returns the “default value” for a type.

impl<Role: EndpointRole> PublishPolicy<ConnectedZmqQueue<Role>> for ZmqQueuePublish

fn pair( self, connected: &ConnectedZmqQueue<Role>, ) -> impl Future<Output = Result<Self::Live, PairError>>

On the bind side the publisher’s socket attaches here, so it listens once the service has started; a dialing publisher attaches on its first publish.

Errors

Returns PairError when the socket of a binding publisher cannot take the endpoint.

fn channel_bindings(&self, channel: &str) -> Bindings

The destination reaches the binding, because on this pattern it is also what frame 0 of every message on the channel holds.

type Live = ZmqQueuePublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

fn operation_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its send operation in the document.

fn message_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to the messages that leave through it.

fn reply_address_location(&self) -> Option<&'static str>

Where a client finds the address of a reply this policy publishes, as a runtime expression.