Create threads earlier.

src/flow/flow.rs

@@ -42,6 +42,9 @@ pub fn compute_flow(
             }
         }
     }
+
+    // TODO prune
+
     println!("Max flow: {flow}");
     let transfers = extract_transfers(source, sink, &flow, used_edges);
     println!("Num transfers: {}", transfers.len());

src/main.rs

@@ -5,15 +5,13 @@ mod io;
 mod server;
 mod types;
 
-use server::Server;
-
 fn main() {
     let port = if env::args().len() == 1 {
         8080
     } else {
         env::args().nth(1).unwrap().as_str().parse::<u16>().unwrap()
     };
-    Server::start(port);
+    server::start_server(port);
 
     // let args: Vec<String> = env::args().collect();
     // if args.len() != 4 {

src/server.rs

@@ -5,81 +5,78 @@ use json::JsonValue;
 use std::collections::HashMap;
 use std::error::Error;
 use std::io::{BufRead, BufReader, Write};
-use std::sync::Arc;
+use std::ops::Deref;
+use std::sync::{Arc, RwLock};
 use std::thread;
 use std::{
     io::Read,
     net::{TcpListener, TcpStream},
 };
 
-pub struct Server {
-    edges: Arc<HashMap<Address, Vec<Edge>>>,
-    //threads: Vec<thread::JoinHandle<()>>,
-}
-
 struct JsonRpcRequest {
     id: JsonValue,
     method: String,
     params: JsonValue,
 }
 
-impl Server {
+type EdgeMap = HashMap<Address, Vec<Edge>>;
-    pub fn start(port: u16) {
+
-        let mut server = Server {
+pub fn start_server(port: u16) {
-            edges: Arc::new(HashMap::new()),
+    let edges: Arc<RwLock<Arc<EdgeMap>>> = Arc::new(RwLock::new(Arc::new(HashMap::new())));
-            //threads: Vec::new(),
-        };
 
     let listener =
         TcpListener::bind(format!("127.0.0.1:{port}")).expect("Could not create server.");
     loop {
+        let c = edges.clone();
         match listener.accept() {
-                Ok((socket, _)) => match server.handle_connection(socket) {
+            // TODO limit number of threads
-                    Ok(_) => {}
+            Ok((socket, _)) => {
-                    Err(e) => println!("Error communicating with client: {e}"),
+                thread::spawn(move || {
-                },
+                    match handle_connection(c.deref(), socket) {
+                        Ok(()) => {}
+                        Err(e) => {
+                            // TODO respond to the jsonrpc
+                            println!("Error handling connection: {e}");
+                        }
+                    }
+                });
+            }
             Err(e) => println!("Error accepting connection: {e}"),
         }
     }
-    }
+}
 
-    fn handle_connection(&mut self, mut socket: TcpStream) -> Result<(), Box<dyn Error>> {
+fn handle_connection(
+    edges: &RwLock<Arc<HashMap<Address, Vec<Edge>>>>,
+    mut socket: TcpStream,
+) -> Result<(), Box<dyn Error>> {
     let request = read_request(&mut socket)?;
     match request.method.as_str() {
         "load_edges_binary" => {
-                // TODO do this in its own thread?
+            let updated_edges = read_edges_binary(&request.params["file"].to_string())?;
-                let edges = read_edges_binary(&request.params["file"].to_string())?;
+            let len = updated_edges.len();
-                self.edges = Arc::new(edges);
+            *edges.write().unwrap() = Arc::new(updated_edges);
-                socket.write_all(jsonrpc_result(request.id, self.edges.len()).as_bytes())?;
+            socket.write_all(jsonrpc_result(request.id, len).as_bytes())?;
         }
         "compute_transfer" => {
-                // TODO limit number of threads
-                let edges = self.edges.clone();
-                let _thread = thread::spawn(move || {
             println!("Computing flow");
+            let e = edges.read().unwrap().clone();
             let flow = flow::compute_flow(
                 &Address::from(request.params["from"].to_string().as_str()),
                 &Address::from(request.params["to"].to_string().as_str()),
                 //&U256::from(request.params["value"].to_string().as_str()),
-                        edges.as_ref(),
+                e.as_ref(),
             );
             println!("Computed flow");
             // TODO error handling
-                    socket
+            socket.write_all(jsonrpc_result(request.id, json::JsonValue::from(flow)).as_bytes())?;
-                        .write_all(
-                            jsonrpc_result(request.id, json::JsonValue::from(flow)).as_bytes(),
-                        )
-                        .unwrap();
-                });
-                //self.threads.push(thread);
         }
         "cancel" => {}
         "update_edges" => {}
         // TODO error handling
         _ => {}
-        }
+    };
     Ok(())
-    }
 }
 
 fn read_request(socket: &mut TcpStream) -> Result<JsonRpcRequest, Box<dyn Error>> {