I broke it.

src/main.rs

@@ -1,46 +1,24 @@
-use once_cell::sync::{Lazy};
-use std::sync::{Mutex};
-use clap::{Arg};
-use std::{net::SocketAddr, time::Duration, error::Error, collections::VecDeque, sync::Arc, thread::current};
-use http::status::StatusCode;
-
-
 use dashmap::DashMap;
+use once_cell::sync::{Lazy};
+use rocket::State;
+use std::{sync::{RwLock}, collections::{VecDeque}};
 
 
-static mut QUEUE_MAP : Lazy<Mutex<DashMap<&str, usize>>> = Lazy::new(|| Mutex::new(DashMap::new()));
-static mut QUEUES : Lazy<Mutex<Vec<VecDeque<&str>>>> = Lazy::new(|| Mutex::new(Vec::new()));
-static mut CURRENT_QUEUE : usize = 0;
 
-static mut DUMB_QUEUE : Lazy<Mutex<DumbQueue>> = Lazy::new(|| Mutex::new(DumbQueue::new()));
 
 #[derive(Debug)]
 struct DumbQueue {
-    queue_map : DashMap<String, usize>,
-    queues : Vec<VecDeque<String>>,
+    queue_map : RwLock<DashMap<String, usize>>,
+    queues : RwLock<Vec<RwLock<VecDeque<String>>>>,
     current_queue : usize,
 }
 
-#[derive(Debug)]
-pub struct KVSet {
-    opt: String,
-    name: String,
-    data: Option<String>,
-    num: Option<i32>,
-}
-
-
-async fn write_request(kind: &str) -> String {
-    println!("request {}", kind);
-    String::from(format!("request {}", kind))
-}
-
 
 impl DumbQueue {
     fn new() -> Self {
-        return DumbQueue { 
-            queue_map: DashMap::new(),
-            queues: vec!(),
+        DumbQueue { 
+            queue_map: RwLock::new(DashMap::new()),
+            queues: RwLock::new(vec!()),
             current_queue: 0,
         }
     }
@@ -54,17 +32,16 @@ impl DumbQueue {
 
         let queue_map = &self.queue_map;
 
-        let queue_index = queue_map.get(&lookup_key);
-        match queue_index {
+        match queue_map.read().unwrap().get(&lookup_key) {
             None => {
-                let new_queue = VecDeque::new();
-                self.queues.push(new_queue);
-                let _ = queue_map.insert(key.to_string(), self.current_queue as usize);
-                self.queues[self.current_queue].push_back(value);
+                let new_queue = RwLock::new(VecDeque::new());
+                self.queues.write().unwrap().push(new_queue);
+                let _ = &self.queue_map.write().unwrap().insert(key.to_string(), self.current_queue as usize);
+                self.queues.read().unwrap()[self.current_queue].write().unwrap().push_back(value);
                 self.current_queue += 1;
             },
             Some(i) => {
-                self.queues[*i].push_back(value); 
+                self.queues.read().unwrap()[*i].write().unwrap().push_back(value); 
             }
         }
     }
@@ -72,11 +49,11 @@ impl DumbQueue {
     fn pop_front(&mut self, key: String) -> Option<String> {
         let val_key = key;
         let queue_map = &self.queue_map;
-        let queue_index = queue_map.get(val_key.as_str());
-        match queue_index {
+        match queue_map.read().unwrap().get(val_key.as_str()) {
             Some(i) => {
                 let index : usize = *i;
-                match self.queues[index].pop_front() {
+                match self.queues.read().unwrap()[index]
+                        .write().unwrap().pop_front() {
                     Some(res) => return Some(res),
                     None => None
                 }
@@ -86,6 +63,41 @@ impl DumbQueue {
     }
 }
 
+struct DumberQueue {
+    queue_map : RwLock<DashMap<String, usize>>,
+}
+
+impl DumberQueue {
+    fn new() -> Self {
+        DumberQueue { 
+            queue_map: RwLock::new(DashMap::new()),
+        }
+    }
+
+    fn get_bearings(&self, key: String) {
+        
+    }
+
+    fn push_back(&mut self, key: String, val: String) {
+        
+    }
+
+    fn pop_front(&mut self, key: String) -> Option<String> {
+        let val_key = key;
+        let queue_map = &self.queue_map;
+        match queue_map.read().unwrap().get(val_key.as_str()) {
+            Some(i) => {
+                let index : usize = *i;
+                match self.queues.read().unwrap()[index]
+                        .write().unwrap().pop_front() {
+                    Some(res) => return Some(res),
+                    None => None
+                }
+            }
+            None => None
+        }
+    }
+}
 
 #[macro_use] extern crate rocket;
 
@@ -94,9 +106,10 @@ fn index() -> &'static str {
     "Hello, world!"
 }
 
+
 #[get("/<id>")]
-fn get_by_id(id: String) -> String {
-    let mut dumb_queue = unsafe { DUMB_QUEUE.lock().unwrap() };
+fn get_by_id(id: String, dumb_queue: &State<DumbQueue>) -> String {
+    
     let result = match dumb_queue.pop_front(id) {
         Some(res) => res.to_string(),
         None => String::from("")
@@ -105,13 +118,17 @@ fn get_by_id(id: String) -> String {
 }
 
 #[put("/<id>", data = "<input>")]
-fn put_by_id(id: String, input: String) {
-    let mut dumb_queue = unsafe { DUMB_QUEUE.lock().unwrap() };
+fn put_by_id(id: String, input: String, dumb_queue: &State<DumbQueue>) {
     dumb_queue.push_back(id, input);
 }
 
-
 #[launch]
 fn rocket() -> _ {
-    rocket::build().mount("/", routes![index, put_by_id, get_by_id])
+
+//    let dumb_queue : DumbQueue = DumbQueue::new();
+
+
+    rocket::build()
+        .manage( DumbQueue::new())
+        .mount("/", routes![index, put_by_id, get_by_id])
 }