Compare commits

..
Author SHA1 Message Date
nvrl a79193f606 Merge pull request #109 from narrrl/refactor/proton-auth-rs
refactor(core): take the keyring store from proton-auth-rs
2026-11-20 12:18:06 +01:00
69 changed files with 6530 additions and 10565 deletions

No files matched your search

-5
View File
@@ -159,9 +159,6 @@ 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
@@ -194,8 +191,6 @@ 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 '-' '.')
-1
View File
@@ -65,7 +65,6 @@ 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 \
-1
View File
@@ -5,4 +5,3 @@
/rpmbuild
/result
/result-*
/data/*.pmtiles
Generated
+15 -122
View File
@@ -2,22 +2,6 @@
# 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"
@@ -248,12 +232,6 @@ 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"
@@ -1498,7 +1476,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [
"libc",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -1953,7 +1931,7 @@ dependencies = [
"gobject-sys",
"libc",
"system-deps 9.0.1",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -3447,15 +3425,6 @@ 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"
@@ -3664,7 +3633,6 @@ dependencies = [
"libc",
"parking_lot 0.13.0",
"proton-auth-rs",
"proton-base-rs",
"proton-drive-rs",
"proton-gallery-rs",
"proton-sdk",
@@ -3700,7 +3668,6 @@ dependencies = [
"proton-drive-rs",
"proton-gallery-app-rs",
"proton-gallery-rs",
"proton-media-rs",
"rustix",
"serde",
"serde_json",
@@ -3727,7 +3694,6 @@ dependencies = [
"pangocairo",
"pdfs-core",
"proton-gallery-rs",
"proton-map-rs",
"reqwest",
"serde",
"serde_json",
@@ -3958,9 +3924,9 @@ dependencies = [
[[package]]
name = "proton-auth-rs"
version = "0.1.1"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc"
checksum = "e140db8b4444e50c818c9793c2078b57c16c5b6c285a8d4bbd74886f41b05c6f"
dependencies = [
"apple-native-keyring-store",
"dbus-secret-service",
@@ -3972,21 +3938,11 @@ dependencies = [
"zeroize",
]
[[package]]
name = "proton-base-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "451151bb1025ea5cb362f69e2bfb2d45afed603e5c6daa3dc752333a7c29c878"
dependencies = [
"rusqlite",
"thiserror 2.0.21",
]
[[package]]
name = "proton-drive-rs"
version = "0.12.4"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "670bfcf0eeb15886c962c18c76dbac976236e4377bfe073eb2360dc1ce448da2"
checksum = "d05ad4be849ce2104759631063dd06867fbe6b6f0e5c37a172a84b5a90203fa7"
dependencies = [
"async-trait",
"base64 0.23.1",
@@ -4054,16 +4010,15 @@ dependencies = [
[[package]]
name = "proton-gallery-rs"
version = "0.1.5"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e374d2053de5df0e6b0797df65d0d024dbce35f7aedfefd4a656896a0495dc9b"
checksum = "dc9c9bbb76a5fba4071ee90de4aada71c292c0e408024ddfb04a12869291404a"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
"getrandom 0.4.3",
"hex",
"kamadak-exif",
"proton-base-rs",
"rusqlite",
"serde",
"serde_json",
@@ -4077,36 +4032,11 @@ 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"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f03aa6c403e4f2f7a8f9a444dff1e268d8bc9bcaf1d0d953cc3a1312d798f1ef"
dependencies = [
"lru",
"sha2 0.11.1",
"thiserror 2.0.21",
"tokio",
"tracing",
]
[[package]]
name = "proton-sdk"
version = "0.12.4"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f578a9d920cef3f6c4da611793001fe6d2ed81face13c45f5e721274b1945f7d"
checksum = "80c381e9066c0bca3c32597df2e902eecaa4c6e05e202e70ec9d0ac2eec78bfe"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
@@ -4225,7 +4155,7 @@ dependencies = [
"once_cell",
"socket2",
"tracing",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -4680,7 +4610,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -4737,7 +4667,7 @@ dependencies = [
"security-framework",
"security-framework-sys",
"webpki-root-certs",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -5137,12 +5067,6 @@ 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"
@@ -5251,7 +5175,7 @@ dependencies = [
"getrandom 0.4.3",
"once_cell",
"rustix",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -5317,31 +5241,6 @@ 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"
@@ -5579,12 +5478,6 @@ 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"
@@ -5947,7 +5840,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
+4 -7
View File
@@ -15,11 +15,10 @@ 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.1" }
proton-drive-rs = { version = "0.12.1" }
proton-gallery-app-rs = "0.1.0"
proton-gallery-rs = "0.1.5"
proton-map-rs = "0.1.0"
proton-gallery-rs = "0.1.1"
chrono = { version = "0.4", default-features = false, features = ["std"] }
# Internal crates.
@@ -66,9 +65,7 @@ rusqlite = { version = "0.41", features = ["bundled"] }
keyring-core = "1"
# The keyring store all three apps share: reconnects after a Secret Service
# restart (B285) and replaces items instead of editing them (B291).
proton-auth-rs = "0.1.1"
proton-base-rs = "0.1"
proton-media-rs = "0.1.1"
proton-auth-rs = "0.1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
+1 -2
View File
@@ -193,8 +193,7 @@ 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/) land, water and borders (public domain), drawn
through [proton-map-rs](https://github.com/narrrl/proton-rs). The optional street
[Natural Earth](https://www.naturalearthdata.com/) outlines (public domain). The optional street
map comes from [OpenFreeMap](https://openfreemap.org/), © [OpenStreetMap](https://www.openstreetmap.org/copyright)
contributors.
+14 -144
View File
@@ -1,6 +1,6 @@
//! `pdfs` — command-line front-end for the Proton Drive Linux client.
use std::collections::{BTreeMap, HashMap};
use std::collections::HashMap;
use std::fs::OpenOptions;
use std::io::Write;
use std::os::unix::fs::FileTypeExt;
@@ -158,12 +158,8 @@ enum Command {
#[arg(long)]
forget: bool,
},
/// Forget the stored session. Asks first while changes are still queued.
Logout {
/// Do not ask first.
#[arg(long)]
yes: bool,
},
/// Forget the stored session.
Logout,
/// Show account login state, and mount status if a daemon is running.
Status,
/// List every local Proton Drive location.
@@ -436,14 +432,7 @@ enum Command {
Diagnostics,
/// List what is in the account's trash, with the uids the restore and
/// delete-forever commands take.
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>,
},
Trash,
/// Restore trashed items, by uid, to the folders they were trashed from.
Restore {
/// Node uids (`volume~link`), as printed by `pdfs trash`.
@@ -868,13 +857,6 @@ 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.
@@ -1065,7 +1047,7 @@ fn main() -> Result<()> {
cli.command,
Command::Login { .. }
| Command::Unlock { .. }
| Command::Logout { .. }
| Command::Logout
| Command::Mount { .. }
| Command::Daemon { .. }
) {
@@ -1075,7 +1057,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 { yes } => cmd_logout(yes),
Command::Logout => cmd_logout(),
Command::Status => cmd_status(),
Command::Locations => cmd_locations(),
Command::Mount { mountpoint } => cmd_mount(mountpoint),
@@ -1146,7 +1128,7 @@ fn main() -> Result<()> {
Command::Upload { sources, parent } => cmd_upload(sources, parent),
Command::Transfers => cmd_transfers(),
Command::Diagnostics => cmd_diagnostics(),
Command::Trash { by_folder, folder } => cmd_trash(by_folder, folder),
Command::Trash => cmd_trash(),
Command::Restore { uids } => cmd_restore(uids),
Command::DeleteForever { uids } => cmd_delete_forever(uids),
Command::EmptyTrash => cmd_empty_trash(),
@@ -1380,7 +1362,6 @@ 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),
@@ -1484,71 +1465,6 @@ 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)?;
@@ -2382,27 +2298,7 @@ fn key_state_name() -> &'static str {
}
}
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?")?;
}
}
fn cmd_logout() -> Result<()> {
if auth::logout()? {
println!("Signed out: the session is ended on Proton and cleared here.");
} else {
@@ -3624,37 +3520,17 @@ fn cmd_diagnostics() -> Result<()> {
Ok(())
}
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)?;
fn cmd_trash() -> Result<()> {
let response = control_request(CtlRequest::ListTrash)?;
if emit_json(&response)? {
return Ok(());
}
match response {
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 } if entries.is_empty() => println!("(trash is empty)"),
CtlResponse::Entries { entries } => {
for e in &entries {
print_trashed(e, "");
for e in entries {
let kind = if e.is_dir { "d" } else { "-" };
println!("{kind} {:>12} {} [{}]", e.size, e.name, e.uid);
}
}
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
@@ -3663,11 +3539,6 @@ fn cmd_trash(by_folder: bool, folder: Option<String>) -> 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}"),
@@ -5123,7 +4994,6 @@ 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");
-1
View File
@@ -26,7 +26,6 @@ sha2.workspace = true
rusqlite.workspace = true
keyring-core.workspace = true
proton-auth-rs = { workspace = true, features = ["keyring"] }
proton-base-rs.workspace = true
dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true
parking_lot.workspace = true
-59
View File
@@ -337,12 +337,6 @@ 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
@@ -597,59 +591,6 @@ 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> {
+71 -57
View File
@@ -36,7 +36,6 @@ use proton_sdk::cache::EncryptedCacheRepository;
use proton_sdk::config::ProtonClientConfiguration;
use proton_sdk::error::ProtonError;
use proton_sdk::http::Tokens;
use proton_sdk::login::{self, LoginError, Step};
use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters};
use proton_sdk::telemetry::TracingTelemetry;
use serde::{Deserialize, Serialize};
@@ -280,56 +279,74 @@ pub async fn login_verified(
get_totp: impl Fn() -> Result<String>,
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
) -> Result<()> {
// The sequence is `proton_sdk::login`, shared with the other Proton
// apps. It reads the key salts before unlocking, while this access token
// still has the `locked` scope: after its first refresh it never will
// again, and without them no later resume can unlock the key chain. See
// `StoredSession::key_salts`.
let mut step = login::begin(client_config(), username, password, verification)
.await
.map_err(sign_in_error)?;
let (unlocked, remember) = loop {
step = match step {
Step::SecondFactor(pending) => {
let code = get_totp()?;
pending.second_factor(&code).await.map_err(sign_in_error)?
}
// A single-password account's mailbox password is the login password.
Step::Unlock(pending) => break (pending.unlock().await.map_err(sign_in_error)?, true),
// A two-password one has a second secret the user must type, and it is
// checked against the account now — a typo found at login is a retry,
// found later it is a daemon that never mounts.
Step::MailboxPassword(pending) => {
let mut attempt = 0;
break loop {
let mailbox = get_mailbox(attempt)?;
match pending.mailbox_password(&mailbox.password).await {
Ok(unlocked) => break (unlocked, mailbox.remember),
Err(LoginError::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
attempt += 1;
}
Err(e) => return Err(sign_in_error(e)),
let password = Zeroizing::new(password.to_owned());
let session = ProtonApiSession::begin_verified(
client_config(),
username,
password.as_bytes(),
verification,
)
.await
.map_err(classify_verification_gate);
let mut session = session?;
if session.is_waiting_for_second_factor() {
let code = get_totp()?;
session.apply_second_factor_code(code.trim()).await?;
}
// Grab the key salts while this access token still has the `locked` scope:
// after its first refresh it never will again, and without them no later
// resume can unlock the key chain. See `StoredSession::key_salts`.
let key_salts = ProtonDriveClient::new(&session, Vec::new())
.account()
.key_salts()
.await?;
// A single-password account's mailbox password is the login password. A
// two-password one has a second secret the user must type, and it is checked
// against the account now — a typo found at login is a retry, found later it
// is a daemon that never mounts.
let (passphrases, remember) = match session.password_mode() {
PasswordMode::Single => (
derive_verified(&session, password.as_bytes(), key_salts.clone()).await?,
true,
),
PasswordMode::Dual => {
let mut attempt = 0;
loop {
let mailbox = get_mailbox(attempt)?;
match derive_verified(&session, mailbox.password.as_bytes(), key_salts.clone())
.await
{
Ok(passphrases) => break (passphrases, mailbox.remember),
Err(Error::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
attempt += 1;
}
};
Err(e) => return Err(e),
}
}
};
}
};
let tokens = unlocked.resume_parameters().await;
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
let tokens = session.current_tokens().await;
register_refresh_handler(&session, tokens.refresh_token.clone());
let stored = StoredSession {
session_id: tokens.session_id.as_str().to_owned(),
username: tokens.username,
user_id: tokens.user_id.as_str().to_owned(),
session_id: session.session_id().as_str().to_owned(),
username: session.username().to_owned(),
user_id: session.user_id().as_str().to_owned(),
access_token: tokens.access_token,
refresh_token: tokens.refresh_token,
scopes: tokens.scopes,
password_mode: tokens.password_mode.to_wire() as u8,
scopes: session.scopes().to_vec(),
password_mode: match session.password_mode() {
PasswordMode::Single => 1,
PasswordMode::Dual => 2,
},
mailbox_password: String::new(),
key_salts: unlocked.key_salts,
key_salts,
key_passphrases: None,
};
keep_passphrases(stored, &unlocked.key_passphrases, remember)
keep_passphrases(stored, &passphrases, remember)
}
/// Derive the key passphrases from `mailbox` and prove they unlock the account.
@@ -403,23 +420,20 @@ fn decode_secret(secret: &[u8]) -> Option<KeyPassphrases> {
decode(&serde_json::from_slice(secret).ok()?)
}
/// A failed sign-in step as this crate's error.
/// Lift a human-verification gate out of the generic API error into the typed
/// variant a front-end can act on.
///
/// A blocked, refused or wrong-code attempt goes back to the Proton error it
/// came from, which is what the front-ends word themselves. Only a gate that
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that
/// offers only `email`/`sms` stays a plain API error, because sending the UI to
/// open a page it cannot complete reads as a hang rather than a refusal.
fn sign_in_error(e: LoginError) -> Error {
match e {
LoginError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
LoginError::SecurityKeyOnly => Error::SecurityKeyOnly,
LoginError::Blocked(api) | LoginError::Rejected(api) | LoginError::WrongCode(api) => {
Error::Proton(ProtonError::Api(api))
}
LoginError::WrongMailboxPassword => Error::WrongMailboxPassword,
LoginError::Proton(e) => e.into(),
other => Error::Other(other.to_string()),
/// Only a gate that names a solvable method is converted. A `9001` with no
/// `Details`, or one offering only `email`/`sms`, stays a plain API error:
/// promoting it would send the UI to open a verification page it cannot
/// complete, which reads to the user as a hang rather than a refusal.
fn classify_verification_gate(e: ProtonError) -> Error {
let ProtonError::Api(api) = &e else {
return e.into();
};
match api.human_verification() {
Some(hv) if hv.supports_captcha() => Error::HumanVerificationRequired(Box::new(hv)),
_ => e.into(),
}
}
+29 -3
View File
@@ -457,7 +457,26 @@ fn load_config_at(path: &Path) -> AppConfig {
/// [`AppDirs::save_config`] for the file at `path`.
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
refuse_to_replace_unreadable(path)?;
proton_base_rs::atomic::write(path, &serde_json::to_vec_pretty(config)?)?;
let parent = path
.parent()
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|duration| duration.as_nanos())
.unwrap_or(0);
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
use std::os::unix::fs::OpenOptionsExt as _;
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(&tmp)?;
use std::io::Write as _;
file.write_all(&serde_json::to_vec_pretty(config)?)?;
file.sync_all()?;
std::fs::rename(&tmp, path)?;
std::fs::File::open(parent)?.sync_all()?;
Ok(())
}
@@ -602,8 +621,15 @@ impl AppDirs {
use std::io::Read as _;
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
// Not secret, and other tools may read it; keep it world-readable.
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?;
let parent = path
.parent()
.ok_or_else(|| Error::Other("machine id path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
std::fs::write(&tmp, format!("{id}\n"))?;
std::fs::File::open(&tmp)?.sync_all()?;
std::fs::rename(&tmp, &path)?;
std::fs::File::open(parent)?.sync_all()?;
Ok(id)
}
+2 -17
View File
@@ -515,13 +515,6 @@ 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 {
@@ -1573,8 +1566,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. Taken from the server;
/// when it gives none, the daemon notes when it first saw the node there.
/// 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.
#[serde(default)]
pub trashed_at: i64,
/// The folder a [`Request::ListTrash`] entry goes back to on restore, as a
@@ -1582,11 +1575,6 @@ 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)]
@@ -3637,9 +3625,6 @@ 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()],
},
+1 -20
View File
@@ -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 = 47;
pub(super) const SCHEMA_VERSION: i64 = 46;
impl Db {
pub(super) fn migrate(&self) -> Result<()> {
@@ -501,16 +501,6 @@ 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",
@@ -1490,12 +1480,3 @@ 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');
";
-48
View File
@@ -650,54 +650,6 @@ 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 -55
View File
@@ -1,6 +1,6 @@
//! Trashed nodes, persisted so the trash view opens without a round-trip.
use std::collections::{HashMap, HashSet};
use std::collections::HashMap;
use rusqlite::params;
@@ -48,60 +48,6 @@ 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>> {
-8
View File
@@ -42,13 +42,6 @@ pub enum Error {
#[error("that mailbox password does not unlock your account")]
WrongMailboxPassword,
/// The account's only second factor is a security key, which needs
/// WebAuthn. Asking for a code would only fail as a wrong one.
#[error(
"this account's only second factor is a security key, which pdfs cannot use yet — add an authenticator app in your Proton account settings"
)]
SecurityKeyOnly,
/// The login was gated behind human verification. Not a failure the user can
/// fix by retrying: the challenge has to be solved and the login restarted
/// with the resulting token (see [`auth::login_verified`](crate::auth::login_verified)).
@@ -227,7 +220,6 @@ fn core_kind(e: &Error) -> ErrorKind {
| Error::ReloginRequired
| Error::Locked
| Error::WrongMailboxPassword
| Error::SecurityKeyOnly
| Error::HumanVerificationRequired(_) => ErrorKind::Denied,
Error::Proton(proton) => proton_kind(proton),
_ => ErrorKind::Internal,
+3 -1
View File
@@ -40,7 +40,9 @@ pub fn path(state_dir: &Path) -> PathBuf {
/// and renamed, so a reader never sees half of it.
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
proton_base_rs::atomic::write_with_mode(&path(state_dir), &json, 0o644)
let tmp = state_dir.join(format!("{FILE_NAME}.tmp"));
std::fs::write(&tmp, json)?;
std::fs::rename(&tmp, path(state_dir))
}
/// Forget the failure: a mount is up, or a new daemon has started.
-1
View File
@@ -16,7 +16,6 @@ sha1.workspace = true
proton-drive-rs.workspace = true
proton-gallery-app-rs.workspace = true
proton-gallery-rs.workspace = true
proton-media-rs.workspace = true
hyper = { version = "1", features = ["http1", "server"] }
hyper-util = { version = "0.1", features = ["tokio"] }
http-body-util = "0.1"
-4
View File
@@ -1342,10 +1342,6 @@ 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);
+1 -26
View File
@@ -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, TrashedNode,
ProtonDriveClient, RevisionReader, Thumbnail, ThumbnailType,
};
/// One outcome per node of a batch request; see [`ProtonDriveClient::trash_nodes`].
@@ -180,23 +180,6 @@ 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>;
@@ -555,14 +538,6 @@ 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
}
-129
View File
@@ -1,129 +0,0 @@
//! 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);
}
}
+48 -193
View File
@@ -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, TrashedNode,
ProtonDriveClient, ProtonPhotosClient, SharedWithMeItem, ThumbnailType,
};
mod albums;
@@ -92,7 +92,6 @@ use drive::{DriveApi, RevisionRead};
mod events;
mod filesystem;
mod gallery;
mod inhibit;
mod keeper;
mod link;
pub use filesystem::ProtonFs;
@@ -4611,7 +4610,6 @@ 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)),
@@ -5605,29 +5603,20 @@ 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(items
Ok(self
.db
.trash_list()
.map_err(CoreError::from)?
.into_iter()
.zip(trashed_parents)
.map(|(item, trashed_parent)| DirEntry {
.map(|item| 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,
@@ -5649,86 +5638,13 @@ 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.
///
/// 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.
/// 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.
async fn refresh_trash(&self) -> CoreResult<()> {
let started = Instant::now();
let uids = within_trash_call("enumerate trash", self.drive.enumerate_trash_node_uids())
@@ -5740,6 +5656,8 @@ 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
@@ -5747,51 +5665,36 @@ impl Core {
.ok()
.flatten()
.is_some();
let _ = self.db.clear_state(TRASH_COMPLETE_MS);
let now = now_secs();
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();
if uids.is_empty() {
self.db.trash_replace(&[]).map_err(CoreError::from)?;
}
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 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_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)?;
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)?;
self.trash_progress.notify_waiters();
self.events.publish(&[Topic::Trash]);
debug!(
materialized,
total = missing.len(),
materialized = items.len(),
total = uids.len(),
chunk_ms = chunk_started.elapsed().as_millis() as u64,
"trash refresh: batch"
);
@@ -5800,9 +5703,7 @@ 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 = listed.len(),
new = materialized,
removed,
count = items.len(),
elapsed_ms = started.elapsed().as_millis() as u64,
"trash refresh: done"
);
@@ -5983,8 +5884,6 @@ 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())
}
@@ -5998,7 +5897,6 @@ 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 {
@@ -6008,7 +5906,6 @@ impl Core {
match outcome {
Ok(()) => {
self.drop_local(std::slice::from_ref(&uid));
gone.push(uid.to_string());
deleted += 1;
}
Err(e) => {
@@ -6025,34 +5922,23 @@ 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 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.
/// 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.
fn empty_trash(&self) -> CoreResult<usize> {
let uids: Vec<String> = self
.db
.trash_seen()
.map_err(CoreError::from)?
.into_keys()
.collect();
let uids = self
.rt
.block_on(self.drive.enumerate_trash_node_uids())
.map_err(|e| CoreError::from_api(&e, "enumerate trash"))?;
self.rt
.block_on(within_trash_call("empty trash", self.drive.empty_trash()))?
.block_on(self.client.empty_trash())
.map_err(|e| CoreError::from_api(&e, "empty 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]);
self.drop_local(&uids);
self.invalidate_trash();
Ok(uids.len())
}
@@ -6954,37 +6840,6 @@ 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
-11
View File
@@ -793,17 +793,6 @@ 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
+76 -8
View File
@@ -212,12 +212,15 @@ impl BlockRing {
}
/// The result of fetching one block, shared between everyone who wanted it.
pub(super) type BlockResult = Result<Arc<Vec<u8>>, Errno>;
type BlockResult = Result<Arc<Vec<u8>>, Errno>;
/// Identifies a block *of a revision*: node, validity tag, and the plaintext
/// range the block covers — see [`RingKey`] for why it is the range and not the
/// index.
pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
type BlockKey = (NodeUid, i64, u64, BlockSpan);
/// A claim on a block key: who owns the fetch, and where its result is published.
type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
/// Block fetches in flight, so a block is downloaded and decrypted once however
/// many readers want it at that moment (audit T1).
@@ -228,7 +231,34 @@ pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
/// for. Without this each of them pays the full round-trip and decrypt and all
/// but one result is discarded — roughly double the bandwidth and CPU in steady
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
pub(super) type BlockFlight = proton_media_rs::SingleFlight<BlockKey, BlockResult>;
#[derive(Default)]
pub(super) struct BlockFlight {
inflight: Mutex<HashMap<BlockKey, Claim>>,
}
/// Distinguishes attempts at the same key, so a leader only retires its own.
static NEXT_FLIGHT_ID: AtomicU64 = AtomicU64::new(0);
/// The leader's claim on a key. Retires it on drop — including when the task is
/// cancelled mid-fetch, which is what keeps a dropped `JoinSet` from leaving a
/// key nobody will ever publish.
struct Flight {
flight: Arc<BlockFlight>,
key: BlockKey,
id: u64,
}
impl Drop for Flight {
fn drop(&mut self) {
let mut inflight = self.flight.inflight.lock();
if inflight
.get(&self.key)
.is_some_and(|(id, _)| *id == self.id)
{
inflight.remove(&self.key);
}
}
}
/// Where each file's reader is expected to read next, so sequential reads can be
/// told from random ones and only the former prefetched (audit T2).
@@ -551,11 +581,49 @@ impl Core {
cache_blocks: bool,
) -> BlockResult {
let key: BlockKey = (uid.clone(), mtime, fsize, span);
self.block_flight
.join(key, || {
self.read_block(reader, uid, mtime, fsize, span, cache_blocks)
})
.await
let claim = {
let mut inflight = self.block_flight.inflight.lock();
match inflight.get(&key) {
Some((_, rx)) => Err(rx.clone()),
None => {
let id = NEXT_FLIGHT_ID.fetch_add(1, Ordering::Relaxed);
let (tx, rx) = tokio::sync::watch::channel(None);
inflight.insert(key.clone(), (id, rx));
Ok((
tx,
Flight {
flight: self.block_flight.clone(),
key: key.clone(),
id,
},
))
}
}
};
let (tx, flight) = match claim {
Ok(lead) => lead,
Err(mut rx) => {
loop {
if let Some(result) = rx.borrow_and_update().clone() {
return result;
}
if rx.changed().await.is_err() {
break;
}
}
return self
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
.await;
}
};
let result = self
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
.await;
// Retire the claim before publishing, so a racer that wakes and re-enters
// finds no stale entry to join.
drop(flight);
let _ = tx.send(Some(result.clone()));
result
}
/// Download and decrypt one block, then put it where the next reader will
-1
View File
@@ -77,7 +77,6 @@ fn shared_entry_of(core: &Core, n: Node) -> DirEntry {
shared_by_unverified,
trashed_at: 0,
trashed_from: None,
trashed_parent: None,
issue: None,
}
}
-75
View File
@@ -1918,81 +1918,6 @@ 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() {
-5
View File
@@ -1746,11 +1746,6 @@ 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
+80 -217
View File
@@ -256,62 +256,6 @@ impl Reporter {
}
}
/// Photos uploaded at once. Each upload waits on Proton between its blocks,
/// so two keep the link busy where one leaves it idle; more would mostly
/// stage more copies on disk.
const IMPORT_UPLOADS: usize = 2;
/// Where an upload reads the photo from.
enum Source<'a> {
/// A copy staged on disk, which a thumbnail can be made from.
Staged(&'a Path),
/// Straight out of the open archive.
Archive(&'a mut zip::ZipArchive<std::io::BufReader<std::fs::File>>),
}
/// A staged photo handed to an upload worker.
struct Upload {
index: usize,
path: PathBuf,
photo: TakeoutPhoto,
tags: Vec<PhotoTag>,
main_uid: Option<NodeUid>,
}
impl Upload {
fn landed(self, result: CoreResult<NodeUid>) -> Landed {
Landed {
index: self.index,
live: self.main_uid.is_some(),
photo: self.photo,
result,
}
}
fn streamed(
index: usize,
photo: TakeoutPhoto,
main_uid: Option<NodeUid>,
result: CoreResult<NodeUid>,
) -> Landed {
Landed {
index,
live: main_uid.is_some(),
photo,
result,
}
}
}
/// A finished upload, to be counted on the import thread.
struct Landed {
index: usize,
/// The video of a live pair, filed with its still.
live: bool,
photo: TakeoutPhoto,
result: CoreResult<NodeUid>,
}
/// How a planned photo relates to a live or motion photo pair.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LiveRole {
@@ -770,133 +714,72 @@ impl Core {
}
}
// Staged photos go to IMPORT_UPLOADS workers while this thread
// reads the next one out of its archive. A round ends only when
// every upload in it has landed, so a pair's video always finds
// its still's uid.
let (jobs, queue) = std::sync::mpsc::sync_channel::<Upload>(0);
let queue = std::sync::Mutex::new(queue);
std::thread::scope(|scope| {
let (landed_tx, landed) = std::sync::mpsc::channel::<Landed>();
for _ in 0..IMPORT_UPLOADS {
let queue = &queue;
let landed_tx = landed_tx.clone();
scope.spawn(move || {
loop {
let next = queue.lock().map(|queue| queue.recv());
let Ok(Ok(upload)) = next else { break };
let result = self.upload_takeout_photo(
Source::Staged(&upload.path),
&upload.photo,
upload.tags.clone(),
upload.main_uid.clone(),
);
let _ = std::fs::remove_file(&upload.path);
if landed_tx.send(upload.landed(result)).is_err() {
break;
}
}
});
for (archive_index, indices) in by_archive {
if self.import_should_stop(cancel) {
stopped = true;
break;
}
drop(landed_tx);
let mut archive = match open_archive(archives, archive_index) {
Ok(archive) => archive,
Err(e) => {
// The archive was readable at scan time; whatever broke
// it since costs its own photos, not the whole run.
warn!(error = %e, photos = indices.len(), "cannot reopen a takeout archive");
summary.failed += indices.len();
for _ in &indices {
job.step();
report.step();
}
report.counts(summary);
continue;
}
};
'archives: for (archive_index, indices) in by_archive {
for index in indices {
if self.import_should_stop(cancel) {
stopped = true;
break;
}
let mut archive = match open_archive(archives, archive_index) {
Ok(archive) => archive,
Err(e) => {
// The archive was readable at scan time; whatever
// broke it since costs its own photos, not the run.
warn!(error = %e, photos = indices.len(), "cannot reopen a takeout archive");
summary.failed += indices.len();
for _ in &indices {
job.step();
report.step();
}
report.counts(summary);
continue;
}
let main_uid = match planned[index].live {
Some(LiveRole::Video(still)) => planned[still].uid.clone(),
_ => None,
};
let photo = planned[index].photo.clone();
job.detail(photo.name.clone());
report.current(&photo.name);
for index in indices {
for done in landed.try_iter() {
self.record_upload(planned, done, summary, &mut favorites, job, report);
}
if self.import_should_stop(cancel) {
stopped = true;
break 'archives;
}
let item = &planned[index];
let main_uid = match item.live {
Some(LiveRole::Video(still)) => planned[still].uid.clone(),
_ => None,
};
let tags = match item.live {
Some(LiveRole::Still(tag)) => vec![tag],
_ => Vec::new(),
};
let photo = item.photo.clone();
job.detail(photo.name.clone());
report.current(&photo.name);
let uploaded =
self.upload_takeout_photo(&mut archive, &planned[index], main_uid.clone());
job.step();
report.step();
// A thumbnail is made from a file, so a photo that can
// have one is copied out of the archive and uploaded
// from the copy by a worker. Without one, Proton's apps
// show a blank tile until they make their own.
let staged = can_make_thumbnail(&photo.name, photo.size)
.then(|| self.stage_takeout_entry(&mut archive, &photo.entry))
.and_then(|staged| {
staged
.inspect_err(|e| {
warn!(error = %e,
"copying a takeout photo out failed; uploading it without a thumbnail")
})
.ok()
});
match staged {
Some(path) => {
let upload = Upload {
index,
path,
photo,
tags,
main_uid,
};
if let Err(std::sync::mpsc::SendError(upload)) = jobs.send(upload) {
let _ = std::fs::remove_file(&upload.path);
}
match uploaded {
Ok(uid) => {
self.note_self_change(&uid);
summary.uploaded += 1;
summary.bytes += photo.size;
if main_uid.is_some() {
summary.live_photos += 1;
}
None => {
let result = self.upload_takeout_photo(
Source::Archive(&mut archive),
&photo,
tags,
main_uid.clone(),
);
let done = Upload::streamed(index, photo, main_uid, result);
self.record_upload(
planned,
done,
summary,
&mut favorites,
job,
report,
);
if photo.favorite {
favorites.push(uid.clone());
}
planned[index].uid = Some(uid);
if summary.uploaded.is_multiple_of(TIMELINE_REFRESH_EVERY) {
self.spawn_timeline_refresh();
}
if summary.uploaded.is_multiple_of(CHECKPOINT_EVERY) {
report.counts(summary);
report.checkpoint();
}
}
Err(e) => {
summary.failed += 1;
warn!(name = photo.name, error = %e, "takeout photo upload failed");
}
}
report.counts(summary);
}
drop(jobs);
for done in landed.iter() {
self.record_upload(planned, done, summary, &mut favorites, job, report);
}
});
if stopped {
break;
}
}
@@ -904,55 +787,14 @@ impl Core {
stopped
}
/// Count one finished upload and file its uid in the plan.
fn record_upload(
&self,
planned: &mut [Planned],
done: Landed,
summary: &mut ImportSummary,
favorites: &mut Vec<NodeUid>,
job: &crate::transfers::JobGuard,
report: &Reporter,
) {
job.step();
report.step();
match done.result {
Ok(uid) => {
self.note_self_change(&uid);
summary.uploaded += 1;
summary.bytes += done.photo.size;
if done.live {
summary.live_photos += 1;
}
if done.photo.favorite {
favorites.push(uid.clone());
}
planned[done.index].uid = Some(uid);
if summary.uploaded.is_multiple_of(TIMELINE_REFRESH_EVERY) {
self.spawn_timeline_refresh();
}
if summary.uploaded.is_multiple_of(CHECKPOINT_EVERY) {
report.counts(summary);
report.checkpoint();
}
}
Err(e) => {
summary.failed += 1;
warn!(error = %e, "takeout photo upload failed");
}
}
report.counts(summary);
}
/// Upload one planned photo, from its staged copy or straight out of its
/// open archive.
/// Upload one planned photo out of its open archive.
fn upload_takeout_photo(
&self,
source: Source<'_>,
photo: &TakeoutPhoto,
tags: Vec<PhotoTag>,
archive: &mut zip::ZipArchive<std::io::BufReader<std::fs::File>>,
item: &Planned,
main_uid: Option<NodeUid>,
) -> CoreResult<NodeUid> {
let photo = &item.photo;
let photos = self.photos();
let guard = self.transfers.begin(
photo.name.clone(),
@@ -960,6 +802,10 @@ impl Core {
TransferDirection::Upload,
photo.size,
);
let tags = match item.live {
Some(LiveRole::Still(tag)) => vec![tag],
_ => Vec::new(),
};
let metadata = |capture_time: Option<i64>| PhotoUploadMetadata {
capture_time,
last_modification_time: capture_time.and_then(pdfs_core::timestamp::modification_time),
@@ -974,8 +820,21 @@ impl Core {
replace_existing_draft: true,
};
match source {
Source::Staged(path) => {
// A thumbnail is made from a file, so a photo that can have one is
// copied out of the archive first and uploaded from the copy. Without
// one, Proton's apps show a blank tile until they make their own.
let staged = can_make_thumbnail(&photo.name, photo.size)
.then(|| self.stage_takeout_entry(archive, &photo.entry))
.and_then(|staged| {
staged
.inspect_err(|e| {
warn!(name = photo.name, error = %e,
"copying a takeout photo out failed; uploading it without a thumbnail")
})
.ok()
});
let uploaded = match &staged {
Some(path) => {
let thumbnails = self.upload_thumbnails(path, &photo.name);
// No sidecar date and none in the name: the photo's own EXIF,
// then when Google received it, before Drive files it under
@@ -1001,7 +860,7 @@ impl Core {
.map_err(|e| CoreError::from_api(&e, "upload"))
})
}
Source::Archive(archive) => read_entry(archive, &photo.entry, |reader| {
None => read_entry(archive, &photo.entry, |reader| {
let counting = CountingReader::new(reader, &guard);
self.rt
.block_on(photos.upload_photo_from(
@@ -1016,7 +875,11 @@ impl Core {
.map_err(|e| CoreError::from_api(&e, "upload"))
})
.and_then(|result| result),
};
if let Some(path) = staged {
let _ = std::fs::remove_file(path);
}
uploaded
}
/// Mark photos as favorites. A separate call: the upload seal takes
-6
View File
@@ -23,8 +23,6 @@ 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
@@ -45,7 +43,3 @@ 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"] }
+1
View File
@@ -154,6 +154,7 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
ui.gallery.decode_queue.borrow_mut().clear();
ui.gallery.thumb_wanted.borrow_mut().clear();
ui.gallery.photo_tex.borrow_mut().clear();
ui.gallery.photo_tex_order.borrow_mut().clear();
ui.gallery.model.remove_all();
ui.gallery.groups.remove_all();
ui.gallery.row_by_photo.borrow_mut().clear();
-248
View File
@@ -1,248 +0,0 @@
//! A least-recently-used cache with a cost budget.
//!
//! Each entry carries a cost (bytes for a texture cache, `1` for a cache capped
//! by count). Inserting past the budget drops the entries used longest ago.
//! Lookups and touches are logarithmic, so a cache of a few thousand textures
//! can be touched on every tile bind without a linear scan.
use std::borrow::Borrow;
use std::collections::{BTreeMap, HashMap};
use std::hash::Hash;
struct Entry<V> {
value: V,
cost: usize,
stamp: u64,
}
pub(crate) struct Lru<K, V> {
entries: HashMap<K, Entry<V>>,
/// Entries by the stamp of their last use, oldest first.
order: BTreeMap<u64, K>,
next: u64,
used: usize,
budget: usize,
}
impl<K: Eq + Hash + Clone, V> Lru<K, V> {
pub(crate) fn new(budget: usize) -> Self {
Self {
entries: HashMap::new(),
order: BTreeMap::new(),
next: 0,
used: 0,
budget,
}
}
/// Look an entry up without marking it used.
pub(crate) fn get<Q>(&self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
self.entries.get(key).map(|entry| &entry.value)
}
pub(crate) fn contains_key<Q>(&self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
self.entries.contains_key(key)
}
/// Mark an entry as just used, so it is the last to be evicted. Returns
/// whether it was there.
pub(crate) fn touch<Q>(&mut self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
let stamp = self.next;
let Some(entry) = self.entries.get_mut(key) else {
return false;
};
if let Some(held) = self.order.remove(&entry.stamp) {
self.order.insert(stamp, held);
}
entry.stamp = stamp;
self.next += 1;
true
}
/// Look an entry up and mark it used.
pub(crate) fn fetch<Q>(&mut self, key: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
if !self.touch(key) {
return None;
}
self.get(key)
}
/// Store `value` as the most recently used entry, then evict the least
/// recently used ones until the total cost fits the budget again. The new
/// entry itself is never evicted, even when it alone is over budget.
pub(crate) fn insert(&mut self, key: K, value: V, cost: usize) {
self.remove(&key);
let stamp = self.next;
self.next += 1;
self.order.insert(stamp, key.clone());
self.entries.insert(key, Entry { value, cost, stamp });
self.used += cost;
while self.used > self.budget && self.order.len() > 1 {
let Some((_, oldest)) = self.order.pop_first() else {
break;
};
if let Some(entry) = self.entries.remove(&oldest) {
self.used -= entry.cost;
}
}
}
pub(crate) fn remove<Q>(&mut self, key: &Q) -> Option<V>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
let entry = self.entries.remove(key)?;
self.order.remove(&entry.stamp);
self.used -= entry.cost;
Some(entry.value)
}
/// Keep only the entries `keep` accepts.
pub(crate) fn retain(&mut self, mut keep: impl FnMut(&K, &V) -> bool) {
let order = &mut self.order;
let used = &mut self.used;
self.entries.retain(|key, entry| {
let kept = keep(key, &entry.value);
if !kept {
order.remove(&entry.stamp);
*used -= entry.cost;
}
kept
});
}
pub(crate) fn clear(&mut self) {
self.entries.clear();
self.order.clear();
self.used = 0;
}
#[cfg(test)]
pub(crate) fn len(&self) -> usize {
self.entries.len()
}
#[cfg(test)]
pub(crate) fn used(&self) -> usize {
self.used
}
}
#[cfg(test)]
mod tests {
use super::Lru;
#[test]
fn evicts_least_recently_used_past_budget() {
let mut cache = Lru::new(3);
cache.insert("a", 1, 1);
cache.insert("b", 2, 1);
cache.insert("c", 3, 1);
assert!(cache.touch("a"));
cache.insert("d", 4, 1);
assert!(cache.contains_key("a"));
assert!(!cache.contains_key("b"));
assert!(cache.contains_key("c"));
assert!(cache.contains_key("d"));
assert_eq!(cache.len(), 3);
}
#[test]
fn budget_counts_cost_not_entries() {
let mut cache = Lru::new(100);
cache.insert("small", (), 10);
cache.insert("medium", (), 40);
cache.insert("large", (), 60);
// 110 > 100: the oldest goes, and that is enough.
assert!(!cache.contains_key("small"));
assert_eq!(cache.used(), 100);
cache.insert("huge", (), 90);
assert_eq!(cache.used(), 90);
assert_eq!(cache.len(), 1);
}
#[test]
fn keeps_a_single_entry_over_budget() {
let mut cache = Lru::new(10);
cache.insert("a", (), 5);
cache.insert("big", (), 50);
assert!(cache.contains_key("big"));
assert!(!cache.contains_key("a"));
assert_eq!(cache.used(), 50);
}
#[test]
fn remove_and_clear_keep_cost_in_step() {
let mut cache = Lru::new(100);
cache.insert("a", (), 10);
cache.insert("b", (), 20);
assert_eq!(cache.remove("a"), Some(()));
assert_eq!(cache.used(), 20);
cache.clear();
assert_eq!(cache.used(), 0);
assert_eq!(cache.len(), 0);
}
#[test]
fn reinsert_replaces_cost_and_refreshes() {
let mut cache = Lru::new(30);
cache.insert("a", 1, 10);
cache.insert("b", 2, 10);
cache.insert("a", 3, 15);
assert_eq!(cache.used(), 25);
assert_eq!(cache.get("a"), Some(&3));
cache.insert("c", 4, 10);
// "b" was used longest ago now.
assert!(!cache.contains_key("b"));
assert!(cache.contains_key("a"));
}
#[test]
fn fetch_touches_and_get_does_not() {
let mut cache = Lru::new(2);
cache.insert("a", 1, 1);
cache.insert("b", 2, 1);
assert_eq!(cache.get("a"), Some(&1));
cache.insert("c", 3, 1);
assert!(!cache.contains_key("a"));
assert_eq!(cache.fetch("b"), Some(&2));
cache.insert("d", 4, 1);
assert!(cache.contains_key("b"));
assert!(!cache.contains_key("c"));
assert_eq!(cache.fetch("missing"), None);
}
#[test]
fn retain_drops_rejected_entries_and_their_cost() {
let mut cache = Lru::new(100);
cache.insert((true, "a".to_string()), (), 10);
cache.insert((false, "b".to_string()), (), 20);
cache.insert((true, "c".to_string()), (), 30);
cache.retain(|(private, _), _| !private);
assert_eq!(cache.used(), 20);
assert_eq!(cache.len(), 1);
assert!(cache.remove(&(false, "b".to_string())).is_some());
assert_eq!(cache.used(), 0);
cache.insert((true, "d".to_string()), (), 10);
cache.clear();
assert_eq!(cache.used(), 0);
assert_eq!(cache.len(), 0);
}
}
+21 -23
View File
@@ -6,7 +6,6 @@ pub(crate) mod dates;
pub(crate) mod events;
#[path = "../i18n.rs"]
pub(crate) mod i18n;
pub(crate) mod lru;
pub(crate) mod pages;
pub(crate) mod reload;
#[path = "../theme.rs"]
@@ -16,7 +15,6 @@ pub(crate) mod widgets;
use compat::*;
use events::*;
use lru::Lru;
use pages::activity::*;
use pages::albums::*;
use pages::browser::*;
@@ -192,11 +190,16 @@ impl Ui {
/// Scrolling back over a day then repaints from memory rather than decoding
/// the same JPEGs off disk again.
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
let bytes = texture_bytes(texture.width(), texture.height());
self.gallery
.photo_tex
.borrow_mut()
.insert(uid.to_string(), texture, bytes);
let mut cache = self.gallery.photo_tex.borrow_mut();
let mut order = self.gallery.photo_tex_order.borrow_mut();
if cache.insert(uid.to_string(), texture).is_none() {
order.push_back(uid.to_string());
}
while order.len() > TEXTURE_CACHE_MAX {
if let Some(old) = order.pop_front() {
cache.remove(&old);
}
}
}
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles
@@ -205,7 +208,14 @@ impl Ui {
/// Insertion order alone evicts the top of the timeline first — exactly what
/// a scroll back up then asks for again.
fn touch_texture(&self, uid: &str) {
self.gallery.photo_tex.borrow_mut().touch(uid);
let mut order = self.gallery.photo_tex_order.borrow_mut();
if order.back().is_some_and(|back| back == uid) {
return;
}
if let Some(at) = order.iter().position(|held| held == uid) {
order.remove(at);
order.push_back(uid.to_string());
}
}
}
@@ -547,13 +557,6 @@ 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(),
@@ -628,7 +631,8 @@ fn build_window(app: &adw::Application) {
library: Cell::new(true),
page_waiters: RefCell::new(Vec::new()),
width: Cell::new(0),
photo_tex: RefCell::new(Lru::new(TEXTURE_CACHE_BYTES)),
photo_tex: RefCell::new(HashMap::new()),
photo_tex_order: RefCell::new(VecDeque::new()),
photo_nothumb: RefCell::new(HashSet::new()),
thumb_wanted: RefCell::new(HashMap::new()),
thumb_queue: RefCell::new(VecDeque::new()),
@@ -636,7 +640,6 @@ fn build_window(app: &adw::Application) {
thumb_generation: Cell::new(0),
decode_queue: RefCell::new(VecDeque::new()),
decode_idle: Cell::new(false),
decode_inflight: RefCell::default(),
thumb_source: RefCell::new(None),
relayout_source: RefCell::new(None),
bound: RefCell::new(BTreeMap::new()),
@@ -649,7 +652,6 @@ fn build_window(app: &adw::Application) {
select_btn: gallery_widgets.select_btn.clone(),
selection: gallery_widgets.selection.clone(),
more: gallery_widgets.more.clone(),
gallery_actions: gallery_widgets.gallery_actions.clone(),
upload_face: gallery_widgets.upload_face.clone(),
float_heading: gallery_widgets.float_heading.clone(),
float_label: gallery_widgets.float_label.clone(),
@@ -735,10 +737,6 @@ fn build_window(app: &adw::Application) {
resume_button: takeout_widgets.resume_button.clone(),
inflight: Cell::new(false),
running: Cell::new(false),
restored: Cell::new(false),
save_seq: Cell::new(0),
saved_seq: Default::default(),
repaint_seq: Cell::new(0),
},
update,
});
@@ -1483,7 +1481,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, water and borders, which are in the public domain.",
"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.",
)),
);
dialog.add_legal_section(
-2
View File
@@ -3185,7 +3185,6 @@ 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();
@@ -3250,7 +3249,6 @@ mod tests {
shared_by_unverified: false,
trashed_at: 0,
trashed_from: None,
trashed_parent: None,
issue: None,
}
}
+40 -116
View File
@@ -1,32 +1,10 @@
use crate::*;
use base64::{Engine, engine::general_purpose::STANDARD};
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
use std::collections::VecDeque;
const PAGE: usize = 150;
/// Decoded thumbnails kept, the least recently shown dropped first.
const THUMB_CACHE: usize = 256;
/// What a new content width asks of the rows.
#[derive(Debug, PartialEq, Eq)]
enum Reflow {
/// Nothing changed, or there is no width yet.
None,
/// The first real width: lay the rows out now, nothing is on screen yet.
Now,
/// A resize: wait for it to settle, since the rows are rebuilt from
/// scratch and a drag resizes on every frame.
Debounced,
}
fn reflow_for(previous: i32, width: i32) -> Reflow {
if width <= 0 || width == previous {
Reflow::None
} else if previous <= 0 {
Reflow::Now
} else {
Reflow::Debounced
}
}
type ThumbnailKey = (u64, bool, String);
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
@@ -67,15 +45,12 @@ pub(crate) struct Browser {
albums: RefCell<Vec<GalleryAlbum>>,
items: RefCell<Vec<PhotoItem>>,
width: Cell<i32>,
/// The pending re-flow after a resize, replaced by each new width.
reflow: RefCell<Option<glib::SourceId>>,
generation: Cell<u64>,
total: Cell<usize>,
loading: Cell<bool>,
unlocked: Cell<bool>,
thumbnail_slots: tokio::sync::Semaphore,
/// Decoded thumbnails by whether they are hidden-album ones and uid.
thumbnails: RefCell<Lru<(bool, String), gtk4::gdk::Texture>>,
thumbnails: RefCell<VecDeque<(bool, String, gtk4::gdk::Texture)>>,
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
}
@@ -111,7 +86,7 @@ impl Browser {
}
self.thumbnails
.borrow_mut()
.retain(|(private, _), _| !private);
.retain(|(private, _, _)| !private);
self.thumb_pending.borrow_mut().clear();
self.trail.borrow_mut().clear();
self.chooser.borrow_mut().take();
@@ -577,7 +552,7 @@ impl Browser {
if self.chooser.borrow().is_some() {
return;
}
let width = self.width.get().max(240);
let width = (self.width.get() - 24).max(240);
let columns = ((width + 8) / 216).max(1);
let card = (width - 8 * (columns - 1)) / columns;
let mut rows = Vec::new();
@@ -627,13 +602,6 @@ impl Browser {
let generation = self.generation.get();
glib::spawn_future_local(async move {
let result = reply.recv().await;
// Decoded before the checks below, so they see the state after it.
let decoded = match &result {
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
decode_thumbnail_off_thread(data.clone()).await
}
_ => None,
};
let close = |token| {
let _ = spawn_request(
browser.ui.dirs.control_socket(),
@@ -678,8 +646,8 @@ impl Browser {
picture.set_vexpand(true);
content.append(&picture);
}
Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => {
let Some(texture) = decoded else {
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
let Some(texture) = decode_thumbnail(&data) else {
browser
.status
.set_label(&gettext("Couldn't open the photo."));
@@ -715,15 +683,13 @@ pub(crate) fn wire(
hidden: &gtk4::Button,
) {
let title = ui.gallery.title.clone();
// The page's header bar holds these, beside Select (see `sync_header`).
let header = &ui.gallery.gallery_actions;
let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
header.set_halign(gtk4::Align::End);
let choose = gtk4::Button::with_label(&gettext("Add This Folder"));
choose.set_visible(false);
choose.add_css_class("suggested-action");
header.append(&choose);
let more = gtk4::Button::from_icon_name("view-more-symbolic");
more.set_tooltip_text(Some(&gettext("Gallery Options")));
more.add_css_class("flat");
let unlock = gtk4::Button::with_label(&gettext("Unlock"));
unlock.set_visible(false);
header.append(&unlock);
@@ -743,6 +709,7 @@ pub(crate) fn wire(
let status = gtk4::Label::new(None);
status.set_wrap(true);
let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
content.append(&header);
content.append(&status);
content.append(&scroll);
ui.gallery
@@ -776,13 +743,12 @@ pub(crate) fn wire(
albums: RefCell::new(Vec::new()),
items: RefCell::new(Vec::new()),
width: Cell::new(0),
reflow: RefCell::new(None),
generation: Cell::new(0),
total: Cell::new(0),
loading: Cell::new(false),
unlocked: Cell::new(false),
thumbnail_slots: tokio::sync::Semaphore::new(8),
thumbnails: RefCell::new(Lru::new(THUMB_CACHE)),
thumbnails: RefCell::default(),
thumb_pending: RefCell::default(),
});
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
@@ -828,13 +794,12 @@ pub(crate) fn wire(
return;
};
let row = data.borrow::<Row>();
// The page around the list already keeps its margins, so rows run edge
// to edge like the timeline's.
let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
line.set_margin_start(12);
line.set_margin_end(12);
line.set_margin_bottom(8);
match &*row {
Row::Heading(label) => {
line.set_margin_top(12);
let label = gtk4::Label::new(Some(label));
label.add_css_class("heading");
line.append(&label);
@@ -876,9 +841,7 @@ pub(crate) fn wire(
}
}
Row::Media(items) => {
// The same gap down as across, as in the timeline.
line.set_spacing(super::photos::TILE_GAP);
line.set_margin_bottom(super::photos::TILE_GAP);
for (item, (width, height)) in items {
let button = tile(
&browser,
@@ -955,6 +918,11 @@ pub(crate) fn wire(
let browser = browser.clone();
move || browser.close()
});
} else {
menu.item(&gettext("Refresh galleries"), {
let browser = browser.clone();
move || browser.change(GalleryAction::Refresh)
});
}
if let Some(album) = browser.current().filter(|album| !album.proton) {
menu.item(&gettext("Choose Cover"), {
@@ -1032,27 +1000,8 @@ pub(crate) fn wire(
return glib::ControlFlow::Break;
};
let width = scroll.width();
match reflow_for(browser.width.get(), width) {
Reflow::None => {}
Reflow::Now => {
browser.width.set(width);
browser.rebuild();
}
Reflow::Debounced => {
browser.width.set(width);
if let Some(source) = browser.reflow.borrow_mut().take() {
source.remove();
}
let weak = Rc::downgrade(&browser);
let source =
glib::timeout_add_local_once(super::photos::RELAYOUT_DEBOUNCE, move || {
if let Some(browser) = weak.upgrade() {
browser.reflow.borrow_mut().take();
browser.rebuild();
}
});
*browser.reflow.borrow_mut() = Some(source);
}
if width > 0 && browser.width.replace(width) != width {
browser.rebuild();
}
glib::ControlFlow::Continue
}
@@ -1140,15 +1089,6 @@ fn decode_thumbnail(data: &str) -> Option<gtk4::gdk::Texture> {
gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok()
}
/// [`decode_thumbnail`] on gio's blocking pool, so neither the base64 nor the
/// image decoder runs on the GTK thread.
async fn decode_thumbnail_off_thread(data: String) -> Option<gtk4::gdk::Texture> {
gio::spawn_blocking(move || decode_thumbnail(&data))
.await
.ok()
.flatten()
}
impl Browser {
fn want_thumbnail(
self: &Rc<Self>,
@@ -1160,17 +1100,20 @@ impl Browser {
if private && !self.unlocked.get() {
return;
}
let cached = self
.thumbnails
.borrow_mut()
.fetch(&(private, uid.to_owned()))
.cloned();
if let Some(texture) = cached {
picture.set_paintable(Some(&texture));
if let Some(icon) = icon.upgrade() {
icon.set_visible(false);
{
let mut cache = self.thumbnails.borrow_mut();
if let Some(index) = cache
.iter()
.position(|(p, id, _)| *p == private && id == uid)
{
let cached = cache.remove(index).unwrap();
picture.set_paintable(Some(&cached.2));
if let Some(icon) = icon.upgrade() {
icon.set_visible(false);
}
cache.push_back(cached);
return;
}
return;
}
let key = (self.generation.get(), private, uid.to_owned());
{
@@ -1209,12 +1152,6 @@ impl Browser {
},
);
let response = request.recv().await;
let texture = match response {
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) => {
decode_thumbnail_off_thread(data).await
}
_ => None,
};
let targets = browser
.thumb_pending
.borrow_mut()
@@ -1223,7 +1160,9 @@ impl Browser {
if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
return;
}
if let Some(texture) = texture {
if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response
&& let Some(texture) = decode_thumbnail(&data)
{
for (picture, icon) in targets {
if let Some(picture) = picture.upgrade() {
picture.set_paintable(Some(&texture));
@@ -1232,27 +1171,12 @@ impl Browser {
icon.set_visible(false);
}
}
// Capped by count, like before: every entry costs one.
browser
.thumbnails
.borrow_mut()
.insert((private, key.2), texture, 1);
let mut cache = browser.thumbnails.borrow_mut();
if cache.len() >= THUMB_CACHE {
cache.pop_front();
}
cache.push_back((private, key.2, texture));
}
});
}
}
#[cfg(test)]
mod tests {
use super::{Reflow, reflow_for};
#[test]
fn the_first_width_lays_out_at_once_and_a_resize_waits() {
assert_eq!(reflow_for(0, 0), Reflow::None);
assert_eq!(reflow_for(0, 800), Reflow::Now);
assert_eq!(reflow_for(800, 800), Reflow::None);
assert_eq!(reflow_for(800, 760), Reflow::Debounced);
// A collapsed widget reports no width; keep the last layout.
assert_eq!(reflow_for(800, 0), Reflow::None);
}
}
+3 -39
View File
@@ -336,9 +336,6 @@ pub(crate) fn login_error_message(error: &pdfs_core::Error) -> String {
pdfs_core::Error::WrongMailboxPassword => {
gettext("That mailbox password didn't unlock your account.")
}
pdfs_core::Error::SecurityKeyOnly => gettext(
"This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code.",
),
pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
),
@@ -675,45 +672,15 @@ 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?"),
&body,
&gettext(
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
),
&gettext("Sign Out"),
move || {
let galleries = ui.drive_galleries.borrow().upgrade();
@@ -744,9 +711,6 @@ mod tests {
#[test]
fn a_cancelled_prompt_says_which_step_was_skipped() {
assert!(
login_error_message(&pdfs_core::Error::SecurityKeyOnly).contains("authenticator app")
);
let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
assert!(login_error_message(&totp).contains("two-factor code"));
let hv = pdfs_core::Error::Other("verification cancelled".into());
+22 -211
View File
@@ -1,12 +1,7 @@
//! 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 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 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
@@ -25,17 +20,9 @@ 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";
@@ -267,20 +254,8 @@ struct Job {
dark: bool,
}
/// 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.
/// The worker thread making tiles. Dropping it stops the thread once the
/// fetches under way are done.
pub(crate) struct Tiles {
jobs: async_channel::Sender<Job>,
wanted: Arc<Mutex<HashSet<TileKey>>>,
@@ -289,35 +264,27 @@ pub(crate) struct Tiles {
}
impl Tiles {
/// 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>) {
/// 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>) {
let (jobs, job_rx) = async_channel::unbounded();
let (done_tx, done_rx) = async_channel::unbounded();
let wanted = Arc::new(Mutex::new(HashSet::new()));
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 worker = Worker {
dir: cache_dir,
language,
scale,
wanted: wanted.clone(),
done: 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}");
}
@@ -496,126 +463,6 @@ 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()?;
@@ -976,42 +823,6 @@ 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 {
+70 -146
View File
@@ -160,10 +160,11 @@ pub(crate) struct GalleryState {
/// Content width the grid is currently laid out to. Updated when the
/// ListView is resized, which re-flows the visible sections.
pub(crate) width: Cell<i32>,
/// Decoded thumbnails by photo uid, the least recently used evicted once
/// their pixels pass [`TEXTURE_CACHE_BYTES`]. Scrolling back over a day
/// therefore repaints from memory instead of re-decoding from disk.
pub(crate) photo_tex: RefCell<Lru<String, gtk4::gdk::Texture>>,
/// Decoded thumbnails by photo uid, with the insertion order that evicts the
/// oldest past [`TEXTURE_CACHE_MAX`]. Scrolling back over a day therefore
/// repaints from memory instead of re-decoding from disk.
pub(crate) photo_tex: RefCell<HashMap<String, gtk4::gdk::Texture>>,
pub(crate) photo_tex_order: RefCell<VecDeque<String>>,
/// Photos the daemon reported as having no thumbnail at all, so a tile that
/// can never be filled isn't requested again on every scroll past it.
pub(crate) photo_nothumb: RefCell<HashSet<String>>,
@@ -185,14 +186,12 @@ pub(crate) struct GalleryState {
pub(crate) thumb_inflight: RefCell<HashSet<String>>,
pub(crate) thumb_generation: Cell<u64>,
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`.
/// [`schedule_decode`] decodes them on worker threads a few at a time, so
/// the scroll never waits on a JPEG decoder. [`Self::decode_idle`] is the
/// "decoder already running" guard, and [`Self::decode_inflight`] the uids
/// being decoded right now, so a tile rebound meanwhile doesn't queue its
/// photo a second time.
/// Decoding happens on the GTK thread (textures are not `Send`), so it is fed
/// a few at a time from an idle callback rather than in one blocking burst
/// that would stutter the scroll. [`Self::decode_idle`] is the "callback
/// already scheduled" guard.
pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>,
pub(crate) decode_idle: Cell<bool>,
pub(crate) decode_inflight: RefCell<HashSet<String>>,
/// Pending debounce timers for the thumbnail queue flush and the section
/// re-flow, replaced on each new trigger so only the last one fires.
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>,
@@ -226,9 +225,6 @@ pub(crate) struct GalleryState {
/// The header's page menu and the Upload button's face, which drops its
/// label in a narrow window.
pub(crate) more: gtk4::MenuButton,
/// The header's end slot for an open Drive gallery's own buttons (Add
/// This Folder, Unlock, options), filled by the Drive gallery browser.
pub(crate) gallery_actions: gtk4::Box,
pub(crate) upload_face: adw::ButtonContent,
/// The section the top of the timeline is in, floating over the grid
/// once its own heading has scrolled away.
@@ -352,23 +348,11 @@ pub(crate) const THUMB_DEBOUNCE: Duration = Duration::from_millis(60);
/// in seconds, not milliseconds.
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
/// Decoded thumbnail pixels held in memory, evicted least-recently-*used*
/// first. Budgeted by bytes rather than by count, because one oversized
/// thumbnail costs as much as dozens of ordinary ones. A 512 px thumbnail is
/// about 600 KiB decoded, so this holds roughly 900 of them: at the justified
/// row density 600 was under two screens' worth, and a scroll down and back up
/// then had to re-fetch and re-decode everything it had just shown.
pub(crate) const TEXTURE_CACHE_BYTES: usize = 512 * 1024 * 1024;
/// What a decoded texture costs [`TEXTURE_CACHE_BYTES`]: four bytes a pixel.
pub(crate) fn texture_bytes(width: i32, height: i32) -> usize {
let width = usize::try_from(width).unwrap_or(0);
let height = usize::try_from(height).unwrap_or(0);
width.saturating_mul(height).saturating_mul(4).max(1)
}
/// How many thumbnails [`schedule_decode`] decodes at once.
const DECODE_BATCH: usize = 4;
/// Decoded thumbnails held in memory, evicted least-recently-*used* first. Each
/// is a few hundred KiB of GPU texture, and at the justified row density 600 was
/// under two screens' worth — a scroll down and back up then had to re-fetch and
/// re-decode everything it had just shown.
pub(crate) const TEXTURE_CACHE_MAX: usize = 1500;
/// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
/// is decoded before it is scrolled onto rather than after.
@@ -540,7 +524,6 @@ pub(crate) struct GalleryWidgets {
pub(crate) select_btn: gtk4::Button,
pub(crate) selection: SelectionBar,
pub(crate) more: gtk4::MenuButton,
pub(crate) gallery_actions: gtk4::Box,
pub(crate) upload_face: adw::ButtonContent,
pub(crate) float_heading: gtk4::Revealer,
pub(crate) float_label: gtk4::Label,
@@ -711,12 +694,6 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
.build();
more.add_css_class("flat");
// An open Drive gallery's own buttons live in the header too, not in a row
// of their own above its grid: that row took height from the photos and
// left its button touching the first row of tiles.
let gallery_actions = gtk4::Box::new(gtk4::Orientation::Horizontal, 6);
gallery_actions.set_visible(false);
// Picking photos is a mode: the button enters it, and the header then
// trades the page's own controls for Cancel and a count, as GNOME apps do.
let select_btn = gtk4::Button::builder()
@@ -1025,7 +1002,6 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
header.pack_start(&back);
header.pack_start(&upload);
header.pack_end(&more);
header.pack_end(&gallery_actions);
header.pack_end(&select_btn);
header.pack_end(&selection.cancel);
@@ -1055,7 +1031,6 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
select_btn,
selection,
more,
gallery_actions,
upload_face,
float_heading,
float_label,
@@ -1166,7 +1141,6 @@ pub(crate) fn sync_header(ui: &Rc<Ui>) {
gallery.back.set_visible(!selecting && collection);
gallery.upload.set_visible(!selecting && !collection);
gallery.more.set_visible(!selecting && !galleries);
gallery.gallery_actions.set_visible(!selecting && galleries);
gallery.select_btn.set_visible(!selecting && timeline);
gallery.selection.title.set_visible(selecting);
gallery.selection.cancel.set_visible(selecting);
@@ -3273,7 +3247,6 @@ pub(crate) fn want_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: &gtk4::Picture
let mut decode = ui.gallery.decode_queue.borrow_mut();
if decode.iter().any(|(uid, _)| uid == &photo.uid)
|| ui.gallery.decode_inflight.borrow().contains(&photo.uid)
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
{
return;
@@ -3465,16 +3438,9 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
batch
}
/// Decode queued thumbnails into textures on worker threads, a few at a time,
/// and hand each finished texture to the tiles still waiting for it.
///
/// Decoding a JPEG takes milliseconds; four of them per idle pass on the GTK
/// thread were enough to stutter a scroll. The main thread now only picks the
/// next batch (visible tiles first) and paints what comes back. A batch that
/// lands after the timeline was reset is dropped, and a tile that was rebound
/// or unbound meanwhile is no longer in [`GalleryState::thumb_wanted`], so it
/// is not painted. [`GalleryState::decode_idle`] is the "decoder running"
/// guard.
/// Decode queued thumbnails into textures on an idle callback, a few per pass, so
/// a big batch fills in progressively instead of freezing the scroll for the
/// length of the whole decode.
pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
return;
@@ -3482,93 +3448,61 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
ui.gallery.decode_idle.set(true);
let ui = ui.clone();
glib::spawn_future_local(async move {
loop {
let batch = next_decode_batch(&ui);
if batch.is_empty() {
break;
}
let generation = ui.gallery.thumb_generation.get();
ui.gallery
.decode_inflight
.borrow_mut()
.extend(batch.iter().map(|(uid, _)| uid.clone()));
// All of the batch decodes at once, on the worker pool; the results
// are collected in the order they were picked.
let jobs: Vec<_> = batch
.into_iter()
.map(|(uid, path)| {
let job = gio::spawn_blocking({
let path = path.clone();
move || gtk4::gdk::Texture::from_filename(&path)
});
(uid, path, job)
glib::idle_add_local(move || {
let batch: Vec<(String, String)> = {
let mut queue = ui.gallery.decode_queue.borrow_mut();
let wanted = ui.gallery.thumb_wanted.borrow();
let list = &ui.gallery.list;
let visible = |uid: &str| {
wanted.get(uid).is_some_and(|pictures| {
pictures.iter().any(|picture| {
if !picture.is_mapped() {
return false;
}
!picture.is_ancestor(list)
|| picture.compute_bounds(list).is_some_and(|bounds| {
bounds.y() + bounds.height() > 0.0
&& bounds.y() < list.height() as f32
})
})
})
.collect();
for (uid, path, job) in jobs {
let decoded = job.await;
ui.gallery.decode_inflight.borrow_mut().remove(&uid);
if generation != ui.gallery.thumb_generation.get() {
};
queue.retain(|(uid, _)| wanted.contains_key(uid));
(0..4)
.filter_map(|_| {
queue
.iter()
.position(|(uid, _)| visible(uid))
.and_then(|index| queue.remove(index))
.or_else(|| queue.pop_front())
})
.collect()
};
for (uid, path) in batch {
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
continue;
}
let texture = match gtk4::gdk::Texture::from_filename(&path) {
Ok(texture) => texture,
Err(e) => {
tracing::debug!("cannot decode thumbnail {path}: {e}");
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
continue;
}
let texture = match decoded {
Ok(Ok(texture)) => texture,
Ok(Err(e)) => {
tracing::debug!("cannot decode thumbnail {path}: {e}");
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
continue;
}
Err(_) => {
tracing::debug!("thumbnail decoder for {path} panicked");
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
continue;
}
};
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
continue;
}
ui.store_texture(&uid, texture.clone());
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
for picture in waiting.into_iter().flatten() {
picture.set_paintable(Some(&texture));
}
};
ui.store_texture(&uid, texture.clone());
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
for picture in waiting.into_iter().flatten() {
picture.set_paintable(Some(&texture));
}
}
ui.gallery.decode_idle.set(false);
});
}
/// Take the next few thumbnails to decode off the queue: the ones on screen
/// first, then in queue order, skipping tiles nobody waits for any more and
/// photos already decoded.
fn next_decode_batch(ui: &Rc<Ui>) -> Vec<(String, String)> {
let mut queue = ui.gallery.decode_queue.borrow_mut();
let wanted = ui.gallery.thumb_wanted.borrow();
let cached = ui.gallery.photo_tex.borrow();
let list = &ui.gallery.list;
let visible = |uid: &str| {
wanted.get(uid).is_some_and(|pictures| {
pictures.iter().any(|picture| {
if !picture.is_mapped() {
return false;
}
!picture.is_ancestor(list)
|| picture.compute_bounds(list).is_some_and(|bounds| {
bounds.y() + bounds.height() > 0.0 && bounds.y() < list.height() as f32
})
})
})
};
queue.retain(|(uid, _)| wanted.contains_key(uid) && !cached.contains_key(uid));
(0..DECODE_BATCH)
.filter_map(|_| {
queue
.iter()
.position(|(uid, _)| visible(uid))
.and_then(|index| queue.remove(index))
.or_else(|| queue.pop_front())
})
.collect()
if ui.gallery.decode_queue.borrow().is_empty() {
ui.gallery.decode_idle.set(false);
return glib::ControlFlow::Break;
}
glib::ControlFlow::Continue
});
}
/// Re-flow the sections on screen shortly. Debounced, because the triggers (a
@@ -4840,23 +4774,13 @@ pub(crate) fn gallery_unreachable(ui: &Rc<Ui>) {
#[cfg(test)]
mod tests {
use super::{
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TEXTURE_CACHE_BYTES,
TILE_GAP, TILE_RATIO_MAX, TILE_RATIO_MIN, active_filters, copy_without_overwrite,
empty_timeline_text, grouping_for, memory_years, month_index, month_range, plan_grid,
plan_justified, section_heading, texture_bytes, tile_ratio, viewport_unfilled,
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TILE_GAP, TILE_RATIO_MAX,
TILE_RATIO_MIN, active_filters, copy_without_overwrite, empty_timeline_text, grouping_for,
memory_years, month_index, month_range, plan_grid, plan_justified, section_heading,
tile_ratio, viewport_unfilled,
};
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth};
#[test]
fn the_texture_cache_is_budgeted_by_decoded_pixels() {
assert_eq!(texture_bytes(512, 384), 512 * 384 * 4);
// A broken size still costs something, so it can't pile up for free.
assert_eq!(texture_bytes(0, 512), 1);
assert_eq!(texture_bytes(-1, -1), 1);
// Ordinary thumbnails: well over two dense screens' worth fit.
assert!(TEXTURE_CACHE_BYTES / texture_bytes(512, 384) >= 600);
}
#[test]
fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
+130 -185
View File
@@ -2,13 +2,13 @@
//! their newest photo, and once the map is zoomed in close, each photo where
//! it was taken.
//!
//! Underneath are up to two maps. The outline is drawn here from Natural
//! Underneath is one of two maps. The built-in one 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`, 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.
//! `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.
//!
//! 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
@@ -17,8 +17,6 @@
//! a single photo opens it in its town, and photos taken on one spot, which
//! never part, are listed to pick from.
// Markers merge the same way in every Proton gallery app.
use proton_gallery_rs::places::{Bubble, bubble_radius, cluster, compact_count};
use std::collections::{HashMap, HashSet};
use std::path::PathBuf;
use std::sync::OnceLock;
@@ -27,7 +25,7 @@ use std::time::{Duration, Instant};
use gtk4::cairo;
use pdfs_core::control::PhotoLocation;
use super::map_tiles::{self, Done, Label, LabelClass, Palette, Source, TILE_EDGE, TileKey, Tiles};
use super::map_tiles::{self, Done, Label, LabelClass, Palette, TILE_EDGE, TileKey, Tiles};
use crate::*;
const LAND: &str = include_str!("../../../data/land.txt");
@@ -37,8 +35,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 outline and the
/// basemap, and down to single streets on the street map.
/// widget: far enough for photos in one town to part on the built-in map,
/// and down to single streets on the street map.
const MAX_ZOOM: f64 = 8192.0;
const ONLINE_MAX_ZOOM: f64 = 65536.0;
@@ -66,14 +64,9 @@ 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 map tiles stay in memory.
/// How many street-map tiles stay in memory.
const TILE_CACHE: usize = 160;
/// Photo marker covers kept, 64 KiB each. A town's own cover is never
/// dropped (it only arrives with the town's card), but the photos zoomed past
/// one by one would otherwise pile up for as long as the map is open.
const COVER_CACHE: usize = 1024;
/// How long a tile that couldn't be had is left alone before it is tried
/// again.
const TILE_RETRY: Duration = Duration::from_secs(60);
@@ -139,6 +132,13 @@ fn parse_ring(line: &str) -> Option<Ring> {
Some(Ring { points, min, max })
}
/// Radius in px of a marker holding `photos` photos: big enough to make the
/// photo out, and growing with the count, but slowly, so a home town with
/// thousands doesn't cover a continent.
fn bubble_radius(photos: usize) -> f64 {
18.0 + 2.0 * (photos.max(1) as f64).ln()
}
/// What the map shows: which part of the world, at what size.
#[derive(Clone, Copy, Debug)]
struct View {
@@ -190,7 +190,18 @@ struct Marker {
target: Target,
}
/// A map tile ready to draw, and the names on it.
/// One marker as last drawn, standing for one or more [`Marker`]s: where, how
/// big, and which (indices into [`MapState::markers`], the one with the most
/// photos first).
struct Bubble {
x: f64,
y: f64,
radius: f64,
photos: usize,
members: Vec<usize>,
}
/// A street-map tile ready to draw, and the names on it.
struct CachedTile {
surface: cairo::ImageSurface,
labels: Rc<Vec<Label>>,
@@ -198,11 +209,9 @@ struct CachedTile {
used: u64,
}
/// The tiles drawn over the outline, from the basemap or the street map.
struct TileLayer {
/// The street map, while it is turned on.
struct Online {
tiles: Tiles,
/// Whether they come from the street map.
online: bool,
cache: HashMap<TileKey, CachedTile>,
pending: HashSet<TileKey>,
failed: HashMap<TileKey, Instant>,
@@ -223,11 +232,8 @@ struct MapState {
/// for from close up.
locations: HashMap<u32, Vec<(PhotoItem, World)>>,
asked_locations: HashSet<u32>,
/// Marker photos, scaled and cropped to a square, by photo uid, with the
/// draw they were last shown in.
covers: HashMap<String, (cairo::ImageSurface, u64)>,
/// Counts draws, for dropping the covers shown longest ago.
draws: u64,
/// Marker photos, scaled and cropped to a square, by photo uid.
covers: HashMap<String, cairo::ImageSurface>,
asked_thumbs: HashSet<String>,
view: View,
/// False until the view has been fitted to the places at a real size, and
@@ -241,11 +247,7 @@ struct MapState {
drag_origin: Option<View>,
/// The scale a pinch started from.
pinch_origin: Option<View>,
tiles: Option<TileLayer>,
/// Whether the street map is turned on in Preferences.
street_map: bool,
/// The installed basemap, if any.
basemap: Option<PathBuf>,
online: Option<Online>,
cache_dir: Option<PathBuf>,
/// The spot [`PlacesMap::show_spot`] went to, ringed until the map is
/// fitted to all places again.
@@ -301,11 +303,32 @@ 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");
@@ -326,7 +349,6 @@ impl PlacesMap {
locations: HashMap::new(),
asked_locations: HashSet::new(),
covers: HashMap::new(),
draws: 0,
asked_thumbs: HashSet::new(),
view: View {
center: World { x: 0.5, y: 0.5 },
@@ -339,9 +361,7 @@ impl PlacesMap {
pointer: (0.0, 0.0),
drag_origin: None,
pinch_origin: None,
tiles: None,
street_map: false,
basemap: map_tiles::find_basemap(),
online: None,
cache_dir: None,
pin: None,
}),
@@ -466,68 +486,43 @@ impl PlacesMap {
let Some(cover) = square_cover(texture) else {
return;
};
let mut state = self.state.borrow_mut();
let state = &mut *state;
state.covers.insert(uid.to_owned(), (cover, state.draws));
let towns: HashSet<&str> = state
.places
.iter()
.map(|(place, _)| place.cover.uid.as_str())
.collect();
for dropped in evict_covers(&mut state.covers, &towns, state.draws) {
// Asked for again once it is back on screen.
state.asked_thumbs.remove(&dropped);
}
self.state.borrow_mut().covers.insert(uid.to_owned(), cover);
self.area.queue_draw();
}
/// Draw OpenFreeMap's street map under the markers, keeping its tiles in
/// `cache_dir`, or else the installed basemap.
/// Draw OpenFreeMap's street map under the markers, or stop, keeping its
/// tiles in `cache_dir`.
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);
let started = state.tiles.is_some() || state.basemap.is_none();
if on == state.street_map && started {
if on == state.online.is_some() {
return;
}
state.street_map = on;
state.tiles = None;
state.online = None;
}
self.credit.set_visible(on);
if on {
self.start_tiles();
}
self.start_tiles();
self.clamp_zoom();
self.area.queue_draw();
}
/// Start a tile worker for the widget's current pixel density, and show
/// the credit for what it draws.
/// Start a tile worker for the widget's current pixel density.
fn start_tiles(self: &Rc<Self>) {
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);
let Some(dir) = self.state.borrow().cache_dir.clone() else {
return;
};
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 {
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 {
tiles,
online,
cache: HashMap::new(),
pending: HashSet::new(),
failed: HashMap::new(),
@@ -547,7 +542,7 @@ impl PlacesMap {
fn tile_done(&self, done: Done) {
let mut state = self.state.borrow_mut();
let Some(online) = state.tiles.as_mut() else {
let Some(online) = state.online.as_mut() else {
return;
};
match done {
@@ -733,7 +728,7 @@ impl PlacesMap {
}
fn max_scale(&self) -> f64 {
let zoom = if self.state.borrow().tiles.as_ref().is_some_and(|t| t.online) {
let zoom = if self.state.borrow().online.is_some() {
ONLINE_MAX_ZOOM
} else {
MAX_ZOOM
@@ -828,11 +823,11 @@ impl PlacesMap {
let restart = self
.state
.borrow()
.tiles
.online
.as_ref()
.is_some_and(|o| o.tiles.scale != area.scale_factor().max(1));
if restart {
self.state.borrow_mut().tiles = None;
self.state.borrow_mut().online = None;
self.start_tiles();
}
@@ -845,9 +840,8 @@ impl PlacesMap {
let mut state = self.state.borrow_mut();
let state = &mut *state;
let view = state.view;
state.draws += 1;
paint_outline(cr, view, size, colors);
let labels = match state.tiles.as_mut() {
let labels = match state.online.as_mut() {
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
None => Vec::new(),
};
@@ -869,10 +863,7 @@ impl PlacesMap {
}
for bubble in &state.bubbles {
let marker = &state.markers[bubble.members[0]];
let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| {
*drawn = state.draws;
&*cover
});
let cover = state.covers.get(&marker.cover);
if cover.is_none()
&& let Target::Photo { place, index } = marker.target
&& state.asked_thumbs.insert(marker.cover.clone())
@@ -1000,16 +991,16 @@ fn paint_outline(cr: &cairo::Context, view: View, size: (f64, f64), colors: &Pal
let _ = cr.stroke();
}
/// The tile zoom whose tiles come closest to their own size on screen.
/// The street-map 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 map tiles on screen, asking for the missing ones and standing in
/// their nearest ancestor meanwhile. Returns the names on them.
/// Draw the street-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 TileLayer,
online: &mut Online,
view: View,
size: (f64, f64),
dark: bool,
@@ -1130,35 +1121,6 @@ fn evict(cache: &mut HashMap<TileKey, CachedTile>, frame: u64) {
}
}
/// Drop the photo covers drawn longest ago, down to [`COVER_CACHE`]. Never
/// one drawn in the current draw, and never a town's cover. Returns the uids
/// dropped.
fn evict_covers<T>(
covers: &mut HashMap<String, (T, u64)>,
towns: &HashSet<&str>,
draw: u64,
) -> Vec<String> {
if covers.len() <= COVER_CACHE {
return Vec::new();
}
let mut ages: Vec<(u64, &String)> = covers
.iter()
.filter(|(uid, (_, drawn))| *drawn < draw && !towns.contains(uid.as_str()))
.map(|(uid, (_, drawn))| (*drawn, uid))
.collect();
ages.sort_unstable_by_key(|(drawn, _)| *drawn);
let excess = covers.len() - COVER_CACHE;
let dropped: Vec<String> = ages
.into_iter()
.take(excess)
.map(|(_, uid)| uid.clone())
.collect();
for uid in &dropped {
covers.remove(uid);
}
dropped
}
/// Set the names of the tiles on screen, the most important first, leaving
/// out any that would overlap one already set.
fn paint_labels(
@@ -1566,47 +1528,6 @@ 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));
@@ -1674,6 +1595,52 @@ fn spread(points: &[World]) -> f64 {
span(&mut xs.into_iter()).max(span(&mut ys.into_iter()))
}
/// Merge markers whose circles would overlap on screen, the one with the
/// most photos claiming its neighbours (the first of equals, when counts
/// tie). Markers off screen are left out.
fn cluster(screen: &[(f64, f64)], counts: &[usize], width: f64, height: f64) -> Vec<Bubble> {
let mut order: Vec<usize> = (0..screen.len()).collect();
order.sort_by(|a, b| counts[*b].cmp(&counts[*a]));
let mut bubbles: Vec<Bubble> = Vec::new();
for index in order {
let (x, y) = screen[index];
let reach = bubble_radius(counts[index]);
if x < -reach || y < -reach || x > width + reach || y > height + reach {
continue;
}
match bubbles
.iter_mut()
.find(|b| (b.x - x).hypot(b.y - y) < b.radius + reach * 0.5)
{
Some(bubble) => {
bubble.photos += counts[index];
bubble.radius = bubble_radius(bubble.photos);
bubble.members.push(index);
}
None => bubbles.push(Bubble {
x,
y,
radius: reach,
photos: counts[index],
members: vec![index],
}),
}
}
// Smallest last, so a small marker next to a big one stays clickable.
bubbles.sort_by(|a, b| b.radius.total_cmp(&a.radius));
bubbles
}
/// "7", "840", "1.2k", "35k": short enough to fit a marker. Digits and the
/// "k" read the same in every language the app ships.
fn compact_count(n: usize) -> String {
match n {
0..1_000 => n.to_string(),
1_000..10_000 => format!("{:.1}k", n as f64 / 1_000.0),
_ => format!("{}k", n / 1_000),
}
}
fn set_color(cr: &cairo::Context, color: &gtk4::gdk::RGBA, alpha: f32) {
cr.set_source_rgba(
f64::from(color.red()),
@@ -1687,28 +1654,6 @@ fn set_color(cr: &cairo::Context, color: &gtk4::gdk::RGBA, alpha: f32) {
mod tests {
use super::*;
#[test]
fn covers_past_the_cap_drop_the_stalest_photos_but_no_town() {
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE as u64 + 3)
.map(|n| (format!("p{n}"), ((), n)))
.collect();
let towns: HashSet<&str> = ["p0"].into_iter().collect();
let mut dropped = evict_covers(&mut covers, &towns, COVER_CACHE as u64);
dropped.sort();
assert_eq!(dropped, ["p1", "p2", "p3"]);
assert_eq!(covers.len(), COVER_CACHE);
assert!(covers.contains_key("p0"));
}
#[test]
fn covers_drawn_this_frame_are_kept_even_past_the_cap() {
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE + 2)
.map(|n| (format!("p{n}"), ((), 7)))
.collect();
assert!(evict_covers(&mut covers, &HashSet::new(), 7).is_empty());
assert_eq!(covers.len(), COVER_CACHE + 2);
}
#[test]
fn projection_puts_the_equator_and_meridian_in_the_middle() {
let p = project(0.0, 0.0);
@@ -635,7 +635,6 @@ 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,
}
}
+1 -1
View File
@@ -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 from OpenFreeMap instead of the offline map. It learns which parts of the world you look at.",
"Show streets and town names from OpenFreeMap. It learns which parts of the world you look at.",
))
.build();
appearance_group.add(&online_map_row);
+19 -122
View File
@@ -52,9 +52,8 @@ fn staged_path(ui: &Rc<Ui>) -> PathBuf {
/// Read the remembered set, dropping any archive that has since been moved or
/// deleted — a stale path would only fail at launch, and silently is worse.
/// Blocking: run it off the GTK thread.
fn load_staged(path: &Path) -> Vec<PathBuf> {
let Ok(text) = std::fs::read_to_string(path) else {
fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
let Ok(text) = std::fs::read_to_string(staged_path(ui)) else {
return Vec::new();
};
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
@@ -65,39 +64,9 @@ fn load_staged(path: &Path) -> Vec<PathBuf> {
.collect()
}
/// Restore whatever was staged when the window last closed, read on a worker.
/// Anything the user staged meanwhile is kept alongside it.
fn restore_staged(ui: &Rc<Ui>) {
let path = staged_path(ui);
let ui = ui.clone();
glib::spawn_future_local(async move {
let restored = gio::spawn_blocking(move || load_staged(&path))
.await
.unwrap_or_default();
{
let mut staged = ui.takeout.archives.borrow_mut();
for path in restored {
if !staged.contains(&path) {
staged.push(path);
}
}
staged.sort();
}
ui.takeout.restored.set(true);
repaint_archives(&ui);
});
}
/// Remember the staged set. Best-effort: failing to write it costs the user a
/// re-pick next time, which is not worth interrupting them over now.
///
/// Written on a worker. Nothing is written before the remembered set has been
/// read back, so the empty list shown meanwhile can't overwrite it, and a
/// write that lands after a newer one is skipped.
fn save_staged(ui: &Rc<Ui>) {
if !ui.takeout.restored.get() {
return;
}
let paths: Vec<String> = ui
.takeout
.archives
@@ -106,24 +75,12 @@ fn save_staged(ui: &Rc<Ui>) {
.map(|p| p.display().to_string())
.collect();
let path = staged_path(ui);
let seq = ui.takeout.save_seq.get() + 1;
ui.takeout.save_seq.set(seq);
let saved = ui.takeout.saved_seq.clone();
gio::spawn_blocking(move || {
let Ok(mut last) = saved.lock() else {
return;
};
if *last > seq {
return;
}
*last = seq;
let written = serde_json::to_string(&paths)
.map_err(|e| e.to_string())
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
if let Err(e) = written {
tracing::warn!("cannot remember staged Takeout archives: {e}");
}
});
let written = serde_json::to_string(&paths)
.map_err(|e| e.to_string())
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
if let Err(e) = written {
tracing::warn!("cannot remember staged Takeout archives: {e}");
}
}
fn empty_list_description() -> String {
@@ -164,16 +121,6 @@ pub(crate) struct TakeoutState {
pub(crate) inflight: Cell<bool>,
/// Whether the daemon reported an import running on the last poll.
pub(crate) running: Cell<bool>,
/// Whether the remembered staged set has been read back yet; until then
/// nothing is saved over it.
pub(crate) restored: Cell<bool>,
/// The last save started, and the last one written by a worker, so an
/// older save that lands late doesn't overwrite a newer one.
pub(crate) save_seq: Cell<u64>,
pub(crate) saved_seq: std::sync::Arc<std::sync::Mutex<u64>>,
/// Bumped by every repaint of the archive list, so the sizes of an older
/// list that arrive late are not painted over a newer one.
pub(crate) repaint_seq: Cell<u64>,
}
/// Widgets the Import page hands back for wiring.
@@ -543,10 +490,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
.back_button
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
// Restore whatever was staged when the window last closed, so the page
// comes up as the user left it.
// Restore whatever was staged when the window last closed, before the first
// paint, so the page comes up as the user left it.
*ui.takeout.archives.borrow_mut() = load_staged(ui);
repaint_archives(ui);
restore_staged(ui);
}
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
@@ -556,36 +503,15 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
/// the scan reads the archives' central directories, and an extracted tree has
/// none — silently importing half of it would be worse than saying no.
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
// Whether each is a regular file is asked of the filesystem, which may be
// a slow network mount: on a worker.
let ui = ui.clone();
glib::spawn_future_local(async move {
let checked = gio::spawn_blocking(move || {
paths
.into_iter()
.map(|path| {
let file = path.is_file();
(path, file)
})
.collect::<Vec<_>>()
})
.await
.unwrap_or_default();
stage_archives(&ui, checked);
});
}
/// Stage the archives [`add_archives`] checked, as `(path, is a file)`.
fn stage_archives(ui: &Rc<Ui>, paths: Vec<(PathBuf, bool)>) {
let mut added = 0usize;
let mut rejected = 0usize;
{
let mut staged = ui.takeout.archives.borrow_mut();
for (path, file) in paths {
for path in paths {
let is_zip = path
.extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
if !is_zip || !file {
if !is_zip || !path.is_file() {
rejected += 1;
continue;
}
@@ -616,44 +542,12 @@ fn stage_archives(ui: &Rc<Ui>, paths: Vec<(PathBuf, bool)>) {
}
/// Rebuild the staged-archive list and re-derive which actions are available.
///
/// The archives' sizes are read on a worker, and the list is rebuilt once
/// they are in.
pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
let seq = ui.takeout.repaint_seq.get().wrapping_add(1);
ui.takeout.repaint_seq.set(seq);
let staged = ui.takeout.archives.borrow().clone();
save_staged(ui);
sync_takeout_actions(ui);
if staged.is_empty() {
paint_archives(ui, Vec::new());
return;
}
let ui = ui.clone();
glib::spawn_future_local(async move {
let sized = gio::spawn_blocking(move || {
staged
.into_iter()
.map(|path| {
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
(path, size)
})
.collect::<Vec<_>>()
})
.await
.unwrap_or_default();
if ui.takeout.repaint_seq.get() == seq {
paint_archives(&ui, sized);
}
});
}
/// Fill the staged-archive list with `staged`, as `(path, size)`.
fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
for row in ui.takeout.rows.borrow_mut().drain(..) {
ui.takeout.list_group.remove(&row);
}
let staged = ui.takeout.archives.borrow().clone();
let mut rows: Vec<adw::PreferencesRow> = Vec::new();
if staged.is_empty() {
ui.takeout
@@ -664,8 +558,8 @@ fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
rows.push(row.upcast());
} else {
let mut total = 0u64;
for (path, size) in &staged {
let size = *size;
for path in &staged {
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
total += size;
let row = adw::ActionRow::builder()
.title(
@@ -707,6 +601,9 @@ fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
)));
}
*ui.takeout.rows.borrow_mut() = rows;
save_staged(ui);
sync_takeout_actions(ui);
}
/// Enable exactly the actions that make sense right now: nothing to launch
+24 -503
View File
@@ -16,28 +16,6 @@ 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.
@@ -52,18 +30,8 @@ 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
@@ -107,41 +75,11 @@ 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
@@ -163,7 +101,6 @@ 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(),
@@ -178,10 +115,6 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
selection_label,
restore_selected,
delete_selected,
back,
crumb,
search,
grouped,
},
)
}
@@ -218,10 +151,7 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, widgets: &TrashWidgets) {
files
.column_view
.append_column(&text_column(&pgettext("column", "Size"), |e| {
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 {
if e.is_dir {
"—".to_string()
} else {
human_bytes(e.size)
@@ -233,21 +163,6 @@ 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
@@ -278,52 +193,17 @@ fn trashed_from_label(entry: &DirEntry) -> String {
}
}
/// Open a location or a trashed folder in place. A trashed file can't be
/// opened; say what would let it be.
/// A trashed file can't be opened; say what would let it be.
fn activate_trashed(ui: &Rc<Ui>, entry: &DirEntry) {
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(),
};
toast(
ui,
// Translators: {name} is a file or folder name.
toast(
ui,
&gettext_f("Restore “{name}” to open it", &[("name", &name)]),
);
}
&gettext_f("Restore “{name}” to open it", &[("name", &entry.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))
@@ -364,7 +244,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.all.borrow().is_empty() {
if ui.trash.files.model.n_items() > 0 {
menu.section();
let ui_c = ui.clone();
menu.item(&gettext("Empty Trash…"), move || {
@@ -420,17 +300,7 @@ pub(crate) fn load_trash(ui: &Rc<Ui>) {
clear_trash(&ui);
}
match result {
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::Entries { entries })) => repaint_trash(&ui, &entries),
Ok(Ok(Response::Error { message, .. })) => trash_status(
&ui,
"dialog-warning-symbolic",
@@ -468,125 +338,14 @@ pub(crate) fn trash_status(ui: &Rc<Ui>, icon: &str, title: &str, description: &s
ui.trash.subtitle.set_subtitle("");
}
/// 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();
/// 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]) {
// 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(!all.is_empty());
repaint_trash_crumb(ui);
if all.is_empty() {
drop(all);
ui.trash.empty.set_visible(!entries.is_empty());
if entries.is_empty() {
trash_status(
ui,
"user-trash-symbolic",
@@ -597,198 +356,22 @@ pub(crate) fn render_trash(ui: &Rc<Ui>) {
clear_trash(ui);
return;
}
let subtitle = ngettext_f("{n} item", "{n} items", all.len() as u64, &[]);
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);
ui.trash.subtitle.set_subtitle(&ngettext_f(
"{n} item",
"{n} items",
entries.len() as u64,
&[],
));
let mut sorted = entries.to_vec();
sort_trash(&mut sorted);
// Only the rows that changed are swapped, so a refresh keeps the
// selection and the scroll position.
replace_items(&ui.trash.files.model, &rows);
replace_items(&ui.trash.files.model, &sorted);
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]) {
@@ -810,10 +393,6 @@ 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)]),
@@ -851,10 +430,6 @@ 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;
@@ -910,7 +485,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.all.borrow().len();
let count = ui.trash.files.model.n_items();
let dialog = adw::AlertDialog::builder()
.heading(gettext("Empty Trash?"))
.body(ngettext_f(
@@ -961,64 +536,10 @@ 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![
+2 -48
View File
@@ -74,6 +74,7 @@ original wording.
| [B134](#b134--a-file-deleted-online-while-the-drain-checks-its-write-is-kept-as-a-conflict-copy) | 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 | |
@@ -108,8 +109,6 @@ 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) |
| [B293](#b293--a-large-trash-never-lists-and-empty-trash-never-empties-it) | A large trash never lists, and Empty Trash never empties it |
| [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 |
@@ -396,38 +395,6 @@ a live account since.
Newest first.
### B293 — A large trash never lists, and Empty Trash never empties it
**Status:** Fixed in code, live check pending
**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.
**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. Pending: a live listing and empty on the affected account.
### B292 — Two programs changing settings at once lose one of the changes
**Status:** Fixed
@@ -7508,7 +7475,7 @@ duplicates, renamed folders, multiple devices, and byte-identical restoration.
### B66 — Local-only pending data is not protected at shutdown (HIGH-21)
**Status:** Fixed, unverified live
**Status:** Open — 1.0 data-safety/UX blocker
**Found:** 2026-07-22, 1.0 recovery audit
**Where:** shutdown, CLI/GUI status, logout/unregister workflows
@@ -7521,19 +7488,6 @@ 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)
-45
View File
@@ -11,45 +11,8 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
## [Unreleased]
### 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.
- proton-sdk 0.12.4: thumbnails need fewer requests to Proton (0.12.3), and the SDK
can list photos that have no thumbnail (0.12.4).
- Signing in runs through `proton_sdk::login` (proton-sdk 0.12.2), the sequence Proton
Gallery and Proton Stream use too. The stored session, the lock/unlock choice for two-password
accounts, the three mailbox-password tries and the messages stay as they were.
- An account whose only second factor is a security key now gets a clear message at
sign-in instead of a code prompt that could only fail.
- Block fetches shared by concurrent readers now use `SingleFlight` from
`proton-media-rs`, the same code Proton Stream uses. Same behaviour: one
download per block, every reader gets its result, and a reader whose fetch was
cancelled downloads the block itself.
- The shared Gallery engine now comes from the `proton-gallery-rs` and
`proton-gallery-app-rs` crates on crates.io instead of a pinned Git revision of
Proton Gallery. Builds, vendoring and the Nix package no longer fetch from Git.
@@ -59,14 +22,6 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
- The keyring code (one Secret Service connection that reconnects after the provider
restarts, B285, and replacing the session item instead of editing it, B291) now comes
from `proton-auth-rs`, shared with Proton Gallery and Proton Stream. No behaviour change.
- Config, machine-id and mount-failure files are written through `proton-base-rs`'s
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). Needs proton-drive-rs 0.12.5.
## [3.9.0] — 2026-11-19
+2 -3
View File
@@ -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 [--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 logout` | End the session on Proton and remove the stored session. |
| `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,7 +125,6 @@ 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. |
@@ -154,7 +153,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. `--by-folder` groups it by original folder; `--folder UID` lists a deleted folder. |
| `pdfs trash` | List the Trash with the UIDs the next commands take. |
| `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. |
+2 -9
View File
@@ -71,20 +71,13 @@ terminal: `pdfs copy PATH... NEW_PARENT`.
## Trash
Deleted files go to the Trash, both from `~/ProtonDrive` and from the app. The **Trash** page
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.
lists them with the date they were deleted.
- **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 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.
`pdfs delete-forever` and `pdfs empty-trash` take those IDs.
## Earlier versions of a file
-5
View File
@@ -360,12 +360,8 @@ 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
@@ -380,7 +376,6 @@ 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" \
+3 -6
View File
@@ -68,14 +68,11 @@ 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): 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.
[Natural Earth](https://www.naturalearthdata.com/) (public domain). Both ship with the app, so
nothing is fetched online.
A street map from [OpenFreeMap](https://openfreemap.org/) (© OpenStreetMap contributors) can be
turned on instead under **Preferences → General → Appearance**. It is off by default, because the map
turned on under **Preferences → General → Appearance**. It is off by default, because the map
server learns which areas you look at.
## Viewer and duplicates
+2 -2
View File
@@ -43,7 +43,7 @@ them along.
| Item | State | Notes |
|---|---|---|
| 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) |
| 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) |
| 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) |
@@ -63,7 +63,7 @@ them along.
| Add someone else's photo to your album | Blocked | Needs `copyPhoto` in the SDK |
| Photo name search | Not started | Photos search by date and filters only |
| Automatic photo upload from a folder | Not started | |
| Faster Google Photos import | Partly done | Two uploads run at once. Trash folders of locales missing from `TRASH_FOLDERS` import as photos |
| Faster Google Photos import | Not started | Uploads run one at a time. Trash folders of locales missing from `TRASH_FOLDERS` import as photos |
| More of a Google Photos export | Not started | `.tgz` exports and extracted folders; shared albums told apart from own ones; album descriptions and covers; photo descriptions |
| Content-addressed block cache | Idea | Store blocks by hash to deduplicate identical content |
Binary file not shown.

Before

Width:  |  Height:  |  Size: 702 KiB

After

Width:  |  Height:  |  Size: 283 KiB

+1 -5
View File
@@ -16,7 +16,7 @@ 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' 'curl')
makedepends=('cargo' 'git' 'gettext')
provides=('pdfs')
# Files-on-demand mount + keyring need these at runtime.
optdepends=('gnome-keyring: credential storage via Secret Service'
@@ -80,10 +80,6 @@ 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,10 +49,6 @@ 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,10 +25,8 @@ 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"
"basemap-v1.pmtiles::https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles")
sha256sums=('SKIP'
'ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280')
source=("$pkgname::git+$_repo.git")
sha256sums=('SKIP')
pkgver() {
cd "$pkgname"
@@ -83,10 +81,6 @@ 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,10 +25,8 @@ 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"
"basemap-v1.pmtiles::https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles")
sha256sums=('095186fa108f27ff2b175188bb13466a94cc8ecfd71088df47a41d4d9baa58c1'
'ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280')
source=("$pkgname-$pkgver.tar.gz::$_repo/archive/refs/tags/v$pkgver.tar.gz")
sha256sums=('095186fa108f27ff2b175188bb13466a94cc8ecfd71088df47a41d4d9baa58c1')
_srcname="proton-drive-linux-$pkgver"
@@ -78,10 +76,6 @@ 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"
-7
View File
@@ -3,7 +3,6 @@
{
lib,
rustPlatform,
fetchurl,
adwaita-icon-theme,
pkg-config,
gettext,
@@ -24,11 +23,6 @@
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";
@@ -122,7 +116,6 @@ 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
'';
-14
View File
@@ -25,10 +25,7 @@ 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
@@ -78,7 +75,6 @@ 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
@@ -123,14 +119,6 @@ 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}
@@ -172,8 +160,6 @@ 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
View File
@@ -1,6 +1,6 @@
#!/usr/bin/env bash
# Lay out the release tarball: built binaries, desktop files, icon, user
# service, the Places basemap, translations, shell completions and install.sh, under one top-level
# service, 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,11 +37,6 @@ 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"
-1
View File
@@ -40,7 +40,6 @@ 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"
+650 -841
View File
File diff suppressed because it is too large. Load diff
+657 -844
View File
File diff suppressed because it is too large. Load diff
+650 -841
View File
File diff suppressed because it is too large. Load diff
+649 -842
View File
File diff suppressed because it is too large. Load diff
+650 -840
View File
File diff suppressed because it is too large. Load diff
+648 -840
View File
File diff suppressed because it is too large. Load diff
+631 -814
View File
File diff suppressed because it is too large. Load diff
+648 -839
View File
File diff suppressed because it is too large. Load diff
+650 -839
View File
File diff suppressed because it is too large. Load diff
-23
View File
@@ -1,23 +0,0 @@
#!/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"
+3 -7
View File
@@ -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 and trash exist too, for pull requests only
preferences_apps 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,trash
extra=preferences_sync,preferences_apps
# 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 trash:trash; do
preferences_sync:preferences-sync preferences_apps:preferences-apps; do
name=${shot%%:*}
wants "$name" || continue
"$BIN/pdfs-app" --page "${shot#*:}"
@@ -233,9 +233,6 @@ 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}" \
@@ -244,7 +241,6 @@ 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"