Struct HttpCallbackSession 

pub struct HttpCallbackSession { /* private fields */ }

A callback-based HTTP session for asynchronous operations

Implementations

impl HttpCallbackSession

pub fn new(host: &str, port: u16, token: Option<String>) -> Result<Self, Error>

Create a new callback HTTP session

Examples found in repository

examples/callback_http.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB HTTP server
	let session = HttpCallbackSession::new("127.0.0.1", 8090, Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	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");

	// Execute a query
	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");

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

	Ok(())
}

pub fn from_client( client: HttpClient, token: Option<String>, ) -> Result<Self, Error>

Create a new callback HTTP session from an existing client

pub fn from_url(url: &str, token: Option<String>) -> Result<Self, Error>

Create from URL (e.g., “http://localhost:8080”)

pub fn with_timeout(self, _timeout: Duration) -> Self

Set timeout for requests

pub fn command<F>( &self, rql: &str, params: Option<Params>, callback: F, ) -> Result<String, Error>

where F: FnOnce(Result<CommandResult, Error>) + Send + 'static,

Send a command with callback

Examples found in repository

examples/callback_http.rs (lines 13-18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB HTTP server
	let session = HttpCallbackSession::new("127.0.0.1", 8090, Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	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");

	// Execute a query
	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");

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

	Ok(())
}

pub fn query<F>( &self, rql: &str, params: Option<Params>, callback: F, ) -> Result<String, Error>

where F: FnOnce(Result<QueryResult, Error>) + Send + 'static,

Send a query with callback

Examples found in repository

examples/callback_http.rs (lines 22-33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB HTTP server
	let session = HttpCallbackSession::new("127.0.0.1", 8090, Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	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");

	// Execute a query
	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");

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

	Ok(())
}

pub fn is_authenticated(&self) -> bool

Check if the session is authenticated

impl HttpCallbackSession

pub fn command_with_handler( &self, rql: &str, params: Option<Params>, handler: impl HttpResponseHandler + 'static, ) -> Result<String, Error>

Execute command with a response handler

pub fn query_with_handler( &self, rql: &str, params: Option<Params>, handler: impl HttpQueryHandler + 'static, ) -> Result<String, Error>

Execute query with a response handler

Trait Implementations

impl Drop for HttpCallbackSession

fn drop(&mut self)

Executes the destructor for this type.