Feature/middlewares (#5)

* added middleware editor * added middlewares * added middlewares * added logs * added more logging * Bump version
PawnTown · Jan 27, 2023 · 51d4e36 · 51d4e36
1 parent fd31f08
commit 51d4e36
Show file tree

Hide file tree

Showing 18 changed files with 575 additions and 62 deletions.
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "drawbridge",
   "private": true,
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
@@ -14,6 +14,7 @@
   "dependencies": {
     "@tauri-apps/api": "^1.2.0",
     "@types/uuid": "^9.0.0",
+    "monaco-editor": "0.34.1",
     "svelte-tauri-filedrop": "^1.0.0",
     "uuid": "^9.0.0"
   },

diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "drawbridge"
-version = "0.0.4"
+version = "0.0.5"
 description = "A Tauri App"
 authors = ["Khadim Fall"]
 license = ""
@@ -30,6 +30,7 @@ regex = "1.7.1"
 rust-embed = "6.4.2"
 humantime = "2.1.0"
 rand = "0.8.5"
+rlua = "0.19.4"
 
 [features]
 # by default Tauri runs in production mode

diff --git a/src-tauri/src/driver.rs b/src-tauri/src/driver.rs
@@ -1,14 +1,14 @@
 use async_trait::async_trait;
 
-use crate::logger;
+use crate::{logger, middleware::Middleware};
 
 pub mod connect;
 pub mod ssh;
 pub mod ptcec;
 
 #[async_trait]
 pub trait Driver {
-    async fn run(&self, args: Vec<String>, log: Option<logger::Logger>) -> Result<(), Box<dyn std::error::Error>>;
+    async fn run(&self, args: Vec<String>, log: Option<logger::Logger>, middleware: Middleware) -> Result<(), Box<dyn std::error::Error>>;
 }
 
 pub fn get_driver(driver_name: String) -> Option<Box<dyn Driver>> {

diff --git a/src-tauri/src/driver/connect.rs b/src-tauri/src/driver/connect.rs
@@ -1,15 +1,15 @@
 use async_trait::async_trait;
 use serde_json::Value;
 
-use crate::{storage, logger};
+use crate::{storage, logger, middleware::Middleware};
 
 use super::{Driver, ptcec, ssh};
 
 pub struct ConnectDriver {}
 
 #[async_trait]
 impl Driver for ConnectDriver {
-    async fn run(&self, args: Vec<String>, logger: Option<logger::Logger>) -> Result<(), Box<dyn std::error::Error>> {
+    async fn run(&self, args: Vec<String>, logger: Option<logger::Logger>, _: Middleware) -> Result<(), Box<dyn std::error::Error>> {
         if args.len() != 3 {
             println!("Invalid number of arguments. Please use: drawbridge connect <remote-id>");
             std::process::exit(1);
@@ -29,6 +29,8 @@ impl Driver for ConnectDriver {
         match remote {
             Some(r) => {
                 let driver_name = r["driver"].as_str().unwrap();
+
+                let middleware = Middleware::new(r["middlewareLua"].as_str().unwrap().to_string());
 
                 if driver_name.eq("ptcec") {
                     // alias for: drawbridge ptcec <url> <engine> <mode> <token>
@@ -40,7 +42,7 @@ impl Driver for ConnectDriver {
                         r["engine"].as_str().unwrap().to_string(),
                         r["mode"].as_str().unwrap().to_string(),
                         r["token"].as_str().unwrap().to_string(),
-                    ], logger).await;
+                    ], logger, middleware).await;
                 }
 
                 if driver_name.eq("ssh") {
@@ -52,7 +54,7 @@ impl Driver for ConnectDriver {
                         r["url"].as_str().unwrap().to_string(),
                         r["runCommand"].as_str().unwrap().to_string(),
                         r["privateKeyFile"].as_str().unwrap().to_string(),
-                    ], logger).await;
+                    ], logger, middleware).await;
                 }
 
                 println!("Driver {} not found.", driver_name);

diff --git a/src-tauri/src/driver/ptcec.rs b/src-tauri/src/driver/ptcec.rs
@@ -17,23 +17,24 @@ pub mod proto {
 }
 
 use crate::logger;
+use crate::middleware::Middleware;
 
 use super::Driver;
 
 pub struct PtcecDriver {}
 
 #[async_trait]
 impl Driver for PtcecDriver {
-    async fn run(&self, args: Vec<String>, logger: Option<logger::Logger>) -> Result<(), Box<dyn std::error::Error>> {
+    async fn run(&self, args: Vec<String>, logger: Option<logger::Logger>, middleware: Middleware) -> Result<(), Box<dyn std::error::Error>> {
         if args.len() != 6 {
             println!("Invalid number of arguments. Please use: drawbridge ptcec <url> <engine> <mode> <token>");
             std::process::exit(1);
         }
-        return ptcec_run(args[2].clone(), args[3].clone(), args[4].clone(), args[5].clone(), gen_session_id(), logger).await;
+        return ptcec_run(args[2].clone(), args[3].clone(), args[4].clone(), args[5].clone(), gen_session_id(), logger, middleware).await;
     }
 }
 
-async fn ptcec_run(url: String, engine: String, mode: String, token: String, session_id: String, logger: Option<logger::Logger>) -> Result<(), Box<dyn std::error::Error>> {
+async fn ptcec_run(url: String, engine: String, mode: String, token: String, session_id: String, logger: Option<logger::Logger>, middleware: Middleware) -> Result<(), Box<dyn std::error::Error>> {
     let channel = Channel::from_shared(url).unwrap().connect().await?;
     let mut auth_header = "Basic ".to_owned();
     auth_header.push_str(&token);
@@ -68,7 +69,10 @@ async fn ptcec_run(url: String, engine: String, mode: String, token: String, ses
     };
     tx.send(init_req).await.unwrap();
 
+    let middleware_ptr = Arc::new(middleware);
 
+
+    let middleware_ptr_a = Arc::clone(&middleware_ptr);
     let logger_ptr_b = Arc::clone(&logger_o_ptr);
     tokio::spawn(async move {
         let stdin = stdin();
@@ -88,6 +92,43 @@ async fn ptcec_run(url: String, engine: String, mode: String, token: String, ses
                 _ => (),
             }
 
+            line = line.replace("\n", "");
+            let oline = line.clone();
+
+            match middleware_ptr_a.handle_out(oline.clone()) {
+                Ok(new_line) => {
+                    line = new_line;
+                },
+                Err(e) => {
+                    let mut guard = logger_ptr_a.lock().await; {
+                        if guard.is_some() {
+                            if guard.as_mut().unwrap().debug_error(&format!("Failed to apply outgoing middleware: {}", e)).is_err() {/* ignored */}
+                        }
+                        drop(guard);
+                    };
+                    continue;
+                },
+            };
+
+            if !oline.eq("") && line.eq("") {
+                let mut guard = logger_ptr_a.lock().await; {
+                    if guard.is_some() {
+                        if guard.as_mut().unwrap().debug_info(&format!("Filtered out by middleware[message_out]: {}", oline)).is_err() {/* ignored */}
+                    }
+                    drop(guard);
+                };
+                continue;
+            } else if !oline.eq(&line) {
+                let mut guard = logger_ptr_a.lock().await; {
+                    if guard.is_some() {
+                        if guard.as_mut().unwrap().debug_info(&format!("Changed by middleware[message_out]: '{}' -> '{}'", oline, line)).is_err() {/* ignored */}
+                    }
+                    drop(guard);
+                };
+            }
+
+            line.push_str("\n");
+
             let mut guard = logger_ptr_a.lock().await; {
                 if guard.is_some() {
                     let mut logline = line.clone();
@@ -121,17 +162,51 @@ async fn ptcec_run(url: String, engine: String, mode: String, token: String, ses
         .await
         .unwrap()
         .into_inner();
-
+
+    let middleware_ptr_b = Arc::clone(&middleware_ptr);
     let logger_ptr_c = Arc::clone(&logger_o_ptr);
     while let Some(item) = stream.next().await {
         match str::from_utf8(item.unwrap().stdout.as_ref()) {
-            Ok(v) => {
+            Ok(oline) => {
+                let mut line = oline.clone().to_string();
+                match middleware_ptr_b.handle_in(line) {
+                    Ok(new_line) => {
+                        line = new_line;
+                    },
+                    Err(e) => {
+                        let mut guard = logger_ptr_c.lock().await; {
+                            if guard.is_some() {
+                                if guard.as_mut().unwrap().debug_error(&format!("Failed to apply incomming middleware: {}", e)).is_err() {/* ignored */}
+                            }
+                            drop(guard);
+                        };
+                        continue;
+                    },
+                };
+
+                if !oline.eq("") && line.eq("") {
+                    let mut guard = logger_ptr_c.lock().await; {
+                        if guard.is_some() {
+                            if guard.as_mut().unwrap().debug_info(&format!("Filtered out by middleware[message_in]: {}", oline)).is_err() {/* ignored */}
+                        }
+                        drop(guard);
+                    };
+                    continue;
+                } else if !oline.eq(&line) {
+                    let mut guard = logger_ptr_c.lock().await; {
+                        if guard.is_some() {
+                            if guard.as_mut().unwrap().debug_info(&format!("Changed by middleware[message_in]: '{}' -> '{}'", oline, line)).is_err() {/* ignored */}
+                        }
+                        drop(guard);
+                    };
+                }
+
                 let mut guard = logger_ptr_c.lock().await;
                 if guard.is_some() {
-                    if guard.as_mut().unwrap().debug_incomming(&v.clone()).is_err() {/* ignored */}
+                    if guard.as_mut().unwrap().debug_incomming(&line.clone()).is_err() {/* ignored */}
                 }
                 drop(guard);
-                println!("{}", v)
+                println!("{}", line)
             },
             Err(e) => {
                 let mut guard = logger_ptr_c.lock().await; {