switched to axum as the web-framework, and got module and render loading

from the mize folder working.

Cargo.lock

@@ -276,6 +276,90 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
+[[package]]
+name = "axum"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08b108ad2665fa3f6e6a517c3d80ec3e77d224c47d605167aefaa5d7ef97fa48"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "base64",
+ "bitflags",
+ "bytes 1.2.1",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sha-1",
+ "sync_wrapper",
+ "tokio",
+ "tokio-tungstenite",
+ "tower",
+ "tower-http",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79b8558f5a0581152dc94dcd289132a1d377494bdeafcd41869b3258e3e2ad92"
+dependencies = [
+ "async-trait",
+ "bytes 1.2.1",
+ "futures-util",
+ "http",
+ "http-body",
+ "mime",
+ "rustversion",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-extra"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9a320103719de37b7b4da4c8eb629d4573f6bcfd3dfe80d3208806895ccf81d"
+dependencies = [
+ "axum",
+ "bytes 1.2.1",
+ "futures-util",
+ "http",
+ "mime",
+ "pin-project-lite",
+ "tokio",
+ "tower",
+ "tower-http",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-macros"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4df0fc33ada14a338b799002f7e8657711422b25d4e16afb032708d6b185621"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "bare-metal"
 version = "0.2.5"
@@ -434,16 +518,6 @@ dependencies = [
  "cipher 0.4.3",
 ]
 
-[[package]]
-name = "buf_redux"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b953a6887648bb07a535631f2bc00fbdb2a2216f135552cb3f534ed136b9c07f"
-dependencies = [
- "memchr",
- "safemem",
-]
-
 [[package]]
 name = "bumpalo"
 version = "3.11.0"
@@ -1191,25 +1265,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "h2"
-version = "0.3.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca32592cf21ac7ccab1825cd87f6c9b3d9022c44d086172ed0966bec8af30be"
-dependencies = [
- "bytes 1.2.1",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
 [[package]]
 name = "hash32"
 version = "0.2.1"
@@ -1225,31 +1280,6 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
-[[package]]
-name = "headers"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3e372db8e5c0d213e0cd0b9be18be2aca3d44cf2fe30a9d46a65581cd454584"
-dependencies = [
- "base64",
- "bitflags",
- "bytes 1.2.1",
- "headers-core",
- "http",
- "httpdate",
- "mime",
- "sha1 0.10.5",
-]
-
-[[package]]
-name = "headers-core"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
-dependencies = [
- "http",
-]
-
 [[package]]
 name = "heapless"
 version = "0.7.16"
@@ -1263,6 +1293,12 @@ dependencies = [
  "stable_deref_trait",
 ]
 
+[[package]]
+name = "heck"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -1342,6 +1378,12 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "http-range-header"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29"
+
 [[package]]
 name = "http-types"
 version = "2.12.0"
@@ -1392,7 +1434,6 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
  "http",
  "http-body",
  "httparse",
@@ -1674,6 +1715,12 @@ dependencies = [
  "value-bag",
 ]
 
+[[package]]
+name = "matchit"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b87248edafb776e59e6ee64a79086f65890d3510f2c656c000bf2a7e8a0aea40"
+
 [[package]]
 name = "md-5"
 version = "0.10.5"
@@ -1727,31 +1774,17 @@ dependencies = [
 name = "mize"
 version = "0.1.0"
 dependencies = [
+ "axum",
+ "axum-extra",
+ "axum-macros",
  "futures-util",
  "itertools",
  "json",
  "surrealdb",
  "tokio",
  "tokio-stream",
- "warp",
+ "toml",
-]
+ "tower-http",
-
-[[package]]
-name = "multipart"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00dec633863867f29cb39df64a397cdf4a6354708ddd7759f70c7fb51c5f9182"
-dependencies = [
- "buf_redux",
- "httparse",
- "log",
- "mime",
- "mime_guess",
- "quick-error",
- "rand 0.8.5",
- "safemem",
- "tempfile",
- "twoway",
 ]
 
 [[package]]
@@ -2070,12 +2103,6 @@ version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33cb294fe86a74cbcf50d4445b37da762029549ebeea341421c7c70370f86cac"
 
-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
 [[package]]
 name = "quote"
 version = "1.0.21"
@@ -2197,15 +2224,6 @@ version = "1.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0df32d82cedd1499386877b062ebe8721f806de80b08d183c70184ef17dd1d42"
 
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
-
 [[package]]
 name = "riscv"
 version = "0.7.0"
@@ -2353,13 +2371,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "rustls-pemfile"
+name = "rustversion"
-version = "0.2.1"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eebeaeb360c87bfb72e84abdb3447159c0eaececf1bef2aecd65a8be949d1c9"
+checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70"
-dependencies = [
- "base64",
-]
 
 [[package]]
 name = "ryu"
@@ -2367,12 +2382,6 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
 
-[[package]]
-name = "safemem"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef703b7cb59335eae2eb93ceb664c0eb7ea6bf567079d843e09420219668e072"
-
 [[package]]
 name = "salsa20"
 version = "0.10.2"
@@ -2392,12 +2401,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "scoped-tls"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2"
-
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
@@ -2475,6 +2478,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b04f22b563c91331a10074bda3dd5492e3cc39d56bd557e91c0af42b6c7341"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_qs"
 version = "0.8.5"
@@ -2518,17 +2530,6 @@ dependencies = [
  "sha1_smol",
 ]
 
-[[package]]
-name = "sha1"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest 0.10.5",
-]
-
 [[package]]
 name = "sha1_smol"
 version = "1.0.0"
@@ -2692,7 +2693,7 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "sha1 0.6.1",
+ "sha1",
  "syn",
 ]
 
@@ -2816,18 +2817,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "tempfile"
+name = "sync_wrapper"
-version = "3.3.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+checksum = "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8"
-dependencies = [
- "cfg-if",
- "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
-]
 
 [[package]]
 name = "termcolor"
@@ -3002,18 +2995,64 @@ dependencies = [
  "futures-sink",
  "pin-project-lite",
  "tokio",
- "tracing",
 ]
 
 [[package]]
 name = "toml"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
+checksum = "1333c76748e868a4d9d1017b5ab53171dfd095f70c712fdb4653a406547f598f"
 dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project",
+ "pin-project-lite",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f873044bf02dd1e8239e9c1293ea39dad76dc594ec16185d0a1bf31d8dc8d858"
+dependencies = [
+ "bitflags",
+ "bytes 1.2.1",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-range-header",
+ "httpdate",
+ "mime",
+ "mime_guess",
+ "percent-encoding",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+
 [[package]]
 name = "tower-service"
 version = "0.3.2"
@@ -3099,15 +3138,6 @@ dependencies = [
  "utf-8",
 ]
 
-[[package]]
-name = "twoway"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b11b2b5241ba34be09c3cc85a36e56e48f9888862e19cedf23336d35316ed1"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "typenum"
 version = "1.15.0"
@@ -3253,37 +3283,6 @@ dependencies = [
  "try-lock",
 ]
 
-[[package]]
-name = "warp"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed7b8be92646fc3d18b06147664ebc5f48d222686cb11a8755e561a735aacc6d"
-dependencies = [
- "bytes 1.2.1",
- "futures-channel",
- "futures-util",
- "headers",
- "http",
- "hyper",
- "log",
- "mime",
- "mime_guess",
- "multipart",
- "percent-encoding",
- "pin-project",
- "rustls-pemfile",
- "scoped-tls",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "tokio",
- "tokio-stream",
- "tokio-tungstenite",
- "tokio-util",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "wasi"
 version = "0.9.0+wasi-snapshot-preview1"

Cargo.toml

@@ -6,10 +6,14 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+axum = { version = "0.6.1", features = ["ws"] }
+axum-extra = { version = "0.4.2", features = ["spa"] }
+axum-macros = "0.3.0"
 futures-util = "0.3.24"
 itertools = "0.10.5"
 json = "0.12.4"
 surrealdb = "1.0.0-beta.7"
 tokio = {version = "1.21.0", features = ["full"]}
 tokio-stream = "0.1.9"
-warp = "0.3.2"
+toml = "0.5.10"
+tower-http = "0.3.5"

src/server.rs

@@ -6,21 +6,34 @@ pub mod proto;
 
 //use futures_util::lock::Mutex;
 use futures_util::{FutureExt, StreamExt, SinkExt};
-use warp::Filter;
-use warp::ws::{WebSocket, self};
 use std::collections::HashMap;
+use std::boxed::Box;
+use std::path::Path;
+use crate::error::MizeError;
 
 use tokio::sync::mpsc::{Sender, channel, Receiver};
 use tokio_stream::wrappers::ReceiverStream;
 use std::alloc::handle_alloc_error;
 use std::fs;
-use std::sync::{Arc};
+use std::sync::Arc;
 use tokio::sync::Mutex;
 use tokio::sync::mpsc;
 use crate::server::proto::handle_mize_message;
 
 use self::itemstore::Itemstore;
 
+use axum_extra::routing::SpaRouter;
+use axum::Router;
+use axum::routing::{get, get_service};
+use std::net::SocketAddr;
+use axum::response::{IntoResponse, Html};
+use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
+use axum::extract::{State, self};
+use axum::http::{StatusCode, Uri, Response, self};
+use tower_http::services::{ServeDir, ServeFile};
+
+
+
 //static API_PATH_STRING: &str = "$api";
 static SOCKET_CHANNEL_SIZE: usize = 200;
 
@@ -55,20 +68,35 @@ static MAX_DATA_FILE_SIZE: usize = 3_000_000_000;
 //";
 
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Client {
 //    rx: UnboundedReceiverStream<Result<ws::Message, warp::Error>>,
     tx: Sender<proto::Message>,
     id: u64,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Module {
     tx: Sender<proto::Message>,
     name: String,
     client_id: u64,
-    //later
+    kind: ModuleKind,
-    //registered_types: Vec<String>,
+    registered_types: Vec<String>,
+}
+
+#[derive(Clone)]
+pub enum ModuleKind {
+    Binary(),
+    Python(),
+    Node(),
+}
+
+#[derive(Clone)]
+pub struct Render {
+    id: String,
+    webroot: String,
+    main: String,
+    folder: String,
 }
 
 //pub struct Upstream maybe???? ... I'd say later....
@@ -81,8 +109,10 @@ pub struct Mutexes {
     clients: Arc<Mutex<Vec<Client>>>,
     modules: Arc<Mutex<Vec<Module>>>,
     subs: Arc<Mutex<HashMap<String, Vec<proto::Origin>>>>,
+    renders: Arc<Mutex<Vec<Render>>>,
     //maybe a list of upstream servers??
     itemstore: Arc<Mutex<Itemstore>>,
+    mize_folder: String,
 }
 
 impl Mutexes {
@@ -91,7 +121,9 @@ impl Mutexes {
             next_free_client_id: Arc::clone(&mutexes.next_free_client_id),
             clients: Arc::clone(&mutexes.clients),
             modules: Arc::clone(&mutexes.modules),
+            renders: Arc::clone(&mutexes.renders),
             subs: Arc::clone(&mutexes.subs),
+            mize_folder: mutexes.mize_folder.clone(),
             itemstore: Arc::clone(&mutexes.itemstore),
         }
     }
@@ -119,24 +151,79 @@ pub async fn run_server(args: Vec<String>) {
     //create the itemstore
     let itemstore = crate::server::itemstore::Itemstore::new(mize_folder.clone() + "/db").await.expect("error creating itemstore");
 
-    // A collection of all the things, that most functions need
+    //load modules and renders
+    let ren_mods = std::fs::read_dir(mize_folder.clone() + "/modules-renders")
+        .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<Render> = Vec::new();
+
+    for ren_mod in ren_mods {
+        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 render_arr = match data.get("render").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
+                toml::Value::Array(arr) => arr,
+                _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
+            };
+
+            for render in render_arr {
+                let id = match render.get("id").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
+                    toml::Value::String(val) => val,
+                    _ => {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())) {
+                    toml::Value::String(val) => val,
+                    _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
+                };
+
+                let main = match render.get("main").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
+                    toml::Value::String(val) => val,
+                    _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
+                };
+                let folder = match render.get("folder").expect(&format!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())) {
+                    toml::Value::String(val) => val,
+                    _ => {panic!("something wrong in the mize.toml file in {:?}", ren_mod.file_name())}
+                };
+
+                let webroot = webroot.clone();
+                let main = main.clone();
+                let id = id.clone();
+                let folder = folder.clone();
+
+                renders.push(Render {id, webroot, main, folder});
+            };
+
+            //set modules
+            //later...
+        }
+    }
+
+
+    // Collection of all the things, that most functions need
     let mutexes: Mutexes = Mutexes {
         next_free_client_id: Arc::new(Mutex::new(0)),
         clients: Arc::new(Mutex::new(Vec::new())),
         subs: Arc::new(Mutex::new(HashMap::new())),
         modules: Arc::new(Mutex::new(Vec::new())),
+        renders: Arc::new(Mutex::new(renders)),
         itemstore: Arc::new(Mutex::new(itemstore)),
+        mize_folder: mize_folder.clone(),
     };
 
     //listen on the local unix socket
     //local_socket_server(mize_folder);
 
     //run the webserver
-    warp_server(mize_folder, mutexes).await;
+    axum_server(mize_folder, mutexes).await;
 }
 
 
