From ddb60a63320656de0b31da325698a914c085fa9c Mon Sep 17 00:00:00 2001 From: Sebastian Moser Date: Fri, 17 Mar 2023 17:43:13 +0100 Subject: [PATCH] changes to how renders and webcomponents are loaded --- js-client | 2 +- src/server.rs | 196 +++++++++++++++++++++++++------------------- src/server/proto.rs | 50 +++++++---- 3 files changed, 145 insertions(+), 103 deletions(-) diff --git a/js-client b/js-client index 4bc7cc8..61b6df9 160000 --- a/js-client +++ b/js-client @@ -1 +1 @@ -Subproject commit 4bc7cc8fa0885a94b8bb8142e6f67e1928910a98 +Subproject commit 61b6df980ac96bec8f9dce34e69aa0de6a832edd diff --git a/src/server.rs b/src/server.rs index c228607..c64860f 100644 --- a/src/server.rs +++ b/src/server.rs @@ -127,42 +127,22 @@ pub enum ModuleKind { Extern(), } -#[derive(Deserialize, Serialize)] -pub enum Render { - WebComponent{ - id: String, - webroot: String, - main: String, - folder: String, - }, - RenderView{ - id: String, - main: String, - folder: String, - }, +#[derive(Deserialize, Serialize, Debug)] +pub struct Render { + #[serde(rename="type")] + render_type: RenderType, + webroot: String, + name: String, + main: String, + folder: String, } -impl Render { - fn get_id(&self) -> String { - match self { - Render::WebComponent{id, webroot, main, folder} => id.to_owned(), - Render::RenderView{id, main, folder} => id.to_owned(), - } - } - - fn get_folder(&self) -> String { - match self { - Render::WebComponent{id, webroot, main, folder} => folder.to_owned(), - Render::RenderView{id, main, folder} => folder.to_owned(), - } - } - - fn get_main(&self) -> String { - match self { - Render::WebComponent{id, webroot, main, folder} => main.to_owned(), - Render::RenderView{id, main, folder} => main.to_owned(), - } - } +#[derive(Deserialize, Serialize, Debug)] +pub enum RenderType { + #[serde(rename="json-ui")] + JsonUi, + #[serde(rename="webcomponent")] + WebComponent, } trait SendMize where T: Into { @@ -227,46 +207,7 @@ pub async fn run_server(args: Vec) { //create the itemstore let itemstore = crate::server::itemstore::Itemstore::new(mize_folder.clone() + "/db").await.expect("error creating itemstore"); - //load modules and renders - let mr_folders = std::fs::read_dir(mize_folder.clone() + "/mr") - .expect("error reading the modules-renders dir in the mize-folder") - .filter(|entry| entry.as_ref().unwrap().file_type().unwrap().is_dir()); - - let mut renders_toml: Vec = Vec::new(); - - for mr_folder in mr_folders { - - let mr_folder = match mr_folder { - Err(_) => {MizeError::new(11).extra_msg("Error unwrapping DirEntry").handle(); continue;}, - Ok(idk) => idk, - }; - - let mr_string = match fs::read_to_string(format!("{}/mize.toml", mr_folder.path().display())) { - Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml file to a toml string").handle(); continue;}, - Ok(idk) => idk, - }; - - let mr_data = match mr_string.parse::() { - Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml string to toml::Value").handle(); continue;}, - Ok(idk) => idk, - }; - - if let Some(local_renders) = mr_data.get("render") { - if let toml::Value::Array(arr) = local_renders { - renders_toml.extend(arr.clone()); - } - } - } - - let mut renders: Vec = Vec::new(); - - for render_toml in renders_toml { - let render = match Render::deserialize(render_toml) { - Ok(render) => render, - Err(err) => {MizeError::new(11).handle(); continue;} - }; - renders.push(render); - } + let renders = load_mr(mize_folder.clone()).expect("Error loading Modules and Renders"); // Collection of all the things, that most functions need let mutexes: Mutexes = Mutexes { @@ -316,12 +257,15 @@ async fn axum_server(mize_folder: String, mutexes: Mutexes) { let renders = mutexes.renders.lock().await; for render in &*renders { - if let Render::WebComponent { id, webroot, main, folder } = render { - let url_path = String::from("/api/render/") + &id + "/webroot"; - let file_path = mutexes.mize_folder.clone() + "/modules-renders/" + &folder[..] + "/" + &webroot.clone()[..]; - let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error); + match render.render_type { + RenderType::JsonUi => {}, + RenderType::WebComponent => { + let url_path = String::from("/api/render/") + &render.name + "/webroot"; + let file_path = mutexes.mize_folder.clone() + "/mr/" + &render.folder[..] + "/" + &render.webroot.clone()[..]; + let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error); - app = app.nest_service(&url_path, serve_dir); + app = app.nest_service(&url_path, serve_dir); + }, } } drop(renders); @@ -347,15 +291,25 @@ async fn render_item(uri: Uri) -> impl IntoResponse { async fn get_render_main(extract::Path(id): extract::Path, State(mutexes): State) -> http::Response { let renders = &*mutexes.renders.lock().await; - let render = renders.iter().filter(|&render| render.get_id() == id).nth(0) - .unwrap_or(renders.iter().filter(|&render| render.get_id() == "mize-mmejs").nth(0).expect("mize-mmejs")); + let render = renders.iter().filter(|&render| render.name == id).nth(0) + .unwrap_or(renders.iter().filter(|&render| render.name == "mize-mmejs").nth(0).expect("mize-mmejs")); - let file_name = mutexes.mize_folder.clone() + "/mr/" + &render.get_folder() + "/" + &render.get_main(); + let file_path = mutexes.mize_folder.clone() + "/mr/" + &render.folder + "/" + &render.main; - Response::builder() - .header("content-type", "application/javascript") - .status(StatusCode::OK) - .body(fs::read_to_string(file_name).unwrap()).unwrap() + match render.render_type { + RenderType::JsonUi => { + return Response::builder() + .header("content-type", "application/json") + .status(StatusCode::OK) + .body(fs::read_to_string(file_path).unwrap()).unwrap(); + }, + RenderType::WebComponent => { + return Response::builder() + .header("content-type", "application/javascript") + .status(StatusCode::OK) + .body(fs::read_to_string(file_path).unwrap()).unwrap(); + }, + } } async fn websocket_handler( @@ -514,5 +468,75 @@ async fn handle_websocket_connection( }; } +fn load_mr(mize_folder: String) -> Result, MizeError> { + //load modules and renders + + let mr_folders = std::fs::read_dir(mize_folder.clone() + "/mr") + .expect("error reading the modules-renders dir in the mize-folder") + .filter(|entry| entry.as_ref().unwrap().file_type().unwrap().is_dir()); + + let mut renders: Vec = Vec::new(); + + for mr_folder in mr_folders { + + let mr_folder = match mr_folder { + Err(_) => {MizeError::new(11).extra_msg("Error unwrapping DirEntry").handle(); continue;}, + Ok(idk) => idk, + }; + + let mr_string = match fs::read_to_string(format!("{}/mize.toml", mr_folder.path().display())) { + Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml file to a toml string").handle(); continue;}, + Ok(idk) => idk, + }; + + let mut mr_data = match mr_string.parse::() { + Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml string to toml::Value").handle(); continue;}, + Ok(idk) => idk, + }; + + if let Some(local_renders) = mr_data.get_mut("render") { + if let Some(arr) = local_renders.as_array_mut(){ + //add folder to local_renders + for mut el in arr.iter_mut() { + if let Some(table) = el.as_table_mut(){ + table.insert("folder".to_owned(), toml::Value::String(mr_folder.file_name().into_string().unwrap())); + table.insert("type".to_owned(), toml::Value::String("json-ui".to_owned())); + } + + let render = match Render::deserialize(el.clone()) { + Ok(render) => render, + Err(err) => {MizeError::new(11).extra_msg(&format!("{}", err)).handle(); continue;} + }; + + renders.push(render); + } + } + } + + if let Some(local_webcomponents) = mr_data.get_mut("webcomponent") { + if let Some(arr) = local_webcomponents.as_array_mut(){ + //add folder to local_renders + for mut el in arr.iter_mut() { + if let Some(table) = el.as_table_mut(){ + table.insert("folder".to_owned(), toml::Value::String(mr_folder.file_name().into_string().unwrap())); + table.insert("type".to_owned(), toml::Value::String("webcomponent".to_owned())); + table.insert("webroot".to_owned(), toml::Value::String("".to_owned())); + } + + let render = match Render::deserialize(el.clone()) { + Ok(render) => render, + Err(err) => {MizeError::new(11).extra_msg(&format!("{}", err)).handle(); continue;} + }; + + renders.push(render); + } + } + } + + } + + return Ok((renders)); +} + diff --git a/src/server/proto.rs b/src/server/proto.rs index a70bf9f..2d7857c 100644 --- a/src/server/proto.rs +++ b/src/server/proto.rs @@ -39,14 +39,10 @@ pub struct BinMessage { pub raw: Vec, } -#[derive(From, Clone, Debug, Serialize, Deserialize)] -#[serde(tag = "cat")] +#[derive(From, Clone, Debug, Deserialize)] pub enum JsonMessage { - #[serde(rename="err")] ErrMsg(ErrMessage), - #[serde(rename="item")] ForItem(ItemMessage), - #[serde(rename="arr")] ForArr(ArrayMessage), } @@ -66,25 +62,25 @@ pub struct ArrayMessage { #[derive(From, Debug, Clone, Serialize, Deserialize)] #[serde(tag = "cmd")] pub enum ItemMessage { - #[serde(rename="get")] + #[serde(rename="item.get")] Get(GetItemMessage), - #[serde(rename="get-sub")] + #[serde(rename="item.get-sub")] GetSub(GetSubMessage), - #[serde(rename="give")] + #[serde(rename="item.give")] Give(GiveItemMessage), - #[serde(rename="create")] + #[serde(rename="item.create")] Create(CreateItemMessage), - #[serde(rename="created-id")] + #[serde(rename="item.created-id")] CreatedId(CreatedIdMessage), - #[serde(rename="delete")] + #[serde(rename="item.delete")] Delete(DeleteItemMessage), - #[serde(rename="sub")] + #[serde(rename="item.sub")] Sub(SubItemMessage), - #[serde(rename="unsub")] + #[serde(rename="item.unsub")] Unsub(UnsubItemMessage), - #[serde(rename="update-req")] + #[serde(rename="item.update-req")] UpdateRequest(UpdateRequestMessage), - #[serde(rename="update")] + #[serde(rename="item.update")] Update(UpdateMessage), } @@ -270,7 +266,6 @@ impl<'de> Deserialize<'de> for MizeId { //scip the # let mod_name: String = iter.clone().take_while(|ch| ch != &'#' || ch != &'/').collect(); let id: String = iter.collect(); - println!("in deserialize..... mod_name: --{}-- id: --{}--", mod_name.clone(), id.clone()); return Ok(MizeId::Module { mod_name, id}); } else { let id: u64 = match v.parse(){ @@ -295,6 +290,29 @@ impl<'de> Deserialize<'de> for MizeId { } } + +impl Serialize for JsonMessage { + fn serialize(&self, serializer: S) -> Result + where + S: serde::Serializer + { + + match self { + JsonMessage::ErrMsg(err_msg) => { + ErrMessage::serialize(&err_msg, serializer) + }, + + JsonMessage::ForArr(arr_msg) => { + ArrayMessage::serialize(&arr_msg, serializer) + }, + + JsonMessage::ForItem(item_msg) => { + ItemMessage::serialize(&item_msg, serializer) + }, + } + } +} + //###//=================================================== // functions