A step toward Malai 0.3

Cargo.toml

@@ -15,7 +15,11 @@ publish = true
 rust-version = "1.89" # update this when you update rust-toolchain.toml
 
 [profile.release]
-strip = true
+codegen-units = 1 # Allows LLVM to perform better optimization.
+lto = true        # Enables link-time-optimizations.
+opt-level = 3
+panic = "abort"   # Higher performance by disabling panic handlers.
+strip = true      # Ensures debug symbols are removed.
 
 [workspace.dependencies]
 # Please do not specify a dependency more precisely than needed. If version "1" works, do
@@ -40,7 +44,6 @@ directories = "6.0.0"
 eyre = "0.6"
 file-guard = "0.2.0"
 futures-util = "0.3"
-http = "1"
 http-body-util = "0.1"
 hyper = { version = "1", features = ["full"] }
 hyper-util = { version = "0.1.15", features = ["tokio", "server"] }

kulfi-utils/Cargo.toml

@@ -10,7 +10,7 @@ repository.workspace = true
 readme.workspace = true
 
 [dependencies]
-kulfi-id52 = { path = "../kulfi-id52", version = "0.1.0" }
+kulfi-id52.workspace = true
 bb8.workspace = true
 bytes.workspace = true
 colored.workspace = true

kulfi-utils/src/graceful.rs

@@ -50,8 +50,8 @@ impl Graceful {
                 .await
                 .wrap_err_with(|| "failed to get ctrl-c signal handler")?;
 
-            tracing::info!("Received ctrl-c signal, showing info.");
-            tracing::info!("Pending tasks: {}", self.tracker.len());
+            tracing::debug!("Received ctrl-c signal, showing info.");
+            tracing::debug!("Pending tasks: {}", self.tracker.len());
 
             self.show_info_tx
                 .send(true)
@@ -85,7 +85,7 @@ impl Graceful {
                     break;
                 }
                 _ = tokio::time::sleep(std::time::Duration::from_secs(3)) => {
-                    tracing::info!("Timeout expired. Continuing...");
+                    tracing::debug!("Timeout expired. Continuing...");
                     println!("Did not receive ctrl+c within 3 secs. Press ctrl+c in quick succession to exit.");
                 }
             }

kulfi-utils/src/lib.rs

@@ -10,7 +10,7 @@ mod http_to_peer;
 mod peer_to_http;
 mod ping;
 pub mod protocol;
-mod secret;
+pub mod secret;
 mod tcp;
 mod utils;
 mod utils_iroh;
@@ -25,7 +25,8 @@ pub use peer_to_http::peer_to_http;
 pub use ping::{PONG, ping};
 pub use protocol::{APNS_IDENTITY, Protocol, ProtocolHeader};
 pub use secret::{
-    SECRET_KEY_FILE, generate_and_save_key, generate_secret_key, get_secret_key, read_or_create_key,
+    ID52_FILE, SECRET_KEY_FILE, generate_and_save_key, generate_secret_key, get_secret_key,
+    read_or_create_key,
 };
 pub use tcp::{peer_to_tcp, pipe_tcp_stream_over_iroh, tcp_to_peer};
 pub use utils::mkdir;

kulfi-utils/src/peer_to_http.rs

