kingluo/hyper main.rs

## hyper main.rs
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use std::net::SocketAddr;

async fn hello_world(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    //let path = _req.uri().path();
    //let v: Vec<&str> = path.split('/').collect();
    //let str = format!("hello {}", v[2]);
    //Ok(Response::new(str.into()))
    Ok(Response::new(Body::from("hello world")))
}

#[tokio::main]
async fn main() {
    // We'll bind to 127.0.0.1:3000
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

    // A `Service` is needed for every connection, so this
    // creates one from our `hello_world` function.
    let make_svc = make_service_fn(|_conn| async {
        // service_fn converts our function into a `Service`
        Ok::<_, Infallible>(service_fn(hello_world))
    });

    let server = Server::bind(&addr).serve(make_svc);

    // Run this server for... forever!
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}

## routerify main.rs
use hyper::{Body, Request, Response, Server};
use routerify::prelude::*;
use routerify::{Router, RouterService};
use std::{convert::Infallible, net::SocketAddr};

async fn home_handler(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("home page")))
}
async fn hello_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
    let name = req.param("name").unwrap();
    Ok(Response::new(Body::from(format!("Hello {}", name))))
}

fn router() -> Router<Body, Infallible> {
    Router::builder()
        .get("/", home_handler)
        .get("/hello/:name", hello_handler)
        .build()
        .unwrap()
}

#[tokio::main]
async fn main() {
    let router = router();

    // Create a Service from the router above to handle incoming requests.
    let service = RouterService::new(router).unwrap();

    // The address on which the server will be listening.
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

    // Create a server by passing the created service to `.serve` method.
    let server = Server::bind(&addr).serve(service);

    println!("App is running on: {}", addr);
    if let Err(err) = server.await {
        eprintln!("Server error: {}", err);
    }
}

## routerify-lite main.rs
use hyper::{header, Body, Request, Response, Server, StatusCode};
use routerify_lite::{RequestExt, Router, RouterService};
use std::{convert::Infallible, net::SocketAddr};

async fn any_method_handler(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("any method")))
}

async fn hello_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
    let user = req.param("name").unwrap();
    Ok(Response::new(Body::from(format!("Hello {}", user))))
}

async fn err_404_handler(_: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::builder()
        .status(StatusCode::NOT_FOUND)
        .header(header::CONTENT_TYPE, "text/plain")
        .body(hyper::Body::from(
            StatusCode::NOT_FOUND.canonical_reason().unwrap(),
        ))
        .expect("Couldn't create the default 404 response"))
}

fn router() -> Router<Body, Infallible> {
    Router::new()
        .get("/", |_| async {
            Ok(Response::new(Body::from("Home page")))
        })
        .get("/hello/:name", hello_handler)
        .any_method("/any_method", any_method_handler)
        .any(err_404_handler)
        .build()
        .unwrap()
}

#[tokio::main]
async fn main() {
    // Create a Service from the router above to handle incoming requests.
    let router = router();

    let service = RouterService::new(router);

    // The address on which the server will be listening.
    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

    // Create a server by passing the created service to `.serve` method.
    let server = Server::bind(&addr).serve(service);

    println!("App is running on: {}", addr);
    if let Err(err) = server.await {
        eprintln!("Server error: {}", err);
    }
}

## warp main.rs
use warp::Filter;

