Struct ntex_mqtt::v5::MqttServer

pub struct MqttServer<St, C, Cn, P> { /* private fields */ }

Mqtt Server

Implementations

impl<St, C> MqttServer<St, C, DefaultControlService<St, C::Error>, DefaultPublishService<St, C::Error>>

where C: ServiceFactory<Handshake, Response = HandshakeAck<St>>, C::Error: Debug,

pub fn new<F>(handshake: F) -> Self

where F: IntoServiceFactory<C, Handshake>,

Create server factory and provide handshake service

impl<St, C, Cn, P> MqttServer<St, C, Cn, P>

where St: 'static, C: ServiceFactory<Handshake, Response = HandshakeAck<St>> + 'static, C::Error: Debug, Cn: ServiceFactory<Control<C::Error>, Session<St>, Response = ControlAck> + 'static, P: ServiceFactory<Publish, Session<St>, Response = PublishAck> + 'static,

pub fn connect_timeout(self, timeout: Seconds) -> Self

Set client timeout for first Connect frame.

Defines a timeout for reading Connect frame. If a client does not transmit the entire frame within this time, the connection is terminated with Mqtt::Handshake(HandshakeError::Timeout) error.

By default, connect timeout is disabled.

pub fn disconnect_timeout(self, val: Seconds) -> Self

Set server connection disconnect timeout.

Defines a timeout for disconnect connection. If a disconnect procedure does not complete within this time, the connection get dropped.

To disable timeout set value to 0.

By default disconnect timeout is set to 3 seconds.

pub fn frame_read_rate( self, timeout: Seconds, max_timeout: Seconds, rate: u16 ) -> Self

Set read rate parameters for single frame.

Set read timeout, max timeout and rate for reading payload. If the client sends rate amount of data within timeout period of time, extend timeout by timeout seconds. But no more than max_timeout timeout.

By default frame read rate is disabled.

pub fn max_size(self, size: u32) -> Self

Set max inbound frame size.

If max size is set to 0, size is unlimited. By default max size is set to 0

pub fn receive_max(self, val: u16) -> Self

Set receive max

Number of in-flight publish packets. By default receive max is set to 15 packets. To disable timeout set value to 0.

pub fn max_topic_alias(self, val: u16) -> Self

Number of topic aliases.

By default value is set to 32

pub fn max_qos(self, qos: QoS) -> Self

Set server max qos setting.

By default max qos is not set.

pub fn max_inflight_size(self, val: usize) -> Self

Total size of in-flight messages.

By default total in-flight size is set to 64Kb

pub fn handle_qos_after_disconnect(self, max_qos: Option<QoS>) -> Self

Handle max received QoS messages after client disconnect.

By default, messages received before dispatched to the publish service will be dropped if the client disconnect immediately.

If this option is set to Some(QoS::AtMostOnce), only the QoS 0 messages received will always be handled by the server’s publish service no matter if the client is disconnected or not.

If this option is set to Some(QoS::AtLeastOnce), only the QoS 0 and QoS 1 messages received will always be handled by the server’s publish service no matter if the client is disconnected or not. The QoS 2 messages will be dropped if the client is disconnected before the server dispatches them to the publish service.

If this option is set to Some(QoS::ExactlyOnce), all the messages received will always be handled by the server’s publish service no matter if the client is disconnected or not.

By default handle-qos-after-disconnect is set to None

pub fn control<F, Srv>(self, service: F) -> MqttServer<St, C, Srv, P>

where F: IntoServiceFactory<Srv, Control<C::Error>, Session<St>>, Srv: ServiceFactory<Control<C::Error>, Session<St>, Response = ControlAck> + 'static, C::Error: From<Srv::Error> + From<Srv::InitError>,

Service to handle control packets

All control packets are processed sequentially, max number of buffered control packets is 16.

pub fn publish<F, Srv>(self, publish: F) -> MqttServer<St, C, Cn, Srv>

where F: IntoServiceFactory<Srv, Publish, Session<St>>, C::Error: From<Srv::Error> + From<Srv::InitError>, Srv: ServiceFactory<Publish, Session<St>, Response = PublishAck> + 'static, Srv::Error: Debug, PublishAck: TryFrom<Srv::Error, Error = C::Error>,

Set service to handle publish packets and create mqtt server factory

impl<St, C, Cn, P> MqttServer<St, C, Cn, P>

where St: 'static, C: ServiceFactory<Handshake, Response = HandshakeAck<St>> + 'static, C::Error: From<Cn::Error> + From<Cn::InitError> + From<P::Error> + From<P::InitError> + Debug, Cn: ServiceFactory<Control<C::Error>, Session<St>, Response = ControlAck> + 'static, P: ServiceFactory<Publish, Session<St>, Response = PublishAck> + 'static, P::Error: Debug, PublishAck: TryFrom<P::Error, Error = C::Error>,

pub fn finish( self ) -> MqttServer<Session<St>, impl ServiceFactory<IoBoxed, Response = (IoBoxed, Rc<MqttShared>, Session<St>, Seconds), Error = MqttError<C::Error>, InitError = C::InitError>, impl ServiceFactory<DispatchItem<Rc<MqttShared>>, Session<St>, Response = Option<Packet>, Error = MqttError<C::Error>, InitError = MqttError<C::Error>>, Rc<MqttShared>>

Finish server configuration and create mqtt server factory