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

loading modules and renders now uses serde to deserialise toml

Browse Source
This commit is contained in:
Sebastian Moser
2023-03-06 17:54:07 +01:00
parent e660f1372c
commit 68ef9286fe
1 changed files with 76 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
src/server.rs
View File

@@ -127,12 +127,42 @@ pub enum ModuleKind {
Extern(), Extern(),
} }
#[derive(Clone, Debug)] #[derive(Deserialize, Serialize)]
pub struct Render { pub enum Render {
id: String, WebComponent{
webroot: String, id: String,
main: String, webroot: String,
folder: String, main: String,
folder: String,
},
RenderView{
id: 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(),
}
}
} }
trait SendMize<T> where T: Into<MizeMessage> { trait SendMize<T> where T: Into<MizeMessage> {
@@ -198,53 +228,45 @@ pub async fn run_server(args: Vec<String>) {
let itemstore = crate::server::itemstore::Itemstore::new(mize_folder.clone() + "/db").await.expect("error creating itemstore"); let itemstore = crate::server::itemstore::Itemstore::new(mize_folder.clone() + "/db").await.expect("error creating itemstore");
//load modules and renders //load modules and renders
let ren_mods = std::fs::read_dir(mize_folder.clone() + "/mr") let mr_folders = std::fs::read_dir(mize_folder.clone() + "/mr")
.expect("error reading the modules-renders dir in the mize-folder") .expect("error reading the modules-renders dir in the mize-folder")
.filter(|entry| entry.as_ref().unwrap().file_type().unwrap().is_dir()); .filter(|entry| entry.as_ref().unwrap().file_type().unwrap().is_dir());
let mut renders: Vec<Render> = Vec::new(); let mut renders_toml: Vec<toml::Value> = Vec::new();
for ren_mod in ren_mods { for mr_folder in mr_folders {
let ren_mod = ren_mod.unwrap();
if let Ok(toml_string) = fs::read_to_string(format!("{}/mize.toml", ren_mod.path().display())){
let data = toml_string.parse::<toml::Value>()
.expect(&format!("error while parsing the mize.toml file in {}", ren_mod.path().display()));
//set renders let mr_folder = match mr_folder {
let render_arr = match data.get("render").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) { Err(_) => {MizeError::new(11).extra_msg("Error unwrapping DirEntry").handle(); continue;},
toml::Value::Array(arr) => arr, Ok(idk) => idk,
_ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())} };
};
for render in render_arr { let mr_string = match fs::read_to_string(format!("{}/mize.toml", mr_folder.path().display())) {
let id = match render.get("id").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) { Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml file to a toml string").handle(); continue;},
toml::Value::String(val) => val, Ok(idk) => idk,
_ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())} };
};
let webroot = match render.get("webroot").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) { let mr_data = match mr_string.parse::<toml::Value>() {
toml::Value::String(val) => val, Err(_) => {MizeError::new(11).extra_msg("Error parsing mize.toml string to toml::Value").handle(); continue;},
_ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())} Ok(idk) => idk,
}; };
let main = match render.get("main").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) { if let Some(local_renders) = mr_data.get("render") {
toml::Value::String(val) => val, if let toml::Value::Array(arr) = local_renders {
_ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())} renders_toml.extend(arr.clone());
}; }
let webroot = webroot.clone();
let main = main.clone();
let id = id.clone();
let folder = format!("{}", ren_mod.file_name().into_string().expect("filename has non utf8 chars in it......"));
renders.push(Render {id, webroot, main, folder});
};
//set modules
//later...
} }
} }
let mut renders: Vec<Render> = 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);
}
// Collection of all the things, that most functions need // Collection of all the things, that most functions need
let mutexes: Mutexes = Mutexes { let mutexes: Mutexes = Mutexes {
@@ -283,22 +305,24 @@ async fn axum_server(mize_folder: String, mutexes: Mutexes) {
let serve_client = get_service(ServeDir::new("js-client/src")).handle_error(handle_error); let serve_client = get_service(ServeDir::new("js-client/src")).handle_error(handle_error);
let mut app = Router::new() let mut app = Router::new()
.route("/==api==/socket", get(websocket_handler)) .route("/api/socket", get(websocket_handler))
.route("/==api==/render/:id", get(get_render_main)) .route("/api/render/:id", get(get_render_main))
// .route("/$api/file", get(get_file_handler)) // .route("/$api/file", get(get_file_handler))
// .merge(SpaRouter::new("/$api/client", "js-client/src").index_file("main.html")) // .merge(SpaRouter::new("/$api/client", "js-client/src").index_file("main.html"))
.nest_service("/==api==/client", serve_client) .nest_service("/api/client", serve_client)
.with_state(mutexes.clone()) .with_state(mutexes.clone())
.fallback(render_item); .fallback(render_item);
let renders = mutexes.renders.lock().await; let renders = mutexes.renders.lock().await;
for render in &*renders { for render in &*renders {
let url_path = String::from("/==api==/render/") + &render.id + "/webroot"; if let Render::WebComponent { id, webroot, main, folder } = render {
let file_path = mutexes.mize_folder.clone() + "/modules-renders/" + &render.folder[..] + "/" + &render.webroot.clone()[..]; let url_path = String::from("/api/render/") + &id + "/webroot";
let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error); 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);
app = app.nest_service(&url_path, serve_dir); app = app.nest_service(&url_path, serve_dir);
}
} }
drop(renders); drop(renders);
@@ -323,11 +347,10 @@ async fn render_item(uri: Uri) -> impl IntoResponse {
async fn get_render_main(extract::Path(id): extract::Path<String>, State(mutexes): State<Mutexes>) -> http::Response<String> { async fn get_render_main(extract::Path(id): extract::Path<String>, State(mutexes): State<Mutexes>) -> http::Response<String> {
let renders = &*mutexes.renders.lock().await; let renders = &*mutexes.renders.lock().await;
let render = renders.iter().filter(|&render| render.id == id).nth(0) let render = renders.iter().filter(|&render| render.get_id() == id).nth(0)
.unwrap_or(renders.iter().filter(|&render| render.id == "first").nth(0).expect("there is no first render")); .unwrap_or(renders.iter().filter(|&render| render.get_id() == "mize-mmejs").nth(0).expect("mize-mmejs"));
let file_name = mutexes.mize_folder.clone() + "/mr/" + &render.folder + "/" + &render.main; let file_name = mutexes.mize_folder.clone() + "/mr/" + &render.get_folder() + "/" + &render.get_main();
println!("filenamd: {}", file_name);
Response::builder() Response::builder()
.header("content-type", "application/javascript") .header("content-type", "application/javascript")