Struct rust_socketio::ClientBuilder

pub struct ClientBuilder { /* private fields */ }

A builder class for a socket.io socket. This handles setting up the client and configuring the callback, the namespace and metadata of the socket. If no namespace is specified, the default namespace / is taken. The connect method acts the build method and returns a connected Client.

Implementations

impl ClientBuilder

pub fn new<T: Into<String>>(address: T) -> Self

Create as client builder from a URL. URLs must be in the form [ws or wss or http or https]://[domain]:[port]/[path]. The path of the URL is optional and if no port is given, port 80 will be used.

Example

use rust_socketio::{ClientBuilder, Payload, Client};
use serde_json::json;


let callback = |payload: Payload, socket: Client| {
           match payload {
               Payload::String(str) => println!("Received: {}", str),
               Payload::Binary(bin_data) => println!("Received bytes: {:#?}", bin_data),
           }
};

let mut socket = ClientBuilder::new("http://localhost:4200")
    .namespace("/admin")
    .on("test", callback)
    .connect()
    .expect("error while connecting");

// use the socket
let json_payload = json!({"token": 123});

let result = socket.emit("foo", json_payload);

assert!(result.is_ok());

pub fn namespace<T: Into<String>>(self, namespace: T) -> Self

Sets the target namespace of the client. The namespace should start with a leading /. Valid examples are e.g. /admin, /foo.

pub fn on<T: Into<Event>, F>(self, event: T, callback: F) -> Self where
    F: for<'a> FnMut(Payload, Client) + 'static + Sync + Send, 

Registers a new callback for a certain [socketio::event::Event]. The event could either be one of the common events like message, error, connect, close or a custom event defined by a string, e.g. onPayment or foo.

Example

use rust_socketio::{ClientBuilder, Payload};

let socket = ClientBuilder::new("http://localhost:4200/")
    .namespace("/admin")
    .on("test", |payload: Payload, _| {
           match payload {
               Payload::String(str) => println!("Received: {}", str),
               Payload::Binary(bin_data) => println!("Received bytes: {:#?}", bin_data),
           }
    })
    .on("error", |err, _| eprintln!("Error: {:#?}", err))
    .connect();

pub fn tls_config(self, tls_config: TlsConnector) -> Self

Uses a preconfigured TLS connector for secure communication. This configures both the polling as well as the websocket transport type.

Example

use rust_socketio::{ClientBuilder, Payload};
use native_tls::TlsConnector;

let tls_connector =  TlsConnector::builder()
           .use_sni(true)
           .build()
           .expect("Found illegal configuration");

let socket = ClientBuilder::new("http://localhost:4200/")
    .namespace("/admin")
    .on("error", |err, _| eprintln!("Error: {:#?}", err))
    .tls_config(tls_connector)
    .connect();

pub fn opening_header<T: Into<HeaderValue>, K: Into<String>>(
    self,
    key: K,
    val: T
) -> Self

Sets custom http headers for the opening request. The headers will be passed to the underlying transport type (either websockets or polling) and then get passed with every request thats made. via the transport layer.

Example

use rust_socketio::{ClientBuilder, Payload};


let socket = ClientBuilder::new("http://localhost:4200/")
    .namespace("/admin")
    .on("error", |err, _| eprintln!("Error: {:#?}", err))
    .opening_header("accept-encoding", "application/json")
    .connect();

pub fn transport_type(self, transport_type: TransportType) -> Self

Specifies which EngineIO TransportType to use.

Example

use rust_socketio::{ClientBuilder, TransportType};

let socket = ClientBuilder::new("http://localhost:4200/")
    // Use websockets to handshake and connect.
    .transport_type(TransportType::Websocket)
    .connect()
    .expect("connection failed");

// use the socket

pub fn connect(self) -> Result<Client, Error>

Connects the socket to a certain endpoint. This returns a connected Client instance. This method returns an std::result::Result::Err value if something goes wrong during connection. Also starts a separate thread to start polling for packets. Used with callbacks.

Example

use rust_socketio::{ClientBuilder, Payload};
use serde_json::json;


let mut socket = ClientBuilder::new("http://localhost:4200/")
    .namespace("/admin")
    .on("error", |err, _| eprintln!("Client error!: {:#?}", err))
    .connect()
    .expect("connection failed");

// use the socket
let json_payload = json!({"token": 123});

let result = socket.emit("foo", json_payload);

assert!(result.is_ok());