Struct MqttPublisher 

pub struct MqttPublisher { /* private fields */ }

Publishes messages to MQTT topics through the shared connection.

The publish is queued into the client session, so Ok means “owned by the session”, not “broker confirmed”. For QoS 1/2 the client keeps the message until the broker acknowledges it, across reconnects: a resumed session retransmits it, and a new session sends it again, where it may arrive twice. Buildable before connect and usable until shutdown; afterwards every publish reports MqttError::NotConnected.

Headers are sent as MQTT 5 user properties, so non-Rust peers see plain MQTT messages. The content-type, reply-to and correlation-id headers take the matching first-class properties (content type, response topic, correlation data), in both directions, and a message with no headers carries no properties at all. A textual content type (application/json, any text/ subtype, any +json vendor type) sets the payload format indicator to 1, and every other one to 0. A header name or value that is not text an MQTT string carries refuses the publish with MqttError::Publish; the correlation data is binary on the wire and takes any bytes.

Examples

Nothing writes the media type for a service: a reply, a deferred retry copy and a plain publish carry the headers something put on them. A service whose peers read the content type property sets it once at the mount site, through a publish transform over the position:

use ruststream::runtime::{Outgoing, Reads};
use ruststream_rumqttc::prelude::*;
use serde::{Deserialize, Serialize};

/// States the media type of every message this position sends, which is what fills the content
/// type property and decides the payload format indicator. It reads nothing about the delivery,
/// so it is generic over the position and mounts on any of them.
struct Json;

impl<K: ContextKind, Options> PublishTransform<K, Options> for Json {
    type Destination = Reads;

    fn apply(&self, out: &mut Outgoing<'_>, _options: &mut Option<Options>, _cx: &K::View<'_>) {
        out.headers_mut().insert("content-type", "application/json");
    }
}

#[derive(Deserialize)]
struct Telemetry {
    device: String,
    temperature: f64,
}

#[derive(Serialize, Outgoing)]
#[outgoing(name = "devices/state")]
struct DeviceState {
    device: String,
    hot: bool,
}

#[subscriber(MqttFilter::new("devices/+/telemetry"), reply)]
async fn track(telemetry: &Telemetry) -> DeviceState {
    DeviceState { device: telemetry.device.clone(), hot: telemetry.temperature > 30.0 }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("states", "0.1.0")).with_broker(
        MqttBroker::new("mqtt://localhost:1883", "states-svc"),
        |b| {
            // Every reply now carries the content type property and the payload format
            // indicator 1, so a peer reads the body as UTF-8 JSON.
            b.include(track)
                .out_reply(Publish::default())
                .transform(Json)
                .out_retry(Publish::default())
                .to("devices/retry/telemetry");
        },
    )
}

Trait Implementations

impl Clone for MqttPublisher

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MqttPublisher

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

Formats the value using the given formatter.

impl Publisher for MqttPublisher

type Payload = Take

The client keeps the payload: a PUBLISH packet is queued into the session, which holds the Bytes until the broker acknowledges it.

type Error = MqttError

The error type returned by publish.

type Options = MqttPublishOptions

The broker’s per-message settings: a QoS, a priority, an ordering key, whatever this transport lets one message differ from the next in.

async fn publish( &self, msg: OutgoingMessage<'_, BytesMut>, options: Option<&Self::Options>, ) -> Result<(), Self::Error>

Publishes a message to the broker, with the per-message settings the call site adjusted.

fn base_headers(&self) -> Option<&HeaderMap>

The headers this publisher contributes to every message it sends, underneath whatever the message itself names.