Compare commits

...
Author SHA1 Message Date
nvrl 2b5d6f2436 feat: protect queued changes at shutdown and sign-out (B66)
While the queue holds changes the drain can send, the daemon holds a logind
shutdown inhibitor through systemd-inhibit, so desktops show why a power-off
is held up. Parked transient files and changes that need the user never hold
it. pdfs sync flush retries failed changes and waits for the queue, exiting 3
when what is left needs the user and 4 on timeout. Signing out, in the app or
with pdfs logout, says how many changes are not on Proton Drive yet.
2026-11-21 23:42:54 +01:00
nvrl 2c4c95812f Merge pull request #119 from narrrl/chore/sdk-0.12.3
chore(deps): proton-sdk 0.12.3 and proton-gallery-rs 0.1.5
2026-11-21 17:12:11 +01:00
nvrl 2bf1622793 chore(deps): proton-sdk 0.12.3 and proton-gallery-rs 0.1.5
SDK 0.12.3 fetches a thumbnail with fewer round trips and caches the
thumbnail target per revision. proton-gallery-rs 0.1.5 advances the
Photos revision only when an album changed.
2026-11-21 17:08:41 +01:00
nvrl 2ea189f1d9 Merge pull request #118 from narrrl/chore/gallery-rs-0.1.3
perf(gui): cluster Places markers with proton-gallery-rs 0.1.3
2026-11-20 22:12:51 +01:00
nvrl 8af671d8ed perf(gui): cluster Places markers with proton-gallery-rs 0.1.3
The map kept its own copy of the marker clustering, identical to the one
in proton-gallery-rs. 0.1.3 makes that one fast (a grid of cells instead
of a scan of every bubble so far, same results), so the map now uses it.
2026-11-20 22:09:04 +01:00
nvrl 9047bdd741 Merge pull request #117 from narrrl/perf/photos-main-thread
perf(gui): keep Photos decoding and file access off the main thread
2026-11-20 21:48:52 +01:00
nvrl ca20e5ed22 perf(gui): keep Takeout staging file access off the main thread
The Import page read and wrote its remembered archive list, checked each
dropped path and stat'ed every staged archive on the GTK thread. Do all
of it on gio's blocking pool. Nothing is saved until the remembered list
has been read back, so it can't be overwritten by the empty list shown
meanwhile, and a late save never overwrites a newer one.
2026-11-20 20:47:47 +01:00
nvrl 10bc9a6a37 perf(gui): cap the Places map's photo marker covers
Every photo cover the map was shown while zooming around stayed in
memory for as long as the map existed. Keep at most 1024 and drop the
ones drawn longest ago, never a town's cover or one drawn this frame,
and ask for a dropped cover again when its marker returns.
2026-11-20 20:43:44 +01:00
nvrl 890adbc189 perf(gui): debounce the Drive gallery re-flow on resize
The Drive gallery rebuilt its whole row model on every frame the width
changed, so dragging the window edge rebuilt it dozens of times a
second. Lay out the first width at once as before, and wait for a resize
to settle (80 ms, like the timeline) before rebuilding.
2026-11-20 20:41:59 +01:00
nvrl 960c6afe2d perf(gui): decode Drive gallery thumbnails off the main thread
Drive gallery tiles and the hidden-album preview decoded the base64
reply and the image itself on the GTK thread. Do both on gio's blocking
pool, then re-check the request generation and lock state before
painting, as before.
2026-11-20 20:37:22 +01:00
nvrl 1b545ba369 perf(gui): look Drive gallery thumbnails up by key
The Drive gallery's thumbnail cache was a queue searched linearly on
every tile bind. Keep it in the shared LRU cache instead, still capped at
256 thumbnails, so a lookup and its touch no longer scan the queue.
2026-11-20 20:36:12 +01:00
nvrl b854c1e819 perf(gui): decode timeline thumbnails off the main thread
The Photos timeline decoded up to four thumbnails per idle pass on the
GTK thread, which stuttered a fast scroll. Decode each batch on gio's
blocking pool instead and only paint the results on the main thread.
Results from before a timeline reset are dropped, and tiles that were
unbound or rebound meanwhile are no longer waiting, so they are not
painted.
2026-11-20 20:34:41 +01:00
nvrl 3fbe651f94 perf(gui): budget the Photos texture cache by bytes
The timeline kept up to 1500 decoded thumbnails regardless of their size,
and marking one as used scanned the whole eviction order on every tile
bind. Replace it with an LRU cache keyed on decoded pixel bytes (512 MiB,
about 900 ordinary 512 px thumbnails) whose touch is logarithmic.
2026-11-20 20:32:59 +01:00
nvrl 61b992cb48 Merge pull request #115 from narrrl/fix/drive-gallery-header
fix(gui): give Drive galleries room under their header
2026-11-20 20:04:38 +01:00
nvrl 08e0e80f34 fix(gui): give Drive galleries room under their header
An open Drive gallery kept Add This Folder, Unlock and its options button
in a row of their own above the grid. The row took height from the photos
and left the options button touching the first row of tiles. They now sit
in the page's header bar, where the timeline keeps its own menu.

