gruberb/protohackers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor

Browse source
This commit is contained in:
Bastian Gruber 2023-04-21 07:26:34 +02:00
parent 0f993095ae
commit 979173efca
No known key found for this signature in database
GPG key ID: BE9F8C772B188CBF
1 changed files with 78 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

135
problem_01/src/main.rs
View file

@ -1,3 +1,5 @@
use std::io::ErrorKind;
use primes::is_prime; use primes::is_prime;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use tokio::io::AsyncBufReadExt; use tokio::io::AsyncBufReadExt;
@ -43,7 +45,6 @@ async fn handle_request(mut socket: TcpStream) {
let mut reader = BufReader::new(read); let mut reader = BufReader::new(read);
loop { loop {
log::info!("Start a new loop!");
let bytes = reader.read_until(b'\n', &mut buf).await; let bytes = reader.read_until(b'\n', &mut buf).await;
if let Ok(0) = bytes { if let Ok(0) = bytes {
@ -51,95 +52,89 @@ async fn handle_request(mut socket: TcpStream) {
return; return;
} }
let message: serde_json::Value = match serde_json::from_slice(&buf) { match validate_request(buf.clone()) {
Ok(m) => m, Ok(m) => {
Err(e) => { let _ = write.write(&m.as_bytes()).await;
log::error!( let _ = write.write(&[b'\n']).await;
"Not a prober JSON message: {}", let _ = buf.clear();
e }
); Err(_) => {
let _ = write.write(&MAL_FORMAT.as_bytes()).await; let _ = write.write(&MAL_FORMAT.as_bytes()).await;
let _ = write.write(&[b'\n']).await; let _ = write.write(&[b'\n']).await;
let _ = write.flush().await; let _ = write.flush().await;
buf.clear(); buf.clear();
continue;
} }
}; }
log::info!("Message received: {}", message); // Bad case
// log::error!("Not a prober JSON message: {}", e);
// let _ = write.write(&MAL_FORMAT.as_bytes()).await;
// let _ = write.write(&[b'\n']).await;
// let _ = write.flush().await;
// buf.clear();
match serde_json::from_slice::<Request>(&buf) { // Good case
// log::info!("Sending back response: {}", message);
// if let Err(e) = write.write(&message.as_bytes()).await {
// log::error!("Error writing serialize step: {}", e);
// }
// if let Err(e) = write.write(&[b'\n']).await {
// log::error!("Error writing: {}", e);
// }
// if let Err(e) = write.flush().await {
// log::error!("Error flushing: {}", e);
// }
// buf.clear();
// log::info!("After clearing buffer!");
}
}
fn validate_request(message: Vec<u8>) -> Result<String, std::io::Error> {
// Is it a proper formated JSON message?
// Do I need this case?
// let message: serde_json::Value = match serde_json::from_slice(&buf) {
// Ok(m) => m,
// Err(e) => {
// log::error!("Not a prober JSON message: {}", e);
// let _ = write.write(&MAL_FORMAT.as_bytes()).await;
// let _ = write.write(&[b'\n']).await;
// let _ = write.flush().await;
// buf.clear();
// }
// };
// Is it a proper Request?
match serde_json::from_slice::<Request>(&message) {
Ok(m) => { Ok(m) => {
let possible_prime = match m.number.to_string().parse::<u64>() { let possible_prime = match m.number.to_string().parse::<u64>() {
Ok(n) => n, Ok(n) => n,
Err(e) => { Err(_) => {
log::error!("Not a valid number: {}", e); return Ok(serde_json::to_string(&Response {
let message = serde_json::to_string(&Response {
method: IS_PRIME.to_owned(), method: IS_PRIME.to_owned(),
prime: false, prime: false,
}) })
.unwrap(); .unwrap());
log::info!("Sending back response: {}", message);
if let Err(e) = write.write(&message.as_bytes()).await {
log::error!("Error writing serialize step: {}", e);
} }
if let Err(e) = write.write(&[b'\n']).await {
log::error!("Error writing: {}", e);
}
if let Err(e) = write.flush().await {
log::error!("Error flushing: {}", e);
}
buf.clear();
log::info!("After clearing buffer!");
continue;
}
};
log::info!("Number is valid!");
let res = Response {
method: IS_PRIME.to_owned(),
prime: is_prime(possible_prime),
}; };
if m.method == IS_PRIME.to_owned() { if m.method == IS_PRIME.to_owned() {
log::info!("All good, send response: {:?}", res); return Ok(serde_json::to_string(&Response {
if let Err(e) = write method: IS_PRIME.to_owned(),
.write(&serde_json::to_string(&res).unwrap().as_bytes()) prime: is_prime(possible_prime),
.await })
{ .unwrap());
log::error!("Error writing serialize step: {}", e);
}
if let Err(e) = write.write(&[b'\n']).await {
log::error!("Error writing: {}", e);
}
if let Err(e) = write.flush().await {
log::error!("Error flushing: {}", e);
}
buf.clear();
} else { } else {
log::error!("Method is not isPrime"); return Err(std::io::Error::new(
if let Err(e) = write.write(&MAL_FORMAT.as_bytes()).await { ErrorKind::InvalidInput,
log::error!("Write mal_format failed: {}", e); "Method is not isPrime",
} ));
if let Err(e) = write.write(&[b'\n']).await {
log::error!("Error writing escape character: {}", e);
}
if let Err(e) = write.flush().await {
log::error!("Error flushing socket: {}", e);
}
log::info!("Wrote malformat response");
buf.clear();
} }
} }
Err(e) => { Err(_) => {
log::error!("Error parsing the message: {}", e); return Err(std::io::Error::new(
log::error!("Message: {}", String::from_utf8_lossy(&buf)); ErrorKind::InvalidData,
"Message is not a Request",
let _ = write.write(&MAL_FORMAT.as_bytes()).await; ));
let _ = write.write(&[b'\n']).await;
let _ = write.flush().await;
buf.clear();
}
} }
} }
} }