feat: moved server_impl to infrastructure, created redislock

saskenuba · saskenuba · commit 0248a20586d6 · 2024-02-27T14:58:21.000-03:00
Signed-off-by: Martin &lt;martin@hotmail.com.br&gt;
diff --git a/benches/http_parse.rs b/benches/http_parse.rs
@@ -1,5 +1,5 @@
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-use httparse::{Header, ParserConfig, Request};
+use httparse::{ParserConfig, Request};
 use rinha_de_backend::server_impl::server::parse_http;
 
 const SAMPLE: &[u8] = b"GET /somepath HTTP/1.1\nHost: ifconfig.me\nUser-Agent: curl/8.5.0\nAccept: */*\nContent-Type: text/html; charset=ISO-8859-4\r\n\r\n{\"json_key\": 10}";
diff --git a/src/application/mod.rs b/src/application/mod.rs
@@ -1,3 +1,7 @@
+use redis::Client;
+use std::sync::Arc;
+
+#[derive(Copy, Clone, Debug)]
 pub struct AccountService {}
 
 impl AccountService {
@@ -7,3 +11,8 @@ impl AccountService {
         // and store transactions on redis so we can get to the balance faster
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct ServerData {
+    pub redis: Arc<Client>,
+}
diff --git a/src/domain/transaction.rs b/src/domain/transaction.rs
@@ -1,4 +1,4 @@
-use crate::server_impl::server::AnyResult;
+use crate::AnyResult;
 use compact_str::CompactString;
 use eyre::bail;
 use serde::Serialize;
diff --git a/src/infrastructure/mod.rs b/src/infrastructure/mod.rs
@@ -0,0 +1,3 @@
+pub mod server_impl;
+
+pub mod redis_lock;
diff --git a/src/infrastructure/redis_lock.rs b/src/infrastructure/redis_lock.rs
@@ -0,0 +1,82 @@
+use compact_str::CompactString;
+use redis::{Client, Value};
+use std::iter::repeat_with;
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct RedisLock {
+    rconn: Arc<Client>,
+    /// A random alphanumeric string
+    resource: CompactString,
+    /// Value the lock is tied to
+    val: i32,
+    ttl_max: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct RedisLockGuard<'a> {
+    lock: &'a RedisLock,
+}
+
+impl<'a> Drop for RedisLockGuard<'a> {
+    fn drop(&mut self) {
+        futures::executor::block_on(async { self.lock.unlock().await });
+    }
+}
+
+impl RedisLock {
+    pub fn new(rconn: impl Into<Arc<Client>>, val: i32, ttl_max: usize) -> RedisLock {
+        let resource: CompactString = repeat_with(fastrand::alphanumeric).take(5).collect();
+
+        Self {
+            rconn: rconn.into(),
+            resource,
+            val,
+            ttl_max,
+        }
+    }
+    pub async fn acquire(&self) -> Result<RedisLockGuard, ()> {
+        if lock(&self.rconn, &self.resource, self.val, self.ttl_max).await {
+            Ok(RedisLockGuard { lock: self })
+        } else {
+            return Err(());
+        }
+    }
+
+    async fn unlock(&self) -> Result<(), ()> {
+        let res = drop_lock(&self.rconn, &self.resource, self.val).await;
+        Ok(())
+    }
+}
+
+async fn lock(redis: &Client, resource: &str, val: i32, ttl: usize) -> bool {
+    let mut conn = redis.get_tokio_connection().await.unwrap();
+    let result = redis::cmd("SET")
+        .arg(resource)
+        .arg(val)
+        .arg("NX")
+        .arg("PX")
+        .arg(ttl)
+        .query_async::<_, Value>(&mut conn)
+        .await
+        .unwrap();
+    matches!(result, Value::Okay)
+}
+
+async fn drop_lock(redis: &Client, resource: &str, val: i32) -> bool {
+    let mut connection = redis.get_tokio_connection().await.unwrap();
+    let script = redis::Script::new(DROP_SCRIPT);
+    let res = script
+        .key(resource)
+        .arg(val)
+        .invoke_async::<_, Value>(&mut connection)
+        .await
+        .unwrap();
+    matches!(res, Value::Okay)
+}
+
+const DROP_SCRIPT: &str = r#"if redis.call("get", KEYS[1]) == ARGV[1] then
+        return redis.call("del", KEYS[1])
+    else
+        return 0
+    end"#;
diff --git a/src/infrastructure/server_impl/mod.rs b/src/infrastructure/server_impl/mod.rs
diff --git a/src/infrastructure/server_impl/request.rs b/src/infrastructure/server_impl/request.rs
@@ -1,5 +1,4 @@
-use crate::server_impl::server::{Header, Method};
-use ahash::AHashMap;
+use crate::infrastructure::server_impl::server::{Header, Method};
 use enum_map::EnumMap;
 
 #[derive(Debug)]
diff --git a/src/infrastructure/server_impl/response.rs b/src/infrastructure/server_impl/response.rs
@@ -1,9 +1,9 @@
-use crate::server_impl::server::Header;
+use crate::infrastructure::server_impl::server::Header;
 use bytes::Bytes;
 use compact_str::CompactString;
 use fnv::FnvHashMap;
+use serde::Serialize;
 use std::fmt::Write;
-use std::str::FromStr;
 use strum::{EnumMessage, EnumString, IntoStaticStr};
 
 #[allow(clippy::upper_case_acronyms, non_camel_case_types)]
@@ -36,17 +36,40 @@ impl From<StatusCode> for Response {
 
 impl Response {
     pub fn into_http(self) -> Bytes {
-        let mut buf = String::new();
+        // FIXME: use BufWriter to avoid calling write multiple times
+        let mut buf = String::with_capacity(80);
         let status_code: &str = self.status_code.into();
         let status_message = self.status_code.get_message().unwrap();
+
         write!(
             buf,
-            "HTTP/1.1 {status_code} {status_message}\n\
-            Content-Type: application/json; charset-utf-8\
-            Connection: keep-alive"
+            "HTTP/1.1 {status_code} {status_message}\r\n\
+            Content-Type: application/json; charset-utf-8\r\n\
+            Connection: keep-alive\r\n"
         )
         .expect("No reason to fail.");
 
+        if let Some(body) = self.body {
+            let length = body.len();
+            write!(buf, "Content-Length: {length}\r\n\r\n{body}").unwrap();
+        }
+
         buf.into()
     }
 }
+
+#[derive(Debug)]
+pub struct JsonResponse(pub(crate) Response);
+
+impl JsonResponse {
+    pub fn from<T>(body: T) -> Self
+    where
+        T: Serialize,
+    {
+        let mut response = Response::from(StatusCode::Ok);
+        let body = simd_json::to_string(&body).ok();
+        println!("body: {:?}", body);
+        response.body = body;
+        Self(response)
+    }
+}
diff --git a/src/infrastructure/server_impl/server.rs b/src/infrastructure/server_impl/server.rs
@@ -1,49 +1,42 @@
-use ahash::AHashMap;
 use std::str::FromStr;
 use std::sync::OnceLock;
 
+use crate::AnyResult;
 use either::Either;
 use enum_map::{Enum, EnumMap};
-use eyre::OptionExt;
-use fnv::FnvHashMap;
 use httparse::{ParserConfig, Status};
 use memchr::memchr;
 use regex_lite::Regex;
 use strum::{EnumString, IntoStaticStr};
 
 use crate::api::{statement_route, transaction_route};
-use crate::server_impl::request::Request;
-use crate::server_impl::response::{Response, StatusCode};
-
-pub type AnyResult<T> = eyre::Result<T>;
+use crate::application::ServerData;
+use crate::infrastructure::server_impl::request::Request;
+use crate::infrastructure::server_impl::response::{Response, StatusCode};
 
 static ROUTER: OnceLock<Regex> = OnceLock::new();
 
 pub fn get_router() -> &'static Regex {
     ROUTER.get_or_init(|| Regex::new(r#"clientes/(\d)/(transacoes|extrato)"#).unwrap())
 }
 
-pub fn process_server_request(buffer: &mut [u8], read_bytes: usize) -> AnyResult<Request> {
-    let request = parse_http(buffer)?;
-
-    // let a = match_routes(request.resource.as_str(), request);
-
-    todo!()
-}
-
-pub fn match_routes(resource: &str, request: Request) -> Either<Response, Response> {
-    let Some(route) = get_router().captures(resource) else {
+pub fn match_routes(server_data: &ServerData, request: Request) -> Either<Response, Response> {
+    let Some(route) = get_router().captures(request.resource) else {
         return Either::Right(StatusCode::NotFound.into());
     };
+    let client_id = route
+        .get(1)
+        .and_then(|c| i32::from_str(c.as_str()).ok())
+        .unwrap();
 
     // the fastest router in existence!
     let response = match route.get(2).map(|c| c.as_str()).unwrap() {
-        "transacao" => statement_route(request),
-        "extrato" => transaction_route(request),
+        "extrato" => statement_route(server_data, request, client_id),
+        "transacao" => transaction_route(server_data, request, client_id),
         _ => unreachable!(),
     };
 
-    todo!()
+    Either::Left(response.unwrap())
 }
 
 #[allow(clippy::upper_case_acronyms, non_camel_case_types)]
@@ -54,6 +47,7 @@ pub enum Header {
     ACCEPT,
     CONTENT_TYPE,
     CONTENT_LENGTH,
+    KEEP_ALIVE,
 }
 
 impl FromStr for Header {
@@ -66,12 +60,14 @@ impl FromStr for Header {
             "Accept" => Self::ACCEPT,
             "Content-Type" => Self::CONTENT_TYPE,
             "Content-Length" => Self::CONTENT_LENGTH,
+            "Keep-Alive" => Self::KEEP_ALIVE,
             _ => return Err(()),
         };
 
         Ok(res)
     }
 }
+
 #[allow(clippy::upper_case_acronyms, non_camel_case_types)]
 #[derive(Debug, Copy, Clone, PartialEq, EnumString, IntoStaticStr)]
 pub enum Method {

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::server_impl::server::AnyResult;`
	`1`	`+use crate::AnyResult;`
`2`	`2`	`use compact_str::CompactString;`
`3`	`3`	`use eyre::bail;`
`4`	`4`	`use serde::Serialize;`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+pub mod server_impl;`
	`2`	`+`
	`3`	`+pub mod redis_lock;`