Struct ServiceBuilder

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

Builder for Service

Implementations

impl<K> ServiceBuilder<K>

where K: KeyProvider,

pub fn new() -> Self

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) -> Self

Insert a custom protocol

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

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) -> Self

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) -> Self

Timeout for handshake and connect

Default timeout is 10 second

pub fn onion_timeout(self, onion_timeout: Duration) -> Self

Onion Timeout for handshake and connect

Default onion_timeout is 120 second

pub fn yamux_config(self, config: Config) -> Self

Yamux config for service

Panic when max_frame_length < yamux_max_window_size

pub fn max_frame_length(self, size: usize) -> Self

Secio max frame length

Panic when max_frame_length < yamux_max_window_size

pub fn set_channel_size(self, size: usize) -> Self

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

pub fn set_send_buffer_size(self, size: usize) -> Self

Set send buffer size, default is 24Mb

pub fn set_recv_buffer_size(self, size: usize) -> Self

Set receive buffer size, default is 24Mb

pub fn keep_buffer(self, keep: bool) -> Self

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) -> Self

Available on crate feature upnp only.

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) -> Self

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) -> Self

where F: Fn(TcpSocket, TransformerContext) -> 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, ctxt: TransformerContext| {
     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)?;
     if ctxt.is_dial() {
        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

Proxy and onion config will be ignored this config

pub fn tcp_proxy_config(self, proxy_url: &str) -> Self

Proxy config for tcp

Example: socks5://127.0.0.1:9050 Example: socks5://username:password@127.0.0.1:9050

pub fn tcp_onion_config(self, onion_url: &str) -> Self

Onion config for tcp

Example: socks5://127.0.0.1:9050

pub fn tcp_proxy_random_auth(self, proxy_random_auth: bool) -> Self

Onion config for proxy, use random username/password is set for proxy connection

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

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

Available on crate feature ws only.

The same as tcp config, but use on ws transport

pub fn clear(&mut self)

Clear all protocols

pub fn tls_config(self, config: TlsConfig) -> Self

Available on crate feature tls only.

set rustls ServerConfig, default is NoClientAuth

pub fn tcp_config_on_tls<F>(self, f: F) -> Self

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

Available on crate feature tls only.

The same as tcp config, but use on tls transport

Trait Implementations

impl<K> Default for ServiceBuilder<K>

fn default() -> Self

Returns the “default value” for a type.