ppc/mize
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
function.
- also cargo update
This commit is contained in:
Sebastian Moser
2022-10-09 12:55:14 +02:00
parent eeb9bbe694
commit f18667b5b3
7 changed files with 493 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/server.rs
View File

@@ -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;},
};
}
}

4
src/server/itemstore.rs
View File

@@ -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"),

112
src/server/proto.rs
View File

@@ -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(