#[tokio::main]
async fn main() {
    let routes = warp::path::end().map(|| "hello world");
    // GET /hello/warp => 200 OK with body "Hello, warp!"
    let hello = warp::path!("hello" / String).map(|name| format!("Hello {}", name));
    let hello = routes.or(hello);

    warp::serve(hello).run(([0, 0, 0, 0], 8080)).await;
}
	use hyper::service::{make_service_fn, service_fn};
	use hyper::{Body, Request, Response, Server};
	use std::convert::Infallible;
	use std::net::SocketAddr;

	async fn hello_world(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
	//let path = _req.uri().path();
	//let v: Vec<&str> = path.split('/').collect();
	//let str = format!("hello {}", v[2]);
	//Ok(Response::new(str.into()))
	Ok(Response::new(Body::from("hello world")))
	}

	#[tokio::main]
	async fn main() {
	// We'll bind to 127.0.0.1:3000
	let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

	// A `Service` is needed for every connection, so this
	// creates one from our `hello_world` function.
	let make_svc = make_service_fn(\|_conn\| async {
	// service_fn converts our function into a `Service`
	Ok::<_, Infallible>(service_fn(hello_world))
	});

	let server = Server::bind(&addr).serve(make_svc);

	// Run this server for... forever!
	if let Err(e) = server.await {
	eprintln!("server error: {}", e);
	}
	}
	use hyper::{Body, Request, Response, Server};
	use routerify::prelude::*;
	use routerify::{Router, RouterService};
	use std::{convert::Infallible, net::SocketAddr};

	async fn home_handler(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
	Ok(Response::new(Body::from("home page")))
	}
	async fn hello_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
	let name = req.param("name").unwrap();
	Ok(Response::new(Body::from(format!("Hello {}", name))))
	}

	fn router() -> Router<Body, Infallible> {
	Router::builder()
	.get("/", home_handler)
	.get("/hello/:name", hello_handler)
	.build()
	.unwrap()
	}

	#[tokio::main]
	async fn main() {
	let router = router();

	// Create a Service from the router above to handle incoming requests.
	let service = RouterService::new(router).unwrap();

	// The address on which the server will be listening.
	let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

	// Create a server by passing the created service to `.serve` method.
	let server = Server::bind(&addr).serve(service);

	println!("App is running on: {}", addr);
	if let Err(err) = server.await {
	eprintln!("Server error: {}", err);
	}
	}
	use hyper::{header, Body, Request, Response, Server, StatusCode};
	use routerify_lite::{RequestExt, Router, RouterService};
	use std::{convert::Infallible, net::SocketAddr};

	async fn any_method_handler(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
	Ok(Response::new(Body::from("any method")))
	}

	async fn hello_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
	let user = req.param("name").unwrap();
	Ok(Response::new(Body::from(format!("Hello {}", user))))
	}

	async fn err_404_handler(_: Request<Body>) -> Result<Response<Body>, Infallible> {
	Ok(Response::builder()
	.status(StatusCode::NOT_FOUND)
	.header(header::CONTENT_TYPE, "text/plain")
	.body(hyper::Body::from(
	StatusCode::NOT_FOUND.canonical_reason().unwrap(),
	))
	.expect("Couldn't create the default 404 response"))
	}

	fn router() -> Router<Body, Infallible> {
	Router::new()
	.get("/", \|_\| async {
	Ok(Response::new(Body::from("Home page")))
	})
	.get("/hello/:name", hello_handler)
	.any_method("/any_method", any_method_handler)
	.any(err_404_handler)
	.build()
	.unwrap()
	}

	#[tokio::main]
	async fn main() {
	// Create a Service from the router above to handle incoming requests.
	let router = router();

	let service = RouterService::new(router);

	// The address on which the server will be listening.
	let addr = SocketAddr::from(([0, 0, 0, 0], 8080));

	// Create a server by passing the created service to `.serve` method.
	let server = Server::bind(&addr).serve(service);

	println!("App is running on: {}", addr);
	if let Err(err) = server.await {
	eprintln!("Server error: {}", err);
	}
	}
	use warp::Filter;

	#[tokio::main]
	async fn main() {
	let routes = warp::path::end().map(\|\| "hello world");
	// GET /hello/warp => 200 OK with body "Hello, warp!"
	let hello = warp::path!("hello" / String).map(\|name\| format!("Hello {}", name));
	let hello = routes.or(hello);

	warp::serve(hello).run(([0, 0, 0, 0], 8080)).await;
	}