@@ -12,7 +12,7 @@ pub async fn peer_to_http(
 
     let req: crate::http::Request = crate::next_json(&mut recv).await?;
 
-    tracing::info!("got request: {req:?}");
+    tracing::debug!("got request: {req:?}");
 
     let mut r = hyper::Request::builder()
         .method(req.method.as_str())

kulfi-utils/src/secret.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use eyre::WrapErr;
 
 pub const SECRET_KEY_ENV_VAR: &str = "KULFI_SECRET_KEY";
@@ -10,21 +12,33 @@ pub fn generate_secret_key() -> eyre::Result<(String, kulfi_id52::SecretKey)> {
     Ok((id52, secret_key))
 }
 
-pub async fn generate_and_save_key() -> eyre::Result<(String, kulfi_id52::SecretKey)> {
+pub fn generate_and_save_key(
+    file: Option<PathBuf>,
+) -> eyre::Result<(String, kulfi_id52::SecretKey)> {
     let (id52, secret_key) = generate_secret_key()?;
     let e = keyring_entry(&id52)?;
     e.set_secret(&secret_key.to_bytes())
         .wrap_err_with(|| format!("failed to save secret key for {id52}"))?;
-    tokio::fs::write(ID52_FILE, &id52).await?;
+    if let Some(file) = &file {
+        std::fs::write(file, &id52)
+            .wrap_err_with(|| format!("failed to save secret key to {}", &file.display()))?;
+        println!("ID52 saved to {}", file.display());
+    }
     Ok((id52, secret_key))
 }
 
+pub fn delete_identity(id52: &str) -> eyre::Result<()> {
+    let e = keyring_entry(id52)?;
+    e.delete_credential()?;
+    Ok(())
+}
+
 fn keyring_entry(id52: &str) -> eyre::Result<keyring::Entry> {
     keyring::Entry::new("kulfi", id52)
         .wrap_err_with(|| format!("failed to create keyring Entry for {id52}"))
 }
 
-fn handle_secret(secret: &str) -> eyre::Result<(String, kulfi_id52::SecretKey)> {
+pub fn handle_secret(secret: &str) -> eyre::Result<(String, kulfi_id52::SecretKey)> {
     use std::str::FromStr;
     let secret_key = kulfi_id52::SecretKey::from_str(secret).map_err(|e| eyre::anyhow!("{}", e))?;
     let id52 = secret_key.id52();
@@ -37,51 +51,54 @@ pub fn get_secret_key(_id52: &str, _path: &str) -> eyre::Result<kulfi_id52::Secr
     todo!("implement for kulfi")
 }
 
+pub fn handle_identity(id52: String) -> eyre::Result<(String, kulfi_id52::SecretKey)> {
+    let e = kulfi_utils::secret::keyring_entry(&id52)?;
+    match e.get_secret() {
+        Ok(secret) => {
+            if secret.len() != 32 {
+                return Err(eyre::anyhow!(
+                    "keyring: secret for {id52} has invalid length: {}",
+                    secret.len()
+                ));
+            }
+
+            let bytes: [u8; 32] = secret.try_into().expect("already checked for length");
+            let secret_key = kulfi_id52::SecretKey::from_bytes(&bytes);
+            let id52 = secret_key.id52();
+            Ok((id52, secret_key))
+        }
+        Err(e) => {
+            tracing::error!("failed to read secret for {id52} from keyring: {e}");
+            Err(e.into())
+        }
+    }
+}
+
 #[tracing::instrument]
 pub async fn read_or_create_key() -> eyre::Result<(String, kulfi_id52::SecretKey)> {
     if let Ok(secret) = std::env::var(SECRET_KEY_ENV_VAR) {
         tracing::info!("Using secret key from environment variable {SECRET_KEY_ENV_VAR}");
         return handle_secret(&secret);
-    } else {
-        match tokio::fs::read_to_string(SECRET_KEY_FILE).await {
-            Ok(secret) => {
-                tracing::info!("Using secret key from file {SECRET_KEY_FILE}");
-                let secret = secret.trim_end();
-                return handle_secret(secret);
-            }
-            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
-            Err(e) => {
-                tracing::error!("failed to read {SECRET_KEY_FILE}: {e}");
-                return Err(e.into());
-            }
+    }
+    match tokio::fs::read_to_string(SECRET_KEY_FILE).await {
+        Ok(secret) => {
+            tracing::info!("Using secret key from file {SECRET_KEY_FILE}");
+            let secret = secret.trim_end();
+            return handle_secret(secret);
+        }
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+        Err(e) => {
+            tracing::error!("failed to read {SECRET_KEY_FILE}: {e}");
+            return Err(e.into());
         }
     }
 
     tracing::info!("No secret key found in environment or file, trying {ID52_FILE}");
     match tokio::fs::read_to_string(ID52_FILE).await {
-        Ok(id52) => {
-            let e = keyring_entry(&id52)?;
-            match e.get_secret() {
-                Ok(secret) => {
-                    if secret.len() != 32 {
-                        return Err(eyre::anyhow!(
-                            "keyring: secret for {id52} has invalid length: {}",
-                            secret.len()
-                        ));
-                    }
-
-                    let bytes: [u8; 32] = secret.try_into().expect("already checked for length");
-                    let secret_key = kulfi_id52::SecretKey::from_bytes(&bytes);
-                    let id52 = secret_key.id52();
-                    Ok((id52, secret_key))
-                }
-                Err(e) => {
-                    tracing::error!("failed to read secret for {id52} from keyring: {e}");
-                    Err(e.into())
-                }
-            }
+        Ok(id52) => handle_identity(id52),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+            generate_and_save_key(Some(PathBuf::from(ID52_FILE)))
         }
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => generate_and_save_key().await,
         Err(e) => {
             tracing::error!("failed to read {ID52_FILE}: {e}");
             Err(e.into())

kulfi/src/control_server/server.rs

@@ -84,7 +84,7 @@ async fn handle_request_(
         }
     };
 
-    tracing::info!("got request for {id}");
+    tracing::debug!("got request for {id}");
 
     // if this is an identity, if so forward the request to fastn corresponding to that identity
     if let Some(fastn_port) = find_identity(id, id_map.clone()).await? {

kulfi/src/identity/create.rs

@@ -23,6 +23,8 @@
 //!
 //! `logs` is the folder that contains the logs for this identity. This contains fastn access logs
 //! and other device access logs etc.
+
+use std::path::PathBuf;
 impl kulfi::Identity {
     #[tracing::instrument(skip(client_pools))]
     pub async fn create(
@@ -31,7 +33,9 @@ impl kulfi::Identity {
     ) -> eyre::Result<Self> {
         use eyre::WrapErr;
 
-        let (id52, secret_key) = kulfi_utils::generate_and_save_key().await?;
+        let (id52, secret_key) = kulfi_utils::generate_and_save_key(Some(PathBuf::from(
+            kulfi_utils::secret::ID52_FILE,
+        )))?;
 
         let now = std::time::SystemTime::now();
         let unixtime = now

malai/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "malai"
-version = "0.2.9"
+version = "0.3.0"
 authors.workspace = true
 edition.workspace = true
 description = "malai: Kulfi Network Toolkit"
@@ -24,6 +24,7 @@ hyper-util.workspace = true
 hyper.workspace = true
 iroh.workspace = true
 kulfi-utils.workspace = true
+kulfi-id52.workspace = true
 mime_guess.workspace = true
 percent-encoding.workspace = true
 serde.workspace = true
@@ -35,6 +36,8 @@ tokio-util.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true
 webbrowser.workspace = true
+toml = "0.9.5"
+tracing-appender = "0.2.3"
 
 [build-dependencies]
 tauri-build = { workspace = true, optional = true }

malai/src/expose_http.rs

@@ -1,12 +1,11 @@
-pub async fn expose_http(host: String, port: u16, bridge: String, graceful: kulfi_utils::Graceful) {
-    let (id52, secret_key) = match kulfi_utils::read_or_create_key().await {
-        Ok(v) => v,
-        Err(e) => {
-            malai::identity_read_err_msg(e);
-            std::process::exit(1);
-        }
-    };
-
+pub async fn expose_http(
+    host: String,
+    port: u16,
+    bridge: String,
+    id52: String,
+    secret_key: kulfi_id52::SecretKey,
+    graceful: kulfi_utils::Graceful,
+) {
     let ep = match kulfi_utils::get_endpoint(secret_key).await {
         Ok(v) => v,
         Err(e) => {

malai/src/expose_tcp.rs

@@ -1,12 +1,10 @@
-pub async fn expose_tcp(host: String, port: u16, graceful: kulfi_utils::Graceful) {
-    let (id52, secret_key) = match kulfi_utils::read_or_create_key().await {
-        Ok(v) => v,
-        Err(e) => {
-            malai::identity_read_err_msg(e);
-            std::process::exit(1);
-        }
-    };
-
+pub async fn expose_tcp(
+    host: String,
+    port: u16,
+    id52: String,
+    secret_key: kulfi_id52::SecretKey,
+    graceful: kulfi_utils::Graceful,
+) {
     let ep = match kulfi_utils::get_endpoint(secret_key).await {
         Ok(v) => v,
         Err(e) => {

malai/src/folder/mod.rs

@@ -58,10 +58,19 @@ pub async fn folder(path: String, bridge: String, graceful: kulfi_utils::Gracefu
     let graceful_for_expose_http = graceful.clone();
 
     graceful.spawn(async move {
+        let (id52, secret_key) = match kulfi_utils::read_or_create_key().await {
+            Ok(v) => v,
+            Err(e) => {
+                malai::identity_read_err_msg(e);
+                std::process::exit(1);
+            }
+        };
         malai::expose_http(
             "127.0.0.1".to_string(),
             port,
             bridge,
+            id52,
+            secret_key,
             graceful_for_expose_http,
         )
         .await

malai/src/http_bridge.rs

@@ -135,7 +135,7 @@ async fn handle_request(
         }
     };
 
-    tracing::info!("got request for {peer_id}");
+    tracing::debug!("got request for {peer_id}");
 
     kulfi_utils::http_to_peer(
         kulfi_utils::Protocol::Http.into(),

malai/src/http_proxy.rs

@@ -130,7 +130,7 @@ async fn handle_request(
     remote: String,
     graceful: kulfi_utils::Graceful,
 ) -> kulfi_utils::http::ProxyResult<eyre::Error> {
-    tracing::info!("got request for {remote}");
+    tracing::debug!("got request for {remote}");
 
     let graceful_for_upgrade = graceful.clone();
     let host = match r