-async fn warp_server(mize_folder: String, mutexes: Mutexes) {
+async fn axum_server(mize_folder: String, mutexes: Mutexes) {
     /*
      *
      *
@@ -147,52 +234,70 @@ async fn warp_server(mize_folder: String, mutexes: Mutexes) {
     //## $api/socket/id
     //## $api/rest/
  
-    // get itemstore
+
 
     let mutexes_clone = Mutexes::clone(&mutexes);
 
-    let socket_route = warp::path!("$api" / "socket")
+    let serve_client = get_service(ServeDir::new("js-client/src")).handle_error(handle_error);
-        .and(warp::ws())
-        .map(move |ws: warp::ws::Ws| {
-            let mutexes_clone = Mutexes::clone(&mutexes_clone);
-            ws.on_upgrade(move |socket| handle_websocket_connection(socket, mutexes_clone))
-    });
 
-    let render_route = warp::path!("$api" / "render").map(move || "render route");
+    let mut app = Router::new()
-    let file_route = warp::path!("$api" / "file").map(move || "file route");
+        .route("/==api==/socket", get(websocket_handler))
+        .route("/==api==/render/:id", get(get_render_main))
+//        .route("/$api/file", get(get_file_handler))
+//        .merge(SpaRouter::new("/$api/client", "js-client/src").index_file("main.html"))
+        .nest_service("/==api==/client", serve_client)
+        .with_state(mutexes.clone())
+        .fallback(render_item);
 
-    //temporary
+    let renders = mutexes.renders.lock().await;
-    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 || {
+    for render in &*renders {
-        let answer = fs::read_to_string("/home/sebastian/work/mize/js-client/src/main.js").unwrap();
+        let url_path = String::from("/==api==/render/webroot/") + &render.id + "/";
-        warp::http::Response::builder().header("content-type", "application/javascript").body(answer)
+        let file_path = render.webroot.clone();
-    });
+        let serve_dir = get_service(ServeDir::new(&file_path)).handle_error(handle_error);
 
-    let defuatl_route = warp::path::full().map(|path|{
+        app = app.nest_service(&url_path, serve_dir);
-        //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
+    drop(renders);
-        //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();
+    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
-        warp::http::Response::builder().body(answer)
+//    tracing::debug!("listening on {}", addr);
-    });
+    axum::Server::bind(&addr)
-    
+        .serve(app.into_make_service())
-    //let routes = warp::get().and(socket_route).or(render_route).or(file_route).map(move |hi| "default");
+        .await
-    let routes = warp::get().and(
+        .unwrap();
-        
+
-        render_route
+}
-            .or(file_route)
+
-            .or(socket_route)
+async fn handle_error(_err: std::io::Error) -> impl IntoResponse {
-            .or(main_route)
+        (StatusCode::INTERNAL_SERVER_ERROR, "Something went wrong...")
-            .or(defuatl_route)
+}
-            //.or(sum)
+
-            //.or(times),
+async fn render_item(uri: Uri) -> impl IntoResponse {
-    );
+    Html(fs::read_to_string("js-client/src/main.html").unwrap())
-       
+}
-    warp::serve(routes).run(([127, 0, 0, 1], 3000)).await;
+
+//#[axum_macros::debug_handler]
+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 render = renders.iter().filter(|&render| render.id == id).nth(0)
+        .unwrap_or(renders.iter().filter(|&render| render.id == "first").nth(0).expect("there is no first render"));
+
+    let file_name = mutexes.mize_folder.clone() + "/modules-renders/" + &render.folder + "/" + &render.main;
+    println!("file_name: {}", file_name);
+
+    Response::builder()
+        .header("content-type", "application/javascript")
+        .status(StatusCode::OK)
+        .body(fs::read_to_string(file_name).unwrap()).unwrap()
+}
+
+async fn websocket_handler(
+        ws: WebSocketUpgrade,
+            State(mutexes): State<Mutexes>,
+) -> impl IntoResponse {
+        ws.on_upgrade(|socket| handle_websocket_connection(socket, mutexes))
 }
 
 async fn handle_websocket_connection(
@@ -204,12 +309,10 @@ async fn handle_websocket_connection(
 
     let mut msg_rx = ReceiverStream::new(msg_rx);
 
-//    tokio::spawn(msg_rx.forward(socket_tx));
-
     //my own forward
     tokio::spawn(async move {
         while let Some(msg) = msg_rx.next().await {
-            socket_tx.send(warp::ws::Message::binary(msg.raw)).await;
+            socket_tx.send(Message::Binary(msg.raw)).await;
         }
     });
 
@@ -226,65 +329,26 @@ async fn handle_websocket_connection(
         let msg = result.expect("Error when getting message from WebSocket");
         println!("got message: {:?}", msg);
 
+        let bytes = match msg {
+            Message::Binary(b) => b,
+            _ => {
+                let err = MizeError{
+                    code: 11,
+                    kind: "don't know yet".to_string(),
+                    message: "the message type was not Binary".to_string(),
+                };
+                msg_tx.send(err.to_message(proto::Origin::Client(client.clone()))).await;
+                vec![0]
+            },
+        };
+
         if let Err(err) = handle_mize_message(
-            proto::Message::from_bytes(msg.clone().into_bytes(),proto::Origin::Client(client.clone())), mutexes.clone(),
+            proto::Message::from_bytes(bytes, proto::Origin::Client(client.clone())), mutexes.clone(),
         ).await {
             msg_tx.send(err.to_message(proto::Origin::Client(client.clone()))).await;
         };
     };
 }
 
-//pub async fn handle_unix_socket_connection(){
-//}
-
-//async fn handle_connection(con: Connection){
-//}
-
-//pub async fn send_to_all_clients(message: ws::Message, mutexes_clone: Mutexes){
-//    let clients = mutexes_clone.clients.lock().await;
-//    for client in &clients.clients[..] {
-//        client.tx.send(Ok(ws::Message::binary(message.clone())));
-//    }
-//    drop(clients);
-
-//    let modules = mutexes_clone.modules.lock().await;
-//    for module in &modules.modules[..] {
-//        module.tx.send(Ok(ws::Message::binary(message.clone())));
-//    }
-//}
-
-//pub async fn send_to_all_subbed_clients(id: String, message: ws::Message, mutexes_clone: Mutexes){
-//    let clients = mutexes_clone.clients.lock().await;
-//    for client in &clients.clients[..] {
-//        if client.sub.contains(&id) {
-//            client.tx.send(Ok(ws::Message::binary(message.clone())));
-//        }
-//    }
-
-//    let modules = mutexes_clone.modules.lock().await;
-//    for module in &modules.modules[..] {
-//        if module.sub.contains(&id) {
-//            module.tx.send(Ok(ws::Message::binary(message.clone())));
-//        }
-//    }
-//}
-
-//that does not work like this
-
-//impl From<proto::Message> for Result<warp::ws::Message, warp::Error> {
-//    fn from(msg: proto::Message) -> Result<warp::ws::Message, warp::Error> { 
-//        let msg = warp::ws::Message::binary(msg.raw);
-//    }
-//}
-
-//impl From<Result<warp::ws::Message, warp::Error>> for proto::Message {
-//    fn from(ws_msg: Result<warp::ws::Message, warp::Error>) -> proto::Message {
-//        let msg = ws_msg.expect("Error in From trait implementation: warp::ws::Messate to proto::Message");
-//    }
-//}
-//191 |     cli.push(Client{tx: client_tx, id: client_id});
-//    = note: expected struct `tokio::sync::mpsc::Sender<proto::Message>`
-//               found struct `tokio::sync::mpsc::Sender<`
-
 
 

src/server/itemstore.rs

@@ -27,14 +27,26 @@ impl Itemstore {
         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 keys = vec![
-                tr.set("0".to_string().into_bytes(), encode(init)).await?;
+                    "num_of_items".as_bytes().to_vec(),
+                    "next_free_id".as_bytes().to_vec(),
+                    "_commit".as_bytes().to_vec(),
+                    "_type".as_bytes().to_vec(),
+                    "renders".as_bytes().to_vec(),
+                    "modules".as_bytes().to_vec(),
+                ];
+
+                tr.set("0".to_string().into_bytes(), encode(keys)).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.set("0:renders".to_string().into_bytes(), Vec::new());
+                tr.set("0:modules".to_string().into_bytes(), Vec::new());
+
                 tr.commit().await?;
             },
 
@@ -69,33 +81,6 @@ impl Itemstore {
         }
         tr.set(format!("{}", id_u64), encode(keys)).await?;
 
-        //increment 0:number_of_items by 1
-        let num_res = tr.get("0:num_of_items".to_string().into_bytes()).await?;
-        if let Some(num) = num_res {
-            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;
-            new_id = num_u64;
-            tr.set("0:num_of_items".to_string().into_bytes(), num_u64.to_be_bytes()).await?;
-        } else {
-            return Err(MizeError{
-                code: 101,
-                kind: "key-missing:item0".to_string(),
-                message: "The Item0 should have a key num_of_items, but that is not there.".to_string(),
-            });
-        }
-
-        //imcrement next_free_id by 1
-        let num_res = tr.get("0:next_free_id".to_string().into_bytes()).await?;
-        if let Some(num) = num_res {
-            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_u64.to_be_bytes()).await?;
-        } else {
-            return Err(MizeError{
-                code: 101,
-                kind: "key-missing:item0".to_string(),
-                message: "The Item0 should have a key next_free_id, but that is not there.".to_string(),
-            });
-        }
-
         tr.commit().await?;
         return Ok(new_id)
     }
@@ -113,9 +98,6 @@ impl Itemstore {
 
         let mut keys: Vec<Vec<u8>> = Vec::new();
 
-        //check the _type of the item and maybe run type-code
-        //TODO: typecode
-
         //read keys
         let mut keys = match tr.get(format!("{}", update.id).into_bytes()).await? {
             Some(keys) => decode(keys),

src/server/proto.rs

@@ -80,7 +80,7 @@ pub struct Message {
 //    None,
 //}
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum Origin {
     Client(server::Client), //the client id
     Module(server::Module), //Module_name
@@ -674,6 +674,7 @@ pub async fn handle_mize_message(
             Err(err) => {return Err(err);},
             Ok(item) => {item0 = item;},
         }
+        println!("got create message");
 
         //update item0
         let mut next_free_id: Vec<u8> = Vec::new();
@@ -720,6 +721,7 @@ pub async fn handle_update(mut update: Update, mutexes: Mutexes, origin: Origin)
     //and either call itemstore.update(), send the update to the module or upstream, or spawn another
     //update by calling handle_update()
     
+    println!("handle_update");
 
     ///////////////////////////////// TYPE CODE ////////////////////////////////////////
     //can change the update and spawn new updates (to a different item) (which would call the handle_update func again)