MeexReay/ezhttp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some refactor

Browse Source
This commit is contained in:
MeexReay 2024-06-03 18:20:20 +03:00
parent 235284094c
commit 60e53910c2
3 changed files with 45 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -30,7 +30,7 @@ impl HttpServer for EzSite {
} }
} }
async fn on_start(&mut self, host: &str, listener: &TcpListener) { async fn on_start(&mut self, host: &str, _listener: &TcpListener) {
println!("Http server started on {}", host); println!("Http server started on {}", host);
} }

90
src/lib.rs
View File

@ -1,6 +1,10 @@
use serde_json::Value; use serde_json::Value;
use std::{ use std::{
boxed::Box, error::Error, net::{IpAddr, SocketAddr, ToSocketAddrs}, ptr::read, sync::Arc future::Future,
boxed::Box,
error::Error,
net::{IpAddr, SocketAddr, ToSocketAddrs},
sync::Arc
}; };
use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader}; use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::{ use tokio::{
@ -8,7 +12,6 @@ use tokio::{
net::{TcpListener, TcpStream}, net::{TcpListener, TcpStream},
sync::Mutex, sync::Mutex,
}; };
use urlencoding::{decode, encode};
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct Headers { pub struct Headers {
@ -36,7 +39,7 @@ impl Headers {
} }
pub fn contains_value(self, value: String) -> bool { pub fn contains_value(self, value: String) -> bool {
for (k, v) in self.entries { for (_, v) in self.entries {
if v == value { if v == value {
return true; return true;
} }
@ -45,7 +48,7 @@ impl Headers {
} }
pub fn contains_key(self, key: String) -> bool { pub fn contains_key(self, key: String) -> bool {
for (k, v) in self.entries { for (k, _) in self.entries {
if k == key.to_lowercase() { if k == key.to_lowercase() {
return true; return true;
} }
@ -83,7 +86,7 @@ impl Headers {
pub fn keys(self) -> Vec<String> { pub fn keys(self) -> Vec<String> {
let mut keys = Vec::new(); let mut keys = Vec::new();
for (k, v) in self.entries { for (k, _) in self.entries {
keys.push(k.to_lowercase()); keys.push(k.to_lowercase());
} }
keys keys
@ -91,7 +94,7 @@ impl Headers {
pub fn values(self) -> Vec<String> { pub fn values(self) -> Vec<String> {
let mut values = Vec::new(); let mut values = Vec::new();
for (k, v) in self.entries { for (_, v) in self.entries {
values.push(v); values.push(v);
} }
values values
@ -169,16 +172,16 @@ impl Error for HttpError {}
async fn read_line(data: &mut BufReader<&mut TcpStream>) -> Result<String, HttpError> { async fn read_line(data: &mut BufReader<&mut TcpStream>) -> Result<String, HttpError> {
let mut buf = String::new(); let mut buf = String::new();
let mut buf = match data.read_line(&mut buf).await { match data.read_line(&mut buf).await {
Ok(i) => { Ok(i) => {
if i == 0 { if i == 0 {
return Err(HttpError::ReadLineEof); Err(HttpError::ReadLineEof)
} else {
Ok(buf)
} }
buf
} }
Err(_) => return Err(HttpError::ReadLineUnknown), Err(_) => Err(HttpError::ReadLineUnknown),
}; }
Ok(buf.to_string())
} }
async fn read_line_crlf(data: &mut BufReader<&mut TcpStream>) -> Result<String, HttpError> { async fn read_line_crlf(data: &mut BufReader<&mut TcpStream>) -> Result<String, HttpError> {
@ -242,15 +245,12 @@ impl HttpRequest {
_ => [127, 0, 0, 1], _ => [127, 0, 0, 1],
}; };
let ip_str = octets[0].to_string().as_str().to_owned() let ip_str = octets[0].to_string()
+ "." + "." + &octets[1].to_string()
+ octets[1].to_string().as_str() + "." + &octets[2].to_string()
+ "." + "." + &octets[3].to_string();
+ octets[2].to_string().as_str()
+ "."
+ octets[3].to_string().as_str();
let mut status = split( let status = split(
match read_line_crlf(&mut data).await { match read_line_crlf(&mut data).await {
Ok(i) => i, Ok(i) => i,
Err(e) => return Err(e), Err(e) => return Err(e),
@ -295,11 +295,11 @@ impl HttpRequest {
}; };
params.insert( params.insert(
match decode(k) { match urlencoding::decode(k) {
Ok(i) => i.to_string(), Ok(i) => i.to_string(),
Err(_) => return Err(HttpError::InvalidQuery), Err(_) => return Err(HttpError::InvalidQuery),
}, },
match decode(v) { match urlencoding::decode(v) {
Ok(i) => Value::String(i.to_string()), Ok(i) => Value::String(i.to_string()),
Err(_) => return Err(HttpError::InvalidQuery), Err(_) => return Err(HttpError::InvalidQuery),
}, },
@ -374,11 +374,11 @@ impl HttpRequest {
}; };
params.insert( params.insert(
match decode(k) { match urlencoding::decode(k) {
Ok(i) => i.to_string(), Ok(i) => i.to_string(),
Err(_) => return Err(HttpError::InvalidQuery), Err(_) => return Err(HttpError::InvalidQuery),
}, },
match decode(v) { match urlencoding::decode(v) {
Ok(i) => Value::String(i.to_string()), Ok(i) => Value::String(i.to_string()),
Err(_) => return Err(HttpError::InvalidQuery), Err(_) => return Err(HttpError::InvalidQuery),
}, },
@ -399,7 +399,7 @@ impl HttpRequest {
}) })
} }
pub async fn read_with_rrs(mut data: BufReader<&mut TcpStream>, addr: &SocketAddr) -> Result<HttpRequest, HttpError> { pub async fn read_with_rrs(mut data: BufReader<&mut TcpStream>) -> Result<HttpRequest, HttpError> {
let addr = match read_line_lf(&mut data).await { let addr = match read_line_lf(&mut data).await {
Ok(i) => i, Ok(i) => i,
Err(e) => { return Err(e); } Err(e) => { return Err(e); }
@ -415,9 +415,9 @@ impl HttpRequest {
if let Value::Object(obj) = self.params.clone() { if let Value::Object(obj) = self.params.clone() {
for (k, v) in obj { for (k, v) in obj {
query.push_str(if i { "?" } else { "&" }); query.push_str(if i { "?" } else { "&" });
query.push_str(encode(k.as_str()).to_string().as_str()); query.push_str(urlencoding::encode(k.as_str()).to_string().as_str());
query.push_str("="); query.push_str("=");
query.push_str(encode(v.as_str().unwrap()).to_string().as_str()); query.push_str(urlencoding::encode(v.as_str().unwrap()).to_string().as_str());
i = false; i = false;
} }
} }
@ -547,9 +547,9 @@ impl HttpResponse {
loop { loop {
let mut buf: Vec<u8> = vec![0; 1024 * 32]; let mut buf: Vec<u8> = vec![0; 1024 * 32];
let mut buf_len: usize = match data.read(&mut buf).await { let buf_len = match data.read(&mut buf).await {
Ok(i) => i, Ok(i) => i,
Err(e) => { Err(_) => {
break; break;
} }
}; };
@ -601,18 +601,15 @@ impl HttpResponse {
} }
pub trait HttpServer: Sync { pub trait HttpServer: Sync {
async fn on_start(&mut self, host: &str, listener: &TcpListener); fn on_start(&mut self, host: &str, listener: &TcpListener) -> impl Future<Output = ()> + Send;
async fn on_close(&mut self); fn on_close(&mut self) -> impl Future<Output = ()> + Send;
fn on_request(&mut self, req: &HttpRequest) -> impl std::future::Future<Output = Option<HttpResponse>> + std::marker::Send; fn on_request(&mut self, req: &HttpRequest) -> impl Future<Output = Option<HttpResponse>> + Send;
} }
pub async fn handle_connection<S: HttpServer + Send + 'static>( async fn handle_connection<S: HttpServer + Send + 'static>(
server: Arc<Mutex<S>>, server: Arc<Mutex<S>>,
mut sock: TcpStream, mut sock: TcpStream
addr: std::net::SocketAddr, ) {
) where
S: HttpServer,
{
let addr = sock.peer_addr().unwrap(); let addr = sock.peer_addr().unwrap();
let req = match HttpRequest::read(BufReader::new(&mut sock), &addr).await { let req = match HttpRequest::read(BufReader::new(&mut sock), &addr).await {
@ -630,20 +627,20 @@ pub async fn handle_connection<S: HttpServer + Send + 'static>(
resp.write(&mut sock).await.unwrap(); resp.write(&mut sock).await.unwrap();
} }
pub async fn start_server(mut server: impl HttpServer + Send + 'static, host: &str) -> Result<(), Box<dyn Error>> { pub async fn start_server(server: impl HttpServer + Send + 'static, host: &str) -> Result<(), Box<dyn Error>> {
let server = Arc::new(Mutex::new(server)); let server = Arc::new(Mutex::new(server));
let listener = TcpListener::bind(host).await?; let listener = TcpListener::bind(host).await?;
server.lock().await.on_start(host, &listener).await; server.lock().await.on_start(host, &listener).await;
loop { loop {
let (sock, addr) = match listener.accept().await { let (sock, _) = match listener.accept().await {
Ok(i) => i, Ok(i) => i,
Err(_) => { break; } Err(_) => { break; }
}; };
let now_server = Arc::clone(&server); let now_server = Arc::clone(&server);
tokio::spawn(handle_connection(now_server, sock, addr)); tokio::spawn(handle_connection(now_server, sock));
} }
server.lock().await.on_close().await; server.lock().await.on_close().await;
@ -653,20 +650,20 @@ pub async fn start_server(mut server: impl HttpServer + Send + 'static, host: &s
// http rrs // http rrs
pub async fn start_server_rrs(mut server: impl HttpServer + Send + 'static, host: &str) -> Result<(), Box<dyn Error>> { pub async fn start_server_rrs(server: impl HttpServer + Send + 'static, host: &str) -> Result<(), Box<dyn Error>> {
let server = Arc::new(Mutex::new(server)); let server = Arc::new(Mutex::new(server));
let listener = TcpListener::bind(host).await?; let listener = TcpListener::bind(host).await?;
server.lock().await.on_start(host, &listener).await; server.lock().await.on_start(host, &listener).await;
loop { loop {
let (sock, addr) = match listener.accept().await { let (sock, _) = match listener.accept().await {
Ok(i) => i, Ok(i) => i,
Err(_) => { break; } Err(_) => { break; }
}; };
let now_server = Arc::clone(&server); let now_server = Arc::clone(&server);
tokio::spawn(handle_connection_rrs(now_server, sock, addr)); tokio::spawn(handle_connection_rrs(now_server, sock));
} }
server.lock().await.on_close().await; server.lock().await.on_close().await;
@ -678,10 +675,9 @@ pub async fn start_server_rrs(mut server: impl HttpServer + Send + 'static, host
// http rrs // http rrs
async fn handle_connection_rrs<S: HttpServer + Send + 'static>( async fn handle_connection_rrs<S: HttpServer + Send + 'static>(
server: Arc<Mutex<S>>, server: Arc<Mutex<S>>,
mut sock: TcpStream, mut sock: TcpStream
addr: std::net::SocketAddr,
) { ) {
let req = match HttpRequest::read_with_rrs(BufReader::new(&mut sock), &addr).await { let req = match HttpRequest::read_with_rrs(BufReader::new(&mut sock)).await {
Ok(i) => i, Ok(i) => i,
Err(_) => { Err(_) => {
return; return;

2
src/main.rs
View File

@ -24,7 +24,7 @@ impl HttpServer for EzSite {
} }
} }
async fn on_start(&mut self, host: &str, listener: &TcpListener) { async fn on_start(&mut self, host: &str, _listener: &TcpListener) {
println!("Http server started on {}", host); println!("Http server started on {}", host);
} }