From b37250ce43557ba964d3498d82f1649a9d017762 Mon Sep 17 00:00:00 2001 From: Sebastian Moser Date: Thu, 13 Oct 2022 19:10:07 +0200 Subject: [PATCH] creating new items now works --- first-render | 2 +- js-client | 2 +- src/server.rs | 13 ++++++----- src/server/itemstore.rs | 48 +++++++++++++++++++------------------ src/server/proto.rs | 52 +++++++++++++++++++++++++++++++++++------ 5 files changed, 79 insertions(+), 38 deletions(-) diff --git a/first-render b/first-render index d495f90..a83e7f7 160000 --- a/first-render +++ b/first-render @@ -1 +1 @@ -Subproject commit d495f9085446ae0c76c5c48b8d7f98cba40fd7dc +Subproject commit a83e7f788d1972fa28cdcf6b81288ca611d37074 diff --git a/js-client b/js-client index 814fb4c..24878dd 160000 --- a/js-client +++ b/js-client @@ -1 +1 @@ -Subproject commit 814fb4caa8e491fa068671c21f0fb8e66d408e8a +Subproject commit 24878ddddee86bd026a049ac74dc3add4cdb6ac4 diff --git a/src/server.rs b/src/server.rs index 0de3a93..e7be307 100644 --- a/src/server.rs +++ b/src/server.rs @@ -134,7 +134,7 @@ async fn warp_server(mize_folder: String) { 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(||{ + let defuatl_route = warp::path::full().map(|path|{ //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"); @@ -144,11 +144,12 @@ async fn warp_server(mize_folder: String) { //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) + + render_route .or(file_route) .or(socket_route) - .or(main_route), + .or(main_route) + .or(defuatl_route) //.or(sum) //.or(times), ); @@ -178,12 +179,12 @@ async fn handle_socket_connection( 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() + client_tx.send(Ok(Message::binary(response.clone()))).unwrap() }, Response::All(response) => { let clients = clients_clone.lock().await; for client in &clients[..] { - client.tx.send(Ok(msg.clone())); + client.tx.send(Ok(Message::binary(response.clone()))); } drop(clients); }, diff --git a/src/server/itemstore.rs b/src/server/itemstore.rs index 9a207b8..656ae21 100644 --- a/src/server/itemstore.rs +++ b/src/server/itemstore.rs @@ -12,63 +12,68 @@ pub type Item = Vec<[Vec; 2]>; impl Itemstore { pub async fn new(path: String) -> Itemstore { let ds = Datastore::new(&(String::from("file://") + &path[..] + "/db")[..]).await.expect("Could not open database"); - println!("in new fn"); let mut tr = ds.transaction(true, false).await.expect("creation of transaction failed"); match tr.get(vec!('0' as u8)).await { Ok(Some(val)) => println!("item 0 already created"), Ok(None) => { - let init = vec!("num_of_items".as_bytes().to_vec(), "next_free_id".as_bytes().to_vec()); + let init = vec!["num_of_items".as_bytes().to_vec(), "next_free_id".as_bytes().to_vec()]; tr.set("0".to_string().into_bytes(), encode(init)).await; - tr.set("0:num_of_items".to_string().into_bytes(), vec!('1' as u8)).await; - tr.set("0:next_free_id".to_string().into_bytes(), vec!('1' as u8)).await; - tr.commit().await; + let one: u64 = 1; + let zero: u64 = 0; + tr.set("0:num_of_items".to_string().into_bytes(), one.to_be_bytes()).await; + tr.set("0:next_free_id".to_string().into_bytes(), one.to_be_bytes()).await; + tr.set("0:_commit".to_string().into_bytes(), zero.to_be_bytes()).await; + tr.set("0:_type".to_string().into_bytes(), "mize-main".as_bytes().to_vec()).await; + tr.commit().await.expect("error commiting transaction in new function"); }, + Err(e) => println!("Error while getting item index with id 0: {}", e) }; return Itemstore {db:ds}; } pub async fn create(&self, item: Item) -> u64 { - let mut tr = self.db.transaction(true, true).await.expect("creation of transaction failed"); + + let mut tr = self.db.transaction(true, false).await.expect("creation of transaction failed"); let id = tr.get("0:next_free_id").await .expect("no item with id 0 when there definetly should be one") .expect("error reading item 0 from db"); + let id_u64 = u64::from_be_bytes(id.clone().try_into().unwrap()); let mut keys: Vec> = Vec::new(); //set id:_commit - let mut key = id.clone(); - key.extend(":_commit".to_string().into_bytes()); - tr.set(key.clone(), vec![0,0,0,0,0,0,0,0]); - keys.push(key); + let key = format!("{}:_commit", id_u64).into_bytes(); + tr.set(key.clone(), vec![0,0,0,0,0,0,0,0]).await; + keys.push("_commit".to_owned().into_bytes()); for field in item { - let mut key = id.clone(); - key.push(':' as u8); + let mut key = format!("{}:", id_u64).into_bytes(); key.extend(field[0].clone()); - let val = field[1].clone(); keys.push(field[0].clone()); + + let val = field[1].clone(); tr.set(key, val).await; } - tr.set(id.clone(), encode(keys)).await; + tr.set(format!("{}", id_u64), encode(keys)).await; //increment 0:number_of_items by 1 let num = tr.get("0:num_of_items".to_string().into_bytes()).await .expect("error getting \"0:num_of_items\"") .expect("error reading item 0 from db"); let mut num_u64 = u64::from_be_bytes([num[0], num[1], num[2], num[3], num[4], num[5], num[6], num[7]]) +1; - tr.set("0:num_of_items".to_string().into_bytes(), num); + tr.set("0:num_of_items".to_string().into_bytes(), num_u64.to_be_bytes()).await; //imcrement next_free_id by 1 let num = tr.get("0:next_free_id".to_string().into_bytes()).await .expect("error getting \"0:next_free_id\"") .expect("error reading item 0 from db"); let mut num_u64 = u64::from_be_bytes([num[0], num[1], num[2], num[3], num[4], num[5], num[6], num[7]]) +1; - tr.set("0:next_free_id".to_string().into_bytes(), num); + tr.set("0:next_free_id".to_string().into_bytes(), num_u64.to_be_bytes()).await; - tr.commit().await; + let res = tr.commit().await.expect("error commiting transaction in create function"); return u64::from_be_bytes([id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7], ]) } @@ -112,7 +117,7 @@ impl Itemstore { keys = keys.into_iter().unique().collect::>>(); tr.set(format!("{}", id).into_bytes(), encode(keys)).await; - tr.commit().await; + let res = tr.commit().await.expect("error commiting transaction in update function"); } pub async fn delete(&self, id: u64){ @@ -130,7 +135,7 @@ impl Itemstore { tr.del(key).await; } tr.del(format!("{}", id)).await; - tr.commit().await; + let res = tr.commit().await.expect("error commiting transaction in delete function"); } pub async fn get(&self, id: u64) -> Item { @@ -145,14 +150,11 @@ impl Itemstore { Err(e) => panic!("Error while querying the db: {}", e), }; - println!("ID: {}", id); for key in keys { let mut field: [Vec; 2] = [Vec::new(), Vec::new()]; field[0] = key.clone(); - let mut ke = format!("{}", id).into_bytes(); - ke.push(':' as u8); + let mut ke = format!("{}:", id).into_bytes(); 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"), diff --git a/src/server/proto.rs b/src/server/proto.rs index 594588d..07cf6ea 100644 --- a/src/server/proto.rs +++ b/src/server/proto.rs @@ -32,7 +32,8 @@ pub async fn handle_mize_message( // 10: update // 11: delete // 12: create - // 13: unsupported_version + // 13: created_id + // 14: unsupported_version //println!("message: {:?}", message); //let version = message.clone().into_iter().nth(0).expect("message has no 0th byte"); @@ -57,8 +58,8 @@ pub async fn handle_mize_message( count += 1; }; - println!("VERSION: {}", version); - println!("CMD: {}", cmd); + //println!("VERSION: {}", version); + //println!("CMD: {}", cmd); match cmd { 1 => { @@ -85,10 +86,10 @@ pub async fn handle_mize_message( answer.extend(num_of_fields.to_be_bytes()); for field in item { - let key_len = field[0].len() as u64; + let key_len = field[0].len() as u32; answer.extend(key_len.to_be_bytes()); answer.extend(field[0].clone()); - let val_len = field[1].len() as u64; + let val_len = field[1].len() as u32; answer.extend(val_len.to_be_bytes()); answer.extend(field[1].clone()); @@ -104,8 +105,45 @@ pub async fn handle_mize_message( 8 => {return Response::None;}, 9 => {return Response::None;}, 10 => {return Response::None;}, - 11 => {return Response::None;}, - 12 => {return Response::None;}, + 11 => { + 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]]); + if id == 0 { + return Response::None; + } + + itemstore.delete(id); + return Response::None; + }, + 12 => { + let tmp = &message[2..6]; + let num_of_fields: u32 = u32::from_be_bytes([tmp[0], tmp[1], tmp[2], tmp[3]]); + let mut item: Vec<[Vec; 2]> = Vec::new(); + + let mut index = 6; + for i in 0..num_of_fields { + let mut tmp = &message[index..index + 4]; + let key_len = u32::from_be_bytes([tmp[0], tmp[1], tmp[2], tmp[3]]); + let key = message[index + 4..(index + 4 + key_len as usize)].to_vec(); + + index += 4 + key_len as usize; + + tmp = &message[index..index + 4]; + let val_len = u32::from_be_bytes([tmp[0], tmp[1], tmp[2], tmp[3]]); + let val = message[index + 4..(index + 4 + val_len as usize)].to_vec(); + + index += 4 + val_len as usize; + + item.push([key, val]); + } + + itemstore.create(item).await; + + let anser: Vec = vec![1,1]; + return Response::None; + }, + 13 => {return Response::None;}, + 14 => {return Response::None;}, _ => {return Response::None;}, }