Struct ntex_amqp::server::Server

pub struct Server<Io, St, H, Ctl> { /* fields omitted */ }

Server dispatcher factory

Implementations

impl<Io, St, H> Server<Io, St, H, DefaultControlService<St, H::Error>> where
    St: 'static,
    Io: AsyncRead + AsyncWrite + Unpin + 'static,
    H: ServiceFactory<Config = (), Request = Handshake<Io>, Response = HandshakeAck<Io, St>> + 'static,
    H::Error: Debug, 

pub fn new<F>(handshake: F) -> Self where
    F: IntoServiceFactory<H>, 

Create server factory and provide handshake service

impl<Io, St, H, Ctl> Server<Io, St, H, Ctl>

pub fn config(self, config: Configuration) -> Self

Provide connection configuration

pub fn max_size(self, size: usize) -> 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 handshake_timeout(self, timeout: Seconds) -> Self

Set handshake timeout.

By default handshake timeuot is 5 seconds.

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 buffer_params(
    self,
    max_read_buf_size: u16,
    max_write_buf_size: u16,
    min_buf_size: u16
) -> Self

Set read/write buffer params

By default read buffer is 8kb, write buffer is 8kb

impl<Io, St, H, Ctl> Server<Io, St, H, Ctl> where
    St: 'static,
    Io: AsyncRead + AsyncWrite + Unpin + 'static,
    H: ServiceFactory<Config = (), Request = Handshake<Io>, Response = HandshakeAck<Io, St>> + 'static,
    H::Error: Debug,
    Ctl: ServiceFactory<Config = State<St>, Request = ControlFrame, Response = ()> + 'static,
    Ctl::Error: Debug,
    Ctl::InitError: Debug,
    Error: From<Ctl::Error>, 

pub fn control<F, S>(self, service: F) -> Server<Io, St, H, S> where
    F: IntoServiceFactory<S>,
    S: ServiceFactory<Config = State<St>, Request = ControlFrame, Response = ()> + 'static,
    S::Error: Debug,
    S::InitError: Debug,
    Error: From<S::Error>, 

Service to call with control frames

pub fn finish<F, Pb>(
    self,
    service: F
) -> impl ServiceFactory<Config = (), Request = Io, Response = (), Error = ServerError<H::Error>, InitError = H::InitError> where
    F: IntoServiceFactory<Pb>,
    Pb: ServiceFactory<Config = State<St>, Request = Message, Response = ()> + 'static,
    Pb::Error: Debug,
    Pb::InitError: Debug,
    Error: From<Pb::Error> + From<Ctl::Error>, 

Set service to execute for incoming links and create service factory