Struct ServiceBuilder

pub struct ServiceBuilder<K> { /* private fields */ }

Builder for Service

Implementations

impl<K> ServiceBuilder<K>

where K: KeyProvider,

pub fn new() -> ServiceBuilder<K>

New a default empty builder

pub fn build<H>(self, handle: H) -> Service<H, K>

where H: ServiceHandle + Unpin + 'static,

Combine the configuration of this builder with service handle to create a Service.

pub fn insert_protocol(self, protocol: ProtocolMeta) -> ServiceBuilder<K>

Insert a custom protocol

pub fn handshake_type( self, handshake_type: HandshakeType<K>, ) -> ServiceBuilder<K>

Handshake encryption layer protocol selection

If you do not need encrypted communication, you do not need to call this method

pub fn forever(self, forever: bool) -> ServiceBuilder<K>

When the service has no tasks, it will be turned off by default. If you do not want to close service, set it to true.

pub fn timeout(self, timeout: Duration) -> ServiceBuilder<K>

Timeout for handshake and connect

Default 10 second

pub fn yamux_config(self, config: Config) -> ServiceBuilder<K>

Yamux config for service

Panic when max_frame_length < yamux_max_window_size

pub fn max_frame_length(self, size: usize) -> ServiceBuilder<K>

Secio max frame length

Panic when max_frame_length < yamux_max_window_size

pub fn set_channel_size(self, size: usize) -> ServiceBuilder<K>

Tentacle use lots of bound channel, default channel size is 128

pub fn set_send_buffer_size(self, size: usize) -> ServiceBuilder<K>

Set send buffer size, default is 24Mb

pub fn set_recv_buffer_size(self, size: usize) -> ServiceBuilder<K>

Set receive buffer size, default is 24Mb

pub fn keep_buffer(self, keep: bool) -> ServiceBuilder<K>

If session is close by remote, did you want to keep unreceived message as more as possible default is false

pub fn upnp(self, enable: bool) -> ServiceBuilder<K>

Whether to allow tentative registration upnp, default is disable(false)

upnp: https://en.wikipedia.org/wiki/Universal_Plug_and_Play

Upnp is a simple solution to nat penetration, which requires routing support for registration mapping.

The function provided here is that if the external ip of the query route is a public network, then an attempt is made to register the local listener port into the mapping so that it can receive the access request of the external network, and if the external ip of the route is not the public network, Then do nothing

pub fn max_connection_number(self, number: usize) -> ServiceBuilder<K>

The limit of max open connection(file descriptors) If not limited, service will try to serve as many connections as possible until it exhausts system resources(os error), and then close the listener, no longer accepting new connection requests, and the established connections remain working

Default is 65535

pub fn tcp_config<F>(self, f: F) -> ServiceBuilder<K>

where F: Fn(TcpSocket) -> Result<TcpSocket, Error> + Send + Sync + 'static,

Users can make their own custom configuration for all tcp socket at the bottom of Tentacle according to their own needs, for example, use reuse port to try to build nat penetration

In this way, any actively connected outbound connection is potentially connectable. Through this setting, the device after NAT can have the opportunity to be connected to the public network.

TCP Hole Punching: http://bford.info/pub/net/p2pnat/ STUN: https://tools.ietf.org/html/rfc5389

for example, set all tcp bind to 127.0.0.1:1080, set keepalive:

 use socket2;
 use tentacle::{service::TcpSocket, builder::ServiceBuilder};
 #[cfg(unix)]
 use std::os::unix::io::{FromRawFd, IntoRawFd};
 #[cfg(windows)]
 use std::os::windows::io::{FromRawSocket, IntoRawSocket};
 use std::net::SocketAddr;

 let mut server = ServiceBuilder::new();
 server.tcp_config(|socket: TcpSocket| {
     let socket = unsafe {
        #[cfg(unix)]
        let socket = socket2::Socket::from_raw_fd(socket.into_raw_fd());
        #[cfg(windows)]
        let socket = socket2::Socket::from_raw_socket(socket.into_raw_socket());
        socket
     };
     #[cfg(all(unix, not(target_os = "solaris"), not(target_os = "illumos")))]
     socket.set_reuse_port(true)?;

     socket.set_reuse_address(true)?;
     socket.bind(&"127.0.0.1:1080".parse::<SocketAddr>().unwrap().into())?;
     socket.set_keepalive(true)?;
     let socket = unsafe {
        #[cfg(unix)]
        let socket = TcpSocket::from_raw_fd(socket.into_raw_fd());
        #[cfg(windows)]
        let socket = TcpSocket::from_raw_socket(socket.into_raw_socket());
        socket
     };
     Ok(socket)
});

Note

User use listen(2) or connect(2) on this closure will cause abnormal behavior

pub fn tcp_config_on_ws<F>(self, f: F) -> ServiceBuilder<K>

where F: Fn(TcpSocket) -> Result<TcpSocket, Error> + Send + Sync + 'static,

The same as tcp config, but use on ws transport

pub fn clear(&mut self)

Clear all protocols

Trait Implementations

impl<K> Default for ServiceBuilder<K>

fn default() -> ServiceBuilder<K>

Returns the “default value” for a type.