Rows in a Drive gallery also lose their extra side inset and use the
timeline's tile gap vertically too, and the options menu no longer lists
Refresh twice while hidden albums are locked.
2026-11-20 19:27:57 +01:00
nvrl 0488ccd5f6 Merge pull request #114 from narrrl/refactor/sdk-login
refactor(core): sign in through proton_sdk::login
2026-11-20 17:53:42 +01:00
nvrl 62d16e03cf refactor(core): sign in through proton_sdk::login
The sign-in sequence moved from proton_auth_rs::session into proton-sdk
0.12.2. Same stored session, same messages; pdfs-core keeps only the
keyring feature of proton-auth-rs.
2026-11-20 17:37:54 +01:00
nvrl c92f78b5c8 Merge pull request #113 from narrrl/refactor/shared-sign-in
refactor(core): sign in through proton_auth_rs::session
2026-11-20 15:52:58 +01:00
nvrl b034e1d4e3 Merge pull request #112 from narrrl/fix/po-catalogs
fix(i18n): bring every catalog up to date with the sources
2026-11-20 15:52:49 +01:00
nvrl e15e1dcc76 refactor(core): sign in through proton_auth_rs::session
The sign-in steps are now the sequence Proton Gallery and Proton Stream
share. The stored session, the lock/unlock choice for two-password
accounts, the three mailbox-password tries and the errors front-ends
word themselves are unchanged. An account whose only second factor is
a security key now gets a clear message instead of a code prompt that
could only fail.
2026-11-20 15:43:31 +01:00
29 changed files with 4796 additions and 3802 deletions

No files matched your search

