fixed some weired panic when accessing an element of a vec in an async

function.
- also cargo update

run

@@ -1,3 +1,3 @@
 #!/bin/bash 
 
-cargo run --bin server -- --folder=./gitignore/folder run
+cargo run -- --folder=./gitignore/folder run

src/server.rs

@@ -11,9 +11,14 @@ use warp::ws::{WebSocket, Message};
 use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use std::alloc::handle_alloc_error;
+use std::fs;
 use std::sync::{Arc};
 use tokio::sync::Mutex;
 use tokio::sync::mpsc;
+use crate::server::proto::Response;
+use crate::server::proto::handle_mize_message;
+
+use self::itemstore::Itemstore;
 
 //static API_PATH_STRING: &str = "$api";
 
@@ -103,37 +108,58 @@ async fn warp_server(mize_folder: String) {
     let itemstore = crate::server::itemstore::Itemstore::new(mize_folder + "/db").await;
 
     let mut clients: Arc<Mutex<Vec<Client>>> = Arc::new(Mutex::new(Vec::new()));
+    let mut itemstore_mutex: Arc<Mutex<Itemstore>> = Arc::new(Mutex::new(itemstore));
 
     let socket_route = warp::path!("$api" / "socket")
         .and(warp::ws())
         .map(move |ws: warp::ws::Ws| {
             let clients_clone = Arc::clone(&clients);
-            ws.on_upgrade(move |socket| handle_socket_connection(socket, clients_clone) )
+            let itemstore_clone = Arc::clone(&itemstore_mutex);
+            ws.on_upgrade(move |socket| handle_socket_connection(
+                    socket,
+                    clients_clone,
+                    itemstore_clone
+                )
+            )
     });
 
-    //let temp = warp::path("temp")
-        //.and(warp::ws())
-        //.map(move |ws: warp::ws::Ws| {
-            //ws.hi();
-    //});
+    let render_route = warp::path!("$api" / "render").map(move || "render route");
+    let file_route = warp::path!("$api" / "file").map(move || "file route");
+    //temporary
+    let render_route = warp::path!("$api" / "render" / "first").map(move || {
+        let answer = fs::read_to_string("/home/sebastian/work/mize/first-render/src/main.js").unwrap();
+        warp::http::Response::builder().header("content-type", "text/javascript").body(answer)
+    });
+    let main_route = warp::path!("$api" / "client" / "main.js").map(move || {
+        let answer = fs::read_to_string("/home/sebastian/work/mize/js-client/src/main.js").unwrap();
+        warp::http::Response::builder().header("content-type", "application/javascript").body(answer)
+    });
+    let defuatl_route = warp::path::end().map(||{
+        //normally should be included in the binary, but for developing just gonna read the file
+        //so I don't have to recompile all the time
+        //let answer = include_str!("../js-client/src/main.html");
+        let answer = fs::read_to_string("/home/sebastian/work/mize/js-client/src/main.html").unwrap();
+        warp::http::Response::builder().body(answer)
+    });
     
-    //let routes = warp::any().map(|| "Hello, World!");
-    let echo = warp::path("echo").map(|| "Hello World");
-    let test = warp::path("test").map(|| {
-
-        let int = 4+4;
-        format!("{}", int)
-    });
-
-    let routes = warp::get().and(socket_route).or(echo).or(test);
+    //let routes = warp::get().and(socket_route).or(render_route).or(file_route).map(move |hi| "default");
+    let routes = warp::get().and(
+        defuatl_route
+            .or(render_route)
+            .or(file_route)
+            .or(socket_route)
+            .or(main_route),
+            //.or(sum)
+            //.or(times),
+    );
        
     warp::serve(routes).run(([127, 0, 0, 1], 3000)).await;
 }
 
 async fn handle_socket_connection(
     socket: WebSocket,
-    clients_clone: Arc<Mutex<Vec<Client>>>
-    //test: String
+    clients_clone: Arc<Mutex<Vec<Client>>>,
+    itemstore_clone: Arc<Mutex<Itemstore>>,
 ){
     let (socket_tx, mut socket_rx) = socket.split();
     let (client_tx, client_rx) = mpsc::unbounded_channel();
@@ -142,18 +168,27 @@ async fn handle_socket_connection(
     tokio::spawn(client_rx.forward(socket_tx));
 
     let mut cli = clients_clone.lock().await;
-    cli.push(Client{tx: client_tx});
+    cli.push(Client{tx: client_tx.clone()});
     drop(cli);
 
     // Reading and broadcasting messages
     while let Some(result) = socket_rx.next().await {
         let msg = result.expect("Error when gettin message from WebSocket");
-        let t = msg.clone().into_bytes();
-        let clients = clients_clone.lock().await;
-        for client in &clients[..] {
-            client.tx.send(Ok(msg.clone()));
-        }
-        drop(clients);
+
+        let itemstore = &*itemstore_clone.lock().await;
+        match handle_mize_message(msg.clone().into_bytes(), itemstore).await {
+            Response::One(response) => {
+                client_tx.send(Ok(msg)).unwrap()
+            },
+            Response::All(response) => {
+                let clients = clients_clone.lock().await;
+                for client in &clients[..] {
+                    client.tx.send(Ok(msg.clone()));
+                }
+                drop(clients);
+            },
+            Response::None => {let t = 0;},
+        };
     }
 }
 

src/server/itemstore.rs

@@ -145,12 +145,14 @@ impl Itemstore {
             Err(e) => panic!("Error while querying the db: {}", e),
         };
 
+        println!("ID: {}", id);
         for key in keys {
             let mut field: [Vec<u8>; 2] = [Vec::new(), Vec::new()];
             field[0] = key.clone();
-            let mut ke = id.to_be_bytes().to_vec();
+            let mut ke = format!("{}", id).into_bytes();
             ke.push(':' as u8);
             ke.extend(key.clone());
+            println!("Key: {}", String::from_utf8(ke.clone()).unwrap());
             field[1] = match tr.get(ke).await {
                 Ok(Some(val)) => val,
                 Ok(None) => panic!("a field that should be there wasn't"),

src/server/proto.rs

@@ -4,15 +4,21 @@ use std::vec;
 use crate::server::itemstore;
 use crate::server::itemstore::encode;
 
+use super::itemstore::Itemstore;
+
+pub enum Response {
+    One(Vec<u8>),
+    All(Vec<u8>),
+    None,
+}
+
 const VERSION: u8 = 1;
 
-async fn handle_mize_message(
-    message: Vec<u8>,
-    itemstore: itemstore::Itemstore,
-    ) -> Option<Vec<u8>>{
+pub async fn handle_mize_message(
+        message: Vec<u8>,
+        itemstore: &itemstore::Itemstore,
+    ) -> Response {
 
-    let version = &message[0..1];
-    let cmd = &message[1..2];
 
     // 1:   get
     // 2:   give
@@ -26,36 +32,84 @@ async fn handle_mize_message(
     // 10:  update
     // 11:  delete
     // 12:  create
-    match cmd[0] {
+    // 13:  unsupported_version
+
+    //println!("message: {:?}", message);
+    //let version = message.clone().into_iter().nth(0).expect("message has no 0th byte");
+    //let cmd = message.clone().into_iter().nth(1).expect("message has no 1th byte");
+    //println!("after chaos");
+
+    // for some weired reason this stupid solution does not panic, while the obove one and vec[0]
+    // do
+    let mut count = 0;
+
+    let mut cmd: u8 = 0;
+    let mut version: u8 = 0;
+
+    for i in message.clone() {
+        if count == 0 {
+            version = i;
+        }
+        if count == 1 {
+            cmd = i
+        }
+
+        count += 1;
+    };
+
+    println!("VERSION: {}", version);
+    println!("CMD: {}", cmd);
+
+    match cmd {
         1 => {
-            let id: u64 = u64::from_be_bytes(message[2..9].try_into().expect("slice with incorrect length"));
-            let id_bytes = id.to_be_bytes();
-            let mut answer: Vec<u8> = vec![VERSION, 2, id_bytes[0], id_bytes[1], id_bytes[2], id_bytes[3]];
+            //let id_bytes = *&message[2..9].to_owned().clone();
+            let tmp = &message[2..10];
+            let id: u64 = u64::from_be_bytes([tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7]]);
+
+            // answer:
+            // u8: version
+            // u8: cmd (2 for give)
+            // u64: id
+            // u32: num_of_fields
+            // as often as num_of_fields:
+                // u64: key_len
+                // key_len: key
+                // u64: val_len
+                // val_len: val
+            let mut answer: Vec<u8> = vec![VERSION, 2];
+            answer.extend(id.to_be_bytes());
+
             let item = itemstore.get(id).await;
 
-            let mut temp: Vec<Vec<u8>> = Vec::new();
+            let num_of_fields = item.len() as u32;
+            answer.extend(num_of_fields.to_be_bytes());
 
             for field in item {
-                let encoded = encode(field.to_vec());
-                temp.push(encoded);
+                let key_len = field[0].len() as u64;
+                answer.extend(key_len.to_be_bytes());
+                answer.extend(field[0].clone());
+                let val_len = field[1].len() as u64;
+
+                answer.extend(val_len.to_be_bytes());
+                answer.extend(field[1].clone());
             }
-
-
-            return Some(answer);
+            return Response::One(answer);
         },
-        2 => {return None;},
-        3 => {return None;},
-        4 => {return None;},
-        5 => {return None;},
-        6 => {return None;},
-        7 => {return None;},
-        8 => {return None;},
-        9 => {return None;},
-        10 => {return None;},
-        11 => {return None;},
-        12 => {return None;},
-        _ => {return None;},
+        2 => {return Response::None;},
+        3 => {return Response::None;},
+        4 => {return Response::None;},
+        5 => {return Response::None;},
+        6 => {return Response::None;},
+        7 => {return Response::None;},
+        8 => {return Response::None;},
+        9 => {return Response::None;},
+        10 => {return Response::None;},
+        11 => {return Response::None;},
+        12 => {return Response::None;},
+        _ => {return Response::None;},
     }
+
+
 }
 
 
@@ -67,5 +121,3 @@ async fn handle_mize_message(
 
 
 
-
-