Struct WsClient 

pub struct WsClient { /* private fields */ }

WebSocket client implementation

Implementations

impl WsClient

pub fn from_url(url: &str) -> Result<Self, Box<dyn Error>>

Create a new WebSocket client from URL string

pub fn new<A: ToSocketAddrs>(addr: A) -> Result<Self, Box<dyn Error>>

Create a new WebSocket client

pub fn blocking_session( &self, token: Option<String>, ) -> Result<WsBlockingSession, Error>

Create a blocking session

Examples found in repository

examples/blocking_ws.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB server - various ways to specify address:
	// Using tuple (address, port):
	let client = Client::ws(("127.0.0.1", 8090))?;

	// Create a blocking session with authentication
	let mut session = client.blocking_session(Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	let command_result =
		session.command("CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }", None)?;
	println!("Command executed: {} frames returned", command_result.frames.len());

	// Execute a query
	let query_result = session.query("MAP { x: 42, y: 'hello' }", None)?;

	println!("Query executed: {} frames returned", query_result.frames.len());

	// Print first frame if available
	if let Some(frame) = query_result.frames.first() {
		println!("First frame:\n{}", frame);
	}

	Ok(())
}

pub fn callback_session( &self, token: Option<String>, ) -> Result<WsCallbackSession, Error>

Create a callback-based session

Examples found in repository

examples/callback_ws.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB server
	let client = Client::ws(("127.0.0.1", 8090))?;

	// Create a callback session with authentication
	let session = client.callback_session(Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	let command_id = session.command(
		"CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }",
		None,
		|result| match result {
			Ok(data) => println!("Command executed: {} frames returned", data.frames.len()),
			Err(e) => println!("Command failed: {}", e),
		},
	)?;
	println!("Command sent with ID: {}", command_id);

	// Execute a query
	let query_id = session.query("MAP { x: 42, y: 'hello' }", None, |result| {
		match result {
			Ok(data) => {
				println!("Query executed: {} frames returned", data.frames.len());
				// Print first frame if available
				if let Some(frame) = data.frames.first() {
					println!("First frame:\n{}", frame);
				}
			}
			Err(e) => println!("Query failed: {}", e),
		}
	})?;
	println!("Query sent with ID: {}", query_id);

	// Wait for callbacks to complete
	thread::sleep(Duration::from_millis(500));

	Ok(())
}

pub fn channel_session( &self, token: Option<String>, ) -> Result<(WsChannelSession, Receiver<ResponseMessage>), Error>

Create a channel-based session

Examples found in repository

examples/channel_ws.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB server
	let client = Client::ws(("127.0.0.1", 8090))?;

	// Create a channel session with authentication
	let (session, receiver) = client.channel_session(Some("mysecrettoken".to_string()))?;

	// Consume authentication response
	if let Ok(msg) = receiver.recv_timeout(Duration::from_millis(100)) {
		if let Ok(ChannelResponse::Auth {
			request_id,
		}) = msg.response
		{
			println!("Authenticated with ID: {}", request_id);
		}
	}

	// Execute a command to create a table
	let command_id =
		session.command("CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }", None)?;
	println!("Command sent with ID: {}", command_id);

	// Execute a query
	let query_id = session.query("MAP { x: 42, y: 'hello' }", None)?;
	println!("Query sent with ID: {}", query_id);

	// Receive responses
	let mut received = 0;
	while received < 2 {
		match receiver.recv_timeout(Duration::from_secs(1)) {
			Ok(msg) => {
				match msg.response {
					Ok(ChannelResponse::Command {
						request_id,
						result,
					}) => {
						println!(
							"Command {} executed: {} frames returned",
							request_id,
							result.frames.len()
						);
						received += 1;
					}
					Ok(ChannelResponse::Query {
						request_id,
						result,
					}) => {
						println!(
							"Query {} executed: {} frames returned",
							request_id,
							result.frames.len()
						);
						// Print first frame if
						// available
						if let Some(frame) = result.frames.first() {
							println!("First frame:\n{}", frame);
						}
						received += 1;
					}
					Ok(ChannelResponse::Auth {
						..
					}) => {
						// Already handled above
					}
					Err(e) => {
						println!("Request {} failed: {}", msg.request_id, e);
						received += 1;
					}
				}
			}
			Err(_) => {
				println!("Timeout waiting for responses");
				break;
			}
		}
	}

	Ok(())
}

pub fn close(self) -> Result<(), Box<dyn Error>>

Close the client connection

Trait Implementations

impl Clone for WsClient

fn clone(&self) -> WsClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for WsClient

fn drop(&mut self)

Executes the destructor for this type.