Generated
+9 -8
View File
@@ -3926,9 +3926,9 @@ dependencies = [
[[package]]
name = "proton-auth-rs"
version = "0.1.0"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e140db8b4444e50c818c9793c2078b57c16c5b6c285a8d4bbd74886f41b05c6f"
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc"
dependencies = [
"apple-native-keyring-store",
"dbus-secret-service",
@@ -3952,9 +3952,9 @@ dependencies = [
[[package]]
name = "proton-drive-rs"
version = "0.12.1"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d05ad4be849ce2104759631063dd06867fbe6b6f0e5c37a172a84b5a90203fa7"
checksum = "e9f7e67c864033e2d13ff48f9e0738f22ae6401cc47131b266b90c23e0dcc381"
dependencies = [
"async-trait",
"base64 0.23.1",
@@ -4022,15 +4022,16 @@ dependencies = [
[[package]]
name = "proton-gallery-rs"
version = "0.1.1"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc9c9bbb76a5fba4071ee90de4aada71c292c0e408024ddfb04a12869291404a"
checksum = "e374d2053de5df0e6b0797df65d0d024dbce35f7aedfefd4a656896a0495dc9b"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
"getrandom 0.4.3",
"hex",
"kamadak-exif",
"proton-base-rs",
"rusqlite",
"serde",
"serde_json",
@@ -4059,9 +4060,9 @@ dependencies = [
[[package]]
name = "proton-sdk"
version = "0.12.1"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80c381e9066c0bca3c32597df2e902eecaa4c6e05e202e70ec9d0ac2eec78bfe"
checksum = "a443d600225687a92724b455c025a049b8668fe9da52fbf7cb46583a8e4970a7"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
+4 -4
View File
@@ -15,10 +15,10 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
categories = ["filesystem", "command-line-utilities"]
[workspace.dependencies]
proton-sdk = { version = "0.12.1" }
proton-drive-rs = { version = "0.12.1" }
proton-sdk = { version = "0.12.3" }
proton-drive-rs = { version = "0.12.3" }
proton-gallery-app-rs = "0.1.0"
proton-gallery-rs = "0.1.1"
proton-gallery-rs = "0.1.5"
chrono = { version = "0.4", default-features = false, features = ["std"] }
# Internal crates.
@@ -65,7 +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"
proton-auth-rs = "0.1.1"
proton-base-rs = "0.1"
proton-media-rs = "0.1.1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
+102 -5
View File
@@ -158,8 +158,12 @@ enum Command {
#[arg(long)]
forget: bool,
},
/// Forget the stored session.
Logout,
/// Forget the stored session. Asks first while changes are still queued.
Logout {
/// Do not ask first.
#[arg(long)]
yes: bool,
},
/// Show account login state, and mount status if a daemon is running.
Status,
/// List every local Proton Drive location.
@@ -857,6 +861,13 @@ enum SyncCmd {
},
/// List uploads and changes not yet on Proton Drive.
Queue,
/// Wait until every queued change is on Proton Drive. Exits 0 once nothing
/// is left, 3 when what is left needs you (see `sync issues`), 4 on timeout.
Flush {
/// Give up after this many seconds.
#[arg(long)]
timeout: Option<u64>,
},
/// List queued changes Proton Drive refused or that keep failing, and what to do.
Issues,
/// Save the content of a queued upload (by id from `sync queue`) to a file.
@@ -1047,7 +1058,7 @@ fn main() -> Result<()> {
cli.command,
Command::Login { .. }
| Command::Unlock { .. }
| Command::Logout
| Command::Logout { .. }
| Command::Mount { .. }
| Command::Daemon { .. }
) {
@@ -1057,7 +1068,7 @@ fn main() -> Result<()> {
Command::Login { username, remember } => cmd_login(username, remember),
Command::Unlock { remember } => cmd_unlock(remember),
Command::Lock { forget } => cmd_lock(forget),
Command::Logout => cmd_logout(),
Command::Logout { yes } => cmd_logout(yes),
Command::Status => cmd_status(),
Command::Locations => cmd_locations(),
Command::Mount { mountpoint } => cmd_mount(mountpoint),
@@ -1362,6 +1373,7 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
})?)?
}
SyncCmd::Queue => return cmd_sync_queue(),
SyncCmd::Flush { timeout } => return cmd_sync_flush(timeout),
SyncCmd::Issues => return cmd_sync_issues(),
SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest),
SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down),
@@ -1465,6 +1477,71 @@ fn cmd_sync_queue() -> Result<()> {
Ok(())
}
/// `pdfs sync flush`: wait for the queue to drain.
///
/// Failed changes are retried at once rather than after their backoff. The
/// wait ends early, with exit code 3, when everything left is waiting on the
/// user: refused by Drive, failing again and again, or a temporary file
/// waiting for its final name. Paused or offline, it keeps waiting and says
/// why.
fn cmd_sync_flush(timeout: Option<u64>) -> Result<()> {
const POLL: std::time::Duration = std::time::Duration::from_secs(1);
let deadline =
timeout.map(|secs| std::time::Instant::now() + std::time::Duration::from_secs(secs));
ok_or_bail(control_request(CtlRequest::RetryPendingOp { id: None })?)?;
let mut last_line = String::new();
loop {
let items = match control_request(CtlRequest::ListPendingOps)? {
CtlResponse::PendingOps { items } => items,
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
other => bail!("unexpected response: {other:?}"),
};
let waiting = items
.iter()
.filter(|op| !op.parked && !op.failing && op.issue.is_none())
.count();
if items.is_empty() {
finish_line(&last_line);
println!("Everything is on Proton Drive.");
return Ok(());
}
if waiting == 0 {
finish_line(&last_line);
eprintln!(
"{} queued change(s) need you before they can be sent. See `pdfs sync issues`.",
items.len()
);
std::process::exit(3);
}
let reason = match control_request(CtlRequest::Status)? {
CtlResponse::Status { paused: true, .. } => " (sync is paused; `pdfs sync resume`)",
CtlResponse::Status { online: false, .. } => " (offline; waiting for Proton Drive)",
_ => "",
};
let line = format!("{waiting} change(s) left to send{reason}");
if line != last_line {
if !last_line.is_empty() {
print!("\r\x1b[2K");
}
print!("{line}");
last_line = line;
}
if deadline.is_some_and(|deadline| std::time::Instant::now() >= deadline) {
finish_line(&last_line);
eprintln!("Timed out with {waiting} change(s) still queued.");
std::process::exit(4);
}
std::thread::sleep(POLL);
}
}
/// End a progress line so the next message starts on its own.
fn finish_line(last_line: &str) {
if !last_line.is_empty() {
println!();
}
}
/// `pdfs sync issues`: the queued changes that need the user, and what to do.
fn cmd_sync_issues() -> Result<()> {
let response = control_request(CtlRequest::ListPendingOps)?;
@@ -2298,7 +2375,27 @@ fn key_state_name() -> &'static str {
}
}
fn cmd_logout() -> Result<()> {
fn cmd_logout(yes: bool) -> Result<()> {
// Queued changes stay staged on this computer and are sent after the next
// sign-in, but until then they exist nowhere else. Without a running
// daemon there is no count to show.
if !yes
&& let Ok(CtlResponse::Status {
pending_uploads,
pending_changes,
parked_uploads,
..
}) = control_request(CtlRequest::Status)
{
let queued = pending_uploads + pending_changes + parked_uploads;
if queued > 0 {
println!(
"{queued} change(s) are not on Proton Drive yet. They stay on this computer and are \
sent after you sign in again. Run `pdfs sync flush` first to send them now."
);
confirm("Sign out anyway?")?;
}
}
if auth::logout()? {
println!("Signed out: the session is ended on Proton and cleared here.");
} else {
+58 -72
View File
@@ -36,6 +36,7 @@ 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};
@@ -279,74 +280,56 @@ pub async fn login_verified(
get_totp: impl Fn() -> Result<String>,
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
) -> Result<()> {
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),
}
// 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 tokens = session.current_tokens().await;
register_refresh_handler(&session, tokens.refresh_token.clone());
let tokens = unlocked.resume_parameters().await;
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
let stored = StoredSession {
session_id: session.session_id().as_str().to_owned(),
username: session.username().to_owned(),
user_id: session.user_id().as_str().to_owned(),
session_id: tokens.session_id.as_str().to_owned(),
username: tokens.username,
user_id: tokens.user_id.as_str().to_owned(),
access_token: tokens.access_token,
refresh_token: tokens.refresh_token,
scopes: session.scopes().to_vec(),
password_mode: match session.password_mode() {
PasswordMode::Single => 1,
PasswordMode::Dual => 2,
},
scopes: tokens.scopes,
password_mode: tokens.password_mode.to_wire() as u8,
mailbox_password: String::new(),
key_salts,
key_salts: unlocked.key_salts,
key_passphrases: None,
};
keep_passphrases(stored, &passphrases, remember)
keep_passphrases(stored, &unlocked.key_passphrases, remember)
}
/// Derive the key passphrases from `mailbox` and prove they unlock the account.
@@ -420,20 +403,23 @@ fn decode_secret(secret: &[u8]) -> Option<KeyPassphrases> {
decode(&serde_json::from_slice(secret).ok()?)
}
/// Lift a human-verification gate out of the generic API error into the typed
/// variant a front-end can act on.
/// A failed sign-in step as this crate's error.
///
/// 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(),
/// 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()),
}
}
+8
View File
@@ -42,6 +42,13 @@ 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)).
@@ -220,6 +227,7 @@ 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,
+129
View File
@@ -0,0 +1,129 @@
//! Hold off a shutdown while queued changes exist only on this computer.
//!
//! A change made through the mount is staged here and sent by the drain. Until
//! it lands, this computer has the only copy, so powering off then risks it
//! more than the user expects (`docs/BUGS.md` B66). While the queue holds work
//! the drain can still send, the daemon takes a logind shutdown inhibitor
//! through `systemd-inhibit`, which desktops show in their power-off dialog
//! with the reason. It is let go as soon as the queue empties.
//!
//! Work that cannot drain on its own — a temporary file waiting for its final
//! name, or a change Drive refused or that keeps failing — never holds the
//! lock, or a shutdown would be held up for something that is not coming.
//! Without `systemd-inhibit` nothing happens.
use std::process::{Child, Command, Stdio};
use std::time::Duration;
use pdfs_core::db::PendingCounts;
use tracing::{debug, warn};
use super::Core;
/// How often the queue is looked at.
const CHECK_EVERY: Duration = Duration::from_secs(5);
/// Changes the drain can still send by itself.
fn sendable(counts: &PendingCounts) -> i64 {
(counts.uploads + counts.changes - counts.parked - counts.failing).max(0)
}
/// Run until the daemon stops, holding the inhibitor while changes wait.
pub(crate) fn run(core: Core) {
let mut held: Option<Child> = None;
loop {
let waiting = core
.db
.pending_op_counts()
.map(|counts| sendable(&counts))
.unwrap_or(0);
// The helper can go away (logind restarted, or it was killed); the
// lock is then taken again on the next round.
if let Some(child) = &mut held
&& !matches!(child.try_wait(), Ok(None))
{
held = None;
}
match (&mut held, waiting > 0) {
(None, true) => held = take(waiting),
(Some(child), false) => {
release(child);
held = None;
}
_ => {}
}
if !core.shutdown.sleep(CHECK_EVERY) {
break;
}
}
if let Some(mut child) = held {
release(&mut child);
}
}
fn take(waiting: i64) -> Option<Child> {
let why = if waiting == 1 {
"Sending 1 change to Proton Drive".to_string()
} else {
format!("Sending {waiting} changes to Proton Drive")
};
match Command::new("systemd-inhibit")
.args([
"--what=shutdown",
"--who=Proton Drive",
&format!("--why={why}"),
"--mode=block",
"sleep",
"infinity",
])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
{
Ok(child) => {
debug!(waiting, "holding off shutdown while changes are queued");
Some(child)
}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
Err(error) => {
warn!(%error, "taking the shutdown inhibitor failed");
None
}
}
}
fn release(child: &mut Child) {
let _ = child.kill();
let _ = child.wait();
debug!("queue drained; shutdown no longer held off");
}
#[cfg(test)]
mod tests {
use super::*;
fn counts(uploads: i64, changes: i64, parked: i64, failing: i64) -> PendingCounts {
PendingCounts {
uploads,
changes,
parked,
failing,
last_error: None,
}
}
#[test]
fn only_work_the_drain_can_send_holds_off_a_shutdown() {
assert_eq!(sendable(&counts(0, 0, 0, 0)), 0);
assert_eq!(sendable(&counts(2, 1, 0, 0)), 3);
assert_eq!(sendable(&counts(1, 0, 1, 0)), 0);
assert_eq!(sendable(&counts(2, 0, 0, 2)), 0);
assert_eq!(sendable(&counts(3, 2, 1, 1)), 3);
}
#[test]
fn counts_that_overlap_never_go_negative() {
assert_eq!(sendable(&counts(1, 0, 1, 1)), 0);
}
}
+1
View File
@@ -92,6 +92,7 @@ use drive::{DriveApi, RevisionRead};
mod events;
mod filesystem;
mod gallery;
mod inhibit;
mod keeper;
mod link;
pub use filesystem::ProtonFs;
+11
View File
@@ -793,6 +793,17 @@ pub(crate) fn mount_with(
warn!(%error, "start My Files share-id repair failed");
}
}
// Hold off a shutdown while changes exist only here (B66). Only the real
// daemon: a simulation's queue is not the user's data.
if matches!(host, Host::Daemon) {
let inhibit_core = core.clone();
if let Err(error) = std::thread::Builder::new()
.name("pdfs-inhibit".into())
.spawn(move || crate::inhibit::run(inhibit_core))
{
warn!(%error, "start the shutdown inhibitor failed");
}
}
// Stop signals (SIGTERM from `systemctl --user stop`, SIGINT from Ctrl-C)
// are delivered onto the async runtime; bridge them onto a sync channel so
-1
View File
@@ -154,7 +154,6 @@ 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
@@ -0,0 +1,248 @@
//! 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);
}
}
+15 -20
View File
@@ -6,6 +6,7 @@ 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"]
@@ -15,6 +16,7 @@ pub(crate) mod widgets;
use compat::*;
use events::*;
use lru::Lru;
use pages::activity::*;
use pages::albums::*;
use pages::browser::*;
@@ -190,16 +192,11 @@ 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 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);
}
}
let bytes = texture_bytes(texture.width(), texture.height());
self.gallery
.photo_tex
.borrow_mut()
.insert(uid.to_string(), texture, bytes);
}
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles
@@ -208,14 +205,7 @@ 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) {
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());
}
self.gallery.photo_tex.borrow_mut().touch(uid);
}
}
@@ -631,8 +621,7 @@ fn build_window(app: &adw::Application) {
library: Cell::new(true),
page_waiters: RefCell::new(Vec::new()),
width: Cell::new(0),
photo_tex: RefCell::new(HashMap::new()),
photo_tex_order: RefCell::new(VecDeque::new()),
photo_tex: RefCell::new(Lru::new(TEXTURE_CACHE_BYTES)),
photo_nothumb: RefCell::new(HashSet::new()),
thumb_wanted: RefCell::new(HashMap::new()),
thumb_queue: RefCell::new(VecDeque::new()),
@@ -640,6 +629,7 @@ 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()),
@@ -652,6 +642,7 @@ 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(),
@@ -737,6 +728,10 @@ 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,
});
+116 -40
View File
@@ -1,10 +1,32 @@
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>);
@@ -45,12 +67,15 @@ 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,
thumbnails: RefCell<VecDeque<(bool, String, gtk4::gdk::Texture)>>,
/// Decoded thumbnails by whether they are hidden-album ones and uid.
thumbnails: RefCell<Lru<(bool, String), gtk4::gdk::Texture>>,
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
}
@@ -86,7 +111,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();
@@ -552,7 +577,7 @@ impl Browser {
if self.chooser.borrow().is_some() {
return;
}
let width = (self.width.get() - 24).max(240);
let width = self.width.get().max(240);
let columns = ((width + 8) / 216).max(1);
let card = (width - 8 * (columns - 1)) / columns;
let mut rows = Vec::new();
@@ -602,6 +627,13 @@ 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(),
@@ -646,8 +678,8 @@ impl Browser {
picture.set_vexpand(true);
content.append(&picture);
}
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
let Some(texture) = decode_thumbnail(&data) else {
Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => {
let Some(texture) = decoded else {
browser
.status
.set_label(&gettext("Couldn't open the photo."));
@@ -683,13 +715,15 @@ pub(crate) fn wire(
hidden: &gtk4::Button,
) {
let title = ui.gallery.title.clone();
let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
header.set_halign(gtk4::Align::End);
// The page's header bar holds these, beside Select (see `sync_header`).
let header = &ui.gallery.gallery_actions;
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);
@@ -709,7 +743,6 @@ 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
@@ -743,12 +776,13 @@ 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::default(),
thumbnails: RefCell::new(Lru::new(THUMB_CACHE)),
thumb_pending: RefCell::default(),
});
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
@@ -794,12 +828,13 @@ 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);
@@ -841,7 +876,9 @@ 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,
@@ -918,11 +955,6 @@ 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"), {
@@ -1000,8 +1032,27 @@ pub(crate) fn wire(
return glib::ControlFlow::Break;
};
let width = scroll.width();
if width > 0 && browser.width.replace(width) != width {
browser.rebuild();
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);
}
}
glib::ControlFlow::Continue
}
@@ -1089,6 +1140,15 @@ 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>,
@@ -1100,20 +1160,17 @@ impl Browser {
if private && !self.unlocked.get() {
return;
}
{
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;
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);
}
return;
}
let key = (self.generation.get(), private, uid.to_owned());
{
@@ -1152,6 +1209,12 @@ 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()
@@ -1160,9 +1223,7 @@ impl Browser {
if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
return;
}
if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response
&& let Some(texture) = decode_thumbnail(&data)
{
if let Some(texture) = texture {
for (picture, icon) in targets {
if let Some(picture) = picture.upgrade() {
picture.set_paintable(Some(&texture));
@@ -1171,12 +1232,27 @@ impl Browser {
icon.set_visible(false);
}
}
let mut cache = browser.thumbnails.borrow_mut();
if cache.len() >= THUMB_CACHE {
cache.pop_front();
}
cache.push_back((private, key.2, texture));
// Capped by count, like before: every entry costs one.
browser
.thumbnails
.borrow_mut()
.insert((private, key.2), texture, 1);
}
});
}
}
#[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);
}
}
+39 -3
View File
@@ -336,6 +336,9 @@ 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.",
),
@@ -672,15 +675,45 @@ fn verify_in_browser(
/// Sign out, after a confirmation: disable+stop the mount service (so the
/// daemon isn't left running without credentials), forget the stored session,
/// and drop back to the login page.
///
/// Changes still queued are named first: they stay staged here and are sent
/// after the next sign-in, but until then they exist nowhere else.
pub(crate) fn sign_out(ui: &Rc<Ui>) {
let rx = spawn_request(ui.dirs.control_socket(), Request::Status);
let ui = ui.clone();
glib::spawn_future_local(async move {
let queued = match rx.recv().await {
Ok(Ok(Response::Status {
pending_uploads,
pending_changes,
parked_uploads,
..
})) => pending_uploads + pending_changes + parked_uploads,
_ => 0,
};
confirm_sign_out(&ui, queued);
});
}
fn confirm_sign_out(ui: &Rc<Ui>, queued: u64) {
let Some(window) = ui_window(ui) else { return };
let ui = ui.clone();
let mut body = gettext(
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
);
if queued > 0 {
let warning = ngettext_f(
"{n} change is not on Proton Drive yet. It stays on this computer and is sent after you sign in again.",
"{n} changes are not on Proton Drive yet. They stay on this computer and are sent after you sign in again.",
queued,
&[],
);
body = format!("{warning}\n\n{body}");
}
confirm_destructive(
&window,
&gettext("Sign Out?"),
&gettext(
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
),
&body,
&gettext("Sign Out"),
move || {
let galleries = ui.drive_galleries.borrow().upgrade();
@@ -711,6 +744,9 @@ 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());
+146 -70
View File
@@ -160,11 +160,10 @@ 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, 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>>,
/// 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>>,
/// 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>>,
@@ -186,12 +185,14 @@ 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)`.
/// 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.
/// [`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.
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>>,
@@ -225,6 +226,9 @@ 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.
@@ -348,11 +352,23 @@ 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 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;
/// 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;
/// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
/// is decoded before it is scrolled onto rather than after.
@@ -524,6 +540,7 @@ 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,
@@ -694,6 +711,12 @@ 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()
@@ -1002,6 +1025,7 @@ 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);
@@ -1031,6 +1055,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
select_btn,
selection,
more,
gallery_actions,
upload_face,
float_heading,
float_label,
@@ -1141,6 +1166,7 @@ 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);
@@ -3247,6 +3273,7 @@ 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;
@@ -3438,9 +3465,16 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
batch
}
/// 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.
/// 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.
pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
return;
@@ -3448,63 +3482,95 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
ui.gallery.decode_idle.set(true);
let ui = ui.clone();
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
})
})
})
};
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;
glib::spawn_future_local(async move {
loop {
let batch = next_decode_batch(&ui);
if batch.is_empty() {
break;
}
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);
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)
})
.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() {
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));
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));
}
}
}
if ui.gallery.decode_queue.borrow().is_empty() {
ui.gallery.decode_idle.set(false);
return glib::ControlFlow::Break;
}
glib::ControlFlow::Continue
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()
}
/// Re-flow the sections on screen shortly. Debounced, because the triggers (a
/// window resize, a zoom step) arrive in floods and only the final state
/// matters.
@@ -4774,13 +4840,23 @@ 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, 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,
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,
};
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 {
+81 -68
View File
@@ -17,6 +17,8 @@
//! 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;
@@ -67,6 +69,11 @@ const COVER_PX: i32 = 128;
/// 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);
@@ -132,13 +139,6 @@ 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,17 +190,6 @@ struct Marker {
target: Target,
}
/// 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,
@@ -232,8 +221,11 @@ 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.
covers: HashMap<String, cairo::ImageSurface>,
/// 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,
asked_thumbs: HashSet<String>,
view: View,
/// False until the view has been fitted to the places at a real size, and
@@ -349,6 +341,7 @@ 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 },
@@ -486,7 +479,18 @@ impl PlacesMap {
let Some(cover) = square_cover(texture) else {
return;
};
self.state.borrow_mut().covers.insert(uid.to_owned(), cover);
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.area.queue_draw();
}
@@ -840,6 +844,7 @@ 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.online.as_mut() {
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
@@ -863,7 +868,10 @@ impl PlacesMap {
}
for bubble in &state.bubbles {
let marker = &state.markers[bubble.members[0]];
let cover = state.covers.get(&marker.cover);
let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| {
*drawn = state.draws;
&*cover
});
if cover.is_none()
&& let Target::Photo { place, index } = marker.target
&& state.asked_thumbs.insert(marker.cover.clone())
@@ -1121,6 +1129,35 @@ 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(
@@ -1595,52 +1632,6 @@ 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()),
@@ -1654,6 +1645,28 @@ 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);
+122 -19
View File
@@ -52,8 +52,9 @@ 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.
fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
let Ok(text) = std::fs::read_to_string(staged_path(ui)) else {
/// Blocking: run it off the GTK thread.
fn load_staged(path: &Path) -> Vec<PathBuf> {
let Ok(text) = std::fs::read_to_string(path) else {
return Vec::new();
};
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
@@ -64,9 +65,39 @@ fn load_staged(ui: &Rc<Ui>) -> 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
@@ -75,12 +106,24 @@ fn save_staged(ui: &Rc<Ui>) {
.map(|p| p.display().to_string())
.collect();
let path = staged_path(ui);
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 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}");
}
});
}
fn empty_list_description() -> String {
@@ -121,6 +164,16 @@ 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.
@@ -490,10 +543,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, before the first
// paint, so the page comes up as the user left it.
*ui.takeout.archives.borrow_mut() = load_staged(ui);
// Restore whatever was staged when the window last closed, so the page
// comes up as the user left it.
repaint_archives(ui);
restore_staged(ui);
}
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
@@ -503,15 +556,36 @@ 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 in paths {
for (path, file) in paths {
let is_zip = path
.extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
if !is_zip || !path.is_file() {
if !is_zip || !file {
rejected += 1;
continue;
}
@@ -542,12 +616,44 @@ pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
}
/// 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
@@ -558,8 +664,8 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
rows.push(row.upcast());
} else {
let mut total = 0u64;
for path in &staged {
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
for (path, size) in &staged {
let size = *size;
total += size;
let row = adw::ActionRow::builder()
.title(
@@ -601,9 +707,6 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
)));
}
*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
+15 -2
View File
@@ -74,7 +74,6 @@ 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 | |
@@ -109,6 +108,7 @@ a live account since.
| Entry | Title |
|---|---|
| [B66](#b66--local-only-pending-data-is-not-protected-at-shutdown-high-21) | Local-only pending data is not protected at shutdown (HIGH-21) |
| [B291](#b291--on-fedora-45s-oo7-every-saved-sign-in-is-lost-at-the-next-reboot) | On Fedora 45's oo7, every saved sign-in is lost at the next reboot |
| [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos |
| [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it |
@@ -7475,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:** Open — 1.0 data-safety/UX blocker
**Status:** Fixed, unverified live
**Found:** 2026-07-22, 1.0 recovery audit
**Where:** shutdown, CLI/GUI status, logout/unregister workflows
@@ -7488,6 +7488,19 @@ and last errors, and protect destructive lifecycle actions. Test offline stop,
logout, unregister, reboot, retry exhaustion, and drain. Credential removal must
never delete staged bytes.
**Fix:** `crates/pdfs-fuse/src/inhibit.rs` takes a logind shutdown inhibitor
(`systemd-inhibit --what=shutdown --mode=block`) while the queue holds changes
the drain can send, and lets it go once they land. Parked transient files and
changes that need the user are left out, so they never hold a power-off up for
good. `pdfs sync flush` retries failed changes and waits for the queue, with
its own exit codes for "needs you" and timeout. `pdfs logout` and the app's
Sign Out dialog say how many changes are still queued and that they stay
staged. Credential removal never touched `staging/`.
**Verified:** unit tests for which work holds the lock; `systemd-inhibit` in
block mode taken by a user process on 2026-11-21. A power-off with a queued
upload is still owed.
---
### B65 — Release artifacts lack supply-chain verification (MED-11)
+15
View File
@@ -11,8 +11,23 @@ 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
- 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
+2 -1
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` | End the session on Proton and remove the stored session. |
| `pdfs logout [--yes]` | End the session on Proton and remove the stored session. Asks first while changes are still queued; they stay on this computer and are sent after the next sign-in. |
| `pdfs status` | Account, mount, queue and cache state. |
| `pdfs quota` | Storage used across all Proton products. |
| `pdfs locations` | Every local place the service occupies: the Proton Drive folder and each synced folder, with mode and state. |
@@ -125,6 +125,7 @@ commands are for scripts and for cases where the mount is not available.
| `pdfs sync ignore check PATH` | Say whether a file in a synced folder is synced, and which pattern decides. |
| `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. |
| `pdfs sync queue` | List changes that have not reached Proton Drive yet. |
| `pdfs sync flush [--timeout SECS]` | Retry failed changes now and wait until the queue is empty. Exits 0 when everything is on Proton Drive, 3 when what is left needs you (see `sync issues`), 4 on timeout. Says so while sync is paused or offline. |
| `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. |
| `pdfs sync export ID DEST` | Save a copy of a queued upload's content. `DEST` may be a folder; an existing file is never overwritten. The upload stays queued. |
| `pdfs sync discard ID [--yes]` | Drop a queued change and undo it here: a new file or folder goes, anything else goes back to what Proton Drive has. Content not exported first is lost. |
+1 -1
View File
@@ -43,7 +43,7 @@ them along.
| Item | State | Notes |
|---|---|---|
| Protect queued changes at shutdown | Not started | A systemd inhibitor lock while `staging/` holds unsent data, a warning when signing out, and a `pdfs sync flush` that waits for the queue. Today the queue is visible in `pdfs sync queue`, the tray and **Sync → Overview**, but nothing stops a shutdown (B66) |
| Protect queued changes at shutdown | Done, live check owed | The daemon holds a logind shutdown inhibitor while the queue holds changes it can send, signing out warns with the count, and `pdfs sync flush` waits for the queue (B66) |
| Restore pins from the machine profile | Not started | `profile.json` records pins; `pdfs sync restore` does not apply them yet |
| Profile backup health | Not started | A failed profile upload is a `WARN` in the log and nothing in the app (B68) |
| Rotated credentials survive a keyring failure | Open | Report and retry keyring write failures, so a rotated single-use refresh token is not lost (B61) |
+411 -388
View File
File diff suppressed because it is too large. Load diff
+407 -387
View File
File diff suppressed because it is too large. Load diff
+410 -388
View File
File diff suppressed because it is too large. Load diff
+411 -388
View File
File diff suppressed because it is too large. Load diff
+409 -388
View File
File diff suppressed because it is too large. Load diff
+410 -388
View File
File diff suppressed because it is too large. Load diff
+401 -387
View File
File diff suppressed because it is too large. Load diff
+408 -387
View File
File diff suppressed because it is too large. Load diff
+407 -387
View File
File diff suppressed because it is too large. Load diff