Now get queue names from stats.

It's actually working fine performance wise, it was a bug in my testing.

Cargo.toml

@@ -6,9 +6,9 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-axum = "0.6.20"
 clap = "4.4.8"
 dashmap = "5.5.3"
 http = "1.0.0"
-tower = "0.4.13"
+once_cell = "1.18.0"
+rocket = "0.5.0"
 tracing = "0.1.40"

src/main.rs

@@ -1,78 +1,106 @@
-use axum::{error_handling::HandleErrorLayer, routing::get, Router};
-use clap::{Arg};
-use std::{net::SocketAddr, time::Duration, error::Error, collections::VecDeque, sync::Arc};
-use tower::ServiceBuilder;
-use http::status::StatusCode;
-
-
-use dashmap::DashMap;
+use rocket::{State, http::Status};
+use std::{sync::RwLock, collections::{VecDeque, HashMap}};
 
 #[derive(Debug)]
-struct DumbQueue<'a> {
-    queue_map : DashMap<&'a str, usize>,
-    queues : Vec<VecDeque<&'a str>>,
-    current_queue : usize,
+struct DumbQueue {
+    queue_map : RwLock<HashMap<String, usize>>,
+    queues : RwLock<Vec<RwLock<VecDeque<String>>>>,
 }
 
-impl <'a> DumbQueue<'a> {
+
+impl DumbQueue {
     fn new() -> Self {
-        return DumbQueue { 
-            queue_map: DashMap::new(),
-            queues: vec!(),
-            current_queue: 0,
-        }
-    }
-
-    fn push_back(&mut self, key: &'a str, val: &'a str) {
-        let val_key = key;
-        let value = val;
-        let queue_map = &self.queue_map;
-
-        let queue_index = queue_map.get(val_key);
-        match queue_index {
-            Some(i) => {
-                let index : usize = *i;
-                self.queues[index].push_back(value)
-            }
-            None => {
-                let new_queue = VecDeque::new();
-                self.queues.push(new_queue);
-                queue_map.insert(val_key, self.current_queue as usize);
-                self.queues[self.current_queue].push_back(value);
-                self.current_queue += 1;
-            }
-        }
-    }
-
-    fn pop_front(&mut self, key: &'a str) -> Option<&str> {
-        let val_key = key;
-        let queue_map = &self.queue_map;
-        let queue_index = queue_map.get(val_key);
-        match queue_index {
-            Some(i) => {
-                let index : usize = *i;
-                return Some(self.queues[index].pop_front().unwrap())
-            }
-            None => None
+        DumbQueue { 
+            queue_map: RwLock::new(HashMap::new()),
+            queues: RwLock::new(vec!()),
         }
     }
 }
 
-fn main() {
-    let mut queue = DumbQueue::new();
 
-    println!("Push value...");
-    let _ = queue.push_back(&"/what", "the fuck?");
-    let _ = queue.push_back(&"/foo", "bar...");
+#[macro_use] extern crate rocket;
 
-    println!("Queue manager thing: {:?}", queue);
+#[get("/")]
+fn index(dumb_queue: &State<DumbQueue>) -> String {
+    let map_reader = &dumb_queue.queue_map.read().unwrap();
+    let queue_reader = &dumb_queue.queues.read().unwrap();
 
-    println!("Pop value...");
-    let popped = queue.pop_front("/what");
-    println!("{:?}", popped);
+    let queue_count = queue_reader.len();
+    let mut stats : HashMap<String, usize> = HashMap::new();
 
-    let _ = queue.push_back(&"/foo", "baz...");
+    for (key,val) in map_reader.iter() {
+        let reader = queue_reader[*val].read().unwrap();
+        stats.insert(key.to_string(), reader.len());
+        drop(reader);
+    }
 
-
-    println!("{:?}", queue);
+    format!("Total queues: {}\nCounts: {:?}", queue_count, stats)
 }
+
+
+#[get("/<name>")]
+fn get_by_name(name: &str, dumb_queue: &State<DumbQueue>) -> Result<String, Status> {
+    
+    let queue_map = &dumb_queue.queue_map;
+    let queues = &dumb_queue.queues;
+    let map_reader = queue_map.read().unwrap();
+    match map_reader.get(name) {
+        Some(i) => {
+            let index = *i;
+            drop(map_reader);
+    
+            match queues.read().unwrap()[index]
+                    .write().unwrap().pop_front() {
+                Some(res) => Ok(res),
+                None => return Err(Status::NoContent)
+            }
+        }
+        None => return Err(Status::NotFound)
+    }
+}
+
+#[put("/<name>", data = "<input>")]
+fn put_by_name(name: &str, input: &str, dumb_queue: &State<DumbQueue>) {
+    
+    let queue_map = &dumb_queue.queue_map;
+    let queues = &dumb_queue.queues;
+    let mut inserted = false;
+    let mut inserted_index = usize::MAX;
+
+    let map_read = queue_map.read().unwrap();
+    
+    match map_read.get(&name.to_string()) {
+        None => {
+            let new_queue = RwLock::new(VecDeque::with_capacity(1024));
+            let mut write = new_queue.write().unwrap();
+            write.push_back(input.to_string());
+            drop(write);
+            
+            let mut write = queues.write().unwrap();
+            write.push(new_queue); 
+            inserted_index = write.len() -1 as usize;
+            drop(write);
+            inserted = true;
+        },
+        Some(i) => {
+            let read = queues.read().unwrap();
+            read[*i].write().unwrap().push_back(input.to_string()); 
+        }
+    }
+    drop(map_read);
+
+    if inserted {
+        let mut write = queue_map.write().unwrap();
+        write.insert(name.to_string(), inserted_index);
+        drop(write);
+    }
+}
+
+
+#[launch]
+fn rocket() -> _ {
+//    let dumb_queue : DumbQueue = DumbQueue::new();
+    rocket::build()
+        .manage( DumbQueue::new())
+        .mount("/", routes![index, put_by_name, get_by_name])
+}