Struct Connect 

pub struct Connect;

This process dials the endpoint: the side ZmqEndpoint::connect takes.

Examples

A test of a worker that pushes its results to a collector it dials addresses that queue by its side:

use std::error::Error;

use ruststream::testing::TestApp;
use ruststream_zeromq::Connect;
use ruststream_zeromq::queue::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Outgoing)]
struct Job {
    id: u64,
}

#[derive(Debug, PartialEq, Deserialize, Serialize, Outgoing)]
#[outgoing(name = "results")]
struct Done {
    id: u64,
}

#[subscriber("jobs", reply)]
async fn work(job: &Job) -> Done {
    Done { id: job.id }
}

pub fn app() -> RustStream {
    let collector = ZmqQueue::new(ZmqEndpoint::connect("tcp://collector:5560")).bindable();
    let results = collector.bind(Publish);
    RustStream::new(AppInfo::new("worker", "0.1.0"))
        .with_broker(ZmqQueue::new(ZmqEndpoint::bind("tcp://0.0.0.0:5555")), |b| {
            b.include(work).out_reply(results);
        })
        .register_broker(collector)
}

pub async fn the_result_reaches_the_collector() -> Result<(), Box<dyn Error>> {
    let tb = TestApp::start(app()).await?;

    tb.broker::<ZmqQueue>()
        .message(&Job { id: 7 })
        .to("jobs")
        .publish()
        .await?;

    tb.broker::<ZmqQueue<Connect>>()
        .published::<Done>("results")
        .assert_called_once()
        .with(&Done { id: 7 });
    tb.shutdown().await?;
    Ok(())
}

Trait Implementations

impl Clone for Connect

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 Connect

impl Debug for Connect

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

Formats the value using the given formatter.

impl Default for Connect

fn default() -> Self

Returns the “default value” for a type.

impl EndpointRole for Connect

impl Eq for Connect

impl Hash for Connect

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Connect

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Connect