Compare commits

...
Author SHA1 Message Date
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
nvrl 43b76d4791 fix(i18n): bring every catalog up to date with the sources
The Drive galleries, hidden albums and move-recovery strings had been
added without regenerating po/, so 11 were untranslated and 17 fell back
to unrelated fuzzy matches ("Hidden albums" showed as "No albums").
Regenerated with po/update.sh and translated in all eight languages.
2026-11-20 15:37:46 +01:00
nvrl 734e9040fb Merge pull request #111 from narrrl/refactor/proton-media-rs
refactor(fuse): block fetch single flight from proton-media-rs
2026-11-20 13:28:42 +01:00
nvrl 01e3860741 refactor(fuse): block fetch single flight from proton-media-rs
BlockFlight is now proton_media_rs::SingleFlight joined with the typed
block result. Same semantics: one fetch per block, the key retires
before the result is published, and a waiter whose leader is cancelled
fetches the block itself.
2026-11-20 13:27:59 +01:00
nvrl 7a65e7011f Merge pull request #110 from narrrl/refactor/proton-base-rs
refactor(core): atomic file writes from proton-base-rs
2026-11-20 12:51:09 +01:00
nvrl 233d9e9e51 refactor(core): atomic file writes from proton-base-rs
Config, machine id and mount-failure files go through
proton_base_rs::atomic. Same modes as before (config 0600, the others
0644); the mount-failure file is now synced before its rename.
2026-11-20 12:16:32 +01:00
nvrl 73c4e1f6bf Merge pull request #107 from narrrl/refactor/proton-rs
refactor(photos): take the Gallery engine from crates.io
2026-11-20 12:10:34 +01:00
nvrl 26272cda6c refactor(core): take the keyring store from proton-auth-rs
The Secret Service connection that reconnects after the provider
restarts (B285) and the item replacement that oo7 before 0.7.0 needs
(B291) moved to proton-auth-rs, shared with Proton Gallery and Proton
Stream. pdfs-core keeps one KeyringStore per process; the session format,
service and user are unchanged. The two secretservice tests moved with
the code.
2026-11-20 12:01:50 +01:00
nvrl 370abd58dc refactor(photos): use the shared photo logic from proton-gallery-rs
RAW+JPEG grouping, Takeout reading, EXIF capture times, look-alike
hashes and the offline town lookup now come from proton-gallery-rs
0.1.1, shared with Proton Gallery. PhotoKind::classify delegates to the
shared MediaClass; the extension lists live there. No behaviour change.
2026-11-20 04:16:52 +01:00
nvrl 24594b24ae refactor(photos): take the Gallery engine from crates.io
Replace the git revision pin on Proton Gallery with proton-gallery-rs and
proton-gallery-app-rs 0.1.0 from the proton-rs workspace. This also moves
the engine from 858d244 to b171232. The Nix package no longer needs to
fetch from Git.
2026-11-20 02:44:22 +01:00
nvrl 04f0713012 Merge pull request #106 from narrrl/feat/shared-gallery
feat(photos): release Proton Drive 3.9.0
2026-11-19 21:31:16 +01:00
nvrl cc020bfb54 feat(photos): unlock hidden albums with system login 2026-11-19 20:55:26 +01:00
nvrl 1e6043d12a fix(photos): keep hidden albums open after unlock 2026-11-19 20:44:44 +01:00
nvrl 834684f6d7 chore(release): prepare Proton Drive 3.9.0 2026-11-19 18:15:54 +01:00
nvrl 1c2a66169f feat(photos): embed galleries and speed up zoom
Keep album browsing and private galleries inside Photos. Build GTK
tiles near the viewport and anchor relayouts on the visible photo.

Migrate the Photos cache to persist pending event work with its cursor.
Pin the published Gallery engine for scoped private album reads.
2026-11-19 17:56:32 +01:00
nvrl cb5ff8b8da feat(photos): integrate the shared Gallery engine
Share gallery settings and layout with Proton Gallery. Preserve Git
source mappings so COPR can resolve the dependency offline.
2026-11-19 11:42:47 +01:00
nvrl c57d98799a fix(sync): explain moves blocked by Trash
Keep blocked moves queued so they can land after a restore. Retain
simulation logs for intermittent conflicts and pick up the SDK fix for
uploads from machines with fast clocks.
2026-11-19 05:01:52 +01:00
nvrl 7d9d5850a4 Merge pull request #105 from narrrl/feat/branding
Feat/branding
2026-11-19 01:13:39 +01:00
nvrl 140bd2eee3 Merge pull request #104 from narrrl/feat/branding
feat(branding) added new icons and branding
2026-11-18 11:16:58 +01:00
80 changed files with 11340 additions and 40232 deletions

No files matched your search

