replica pool & banlist

src/main.rs

@@ -4,25 +4,29 @@ extern crate bytes;
 extern crate md5;
 extern crate tokio;
 
-use bb8::Pool;
 use tokio::net::TcpListener;
 
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 
 mod client;
+mod config;
 mod errors;
 mod messages;
 mod pool;
 mod server;
 
-type ClientServerMap = Arc<Mutex<HashMap<(i32, i32), (i32, i32)>>>;
+// Support for query cancellation: this maps our process_ids and
+// secret keys to the backend's.
+use config::{Address, User};
+use pool::{ClientServerMap, ReplicaPool};
 
 #[tokio::main]
 async fn main() {
-    println!("> Welcome to PgRabbit");
+    println!("> Welcome to PgCat! Meow.");
 
-    let listener = match TcpListener::bind("0.0.0.0:5433").await {
+    let addr = "0.0.0.0:5433";
+    let listener = match TcpListener::bind(addr).await {
         Ok(sock) => sock,
         Err(err) => {
             println!("> Error: {:?}", err);
@@ -30,20 +34,32 @@ async fn main() {
         }
     };
 
+    println!("> Running on {}", addr);
+
     let client_server_map: ClientServerMap = Arc::new(Mutex::new(HashMap::new()));
-    let manager = pool::ServerPool::new(
-        "127.0.0.1",
-        "5432",
-        "lev",
-        "lev",
-        "lev",
-        client_server_map.clone(),
-    );
-    let pool = Pool::builder().max_size(15).build(manager).await.unwrap();
+
+    // Note in the logs that it will fetch two connections!
+    let addresses = vec![
+        Address {
+            host: "127.0.0.1".to_string(),
+            port: "5432".to_string(),
+        },
+        Address {
+            host: "localhost".to_string(),
+            port: "5432".to_string(),
+        },
+    ];
+
+    let user = User {
+        name: "lev".to_string(),
+        password: "lev".to_string(),
+    };
+
+    let replica_pool = ReplicaPool::new(addresses, user, "lev", client_server_map.clone()).await;
 
     loop {
-        let pool = pool.clone();
         let client_server_map = client_server_map.clone();
+        let replica_pool = replica_pool.clone();
 
         let (socket, addr) = match listener.accept().await {
             Ok((socket, addr)) => (socket, addr),
@@ -57,14 +73,11 @@ async fn main() {
         tokio::task::spawn(async move {
             println!(">> Client {:?} connected.", addr);
 
-            let pool = pool.clone();
-            let client_server_map = client_server_map.clone();
-
             match client::Client::startup(socket, client_server_map).await {
                 Ok(mut client) => {
                     println!(">> Client {:?} authenticated successfully!", addr);
 
-                    match client.handle(pool).await {
+                    match client.handle(replica_pool).await {
                         Ok(()) => {
                             println!(">> Client {:?} disconnected.", addr);
                         }