feat: check and transform share roots, accepting uuids

Author: JupiterPi

README.md

@@ -10,9 +10,11 @@ Filen Relay provides a convenient way to serve your Filen Drive via WebDAV/HTTP/
 ### On Your Machine
 
 ```bash
-docker run -e FILEN_RELAY_ADMIN_EMAIL='your-filen-account@email.com' -p 80:80 ghcr.io/FilenCloudDienste/filen-relay:main
+docker run -e FILEN_RELAY_ADMIN_EMAIL='your-filen-account@email.com' -p 80:80 ghcr.io/filenclouddienste/filen-relay:main
 ```
 
+<!-- todo: fix issues here -->
+
 Configuration options (choose one):
 - Set `--admin-email` (`FILEN_RELAY_ADMIN_EMAIL`) and `--db-dir` (`FILEN_RELAY_DB_DIR`) options (or environment variables) to create a normal deployment.
 - Set `--admin-email` (`FILEN_RELAY_ADMIN_EMAIL`), `--admin-password` (`FILEN_RELAY_ADMIN_PASSWORD`) and `--db-dir` (`FILEN_RELAY_DB_DIR`) to create a deployment where data is stored in the admin's Filen drive. This is useful when the deployments needs to be stateless.

filen-relay/src/api.rs

@@ -56,6 +56,87 @@ pub(crate) async fn logout() -> Result<Response> {
         .unwrap())
 }
 
+#[derive(Serialize, Deserialize)]
+pub(crate) struct CheckedShareRoot {
+    pub path: String,
+    pub item_type: ShareRootType,
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) enum ShareRootType {
+    Root,
+    File,
+    Dir,
+}
+
+#[post("/api/checkRoot", session: auth::AuthSession)]
+pub(crate) async fn check_and_transform_root(
+    root: String,
+) -> Result<CheckedShareRoot, anyhow::Error> {
+    use super::backend::util::{find_path_for_dir, find_path_for_file};
+    use filen_sdk_rs::fs::categories::NonRootFileType;
+    use filen_types::fs::UuidStr;
+
+    // check if it is a uuid
+    if let Ok(uuid) = uuid::Uuid::try_parse(&root) {
+        dioxus::logger::tracing::info!("Checking root as UUID: {}", uuid);
+        // try to find a dir with the uuid
+        match session.filen_client.get_dir(UuidStr::from(&uuid)).await {
+            Ok(dir) => {
+                let path = find_path_for_dir(session.filen_client.as_ref(), dir).await?;
+                Ok(CheckedShareRoot {
+                    path,
+                    item_type: ShareRootType::Dir,
+                })
+            }
+            Err(e1) => {
+                // try to find a file with the uuid
+                match session.filen_client.get_file(UuidStr::from(&uuid)).await {
+                    Ok(file) => {
+                        let path = find_path_for_file(session.filen_client.as_ref(), file).await?;
+                        Ok(CheckedShareRoot {
+                            path,
+                            item_type: ShareRootType::File,
+                        })
+                    }
+                    Err(e2) => Err(anyhow::anyhow!(
+                        "Failed to find dir ({}), also failed to find file ({}), for provided UUID",
+                        e1,
+                        e2
+                    )),
+                }
+            }
+        }
+    } else {
+        let root = format!("/{}", root.trim_start_matches('/').trim_end_matches('/'));
+        // not a uuid, try to find a dir with the path
+        match session.filen_client.find_item_at_path(&root).await {
+            Ok(item) => match item {
+                Some(item) => match item {
+                    NonRootFileType::Root(_) => Ok(CheckedShareRoot {
+                        path: root,
+                        item_type: ShareRootType::Root,
+                    }),
+                    NonRootFileType::File(_) => Ok(CheckedShareRoot {
+                        path: root,
+                        item_type: ShareRootType::File,
+                    }),
+                    NonRootFileType::Dir(_) => Ok(CheckedShareRoot {
+                        path: root,
+                        item_type: ShareRootType::Dir,
+                    }),
+                }
+                None => Err(anyhow::anyhow!("No item found at provided path")),
+            },
+            Err(e) => Err(anyhow::anyhow!(
+                "Failed to find dir at path ({}), also failed to find file at path ({}), for provided path",
+                e,
+                e
+            )),
+        }
+    }
+}
+
 #[get("/api/shares", session: auth::AuthSession)]
 pub(crate) async fn get_shares() -> Result<Vec<Share>, anyhow::Error> {
     Ok(DB
@@ -72,7 +153,10 @@ pub(crate) async fn add_share(
     read_only: bool,
     password: Option<String>,
 ) -> Result<(), anyhow::Error> {
-    let root = format!("/{}", root.trim_start_matches('/'));
+    let root = check_and_transform_root(root)
+        .await
+        .context("Failed to check root")?
+        .path;
     DB.create_share(&Share {
         id: ShareId::new(),
         root,

filen-relay/src/backend/db.rs

@@ -8,8 +8,7 @@ use filen_sdk_rs::{
 use rusqlite::Connection;
 
 use crate::{
-    common::{ShareId, Share},
-    util::UnwrapOnceLock,
+    backend::util::UnwrapOnceLock, common::{Share, ShareId}
 };
 
 // todo: is it good (or safe) that this needs to be .lock().unwrap() everywhere?

filen-relay/src/backend/mod.rs

@@ -29,6 +29,7 @@ pub(crate) mod auth;
 pub(crate) mod db;
 pub(crate) mod rclone_auth_proxy;
 pub(crate) mod server_manager;
+pub(crate) mod util;
 
 pub(crate) fn serve(args: Args) {
     dioxus::serve(move || {

filen-relay/src/backend/server_manager.rs

@@ -50,7 +50,6 @@ impl ServerManager {
             let mut perms = script_file.as_file().metadata()?.permissions();
             perms.set_mode(0o755);
             script_file.as_file().set_permissions(perms)?;
-            dbg!(script_file.path());
             // todo: can we avoid creating a platform-dependent shell script?
 
             // spawn rclone process

filen-relay/src/backend/util.rs

@@ -0,0 +1,73 @@
+use std::{ops::Deref, sync::OnceLock};
+
+use anyhow::{Context, Result};
+use filen_sdk_rs::{
+    auth::Client,
+    fs::HasUUID,
+    io::{RemoteDirectory, RemoteFile},
+};
+use filen_types::fs::UuidStr;
+
+/// A wrapper around OnceLock that panics if accessed before initialization.
+/// This is useful for when you know the value will be initialized and want to avoid
+/// explicitly calling unwrap() everywhere.
+pub struct UnwrapOnceLock<T>(OnceLock<T>);
+
+impl<T> UnwrapOnceLock<T> {
+    pub const fn new() -> Self {
+        UnwrapOnceLock(OnceLock::new())
+    }
+}
+
+impl<T> UnwrapOnceLock<T> {
+    pub fn init(&self, val: T) {
+        let _ = self.0.set(val);
+    }
+}
+
+impl<T> Deref for UnwrapOnceLock<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.get().expect("OnceLock not initialized")
+    }
+}
+
+pub(crate) async fn find_path_for_dir(client: &Client, dir: RemoteDirectory) -> Result<String> {
+    dbg!("Finding path for dir", dir.uuid());
+    dbg!("Root dir", client.root().uuid());
+    dbg!("Parent uuid", dir.parent);
+    if dir.uuid() == client.root().uuid() {
+        return Ok(String::new());
+    }
+    let parent_uuid = UuidStr::try_from(dir.parent)
+        .context("Failed to get parent UUID for directory not inside regular file tree")?;
+    let parent_path = if &parent_uuid == client.root().uuid() {
+        String::new()
+    } else {
+        let parent = client.get_dir(parent_uuid).await.with_context(|| {
+            format!("Failed to find parent {parent_uuid} while traversing path")
+        })?;
+        Box::pin(find_path_for_dir(client, parent)).await?
+    };
+    Ok(format!(
+        "{}/{}",
+        parent_path,
+        dir.meta.name().unwrap_or("INVALID_NAME")
+    ))
+}
+
+pub(crate) async fn find_path_for_file(client: &Client, file: RemoteFile) -> Result<String> {
+    let parent_uuid = UuidStr::try_from(file.parent)
+        .context("Failed to get parent UUID for file not inside regular file tree")?;
+    let parent = client
+        .get_dir(parent_uuid)
+        .await
+        .with_context(|| format!("Failed to find parent {parent_uuid} while traversing path"))?;
+    let parent_path = find_path_for_dir(client, parent).await?;
+    Ok(format!(
+        "{}/{}",
+        parent_path,
+        file.meta.name().unwrap_or("INVALID_NAME")
+    ))
+}

filen-relay/src/frontend/mod.rs

@@ -310,7 +310,11 @@ fn Login() -> Element {
                                 checked: if *save_credentials.read() { CheckboxState::Checked } else { CheckboxState::Unchecked },
                                 on_checked_change: move |new_state| save_credentials.set(new_state == CheckboxState::Checked),
                             }
-                            "Remember me"
+                            label {
+                                r#for: "save_credentials",
+                                class: "cursor-pointer",
+                                "Remember me"
+                            }
                         }
                     }
                 }

filen-relay/src/frontend/shares.rs

@@ -1,6 +1,9 @@
-use crate::components::{
-    label::Label,
-    select::{SelectGroupLabel, SelectOption, SelectTrigger},
+use crate::{
+    api::ShareRootType,
+    components::{
+        label::Label,
+        select::{SelectGroupLabel, SelectOption, SelectTrigger},
+    },
 };
 use dioxus::prelude::*;
 use dioxus_primitives::checkbox::CheckboxState;
@@ -95,6 +98,7 @@ pub(crate) fn ShareCard(share: Share, open_as: ServerType, on_remove: EventHandl
                     target: "_blank",
                     "{share.root}"
                     img { src: open_external_icon, style: "color: #ffffff" }
+                                // todo: display copy icon instead when server type is not web
                 }
                 div { class: "flex-1" }
                 div { class: "flex items-center gap-2",
@@ -160,11 +164,16 @@ pub(crate) fn CreateShareCard(on_create: EventHandler<()>) -> Element {
                 },
                 div { class: "flex items-center gap-2 justify-between flex-wrap",
                     div { class: "flex items-center gap-4 flex-wrap",
-                        Input {
-                            id: "root",
-                            placeholder: "/path/to/share",
-                            value: "{root}",
-                            oninput: move |e: Event<FormData>| root.set(e.value().clone()),
+                        div { class: "flex flex-col gap-1",
+                            Input {
+                                id: "root",
+                                placeholder: "/path/to/share or ID",
+                                value: "{root}",
+                                oninput: move |e: Event<FormData>| root.set(e.value().clone()),
+                            }
+                            if root.len() > 0 {
+                                ShareRootChecker { root }
+                            }
                         }
                         div { class: "flex gap-2 items-center",
                             Checkbox {
@@ -201,3 +210,41 @@ pub(crate) fn CreateShareCard(on_create: EventHandler<()>) -> Element {
         }
     }
 }
+
+#[component]
+fn ShareRootChecker(root: ReadSignal<String>) -> Element {
+    let mut checked_root = use_action(move |root: String| async move {
+        match crate::api::check_and_transform_root(root).await {
+            Ok(checked_root) => Ok(checked_root),
+            Err(e) => {
+                dioxus::logger::tracing::error!("Failed to check root: {}", e);
+                Err(e)
+            }
+        }
+    });
+    use_effect(move || {
+        checked_root.call(root());
+    });
+    match checked_root.value() {
+        Some(Ok(checked_root)) => {
+            let item_type = match checked_root.read().item_type {
+                ShareRootType::File => "file",
+                ShareRootType::Dir => "directory",
+                ShareRootType::Root => "root",
+            };
+            let path = checked_root.read().path.clone();
+            rsx! {
+                div { class: "text-green-400 text-sm flex gap-1",
+                    "Sharing "
+                    span { class: "font-semibold", "{item_type}" }
+                    " at "
+                    span { class: "font-semibold", "{path}" }
+                }
+            }
+        }
+        Some(Err(_)) => rsx! {
+            span { class: "text-red-400 text-sm", "Must be a valid path or ID" }
+        },
+        None => rsx! {},
+    }
+}

filen-relay/src/main.rs

@@ -4,7 +4,6 @@ mod backend;
 mod common;
 mod components;
 mod frontend;
-mod util;
 
 #[cfg(feature = "server")]
 #[derive(clap::Parser, Clone)]