diff --git a/src/bin/relay.rs b/src/bin/relay.rs index 51bfde7..ad5bc2c 100644 --- a/src/bin/relay.rs +++ b/src/bin/relay.rs @@ -2,5 +2,5 @@ use std::error::Error; #[tokio::main] async fn main () -> Result <(), Box > { - ptth::relay::relay_main ().await + ptth::relay::main ().await } diff --git a/src/bin/server.rs b/src/bin/server.rs index 5ab7391..94b16be 100644 --- a/src/bin/server.rs +++ b/src/bin/server.rs @@ -1,97 +1,6 @@ -use std::{ - error::Error, - sync::Arc, - time::Duration, -}; - -use hyper::{ - StatusCode, -}; -use reqwest::Client; -use tokio::{ - time::delay_for, -}; - -use ptth::http_serde; - -const RELAY_URL: &str = "http://127.0.0.1:4000"; -const SERVER_NAME: &str = "alien_wildlands"; - -async fn handle_req_resp ( - client: &Client, - req_resp: reqwest::Response -) -> Result <(), Box > { - //println! ("Step 1"); - - if req_resp.status () != StatusCode::OK { - // TODO: Error handling - return Ok (()); - } - - let body = req_resp.bytes ().await?; - let wrapped_req: http_serde::WrappedRequest = match rmp_serde::from_read_ref (&body) - { - Ok (x) => x, - _ => return Ok (()), - }; - - let (req_id, parts) = (wrapped_req.id, wrapped_req.req); - - let response = ptth::file_server::serve_all (parts).await; - - let mut resp_req = client - .post (&format! ("{}/http_response/{}", RELAY_URL, req_id)) - .header (ptth::PTTH_MAGIC_HEADER, base64::encode (rmp_serde::to_vec (&response.parts).unwrap ())); - - if let Some (body) = response.body { - resp_req = resp_req.body (body); - } - - //println! ("Step 6"); - if let Err (e) = resp_req.send ().await { - println! ("Err: {:?}", e); - } - - Ok (()) -} - -async fn server_main () -> Result <(), Box > { - let client = Arc::new (Client::new ()); - - let mut backoff_delay = 0; - - loop { - if backoff_delay > 0 { - delay_for (Duration::from_millis (backoff_delay)).await; - } - - let req_req = client.get (&format! ("{}/http_listen/{}", RELAY_URL, SERVER_NAME)); - - let req_resp = match req_req.send ().await { - Err (e) => { - println! ("Err: {:?}", e); - backoff_delay = backoff_delay * 2 + 500; - continue; - }, - Ok (r) => { - backoff_delay = 0; - r - }, - }; - - // Spawn another task for each request so we can - // immediately listen for the next connection - - let client = client.clone (); - tokio::spawn (async move { - match handle_req_resp (&client, req_resp).await { - _ => (), - } - }); - } -} +use std::error::Error; #[tokio::main] async fn main () -> Result <(), Box > { - server_main ().await + ptth::server::main ().await } diff --git a/src/lib.rs b/src/lib.rs index ec6a2d1..7d12142 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,9 @@ -pub mod file_server; pub mod http_serde; -pub mod relay; pub const PTTH_MAGIC_HEADER: &str = "X-PTTH-2LJYXWC4"; + +// Basically binaries, but in the lib we can do experimental +// test stuff like spawn them both in the same process + +pub mod relay; +pub mod server; diff --git a/src/relay/mod.rs b/src/relay/mod.rs index 61b5b68..fe8026d 100644 --- a/src/relay/mod.rs +++ b/src/relay/mod.rs @@ -246,7 +246,7 @@ async fn handle_all (req: Request , state: Arc ) } } -pub async fn relay_main () -> Result <(), Box > { +pub async fn main () -> Result <(), Box > { let addr = SocketAddr::from(([0, 0, 0, 0], 4000)); let state = Arc::new (ServerState::default ()); diff --git a/src/file_server.rs b/src/server/file_server.rs similarity index 100% rename from src/file_server.rs rename to src/server/file_server.rs diff --git a/src/server/mod.rs b/src/server/mod.rs new file mode 100644 index 0000000..825058e --- /dev/null +++ b/src/server/mod.rs @@ -0,0 +1,94 @@ +use std::{ + error::Error, + sync::Arc, + time::Duration, +}; + +use hyper::{ + StatusCode, +}; +use reqwest::Client; +use tokio::{ + time::delay_for, +}; + +use crate::http_serde; + +mod file_server; + +const RELAY_URL: &str = "http://127.0.0.1:4000"; +const SERVER_NAME: &str = "alien_wildlands"; + +async fn handle_req_resp ( + client: &Client, + req_resp: reqwest::Response +) -> Result <(), Box > { + //println! ("Step 1"); + + if req_resp.status () != StatusCode::OK { + // TODO: Error handling + return Ok (()); + } + + let body = req_resp.bytes ().await?; + let wrapped_req: http_serde::WrappedRequest = match rmp_serde::from_read_ref (&body) + { + Ok (x) => x, + _ => return Ok (()), + }; + + let (req_id, parts) = (wrapped_req.id, wrapped_req.req); + + let response = file_server::serve_all (parts).await; + + let mut resp_req = client + .post (&format! ("{}/http_response/{}", RELAY_URL, req_id)) + .header (crate::PTTH_MAGIC_HEADER, base64::encode (rmp_serde::to_vec (&response.parts).unwrap ())); + + if let Some (body) = response.body { + resp_req = resp_req.body (body); + } + + //println! ("Step 6"); + if let Err (e) = resp_req.send ().await { + println! ("Err: {:?}", e); + } + + Ok (()) +} + +pub async fn main () -> Result <(), Box > { + let client = Arc::new (Client::new ()); + + let mut backoff_delay = 0; + + loop { + if backoff_delay > 0 { + delay_for (Duration::from_millis (backoff_delay)).await; + } + + let req_req = client.get (&format! ("{}/http_listen/{}", RELAY_URL, SERVER_NAME)); + + let req_resp = match req_req.send ().await { + Err (e) => { + println! ("Err: {:?}", e); + backoff_delay = backoff_delay * 2 + 500; + continue; + }, + Ok (r) => { + backoff_delay = 0; + r + }, + }; + + // Spawn another task for each request so we can + // immediately listen for the next connection + + let client = client.clone (); + tokio::spawn (async move { + match handle_req_resp (&client, req_resp).await { + _ => (), + } + }); + } +}