Struct Client

pub struct Client { /* private fields */ }

This struct represents a client which has connected to the µHTTP server.microhttp

If an instance of this struct is dropped, the connection is closed.

Implementations

impl Client

pub fn addr(&self) -> SocketAddr

Return the address of the requesting client, for example “1.2.3.4:9435”.

Examples found in repository

examples/echo.rs (line 21)

pub fn main() {
	let server = MicroHTTP::new("127.0.0.1:3000")
		.expect("Could not create server.");

	println!("Waiting for requests on: http://127.0.0.1:3000");

	loop {
		let result = server.next_client();
		if result.is_err() {
			println!("Server failed: {:?}", result);
			break;
		}

		match result.unwrap() {
			None => ::std::thread::sleep(::std::time::Duration::from_millis(500)),
			Some(mut client) => {
				if client.request().is_none() {
					println!("Client {} didn't send any request", client.addr());
					client.respond_ok("No request :(".as_bytes())
						.expect("Could not send data to client!");
				} else {
					let request_copy = client.request().as_ref().unwrap().clone();

					println!("Client {} requested {}, echoing...", client.addr(), request_copy);
					client.respond_ok(request_copy.as_bytes())
						.expect("Could not send data to client!");
				}
			}
		}
	}
}

pub fn request(&self) -> &Option<String>

Return the request the client made or None if the client didn’t make any or an invalid one.

Note: At the moment, only HTTP GET is supported. Any other requests will not be collected.

Examples found in repository

examples/echo.rs (line 20)

pub fn main() {
	let server = MicroHTTP::new("127.0.0.1:3000")
		.expect("Could not create server.");

	println!("Waiting for requests on: http://127.0.0.1:3000");

	loop {
		let result = server.next_client();
		if result.is_err() {
			println!("Server failed: {:?}", result);
			break;
		}

		match result.unwrap() {
			None => ::std::thread::sleep(::std::time::Duration::from_millis(500)),
			Some(mut client) => {
				if client.request().is_none() {
					println!("Client {} didn't send any request", client.addr());
					client.respond_ok("No request :(".as_bytes())
						.expect("Could not send data to client!");
				} else {
					let request_copy = client.request().as_ref().unwrap().clone();

					println!("Client {} requested {}, echoing...", client.addr(), request_copy);
					client.respond_ok(request_copy.as_bytes())
						.expect("Could not send data to client!");
				}
			}
		}
	}
}

pub fn respond_ok(&mut self, data: &[u8]) -> Result<usize>

Send a HTTP 200 OK response to the client + the provided data. The data may be an empty array, for example the following implementation echos all requests except “/hello”:

Consider using respond_ok_chunked for sending file-backed data.

use micro_http_server::MicroHTTP;
use std::io::*;
let server = MicroHTTP::new("127.0.0.1:4000").expect("Could not create server.");
let mut client = server.next_client().unwrap().unwrap();
let request_str: String = client.request().as_ref().unwrap().clone();

match request_str.as_ref() {
	"/hello" => client.respond_ok(&[]),
    _ => client.respond_ok(request_str.as_bytes())  // Echo request
};

Examples found in repository

examples/echo.rs (line 22)

pub fn main() {
	let server = MicroHTTP::new("127.0.0.1:3000")
		.expect("Could not create server.");

	println!("Waiting for requests on: http://127.0.0.1:3000");

	loop {
		let result = server.next_client();
		if result.is_err() {
			println!("Server failed: {:?}", result);
			break;
		}

		match result.unwrap() {
			None => ::std::thread::sleep(::std::time::Duration::from_millis(500)),
			Some(mut client) => {
				if client.request().is_none() {
					println!("Client {} didn't send any request", client.addr());
					client.respond_ok("No request :(".as_bytes())
						.expect("Could not send data to client!");
				} else {
					let request_copy = client.request().as_ref().unwrap().clone();

					println!("Client {} requested {}, echoing...", client.addr(), request_copy);
					client.respond_ok(request_copy.as_bytes())
						.expect("Could not send data to client!");
				}
			}
		}
	}
}

pub fn respond_ok_chunked( &mut self, data: impl Read, content_size: usize, ) -> Result<usize>

Send a HTTP 200 OK response to the client + the provided data. The data may be any type implementing Read and will be read in chunks. This is useful for serving file-backed data that should not be loaded into memory all at once.

use micro_http_server::MicroHTTP;
use std::io::*;
use std::fs::*;
let server = MicroHTTP::new("127.0.0.1:4000").expect("Could not create server.");
let mut client = server.next_client().unwrap().unwrap();
client.request();

let mut file_handle = OpenOptions::new()
	.read(true)
	.write(false)
	.open("/some/local/file")
	.unwrap();
let file_len = file_handle.metadata().unwrap().len() as usize;

client.respond_ok_chunked(file_handle, file_len);

pub fn respond( &mut self, status_code: &str, data: &[u8], headers: &Vec<String>, ) -> Result<usize>

Send response data to the client.

This is similar to respond_ok, but you may control the details yourself.

Consider using respond_chunked for sending file-backed data.

Parameters

• status_code: Select the status code of the response, e.g. 200 OK.
• data: Data to transmit. May be empty.
• headers: Additional headers to add to the response. May be empty.

Calling respond("200 OK", data, &vec!()) is the same as calling respond_ok(data).

pub fn respond_chunked( &mut self, status_code: &str, data: impl Read, content_size: usize, headers: &Vec<String>, ) -> Result<usize>

Send repsonse data to the client.

This is similar to respond_ok_chunked, but you may control the details yourself.

Parameters

• status_code: Select the status code of the response, e.ge 200 OK.
• data: Data to transmit. May be empty
• content_size: Size of the data to transmit in bytes
• headers: Additional headers to add to the response. May be empty.

Calling respond_chunked("200 OK", data, content_size, &vec!()) is the same as calling repsond_ok_chunked(data, content_size).

Trait Implementations

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.