Created
May 18, 2021 01:56
-
-
Save kingluo/73592448153fcc0e48788a5f9080b3bd to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment