mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-19 01:55:04 +01:00
feat(sync): attach local folders to existing My files folders
This commit is contained in:
1 parent
800705ccb0
commit
5ca0272f15
13 files changed
+453
-1
No files matched your search
@@ -2912,6 +2912,220 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "mounts FUSE: run explicitly on an isolated fake Drive"]
|
||||
fn attaching_my_files_preserves_local_files_and_syncs_both_ways() {
|
||||
use std::os::unix::fs::MetadataExt;
|
||||
let drive = FakeDrive::new();
|
||||
let dir = scratch("attach-my-files");
|
||||
let daemon = Daemon::start(&dir, drive.client(1, Faults::lan())).unwrap();
|
||||
std::fs::create_dir(daemon.mountpoint.join("Work")).unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || {
|
||||
daemon.pending().is_ok_and(|items| items.is_empty()) && drive.lookup("Work").is_some()
|
||||
}));
|
||||
drive.device().write("Work/cloud.txt", b"from cloud");
|
||||
drive.device().write("Work/common.txt", b"remote version");
|
||||
drive.device().write("Work/identical.txt", b"same bytes");
|
||||
let local = dir.join("local");
|
||||
std::fs::create_dir(&local).unwrap();
|
||||
std::fs::write(local.join("local.txt"), b"only on this computer").unwrap();
|
||||
std::fs::write(local.join("common.txt"), b"local version").unwrap();
|
||||
std::fs::write(local.join("identical.txt"), b"same bytes").unwrap();
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: local.to_str().unwrap().into(),
|
||||
remote_path: "Work".into(),
|
||||
})
|
||||
.unwrap();
|
||||
let folder = match daemon.request(&Request::ListSyncFolders).unwrap() {
|
||||
Response::SyncFolders { items } => {
|
||||
items
|
||||
.into_iter()
|
||||
.find(|f| f.local_path == local.to_str().unwrap())
|
||||
.unwrap()
|
||||
.id
|
||||
}
|
||||
other => panic!("unexpected reply: {other:?}"),
|
||||
};
|
||||
assert!(wait_until(Duration::from_secs(30), || {
|
||||
drive.lookup("Work/local.txt").is_some()
|
||||
&& std::fs::read(local.join("cloud.txt")).is_ok_and(|b| b == b"from cloud")
|
||||
&& std::fs::read(local.join("common.txt")).is_ok_and(|b| b == b"remote version")
|
||||
&& !conflict_copies(&local, "common").is_empty()
|
||||
}));
|
||||
assert_ne!(
|
||||
std::fs::metadata(&local).unwrap().dev(),
|
||||
std::fs::metadata(&daemon.mountpoint).unwrap().dev()
|
||||
);
|
||||
assert!(
|
||||
conflict_copies(&local, "common")
|
||||
.iter()
|
||||
.any(|p| std::fs::read(p).is_ok_and(|b| b == b"local version"))
|
||||
);
|
||||
assert!(
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: local.to_str().unwrap().into(),
|
||||
remote_path: "Work".into()
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
let duplicate = dir.join("duplicate");
|
||||
std::fs::create_dir(&duplicate).unwrap();
|
||||
assert!(
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: duplicate.to_str().unwrap().into(),
|
||||
remote_path: "Work".into()
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: duplicate.to_str().unwrap().into(),
|
||||
remote_path: "../Work".into()
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
// Parent/child mappings, the account root and files cannot be attached.
|
||||
std::fs::create_dir(daemon.mountpoint.join("Work/Sub")).unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || {
|
||||
daemon.pending().is_ok_and(|items| items.is_empty())
|
||||
&& drive.lookup("Work/Sub").is_some()
|
||||
}));
|
||||
for remote in ["Work/Sub", ".", "Work/cloud.txt"] {
|
||||
assert!(
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: duplicate.to_str().unwrap().into(),
|
||||
remote_path: remote.into(),
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
// Local overlap and symlink aliases into the actual cloud mount are refused.
|
||||
let alias = dir.join("cloud-alias");
|
||||
std::os::unix::fs::symlink(daemon.mountpoint.join("Work"), &alias).unwrap();
|
||||
std::fs::create_dir_all(local.join("Sub")).unwrap();
|
||||
for path in [
|
||||
local.join("Sub"),
|
||||
dir.clone(),
|
||||
daemon.mountpoint.join("Work"),
|
||||
alias,
|
||||
] {
|
||||
let error = daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: path.to_string_lossy().into_owned(),
|
||||
remote_path: "Work/Sub".into(),
|
||||
})
|
||||
.unwrap_err()
|
||||
.to_string();
|
||||
assert!(error.contains("overlaps"), "{error}");
|
||||
}
|
||||
assert!(conflict_copies(&local, "identical").is_empty());
|
||||
assert_eq!(
|
||||
std::fs::read(local.join("identical.txt")).unwrap(),
|
||||
b"same bytes"
|
||||
);
|
||||
// Simultaneous requests cannot register two local trees for one cloud root.
|
||||
std::fs::create_dir(daemon.mountpoint.join("Other")).unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || {
|
||||
daemon.pending().is_ok_and(|items| items.is_empty()) && drive.lookup("Other").is_some()
|
||||
}));
|
||||
let candidate_a = dir.join("candidate-a");
|
||||
let candidate_b = dir.join("candidate-b");
|
||||
std::fs::create_dir(&candidate_a).unwrap();
|
||||
std::fs::create_dir(&candidate_b).unwrap();
|
||||
let outcomes = std::thread::scope(|scope| {
|
||||
let a = scope.spawn(|| {
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: candidate_a.to_str().unwrap().into(),
|
||||
remote_path: "Other".into(),
|
||||
})
|
||||
.map_err(|e| e.to_string())
|
||||
});
|
||||
let b = scope.spawn(|| {
|
||||
daemon
|
||||
.request(&Request::AttachSyncFolder {
|
||||
local_path: candidate_b.to_str().unwrap().into(),
|
||||
remote_path: "Other".into(),
|
||||
})
|
||||
.map_err(|e| e.to_string())
|
||||
});
|
||||
[a.join().unwrap(), b.join().unwrap()]
|
||||
});
|
||||
assert_eq!(
|
||||
outcomes.iter().filter(|result| result.is_ok()).count(),
|
||||
1,
|
||||
"exactly one mapping may own a remote root: {outcomes:?}"
|
||||
);
|
||||
drive
|
||||
.device()
|
||||
.write("Work/cloud.txt", b"new cloud revision");
|
||||
daemon
|
||||
.request(&Request::SyncNow { id: Some(folder) })
|
||||
.unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || std::fs::read(
|
||||
local.join("cloud.txt")
|
||||
)
|
||||
.is_ok_and(|b| b == b"new cloud revision")));
|
||||
std::fs::write(local.join("local.txt"), b"new local revision").unwrap();
|
||||
daemon
|
||||
.request(&Request::SyncNow { id: Some(folder) })
|
||||
.unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || drive
|
||||
.tree()
|
||||
.get("Work/local.txt")
|
||||
== Some(&Entry::File(Arc::new(b"new local revision".to_vec())))));
|
||||
assert!(wait_until(Duration::from_secs(30), || listed_folder(
|
||||
&daemon, folder
|
||||
)
|
||||
.is_some_and(|f| f.state == "idle")));
|
||||
daemon
|
||||
.request(&Request::SetSyncFolderPaused {
|
||||
id: folder,
|
||||
paused: true,
|
||||
})
|
||||
.unwrap();
|
||||
let before = drive.tree();
|
||||
for entry in std::fs::read_dir(&local).unwrap() {
|
||||
let path = entry.unwrap().path();
|
||||
if path.is_dir() {
|
||||
std::fs::remove_dir_all(path).unwrap();
|
||||
} else {
|
||||
std::fs::remove_file(path).unwrap();
|
||||
}
|
||||
}
|
||||
daemon
|
||||
.request(&Request::SetSyncFolderPaused {
|
||||
id: folder,
|
||||
paused: false,
|
||||
})
|
||||
.unwrap();
|
||||
daemon
|
||||
.request(&Request::SyncNow { id: Some(folder) })
|
||||
.unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || listed_folder(
|
||||
&daemon, folder
|
||||
)
|
||||
.is_some_and(|f| f.state == "error")));
|
||||
assert_eq!(
|
||||
drive.tree(),
|
||||
before,
|
||||
"the wipe guard must preserve the remote tree"
|
||||
);
|
||||
assert!(matches!(daemon.stop(), Ok(MountOutcome::Shutdown)));
|
||||
let db = Db::open(&dir.join("pdfs.db")).unwrap();
|
||||
assert_eq!(
|
||||
db.sync_folder_get(folder).unwrap().unwrap().remote_share_id,
|
||||
"my-files-share"
|
||||
);
|
||||
drop(db);
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// Register `local` as a synced folder in `mode` and wait until the daemon
|
||||
/// lists it that way, returning its id.
|
||||
fn sync_folder(daemon: &Daemon, local: &Path, mode: &str) -> i64 {
|
||||
|
||||
@@ -1123,6 +1123,14 @@ fn delete_one(server: &mut Server, uid: &NodeUid) -> Result<()> {
|
||||
|
||||
#[async_trait]
|
||||
impl DriveApi for FakeClient {
|
||||
async fn context_share_id(&self, uid: &NodeUid) -> Result<ShareId> {
|
||||
self.request(false, |server| {
|
||||
assert_eq!(uid, &server.root);
|
||||
Ok(ShareId::new("my-files-share"))
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
async fn get_my_files_folder(&self) -> Result<Node> {
|
||||
self.request(false, |server| {
|
||||
let root = server.root.clone();
|
||||
|
||||
Reference in new issue
Block a user