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
27 changed files with 4665 additions and 6411 deletions

No files matched your search

Generated
+13 -38
View File
@@ -1476,7 +1476,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [ dependencies = [
"libc", "libc",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -1931,7 +1931,7 @@ dependencies = [
"gobject-sys", "gobject-sys",
"libc", "libc",
"system-deps 9.0.1", "system-deps 9.0.1",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -3633,7 +3633,6 @@ dependencies = [
"libc", "libc",
"parking_lot 0.13.0", "parking_lot 0.13.0",
"proton-auth-rs", "proton-auth-rs",
"proton-base-rs",
"proton-drive-rs", "proton-drive-rs",
"proton-gallery-rs", "proton-gallery-rs",
"proton-sdk", "proton-sdk",
@@ -3669,7 +3668,6 @@ dependencies = [
"proton-drive-rs", "proton-drive-rs",
"proton-gallery-app-rs", "proton-gallery-app-rs",
"proton-gallery-rs", "proton-gallery-rs",
"proton-media-rs",
"rustix", "rustix",
"serde", "serde",
"serde_json", "serde_json",
@@ -3926,9 +3924,9 @@ dependencies = [
[[package]] [[package]]
name = "proton-auth-rs" name = "proton-auth-rs"
version = "0.1.1" version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc" checksum = "e140db8b4444e50c818c9793c2078b57c16c5b6c285a8d4bbd74886f41b05c6f"
dependencies = [ dependencies = [
"apple-native-keyring-store", "apple-native-keyring-store",
"dbus-secret-service", "dbus-secret-service",
@@ -3940,21 +3938,11 @@ dependencies = [
"zeroize", "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]] [[package]]
name = "proton-drive-rs" name = "proton-drive-rs"
version = "0.12.2" version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bdeb7ee7495bc34198c78d7ec569f6371ad01a88f188b5eee418b013b082626a" checksum = "d05ad4be849ce2104759631063dd06867fbe6b6f0e5c37a172a84b5a90203fa7"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"base64 0.23.1", "base64 0.23.1",
@@ -4044,24 +4032,11 @@ dependencies = [
"zip", "zip",
] ]
[[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]] [[package]]
name = "proton-sdk" name = "proton-sdk"
version = "0.12.2" version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3189873dcdf0bc0a3d0fa5619cea80594085252d1d66a57459ec6adfd1f35ac1" checksum = "80c381e9066c0bca3c32597df2e902eecaa4c6e05e202e70ec9d0ac2eec78bfe"
dependencies = [ dependencies = [
"aes-gcm 0.11.1", "aes-gcm 0.11.1",
"async-trait", "async-trait",
@@ -4180,7 +4155,7 @@ dependencies = [
"once_cell", "once_cell",
"socket2", "socket2",
"tracing", "tracing",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -4635,7 +4610,7 @@ dependencies = [
"errno", "errno",
"libc", "libc",
"linux-raw-sys", "linux-raw-sys",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -4692,7 +4667,7 @@ dependencies = [
"security-framework", "security-framework",
"security-framework-sys", "security-framework-sys",
"webpki-root-certs", "webpki-root-certs",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -5200,7 +5175,7 @@ dependencies = [
"getrandom 0.4.3", "getrandom 0.4.3",
"once_cell", "once_cell",
"rustix", "rustix",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -5865,7 +5840,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
+3 -5
View File
@@ -15,8 +15,8 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
categories = ["filesystem", "command-line-utilities"] categories = ["filesystem", "command-line-utilities"]
[workspace.dependencies] [workspace.dependencies]
proton-sdk = { version = "0.12.2" } proton-sdk = { version = "0.12.1" }
proton-drive-rs = { version = "0.12.2" } proton-drive-rs = { version = "0.12.1" }
proton-gallery-app-rs = "0.1.0" proton-gallery-app-rs = "0.1.0"
proton-gallery-rs = "0.1.1" proton-gallery-rs = "0.1.1"
chrono = { version = "0.4", default-features = false, features = ["std"] } chrono = { version = "0.4", default-features = false, features = ["std"] }
@@ -65,9 +65,7 @@ rusqlite = { version = "0.41", features = ["bundled"] }
keyring-core = "1" keyring-core = "1"
# The keyring store all three apps share: reconnects after a Secret Service # The keyring store all three apps share: reconnects after a Secret Service
# restart (B285) and replaces items instead of editing them (B291). # restart (B285) and replaces items instead of editing them (B291).
proton-auth-rs = "0.1.1" proton-auth-rs = "0.1"
proton-base-rs = "0.1"
proton-media-rs = "0.1.1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] } dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an # 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). # item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
-1
View File
@@ -26,7 +26,6 @@ sha2.workspace = true
rusqlite.workspace = true rusqlite.workspace = true
keyring-core.workspace = true keyring-core.workspace = true
proton-auth-rs = { workspace = true, features = ["keyring"] } proton-auth-rs = { workspace = true, features = ["keyring"] }
proton-base-rs.workspace = true
dbus-secret-service-keyring-store.workspace = true dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true dbus-secret-service.workspace = true
parking_lot.workspace = true parking_lot.workspace = true
+71 -57
View File
@@ -36,7 +36,6 @@ use proton_sdk::cache::EncryptedCacheRepository;
use proton_sdk::config::ProtonClientConfiguration; use proton_sdk::config::ProtonClientConfiguration;
use proton_sdk::error::ProtonError; use proton_sdk::error::ProtonError;
use proton_sdk::http::Tokens; use proton_sdk::http::Tokens;
use proton_sdk::login::{self, LoginError, Step};
use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters}; use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters};
use proton_sdk::telemetry::TracingTelemetry; use proton_sdk::telemetry::TracingTelemetry;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@@ -280,56 +279,74 @@ pub async fn login_verified(
get_totp: impl Fn() -> Result<String>, get_totp: impl Fn() -> Result<String>,
get_mailbox: impl Fn(u32) -> Result<Mailbox>, get_mailbox: impl Fn(u32) -> Result<Mailbox>,
) -> Result<()> { ) -> Result<()> {
// The sequence is `proton_sdk::login`, shared with the other Proton let password = Zeroizing::new(password.to_owned());
// apps. It reads the key salts before unlocking, while this access token let session = ProtonApiSession::begin_verified(
// still has the `locked` scope: after its first refresh it never will client_config(),
// again, and without them no later resume can unlock the key chain. See username,
// `StoredSession::key_salts`. password.as_bytes(),
let mut step = login::begin(client_config(), username, password, verification) verification,
.await )
.map_err(sign_in_error)?; .await
let (unlocked, remember) = loop { .map_err(classify_verification_gate);
step = match step { let mut session = session?;
Step::SecondFactor(pending) => {
let code = get_totp()?; if session.is_waiting_for_second_factor() {
pending.second_factor(&code).await.map_err(sign_in_error)? let code = get_totp()?;
} session.apply_second_factor_code(code.trim()).await?;
// 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 // Grab the key salts while this access token still has the `locked` scope:
// checked against the account now — a typo found at login is a retry, // after its first refresh it never will again, and without them no later
// found later it is a daemon that never mounts. // resume can unlock the key chain. See `StoredSession::key_salts`.
Step::MailboxPassword(pending) => { let key_salts = ProtonDriveClient::new(&session, Vec::new())
let mut attempt = 0; .account()
break loop { .key_salts()
let mailbox = get_mailbox(attempt)?; .await?;
match pending.mailbox_password(&mailbox.password).await {
Ok(unlocked) => break (unlocked, mailbox.remember), // A single-password account's mailbox password is the login password. A
Err(LoginError::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => { // two-password one has a second secret the user must type, and it is checked
attempt += 1; // against the account now — a typo found at login is a retry, found later it
} // is a daemon that never mounts.
Err(e) => return Err(sign_in_error(e)), 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; let tokens = session.current_tokens().await;
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone()); register_refresh_handler(&session, tokens.refresh_token.clone());
let stored = StoredSession { let stored = StoredSession {
session_id: tokens.session_id.as_str().to_owned(), session_id: session.session_id().as_str().to_owned(),
username: tokens.username, username: session.username().to_owned(),
user_id: tokens.user_id.as_str().to_owned(), user_id: session.user_id().as_str().to_owned(),
access_token: tokens.access_token, access_token: tokens.access_token,
refresh_token: tokens.refresh_token, refresh_token: tokens.refresh_token,
scopes: tokens.scopes, scopes: session.scopes().to_vec(),
password_mode: tokens.password_mode.to_wire() as u8, password_mode: match session.password_mode() {
PasswordMode::Single => 1,
PasswordMode::Dual => 2,
},
mailbox_password: String::new(), mailbox_password: String::new(),
key_salts: unlocked.key_salts, key_salts,
key_passphrases: None, 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. /// 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()?) 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 /// Only a gate that names a solvable method is converted. A `9001` with no
/// came from, which is what the front-ends word themselves. Only a gate that /// `Details`, or one offering only `email`/`sms`, stays a plain API error:
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that /// promoting it would send the UI to open a verification page it cannot
/// offers only `email`/`sms` stays a plain API error, because sending the UI to /// complete, which reads to the user as a hang rather than a refusal.
/// open a page it cannot complete reads as a hang rather than a refusal. fn classify_verification_gate(e: ProtonError) -> Error {
fn sign_in_error(e: LoginError) -> Error { let ProtonError::Api(api) = &e else {
match e { return e.into();
LoginError::HumanVerification(hv) => Error::HumanVerificationRequired(hv), };
LoginError::SecurityKeyOnly => Error::SecurityKeyOnly, match api.human_verification() {
LoginError::Blocked(api) | LoginError::Rejected(api) | LoginError::WrongCode(api) => { Some(hv) if hv.supports_captcha() => Error::HumanVerificationRequired(Box::new(hv)),
Error::Proton(ProtonError::Api(api)) _ => e.into(),
}
LoginError::WrongMailboxPassword => Error::WrongMailboxPassword,
LoginError::Proton(e) => e.into(),
other => Error::Other(other.to_string()),
} }
} }
+29 -3
View File
@@ -457,7 +457,26 @@ fn load_config_at(path: &Path) -> AppConfig {
/// [`AppDirs::save_config`] for the file at `path`. /// [`AppDirs::save_config`] for the file at `path`.
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> { fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
refuse_to_replace_unreadable(path)?; 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(()) Ok(())
} }
@@ -602,8 +621,15 @@ impl AppDirs {
use std::io::Read as _; use std::io::Read as _;
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?; std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect(); let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
// Not secret, and other tools may read it; keep it world-readable. let parent = path
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?; .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) Ok(id)
} }
-8
View File
@@ -42,13 +42,6 @@ pub enum Error {
#[error("that mailbox password does not unlock your account")] #[error("that mailbox password does not unlock your account")]
WrongMailboxPassword, 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 /// 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 /// 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)). /// 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::ReloginRequired
| Error::Locked | Error::Locked
| Error::WrongMailboxPassword | Error::WrongMailboxPassword
| Error::SecurityKeyOnly
| Error::HumanVerificationRequired(_) => ErrorKind::Denied, | Error::HumanVerificationRequired(_) => ErrorKind::Denied,
Error::Proton(proton) => proton_kind(proton), Error::Proton(proton) => proton_kind(proton),
_ => ErrorKind::Internal, _ => 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. /// and renamed, so a reader never sees half of it.
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> { pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?; 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. /// 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-drive-rs.workspace = true
proton-gallery-app-rs.workspace = true proton-gallery-app-rs.workspace = true
proton-gallery-rs.workspace = true proton-gallery-rs.workspace = true
proton-media-rs.workspace = true
hyper = { version = "1", features = ["http1", "server"] } hyper = { version = "1", features = ["http1", "server"] }
hyper-util = { version = "0.1", features = ["tokio"] } hyper-util = { version = "0.1", features = ["tokio"] }
http-body-util = "0.1" http-body-util = "0.1"
+76 -8
View File
@@ -212,12 +212,15 @@ impl BlockRing {
} }
/// The result of fetching one block, shared between everyone who wanted it. /// 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 /// 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 /// range the block covers — see [`RingKey`] for why it is the range and not the
/// index. /// 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 /// Block fetches in flight, so a block is downloaded and decrypted once however
/// many readers want it at that moment (audit T1). /// 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 /// 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 /// but one result is discarded — roughly double the bandwidth and CPU in steady
/// state. Same shape as [`ReaderSlot::Pending`] one level up. /// 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 /// 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). /// told from random ones and only the former prefetched (audit T2).
@@ -551,11 +581,49 @@ impl Core {
cache_blocks: bool, cache_blocks: bool,
) -> BlockResult { ) -> BlockResult {
let key: BlockKey = (uid.clone(), mtime, fsize, span); let key: BlockKey = (uid.clone(), mtime, fsize, span);
self.block_flight let claim = {
.join(key, || { let mut inflight = self.block_flight.inflight.lock();
self.read_block(reader, uid, mtime, fsize, span, cache_blocks) match inflight.get(&key) {
}) Some((_, rx)) => Err(rx.clone()),
.await 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 /// Download and decrypt one block, then put it where the next reader will
+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.decode_queue.borrow_mut().clear();
ui.gallery.thumb_wanted.borrow_mut().clear(); ui.gallery.thumb_wanted.borrow_mut().clear();
ui.gallery.photo_tex.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.model.remove_all();
ui.gallery.groups.remove_all(); ui.gallery.groups.remove_all();
ui.gallery.row_by_photo.borrow_mut().clear(); 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);
}
}
+20 -15
View File
@@ -6,7 +6,6 @@ pub(crate) mod dates;
pub(crate) mod events; pub(crate) mod events;
#[path = "../i18n.rs"] #[path = "../i18n.rs"]
pub(crate) mod i18n; pub(crate) mod i18n;
pub(crate) mod lru;
pub(crate) mod pages; pub(crate) mod pages;
pub(crate) mod reload; pub(crate) mod reload;
#[path = "../theme.rs"] #[path = "../theme.rs"]
@@ -16,7 +15,6 @@ pub(crate) mod widgets;
use compat::*; use compat::*;
use events::*; use events::*;
use lru::Lru;
use pages::activity::*; use pages::activity::*;
use pages::albums::*; use pages::albums::*;
use pages::browser::*; use pages::browser::*;
@@ -192,11 +190,16 @@ impl Ui {
/// Scrolling back over a day then repaints from memory rather than decoding /// Scrolling back over a day then repaints from memory rather than decoding
/// the same JPEGs off disk again. /// the same JPEGs off disk again.
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) { fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
let bytes = texture_bytes(texture.width(), texture.height()); let mut cache = self.gallery.photo_tex.borrow_mut();
self.gallery let mut order = self.gallery.photo_tex_order.borrow_mut();
.photo_tex if cache.insert(uid.to_string(), texture).is_none() {
.borrow_mut() order.push_back(uid.to_string());
.insert(uid.to_string(), texture, bytes); }
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 /// 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 /// Insertion order alone evicts the top of the timeline first — exactly what
/// a scroll back up then asks for again. /// a scroll back up then asks for again.
fn touch_texture(&self, uid: &str) { 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());
}
} }
} }
@@ -621,7 +631,8 @@ fn build_window(app: &adw::Application) {
library: Cell::new(true), library: Cell::new(true),
page_waiters: RefCell::new(Vec::new()), page_waiters: RefCell::new(Vec::new()),
width: Cell::new(0), 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()), photo_nothumb: RefCell::new(HashSet::new()),
thumb_wanted: RefCell::new(HashMap::new()), thumb_wanted: RefCell::new(HashMap::new()),
thumb_queue: RefCell::new(VecDeque::new()), thumb_queue: RefCell::new(VecDeque::new()),
@@ -629,7 +640,6 @@ fn build_window(app: &adw::Application) {
thumb_generation: Cell::new(0), thumb_generation: Cell::new(0),
decode_queue: RefCell::new(VecDeque::new()), decode_queue: RefCell::new(VecDeque::new()),
decode_idle: Cell::new(false), decode_idle: Cell::new(false),
decode_inflight: RefCell::default(),
thumb_source: RefCell::new(None), thumb_source: RefCell::new(None),
relayout_source: RefCell::new(None), relayout_source: RefCell::new(None),
bound: RefCell::new(BTreeMap::new()), bound: RefCell::new(BTreeMap::new()),
@@ -642,7 +652,6 @@ fn build_window(app: &adw::Application) {
select_btn: gallery_widgets.select_btn.clone(), select_btn: gallery_widgets.select_btn.clone(),
selection: gallery_widgets.selection.clone(), selection: gallery_widgets.selection.clone(),
more: gallery_widgets.more.clone(), more: gallery_widgets.more.clone(),
gallery_actions: gallery_widgets.gallery_actions.clone(),
upload_face: gallery_widgets.upload_face.clone(), upload_face: gallery_widgets.upload_face.clone(),
float_heading: gallery_widgets.float_heading.clone(), float_heading: gallery_widgets.float_heading.clone(),
float_label: gallery_widgets.float_label.clone(), float_label: gallery_widgets.float_label.clone(),
@@ -728,10 +737,6 @@ fn build_window(app: &adw::Application) {
resume_button: takeout_widgets.resume_button.clone(), resume_button: takeout_widgets.resume_button.clone(),
inflight: Cell::new(false), inflight: Cell::new(false),
running: 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, update,
}); });
+40 -116
View File
@@ -1,32 +1,10 @@
use crate::*; use crate::*;
use base64::{Engine, engine::general_purpose::STANDARD}; use base64::{Engine, engine::general_purpose::STANDARD};
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace}; use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
use std::collections::VecDeque;
const PAGE: usize = 150; const PAGE: usize = 150;
/// Decoded thumbnails kept, the least recently shown dropped first.
const THUMB_CACHE: usize = 256; 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 ThumbnailKey = (u64, bool, String);
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>); type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
@@ -67,15 +45,12 @@ pub(crate) struct Browser {
albums: RefCell<Vec<GalleryAlbum>>, albums: RefCell<Vec<GalleryAlbum>>,
items: RefCell<Vec<PhotoItem>>, items: RefCell<Vec<PhotoItem>>,
width: Cell<i32>, width: Cell<i32>,
/// The pending re-flow after a resize, replaced by each new width.
reflow: RefCell<Option<glib::SourceId>>,
generation: Cell<u64>, generation: Cell<u64>,
total: Cell<usize>, total: Cell<usize>,
loading: Cell<bool>, loading: Cell<bool>,
unlocked: Cell<bool>, unlocked: Cell<bool>,
thumbnail_slots: tokio::sync::Semaphore, thumbnail_slots: tokio::sync::Semaphore,
/// Decoded thumbnails by whether they are hidden-album ones and uid. thumbnails: RefCell<VecDeque<(bool, String, gtk4::gdk::Texture)>>,
thumbnails: RefCell<Lru<(bool, String), gtk4::gdk::Texture>>,
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>, thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
} }
@@ -111,7 +86,7 @@ impl Browser {
} }
self.thumbnails self.thumbnails
.borrow_mut() .borrow_mut()
.retain(|(private, _), _| !private); .retain(|(private, _, _)| !private);
self.thumb_pending.borrow_mut().clear(); self.thumb_pending.borrow_mut().clear();
self.trail.borrow_mut().clear(); self.trail.borrow_mut().clear();
self.chooser.borrow_mut().take(); self.chooser.borrow_mut().take();
@@ -577,7 +552,7 @@ impl Browser {
if self.chooser.borrow().is_some() { if self.chooser.borrow().is_some() {
return; return;
} }
let width = self.width.get().max(240); let width = (self.width.get() - 24).max(240);
let columns = ((width + 8) / 216).max(1); let columns = ((width + 8) / 216).max(1);
let card = (width - 8 * (columns - 1)) / columns; let card = (width - 8 * (columns - 1)) / columns;
let mut rows = Vec::new(); let mut rows = Vec::new();
@@ -627,13 +602,6 @@ impl Browser {
let generation = self.generation.get(); let generation = self.generation.get();
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
let result = reply.recv().await; 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 close = |token| {
let _ = spawn_request( let _ = spawn_request(
browser.ui.dirs.control_socket(), browser.ui.dirs.control_socket(),
@@ -678,8 +646,8 @@ impl Browser {
picture.set_vexpand(true); picture.set_vexpand(true);
content.append(&picture); content.append(&picture);
} }
Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => { Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
let Some(texture) = decoded else { let Some(texture) = decode_thumbnail(&data) else {
browser browser
.status .status
.set_label(&gettext("Couldn't open the photo.")); .set_label(&gettext("Couldn't open the photo."));
@@ -715,15 +683,13 @@ pub(crate) fn wire(
hidden: &gtk4::Button, hidden: &gtk4::Button,
) { ) {
let title = ui.gallery.title.clone(); let title = ui.gallery.title.clone();
// The page's header bar holds these, beside Select (see `sync_header`). let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
let header = &ui.gallery.gallery_actions; header.set_halign(gtk4::Align::End);
let choose = gtk4::Button::with_label(&gettext("Add This Folder")); let choose = gtk4::Button::with_label(&gettext("Add This Folder"));
choose.set_visible(false); choose.set_visible(false);
choose.add_css_class("suggested-action");
header.append(&choose); header.append(&choose);
let more = gtk4::Button::from_icon_name("view-more-symbolic"); let more = gtk4::Button::from_icon_name("view-more-symbolic");
more.set_tooltip_text(Some(&gettext("Gallery Options"))); more.set_tooltip_text(Some(&gettext("Gallery Options")));
more.add_css_class("flat");
let unlock = gtk4::Button::with_label(&gettext("Unlock")); let unlock = gtk4::Button::with_label(&gettext("Unlock"));
unlock.set_visible(false); unlock.set_visible(false);
header.append(&unlock); header.append(&unlock);
@@ -743,6 +709,7 @@ pub(crate) fn wire(
let status = gtk4::Label::new(None); let status = gtk4::Label::new(None);
status.set_wrap(true); status.set_wrap(true);
let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0); let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
content.append(&header);
content.append(&status); content.append(&status);
content.append(&scroll); content.append(&scroll);
ui.gallery ui.gallery
@@ -776,13 +743,12 @@ pub(crate) fn wire(
albums: RefCell::new(Vec::new()), albums: RefCell::new(Vec::new()),
items: RefCell::new(Vec::new()), items: RefCell::new(Vec::new()),
width: Cell::new(0), width: Cell::new(0),
reflow: RefCell::new(None),
generation: Cell::new(0), generation: Cell::new(0),
total: Cell::new(0), total: Cell::new(0),
loading: Cell::new(false), loading: Cell::new(false),
unlocked: Cell::new(false), unlocked: Cell::new(false),
thumbnail_slots: tokio::sync::Semaphore::new(8), thumbnail_slots: tokio::sync::Semaphore::new(8),
thumbnails: RefCell::new(Lru::new(THUMB_CACHE)), thumbnails: RefCell::default(),
thumb_pending: RefCell::default(), thumb_pending: RefCell::default(),
}); });
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser); *ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
@@ -828,13 +794,12 @@ pub(crate) fn wire(
return; return;
}; };
let row = data.borrow::<Row>(); 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); let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
line.set_margin_start(12);
line.set_margin_end(12);
line.set_margin_bottom(8); line.set_margin_bottom(8);
match &*row { match &*row {
Row::Heading(label) => { Row::Heading(label) => {
line.set_margin_top(12);
let label = gtk4::Label::new(Some(label)); let label = gtk4::Label::new(Some(label));
label.add_css_class("heading"); label.add_css_class("heading");
line.append(&label); line.append(&label);
@@ -876,9 +841,7 @@ pub(crate) fn wire(
} }
} }
Row::Media(items) => { Row::Media(items) => {
// The same gap down as across, as in the timeline.
line.set_spacing(super::photos::TILE_GAP); line.set_spacing(super::photos::TILE_GAP);
line.set_margin_bottom(super::photos::TILE_GAP);
for (item, (width, height)) in items { for (item, (width, height)) in items {
let button = tile( let button = tile(
&browser, &browser,
@@ -955,6 +918,11 @@ pub(crate) fn wire(
let browser = browser.clone(); let browser = browser.clone();
move || browser.close() 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) { if let Some(album) = browser.current().filter(|album| !album.proton) {
menu.item(&gettext("Choose Cover"), { menu.item(&gettext("Choose Cover"), {
@@ -1032,27 +1000,8 @@ pub(crate) fn wire(
return glib::ControlFlow::Break; return glib::ControlFlow::Break;
}; };
let width = scroll.width(); let width = scroll.width();
match reflow_for(browser.width.get(), width) { if width > 0 && browser.width.replace(width) != width {
Reflow::None => {} browser.rebuild();
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 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() 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 { impl Browser {
fn want_thumbnail( fn want_thumbnail(
self: &Rc<Self>, self: &Rc<Self>,
@@ -1160,17 +1100,20 @@ impl Browser {
if private && !self.unlocked.get() { if private && !self.unlocked.get() {
return; return;
} }
let cached = self {
.thumbnails let mut cache = self.thumbnails.borrow_mut();
.borrow_mut() if let Some(index) = cache
.fetch(&(private, uid.to_owned())) .iter()
.cloned(); .position(|(p, id, _)| *p == private && id == uid)
if let Some(texture) = cached { {
picture.set_paintable(Some(&texture)); let cached = cache.remove(index).unwrap();
if let Some(icon) = icon.upgrade() { picture.set_paintable(Some(&cached.2));
icon.set_visible(false); 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()); let key = (self.generation.get(), private, uid.to_owned());
{ {
@@ -1209,12 +1152,6 @@ impl Browser {
}, },
); );
let response = request.recv().await; 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 let targets = browser
.thumb_pending .thumb_pending
.borrow_mut() .borrow_mut()
@@ -1223,7 +1160,9 @@ impl Browser {
if key.0 != browser.generation.get() || private && !browser.unlocked.get() { if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
return; 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 { for (picture, icon) in targets {
if let Some(picture) = picture.upgrade() { if let Some(picture) = picture.upgrade() {
picture.set_paintable(Some(&texture)); picture.set_paintable(Some(&texture));
@@ -1232,27 +1171,12 @@ impl Browser {
icon.set_visible(false); icon.set_visible(false);
} }
} }
// Capped by count, like before: every entry costs one. let mut cache = browser.thumbnails.borrow_mut();
browser if cache.len() >= THUMB_CACHE {
.thumbnails cache.pop_front();
.borrow_mut() }
.insert((private, key.2), texture, 1); 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);
}
}
-6
View File
@@ -336,9 +336,6 @@ pub(crate) fn login_error_message(error: &pdfs_core::Error) -> String {
pdfs_core::Error::WrongMailboxPassword => { pdfs_core::Error::WrongMailboxPassword => {
gettext("That mailbox password didn't unlock your account.") 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( 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.", "Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
), ),
@@ -714,9 +711,6 @@ mod tests {
#[test] #[test]
fn a_cancelled_prompt_says_which_step_was_skipped() { 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()); let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
assert!(login_error_message(&totp).contains("two-factor code")); assert!(login_error_message(&totp).contains("two-factor code"));
let hv = pdfs_core::Error::Other("verification cancelled".into()); let hv = pdfs_core::Error::Other("verification cancelled".into());
+70 -146
View File
@@ -160,10 +160,11 @@ pub(crate) struct GalleryState {
/// Content width the grid is currently laid out to. Updated when the /// Content width the grid is currently laid out to. Updated when the
/// ListView is resized, which re-flows the visible sections. /// ListView is resized, which re-flows the visible sections.
pub(crate) width: Cell<i32>, pub(crate) width: Cell<i32>,
/// Decoded thumbnails by photo uid, the least recently used evicted once /// Decoded thumbnails by photo uid, with the insertion order that evicts the
/// their pixels pass [`TEXTURE_CACHE_BYTES`]. Scrolling back over a day /// oldest past [`TEXTURE_CACHE_MAX`]. Scrolling back over a day therefore
/// therefore repaints from memory instead of re-decoding from disk. /// repaints from memory instead of re-decoding from disk.
pub(crate) photo_tex: RefCell<Lru<String, gtk4::gdk::Texture>>, 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 /// 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. /// can never be filled isn't requested again on every scroll past it.
pub(crate) photo_nothumb: RefCell<HashSet<String>>, 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_inflight: RefCell<HashSet<String>>,
pub(crate) thumb_generation: Cell<u64>, pub(crate) thumb_generation: Cell<u64>,
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`. /// 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 /// Decoding happens on the GTK thread (textures are not `Send`), so it is fed
/// the scroll never waits on a JPEG decoder. [`Self::decode_idle`] is the /// a few at a time from an idle callback rather than in one blocking burst
/// "decoder already running" guard, and [`Self::decode_inflight`] the uids /// that would stutter the scroll. [`Self::decode_idle`] is the "callback
/// being decoded right now, so a tile rebound meanwhile doesn't queue its /// already scheduled" guard.
/// photo a second time.
pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>, pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>,
pub(crate) decode_idle: Cell<bool>, pub(crate) decode_idle: Cell<bool>,
pub(crate) decode_inflight: RefCell<HashSet<String>>,
/// Pending debounce timers for the thumbnail queue flush and the section /// Pending debounce timers for the thumbnail queue flush and the section
/// re-flow, replaced on each new trigger so only the last one fires. /// re-flow, replaced on each new trigger so only the last one fires.
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>, 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 /// The header's page menu and the Upload button's face, which drops its
/// label in a narrow window. /// label in a narrow window.
pub(crate) more: gtk4::MenuButton, 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, pub(crate) upload_face: adw::ButtonContent,
/// The section the top of the timeline is in, floating over the grid /// The section the top of the timeline is in, floating over the grid
/// once its own heading has scrolled away. /// 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. /// in seconds, not milliseconds.
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4); pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
/// Decoded thumbnail pixels held in memory, evicted least-recently-*used* /// Decoded thumbnails held in memory, evicted least-recently-*used* first. Each
/// first. Budgeted by bytes rather than by count, because one oversized /// is a few hundred KiB of GPU texture, and at the justified row density 600 was
/// thumbnail costs as much as dozens of ordinary ones. A 512 px thumbnail is /// under two screens' worth — a scroll down and back up then had to re-fetch and
/// about 600 KiB decoded, so this holds roughly 900 of them: at the justified /// re-decode everything it had just shown.
/// row density 600 was under two screens' worth, and a scroll down and back up pub(crate) const TEXTURE_CACHE_MAX: usize = 1500;
/// 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 /// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
/// is decoded before it is scrolled onto rather than after. /// 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) select_btn: gtk4::Button,
pub(crate) selection: SelectionBar, pub(crate) selection: SelectionBar,
pub(crate) more: gtk4::MenuButton, pub(crate) more: gtk4::MenuButton,
pub(crate) gallery_actions: gtk4::Box,
pub(crate) upload_face: adw::ButtonContent, pub(crate) upload_face: adw::ButtonContent,
pub(crate) float_heading: gtk4::Revealer, pub(crate) float_heading: gtk4::Revealer,
pub(crate) float_label: gtk4::Label, pub(crate) float_label: gtk4::Label,
@@ -711,12 +694,6 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
.build(); .build();
more.add_css_class("flat"); 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 // 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. // trades the page's own controls for Cancel and a count, as GNOME apps do.
let select_btn = gtk4::Button::builder() 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(&back);
header.pack_start(&upload); header.pack_start(&upload);
header.pack_end(&more); header.pack_end(&more);
header.pack_end(&gallery_actions);
header.pack_end(&select_btn); header.pack_end(&select_btn);
header.pack_end(&selection.cancel); header.pack_end(&selection.cancel);
@@ -1055,7 +1031,6 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
select_btn, select_btn,
selection, selection,
more, more,
gallery_actions,
upload_face, upload_face,
float_heading, float_heading,
float_label, float_label,
@@ -1166,7 +1141,6 @@ pub(crate) fn sync_header(ui: &Rc<Ui>) {
gallery.back.set_visible(!selecting && collection); gallery.back.set_visible(!selecting && collection);
gallery.upload.set_visible(!selecting && !collection); gallery.upload.set_visible(!selecting && !collection);
gallery.more.set_visible(!selecting && !galleries); gallery.more.set_visible(!selecting && !galleries);
gallery.gallery_actions.set_visible(!selecting && galleries);
gallery.select_btn.set_visible(!selecting && timeline); gallery.select_btn.set_visible(!selecting && timeline);
gallery.selection.title.set_visible(selecting); gallery.selection.title.set_visible(selecting);
gallery.selection.cancel.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(); let mut decode = ui.gallery.decode_queue.borrow_mut();
if decode.iter().any(|(uid, _)| uid == &photo.uid) if decode.iter().any(|(uid, _)| uid == &photo.uid)
|| ui.gallery.decode_inflight.borrow().contains(&photo.uid)
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid) || ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
{ {
return; return;
@@ -3465,16 +3438,9 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
batch batch
} }
/// Decode queued thumbnails into textures on worker threads, a few at a time, /// Decode queued thumbnails into textures on an idle callback, a few per pass, so
/// and hand each finished texture to the tiles still waiting for it. /// a big batch fills in progressively instead of freezing the scroll for the
/// /// length of the whole decode.
/// 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>) { pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() { if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
return; return;
@@ -3482,93 +3448,61 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
ui.gallery.decode_idle.set(true); ui.gallery.decode_idle.set(true);
let ui = ui.clone(); let ui = ui.clone();
glib::spawn_future_local(async move { glib::idle_add_local(move || {
loop { let batch: Vec<(String, String)> = {
let batch = next_decode_batch(&ui); let mut queue = ui.gallery.decode_queue.borrow_mut();
if batch.is_empty() { let wanted = ui.gallery.thumb_wanted.borrow();
break; let list = &ui.gallery.list;
} let visible = |uid: &str| {
let generation = ui.gallery.thumb_generation.get(); wanted.get(uid).is_some_and(|pictures| {
ui.gallery pictures.iter().any(|picture| {
.decode_inflight if !picture.is_mapped() {
.borrow_mut() return false;
.extend(batch.iter().map(|(uid, _)| uid.clone())); }
// All of the batch decodes at once, on the worker pool; the results !picture.is_ancestor(list)
// are collected in the order they were picked. || picture.compute_bounds(list).is_some_and(|bounds| {
let jobs: Vec<_> = batch bounds.y() + bounds.height() > 0.0
.into_iter() && bounds.y() < list.height() as f32
.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 { queue.retain(|(uid, _)| wanted.contains_key(uid));
let decoded = job.await; (0..4)
ui.gallery.decode_inflight.borrow_mut().remove(&uid); .filter_map(|_| {
if generation != ui.gallery.thumb_generation.get() { 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; continue;
} }
let texture = match decoded { };
Ok(Ok(texture)) => texture, ui.store_texture(&uid, texture.clone());
Ok(Err(e)) => { let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
tracing::debug!("cannot decode thumbnail {path}: {e}"); for picture in waiting.into_iter().flatten() {
ui.gallery.photo_nothumb.borrow_mut().insert(uid); picture.set_paintable(Some(&texture));
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.gallery.decode_idle.set(false);
});
}
/// Take the next few thumbnails to decode off the queue: the ones on screen if ui.gallery.decode_queue.borrow().is_empty() {
/// first, then in queue order, skipping tiles nobody waits for any more and ui.gallery.decode_idle.set(false);
/// photos already decoded. return glib::ControlFlow::Break;
fn next_decode_batch(ui: &Rc<Ui>) -> Vec<(String, String)> { }
let mut queue = ui.gallery.decode_queue.borrow_mut(); glib::ControlFlow::Continue
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 /// 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)] #[cfg(test)]
mod tests { mod tests {
use super::{ use super::{
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TEXTURE_CACHE_BYTES, Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TILE_GAP, TILE_RATIO_MAX,
TILE_GAP, TILE_RATIO_MAX, TILE_RATIO_MIN, active_filters, copy_without_overwrite, TILE_RATIO_MIN, active_filters, copy_without_overwrite, empty_timeline_text, grouping_for,
empty_timeline_text, grouping_for, memory_years, month_index, month_range, plan_grid, memory_years, month_index, month_range, plan_grid, plan_justified, section_heading,
plan_justified, section_heading, texture_bytes, tile_ratio, viewport_unfilled, tile_ratio, viewport_unfilled,
}; };
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth}; 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] #[test]
fn the_scrubber_finds_the_month_a_photo_was_taken_in() { fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth { let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
+4 -79
View File
@@ -67,11 +67,6 @@ const COVER_PX: i32 = 128;
/// How many street-map tiles stay in memory. /// How many street-map tiles stay in memory.
const TILE_CACHE: usize = 160; 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 /// How long a tile that couldn't be had is left alone before it is tried
/// again. /// again.
const TILE_RETRY: Duration = Duration::from_secs(60); const TILE_RETRY: Duration = Duration::from_secs(60);
@@ -237,11 +232,8 @@ struct MapState {
/// for from close up. /// for from close up.
locations: HashMap<u32, Vec<(PhotoItem, World)>>, locations: HashMap<u32, Vec<(PhotoItem, World)>>,
asked_locations: HashSet<u32>, asked_locations: HashSet<u32>,
/// Marker photos, scaled and cropped to a square, by photo uid, with the /// Marker photos, scaled and cropped to a square, by photo uid.
/// draw they were last shown in. covers: HashMap<String, cairo::ImageSurface>,
covers: HashMap<String, (cairo::ImageSurface, u64)>,
/// Counts draws, for dropping the covers shown longest ago.
draws: u64,
asked_thumbs: HashSet<String>, asked_thumbs: HashSet<String>,
view: View, view: View,
/// False until the view has been fitted to the places at a real size, and /// False until the view has been fitted to the places at a real size, and
@@ -357,7 +349,6 @@ impl PlacesMap {
locations: HashMap::new(), locations: HashMap::new(),
asked_locations: HashSet::new(), asked_locations: HashSet::new(),
covers: HashMap::new(), covers: HashMap::new(),
draws: 0,
asked_thumbs: HashSet::new(), asked_thumbs: HashSet::new(),
view: View { view: View {
center: World { x: 0.5, y: 0.5 }, center: World { x: 0.5, y: 0.5 },
@@ -495,18 +486,7 @@ impl PlacesMap {
let Some(cover) = square_cover(texture) else { let Some(cover) = square_cover(texture) else {
return; return;
}; };
let mut state = self.state.borrow_mut(); self.state.borrow_mut().covers.insert(uid.to_owned(), cover);
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(); self.area.queue_draw();
} }
@@ -860,7 +840,6 @@ impl PlacesMap {
let mut state = self.state.borrow_mut(); let mut state = self.state.borrow_mut();
let state = &mut *state; let state = &mut *state;
let view = state.view; let view = state.view;
state.draws += 1;
paint_outline(cr, view, size, colors); paint_outline(cr, view, size, colors);
let labels = match state.online.as_mut() { let labels = match state.online.as_mut() {
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()), Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
@@ -884,10 +863,7 @@ impl PlacesMap {
} }
for bubble in &state.bubbles { for bubble in &state.bubbles {
let marker = &state.markers[bubble.members[0]]; let marker = &state.markers[bubble.members[0]];
let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| { let cover = state.covers.get(&marker.cover);
*drawn = state.draws;
&*cover
});
if cover.is_none() if cover.is_none()
&& let Target::Photo { place, index } = marker.target && let Target::Photo { place, index } = marker.target
&& state.asked_thumbs.insert(marker.cover.clone()) && state.asked_thumbs.insert(marker.cover.clone())
@@ -1145,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 /// Set the names of the tiles on screen, the most important first, leaving
/// out any that would overlap one already set. /// out any that would overlap one already set.
fn paint_labels( fn paint_labels(
@@ -1707,28 +1654,6 @@ fn set_color(cr: &cairo::Context, color: &gtk4::gdk::RGBA, alpha: f32) {
mod tests { mod tests {
use super::*; 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] #[test]
fn projection_puts_the_equator_and_meridian_in_the_middle() { fn projection_puts_the_equator_and_meridian_in_the_middle() {
let p = project(0.0, 0.0); let p = project(0.0, 0.0);
+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 /// 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. /// deleted — a stale path would only fail at launch, and silently is worse.
/// Blocking: run it off the GTK thread. fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
fn load_staged(path: &Path) -> Vec<PathBuf> { let Ok(text) = std::fs::read_to_string(staged_path(ui)) else {
let Ok(text) = std::fs::read_to_string(path) else {
return Vec::new(); return Vec::new();
}; };
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default(); let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
@@ -65,39 +64,9 @@ fn load_staged(path: &Path) -> Vec<PathBuf> {
.collect() .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 /// 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. /// 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>) { fn save_staged(ui: &Rc<Ui>) {
if !ui.takeout.restored.get() {
return;
}
let paths: Vec<String> = ui let paths: Vec<String> = ui
.takeout .takeout
.archives .archives
@@ -106,24 +75,12 @@ fn save_staged(ui: &Rc<Ui>) {
.map(|p| p.display().to_string()) .map(|p| p.display().to_string())
.collect(); .collect();
let path = staged_path(ui); let path = staged_path(ui);
let seq = ui.takeout.save_seq.get() + 1; let written = serde_json::to_string(&paths)
ui.takeout.save_seq.set(seq); .map_err(|e| e.to_string())
let saved = ui.takeout.saved_seq.clone(); .and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
gio::spawn_blocking(move || { if let Err(e) = written {
let Ok(mut last) = saved.lock() else { tracing::warn!("cannot remember staged Takeout archives: {e}");
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 { fn empty_list_description() -> String {
@@ -164,16 +121,6 @@ pub(crate) struct TakeoutState {
pub(crate) inflight: Cell<bool>, pub(crate) inflight: Cell<bool>,
/// Whether the daemon reported an import running on the last poll. /// Whether the daemon reported an import running on the last poll.
pub(crate) running: Cell<bool>, 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. /// Widgets the Import page hands back for wiring.
@@ -543,10 +490,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
.back_button .back_button
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery")); .connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
// Restore whatever was staged when the window last closed, so the page // Restore whatever was staged when the window last closed, before the first
// comes up as the user left it. // paint, so the page comes up as the user left it.
*ui.takeout.archives.borrow_mut() = load_staged(ui);
repaint_archives(ui); repaint_archives(ui);
restore_staged(ui);
} }
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged. /// 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 /// the scan reads the archives' central directories, and an extracted tree has
/// none — silently importing half of it would be worse than saying no. /// none — silently importing half of it would be worse than saying no.
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) { 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 added = 0usize;
let mut rejected = 0usize; let mut rejected = 0usize;
{ {
let mut staged = ui.takeout.archives.borrow_mut(); let mut staged = ui.takeout.archives.borrow_mut();
for (path, file) in paths { for path in paths {
let is_zip = path let is_zip = path
.extension() .extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip")); .is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
if !is_zip || !file { if !is_zip || !path.is_file() {
rejected += 1; rejected += 1;
continue; 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. /// 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>) { 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(..) { for row in ui.takeout.rows.borrow_mut().drain(..) {
ui.takeout.list_group.remove(&row); ui.takeout.list_group.remove(&row);
} }
let staged = ui.takeout.archives.borrow().clone();
let mut rows: Vec<adw::PreferencesRow> = Vec::new(); let mut rows: Vec<adw::PreferencesRow> = Vec::new();
if staged.is_empty() { if staged.is_empty() {
ui.takeout ui.takeout
@@ -664,8 +558,8 @@ fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
rows.push(row.upcast()); rows.push(row.upcast());
} else { } else {
let mut total = 0u64; let mut total = 0u64;
for (path, size) in &staged { for path in &staged {
let size = *size; let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
total += size; total += size;
let row = adw::ActionRow::builder() let row = adw::ActionRow::builder()
.title( .title(
@@ -707,6 +601,9 @@ fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
))); )));
} }
*ui.takeout.rows.borrow_mut() = rows; *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 /// Enable exactly the actions that make sense right now: nothing to launch
-12
View File
@@ -13,15 +13,6 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
### Changed ### 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
cancelled downloads the block itself.
- The shared Gallery engine now comes from the `proton-gallery-rs` and - 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-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. Proton Gallery. Builds, vendoring and the Nix package no longer fetch from Git.
@@ -31,9 +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 - 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 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. 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.
## [3.9.0] — 2026-11-19 ## [3.9.0] — 2026-11-19
+479 -618
View File
File diff suppressed because it is too large. Load diff
+487 -623
View File
File diff suppressed because it is too large. Load diff
+479 -617
View File
File diff suppressed because it is too large. Load diff
+479 -618
View File
File diff suppressed because it is too large. Load diff
+479 -616
View File
File diff suppressed because it is too large. Load diff
+479 -618
View File
File diff suppressed because it is too large. Load diff
+475 -604
View File
File diff suppressed because it is too large. Load diff
+480 -616
View File
File diff suppressed because it is too large. Load diff
+479 -615
View File
File diff suppressed because it is too large. Load diff