+8 -5
View File
@@ -105,14 +105,17 @@ jobs:
- name: Simulation runs
run: 'cargo test -p pdfs-fuse --lib --locked sim:: -- --ignored --test-threads=1'
# A hung step writes every daemon thread's stack next to the run's
# state; without them a hang that does not replay cannot be told apart.
- name: Keep the stacks of a hung run
# Retain the operation trace and daemon logs for the failing seed, plus
# every daemon thread's stack if the watchdog caught a hang.
- name: Keep simulation failure diagnostics
if: failure()
uses: actions/upload-artifact@v7
with:
name: simulation-stacks
path: /tmp/pdfs-sim-*/stacks.txt
name: simulation-diagnostics
path: |
/tmp/pdfs-sim-*/steps.log
/tmp/pdfs-sim-*/daemon.log
/tmp/pdfs-sim-*/stacks.txt
if-no-files-found: ignore
# Keeps the release-profile dependencies cached on main, where the release
+8 -3
View File
@@ -129,8 +129,12 @@ jobs:
# Every crate the build needs, so COPR can build the spec without network.
- name: Package vendored crates (.tar.xz)
run: |
cargo vendor --locked dist/vendor > /dev/null
tar -cJf proton-drive-linux-vendor-${{ env.VERSION }}.tar.xz -C dist vendor
mkdir -p dist/.cargo
(
cd dist
cargo vendor --locked --manifest-path ../Cargo.toml vendor > .cargo/config.toml
)
tar -cJf proton-drive-linux-vendor-${{ env.VERSION }}.tar.xz -C dist vendor .cargo/config.toml
- name: Package Debian package (.deb)
run: |
@@ -152,6 +156,7 @@ jobs:
cp packaging/io.narl.proton-drive-linux.desktop deb/usr/share/applications/
cp packaging/io.narl.proton-drive-linux-tray.desktop deb/etc/xdg/autostart/
cp packaging/io.narl.proton-drive-linux.svg deb/usr/share/icons/hicolor/scalable/apps/
install -Dm644 packaging/io.narl.proton-drive-linux.policy deb/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy
cp packaging/proton-drive.service deb/usr/lib/systemd/user/
cp LICENSE deb/usr/share/licenses/proton-drive-linux/
po/build.sh deb/usr/share/locale
@@ -171,7 +176,7 @@ jobs:
Priority: optional
Architecture: amd64
Maintainer: Nils Pukropp <contact@narl.io>
Depends: fuse3, libgtk-4-1 (>= 4.12.0), libadwaita-1-0 (>= 1.5.0), libsecret-1-0, libwebkitgtk-6.0-4, libimage-exiftool-perl
Depends: polkitd, fuse3, libgtk-4-1 (>= 4.12.0), libadwaita-1-0 (>= 1.5.0), libsecret-1-0, libwebkitgtk-6.0-4, libimage-exiftool-perl
Installed-Size: ${INSTALLED_SIZE}
Homepage: https://proton-drive.narl.io
Description: Unofficial Proton Drive client for Linux
Generated
+166 -13
View File
@@ -49,6 +49,7 @@ dependencies = [
"cipher 0.5.2",
"cpubits",
"cpufeatures 0.3.1",
"zeroize",
]
[[package]]
@@ -77,6 +78,7 @@ dependencies = [
"ctr 0.10.1",
"ctutils",
"ghash 0.6.0",
"zeroize",
]
[[package]]
@@ -180,6 +182,17 @@ version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "apple-native-keyring-store"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b350bfd03649e07aa05c0a81b3e15934374e585c98204a57e20b9d49f49bb9a"
dependencies = [
"keyring-core",
"log",
"security-framework",
]
[[package]]
name = "arbitrary"
version = "1.5.0"
@@ -1878,6 +1891,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"
dependencies = [
"polyval 0.7.3",
"zeroize",
]
[[package]]
@@ -2237,6 +2251,12 @@ version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
[[package]]
name = "httpdate"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
[[package]]
name = "hybrid-array"
version = "0.4.15"
@@ -2260,6 +2280,7 @@ dependencies = [
"http",
"http-body",
"httparse",
"httpdate",
"itoa",
"pin-project-lite",
"smallvec",
@@ -3582,7 +3603,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
[[package]]
name = "pdfs-cli"
version = "3.8.1"
version = "3.9.0"
dependencies = [
"anyhow",
"clap",
@@ -3599,7 +3620,7 @@ dependencies = [
[[package]]
name = "pdfs-core"
version = "3.8.1"
version = "3.9.0"
dependencies = [
"async-trait",
"base64 0.23.1",
@@ -3608,33 +3629,37 @@ dependencies = [
"dbus-secret-service-keyring-store",
"directories",
"ignore",
"kamadak-exif",
"keyring-core",
"libc",
"parking_lot 0.13.0",
"proton-auth-rs",
"proton-base-rs",
"proton-drive-rs",
"proton-gallery-rs",
"proton-sdk",
"rusqlite",
"serde",
"serde_json",
"sha1 0.11.0",
"sha2 0.11.1",
"shell-words",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
"zip",
]
[[package]]
name = "pdfs-fuse"
version = "3.8.1"
version = "3.9.0"
dependencies = [
"async-trait",
"base64 0.23.1",
"fuser",
"futures",
"getrandom 0.4.3",
"http-body-util",
"hyper",
"hyper-util",
"image",
"libc",
"lofty",
@@ -3642,21 +3667,27 @@ dependencies = [
"parking_lot 0.13.0",
"pdfs-core",
"proton-drive-rs",
"proton-gallery-app-rs",
"proton-gallery-rs",
"proton-media-rs",
"rustix",
"serde",
"serde_json",
"sha1 0.11.0",
"tokio",
"tracing",
"tracing-subscriber",
"zeroize",
"zip",
]
[[package]]
name = "pdfs-gui"
version = "3.8.1"
version = "3.9.0"
dependencies = [
"anyhow",
"async-channel",
"base64 0.23.1",
"gettext-rs",
"gtk4",
"kamadak-exif",
@@ -3664,6 +3695,7 @@ dependencies = [
"libadwaita",
"pangocairo",
"pdfs-core",
"proton-gallery-rs",
"reqwest",
"serde",
"serde_json",
@@ -3825,6 +3857,7 @@ dependencies = [
"cpubits",
"cpufeatures 0.3.1",
"universal-hash 0.6.1",
"zeroize",
]
[[package]]
@@ -3892,10 +3925,36 @@ dependencies = [
]
[[package]]
name = "proton-drive-rs"
version = "0.12.0"
name = "proton-auth-rs"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4265c2cf3bdc59ee273d7363c8b6a7cb4e98be6102ffa18144c4d8ebda00737b"
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc"
dependencies = [
"apple-native-keyring-store",
"dbus-secret-service",
"dbus-secret-service-keyring-store",
"keyring-core",
"thiserror 2.0.21",
"tracing",
"windows-native-keyring-store",
"zeroize",
]
[[package]]
name = "proton-base-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "451151bb1025ea5cb362f69e2bfb2d45afed603e5c6daa3dc752333a7c29c878"
dependencies = [
"rusqlite",
"thiserror 2.0.21",
]
[[package]]
name = "proton-drive-rs"
version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bdeb7ee7495bc34198c78d7ec569f6371ad01a88f188b5eee418b013b082626a"
dependencies = [
"async-trait",
"base64 0.23.1",
@@ -3920,10 +3979,90 @@ dependencies = [
]
[[package]]
name = "proton-sdk"
version = "0.12.0"
name = "proton-gallery-app-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fb98ab3e336ed95f82368a50348dad00e5fc919e982d748e83e844afcadbd5d8"
checksum = "d6d18d11266ab2be5ab2f4b4040941caf2736c257e13909af7be8ea331892d59"
dependencies = [
"async-trait",
"futures-util",
"hex",
"proton-drive-rs",
"proton-gallery-drive-rs",
"proton-gallery-rs",
"proton-sdk",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
]
[[package]]
name = "proton-gallery-drive-rs"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "535a14f63fd542701d2606acb971d4a7e8f235ca7b9439fea8c80a3f26110186"
dependencies = [
"async-trait",
"hex",
"proton-drive-rs",
"proton-gallery-rs",
"proton-sdk",
"serde",
"serde_json",
"sha2 0.11.1",
"thiserror 2.0.21",
"tokio",
"tracing",
"zeroize",
]
[[package]]
name = "proton-gallery-rs"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a978cc4dc990ae1941209fece17c952a11dbaee392b358ca64c0c836cb2ec21"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
"getrandom 0.4.3",
"hex",
"kamadak-exif",
"proton-base-rs",
"rusqlite",
"serde",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tokio-util",
"tracing",
"zeroize",
"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]]
name = "proton-sdk"
version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3189873dcdf0bc0a3d0fa5619cea80594085252d1d66a57459ec6adfd1f35ac1"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
@@ -5191,6 +5330,7 @@ dependencies = [
"bytes",
"futures-core",
"futures-sink",
"futures-util",
"libc",
"pin-project-lite",
"tokio",
@@ -5776,6 +5916,19 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
[[package]]
name = "windows-native-keyring-store"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "063426e76fdec7438d56bb777f67e318a84a25c707b07e575cb8b78e10c028f8"
dependencies = [
"byteorder",
"keyring-core",
"regex",
"windows-sys 0.61.2",
"zeroize",
]
[[package]]
name = "windows-result"
version = "0.4.1"
+10 -3
View File
@@ -3,7 +3,7 @@ resolver = "2"
members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"]
[workspace.package]
version = "3.8.1"
version = "3.9.0"
edition = "2024"
license = "MIT"
authors = ["Nils Pukropp <contact@narl.io>"]
@@ -15,8 +15,10 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
categories = ["filesystem", "command-line-utilities"]
[workspace.dependencies]
proton-sdk = { version = "0.12.0" }
proton-drive-rs = { version = "0.12.0" }
proton-sdk = { version = "0.12.2" }
proton-drive-rs = { version = "0.12.2" }
proton-gallery-app-rs = "0.1.0"
proton-gallery-rs = "0.1.3"
chrono = { version = "0.4", default-features = false, features = ["std"] }
# Internal crates.
@@ -61,6 +63,11 @@ rusqlite = { version = "0.41", features = ["bundled"] }
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and
# with no `target` it matches items v3 wrote, so existing logins survive.
keyring-core = "1"
# The keyring store all three apps share: reconnects after a Secret Service
# restart (B285) and replaces items instead of editing them (B291).
proton-auth-rs = "0.1.1"
proton-base-rs = "0.1"
proton-media-rs = "0.1.1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
+2
View File
@@ -1511,6 +1511,7 @@ fn issue_text(issue: SyncIssue) -> &'static str {
"you can no longer change this on Proton Drive, for example because a share was \
revoked. Save a copy to keep the content."
}
SyncIssue::Trashed => "restore the item or folder from Trash, then retry the move.",
SyncIssue::Missing => {
"the file or its folder is gone from Proton Drive. Save a copy to keep the content."
}
@@ -2695,6 +2696,7 @@ fn mount_once(mountpoint: Option<PathBuf>) -> Result<pdfs_fuse::MountOutcome> {
db,
pdfs_fuse::MountOptions {
username,
gallery_session: Some(session.clone()),
sweep_mode: config.resolved_conflict_sweep(),
upload_limit: config.upload_limit.unwrap_or(0),
download_limit: config.download_limit.unwrap_or(0),
+3 -3
View File
@@ -12,6 +12,7 @@ description = "Core auth/session/config for the Proton Drive Linux client"
[dependencies]
proton-sdk.workspace = true
proton-drive-rs.workspace = true
proton-gallery-rs.workspace = true
chrono.workspace = true
tokio.workspace = true
serde.workspace = true
@@ -22,10 +23,10 @@ directories.workspace = true
ignore.workspace = true
shell-words.workspace = true
sha2.workspace = true
sha1.workspace = true
zip.workspace = true
rusqlite.workspace = true
keyring-core.workspace = true
proton-auth-rs = { workspace = true, features = ["keyring"] }
proton-base-rs.workspace = true
dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true
parking_lot.workspace = true
@@ -33,4 +34,3 @@ async-trait.workspace = true
libc.workspace = true
zeroize.workspace = true
base64.workspace = true
exif = { version = "0.6", package = "kamadak-exif" }
File diff suppressed because it is too large. Load diff
-250
View File
@@ -1,250 +0,0 @@
AD Andorra
AE United Arab Emirates
AF Afghanistan
AG Antigua and Barbuda
AI Anguilla
AL Albania
AM Armenia
AO Angola
AQ Antarctica
AR Argentina
AS American Samoa
AT Austria
AU Australia
AW Aruba
AX Åland Islands
AZ Azerbaijan
BA Bosnia and Herzegovina
BB Barbados
BD Bangladesh
BE Belgium
BF Burkina Faso
BG Bulgaria
BH Bahrain
BI Burundi
BJ Benin
BL Saint Barthélemy
BM Bermuda
BN Brunei Darussalam
BO Bolivia, Plurinational State of
BQ Bonaire, Sint Eustatius and Saba
BR Brazil
BS Bahamas
BT Bhutan
BV Bouvet Island
BW Botswana
BY Belarus
BZ Belize
CA Canada
CC Cocos (Keeling) Islands
CD Congo, The Democratic Republic of the
CF Central African Republic
CG Congo
CH Switzerland
CI Côte d'Ivoire
CK Cook Islands
CL Chile
CM Cameroon
CN China
CO Colombia
CR Costa Rica
CU Cuba
CV Cabo Verde
CW Curaçao
CX Christmas Island
CY Cyprus
CZ Czechia
DE Germany
DJ Djibouti
DK Denmark
DM Dominica
DO Dominican Republic
DZ Algeria
EC Ecuador
EE Estonia
EG Egypt
EH Western Sahara
ER Eritrea
ES Spain
ET Ethiopia
FI Finland
FJ Fiji
FK Falkland Islands (Malvinas)
FM Micronesia, Federated States of
FO Faroe Islands
FR France
GA Gabon
GB United Kingdom
GD Grenada
GE Georgia
GF French Guiana
GG Guernsey
GH Ghana
GI Gibraltar
GL Greenland
GM Gambia
GN Guinea
GP Guadeloupe
GQ Equatorial Guinea
GR Greece
GS South Georgia and the South Sandwich Islands
GT Guatemala
GU Guam
GW Guinea-Bissau
GY Guyana
HK Hong Kong
HM Heard Island and McDonald Islands
HN Honduras
HR Croatia
HT Haiti
HU Hungary
ID Indonesia
IE Ireland
IL Israel
IM Isle of Man
IN India
IO British Indian Ocean Territory
IQ Iraq
IR Iran, Islamic Republic of
IS Iceland
IT Italy
JE Jersey
JM Jamaica
JO Jordan
JP Japan
KE Kenya
KG Kyrgyzstan
KH Cambodia
KI Kiribati
KM Comoros
KN Saint Kitts and Nevis
KP Korea, Democratic People's Republic of
KR Korea, Republic of
KW Kuwait
KY Cayman Islands
KZ Kazakhstan
LA Lao People's Democratic Republic
LB Lebanon
LC Saint Lucia
LI Liechtenstein
LK Sri Lanka
LR Liberia
LS Lesotho
LT Lithuania
LU Luxembourg
LV Latvia
LY Libya
MA Morocco
MC Monaco
MD Moldova, Republic of
ME Montenegro
MF Saint Martin (French part)
MG Madagascar
MH Marshall Islands
MK North Macedonia
ML Mali
MM Myanmar
MN Mongolia
MO Macao
MP Northern Mariana Islands
MQ Martinique
MR Mauritania
MS Montserrat
MT Malta
MU Mauritius
MV Maldives
MW Malawi
MX Mexico
MY Malaysia
MZ Mozambique
NA Namibia
NC New Caledonia
NE Niger
NF Norfolk Island
NG Nigeria
NI Nicaragua
NL Netherlands
NO Norway
NP Nepal
NR Nauru
NU Niue
NZ New Zealand
OM Oman
PA Panama
PE Peru
PF French Polynesia
PG Papua New Guinea
PH Philippines
PK Pakistan
PL Poland
PM Saint Pierre and Miquelon
PN Pitcairn
PR Puerto Rico
PS Palestine, State of
PT Portugal
PW Palau
PY Paraguay
QA Qatar
RE Réunion
RO Romania
RS Serbia
RU Russian Federation
RW Rwanda
SA Saudi Arabia
SB Solomon Islands
SC Seychelles
SD Sudan
SE Sweden
SG Singapore
SH Saint Helena, Ascension and Tristan da Cunha
SI Slovenia
SJ Svalbard and Jan Mayen
SK Slovakia
SL Sierra Leone
SM San Marino
SN Senegal
SO Somalia
SR Suriname
SS South Sudan
ST Sao Tome and Principe
SV El Salvador
SX Sint Maarten (Dutch part)
SY Syrian Arab Republic
SZ Eswatini
TC Turks and Caicos Islands
TD Chad
TF French Southern Territories
TG Togo
TH Thailand
TJ Tajikistan
TK Tokelau
TL Timor-Leste
TM Turkmenistan
TN Tunisia
TO Tonga
TR Türkiye
TT Trinidad and Tobago
TV Tuvalu
TW Taiwan, Province of China
TZ Tanzania, United Republic of
UA Ukraine
UG Uganda
UM United States Minor Outlying Islands
US United States
UY Uruguay
UZ Uzbekistan
VA Holy See (Vatican City State)
VC Saint Vincent and the Grenadines
VE Venezuela, Bolivarian Republic of
VG Virgin Islands, British
VI Virgin Islands, U.S.
VN Viet Nam
VU Vanuatu
WF Wallis and Futuna
WS Samoa
XK Kosovo
YE Yemen
YT Mayotte
ZA South Africa
ZM Zambia
ZW Zimbabwe
1 AD Andorra
2 AE United Arab Emirates
3 AF Afghanistan
4 AG Antigua and Barbuda
5 AI Anguilla
6 AL Albania
7 AM Armenia
8 AO Angola
9 AQ Antarctica
10 AR Argentina
11 AS American Samoa
12 AT Austria
13 AU Australia
14 AW Aruba
15 AX Åland Islands
16 AZ Azerbaijan
17 BA Bosnia and Herzegovina
18 BB Barbados
19 BD Bangladesh
20 BE Belgium
21 BF Burkina Faso
22 BG Bulgaria
23 BH Bahrain
24 BI Burundi
25 BJ Benin
26 BL Saint Barthélemy
27 BM Bermuda
28 BN Brunei Darussalam
29 BO Bolivia, Plurinational State of
30 BQ Bonaire, Sint Eustatius and Saba
31 BR Brazil
32 BS Bahamas
33 BT Bhutan
34 BV Bouvet Island
35 BW Botswana
36 BY Belarus
37 BZ Belize
38 CA Canada
39 CC Cocos (Keeling) Islands
40 CD Congo, The Democratic Republic of the
41 CF Central African Republic
42 CG Congo
43 CH Switzerland
44 CI Côte d'Ivoire
45 CK Cook Islands
46 CL Chile
47 CM Cameroon
48 CN China
49 CO Colombia
50 CR Costa Rica
51 CU Cuba
52 CV Cabo Verde
53 CW Curaçao
54 CX Christmas Island
55 CY Cyprus
56 CZ Czechia
57 DE Germany
58 DJ Djibouti
59 DK Denmark
60 DM Dominica
61 DO Dominican Republic
62 DZ Algeria
63 EC Ecuador
64 EE Estonia
65 EG Egypt
66 EH Western Sahara
67 ER Eritrea
68 ES Spain
69 ET Ethiopia
70 FI Finland
71 FJ Fiji
72 FK Falkland Islands (Malvinas)
73 FM Micronesia, Federated States of
74 FO Faroe Islands
75 FR France
76 GA Gabon
77 GB United Kingdom
78 GD Grenada
79 GE Georgia
80 GF French Guiana
81 GG Guernsey
82 GH Ghana
83 GI Gibraltar
84 GL Greenland
85 GM Gambia
86 GN Guinea
87 GP Guadeloupe
88 GQ Equatorial Guinea
89 GR Greece
90 GS South Georgia and the South Sandwich Islands
91 GT Guatemala
92 GU Guam
93 GW Guinea-Bissau
94 GY Guyana
95 HK Hong Kong
96 HM Heard Island and McDonald Islands
97 HN Honduras
98 HR Croatia
99 HT Haiti
100 HU Hungary
101 ID Indonesia
102 IE Ireland
103 IL Israel
104 IM Isle of Man
105 IN India
106 IO British Indian Ocean Territory
107 IQ Iraq
108 IR Iran, Islamic Republic of
109 IS Iceland
110 IT Italy
111 JE Jersey
112 JM Jamaica
113 JO Jordan
114 JP Japan
115 KE Kenya
116 KG Kyrgyzstan
117 KH Cambodia
118 KI Kiribati
119 KM Comoros
120 KN Saint Kitts and Nevis
121 KP Korea, Democratic People's Republic of
122 KR Korea, Republic of
123 KW Kuwait
124 KY Cayman Islands
125 KZ Kazakhstan
126 LA Lao People's Democratic Republic
127 LB Lebanon
128 LC Saint Lucia
129 LI Liechtenstein
130 LK Sri Lanka
131 LR Liberia
132 LS Lesotho
133 LT Lithuania
134 LU Luxembourg
135 LV Latvia
136 LY Libya
137 MA Morocco
138 MC Monaco
139 MD Moldova, Republic of
140 ME Montenegro
141 MF Saint Martin (French part)
142 MG Madagascar
143 MH Marshall Islands
144 MK North Macedonia
145 ML Mali
146 MM Myanmar
147 MN Mongolia
148 MO Macao
149 MP Northern Mariana Islands
150 MQ Martinique
151 MR Mauritania
152 MS Montserrat
153 MT Malta
154 MU Mauritius
155 MV Maldives
156 MW Malawi
157 MX Mexico
158 MY Malaysia
159 MZ Mozambique
160 NA Namibia
161 NC New Caledonia
162 NE Niger
163 NF Norfolk Island
164 NG Nigeria
165 NI Nicaragua
166 NL Netherlands
167 NO Norway
168 NP Nepal
169 NR Nauru
170 NU Niue
171 NZ New Zealand
172 OM Oman
173 PA Panama
174 PE Peru
175 PF French Polynesia
176 PG Papua New Guinea
177 PH Philippines
178 PK Pakistan
179 PL Poland
180 PM Saint Pierre and Miquelon
181 PN Pitcairn
182 PR Puerto Rico
183 PS Palestine, State of
184 PT Portugal
185 PW Palau
186 PY Paraguay
187 QA Qatar
188 RE Réunion
189 RO Romania
190 RS Serbia
191 RU Russian Federation
192 RW Rwanda
193 SA Saudi Arabia
194 SB Solomon Islands
195 SC Seychelles
196 SD Sudan
197 SE Sweden
198 SG Singapore
199 SH Saint Helena, Ascension and Tristan da Cunha
200 SI Slovenia
201 SJ Svalbard and Jan Mayen
202 SK Slovakia
203 SL Sierra Leone
204 SM San Marino
205 SN Senegal
206 SO Somalia
207 SR Suriname
208 SS South Sudan
209 ST Sao Tome and Principe
210 SV El Salvador
211 SX Sint Maarten (Dutch part)
212 SY Syrian Arab Republic
213 SZ Eswatini
214 TC Turks and Caicos Islands
215 TD Chad
216 TF French Southern Territories
217 TG Togo
218 TH Thailand
219 TJ Tajikistan
220 TK Tokelau
221 TL Timor-Leste
222 TM Turkmenistan
223 TN Tunisia
224 TO Tonga
225 TR Türkiye
226 TT Trinidad and Tobago
227 TV Tuvalu
228 TW Taiwan, Province of China
229 TZ Tanzania, United Republic of
230 UA Ukraine
231 UG Uganda
232 UM United States Minor Outlying Islands
233 US United States
234 UY Uruguay
235 UZ Uzbekistan
236 VA Holy See (Vatican City State)
237 VC Saint Vincent and the Grenadines
238 VE Venezuela, Bolivarian Republic of
239 VG Virgin Islands, British
240 VI Virgin Islands, U.S.
241 VN Viet Nam
242 VU Vanuatu
243 WF Wallis and Futuna
244 WS Samoa
245 XK Kosovo
246 YE Yemen
247 YT Mayotte
248 ZA South Africa
249 ZM Zambia
250 ZW Zimbabwe
+105 -170
View File
@@ -28,6 +28,7 @@ use std::time::Duration;
use base64::Engine as _;
use base64::engine::general_purpose::STANDARD as BASE64;
use keyring_core::Entry;
use proton_auth_rs::{KeyringStore, SecretStore};
use proton_drive_rs::{KeySalt, ProtonDriveClient};
use proton_sdk::account::KeyPassphrases;
use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
@@ -35,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};
@@ -125,82 +127,28 @@ fn client_config() -> ProtonClientConfiguration {
/// Run `op` on the session's keyring entry.
fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op)
Ok(keyring().with_entry(KEYRING_USER, op)?)
}
/// Run `op` on the entry `service`/`user`, reconnecting once if the Secret
/// Service fails the call.
/// The process's keyring, connected on first use.
///
/// The store holds one D-Bus connection and one Secret Service session for the
/// whole process. The session lives in the provider's memory: once the provider
/// restarts (oo7's unit restarts it on failure, and both oo7 and gnome-keyring
/// can be `--replace`d), every read and write on the old session fails with
/// `NoSession`, for as long as this process runs. A daemon then keeps refreshed
/// tokens only in memory, and a cold boot loses them (`docs/BUGS.md` B285). A
/// platform failure therefore drops the store, and the call is made once more
/// on a new one. A locked keyring, a dismissed prompt or a missing entry is
/// not the connection's fault and comes back as it is.
fn with_keyring_entry<T>(
service: &str,
user: &str,
op: impl Fn(&Entry) -> keyring_core::Result<T>,
) -> Result<T> {
let store = keyring_store()?;
match op(&Entry::new(service, user)?) {
Err(keyring_core::Error::PlatformFailure(e)) => {
tracing::warn!(
error = %e,
"the Secret Service failed this process's connection; reconnecting"
);
drop_keyring_store(&store);
keyring_store()?;
Ok(op(&Entry::new(service, user)?)?)
/// One connection for the whole process; when the Secret Service fails it
/// (a restarted provider forgets the session, `docs/BUGS.md` B285), the call
/// reconnects and is made once more. A changed session replaces its item
/// instead of editing it (B291). Both live in `proton-auth-rs`.
fn keyring() -> &'static KeyringStore {
static STORE: std::sync::OnceLock<KeyringStore> = std::sync::OnceLock::new();
STORE.get_or_init(|| {
#[cfg(not(test))]
{
KeyringStore::new(KEYRING_SERVICE)
}
result => Ok(result?),
}
}
/// Held while the default store is looked at and replaced, so that threads
/// failing at the same time drop the broken store once and share its
/// replacement.
static KEYRING_STORE: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
/// The process's Secret Service store, connected now if there is none.
///
/// Connected lazily rather than once at startup so a session bus that was not
/// up yet on the first attempt is tried again on the next one.
fn keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
let _swap = KEYRING_STORE.lock();
if let Some(store) = keyring_core::get_default_store() {
return Ok(store);
}
let store = connect_keyring_store()?;
keyring_core::set_default_store(Arc::clone(&store));
Ok(store)
}
/// Forget `failed`, unless another thread has already replaced it.
fn drop_keyring_store(failed: &Arc<keyring_core::CredentialStore>) {
let _swap = KEYRING_STORE.lock();
if keyring_core::get_default_store().is_some_and(|store| Arc::ptr_eq(&store, failed)) {
keyring_core::unset_default_store();
}
}
#[cfg(not(test))]
fn connect_keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
Ok(dbus_secret_service_keyring_store::Store::new()?)
}
/// The tests' in-memory store when they set one, so a reconnect finds the
/// same entries; the real Secret Service otherwise.
#[cfg(test)]
fn connect_keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
tests::KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst);
match tests::MOCK_STORE.lock().clone() {
Some(store) => Ok(store),
None => Ok(dbus_secret_service_keyring_store::Store::new()?),
}
#[cfg(test)]
{
KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store))
.replace_items(|| tests::MOCK_STORE.lock().is_none())
}
})
}
/// What the user answered when asked for the mailbox password.
@@ -332,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.
@@ -473,52 +403,34 @@ 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()),
}
}
/// Save `stored` to the keyring.
///
/// An existing entry is replaced by a new item rather than edited, because
/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the
/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the
/// fallback: for the first save, and whenever replacing is not possible.
/// Save the session. An existing entry is replaced by a new item rather than
/// edited, because oo7 before 0.7.0 keeps an edit only in memory and a reboot
/// brings the spent refresh token back (`docs/BUGS.md` B291).
fn write_stored(stored: &StoredSession) -> Result<()> {
let json = Zeroizing::new(serde_json::to_string(stored)?);
if replace_items() {
match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) {
crate::secretservice::Replaced::Saved => return Ok(()),
crate::secretservice::Replaced::Skipped(why) => {
tracing::debug!(%why, "not replacing the keyring item; writing it in place");
}
}
}
with_keyring(|entry| entry.set_password(&json))
}
/// Whether [`write_stored`] talks to the Secret Service directly: always,
/// except in tests that use the in-memory store.
#[cfg(not(test))]
fn replace_items() -> bool {
true
}
#[cfg(test)]
fn replace_items() -> bool {
tests::MOCK_STORE.lock().is_none()
Ok(keyring().set(KEYRING_USER, &json)?)
}
/// A short, one-way tag for a refresh token, for the log: enough to tell
@@ -1324,9 +1236,30 @@ mod tests {
let store: Arc<keyring_core::CredentialStore> = keyring_core::mock::Store::new().unwrap();
*MOCK_STORE.lock() = Some(Arc::clone(&store));
keyring_core::set_default_store(store);
keyring().disconnect();
turn
}
/// The tests' in-memory store when they set one, so a reconnect finds the
/// same entries; the real Secret Service otherwise.
pub(super) fn connect_keyring_store() -> keyring_core::Result<Arc<keyring_core::CredentialStore>>
{
KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst);
match MOCK_STORE.lock().clone() {
Some(store) => Ok(store),
None => Ok(dbus_secret_service_keyring_store::Store::new()?),
}
}
/// Run `op` on the entry `service`/`user` of the real Secret Service.
fn with_keyring_entry<T>(
store: &KeyringStore,
user: &str,
op: impl Fn(&Entry) -> keyring_core::Result<T>,
) -> Result<T> {
Ok(store.with_entry(user, op)?)
}
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
/// The in-memory store a reconnect hands out, so it finds the same
@@ -1427,7 +1360,8 @@ mod tests {
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
let (service, user) = ("pdfs-test", "restart");
let user = "restart";
let service = &KeyringStore::with_connector("pdfs-test", Arc::new(connect_keyring_store));
with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
let status = std::process::Command::new("sh")
@@ -1468,6 +1402,7 @@ mod tests {
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
keyring().disconnect();
for refresh in ["r1", "r2", "r3"] {
write_stored(&stored_with(refresh)).unwrap();
+3 -29
View File
@@ -457,26 +457,7 @@ fn load_config_at(path: &Path) -> AppConfig {
/// [`AppDirs::save_config`] for the file at `path`.
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
refuse_to_replace_unreadable(path)?;
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()?;
proton_base_rs::atomic::write(path, &serde_json::to_vec_pretty(config)?)?;
Ok(())
}
@@ -621,15 +602,8 @@ impl AppDirs {
use std::io::Read as _;
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
let parent = path
.parent()
.ok_or_else(|| Error::Other("machine id path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
std::fs::write(&tmp, format!("{id}\n"))?;
std::fs::File::open(&tmp)?.sync_all()?;
std::fs::rename(&tmp, &path)?;
std::fs::File::open(parent)?.sync_all()?;
// Not secret, and other tools may read it; keep it world-readable.
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?;
Ok(id)
}
+426 -135
View File
@@ -44,14 +44,20 @@ pub enum Request {
/// Report mount status (account, mountpoint, pin count).
Status,
/// Pin a file (path relative to the mountpoint, or absolute under it).
Pin { path: String },
Pin {
path: String,
},
/// Unpin a file, evicting its cached content.
Unpin { path: String },
Unpin {
path: String,
},
/// List pinned files.
ListPins,
/// List a directory for the in-app file browser. `path` is
/// mountpoint-relative (empty or "." = the mount root).
ListDir { path: String },
ListDir {
path: String,
},
/// Fetch a page of the photos timeline, newest first. Returns metadata only:
/// a thumbnail path comes back only for photos already in the cache, so the
/// reply never waits on the network. Front-ends ask for the thumbnails they
@@ -83,7 +89,15 @@ pub enum Request {
/// live photo and its clip. Replies with [`Response::Photos`], holding one
/// item per file in server order; a photo that stands alone comes back as a
/// single item. The lightbox uses it to switch between a shot's files.
PhotoGroup { uid: String },
PhotoGroup {
uid: String,
},
/// Check the cached photo or its membership in the viewer's open album.
PhotoPresence {
uid: String,
#[serde(default)]
album: Option<String>,
},
/// The months the timeline spans (newest first, with per-month counts) so a
/// front-end can build a date scrubber without paging the whole library.
/// `kind` scopes the counts to one tab when set.
@@ -94,7 +108,9 @@ pub enum Request {
/// Photos taken on today's date in earlier years, newest first, at most
/// `limit` of them — the "On this day" strip above the timeline. Replies
/// with [`Response::Photos`]; a front-end groups them by year itself.
PhotosOnThisDay { limit: usize },
PhotosOnThisDay {
limit: usize,
},
/// Sets of photos that are byte-identical copies of each other, going by
/// the server's content hash. Replies with [`Response::PhotoDuplicates`].
PhotoDuplicates,
@@ -118,7 +134,9 @@ pub enum Request {
},
/// Every photo taken in one town with where exactly it was taken, for the
/// map's close-up. Replies with [`Response::PhotoLocations`].
PlaceLocations { id: u32 },
PlaceLocations {
id: u32,
},
/// List the account's photo albums, newest activity first, including the
/// albums other people share with us. Metadata only — an album's cover
/// thumbnail is fetched with [`Request::PhotoThumbs`] like any other photo.
@@ -134,9 +152,14 @@ pub enum Request {
limit: usize,
},
/// Create an album named `name`. Replies with [`Response::AlbumCreated`].
CreateAlbum { name: String },
CreateAlbum {
name: String,
},
/// Rename the album `uid`. Replies with [`Response::Ok`].
RenameAlbum { uid: String, name: String },
RenameAlbum {
uid: String,
name: String,
},
/// Delete the album `uid`. Its photos stay in the timeline; with
/// `delete_photos` set, photos that exist only in the album (saved from a
/// shared album) are deleted with it, which the server otherwise refuses.
@@ -148,14 +171,22 @@ pub enum Request {
},
/// Add timeline photos to the album `uid`. Replies with
/// [`Response::AlbumChanged`].
AddToAlbum { uid: String, photos: Vec<String> },
AddToAlbum {
uid: String,
photos: Vec<String>,
},
/// Take photos out of the album `uid`. They stay in the timeline: this is
/// not a trash. Replies with [`Response::AlbumChanged`].
RemoveFromAlbum { uid: String, photos: Vec<String> },
RemoveFromAlbum {
uid: String,
photos: Vec<String>,
},
/// Fetch thumbnails for the given photo uids, downloading the ones not
/// already cached (one batched round-trip) and replying with their on-disk
/// paths. Keep the batch small — it is served on demand, as tiles scroll in.
PhotoThumbs { uids: Vec<String> },
PhotoThumbs {
uids: Vec<String>,
},
/// Trash photos by node uid, answered with [`Response::Trashed`].
///
/// Uid-addressed rather than path-addressed because the photos volume is not
@@ -190,11 +221,15 @@ pub enum Request {
ReserveFileThumbGeneration,
/// Stop ordinary-file thumbnail work belonging to older listings. Photos
/// timeline work and an explicit recursive build are deliberately separate.
CancelFileThumbs { generation: u64 },
CancelFileThumbs {
generation: u64,
},
/// Start building local thumbnails for every supported image below `path`.
/// The request returns immediately; progress is read with
/// [`Request::ThumbnailBuildStatus`].
StartThumbnailBuild { path: String },
StartThumbnailBuild {
path: String,
},
/// Stop the current recursive ordinary-file thumbnail build, if any.
CancelThumbnailBuild,
/// Read progress for the recursive ordinary-file thumbnail build.
@@ -206,7 +241,31 @@ pub enum Request {
/// is how a front-end knows when the refreshed timeline is worth re-reading.
PhotosRefreshStatus,
/// Download a photo's full content into the cache; replies with its path.
OpenPhoto { uid: String },
OpenPhoto {
uid: String,
},
/// Open a revision for playback in the local viewer.
OpenGalleryVideo {
uid: String,
#[serde(default)]
private: bool,
},
OpenGalleryImage {
uid: String,
#[serde(default)]
private: bool,
},
CloseGalleryVideo {
token: String,
},
GalleryThumbnail {
uid: String,
#[serde(default)]
private: bool,
},
DriveGallery {
action: GalleryAction,
},
/// Add or remove Proton's `Favorite` tag on a photo. Replies with
/// [`Response::Ok`].
///
@@ -214,7 +273,10 @@ pub enum Request {
/// one shared with us, or one that lives only in an album — needs it
/// re-encrypted for our timeline, which the SDK does not implement yet; the
/// daemon reports that as an error rather than silently doing nothing.
SetPhotoFavorite { uid: String, favorite: bool },
SetPhotoFavorite {
uid: String,
favorite: bool,
},
/// Import Google Photos **Takeout** archives into Proton Photos.
///
/// `archives` are absolute paths to the export's `.zip` parts on the
@@ -326,7 +388,10 @@ pub enum Request {
/// Search the daemon's index of *local* (non-Drive) files on this machine.
/// Independent of [`Request::Search`] so a front-end can fire both at once and
/// render whichever lands first. Replies with [`Response::LocalResults`].
SearchLocal { query: String, limit: usize },
SearchLocal {
query: String,
limit: usize,
},
/// Search both the Drive metadata index and the local-file index in one
/// round-trip. This is the preferred prompt API; the two legacy search
/// requests remain available for older clients. `limit` applies to each
@@ -342,30 +407,48 @@ pub enum Request {
},
/// Rename a file or folder. `path` is mountpoint-relative; `new_name` is a
/// single path component (no separators). Replies with [`Response::Ok`].
Rename { path: String, new_name: String },
Rename {
path: String,
new_name: String,
},
/// Move a file or folder into a new parent folder. Both `path` and
/// `new_parent` are mountpoint-relative, or both absolute local paths; two
/// absolute paths may lie in different locations (My files, an on-demand
/// or a mirror synced folder), and the move is still made on Proton Drive
/// without transferring content. Replies with [`Response::Ok`].
Move { path: String, new_parent: String },
Move {
path: String,
new_parent: String,
},
/// Copy a file or folder into a folder on Proton Drive, without
/// downloading or uploading it. Both `path` and `new_parent` are
/// mountpoint-relative, or absolute paths inside My files. A name already
/// taken in `new_parent` gets the next free ` (n)` suffix. Replies with
/// [`Response::Ok`].
Copy { path: String, new_parent: String },
Copy {
path: String,
new_parent: String,
},
/// Ask Proton Drive how much the folder at mountpoint-relative `path`
/// holds. Replies with [`Response::FolderSize`].
FolderSize { path: String },
FolderSize {
path: String,
},
/// The by-uid twin of [`Request::FolderSize`].
FolderSizeByUid { uid: String },
FolderSizeByUid {
uid: String,
},
/// Trash a file or folder. `path` is mountpoint-relative. Replies with
/// [`Response::Ok`].
Delete { path: String },
Delete {
path: String,
},
/// Create a new folder named `name` under the mountpoint-relative `parent`.
/// Replies with [`Response::Ok`].
CreateFolder { parent: String, name: String },
CreateFolder {
parent: String,
name: String,
},
// There is deliberately no bytes-carrying single-file upload: it was
// `UploadFile { parent, name, bytes }`, and it OOMed on anything large for
// the reason described on `UploadPhoto`. `UploadPaths` covers the same case
@@ -388,11 +471,16 @@ pub enum Request {
/// Retune the on-disk cache's soft byte cap at runtime (`0` = unlimited) and
/// persist it to config so the next mount keeps it. Replies with
/// [`Response::Ok`].
SetCacheBudget { bytes: u64 },
SetCacheBudget {
bytes: u64,
},
/// Cap uploads and downloads at these bytes per second (`0` = no cap),
/// live for running transfers, and persist both to config so the next
/// mount keeps them. Replies with [`Response::Ok`].
SetBandwidthLimits { upload: u64, download: u64 },
SetBandwidthLimits {
upload: u64,
download: u64,
},
/// Report on the health of the metadata database and content cache: sizes,
/// row counts, and — when `deep` — SQLite's own integrity check. Replies
/// with [`Response::CacheReport`].
@@ -429,10 +517,14 @@ pub enum Request {
ListTrash,
/// Restore trashed nodes, by uid, to the folders they were trashed from.
/// Replies with [`Response::Ok`].
Restore { uids: Vec<String> },
Restore {
uids: Vec<String>,
},
/// Permanently delete trashed nodes by uid. Irreversible: the content is
/// gone from Proton Drive, not moved. Replies with [`Response::Ok`].
DeleteForever { uids: Vec<String> },
DeleteForever {
uids: Vec<String>,
},
/// Permanently delete everything in the trash. Irreversible.
/// Replies with [`Response::Ok`].
EmptyTrash,
@@ -443,7 +535,9 @@ pub enum Request {
/// only notices another client's changes when its TTL lapses, so a user who
/// knows the cache is stale needs a way to say so. Cheap and idempotent —
/// it invalidates, it does not fetch.
Refresh { scope: RefreshScope },
Refresh {
scope: RefreshScope,
},
// ---- locations --------------------------------------------------------
/// List every local Proton Drive location. Replies with
@@ -454,26 +548,37 @@ pub enum Request {
/// List the account's registered devices. Replies with [`Response::Devices`].
ListDevices,
/// Rename a device by its uid. Replies with [`Response::Ok`].
RenameDevice { uid: String, name: String },
RenameDevice {
uid: String,
name: String,
},
/// Delete (deregister) a device by its uid. Replies with [`Response::Ok`].
DeleteDevice { uid: String },
DeleteDevice {
uid: String,
},
/// Adopt an existing device as this machine's, pinning its uid in
/// `config.json` so a hostname change or reinstall re-attaches to it instead
/// of registering a duplicate. `uid: None` clears the pin.
/// Replies with [`Response::Ok`].
AdoptDevice { uid: Option<String> },
AdoptDevice {
uid: Option<String>,
},
/// Move every folder another device backs up into this machine's own
/// device, as server-side moves on the main volume. The other device stays
/// registered, without those folders. Sync folders here that already track
/// one of them follow it to its new share. Nothing is downloaded: the moved
/// folders are then offered by [`Request::ListRestorableFolders`].
/// Replies with [`Response::Ok`].
MigrateDevice { uid: String },
MigrateDevice {
uid: String,
},
// ---- device folder sync ----------------------------------
/// Add a local folder to this machine's device, uploading its tree and
/// registering the device on first use. Replies with [`Response::Ok`].
AddSyncFolder { local_path: String },
AddSyncFolder {
local_path: String,
},
/// Keep a real local directory in step with an existing folder in My files.
/// First sync unions one-sided files and preserves differing versions.
/// Replies with [`Response::Ok`]; no device backup is created.
@@ -485,42 +590,65 @@ pub enum Request {
ListSyncFolders,
/// Remove a synced folder by id; `delete_remote` also trashes its cloud copy.
/// Replies with [`Response::Ok`].
RemoveSyncFolder { id: i64, delete_remote: bool },
RemoveSyncFolder {
id: i64,
delete_remote: bool,
},
/// Switch a synced folder between `mirror` and `ondemand` (Phase 3). Replies
/// with [`Response::Ok`].
SetSyncFolderMode { id: i64, mode: String },
SetSyncFolderMode {
id: i64,
mode: String,
},
/// Pause or resume one mirror folder's reconcile, independent of the
/// global pause. Persisted until resumed. Replies with [`Response::Ok`].
SetSyncFolderPaused { id: i64, paused: bool },
SetSyncFolderPaused {
id: i64,
paused: bool,
},
/// Forget what a mirror folder synced before, so its next pass compares
/// both sides afresh: what is on one side only is copied to the other, and
/// a file that differs keeps both versions. Nothing is deleted. Replies
/// with [`Response::Ok`].
ResetSyncFolder { id: i64 },
ResetSyncFolder {
id: i64,
},
/// Force a reconcile pass: one folder by id, or all when `id` is `None`.
/// Replies with [`Response::Ok`].
SyncNow { id: Option<i64> },
SyncNow {
id: Option<i64>,
},
/// Pause or resume syncing: queued uploads and changes stop draining and
/// mirror folders stop reconciling, while reads through the mount keep
/// working. `until` is the Unix second a pause ends by itself; `None`
/// pauses until resumed. Ignored when resuming. Replies with
/// [`Response::Ok`].
SetSyncPaused { paused: bool, until: Option<i64> },
SetSyncPaused {
paused: bool,
until: Option<i64>,
},
/// List the queue of uploads and changes not yet on the remote. Replies
/// with [`Response::PendingOps`].
ListPendingOps,
/// Retry a backed-off queued op now instead of waiting out its backoff;
/// every failed op when `id` is `None`. Replies with [`Response::Ok`].
RetryPendingOp { id: Option<i64> },
RetryPendingOp {
id: Option<i64>,
},
/// Copy the content of a queued upload (`id` from
/// [`Request::ListPendingOps`]) to `dest`, an absolute path that must not
/// exist yet. The op stays queued. Replies with [`Response::Ok`].
ExportPendingOp { id: i64, dest: String },
ExportPendingOp {
id: i64,
dest: String,
},
/// Drop a queued change (`id` from [`Request::ListPendingOps`]) and undo
/// it locally: a node made here goes, a node Drive has goes back to what
/// Drive has, along with every other change queued on it. Its content is
/// lost unless it was exported first. Replies with [`Response::Ok`].
DiscardPendingOp { id: i64 },
DiscardPendingOp {
id: i64,
},
/// List the `(sync-conflict …)` copies under My Files and in synced
/// folders. Replies with
/// [`Response::Conflicts`].
@@ -529,18 +657,25 @@ pub enum Request {
/// copy in a synced folder).
/// Everything removed goes to the Proton trash. Replies with
/// [`Response::Ok`].
ResolveConflict { path: String, keep: ConflictKeep },
ResolveConflict {
path: String,
keep: ConflictKeep,
},
/// List the folders under this machine's device that can be synced here,
/// each with a proposed local path. Replies with
/// [`Response::RestorableFolders`].
ListRestorableFolders,
/// Attach the given remote device folders to local paths and sync them down.
/// Replies with [`Response::Ok`].
RestoreSyncFolders { items: Vec<RestoreItem> },
RestoreSyncFolders {
items: Vec<RestoreItem>,
},
/// [`Request::ListRestorableFolders`] for another registered device, by
/// uid, so its folders can be synced down to this machine. Replies with
/// [`Response::RestorableFolders`].
ListDeviceRestorableFolders { device: String },
ListDeviceRestorableFolders {
device: String,
},
/// [`Request::RestoreSyncFolders`] for folders under another device. A
/// separate variant rather than an optional field: an older daemon that
/// ignored the field would attach the folders under this machine's device
@@ -571,9 +706,13 @@ pub enum Request {
},
/// List the members, pending invitations and public link of the node at
/// mountpoint-relative `path`. Replies with [`Response::Share`].
ListShare { path: String },
ListShare {
path: String,
},
/// The by-uid twin of [`Request::ListShare`].
ListShareByUid { uid: String },
ListShareByUid {
uid: String,
},
/// Change the role of a share entry (member or pending invitation) on the node
/// at `path`. `id` and `kind` identify the entry (from [`Response::Share`]).
/// Replies with [`Response::Ok`].
@@ -621,9 +760,15 @@ pub enum Request {
},
/// Remove the public link `id` from the node at `path`. Replies with
/// [`Response::Ok`].
RemovePublicLink { path: String, id: String },
RemovePublicLink {
path: String,
id: String,
},
/// The by-uid twin of [`Request::RemovePublicLink`].
RemovePublicLinkByUid { uid: String, id: String },
RemovePublicLinkByUid {
uid: String,
id: String,
},
/// Change the public link `id` on the node at `path`, keeping its URL.
/// `role` is "viewer" or "editor", or `None` to keep the current one.
/// Replies with [`Response::PublicLink`].
@@ -646,28 +791,48 @@ pub enum Request {
/// invitation and every member. Each removal is attempted even if an
/// earlier one fails. Replies with [`Response::Ok`], or an error naming
/// what is still shared.
StopSharing { path: String },
StopSharing {
path: String,
},
/// The by-uid twin of [`Request::StopSharing`].
StopSharingByUid { uid: String },
StopSharingByUid {
uid: String,
},
// ---- revisions --------------------------------------------------------
/// List the version history of the file at mountpoint-relative `path`,
/// newest first. Replies with [`Response::Revisions`].
ListRevisions { path: String },
ListRevisions {
path: String,
},
/// The by-uid twin of [`Request::ListRevisions`].
ListRevisionsByUid { uid: String },
ListRevisionsByUid {
uid: String,
},
/// Make revision `revision_id` of the file at `path` current again. The
/// server applies this asynchronously, so the restored content may take a
/// moment to appear. Replies with [`Response::Ok`].
RestoreRevision { path: String, revision_id: String },
RestoreRevision {
path: String,
revision_id: String,
},
/// The by-uid twin of [`Request::RestoreRevision`].
RestoreRevisionByUid { uid: String, revision_id: String },
RestoreRevisionByUid {
uid: String,
revision_id: String,
},
/// Permanently delete revision `revision_id` of the file at `path`. The
/// content is unrecoverable, and the server refuses to delete the revision
/// that is currently active. Replies with [`Response::Ok`].
DeleteRevision { path: String, revision_id: String },
DeleteRevision {
path: String,
revision_id: String,
},
/// The by-uid twin of [`Request::DeleteRevision`].
DeleteRevisionByUid { uid: String, revision_id: String },
DeleteRevisionByUid {
uid: String,
revision_id: String,
},
/// Write revision `revision_id` of the file at `path` to the absolute local
/// path `dest`, leaving the file's current content untouched. Replies with
/// [`Response::Ok`].
@@ -699,15 +864,21 @@ pub enum Request {
/// with [`Response::Entries`]; like [`Request::ListSharedWithMe`] the entries
/// carry a `uid` and an empty `path`, since the subtree lives outside the
/// mount. Lets a front-end browse into a shared folder.
ListSharedFolder { uid: String },
ListSharedFolder {
uid: String,
},
/// Download a file shared with me into the content cache, addressed by `uid`.
/// Replies with [`Response::FilePath`] so the front-end can open it with the
/// default app. The by-uid twin of [`Request::OpenFile`], which can only
/// address nodes inside the mount.
OpenSharedFile { uid: String },
OpenSharedFile {
uid: String,
},
/// Leave a shared node by its `uid`, giving up my access. Replies with
/// [`Response::Ok`].
LeaveShared { uid: String },
LeaveShared {
uid: String,
},
// ---- incoming invitations ---------------------------------------------
/// List invitations addressed to me, pending accept or reject. Replies with
@@ -715,9 +886,13 @@ pub enum Request {
ListInvitations,
/// Accept the invitation `id`, gaining access to the shared node. Replies with
/// [`Response::Ok`].
AcceptInvitation { id: String },
AcceptInvitation {
id: String,
},
/// Reject the invitation `id`, declining access. Replies with [`Response::Ok`].
RejectInvitation { id: String },
RejectInvitation {
id: String,
},
// ---- bookmarks --------------------------------------------------------
/// List public links saved to my account. Replies with [`Response::Bookmarks`].
@@ -729,7 +904,9 @@ pub enum Request {
password: Option<String>,
},
/// Remove a saved bookmark by its `token`. Replies with [`Response::Ok`].
DeleteBookmark { token: String },
DeleteBookmark {
token: String,
},
// ---- account ----------------------------------------------------------
/// Total account storage usage (used/total, all Proton products, not just
@@ -743,7 +920,9 @@ pub enum Request {
/// daemon performs (uploads, downloads, deletes, renames, shares, sync
/// passes, …), so a front-end can show a running "what happened" feed
/// without re-deriving it from anywhere.
ListActivity { limit: usize },
ListActivity {
limit: usize,
},
// ---- push -------------------------------------------------------------
/// Keep the connection open and stream [`Event`] lines instead of one
@@ -761,6 +940,10 @@ pub enum Topic {
Files,
/// The photos timeline or albums.
Photos,
/// The visible set of gallery media changed.
GalleryVisibility,
/// A remote Gallery visibility update arrived or its state became unavailable.
GalleryVisibilitySynced,
Trash,
/// Shares, links, invitations and saved links, in either direction.
Shares,
@@ -785,9 +968,11 @@ impl Topic {
/// Every topic a front-end can act on. A new subscription is told all of
/// them have changed, so it catches up on whatever happened while it was
/// not connected.
pub const ALL: [Topic; 10] = [
pub const ALL: [Topic; 12] = [
Topic::Files,
Topic::Photos,
Topic::GalleryVisibility,
Topic::GalleryVisibilitySynced,
Topic::Trash,
Topic::Shares,
Topic::Devices,
@@ -964,6 +1149,8 @@ pub enum SyncIssue {
/// The account may no longer change the file or its folder, for example
/// because a share was revoked.
Access,
/// The item or a folder involved in a move can be restored from Trash.
Trashed,
/// The file or the folder it goes into is gone from Drive.
Missing,
/// The folder holds too many items, or is nested too deep.
@@ -981,6 +1168,7 @@ impl SyncIssue {
match self {
SyncIssue::Quota => "quota",
SyncIssue::Access => "access",
SyncIssue::Trashed => "trashed",
SyncIssue::Missing => "missing",
SyncIssue::Limit => "limit",
SyncIssue::Rejected => "rejected",
@@ -993,6 +1181,7 @@ impl SyncIssue {
match name {
"quota" => SyncIssue::Quota,
"access" => SyncIssue::Access,
"trashed" => SyncIssue::Trashed,
"missing" => SyncIssue::Missing,
"limit" => SyncIssue::Limit,
"rejected" => SyncIssue::Rejected,
@@ -1551,27 +1740,6 @@ pub enum PhotoKind {
Raw,
}
/// File-name extensions that denote a video, matched case-insensitively.
const VIDEO_EXTS: &[&str] = &[
"mkv", "mp4", "mov", "avi", "webm", "m4v", "flv", "wmv", "mpg", "mpeg", "ts", "3gp", "m2ts",
"mts", "ogv",
];
/// File-name extensions that denote a camera raw. The server media type for
/// these is frequently a generic `application/octet-stream`, so the extension is
/// the authoritative signal.
const RAW_EXTS: &[&str] = &[
"cr2", "cr3", "nef", "nrw", "arw", "srf", "sr2", "dng", "raf", "orf", "rw2", "srw", "pef",
"raw", "rwl", "iiq", "3fr", "dcr", "kdc", "mrw", "x3f",
];
/// File-name extensions that denote a ready-to-view still photo. Listed so a
/// known image name classifies as a photo outright, without deferring to a media
/// type that might disagree.
const PHOTO_EXTS: &[&str] = &[
"jpg", "jpeg", "png", "gif", "webp", "heic", "heif", "avif", "bmp", "tif", "tiff",
];
impl PhotoKind {
/// Classify a photo from what the daemon knows about it. A recognised
/// file-name extension is authoritative — it is reliable even before the
@@ -1579,26 +1747,11 @@ impl PhotoKind {
/// useless generic — so the media type is only consulted for names that carry
/// no extension we know. Anything still unresolved is a still photo.
pub fn classify(name: Option<&str>, media_type: Option<&str>) -> PhotoKind {
if let Some(ext) = name
.and_then(|n| n.rsplit_once('.'))
.map(|(_, e)| e.to_ascii_lowercase())
{
if RAW_EXTS.contains(&ext.as_str()) {
return PhotoKind::Raw;
}
if VIDEO_EXTS.contains(&ext.as_str()) {
return PhotoKind::Video;
}
if PHOTO_EXTS.contains(&ext.as_str()) {
return PhotoKind::Photo;
}
match proton_gallery_rs::grouping::MediaClass::classify(name, media_type) {
proton_gallery_rs::grouping::MediaClass::Photo => PhotoKind::Photo,
proton_gallery_rs::grouping::MediaClass::Video => PhotoKind::Video,
proton_gallery_rs::grouping::MediaClass::Raw => PhotoKind::Raw,
}
if let Some(mt) = media_type
&& mt.starts_with("video/")
{
return PhotoKind::Video;
}
PhotoKind::Photo
}
/// The stable integer this kind is persisted as (see the `kind` column of the
@@ -1827,6 +1980,62 @@ pub struct MappingProgress {
pub total: usize,
}
/// Actions on saved Drive folder galleries.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum GalleryAction {
AuthenticateHidden,
Lock,
List {
album: Option<GalleryPlace>,
offset: usize,
limit: usize,
},
PrivateList {
album: Option<GalleryPlace>,
proton: bool,
offset: usize,
limit: usize,
},
Folders {
parent: Option<String>,
},
Add {
uid: String,
},
Remove {
gallery: String,
},
Refresh,
Cover {
album: GalleryPlace,
uid: String,
},
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GalleryPlace {
pub gallery: String,
pub album: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GalleryFolder {
pub uid: String,
pub name: String,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GalleryAlbum {
pub place: GalleryPlace,
#[serde(default)]
pub proton: bool,
pub folder: GalleryFolder,
pub cover: Option<String>,
pub items: u64,
pub folders: u64,
pub hidden: bool,
}
/// One photo in a [`Request::PhotosTimeline`] page.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PhotoItem {
@@ -2218,7 +2427,9 @@ pub enum Response {
version: String,
},
/// A human-readable success message.
Ok { message: String },
Ok {
message: String,
},
/// Health report for the metadata database and content cache (reply to
/// [`Request::CacheInspect`]).
CacheReport {
@@ -2248,10 +2459,14 @@ pub enum Response {
integrity_running: bool,
},
/// The pin registry.
Pins { pins: Vec<Pin> },
Pins {
pins: Vec<Pin>,
},
/// A directory listing (reply to [`Request::ListDir`]) or a trash listing
/// (reply to [`Request::ListTrash`]).
Entries { entries: Vec<DirEntry> },
Entries {
entries: Vec<DirEntry>,
},
/// A page of the photos timeline. `available` is false when the account
/// has no photos volume.
Photos {
@@ -2264,6 +2479,22 @@ pub enum Response {
#[serde(default)]
counts: Option<(usize, usize, usize)>,
},
GalleryFolders {
folders: Vec<GalleryFolder>,
},
GalleryPage {
albums: Vec<GalleryAlbum>,
items: Vec<PhotoItem>,
total: usize,
},
GalleryVideo {
url: String,
token: String,
size: u64,
},
GalleryThumbnail {
data: Option<String>,
},
/// The account's photo albums (reply to [`Request::PhotoAlbums`]).
/// `available` is false when the account has no photos volume, matching
/// [`Response::Photos`].
@@ -2272,7 +2503,9 @@ pub enum Response {
items: Vec<AlbumInfo>,
},
/// What the daemon is doing right now (reply to [`Request::Diagnostics`]).
Diagnostics { diagnostics: Diagnostics },
Diagnostics {
diagnostics: Diagnostics,
},
/// How the Takeout import is doing (reply to [`Request::ImportStatus`]).
/// `running` is false once it has finished, when `summary` is the final
/// report; `summary` is `None` when no import has run this session.
@@ -2298,12 +2531,19 @@ pub enum Response {
#[serde(default)]
summary: Option<RedateSummary>,
},
PhotoPresence {
present: bool,
},
/// The months the timeline spans (reply to [`Request::PhotoMonths`]),
/// newest first.
PhotoMonths { months: Vec<PhotoMonth> },
PhotoMonths {
months: Vec<PhotoMonth>,
},
/// The duplicate sets (reply to [`Request::PhotoDuplicates`]), newest
/// first. Each set lists the copy worth keeping first.
PhotoDuplicates { sets: Vec<Vec<PhotoItem>> },
PhotoDuplicates {
sets: Vec<Vec<PhotoItem>>,
},
/// The sets of alike shots (reply to [`Request::PhotoSimilar`]), newest
/// first, each in capture order; and how far hashing has got, `None`
/// once no pass is running. `uncompared` counts the shots left out
@@ -2325,9 +2565,13 @@ pub enum Response {
},
/// The photos of one town, each with its location (reply to
/// [`Request::PlaceLocations`]).
PhotoLocations { items: Vec<PhotoLocation> },
PhotoLocations {
items: Vec<PhotoLocation>,
},
/// Thumbnails for a [`Request::PhotoThumbs`] batch.
Thumbs { items: Vec<PhotoThumb> },
Thumbs {
items: Vec<PhotoThumb>,
},
/// Per-node outcome of a [`Request::TrashNodes`] batch. Reported per uid
/// rather than as one verdict: the server answers each node separately, and
/// a front-end that removed all of them on a partial success would show a
@@ -2337,7 +2581,9 @@ pub enum Response {
failed: Vec<TrashFailure>,
},
/// The album a [`Request::CreateAlbum`] made.
AlbumCreated { uid: String },
AlbumCreated {
uid: String,
},
/// Outcome of a [`Request::AddToAlbum`] or [`Request::RemoveFromAlbum`],
/// per photo like [`Response::Trashed`]: `changed` photos were added or
/// removed, `failed` ones were not.
@@ -2351,20 +2597,33 @@ pub enum Response {
FileThumbsStale,
/// Daemon-issued generation reserved by
/// [`Request::ReserveFileThumbGeneration`].
FileThumbGeneration { generation: u64 },
FileThumbGeneration {
generation: u64,
},
/// Current recursive thumbnail-build progress.
ThumbnailBuild { status: ThumbnailBuildStatus },
ThumbnailBuild {
status: ThumbnailBuildStatus,
},
/// Whether a photos-timeline refresh is still running (reply to
/// [`Request::PhotosRefreshStatus`]).
PhotosRefresh { running: bool },
PhotosRefresh {
running: bool,
},
/// An on-disk path the front-end can open (e.g. a downloaded photo).
FilePath { path: String },
FilePath {
path: String,
},
/// Full-text search results (reply to [`Request::Search`]).
SearchResults { hits: Vec<SearchHit> },
SearchResults {
hits: Vec<SearchHit>,
},
/// Local-file search results (reply to [`Request::SearchLocal`]). `indexing`
/// is true while a scan of the machine is still running, so a front-end can
/// say "still indexing" instead of "no matches" on a cold first launch.
LocalResults { hits: Vec<LocalHit>, indexing: bool },
LocalResults {
hits: Vec<LocalHit>,
indexing: bool,
},
/// Drive and local-file search results returned together (reply to
/// [`Request::SearchV2`]). `local_indexing` distinguishes a genuinely empty
/// local result set from one observed while the initial scan is running.
@@ -2383,17 +2642,29 @@ pub enum Response {
jobs: Vec<JobItem>,
},
/// The account's devices (reply to [`Request::ListDevices`]).
Devices { items: Vec<DeviceInfo> },
Devices {
items: Vec<DeviceInfo>,
},
/// Every local Proton Drive location (reply to [`Request::ListLocations`]).
Locations { items: Vec<MountSpec> },
Locations {
items: Vec<MountSpec>,
},
/// This device's synced folders (reply to [`Request::ListSyncFolders`]).
SyncFolders { items: Vec<SyncFolderInfo> },
SyncFolders {
items: Vec<SyncFolderInfo>,
},
/// The upload/change queue (reply to [`Request::ListPendingOps`]).
PendingOps { items: Vec<PendingOpInfo> },
PendingOps {
items: Vec<PendingOpInfo>,
},
/// Conflict copies (reply to [`Request::ListConflicts`]).
Conflicts { items: Vec<ConflictInfo> },
Conflicts {
items: Vec<ConflictInfo>,
},
/// Folders offered for restore (reply to [`Request::ListRestorableFolders`]).
RestorableFolders { items: Vec<RestorableFolder> },
RestorableFolders {
items: Vec<RestorableFolder>,
},
/// A node's share: members + pending invitations, and its public link if any
/// (reply to [`Request::ListShare`]).
Share {
@@ -2403,28 +2674,46 @@ pub enum Response {
/// A freshly created or changed public link, carrying the shareable URL
/// (reply to [`Request::CreatePublicLink`] and
/// [`Request::UpdatePublicLink`]).
PublicLink { link: PublicLinkInfo },
PublicLink {
link: PublicLinkInfo,
},
/// What a folder holds on Proton Drive (reply to [`Request::FolderSize`]):
/// the bytes on storage and the number of items below it, folders and
/// trashed items included.
FolderSize { size: u64, items: u64 },
FolderSize {
size: u64,
items: u64,
},
/// Invitations addressed to me (reply to [`Request::ListInvitations`]).
Invitations { items: Vec<InvitationInfo> },
Invitations {
items: Vec<InvitationInfo>,
},
/// Saved public links (reply to [`Request::ListBookmarks`]).
Bookmarks { items: Vec<BookmarkInfo> },
Bookmarks {
items: Vec<BookmarkInfo>,
},
/// Account storage usage in bytes (reply to [`Request::AccountQuota`]).
/// `max_space` is the total; `used_space` what is consumed. `max_space == 0`
/// means the total is unknown, which a front-end shows as a plain used figure
/// rather than a full bar.
AccountQuota { max_space: i64, used_space: i64 },
AccountQuota {
max_space: i64,
used_space: i64,
},
/// Nodes I have shared with others (reply to [`Request::ListSharedByMe`]).
SharedByMe { items: Vec<SharedItem> },
SharedByMe {
items: Vec<SharedItem>,
},
/// A file's version history, newest first (reply to
/// [`Request::ListRevisions`]).
Revisions { items: Vec<RevisionInfo> },
Revisions {
items: Vec<RevisionInfo>,
},
/// The daemon's recent activity, newest first (reply to
/// [`Request::ListActivity`]).
Activity { items: Vec<ActivityEntry> },
Activity {
items: Vec<ActivityEntry>,
},
/// The request failed. `message` is for the user; `kind` is for the code —
/// a front-end decides its copy and whether to offer a retry from `kind`,
/// never by matching on the text.
@@ -2523,6 +2812,8 @@ impl Request {
pub fn read_timeout(&self) -> Duration {
if self.is_poll() {
POLL_READ_TIMEOUT
} else if matches!(self, Request::DriveGallery { .. }) {
Duration::from_secs(300)
} else {
READ_TIMEOUT
}
@@ -2869,7 +3160,7 @@ mod tests {
/// videos back to the expensive whole-file path.
#[test]
fn photo_kind_recognises_every_supported_video_extension() {
for ext in VIDEO_EXTS {
for ext in proton_gallery_rs::grouping::VIDEO_EXTENSIONS {
let lower = format!("movie.{ext}");
let upper = format!("MOVIE.{}", ext.to_ascii_uppercase());
assert_eq!(
+129 -34
View File
@@ -31,8 +31,30 @@ pub struct StoredAlbum {
impl Db {
/// Replace the album listing wholesale, in the given order.
pub fn albums_replace(&self, albums: &[StoredAlbum]) -> Result<()> {
self.albums_replace_impl(albums, None).map(|_| ())
}
pub fn albums_replace_at(
&self,
albums: &[StoredAlbum],
generation: i64,
now: i64,
) -> Result<bool> {
self.albums_replace_impl(albums, Some((generation, now)))
}
fn albums_replace_impl(
&self,
albums: &[StoredAlbum],
stamp: Option<(i64, i64)>,
) -> Result<bool> {
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
if let Some((generation, _)) = stamp
&& super::photos::photos_generation(&tx)? != generation
{
return Ok(false);
}
// Contents of an album that no longer exists (unshared, deleted) go with
// it — otherwise they would linger forever, keyed by an album uid no
// listing mentions again.
@@ -56,7 +78,11 @@ impl Db {
let mut stmt = tx.prepare(
"INSERT INTO albums
(uid, name, photo_count, cover_uid, last_activity, shared, seq)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
SELECT ?1,?2,?3,
CASE WHEN EXISTS(SELECT 1 FROM photo_tombstones WHERE uid=?4)
THEN (SELECT uid FROM album_photos WHERE album_uid=?1 ORDER BY seq LIMIT 1) ELSE ?4 END,
?5,?6,?7
WHERE NOT EXISTS(SELECT 1 FROM photo_tombstones WHERE uid=?1)",
)?;
for (seq, album) in albums.iter().enumerate() {
stmt.execute(params![
@@ -70,8 +96,11 @@ impl Db {
])?;
}
}
if let Some((_, now)) = stamp {
super::photos::gallery_state(&tx, "albums_synced_ms", now)?;
}
tx.commit()?;
Ok(())
Ok(true)
}
/// The persisted album listing, in stored order.
@@ -111,15 +140,44 @@ impl Db {
album_uid: &str,
items: &[(String, i64, Option<String>, Option<String>)],
) -> Result<()> {
self.album_photos_replace_impl(album_uid, items, None)
.map(|_| ())
}
pub fn album_photos_replace_at(
&self,
album_uid: &str,
items: &[(String, i64, Option<String>, Option<String>)],
generation: i64,
now: i64,
) -> Result<bool> {
self.album_photos_replace_impl(album_uid, items, Some((generation, now)))
}
fn album_photos_replace_impl(
&self,
album_uid: &str,
items: &[(String, i64, Option<String>, Option<String>)],
stamp: Option<(i64, i64)>,
) -> Result<bool> {
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
let learned: HashMap<String, (Option<f64>, i64, Option<String>)> = {
if let Some((generation, _)) = stamp
&& super::photos::photos_generation(&tx)? != generation
{
return Ok(false);
}
type StoredPhotoMetadata = (Option<f64>, i64, Option<String>, Option<String>);
let learned: HashMap<String, StoredPhotoMetadata> = {
let mut stmt = tx.prepare(
"SELECT uid, ratio, thumb_state, media_type FROM album_photos
"SELECT uid, ratio, thumb_state, media_type, name FROM album_photos
WHERE album_uid = ?1",
)?;
let rows = stmt.query_map([album_uid], |r| {
Ok((r.get::<_, String>(0)?, (r.get(1)?, r.get(2)?, r.get(3)?)))
Ok((
r.get::<_, String>(0)?,
(r.get(1)?, r.get(2)?, r.get(3)?, r.get(4)?),
))
})?;
rows.collect::<rusqlite::Result<_>>()?
};
@@ -128,15 +186,17 @@ impl Db {
{
let mut stmt = tx.prepare(
"INSERT INTO album_photos
(album_uid, uid, capture_time, name, media_type, kind, ratio, thumb_state, seq)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
(album_uid, uid, capture_time, name, media_type, kind, ratio, thumb_state, seq, resolved)
SELECT ?1,?2,?3,?4,?5,?6,?7,?8,?9,?10
WHERE NOT EXISTS(SELECT 1 FROM photo_tombstones WHERE uid IN (?1,?2))",
)?;
for (seq, (uid, capture_time, name, media_type)) in items.iter().enumerate() {
let (ratio, thumb_state, learned_media) =
learned
.get(uid)
.cloned()
.unwrap_or((None, THUMB_UNKNOWN, None));
let (ratio, thumb_state, learned_media, learned_name) = learned
.get(uid)
.cloned()
.unwrap_or((None, THUMB_UNKNOWN, None, None));
let resolved = name.is_some();
let name = name.clone().or(learned_name);
let media_type = media_type.clone().or(learned_media);
let kind =
crate::control::PhotoKind::classify(name.as_deref(), media_type.as_deref());
@@ -150,11 +210,32 @@ impl Db {
ratio,
thumb_state,
seq as i64,
resolved,
])?;
}
}
if let Some((_, now)) = stamp {
super::photos::gallery_state(&tx, &format!("album_synced_ms:{album_uid}"), now)?;
}
tx.commit()?;
Ok(())
Ok(true)
}
/// Reuse current timeline metadata and resolved album-only metadata.
pub fn album_photo_metadata(
&self,
album: &str,
) -> Result<HashMap<String, (String, Option<String>)>> {
let conn = self.read();
let mut stmt = conn.prepare(
"SELECT uid,name,media_type FROM album_photos
WHERE album_uid=?1 AND resolved=1 AND name IS NOT NULL
UNION ALL SELECT uid,name,media_type FROM photos
WHERE resolved_at IS NOT NULL AND name IS NOT NULL",
)?;
Ok(stmt
.query_map([album], |r| Ok((r.get(0)?, (r.get(1)?, r.get(2)?))))?
.collect::<rusqlite::Result<_>>()?)
}
/// One page of an album's photos, in stored order.
@@ -163,33 +244,47 @@ impl Db {
album_uid: &str,
offset: usize,
limit: usize,
) -> Result<Vec<StoredPhoto>> {
self.album_photos_page_visible(album_uid, offset, limit, "[]")
}
pub fn album_photos_page_visible(
&self,
album_uid: &str,
offset: usize,
limit: usize,
excluded: &str,
) -> Result<Vec<StoredPhoto>> {
let conn = self.read();
let mut stmt = conn.prepare(
"SELECT uid, capture_time, name, ratio, thumb_state, kind FROM album_photos
WHERE album_uid = ?1 ORDER BY seq LIMIT ?2 OFFSET ?3",
WHERE album_uid = ?1 AND uid NOT IN (SELECT value FROM json_each(?4))
ORDER BY seq LIMIT ?2 OFFSET ?3",
)?;
let rows = stmt
.query_map(params![album_uid, limit as i64, offset as i64], |r| {
Ok(StoredPhoto {
uid: r.get(0)?,
capture_time: r.get(1)?,
name: r.get(2)?,
ratio: r.get(3)?,
thumb_state: r.get(4)?,
kind: crate::control::PhotoKind::from_i64(r.get(5)?),
// Album rows have no favorite state of their own: an album
// photo on someone else's volume is not in our timeline, and
// favouriting one is not supported yet anyway.
favorite: false,
// Nor are album rows grouped: an album is a list the user
// made, and it shows exactly what they put in it.
group_size: 1,
has_raw: false,
// Album rows carry no location.
place_id: None,
})
})?
.query_map(
params![album_uid, limit as i64, offset as i64, excluded],
|r| {
Ok(StoredPhoto {
uid: r.get(0)?,
capture_time: r.get(1)?,
name: r.get(2)?,
ratio: r.get(3)?,
thumb_state: r.get(4)?,
kind: crate::control::PhotoKind::from_i64(r.get(5)?),
// Album rows have no favorite state of their own: an album
// photo on someone else's volume is not in our timeline, and
// favouriting one is not supported yet anyway.
favorite: false,
// Nor are album rows grouped: an album is a list the user
// made, and it shows exactly what they put in it.
group_size: 1,
has_raw: false,
// Album rows carry no location.
place_id: None,
})
},
)?
.collect::<rusqlite::Result<_>>()?;
Ok(rows)
}
+22 -1
View File
@@ -11,7 +11,7 @@ use super::Db;
use crate::Result;
/// Current schema version. Bump on every forward migration added below.
pub(super) const SCHEMA_VERSION: i64 = 45;
pub(super) const SCHEMA_VERSION: i64 = 46;
impl Db {
pub(super) fn migrate(&self) -> Result<()> {
@@ -490,6 +490,17 @@ impl Db {
}
}
}
if current < 46 {
tx.execute_batch(MIGRATION_V46)?;
let has_resolved: bool = tx.query_row(
"SELECT EXISTS(SELECT 1 FROM pragma_table_info('album_photos') WHERE name='resolved')",
[],
|row| row.get(0),
)?;
if !has_resolved {
tx.execute_batch(MIGRATION_V46_ALBUM_PHOTOS)?;
}
}
tx.execute(
"INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1)
ON CONFLICT(key) DO UPDATE SET value = excluded.value",
@@ -1459,3 +1470,13 @@ BEGIN
UPDATE mount SET kind = NEW.kind WHERE sync_folder_id = NEW.id;
END;
";
/// Keep deletion evidence across listing races and remember unresolved album metadata.
const MIGRATION_V46: &str = "
CREATE TABLE IF NOT EXISTS photo_tombstones(uid TEXT PRIMARY KEY);
";
const MIGRATION_V46_ALBUM_PHOTOS: &str = "
ALTER TABLE album_photos ADD COLUMN resolved INTEGER NOT NULL DEFAULT 0;
UPDATE album_photos SET resolved=1 WHERE name IS NOT NULL;
";
+400 -173
View File
@@ -1,10 +1,12 @@
//! The photos timeline: a flat, date-ordered projection of the photo share,
//! persisted so the gallery opens instantly instead of re-enumerating on launch.
use rusqlite::params;
use rusqlite::{Connection, OptionalExtension, Transaction, params};
use std::collections::{HashMap, HashSet};
use proton_gallery_rs::grouping::{Grouped, group_photos, name_stem};
use super::Db;
use crate::Result;
@@ -121,135 +123,6 @@ fn capture_day(conn: &rusqlite::Connection, capture_time: i64) -> Option<String>
.flatten()
}
/// The file name without its extension, lowercased — `IMG_1234.CR2` and
/// `IMG_1234.JPG` share `img_1234` — with the camera's own part-of-a-shot
/// marker removed, so the two files a raw capture writes share a stem too.
fn name_stem(name: Option<&str>) -> Option<String> {
let name = name?;
let stem = match name.rsplit_once('.') {
Some((stem, _)) if !stem.is_empty() => stem,
_ => name,
};
let stem = stem.to_ascii_lowercase();
Some(strip_shot_marker(&stem).to_string())
}
/// Drop a `.RAW-NN.ROLE` marker from a stem.
///
/// Pixel stores one raw capture as `PXL_20260919_000625670.RAW-01.COVER.jpg`
/// and `PXL_20260919_000625670.RAW-02.ORIGINAL.dng`: one shot, two files, two
/// stems that differ in exactly the part naming which file of the shot this is.
/// Cutting the marker off is what lets rule 2 see the pair. The check is narrow
/// on purpose — digits, then a single role word — so an ordinary name that
/// happens to contain `.raw-` keeps its stem.
fn strip_shot_marker(stem: &str) -> &str {
let Some(at) = stem.rfind(".raw-") else {
return stem;
};
let rest = &stem[at + ".raw-".len()..];
let Some((index, role)) = rest.split_once('.') else {
return stem;
};
let marked = !index.is_empty()
&& index.bytes().all(|b| b.is_ascii_digit())
&& !role.is_empty()
&& role.bytes().all(|b| b.is_ascii_alphabetic());
if marked { &stem[..at] } else { stem }
}
/// One entry of the grouping pass: what rule 2 needs, plus what choosing a
/// representative needs.
struct Grouped {
uid: String,
kind: crate::control::PhotoKind,
main_uid: Option<String>,
day: Option<String>,
stem: Option<String>,
}
/// Which group each photo belongs to, and which member of it the gallery shows.
///
/// Precedence, as agreed:
///
/// 1. The server's own relation — a photo with a `main_photo_uid` joins that
/// photo's group. The server knows about live photos and bursts; we do not
/// have to guess at them.
/// 2. Otherwise, same capture day **and** same file-name stem **and** one of the
/// two is a camera raw while the other is not. That is the RAW+JPEG pair a
/// camera writes, and the differing-kind clause keeps two JPEGs that happen
/// to share a name apart.
/// 3. Otherwise the photo is its own group.
///
/// The representative is the non-raw member when the group has one — a JPEG
/// decodes in milliseconds and is what the person expects to see — and the
/// earliest member in server order otherwise.
fn group_photos(entries: &[Grouped]) -> Vec<String> {
let mut parent: Vec<usize> = (0..entries.len()).collect();
fn find(parent: &mut [usize], mut i: usize) -> usize {
while parent[i] != i {
parent[i] = parent[parent[i]];
i = parent[i];
}
i
}
let union = |parent: &mut [usize], a: usize, b: usize| {
let (a, b) = (find(parent, a), find(parent, b));
if a != b {
parent[b] = a;
}
};
let index: HashMap<&str, usize> = entries
.iter()
.enumerate()
.map(|(i, e)| (e.uid.as_str(), i))
.collect();
for (i, entry) in entries.iter().enumerate() {
if let Some(main) = entry.main_uid.as_deref()
&& let Some(&j) = index.get(main)
{
union(&mut parent, j, i);
}
}
// Rule 2 needs only one pass: everything sharing a day and a stem lands in
// the same bucket, and the raw / non-raw split is checked pairwise there.
let mut by_name: HashMap<(&str, &str), Vec<usize>> = HashMap::new();
for (i, entry) in entries.iter().enumerate() {
if let (Some(day), Some(stem)) = (entry.day.as_deref(), entry.stem.as_deref()) {
by_name.entry((day, stem)).or_default().push(i);
}
}
let is_raw = |i: usize| entries[i].kind == crate::control::PhotoKind::Raw;
for bucket in by_name.values() {
for (n, &i) in bucket.iter().enumerate() {
for &j in &bucket[n + 1..] {
if is_raw(i) != is_raw(j) {
union(&mut parent, i, j);
}
}
}
}
// Representative per root, then the key every member carries.
let mut representative: HashMap<usize, usize> = HashMap::new();
for i in 0..entries.len() {
let root = find(&mut parent, i);
match representative.get(&root).copied() {
Some(current) if !is_raw(current) || is_raw(i) => {}
_ => {
representative.insert(root, i);
}
}
}
(0..entries.len())
.map(|i| {
let root = find(&mut parent, i);
entries[representative[&root]].uid.clone()
})
.collect()
}
/// The columns every photo read selects, with the group aggregates joined in.
/// `g.n` is how many photos the group holds and `g.raw` whether any of them is a
/// camera raw file — one query rather than a second lookup per tile.
@@ -278,15 +151,286 @@ fn stored_photo(r: &rusqlite::Row<'_>) -> rusqlite::Result<StoredPhoto> {
})
}
const PHOTOS_GENERATION: &str = "photos_projection_generation";
const PHOTOS_SYNCED: &str = "photos_synced_ms";
const PHOTOS_AVAILABLE: &str = "photos_available";
const PHOTOS_RECONCILE: &str = "photos_reconcile";
pub(super) fn photos_generation(conn: &Connection) -> rusqlite::Result<i64> {
conn.query_row(
"SELECT coalesce((SELECT CAST(value AS INTEGER) FROM sync_state WHERE key=?1),0)",
[PHOTOS_GENERATION],
|row| row.get(0),
)
}
pub(super) fn gallery_state(
conn: &Connection,
key: &str,
value: impl rusqlite::ToSql,
) -> rusqlite::Result<()> {
conn.execute(
"INSERT INTO sync_state(key,value) VALUES (?1,?2)
ON CONFLICT(key) DO UPDATE SET value=excluded.value",
params![key, value],
)?;
Ok(())
}
fn photos_delete_tx(tx: &Transaction<'_>, uids: &[String]) -> Result<usize> {
let mut removed = 0;
for uid in uids {
tx.execute(
"INSERT OR IGNORE INTO photo_tombstones(uid) VALUES (?1)",
[uid],
)?;
removed += tx.execute("DELETE FROM photos WHERE uid=?1", [uid])?;
tx.execute("DELETE FROM albums WHERE uid=?1", [uid])?;
tx.execute("DELETE FROM album_photos WHERE album_uid=?1", [uid])?;
tx.execute(
"UPDATE albums SET photo_count=max(photo_count-1,0)
WHERE cover_uid=?1 OR uid IN (SELECT album_uid FROM album_photos WHERE uid=?1)",
[uid],
)?;
tx.execute("DELETE FROM album_photos WHERE uid=?1", [uid])?;
tx.execute(
"UPDATE albums SET cover_uid=(SELECT uid FROM album_photos
WHERE album_uid=albums.uid ORDER BY seq LIMIT 1) WHERE cover_uid=?1",
[uid],
)?;
}
tx.execute(
"UPDATE photos SET group_key=NULL WHERE group_key IS NOT NULL
AND group_key NOT IN (SELECT uid FROM photos)",
[],
)?;
Ok(removed)
}
impl Db {
pub fn photo_projection_generation(&self) -> Result<i64> {
Ok(photos_generation(&self.read())?)
}
/// One transaction records the deletion, stale metadata, listing work and feed position.
pub fn photos_apply_events(
&self,
cursor_key: &str,
cursor: &str,
gone: &[String],
touched: &[String],
gap: bool,
seed: bool,
) -> Result<()> {
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
if !gone.is_empty() {
photos_delete_tx(&tx, gone)?;
}
for uid in touched {
tx.execute("DELETE FROM photo_tombstones WHERE uid=?1", [uid])?;
tx.execute("UPDATE photos SET resolved_at=NULL WHERE uid=?1", [uid])?;
tx.execute("UPDATE album_photos SET resolved=0 WHERE uid=?1", [uid])?;
}
if gap {
tx.execute("UPDATE photos SET resolved_at=NULL", [])?;
tx.execute("UPDATE album_photos SET resolved=0", [])?;
gallery_state(&tx, PHOTOS_RECONCILE, 1)?;
}
if seed || gap || !gone.is_empty() || !touched.is_empty() {
let generation = photos_generation(&tx)?;
gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?;
tx.execute(
"DELETE FROM sync_state WHERE key='albums_synced_ms'
OR key GLOB 'album_synced_ms:*'",
[],
)?;
}
if seed || gap || !touched.is_empty() {
tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_SYNCED])?;
}
gallery_state(&tx, cursor_key, cursor)?;
tx.commit()?;
Ok(())
}
pub fn photos_invalidate(&self) -> Result<()> {
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
let generation = photos_generation(&tx)?;
gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?;
tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_SYNCED])?;
tx.commit()?;
Ok(())
}
pub fn photos_need_work(&self) -> Result<bool> {
let conn = self.read();
Ok(conn.query_row(
"SELECT NOT EXISTS(SELECT 1 FROM sync_state WHERE key=?1)
OR EXISTS(SELECT 1 FROM photos WHERE resolved_at IS NULL)",
[PHOTOS_SYNCED],
|r| r.get(0),
)?)
}
pub fn photos_pending(&self) -> Result<Vec<String>> {
let conn = self.read();
let mut stmt =
conn.prepare("SELECT uid FROM photos WHERE resolved_at IS NULL ORDER BY seq")?;
Ok(stmt
.query_map([], |r| r.get(0))?
.collect::<rusqlite::Result<_>>()?)
}
pub fn photo_removed(&self, uid: &str) -> Result<bool> {
Ok(self.read().query_row(
"SELECT EXISTS(SELECT 1 FROM photo_tombstones WHERE uid=?1)",
[uid],
|r| r.get(0),
)?)
}
pub fn photos_contains(&self, uid: &str, album: Option<&str>) -> Result<bool> {
let conn = self.read();
Ok(match album {
Some(album) => conn.query_row(
"SELECT EXISTS(SELECT 1 FROM album_photos WHERE album_uid=?1 AND uid=?2)",
params![album, uid],
|r| r.get(0),
)?,
None => conn.query_row(
"SELECT EXISTS(SELECT 1 FROM photos WHERE uid=?1)
OR EXISTS(SELECT 1 FROM album_photos WHERE uid=?1)",
[uid],
|r| r.get(0),
)?,
})
}
/// Persist one enrichment batch. The generation check and UPDATE share the
/// writer transaction with deletion, so a stale batch cannot restore a row.
pub fn photos_resolve_at(&self, generation: i64, rows: &[TimelineRow]) -> Result<bool> {
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
if photos_generation(&tx)? != generation {
return Ok(false);
}
{
let mut update = tx.prepare(
"UPDATE photos SET name=?2, media_type=?3, kind=?4, favorite=?5,
similar_hash=CASE WHEN content_hash IS ?6 THEN similar_hash ELSE NULL END,
content_hash=?6, main_uid=?7, latitude=?8, longitude=?9, place_id=?10,
resolved_at=?11 WHERE uid=?1",
)?;
for row in rows.iter().filter(|row| row.resolved_at.is_some()) {
let kind = crate::control::PhotoKind::classify(
row.name.as_deref(),
row.media_type.as_deref(),
);
update.execute(params![
row.uid,
row.name,
row.media_type,
kind.as_i64(),
row.favorite.unwrap_or(false),
row.content_hash,
row.main_uid,
row.location.map(|p| p.0),
row.location.map(|p| p.1),
row.location
.and_then(|(lat, lon)| crate::places::nearest(lat, lon))
.map(|city| city.id),
row.resolved_at
])?;
}
}
if !rows.is_empty() {
let (entries, existing): (Vec<_>, Vec<Option<String>>) = {
let mut stmt = tx.prepare(
"SELECT uid,kind,main_uid,strftime('%Y-%m-%d',capture_time,'unixepoch','localtime'),
name,group_key FROM photos ORDER BY seq",
)?;
stmt.query_map([], |r| {
let name: Option<String> = r.get(4)?;
Ok((
Grouped {
uid: r.get(0)?,
raw: crate::control::PhotoKind::from_i64(r.get(1)?)
== crate::control::PhotoKind::Raw,
main_uid: r.get(2)?,
day: r.get(3)?,
stem: name_stem(name.as_deref()),
},
r.get(5)?,
))
})?
.collect::<rusqlite::Result<Vec<_>>>()?
.into_iter()
.unzip()
};
let mut update = tx.prepare("UPDATE photos SET group_key=?2 WHERE uid=?1")?;
for ((entry, old), group) in entries.iter().zip(existing).zip(group_photos(&entries)) {
if old.as_deref() != Some(group.as_str()) {
update.execute(params![entry.uid, group])?;
}
}
}
tx.commit()?;
Ok(true)
}
/// Replace the timeline wholesale. A row whose `resolved_at` is `Some` was
/// read from the server in this pass, so its fields are taken as they are —
/// a `None` there means the server no longer reports that value. A row whose
/// `resolved_at` is `None` was skipped or failed to resolve, and keeps
/// whatever is already stored rather than having it silently cleared.
pub fn photos_replace(&self, items: &[TimelineRow]) -> Result<()> {
self.photos_replace_impl(items, None).map(|_| ())
}
pub fn photos_replace_at(
&self,
items: &[TimelineRow],
generation: i64,
available: bool,
now: i64,
) -> Result<bool> {
self.photos_replace_impl(items, Some((generation, available, now)))
}
fn photos_replace_impl(
&self,
items: &[TimelineRow],
stamp: Option<(i64, bool, i64)>,
) -> Result<bool> {
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
let mut tombstones = HashSet::new();
if let Some((generation, _, _)) = stamp {
if photos_generation(&tx)? != generation {
return Ok(false);
}
let repairing = tx
.query_row(
"SELECT 1 FROM sync_state WHERE key=?1",
[PHOTOS_RECONCILE],
|_| Ok(()),
)
.optional()?
.is_some();
if repairing {
let mut remove = tx.prepare("DELETE FROM photo_tombstones WHERE uid=?1")?;
for row in items {
remove.execute([&row.uid])?;
}
tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_RECONCILE])?;
}
let mut stmt = tx.prepare("SELECT uid FROM photo_tombstones")?;
tombstones = stmt
.query_map([], |r| r.get::<_, String>(0))?
.collect::<rusqlite::Result<_>>()?;
}
// `name` and `media_type` are learned-and-kept like the ratio and thumb
// verdict: the timeline DTO carries only the uid and capture time, so the
// daemon may not know them when it replaces the timeline — because the
@@ -325,6 +469,7 @@ impl Db {
// Everything the insert and the grouping need, resolved once per photo.
let resolved: Vec<(&TimelineRow, Learned, crate::control::PhotoKind)> = items
.iter()
.filter(|row| !tombstones.contains(&row.uid))
.map(|row| {
let mut carried = learned.get(&row.uid).cloned().unwrap_or(Learned {
thumb_state: THUMB_UNKNOWN,
@@ -369,7 +514,7 @@ impl Db {
.iter()
.map(|(row, carried, kind)| Grouped {
uid: row.uid.clone(),
kind: *kind,
raw: *kind == crate::control::PhotoKind::Raw,
main_uid: carried.main_uid.clone(),
day: capture_day(&tx, row.capture_time),
stem: name_stem(carried.name.as_deref()),
@@ -414,8 +559,12 @@ impl Db {
])?;
}
}
if let Some((_, available, now)) = stamp {
gallery_state(&tx, PHOTOS_AVAILABLE, available as i64)?;
gallery_state(&tx, PHOTOS_SYNCED, now)?;
}
tx.commit()?;
Ok(())
Ok(true)
}
/// The uids whose node metadata is already resolved, so a refresh can skip
@@ -458,8 +607,16 @@ impl Db {
/// refresh. For a continuity loss, where the daemon cannot know what it
/// missed, and for an explicit `refresh photos --full`.
pub fn photos_mark_all_unresolved(&self) -> Result<usize> {
let conn = self.conn.lock();
Ok(conn.execute("UPDATE photos SET resolved_at = NULL", [])?)
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
let marked = tx.execute("UPDATE photos SET resolved_at=NULL", [])?;
tx.execute("UPDATE album_photos SET resolved=0", [])?;
let generation = photos_generation(&tx)?;
gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?;
gallery_state(&tx, PHOTOS_RECONCILE, 1)?;
tx.execute("DELETE FROM sync_state WHERE key=?1", [PHOTOS_SYNCED])?;
tx.commit()?;
Ok(marked)
}
/// Forget photos that have been trashed, so the gallery does not show them
@@ -474,23 +631,9 @@ impl Db {
}
let mut conn = self.conn.lock();
let tx = conn.transaction()?;
let mut removed = 0;
{
let mut photos = tx.prepare("DELETE FROM photos WHERE uid = ?1")?;
let mut albums = tx.prepare("DELETE FROM album_photos WHERE uid = ?1")?;
for uid in uids {
removed += photos.execute([uid])?;
albums.execute([uid])?;
}
}
// A group whose representative went is left pointing at nothing, which
// drops its other files off every page. Make them stand alone until the
// next refresh groups them again.
tx.execute(
"UPDATE photos SET group_key = NULL WHERE group_key IS NOT NULL \
AND group_key NOT IN (SELECT uid FROM photos)",
[],
)?;
let removed = photos_delete_tx(&tx, uids)?;
let generation = photos_generation(&tx)?;
gallery_state(&tx, PHOTOS_GENERATION, generation + 1)?;
tx.commit()?;
Ok(removed)
}
@@ -513,24 +656,42 @@ impl Db {
range: Option<(i64, i64)>,
favorites: bool,
not_in_album: bool,
) -> Result<Vec<StoredPhoto>> {
self.photos_page_visible(offset, limit, kind, range, favorites, not_in_album, "[]")
}
#[allow(clippy::too_many_arguments)]
pub fn photos_page_visible(
&self,
offset: usize,
limit: usize,
kind: Option<crate::control::PhotoKind>,
range: Option<(i64, i64)>,
favorites: bool,
not_in_album: bool,
excluded: &str,
) -> Result<Vec<StoredPhoto>> {
let conn = self.read();
// Built up so any combination of the optional filters is one indexed
// query rather than a statement per case.
let mut sql = String::from(PHOTO_SELECT);
let mut binds: Vec<i64> = Vec::new();
let mut binds: Vec<rusqlite::types::Value> = Vec::new();
let mut conds: Vec<String> = Vec::new();
if excluded != "[]" {
binds.push(excluded.to_owned().into());
conds.push("p.uid NOT IN (SELECT value FROM json_each(?1))".to_owned());
}
if kind != Some(crate::control::PhotoKind::Raw) {
conds.push("p.uid = COALESCE(p.group_key, p.uid)".to_string());
}
if let Some(k) = kind {
binds.push(k.as_i64());
binds.push((k.as_i64()).into());
conds.push(format!("p.kind = ?{}", binds.len()));
}
if let Some((from, to)) = range {
binds.push(from);
binds.push((from).into());
conds.push(format!("p.capture_time >= ?{}", binds.len()));
binds.push(to);
binds.push((to).into());
conds.push(format!("p.capture_time < ?{}", binds.len()));
}
if favorites {
@@ -549,9 +710,9 @@ impl Db {
sql.push_str(" WHERE ");
sql.push_str(&conds.join(" AND "));
}
binds.push(limit as i64);
binds.push((limit as i64).into());
let limit_pos = binds.len();
binds.push(offset as i64);
binds.push((offset as i64).into());
let offset_pos = binds.len();
sql.push_str(&format!(
" ORDER BY p.seq LIMIT ?{limit_pos} OFFSET ?{offset_pos}"
@@ -580,6 +741,25 @@ impl Db {
Ok(rows)
}
/// Include associated files so a public preview cannot reveal a hidden
/// RAW, JPEG or Live Photo through another part of the same shot.
pub fn photo_group_members_for(&self, uids: &HashSet<String>) -> Result<HashSet<String>> {
if uids.is_empty() {
return Ok(HashSet::new());
}
let ids = serde_json::to_string(uids).expect("file identifiers serialize");
let conn = self.read();
let mut query = conn.prepare(
"SELECT uid FROM photos WHERE COALESCE(group_key, uid) IN (
SELECT COALESCE(group_key, uid) FROM photos
WHERE uid IN (SELECT value FROM json_each(?1))
)",
)?;
Ok(query
.query_map([ids], |row| row.get(0))?
.collect::<rusqlite::Result<_>>()?)
}
/// The whole persisted timeline, in stored order — every file, not one row
/// per group. Only for whole-library passes (the photo re-date); the gallery
/// pages with [`Db::photos_page`].
@@ -601,27 +781,38 @@ impl Db {
pub fn photos_months(
&self,
kind: Option<crate::control::PhotoKind>,
) -> Result<Vec<(i32, i32, usize)>> {
self.photos_months_visible(kind, "[]")
}
pub fn photos_months_visible(
&self,
kind: Option<crate::control::PhotoKind>,
excluded: &str,
) -> Result<Vec<(i32, i32, usize)>> {
let conn = self.read();
// The scrubber has to agree with the page it scrubs, so it counts what
// the page shows: groups everywhere except on the Raw tab.
let (filter, binds): (&str, Vec<i64>) = match kind {
Some(crate::control::PhotoKind::Raw) => (" WHERE kind = 2", Vec::new()),
Some(k) => (
" WHERE uid = COALESCE(group_key, uid) AND kind = ?1",
vec![k.as_i64()],
),
None => (" WHERE uid = COALESCE(group_key, uid)", Vec::new()),
let filter = match kind {
Some(crate::control::PhotoKind::Raw) => "kind = ?2",
Some(_) => "uid = COALESCE(group_key, uid) AND kind = ?2",
None => "uid = COALESCE(group_key, uid) AND ?2 IS NULL",
};
let sql = format!(
"SELECT CAST(strftime('%Y', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS y, \
"WITH hidden_groups AS (
SELECT COALESCE(group_key, uid) FROM photos
WHERE uid IN (SELECT value FROM json_each(?1))
)
SELECT CAST(strftime('%Y', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS y, \
CAST(strftime('%m', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS m, \
COUNT(*) \
FROM photos{filter} GROUP BY y, m ORDER BY y DESC, m DESC"
FROM photos WHERE {filter}
AND COALESCE(group_key, uid) NOT IN (SELECT * FROM hidden_groups)
GROUP BY y, m ORDER BY y DESC, m DESC"
);
let mut stmt = conn.prepare(&sql)?;
let rows = stmt
.query_map(rusqlite::params_from_iter(binds), |r| {
.query_map(params![excluded, kind.map(|kind| kind.as_i64())], |r| {
Ok((
r.get::<_, i32>(0)?,
r.get::<_, i32>(1)?,
@@ -637,6 +828,15 @@ impl Db {
/// pick the date, and its own year is left out, because today's photos are
/// what the timeline already opens on. One row per group, like the timeline.
pub fn photos_on_this_day(&self, today: i64, limit: usize) -> Result<Vec<StoredPhoto>> {
self.photos_on_this_day_visible(today, limit, "[]")
}
pub fn photos_on_this_day_visible(
&self,
today: i64,
limit: usize,
excluded: &str,
) -> Result<Vec<StoredPhoto>> {
let conn = self.read();
let sql = format!(
"{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) \
@@ -644,11 +844,12 @@ impl Db {
= strftime('%m-%d', ?1, 'unixepoch', 'localtime') \
AND strftime('%Y', p.capture_time, 'unixepoch', 'localtime') \
< strftime('%Y', ?1, 'unixepoch', 'localtime') \
AND p.uid NOT IN (SELECT value FROM json_each(?3))
ORDER BY p.seq LIMIT ?2"
);
let mut stmt = conn.prepare(&sql)?;
let rows = stmt
.query_map(params![today, limit as i64], stored_photo)?
.query_map(params![today, limit as i64, excluded], stored_photo)?
.collect::<rusqlite::Result<_>>()?;
Ok(rows)
}
@@ -657,6 +858,10 @@ impl Db {
/// cover, most photographed first. Counted per group, like the timeline;
/// photos without a location, or taken far from any town, are in none.
pub fn photo_places(&self) -> Result<Vec<StoredPlace>> {
self.photo_places_visible("[]")
}
pub fn photo_places_visible(&self, excluded: &str) -> Result<Vec<StoredPlace>> {
let rows: Vec<(u32, usize, String)> = {
let conn = self.read();
// SQLite fills the bare `uid` from the row `MIN(seq)` picked, which
@@ -664,9 +869,10 @@ impl Db {
let mut stmt = conn.prepare(
"SELECT place_id, COUNT(*), uid, MIN(seq) FROM photos \
WHERE uid = COALESCE(group_key, uid) AND place_id IS NOT NULL \
AND uid NOT IN (SELECT value FROM json_each(?1))
GROUP BY place_id ORDER BY COUNT(*) DESC, MIN(seq)",
)?;
stmt.query_map([], |r| {
stmt.query_map([excluded], |r| {
Ok((r.get(0)?, r.get::<_, i64>(1)? as usize, r.get(2)?))
})?
.collect::<rusqlite::Result<_>>()?
@@ -695,15 +901,29 @@ impl Db {
id: u32,
offset: usize,
limit: usize,
) -> Result<Vec<StoredPhoto>> {
self.photos_at_place_visible(id, offset, limit, "[]")
}
pub fn photos_at_place_visible(
&self,
id: u32,
offset: usize,
limit: usize,
excluded: &str,
) -> Result<Vec<StoredPhoto>> {
let conn = self.read();
let sql = format!(
"{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) AND p.place_id = ?1 \
"{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) AND p.place_id = ?1
AND p.uid NOT IN (SELECT value FROM json_each(?4))
ORDER BY p.seq LIMIT ?2 OFFSET ?3"
);
let mut stmt = conn.prepare(&sql)?;
let rows = stmt
.query_map(params![id, limit as i64, offset as i64], stored_photo)?
.query_map(
params![id, limit as i64, offset as i64, excluded],
stored_photo,
)?
.collect::<rusqlite::Result<_>>()?;
Ok(rows)
}
@@ -884,6 +1104,10 @@ impl Db {
/// Per-tab counts for the Photos page subtitle: `(photos, videos, raw)`.
pub fn photos_counts(&self) -> Result<(usize, usize, usize)> {
self.photos_counts_visible("[]")
}
pub fn photos_counts_visible(&self, excluded: &str) -> Result<(usize, usize, usize)> {
use crate::control::PhotoKind;
let conn = self.read();
// Photos and Videos count groups — one shot is one entry, however many
@@ -891,9 +1115,12 @@ impl Db {
// them individually.
let mut stmt = conn.prepare(
"SELECT kind, COUNT(*) FROM photos \
WHERE uid = COALESCE(group_key, uid) OR kind = 2 GROUP BY kind",
WHERE (uid = COALESCE(group_key, uid) OR kind = 2)
AND uid NOT IN (SELECT value FROM json_each(?1)) GROUP BY kind",
)?;
let rows = stmt.query_map([], |r| Ok((r.get::<_, i64>(0)?, r.get::<_, i64>(1)?)))?;
let rows = stmt.query_map([excluded], |r| {
Ok((r.get::<_, i64>(0)?, r.get::<_, i64>(1)?))
})?;
let (mut photos, mut videos, mut raw) = (0usize, 0usize, 0usize);
for row in rows {
let (kind, n) = row?;
+111
View File
@@ -337,6 +337,10 @@ fn places_group_photos_by_the_nearest_town() {
.map(|p| p.uid)
.collect();
assert_eq!(berlin, ["b2", "b1-jpeg"]);
let visible = db.photo_places_visible(r#"["b2","p1"]"#).unwrap();
assert_eq!(visible.len(), 1);
assert_eq!(visible[0].count, 1);
assert_eq!(visible[0].cover.uid, "b1-jpeg");
}
/// A town's photos come with where each was taken, one per RAW+JPEG shot.
@@ -7165,6 +7169,29 @@ fn a_raw_and_its_jpeg_are_one_entry_in_the_grid() {
["jpeg", "raw"]
);
assert_eq!(db.photos_group("alone").unwrap().len(), 1);
let hidden = db
.photo_group_members_for(&["raw".to_owned()].into_iter().collect())
.unwrap();
assert_eq!(
hidden,
["raw".to_owned(), "jpeg".to_owned()].into_iter().collect()
);
let excluded = serde_json::to_string(&hidden).unwrap();
assert_eq!(db.photos_counts_visible(&excluded).unwrap(), (1, 0, 0));
let months = db.photos_months_visible(None, &excluded).unwrap();
assert_eq!(months.len(), 1);
assert_eq!(months[0].2, 1);
let public = db
.photos_page_visible(0, 1, None, None, false, false, &excluded)
.unwrap();
assert_eq!(
public
.iter()
.map(|photo| photo.uid.as_str())
.collect::<Vec<_>>(),
["alone"]
);
}
/// Pixel names the two files of one raw capture after the role each plays, so
@@ -7845,3 +7872,87 @@ fn migration_v45_keeps_existing_device_folders_and_location_ids() {
db.migrate().unwrap();
assert_eq!(db.mount_list().unwrap().len(), 2);
}
#[test]
fn photo_feed_failure_keeps_the_cursor_and_a_stale_listing_cannot_restore_deleted_rows() {
let db = Db::open_in_memory().unwrap();
let rows = vec![TimelineRow::new("gone", 200), TimelineRow::new("keep", 100)];
db.photos_replace(&rows).unwrap();
db.albums_replace(&[StoredAlbum {
uid: "album".into(),
name: "Test album".into(),
photo_count: 2,
cover_uid: Some("gone".into()),
last_activity: None,
shared: false,
}])
.unwrap();
db.album_photos_replace(
"album",
&[
("gone".into(), 200, None, None),
("keep".into(), 100, None, None),
],
)
.unwrap();
db.set_state_str("photos-cursor-test", "old").unwrap();
let stale = db.photo_projection_generation().unwrap();
db.conn.lock().execute_batch(
"CREATE TEMP TRIGGER reject_cursor BEFORE INSERT ON sync_state WHEN NEW.key='photos-cursor-test'
BEGIN SELECT RAISE(ABORT, 'simulated cursor failure'); END;",
).unwrap();
let gone = ["gone".into()];
assert!(
db.photos_apply_events("photos-cursor-test", "next", &gone, &[], false, false)
.is_err()
);
assert_eq!(
db.state_str("photos-cursor-test").unwrap().as_deref(),
Some("old")
);
assert_eq!(db.photos_count().unwrap(), 2);
assert!(db.photos_contains("gone", Some("album")).unwrap());
db.conn
.lock()
.execute("DROP TRIGGER reject_cursor", [])
.unwrap();
db.photos_apply_events("photos-cursor-test", "next", &gone, &[], false, false)
.unwrap();
assert_eq!(
db.state_str("photos-cursor-test").unwrap().as_deref(),
Some("next")
);
assert!(!db.photos_contains("gone", None).unwrap());
assert_eq!(
db.albums_list().unwrap()[0].cover_uid.as_deref(),
Some("keep")
);
assert!(!db.photos_replace_at(&rows, stale, true, 1).unwrap());
assert!(
!db.album_photos_replace_at("album", &[("gone".into(), 200, None, None)], stale, 1)
.unwrap()
);
assert!(!db.photos_contains("gone", None).unwrap());
db.photos_apply_events("photos-cursor-test", "restore", &[], &gone, false, false)
.unwrap();
let current = db.photo_projection_generation().unwrap();
assert!(db.photos_replace_at(&rows, current, true, 2).unwrap());
assert!(db.photos_contains("gone", None).unwrap());
}
#[test]
fn warm_photo_months_exclude_hidden_groups_with_thirteen_thousand_rows() {
let db = Db::open_in_memory().unwrap();
let mut rows: Vec<_> = (0..13_000)
.map(|i| TimelineRow::new(format!("volume~{i}"), 1_700_000_000 + i))
.collect();
rows[1].main_uid = Some(rows[0].uid.clone());
db.photos_replace(&rows).unwrap();
let started = std::time::Instant::now();
let months = db.photos_months_visible(None, r#"["volume~1"]"#).unwrap();
assert_eq!(months.iter().map(|month| month.2).sum::<usize>(), 12_998);
assert!(started.elapsed() < std::time::Duration::from_secs(1));
}
+17
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,
@@ -347,6 +355,15 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool {
/// The result every request-serving method in the daemon returns.
pub type CoreResult<T> = std::result::Result<T, CoreError>;
impl From<proton_auth_rs::Error> for Error {
fn from(error: proton_auth_rs::Error) -> Self {
match error {
proton_auth_rs::Error::Keyring(error) => Self::Keyring(error),
other => Self::Other(other.to_string()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
-133
View File
@@ -1,133 +0,0 @@
//! When a photo was taken, as its own EXIF tags say.
//!
//! The fallback for a photo nothing else dates: a Takeout photo without a
//! sidecar or a date in its name, and a photo uploaded from the app. Without
//! it the first was filed under the moment of the import and the second under
//! the file's modification time, which a copy resets.
use std::io::{BufRead, Seek};
use std::path::Path;
use crate::takeout::days_from_civil;
/// The capture time in the EXIF of the file at `path`, in epoch seconds.
pub fn capture_time_of(path: &Path) -> Option<i64> {
let file = std::fs::File::open(path).ok()?;
capture_time(&mut std::io::BufReader::new(file))
}
/// The capture time in the EXIF `reader` holds: `DateTimeOriginal`, then
/// `DateTimeDigitized`, each adjusted by its `OffsetTime…` tag when the camera
/// wrote one. Without an offset the time is read as UTC, as a date in a file
/// name is (`takeout::capture_time_from_name`).
pub fn capture_time(reader: &mut (impl BufRead + Seek)) -> Option<i64> {
let exif = exif::Reader::new().read_from_container(reader).ok()?;
let ascii = |tag: exif::Tag| -> Option<String> {
let field = exif.get_field(tag, exif::In::PRIMARY)?;
match &field.value {
exif::Value::Ascii(parts) => parts.first().map(|part| {
String::from_utf8_lossy(part)
.trim_matches('\0')
.trim()
.to_string()
}),
_ => None,
}
};
[
(exif::Tag::DateTimeOriginal, exif::Tag::OffsetTimeOriginal),
(exif::Tag::DateTimeDigitized, exif::Tag::OffsetTimeDigitized),
]
.into_iter()
.find_map(|(time, offset)| {
let local = parse_exif_time(&ascii(time)?)?;
let offset = ascii(offset).and_then(|o| parse_offset(&o)).unwrap_or(0);
Some(local - offset)
})
}
/// `YYYY:MM:DD HH:MM:SS` as epoch seconds, read as UTC. `None` for the
/// all-zero or blank value cameras write when they do not know.
fn parse_exif_time(text: &str) -> Option<i64> {
let bytes = text.as_bytes();
if bytes.len() < 19 || bytes[4] != b':' || bytes[7] != b':' || bytes[13] != b':' {
return None;
}
let number = |range: std::ops::Range<usize>| text.get(range)?.parse::<i64>().ok();
let (year, month, day) = (number(0..4)?, number(5..7)?, number(8..10)?);
let (hour, minute, second) = (number(11..13)?, number(14..16)?, number(17..19)?);
if !(1800..=9999).contains(&year)
|| !(1..=12).contains(&month)
|| !(1..=31).contains(&day)
|| hour > 23
|| minute > 59
|| second > 60
{
return None;
}
Some(days_from_civil(year, month, day) * 86_400 + hour * 3600 + minute * 60 + second)
}
/// `+HH:MM` or `-HH:MM` as seconds east of UTC.
fn parse_offset(text: &str) -> Option<i64> {
let sign = match text.as_bytes().first()? {
b'+' => 1,
b'-' => -1,
_ => return None,
};
let (hours, minutes) = text.get(1..)?.split_once(':')?;
let (hours, minutes) = (hours.parse::<i64>().ok()?, minutes.parse::<i64>().ok()?);
(hours <= 14 && minutes < 60).then_some(sign * (hours * 3600 + minutes * 60))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_exif_time_reads_as_utc_and_its_offset_moves_it() {
// 2023-06-01 12:00:00 UTC.
let noon = 1_685_620_800;
assert_eq!(parse_exif_time("2023:06:01 12:00:00"), Some(noon));
assert_eq!(parse_offset("+02:00"), Some(7200));
assert_eq!(parse_offset("-05:30"), Some(-19_800));
assert_eq!(
parse_exif_time("2023:06:01 14:00:00").map(|t| t - parse_offset("+02:00").unwrap()),
Some(noon)
);
}
#[test]
fn an_unknown_exif_time_is_no_time() {
assert_eq!(parse_exif_time("0000:00:00 00:00:00"), None);
assert_eq!(parse_exif_time(" : : : : "), None);
assert_eq!(parse_exif_time(""), None);
assert_eq!(parse_offset("02:00"), None);
}
#[test]
fn a_photo_is_dated_by_its_original_time_and_offset() {
let ascii = |tag, text: &str| exif::Field {
tag,
ifd_num: exif::In::PRIMARY,
value: exif::Value::Ascii(vec![text.as_bytes().to_vec()]),
};
let taken = ascii(exif::Tag::DateTimeOriginal, "2023:06:01 14:00:00");
let offset = ascii(exif::Tag::OffsetTimeOriginal, "+02:00");
let digitized = ascii(exif::Tag::DateTimeDigitized, "2024:01:01 00:00:00");
let mut writer = exif::experimental::Writer::new();
writer.push_field(&taken);
writer.push_field(&offset);
writer.push_field(&digitized);
let mut tiff = std::io::Cursor::new(Vec::new());
writer.write(&mut tiff, false).unwrap();
tiff.set_position(0);
assert_eq!(capture_time(&mut tiff), Some(1_685_620_800));
}
#[test]
fn a_file_without_exif_has_no_capture_time() {
let mut png = std::io::Cursor::new(b"\x89PNG\r\n\x1a\n".to_vec());
assert_eq!(capture_time(&mut png), None);
}
}
+3 -5
View File
@@ -10,7 +10,6 @@ pub mod config;
pub mod control;
pub mod db;
pub mod error;
pub mod exiftime;
pub mod kernelkey;
pub mod keycheck;
pub mod localindex;
@@ -19,21 +18,20 @@ pub mod mountfail;
pub mod mountpoint;
pub mod mounts;
pub mod opener;
pub mod places;
pub mod profile;
pub mod sdkcache;
pub mod search;
mod secretservice;
pub mod service;
pub mod shell;
pub mod similar;
pub mod syncignore;
pub mod syncroot;
pub mod takeout;
pub mod timestamp;
pub mod tray;
pub mod update;
// Photo logic shared with Proton Gallery through the proton-rs crates.
pub use proton_gallery_rs::{exiftime, places, similar, takeout};
pub use access::{Access, access_for, perm_bits};
pub use error::{CoreError, CoreResult, Error, Result};
+1 -3
View File
@@ -40,9 +40,7 @@ pub fn path(state_dir: &Path) -> PathBuf {
/// and renamed, so a reader never sees half of it.
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
let tmp = state_dir.join(format!("{FILE_NAME}.tmp"));
std::fs::write(&tmp, json)?;
std::fs::rename(&tmp, path(state_dir))
proton_base_rs::atomic::write_with_mode(&path(state_dir), &json, 0o644)
}
/// Forget the failure: a mount is up, or a new daemon has started.
-185
View File
@@ -1,185 +0,0 @@
//! Offline reverse geocoding: the town a photo was taken in, from its GPS
//! position, without asking any service.
//!
//! The towns are GeoNames' `cities15000` dump (every place with more than
//! 15,000 people), trimmed to id, name, position and country in
//! `data/cities15000.tsv` by `scripts/geonames-cities.py`. The script drops the
//! parts of a city, such as Kreuzberg or "Paris 15 Vaugirard", so that a photo
//! lands in the town people would name. GeoNames publishes the dump under
//! CC BY 4.0, which is why the About dialog credits it.
//!
//! `data/countries.tsv` maps each country code to its ISO 3166-1 English name,
//! as the `iso-codes` project spells it, so a front end can translate it
//! through that project's `iso_3166-1` gettext domain.
use std::collections::HashMap;
use std::sync::OnceLock;
/// How far from the nearest town a photo may be and still count as taken
/// there, in km. Farther out (at sea, in the wilderness) it has no place.
pub const MAX_DISTANCE_KM: f64 = 50.0;
/// Mean Earth radius in km, for the haversine distance.
const EARTH_RADIUS_KM: f64 = 6371.0;
const CITIES: &str = include_str!("../data/cities15000.tsv");
const COUNTRIES: &str = include_str!("../data/countries.tsv");
/// One town of the table.
#[derive(Debug, Clone, PartialEq)]
pub struct City {
/// The GeoNames id, stable across dumps.
pub id: u32,
pub name: &'static str,
pub latitude: f64,
pub longitude: f64,
/// ISO 3166-1 alpha-2 country code.
pub country: &'static str,
}
/// The towns, and an index of them by whole-degree cell.
struct Table {
cities: Vec<City>,
cells: HashMap<(i32, i32), Vec<usize>>,
}
fn table() -> &'static Table {
static TABLE: OnceLock<Table> = OnceLock::new();
TABLE.get_or_init(|| {
let cities: Vec<City> = CITIES.lines().filter_map(parse_city).collect();
let mut cells: HashMap<(i32, i32), Vec<usize>> = HashMap::new();
for (index, city) in cities.iter().enumerate() {
cells
.entry(cell(city.latitude, city.longitude))
.or_default()
.push(index);
}
Table { cities, cells }
})
}
fn parse_city(line: &'static str) -> Option<City> {
let mut fields = line.split('\t');
Some(City {
id: fields.next()?.parse().ok()?,
name: fields.next()?,
latitude: fields.next()?.parse().ok()?,
longitude: fields.next()?.parse().ok()?,
country: fields.next()?,
})
}
fn cell(latitude: f64, longitude: f64) -> (i32, i32) {
(latitude.floor() as i32, longitude.floor() as i32)
}
/// Great-circle distance between two positions, in km.
pub fn distance_km(a: (f64, f64), b: (f64, f64)) -> f64 {
let (lat1, lat2) = (a.0.to_radians(), b.0.to_radians());
let dlat = lat2 - lat1;
let dlon = (b.1 - a.1).to_radians();
let h = (dlat / 2.0).sin().powi(2) + lat1.cos() * lat2.cos() * (dlon / 2.0).sin().powi(2);
2.0 * EARTH_RADIUS_KM * h.sqrt().min(1.0).asin()
}
/// The town nearest to a position, if one lies within [`MAX_DISTANCE_KM`].
pub fn nearest(latitude: f64, longitude: f64) -> Option<&'static City> {
if !latitude.is_finite() || !longitude.is_finite() {
return None;
}
let table = table();
// A degree of latitude is about 111 km everywhere; a degree of longitude
// shrinks towards the poles, so more cells are needed to cover the radius.
let lat_span = (MAX_DISTANCE_KM / 111.0).ceil() as i32;
let lon_span = {
let scale = latitude.to_radians().cos().abs().max(0.01);
((MAX_DISTANCE_KM / (111.0 * scale)).ceil() as i32).min(180)
};
let (row, column) = cell(latitude, longitude);
let mut best: Option<(f64, &City)> = None;
for dlat in -lat_span..=lat_span {
for dlon in -lon_span..=lon_span {
// Longitude wraps at the antimeridian: -181 is 179.
let lon_cell = (column + dlon + 180).rem_euclid(360) - 180;
let Some(indices) = table.cells.get(&(row + dlat, lon_cell)) else {
continue;
};
for &index in indices {
let city = &table.cities[index];
let d = distance_km((latitude, longitude), (city.latitude, city.longitude));
if d <= MAX_DISTANCE_KM && best.is_none_or(|(bd, _)| d < bd) {
best = Some((d, city));
}
}
}
}
best.map(|(_, city)| city)
}
/// The town with this GeoNames id.
pub fn city(id: u32) -> Option<&'static City> {
let cities = &table().cities;
// The table is sorted by id.
cities
.binary_search_by_key(&id, |city| city.id)
.ok()
.map(|index| &cities[index])
}
/// The English ISO 3166-1 name of a country code, such as "Germany" for "DE".
pub fn country_name(code: &str) -> Option<&'static str> {
COUNTRIES.lines().find_map(|line| {
let (c, name) = line.split_once('\t')?;
(c == code).then_some(name)
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_position_in_a_town_resolves_to_that_town() {
let berlin = nearest(52.52, 13.405).expect("Berlin is a town");
assert_eq!(berlin.name, "Berlin");
assert_eq!(berlin.country, "DE");
assert_eq!(city(berlin.id), Some(berlin));
}
#[test]
fn the_open_sea_has_no_town() {
assert_eq!(nearest(0.0, -30.0), None);
assert_eq!(nearest(f64::NAN, 0.0), None);
}
#[test]
fn a_town_across_the_antimeridian_is_still_found() {
// Just east of 180°, the nearest towns in Fiji are west of it.
let town = nearest(-16.8, 179.99);
assert!(town.is_none_or(|t| t.country == "FJ"));
let suva = nearest(-18.14, 178.44).expect("Suva is a town");
assert_eq!(suva.country, "FJ");
}
#[test]
fn every_town_has_a_named_country() {
for city in &table().cities {
assert!(
country_name(city.country).is_some(),
"{} has no country name for {}",
city.name,
city.country
);
}
assert_eq!(country_name("DE"), Some("Germany"));
}
#[test]
fn distances_are_great_circle_km() {
let d = distance_km((52.52, 13.405), (48.137, 11.575));
assert!(
(d - 504.0).abs() < 5.0,
"Berlin to Munich is about 504 km, got {d}"
);
}
}
-135
View File
@@ -1,135 +0,0 @@
//! Saving a new secret into an existing Secret Service item by replacing the
//! item, not by editing its secret (`docs/BUGS.md` B291).
//!
//! oo7-daemon before 0.7.0 applies `SetSecret` only in memory: the keyring
//! file keeps the old secret, and it comes back once the daemon restarts.
//! Fedora 45 ships such a build (`0.7.0~beta^1.e91b98a`). Every refreshed
//! sign-in pdfs saved there was gone after a reboot, and the next start found
//! a refresh token Proton had already spent.
//!
//! `CreateItem` with `replace` is written to the file there, and every
//! provider implements it. So a secret that changes is written as a new item
//! that replaces the old one: in the old one's collection, with its label and
//! all of its attributes, so the provider recognises it as the same entry.
use dbus_secret_service::{Collection, EncryptionType, Path, SecretService};
use std::collections::HashMap;
/// The content type the keyring store writes its secrets with.
const CONTENT_TYPE: &str = "application/octet-stream";
/// What [`replace`] did.
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Replaced {
/// The secret is saved.
Saved,
/// Nothing was changed; save it the usual way. Says why, for the log.
Skipped(String),
}
/// Save `secret` into the one item for `service`/`user` by replacing it.
///
/// Skips, changing nothing, when there is no such item yet (the store creates
/// it), when there is more than one, when it is locked, or when the Secret
/// Service fails before the new item exists. Never shows a prompt: one would
/// block the caller, so it is dismissed and the write is skipped.
pub(crate) fn replace(service: &str, user: &str, secret: &[u8]) -> Replaced {
match try_replace(service, user, secret) {
Ok(replaced) => replaced,
Err(e) => Replaced::Skipped(e.to_string()),
}
}
fn try_replace(
service: &str,
user: &str,
secret: &[u8],
) -> Result<Replaced, dbus_secret_service::Error> {
let ss = SecretService::connect_with_max_prompt_timeout(EncryptionType::Dh, 0)?;
let lookup = HashMap::from([("service", service), ("username", user)]);
let found = ss.search_items(lookup.clone())?;
if !found.locked.is_empty() {
return Ok(Replaced::Skipped("the item is locked".into()));
}
let [old] = found.unlocked.as_slice() else {
return Ok(Replaced::Skipped(format!(
"{} items match, not one",
found.unlocked.len()
)));
};
let Some(collection) = collection_of(&old.path) else {
return Ok(Replaced::Skipped(format!(
"no collection in the item path {}",
old.path
)));
};
let label = old.get_label()?;
let attributes = old.get_attributes()?;
let attributes: HashMap<&str, &str> = attributes
.iter()
.map(|(k, v)| (k.as_str(), v.as_str()))
.collect();
let collection = Collection::new(&ss, collection);
let new = collection.create_item(&label, attributes, secret, true, CONTENT_TYPE)?;
// A provider that did not match the old item leaves it next to the new
// one, and two items make every read ambiguous.
let after = ss.search_items(lookup)?;
for item in after.unlocked.iter().chain(&after.locked) {
if item.path == new.path {
continue;
}
if let Err(e) = item.delete() {
// The old item still holds the previous secret, so taking the new
// one out leaves things as they were, for the usual write.
if let Err(undo) = new.delete() {
tracing::error!(
error = %undo,
"could not remove a duplicate keyring item; remove one of the two \
`proton-drive-linux` entries in your keyring and sign in again"
);
}
return Ok(Replaced::Skipped(format!(
"could not remove the replaced item: {e}"
)));
}
}
Ok(Replaced::Saved)
}
/// The collection an item path belongs to: the path without its last part,
/// as long as it is a Secret Service object path.
fn collection_of(item: &Path<'_>) -> Option<Path<'static>> {
let (collection, _) = item.rsplit_once('/')?;
if !collection.starts_with("/org/freedesktop/secrets/") || collection.ends_with('/') {
return None;
}
Path::new(collection.to_owned()).ok()
}
#[cfg(test)]
mod tests {
use super::*;
fn collection(item: &str) -> Option<String> {
collection_of(&Path::new(item).unwrap()).map(|p| p.to_string())
}
#[test]
fn an_item_belongs_to_the_collection_its_path_names() {
assert_eq!(
collection("/org/freedesktop/secrets/collection/login/14").as_deref(),
Some("/org/freedesktop/secrets/collection/login")
);
assert_eq!(
collection("/org/freedesktop/secrets/aliases/default/3").as_deref(),
Some("/org/freedesktop/secrets/aliases/default")
);
}
#[test]
fn a_path_outside_the_secret_service_names_no_collection() {
assert_eq!(collection("/org/example/item/1"), None);
assert_eq!(collection("/item"), None);
}
}
-193
View File
@@ -1,193 +0,0 @@
//! Telling photos apart by what they show rather than by their bytes.
//!
//! The server's content hash only matches byte-identical files. A photo that
//! was resized, re-encoded or sent through a messenger is another file, so the
//! similar-photo finder hashes each thumbnail instead: a 64-bit difference
//! hash ("dHash"), which compares neighbouring brightness in a 9×8 grid. Two
//! copies of one picture land a few bits apart, and different pictures about
//! half of the bits apart.
/// Hashes this many bits apart or fewer show the same picture.
pub const SIMILAR_BITS: u32 = 6;
/// Stored for a photo whose thumbnail was looked at and gave no usable hash
/// (it couldn't be decoded, or is one flat colour), so it isn't looked at
/// again. A real hash is never 0: a picture that would hash to 0 has no
/// brightness changes, which [`difference_hash`] turns down as flat.
pub const NO_HASH: u64 = 0;
/// Samples of the grid that differ by less than this in brightness, all of
/// them, make a flat picture — a black frame, a blank page — whose hash is
/// noise and would match every other flat picture.
const FLAT: u8 = 8;
/// The difference hash of an 8-bit greyscale image `width` px wide, rows
/// stored one after another in `luma`. `None` for an empty or flat image.
pub fn difference_hash(width: usize, height: usize, luma: &[u8]) -> Option<u64> {
if width == 0 || height == 0 || luma.len() < width * height {
return None;
}
// Box-average down to 9×8, so every source pixel counts once and the hash
// doesn't depend on which pixels a nearest-neighbour pick happens to hit.
let mut grid = [[0u8; 9]; 8];
for (gy, row) in grid.iter_mut().enumerate() {
let (y0, y1) = span(gy, 8, height);
for (gx, cell) in row.iter_mut().enumerate() {
let (x0, x1) = span(gx, 9, width);
let mut sum = 0u64;
for y in y0..y1 {
sum += luma[y * width + x0..y * width + x1]
.iter()
.map(|&v| u64::from(v))
.sum::<u64>();
}
*cell = (sum / ((y1 - y0) * (x1 - x0)) as u64) as u8;
}
}
let (min, max) = grid
.iter()
.flatten()
.fold((u8::MAX, 0), |(min, max), &v| (min.min(v), max.max(v)));
if max - min < FLAT {
return None;
}
let mut hash = 0u64;
for row in &grid {
for pair in row.windows(2) {
hash = hash << 1 | u64::from(pair[0] < pair[1]);
}
}
(hash != NO_HASH).then_some(hash)
}
/// The source pixels `from..to` that cell `i` of `cells` covers along an edge
/// of `len` px; never empty, even for an edge shorter than the grid.
fn span(i: usize, cells: usize, len: usize) -> (usize, usize) {
let from = (i * len / cells).min(len - 1);
let to = ((i + 1) * len / cells).max(from + 1);
(from, to)
}
/// Whether two hashes show the same picture.
pub fn alike(a: u64, b: u64) -> bool {
(a ^ b).count_ones() <= SIMILAR_BITS
}
/// Group `hashes` into sets of alike ones, by index, each set in index order
/// and the sets by their first index. A hash alike to none other is in no
/// set. Alike is taken as catching: a burst of shots each a little different
/// from the last is one set.
pub fn sets(hashes: &[u64]) -> Vec<Vec<usize>> {
// Two hashes at most SIMILAR_BITS apart agree on at least one of their
// eight bytes, as long as SIMILAR_BITS < 8. So only hashes sharing some
// byte are compared, not every pair of the library.
const _: () = assert!(SIMILAR_BITS < 8);
let mut parent: Vec<usize> = (0..hashes.len()).collect();
fn root(parent: &mut [usize], mut i: usize) -> usize {
while parent[i] != i {
parent[i] = parent[parent[i]];
i = parent[i];
}
i
}
for byte in 0..8 {
let mut buckets: Vec<Vec<usize>> = vec![Vec::new(); 256];
for (i, &hash) in hashes.iter().enumerate() {
buckets[(hash >> (byte * 8)) as u8 as usize].push(i);
}
for bucket in &buckets {
for (n, &a) in bucket.iter().enumerate() {
for &b in &bucket[n + 1..] {
if alike(hashes[a], hashes[b]) {
let (ra, rb) = (root(&mut parent, a), root(&mut parent, b));
if ra != rb {
parent[ra.max(rb)] = ra.min(rb);
}
}
}
}
}
}
let mut by_root: std::collections::BTreeMap<usize, Vec<usize>> = Default::default();
for i in 0..hashes.len() {
let r = root(&mut parent, i);
by_root.entry(r).or_default().push(i);
}
by_root.into_values().filter(|set| set.len() > 1).collect()
}
#[cfg(test)]
mod tests {
use super::*;
/// A 90×80 picture: a bright disc on a gradient.
fn picture(width: usize, height: usize) -> Vec<u8> {
let mut luma = Vec::with_capacity(width * height);
for y in 0..height {
for x in 0..width {
let (fx, fy) = (x as f64 / width as f64, y as f64 / height as f64);
let disc = ((fx - 0.3).powi(2) + (fy - 0.6).powi(2)).sqrt() < 0.2;
let v = if disc { 240.0 } else { 40.0 + 120.0 * fx * fy };
luma.push(v as u8);
}
}
luma
}
#[test]
fn a_resized_copy_hashes_alike() {
let big = difference_hash(900, 800, &picture(900, 800)).unwrap();
let small = difference_hash(91, 79, &picture(91, 79)).unwrap();
assert!(
alike(big, small),
"{} bits apart",
(big ^ small).count_ones()
);
}
#[test]
fn a_different_picture_hashes_apart() {
let one = difference_hash(90, 80, &picture(90, 80)).unwrap();
let mirrored: Vec<u8> = picture(90, 80)
.chunks(90)
.flat_map(|row| row.iter().rev().copied().collect::<Vec<_>>())
.collect();
let other = difference_hash(90, 80, &mirrored).unwrap();
assert!(!alike(one, other));
}
#[test]
fn a_flat_picture_has_no_hash() {
assert_eq!(difference_hash(64, 64, &[17; 64 * 64]), None);
assert_eq!(difference_hash(0, 0, &[]), None);
assert_eq!(difference_hash(4, 4, &[0; 3]), None);
}
#[test]
fn a_picture_smaller_than_the_grid_still_hashes() {
let luma: Vec<u8> = (0..4 * 3).map(|i| (i * 20) as u8).collect();
assert!(difference_hash(4, 3, &luma).is_some());
}
#[test]
fn alike_hashes_form_sets_and_catch_on() {
let a = 0x0123_4567_89ab_cdef_u64;
let hashes = [
a,
!a,
a ^ 0b111,
a ^ 0b111 ^ (0b1111 << 40),
0x5555_0000_ffff_aaaa,
];
assert_eq!(sets(&hashes), vec![vec![0, 2, 3]]);
}
#[test]
fn hashes_apart_in_most_bytes_are_still_found() {
// One bit apart in each of six bytes: six bits in all, and only the
// top two bytes agree.
let a = 1u64 << 63;
let b = (0..6).fold(a, |h, byte| h | 1 << (byte * 8));
assert_eq!(sets(&[a, b]), vec![vec![0, 1]]);
}
}
File diff suppressed because it is too large. Load diff
+9
View File
@@ -14,12 +14,21 @@ pdfs-core.workspace = true
zip.workspace = true
sha1.workspace = true
proton-drive-rs.workspace = true
proton-gallery-app-rs.workspace = true
proton-gallery-rs.workspace = true
proton-media-rs.workspace = true
hyper = { version = "1", features = ["http1", "server"] }
hyper-util = { version = "0.1", features = ["tokio"] }
http-body-util = "0.1"
getrandom = "0.4"
zeroize.workspace = true
futures.workspace = true
async-trait.workspace = true
tokio.workspace = true
tracing.workspace = true
fuser.workspace = true
libc.workspace = true
rustix = { version = "1", features = ["net", "process"] }
serde.workspace = true
serde_json.workspace = true
base64.workspace = true
+111 -92
View File
@@ -12,7 +12,7 @@
//! than looked up in our own timeline, where a shared album's photos never
//! appear.
use std::collections::{HashMap, HashSet};
use std::collections::HashSet;
use std::sync::atomic::Ordering;
use pdfs_core::control::{AlbumInfo, PhotoItem, Topic};
@@ -24,8 +24,8 @@ use proton_drive_rs::proton_sdk::ids::NodeUid;
use tracing::warn;
use super::{
ALBUM_SYNCED_PREFIX, ALBUMS_SYNCED_MS, Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS,
TIMELINE_ENRICH_CHUNK, TIMELINE_TTL, now_ms, parse_uid,
ALBUM_SYNCED_PREFIX, ALBUMS_SYNCED_MS, Core, PHOTOS_AVAILABLE, TIMELINE_ENRICH_CHUNK,
TIMELINE_TTL, link, now_ms, parse_uid,
};
impl Core {
@@ -34,7 +34,13 @@ impl Core {
/// [`Core::photos_timeline`] gives.
pub(crate) fn albums(&self) -> CoreResult<Option<Vec<AlbumInfo>>> {
let count = self.db.albums_count().map_err(CoreError::from)?;
if count == 0 {
if count == 0
&& self
.db
.state_i64(ALBUMS_SYNCED_MS)
.map_err(CoreError::from)?
.is_none()
{
// Nothing on disk, so this one request waits for the fetch — unless
// the account is already known to have no photos volume.
let known_empty = self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() == Some(0);
@@ -56,77 +62,71 @@ impl Core {
/// the persisted listing. Returns false when the account has no photos
/// volume.
pub(crate) async fn refresh_albums(&self) -> CoreResult<bool> {
let generation = self
.db
.photo_projection_generation()
.map_err(CoreError::from)?;
let photos = self.photos();
if photos
.get_photos_root()
if link::bounded(photos.get_photos_root())
.await
.map_err(|e| CoreError::from_api(&e, "photos root"))?
.is_none()
{
let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 0);
let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms());
let _ = self.db.set_state_i64(ALBUMS_SYNCED_MS, now_ms());
self.db
.albums_replace_at(&[], generation, now_ms())
.map_err(CoreError::from)?;
return Ok(false);
}
let mut uids = photos
.enumerate_album_node_uids()
let mut uids = link::bounded(photos.enumerate_album_node_uids())
.await
.map_err(|e| CoreError::from_api(&e, "albums"))?;
let shared = link::bounded(photos.enumerate_shared_with_me_album_uids())
.await
.map_err(|e| CoreError::from_api(&e, "shared albums"))?;
let shared_keys: HashSet<_> = shared.iter().map(ToString::to_string).collect();
uids.extend(shared);
let mut unique = HashSet::new();
uids.retain(|uid| unique.insert(uid.clone()));
// Shared-with-me albums are a separate listing on the sharer's volume.
// Best-effort: an account whose sharing listing fails still gets its own
// albums rather than an error page.
let shared: HashSet<String> = match photos.enumerate_shared_with_me_album_uids().await {
Ok(shared) => {
let keys = shared.iter().map(|u| u.to_string()).collect();
uids.extend(shared);
keys
}
Err(e) => {
warn!(error = %e, "enumerating shared-with-me albums failed");
HashSet::new()
}
};
// The listings carry uids only; the name, photo count and cover come from
// the album nodes themselves. A chunk that fails to resolve drops those
// albums from this refresh rather than failing the whole listing.
let mut albums: Vec<StoredAlbum> = Vec::with_capacity(uids.len());
let mut albums = Vec::with_capacity(uids.len());
for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) {
match photos.enumerate_nodes(chunk).await {
Ok(nodes) => {
for node in nodes {
let key = node.uid.to_string();
let props = node.album.as_ref();
albums.push(StoredAlbum {
shared: shared.contains(&key),
uid: key,
name: node.name,
photo_count: props.map_or(0, |a| a.photo_count.max(0) as usize),
cover_uid: props
.and_then(|a| a.cover_photo_uid.as_ref())
.map(|u| u.to_string()),
last_activity: props.and_then(|a| a.last_activity_time),
});
}
}
Err(e) => warn!(error = %e, "resolving an album chunk failed"),
let nodes = link::bounded(photos.enumerate_nodes(chunk))
.await
.map_err(|e| CoreError::from_api(&e, "album metadata"))?;
if nodes.len() != chunk.len() {
return Err(CoreError::remote(
"Some album details are still unavailable.",
));
}
for node in nodes.into_iter().filter(|node| !node.trashed) {
let uid = node.uid.to_string();
let props = node.album.as_ref();
albums.push(StoredAlbum {
shared: shared_keys.contains(&uid),
uid,
name: node.name,
photo_count: props.map_or(0, |a| a.photo_count.max(0) as usize),
cover_uid: props
.and_then(|a| a.cover_photo_uid.as_ref())
.map(ToString::to_string),
last_activity: props.and_then(|a| a.last_activity_time),
});
}
}
// Newest activity first, and albums the server gave no activity time for
// last — an album nobody has touched belongs below the ones in use. Ties
// fall back to the name so the order is stable between refreshes.
albums.sort_by(|a, b| {
b.last_activity
.cmp(&a.last_activity)
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
});
self.db.albums_replace(&albums).map_err(CoreError::from)?;
let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 1);
let _ = self.db.set_state_i64(ALBUMS_SYNCED_MS, now_ms());
if !self
.db
.albums_replace_at(&albums, generation, now_ms())
.map_err(CoreError::from)?
{
return Err(CoreError::remote(
"Photos changed during the album refresh. Try again shortly.",
));
}
Ok(true)
}
@@ -154,11 +154,21 @@ impl Core {
album: &NodeUid,
offset: usize,
limit: usize,
excluded: &str,
) -> CoreResult<Vec<PhotoItem>> {
let key = album.to_string();
if self.db.photo_removed(&key).map_err(CoreError::from)? {
return Ok(Vec::new());
}
let stamp = format!("{ALBUM_SYNCED_PREFIX}{key}");
let count = self.db.album_photos_count(&key).map_err(CoreError::from)?;
if count == 0 {
if count == 0
&& self
.db
.state_i64(&stamp)
.map_err(CoreError::from)?
.is_none()
{
self.rt.block_on(self.refresh_album(album))?;
} else if self.listing_stale(&stamp, TIMELINE_TTL) {
let core = self.clone();
@@ -172,7 +182,7 @@ impl Core {
let page = self
.db
.album_photos_page(&key, offset, limit)
.album_photos_page_visible(&key, offset, limit, excluded)
.map_err(CoreError::from)?;
Ok(page.into_iter().map(|p| self.photo_item(p)).collect())
}
@@ -213,47 +223,56 @@ impl Core {
/// Re-enumerate one album's photos and replace its persisted contents.
pub(crate) async fn refresh_album(&self, album: &NodeUid) -> CoreResult<()> {
let generation = self
.db
.photo_projection_generation()
.map_err(CoreError::from)?;
let photos = self.photos();
let items = photos
.enumerate_album(album)
let items = link::bounded(photos.enumerate_album(album))
.await
.map_err(|e| CoreError::from_api(&e, "album"))?;
// Same enrichment as the timeline: the listing carries a uid and a
// capture time, and the gallery needs a name and media type to classify
// each entry. Best-effort per chunk.
let uids: Vec<NodeUid> = items.iter().map(|it| it.uid.clone()).collect();
let mut meta: HashMap<String, (Option<String>, Option<String>)> = HashMap::new();
let key = album.to_string();
let mut meta = self
.db
.album_photo_metadata(&key)
.map_err(CoreError::from)?;
let uids: Vec<NodeUid> = items
.iter()
.filter(|item| !meta.contains_key(&item.uid.to_string()))
.map(|item| item.uid.clone())
.collect();
for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) {
match photos.enumerate_nodes(chunk).await {
Ok(nodes) => {
for node in nodes {
let media_type = match &node.kind {
NodeKind::File { media_type, .. } => Some(media_type.clone()),
NodeKind::Folder => None,
};
meta.insert(node.uid.to_string(), (Some(node.name), media_type));
}
}
Err(e) => warn!(error = %e, "resolving album photo metadata failed"),
let nodes = link::bounded(photos.enumerate_nodes(chunk))
.await
.map_err(|e| CoreError::from_api(&e, "album photo metadata"))?;
for node in nodes.into_iter().filter(|node| !node.trashed) {
let media_type = match node.kind {
NodeKind::File { media_type, .. } => Some(media_type),
NodeKind::Folder => None,
};
meta.insert(node.uid.to_string(), (node.name, media_type));
}
}
let rows: Vec<(String, i64, Option<String>, Option<String>)> = items
.iter()
.map(|it| {
let key = it.uid.to_string();
let (name, media_type) = meta.get(&key).cloned().unwrap_or((None, None));
(key, it.capture_time, name, media_type)
let rows: Vec<_> = items
.into_iter()
.map(|item| {
let uid = item.uid.to_string();
let (name, media_type) = meta
.get(&uid)
.map(|(name, mime)| (Some(name.clone()), mime.clone()))
.unwrap_or_default();
(uid, item.capture_time, name, media_type)
})
.collect();
let key = album.to_string();
self.db
.album_photos_replace(&key, &rows)
.map_err(CoreError::from)?;
let _ = self
if !self
.db
.set_state_i64(&format!("{ALBUM_SYNCED_PREFIX}{key}"), now_ms());
.album_photos_replace_at(&key, &rows, generation, now_ms())
.map_err(CoreError::from)?
{
return Err(CoreError::remote(
"Photos changed during the album refresh. Try again shortly.",
));
}
Ok(())
}
@@ -283,7 +302,7 @@ impl Core {
.block_on(self.photos().delete_album(album, delete_photos))
.map_err(|e| CoreError::from_api(&e, "delete album"))?;
let key = album.to_string();
if let Err(error) = self.db.album_photos_replace(&key, &[]) {
if let Err(error) = self.db.photos_delete(&[key]) {
warn!(%album, %error, "a deleted album's photos could not be dropped");
}
self.after_album_change(None);
+68 -81
View File
@@ -517,32 +517,15 @@ pub(super) async fn run_event_sync(
}
}
/// The state key holding the photos volume's event cursor. Separate from the
/// Drive cursor because the two volumes have their own event streams, and one
/// cursor cannot address both.
const PHOTOS_EVENT_CURSOR: &str = "photos_event_cursor";
/// Poll the photos volume's event stream, so a photo deleted or added on another
/// device shows up in the gallery within one poll instead of on the timeline's
/// freshness window.
///
/// Deliberately much smaller than [`run_event_sync`]: the photos volume is not
/// part of the FUSE mount, so there is no inode space to converge and nothing to
/// invalidate in the kernel. A trash or a delete removes the rows behind the
/// gallery; anything else only drops the timeline's freshness stamp, and the
/// next read re-enumerates. Getting that wrong costs a stale tile, not a wrong
/// file.
/// Follow the Photos volume and commit changes with its durable event cursor.
pub(super) async fn run_photos_event_sync(core: Core) {
let photos = core.photos();
// The photos volume only exists once the user has used Photos at all, and
// the daemon may well start before the network does.
let scope = loop {
match photos.get_photos_root().await {
match link::bounded(photos.get_photos_root()).await {
Ok(Some(root)) => break root.tree_event_scope_id(),
Ok(None) => {
debug!("no photos volume; photo event sync not started");
return;
}
Ok(None) => core.next_poll(POLL_INTERVAL).await,
Err(error) if session_revoked(&error) => {
core.mark_session_expired("read the photos root", &error);
return;
@@ -554,39 +537,71 @@ pub(super) async fn run_photos_event_sync(core: Core) {
}
};
let mut cursor: Option<DriveEventId> = core
.db
.state_str(PHOTOS_EVENT_CURSOR)
.ok()
.flatten()
.map(DriveEventId::from);
info!(?cursor, "photo event sync started");
let key = format!("photos_event_cursor:{}", scope.volume_id());
let mut cursor = loop {
match core.db.state_str(&key) {
Ok(cursor) => break cursor.map(DriveEventId::from),
Err(error) => {
warn!(%error, "reading the photo event checkpoint failed");
core.next_poll(POLL_INTERVAL).await;
}
}
};
info!("photo event sync started");
loop {
core.next_poll(POLL_INTERVAL).await;
let events = match link::bounded(photos.enumerate_events(&scope, cursor.as_ref())).await {
Ok(events) => events,
Err(error) if core.lost_link(&error, "poll photo events") => continue,
Err(error) => {
warn!(%error, "photo event poll failed; retrying after interval");
if !core.lost_link(&error, "poll photo events") {
warn!(%error, "photo event poll failed; retrying after interval");
}
core.next_poll(POLL_INTERVAL).await;
continue;
}
};
let Some(head) = events.last().map(|event| event.id().clone()) else {
continue;
};
apply_photo_events(&core, &events);
core.events.publish(&[Topic::Photos]);
// One cursor write per batch, after the batch is applied: a crash in
// between replays events whose effects are idempotent.
if let Err(error) = core.db.set_state_str(PHOTOS_EVENT_CURSOR, head.as_str()) {
warn!(%error, "persisting the photo event cursor failed");
continue;
if let Some(head) = events.last().map(|event| event.id().clone()) {
if let Err(error) = invalidate_photo_events(&core, &events).await {
warn!(%error, "invalidating photo event metadata failed");
core.next_poll(POLL_INTERVAL).await;
continue;
}
// A failed database write must replay all changes, including echoes.
let plan = classify_photo_events(&events, |_| false);
if let Err(error) = core.db.photos_apply_events(
&key,
head.as_str(),
&plan.gone,
&plan.touched,
plan.full,
cursor.is_none(),
) {
warn!(%error, "committing the photo event checkpoint failed");
core.next_poll(POLL_INTERVAL).await;
continue;
}
cursor = Some(head);
if !plan.is_empty() {
core.events.publish(&[Topic::Photos]);
}
}
cursor = Some(head);
if core.db.photos_need_work().unwrap_or(true) {
core.spawn_timeline_refresh();
}
core.next_poll(POLL_INTERVAL).await;
}
}
async fn invalidate_photo_events(
core: &Core,
events: &[DriveEvent],
) -> proton_drive_rs::proton_sdk::error::Result<()> {
for event in events {
core.client.invalidate_caches_for_event(event).await?;
}
Ok(())
}
/// What one batch of photos-volume events asks the gallery's tables to do.
#[derive(Debug, Default, PartialEq)]
pub(super) struct PhotoEventPlan {
@@ -616,14 +631,22 @@ fn classify_photo_events(
mut is_echo: impl FnMut(&NodeUid) -> bool,
) -> PhotoEventPlan {
let mut plan = PhotoEventPlan::default();
for event in events {
let mut seen = HashSet::new();
for event in events.iter().rev() {
match event {
DriveEvent::NodeDeleted { node_uid, .. } => plan.gone.push(node_uid.to_string()),
DriveEvent::NodeDeleted { node_uid, .. } => {
if seen.insert(node_uid) {
plan.gone.push(node_uid.to_string());
}
}
DriveEvent::NodeUpdated {
node_uid,
is_trashed,
..
} => {
if !seen.insert(node_uid) {
continue;
}
if *is_trashed {
plan.gone.push(node_uid.to_string());
} else if !is_echo(node_uid) {
@@ -641,47 +664,11 @@ fn classify_photo_events(
DriveEvent::CursorAdvanced { .. } | DriveEvent::SharedWithMeUpdated { .. } => {}
}
}
plan.gone.reverse();
plan.touched.reverse();
plan
}
/// Apply one batch of photos-volume events to the gallery's tables.
fn apply_photo_events(core: &Core, events: &[DriveEvent]) {
let plan = classify_photo_events(events, |uid| core.take_self_change(uid));
let PhotoEventPlan {
gone,
touched,
full,
} = &plan;
if !gone.is_empty() {
match core.db.photos_delete(gone) {
Ok(removed) if removed > 0 => {
debug!(removed, "photos removed by a remote event");
}
Ok(_) => {}
Err(error) => warn!(%error, "removing remotely deleted photos failed"),
}
}
// A stale mark is what makes the next refresh cheap: it reads these photos'
// nodes and carries every other photo's metadata as it stands.
if !touched.is_empty() {
match core.db.photos_mark_unresolved(touched) {
Ok(marked) if marked > 0 => debug!(marked, "photos changed by a remote event"),
Ok(_) => {}
Err(error) => warn!(%error, "marking remotely changed photos failed"),
}
}
if *full {
match core.db.photos_mark_all_unresolved() {
Ok(marked) => debug!(marked, "the photo event stream lost continuity"),
Err(error) => warn!(%error, "marking the whole timeline unresolved failed"),
}
}
if !plan.is_empty() {
core.invalidate_photos();
core.invalidate_albums();
}
}
/// Keep the local-file index fresh for the launcher prompt's "This computer"
/// results. Rebuilds the index whenever it is older than [`LOCAL_INDEX_TTL`],
/// then sleeps; runs on its own thread for the life of the daemon.
+167 -17
View File
@@ -396,6 +396,11 @@ fn touched_topics(request: &CtlRequest) -> &'static [Topic] {
use CtlRequest as R;
match request {
R::Pin { .. } | R::Unpin { .. } => &[Topic::Files],
// Only locking invalidates a hidden view. Authentication does not
// change the public catalog and must not emit this notification.
R::DriveGallery {
action: pdfs_core::control::GalleryAction::Lock,
} => &[Topic::GalleryVisibility],
R::CreateAlbum { .. }
| R::RenameAlbum { .. }
| R::DeleteAlbum { .. }
@@ -552,6 +557,68 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// Registered before the request is even parsed, so a handler that wedges
// inside the daemon shows up by name in `pdfs diagnostics`.
let _inflight = super::diagnostics::InflightGuard::new(super::diagnostics::request_kind(&line));
if let Ok(CtlRequest::PhotoMonths { kind }) = &request {
let started = std::time::Instant::now();
let visibility = core.cached_gallery_visibility();
let visibility_ms = started.elapsed().as_millis() as u64;
let mut database_ms = None;
let mut response_started = std::time::Instant::now();
let response = match visibility {
Ok(visibility) => {
let excluded = serde_json::to_string(&visibility.media)
.expect("a set of file identifiers serializes");
let query = std::time::Instant::now();
let months = core.db.photos_months_visible(*kind, &excluded);
response_started = std::time::Instant::now();
database_ms = Some(response_started.duration_since(query).as_millis() as u64);
match months {
Ok(months) => CtlResponse::PhotoMonths {
months: months
.into_iter()
.map(|(year, month, count)| PhotoMonth { year, month, count })
.collect(),
},
Err(error) => CtlResponse::error(error.into()),
}
}
Err(error) => CtlResponse::error(error),
};
write_response(stream, response);
tracing::info!(
visibility_ms,
database_ms,
response_ms = response_started.elapsed().as_millis() as u64,
total_ms = started.elapsed().as_millis() as u64,
"PhotoMonths timings"
);
return;
}
let visibility = if matches!(
&request,
Ok(CtlRequest::PhotosTimeline { .. }
| CtlRequest::PhotoDuplicates
| CtlRequest::PhotoSimilar
| CtlRequest::PhotoPlaces
| CtlRequest::PlacePhotos { .. }
| CtlRequest::PlaceLocations { .. }
| CtlRequest::PhotosOnThisDay { .. }
| CtlRequest::PhotoGroup { .. }
| CtlRequest::PhotoAlbums
| CtlRequest::AlbumPhotos { .. }
| CtlRequest::PhotoThumbs { .. }
| CtlRequest::OpenGalleryImage { private: false, .. }
| CtlRequest::OpenPhoto { .. })
) {
core.gallery_visibility()
} else {
Ok(std::sync::Arc::default())
};
let visibility = match visibility {
Ok(visibility) => visibility,
Err(error) => return write_response(stream, CtlResponse::error(error)),
};
let excluded =
serde_json::to_string(&visibility.media).expect("a set of file identifiers serializes");
let response = match request {
Ok(CtlRequest::Status) => status_response(core, username, mountpoint),
Ok(CtlRequest::Subscribe) => {
@@ -627,7 +694,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// A full refresh is "forget what you know", not a second code
// path: the ordinary refresh then finds every photo stale.
if let Some(Err(e)) = full.then(|| core.db.photos_mark_all_unresolved()) {
warn!(error = %e, "marking the whole timeline unresolved failed");
return write_response(stream, CtlResponse::error(e.into()));
}
// Whatever changed the timeline can just as easily have
// changed an album; one scope covers the whole photos view.
@@ -668,11 +735,12 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
range,
favorites,
not_in_album,
&excluded,
) {
Ok(Some(items)) => CtlResponse::Photos {
available: true,
items,
counts: core.db.photos_counts().ok(),
counts: core.db.photos_counts_visible(&excluded).ok(),
},
Ok(None) => CtlResponse::Photos {
available: false,
@@ -693,7 +761,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
},
Err(e) => CtlResponse::error(e),
},
Ok(CtlRequest::PhotoPlaces) => match core.photo_places() {
Ok(CtlRequest::PhotoPlaces) => match core.photo_places(&excluded) {
Ok(items) => CtlResponse::Places {
items,
mapping: core.timeline_progress(),
@@ -701,7 +769,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
Err(e) => CtlResponse::error(e),
},
Ok(CtlRequest::PlacePhotos { id, offset, limit }) => {
match core.place_photos(id, offset, clamp_limit(limit)) {
match core.place_photos(id, offset, clamp_limit(limit), &excluded) {
Ok(items) => CtlResponse::Photos {
available: true,
items,
@@ -715,7 +783,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
Err(e) => CtlResponse::error(e),
},
Ok(CtlRequest::PhotosOnThisDay { limit }) => {
match core.photos_on_this_day(clamp_limit(limit)) {
match core.photos_on_this_day(clamp_limit(limit), &excluded) {
Ok(items) => CtlResponse::Photos {
available: true,
items,
@@ -760,7 +828,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// An album page is a timeline page as far as the front-end is
// concerned, so it comes back in the same reply — with `counts`
// unset, which describe the whole timeline rather than this album.
Some(album) => match core.album_photos(&album, offset, clamp_limit(limit)) {
Some(album) => match visibility
.permits(&uid)
.and_then(|()| core.album_photos(&album, offset, clamp_limit(limit), &excluded))
{
Ok(items) => CtlResponse::Photos {
available: true,
items,
@@ -802,17 +873,28 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
core.remove_from_album(album, photos)
})
}
Ok(CtlRequest::PhotoMonths { kind }) => match core.db.photos_months(kind) {
Ok(months) => CtlResponse::PhotoMonths {
months: months
.into_iter()
.map(|(year, month, count)| PhotoMonth { year, month, count })
.collect(),
Ok(CtlRequest::PhotoPresence { uid, album }) => match core.cached_gallery_visibility() {
Ok(visibility)
if visibility.media.contains(&uid)
|| album
.as_ref()
.is_some_and(|uid| visibility.albums.contains(uid)) =>
{
CtlResponse::PhotoPresence { present: false }
}
Ok(_) => match core.db.photos_contains(&uid, album.as_deref()) {
Ok(present) => CtlResponse::PhotoPresence { present },
Err(error) => CtlResponse::error(error.into()),
},
Err(e) => CtlResponse::error(e.into()),
Err(error) => CtlResponse::error(error),
},
Ok(CtlRequest::PhotoMonths { .. }) => unreachable!("handled before visibility requests"),
Ok(CtlRequest::PhotoThumbs { uids }) => {
let parsed: Vec<NodeUid> = uids.iter().filter_map(|u| parse_uid(u)).collect();
let parsed: Vec<NodeUid> = uids
.iter()
.filter(|uid| !visibility.media.contains(*uid))
.filter_map(|u| parse_uid(u))
.collect();
CtlResponse::Thumbs {
items: core.photo_thumbs(&parsed),
}
@@ -862,7 +944,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
running: core.timeline_refreshing(),
},
Ok(CtlRequest::OpenPhoto { uid }) => match parse_uid(&uid) {
Some(u) => match core.open_photo(&u) {
Some(u) => match visibility.permits(&uid).and_then(|()| core.open_photo(&u)) {
Ok(p) => CtlResponse::FilePath {
path: p.display().to_string(),
},
@@ -870,6 +952,38 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
},
None => CtlResponse::error(CoreError::invalid(format!("bad uid: {uid}"))),
},
Ok(CtlRequest::DriveGallery {
action: pdfs_core::control::GalleryAction::AuthenticateHidden,
}) => core
.authenticate_hidden_gallery(&stream)
.unwrap_or_else(CtlResponse::error),
Ok(CtlRequest::DriveGallery { action }) => core
.drive_gallery(action)
.unwrap_or_else(CtlResponse::error),
Ok(CtlRequest::OpenGalleryVideo { uid, private }) => core
.open_gallery_video(&uid, private)
.unwrap_or_else(CtlResponse::error),
Ok(CtlRequest::OpenGalleryImage { uid, private: true }) => {
core.gallery_image(&uid).unwrap_or_else(CtlResponse::error)
}
Ok(CtlRequest::OpenGalleryImage {
uid,
private: false,
}) => match visibility
.permits(&uid)
.and_then(|()| core.open_shared_file(&uid))
{
Ok(path) => CtlResponse::FilePath {
path: path.display().to_string(),
},
Err(error) => CtlResponse::error(error),
},
Ok(CtlRequest::CloseGalleryVideo { token }) => core
.close_gallery_video(&token)
.unwrap_or_else(CtlResponse::error),
Ok(CtlRequest::GalleryThumbnail { uid, private }) => core
.gallery_thumbnail(&uid, private)
.unwrap_or_else(CtlResponse::error),
// The scan alone walks every archive's central directory, so even the
// dry run goes to a background thread and is read back through
// `ImportStatus` rather than answered inline.
@@ -986,7 +1100,8 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// timeline, and the GUI reloads the gallery the moment this
// reply lands — so refresh now rather than leaving it to a
// background pass that would land just after that reload.
if let Err(e) = core.rt.block_on(core.refresh_timeline()) {
core.invalidate_photos();
if let Err(e) = core.refresh_timeline_joined() {
warn!(error = %e, "timeline refresh after upload failed");
}
CtlResponse::Ok {
@@ -1929,9 +2044,14 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// The request did not parse: the caller sent something malformed.
Err(e) => CtlResponse::error(CoreError::invalid(format!("bad request: {e}"))),
};
let response = filter_gallery_response(response, &visibility);
if !touched.is_empty() && !matches!(response, CtlResponse::Error { .. }) {
core.events.publish(touched);
}
write_response(stream, response);
}
fn write_response(mut stream: UnixStream, response: CtlResponse) {
let mut out = match serde_json::to_vec(&response) {
Ok(v) => v,
Err(e) => {
@@ -1940,10 +2060,40 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
}
};
out.push(b'\n');
let mut stream = stream;
let _ = stream.write_all(&out);
}
fn filter_gallery_response(
mut response: CtlResponse,
visibility: &super::gallery::Visibility,
) -> CtlResponse {
let visible = |item: &pdfs_core::control::PhotoItem| !visibility.media.contains(&item.uid);
match &mut response {
CtlResponse::Photos { items, .. } => items.retain(visible),
CtlResponse::Albums { items, .. } => {
items.retain(|item| !visibility.albums.contains(&item.uid));
for album in items {
if album
.cover_uid
.as_ref()
.is_some_and(|uid| visibility.media.contains(uid))
{
album.cover_uid = None;
}
}
}
CtlResponse::PhotoDuplicates { sets } | CtlResponse::PhotoSimilar { sets, .. } => {
for set in sets.iter_mut() {
set.retain(visible);
}
sets.retain(|set| set.len() > 1);
}
CtlResponse::PhotoLocations { items } => items.retain(|located| visible(&located.photo)),
_ => {}
}
response
}
/// Listen on the control socket, serving one command per connection, each on its
/// own thread. Runs on its own thread; returns only if the listener itself fails.
///
+96 -15
View File
@@ -20,7 +20,7 @@
//! are kept as a conflict copy rather than discarded — see
//! [`Core::revision_conflict`].
use std::collections::HashMap;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::path::{Path, PathBuf};
use std::sync::Arc;
@@ -53,6 +53,21 @@ use super::{
use proton_drive_rs::proton_sdk::api::ResponseCode;
use proton_drive_rs::proton_sdk::error::ProtonError;
#[derive(Debug)]
struct TrashedMove(String);
impl std::fmt::Display for TrashedMove {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"‘{}’ is in Proton Drive Trash. Restore it before retrying this move.",
self.0
)
}
}
impl std::error::Error for TrashedMove {}
const DRAIN_ACCESS_RECHECK: Duration = Duration::from_secs(5);
/// How long an op may stay access-deferred before the deferral is reported as a
@@ -795,13 +810,13 @@ impl Core {
let parent = parse_node_uid(parent_str).ok_or("rename op has an unparseable parent")?;
let name = op.name.clone().ok_or("rename op has no name")?;
// The node we were asked to rename may be gone or trashed by now. Either
// way there is nothing to rename and nothing to lose — a rename holds no
// bytes — so the op is satisfied rather than retried forever.
// A trashed node can be restored. Only retire the operation if the node
// is gone entirely.
let node = match self.fetch_node_remote(&uid)? {
Some(n) if !n.trashed => n,
_ => {
warn!(%uid, name, "renamed node is gone or trashed remotely; dropping the rename");
Some(n) if n.trashed => return Err(TrashedMove(n.name).into()),
Some(n) => n,
None => {
warn!(%uid, name, "renamed node is gone remotely; dropping the rename");
self.db.delete_op(op.id)?;
return Ok(());
}
@@ -827,23 +842,38 @@ impl Core {
// no window for the requirements to go stale between two calls —
// the race B46 queued this op to get away from.
let target = (node.name != name).then_some(name.as_str());
match self.move_rename_remote(&uid, &parent, target) {
let try_move = |target| {
self.move_rename_remote(&uid, &parent, target).map_err(
|error| -> Box<dyn std::error::Error> {
if (is_gone(&error) || refusal(&error) == Some(Some(SyncIssue::Access)))
&& let Some(name) = trashed_move_folder(
node.parent_uid.iter().chain(std::iter::once(&parent)),
|uid| self.fetch_node_remote(uid).ok().flatten(),
)
{
return TrashedMove(name).into();
}
error.into()
},
)
};
match try_move(target) {
Ok(()) => name.clone(),
// The destination holds that name already. Landing under a
// *different* name is the non-destructive resolution: it neither
// clobbers their file nor drops ours, and it is visible.
Err(e) if is_already_exists(&e) => {
Err(e) if is_already_exists(e.as_ref()) => {
if self.name_is_held(op, Some(&parent), &name)? {
return Err(held_by_queued_change(&name));
}
// What held it may have let go since Drive answered
// (docs/BUGS.md B144).
match self.move_rename_remote(&uid, &parent, target) {
match try_move(target) {
Ok(()) => name.clone(),
Err(e) if is_already_exists(&e) => {
Err(e) if is_already_exists(e.as_ref()) => {
let alt = conflict_name(&name, now_secs());
warn!(%uid, name, alt, "destination already holds that name; using a conflict name");
self.move_rename_remote(&uid, &parent, Some(&alt))?;
try_move(Some(&alt))?;
self.adopt_drained_name(&uid, &alt);
self.log_activity(
ActivityKind::Rename,
@@ -853,7 +883,7 @@ impl Core {
);
alt
}
Err(e) => return Err(e.into()),
Err(e) => return Err(e),
}
}
// The destination folder is gone. Leaving the node in its current
@@ -862,7 +892,7 @@ impl Core {
// the user chose still applies there. Retrying the move could
// only fail again — the folder is not coming back — and would
// wedge the queue.
Err(e) if is_gone(&e) => {
Err(e) if is_gone(e.as_ref()) => {
warn!(%uid, name, %parent, "move destination is gone; leaving the node where it is");
let landed = match self.drain_rename_in_place(
op,
@@ -885,7 +915,7 @@ impl Core {
);
landed
}
Err(e) => return Err(e.into()),
Err(e) => return Err(e),
}
};
self.db.delete_op(op.id)?;
@@ -2699,6 +2729,29 @@ fn moved_elsewhere(meta: &RenameMeta, node: &Node, parent: &NodeUid, name: &str)
!at(&meta.original_parent_uid, original_name) && !at(&parent.to_string(), name)
}
/// A child can have a normal metadata record even when an ancestor is trashed.
/// Check both live parent chains before interpreting a refused move as an
/// access problem. Shared ancestors only need to be fetched once.
fn trashed_move_folder<'a>(
parents: impl IntoIterator<Item = &'a NodeUid>,
mut fetch: impl FnMut(&NodeUid) -> Option<Node>,
) -> Option<String> {
let mut seen = HashSet::new();
for parent in parents {
let mut next = Some(parent.clone());
while let Some(uid) = next.take()
&& seen.insert(uid.clone())
&& let Some(node) = fetch(&uid)
{
if node.trashed {
return Some(node.name);
}
next = node.parent_uid;
}
}
None
}
/// The answer from Drive somewhere in `e`'s chain, if it got that far.
fn proton_error<'e>(e: &'e (dyn std::error::Error + 'static)) -> Option<&'e ProtonError> {
std::iter::successors(Some(e), |e| e.source()).find_map(|e| e.downcast_ref::<ProtonError>())
@@ -2708,6 +2761,9 @@ fn proton_error<'e>(e: &'e (dyn std::error::Error + 'static)) -> Option<&'e Prot
/// could not be reached, which says nothing; otherwise the issue Drive's answer
/// is, or `Some(None)` for a failure that is not a refusal.
fn refusal(e: &(dyn std::error::Error + 'static)) -> Option<Option<SyncIssue>> {
if e.is::<TrashedMove>() {
return Some(Some(SyncIssue::Trashed));
}
let proton = proton_error(e)?;
// A refused session refuses everything, so it says nothing about this
// op either; the mount is offline for it (`Core::lost_link`).
@@ -3115,6 +3171,31 @@ mod tests {
}
}
#[test]
fn a_refused_move_identifies_a_trashed_ancestor_on_either_side() {
let source = folder_node("source", Some("old"));
let destination = folder_node("destination", Some("new"));
let mut old = folder_node("old", None);
let mut new = folder_node("new", None);
let find = |old: &Node, new: &Node| {
trashed_move_folder([&source.uid, &destination.uid], |uid| {
[&source, &destination, old, new]
.into_iter()
.find(|node| node.uid == *uid)
.cloned()
})
};
old.trashed = true;
assert_eq!(find(&old, &new).as_deref(), Some("old"));
old.trashed = false;
new.trashed = true;
let error = TrashedMove(find(&old, &new).unwrap());
assert_eq!(refusal(&error), Some(Some(SyncIssue::Trashed)));
assert!(error.to_string().contains("‘new’"));
new.trashed = false;
assert_eq!(find(&old, &new), None);
}
#[test]
fn queued_cross_parent_rename_retains_viewer_source_authority_after_local_move() {
use std::sync::atomic::{AtomicU64, Ordering};
+653
View File
@@ -0,0 +1,653 @@
//! Host Proton Gallery's account and catalog services in the Drive daemon.
mod video;
use std::collections::HashSet;
use std::path::PathBuf;
use std::sync::{
Arc, RwLock,
atomic::{AtomicU64, Ordering},
};
use std::time::{Duration, Instant};
use pdfs_core::control::{
GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace, PhotoItem, PhotoKind, Response,
};
use pdfs_core::{CoreError, CoreResult};
use proton_drive_rs::proton_sdk::session::ProtonApiSession;
use proton_gallery_app_rs::{App, View};
use proton_gallery_rs::CancellationToken;
use proton_gallery_rs::model::{AssetKey, SourceId};
use tokio::sync::{Mutex, Notify, OnceCell};
use super::{Core, NodeUid, parse_uid};
pub(super) struct Gallery {
root: PathBuf,
session: ProtonApiSession,
cancel: CancellationToken,
app: OnceCell<App>,
checked: Mutex<Option<Instant>>,
visibility: RwLock<Option<Arc<Visibility>>>,
refresh: Notify,
access: AtomicU64,
video: video::Server,
}
#[derive(Default, PartialEq, Eq)]
pub(super) struct Visibility {
pub(super) media: HashSet<String>,
pub(super) albums: HashSet<String>,
}
impl Visibility {
pub(super) fn permits(&self, uid: &str) -> CoreResult<()> {
if self.media.contains(uid) || self.albums.contains(uid) {
return Err(CoreError::invalid("Unlock hidden albums to open this item"));
}
Ok(())
}
}
impl Gallery {
pub(super) fn new(root: PathBuf, session: ProtonApiSession) -> Self {
Self {
root,
session,
cancel: CancellationToken::new(),
app: OnceCell::new(),
checked: Mutex::new(None),
visibility: RwLock::default(),
refresh: Notify::new(),
access: AtomicU64::new(0),
video: video::Server::default(),
}
}
pub(super) fn cancel(&self) {
self.cancel.cancel();
self.video.close_all();
}
async fn app(&self, core: &Core) -> CoreResult<&App> {
self.app
.get_or_try_init(|| async {
App::open_hosted(
self.root.clone(),
self.session.clone(),
core.client.clone(),
self.cancel.child_token(),
)
.await
.map_err(gallery_error)
})
.await
}
async fn ensure_visibility(
&self,
core: &Core,
app: &App,
force: bool,
) -> CoreResult<Arc<Visibility>> {
if self.cancel.is_cancelled() {
return Err(CoreError::remote("The Gallery session expired"));
}
let mut checked = self.checked.lock().await;
if !force
&& let Some(instant) = *checked
&& instant.elapsed()
< if self.snapshot().is_some() {
Duration::from_secs(60)
} else {
Duration::from_secs(5)
}
{
return self.snapshot().ok_or_else(visibility_loading);
}
if self.snapshot().is_none()
&& app
.gallery_visibility_cached()
.await
.map_err(gallery_error)?
{
self.publish_visibility(core, self.read_visibility(core, app).await?);
}
let started = Instant::now();
let result = tokio::select! {
biased;
_ = self.cancel.cancelled() => Err(CoreError::remote("The Gallery session expired")),
result = tokio::time::timeout(Duration::from_secs(20), async {
app.refresh_gallery_configuration(false).await.map_err(gallery_error)?;
self.read_visibility(core, app).await
}) => result.unwrap_or_else(|_| Err(CoreError::remote("Gallery visibility check timed out"))),
};
tracing::debug!(
elapsed_ms = started.elapsed().as_millis() as u64,
success = result.is_ok(),
"Gallery visibility refresh"
);
*checked = Some(Instant::now());
if let Ok(visibility) = result {
self.publish_visibility(core, visibility.clone());
return Ok(visibility);
}
if !force && let Some(visibility) = self.snapshot() {
return Ok(visibility);
}
result
}
fn snapshot(&self) -> Option<Arc<Visibility>> {
self.visibility
.read()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
fn publish_visibility(&self, core: &Core, visibility: Arc<Visibility>) {
let mut snapshot = self.visibility.write().unwrap_or_else(|e| e.into_inner());
if snapshot.as_ref() != Some(&visibility) {
*snapshot = Some(visibility);
drop(snapshot);
self.video.close_all();
core.events
.publish(&[pdfs_core::control::Topic::GalleryVisibilitySynced]);
}
}
async fn read_visibility(&self, core: &Core, app: &App) -> CoreResult<Arc<Visibility>> {
let account = self.account()?;
let mut visibility = Visibility::default();
for (volume, node) in app
.catalog
.hidden_assets(account.clone())
.await
.map_err(gallery_error)?
{
visibility
.media
.insert(NodeUid::new(volume.into(), node.into()).to_string());
}
visibility.media.extend(
core.db
.photo_group_members_for(&visibility.media)
.map_err(CoreError::from)?,
);
for album in app
.catalog
.hidden_configuration_albums(account)
.await
.map_err(gallery_error)?
{
visibility.albums.insert(
NodeUid::new(album.volume.as_str().into(), album.node.as_str().into()).to_string(),
);
}
Ok(Arc::new(visibility))
}
fn account(&self) -> CoreResult<proton_gallery_rs::model::AccountId> {
proton_gallery_rs::model::AccountId::new(self.session.user_id().as_str())
.map_err(gallery_error)
}
async fn page(
&self,
app: &App,
album: Option<GalleryPlace>,
proton: bool,
access: Option<u64>,
offset: usize,
limit: usize,
) -> CoreResult<Response> {
let private = access.is_some();
let parent = album
.as_ref()
.map(|a| (a.gallery.as_str(), a.album.as_str()));
let mut albums = Vec::new();
if offset == 0 && !proton {
if private && parent.is_none() {
albums.extend(
app.photo_albums_with_hidden(true)
.await
.map_err(gallery_error)?
.into_iter()
.filter(|entry| entry.settings.hidden)
.map(|entry| gallery_album(entry, true)),
);
albums.extend(
app.hidden_drive_albums()
.await
.map_err(gallery_error)?
.into_iter()
.map(|entry| gallery_album(entry, false)),
);
} else {
albums.extend(
app.drive_albums(parent, private)
.await
.map_err(gallery_error)?
.into_iter()
.map(|entry| gallery_album(entry, false)),
);
}
}
let (items, total) = if let Some(GalleryPlace { gallery, album }) = album {
let view = if proton && private {
let id = SourceId::new(&album).map_err(gallery_error)?;
if !app
.catalog
.album_settings(id)
.await
.map_err(gallery_error)?
.hidden
{
return Err(CoreError::not_found("Hidden album"));
}
View::PhotoAlbum(album)
} else {
if private
&& !app
.catalog
.drive_album_is_private(
SourceId::new(&gallery).map_err(gallery_error)?,
SourceId::new(&album).map_err(gallery_error)?,
)
.await
.map_err(gallery_error)?
{
return Err(CoreError::not_found("Hidden gallery folder"));
}
View::DriveAlbum { gallery, album }
};
let outline = app
.outline_with_visibility(view, false, private)
.await
.map_err(gallery_error)?;
let total = outline.len();
let items = app
.outline_items(&outline, offset.min(total), limit.clamp(1, 250))
.await
.map_err(gallery_error)?
.into_iter()
.flatten()
.map(|item| PhotoItem {
uid: asset_uid(&item.key),
capture_time: item.sort_time,
thumb_path: None,
name: Some(item.name),
ratio: item.aspect_ratio,
no_thumb: false,
kind: if item.is_video {
PhotoKind::Video
} else {
PhotoKind::Photo
},
favorite: item.favorite,
group_size: 1,
has_raw: false,
place_id: None,
})
.collect();
(items, total)
} else {
(Vec::new(), 0)
};
self.require_access(access)?;
Ok(Response::GalleryPage {
albums,
items,
total,
})
}
fn lock(&self) {
let _ = self
.access
.try_update(Ordering::SeqCst, Ordering::SeqCst, |value| {
Some((value | 1).wrapping_add(1))
});
self.video.close_all();
}
fn private_access(&self) -> CoreResult<u64> {
let access = self.access.load(Ordering::SeqCst);
if access & 1 == 0 {
return Err(CoreError::invalid("Unlock hidden albums to open this item"));
}
Ok(access)
}
fn require_access(&self, access: Option<u64>) -> CoreResult<()> {
if let Some(access) = access
&& self.private_access()? != access
{
return Err(CoreError::invalid("Hidden albums were locked"));
}
Ok(())
}
pub(super) async fn poll(self: Arc<Self>, core: Core) {
loop {
tokio::select! {
biased;
_ = self.cancel.cancelled() => break,
_ = self.refresh.notified() => {},
_ = tokio::time::sleep(Duration::from_secs(60)) => {}
}
if let Ok(Ok(app)) = tokio::time::timeout(Duration::from_secs(5), self.app(&core)).await
{
let _ = self.ensure_visibility(&core, app, false).await;
}
}
}
fn asset(&self, uid: &NodeUid) -> CoreResult<AssetKey> {
Ok(AssetKey {
account: self.account()?,
volume: proton_gallery_rs::model::VolumeId::new(uid.volume_id.as_str())
.map_err(gallery_error)?,
node: proton_gallery_rs::model::NodeId::new(uid.link_id.as_str())
.map_err(gallery_error)?,
})
}
}
fn gallery_album(entry: proton_gallery_rs::library::Album, proton: bool) -> GalleryAlbum {
GalleryAlbum {
place: GalleryPlace {
gallery: entry.gallery.to_string(),
album: entry.source.id.to_string(),
},
proton,
folder: GalleryFolder {
uid: NodeUid::new(
entry.source.volume.as_str().into(),
entry.source.root.as_str().into(),
)
.to_string(),
name: entry.settings.title.unwrap_or(entry.source.label),
},
cover: entry.cover.map(|asset| asset_uid(&asset.key)),
items: entry.direct_items,
folders: entry.child_albums,
hidden: entry.settings.hidden,
}
}
fn gallery_error(error: impl std::fmt::Display) -> CoreError {
CoreError::remote(error.to_string())
}
fn uid(value: &str) -> CoreResult<NodeUid> {
parse_uid(value).ok_or_else(|| CoreError::invalid("Invalid gallery node"))
}
fn done() -> Response {
Response::Ok {
message: "Gallery updated".into(),
}
}
fn asset_uid(asset: &AssetKey) -> String {
NodeUid::new(asset.volume.as_str().into(), asset.node.as_str().into()).to_string()
}
fn visibility_loading() -> CoreError {
CoreError::new(
pdfs_core::control::ErrorKind::Offline,
"Gallery visibility is loading. Try again shortly.",
)
}
impl Core {
pub(super) fn cached_gallery_visibility(&self) -> CoreResult<Arc<Visibility>> {
if self.gallery.is_none() {
return Ok(Arc::default());
}
let gallery = self.gallery_host()?;
match gallery.snapshot() {
Some(snapshot) => Ok(snapshot),
None => {
gallery.refresh.notify_one();
Err(visibility_loading())
}
}
}
pub(super) fn gallery_visibility(&self) -> CoreResult<Arc<Visibility>> {
if self.gallery.is_none() {
return Ok(Arc::default());
}
let gallery = self.gallery_host()?;
self.rt.block_on(async {
let app = gallery.app(self).await?;
gallery.ensure_visibility(self, app, false).await
})
}
fn gallery_host(&self) -> CoreResult<&Gallery> {
self.gallery
.as_deref()
.filter(|gallery| !gallery.cancel.is_cancelled())
.ok_or_else(|| CoreError::remote("The Gallery session is unavailable"))
}
pub(super) fn authenticate_hidden_gallery(
&self,
stream: &std::os::unix::net::UnixStream,
) -> CoreResult<Response> {
let gallery = self.gallery_host()?;
let access = gallery.access.load(Ordering::SeqCst);
let peer = rustix::net::sockopt::socket_peercred(stream)
.map_err(|_| CoreError::invalid("Couldn’t identify the authentication requester."))?;
if peer.uid != rustix::process::geteuid() {
return Err(CoreError::invalid(
"Use your Linux sign-in to unlock Hidden albums.",
));
}
let subject = proton_gallery_app_rs::desktop_auth::Subject::new(
peer.pid.as_raw_nonzero().get() as u32,
peer.uid.as_raw(),
)
.map_err(gallery_error)?;
self.rt
.block_on(subject.authenticate("io.narl.proton-drive-linux.unlock-hidden-albums"))
.map_err(gallery_error)?;
if gallery.cancel.is_cancelled() {
return Err(CoreError::invalid("The Gallery session has ended."));
}
gallery
.access
.compare_exchange(access, access | 1, Ordering::SeqCst, Ordering::SeqCst)
.map_err(|_| CoreError::invalid("Hidden albums were locked"))?;
Ok(done())
}
pub(super) fn drive_gallery(&self, action: GalleryAction) -> CoreResult<Response> {
let gallery = self.gallery_host()?;
let action = match action {
GalleryAction::Lock => {
gallery.lock();
return Ok(done());
}
other => other,
};
self.rt.block_on(async {
let app = gallery.app(self).await?;
gallery
.ensure_visibility(self, app, matches!(action, GalleryAction::Refresh))
.await?;
match action {
GalleryAction::AuthenticateHidden | GalleryAction::Lock => unreachable!(),
GalleryAction::List {
album,
offset,
limit,
} => gallery.page(app, album, false, None, offset, limit).await,
GalleryAction::PrivateList {
album,
proton,
offset,
limit,
} => {
let access = gallery.private_access()?;
gallery
.page(app, album, proton, Some(access), offset, limit)
.await
}
GalleryAction::Folders { parent } => {
let list = app
.browse_drive_folders(parent.as_deref().map(uid).transpose()?)
.await
.map_err(gallery_error)?;
Ok(Response::GalleryFolders {
folders: list
.children
.into_iter()
.map(|folder| GalleryFolder {
uid: folder.uid.to_string(),
name: folder.name,
})
.collect(),
})
}
GalleryAction::Add { uid: node } => {
app.add_drive_folder(uid(&node)?)
.await
.map_err(gallery_error)?;
gallery.ensure_visibility(self, app, true).await?;
Ok(done())
}
GalleryAction::Remove { gallery: id } => {
app.forget_drive_gallery(SourceId::new(id).map_err(gallery_error)?)
.await
.map_err(gallery_error)?;
gallery.ensure_visibility(self, app, true).await?;
Ok(done())
}
GalleryAction::Refresh => {
for album in app.drive_albums(None, true).await.map_err(gallery_error)? {
let root = NodeUid::new(
album.source.volume.as_str().into(),
album.source.root.as_str().into(),
);
app.scan_drive_folder(root).await.map_err(gallery_error)?;
}
gallery.ensure_visibility(self, app, true).await?;
Ok(done())
}
GalleryAction::Cover { album, uid: node } => {
let id = SourceId::new(&album.album).map_err(gallery_error)?;
let root = SourceId::new(&album.gallery).map_err(gallery_error)?;
app.checked_album(album.gallery, album.album)
.await
.map_err(gallery_error)?;
let access = if app
.catalog
.drive_album_is_private(root.clone(), id.clone())
.await
.map_err(gallery_error)?
{
Some(gallery.private_access()?)
} else {
None
};
let mut settings = app
.catalog
.album_settings(id.clone())
.await
.map_err(gallery_error)?;
gallery.require_access(access)?;
settings.cover = Some(gallery.asset(&uid(&node)?)?);
app.catalog
.set_album_settings_at(Some(root), id, settings)
.await
.map_err(gallery_error)?;
gallery.ensure_visibility(self, app, true).await?;
Ok(done())
}
}
})
}
pub(super) fn open_gallery_video(&self, node: &str, private: bool) -> CoreResult<Response> {
let gallery = self.gallery_host()?;
let uid = uid(node)?;
self.rt.block_on(async {
let app = gallery.app(self).await?;
let visibility = gallery.ensure_visibility(self, app, false).await?;
let access = if private {
Some(gallery.private_access()?)
} else {
visibility.permits(node)?;
None
};
let stream = app
.stream_video(&gallery.asset(&uid)?)
.await
.map_err(gallery_error)?;
let response = gallery.video.open(stream, &gallery.cancel).await?;
if let Err(error) = gallery.require_access(access) {
if let Response::GalleryVideo { token, .. } = &response {
gallery.video.close(token);
}
return Err(error);
}
Ok(response)
})
}
pub(super) fn gallery_image(&self, node: &str) -> CoreResult<Response> {
use base64::{Engine, engine::general_purpose::STANDARD};
let gallery = self.gallery_host()?;
let access = gallery.private_access()?;
let asset = gallery.asset(&uid(node)?)?;
self.rt.block_on(async {
let app = gallery.app(self).await?;
let bytes = tokio::time::timeout(Duration::from_secs(30), async {
if let Some(bytes) = app.preview(&asset).await? {
Ok(bytes)
} else {
app.original_in_memory(&asset, 8 * 1024 * 1024).await
}
})
.await
.map_err(|_| CoreError::remote("Proton took too long to open this photo"))?
.map_err(gallery_error)?;
gallery.require_access(Some(access))?;
Ok(Response::GalleryThumbnail {
data: Some(STANDARD.encode(bytes)),
})
})
}
pub(super) fn close_gallery_video(&self, token: &str) -> CoreResult<Response> {
self.gallery_host()?.video.close(token);
Ok(done())
}
pub(super) fn gallery_thumbnail(&self, node: &str, private: bool) -> CoreResult<Response> {
use base64::{Engine, engine::general_purpose::STANDARD};
let gallery = self.gallery_host()?;
let asset = gallery.asset(&uid(node)?)?;
self.rt.block_on(async {
let app = gallery.app(self).await?;
let visibility = gallery.ensure_visibility(self, app, false).await?;
let access = if private {
Some(gallery.private_access()?)
} else {
visibility.permits(node)?;
None
};
let data = app
.thumbnail(&asset)
.await
.map_err(gallery_error)?
.map(|bytes| STANDARD.encode(bytes));
gallery.require_access(access)?;
Ok(Response::GalleryThumbnail { data })
})
}
}
+205
View File
@@ -0,0 +1,205 @@
use std::{collections::VecDeque, io, sync::Arc, time::Duration};
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use http_body_util::{BodyExt, Empty, StreamBody, combinators::UnsyncBoxBody};
use hyper::{
Method, Request, Response, StatusCode,
body::{Bytes, Frame, Incoming},
header,
server::conn::http1,
service::service_fn,
};
use hyper_util::rt::TokioIo;
use pdfs_core::{CoreResult, control::Response as ControlResponse};
use proton_gallery_app_rs::video::VideoStream;
use proton_gallery_rs::CancellationToken;
use tokio::net::TcpListener;
type Body = UnsyncBoxBody<Bytes, io::Error>;
const LEASE: Duration = Duration::from_secs(4 * 60 * 60);
const MAX_STREAMS: usize = 4;
const CHUNK: u32 = 256 * 1024;
#[derive(Default)]
pub(super) struct Server {
active: parking_lot::Mutex<VecDeque<(String, CancellationToken)>>,
}
impl Server {
pub(super) fn close(&self, token: &str) {
let mut active = self.active.lock();
if let Some(index) = active.iter().position(|(id, _)| id == token)
&& let Some((_, cancel)) = active.remove(index)
{
cancel.cancel();
}
}
pub(super) fn close_all(&self) {
for (_, cancel) in self.active.lock().drain(..) {
cancel.cancel();
}
}
pub(super) async fn open(
&self,
stream: Arc<VideoStream>,
account: &CancellationToken,
) -> CoreResult<ControlResponse> {
let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
.await
.map_err(super::gallery_error)?;
let address = listener.local_addr().map_err(super::gallery_error)?;
let mut nonce = [0; 32];
getrandom::fill(&mut nonce).map_err(super::gallery_error)?;
let token = URL_SAFE_NO_PAD.encode(nonce);
let path: Arc<str> = format!("/{token}").into();
let cancel = account.child_token();
{
let mut active = self.active.lock();
active.retain(|(_, cancel)| !cancel.is_cancelled());
if active.len() >= MAX_STREAMS
&& let Some((_, oldest)) = active.pop_front()
{
oldest.cancel();
}
active.push_back((token.clone(), cancel.clone()));
}
let size = stream.length();
tokio::spawn(async move {
let mut connections = tokio::task::JoinSet::new();
let lifetime = tokio::time::sleep(LEASE);
tokio::pin!(lifetime);
loop {
tokio::select! {
biased;
_ = cancel.cancelled() => break,
_ = &mut lifetime => break,
_ = connections.join_next(), if !connections.is_empty() => {},
incoming = listener.accept(), if connections.len() < 8 => {
let Ok((socket, _)) = incoming else { break };
let stream = stream.clone();
let path = path.clone();
connections.spawn(async move {
let service = service_fn(move |request| reply(request, stream.clone(), path.clone()));
let _ = http1::Builder::new()
.timer(hyper_util::rt::TokioTimer::new())
.header_read_timeout(Duration::from_secs(10))
.keep_alive(false)
.serve_connection(TokioIo::new(socket), service).await;
});
}
}
}
stream.stop();
cancel.cancel();
connections.abort_all();
});
Ok(ControlResponse::GalleryVideo {
url: format!("http://{address}/{token}"),
token,
size,
})
}
}
fn range(value: Option<&str>, size: u64) -> Option<(u64, u64)> {
let Some(value) = value else {
return Some((0, size));
};
let (first, last) = value.strip_prefix("bytes=")?.split_once('-')?;
if first.is_empty() {
let suffix = last.parse::<u64>().ok()?.min(size);
return (suffix > 0).then_some((size - suffix, size));
}
let start = first.parse::<u64>().ok()?;
let end = if last.is_empty() {
size
} else {
last.parse::<u64>().ok()?.saturating_add(1).min(size)
};
(start < end).then_some((start, end))
}
fn empty() -> Body {
Empty::new().map_err(|never| match never {}).boxed_unsync()
}
async fn reply(
request: Request<Incoming>,
stream: Arc<VideoStream>,
path: Arc<str>,
) -> Result<Response<Body>, hyper::http::Error> {
let response = Response::builder().header(header::CACHE_CONTROL, "no-store");
if request
.uri()
.path_and_query()
.is_none_or(|actual| actual.as_str() != path.as_ref())
{
return response.status(StatusCode::NOT_FOUND).body(empty());
}
if !matches!(*request.method(), Method::HEAD | Method::GET) {
return response
.status(StatusCode::METHOD_NOT_ALLOWED)
.body(empty());
}
let size = stream.length();
let requested = request.headers().get(header::RANGE);
let parsed = match requested {
Some(value) => value
.to_str()
.ok()
.and_then(|value| range(Some(value), size)),
None => range(None, size),
};
let Some((start, end)) = parsed else {
return response
.status(StatusCode::RANGE_NOT_SATISFIABLE)
.header(header::CONTENT_RANGE, format!("bytes */{size}"))
.body(empty());
};
let response = response
.header(header::ACCEPT_RANGES, "bytes")
.header(header::CONTENT_LENGTH, end - start)
.header(header::CONTENT_TYPE, "application/octet-stream");
let response = if requested.is_some() {
response.status(StatusCode::PARTIAL_CONTENT).header(
header::CONTENT_RANGE,
format!("bytes {start}-{}/{size}", end - 1),
)
} else {
response
};
if request.method() == Method::HEAD {
return response.body(empty());
}
let body = futures::stream::try_unfold((stream, start), move |(stream, at)| async move {
if at == end {
return Ok(None);
}
let read = (end - at).min(u64::from(CHUNK)) as u32;
let bytes = stream.read(at, read).await.map_err(io::Error::other)?;
if bytes.is_empty() {
return Err(io::Error::from(io::ErrorKind::UnexpectedEof));
}
let next = at + bytes.len() as u64;
Ok(Some((Frame::data(Bytes::from(bytes)), (stream, next))))
});
response.body(BodyExt::boxed_unsync(StreamBody::new(body)))
}
#[cfg(test)]
mod tests {
use super::range;
#[test]
fn resolves_seek_ranges_and_rejects_invalid_ranges() {
assert_eq!(range(None, 10), Some((0, 10)));
assert_eq!(range(Some("bytes=3-5"), 10), Some((3, 6)));
assert_eq!(range(Some("bytes=9-"), 10), Some((9, 10)));
assert_eq!(range(Some("bytes=-3"), 10), Some((7, 10)));
assert_eq!(range(Some("bytes=10-"), 10), None);
assert_eq!(range(Some("bytes=0-1,3-4"), 10), None);
}
}
+3 -1
View File
@@ -91,6 +91,7 @@ mod drive;
use drive::{DriveApi, RevisionRead};
mod events;
mod filesystem;
mod gallery;
mod keeper;
mod link;
pub use filesystem::ProtonFs;
@@ -499,6 +500,7 @@ struct Core {
/// The concrete client, for what [`DriveApi`] does not cover: sharing,
/// Photos, devices, invitations and public links.
client: ProtonDriveClient,
gallery: Option<Arc<gallery::Gallery>>,
rt: tokio::runtime::Handle,
/// The daemon's My Files root. Forked on-demand sessions retain this value
/// so ownership checks never mistake their own mount root for account scope.
@@ -5770,7 +5772,7 @@ impl Core {
/// Drop the persisted photos timeline's freshness stamp, so the next timeline
/// read fetches rather than serving what it already has.
fn invalidate_photos(&self) {
let _ = self.db.clear_state(PHOTOS_SYNCED_MS);
let _ = self.db.photos_invalidate();
}
/// Drop one folder's cached child listing (`rel` is mountpoint-relative), so
+3
View File
@@ -232,6 +232,9 @@ impl Core {
/// Unless the keyring holds a newer session than the refused one: then
/// the mount ends, for the daemon to mount again on that one.
pub(crate) fn mark_session_expired(&self, what: &str, error: &dyn std::fmt::Display) {
if let Some(gallery) = &self.gallery {
gallery.cancel();
}
if self.link.resume_stored.load(Ordering::Relaxed) {
return self.mark_offline(what, error);
}
+12
View File
@@ -310,6 +310,7 @@ enum Start {
pub struct MountOptions {
/// Proton account the session belongs to, for display and per-user paths.
pub username: String,
pub gallery_session: Option<proton_drive_rs::proton_sdk::session::ProtonApiSession>,
/// What the background conflict sweep may do. See `docs/BUGS.md` B71.
pub sweep_mode: SweepMode,
/// Upload and download caps in bytes per second (`0` = no cap).
@@ -456,6 +457,7 @@ pub(crate) fn mount_with(
) -> std::io::Result<MountOutcome> {
let MountOptions {
username,
gallery_session,
sweep_mode,
upload_limit,
download_limit,
@@ -480,9 +482,13 @@ pub(crate) fn mount_with(
let (sync_tx, sync_rx) = std::sync::mpsc::channel::<sync::SyncMsg>();
let paused_until = pause::load_paused_until(&db);
let gallery_dir = control_socket.with_file_name("gallery-catalog");
let gallery =
gallery_session.map(|session| Arc::new(super::gallery::Gallery::new(gallery_dir, session)));
let core = Core {
drive,
client,
gallery,
rt: rt.clone(),
maintenance: Arc::new(Mutex::new(Default::default())),
primary_root_uid: root.uid.clone(),
@@ -636,6 +642,9 @@ pub(crate) fn mount_with(
// Keep the launcher prompt's "This computer" index fresh. Its own thread:
// the walk is I/O-heavy and must never sit in front of a FUSE callback.
if matches!(host, Host::Daemon) {
if let Some(gallery) = &core.gallery {
rt.spawn(gallery.clone().poll(core.clone()));
}
let db = core.db.clone();
let indexing = core.indexing.clone();
let transfers = core.transfers.clone();
@@ -954,6 +963,9 @@ fn keep_or_abandon(
/// Signal every worker to stop, then join them up to [`WORKER_JOIN_DEADLINE`].
fn halt_workers(core: &Core, control_socket: &Path, workers: Vec<std::thread::JoinHandle<()>>) {
core.shutdown.stop();
if let Some(gallery) = &core.gallery {
gallery.cancel();
}
core.wake_drain();
let _ = core.sync_tx.send(sync::SyncMsg::Stop);
// Connect while the socket still exists — that is the whole point of the
+139 -171
View File
@@ -32,7 +32,7 @@ use tracing::{debug, info, warn};
use super::drive::RevisionRead;
use super::{
Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS, TIMELINE_ENRICH_CHUNK, TIMELINE_TTL, WriteAuthority,
Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS, TIMELINE_ENRICH_CHUNK, WriteAuthority, link,
node_size, now_ms, parse_uid,
};
@@ -1144,18 +1144,6 @@ impl Drop for ProgressGuard<'_> {
}
}
/// What a timeline enrichment pass resolves for one photo, beyond what the
/// timeline listing already carries.
#[derive(Clone, Debug)]
struct PhotoMeta {
name: Option<String>,
media_type: Option<String>,
favorite: bool,
content_hash: Option<String>,
/// Where the photo was taken, as its uploader recorded it.
location: Option<(f64, f64)>,
}
impl Core {
/// [`upload_thumbnails`] for a file about to upload, staging any RAW copy
/// under this cache. Blocking.
@@ -1175,6 +1163,7 @@ impl Core {
.unwrap_or_default()
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn photos_timeline(
&self,
offset: usize,
@@ -1183,21 +1172,29 @@ impl Core {
range: Option<(i64, i64)>,
favorites: bool,
not_in_album: bool,
excluded: &str,
) -> CoreResult<Option<Vec<PhotoItem>>> {
let count = self.db.photos_count().map_err(CoreError::from)?;
if count == 0 {
// Nothing to serve, so this one request has to wait for the fetch —
// unless we already know the account has no photos volume and the
// answer is a fresh "no".
let known_empty = self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() == Some(0);
if known_empty && !self.listing_stale(PHOTOS_SYNCED_MS, TIMELINE_TTL) {
return Ok(None);
let listed = self
.db
.state_i64(PHOTOS_SYNCED_MS)
.map_err(CoreError::from)?
.is_some();
if !listed {
if count == 0 {
if !self.refresh_timeline_joined()? {
return Ok(None);
}
} else {
self.spawn_timeline_refresh();
}
if !self.refresh_timeline_joined()? {
return Ok(None);
}
} else if self.listing_stale(PHOTOS_SYNCED_MS, TIMELINE_TTL) {
self.spawn_timeline_refresh();
} else if self
.db
.state_i64(PHOTOS_AVAILABLE)
.map_err(CoreError::from)?
== Some(0)
{
return Ok(None);
}
// The filter is only as good as the album contents on disk, and those
// are fetched lazily, per album opened. Fill in the missing ones before
@@ -1208,7 +1205,15 @@ impl Core {
let page = self
.db
.photos_page(offset, limit, kind, range, favorites, not_in_album)
.photos_page_visible(
offset,
limit,
kind,
range,
favorites,
not_in_album,
excluded,
)
.map_err(CoreError::from)?;
Ok(Some(page.into_iter().map(|p| self.photo_item(p)).collect()))
}
@@ -1365,8 +1370,11 @@ impl Core {
/// The towns the photos were taken in, as wire items. A town the bundled
/// table no longer knows (the stored id came from an older table) is left
/// out rather than shown without a name.
pub(crate) fn photo_places(&self) -> CoreResult<Vec<PlaceInfo>> {
let places = self.db.photo_places().map_err(CoreError::from)?;
pub(crate) fn photo_places(&self, excluded: &str) -> CoreResult<Vec<PlaceInfo>> {
let places = self
.db
.photo_places_visible(excluded)
.map_err(CoreError::from)?;
Ok(places
.into_iter()
.filter_map(|place| {
@@ -1390,10 +1398,11 @@ impl Core {
id: u32,
offset: usize,
limit: usize,
excluded: &str,
) -> CoreResult<Vec<PhotoItem>> {
let photos = self
.db
.photos_at_place(id, offset, limit)
.photos_at_place_visible(id, offset, limit, excluded)
.map_err(CoreError::from)?;
Ok(photos.into_iter().map(|p| self.photo_item(p)).collect())
}
@@ -1417,13 +1426,17 @@ impl Core {
/// Photos taken on today's date in earlier years, as wire items. Served
/// from the stored timeline only: the strip is a nicety, not worth a wait
/// on the network, and the timeline's own load keeps that store fresh.
pub(crate) fn photos_on_this_day(&self, limit: usize) -> CoreResult<Vec<PhotoItem>> {
pub(crate) fn photos_on_this_day(
&self,
limit: usize,
excluded: &str,
) -> CoreResult<Vec<PhotoItem>> {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_secs() as i64);
let photos = self
.db
.photos_on_this_day(now, limit)
.photos_on_this_day_visible(now, limit, excluded)
.map_err(CoreError::from)?;
Ok(photos.into_iter().map(|p| self.photo_item(p)).collect())
}
@@ -2477,162 +2490,113 @@ impl Core {
}
}
/// Whether the listing stamped under `key` is older than `ttl` (or was never
/// fetched).
/// Commit the lightweight listing before resolving pending nodes. The
/// feed generation fences both commits against events received in flight.
pub(crate) async fn refresh_timeline(&self) -> CoreResult<bool> {
let started = Instant::now();
let generation = self
.db
.photo_projection_generation()
.map_err(CoreError::from)?;
let photos = self.photos();
if photos
.get_photos_root()
.await
.map_err(|e| CoreError::from_api(&e, "photos root"))?
if self
.db
.state_i64(PHOTOS_SYNCED_MS)
.map_err(CoreError::from)?
.is_none()
{
let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 0);
let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms());
let available = link::bounded(photos.get_photos_root())
.await
.map_err(|e| CoreError::from_api(&e, "photos root"))?
.is_some();
let items = if available {
link::bounded_by(super::BATCH_CALL_TIMEOUT, photos.enumerate_timeline())
.await
.map_err(|e| CoreError::from_api(&e, "timeline"))?
.into_iter()
.map(|item| db::TimelineRow::new(item.uid.to_string(), item.capture_time))
.collect()
} else {
Vec::new()
};
if !self
.db
.photos_replace_at(&items, generation, available, now_ms())
.map_err(CoreError::from)?
{
return Err(CoreError::remote(
"Photos changed during the refresh. Try again shortly.",
));
}
if !available {
return Ok(false);
}
} else if self
.db
.state_i64(PHOTOS_AVAILABLE)
.map_err(CoreError::from)?
== Some(0)
{
return Ok(false);
}
let items = photos
.enumerate_timeline()
.await
.map_err(|e| CoreError::from_api(&e, "timeline"))?;
// The timeline DTO carries only a uid and capture time, but the gallery
// has to split into its tabs — which needs each photo's name and media
// type. Resolve those in batches off the request path. Best-effort: a
// photo whose node we fail to resolve keeps whatever was learned before
// (or classifies from nothing, i.e. a still photo), so a partial resolve
// never blanks the timeline.
//
// Only photos the daemon has never read, and ones a remote event marked
// stale, are read. Resolving all of them every time is what made a
// 12k-photo refresh take minutes (`docs/BUGS.md` B92): this metadata does
// not change on its own, and when it does change the event feed names the
// uid that changed (`Db::photos_mark_unresolved`).
let known: HashSet<String> = self
.db
.photos_resolved()
.map_err(CoreError::from)?
.into_iter()
.collect();
let uids: Vec<NodeUid> = items
.iter()
.filter(|it| !known.contains(&it.uid.to_string()))
.map(|it| it.uid.clone())
.collect();
let resolved_at = now_ms();
let mut meta: HashMap<String, PhotoMeta> = HashMap::new();
// A main photo names its related photos rather than the other way round,
// so the relation is recorded from whichever end resolves — the two ends
// can land in different chunks, and one of them may not resolve at all.
let mut main_of: HashMap<String, String> = HashMap::new();
let mut stopped = false;
// Photos read before count as done, so the bar picks up where an
// interrupted pass left off. Cleared however the pass ends.
let skipped = items.len() - uids.len();
let pending = self.db.photos_pending().map_err(CoreError::from)?;
let total = self.db.photos_count().map_err(CoreError::from)?;
let skipped = total.saturating_sub(pending.len());
let mut resolved = 0;
let progress = ProgressGuard(&self.timeline_progress);
if !uids.is_empty() {
*progress.0.lock() = Some((skipped, items.len()));
}
for (index, chunk) in uids.chunks(TIMELINE_ENRICH_CHUNK).enumerate() {
// Teardown cancels the runtime under this loop, and every chunk
// still in flight then fails its decrypt task — a burst of
// "skipping undecryptable photo ... task was cancelled" warnings
// that read like corruption and are only a shutdown. Stop asking
// for chunks instead. What resolved so far is kept below; the rest
// stay unresolved and are read by the next refresh.
for (index, chunk) in pending.chunks(TIMELINE_ENRICH_CHUNK).enumerate() {
if self.shutdown.is_stopping() {
stopped = true;
break;
}
match photos.enumerate_nodes(chunk).await {
Ok(nodes) => {
for node in nodes {
let media_type = match &node.kind {
NodeKind::File { media_type, .. } => Some(media_type.clone()),
NodeKind::Folder => None,
};
// The favorite state is a tag on the photo node, so it
// rides along with the metadata resolve rather than
// costing a listing of its own.
let favorite = node
.photo
.as_ref()
.is_some_and(|p| p.tags.contains(&PhotoTag::Favorite));
let key = node.uid.to_string();
let content_hash = node.photo.as_ref().and_then(|p| p.content_hash.clone());
let location = node
.photo
.as_ref()
.and_then(|p| p.location)
.map(|l| (l.latitude, l.longitude));
if let Some(photo) = node.photo.as_ref() {
if let Some(main) = photo.main_photo_uid.as_ref() {
main_of.insert(key.clone(), main.to_string());
}
for related in &photo.related_photo_uids {
main_of.insert(related.to_string(), key.clone());
}
}
meta.insert(
key,
PhotoMeta {
name: Some(node.name),
media_type,
favorite,
content_hash,
location,
},
);
*progress.0.lock() = Some((skipped + index * TIMELINE_ENRICH_CHUNK, total));
let uids: Vec<_> = chunk.iter().filter_map(|uid| parse_uid(uid)).collect();
let nodes = link::bounded(photos.enumerate_nodes(&uids))
.await
.map_err(|e| CoreError::from_api(&e, "read photo metadata"))?;
let rows: Vec<_> = nodes
.into_iter()
.filter_map(|node| {
let NodeKind::File { media_type, .. } = node.kind else {
return None;
};
if node.trashed {
return None;
}
}
Err(e) => warn!(error = %e, "resolving photo metadata for a timeline chunk failed"),
let photo = node.photo.as_ref();
Some(db::TimelineRow {
name: Some(node.name),
media_type: Some(media_type),
favorite: Some(photo.is_some_and(|p| p.tags.contains(&PhotoTag::Favorite))),
content_hash: photo.and_then(|p| p.content_hash.clone()),
location: photo
.and_then(|p| p.location)
.map(|l| (l.latitude, l.longitude)),
main_uid: photo
.and_then(|p| p.main_photo_uid.as_ref())
.map(ToString::to_string),
resolved_at: Some(now_ms()),
..db::TimelineRow::new(node.uid.to_string(), 0)
})
})
.collect();
if !self
.db
.photos_resolve_at(generation, &rows)
.map_err(CoreError::from)?
{
return Err(CoreError::remote(
"Photos changed during the refresh. Try again shortly.",
));
}
let done = (skipped + (index + 1) * TIMELINE_ENRICH_CHUNK).min(items.len());
*progress.0.lock() = Some((done, items.len()));
resolved += rows.len();
}
drop(progress);
let rows: Vec<db::TimelineRow> = items
.iter()
.map(|it| {
let key = it.uid.to_string();
let main_uid = main_of.get(&key).cloned();
// An unresolved photo keeps whatever was learned before, for the
// favorite flag as much as for the name and media type.
match meta.get(&key).cloned() {
Some(m) => db::TimelineRow {
name: m.name,
media_type: m.media_type,
favorite: Some(m.favorite),
content_hash: m.content_hash,
location: m.location,
main_uid,
resolved_at: Some(resolved_at),
..db::TimelineRow::new(key, it.capture_time)
},
None => db::TimelineRow {
main_uid,
..db::TimelineRow::new(key, it.capture_time)
},
}
})
.collect();
self.db.photos_replace(&rows).map_err(CoreError::from)?;
let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 1);
let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms());
// How long this took is the first thing to know when a refresh looks
// like it never happened, and the chunk count is what it scales with.
info!(
photos = rows.len(),
// `resolved` is what came back, which is short of `wanted` when
// shutdown cut the pass off or a chunk failed.
resolved = meta.len(),
wanted = uids.len(),
skipped = rows.len().saturating_sub(uids.len()),
chunks = uids.len().div_ceil(TIMELINE_ENRICH_CHUNK),
photos = total,
resolved,
wanted = pending.len(),
skipped,
elapsed_ms = started.elapsed().as_millis() as u64,
stopped,
"photos timeline refreshed"
);
Ok(true)
@@ -2656,7 +2620,11 @@ impl Core {
// A refresh that landed stamped the timeline fresh. One that failed
// did not, and the caller gets this refresh's own error instead of
// an empty timeline.
if !self.listing_stale(PHOTOS_SYNCED_MS, TIMELINE_TTL)
if self
.db
.state_i64(PHOTOS_SYNCED_MS)
.map_err(CoreError::from)?
.is_some()
|| self.timeline_refreshing.swap(true, Ordering::SeqCst)
{
return Ok(self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() != Some(0));
+8 -76
View File
@@ -212,15 +212,12 @@ impl BlockRing {
}
/// The result of fetching one block, shared between everyone who wanted it.
type BlockResult = Result<Arc<Vec<u8>>, Errno>;
pub(super) type BlockResult = Result<Arc<Vec<u8>>, Errno>;
/// Identifies a block *of a revision*: node, validity tag, and the plaintext
/// range the block covers — see [`RingKey`] for why it is the range and not the
/// index.
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>>);
pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
/// Block fetches in flight, so a block is downloaded and decrypted once however
/// many readers want it at that moment (audit T1).
@@ -231,34 +228,7 @@ type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
/// for. Without this each of them pays the full round-trip and decrypt and all
/// but one result is discarded — roughly double the bandwidth and CPU in steady
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
#[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);
}
}
}
pub(super) type BlockFlight = proton_media_rs::SingleFlight<BlockKey, BlockResult>;
/// 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).
@@ -581,49 +551,11 @@ impl Core {
cache_blocks: bool,
) -> BlockResult {
let key: BlockKey = (uid.clone(), mtime, fsize, span);
let claim = {
let mut inflight = self.block_flight.inflight.lock();
match inflight.get(&key) {
Some((_, rx)) => Err(rx.clone()),
None => {
let id = NEXT_FLIGHT_ID.fetch_add(1, Ordering::Relaxed);
let (tx, rx) = tokio::sync::watch::channel(None);
inflight.insert(key.clone(), (id, rx));
Ok((
tx,
Flight {
flight: self.block_flight.clone(),
key: key.clone(),
id,
},
))
}
}
};
let (tx, flight) = match claim {
Ok(lead) => lead,
Err(mut rx) => {
loop {
if let Some(result) = rx.borrow_and_update().clone() {
return result;
}
if rx.changed().await.is_err() {
break;
}
}
return self
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
.await;
}
};
let result = self
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
.await;
// Retire the claim before publishing, so a racer that wakes and re-enters
// finds no stale entry to join.
drop(flight);
let _ = tx.send(Some(result.clone()));
result
self.block_flight
.join(key, || {
self.read_block(reader, uid, mtime, fsize, span, cache_blocks)
})
.await
}
/// Download and decrypt one block, then put it where the next reader will
+63
View File
@@ -89,6 +89,7 @@ impl Daemon {
db,
MountOptions {
username: "sim".into(),
gallery_session: None,
sweep_mode: AppConfig::default().resolved_conflict_sweep(),
upload_limit: 0,
download_limit: 0,
@@ -1917,6 +1918,68 @@ mod tests {
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
fn a_move_blocked_by_trash_can_be_retried_after_restore() {
use pdfs_core::control::SyncIssue;
let drive = FakeDrive::new();
let dir = scratch("move-out-of-trash");
let daemon = Daemon::start(&dir, drive.client(1, Faults::none())).unwrap();
let mount = &daemon.mountpoint;
std::fs::create_dir_all(mount.join("source/nested")).unwrap();
std::fs::create_dir(mount.join("destination")).unwrap();
std::fs::write(mount.join("source/nested/wallpaper.jpg"), b"image").unwrap();
assert!(wait_until(Duration::from_secs(30), || daemon.drained()
&& drive.lookup("source/nested/wallpaper.jpg").is_some()));
let source = drive.lookup("source").unwrap();
let pause = |paused| Request::SetSyncPaused {
paused,
until: None,
};
daemon.request(&pause(true)).unwrap();
std::fs::rename(
mount.join("source/nested/wallpaper.jpg"),
mount.join("destination/wallpaper.jpg"),
)
.unwrap();
drive.device().trash("source");
daemon.request(&pause(false)).unwrap();
assert!(wait_until(Duration::from_secs(30), || daemon
.pending()
.is_ok_and(|ops| ops.iter().any(|op| op.issue
== Some(SyncIssue::Trashed)
&& op
.last_error
.as_deref()
.is_some_and(|message| message.contains("‘source’"))))));
daemon
.request(&Request::RetryPendingOp { id: None })
.unwrap();
assert!(wait_until(Duration::from_secs(30), || daemon
.pending()
.is_ok_and(|ops| ops.iter().any(|op| op.attempts >= 2))));
daemon
.request(&Request::Restore {
uids: vec![source.to_string()],
})
.unwrap();
daemon
.request(&Request::RetryPendingOp { id: None })
.unwrap();
assert!(wait_until(Duration::from_secs(30), || daemon.drained()
&& drive.lookup("destination/wallpaper.jpg").is_some()));
assert_eq!(
std::fs::read(mount.join("destination/wallpaper.jpg")).unwrap(),
b"image"
);
assert!(matches!(daemon.stop(), Ok(MountOutcome::Shutdown)));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
fn a_write_over_a_create_whose_read_back_failed_is_not_a_conflict() {
+17
View File
@@ -160,6 +160,17 @@ impl Server {
.is_some_and(|remote| remote.file.is_none() && !remote.trashed)
}
fn in_trash(&self, uid: &NodeUid) -> bool {
let mut node = self.current(uid);
while let Some(remote) = node {
if remote.trashed {
return true;
}
node = remote.parent.as_ref().and_then(|uid| self.current(uid));
}
false
}
fn is_below(&self, uid: &NodeUid, ancestor: &NodeUid) -> bool {
let mut cursor = Some(uid.clone());
while let Some(at) = cursor {
@@ -1037,6 +1048,12 @@ impl FakeClient {
}
let parent = new_parent.cloned().or(remote.parent.clone());
let name = new_name.unwrap_or(&remote.name).to_owned();
if server.in_trash(uid) || parent.as_ref().is_some_and(|uid| server.in_trash(uid)) {
return Err(api(
ResponseCode::NotEnoughPermissions,
"an item involved in the move is in Trash",
));
}
if let Some(parent) = &parent {
if !server.is_folder(parent) {
return Err(api(
+4
View File
@@ -112,6 +112,8 @@ struct Run {
/// Run `profile` on `seed`. It answers a report of what went wrong, if
/// anything did.
pub(crate) fn run(seed: u64, profile: &'static Profile) -> Result<(), String> {
// The simulation suite runs serially. Discard logs left by earlier tests.
take_logged();
let dir = scratch(&format!("{}-{seed}", profile.name));
let mut rng = Rng::new(seed);
let drive = FakeDrive::new();
@@ -137,6 +139,7 @@ pub(crate) fn run(seed: u64, profile: &'static Profile) -> Result<(), String> {
let _ = daemon.stop();
}
}
run.logged.extend(take_logged());
match outcome {
Ok(()) => {
let _ = std::fs::remove_dir_all(&dir);
@@ -432,6 +435,7 @@ impl Run {
fn report(&self, failure: &str, dir: &Path) -> String {
let _ = std::fs::write(dir.join("steps.log"), self.log.join("\n") + "\n");
let _ = std::fs::write(dir.join("daemon.log"), self.logged.join("\n") + "\n");
let tail = &self.log[self.log.len().saturating_sub(LOG_TAIL)..];
format!(
"{} seed {} failed: {failure}\nreplay with PDFS_SIM_SEED={}; state kept in {}\nlast steps:\n{}",
+1 -1
View File
@@ -527,7 +527,7 @@ impl Core {
let scan = match scan_archives_until(archives, || self.import_should_stop(cancel)) {
Ok(scan) => scan,
Err(_) if self.import_should_stop(cancel) => return Ok(true),
Err(e) => return Err(e),
Err(e) => return Err(CoreError::conflict(e.to_string())),
};
*planned = plan(&scan);
*albums = scan.albums.clone();
+2
View File
@@ -22,6 +22,8 @@ name = "pdfs-prompt"
path = "src/prompt.rs"
[dependencies]
proton-gallery-rs.workspace = true
base64.workspace = true
pdfs-core.workspace = true
tracing.workspace = true
tracing-subscriber.workspace = true
+4
View File
@@ -118,11 +118,15 @@ scale.browser-status-meter trough { min-width: 140px; min-height: 6px; }
.memory-card { padding: 0; border-radius: 12px; }
.memory-cover { border-radius: 12px; background: alpha(currentColor, 0.06); }
.memory-label { font-weight: 700; color: white; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); padding: 22px 10px 6px 10px; background: linear-gradient(to top, rgba(0, 0, 0, 0.6), rgba(0, 0, 0, 0)); }
/* The button handles hover and clicks. The FlowBox cell can be wider than it. */
flowbox.photo-album-grid > flowboxchild:hover,
flowbox.photo-album-grid > flowboxchild:active { background: transparent; }
.album-card { padding: 0; border-radius: 16px; transition: background 180ms ease; }
.album-card:hover { background: alpha(currentColor, 0.07); }
.album-cover { border-radius: 16px; background: alpha(currentColor, 0.06); box-shadow: 0 4px 16px rgba(0, 0, 0, 0.32); transition: box-shadow 180ms ease; }
.album-card:hover .album-cover { box-shadow: 0 10px 26px rgba(0, 0, 0, 0.5); }
.album-card:hover .photo-thumb { transform: scale(1.05); }
listview.drive-gallery-rows > row { padding: 0; }
.view-switch button, .view-switch toggle { padding-left: 12px; padding-right: 12px; }
/* Shared with Me: what a share lets me do, as a tinted pill beside the name. */
+40 -5
View File
@@ -100,6 +100,9 @@ fn on_feed(ui: &Rc<Ui>, state: &Rc<FeedState>, feed: Feed, hidden: bool) {
follow_takeout(ui, state, &jobs);
}
Feed::Event(Event::Changed { topics }) if hidden => {
if topics.contains(&Topic::Photos) {
check_photo_viewer(ui);
}
state.deferred.borrow_mut().extend(topics);
}
Feed::Event(Event::Changed { topics }) => follow_changes(ui, state, &topics),
@@ -133,10 +136,44 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
refresh_file_thumbnails(ui);
}
let page = ui.stack.visible_child_name();
// A timeline out of sight is read again when the user comes back to it;
// one on screen is left alone (below).
if changed(Topic::Photos) && (page.as_deref() != Some("gallery") || !photo_grid_shown(ui)) {
if changed(Topic::GalleryVisibility) || changed(Topic::GalleryVisibilitySynced) {
if let Some(browser) = ui.drive_galleries.borrow().upgrade() {
browser.refresh_visibility(changed(Topic::GalleryVisibility));
}
for window in gtk4::Window::list_toplevels() {
if let Ok(window) = window.downcast::<gtk4::Window>()
&& window.has_css_class("photo-viewer-window")
{
window.close();
}
}
ui.gallery
.thumb_generation
.set(ui.gallery.thumb_generation.get().wrapping_add(1));
ui.gallery.thumb_queue.borrow_mut().clear();
ui.gallery.decode_queue.borrow_mut().clear();
ui.gallery.thumb_wanted.borrow_mut().clear();
ui.gallery.photo_tex.borrow_mut().clear();
ui.gallery.model.remove_all();
ui.gallery.groups.remove_all();
ui.gallery.row_by_photo.borrow_mut().clear();
ui.gallery.timeline_stale.set(true);
if page.as_deref() == Some("gallery") {
match ui.gallery.content.visible_child_name().as_deref() {
Some("albums") => load_albums(ui),
Some("drive-galleries") => {}
Some("places") => load_places(ui),
_ => load_gallery(ui, false),
}
}
}
if changed(Topic::Photos) {
check_photo_viewer(ui);
if page.as_deref() != Some("gallery") || !photo_grid_shown(ui) {
ui.gallery.timeline_stale.set(true);
} else {
refresh_visible_photos(ui);
}
}
match page.as_deref() {
// A search on screen is left alone: reloading would swap its hits for
@@ -144,8 +181,6 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
Some("browser") if changed(Topic::Files) && ui.browser.search.text().trim().is_empty() => {
load_browser(ui)
}
// The timeline is left alone: reloading it would throw away the place
// the user scrolled to. F5 reloads it on request.
Some("gallery")
if changed(Topic::Photos)
&& ui.gallery.content.visible_child_name().as_deref() == Some("albums") =>
+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);
}
}
+45 -23
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::*;
@@ -160,6 +162,7 @@ struct Ui {
pub(crate) details: DetailsState,
pub(crate) trash: TrashState,
pub(crate) gallery: GalleryState,
drive_galleries: RefCell<std::rc::Weak<pages::drive_galleries::Browser>>,
pub(crate) shared: SharedState,
pub(crate) shared_by_me: SharedByMeState,
pub(crate) devices: DevicesState,
@@ -189,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
@@ -207,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);
}
}
@@ -459,6 +450,7 @@ fn build_window(app: &adw::Application) {
nav: split.clone(),
narrow: Cell::new(false),
file_thumbs: FileThumbnailState::new(),
drive_galleries: RefCell::default(),
login: login_widgets,
status: StatusState {
status_inflight: Cell::new(false),
@@ -559,6 +551,10 @@ fn build_window(app: &adw::Application) {
gallery: GalleryState {
model: gallery_widgets.model.clone(),
groups: gallery_widgets.groups.clone(),
row_by_photo: RefCell::default(),
rendered_layout: Cell::new(None),
rendered_photos: Cell::new(0),
align_tick: RefCell::default(),
row_height: Cell::new(ROW_DEFAULT),
scrolling_down: Cell::new(true),
scroll_offset: Cell::new(0.0),
@@ -615,23 +611,29 @@ fn build_window(app: &adw::Application) {
memory_cards: gallery_widgets.memory_cards.clone(),
has_memories: Cell::new(false),
date_suppress: Cell::new(false),
months_loading: Cell::new(false),
months_pending: Cell::new(false),
changes_pending: Cell::new(false),
viewer: RefCell::new(std::rc::Weak::new()),
reload_pending: Cell::new(false),
loading: Cell::new(false),
has_more: Cell::new(false),
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()),
thumb_inflight: Cell::new(false),
thumb_inflight: RefCell::default(),
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()),
visible_tiles_pending: Cell::new(0),
tile_pools: RefCell::new(HashMap::new()),
list: gallery_widgets.list.clone(),
selecting: Cell::new(false),
@@ -640,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(),
@@ -725,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,
});
@@ -787,6 +794,11 @@ fn build_window(app: &adw::Application) {
// thumbnail generation as it paints.
cancel_file_thumbnails(&ui_nav);
sync_sidebar(&ui_nav);
if st.visible_child_name().as_deref() != Some("gallery")
&& let Some(browser) = ui_nav.drive_galleries.borrow().upgrade()
{
browser.close();
}
match st.visible_child_name().as_deref() {
Some("browser") => reload_browser_view(&ui_nav),
// The Albums and Places listings are re-read in place. Loading the
@@ -796,7 +808,7 @@ fn build_window(app: &adw::Application) {
// sight (see `follow_changes`) or nothing is loaded yet.
Some("gallery") if !ui_nav.gallery.in_collection() => {
match ui_nav.gallery.view_switch.active() {
VIEW_ALBUMS => load_albums(&ui_nav),
VIEW_ALBUMS => show_albums(&ui_nav),
VIEW_PLACES => load_places(&ui_nav),
_ if ui_nav.gallery.timeline_stale.replace(false)
|| ui_nav.gallery.model.n_items() == 0 =>
@@ -833,6 +845,14 @@ fn build_window(app: &adw::Application) {
.height_request(WindowState::MIN_HEIGHT)
.content(&toasts)
.build();
pages::drive_galleries::wire(
&ui,
&window,
&gallery_widgets.drive_galleries,
&gallery_widgets.drive_status,
&gallery_widgets.add_gallery,
&gallery_widgets.hidden_albums,
);
remember_window_state(&ui, app, &window);
// A wide window docks the details pane beside the files instead of laying it
// over them.
@@ -1673,7 +1693,9 @@ fn install_shortcuts(ui: &Rc<Ui>, window: &adw::ApplicationWindow) {
let on_trash = page.as_deref() == Some("trash");
let on_gallery = page.as_deref() == Some("gallery");
// Pages with a level to go back to, besides My files' own history.
let in_collection = on_gallery && ui.gallery.in_collection();
let in_collection = on_gallery
&& (ui.gallery.in_collection()
|| ui.gallery.content.visible_child_name().as_deref() == Some("drive-galleries"));
let in_shared_folder =
page.as_deref() == Some("shared") && !ui.shared.nav.borrow().is_empty();
let in_device_folder =
+35 -8
View File
@@ -18,6 +18,9 @@ const COVER_EDGE: i32 = 200;
pub(crate) fn show_albums(ui: &Rc<Ui>) {
show_album_grid(ui);
load_albums(ui);
if let Some(browser) = ui.drive_galleries.borrow().upgrade() {
browser.load_root();
}
}
/// Switch to the album grid as it was last filled, keeping its scroll
@@ -102,7 +105,7 @@ fn fill_albums(ui: &Rc<Ui>, albums: &[AlbumInfo]) {
ui.gallery.albums.remove(&child);
}
*ui.gallery.album_list.borrow_mut() = albums.to_vec();
if ui.gallery.album.borrow().is_none() {
if ui.gallery.content.visible_child_name().as_deref() == Some("albums") {
ui.gallery.title.set_subtitle(&ngettext_f(
"{n} album",
"{n} albums",
@@ -125,7 +128,12 @@ fn fill_albums(ui: &Rc<Ui>, albums: &[AlbumInfo]) {
/// One album as a clickable card: its cover, its name, and how many photos it
/// holds. An album shared with us says so — it lives on someone else's volume,
/// and that is worth knowing before opening it.
fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
pub(crate) fn collection_card(
title: &str,
subtitle: &str,
icon: &str,
(width, height): (i32, i32),
) -> (gtk4::Button, gtk4::Picture) {
let picture = gtk4::Picture::builder()
// Fills and crops the cover square, like a timeline tile.
.content_fit(gtk4::ContentFit::Cover)
@@ -136,7 +144,7 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
picture.add_css_class("photo-thumb");
let placeholder = gtk4::Image::builder()
.icon_name("pdfs-album-symbolic")
.icon_name(icon)
.pixel_size(32)
.halign(gtk4::Align::Center)
.valign(gtk4::Align::Center)
@@ -146,12 +154,12 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
let cover = gtk4::Overlay::new();
cover.set_child(Some(&placeholder));
cover.add_overlay(&picture);
cover.set_size_request(COVER_EDGE, COVER_EDGE);
cover.set_size_request(width, height);
cover.set_overflow(gtk4::Overflow::Hidden);
cover.add_css_class("album-cover");
let name = gtk4::Label::builder()
.label(&album.name)
.label(title)
.halign(gtk4::Align::Start)
.xalign(0.0)
.ellipsize(gtk4::pango::EllipsizeMode::End)
@@ -159,7 +167,7 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
name.add_css_class("heading");
let count = gtk4::Label::builder()
.label(album_subtitle(album))
.label(subtitle)
.halign(gtk4::Align::Start)
.xalign(0.0)
.ellipsize(gtk4::pango::EllipsizeMode::End)
@@ -172,10 +180,23 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
card.append(&name);
card.append(&count);
let button = gtk4::Button::builder().child(&card).build();
let button = gtk4::Button::builder()
.child(&card)
.halign(gtk4::Align::Start)
.build();
button.add_css_class("flat");
button.add_css_class("album-card");
button.set_tooltip_text(Some(&album.name));
button.set_tooltip_text(Some(title));
(button, picture)
}
fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
let (button, picture) = collection_card(
&album.name,
&album_subtitle(album),
"pdfs-album-symbolic",
(COVER_EDGE, COVER_EDGE),
);
if let Some(uid) = album.cover_uid.clone() {
want_cover(ui, uid, &picture);
@@ -693,6 +714,12 @@ pub(crate) fn wire_albums(ui: &Rc<Ui>) {
// where it was, instead of reloading it.
let ui_back = ui.clone();
ui.gallery.back.clone().connect_clicked(move |_| {
if ui_back.gallery.content.visible_child_name().as_deref() == Some("drive-galleries") {
if let Some(browser) = ui_back.drive_galleries.borrow().upgrade() {
browser.back();
}
return;
}
if ui_back.gallery.place.borrow().is_some() {
show_place_grid(&ui_back);
return;
File diff suppressed because it is too large. Load diff
@@ -788,6 +788,9 @@ pub(crate) fn issue_text(issue: SyncIssue) -> String {
SyncIssue::Access => gettext(
"You can no longer change this on Proton Drive. Ask the owner for edit access, or export the file to keep your version.",
),
SyncIssue::Trashed => {
gettext("Restore the item or folder from Trash, then retry the move.")
}
SyncIssue::Missing => gettext(
"The folder this change belongs in is gone from Proton Drive. Export the file to keep your version.",
),
+10
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.",
),
@@ -683,6 +686,10 @@ pub(crate) fn sign_out(ui: &Rc<Ui>) {
),
&gettext("Sign Out"),
move || {
let galleries = ui.drive_galleries.borrow().upgrade();
if let Some(galleries) = galleries {
galleries.reset();
}
// systemctl and the keyring both block, so run them on a worker.
let ui = ui.clone();
glib::spawn_future_local(async move {
@@ -707,6 +714,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());
+1
View File
@@ -3,6 +3,7 @@ pub(crate) mod activity_text;
pub(crate) mod albums;
pub(crate) mod browser;
pub(crate) mod devices;
pub(crate) mod drive_galleries;
pub(crate) mod duplicates;
pub(crate) mod locations;
pub(crate) mod login;
+128 -16
View File
@@ -31,6 +31,11 @@ pub(crate) struct Viewer {
pub(crate) scroller: gtk4::ScrolledWindow,
pub(crate) picture: gtk4::Picture,
pub(crate) video: gtk4::Video,
video_token: RefCell<Option<String>>,
load_generation: Cell<u64>,
presence_loading: Cell<bool>,
presence_pending: Cell<bool>,
album: Option<String>,
pub(crate) spinner: Spinner,
pub(crate) status: gtk4::Label,
pub(crate) title: gtk4::Label,
@@ -272,12 +277,14 @@ fn viewer_item(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: &str) -> Option<PhotoItem>
/// full-size file, and swap it in — plus its EXIF — when it lands. A video
/// plays in place once its file is down.
pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) {
let generation = viewer.load_generation.get().wrapping_add(1);
viewer.load_generation.set(generation);
viewer.spinner.set_visible(true);
viewer.status.set_visible(false);
viewer.loading.set(true);
*viewer.path.borrow_mut() = None;
clear_info(viewer);
stop_video(viewer);
stop_video(ui, viewer);
viewer.media.set_visible_child_name("photo");
sync_strip(viewer);
reset_zoom(viewer);
@@ -302,17 +309,25 @@ pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) {
None => viewer.picture.set_paintable(gtk4::gdk::Paintable::NONE),
}
let rx = spawn_request(
ui.dirs.control_socket(),
Request::OpenPhoto { uid: uid.clone() },
);
let request = if is_video {
Request::OpenGalleryVideo {
uid: uid.clone(),
private: false,
}
} else {
Request::OpenPhoto { uid: uid.clone() }
};
let rx = spawn_request(ui.dirs.control_socket(), request);
let viewer = viewer.clone();
let ui = ui.clone();
glib::spawn_future_local(async move {
let result = rx.recv().await;
// The user may have moved on while this was in flight; that photo's own
// request owns the viewer now.
if *viewer.uid.borrow() != uid {
if viewer.load_generation.get() != generation {
if let Ok(Ok(Response::GalleryVideo { token, .. })) = result {
close_video(&ui, token);
}
return;
}
viewer.spinner.set_visible(false);
@@ -326,6 +341,14 @@ pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) {
viewer.status.set_visible(true);
};
let path = match result {
Ok(Ok(Response::GalleryVideo { url, token, size })) => {
*viewer.video_token.borrow_mut() = Some(token);
viewer.video.set_file(Some(&gio::File::for_uri(&url)));
viewer.media.set_visible_child_name("video");
sync_strip(&viewer);
show_info(&viewer, Some(size), ExifInfo::default());
return;
}
Ok(Ok(Response::FilePath { path })) => path,
Ok(Ok(Response::Error { message, .. })) => return fail(&message),
Ok(Ok(_)) => return fail(&gettext("Unexpected reply from the Proton Drive service.")),
@@ -481,8 +504,18 @@ fn next_slide(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
/// Stop whatever the player was playing, so stepping off a video (or closing
/// the lightbox) doesn't leave its sound running.
fn stop_video(viewer: &Rc<Viewer>) {
fn close_video(ui: &Ui, token: String) {
let _reply = spawn_request(
ui.dirs.control_socket(),
Request::CloseGalleryVideo { token },
);
}
fn stop_video(ui: &Ui, viewer: &Rc<Viewer>) {
viewer.video.set_media_stream(gtk4::MediaStream::NONE);
if let Some(token) = viewer.video_token.borrow_mut().take() {
close_video(ui, token);
}
}
/// Warm the cache with the photo `delta` steps away, so stepping there is
@@ -1210,6 +1243,43 @@ fn build_strip(ui: &Rc<Ui>) -> (gtk4::ListView, gtk4::SingleSelection) {
///
/// Returns the lightbox's window, for a caller that has to put the page
/// behind it back once it closes.
pub(crate) fn check_photo_viewer(ui: &Rc<Ui>) {
let Some(viewer) = ui.gallery.viewer.borrow().upgrade() else {
return;
};
if !viewer.window.is_visible() {
return;
}
if viewer.presence_loading.replace(true) {
viewer.presence_pending.set(true);
return;
}
let uid = viewer.uid.borrow().clone();
let rx = spawn_request(
ui.dirs.control_socket(),
Request::PhotoPresence {
uid: uid.clone(),
album: viewer.album.clone(),
},
);
let ui = ui.clone();
let viewer = Rc::downgrade(&viewer);
glib::spawn_future_local(async move {
let result = rx.recv().await;
let Some(viewer) = viewer.upgrade() else {
return;
};
viewer.presence_loading.set(false);
if *viewer.uid.borrow() == uid
&& matches!(result, Ok(Ok(Response::PhotoPresence { present: false })))
{
viewer.window.close();
} else if viewer.presence_pending.replace(false) {
check_photo_viewer(&ui);
}
});
}
pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Window {
let parent = ui.stack.root().and_downcast::<gtk4::Window>().unwrap();
@@ -1473,6 +1543,16 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
scroller: scroller.clone(),
picture: picture.clone(),
video,
video_token: RefCell::new(None),
load_generation: Cell::new(0),
presence_loading: Cell::new(false),
presence_pending: Cell::new(false),
album: ui
.gallery
.album
.borrow()
.as_ref()
.map(|album| album.uid.clone()),
spinner,
status: status_label,
title: title_label,
@@ -1515,6 +1595,7 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
toasts,
});
*ui.gallery.viewer.borrow_mut() = Rc::downgrade(&viewer);
let initial_idx = find_photo_index(&ui.gallery.model, &initial_uid).unwrap_or(0);
let capture_time = viewer_item(ui, &viewer, &initial_uid).map_or(0, |item| item.capture_time);
show_photo_position(ui, &viewer, initial_idx, capture_time);
@@ -1700,7 +1781,10 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
}
if let Some(viewer) = keep.borrow_mut().take() {
reveal_photo(&ui_close, &viewer.uid.borrow());
stop_video(&viewer);
viewer
.load_generation
.set(viewer.load_generation.get().wrapping_add(1));
stop_video(&ui_close, &viewer);
disarm_slide(&viewer);
if let Some(source) = viewer.chrome_source.borrow_mut().take() {
source.remove();
@@ -1952,7 +2036,7 @@ fn open_viewer_menu(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
}
menu.section();
// These need the full-size file, which may still be downloading.
if viewer.path.borrow().is_some() {
if viewer.path.borrow().is_some() || viewer.video_token.borrow().is_some() {
let still = viewer.media.visible_child_name().as_deref() == Some("photo");
if still {
// Translators: menu item that puts the photo on the clipboard as an image.
@@ -1999,17 +2083,45 @@ fn open_viewer_menu(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
});
}
fn save_shown_photo(_ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
if let Some(path) = viewer.path.borrow().as_deref() {
let name = viewer.name.borrow();
save_photo_to_disk(viewer, path, name.as_deref().unwrap_or("photo"));
}
fn save_shown_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
with_viewer_file(ui, viewer, |viewer, path, name| {
save_photo_to_disk(viewer, path, name.unwrap_or("photo"))
});
}
fn open_shown_photo(_ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
fn open_shown_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
with_viewer_file(ui, viewer, |viewer, path, name| {
open_with(&viewer.window, path, name)
});
}
fn with_viewer_file(
ui: &Rc<Ui>,
viewer: &Rc<Viewer>,
use_file: impl FnOnce(&Rc<Viewer>, &str, Option<&str>) + 'static,
) {
let name = viewer.name.borrow().clone();
if let Some(path) = viewer.path.borrow().as_deref() {
open_with(&viewer.window, path, viewer.name.borrow().as_deref());
use_file(viewer, path, name.as_deref());
return;
}
if viewer.video_token.borrow().is_none() {
return;
}
let uid = viewer.uid.borrow().clone();
let viewer = viewer.clone();
let rx = spawn_request(ui.dirs.control_socket(), Request::OpenPhoto { uid });
glib::spawn_future_local(async move {
match rx.recv().await {
Ok(Ok(Response::FilePath { path })) => use_file(&viewer, &path, name.as_deref()),
Ok(Ok(Response::Error { message, .. })) => {
viewer.toasts.add_toast(adw::Toast::new(&message))
}
_ => viewer
.toasts
.add_toast(adw::Toast::new(&gettext("Couldn't open the file."))),
}
});
}
fn add_shown_photo_to_album(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
File diff suppressed because it is too large. Load diff
+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
+1
View File
@@ -26,6 +26,7 @@ const STOCK: &[&str] = &[
// Adwaita
"application-x-executable-symbolic",
"audio-x-generic-symbolic",
"changes-prevent-symbolic",
"checkbox-checked-symbolic",
"checkbox-symbolic",
"computer-symbolic",
+7 -2
View File
@@ -432,7 +432,7 @@ the build Fedora 45 and 46 ship as stable, from before oo7's
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
("server: Write item changes to the keyring file"). See
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7).
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `crates/pdfs-core/src/secretservice.rs`
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `proton-auth-rs` (`secret_service.rs`, moved from `crates/pdfs-core/src/secretservice.rs`)
**Repro:** With oo7-daemon at e91b98a, save the session blob, save it again with a new refresh
token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
@@ -988,11 +988,16 @@ timing.
**Where:** not located; the drain's conflict check in `crates/pdfs-fuse/src/drain.rs` is the
first suspect
**Repro:** Only the CI run above. The last steps created `x/z/y/a.txt` (37 bytes), wrote 42
**Repro:** The first CI failure created `x/z/y/a.txt` (37 bytes), wrote 42
bytes into it at offset 20, and brought every link up. Drive then held the file at its first
37 bytes, and the full content was in `x/z/y/a (sync-conflict …).txt`. No other client wrote
to it.
On 2026-11-19, seed 1 of `one-client-echoes` showed the same symptom with delayed,
duplicated, and reordered events. A two-byte overwrite of `x/d` appeared only in a
conflict copy. Local replays passed. The simulation now retains its operation trace
and daemon logs on failure. [CI run](https://github.com/narrrl/proton-drive-linux/actions/runs/44427290348)
**Cause.** Not known. Nothing was lost, since the conflict copy holds the bytes, but the file
conflicted with its own create. B183 and B184 found the same symptom after a lost create
reply.
+63 -3
View File
@@ -11,15 +11,73 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
## [Unreleased]
## [3.8.1] — 2026-11-19
### 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
`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.
- RAW+JPEG grouping, Google Takeout reading, EXIF capture times, look-alike
detection and the offline town lookup now come from `proton-gallery-rs`,
shared with Proton Gallery. No behaviour change.
- The keyring code (one Secret Service connection that reconnects after the provider
restarts, B285, and replacing the session item instead of editing it, B291) now comes
from `proton-auth-rs`, shared with Proton Gallery and Proton Stream. No behaviour change.
- Config, machine-id and mount-failure files are written through `proton-base-rs`'s
atomic writer (temporary file, sync, rename, directory sync). The mount-failure file
is now synced before the rename too, so a crash cannot leave it empty.
## [3.9.0] — 2026-11-19
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
### Added
- **Branding** icons updated, screenshots updated
- Open **Drive galleries** in Photos → Albums to browse saved My files folders and their
subfolders, choose album covers, and manage public links. Saved galleries and
covers sync with Proton Gallery on desktop and Android.
- Unlock hidden albums from the Albums view with your Linux sign-in.
### Changed
- Photos uses Proton Gallery's justified row planner. The Photos viewer starts
and seeks through supported videos without caching the whole original.
- Gallery-hidden albums and their contents are filtered from Photos and Drive
Galleries until unlocked.
- Photo grids defer work for off-screen tiles and keep the viewed photo anchored
during zoom.
### Fixed
- **Cache Eviction** fixed an issue where it didn't scan past pinned files and now also reapplies the limit at startup.
- Unlocking Hidden albums keeps the private view open while its albums load.
- Hovering over an album highlights its card without shading the surrounding grid cell.
## [3.8.1] — 2026-11-19
Schema: **45**. No database migration in this release.
### Changed
- Refreshed the application icon and project artwork, and updated the documentation screenshots.
### Fixed
- The cache skips pinned files when looking for space to reclaim and reapplies the configured
limit when the service starts. Pinned files and recovery data are preserved.
- Trashing a folder waits for queued moves out of it, including moves from nested subfolders.
If a move is blocked by an item or folder already in Trash, Sync and `pdfs sync issues`
identify what to restore before retrying.
- The system tray displays a warning icon when sync needs attention or the session has expired.
- Updated the Proton SDK to 0.12.1 so a fast local clock no longer causes Proton to reject
uploads of new files and photos.
## [3.8.0] — 2026-11-14
@@ -2363,6 +2421,8 @@ First stable release: FUSE files-on-demand mount, sync daemon under `proton-driv
- The outstanding FUSE defects tracked in `docs/BUGS.md`, plus a truncate defect, validated
by a new POSIX compliance suite for the filesystem.
[3.9.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.9.0
[3.8.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.8.1
[3.5.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.5.0
[3.4.1]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.4.1
[3.4.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.4.0
+34
View File
@@ -1,5 +1,39 @@
# Photos
## How Photos is organized
Timeline, Albums, and Places share the same Photos workspace. The Timeline opens
with the media type, Filters, and, where available, **On this day**. Albums
contains the two collections **Proton albums** and **Drive galleries**. Add a
gallery by choosing a folder from **My files**. Opening it or any subfolder
keeps you in Photos. Back or Escape returns to the parent and its scroll
position.
**Hidden albums** opens with your Linux sign-in. The app uses the desktop
polkit prompt, so it needs a running authentication agent and the installed
polkit policy. Existing hidden albums remain hidden after upgrading. This view
includes hidden Proton albums and hidden Drive folders, including folders
inside public galleries. Leaving Hidden albums or switching away from the
window locks it and closes its previews.
For a system package, the policy is installed with the app. For a source build
or a per-user tarball install, have your system administrator install
`packaging/io.narl.proton-drive-linux.policy` (or the corresponding file under the
tarball's `share/polkit-1/actions/`) into the system polkit actions directory.
On NixOS, enable `security.polkit` and install the package system-wide to
register its policy.
GTK pages Timeline, Proton albums, and Places through the Drive daemon's Photos
control requests backed by its SQLite database. Saved Drive galleries come from
the shared Proton Gallery catalog, which the daemon hosts for the signed-in
account. Photos applies that catalog's visibility rules to public queries.
Hidden albums use separate, unlock-gated requests. Thumbnails in the hidden
view are kept in memory and cleared on lock.
Ctrl+mousewheel changes timeline tile size. GTK updates only the changed row
range and keeps the visible photo in place. As you scroll, each new page
updates the last affected section and adds new sections below it.
The **Photos** page of the app shows your Proton Photos library. Photos are stored apart from
My files, so they do not appear in `~/ProtonDrive`.
+2 -1
View File
@@ -75,7 +75,8 @@ PDFS_SIM_SEED=7 RUST_LOG=pdfs_fuse=debug cargo test -p pdfs-fuse --lib \
| `PDFS_SIM_MEASURE` | Run `a_thousand_files_drain_as_fast_on_wifi_as_on_lan`, which times 1,000 files in 100 folders on a LAN and a Wi-Fi profile and prints the times |
A failure is a seed that can be replayed, but the daemon uses real threads, so a race may need
several replays. In CI, the `simulation` job uploads the stacks of a hung run as an artifact.
several replays. In CI, the `simulation` job uploads the failed seed's steps and daemon logs,
along with thread stacks when the watchdog catches a hang.
## Acceptance suite
+5 -2
View File
@@ -9,13 +9,13 @@
# Build + install: cd packaging && makepkg -fi
pkgname=proton-drive-linux
pkgver=3.8.1
pkgver=3.9.0
pkgrel=1
pkgdesc="Unofficial Proton Drive client for Linux: files-on-demand FUSE mount, CLI, GTK4 app + tray"
arch=('x86_64')
url="https://proton-drive.narl.io"
license=('MIT')
depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool')
depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool')
makedepends=('cargo' 'git' 'gettext')
provides=('pdfs')
# Files-on-demand mount + keyring need these at runtime.
@@ -77,6 +77,9 @@ package() {
install -Dm644 "packaging/proton-drive.service" \
"$pkgdir/usr/lib/systemd/user/proton-drive.service"
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
# Translations: compiled from po/ into /usr/share/locale.
po/build.sh "$pkgdir/usr/share/locale"
@@ -7,6 +7,7 @@ pkgbase = proton-drive-for-linux-bin
arch = x86_64
license = MIT
depends = fuse3
depends = polkit
depends = gtk4
depends = libadwaita
depends = webkitgtk-6.0
@@ -8,7 +8,7 @@ arch=('x86_64')
url="https://proton-drive.narl.io"
_repo="https://github.com/narrrl/proton-drive-linux"
license=('MIT')
depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
'hicolor-icon-theme')
optdepends=('perl-image-exiftool: thumbnails for camera RAW files'
'ffmpeg: video thumbnails'
@@ -10,6 +10,7 @@ pkgbase = proton-drive-for-linux-git
makedepends = git
makedepends = gettext
depends = fuse3
depends = polkit
depends = gtk4
depends = libadwaita
depends = webkitgtk-6.0
@@ -8,7 +8,7 @@ arch=('x86_64')
url="https://proton-drive.narl.io"
_repo="https://github.com/narrrl/proton-drive-linux"
license=('MIT')
depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
'hicolor-icon-theme')
makedepends=('cargo' 'git' 'gettext')
optdepends=('perl-image-exiftool: thumbnails for camera RAW files'
@@ -78,6 +78,9 @@ package() {
install -Dm644 packaging/proton-drive.service \
"$pkgdir/usr/lib/systemd/user/proton-drive.service"
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
# Translations: compiled from po/ into /usr/share/locale.
po/build.sh "$pkgdir/usr/share/locale"
@@ -9,6 +9,7 @@ pkgbase = proton-drive-for-linux
makedepends = cargo
makedepends = gettext
depends = fuse3
depends = polkit
depends = gtk4
depends = libadwaita
depends = webkitgtk-6.0
@@ -8,7 +8,7 @@ arch=('x86_64')
url="https://proton-drive.narl.io"
_repo="https://github.com/narrrl/proton-drive-linux"
license=('MIT')
depends=('fuse3' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'dbus' 'gcc-libs' 'glibc'
'hicolor-icon-theme')
makedepends=('cargo' 'gettext')
optdepends=('perl-image-exiftool: thumbnails for camera RAW files'
@@ -73,6 +73,9 @@ package() {
install -Dm644 packaging/proton-drive.service \
"$pkgdir/usr/lib/systemd/user/proton-drive.service"
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
# Translations: compiled from po/ into /usr/share/locale.
po/build.sh "$pkgdir/usr/share/locale"
+1 -1
View File
@@ -8,7 +8,7 @@ release assets:
| Source | What it is |
| --- | --- |
| `Source0` | GitHub's archive of the `v<version>` tag |
| `Source1` | `proton-drive-linux-vendor-<version>.tar.xz`: every crate from `Cargo.lock`, made by `cargo vendor` in `release.yml` |
| `Source1` | `proton-drive-linux-vendor-<version>.tar.xz`: the crates and source mappings generated by `cargo vendor` in `release.yml` |
With the vendored crates the build needs no network, so the COPR project keeps network access
off.
@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE policyconfig PUBLIC "-//freedesktop//DTD polkit Policy Configuration 1.0//EN"
"http://www.freedesktop.org/software/polkit/policyconfig-1.dtd">
<policyconfig>
<action id="io.narl.proton-drive-linux.unlock-hidden-albums">
<description>Unlock Hidden albums in Proton Drive</description>
<message>Authenticate to unlock Hidden albums in Proton Drive</message>
<defaults>
<allow_any>no</allow_any>
<allow_inactive>no</allow_inactive>
<allow_active>auth_self</allow_active>
</defaults>
</action>
</policyconfig>
+5 -1
View File
@@ -15,6 +15,7 @@
webkitgtk_6_0,
libsecret,
dbus,
polkit,
exiftool,
ffmpeg-headless,
withFfmpeg ? true,
@@ -36,6 +37,7 @@ rustPlatform.buildRustPackage {
../../crates
../../po
../../LICENSE
../io.narl.proton-drive-linux.policy
../proton-drive.service
../io.narl.proton-drive-linux.desktop
../io.narl.proton-drive-linux-tray.desktop
@@ -100,6 +102,8 @@ rustPlatform.buildRustPackage {
substituteInPlace $out/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop \
--replace-fail "Exec=pdfs-tray" "Exec=$out/bin/pdfs-tray"
install -Dm644 packaging/io.narl.proton-drive-linux.policy \
$out/share/polkit-1/actions/io.narl.proton-drive-linux.policy
install -Dm644 packaging/proton-drive.service \
$out/lib/systemd/user/proton-drive.service
substituteInPlace $out/lib/systemd/user/proton-drive.service \
@@ -120,7 +124,7 @@ rustPlatform.buildRustPackage {
# it is the setuid wrapper in /run/wrappers/bin.
preFixup = ''
gappsWrapperArgs+=(--suffix PATH : ${
lib.makeBinPath ([ exiftool ] ++ lib.optional withFfmpeg ffmpeg-headless)
lib.makeBinPath ([ exiftool polkit ] ++ lib.optional withFfmpeg ffmpeg-headless)
})
'';
+12 -5
View File
@@ -2,7 +2,7 @@
#
# - From a checkout (local builds and the release workflow). From the repository root:
# rpmbuild -bb packaging/proton-drive-linux.spec --define "git_dir $PWD" ...
# %build needs network so cargo can fetch crates.io (same trade-off as the Arch PKGBUILD).
# %build needs network so Cargo can fetch crates.io and Git dependencies.
# - From the release tarballs (COPR, .github/workflows/copr.yml), when git_dir is not
# defined. Source1 holds every crate, so the build runs offline.
@@ -10,7 +10,7 @@
# Match Arch PKGBUILD `!lto` — LTO has broken some GTK/Rust links in practice.
%global _lto_cflags %{nil}
%{!?version: %global version 3.8.0}
%{!?version: %global version 3.9.0}
%global forge https://github.com/narrrl/proton-drive-linux
# Files come from the checkout, or from the unpacked tag archive.
%global src %{?git_dir}%{!?git_dir:.}
@@ -39,6 +39,7 @@ BuildRequires: glib2-devel
BuildRequires: webkitgtk6.0-devel
BuildRequires: gettext
Requires: polkit
Requires: fuse3
Requires: gtk4
Requires: libadwaita
@@ -72,16 +73,19 @@ system tray and search launcher. Unofficial and not affiliated with Proton AG.
test -f %{git_dir}/Cargo.toml
cp -a %{git_dir}/LICENSE .
%else
# -a 1 unpacks the vendored crates into vendor/ inside the source tree.
# -a 1 unpacks the vendored crates and their source mappings.
%autosetup -n %{name}-%{version} -a 1
mkdir -p .cargo
cat > .cargo/config.toml <<'EOF'
# Older vendor tarballs contained only crates.io dependencies.
if [ ! -f .cargo/config.toml ]; then
mkdir -p .cargo
cat > .cargo/config.toml <<'EOF'
[source.crates-io]
replace-with = "vendored-sources"
[source.vendored-sources]
directory = "vendor"
EOF
fi
%endif
%build
@@ -111,6 +115,8 @@ install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux-tray.desktop \
%{buildroot}%{_sysconfdir}/xdg/autostart/io.narl.proton-drive-linux-tray.desktop
install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux.svg \
%{buildroot}%{_datadir}/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg
install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux.policy \
%{buildroot}/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy
install -D -m0644 %{src}/packaging/proton-drive.service \
%{buildroot}/usr/lib/systemd/user/proton-drive.service
%{src}/po/build.sh %{buildroot}%{_datadir}/locale
@@ -149,6 +155,7 @@ fi
%{_sysconfdir}/xdg/autostart/io.narl.proton-drive-linux-tray.desktop
%{_datadir}/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg
/usr/lib/systemd/user/proton-drive.service
%{_datadir}/polkit-1/actions/io.narl.proton-drive-linux.policy
%{_datadir}/locale/*/LC_MESSAGES/pdfs.mo
%{_datadir}/bash-completion/completions/pdfs
%{_datadir}/zsh/site-functions/_pdfs
+2
View File
@@ -32,6 +32,8 @@ install -Dm644 "$repo/packaging/io.narl.proton-drive-linux-tray.desktop" \
"$root/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop"
install -Dm644 "$repo/packaging/io.narl.proton-drive-linux.svg" \
"$root/share/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg"
install -Dm644 "$repo/packaging/io.narl.proton-drive-linux.policy" \
"$root/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
install -Dm644 "$repo/packaging/proton-drive.service" \
"$root/lib/systemd/user/proton-drive.service"
install -Dm644 "$repo/LICENSE" "$root/share/licenses/proton-drive-linux/LICENSE"
+1
View File
@@ -6,6 +6,7 @@ crates/pdfs-gui/src/app/pages/activity_text.rs
crates/pdfs-gui/src/app/pages/albums.rs
crates/pdfs-gui/src/app/pages/browser.rs
crates/pdfs-gui/src/app/pages/devices.rs
crates/pdfs-gui/src/app/pages/drive_galleries.rs
crates/pdfs-gui/src/app/pages/duplicates.rs
crates/pdfs-gui/src/app/pages/locations.rs
crates/pdfs-gui/src/app/pages/login.rs
+618 -479
View File
File diff suppressed because it is too large. Load diff
+620 -484
View File
File diff suppressed because it is too large. Load diff
+617 -479
View File
File diff suppressed because it is too large. Load diff
+618 -479
View File
File diff suppressed because it is too large. Load diff
+616 -479
View File
File diff suppressed because it is too large. Load diff
+618 -479
View File
File diff suppressed because it is too large. Load diff
+604 -475
View File
File diff suppressed because it is too large. Load diff
+616 -480
View File
File diff suppressed because it is too large. Load diff
+615 -479
View File
File diff suppressed because it is too large. Load diff