feat: added pool for postgress, connection manager for redis

saskenuba · saskenuba · commit 0b62182cbdeb · 2024-02-29T14:45:19.000-03:00
Signed-off-by: Martin &lt;martin@hotmail.com.br&gt;
diff --git a/src/application/mod.rs b/src/application/mod.rs
@@ -1,4 +1,6 @@
-use redis::Client;
+pub mod adapters;
+
+use deadpool_postgres::Pool;
 use std::sync::Arc;
 
 #[derive(Copy, Clone, Debug)]
@@ -12,7 +14,8 @@ impl AccountService {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct ServerData {
-    pub redis: Arc<Client>,
+    pub re_conn: redis::aio::ConnectionManager,
+    pub pg_pool: Pool,
 }
diff --git a/src/bin/main.rs b/src/bin/main.rs
@@ -1,22 +1,54 @@
+use deadpool_postgres::{ManagerConfig, Pool, RecyclingMethod, Runtime};
+use listenfd::ListenFd;
 use redis::Client;
 use rinha_de_backend::application::ServerData;
 use rinha_de_backend::infrastructure::server_impl::server::{match_routes, parse_http};
-use std::sync::Arc;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
+use tokio::net::{TcpListener, UnixListener};
+use tokio_postgres::NoTls;
 
 #[tokio::main]
 async fn main() {
     run().await
 }
 
+async fn setup_pgsql() -> Pool {
+    let mut cfg = deadpool_postgres::Config::new();
+    cfg.dbname = Some("rinhabackend".to_string());
+    cfg.host = Some("localhost".to_string());
+    cfg.user = Some("postgres".to_string());
+    // cfg.password = "inha";
+    cfg.manager = Some(ManagerConfig {
+        recycling_method: RecyclingMethod::Fast,
+    });
+
+    cfg.create_pool(Some(Runtime::Tokio1), NoTls).unwrap()
+}
+
 async fn run() {
-    let socket = TcpListener::bind("0.0.0.0:1337").await.unwrap();
-    let redis = Client::open("redis://0.0.0.0:1000").unwrap();
+    let mut listenfd = ListenFd::from_env();
+    let socket = if let Some(listener) = listenfd.take_tcp_listener(0).unwrap() {
+        listener.set_nonblocking(true).unwrap();
+        // UnixListener::from_std(listener).unwrap()
+        TcpListener::from_std(listener).unwrap()
+    } else {
+        TcpListener::bind("localhost:1337").await.unwrap()
+    };
+
+    let re_conn =
+        redis::aio::ConnectionManager::new(Client::open("redis://localhost:6379").unwrap())
+            .await
+            .unwrap();
+
+    let pg_pool = setup_pgsql().await;
+
     let data = ServerData {
-        redis: Arc::new(redis),
+        re_conn: re_conn,
+        pg_pool: pg_pool,
     };
 
+    println!("Server is running!");
+
     loop {
         let (mut socket, other) = socket.accept().await.unwrap();
 
@@ -38,18 +70,14 @@ async fn run() {
                     return;
                 }
 
-                eprintln!("one request, read bytes: {}", read_bytes);
-
                 let request = parse_http(&buf).unwrap();
-                let response = match_routes(&data, request);
-
-                socket
-                    .write_all(&response.left().unwrap().into_http())
-                    .await
-                    .unwrap();
-
-                // shutdown connections immediately since gatling doesn't have keep-alive connection by default
-                // socket.shutdown().await.unwrap();
+                let response = match_routes(&data, request).await;
+                let response = if response.is_left() {
+                    response.unwrap_left()
+                } else {
+                    response.unwrap_right()
+                };
+                socket.write_all(&response.into_http()).await.unwrap();
             }
         });
     }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,6 @@`
`1`		`-use redis::Client;`
	`1`	`+pub mod adapters;`
	`2`	`+`
	`3`	`+use deadpool_postgres::Pool;`
`2`	`4`	`use std::sync::Arc;`
`3`	`5`
`4`	`6`	`#[derive(Copy, Clone, Debug)]`
`@@ -12,7 +14,8 @@ impl AccountService {`
`12`	`14`	`}`
`13`	`15`	`}`
`14`	`16`
`15`		`-#[derive(Debug, Clone)]`
	`17`	`+#[derive(Clone)]`
`16`	`18`	`pub struct ServerData {`
`17`		`- pub redis: Arc<Client>,`
	`19`	`+ pub re_conn: redis::aio::ConnectionManager,`
	`20`	`+ pub pg_pool: Pool,`
`18`	`21`	`}`