mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-22 18:33:31 +01:00
Compare commits
11
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5ffaa2c437 | ||
|
|
3694551158 | ||
|
|
a38829aace | ||
|
|
3c6ebfb705 | ||
|
|
4aa34cf8ce | ||
|
|
d0f9681593 | ||
|
|
f141d88d97 | ||
|
|
795dd7edb0 | ||
|
|
7be4c7db1e | ||
|
|
2b5d6f2436 | ||
|
|
ff8ee9d997 |
No files matched your search
@@ -159,6 +159,9 @@ jobs:
|
||||
install -Dm644 packaging/io.narl.proton-drive-linux.policy deb/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy
|
||||
cp packaging/proton-drive.service deb/usr/lib/systemd/user/
|
||||
cp LICENSE deb/usr/share/licenses/proton-drive-linux/
|
||||
# The offline Places basemap, already fetched for the tarball.
|
||||
scripts/fetch-basemap.sh
|
||||
install -Dm644 data/basemap-v1.pmtiles deb/usr/share/proton-drive-linux/basemap-v1.pmtiles
|
||||
po/build.sh deb/usr/share/locale
|
||||
packaging/completions.sh target/release/pdfs deb/usr/share
|
||||
|
||||
@@ -191,6 +194,8 @@ jobs:
|
||||
|
||||
- name: Package Fedora package (.rpm)
|
||||
run: |
|
||||
# The in-tree spec build installs the basemap from data/.
|
||||
scripts/fetch-basemap.sh
|
||||
# Sanitize version (replace hyphens with dots for RPM compatibility)
|
||||
RPM_VERSION=$(echo "${{ env.VERSION }}" | tr '-' '.')
|
||||
|
||||
|
||||
@@ -65,6 +65,7 @@ jobs:
|
||||
git config --global --add safe.directory "$GITHUB_WORKSPACE"
|
||||
VERSION=$(grep -m1 '^version' Cargo.toml | cut -d'"' -f2)
|
||||
SHORT=${GITHUB_SHA::7}
|
||||
scripts/fetch-basemap.sh
|
||||
mkdir -p rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS,BUILDROOT,db}
|
||||
rpmbuild -bb \
|
||||
--nodeps \
|
||||
|
||||
@@ -5,3 +5,4 @@
|
||||
/rpmbuild
|
||||
/result
|
||||
/result-*
|
||||
/data/*.pmtiles
|
||||
Generated
+89
-8
@@ -2,6 +2,22 @@
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "ab_glyph"
|
||||
version = "0.2.32"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"
|
||||
dependencies = [
|
||||
"ab_glyph_rasterizer",
|
||||
"owned_ttf_parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ab_glyph_rasterizer"
|
||||
version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
|
||||
|
||||
[[package]]
|
||||
name = "adler2"
|
||||
version = "2.0.1"
|
||||
@@ -232,6 +248,12 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "arrayref"
|
||||
version = "0.3.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
|
||||
|
||||
[[package]]
|
||||
name = "arrayvec"
|
||||
version = "0.7.8"
|
||||
@@ -3425,6 +3447,15 @@ dependencies = [
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "owned_ttf_parser"
|
||||
version = "0.25.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b"
|
||||
dependencies = [
|
||||
"ttf-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "p256"
|
||||
version = "0.13.2"
|
||||
@@ -3603,7 +3634,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
|
||||
|
||||
[[package]]
|
||||
name = "pdfs-cli"
|
||||
version = "3.9.0"
|
||||
version = "3.10.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"clap",
|
||||
@@ -3620,7 +3651,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pdfs-core"
|
||||
version = "3.9.0"
|
||||
version = "3.10.0"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.23.1",
|
||||
@@ -3650,7 +3681,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pdfs-fuse"
|
||||
version = "3.9.0"
|
||||
version = "3.10.0"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.23.1",
|
||||
@@ -3683,7 +3714,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pdfs-gui"
|
||||
version = "3.9.0"
|
||||
version = "3.10.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"async-channel",
|
||||
@@ -3696,6 +3727,7 @@ dependencies = [
|
||||
"pangocairo",
|
||||
"pdfs-core",
|
||||
"proton-gallery-rs",
|
||||
"proton-map-rs",
|
||||
"reqwest",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -3952,9 +3984,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "proton-drive-rs"
|
||||
version = "0.12.4"
|
||||
version = "0.12.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "670bfcf0eeb15886c962c18c76dbac976236e4377bfe073eb2360dc1ce448da2"
|
||||
checksum = "8b1a71d0e737a9bd6cff07105218e7bef3bddcfd9d6651646d7302cdbba71961"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.23.1",
|
||||
@@ -4045,6 +4077,18 @@ dependencies = [
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-map-rs"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a8440e8a25b89e1c3d3c0747285ebc558e84a019b237307111f21306f183e78d"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
"tiny-skia",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-media-rs"
|
||||
version = "0.1.1"
|
||||
@@ -4060,9 +4104,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "proton-sdk"
|
||||
version = "0.12.4"
|
||||
version = "0.12.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f578a9d920cef3f6c4da611793001fe6d2ed81face13c45f5e721274b1945f7d"
|
||||
checksum = "81edef2b4b174e936a3537793ee901b92dd7c0484eb7fed09ad69432f407f86b"
|
||||
dependencies = [
|
||||
"aes-gcm 0.11.1",
|
||||
"async-trait",
|
||||
@@ -5093,6 +5137,12 @@ version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
|
||||
|
||||
[[package]]
|
||||
name = "strict-num"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
|
||||
|
||||
[[package]]
|
||||
name = "strsim"
|
||||
version = "0.11.1"
|
||||
@@ -5267,6 +5317,31 @@ dependencies = [
|
||||
"zune-jpeg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tiny-skia"
|
||||
version = "0.11.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
|
||||
dependencies = [
|
||||
"arrayref",
|
||||
"arrayvec",
|
||||
"bytemuck",
|
||||
"cfg-if",
|
||||
"log",
|
||||
"tiny-skia-path",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tiny-skia-path"
|
||||
version = "0.11.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
|
||||
dependencies = [
|
||||
"arrayref",
|
||||
"bytemuck",
|
||||
"strict-num",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinystr"
|
||||
version = "0.8.5"
|
||||
@@ -5504,6 +5579,12 @@ version = "0.2.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
|
||||
|
||||
[[package]]
|
||||
name = "ttf-parser"
|
||||
version = "0.25.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
|
||||
|
||||
[[package]]
|
||||
name = "twofish"
|
||||
version = "0.7.1"
|
||||
|
||||
+4
-3
@@ -3,7 +3,7 @@ resolver = "2"
|
||||
members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"]
|
||||
|
||||
[workspace.package]
|
||||
version = "3.9.0"
|
||||
version = "3.10.0"
|
||||
edition = "2024"
|
||||
license = "MIT"
|
||||
authors = ["Nils Pukropp <contact@narl.io>"]
|
||||
@@ -15,10 +15,11 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
|
||||
categories = ["filesystem", "command-line-utilities"]
|
||||
|
||||
[workspace.dependencies]
|
||||
proton-sdk = { version = "0.12.4" }
|
||||
proton-drive-rs = { version = "0.12.4" }
|
||||
proton-sdk = { version = "0.12.6" }
|
||||
proton-drive-rs = { version = "0.12.6" }
|
||||
proton-gallery-app-rs = "0.1.0"
|
||||
proton-gallery-rs = "0.1.5"
|
||||
proton-map-rs = "0.1.0"
|
||||
chrono = { version = "0.4", default-features = false, features = ["std"] }
|
||||
|
||||
# Internal crates.
|
||||
|
||||
@@ -193,7 +193,8 @@ Proton Drive Linux is free and built in spare time. If it saves you a few headac
|
||||
Released under the [MIT License](LICENSE).
|
||||
|
||||
The Places map uses [GeoNames](https://www.geonames.org/) data (CC BY 4.0) and
|
||||
[Natural Earth](https://www.naturalearthdata.com/) outlines (public domain). The optional street
|
||||
[Natural Earth](https://www.naturalearthdata.com/) land, water and borders (public domain), drawn
|
||||
through [proton-map-rs](https://github.com/narrrl/proton-rs). The optional street
|
||||
map comes from [OpenFreeMap](https://openfreemap.org/), © [OpenStreetMap](https://www.openstreetmap.org/copyright)
|
||||
contributors.
|
||||
|
||||
|
||||
+144
-14
@@ -1,6 +1,6 @@
|
||||
//! `pdfs` — command-line front-end for the Proton Drive Linux client.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::FileTypeExt;
|
||||
@@ -158,8 +158,12 @@ enum Command {
|
||||
#[arg(long)]
|
||||
forget: bool,
|
||||
},
|
||||
/// Forget the stored session.
|
||||
Logout,
|
||||
/// Forget the stored session. Asks first while changes are still queued.
|
||||
Logout {
|
||||
/// Do not ask first.
|
||||
#[arg(long)]
|
||||
yes: bool,
|
||||
},
|
||||
/// Show account login state, and mount status if a daemon is running.
|
||||
Status,
|
||||
/// List every local Proton Drive location.
|
||||
@@ -432,7 +436,14 @@ enum Command {
|
||||
Diagnostics,
|
||||
/// List what is in the account's trash, with the uids the restore and
|
||||
/// delete-forever commands take.
|
||||
Trash,
|
||||
Trash {
|
||||
/// Group the trash by the folder each item was deleted from.
|
||||
#[arg(long, conflicts_with = "folder")]
|
||||
by_folder: bool,
|
||||
/// List what a trashed folder holds, by its uid.
|
||||
#[arg(long, value_name = "UID")]
|
||||
folder: Option<String>,
|
||||
},
|
||||
/// Restore trashed items, by uid, to the folders they were trashed from.
|
||||
Restore {
|
||||
/// Node uids (`volume~link`), as printed by `pdfs trash`.
|
||||
@@ -857,6 +868,13 @@ enum SyncCmd {
|
||||
},
|
||||
/// List uploads and changes not yet on Proton Drive.
|
||||
Queue,
|
||||
/// Wait until every queued change is on Proton Drive. Exits 0 once nothing
|
||||
/// is left, 3 when what is left needs you (see `sync issues`), 4 on timeout.
|
||||
Flush {
|
||||
/// Give up after this many seconds.
|
||||
#[arg(long)]
|
||||
timeout: Option<u64>,
|
||||
},
|
||||
/// List queued changes Proton Drive refused or that keep failing, and what to do.
|
||||
Issues,
|
||||
/// Save the content of a queued upload (by id from `sync queue`) to a file.
|
||||
@@ -1047,7 +1065,7 @@ fn main() -> Result<()> {
|
||||
cli.command,
|
||||
Command::Login { .. }
|
||||
| Command::Unlock { .. }
|
||||
| Command::Logout
|
||||
| Command::Logout { .. }
|
||||
| Command::Mount { .. }
|
||||
| Command::Daemon { .. }
|
||||
) {
|
||||
@@ -1057,7 +1075,7 @@ fn main() -> Result<()> {
|
||||
Command::Login { username, remember } => cmd_login(username, remember),
|
||||
Command::Unlock { remember } => cmd_unlock(remember),
|
||||
Command::Lock { forget } => cmd_lock(forget),
|
||||
Command::Logout => cmd_logout(),
|
||||
Command::Logout { yes } => cmd_logout(yes),
|
||||
Command::Status => cmd_status(),
|
||||
Command::Locations => cmd_locations(),
|
||||
Command::Mount { mountpoint } => cmd_mount(mountpoint),
|
||||
@@ -1128,7 +1146,7 @@ fn main() -> Result<()> {
|
||||
Command::Upload { sources, parent } => cmd_upload(sources, parent),
|
||||
Command::Transfers => cmd_transfers(),
|
||||
Command::Diagnostics => cmd_diagnostics(),
|
||||
Command::Trash => cmd_trash(),
|
||||
Command::Trash { by_folder, folder } => cmd_trash(by_folder, folder),
|
||||
Command::Restore { uids } => cmd_restore(uids),
|
||||
Command::DeleteForever { uids } => cmd_delete_forever(uids),
|
||||
Command::EmptyTrash => cmd_empty_trash(),
|
||||
@@ -1362,6 +1380,7 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
|
||||
})?)?
|
||||
}
|
||||
SyncCmd::Queue => return cmd_sync_queue(),
|
||||
SyncCmd::Flush { timeout } => return cmd_sync_flush(timeout),
|
||||
SyncCmd::Issues => return cmd_sync_issues(),
|
||||
SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest),
|
||||
SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down),
|
||||
@@ -1465,6 +1484,71 @@ fn cmd_sync_queue() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `pdfs sync flush`: wait for the queue to drain.
|
||||
///
|
||||
/// Failed changes are retried at once rather than after their backoff. The
|
||||
/// wait ends early, with exit code 3, when everything left is waiting on the
|
||||
/// user: refused by Drive, failing again and again, or a temporary file
|
||||
/// waiting for its final name. Paused or offline, it keeps waiting and says
|
||||
/// why.
|
||||
fn cmd_sync_flush(timeout: Option<u64>) -> Result<()> {
|
||||
const POLL: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
let deadline =
|
||||
timeout.map(|secs| std::time::Instant::now() + std::time::Duration::from_secs(secs));
|
||||
ok_or_bail(control_request(CtlRequest::RetryPendingOp { id: None })?)?;
|
||||
let mut last_line = String::new();
|
||||
loop {
|
||||
let items = match control_request(CtlRequest::ListPendingOps)? {
|
||||
CtlResponse::PendingOps { items } => items,
|
||||
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
|
||||
other => bail!("unexpected response: {other:?}"),
|
||||
};
|
||||
let waiting = items
|
||||
.iter()
|
||||
.filter(|op| !op.parked && !op.failing && op.issue.is_none())
|
||||
.count();
|
||||
if items.is_empty() {
|
||||
finish_line(&last_line);
|
||||
println!("Everything is on Proton Drive.");
|
||||
return Ok(());
|
||||
}
|
||||
if waiting == 0 {
|
||||
finish_line(&last_line);
|
||||
eprintln!(
|
||||
"{} queued change(s) need you before they can be sent. See `pdfs sync issues`.",
|
||||
items.len()
|
||||
);
|
||||
std::process::exit(3);
|
||||
}
|
||||
let reason = match control_request(CtlRequest::Status)? {
|
||||
CtlResponse::Status { paused: true, .. } => " (sync is paused; `pdfs sync resume`)",
|
||||
CtlResponse::Status { online: false, .. } => " (offline; waiting for Proton Drive)",
|
||||
_ => "",
|
||||
};
|
||||
let line = format!("{waiting} change(s) left to send{reason}");
|
||||
if line != last_line {
|
||||
if !last_line.is_empty() {
|
||||
print!("\r\x1b[2K");
|
||||
}
|
||||
print!("{line}");
|
||||
last_line = line;
|
||||
}
|
||||
if deadline.is_some_and(|deadline| std::time::Instant::now() >= deadline) {
|
||||
finish_line(&last_line);
|
||||
eprintln!("Timed out with {waiting} change(s) still queued.");
|
||||
std::process::exit(4);
|
||||
}
|
||||
std::thread::sleep(POLL);
|
||||
}
|
||||
}
|
||||
|
||||
/// End a progress line so the next message starts on its own.
|
||||
fn finish_line(last_line: &str) {
|
||||
if !last_line.is_empty() {
|
||||
println!();
|
||||
}
|
||||
}
|
||||
|
||||
/// `pdfs sync issues`: the queued changes that need the user, and what to do.
|
||||
fn cmd_sync_issues() -> Result<()> {
|
||||
let response = control_request(CtlRequest::ListPendingOps)?;
|
||||
@@ -2298,7 +2382,27 @@ fn key_state_name() -> &'static str {
|
||||
}
|
||||
}
|
||||
|
||||
fn cmd_logout() -> Result<()> {
|
||||
fn cmd_logout(yes: bool) -> Result<()> {
|
||||
// Queued changes stay staged on this computer and are sent after the next
|
||||
// sign-in, but until then they exist nowhere else. Without a running
|
||||
// daemon there is no count to show.
|
||||
if !yes
|
||||
&& let Ok(CtlResponse::Status {
|
||||
pending_uploads,
|
||||
pending_changes,
|
||||
parked_uploads,
|
||||
..
|
||||
}) = control_request(CtlRequest::Status)
|
||||
{
|
||||
let queued = pending_uploads + pending_changes + parked_uploads;
|
||||
if queued > 0 {
|
||||
println!(
|
||||
"{queued} change(s) are not on Proton Drive yet. They stay on this computer and are \
|
||||
sent after you sign in again. Run `pdfs sync flush` first to send them now."
|
||||
);
|
||||
confirm("Sign out anyway?")?;
|
||||
}
|
||||
}
|
||||
if auth::logout()? {
|
||||
println!("Signed out: the session is ended on Proton and cleared here.");
|
||||
} else {
|
||||
@@ -3520,17 +3624,37 @@ fn cmd_diagnostics() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn cmd_trash() -> Result<()> {
|
||||
let response = control_request(CtlRequest::ListTrash)?;
|
||||
fn cmd_trash(by_folder: bool, folder: Option<String>) -> Result<()> {
|
||||
let request = match folder {
|
||||
Some(uid) => CtlRequest::ListTrashedFolder { uid },
|
||||
None => CtlRequest::ListTrash,
|
||||
};
|
||||
let response = control_request(request)?;
|
||||
if emit_json(&response)? {
|
||||
return Ok(());
|
||||
}
|
||||
match response {
|
||||
CtlResponse::Entries { entries } if entries.is_empty() => println!("(trash is empty)"),
|
||||
CtlResponse::Entries { entries } if entries.is_empty() => println!("(nothing here)"),
|
||||
CtlResponse::Entries { entries } if by_folder => {
|
||||
let mut groups: BTreeMap<String, Vec<&pdfs_core::control::DirEntry>> = BTreeMap::new();
|
||||
for e in entries.iter().filter(|e| e.trashed_parent.is_none()) {
|
||||
let folder = match e.trashed_from.as_deref() {
|
||||
None => "(unknown folder)".to_string(),
|
||||
Some("") => "/".to_string(),
|
||||
Some(path) => format!("/{path}"),
|
||||
};
|
||||
groups.entry(folder).or_default().push(e);
|
||||
}
|
||||
for (folder, items) in groups {
|
||||
println!("{folder} ({} item(s))", items.len());
|
||||
for e in items {
|
||||
print_trashed(e, " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
CtlResponse::Entries { entries } => {
|
||||
for e in entries {
|
||||
let kind = if e.is_dir { "d" } else { "-" };
|
||||
println!("{kind} {:>12} {} [{}]", e.size, e.name, e.uid);
|
||||
for e in &entries {
|
||||
print_trashed(e, "");
|
||||
}
|
||||
}
|
||||
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
|
||||
@@ -3539,6 +3663,11 @@ fn cmd_trash() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn print_trashed(e: &pdfs_core::control::DirEntry, indent: &str) {
|
||||
let kind = if e.is_dir { "d" } else { "-" };
|
||||
println!("{indent}{kind} {:>12} {} [{}]", e.size, e.name, e.uid);
|
||||
}
|
||||
|
||||
fn cmd_restore(uids: Vec<String>) -> Result<()> {
|
||||
match control_request(CtlRequest::Restore { uids })? {
|
||||
CtlResponse::Ok { message } => println!("{message}"),
|
||||
@@ -4994,6 +5123,7 @@ mod login_wait_tests {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
};
|
||||
assert_eq!(shared_by_line(&entry), None, "no invitation, no line");
|
||||
|
||||
@@ -337,6 +337,12 @@ impl Demo {
|
||||
Request::ListDir { path } => Response::Entries {
|
||||
entries: self.dir(path),
|
||||
},
|
||||
Request::ListTrash => Response::Entries {
|
||||
entries: self.trash(),
|
||||
},
|
||||
Request::ListTrashedFolder { uid } => Response::Entries {
|
||||
entries: self.trashed_folder(uid),
|
||||
},
|
||||
Request::ReserveFileThumbGeneration => Response::FileThumbGeneration { generation: 1 },
|
||||
Request::FileThumbs { items, .. } => Response::Thumbs {
|
||||
items: items
|
||||
@@ -591,6 +597,59 @@ impl Demo {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The trash: things deleted from a few folders, and a deleted folder with
|
||||
/// a file deleted from it before it went.
|
||||
fn trash(&self) -> Vec<DirEntry> {
|
||||
let item = |name: &str, size: u64, hours: i64, from: &str| DirEntry {
|
||||
name: name.into(),
|
||||
is_dir: size == 0,
|
||||
size,
|
||||
modified: self.now - 40 * DAY,
|
||||
uid: format!("demo-trash~{from}/{name}"),
|
||||
trashed_at: self.now - hours * 3600,
|
||||
trashed_from: Some(from.into()),
|
||||
..Default::default()
|
||||
};
|
||||
let mut inside = item("Draft 3.odt", 48_120, 30, "");
|
||||
inside.uid = "demo-trash~Old drafts/Draft 3.odt".into();
|
||||
inside.trashed_from = None;
|
||||
inside.trashed_parent = Some("demo-trash~Work/Old drafts".into());
|
||||
vec![
|
||||
item("Budget 2025.ods", 51_200, 2, "Documents"),
|
||||
item("Scan 0042.pdf", 1_204_331, 5, "Documents"),
|
||||
item("Scan 0043.pdf", 1_198_002, 5, "Documents"),
|
||||
item("IMG_2041.jpg", 3_402_112, 20, "Pictures/Lisbon"),
|
||||
item("IMG_2042.jpg", 3_311_870, 20, "Pictures/Lisbon"),
|
||||
item("IMG_2043.jpg", 3_587_004, 20, "Pictures/Lisbon"),
|
||||
item("Old drafts", 0, 26, "Work"),
|
||||
item("Meeting notes (copy).md", 6_120, 50, ""),
|
||||
item("Invoice 118.pdf", 88_341, 80, "Taxes/2025"),
|
||||
inside,
|
||||
]
|
||||
}
|
||||
|
||||
/// What the deleted folder in [`Self::trash`] holds.
|
||||
fn trashed_folder(&self, uid: &str) -> Vec<DirEntry> {
|
||||
if uid != "demo-trash~Work/Old drafts" {
|
||||
return Vec::new();
|
||||
}
|
||||
let file = |name: &str, size: u64| DirEntry {
|
||||
name: name.into(),
|
||||
size,
|
||||
modified: self.now - 50 * DAY,
|
||||
uid: format!("demo-trash~Old drafts/{name}"),
|
||||
trashed_parent: Some(uid.into()),
|
||||
..Default::default()
|
||||
};
|
||||
let mut gone = file("Draft 3.odt", 48_120);
|
||||
gone.trashed_at = self.now - 30 * 3600;
|
||||
vec![
|
||||
file("Draft 1.odt", 41_002),
|
||||
file("Draft 2.odt", 44_870),
|
||||
gone,
|
||||
]
|
||||
}
|
||||
|
||||
/// My files: folders first, then a few files, some of them pictures with
|
||||
/// thumbnails. Any folder below the root holds the same few documents.
|
||||
fn dir(&self, path: &str) -> Vec<DirEntry> {
|
||||
|
||||
@@ -515,6 +515,13 @@ pub enum Request {
|
||||
/// its `uid` — the handle for [`Request::Restore`] and
|
||||
/// [`Request::DeleteForever`] — and its `path` is empty.
|
||||
ListTrash,
|
||||
/// List what a trashed folder holds, by the folder's `uid`. Replies with
|
||||
/// [`Response::Entries`]; each entry's `trashed_parent` is that folder.
|
||||
/// The contents went to the trash with the folder, so only the entries
|
||||
/// [`Request::ListTrash`] also lists can be restored on their own.
|
||||
ListTrashedFolder {
|
||||
uid: String,
|
||||
},
|
||||
/// Restore trashed nodes, by uid, to the folders they were trashed from.
|
||||
/// Replies with [`Response::Ok`].
|
||||
Restore {
|
||||
@@ -1566,8 +1573,8 @@ pub struct DirEntry {
|
||||
#[serde(default)]
|
||||
pub shared_by_unverified: bool,
|
||||
/// When a [`Request::ListTrash`] entry went to the trash, epoch seconds; 0
|
||||
/// when unknown, and for anything not in the trash. The API does not report
|
||||
/// it to this client, so the daemon notes when it first saw the node there.
|
||||
/// when unknown, and for anything not in the trash. Taken from the server;
|
||||
/// when it gives none, the daemon notes when it first saw the node there.
|
||||
#[serde(default)]
|
||||
pub trashed_at: i64,
|
||||
/// The folder a [`Request::ListTrash`] entry goes back to on restore, as a
|
||||
@@ -1575,6 +1582,11 @@ pub struct DirEntry {
|
||||
/// not known, and for anything not in the trash.
|
||||
#[serde(default)]
|
||||
pub trashed_from: Option<String>,
|
||||
/// The trashed folder a [`Request::ListTrash`] entry was trashed inside, by
|
||||
/// uid, when that folder is in the trash too; `None` otherwise. Lets a
|
||||
/// front end show the trash as folders.
|
||||
#[serde(default)]
|
||||
pub trashed_parent: Option<String>,
|
||||
/// Why Drive refused a change queued on the node, for a [`Request::ListDir`]
|
||||
/// entry; `None` otherwise.
|
||||
#[serde(default)]
|
||||
@@ -3625,6 +3637,9 @@ mod tests {
|
||||
fn trash_requests_roundtrip() {
|
||||
let reqs = [
|
||||
Request::ListTrash,
|
||||
Request::ListTrashedFolder {
|
||||
uid: "vol~folder".into(),
|
||||
},
|
||||
Request::Restore {
|
||||
uids: vec!["vol~link".into(), "vol~other".into()],
|
||||
},
|
||||
|
||||
@@ -11,7 +11,7 @@ use super::Db;
|
||||
use crate::Result;
|
||||
|
||||
/// Current schema version. Bump on every forward migration added below.
|
||||
pub(super) const SCHEMA_VERSION: i64 = 46;
|
||||
pub(super) const SCHEMA_VERSION: i64 = 47;
|
||||
|
||||
impl Db {
|
||||
pub(super) fn migrate(&self) -> Result<()> {
|
||||
@@ -501,6 +501,16 @@ impl Db {
|
||||
tx.execute_batch(MIGRATION_V46_ALBUM_PHOTOS)?;
|
||||
}
|
||||
}
|
||||
if current < 47 {
|
||||
let has_trash: bool = tx.query_row(
|
||||
"SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'trash'",
|
||||
[],
|
||||
|row| row.get::<_, i64>(0).map(|n| n > 0),
|
||||
)?;
|
||||
if has_trash {
|
||||
tx.execute_batch(MIGRATION_V47)?;
|
||||
}
|
||||
}
|
||||
tx.execute(
|
||||
"INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1)
|
||||
ON CONFLICT(key) DO UPDATE SET value = excluded.value",
|
||||
@@ -1480,3 +1490,12 @@ const MIGRATION_V46_ALBUM_PHOTOS: &str = "
|
||||
ALTER TABLE album_photos ADD COLUMN resolved INTEGER NOT NULL DEFAULT 0;
|
||||
UPDATE album_photos SET resolved=1 WHERE name IS NOT NULL;
|
||||
";
|
||||
|
||||
/// Index the trash by parent, for browsing it by folder. The rows are dropped
|
||||
/// so the next refresh reads them again with the time each was trashed, which
|
||||
/// earlier builds did not get from the server and made up instead.
|
||||
const MIGRATION_V47: &str = "
|
||||
CREATE INDEX IF NOT EXISTS trash_parent ON trash(parent_uid);
|
||||
DELETE FROM trash;
|
||||
DELETE FROM sync_state WHERE key IN ('trash_synced_ms', 'trash_complete_ms');
|
||||
";
|
||||
@@ -650,6 +650,54 @@ fn trash_replace_lists_folders_first() {
|
||||
assert!(db.trash_list().unwrap().is_empty());
|
||||
}
|
||||
|
||||
fn stored_trash(uid: &str, name: &str, trashed_at: Option<i64>) -> StoredTrash {
|
||||
StoredTrash {
|
||||
uid: uid.into(),
|
||||
name: name.into(),
|
||||
is_dir: false,
|
||||
size: 1,
|
||||
mtime: 1,
|
||||
parent_uid: None,
|
||||
trashed_at,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trash_upsert_keeps_other_rows_and_retain_drops_unlisted_ones() {
|
||||
let db = Db::open_in_memory().unwrap();
|
||||
db.trash_upsert(&[
|
||||
stored_trash("a", "a.txt", Some(1)),
|
||||
stored_trash("b", "b.txt", None),
|
||||
])
|
||||
.unwrap();
|
||||
// A later refresh adds what is new without touching what it kept.
|
||||
db.trash_upsert(&[
|
||||
stored_trash("c", "c.txt", Some(3)),
|
||||
stored_trash("b", "b2.txt", Some(2)),
|
||||
])
|
||||
.unwrap();
|
||||
let mut names: Vec<String> = db
|
||||
.trash_list()
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|i| i.name)
|
||||
.collect();
|
||||
names.sort();
|
||||
assert_eq!(names, ["a.txt", "b2.txt", "c.txt"]);
|
||||
|
||||
// Rows the server no longer lists go; the listed ones stay.
|
||||
let keep: std::collections::HashSet<String> = ["a", "c"].map(String::from).into();
|
||||
assert_eq!(db.trash_retain(&keep).unwrap(), 1);
|
||||
assert_eq!(db.trash_remove(&["a".into(), "gone".into()]).unwrap(), 1);
|
||||
let left: Vec<String> = db
|
||||
.trash_list()
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|i| i.uid)
|
||||
.collect();
|
||||
assert_eq!(left, ["c"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn state_stamps_round_trip_and_clear() {
|
||||
let db = Db::open_in_memory().unwrap();
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Trashed nodes, persisted so the trash view opens without a round-trip.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use rusqlite::params;
|
||||
|
||||
@@ -48,6 +48,60 @@ impl Db {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Add or update trashed nodes, keeping every other row.
|
||||
pub fn trash_upsert(&self, items: &[StoredTrash]) -> Result<()> {
|
||||
let mut conn = self.conn.lock();
|
||||
let tx = conn.transaction()?;
|
||||
{
|
||||
let mut stmt = tx.prepare(
|
||||
"INSERT INTO trash (uid, name, is_dir, size, mtime, parent_uid, trashed_at)
|
||||
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
|
||||
ON CONFLICT(uid) DO UPDATE SET
|
||||
name = excluded.name, is_dir = excluded.is_dir, size = excluded.size,
|
||||
mtime = excluded.mtime, parent_uid = excluded.parent_uid,
|
||||
trashed_at = excluded.trashed_at",
|
||||
)?;
|
||||
for item in items {
|
||||
stmt.execute(params![
|
||||
item.uid,
|
||||
item.name,
|
||||
item.is_dir as i64,
|
||||
item.size,
|
||||
item.mtime,
|
||||
item.parent_uid,
|
||||
item.trashed_at
|
||||
])?;
|
||||
}
|
||||
}
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Drop the trashed nodes with these uids. Returns how many rows went.
|
||||
pub fn trash_remove(&self, uids: &[String]) -> Result<usize> {
|
||||
let mut conn = self.conn.lock();
|
||||
let tx = conn.transaction()?;
|
||||
let mut removed = 0;
|
||||
{
|
||||
let mut stmt = tx.prepare("DELETE FROM trash WHERE uid = ?1")?;
|
||||
for uid in uids {
|
||||
removed += stmt.execute(params![uid])?;
|
||||
}
|
||||
}
|
||||
tx.commit()?;
|
||||
Ok(removed)
|
||||
}
|
||||
|
||||
/// Drop every trashed node not in `keep`. Returns how many rows went.
|
||||
pub fn trash_retain(&self, keep: &HashSet<String>) -> Result<usize> {
|
||||
let gone: Vec<String> = self
|
||||
.trash_seen()?
|
||||
.into_keys()
|
||||
.filter(|uid| !keep.contains(uid))
|
||||
.collect();
|
||||
self.trash_remove(&gone)
|
||||
}
|
||||
|
||||
/// The persisted trash listing, folders first then by name — the order the
|
||||
/// Trash page shows it in.
|
||||
pub fn trash_list(&self) -> Result<Vec<StoredTrash>> {
|
||||
|
||||
@@ -1342,6 +1342,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
|
||||
Ok(entries) => CtlResponse::Entries { entries },
|
||||
Err(e) => CtlResponse::error(e),
|
||||
},
|
||||
Ok(CtlRequest::ListTrashedFolder { uid }) => match core.list_trashed_folder(&uid) {
|
||||
Ok(entries) => CtlResponse::Entries { entries },
|
||||
Err(e) => CtlResponse::error(e),
|
||||
},
|
||||
Ok(CtlRequest::Restore { uids }) => match core.restore(&uids) {
|
||||
Ok(n) => {
|
||||
core.log_activity(ActivityKind::Restore, format!("{n} item(s)"), "", true);
|
||||
|
||||
@@ -29,7 +29,7 @@ use proton_drive_rs::proton_sdk::error::Result;
|
||||
use proton_drive_rs::proton_sdk::ids::{DriveEventId, NodeUid, ShareId};
|
||||
use proton_drive_rs::{
|
||||
AvailableNameTarget, Device, DeviceType, DriveEvent, DriveEventScopeId, Node, NodeMoveItem,
|
||||
ProtonDriveClient, RevisionReader, Thumbnail, ThumbnailType,
|
||||
ProtonDriveClient, RevisionReader, Thumbnail, ThumbnailType, TrashedNode,
|
||||
};
|
||||
|
||||
/// One outcome per node of a batch request; see [`ProtonDriveClient::trash_nodes`].
|
||||
@@ -180,6 +180,23 @@ pub(crate) trait DriveApi: Send + Sync {
|
||||
|
||||
async fn enumerate_trash_node_uids(&self) -> Result<Vec<NodeUid>>;
|
||||
|
||||
/// Permanently delete everything in the trash.
|
||||
async fn empty_trash(&self) -> Result<()>;
|
||||
|
||||
/// As [`DriveApi::enumerate_nodes_light`], for nodes in the trash, each
|
||||
/// with the time it was trashed when the server reports one.
|
||||
async fn enumerate_trashed_nodes_light(&self, uids: &[NodeUid]) -> Result<Vec<TrashedNode>> {
|
||||
Ok(self
|
||||
.enumerate_nodes_light(uids)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|node| TrashedNode {
|
||||
node,
|
||||
trash_time: None,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// The account's storage, across every Proton product.
|
||||
async fn quota(&self) -> Result<Quota>;
|
||||
|
||||
@@ -538,6 +555,14 @@ impl DriveApi for ProtonDriveClient {
|
||||
ProtonDriveClient::enumerate_trash_node_uids(self).await
|
||||
}
|
||||
|
||||
async fn enumerate_trashed_nodes_light(&self, uids: &[NodeUid]) -> Result<Vec<TrashedNode>> {
|
||||
ProtonDriveClient::enumerate_trashed_nodes_light(self, uids).await
|
||||
}
|
||||
|
||||
async fn empty_trash(&self) -> Result<()> {
|
||||
ProtonDriveClient::empty_trash(self).await
|
||||
}
|
||||
|
||||
async fn quota(&self) -> Result<Quota> {
|
||||
ProtonDriveClient::quota(self).await
|
||||
}
|
||||
|
||||
@@ -0,0 +1,129 @@
|
||||
//! Hold off a shutdown while queued changes exist only on this computer.
|
||||
//!
|
||||
//! A change made through the mount is staged here and sent by the drain. Until
|
||||
//! it lands, this computer has the only copy, so powering off then risks it
|
||||
//! more than the user expects (`docs/BUGS.md` B66). While the queue holds work
|
||||
//! the drain can still send, the daemon takes a logind shutdown inhibitor
|
||||
//! through `systemd-inhibit`, which desktops show in their power-off dialog
|
||||
//! with the reason. It is let go as soon as the queue empties.
|
||||
//!
|
||||
//! Work that cannot drain on its own — a temporary file waiting for its final
|
||||
//! name, or a change Drive refused or that keeps failing — never holds the
|
||||
//! lock, or a shutdown would be held up for something that is not coming.
|
||||
//! Without `systemd-inhibit` nothing happens.
|
||||
|
||||
use std::process::{Child, Command, Stdio};
|
||||
use std::time::Duration;
|
||||
|
||||
use pdfs_core::db::PendingCounts;
|
||||
use tracing::{debug, warn};
|
||||
|
||||
use super::Core;
|
||||
|
||||
/// How often the queue is looked at.
|
||||
const CHECK_EVERY: Duration = Duration::from_secs(5);
|
||||
|
||||
/// Changes the drain can still send by itself.
|
||||
fn sendable(counts: &PendingCounts) -> i64 {
|
||||
(counts.uploads + counts.changes - counts.parked - counts.failing).max(0)
|
||||
}
|
||||
|
||||
/// Run until the daemon stops, holding the inhibitor while changes wait.
|
||||
pub(crate) fn run(core: Core) {
|
||||
let mut held: Option<Child> = None;
|
||||
loop {
|
||||
let waiting = core
|
||||
.db
|
||||
.pending_op_counts()
|
||||
.map(|counts| sendable(&counts))
|
||||
.unwrap_or(0);
|
||||
// The helper can go away (logind restarted, or it was killed); the
|
||||
// lock is then taken again on the next round.
|
||||
if let Some(child) = &mut held
|
||||
&& !matches!(child.try_wait(), Ok(None))
|
||||
{
|
||||
held = None;
|
||||
}
|
||||
match (&mut held, waiting > 0) {
|
||||
(None, true) => held = take(waiting),
|
||||
(Some(child), false) => {
|
||||
release(child);
|
||||
held = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if !core.shutdown.sleep(CHECK_EVERY) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if let Some(mut child) = held {
|
||||
release(&mut child);
|
||||
}
|
||||
}
|
||||
|
||||
fn take(waiting: i64) -> Option<Child> {
|
||||
let why = if waiting == 1 {
|
||||
"Sending 1 change to Proton Drive".to_string()
|
||||
} else {
|
||||
format!("Sending {waiting} changes to Proton Drive")
|
||||
};
|
||||
match Command::new("systemd-inhibit")
|
||||
.args([
|
||||
"--what=shutdown",
|
||||
"--who=Proton Drive",
|
||||
&format!("--why={why}"),
|
||||
"--mode=block",
|
||||
"sleep",
|
||||
"infinity",
|
||||
])
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
{
|
||||
Ok(child) => {
|
||||
debug!(waiting, "holding off shutdown while changes are queued");
|
||||
Some(child)
|
||||
}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
|
||||
Err(error) => {
|
||||
warn!(%error, "taking the shutdown inhibitor failed");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn release(child: &mut Child) {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
debug!("queue drained; shutdown no longer held off");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn counts(uploads: i64, changes: i64, parked: i64, failing: i64) -> PendingCounts {
|
||||
PendingCounts {
|
||||
uploads,
|
||||
changes,
|
||||
parked,
|
||||
failing,
|
||||
last_error: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_work_the_drain_can_send_holds_off_a_shutdown() {
|
||||
assert_eq!(sendable(&counts(0, 0, 0, 0)), 0);
|
||||
assert_eq!(sendable(&counts(2, 1, 0, 0)), 3);
|
||||
assert_eq!(sendable(&counts(1, 0, 1, 0)), 0);
|
||||
assert_eq!(sendable(&counts(2, 0, 0, 2)), 0);
|
||||
assert_eq!(sendable(&counts(3, 2, 1, 1)), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn counts_that_overlap_never_go_negative() {
|
||||
assert_eq!(sendable(&counts(1, 0, 1, 1)), 0);
|
||||
}
|
||||
}
|
||||
+195
-50
@@ -75,7 +75,7 @@ use proton_drive_rs::proton_sdk::error::ProtonError;
|
||||
use proton_drive_rs::proton_sdk::ids::{DriveEventId, LinkId, NodeUid, ShareId, VolumeId};
|
||||
use proton_drive_rs::{
|
||||
AvailableNameTarget, DriveEvent, DriveEventScopeId, MemberRole, Node, NodeKind, NodeMoveItem,
|
||||
ProtonDriveClient, ProtonPhotosClient, SharedWithMeItem, ThumbnailType,
|
||||
ProtonDriveClient, ProtonPhotosClient, SharedWithMeItem, ThumbnailType, TrashedNode,
|
||||
};
|
||||
|
||||
mod albums;
|
||||
@@ -92,6 +92,7 @@ use drive::{DriveApi, RevisionRead};
|
||||
mod events;
|
||||
mod filesystem;
|
||||
mod gallery;
|
||||
mod inhibit;
|
||||
mod keeper;
|
||||
mod link;
|
||||
pub use filesystem::ProtonFs;
|
||||
@@ -4610,6 +4611,7 @@ impl Core {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: state::ino_lid(ino)
|
||||
.and_then(|lid| issues.get(&lid))
|
||||
.map(|issue| SyncIssue::parse(issue)),
|
||||
@@ -5603,20 +5605,29 @@ impl Core {
|
||||
self.await_trash_refresh(TRASH_FIRST_WAIT);
|
||||
}
|
||||
|
||||
let items = self.db.trash_list().map_err(CoreError::from)?;
|
||||
let trashed: HashSet<&str> = items.iter().map(|item| item.uid.as_str()).collect();
|
||||
let trashed_parents: Vec<Option<String>> = items
|
||||
.iter()
|
||||
.map(|item| {
|
||||
item.parent_uid
|
||||
.clone()
|
||||
.filter(|parent| trashed.contains(parent.as_str()))
|
||||
})
|
||||
.collect();
|
||||
// Most of a trash comes from a handful of folders.
|
||||
let mut origins: HashMap<String, Option<String>> = HashMap::new();
|
||||
Ok(self
|
||||
.db
|
||||
.trash_list()
|
||||
.map_err(CoreError::from)?
|
||||
Ok(items
|
||||
.into_iter()
|
||||
.map(|item| DirEntry {
|
||||
.zip(trashed_parents)
|
||||
.map(|(item, trashed_parent)| DirEntry {
|
||||
trashed_from: item.parent_uid.as_ref().and_then(|parent| {
|
||||
origins
|
||||
.entry(parent.clone())
|
||||
.or_insert_with(|| self.db.node_path(parent).ok().flatten())
|
||||
.clone()
|
||||
}),
|
||||
trashed_parent,
|
||||
trashed_at: item.trashed_at.unwrap_or(0),
|
||||
name: item.name,
|
||||
is_dir: item.is_dir,
|
||||
@@ -5638,13 +5649,86 @@ impl Core {
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// What a trashed folder holds: its children on the server, and the
|
||||
/// stored trash entries trashed inside it before it went.
|
||||
fn list_trashed_folder(&self, uid: &str) -> CoreResult<Vec<DirEntry>> {
|
||||
let folder =
|
||||
parse_uid(uid).ok_or_else(|| CoreError::invalid(format!("invalid uid: {uid}")))?;
|
||||
let children = self
|
||||
.rt
|
||||
.block_on(within_trash_call(
|
||||
"enumerate trashed folder",
|
||||
self.drive.enumerate_folder_children_node_uids(&folder),
|
||||
))?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate trashed folder"))?;
|
||||
let mut nodes = Vec::with_capacity(children.len());
|
||||
for chunk in children.chunks(TRASH_MATERIALIZE_CHUNK) {
|
||||
nodes.extend(
|
||||
self.rt
|
||||
.block_on(within_trash_call(
|
||||
"enumerate nodes",
|
||||
self.drive.enumerate_trashed_nodes_light(chunk),
|
||||
))?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate nodes"))?,
|
||||
);
|
||||
}
|
||||
let stored = self.db.trash_list().map_err(CoreError::from)?;
|
||||
let stored_at: HashMap<&str, Option<i64>> = stored
|
||||
.iter()
|
||||
.map(|item| (item.uid.as_str(), item.trashed_at))
|
||||
.collect();
|
||||
let mut entries: Vec<DirEntry> = nodes
|
||||
.iter()
|
||||
.map(|TrashedNode { node, trash_time }| {
|
||||
let uid = node.uid.to_string();
|
||||
let trashed_at = trash_time
|
||||
.or_else(|| stored_at.get(uid.as_str()).copied().flatten())
|
||||
.unwrap_or(0);
|
||||
trashed_entry(
|
||||
uid,
|
||||
node.name.clone(),
|
||||
node.is_folder(),
|
||||
node_size(node) as i64,
|
||||
node.modification_time,
|
||||
trashed_at,
|
||||
folder.to_string(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
let listed: HashSet<String> = entries.iter().map(|e| e.uid.clone()).collect();
|
||||
entries.extend(
|
||||
stored
|
||||
.into_iter()
|
||||
.filter(|item| {
|
||||
item.parent_uid.as_deref() == Some(uid) && !listed.contains(&item.uid)
|
||||
})
|
||||
.map(|item| {
|
||||
trashed_entry(
|
||||
item.uid,
|
||||
item.name,
|
||||
item.is_dir,
|
||||
item.size,
|
||||
item.mtime,
|
||||
item.trashed_at.unwrap_or(0),
|
||||
folder.to_string(),
|
||||
)
|
||||
}),
|
||||
);
|
||||
entries.sort_by(|a, b| {
|
||||
b.is_dir
|
||||
.cmp(&a.is_dir)
|
||||
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
|
||||
});
|
||||
Ok(entries)
|
||||
}
|
||||
|
||||
/// Re-fetch the trash listing from the server and persist it.
|
||||
///
|
||||
/// Materialized in chunks of [`TRASH_MATERIALIZE_CHUNK`], each persisted as
|
||||
/// it lands: decrypting a trashed node costs an S2K unlock, so a trash of a
|
||||
/// few thousand nodes takes minutes, and an all-or-nothing write would throw
|
||||
/// that away on the first failure and show the user nothing until the very
|
||||
/// end. Every batch is a usable listing.
|
||||
/// Only nodes the stored listing does not hold yet are read, and light: a
|
||||
/// trashed file needs no content key, so none is unlocked. Each chunk of
|
||||
/// [`TRASH_MATERIALIZE_CHUNK`] is stored as it lands, so a large trash
|
||||
/// fills the page while it loads. Rows the server no longer lists go once
|
||||
/// the whole listing is in, never earlier.
|
||||
async fn refresh_trash(&self) -> CoreResult<()> {
|
||||
let started = Instant::now();
|
||||
let uids = within_trash_call("enumerate trash", self.drive.enumerate_trash_node_uids())
|
||||
@@ -5656,8 +5740,6 @@ impl Core {
|
||||
"trash refresh: enumerated"
|
||||
);
|
||||
|
||||
// What the listing held before, and whether it was the whole trash: the
|
||||
// chunks below overwrite it, so both are read up front.
|
||||
let seen = self.db.trash_seen().unwrap_or_default();
|
||||
let complete = self
|
||||
.db
|
||||
@@ -5665,36 +5747,51 @@ impl Core {
|
||||
.ok()
|
||||
.flatten()
|
||||
.is_some();
|
||||
let _ = self.db.clear_state(TRASH_COMPLETE_MS);
|
||||
let now = now_secs();
|
||||
|
||||
if uids.is_empty() {
|
||||
self.db.trash_replace(&[]).map_err(CoreError::from)?;
|
||||
}
|
||||
let mut items: Vec<StoredTrash> = Vec::with_capacity(uids.len());
|
||||
for chunk in uids.chunks(TRASH_MATERIALIZE_CHUNK) {
|
||||
let chunk_started = Instant::now();
|
||||
let nodes = within_trash_call("enumerate nodes", self.drive.enumerate_nodes(chunk))
|
||||
.await?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate nodes"))?;
|
||||
items.extend(nodes.into_iter().map(|node| StoredTrash {
|
||||
uid: node.uid.to_string(),
|
||||
name: node.name.clone(),
|
||||
is_dir: node.is_folder(),
|
||||
size: node_size(&node) as i64,
|
||||
mtime: node.modification_time,
|
||||
// The folder the node will go back to, which is also what tells
|
||||
// a restore whether that folder is itself in the trash.
|
||||
parent_uid: node.parent_uid.as_ref().map(|uid| uid.to_string()),
|
||||
trashed_at: first_seen_in_trash(&seen, &node.uid.to_string(), complete, now),
|
||||
}));
|
||||
// Cumulative, so the table is always a prefix of the real trash
|
||||
// rather than a mix of this refresh and the last one.
|
||||
self.db.trash_replace(&items).map_err(CoreError::from)?;
|
||||
let listed: HashSet<String> = uids.iter().map(ToString::to_string).collect();
|
||||
let removed = self.db.trash_retain(&listed).map_err(CoreError::from)?;
|
||||
if removed > 0 {
|
||||
self.trash_progress.notify_waiters();
|
||||
}
|
||||
let missing: Vec<NodeUid> = uids
|
||||
.into_iter()
|
||||
.filter(|uid| !seen.contains_key(&uid.to_string()))
|
||||
.collect();
|
||||
let mut materialized = 0usize;
|
||||
for chunk in missing.chunks(TRASH_MATERIALIZE_CHUNK) {
|
||||
let chunk_started = Instant::now();
|
||||
let nodes = within_trash_call(
|
||||
"enumerate nodes",
|
||||
self.drive.enumerate_trashed_nodes_light(chunk),
|
||||
)
|
||||
.await?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate nodes"))?;
|
||||
let items: Vec<StoredTrash> = nodes
|
||||
.into_iter()
|
||||
.map(|TrashedNode { node, trash_time }| {
|
||||
let uid = node.uid.to_string();
|
||||
StoredTrash {
|
||||
trashed_at: trash_time
|
||||
.or_else(|| first_seen_in_trash(&seen, &uid, complete, now)),
|
||||
uid,
|
||||
name: node.name.clone(),
|
||||
is_dir: node.is_folder(),
|
||||
size: node_size(&node) as i64,
|
||||
mtime: node.modification_time,
|
||||
// The folder the node will go back to, which is also what
|
||||
// tells a restore whether that folder is itself in the trash.
|
||||
parent_uid: node.parent_uid.as_ref().map(|uid| uid.to_string()),
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
materialized += items.len();
|
||||
self.db.trash_upsert(&items).map_err(CoreError::from)?;
|
||||
self.trash_progress.notify_waiters();
|
||||
self.events.publish(&[Topic::Trash]);
|
||||
debug!(
|
||||
materialized = items.len(),
|
||||
total = uids.len(),
|
||||
materialized,
|
||||
total = missing.len(),
|
||||
chunk_ms = chunk_started.elapsed().as_millis() as u64,
|
||||
"trash refresh: batch"
|
||||
);
|
||||
@@ -5703,7 +5800,9 @@ impl Core {
|
||||
let _ = self.db.set_state_i64(TRASH_SYNCED_MS, now_ms());
|
||||
let _ = self.db.set_state_i64(TRASH_COMPLETE_MS, now_ms());
|
||||
info!(
|
||||
count = items.len(),
|
||||
count = listed.len(),
|
||||
new = materialized,
|
||||
removed,
|
||||
elapsed_ms = started.elapsed().as_millis() as u64,
|
||||
"trash refresh: done"
|
||||
);
|
||||
@@ -5884,6 +5983,8 @@ impl Core {
|
||||
}
|
||||
}
|
||||
});
|
||||
let back: Vec<String> = restored.iter().map(ToString::to_string).collect();
|
||||
let _ = self.db.trash_remove(&back);
|
||||
self.invalidate_trash();
|
||||
Ok(restored.len())
|
||||
}
|
||||
@@ -5897,6 +5998,7 @@ impl Core {
|
||||
// daemon interrupted mid-batch has already forgotten exactly the nodes
|
||||
// the server destroyed — never more, never fewer.
|
||||
let mut deleted = 0usize;
|
||||
let mut gone: Vec<String> = Vec::new();
|
||||
let mut first_error: Option<ProtonError> = None;
|
||||
self.rt
|
||||
.block_on(async {
|
||||
@@ -5906,6 +6008,7 @@ impl Core {
|
||||
match outcome {
|
||||
Ok(()) => {
|
||||
self.drop_local(std::slice::from_ref(&uid));
|
||||
gone.push(uid.to_string());
|
||||
deleted += 1;
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -5922,23 +6025,34 @@ impl Core {
|
||||
{
|
||||
return Err(CoreError::from_api(&error, "delete"));
|
||||
}
|
||||
let _ = self.db.trash_remove(&gone);
|
||||
self.invalidate_trash();
|
||||
Ok(deleted)
|
||||
}
|
||||
|
||||
/// Permanently delete everything in the trash. The uids are listed first so
|
||||
/// the blobs of items trashed by *another* client — which this daemon may
|
||||
/// still hold in its cache — are reclaimed too, not just the ones it trashed.
|
||||
/// Permanently delete everything in the trash.
|
||||
///
|
||||
/// The stored listing says what goes, so the blobs of items trashed by
|
||||
/// another client, which this daemon may still hold, are reclaimed too. It
|
||||
/// is not read from the server again first: on a large trash that listing
|
||||
/// is what kept the delete from ever being sent (`docs/BUGS.md` B293).
|
||||
/// The stored listing is cleared at once, and the server is asked again
|
||||
/// after [`TRASH_TTL`], so anything it still holds then shows up again.
|
||||
fn empty_trash(&self) -> CoreResult<usize> {
|
||||
let uids = self
|
||||
.rt
|
||||
.block_on(self.drive.enumerate_trash_node_uids())
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate trash"))?;
|
||||
let uids: Vec<String> = self
|
||||
.db
|
||||
.trash_seen()
|
||||
.map_err(CoreError::from)?
|
||||
.into_keys()
|
||||
.collect();
|
||||
self.rt
|
||||
.block_on(self.client.empty_trash())
|
||||
.block_on(within_trash_call("empty trash", self.drive.empty_trash()))?
|
||||
.map_err(|e| CoreError::from_api(&e, "empty trash"))?;
|
||||
self.drop_local(&uids);
|
||||
self.invalidate_trash();
|
||||
let parsed: Vec<NodeUid> = uids.iter().filter_map(|uid| parse_uid(uid)).collect();
|
||||
self.drop_local(&parsed);
|
||||
let _ = self.db.trash_replace(&[]);
|
||||
let _ = self.db.set_state_i64(TRASH_SYNCED_MS, now_ms());
|
||||
self.events.publish(&[Topic::Trash]);
|
||||
Ok(uids.len())
|
||||
}
|
||||
|
||||
@@ -6840,6 +6954,37 @@ async fn within_trash_call<T>(what: &str, call: impl Future<Output = T>) -> Core
|
||||
})
|
||||
}
|
||||
|
||||
/// An entry inside a trashed folder, for [`Core::list_trashed_folder`].
|
||||
fn trashed_entry(
|
||||
uid: String,
|
||||
name: String,
|
||||
is_dir: bool,
|
||||
size: i64,
|
||||
mtime: i64,
|
||||
trashed_at: i64,
|
||||
parent: String,
|
||||
) -> DirEntry {
|
||||
DirEntry {
|
||||
name,
|
||||
is_dir,
|
||||
size: size.max(0) as u64,
|
||||
modified: mtime,
|
||||
pinned: false,
|
||||
pinned_by_folder: false,
|
||||
cached: false,
|
||||
uid,
|
||||
path: String::new(),
|
||||
role: String::new(),
|
||||
shared_by: String::new(),
|
||||
shared_at: 0,
|
||||
shared_by_unverified: false,
|
||||
trashed_at,
|
||||
trashed_from: None,
|
||||
trashed_parent: Some(parent),
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// When a node a trash refresh found went to the trash, as far as the daemon
|
||||
/// can tell. A node the stored listing already had keeps the time it had. A new
|
||||
/// one went there since the last refresh, so now is close, but only when that
|
||||
|
||||
@@ -793,6 +793,17 @@ pub(crate) fn mount_with(
|
||||
warn!(%error, "start My Files share-id repair failed");
|
||||
}
|
||||
}
|
||||
// Hold off a shutdown while changes exist only here (B66). Only the real
|
||||
// daemon: a simulation's queue is not the user's data.
|
||||
if matches!(host, Host::Daemon) {
|
||||
let inhibit_core = core.clone();
|
||||
if let Err(error) = std::thread::Builder::new()
|
||||
.name("pdfs-inhibit".into())
|
||||
.spawn(move || crate::inhibit::run(inhibit_core))
|
||||
{
|
||||
warn!(%error, "start the shutdown inhibitor failed");
|
||||
}
|
||||
}
|
||||
|
||||
// Stop signals (SIGTERM from `systemctl --user stop`, SIGINT from Ctrl-C)
|
||||
// are delivered onto the async runtime; bridge them onto a sync channel so
|
||||
|
||||
@@ -77,6 +77,7 @@ fn shared_entry_of(core: &Core, n: Node) -> DirEntry {
|
||||
shared_by_unverified,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1918,6 +1918,81 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
|
||||
fn the_trash_lists_by_folder_and_empties() {
|
||||
let drive = FakeDrive::new();
|
||||
let dir = scratch("trash-by-folder");
|
||||
let daemon = Daemon::start(&dir, drive.client(1, Faults::none())).unwrap();
|
||||
let mount = &daemon.mountpoint;
|
||||
std::fs::create_dir_all(mount.join("album/inner")).unwrap();
|
||||
std::fs::write(mount.join("album/inner/a.jpg"), b"a").unwrap();
|
||||
std::fs::write(mount.join("album/b.jpg"), b"b").unwrap();
|
||||
std::fs::write(mount.join("loose.txt"), b"c").unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || daemon.drained()
|
||||
&& drive.lookup("album/inner/a.jpg").is_some()
|
||||
&& drive.lookup("loose.txt").is_some()));
|
||||
let album = drive.lookup("album").unwrap();
|
||||
let inner = drive.lookup("album/inner").unwrap();
|
||||
|
||||
// A file trashed on its own, then the folder that held it.
|
||||
drive.device().trash("album/b.jpg");
|
||||
drive.device().trash("album");
|
||||
std::fs::remove_file(mount.join("loose.txt")).unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || daemon.drained()));
|
||||
|
||||
let list = |request: &Request| match daemon.request(request) {
|
||||
Ok(Response::Entries { entries }) => entries,
|
||||
other => panic!("unexpected reply: {other:?}"),
|
||||
};
|
||||
daemon
|
||||
.request(&Request::Refresh {
|
||||
scope: RefreshScope::Trash,
|
||||
})
|
||||
.unwrap();
|
||||
let mut trash = Vec::new();
|
||||
assert!(wait_until(Duration::from_secs(30), || {
|
||||
trash = list(&Request::ListTrash);
|
||||
trash.len() == 3
|
||||
}));
|
||||
let b = trash.iter().find(|e| e.name == "b.jpg").unwrap();
|
||||
assert_eq!(
|
||||
b.trashed_parent.as_deref(),
|
||||
Some(album.to_string().as_str())
|
||||
);
|
||||
let top: Vec<&str> = trash
|
||||
.iter()
|
||||
.filter(|e| e.trashed_parent.is_none())
|
||||
.map(|e| e.name.as_str())
|
||||
.collect();
|
||||
assert_eq!(top.len(), 2);
|
||||
assert!(top.contains(&"album") && top.contains(&"loose.txt"));
|
||||
|
||||
let inside = list(&Request::ListTrashedFolder {
|
||||
uid: album.to_string(),
|
||||
});
|
||||
let names: Vec<&str> = inside.iter().map(|e| e.name.as_str()).collect();
|
||||
assert!(names.contains(&"inner"), "{names:?}");
|
||||
assert!(names.contains(&"b.jpg"), "{names:?}");
|
||||
assert!(inside.iter().any(|e| e.uid == inner.to_string()));
|
||||
|
||||
assert!(matches!(
|
||||
daemon.request(&Request::EmptyTrash),
|
||||
Ok(Response::Ok { .. })
|
||||
));
|
||||
assert!(list(&Request::ListTrash).is_empty());
|
||||
daemon
|
||||
.request(&Request::Refresh {
|
||||
scope: RefreshScope::Trash,
|
||||
})
|
||||
.unwrap();
|
||||
assert!(list(&Request::ListTrash).is_empty());
|
||||
assert!(drive.lookup("album").is_none());
|
||||
|
||||
assert!(matches!(daemon.stop(), Ok(MountOutcome::Shutdown)));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
|
||||
fn a_move_blocked_by_trash_can_be_retried_after_restore() {
|
||||
|
||||
@@ -1746,6 +1746,11 @@ impl DriveApi for FakeClient {
|
||||
.await
|
||||
}
|
||||
|
||||
async fn empty_trash(&self) -> Result<()> {
|
||||
let trashed = self.enumerate_trash_node_uids().await?;
|
||||
self.batch(&trashed, delete_one).await.map(|_| ())
|
||||
}
|
||||
|
||||
async fn enumerate_trash_node_uids(&self) -> Result<Vec<NodeUid>> {
|
||||
self.request(false, |server| {
|
||||
Ok(server
|
||||
|
||||
@@ -23,6 +23,8 @@ path = "src/prompt.rs"
|
||||
|
||||
[dependencies]
|
||||
proton-gallery-rs.workspace = true
|
||||
# The offline basemap under the Places map.
|
||||
proton-map-rs.workspace = true
|
||||
base64.workspace = true
|
||||
pdfs-core.workspace = true
|
||||
tracing.workspace = true
|
||||
@@ -43,3 +45,7 @@ pangocairo = "0.22"
|
||||
reqwest = { version = "0.13", default-features = false, features = ["rustls", "webpki-roots"] }
|
||||
# The system libintl (glibc) rather than a bundled gettext build.
|
||||
gettext-rs = { version = "0.8", features = ["gettext-system"] }
|
||||
|
||||
[dev-dependencies]
|
||||
# Builds small basemaps for the map tests.
|
||||
proton-map-rs = { workspace = true, features = ["writer"] }
|
||||
@@ -547,6 +547,13 @@ fn build_window(app: &adw::Application) {
|
||||
selection_bar: trash_widgets.selection_bar.clone(),
|
||||
selection_label: trash_widgets.selection_label.clone(),
|
||||
loader: Loader::new(&trash_widgets.content),
|
||||
back: trash_widgets.back.clone(),
|
||||
crumb: trash_widgets.crumb.clone(),
|
||||
search: trash_widgets.search.clone(),
|
||||
grouped: trash_widgets.grouped.clone(),
|
||||
all: RefCell::new(Vec::new()),
|
||||
nav: RefCell::new(Vec::new()),
|
||||
folder_rows: RefCell::new(None),
|
||||
},
|
||||
gallery: GalleryState {
|
||||
model: gallery_widgets.model.clone(),
|
||||
@@ -1476,7 +1483,7 @@ fn install_window_actions(ui: &Rc<Ui>, window: &adw::ApplicationWindow) {
|
||||
None,
|
||||
gtk4::License::Custom,
|
||||
Some(&gettext(
|
||||
"The places map is drawn from <a href=\"https://www.naturalearthdata.com/\">Natural Earth</a> land outlines and country borders, which are in the public domain.",
|
||||
"The places map is drawn from <a href=\"https://www.naturalearthdata.com/\">Natural Earth</a> land, water and borders, which are in the public domain.",
|
||||
)),
|
||||
);
|
||||
dialog.add_legal_section(
|
||||
|
||||
@@ -3185,6 +3185,7 @@ pub(crate) fn repaint_search(ui: &Rc<Ui>, hits: &[SearchHit]) {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
})
|
||||
.collect();
|
||||
@@ -3249,6 +3250,7 @@ mod tests {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -675,15 +675,45 @@ fn verify_in_browser(
|
||||
/// Sign out, after a confirmation: disable+stop the mount service (so the
|
||||
/// daemon isn't left running without credentials), forget the stored session,
|
||||
/// and drop back to the login page.
|
||||
///
|
||||
/// Changes still queued are named first: they stay staged here and are sent
|
||||
/// after the next sign-in, but until then they exist nowhere else.
|
||||
pub(crate) fn sign_out(ui: &Rc<Ui>) {
|
||||
let rx = spawn_request(ui.dirs.control_socket(), Request::Status);
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let queued = match rx.recv().await {
|
||||
Ok(Ok(Response::Status {
|
||||
pending_uploads,
|
||||
pending_changes,
|
||||
parked_uploads,
|
||||
..
|
||||
})) => pending_uploads + pending_changes + parked_uploads,
|
||||
_ => 0,
|
||||
};
|
||||
confirm_sign_out(&ui, queued);
|
||||
});
|
||||
}
|
||||
|
||||
fn confirm_sign_out(ui: &Rc<Ui>, queued: u64) {
|
||||
let Some(window) = ui_window(ui) else { return };
|
||||
let ui = ui.clone();
|
||||
let mut body = gettext(
|
||||
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
|
||||
);
|
||||
if queued > 0 {
|
||||
let warning = ngettext_f(
|
||||
"{n} change is not on Proton Drive yet. It stays on this computer and is sent after you sign in again.",
|
||||
"{n} changes are not on Proton Drive yet. They stay on this computer and are sent after you sign in again.",
|
||||
queued,
|
||||
&[],
|
||||
);
|
||||
body = format!("{warning}\n\n{body}");
|
||||
}
|
||||
confirm_destructive(
|
||||
&window,
|
||||
&gettext("Sign Out?"),
|
||||
&gettext(
|
||||
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
|
||||
),
|
||||
&body,
|
||||
&gettext("Sign Out"),
|
||||
move || {
|
||||
let galleries = ui.drive_galleries.borrow().upgrade();
|
||||
|
||||
@@ -1,7 +1,12 @@
|
||||
//! The online street map under the Places map: vector tiles from OpenFreeMap,
|
||||
//! fetched and drawn on a worker thread, and handed to the map as finished
|
||||
//! images.
|
||||
//! The tiles under the Places map, made on worker threads and handed to the
|
||||
//! map as finished images. They come from one of two sources.
|
||||
//!
|
||||
//! The offline basemap is a PMTiles file installed with the app and drawn by
|
||||
//! `proton-map-rs`, the same map Proton Gallery shows: seas, lakes, rivers,
|
||||
//! built-up areas, borders and town names from Natural Earth and GeoNames.
|
||||
//! It sends nothing anywhere. Its names are drawn into the tiles.
|
||||
//!
|
||||
//! The online street map is vector tiles from OpenFreeMap.
|
||||
//! It is off unless turned on in Preferences, since every tile fetched tells
|
||||
//! OpenFreeMap which part of the world is being looked at. OpenFreeMap needs
|
||||
//! no account or key, and its tiles are OpenStreetMap data in the
|
||||
@@ -20,9 +25,17 @@ use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
use gtk4::cairo;
|
||||
use proton_map::{Basemap, Style, TileId};
|
||||
|
||||
use super::mvt::{self, Kind, Layer};
|
||||
|
||||
/// The basemap's file name, wherever it is installed.
|
||||
pub(crate) const BASEMAP_FILE: &str = "basemap-v1.pmtiles";
|
||||
|
||||
/// How many threads draw basemap tiles. Drawing is all CPU; two keep the map
|
||||
/// quick without taking the machine.
|
||||
const BASEMAP_THREADS: usize = 2;
|
||||
|
||||
/// Where OpenFreeMap describes its current tile set.
|
||||
const TILEJSON_URL: &str = "https://tiles.openfreemap.org/planet";
|
||||
|
||||
@@ -254,8 +267,20 @@ struct Job {
|
||||
dark: bool,
|
||||
}
|
||||
|
||||
/// The worker thread making tiles. Dropping it stops the thread once the
|
||||
/// fetches under way are done.
|
||||
/// Where a tile worker gets its tiles.
|
||||
pub(crate) enum Source {
|
||||
/// OpenFreeMap's street map, cached under `cache_dir`, with names in
|
||||
/// `language` where the map has them.
|
||||
Online {
|
||||
cache_dir: PathBuf,
|
||||
language: String,
|
||||
},
|
||||
/// The basemap installed at this path.
|
||||
Offline(PathBuf),
|
||||
}
|
||||
|
||||
/// The worker threads making tiles. Dropping it stops them once the tiles
|
||||
/// under way are done.
|
||||
pub(crate) struct Tiles {
|
||||
jobs: async_channel::Sender<Job>,
|
||||
wanted: Arc<Mutex<HashSet<TileKey>>>,
|
||||
@@ -264,27 +289,35 @@ pub(crate) struct Tiles {
|
||||
}
|
||||
|
||||
impl Tiles {
|
||||
/// Start the worker, caching under `cache_dir`, drawing names in
|
||||
/// `language` where the map has them. Finished tiles arrive on the
|
||||
/// returned channel.
|
||||
pub(crate) fn start(
|
||||
cache_dir: PathBuf,
|
||||
language: String,
|
||||
scale: i32,
|
||||
) -> (Self, async_channel::Receiver<Done>) {
|
||||
/// Start the worker for `source`. Finished tiles arrive on the returned
|
||||
/// channel.
|
||||
pub(crate) fn start(source: Source, scale: i32) -> (Self, async_channel::Receiver<Done>) {
|
||||
let (jobs, job_rx) = async_channel::unbounded();
|
||||
let (done_tx, done_rx) = async_channel::unbounded();
|
||||
let wanted = Arc::new(Mutex::new(HashSet::new()));
|
||||
let worker = Worker {
|
||||
dir: cache_dir,
|
||||
language,
|
||||
scale,
|
||||
wanted: wanted.clone(),
|
||||
done: done_tx,
|
||||
let spawned = match source {
|
||||
Source::Online {
|
||||
cache_dir,
|
||||
language,
|
||||
} => {
|
||||
let worker = Worker {
|
||||
dir: cache_dir,
|
||||
language,
|
||||
scale,
|
||||
wanted: wanted.clone(),
|
||||
done: done_tx,
|
||||
};
|
||||
std::thread::Builder::new()
|
||||
.name("map-tiles".into())
|
||||
.spawn(move || worker.run(job_rx))
|
||||
}
|
||||
Source::Offline(path) => {
|
||||
let wanted = wanted.clone();
|
||||
std::thread::Builder::new()
|
||||
.name("map-basemap".into())
|
||||
.spawn(move || draw_basemap(&path, scale, &wanted, &job_rx, &done_tx))
|
||||
}
|
||||
};
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("map-tiles".into())
|
||||
.spawn(move || worker.run(job_rx));
|
||||
if let Err(e) = spawned {
|
||||
tracing::warn!("map tiles: cannot start the worker: {e}");
|
||||
}
|
||||
@@ -463,6 +496,126 @@ impl Worker {
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the basemap may be installed, most specific first.
|
||||
fn basemap_paths() -> Vec<PathBuf> {
|
||||
let mut paths = Vec::new();
|
||||
if let Some(path) = std::env::var_os("PDFS_BASEMAP") {
|
||||
paths.push(PathBuf::from(path));
|
||||
}
|
||||
if let Some(dir) = std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|exe| exe.parent().map(Path::to_path_buf))
|
||||
{
|
||||
paths.push(dir.join("../share/proton-drive-linux").join(BASEMAP_FILE));
|
||||
}
|
||||
paths.push(Path::new("/usr/share/proton-drive-linux").join(BASEMAP_FILE));
|
||||
if let Some(dir) = std::env::var_os("XDG_DATA_HOME")
|
||||
.map(PathBuf::from)
|
||||
.or_else(|| std::env::var_os("HOME").map(|home| Path::new(&home).join(".local/share")))
|
||||
{
|
||||
paths.push(dir.join("proton-drive-linux").join(BASEMAP_FILE));
|
||||
}
|
||||
if cfg!(debug_assertions) {
|
||||
// `scripts/fetch-basemap.sh` puts it here for development builds.
|
||||
paths
|
||||
.push(Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../data")).join(BASEMAP_FILE));
|
||||
}
|
||||
paths
|
||||
}
|
||||
|
||||
/// The installed basemap's path, if there is one.
|
||||
pub(crate) fn find_basemap() -> Option<PathBuf> {
|
||||
basemap_paths().into_iter().find(|path| path.is_file())
|
||||
}
|
||||
|
||||
/// The basemap, read once per run: the map restarts its worker when the
|
||||
/// window moves to a screen of another density, and the file is 25 MB.
|
||||
fn open_basemap(path: &Path) -> Option<Arc<Basemap>> {
|
||||
static OPENED: Mutex<Option<(PathBuf, Arc<Basemap>)>> = Mutex::new(None);
|
||||
let mut opened = OPENED.lock().ok()?;
|
||||
if let Some((at, basemap)) = opened.as_ref()
|
||||
&& at == path
|
||||
{
|
||||
return Some(basemap.clone());
|
||||
}
|
||||
match Basemap::open(path) {
|
||||
Ok(basemap) => {
|
||||
let basemap = Arc::new(basemap);
|
||||
*opened = Some((path.to_path_buf(), basemap.clone()));
|
||||
Some(basemap)
|
||||
}
|
||||
Err(e) => {
|
||||
tracing::warn!("map tiles: cannot open the basemap: {e}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Open the basemap at `path` and draw the tiles asked for on
|
||||
/// [`BASEMAP_THREADS`] threads until the map lets go of the worker. Without
|
||||
/// a readable basemap every tile fails, and the outline shows.
|
||||
fn draw_basemap(
|
||||
path: &Path,
|
||||
scale: i32,
|
||||
wanted: &Mutex<HashSet<TileKey>>,
|
||||
jobs: &async_channel::Receiver<Job>,
|
||||
done: &async_channel::Sender<Done>,
|
||||
) {
|
||||
let basemap = open_basemap(path);
|
||||
std::thread::scope(|scope| {
|
||||
for _ in 0..BASEMAP_THREADS {
|
||||
let basemap = basemap.clone();
|
||||
scope.spawn(move || {
|
||||
while let Ok(job) = jobs.recv_blocking() {
|
||||
let key = job.key;
|
||||
let still_wanted = wanted.lock().map(|w| w.contains(&key)).unwrap_or(true);
|
||||
let result = match &basemap {
|
||||
_ if !still_wanted => Done::Dropped(key),
|
||||
Some(basemap) => Done::Tile(draw_basemap_tile(basemap, job, scale)),
|
||||
None => Done::Failed(key),
|
||||
};
|
||||
if done.send_blocking(result).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// One basemap tile at `scale` device px per logical px.
|
||||
fn draw_basemap_tile(basemap: &Basemap, job: Job, scale: i32) -> Raster {
|
||||
let style = if job.dark {
|
||||
Style::dark()
|
||||
} else {
|
||||
Style::light()
|
||||
};
|
||||
let key = job.key;
|
||||
let tile = proton_map::render_tile(
|
||||
basemap,
|
||||
TileId::new(key.z, key.x, key.y),
|
||||
scale.max(1) as f32,
|
||||
&style,
|
||||
);
|
||||
Raster {
|
||||
key,
|
||||
dark: job.dark,
|
||||
edge: tile.width as i32,
|
||||
pixels: rgba_to_cairo(tile.rgba),
|
||||
labels: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Premultiplied RGBA bytes to cairo's premultiplied ARGB, one native-endian
|
||||
/// word per pixel.
|
||||
fn rgba_to_cairo(mut pixels: Vec<u8>) -> Vec<u8> {
|
||||
for px in pixels.as_chunks_mut::<4>().0 {
|
||||
let [r, g, b, a] = *px;
|
||||
*px = u32::from_be_bytes([a, r, g, b]).to_ne_bytes();
|
||||
}
|
||||
pixels
|
||||
}
|
||||
|
||||
/// The first tile URL template in a TileJSON document.
|
||||
fn tile_template(json: &[u8]) -> Option<String> {
|
||||
let doc: serde_json::Value = serde_json::from_slice(json).ok()?;
|
||||
@@ -823,6 +976,42 @@ fn label_name(layer: &Layer, feature: &mvt::Feature, language: &str) -> Option<S
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn empty_basemap() -> Basemap {
|
||||
Basemap::from_bytes(proton_map::pmtiles::writer::Writer::new().finish(
|
||||
"{}",
|
||||
[-180.0, -85.0, 180.0, 85.0],
|
||||
[0.0, 0.0],
|
||||
))
|
||||
.expect("empty archive opens")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rgba_pixels_become_cairo_words() {
|
||||
let pixels = rgba_to_cairo(vec![0x11, 0x22, 0x33, 0xff]);
|
||||
let word = u32::from_ne_bytes(pixels.try_into().expect("one pixel"));
|
||||
assert_eq!(word, 0xff11_2233);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basemap_tiles_come_at_the_screen_density_in_the_theme_asked() {
|
||||
let basemap = empty_basemap();
|
||||
let key = TileKey { z: 3, x: 4, y: 2 };
|
||||
for dark in [false, true] {
|
||||
let raster = draw_basemap_tile(&basemap, Job { key, dark }, 2);
|
||||
assert_eq!((raster.key, raster.dark), (key, dark));
|
||||
assert_eq!(raster.edge, 512);
|
||||
assert_eq!(raster.pixels.len(), 512 * 512 * 4);
|
||||
// An empty basemap is all open sea.
|
||||
let sea = if dark { Style::dark() } else { Style::light() }.water[0];
|
||||
let word = u32::from_ne_bytes(raster.pixels[..4].try_into().expect("a pixel"));
|
||||
assert_eq!(
|
||||
word & 0x00ff_ffff,
|
||||
u32::from_be_bytes([0, sea.r, sea.g, sea.b])
|
||||
);
|
||||
assert!(raster.surface().is_some());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deep_tiles_draw_from_their_ancestor_at_the_data_zoom() {
|
||||
let key = TileKey {
|
||||
|
||||
@@ -2,13 +2,13 @@
|
||||
//! their newest photo, and once the map is zoomed in close, each photo where
|
||||
//! it was taken.
|
||||
//!
|
||||
//! Underneath is one of two maps. The built-in one is drawn here from Natural
|
||||
//! Underneath are up to two maps. The outline is drawn here from Natural
|
||||
//! Earth's 1:50m land polygons and country borders (public domain), trimmed
|
||||
//! into `data/land.txt` and `data/borders.txt` by
|
||||
//! `scripts/natural-earth-land.py`; it needs no network and tells nobody
|
||||
//! anything. The street map from OpenFreeMap ([`super::map_tiles`]) is
|
||||
//! opt-in, in Preferences, and draws over the built-in one wherever its tiles
|
||||
//! have arrived.
|
||||
//! `scripts/natural-earth-land.py`, and is always there. Over it go tiles
|
||||
//! ([`super::map_tiles`]) wherever they have arrived: the offline basemap
|
||||
//! installed with the app, which needs no network and tells nobody anything,
|
||||
//! or, when turned on in Preferences, the street map from OpenFreeMap.
|
||||
//!
|
||||
//! The projection is Web Mercator, the one every other map uses, so the
|
||||
//! world looks the way people expect. Markers that would overlap on screen
|
||||
@@ -27,7 +27,7 @@ use std::time::{Duration, Instant};
|
||||
use gtk4::cairo;
|
||||
use pdfs_core::control::PhotoLocation;
|
||||
|
||||
use super::map_tiles::{self, Done, Label, LabelClass, Palette, TILE_EDGE, TileKey, Tiles};
|
||||
use super::map_tiles::{self, Done, Label, LabelClass, Palette, Source, TILE_EDGE, TileKey, Tiles};
|
||||
use crate::*;
|
||||
|
||||
const LAND: &str = include_str!("../../../data/land.txt");
|
||||
@@ -37,8 +37,8 @@ const BORDERS: &str = include_str!("../../../data/borders.txt");
|
||||
const MAX_LATITUDE: f64 = 85.0;
|
||||
|
||||
/// How far in the map zooms, as a multiple of the whole world fitting the
|
||||
/// widget: far enough for photos in one town to part on the built-in map,
|
||||
/// and down to single streets on the street map.
|
||||
/// widget: far enough for photos in one town to part on the outline and the
|
||||
/// basemap, and down to single streets on the street map.
|
||||
const MAX_ZOOM: f64 = 8192.0;
|
||||
const ONLINE_MAX_ZOOM: f64 = 65536.0;
|
||||
|
||||
@@ -66,7 +66,7 @@ const MIN_SEGMENT: f64 = 0.75;
|
||||
/// Edge in px of the square a marker's photo is scaled down to once.
|
||||
const COVER_PX: i32 = 128;
|
||||
|
||||
/// How many street-map tiles stay in memory.
|
||||
/// How many map tiles stay in memory.
|
||||
const TILE_CACHE: usize = 160;
|
||||
|
||||
/// Photo marker covers kept, 64 KiB each. A town's own cover is never
|
||||
@@ -190,7 +190,7 @@ struct Marker {
|
||||
target: Target,
|
||||
}
|
||||
|
||||
/// A street-map tile ready to draw, and the names on it.
|
||||
/// A map tile ready to draw, and the names on it.
|
||||
struct CachedTile {
|
||||
surface: cairo::ImageSurface,
|
||||
labels: Rc<Vec<Label>>,
|
||||
@@ -198,9 +198,11 @@ struct CachedTile {
|
||||
used: u64,
|
||||
}
|
||||
|
||||
/// The street map, while it is turned on.
|
||||
struct Online {
|
||||
/// The tiles drawn over the outline, from the basemap or the street map.
|
||||
struct TileLayer {
|
||||
tiles: Tiles,
|
||||
/// Whether they come from the street map.
|
||||
online: bool,
|
||||
cache: HashMap<TileKey, CachedTile>,
|
||||
pending: HashSet<TileKey>,
|
||||
failed: HashMap<TileKey, Instant>,
|
||||
@@ -239,7 +241,11 @@ struct MapState {
|
||||
drag_origin: Option<View>,
|
||||
/// The scale a pinch started from.
|
||||
pinch_origin: Option<View>,
|
||||
online: Option<Online>,
|
||||
tiles: Option<TileLayer>,
|
||||
/// Whether the street map is turned on in Preferences.
|
||||
street_map: bool,
|
||||
/// The installed basemap, if any.
|
||||
basemap: Option<PathBuf>,
|
||||
cache_dir: Option<PathBuf>,
|
||||
/// The spot [`PlacesMap::show_spot`] went to, ringed until the map is
|
||||
/// fitted to all places again.
|
||||
@@ -295,32 +301,11 @@ impl PlacesMap {
|
||||
buttons.append(&zoom);
|
||||
buttons.append(&fit);
|
||||
|
||||
let link = |url: &str, name: &str| format!("<a href=\"{url}\">{name}</a>");
|
||||
let credit = gtk4::Label::builder()
|
||||
.use_markup(true)
|
||||
.halign(gtk4::Align::End)
|
||||
.valign(gtk4::Align::End)
|
||||
.visible(false)
|
||||
.label(gettext_f(
|
||||
// Translators: the credit on the street map. {openfreemap},
|
||||
// {openmaptiles} and {openstreetmap} are the linked names of
|
||||
// the projects, which stay as they are.
|
||||
"{openfreemap} © {openmaptiles} Data from {openstreetmap}",
|
||||
&[
|
||||
(
|
||||
"openfreemap",
|
||||
&link("https://openfreemap.org", "OpenFreeMap"),
|
||||
),
|
||||
(
|
||||
"openmaptiles",
|
||||
&link("https://www.openmaptiles.org/", "OpenMapTiles"),
|
||||
),
|
||||
(
|
||||
"openstreetmap",
|
||||
&link("https://www.openstreetmap.org/copyright", "OpenStreetMap"),
|
||||
),
|
||||
],
|
||||
))
|
||||
.build();
|
||||
credit.add_css_class("places-map-credit");
|
||||
credit.add_css_class("caption");
|
||||
@@ -354,7 +339,9 @@ impl PlacesMap {
|
||||
pointer: (0.0, 0.0),
|
||||
drag_origin: None,
|
||||
pinch_origin: None,
|
||||
online: None,
|
||||
tiles: None,
|
||||
street_map: false,
|
||||
basemap: map_tiles::find_basemap(),
|
||||
cache_dir: None,
|
||||
pin: None,
|
||||
}),
|
||||
@@ -494,39 +481,53 @@ impl PlacesMap {
|
||||
self.area.queue_draw();
|
||||
}
|
||||
|
||||
/// Draw OpenFreeMap's street map under the markers, or stop, keeping its
|
||||
/// tiles in `cache_dir`.
|
||||
/// Draw OpenFreeMap's street map under the markers, keeping its tiles in
|
||||
/// `cache_dir`, or else the installed basemap.
|
||||
pub(crate) fn set_online(self: &Rc<Self>, on: bool, cache_dir: PathBuf) {
|
||||
{
|
||||
let mut state = self.state.borrow_mut();
|
||||
state.cache_dir = Some(cache_dir);
|
||||
if on == state.online.is_some() {
|
||||
let started = state.tiles.is_some() || state.basemap.is_none();
|
||||
if on == state.street_map && started {
|
||||
return;
|
||||
}
|
||||
state.online = None;
|
||||
}
|
||||
self.credit.set_visible(on);
|
||||
if on {
|
||||
self.start_tiles();
|
||||
state.street_map = on;
|
||||
state.tiles = None;
|
||||
}
|
||||
self.start_tiles();
|
||||
self.clamp_zoom();
|
||||
self.area.queue_draw();
|
||||
}
|
||||
|
||||
/// Start a tile worker for the widget's current pixel density.
|
||||
/// Start a tile worker for the widget's current pixel density, and show
|
||||
/// the credit for what it draws.
|
||||
fn start_tiles(self: &Rc<Self>) {
|
||||
let Some(dir) = self.state.borrow().cache_dir.clone() else {
|
||||
let source = {
|
||||
let state = self.state.borrow();
|
||||
match (&state.cache_dir, &state.basemap) {
|
||||
(Some(dir), _) if state.street_map => {
|
||||
let language = gtk4::pango::Language::default().to_string();
|
||||
let language = language.split(['-', '_']).next().unwrap_or("en").to_owned();
|
||||
Some(Source::Online {
|
||||
cache_dir: dir.join("map-tiles"),
|
||||
language,
|
||||
})
|
||||
}
|
||||
(_, Some(basemap)) => Some(Source::Offline(basemap.clone())),
|
||||
_ => None,
|
||||
}
|
||||
};
|
||||
let Some(source) = source else {
|
||||
self.credit.set_visible(false);
|
||||
return;
|
||||
};
|
||||
let language = gtk4::pango::Language::default().to_string();
|
||||
let language = language.split(['-', '_']).next().unwrap_or("en").to_owned();
|
||||
let (tiles, done) = Tiles::start(
|
||||
dir.join("map-tiles"),
|
||||
language,
|
||||
self.area.scale_factor().max(1),
|
||||
);
|
||||
self.state.borrow_mut().online = Some(Online {
|
||||
let online = matches!(source, Source::Online { .. });
|
||||
self.credit.set_label(&credit_text(online));
|
||||
self.credit.set_visible(true);
|
||||
let (tiles, done) = Tiles::start(source, self.area.scale_factor().max(1));
|
||||
self.state.borrow_mut().tiles = Some(TileLayer {
|
||||
tiles,
|
||||
online,
|
||||
cache: HashMap::new(),
|
||||
pending: HashSet::new(),
|
||||
failed: HashMap::new(),
|
||||
@@ -546,7 +547,7 @@ impl PlacesMap {
|
||||
|
||||
fn tile_done(&self, done: Done) {
|
||||
let mut state = self.state.borrow_mut();
|
||||
let Some(online) = state.online.as_mut() else {
|
||||
let Some(online) = state.tiles.as_mut() else {
|
||||
return;
|
||||
};
|
||||
match done {
|
||||
@@ -732,7 +733,7 @@ impl PlacesMap {
|
||||
}
|
||||
|
||||
fn max_scale(&self) -> f64 {
|
||||
let zoom = if self.state.borrow().online.is_some() {
|
||||
let zoom = if self.state.borrow().tiles.as_ref().is_some_and(|t| t.online) {
|
||||
ONLINE_MAX_ZOOM
|
||||
} else {
|
||||
MAX_ZOOM
|
||||
@@ -827,11 +828,11 @@ impl PlacesMap {
|
||||
let restart = self
|
||||
.state
|
||||
.borrow()
|
||||
.online
|
||||
.tiles
|
||||
.as_ref()
|
||||
.is_some_and(|o| o.tiles.scale != area.scale_factor().max(1));
|
||||
if restart {
|
||||
self.state.borrow_mut().online = None;
|
||||
self.state.borrow_mut().tiles = None;
|
||||
self.start_tiles();
|
||||
}
|
||||
|
||||
@@ -846,7 +847,7 @@ impl PlacesMap {
|
||||
let view = state.view;
|
||||
state.draws += 1;
|
||||
paint_outline(cr, view, size, colors);
|
||||
let labels = match state.online.as_mut() {
|
||||
let labels = match state.tiles.as_mut() {
|
||||
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
|
||||
None => Vec::new(),
|
||||
};
|
||||
@@ -999,16 +1000,16 @@ fn paint_outline(cr: &cairo::Context, view: View, size: (f64, f64), colors: &Pal
|
||||
let _ = cr.stroke();
|
||||
}
|
||||
|
||||
/// The street-map zoom whose tiles come closest to their own size on screen.
|
||||
/// The tile zoom whose tiles come closest to their own size on screen.
|
||||
fn tile_zoom(scale: f64) -> u8 {
|
||||
(scale / TILE_EDGE).log2().round().clamp(0.0, 18.0) as u8
|
||||
}
|
||||
|
||||
/// Draw the street-map tiles on screen, asking for the missing ones and
|
||||
/// standing in their nearest ancestor meanwhile. Returns the names on them.
|
||||
/// Draw the map tiles on screen, asking for the missing ones and standing in
|
||||
/// their nearest ancestor meanwhile. Returns the names on them.
|
||||
fn paint_tiles(
|
||||
cr: &cairo::Context,
|
||||
online: &mut Online,
|
||||
online: &mut TileLayer,
|
||||
view: View,
|
||||
size: (f64, f64),
|
||||
dark: bool,
|
||||
@@ -1565,6 +1566,47 @@ impl PlacesMap {
|
||||
/// How many town names a merged marker's tooltip lists.
|
||||
const TOOLTIP_NAMES: usize = 5;
|
||||
|
||||
/// The credit for the map's tiles, as Pango markup.
|
||||
fn credit_text(online: bool) -> String {
|
||||
let link = |url: &str, name: &str| format!("<a href=\"{url}\">{name}</a>");
|
||||
if online {
|
||||
gettext_f(
|
||||
// Translators: the credit on the street map. {openfreemap},
|
||||
// {openmaptiles} and {openstreetmap} are the linked names of
|
||||
// the projects, which stay as they are.
|
||||
"{openfreemap} © {openmaptiles} Data from {openstreetmap}",
|
||||
&[
|
||||
(
|
||||
"openfreemap",
|
||||
&link("https://openfreemap.org", "OpenFreeMap"),
|
||||
),
|
||||
(
|
||||
"openmaptiles",
|
||||
&link("https://www.openmaptiles.org/", "OpenMapTiles"),
|
||||
),
|
||||
(
|
||||
"openstreetmap",
|
||||
&link("https://www.openstreetmap.org/copyright", "OpenStreetMap"),
|
||||
),
|
||||
],
|
||||
)
|
||||
} else {
|
||||
gettext_f(
|
||||
// Translators: the credit on the offline map. {naturalearth} and
|
||||
// {geonames} are the linked names of the projects, which stay as
|
||||
// they are.
|
||||
"Map data © {naturalearth} (public domain) and {geonames} (CC BY 4.0)",
|
||||
&[
|
||||
(
|
||||
"naturalearth",
|
||||
&link("https://www.naturalearthdata.com/", "Natural Earth"),
|
||||
),
|
||||
("geonames", &link("https://www.geonames.org/", "GeoNames")),
|
||||
],
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn map_button(icon: &str, tooltip: &str) -> gtk4::Button {
|
||||
let button = gtk4::Button::from_icon_name(icon);
|
||||
button.set_tooltip_text(Some(tooltip));
|
||||
|
||||
@@ -635,6 +635,7 @@ pub(crate) fn shared_item_as_entry(item: &SharedItem) -> DirEntry {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -245,7 +245,7 @@ pub(crate) fn build_main_page() -> MainWidgets {
|
||||
let online_map_row = adw::SwitchRow::builder()
|
||||
.title(gettext("Street map for Places"))
|
||||
.subtitle(gettext(
|
||||
"Show streets and town names from OpenFreeMap. It learns which parts of the world you look at.",
|
||||
"Show streets from OpenFreeMap instead of the offline map. It learns which parts of the world you look at.",
|
||||
))
|
||||
.build();
|
||||
appearance_group.add(&online_map_row);
|
||||
|
||||
@@ -16,6 +16,28 @@ pub(crate) struct TrashState {
|
||||
pub(crate) selection_label: gtk4::Label,
|
||||
/// Runs the loads; the rows stay up while one runs.
|
||||
pub(crate) loader: Rc<Loader>,
|
||||
/// Back, the breadcrumb and the search entry over the list.
|
||||
pub(crate) back: gtk4::Button,
|
||||
pub(crate) crumb: gtk4::Box,
|
||||
pub(crate) search: gtk4::SearchEntry,
|
||||
/// On: the trash as the folders things were deleted from. Off: one list.
|
||||
pub(crate) grouped: gtk4::ToggleButton,
|
||||
/// The whole trash as last read, newest deletion first.
|
||||
pub(crate) all: RefCell<Vec<DirEntry>>,
|
||||
/// Where the list is, below the top level.
|
||||
pub(crate) nav: RefCell<Vec<TrashNav>>,
|
||||
/// What the trashed folder on screen holds, once read.
|
||||
pub(crate) folder_rows: RefCell<Option<Vec<DirEntry>>>,
|
||||
}
|
||||
|
||||
/// One step down from the top of the Trash page.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) enum TrashNav {
|
||||
/// The things deleted from one folder: its path, `""` for My files, `None`
|
||||
/// when the folder is not known.
|
||||
Location { key: Option<String>, label: String },
|
||||
/// Inside a trashed folder.
|
||||
Folder { uid: String, name: String },
|
||||
}
|
||||
|
||||
/// The widgets of the Trash page that a load repaints.
|
||||
@@ -30,8 +52,18 @@ pub(crate) struct TrashWidgets {
|
||||
pub(crate) selection_label: gtk4::Label,
|
||||
pub(crate) restore_selected: gtk4::Button,
|
||||
pub(crate) delete_selected: gtk4::Button,
|
||||
pub(crate) back: gtk4::Button,
|
||||
pub(crate) crumb: gtk4::Box,
|
||||
pub(crate) search: gtk4::SearchEntry,
|
||||
pub(crate) grouped: gtk4::ToggleButton,
|
||||
}
|
||||
|
||||
/// The uid prefix of a row that stands for a folder things were deleted from.
|
||||
/// Such a row is made here, never sent to the daemon.
|
||||
const LOCATION_UID: &str = "trash-location:";
|
||||
/// The location key of the folder that is not known.
|
||||
const UNKNOWN_LOCATION: &str = "\u{0}";
|
||||
|
||||
/// The Trash page: everything Drive is holding in the trash, as a list with
|
||||
/// the folder each item came from and when it was deleted, or as a grid, where
|
||||
/// photos are easier to recognise. Restore and Delete Permanently sit in the
|
||||
@@ -75,11 +107,41 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
|
||||
content.add_named(&files.views, Some("list"));
|
||||
content.add_named(&status, Some("status"));
|
||||
|
||||
let back = gtk4::Button::builder()
|
||||
.icon_name("go-previous-symbolic")
|
||||
.tooltip_text(gettext("Back"))
|
||||
.visible(false)
|
||||
.build();
|
||||
back.add_css_class("flat");
|
||||
let crumb = gtk4::Box::new(gtk4::Orientation::Horizontal, 2);
|
||||
crumb.set_valign(gtk4::Align::Center);
|
||||
let crumb_scroll = gtk4::ScrolledWindow::builder()
|
||||
.hscrollbar_policy(gtk4::PolicyType::External)
|
||||
.vscrollbar_policy(gtk4::PolicyType::Never)
|
||||
.hexpand(true)
|
||||
.child(&crumb)
|
||||
.build();
|
||||
let search = gtk4::SearchEntry::builder()
|
||||
.placeholder_text(gettext("Search the trash"))
|
||||
.width_chars(24)
|
||||
.build();
|
||||
let path_bar = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||
path_bar.append(&back);
|
||||
path_bar.append(&crumb_scroll);
|
||||
path_bar.append(&search);
|
||||
|
||||
let grouped = gtk4::ToggleButton::builder()
|
||||
.icon_name("folder-symbolic")
|
||||
.tooltip_text(gettext("Group by original folder"))
|
||||
.active(true)
|
||||
.build();
|
||||
|
||||
let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
|
||||
inner.set_margin_top(12);
|
||||
inner.set_margin_bottom(12);
|
||||
inner.set_margin_start(12);
|
||||
inner.set_margin_end(12);
|
||||
inner.append(&path_bar);
|
||||
inner.append(&content);
|
||||
|
||||
// Bulk Delete Permanently always confirms with the count, so a stale
|
||||
@@ -101,6 +163,7 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
|
||||
let (frame, header, subtitle) = page_frame(&gettext("Trash"), &inner);
|
||||
header.pack_start(&empty);
|
||||
header.pack_end(&layout);
|
||||
header.pack_end(&grouped);
|
||||
|
||||
(
|
||||
frame.upcast(),
|
||||
@@ -115,6 +178,10 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
|
||||
selection_label,
|
||||
restore_selected,
|
||||
delete_selected,
|
||||
back,
|
||||
crumb,
|
||||
search,
|
||||
grouped,
|
||||
},
|
||||
)
|
||||
}
|
||||
@@ -151,7 +218,10 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, widgets: &TrashWidgets) {
|
||||
files
|
||||
.column_view
|
||||
.append_column(&text_column(&pgettext("column", "Size"), |e| {
|
||||
if e.is_dir {
|
||||
if location_key(&e.uid).is_some() {
|
||||
// A location row carries how many items it holds as its size.
|
||||
ngettext_f("{n} item", "{n} items", e.size, &[])
|
||||
} else if e.is_dir {
|
||||
"—".to_string()
|
||||
} else {
|
||||
human_bytes(e.size)
|
||||
@@ -163,6 +233,21 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, widgets: &TrashWidgets) {
|
||||
.empty
|
||||
.connect_clicked(move |_| prompt_empty_trash(&ui_empty));
|
||||
|
||||
let ui_back = ui.clone();
|
||||
widgets.back.connect_clicked(move |_| {
|
||||
ui_back.trash.nav.borrow_mut().pop();
|
||||
show_trash_place(&ui_back);
|
||||
});
|
||||
let ui_search = ui.clone();
|
||||
widgets
|
||||
.search
|
||||
.connect_search_changed(move |_| render_trash(&ui_search));
|
||||
let ui_grouped = ui.clone();
|
||||
widgets.grouped.connect_toggled(move |_| {
|
||||
ui_grouped.trash.nav.borrow_mut().clear();
|
||||
show_trash_place(&ui_grouped);
|
||||
});
|
||||
|
||||
let ui_sel = ui.clone();
|
||||
files
|
||||
.selection
|
||||
@@ -193,17 +278,52 @@ fn trashed_from_label(entry: &DirEntry) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// A trashed file can't be opened; say what would let it be.
|
||||
/// Open a location or a trashed folder in place. A trashed file can't be
|
||||
/// opened; say what would let it be.
|
||||
fn activate_trashed(ui: &Rc<Ui>, entry: &DirEntry) {
|
||||
toast(
|
||||
ui,
|
||||
if let Some(key) = location_key(&entry.uid) {
|
||||
ui.trash.nav.borrow_mut().push(TrashNav::Location {
|
||||
key,
|
||||
label: entry.name.clone(),
|
||||
});
|
||||
show_trash_place(ui);
|
||||
} else if entry.is_dir {
|
||||
ui.trash.nav.borrow_mut().push(TrashNav::Folder {
|
||||
uid: entry.uid.clone(),
|
||||
name: entry.name.clone(),
|
||||
});
|
||||
show_trash_place(ui);
|
||||
} else {
|
||||
let name = match outer_folder(ui) {
|
||||
Some(folder) if !in_trash(ui, &entry.uid) => folder.name,
|
||||
_ => entry.name.clone(),
|
||||
};
|
||||
// Translators: {name} is a file or folder name.
|
||||
&gettext_f("Restore “{name}” to open it", &[("name", &entry.name)]),
|
||||
);
|
||||
toast(
|
||||
ui,
|
||||
&gettext_f("Restore “{name}” to open it", &[("name", &name)]),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn trash_entry_menu(ui: &Rc<Ui>, entry: &DirEntry) -> ActionMenu {
|
||||
let mut menu = ActionMenu::new();
|
||||
if location_key(&entry.uid).is_none()
|
||||
&& !in_trash(ui, &entry.uid)
|
||||
&& let Some(folder) = outer_folder(ui)
|
||||
{
|
||||
// Went to the trash with the folder, so only the folder goes back.
|
||||
let ui_c = ui.clone();
|
||||
let label = gettext_f(
|
||||
// Translators: {name} is a folder name.
|
||||
"Restore “{name}”",
|
||||
&[("name", &folder.name)],
|
||||
);
|
||||
menu.item(&label, move || {
|
||||
restore_entries(&ui_c, std::slice::from_ref(&folder))
|
||||
});
|
||||
return menu;
|
||||
}
|
||||
let (ui_c, entry_c) = (ui.clone(), entry.clone());
|
||||
menu.item(&pgettext("verb", "Restore"), move || {
|
||||
restore_entries(&ui_c, std::slice::from_ref(&entry_c))
|
||||
@@ -244,7 +364,7 @@ fn trash_background_menu(ui: &Rc<Ui>) -> ActionMenu {
|
||||
});
|
||||
let ui_c = ui.clone();
|
||||
menu.item(&gettext("Refresh"), move || reload_current_page(&ui_c));
|
||||
if ui.trash.files.model.n_items() > 0 {
|
||||
if !ui.trash.all.borrow().is_empty() {
|
||||
menu.section();
|
||||
let ui_c = ui.clone();
|
||||
menu.item(&gettext("Empty Trash…"), move || {
|
||||
@@ -300,7 +420,17 @@ pub(crate) fn load_trash(ui: &Rc<Ui>) {
|
||||
clear_trash(&ui);
|
||||
}
|
||||
match result {
|
||||
Ok(Ok(Response::Entries { entries })) => repaint_trash(&ui, &entries),
|
||||
Ok(Ok(Response::Entries { entries })) => {
|
||||
let mut entries = entries;
|
||||
sort_trash(&mut entries);
|
||||
*ui.trash.all.borrow_mut() = entries;
|
||||
keep_trash_place(&ui);
|
||||
if matches!(ui.trash.nav.borrow().last(), Some(TrashNav::Folder { .. })) {
|
||||
load_trashed_folder(&ui);
|
||||
} else {
|
||||
render_trash(&ui);
|
||||
}
|
||||
}
|
||||
Ok(Ok(Response::Error { message, .. })) => trash_status(
|
||||
&ui,
|
||||
"dialog-warning-symbolic",
|
||||
@@ -338,14 +468,125 @@ pub(crate) fn trash_status(ui: &Rc<Ui>, icon: &str, title: &str, description: &s
|
||||
ui.trash.subtitle.set_subtitle("");
|
||||
}
|
||||
|
||||
/// Repopulate the trash, most recently deleted first: the order in which a user
|
||||
/// looks for what they just deleted.
|
||||
pub(crate) fn repaint_trash(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
/// Go to the place `nav` now points at: read a trashed folder, or show
|
||||
/// what the stored listing already holds.
|
||||
fn show_trash_place(ui: &Rc<Ui>) {
|
||||
if !ui.trash.search.text().is_empty() {
|
||||
ui.trash.search.set_text("");
|
||||
}
|
||||
ui.trash.files.selection.unselect_all();
|
||||
ui.trash.files.scroll_to_top();
|
||||
if matches!(ui.trash.nav.borrow().last(), Some(TrashNav::Folder { .. })) {
|
||||
load_trashed_folder(ui);
|
||||
} else {
|
||||
render_trash(ui);
|
||||
}
|
||||
}
|
||||
|
||||
/// Read what the trashed folder on screen holds, then show it.
|
||||
fn load_trashed_folder(ui: &Rc<Ui>) {
|
||||
let Some(TrashNav::Folder { uid, .. }) = ui.trash.nav.borrow().last().cloned() else {
|
||||
return;
|
||||
};
|
||||
ui.trash.folder_rows.borrow_mut().take();
|
||||
let ui_p = ui.clone();
|
||||
let ticket = ui.trash.loader.replace(move || {
|
||||
clear_trash(&ui_p);
|
||||
trash_status(
|
||||
&ui_p,
|
||||
"folder-open-symbolic",
|
||||
&gettext("Loading…"),
|
||||
&gettext("Reading this folder."),
|
||||
false,
|
||||
);
|
||||
});
|
||||
ui.busy_begin();
|
||||
let rx = spawn_request(
|
||||
ui.dirs.control_socket(),
|
||||
Request::ListTrashedFolder { uid: uid.clone() },
|
||||
);
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let result = rx.recv().await;
|
||||
ui.busy_end();
|
||||
if !ticket.is_current() {
|
||||
return;
|
||||
}
|
||||
let still_here = matches!(
|
||||
ui.trash.nav.borrow().last(),
|
||||
Some(TrashNav::Folder { uid: on, .. }) if *on == uid
|
||||
);
|
||||
if !still_here {
|
||||
return;
|
||||
}
|
||||
match result {
|
||||
Ok(Ok(Response::Entries { entries })) => {
|
||||
*ui.trash.folder_rows.borrow_mut() = Some(entries);
|
||||
render_trash(&ui);
|
||||
}
|
||||
Ok(Ok(Response::Error { message, .. })) => {
|
||||
clear_trash(&ui);
|
||||
trash_status(
|
||||
&ui,
|
||||
"dialog-warning-symbolic",
|
||||
&gettext("Couldn't open the folder"),
|
||||
&message,
|
||||
false,
|
||||
);
|
||||
}
|
||||
Ok(Ok(_)) => {
|
||||
clear_trash(&ui);
|
||||
trash_status(
|
||||
&ui,
|
||||
"dialog-warning-symbolic",
|
||||
&gettext("Couldn't open the folder"),
|
||||
&gettext("Unexpected reply from the Proton Drive service."),
|
||||
false,
|
||||
);
|
||||
}
|
||||
Ok(Err(_)) | Err(_) => trash_unreachable(&ui),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// After a new listing, step back out of places that are gone from it.
|
||||
fn keep_trash_place(ui: &Rc<Ui>) {
|
||||
let all = ui.trash.all.borrow();
|
||||
let mut nav = ui.trash.nav.borrow_mut();
|
||||
let keep = kept_steps(&nav, &all);
|
||||
nav.truncate(keep);
|
||||
}
|
||||
|
||||
/// How many steps of `nav` still lead somewhere in `all`. A location stays
|
||||
/// while something deleted from it is listed, and the trashed folder opened
|
||||
/// from it while that folder is; the folders below it went with it.
|
||||
fn kept_steps(nav: &[TrashNav], all: &[DirEntry]) -> usize {
|
||||
let mut inside = false;
|
||||
for (i, step) in nav.iter().enumerate() {
|
||||
let there = match step {
|
||||
TrashNav::Location { key, .. } => all
|
||||
.iter()
|
||||
.any(|e| e.trashed_parent.is_none() && e.trashed_from == *key),
|
||||
TrashNav::Folder { uid, .. } => inside || all.iter().any(|e| e.uid == *uid),
|
||||
};
|
||||
if !there {
|
||||
return i;
|
||||
}
|
||||
inside |= matches!(step, TrashNav::Folder { .. });
|
||||
}
|
||||
nav.len()
|
||||
}
|
||||
|
||||
/// Show the rows for the current place, search and grouping.
|
||||
pub(crate) fn render_trash(ui: &Rc<Ui>) {
|
||||
let all = ui.trash.all.borrow();
|
||||
// An empty Trash has nothing to empty, so the button goes away rather than
|
||||
// sitting there greyed out.
|
||||
ui.trash.empty.set_sensitive(true);
|
||||
ui.trash.empty.set_visible(!entries.is_empty());
|
||||
if entries.is_empty() {
|
||||
ui.trash.empty.set_visible(!all.is_empty());
|
||||
repaint_trash_crumb(ui);
|
||||
if all.is_empty() {
|
||||
drop(all);
|
||||
trash_status(
|
||||
ui,
|
||||
"user-trash-symbolic",
|
||||
@@ -356,22 +597,198 @@ pub(crate) fn repaint_trash(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
clear_trash(ui);
|
||||
return;
|
||||
}
|
||||
ui.trash.content.set_visible_child_name("list");
|
||||
ui.trash.subtitle.set_subtitle(&ngettext_f(
|
||||
"{n} item",
|
||||
"{n} items",
|
||||
entries.len() as u64,
|
||||
&[],
|
||||
));
|
||||
let subtitle = ngettext_f("{n} item", "{n} items", all.len() as u64, &[]);
|
||||
|
||||
let mut sorted = entries.to_vec();
|
||||
sort_trash(&mut sorted);
|
||||
let query = ui.trash.search.text().to_lowercase();
|
||||
let nav = ui.trash.nav.borrow().clone();
|
||||
let rows: Vec<DirEntry> = if !query.is_empty() {
|
||||
all.iter()
|
||||
.filter(|e| e.name.to_lowercase().contains(&query))
|
||||
.cloned()
|
||||
.collect()
|
||||
} else if !ui.trash.grouped.is_active() {
|
||||
all.clone()
|
||||
} else {
|
||||
match nav.last() {
|
||||
None => trash_locations(&all),
|
||||
Some(TrashNav::Location { key, .. }) => all
|
||||
.iter()
|
||||
.filter(|e| e.trashed_parent.is_none() && e.trashed_from == *key)
|
||||
.cloned()
|
||||
.collect(),
|
||||
Some(TrashNav::Folder { .. }) => {
|
||||
ui.trash.folder_rows.borrow().clone().unwrap_or_default()
|
||||
}
|
||||
}
|
||||
};
|
||||
drop(all);
|
||||
if rows.is_empty() {
|
||||
clear_trash(ui);
|
||||
if query.is_empty() {
|
||||
trash_status(
|
||||
ui,
|
||||
"folder-open-symbolic",
|
||||
&gettext("This folder is empty"),
|
||||
&gettext("Nothing else was in this folder when it was deleted."),
|
||||
false,
|
||||
);
|
||||
} else {
|
||||
trash_status(
|
||||
ui,
|
||||
"edit-find-symbolic",
|
||||
&gettext("No results"),
|
||||
&gettext("Nothing in the trash has that name."),
|
||||
false,
|
||||
);
|
||||
}
|
||||
ui.trash.subtitle.set_subtitle(&subtitle);
|
||||
return;
|
||||
}
|
||||
ui.trash.content.set_visible_child_name("list");
|
||||
ui.trash.subtitle.set_subtitle(&subtitle);
|
||||
// Only the rows that changed are swapped, so a refresh keeps the
|
||||
// selection and the scroll position.
|
||||
replace_items(&ui.trash.files.model, &sorted);
|
||||
replace_items(&ui.trash.files.model, &rows);
|
||||
sync_trash_selection(ui);
|
||||
}
|
||||
|
||||
/// One row per folder things were deleted from, the most recent first. Items
|
||||
/// trashed inside a trashed folder are found by opening that folder.
|
||||
fn trash_locations(all: &[DirEntry]) -> Vec<DirEntry> {
|
||||
let mut rows: Vec<DirEntry> = Vec::new();
|
||||
let mut index: HashMap<Option<String>, usize> = HashMap::new();
|
||||
for entry in all.iter().filter(|e| e.trashed_parent.is_none()) {
|
||||
let key = entry.trashed_from.clone();
|
||||
let at = *index.entry(key.clone()).or_insert_with(|| {
|
||||
rows.push(location_row(key));
|
||||
rows.len() - 1
|
||||
});
|
||||
let row = &mut rows[at];
|
||||
row.size += 1;
|
||||
row.trashed_at = row.trashed_at.max(entry.trashed_at);
|
||||
row.modified = row.modified.max(entry.modified);
|
||||
}
|
||||
sort_trash(&mut rows);
|
||||
rows
|
||||
}
|
||||
|
||||
/// The row that stands for the folder `key`, still holding nothing.
|
||||
fn location_row(key: Option<String>) -> DirEntry {
|
||||
let (uid, name) = match key.as_deref() {
|
||||
None => (
|
||||
format!("{LOCATION_UID}{UNKNOWN_LOCATION}"),
|
||||
gettext("Unknown folder"),
|
||||
),
|
||||
Some("") => (LOCATION_UID.to_string(), gettext("My files")),
|
||||
Some(path) => (
|
||||
format!("{LOCATION_UID}{path}"),
|
||||
path.rsplit('/').next().unwrap_or(path).to_string(),
|
||||
),
|
||||
};
|
||||
DirEntry {
|
||||
name,
|
||||
is_dir: true,
|
||||
size: 0,
|
||||
modified: 0,
|
||||
pinned: false,
|
||||
pinned_by_folder: false,
|
||||
cached: false,
|
||||
uid,
|
||||
path: String::new(),
|
||||
role: String::new(),
|
||||
shared_by: String::new(),
|
||||
shared_at: 0,
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: key,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The folder a location row stands for, or `None` for any other row.
|
||||
fn location_key(uid: &str) -> Option<Option<String>> {
|
||||
let key = uid.strip_prefix(LOCATION_UID)?;
|
||||
Some((key != UNKNOWN_LOCATION).then(|| key.to_string()))
|
||||
}
|
||||
|
||||
/// Whether the stored listing holds `uid`, so it can be restored on its own.
|
||||
fn in_trash(ui: &Ui, uid: &str) -> bool {
|
||||
ui.trash.all.borrow().iter().any(|e| e.uid == uid)
|
||||
}
|
||||
|
||||
/// The trashed folder the user opened from a location, when inside one.
|
||||
fn outer_folder(ui: &Ui) -> Option<DirEntry> {
|
||||
let nav = ui.trash.nav.borrow();
|
||||
let uid = nav.iter().find_map(|step| match step {
|
||||
TrashNav::Folder { uid, .. } => Some(uid.clone()),
|
||||
TrashNav::Location { .. } => None,
|
||||
})?;
|
||||
ui.trash.all.borrow().iter().find(|e| e.uid == uid).cloned()
|
||||
}
|
||||
|
||||
/// What acting on `entries` acts on: a location row stands for everything
|
||||
/// deleted from that folder, and an item that went with its folder for the
|
||||
/// folder. Each node once.
|
||||
fn trashed_targets(ui: &Ui, entries: &[DirEntry]) -> Vec<DirEntry> {
|
||||
let all = ui.trash.all.borrow();
|
||||
let outer = outer_folder(ui);
|
||||
let mut seen = HashSet::new();
|
||||
let mut targets = Vec::new();
|
||||
for entry in entries {
|
||||
let picked: Vec<DirEntry> = if let Some(key) = location_key(&entry.uid) {
|
||||
all.iter()
|
||||
.filter(|e| e.trashed_parent.is_none() && e.trashed_from == key)
|
||||
.cloned()
|
||||
.collect()
|
||||
} else if all.iter().any(|e| e.uid == entry.uid) {
|
||||
vec![entry.clone()]
|
||||
} else {
|
||||
outer.clone().into_iter().collect()
|
||||
};
|
||||
for target in picked {
|
||||
if seen.insert(target.uid.clone()) {
|
||||
targets.push(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
targets
|
||||
}
|
||||
|
||||
/// Rebuild the path bar for `nav`: "Trash", then each place down to the
|
||||
/// current one. Hidden at the top, where there is nowhere to go back to.
|
||||
fn repaint_trash_crumb(ui: &Rc<Ui>) {
|
||||
let nav = ui.trash.nav.borrow();
|
||||
let crumb = &ui.trash.crumb;
|
||||
while let Some(child) = crumb.first_child() {
|
||||
crumb.remove(&child);
|
||||
}
|
||||
ui.trash.back.set_visible(!nav.is_empty());
|
||||
crumb.append(&trash_crumb_node(ui, &gettext("Trash"), 0, nav.is_empty()));
|
||||
for (i, step) in nav.iter().enumerate() {
|
||||
let label = match step {
|
||||
TrashNav::Location { label, .. } => label,
|
||||
TrashNav::Folder { name, .. } => name,
|
||||
};
|
||||
crumb.append(&crumb_separator());
|
||||
crumb.append(&trash_crumb_node(ui, label, i + 1, i + 1 == nav.len()));
|
||||
}
|
||||
}
|
||||
|
||||
fn trash_crumb_node(ui: &Rc<Ui>, label: &str, depth: usize, current: bool) -> gtk4::Widget {
|
||||
if current {
|
||||
return crumb_current(label);
|
||||
}
|
||||
let button = gtk4::Button::builder().label(label).build();
|
||||
button.add_css_class("flat");
|
||||
let ui = ui.clone();
|
||||
button.connect_clicked(move |_| {
|
||||
ui.trash.nav.borrow_mut().truncate(depth);
|
||||
show_trash_place(&ui);
|
||||
});
|
||||
button.upcast()
|
||||
}
|
||||
|
||||
/// Newest deletion first. Entries with no known deletion time go last, newest
|
||||
/// modification first among themselves.
|
||||
fn sort_trash(entries: &mut [DirEntry]) {
|
||||
@@ -393,6 +810,10 @@ fn clear_trash(ui: &Rc<Ui>) {
|
||||
/// Restore trashed entries to the folders they were trashed from. When they
|
||||
/// all came from one known folder, the toast offers to show it.
|
||||
pub(crate) fn restore_entries(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
let entries = &trashed_targets(ui, entries)[..];
|
||||
if entries.is_empty() {
|
||||
return;
|
||||
}
|
||||
let message = match entries {
|
||||
// Translators: {name} is a file or folder name.
|
||||
[one] => gettext_f("Restored “{name}”", &[("name", &one.name)]),
|
||||
@@ -430,6 +851,10 @@ fn common_origin(entries: &[DirEntry]) -> Option<String> {
|
||||
|
||||
/// Confirm, then permanently delete trashed entries. Irreversible, so it asks.
|
||||
pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
let entries = &trashed_targets(ui, entries)[..];
|
||||
if entries.is_empty() {
|
||||
return;
|
||||
}
|
||||
let win = ui_window(ui);
|
||||
let uids: Vec<String> = entries.iter().map(|e| e.uid.clone()).collect();
|
||||
let count = entries.len() as u64;
|
||||
@@ -485,7 +910,7 @@ pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
/// Confirm, then permanently delete everything in the trash.
|
||||
pub(crate) fn prompt_empty_trash(ui: &Rc<Ui>) {
|
||||
let win = ui_window(ui);
|
||||
let count = ui.trash.files.model.n_items();
|
||||
let count = ui.trash.all.borrow().len();
|
||||
let dialog = adw::AlertDialog::builder()
|
||||
.heading(gettext("Empty Trash?"))
|
||||
.body(ngettext_f(
|
||||
@@ -536,10 +961,64 @@ mod tests {
|
||||
shared_by_unverified: false,
|
||||
trashed_at,
|
||||
trashed_from: from.map(str::to_string),
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn inside(name: &str, parent: &str) -> DirEntry {
|
||||
DirEntry {
|
||||
trashed_parent: Some(parent.into()),
|
||||
..trashed(name, 5, 1, None)
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn locations_group_top_level_items_by_folder() {
|
||||
let all = vec![
|
||||
trashed("a", 30, 1, Some("Photos/2019")),
|
||||
trashed("b", 10, 1, Some("Photos/2019")),
|
||||
trashed("c", 20, 1, Some("")),
|
||||
trashed("d", 5, 1, None),
|
||||
inside("e", "a"),
|
||||
];
|
||||
let rows = trash_locations(&all);
|
||||
let summary: Vec<(&str, u64, i64)> = rows
|
||||
.iter()
|
||||
.map(|r| (r.name.as_str(), r.size, r.trashed_at))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
summary,
|
||||
[
|
||||
("2019", 2, 30),
|
||||
("My files", 1, 20),
|
||||
("Unknown folder", 1, 5)
|
||||
]
|
||||
);
|
||||
assert_eq!(location_key(&rows[0].uid), Some(Some("Photos/2019".into())));
|
||||
assert_eq!(location_key(&rows[1].uid), Some(Some(String::new())));
|
||||
assert_eq!(location_key(&rows[2].uid), Some(None));
|
||||
assert_eq!(location_key("vol~link"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_place_stays_only_while_the_listing_still_leads_there() {
|
||||
let all = vec![trashed("album", 1, 1, Some("Photos")), inside("x", "album")];
|
||||
let location = TrashNav::Location {
|
||||
key: Some("Photos".into()),
|
||||
label: "Photos".into(),
|
||||
};
|
||||
let folder = |uid: &str| TrashNav::Folder {
|
||||
uid: uid.into(),
|
||||
name: uid.into(),
|
||||
};
|
||||
// Folders below the trashed one are not listed themselves.
|
||||
let nav = [location.clone(), folder("album"), folder("child")];
|
||||
assert_eq!(kept_steps(&nav, &all), 3);
|
||||
assert_eq!(kept_steps(&[location.clone(), folder("gone")], &all), 1);
|
||||
assert_eq!(kept_steps(&nav, &[]), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trash_lists_newest_deletion_first_and_undated_last() {
|
||||
let mut entries = vec | A file deleted online while the drain checks its write is kept as a conflict copy | Only with `local_first` off |
|
||||
| [B91](#b91--the-daemon-hung-overnight-and-nothing-could-say-what-it-was-waiting-on) | The daemon hung overnight, and nothing could say what it was waiting on | The cause is not diagnosed; the daemon now reports where it is stuck and is restarted |
|
||||
| [B67](#b67--fresh-state-restore-can-silently-select-a-new-device-high-22) | Fresh-state restore can silently select a new device (HIGH-22) | An ambiguous device after a loss of local state is not asked about |
|
||||
| [B66](#b66--local-only-pending-data-is-not-protected-at-shutdown-high-21) | Local-only pending data is not protected at shutdown (HIGH-21) | No shutdown protection and no `pdfs sync flush` |
|
||||
| [B65](#b65--release-artifacts-lack-supply-chain-verification-med-11) | Release artifacts lack supply-chain verification (MED-11) | No SBOM, provenance or checksums |
|
||||
| [B15](#b15--an-empty-but-listed-folder-and-duplicated-folder-uids) | An empty-but-`listed` folder, and duplicated folder uids | Cause not attributed |
|
||||
| [B10](#b10--glib-critical-when-the-launcher-closes-over-an-in-flight-open) | GLib critical when the launcher closes over an in-flight open | |
|
||||
@@ -109,6 +108,7 @@ a live account since.
|
||||
|
||||
| Entry | Title |
|
||||
|---|---|
|
||||
| [B66](#b66--local-only-pending-data-is-not-protected-at-shutdown-high-21) | Local-only pending data is not protected at shutdown (HIGH-21) |
|
||||
| [B291](#b291--on-fedora-45s-oo7-every-saved-sign-in-is-lost-at-the-next-reboot) | On Fedora 45's oo7, every saved sign-in is lost at the next reboot |
|
||||
| [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos |
|
||||
| [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it |
|
||||
@@ -306,6 +306,7 @@ a live account since.
|
||||
|
||||
| Entry | Title |
|
||||
|---|---|
|
||||
| [B293](#b293--a-large-trash-never-lists-and-empty-trash-never-empties-it) | A large trash never lists, and Empty Trash never empties it |
|
||||
| [B292](#b292--two-programs-changing-settings-at-once-lose-one-of-the-changes) | Two programs changing settings at once lose one of the changes |
|
||||
| [B290](#b290--reopening-the-database-right-after-closing-it-can-be-refused-as-another-daemon) | Reopening the database right after closing it can be refused as another daemon |
|
||||
| [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for |
|
||||
@@ -395,6 +396,42 @@ a live account since.
|
||||
|
||||
Newest first.
|
||||
|
||||
### B293 — A large trash never lists, and Empty Trash never empties it
|
||||
|
||||
**Status:** Fixed (verified 2026-11-22)
|
||||
|
||||
**Found:** 2026-11-22. The user reported that the Trash page always showed the same 64 items and
|
||||
that Empty Trash did nothing.
|
||||
|
||||
**Where:** `proton-drive-rs` `enumerate_trash_node_uids`; `crates/pdfs-fuse/src/lib.rs`
|
||||
`Core::refresh_trash` and `Core::empty_trash`
|
||||
|
||||
**Repro:** An account with a few thousand items in the trash. The log shows `background trash
|
||||
refresh failed error=enumerate trash: no answer within 120s` on every refresh, and Empty Trash
|
||||
shows `a control request has been running for a long time request=EmptyTrash age_secs=417`.
|
||||
|
||||
**Cause:** The SDK sent the trash paging parameters in lower case, unlike every other paged
|
||||
request, and kept asking while pages came back full. On a large trash the listing never
|
||||
finished. The refresh therefore timed out every time, and the page kept the rows of the last
|
||||
refresh that had got anywhere. Empty Trash listed the trash first, with no time limit, so the
|
||||
`DELETE` was never sent. A refresh also decrypted every trashed file again, and rewrote the whole
|
||||
table after every chunk.
|
||||
|
||||
**Fix:** SDK 0.12.5 sends `Page` and `PageSize` and stops on a page that brings nothing new.
|
||||
The refresh reads only nodes it has not stored yet, without unlocking file keys, and keeps the
|
||||
time the server says each was trashed. Rows go only once the whole listing is in. Empty Trash
|
||||
sends the `DELETE` at once, under the trash call time limit, and clears the stored listing.
|
||||
Restore and Delete Permanently drop their rows right away. Schema v47 indexes `trash.parent_uid`
|
||||
and drops the stored rows once, so they are read again with real deletion times.
|
||||
SDK 0.12.6 accepts the `202 Accepted` the server answers to the `DELETE`; it empties the trash
|
||||
in the background, and Empty Trash had reported that answer as an error.
|
||||
|
||||
**Verified:** `cargo test -p pdfs-fuse the_trash_lists_by_folder_and_empties -- --ignored`, the
|
||||
new `trash_upsert_keeps_other_rows_and_retain_drops_unlisted_ones`, and the SDK paging tests on
|
||||
2026-11-22. Live on the affected account the same day: the listing read all 3379 items in
|
||||
2.8 s and stored them in 23 s, and Empty Trash emptied it on the server (the next refresh
|
||||
removed all 3379 rows).
|
||||
|
||||
### B292 — Two programs changing settings at once lose one of the changes
|
||||
|
||||
**Status:** Fixed
|
||||
@@ -7475,7 +7512,7 @@ duplicates, renamed folders, multiple devices, and byte-identical restoration.
|
||||
|
||||
### B66 — Local-only pending data is not protected at shutdown (HIGH-21)
|
||||
|
||||
**Status:** Open — 1.0 data-safety/UX blocker
|
||||
**Status:** Fixed, unverified live
|
||||
**Found:** 2026-07-22, 1.0 recovery audit
|
||||
**Where:** shutdown, CLI/GUI status, logout/unregister workflows
|
||||
|
||||
@@ -7488,6 +7525,19 @@ and last errors, and protect destructive lifecycle actions. Test offline stop,
|
||||
logout, unregister, reboot, retry exhaustion, and drain. Credential removal must
|
||||
never delete staged bytes.
|
||||
|
||||
**Fix:** `crates/pdfs-fuse/src/inhibit.rs` takes a logind shutdown inhibitor
|
||||
(`systemd-inhibit --what=shutdown --mode=block`) while the queue holds changes
|
||||
the drain can send, and lets it go once they land. Parked transient files and
|
||||
changes that need the user are left out, so they never hold a power-off up for
|
||||
good. `pdfs sync flush` retries failed changes and waits for the queue, with
|
||||
its own exit codes for "needs you" and timeout. `pdfs logout` and the app's
|
||||
Sign Out dialog say how many changes are still queued and that they stay
|
||||
staged. Credential removal never touched `staging/`.
|
||||
|
||||
**Verified:** unit tests for which work holds the lock; `systemd-inhibit` in
|
||||
block mode taken by a user process on 2026-11-21. A power-off with a queued
|
||||
upload is still owed.
|
||||
|
||||
---
|
||||
|
||||
### B65 — Release artifacts lack supply-chain verification (MED-11)
|
||||
|
||||
@@ -11,8 +11,36 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [3.10.0] — 2026-11-22
|
||||
|
||||
Schema: **47**. The trash table gets an index on the original folder, and its stored rows are
|
||||
dropped once so they are read again with real deletion times.
|
||||
|
||||
### Added
|
||||
|
||||
- `pdfs sync flush` waits until every queued change is on Proton Drive, retrying
|
||||
failed ones at once. It exits 3 when what is left needs you and 4 on `--timeout`.
|
||||
- While changes are queued that only this computer has, the daemon holds off a
|
||||
shutdown through logind, and desktops show "Sending N changes to Proton Drive" in
|
||||
their power-off dialog. Changes waiting on you never hold it up (B66).
|
||||
- Signing out, in the app or with `pdfs logout`, says how many changes are not on
|
||||
Proton Drive yet. They stay on this computer and are sent after the next sign-in.
|
||||
|
||||
### Changed
|
||||
|
||||
- The Trash page shows the folders things were deleted from. Open one to see what
|
||||
was deleted there, and open a deleted folder to see what it held. A switch in
|
||||
the header goes back to one list, and a search box finds anything in the trash
|
||||
by name. Restore and Delete Permanently work on a whole folder row. `pdfs trash`
|
||||
takes `--by-folder`, and `--folder UID` for a deleted folder.
|
||||
- The trash loads faster: a refresh reads only what is new, without unlocking file
|
||||
keys, and shows the time each item was deleted as Proton Drive reports it.
|
||||
- The Places map draws an offline basemap, the one Proton Gallery shows: seas by
|
||||
depth, lakes, rivers, built-up areas, borders and town names, in light and dark,
|
||||
rendered in the background through `proton-map-rs`. It ships with every package
|
||||
(about 25 MB, fetched by `scripts/fetch-basemap.sh` against a pinned SHA-256) and
|
||||
sends no request. The street map stays opt-in and replaces it when turned on.
|
||||
Without the file the map falls back to the coarse outlines.
|
||||
- A Google Photos import uploads two photos at once instead of one, while the next
|
||||
photo is read out of its archive. Live-photo videos still go after their stills, and
|
||||
cancelling still lets the uploads in flight finish.
|
||||
@@ -40,6 +68,12 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
|
||||
atomic writer (temporary file, sync, rename, directory sync). The mount-failure file
|
||||
is now synced before the rename too, so a crash cannot leave it empty.
|
||||
|
||||
### Fixed
|
||||
|
||||
- A large trash listed only its first items and never refreshed, and Empty Trash
|
||||
never emptied it (B293). Empty Trash no longer reports the server's "Accepted"
|
||||
answer as an error. Needs proton-sdk and proton-drive-rs 0.12.6.
|
||||
|
||||
## [3.9.0] — 2026-11-19
|
||||
|
||||
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
|
||||
@@ -2426,6 +2460,7 @@ First stable release: FUSE files-on-demand mount, sync daemon under `proton-driv
|
||||
- The outstanding FUSE defects tracked in `docs/BUGS.md`, plus a truncate defect, validated
|
||||
by a new POSIX compliance suite for the filesystem.
|
||||
|
||||
[3.10.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.10.0
|
||||
[3.9.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.9.0
|
||||
[3.8.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.8.1
|
||||
[3.5.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.5.0
|
||||
|
||||
+3
-2
@@ -70,7 +70,7 @@ The script runs `pdfs` from `PATH` on every Tab, so it keeps working after an up
|
||||
| `pdfs login [-u EMAIL] [--remember]` | Sign in (password, then a 2FA code if the account has one) and store the session in the system keyring. Restarts the service if it is running. `--remember` keeps a two-password account unlocked across logins. |
|
||||
| `pdfs unlock [--remember]` | Enter the mailbox password of a two-password account, so the service can open your files. Needed once per login session, or once with `--remember`. |
|
||||
| `pdfs lock` | Forget the unlock held in memory; the account is locked again. |
|
||||
| `pdfs logout` | End the session on Proton and remove the stored session. |
|
||||
| `pdfs logout [--yes]` | End the session on Proton and remove the stored session. Asks first while changes are still queued; they stay on this computer and are sent after the next sign-in. |
|
||||
| `pdfs status` | Account, mount, queue and cache state. |
|
||||
| `pdfs quota` | Storage used across all Proton products. |
|
||||
| `pdfs locations` | Every local place the service occupies: the Proton Drive folder and each synced folder, with mode and state. |
|
||||
@@ -125,6 +125,7 @@ commands are for scripts and for cases where the mount is not available.
|
||||
| `pdfs sync ignore check PATH` | Say whether a file in a synced folder is synced, and which pattern decides. |
|
||||
| `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. |
|
||||
| `pdfs sync queue` | List changes that have not reached Proton Drive yet. |
|
||||
| `pdfs sync flush [--timeout SECS]` | Retry failed changes now and wait until the queue is empty. Exits 0 when everything is on Proton Drive, 3 when what is left needs you (see `sync issues`), 4 on timeout. Says so while sync is paused or offline. |
|
||||
| `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. |
|
||||
| `pdfs sync export ID DEST` | Save a copy of a queued upload's content. `DEST` may be a folder; an existing file is never overwritten. The upload stays queued. |
|
||||
| `pdfs sync discard ID [--yes]` | Drop a queued change and undo it here: a new file or folder goes, anything else goes back to what Proton Drive has. Content not exported first is lost. |
|
||||
@@ -153,7 +154,7 @@ commands are for scripts and for cases where the mount is not available.
|
||||
|
||||
| Command | Description |
|
||||
|---|---|
|
||||
| `pdfs trash` | List the Trash with the UIDs the next commands take. |
|
||||
| `pdfs trash` | List the Trash with the UIDs the next commands take. `--by-folder` groups it by original folder; `--folder UID` lists a deleted folder. |
|
||||
| `pdfs restore UIDS...` | Put items back where they were. |
|
||||
| `pdfs delete-forever UIDS...` | Delete items permanently. |
|
||||
| `pdfs empty-trash` | Delete everything in the Trash permanently. |
|
||||
|
||||
+9
-2
@@ -71,13 +71,20 @@ terminal: `pdfs copy PATH... NEW_PARENT`.
|
||||
## Trash
|
||||
|
||||
Deleted files go to the Trash, both from `~/ProtonDrive` and from the app. The **Trash** page
|
||||
lists them with the date they were deleted.
|
||||
shows the folders things were deleted from, with how many items each holds and when the last
|
||||
one went. Open a folder to see what was deleted from it, and open a deleted folder to see what
|
||||
it held. The folder button in the header switches to one list of everything, newest deletion
|
||||
first, and the search box finds an item anywhere in the Trash by name.
|
||||
|
||||
- **Restore** puts an item back where it was, together with any trashed folders above it.
|
||||
- **Delete Forever** and **Empty Trash** are permanent.
|
||||
|
||||
- Restore or delete a whole folder row to act on everything deleted from that folder.
|
||||
|
||||
From a terminal: `pdfs trash` lists the Trash with an ID for each item, and `pdfs restore`,
|
||||
`pdfs delete-forever` and `pdfs empty-trash` take those IDs.
|
||||
`pdfs delete-forever` and `pdfs empty-trash` take those IDs. `pdfs trash --by-folder` groups the
|
||||
list by the folder each item was deleted from, and `pdfs trash --folder ID` shows what a deleted
|
||||
folder holds.
|
||||
|
||||
## Earlier versions of a file
|
||||
|
||||
|
||||
+6
-1
@@ -103,7 +103,7 @@ That URL follows `main`. To stay on releases, pin the input to a release tag ins
|
||||
the tag to update:
|
||||
|
||||
```nix
|
||||
inputs.proton-drive-linux.url = "github:narrrl/proton-drive-linux/v3.8.0";
|
||||
inputs.proton-drive-linux.url = "github:narrrl/proton-drive-linux/v3.10.0";
|
||||
```
|
||||
|
||||
Each release tag is built with Nix before the release is published.
|
||||
@@ -360,8 +360,12 @@ git clone https://github.com/narrrl/proton-drive-linux.git
|
||||
cd proton-drive-linux
|
||||
cargo build --release --locked
|
||||
po/build.sh target/locale # optional: compile the translations
|
||||
scripts/fetch-basemap.sh # optional: the offline Places map, into data/
|
||||
```
|
||||
|
||||
Install `data/basemap-v1.pmtiles` as `~/.local/share/proton-drive-linux/basemap-v1.pmtiles`, or
|
||||
point `PDFS_BASEMAP` at it. Without it Places shows coarse outlines only.
|
||||
|
||||
The four programs are in `target/release/`: `pdfs`, `pdfs-app`, `pdfs-tray` and `pdfs-prompt`.
|
||||
|
||||
### Build a package from the working tree
|
||||
@@ -376,6 +380,7 @@ cd packaging && makepkg -fi
|
||||
|
||||
```bash
|
||||
sudo dnf install -y rpm-build
|
||||
scripts/fetch-basemap.sh
|
||||
rpmbuild -bb packaging/proton-drive-linux.spec \
|
||||
--define "git_dir $PWD" \
|
||||
--define "_rpmdir $PWD/packaging/out" \
|
||||
|
||||
+6
-3
@@ -68,11 +68,14 @@ albums, and add or remove photos. Deleting an album keeps its photos in the time
|
||||
|
||||
**Places** groups photos by the town they were taken in, as cards or on a map. Town names come
|
||||
from [GeoNames](https://www.geonames.org/) data (CC BY 4.0) and the map from
|
||||
[Natural Earth](https://www.naturalearthdata.com/) (public domain). Both ship with the app, so
|
||||
nothing is fetched online.
|
||||
[Natural Earth](https://www.naturalearthdata.com/) (public domain): seas by depth, lakes, rivers,
|
||||
built-up areas, borders and town names, in light and dark. Both ship with the app as
|
||||
`/usr/share/proton-drive-linux/basemap-v1.pmtiles`, so nothing is fetched online. Without that file,
|
||||
for example in a build from source that skipped `scripts/fetch-basemap.sh`, the map shows coarse
|
||||
land outlines only. `PDFS_BASEMAP` points the app at another copy.
|
||||
|
||||
A street map from [OpenFreeMap](https://openfreemap.org/) (© OpenStreetMap contributors) can be
|
||||
turned on under **Preferences → General → Appearance**. It is off by default, because the map
|
||||
turned on instead under **Preferences → General → Appearance**. It is off by default, because the map
|
||||
server learns which areas you look at.
|
||||
|
||||
## Viewer and duplicates
|
||||
|
||||
+1
-1
@@ -43,7 +43,7 @@ them along.
|
||||
|
||||
| Item | State | Notes |
|
||||
|---|---|---|
|
||||
| Protect queued changes at shutdown | Not started | A systemd inhibitor lock while `staging/` holds unsent data, a warning when signing out, and a `pdfs sync flush` that waits for the queue. Today the queue is visible in `pdfs sync queue`, the tray and **Sync → Overview**, but nothing stops a shutdown (B66) |
|
||||
| Protect queued changes at shutdown | Done, live check owed | The daemon holds a logind shutdown inhibitor while the queue holds changes it can send, signing out warns with the count, and `pdfs sync flush` waits for the queue (B66) |
|
||||
| Restore pins from the machine profile | Not started | `profile.json` records pins; `pdfs sync restore` does not apply them yet |
|
||||
| Profile backup health | Not started | A failed profile upload is a `WARN` in the log and nothing in the app (B68) |
|
||||
| Rotated credentials survive a keyring failure | Open | Report and retry keyring write failures, so a rotated single-use refresh token is not lost (B61) |
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 283 KiB After Width: | Height: | Size: 702 KiB |
+6
-2
@@ -9,14 +9,14 @@
|
||||
# Build + install: cd packaging && makepkg -fi
|
||||
|
||||
pkgname=proton-drive-linux
|
||||
pkgver=3.9.0
|
||||
pkgver=3.10.0
|
||||
pkgrel=1
|
||||
pkgdesc="Unofficial Proton Drive client for Linux: files-on-demand FUSE mount, CLI, GTK4 app + tray"
|
||||
arch=('x86_64')
|
||||
url="https://proton-drive.narl.io"
|
||||
license=('MIT')
|
||||
depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool')
|
||||
makedepends=('cargo' 'git' 'gettext')
|
||||
makedepends=('cargo' 'git' 'gettext' 'curl')
|
||||
provides=('pdfs')
|
||||
# Files-on-demand mount + keyring need these at runtime.
|
||||
optdepends=('gnome-keyring: credential storage via Secret Service'
|
||||
@@ -80,6 +80,10 @@ package() {
|
||||
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
|
||||
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
|
||||
|
||||
# The offline Places basemap, fetched and checked against its pinned
|
||||
# SHA-256 by scripts/fetch-basemap.sh.
|
||||
scripts/fetch-basemap.sh "$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations: compiled from po/ into /usr/share/locale.
|
||||
po/build.sh "$pkgdir/usr/share/locale"
|
||||
|
||||
|
||||
@@ -49,6 +49,10 @@ package() {
|
||||
install -Dm644 lib/systemd/user/proton-drive.service \
|
||||
"$pkgdir/usr/lib/systemd/user/proton-drive.service"
|
||||
|
||||
# The offline Places basemap.
|
||||
install -Dm644 share/proton-drive-linux/basemap-v1.pmtiles \
|
||||
"$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations and shell completion for bash, zsh and fish.
|
||||
install -dm755 "$pkgdir/usr/share"
|
||||
cp -r --no-preserve=ownership share/locale share/bash-completion share/zsh share/fish \
|
||||
|
||||
@@ -25,8 +25,10 @@ conflicts=('proton-drive-linux' 'proton-drive-for-linux' 'proton-drive-for-linux
|
||||
options=('!lto')
|
||||
# Stops the running daemon before removal, so the mount stops mirroring deletes.
|
||||
install=proton-drive.install
|
||||
source=("$pkgname::git+$_repo.git")
|
||||
sha256sums=('SKIP')
|
||||
source=("$pkgname::git+$_repo.git"
|
||||
"basemap-v1.pmtiles::https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles")
|
||||
sha256sums=('SKIP'
|
||||
'ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280')
|
||||
|
||||
pkgver() {
|
||||
cd "$pkgname"
|
||||
@@ -81,6 +83,10 @@ package() {
|
||||
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
|
||||
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
|
||||
|
||||
# The offline Places basemap.
|
||||
install -Dm644 "$srcdir/basemap-v1.pmtiles" \
|
||||
"$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations: compiled from po/ into /usr/share/locale.
|
||||
po/build.sh "$pkgdir/usr/share/locale"
|
||||
|
||||
|
||||
@@ -25,8 +25,10 @@ conflicts=('proton-drive-linux' 'proton-drive-for-linux-bin' 'proton-drive-for-l
|
||||
options=('!lto')
|
||||
# Stops the running daemon before removal, so the mount stops mirroring deletes.
|
||||
install=proton-drive.install
|
||||
source=("$pkgname-$pkgver.tar.gz::$_repo/archive/refs/tags/v$pkgver.tar.gz")
|
||||
sha256sums=('095186fa108f27ff2b175188bb13466a94cc8ecfd71088df47a41d4d9baa58c1')
|
||||
source=("$pkgname-$pkgver.tar.gz::$_repo/archive/refs/tags/v$pkgver.tar.gz"
|
||||
"basemap-v1.pmtiles::https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles")
|
||||
sha256sums=('095186fa108f27ff2b175188bb13466a94cc8ecfd71088df47a41d4d9baa58c1'
|
||||
'ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280')
|
||||
|
||||
_srcname="proton-drive-linux-$pkgver"
|
||||
|
||||
@@ -76,6 +78,10 @@ package() {
|
||||
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
|
||||
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
|
||||
|
||||
# The offline Places basemap.
|
||||
install -Dm644 "$srcdir/basemap-v1.pmtiles" \
|
||||
"$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations: compiled from po/ into /usr/share/locale.
|
||||
po/build.sh "$pkgdir/usr/share/locale"
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
{
|
||||
lib,
|
||||
rustPlatform,
|
||||
fetchurl,
|
||||
adwaita-icon-theme,
|
||||
pkg-config,
|
||||
gettext,
|
||||
@@ -23,6 +24,11 @@
|
||||
|
||||
let
|
||||
cargoToml = lib.importTOML ../../Cargo.toml;
|
||||
# The offline Places basemap, as scripts/fetch-basemap.sh pins it.
|
||||
basemap = fetchurl {
|
||||
url = "https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles";
|
||||
sha256 = "ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280";
|
||||
};
|
||||
in
|
||||
rustPlatform.buildRustPackage {
|
||||
pname = "proton-drive-linux";
|
||||
@@ -116,6 +122,7 @@ rustPlatform.buildRustPackage {
|
||||
packaging/completions.sh $out/bin/pdfs $out/share
|
||||
|
||||
# Nix brings new releases, so the app never checks for them itself.
|
||||
install -Dm644 ${basemap} $out/share/proton-drive-linux/basemap-v1.pmtiles
|
||||
install -Dm644 /dev/null $out/share/proton-drive-linux/managed-updates
|
||||
'';
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
# Match Arch PKGBUILD `!lto` — LTO has broken some GTK/Rust links in practice.
|
||||
%global _lto_cflags %{nil}
|
||||
|
||||
%{!?version: %global version 3.9.0}
|
||||
%{!?version: %global version 3.10.0}
|
||||
%global forge https://github.com/narrrl/proton-drive-linux
|
||||
# Files come from the checkout, or from the unpacked tag archive.
|
||||
%global src %{?git_dir}%{!?git_dir:.}
|
||||
@@ -25,7 +25,10 @@ ExclusiveArch: x86_64
|
||||
%if 0%{!?git_dir:1}
|
||||
Source0: %{forge}/archive/refs/tags/v%{version}.tar.gz#/%{name}-%{version}.tar.gz
|
||||
Source1: %{forge}/releases/download/v%{version}/%{name}-vendor-%{version}.tar.xz
|
||||
# The offline Places basemap, checked against its pinned SHA-256 in %%prep.
|
||||
Source2: https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles
|
||||
%endif
|
||||
%global basemap_sha256 ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280
|
||||
|
||||
BuildRequires: cargo
|
||||
BuildRequires: rust >= 1.96
|
||||
@@ -75,6 +78,7 @@ cp -a %{git_dir}/LICENSE .
|
||||
%else
|
||||
# -a 1 unpacks the vendored crates and their source mappings.
|
||||
%autosetup -n %{name}-%{version} -a 1
|
||||
echo "%{basemap_sha256} %{SOURCE2}" | sha256sum --check --quiet
|
||||
# Older vendor tarballs contained only crates.io dependencies.
|
||||
if [ ! -f .cargo/config.toml ]; then
|
||||
mkdir -p .cargo
|
||||
@@ -119,6 +123,14 @@ install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux.policy \
|
||||
%{buildroot}/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy
|
||||
install -D -m0644 %{src}/packaging/proton-drive.service \
|
||||
%{buildroot}/usr/lib/systemd/user/proton-drive.service
|
||||
%if 0%{?git_dir:1}
|
||||
# scripts/fetch-basemap.sh puts it here for in-tree builds.
|
||||
basemap=%{git_dir}/data/basemap-v1.pmtiles
|
||||
%else
|
||||
basemap=%{SOURCE2}
|
||||
%endif
|
||||
echo "%{basemap_sha256} $basemap" | sha256sum --check --quiet
|
||||
install -D -m0644 "$basemap" %{buildroot}%{_datadir}/proton-drive-linux/basemap-v1.pmtiles
|
||||
%{src}/po/build.sh %{buildroot}%{_datadir}/locale
|
||||
%{src}/packaging/completions.sh "$rel/pdfs" %{buildroot}%{_datadir}
|
||||
%if 0%{!?git_dir:1}
|
||||
@@ -160,6 +172,8 @@ fi
|
||||
%{_datadir}/bash-completion/completions/pdfs
|
||||
%{_datadir}/zsh/site-functions/_pdfs
|
||||
%{_datadir}/fish/vendor_completions.d/pdfs.fish
|
||||
%dir %{_datadir}/proton-drive-linux
|
||||
%{_datadir}/proton-drive-linux/basemap-v1.pmtiles
|
||||
%if 0%{!?git_dir:1}
|
||||
%{_datadir}/proton-drive-linux/managed-updates
|
||||
%endif
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#!/usr/bin/env bash
|
||||
# Lay out the release tarball: built binaries, desktop files, icon, user
|
||||
# service, translations, shell completions and install.sh, under one top-level
|
||||
# service, the Places basemap, translations, shell completions and install.sh, under one top-level
|
||||
# directory with a /usr-like tree, then pack it.
|
||||
#
|
||||
# usage: packaging/tarball/build.sh <binary dir> <version> <output dir>
|
||||
@@ -37,6 +37,11 @@ install -Dm644 "$repo/packaging/io.narl.proton-drive-linux.policy" \
|
||||
install -Dm644 "$repo/packaging/proton-drive.service" \
|
||||
"$root/lib/systemd/user/proton-drive.service"
|
||||
install -Dm644 "$repo/LICENSE" "$root/share/licenses/proton-drive-linux/LICENSE"
|
||||
# The offline Places basemap, fetched once into data/ and checked against
|
||||
# its pinned SHA-256.
|
||||
"$repo/scripts/fetch-basemap.sh"
|
||||
install -Dm644 "$repo/data/basemap-v1.pmtiles" \
|
||||
"$root/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
"$repo/po/build.sh" "$root/share/locale"
|
||||
"$repo/packaging/completions.sh" "$root/bin/pdfs" "$root/share"
|
||||
install -Dm755 "$repo/packaging/tarball/install.sh" "$root/install.sh"
|
||||
|
||||
@@ -40,6 +40,7 @@ grep -qx "ExecStart=\"$prefix/bin/pdfs\" daemon" "$unit" || fail "ExecStart= was
|
||||
[ -f "$prefix/share/locale/de/LC_MESSAGES/pdfs.mo" ] || fail "no translations"
|
||||
[ -f "$prefix/share/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg" ] || fail "no icon"
|
||||
[ -f "$prefix/share/bash-completion/completions/pdfs" ] || fail "no bash completion"
|
||||
[ -f "$prefix/share/proton-drive-linux/basemap-v1.pmtiles" ] || fail "no Places basemap"
|
||||
[ ! -e "$prefix/share/proton-drive-linux/managed-updates" ] || fail "the update check must stay on offer"
|
||||
uninstaller="$prefix/share/proton-drive-linux/install.sh"
|
||||
[ -x "$uninstaller" ] || fail "install.sh was not kept for --uninstall"
|
||||
|
||||
+485
-434
File diff suppressed because it is too large.
Load diff
+475
-421
File diff suppressed because it is too large.
Load diff
+488
-435
File diff suppressed because it is too large.
Load diff
Executable
+23
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env bash
|
||||
# Download the offline Places basemap built by proton-rs's `basemap` tool,
|
||||
# checked against its pinned SHA-256. Without it the map shows coarse
|
||||
# outlines only.
|
||||
set -euo pipefail
|
||||
root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
|
||||
name=basemap-v1.pmtiles
|
||||
url=https://github.com/narrrl/proton-rs/releases/download/basemap-v1/$name
|
||||
sha256=ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280
|
||||
out=${1:-$root/data/$name}
|
||||
if [[ -f $out ]] && echo "$sha256 $out" | sha256sum --check --status; then
|
||||
exit 0
|
||||
fi
|
||||
mkdir -p "$(dirname -- "$out")"
|
||||
part=$(mktemp "$out.XXXXXX")
|
||||
trap 'rm -f -- "$part"' EXIT
|
||||
curl --fail --location --silent --show-error --retry 3 --output "$part" "$url"
|
||||
echo "$sha256 $part" | sha256sum --check --status || {
|
||||
echo "The downloaded $name doesn't match its pinned checksum." >&2
|
||||
exit 1
|
||||
}
|
||||
chmod 644 "$part"
|
||||
mv -- "$part" "$out"
|
||||
@@ -17,7 +17,7 @@ Options:
|
||||
--only LIST capture only these, comma-separated (default: all of
|
||||
login,files,photos,photos_map,computers,sync,conflicts,
|
||||
prompt_gtk,prompt_fzf). preferences_sync and
|
||||
preferences_apps exist too, for pull requests only
|
||||
preferences_apps and trash exist too, for pull requests only
|
||||
--website DIR afterwards, copy them into the website checkout at DIR
|
||||
with its scripts/sync-screenshots.sh
|
||||
--settle SECS how long a page gets to load before its capture (default 3)
|
||||
@@ -37,7 +37,7 @@ EOF
|
||||
repo="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
|
||||
all=login,files,photos,photos_map,computers,sync,conflicts,prompt_gtk,prompt_fzf
|
||||
# Not in the README, so not taken by default.
|
||||
extra=preferences_sync,preferences_apps
|
||||
extra=preferences_sync,preferences_apps,trash
|
||||
|
||||
# The capture itself, run by cage inside the throwaway session (see below).
|
||||
if [[ "${1:-}" == --capture ]]; then
|
||||
@@ -82,7 +82,7 @@ if [[ "${1:-}" == --capture ]]; then
|
||||
sleep "$SETTLE"
|
||||
for shot in files:browser photos:gallery photos_map:places-map computers:devices \
|
||||
sync:sync-folders conflicts:activity \
|
||||
preferences_sync:preferences-sync preferences_apps:preferences-apps; do
|
||||
preferences_sync:preferences-sync preferences_apps:preferences-apps trash:trash; do
|
||||
name=${shot%%:*}
|
||||
wants "$name" || continue
|
||||
"$BIN/pdfs-app" --page "${shot#*:}"
|
||||
@@ -233,6 +233,9 @@ printf '[Settings]\ngtk-decoration-layout=:close\n' >"$root/config/gtk-4.0/setti
|
||||
home=/home/alex
|
||||
[[ -e "$home" ]] && home="$root/home"
|
||||
|
||||
# The offline Places basemap, as the packages install it.
|
||||
"$repo/scripts/fetch-basemap.sh"
|
||||
|
||||
outer_bus=${DBUS_SESSION_BUS_ADDRESS:-unset}
|
||||
env -i \
|
||||
PATH="$PATH" LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8 TZ="${TZ:-Europe/Berlin}" \
|
||||
@@ -241,6 +244,7 @@ env -i \
|
||||
XDG_CACHE_HOME="$root/cache" XDG_DATA_HOME="$root/data" \
|
||||
XDG_RUNTIME_DIR="$root/run" \
|
||||
PDFS_DEMO_ROOT="$root" PDFS_DEMO_OUTER_BUS="$outer_bus" \
|
||||
PDFS_BASEMAP="$repo/data/basemap-v1.pmtiles" \
|
||||
GSETTINGS_BACKEND=memory ADW_DEBUG_COLOR_SCHEME=prefer-dark GTK_A11Y=none GDK_DEBUG=no-portals \
|
||||
BIN="$bin" PHOTOS="$photos" OUT="$out" SHOTS="$shots" SETTLE="$settle" \
|
||||
dbus-run-session -- "$repo/scripts/screenshots.sh" --session 2>"$root/session.log"
|
||||
|
||||
Reference in new issue
Block a user