Struct MicroHTTP

pub struct MicroHTTP { /* private fields */ }

This is the main struct of the µHTTP server.

Implementations

impl MicroHTTP

pub fn new(interface: impl ToSocketAddrs) -> Result<MicroHTTP, Error>

Create a new MicroHTTP server on the given interface.microhttp

Internally, this just tries to create a TcpListener - nothing special. Returns the new MicroHTTP server or an std::io::Error on error.

Example

use micro_http_server::MicroHTTP;

let interface: &str = "127.0.0.1:3000";
let server = MicroHTTP::new(interface)
    .expect("Could not create server, maybe the port is already being used?");

Examples found in repository

examples/echo.rs (line 5)

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 set_nonblocking(&mut self, state: bool) -> Result<(), Error>

Set whether or not the underlying TcpListener awaits connections in nonblocking mode

pub fn next_client(&self) -> Result<Option<Client>, Error>

Return the next available client which is incoming at this server.

Returns either:

• Some(client) if a client is available
• None if no client is currently available (i.e. no one has reached out to the server yet)
• std::io::Error if something is wrong with the server.

Example

use std::{io::{Read,Write},net::TcpStream};
use micro_http_server::MicroHTTP;

let server = MicroHTTP::new("127.0.0.1:3000").expect("Could not create server.");
println!("[Server] Waiting for a client @ 127.0.0.1:3000...");

loop {
    let result = server.next_client();
    if result.is_err() {
        println!("Something is wrong with the client: {:?}", result.unwrap_err());
        break;
    }

    match result.unwrap() {
        None => {
            // Here you can sleep or do something else.
            println!("Still waiting for clients...");
        },
        Some(client) => {
            println!("Got a new client from: {:?}", client.addr());
        }
    }
}

Examples found in repository

examples/echo.rs (line 11)

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!");
				}
			}
		}
	}
}