Compare commits

...
Author SHA1 Message Date
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 a69ebbdd10 chore(version) 2026-11-19 00:57:31 +01:00
nvrl ddf7335894 fix(cache eviction) fixed a bug which didn't scan past pinned files and now reapplies at startup 2026-11-19 00:54:47 +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
nvrl 2462cb24bd fix(removed old logo) 2026-11-18 01:42:13 +01:00
nvrl a1dd2b5a9b feat(branding) added new icons and branding 2026-11-18 01:35:08 +01:00
Nils Pukropp e9d6d4a907 chore(aur): update packages to 3.8.0 2026-11-16 00:32:51 +00:00
nvrl 6fa91e83f1 Merge pull request #81 from narrrl/chore/release-3.8.0
chore(release): 3.8.0
2026-11-16 01:23:44 +01:00
nvrl f239dffbcc Merge pull request #103 from narrrl/feat/sync-exclusions
fix(gui): show Excluded Files on the Sync page when every folder is o…
2026-11-16 01:01:01 +01:00
nvrl e011a0d89f fix(gui): show Excluded Files on the Sync page when every folder is online only
The group was hidden without a folder set to Synced, so it could not be
found. It now always shows, with the patterns for all folders and Add
Pattern, and says that patterns apply only to folders kept on this
computer.
2026-11-16 00:40:30 +01:00
nvrl f2c4c05f27 Merge pull request #102 from narrrl/feat/sync-exclusions
feat(gui,cli,core): add excluded-file patterns from the Sync page, for all folders or one (#99)
2026-11-16 00:24:11 +01:00
nvrl 8598aff7dd feat(gui,cli,core): add excluded-file patterns from the Sync page, for all folders or one (#99)
The Sync page's Folders view gets an Excluded Files group under the
folder list: one row for the patterns of all synced folders (opens
Preferences → Sync) and one per folder kept on this computer with its
count of own patterns (opens that folder's .pdfsignore editor). Add
Pattern asks for a pattern and where it goes: all synced folders or one
of them.

pdfs-core gains add_folder_pattern/remove_folder_pattern, which edit a
folder's rules line by line and read them again when sync changed the
file in between, and AppDirs::change_ignore_patterns, now shared by the
CLI and Preferences. `pdfs sync ignore list|add|remove` take --folder.
Preferences → Sync repaints from the config each time it opens, so a
pattern added elsewhere shows there.
2026-11-16 00:21:01 +01:00
nvrl 38a8db0e3e Merge pull request #101 from narrrl/feat/tarball-install
feat(packaging): an installable release tarball for immutable distributions (#99)
2026-11-16 00:12:21 +01:00
nvrl db8c0cb382 fix(packaging): use an if for the icon cache update in install.sh (SC2015) 2026-11-15 23:57:01 +01:00
nvrl a7baf2313c feat(packaging): an installable release tarball for immutable distributions (#99)
The release .tar.gz held the four binaries and their translations only,
and the service unit pointed at /usr/bin/pdfs, so it was no install on
its own. It now carries a /usr-like tree (bin, share, the user unit, the
tray's autostart entry) and install.sh, which installs it into ~/.local
without root:

- checks the libraries with ldd and names the packages to install per
  distribution, and that fusermount3 is there and setuid;
- refuses to install next to a package of the client;
- rewrites Exec= and ExecStart= to absolute paths, since ~/.local/bin is
  often not on a session's PATH;
- keeps a manifest, removes what an older version left, restarts a
  running service on update, and --uninstall leaves settings alone.

packaging/tarball/build.sh lays the tarball out and test.sh installs,
updates and uninstalls it in a throwaway home; the release job runs
both, CI runs shellcheck on them. The app looks for its translations in
share/locale beside its own bin directory and starts the tray from there,
so nothing needs PDFS_LOCALEDIR or the PATH. The -bin AUR package takes
every file from the new tarball instead of raw.githubusercontent.com.

INSTALL.md documents the tarball and layering the COPR package on Fedora
Atomic.
2026-11-15 23:57:01 +01:00
nvrl 7e0d7d020e Merge pull request #100 from narrrl/feat/settings-editor
feat(gui,core,cli): edit excluded files, open-with rules and the launcher in Preferences (#99)
2026-11-15 23:56:16 +01:00
nvrl 0df4b3c5f9 feat(gui,core,cli): edit excluded files, open-with rules and the launcher in Preferences (#99)
Preferences gains two pages for the config.json settings that had no
place in the app:

- Sync: the patterns every synced folder leaves out (own patterns, and
  each built-in one on or off), and what the conflict sweep may do.
- Apps: which program opens which kind of file (open_with), and how the
  search launcher opens (prompt).

Each synced folder kept on this computer gets "Excluded Files…" in its
menu for its own .pdfsignore: checked as typed, "Check a path" says
which rule decides, and a version changed elsewhere is never written
over without asking. `pdfs sync ignore list|add|remove|reset|check` does
the same from a terminal, and `--page preferences-sync` (and -apps,
-storage) opens Preferences at a page.

Every writer of config.json now goes through AppDirs::update_config,
which reads, changes and writes under an flock on config.json.lock, so
the app, the tray and the daemon no longer undo each other's change
(B292). The opener reads its rules on each open, so a new rule applies
without a restart.

The built-in ignore list also leaves out what Nextcloud, Dropbox and
Syncthing leave out: desktop.ini, .directory, trash folders, NFS/FUSE
leftovers, partial downloads, Kate swap and office lock files.
2026-11-15 23:03:58 +01:00
nvrl 14b9e0fe64 Merge pull request #98 from narrrl/fix/78-keyring-replace
fix(core): save the session by replacing its keyring item (#78, B291)
2026-11-15 20:46:39 +01:00
nvrl 64864562ef fix(core): save the session by replacing its keyring item (#78, B291)
Fedora 45 and 46 ship oo7-daemon 0.7.0~beta^1.e91b98a, which applies
SetSecret only in memory (fixed upstream in 7fb11dd, after that
snapshot). Every token rotation saved there was lost at the next
reboot, and the next start found a spent refresh token.

An existing entry is now written with CreateItem and replace, in the
old item's collection with its label and attributes, which that build
persists. A duplicate left behind is removed; the first save, a locked
item, ambiguity or any failure fall back to SetSecret. No prompt is
ever shown on this path.

The daemon also logs a short fingerprint of the refresh token at each
resume and each save, so a log across a reboot shows whether the
keyring returned the last token saved.
2026-11-15 20:31:43 +01:00
nvrl ce3bfa217d Merge pull request #97 from narrrl/fix/db-lock-fork-race
fix(core): retry the database lock briefly before calling it another daemon (B290)
2026-11-15 19:44:24 +01:00
nvrl 593df5c401 fix(core): retry the database lock briefly before calling it another daemon (B290)
A child spawned by another thread holds a copy of the lock descriptor
between its fork and its exec, so a reopen right after a drop could be
refused. Seen once in CI in
what_a_create_sent_outlives_a_newer_blob_its_trash_and_a_restart.
2026-11-15 19:42:22 +01:00
nvrl fd6b2d3e85 Merge pull request #96 from narrrl/chore/screenshots
chore: retake the screenshots from a demo account, by script
2026-11-15 19:20:45 +01:00
nvrl 34902390f3 chore: retake the screenshots from a demo account, by script
scripts/screenshots.sh builds the app and runs it in a headless cage
compositor against crates/pdfs-core/examples/demo_daemon.rs, a stand-in
daemon that answers the control socket with an invented account. HOME,
the XDG directories, the session bus and the keyring are throwaway ones,
and the demo daemon refuses to run outside them.

The old screenshots showed real folder names, paths and photo places.
All nine are retaken from the demo data.

pdfs-app --page also takes albums, places, places-map and sync-folders,
which the script uses to reach those views.
2026-11-15 19:20:07 +01:00
nvrl 1dcf7c84ca Merge pull request #95 from narrrl/fix/takeout-import-94
fix(fuse,core,gui,cli): resumable, robust Google Photos import (#94)
2026-11-15 17:25:39 +01:00
nvrl a05772aa13 docs: keep the SDK 0.12.0 review out of the wiki 2026-11-15 17:23:45 +01:00
nvrl 2f2fe96cdf fix(fuse,core,gui,cli): resumable, robust Google Photos import (#94)
A Takeout import cut short by a restart could never be resumed: the
duplicate check failed on the draft the interrupted upload left behind
("invalid type: null, expected a string"). SDK 0.12.0 skips such drafts,
lets the import replace them across logins, and removes the draft of a
failed upload (B285, B286).

The import keeps its archives and outcome in the state directory, so a
run the service did not finish is reported as interrupted and can be
resumed from the app or with `pdfs import-google-photos --resume`. An
unreadable archive is left out instead of failing the scan, a failure
keeps its counts and still files albums, and a cancel or shutdown is
only reported when work was left undone (B287).

ImportStatus carries the phase, its progress, the running counts and
what can be resumed; the summary says dry_run, to_upload and
error_kind. The app shows these in the user's language, and --wait
prints progress. An empty gallery waits for a timeline refresh already
running instead of starting a second one.

The scan imports only the Photos service of an export, reads geoData
into the photo's Location, pairs live and motion photos (.MOV, .MP) with
their stills, and dates a photo by name and EXIF before Google's upload
time (B288).
2026-11-15 17:17:47 +01:00
nvrl 2ec3b7ff62 Merge pull request #93 from narrrl/fix/78-reconnect-secret-service
fix(core): reconnect to the Secret Service after it restarts
2026-11-15 16:23:54 +01:00
nvrl 38bd282d3a fix(core): reconnect to the Secret Service after it restarts
The keyring store keeps one D-Bus connection and one Secret Service
session for the whole process, and was installed once. The session lives
only in the provider's memory, so after the provider restarts every read
and write on it fails with NoSession until the process restarts. oo7,
the provider on Fedora 45, restarts on failure and can be replaced. A
daemon that met this kept every later token refresh only in memory and
the kernel keyring, and the next cold boot found the spent refresh token
(issue #78, B285).

Every keyring call now goes through with_keyring_entry. A platform
failure drops the store, unless another thread already replaced it, and
the call is made once more on a new connection. A locked keyring, a
dismissed prompt and a missing entry come back unchanged.

Reproduced against gnome-keyring 51.1 and oo7 0.7.1 restarted with
--replace in a throwaway session bus; the ignored test
real_secret_service_survives_a_provider_restart passes against both.

Refs #78
2026-11-14 19:17:11 +01:00
nvrl d773ba15d3 Merge pull request #92 from narrrl/feat/audio-cover-thumbnails
feat(gui,fuse,core): album covers for songs, thumbnails that appear live
2026-11-14 17:44:22 +01:00
nvrl d93982baa9 feat(gui,fuse,core): album covers as song thumbnails
A song in a listing showed a generic icon, and the player a music note.
Both now show the song's cover: the picture in its tags, read with
lofty, or else a cover, folder, front or album image in its folder.

Only the tags are downloaded. A song up to 4 MiB comes whole. A larger
one brings the ID3v2 tag or the FLAC metadata blocks at its start, an
M4A's moov box, the first 4 MiB of an Ogg file, and the last 4 MiB for
formats that keep their tags at the end. The parts are laid out in a
sparse staging file at their own offsets, as video samples are.

A folder cover comes from that image's cached thumbnail, the thumbnail
its uploader attached, or the image itself. It is stored under the song.
Uploads of songs carry their embedded cover as the Drive thumbnail.
2026-11-14 16:48:08 +01:00
nvrl 3f5001b2d2 fix(gui,fuse,core): fill in thumbnails without reopening the folder
Build thumbnails cancelled the requests of the tiles on screen, and those
tiles stayed blank until the folder was opened again, or the whole
recursive build ended.

The daemon now publishes a new Topic::Thumbnails whenever a batch made
at least one thumbnail. The app keeps the tiles still showing their icon
across a cancel, and asks for them again on that event, whatever page is
open. Older front-ends read the topic as Unknown, and older daemons never
send it.
2026-11-14 16:27:57 +01:00
nvrl 2308021aa2 Merge pull request #91 from narrrl/feat/media-player
feat(gui): play videos and music in the app
2026-11-14 15:58:17 +01:00
nvrl 602f1c9577 feat(gui): play videos and music in the app
Opening a video or a song in My files, by a double-click or Open, now
plays it in an in-app player window, streamed from the mount as before.
Open With… is the way to another player, and the separate Play item is
gone. A file GStreamer can't play shows the error with Open With….

Both that player and the Photos lightbox share the new widgets/player.rs:
a fullscreen button, fullscreen on a double-click, Repeat in the ⋮ menu,
K to play and pause, J/L or Shift+arrows to jump 10 seconds, M to mute,
and a volume that carries over between videos. The lightbox's thumbnail
strip stays off a video, where it covered the seek bar.
2026-11-14 15:57:10 +01:00
nvrl 9132c7ebd5 Merge pull request #90 from narrrl/feat/photos-drag-out
feat(gui): drag photos out of the timeline, upload progress bar
2026-11-14 15:44:55 +01:00
nvrl 94304ccc1a Merge pull request #89 from narrrl/fix/78-retain-unsaved-session-tokens
fix(core): retain unsaved session tokens
2026-11-14 15:37:44 +01:00
nvrl 74cd6fd2a9 fix(gui): keep paging the timeline when zoomed out onto one screen
Zoomed all the way out, a 200-photo page fits on one screen. With
nothing to scroll, the scroll handler never asked for the next page and
the timeline stopped after the first rows. Ask for more whenever the
content no longer fills a screen and a half, also after a zoom step or
a resize, not only when a page lands.
2026-11-14 15:33:41 +01:00
nvrl 4b669168ee feat(gui): drag photos out of the timeline, upload progress bar
- A drag that starts on a selected tile carries the selection out as a
  text/uri-list. PhotoDrag, a gdk::ContentProvider, downloads the photos
  only when the receiver reads the list, and hands over hard links (or
  copies) under their Drive names in the user cache; copies older than
  a day are pruned. Drag-select steps aside for such a drag, and the
  timeline's own drop target ignores drags from inside the app.
- Uploading several photos shows "Uploading 3 of 12 items…" with a
  progress bar under the Photos header, replacing the start toast.
  Photo uploads report no byte progress from the daemon, so the bar
  counts files; per-tile rings would need that first.
2026-11-14 15:25:26 +01:00
nvrl ba5b6a8bf2 fix(core): retain unsaved session tokens
Retry token persistence when the keyring reports a missing session.
oo7 can hide locked entries, so discarding the pending rotation leaves
a spent refresh token in the saved session.

Refs #78
2026-11-14 15:18:27 +01:00
nvrl 3295eda1f0 Merge pull request #88 from narrrl/feat/photos-drag-upload
Feat/photos drag upload
2026-11-14 14:38:24 +01:00
nvrl 41212efdf3 feat(gui,fuse,core): share photos, copy image, thumbnail strip in the viewer
- Share… in the grid's photo menu and the viewer's ⋮ menu opens the Share
  dialog by uid. The daemon accepts a uid from the Photos timeline for
  sharing (resolve_shareable), since the photos volume is in no mount.
  Photos in an album someone else shared are not offered.
- Copy Image (Ctrl+C) puts the shown still on the clipboard. The viewer
  has its own toast overlay, so this and Save a Copy confirm over it
  instead of behind it.
- A thumbnail strip along the viewer's bottom edge, on the gallery model,
  marks the shown photo and jumps on click. Several pictures can now
  wait for one thumbnail, so the strip and the grid tile don't steal it
  from each other.
- PhotoItem carries place_id (serde default); the line under the
  viewer's title reads "Berlin · 12 of 340".
2026-11-14 13:58:25 +01:00
nvrl 5f0b15fe70 fix(gui): a photo viewer bar that reads on any photo
The bar's white-on-translucent-white buttons vanished over a bright photo,
and eight look-alike icons, a floppy disk and an open-document glyph among
them, left the user guessing. The bar now holds the favorite, the details
and a menu with Slideshow, Save a Copy, Open With, Add to Album, Show on
Map and Move to Trash, on dark discs that read over white and black
alike.

A shot stored as more than one file shows a labelled pill ("RAW", "Live",
"2 of 3") instead of a paged icon, lit while the second file is shown.
The title is the localized full date instead of a raw timestamp.

Delete asks first, as the grid does: the dialog opens over the viewer,
and the album prompts can open there too. Alt+Left closes the viewer and
F10 opens the menu; the shortcuts window lists F5, F10 and Alt+Left.
2026-11-14 13:37:50 +01:00
nvrl 033c8d3d71 Merge pull request #86 from narrrl/fix/keep-place-when-navigating
fix(gui): keep the user's place when navigating
2026-11-14 12:57:35 +01:00
nvrl 7d445bb02c Merge pull request #84 from narrrl/feat/video-thumbnails
feat(gui,fuse,core): video thumbnails in file views
2026-11-14 03:43:36 +01:00
135 changed files with 30225 additions and 44996 deletions

No files matched your search

+11 -5
View File
@@ -44,6 +44,9 @@ jobs:
- name: Formatting - name: Formatting
run: cargo fmt --all -- --check run: cargo fmt --all -- --check
- name: Shell scripts of the release tarball
run: shellcheck packaging/tarball/*.sh
- name: Lints - name: Lints
run: cargo clippy --workspace --all-targets --locked -- -D warnings run: cargo clippy --workspace --all-targets --locked -- -D warnings
@@ -102,14 +105,17 @@ jobs:
- name: Simulation runs - name: Simulation runs
run: 'cargo test -p pdfs-fuse --lib --locked sim:: -- --ignored --test-threads=1' 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 # Retain the operation trace and daemon logs for the failing seed, plus
# state; without them a hang that does not replay cannot be told apart. # every daemon thread's stack if the watchdog caught a hang.
- name: Keep the stacks of a hung run - name: Keep simulation failure diagnostics
if: failure() if: failure()
uses: actions/upload-artifact@v7 uses: actions/upload-artifact@v7
with: with:
name: simulation-stacks name: simulation-diagnostics
path: /tmp/pdfs-sim-*/stacks.txt path: |
/tmp/pdfs-sim-*/steps.log
/tmp/pdfs-sim-*/daemon.log
/tmp/pdfs-sim-*/stacks.txt
if-no-files-found: ignore if-no-files-found: ignore
# Keeps the release-profile dependencies cached on main, where the release # Keeps the release-profile dependencies cached on main, where the release
+13 -13
View File
@@ -119,23 +119,22 @@ jobs:
echo "VERSION=$VERSION" >> $GITHUB_ENV echo "VERSION=$VERSION" >> $GITHUB_ENV
echo "Building version: $VERSION" echo "Building version: $VERSION"
- name: Package raw binaries (.tar.gz) # Binaries plus everything around them, with install.sh for a home
# directory install (immutable distributions, anything without a package).
- name: Package the installable tarball (.tar.gz)
run: | run: |
mkdir -p dist/binaries tarball=$(packaging/tarball/build.sh target/release "${{ env.VERSION }}" .)
cp target/release/pdfs dist/binaries/ packaging/tarball/test.sh "$tarball"
cp target/release/pdfs-tray dist/binaries/
cp target/release/pdfs-app dist/binaries/
cp target/release/pdfs-prompt dist/binaries/
po/build.sh dist/binaries/locale
# Create tarball
tar -czf proton-drive-linux-${{ env.VERSION }}-x86_64.tar.gz -C dist/binaries .
# Every crate the build needs, so COPR can build the spec without network. # Every crate the build needs, so COPR can build the spec without network.
- name: Package vendored crates (.tar.xz) - name: Package vendored crates (.tar.xz)
run: | run: |
cargo vendor --locked dist/vendor > /dev/null mkdir -p dist/.cargo
tar -cJf proton-drive-linux-vendor-${{ env.VERSION }}.tar.xz -C dist vendor (
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) - name: Package Debian package (.deb)
run: | run: |
@@ -157,6 +156,7 @@ jobs:
cp packaging/io.narl.proton-drive-linux.desktop deb/usr/share/applications/ 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-tray.desktop deb/etc/xdg/autostart/
cp packaging/io.narl.proton-drive-linux.svg deb/usr/share/icons/hicolor/scalable/apps/ 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 packaging/proton-drive.service deb/usr/lib/systemd/user/
cp LICENSE deb/usr/share/licenses/proton-drive-linux/ cp LICENSE deb/usr/share/licenses/proton-drive-linux/
po/build.sh deb/usr/share/locale po/build.sh deb/usr/share/locale
@@ -176,7 +176,7 @@ jobs:
Priority: optional Priority: optional
Architecture: amd64 Architecture: amd64
Maintainer: Nils Pukropp <contact@narl.io> 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} Installed-Size: ${INSTALLED_SIZE}
Homepage: https://proton-drive.narl.io Homepage: https://proton-drive.narl.io
Description: Unofficial Proton Drive client for Linux Description: Unofficial Proton Drive client for Linux
Generated
+149 -12
View File
@@ -49,6 +49,7 @@ dependencies = [
"cipher 0.5.2", "cipher 0.5.2",
"cpubits", "cpubits",
"cpufeatures 0.3.1", "cpufeatures 0.3.1",
"zeroize",
] ]
[[package]] [[package]]
@@ -77,6 +78,7 @@ dependencies = [
"ctr 0.10.1", "ctr 0.10.1",
"ctutils", "ctutils",
"ghash 0.6.0", "ghash 0.6.0",
"zeroize",
] ]
[[package]] [[package]]
@@ -1114,6 +1116,12 @@ dependencies = [
"syn 2.0.119", "syn 2.0.119",
] ]
[[package]]
name = "data-encoding"
version = "2.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
[[package]] [[package]]
name = "dbl" name = "dbl"
version = "0.3.2" version = "0.3.2"
@@ -1872,6 +1880,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5" checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"
dependencies = [ dependencies = [
"polyval 0.7.3", "polyval 0.7.3",
"zeroize",
] ]
[[package]] [[package]]
@@ -2231,6 +2240,12 @@ version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
[[package]]
name = "httpdate"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
[[package]] [[package]]
name = "hybrid-array" name = "hybrid-array"
version = "0.4.15" version = "0.4.15"
@@ -2254,6 +2269,7 @@ dependencies = [
"http", "http",
"http-body", "http-body",
"httparse", "httparse",
"httpdate",
"itoa", "itoa",
"pin-project-lite", "pin-project-lite",
"smallvec", "smallvec",
@@ -2902,6 +2918,32 @@ dependencies = [
"scopeguard", "scopeguard",
] ]
[[package]]
name = "lofty"
version = "0.25.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35d45c446382e04663705aa8e786157f64ef1fa85755d410121ffbf08f54b0db"
dependencies = [
"byteorder",
"data-encoding",
"flate2",
"lofty_attr",
"log",
"ogg_pager",
"paste",
]
[[package]]
name = "lofty_attr"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdbca1b60ba7cea959ffc84ac27f3dbdbacd6dfda168c7eabbc00e48654bb9fd"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]] [[package]]
name = "log" name = "log"
version = "0.4.35" version = "0.4.35"
@@ -3323,6 +3365,15 @@ dependencies = [
"subtle", "subtle",
] ]
[[package]]
name = "ogg_pager"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "166611b491f939446e64c6be930843a31eb8e6798204ec3e9f57e084c18e7446"
dependencies = [
"byteorder",
]
[[package]] [[package]]
name = "once_cell" name = "once_cell"
version = "1.21.4" version = "1.21.4"
@@ -3541,7 +3592,7 @@ checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
[[package]] [[package]]
name = "pdfs-cli" name = "pdfs-cli"
version = "3.8.0" version = "3.9.0"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"clap", "clap",
@@ -3558,60 +3609,71 @@ dependencies = [
[[package]] [[package]]
name = "pdfs-core" name = "pdfs-core"
version = "3.8.0" version = "3.9.0"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"base64 0.23.1", "base64 0.23.1",
"chrono", "chrono",
"dbus-secret-service",
"dbus-secret-service-keyring-store", "dbus-secret-service-keyring-store",
"directories", "directories",
"ignore", "ignore",
"kamadak-exif",
"keyring-core", "keyring-core",
"libc", "libc",
"parking_lot 0.13.0", "parking_lot 0.13.0",
"proton-drive-rs", "proton-drive-rs",
"proton-gallery-rs",
"proton-sdk", "proton-sdk",
"rusqlite", "rusqlite",
"serde", "serde",
"serde_json", "serde_json",
"sha1 0.11.0",
"sha2 0.11.1", "sha2 0.11.1",
"shell-words",
"thiserror 2.0.21", "thiserror 2.0.21",
"tokio", "tokio",
"tracing", "tracing",
"zeroize", "zeroize",
"zip",
] ]
[[package]] [[package]]
name = "pdfs-fuse" name = "pdfs-fuse"
version = "3.8.0" version = "3.9.0"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"base64 0.23.1", "base64 0.23.1",
"fuser", "fuser",
"futures", "futures",
"getrandom 0.4.3",
"http-body-util",
"hyper",
"hyper-util",
"image", "image",
"libc", "libc",
"lofty",
"notify", "notify",
"parking_lot 0.13.0", "parking_lot 0.13.0",
"pdfs-core", "pdfs-core",
"proton-drive-rs", "proton-drive-rs",
"proton-gallery-app-rs",
"proton-gallery-rs",
"rustix",
"serde",
"serde_json", "serde_json",
"sha1 0.11.0", "sha1 0.11.0",
"tokio", "tokio",
"tracing", "tracing",
"tracing-subscriber", "tracing-subscriber",
"zeroize",
"zip", "zip",
] ]
[[package]] [[package]]
name = "pdfs-gui" name = "pdfs-gui"
version = "3.8.0" version = "3.9.0"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"async-channel", "async-channel",
"base64 0.23.1",
"gettext-rs", "gettext-rs",
"gtk4", "gtk4",
"kamadak-exif", "kamadak-exif",
@@ -3619,6 +3681,7 @@ dependencies = [
"libadwaita", "libadwaita",
"pangocairo", "pangocairo",
"pdfs-core", "pdfs-core",
"proton-gallery-rs",
"reqwest", "reqwest",
"serde", "serde",
"serde_json", "serde_json",
@@ -3780,6 +3843,7 @@ dependencies = [
"cpubits", "cpubits",
"cpufeatures 0.3.1", "cpufeatures 0.3.1",
"universal-hash 0.6.1", "universal-hash 0.6.1",
"zeroize",
] ]
[[package]] [[package]]
@@ -3848,9 +3912,9 @@ dependencies = [
[[package]] [[package]]
name = "proton-drive-rs" name = "proton-drive-rs"
version = "0.11.0" version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14a22e621abbc1c61b4640728a7de969c16b66d5d983b59c638d501fda25a7b9" checksum = "d05ad4be849ce2104759631063dd06867fbe6b6f0e5c37a172a84b5a90203fa7"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"base64 0.23.1", "base64 0.23.1",
@@ -3875,10 +3939,76 @@ dependencies = [
] ]
[[package]] [[package]]
name = "proton-sdk" name = "proton-gallery-app-rs"
version = "0.11.0" version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd55a5e8b6600f3aa282ebbdf13ff366431ff9aae84d4eb20b0ef06d598919fe" 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.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc9c9bbb76a5fba4071ee90de4aada71c292c0e408024ddfb04a12869291404a"
dependencies = [
"aes-gcm 0.11.1",
"async-trait",
"getrandom 0.4.3",
"hex",
"kamadak-exif",
"rusqlite",
"serde",
"serde_json",
"sha2 0.11.1",
"tempfile",
"thiserror 2.0.21",
"tokio",
"tokio-util",
"tracing",
"zeroize",
"zip",
]
[[package]]
name = "proton-sdk"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80c381e9066c0bca3c32597df2e902eecaa4c6e05e202e70ec9d0ac2eec78bfe"
dependencies = [ dependencies = [
"aes-gcm 0.11.1", "aes-gcm 0.11.1",
"async-trait", "async-trait",
@@ -4761,6 +4891,12 @@ dependencies = [
"lazy_static", "lazy_static",
] ]
[[package]]
name = "shell-words"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
[[package]] [[package]]
name = "shlex" name = "shlex"
version = "2.0.1" version = "2.0.1"
@@ -5140,6 +5276,7 @@ dependencies = [
"bytes", "bytes",
"futures-core", "futures-core",
"futures-sink", "futures-sink",
"futures-util",
"libc", "libc",
"pin-project-lite", "pin-project-lite",
"tokio", "tokio",
+14 -3
View File
@@ -3,7 +3,7 @@ resolver = "2"
members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"] members = ["crates/pdfs-core", "crates/pdfs-fuse", "crates/pdfs-cli", "crates/pdfs-gui"]
[workspace.package] [workspace.package]
version = "3.8.0" version = "3.9.0"
edition = "2024" edition = "2024"
license = "MIT" license = "MIT"
authors = ["Nils Pukropp <contact@narl.io>"] authors = ["Nils Pukropp <contact@narl.io>"]
@@ -15,8 +15,10 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
categories = ["filesystem", "command-line-utilities"] categories = ["filesystem", "command-line-utilities"]
[workspace.dependencies] [workspace.dependencies]
proton-sdk = { version = "0.11.0" } proton-sdk = { version = "0.12.1" }
proton-drive-rs = { version = "0.11.0" } proton-drive-rs = { version = "0.12.1" }
proton-gallery-app-rs = "0.1.0"
proton-gallery-rs = "0.1.1"
chrono = { version = "0.4", default-features = false, features = ["std"] } chrono = { version = "0.4", default-features = false, features = ["std"] }
# Internal crates. # Internal crates.
@@ -39,6 +41,8 @@ tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-subscriber = { version = "0.3", features = ["env-filter"] }
directories = "6" directories = "6"
ignore = "0.4" ignore = "0.4"
# Command lines typed into Preferences, split and shown the way a shell would.
shell-words = "1"
sha2 = "0.11" sha2 = "0.11"
# Google Takeout exports are zip sets; the importer reads their central # Google Takeout exports are zip sets; the importer reads their central
# directories and streams entries out without extracting to disk first. # directories and streams entries out without extracting to disk first.
@@ -50,12 +54,19 @@ sha1 = "0.11"
# formats a camera or phone actually produces — the rest of the crate's codecs # formats a camera or phone actually produces — the rest of the crate's codecs
# would be dead weight in the daemon. # would be dead weight in the daemon.
image = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp", "gif", "tiff", "bmp", "rayon"] } image = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp", "gif", "tiff", "bmp", "rayon"] }
# Cover pictures of songs, read from their tags (ID3, FLAC, Ogg, MP4, APE) for
# the song's thumbnail. Its default feature is required: 0.25 does not build
# without it.
lofty = "0.25"
rusqlite = { version = "0.41", features = ["bundled"] } rusqlite = { version = "0.41", features = ["bundled"] }
# keyring 4 split into `keyring-core` plus per-platform stores. The libdbus # keyring 4 split into `keyring-core` plus per-platform stores. The libdbus
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and # 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. # with no `target` it matches items v3 wrote, so existing logins survive.
keyring-core = "1" keyring-core = "1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] } dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
dbus-secret-service = { version = "4.1", features = ["crypto-rust"] }
clap = { version = "4", features = ["derive"] } clap = { version = "4", features = ["derive"] }
# `unstable-dynamic`: Tab calls `pdfs` back, so arguments complete from the # `unstable-dynamic`: Tab calls `pdfs` back, so arguments complete from the
# running service. Only `pdfs-cli/src/complete.rs` uses it. # running service. Only `pdfs-cli/src/complete.rs` uses it.
+3 -2
View File
@@ -1,6 +1,6 @@
<div align="center"> <div align="center">
<img src="images/logo.svg" alt="" width="112" height="112"> <a href="images/logo.svg"><img src="images/logo.svg" alt="Proton Drive for Linux icon" width="128" height="128"></a>
# Proton Drive for Linux # Proton Drive for Linux
@@ -77,7 +77,8 @@ scriptable CLI.
| Arch Linux | [`proton-drive-for-linux`](https://aur.archlinux.org/packages/proton-drive-for-linux) (also `-bin` and `-git`) in the AUR | | Arch Linux | [`proton-drive-for-linux`](https://aur.archlinux.org/packages/proton-drive-for-linux) (also `-bin` and `-git`) in the AUR |
| Debian, Ubuntu 24.04 or newer | `.deb` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest) | | Debian, Ubuntu 24.04 or newer | `.deb` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest) |
| NixOS | The flake in this repository: see [Installation → NixOS](docs/INSTALL.md#nixos-flake) | | NixOS | The flake in this repository: see [Installation → NixOS](docs/INSTALL.md#nixos-flake) |
| Anything else | [Build from source](docs/INSTALL.md#build-from-source) | | Fedora Atomic (Silverblue, Kinoite, Bazzite, Bluefin) | The COPR repository, layered with `rpm-ostree`: see [Installation → Fedora Atomic](docs/INSTALL.md#fedora-atomic-silverblue-kinoite-bazzite-bluefin) |
| Anything else, immutable ones included | `.tar.gz` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest), installed into your home folder by its `install.sh`: see [Installation → Other distributions](docs/INSTALL.md#other-distributions), or [build from source](docs/INSTALL.md#build-from-source) |
**Fedora** **Fedora**
+428 -40
View File
@@ -15,8 +15,8 @@ use pdfs_core::cache::ContentCache;
use pdfs_core::config::AppDirs; use pdfs_core::config::AppDirs;
use pdfs_core::control::{ use pdfs_core::control::{
ConflictKeep, ErrorKind, LinkChange, MountKind, RefreshScope, Request as CtlRequest, ConflictKeep, ErrorKind, LinkChange, MountKind, RefreshScope, Request as CtlRequest,
Response as CtlResponse, RestoreItem as CtlRestoreItem, ShareEntryKind, SyncIssue, SyncPhase, Response as CtlResponse, RestoreItem as CtlRestoreItem, ShareEntryKind, SyncFolderInfo,
daemon_outdated, pending_summary, SyncIssue, SyncPhase, daemon_outdated, pending_summary,
}; };
use pdfs_core::db::Db; use pdfs_core::db::Db;
use pdfs_core::service; use pdfs_core::service;
@@ -228,14 +228,19 @@ enum Command {
/// numbered parts, and a photo's metadata often sits in a different part /// numbered parts, and a photo's metadata often sits in a different part
/// than the photo. Albums in the export are recreated as Proton albums, and /// than the photo. Albums in the export are recreated as Proton albums, and
/// photos already on the account (same name and same content) are skipped, /// photos already on the account (same name and same content) are skipped,
/// so an interrupted import can simply be run again. /// so an interrupted import can simply be run again, or resumed with
/// `--resume` without naming the archives again.
ImportGooglePhotos { ImportGooglePhotos {
/// The export's `.zip` files (e.g. `takeout-*.zip`). /// The export's `.zip` files (e.g. `takeout-*.zip`).
#[arg(required = true, value_hint = ValueHint::FilePath)] #[arg(required_unless_present = "resume", value_hint = ValueHint::FilePath)]
archives: Vec<PathBuf>, archives: Vec<PathBuf>,
/// Report what would be imported without uploading anything. /// Report what would be imported without uploading anything.
#[arg(long)] #[arg(long, conflicts_with = "resume")]
dry_run: bool, dry_run: bool,
/// Start the last import again with the same archives, after it was
/// interrupted, stopped or failed.
#[arg(long, conflicts_with = "archives")]
resume: bool,
/// Stay attached and print progress until the import finishes. /// Stay attached and print progress until the import finishes.
#[arg(long)] #[arg(long)]
wait: bool, wait: bool,
@@ -746,6 +751,42 @@ enum ConflictCmd {
}, },
} }
/// `pdfs sync ignore`: the patterns in `ignore_patterns`, for every synced
/// folder, or with `--folder` the ones in that folder's own `.pdfsignore`.
#[derive(Subcommand, Debug)]
enum IgnoreCmd {
/// List the patterns every synced folder leaves out, or one folder's own.
List {
/// List the own patterns of the synced folder holding this path.
#[arg(long, value_hint = ValueHint::DirPath)]
folder: Option<PathBuf>,
},
/// Leave out files matching a gitignore-style pattern, e.g. `*.db` or `build/`.
Add {
/// The pattern; end it with `/` to match folders only.
pattern: String,
/// Add it only for the synced folder holding this path.
#[arg(long, value_hint = ValueHint::DirPath)]
folder: Option<PathBuf>,
},
/// Stop leaving out files matching a pattern.
Remove {
/// The pattern, as `sync ignore list` shows it.
pattern: String,
/// Remove it from the own patterns of the synced folder holding this path.
#[arg(long, value_hint = ValueHint::DirPath)]
folder: Option<PathBuf>,
},
/// Go back to the built-in patterns.
Reset,
/// Say whether a file in a synced folder is synced, and which pattern decides.
Check {
/// A file or folder inside a synced folder.
#[arg(value_hint = ValueHint::AnyPath)]
path: PathBuf,
},
}
#[derive(Subcommand)] #[derive(Subcommand)]
enum SyncCmd { enum SyncCmd {
/// Add a local folder to this machine's device and upload its contents. /// Add a local folder to this machine's device and upload its contents.
@@ -844,6 +885,11 @@ enum SyncCmd {
#[arg(add = ArgValueCandidates::new(complete::queue_id))] #[arg(add = ArgValueCandidates::new(complete::queue_id))]
id: Option<i64>, id: Option<i64>,
}, },
/// Show or change the patterns every synced folder leaves out, or check a path.
Ignore {
#[command(subcommand)]
action: IgnoreCmd,
},
/// Switch a folder between full-copy sync and on-demand (FUSE, no local storage). /// Switch a folder between full-copy sync and on-demand (FUSE, no local storage).
Mode { Mode {
/// Synced-folder id (from `sync list`). /// Synced-folder id (from `sync list`).
@@ -1030,8 +1076,9 @@ fn main() -> Result<()> {
Command::ImportGooglePhotos { Command::ImportGooglePhotos {
archives, archives,
dry_run, dry_run,
resume,
wait, wait,
} => cmd_import_google_photos(archives, dry_run, wait), } => cmd_import_google_photos(archives, dry_run, resume, wait),
Command::RedatePhotos { Command::RedatePhotos {
dry_run, dry_run,
limit, limit,
@@ -1318,6 +1365,7 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
SyncCmd::Issues => return cmd_sync_issues(), SyncCmd::Issues => return cmd_sync_issues(),
SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest), SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest),
SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down), SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down),
SyncCmd::Ignore { action } => return cmd_sync_ignore(action),
SyncCmd::Discard { id, yes } => { SyncCmd::Discard { id, yes } => {
if !yes { if !yes {
confirm(&format!( confirm(&format!(
@@ -1463,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 \ "you can no longer change this on Proton Drive, for example because a share was \
revoked. Save a copy to keep the content." revoked. Save a copy to keep the content."
} }
SyncIssue::Trashed => "restore the item or folder from Trash, then retry the move.",
SyncIssue::Missing => { SyncIssue::Missing => {
"the file or its folder is gone from Proton Drive. Save a copy to keep the content." "the file or its folder is gone from Proton Drive. Save a copy to keep the content."
} }
@@ -2647,6 +2696,7 @@ fn mount_once(mountpoint: Option<PathBuf>) -> Result<pdfs_fuse::MountOutcome> {
db, db,
pdfs_fuse::MountOptions { pdfs_fuse::MountOptions {
username, username,
gallery_session: Some(session.clone()),
sweep_mode: config.resolved_conflict_sweep(), sweep_mode: config.resolved_conflict_sweep(),
upload_limit: config.upload_limit.unwrap_or(0), upload_limit: config.upload_limit.unwrap_or(0),
download_limit: config.download_limit.unwrap_or(0), download_limit: config.download_limit.unwrap_or(0),
@@ -2916,24 +2966,34 @@ fn photo_count(n: usize) -> String {
} }
} }
fn cmd_import_google_photos(archives: Vec<PathBuf>, dry_run: bool, wait: bool) -> Result<()> { fn cmd_import_google_photos(
// The daemon opens the archives itself off the shared filesystem, so it gets archives: Vec<PathBuf>,
// absolute paths — the same arrangement `pdfs upload` uses. dry_run: bool,
let mut absolute = Vec::with_capacity(archives.len()); resume: bool,
for archive in &archives { wait: bool,
let path = std::fs::canonicalize(archive) ) -> Result<()> {
.with_context(|| format!("resolve {}", archive.display()))?; let request = if resume {
absolute.push( CtlRequest::ResumeImport
path.to_str() } else {
.ok_or_else(|| anyhow!("path is not valid UTF-8: {}", path.display()))? // The daemon opens the archives itself off the shared filesystem, so it
.to_owned(), // gets absolute paths — the same arrangement `pdfs upload` uses.
); let mut absolute = Vec::with_capacity(archives.len());
} for archive in &archives {
let path = std::fs::canonicalize(archive)
.with_context(|| format!("resolve {}", archive.display()))?;
absolute.push(
path.to_str()
.ok_or_else(|| anyhow!("path is not valid UTF-8: {}", path.display()))?
.to_owned(),
);
}
CtlRequest::ImportTakeout {
archives: absolute,
dry_run,
}
};
match control_request(CtlRequest::ImportTakeout { match control_request(request)? {
archives: absolute,
dry_run,
})? {
CtlResponse::Ok { message } => println!("{message}"), CtlResponse::Ok { message } => println!("{message}"),
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)), CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
other => bail!("unexpected response: {other:?}"), other => bail!("unexpected response: {other:?}"),
@@ -2945,20 +3005,34 @@ fn cmd_import_google_photos(archives: Vec<PathBuf>, dry_run: bool, wait: bool) -
// Poll rather than stream: the control protocol is request/response, and an // Poll rather than stream: the control protocol is request/response, and an
// import runs for hours — a held-open socket would be the only long-lived // import runs for hours — a held-open socket would be the only long-lived
// connection the daemon has. // connection the daemon has. A line is printed when the step changes and
// every few percent of it, not on every poll.
let mut last_line = String::new();
let mut last_printed = std::time::Instant::now();
loop { loop {
std::thread::sleep(std::time::Duration::from_secs(2)); std::thread::sleep(std::time::Duration::from_secs(2));
match control_request(CtlRequest::ImportStatus)? { match control_request(CtlRequest::ImportStatus)? {
CtlResponse::ImportStatus { CtlResponse::ImportStatus {
running: true, running: true,
summary: _, progress,
} => continue, ..
CtlResponse::ImportStatus { summary, .. } => { } => {
print_import_summary(summary.as_ref()); let line = progress.as_ref().map(progress_line).unwrap_or_default();
return finished_run( let step_changed = line.split(':').next() != last_line.split(':').next();
"the import", if !line.is_empty()
summary.map(|s| (s.failed, s.cancelled, s.error)), && line != last_line
); && (step_changed || last_printed.elapsed().as_secs() >= 30)
{
println!("{line}");
last_line = line;
last_printed = std::time::Instant::now();
}
}
CtlResponse::ImportStatus {
summary, resumable, ..
} => {
print_import_summary(summary.as_ref(), &resumable);
return import_outcome(summary.as_ref());
} }
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)), CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
other => bail!("unexpected response: {other:?}"), other => bail!("unexpected response: {other:?}"),
@@ -2966,6 +3040,47 @@ fn cmd_import_google_photos(archives: Vec<PathBuf>, dry_run: bool, wait: bool) -
} }
} }
/// One line saying where a running import is.
fn progress_line(progress: &pdfs_core::control::ImportProgress) -> String {
use pdfs_core::control::ImportPhase;
let step = match progress.phase {
ImportPhase::Scanning => "Reading archives",
ImportPhase::Checking => "Checking for photos already on Proton",
ImportPhase::Uploading => "Uploading",
ImportPhase::Albums => "Filing photos into albums",
};
match (progress.total, &progress.current) {
(0, _) => format!("{step}…"),
(total, Some(name)) => format!("{step}: {} of {total} ({name})", progress.done),
(total, None) => format!("{step}: {} of {total}", progress.done),
}
}
/// How an import `--wait` followed ended, as the exit status: an error unless
/// it did everything it set out to do, so a script can tell.
fn import_outcome(summary: Option<&pdfs_core::control::ImportSummary>) -> Result<()> {
let Some(summary) = summary else {
bail!("the import ended without a result; the service may have restarted");
};
if let Some(error) = &summary.error {
bail!("the import failed: {error}");
}
if summary.interrupted {
bail!("the import was interrupted; run `pdfs import-google-photos --resume` to continue");
}
if summary.cancelled {
bail!("the import was cancelled");
}
if summary.failed > 0 || !summary.unreadable_archives.is_empty() {
bail!(
"the import finished, but {} photo(s) and {} archive(s) failed",
summary.failed,
summary.unreadable_archives.len()
);
}
Ok(())
}
fn cmd_redate_photos( fn cmd_redate_photos(
dry_run: bool, dry_run: bool,
limit: Option<usize>, limit: Option<usize>,
@@ -3100,11 +3215,19 @@ fn print_redate_summary(summary: Option<&pdfs_core::control::RedateSummary>) {
fn cmd_import_status() -> Result<()> { fn cmd_import_status() -> Result<()> {
match control_request(CtlRequest::ImportStatus)? { match control_request(CtlRequest::ImportStatus)? {
CtlResponse::ImportStatus { running, summary } => { CtlResponse::ImportStatus {
running,
summary,
progress,
resumable,
} => {
if running { if running {
println!("Import running. `pdfs transfers` shows its progress."); match progress.as_ref() {
Some(progress) => println!("Import running. {}", progress_line(progress)),
None => println!("Import running."),
}
} }
print_import_summary(summary.as_ref()); print_import_summary(summary.as_ref(), &resumable);
} }
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)), CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
other => bail!("unexpected response: {other:?}"), other => bail!("unexpected response: {other:?}"),
@@ -3121,18 +3244,28 @@ fn cmd_cancel_import() -> Result<()> {
Ok(()) Ok(())
} }
fn print_import_summary(summary: Option<&pdfs_core::control::ImportSummary>) { fn print_import_summary(summary: Option<&pdfs_core::control::ImportSummary>, resumable: &[String]) {
let Some(summary) = summary else { let Some(summary) = summary else {
println!("No import has run yet."); println!("No import has run yet.");
return; return;
}; };
if summary.dry_run {
println!("Scan only; nothing was uploaded.");
}
if let Some(error) = &summary.error { if let Some(error) = &summary.error {
println!("Failed : {error}"); println!("Stopped by : {error}");
return;
} }
println!("Photos in export : {}", summary.found); println!("Photos in export : {}", summary.found);
println!("Uploaded : {}", summary.uploaded); if summary.dry_run {
println!("Would upload : {}", summary.to_upload);
println!("Bytes to upload : {}", summary.to_upload_bytes);
} else {
println!("Uploaded : {}", summary.uploaded);
}
println!("Already on Proton: {}", summary.duplicates); println!("Already on Proton: {}", summary.duplicates);
if summary.live_photos > 0 {
println!("Live photos : {}", summary.live_photos);
}
if summary.skipped_trashed > 0 { if summary.skipped_trashed > 0 {
println!("Skipped (trash) : {}", summary.skipped_trashed); println!("Skipped (trash) : {}", summary.skipped_trashed);
} }
@@ -3145,12 +3278,20 @@ fn print_import_summary(summary: Option<&pdfs_core::control::ImportSummary>) {
if summary.failed > 0 { if summary.failed > 0 {
println!("Failed : {}", summary.failed); println!("Failed : {}", summary.failed);
} }
for archive in &summary.unreadable_archives {
println!("Unreadable : {archive}");
}
if summary.bytes > 0 { if summary.bytes > 0 {
println!("Uploaded bytes : {}", summary.bytes); println!("Uploaded bytes : {}", summary.bytes);
} }
if summary.cancelled { if summary.interrupted {
println!("The service stopped before the import finished.");
} else if summary.cancelled {
println!("Import was cancelled before it finished."); println!("Import was cancelled before it finished.");
} }
if !resumable.is_empty() {
println!("Run `pdfs import-google-photos --resume` to continue it.");
}
} }
fn cmd_album(uid: String, limit: usize, offset: usize) -> Result<()> { fn cmd_album(uid: String, limit: usize, offset: usize) -> Result<()> {
@@ -3602,6 +3743,173 @@ fn cmd_sync_limit(up: Option<u64>, down: Option<u64>) -> Result<()> {
})?) })?)
} }
fn cmd_sync_ignore(action: IgnoreCmd) -> Result<()> {
use pdfs_core::syncignore::{
DEFAULT_IGNORE_PATTERNS, FolderRules, IgnoreRules, RuleSource, Verdict, add_folder_pattern,
check_pattern, remove_folder_pattern,
};
let dirs = AppDirs::new()?;
let change = |edit: &dyn Fn(&mut Vec<String>)| -> Result<()> {
dirs.change_ignore_patterns(edit)?;
// The next pass picks the change up anyway; this only hurries it.
let _ = control_request(CtlRequest::SyncNow { id: None });
Ok(())
};
let valid = |pattern: &str| -> Result<String> {
let pattern = pattern.trim();
if pattern.is_empty() || pattern.starts_with('#') {
bail!("not a pattern: `{pattern}`");
}
check_pattern(pattern).map_err(|e| anyhow!("not a valid pattern: {e}"))?;
Ok(pattern.to_string())
};
match action {
IgnoreCmd::List { folder: None } => {
let config = dirs.load_config();
let list = config.resolved_ignore_patterns();
if list.is_empty() {
println!("No patterns: every file is synced.");
}
for pattern in list {
if DEFAULT_IGNORE_PATTERNS.contains(&pattern.as_str()) {
println!("{pattern} (built in)");
} else {
println!("{pattern}");
}
}
}
IgnoreCmd::List {
folder: Some(folder),
} => {
let (_, root) = mirror_folder_of(&folder)?;
let rules = FolderRules::read(&root)?;
let patterns = rules.patterns();
if patterns.is_empty() {
println!(
"{} has no own patterns; the ones for all synced folders apply.",
root.display()
);
}
for pattern in patterns {
println!("{pattern}");
}
}
IgnoreCmd::Add {
pattern,
folder: None,
} => {
let pattern = valid(&pattern)?;
change(&|list| {
if !list.contains(&pattern) {
list.push(pattern.clone());
}
})?;
}
IgnoreCmd::Add {
pattern,
folder: Some(folder),
} => {
let pattern = valid(&pattern)?;
let (id, root) = mirror_folder_of(&folder)?;
if add_folder_pattern(&root, &pattern)? {
let _ = control_request(CtlRequest::SyncNow { id: Some(id) });
} else {
println!("`{pattern}` is already in {}/.pdfsignore.", root.display());
}
}
IgnoreCmd::Remove {
pattern,
folder: None,
} => {
let pattern = pattern.trim().to_string();
let list = dirs.load_config().resolved_ignore_patterns();
if !list.contains(&pattern) {
bail!("`{pattern}` is not in the list; see `pdfs sync ignore list`");
}
change(&|list| list.retain(|p| *p != pattern))?;
}
IgnoreCmd::Remove {
pattern,
folder: Some(folder),
} => {
let (id, root) = mirror_folder_of(&folder)?;
if !remove_folder_pattern(&root, &pattern)? {
bail!(
"`{}` is not among the own patterns of {}; see `pdfs sync ignore list --folder {}`",
pattern.trim(),
root.display(),
root.display()
);
}
let _ = control_request(CtlRequest::SyncNow { id: Some(id) });
}
IgnoreCmd::Reset => change(&|list| {
*list = DEFAULT_IGNORE_PATTERNS
.iter()
.map(|p| (*p).to_string())
.collect()
})?,
IgnoreCmd::Check { path } => {
let path = std::path::absolute(&path)?;
let folder = synced_folder_of(&path)?;
if folder.mode != "mirror" {
println!(
"{} is online only; patterns apply only to folders kept on this computer.",
folder.local_path
);
return Ok(());
}
let root = PathBuf::from(&folder.local_path);
let rel = path.strip_prefix(&root).unwrap_or(&path).to_string_lossy();
let globals = dirs.load_config().resolved_ignore_patterns();
let rules = IgnoreRules::load(&root, &globals);
let source = |source: &RuleSource| match source {
RuleSource::AllFolders => "the patterns for all synced folders".to_string(),
RuleSource::ThisFolder => format!("{}/.pdfsignore", root.display()),
};
match rules.explain(&rel, path.is_dir()) {
Verdict::Synced => println!("Synced: no pattern matches it."),
Verdict::Excluded { pattern, source: s } => {
println!("Not synced: excluded by `{pattern}` in {}.", source(&s))
}
Verdict::Included { pattern, source: s } => {
println!("Synced: `{pattern}` in {} includes it again.", source(&s))
}
}
}
}
Ok(())
}
/// The synced folder holding `path`: the innermost one, as the daemon lists
/// them.
fn synced_folder_of(path: &Path) -> Result<SyncFolderInfo> {
let path = std::path::absolute(path)?;
let folders = match control_request(CtlRequest::ListSyncFolders)? {
CtlResponse::SyncFolders { items } => items,
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
other => bail!("unexpected reply: {other:?}"),
};
folders
.into_iter()
.filter(|f| path.starts_with(&f.local_path))
.max_by_key(|f| f.local_path.len())
.ok_or_else(|| anyhow!("{} is not in a synced folder", path.display()))
}
/// The id and root of the synced folder kept on this computer that holds
/// `path`. Own patterns mean nothing to an online-only folder.
fn mirror_folder_of(path: &Path) -> Result<(i64, PathBuf)> {
let folder = synced_folder_of(path)?;
if folder.mode != "mirror" {
bail!(
"{} is online only; patterns apply only to folders kept on this computer",
folder.local_path
);
}
Ok((folder.id, PathBuf::from(folder.local_path)))
}
/// How long the oldest write may wait to upload before `diagnose` calls it /// How long the oldest write may wait to upload before `diagnose` calls it
/// out. Under a day it is a slow link or a big file; past it, something is /// out. Under a day it is a slow link or a big file; past it, something is
/// holding the queue. /// holding the queue.
@@ -4509,6 +4817,86 @@ mod login_wait_tests {
assert!(finished_run("the import", None).is_err()); assert!(finished_run("the import", None).is_err());
} }
#[test]
fn a_waited_for_import_that_did_not_finish_exits_with_an_error() {
use pdfs_core::control::ImportSummary;
let done = ImportSummary {
uploaded: 4,
..Default::default()
};
assert!(import_outcome(Some(&done)).is_ok());
assert!(import_outcome(None).is_err());
for broken in [
ImportSummary {
interrupted: true,
..Default::default()
},
ImportSummary {
unreadable_archives: vec!["/exports/takeout-002.zip".into()],
..Default::default()
},
ImportSummary {
error: Some("check for existing photos: offline".into()),
..Default::default()
},
] {
assert!(import_outcome(Some(&broken)).is_err(), "{broken:?}");
}
let interrupted = import_outcome(Some(&ImportSummary {
interrupted: true,
..Default::default()
}));
assert!(interrupted.unwrap_err().to_string().contains("--resume"));
}
#[test]
fn resume_needs_no_archives_and_excludes_them() {
let cli = Cli::try_parse_from(["pdfs", "import-google-photos", "--resume"]).unwrap();
assert!(matches!(
cli.command,
Command::ImportGooglePhotos { resume: true, .. }
));
assert!(Cli::try_parse_from(["pdfs", "import-google-photos"]).is_err());
}
#[test]
fn sync_ignore_takes_a_pattern_that_looks_like_an_option_after_dashes() {
let cli = Cli::try_parse_from(["pdfs", "sync", "ignore", "add", "--", "-temp*"]).unwrap();
assert!(matches!(
cli.command,
Command::Sync {
action: SyncCmd::Ignore {
action: IgnoreCmd::Add {
ref pattern,
folder: None
}
}
} if pattern == "-temp*"
));
assert!(Cli::try_parse_from(["pdfs", "sync", "ignore", "add"]).is_err());
assert!(Cli::try_parse_from(["pdfs", "sync", "ignore", "reset"]).is_ok());
let cli =
Cli::try_parse_from(["pdfs", "sync", "ignore", "add", "*.db", "--folder", "Work"])
.unwrap();
assert!(matches!(
cli.command,
Command::Sync {
action: SyncCmd::Ignore {
action: IgnoreCmd::Add {
ref pattern,
folder: Some(ref folder)
}
}
} if pattern == "*.db" && folder == Path::new("Work")
));
assert!(
Cli::try_parse_from(["pdfs", "sync", "ignore", "list", "--folder", "Work"]).is_ok()
);
assert!(
Cli::try_parse_from(["pdfs", "import-google-photos", "--resume", "a.zip"]).is_err()
);
}
#[test] #[test]
fn waiting_for_a_session_stops_hammering_the_keyring() { fn waiting_for_a_session_stops_hammering_the_keyring() {
let mut checks_left = 20; let mut checks_left = 20;
+3 -3
View File
@@ -12,6 +12,7 @@ description = "Core auth/session/config for the Proton Drive Linux client"
[dependencies] [dependencies]
proton-sdk.workspace = true proton-sdk.workspace = true
proton-drive-rs.workspace = true proton-drive-rs.workspace = true
proton-gallery-rs.workspace = true
chrono.workspace = true chrono.workspace = true
tokio.workspace = true tokio.workspace = true
serde.workspace = true serde.workspace = true
@@ -20,15 +21,14 @@ thiserror.workspace = true
tracing.workspace = true tracing.workspace = true
directories.workspace = true directories.workspace = true
ignore.workspace = true ignore.workspace = true
shell-words.workspace = true
sha2.workspace = true sha2.workspace = true
sha1.workspace = true
zip.workspace = true
rusqlite.workspace = true rusqlite.workspace = true
keyring-core.workspace = true keyring-core.workspace = true
dbus-secret-service-keyring-store.workspace = true dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true
parking_lot.workspace = true parking_lot.workspace = true
async-trait.workspace = true async-trait.workspace = true
libc.workspace = true libc.workspace = true
zeroize.workspace = true zeroize.workspace = true
base64.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
+925
View File
@@ -0,0 +1,925 @@
//! A stand-in daemon that serves made-up data, for the README screenshots.
//!
//! `scripts/screenshots.sh` runs it; see `docs/DEVELOPMENT.md`. It answers the
//! control socket the way the real daemon does, for the requests the captured
//! pages send, with an invented account: no Proton login, no FUSE mount and
//! nothing private. Every name, place and number below is made up.
//!
//! ```text
//! demo_daemon serve <photos-dir> answer the control socket until killed
//! demo_daemon seed-keyring store a fake session, so the app signs in
//! ```
//!
//! Both refuse to run outside a throwaway environment: `PDFS_DEMO_ROOT` must be
//! set and every XDG directory must lie inside it, so the real daemon's socket
//! is never touched (`HOME` may instead name a folder that does not exist, the
//! demo user's, so paths read as theirs), and `seed-keyring` refuses the session bus the script was
//! started on (`PDFS_DEMO_OUTER_BUS`), so the fake session only ever lands in a
//! private keyring.
use std::collections::BTreeMap;
use std::io::{BufRead, BufReader, Write};
use std::os::unix::fs::PermissionsExt;
use std::os::unix::net::{UnixListener, UnixStream};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
use chrono::{Datelike, Local, TimeZone};
use pdfs_core::cache::Pin;
use pdfs_core::config::{AppDirs, KEYRING_SERVICE};
use pdfs_core::control::{
ActivityEntry, ActivityKind, AlbumInfo, DeviceInfo, DirEntry, Event, LocalHit, PhotoItem,
PhotoKind, PhotoLocation, PhotoMonth, PhotoThumb, PlaceInfo, Request, Response, SearchHit,
SyncFolderInfo, Topic,
};
use pdfs_core::mounts::{MountAccess, MountKind, MountMode, MountSpec};
const USERNAME: &str = "alex.example";
const MOUNTPOINT: &str = "/home/alex/ProtonDrive";
const GIB: u64 = 1 << 30;
const DAY: i64 = 86_400;
/// How many photos the timeline holds. The demo pictures repeat, but not
/// within a screen.
const PHOTOS: usize = 1_840;
fn main() {
if let Err(e) = run() {
eprintln!("demo_daemon: {e}");
std::process::exit(1);
}
}
fn run() -> Result<(), String> {
check_sandbox()?;
let args: Vec<String> = std::env::args().skip(1).collect();
match args.iter().map(String::as_str).collect::<Vec<_>>()[..] {
["serve", photos] => serve(Path::new(photos)),
["seed-keyring"] => seed_keyring(),
_ => Err("usage: demo_daemon serve <photos-dir> | seed-keyring".into()),
}
}
/// Refuse to run anywhere but inside the throwaway root the script made.
fn check_sandbox() -> Result<(), String> {
let root = std::env::var_os("PDFS_DEMO_ROOT")
.map(PathBuf::from)
.ok_or("PDFS_DEMO_ROOT is not set; run scripts/screenshots.sh")?;
let home = std::env::var_os("HOME").map(PathBuf::from);
if home.is_none_or(|home| home.exists() && !home.starts_with(&root)) {
return Err("HOME must lie inside PDFS_DEMO_ROOT or not exist".into());
}
for var in [
"XDG_CONFIG_HOME",
"XDG_STATE_HOME",
"XDG_CACHE_HOME",
"XDG_DATA_HOME",
] {
let inside = std::env::var_os(var)
.map(PathBuf::from)
.is_some_and(|dir| dir.starts_with(&root));
if !inside {
return Err(format!("{var} must lie inside PDFS_DEMO_ROOT"));
}
}
Ok(())
}
/// Store a made-up session where the app looks for one. Its keys "unlock"
/// without a prompt; nothing ever uses them against Proton.
fn seed_keyring() -> Result<(), String> {
let bus = std::env::var("DBUS_SESSION_BUS_ADDRESS").unwrap_or_default();
let outer =
std::env::var("PDFS_DEMO_OUTER_BUS").map_err(|_| "PDFS_DEMO_OUTER_BUS is not set")?;
if bus.is_empty() || bus == outer {
return Err("refusing to write a fake session to your own keyring".into());
}
let session = serde_json::json!({
"session_id": "demo-session",
"username": USERNAME,
"user_id": "demo-user",
"access_token": "demo",
"refresh_token": "demo",
"scopes": ["full", "self", "drive"],
"password_mode": 1,
"key_passphrases": { "demo-key": "ZGVtbw==" },
});
let store: Arc<keyring_core::CredentialStore> =
dbus_secret_service_keyring_store::Store::new().map_err(|e| e.to_string())?;
keyring_core::set_default_store(store);
keyring_core::Entry::new(KEYRING_SERVICE, "session")
.and_then(|entry| entry.set_password(&session.to_string()))
.map_err(|e| e.to_string())
}
fn serve(photos: &Path) -> Result<(), String> {
let demo = Arc::new(Demo::new(photos)?);
let dirs = AppDirs::new().map_err(|e| e.to_string())?;
dirs.ensure().map_err(|e| e.to_string())?;
let socket = dirs.control_socket();
let _ = std::fs::remove_file(&socket);
let listener = UnixListener::bind(&socket).map_err(|e| format!("{}: {e}", socket.display()))?;
std::fs::set_permissions(&socket, std::fs::Permissions::from_mode(0o600))
.map_err(|e| e.to_string())?;
eprintln!("demo_daemon: serving {}", socket.display());
for stream in listener.incoming().flatten() {
let demo = Arc::clone(&demo);
std::thread::spawn(move || {
if let Err(e) = connection(&demo, stream) {
eprintln!("demo_daemon: {e}");
}
});
}
Ok(())
}
fn connection(demo: &Demo, stream: UnixStream) -> std::io::Result<()> {
let mut reader = BufReader::new(stream.try_clone()?);
let mut line = String::new();
reader.read_line(&mut line)?;
let request: Request = match serde_json::from_str(line.trim()) {
Ok(request) => request,
Err(e) => {
eprintln!("demo_daemon: unreadable request: {e}");
return Ok(());
}
};
let mut out = stream;
if matches!(request, Request::Subscribe) {
return subscription(demo, &mut out);
}
send(&mut out, &demo.answer(&request))
}
/// What the real daemon sends a new subscriber, then a heartbeat now and then
/// so the window never counts the daemon as gone.
fn subscription(demo: &Demo, out: &mut UnixStream) -> std::io::Result<()> {
send(out, &Event::Status(Box::new(demo.status())))?;
send(
out,
&Event::Transfers {
items: Vec::new(),
jobs: Vec::new(),
},
)?;
send(
out,
&Event::Changed {
topics: Topic::ALL.to_vec(),
},
)?;
loop {
std::thread::sleep(Duration::from_secs(10));
send(out, &Event::Heartbeat)?;
}
}
fn send(out: &mut UnixStream, value: &impl serde::Serialize) -> std::io::Result<()> {
let mut line = serde_json::to_vec(value)?;
line.push(b'\n');
out.write_all(&line)?;
out.flush()
}
/// One invented account.
struct Demo {
now: i64,
pictures: Vec<PathBuf>,
photos: Vec<PhotoItem>,
/// Each photo's place, by index into [`PLACES`].
place_of: Vec<Option<usize>>,
}
/// Towns the photos were "taken" in: name, ISO country, latitude, longitude.
const PLACES: &[(&str, &str, f64, f64)] = &[
("Lisbon", "PT", 38.7223, -9.1393),
("Porto", "PT", 41.1579, -8.6291),
("Barcelona", "ES", 41.3874, 2.1686),
("Paris", "FR", 48.8566, 2.3522),
("Amsterdam", "NL", 52.3676, 4.9041),
("Copenhagen", "DK", 55.6761, 12.5683),
("Berlin", "DE", 52.5200, 13.4050),
("Prague", "CZ", 50.0755, 14.4378),
("Vienna", "AT", 48.2082, 16.3738),
("Florence", "IT", 43.7696, 11.2558),
("Rome", "IT", 41.9028, 12.4964),
("Thira", "GR", 36.4166, 25.4318),
];
const ALBUMS: &[&str] = &[
"Summer in Portugal",
"Family",
"Hiking",
"Food",
"City trips",
"Best of 2025",
];
impl Demo {
fn new(dir: &Path) -> Result<Self, String> {
let mut pictures: Vec<PathBuf> = std::fs::read_dir(dir)
.map_err(|e| format!("{}: {e}", dir.display()))?
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|ext| ext == "jpg"))
.collect();
pictures.sort();
if pictures.is_empty() {
return Err(format!("no .jpg pictures in {}", dir.display()));
}
let now = Local::now().timestamp();
let mut demo = Demo {
now,
pictures,
photos: Vec::new(),
place_of: Vec::new(),
};
demo.make_photos();
Ok(demo)
}
/// The timeline: newest first, a few a week back three years, plus a
/// photo on this day in each of the last three years.
fn make_photos(&mut self) {
let mut seed = 0x5eed_u64;
let mut next = move || {
seed = seed
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
(seed >> 33) as i64
};
let today = Local::now().date_naive();
let noon = |years_back: i32| {
let day = today
.with_year(today.year() - years_back)
.unwrap_or(today - chrono::Days::new(365 * years_back as u64));
Local
.from_local_datetime(&day.and_hms_opt(11, 30, 0).unwrap_or_default())
.single()
.map_or(0, |t| t.timestamp())
};
// Three years, so a few a day.
let step = 3 * 365 * DAY / PHOTOS as i64;
let mut times: Vec<i64> = (0..PHOTOS as i64)
.map(|i| self.now - 3 * 3600 - i * step - next() % step)
.collect();
times.extend([noon(1), noon(2), noon(3)]);
times.sort_unstable_by(|a, b| b.cmp(a));
for (i, time) in times.into_iter().enumerate() {
let picture = &self.pictures[i % self.pictures.len()];
let kind = match i % 23 {
7 | 15 => PhotoKind::Video,
19 => PhotoKind::Raw,
_ => PhotoKind::Photo,
};
let place = (i % 5 != 4).then_some((i / 7) % PLACES.len());
self.photos.push(PhotoItem {
uid: format!("demo-photos~{i}"),
capture_time: time,
thumb_path: Some(picture.display().to_string()),
name: Some(format!(
"IMG_{}.{}",
20_000 + i,
if kind == PhotoKind::Video {
"MP4"
} else {
"JPG"
}
)),
ratio: Some(if picture.to_string_lossy().ends_with("-p.jpg") {
2.0 / 3.0
} else {
1.5
}),
no_thumb: false,
kind,
favorite: i % 11 == 3,
group_size: 0,
has_raw: kind == PhotoKind::Raw,
place_id: place.map(|p| p as u32 + 1),
});
self.place_of.push(place);
}
}
fn status(&self) -> Response {
Response::Status {
username: USERNAME.into(),
mountpoint: MOUNTPOINT.into(),
pinned: 3,
used: 6 * GIB + 300 * (1 << 20),
budget: 20 * GIB,
pins: self.pins(),
online: true,
pending_uploads: 0,
pending_changes: 0,
parked_uploads: 0,
failing_ops: 0,
failing_error: None,
staged_bytes: 0,
staged_oldest_secs: 0,
paused: false,
paused_until: None,
session_expired: false,
tokens_unsaved: false,
version: env!("CARGO_PKG_VERSION").into(),
}
}
fn answer(&self, request: &Request) -> Response {
match request {
Request::Status => self.status(),
Request::AccountQuota => Response::AccountQuota {
max_space: 500 * GIB as i64,
used_space: 137 * GIB as i64,
},
Request::ListDir { path } => Response::Entries {
entries: self.dir(path),
},
Request::ReserveFileThumbGeneration => Response::FileThumbGeneration { generation: 1 },
Request::FileThumbs { items, .. } => Response::Thumbs {
items: items
.iter()
.map(|item| PhotoThumb {
uid: item.uid.clone(),
path: self.file_picture(&item.uid),
pending: false,
})
.collect(),
},
Request::PhotosTimeline {
offset,
limit,
kind,
favorites,
..
} => {
let items: Vec<PhotoItem> = self
.photos
.iter()
.filter(|p| kind.is_none_or(|k| p.kind == k))
.filter(|p| !favorites || p.favorite)
.skip(*offset)
.take(*limit)
.cloned()
.collect();
Response::Photos {
available: true,
items,
counts: Some(self.counts()),
}
}
Request::PhotoMonths { kind } => Response::PhotoMonths {
months: self.months(*kind),
},
Request::PhotosOnThisDay { .. } => {
let today = Local::now();
let items = self
.photos
.iter()
.filter(|p| {
let at = Local.timestamp_opt(p.capture_time, 0).single();
at.is_some_and(|at| {
at.year() < today.year()
&& at.month() == today.month()
&& at.day() == today.day()
})
})
.cloned()
.collect();
Response::Photos {
available: true,
items,
counts: None,
}
}
Request::PhotoThumbs { uids } => Response::Thumbs {
items: uids
.iter()
.map(|uid| PhotoThumb {
uid: uid.clone(),
path: self
.photos
.iter()
.find(|p| &p.uid == uid)
.and_then(|p| p.thumb_path.clone()),
pending: false,
})
.collect(),
},
Request::PhotoAlbums => Response::Albums {
available: true,
items: self.albums(),
},
Request::AlbumPhotos { uid, offset, limit } => {
let index: usize = uid
.rsplit('~')
.next()
.and_then(|n| n.parse().ok())
.unwrap_or(0);
Response::Photos {
available: true,
items: self
.album_photos(index)
.skip(*offset)
.take(*limit)
.cloned()
.collect(),
counts: None,
}
}
Request::PhotoPlaces => Response::Places {
items: self.places(),
mapping: None,
},
Request::PlaceLocations { id } => Response::PhotoLocations {
items: self.place_locations(*id),
},
Request::PlacePhotos { id, offset, limit } => Response::Photos {
available: true,
items: self
.in_place(*id)
.map(|(_, p)| p)
.skip(*offset)
.take(*limit)
.cloned()
.collect(),
counts: None,
},
Request::ListDevices => Response::Devices {
items: self.devices(),
},
Request::ListSyncFolders => Response::SyncFolders {
items: self.sync_folders(),
},
Request::ListLocations => Response::Locations {
items: self.locations(),
},
// Every conflict in the history is resolved: an open one would
// badge every page.
Request::ListConflicts => Response::Conflicts { items: Vec::new() },
Request::ListPendingOps => Response::PendingOps { items: Vec::new() },
Request::ListActivity { limit } => Response::Activity {
items: self.activity().into_iter().take(*limit).collect(),
},
Request::ListInvitations => Response::Invitations { items: Vec::new() },
Request::ListBookmarks => Response::Bookmarks { items: Vec::new() },
Request::GetQueueStatus => Response::Transfers {
items: Vec::new(),
jobs: Vec::new(),
},
Request::ListPins => Response::Pins { pins: self.pins() },
Request::SearchV2 { query, limit, .. } => Response::SearchResultsV2 {
drive_hits: self.search(query, *limit),
local_hits: self.local_search(query),
local_indexing: false,
},
Request::Search { query, limit, .. } => Response::SearchResults {
hits: self.search(query, *limit),
},
Request::ImportStatus => Response::ImportStatus {
running: false,
summary: None,
progress: None,
resumable: Vec::new(),
},
Request::PhotosRefreshStatus => Response::PhotosRefresh { running: false },
other => {
eprintln!("demo_daemon: no demo answer for {}", request_name(other));
Response::Ok {
message: String::new(),
}
}
}
}
fn counts(&self) -> (usize, usize, usize) {
let of = |kind| self.photos.iter().filter(|p| p.kind == kind).count();
(
of(PhotoKind::Photo),
of(PhotoKind::Video),
of(PhotoKind::Raw),
)
}
fn months(&self, kind: Option<PhotoKind>) -> Vec<PhotoMonth> {
let mut months: BTreeMap<(i32, i32), usize> = BTreeMap::new();
for photo in self
.photos
.iter()
.filter(|p| kind.is_none_or(|k| p.kind == k))
{
if let Some(at) = Local.timestamp_opt(photo.capture_time, 0).single() {
*months.entry((at.year(), at.month() as i32)).or_default() += 1;
}
}
months
.into_iter()
.rev()
.map(|((year, month), count)| PhotoMonth { year, month, count })
.collect()
}
fn albums(&self) -> Vec<AlbumInfo> {
ALBUMS
.iter()
.enumerate()
.map(|(i, name)| AlbumInfo {
uid: format!("demo-album~{i}"),
name: (*name).into(),
photo_count: self.album_photos(i).count(),
cover_uid: self.album_photos(i).next().map(|p| p.uid.clone()),
last_activity: Some(self.now - (i as i64 * 9 + 2) * DAY),
shared: i == 1,
})
.collect()
}
fn album_photos(&self, album: usize) -> impl Iterator<Item = &PhotoItem> {
let stride = 3 + album;
self.photos
.iter()
.skip(album * 2)
.step_by(stride)
.take(40 + album * 17)
}
fn in_place(&self, id: u32) -> impl Iterator<Item = (usize, &PhotoItem)> {
self.photos
.iter()
.enumerate()
.filter(move |(i, _)| self.place_of[*i].is_some_and(|p| p as u32 + 1 == id))
}
fn places(&self) -> Vec<PlaceInfo> {
PLACES
.iter()
.enumerate()
.filter_map(|(i, (name, country, latitude, longitude))| {
let id = i as u32 + 1;
let count = self.in_place(id).count();
let cover = self.in_place(id).next()?.1.clone();
Some(PlaceInfo {
id,
name: (*name).into(),
country: (*country).into(),
latitude: *latitude,
longitude: *longitude,
photo_count: count,
cover,
})
})
.collect()
}
fn place_locations(&self, id: u32) -> Vec<PhotoLocation> {
let Some((_, _, latitude, longitude)) = PLACES.get(id as usize - 1) else {
return Vec::new();
};
self.in_place(id)
.map(|(i, photo)| {
// Spread around the centre, the same way on every run.
let angle = i as f64 * 2.399;
let reach = 0.004 + (i % 9) as f64 * 0.003;
PhotoLocation {
photo: photo.clone(),
latitude: latitude + reach * angle.sin(),
longitude: longitude + reach * angle.cos(),
}
})
.collect()
}
/// My files: folders first, then a few files, some of them pictures with
/// thumbnails. Any folder below the root holds the same few documents.
fn dir(&self, path: &str) -> Vec<DirEntry> {
let folder = |name: &str, days: i64| DirEntry {
name: name.into(),
is_dir: true,
modified: self.now - days * DAY,
uid: format!("demo-files~{path}/{name}"),
path: join(path, name),
..Default::default()
};
let file = |name: &str, size: u64, days: i64| DirEntry {
name: name.into(),
is_dir: false,
size,
modified: self.now - days * DAY - 4000,
uid: format!("demo-files~{path}/{name}"),
path: join(path, name),
..Default::default()
};
if !path.trim_matches('/').is_empty() {
return vec![
file("Notes.md", 4_812, 1),
file("Overview.pdf", 912_384, 6),
file("Budget.ods", 38_112, 12),
];
}
let mut entries = vec![
folder("Documents", 1),
folder("Music", 30),
folder("Pictures", 2),
folder("Projects", 4),
folder("Recipes", 60),
folder("Taxes", 120),
folder("Videos", 14),
folder("Work", 3),
];
let mut pinned = file("Lisbon sunset.jpg", 4_218_112, 20);
pinned.pinned = true;
pinned.cached = true;
entries.extend([
file("Apartment lease.pdf", 1_482_011, 40),
file("Budget 2026.ods", 52_340, 2),
file("Cliffs.jpg", 3_844_201, 33),
file("Garden.jpg", 2_904_877, 9),
pinned,
file("Meeting notes.md", 6_120, 0),
file("Mountain lake.jpg", 5_120_330, 61),
file("Packing list.txt", 1_204, 5),
file("Road trip.jpg", 3_211_008, 75),
file("Thesis draft.odt", 812_448, 18),
]);
entries
}
/// The picture behind a demo file, for its thumbnail.
fn file_picture(&self, uid: &str) -> Option<String> {
let name = uid.rsplit('/').next()?;
if !name.ends_with(".jpg") {
return None;
}
let index = name.bytes().map(usize::from).sum::<usize>() % self.pictures.len();
Some(self.pictures[index].display().to_string())
}
fn pins(&self) -> Vec<Pin> {
[
("Documents", true),
("Work/Quarterly report.odt", false),
("Lisbon sunset.jpg", false),
]
.into_iter()
.map(|(path, dir)| Pin {
uid: format!("demo-files~/{path}"),
path: (*path).into(),
recursive: dir,
is_dir: Some(dir),
cached: true,
})
.collect()
}
fn devices(&self) -> Vec<DeviceInfo> {
vec![
DeviceInfo {
uid: "demo-devices~1".into(),
name: "alex-laptop".into(),
device_type: "Linux".into(),
last_sync: Some(self.now - 240),
this_device: true,
adopted: true,
},
DeviceInfo {
uid: "demo-devices~2".into(),
name: "studio-desktop".into(),
device_type: "Windows".into(),
last_sync: Some(self.now - 2 * DAY - 3 * 3600),
this_device: false,
adopted: false,
},
DeviceInfo {
uid: "demo-devices~3".into(),
name: "old-macbook".into(),
device_type: "MacOs".into(),
last_sync: Some(self.now - 210 * DAY),
this_device: false,
adopted: false,
},
]
}
/// This computer's synced folders: mirrors, and one kept online only.
const FOLDERS: &[(&str, &str)] = &[
("/home/alex/Documents", "mirror"),
("/home/alex/Pictures/Camera", "mirror"),
("/home/alex/Music", "ondemand"),
("/home/alex/Projects", "mirror"),
];
fn sync_folders(&self) -> Vec<SyncFolderInfo> {
Self::FOLDERS
.iter()
.enumerate()
.map(|(i, (path, mode))| SyncFolderInfo {
id: i as i64 + 1,
kind: "device".into(),
local_path: (*path).into(),
remote_uid: format!("demo-sync~{i}"),
mode: (*mode).into(),
pending_mode: None,
state: "idle".into(),
last_sync: self.now - 240 - i as i64 * 60,
progress: None,
paused: false,
})
.collect()
}
fn locations(&self) -> Vec<MountSpec> {
let mut items = vec![MountSpec {
id: 1,
kind: MountKind::MyFiles,
local_path: MOUNTPOINT.into(),
root_uid: "demo-files~".into(),
root_share_id: String::new(),
mode: MountMode::OnDemand,
access: MountAccess::Rw,
state: "idle".into(),
last_sync: self.now - 60,
pending_mode: None,
mounted: true,
progress: None,
paused: false,
}];
items.extend(
Self::FOLDERS
.iter()
.enumerate()
.map(|(i, (path, mode))| MountSpec {
id: i as i64 + 2,
kind: MountKind::Device {
sync_folder_id: i as i64 + 1,
},
local_path: (*path).into(),
root_uid: format!("demo-sync~{i}"),
root_share_id: String::new(),
mode: MountMode::from(*mode),
access: MountAccess::Rw,
state: "idle".into(),
last_sync: self.now - 240 - i as i64 * 60,
pending_mode: None,
mounted: *mode == "ondemand",
progress: None,
paused: false,
}),
);
items
}
fn activity(&self) -> Vec<ActivityEntry> {
let at = |minutes: i64| self.now - minutes * 60;
let entry = |time, kind, target: &str, detail: &str, ok| ActivityEntry {
time,
kind,
target: target.into(),
detail: detail.into(),
ok,
};
let conflict = |time, name: &str, ext: &str| {
entry(
time,
ActivityKind::Conflict,
&format!("{name} (sync-conflict {time}).{ext}"),
&format!("differs from {name}.{ext}"),
false,
)
};
vec![
entry(at(2), ActivityKind::Upload, "Meeting notes.md", "", true),
entry(
at(14),
ActivityKind::Share,
"Budget 2026.ods",
"1 recipient(s) as editor",
true,
),
entry(
at(38),
ActivityKind::Upload,
"Pictures/Camera/IMG_20481.JPG",
"",
true,
),
entry(
at(39),
ActivityKind::Upload,
"Pictures/Camera/IMG_20480.JPG",
"",
true,
),
entry(
at(52),
ActivityKind::Rename,
"Thesis draft.odt",
"was thesis-v3.odt",
true,
),
conflict(at(180), "Quarterly report", "odt"),
entry(
at(240),
ActivityKind::Move,
"Taxes/2025",
"from Documents",
true,
),
entry(
at(26 * 60),
ActivityKind::PublicLink,
"Road trip.jpg",
"",
true,
),
conflict(at(26 * 60 + 5), "Packing list", "txt"),
entry(at(27 * 60), ActivityKind::CreateFolder, "Recipes", "", true),
conflict(at(28 * 60), "Garden plan", "svg"),
entry(at(29 * 60), ActivityKind::Trash, "Old invoices", "", true),
entry(
at(30 * 60),
ActivityKind::Restore,
"Apartment lease.pdf",
"",
true,
),
entry(
at(50 * 60),
ActivityKind::Upload,
"Videos/Harbour at dusk.mp4",
"",
true,
),
]
}
/// Hits for the search launcher: every demo file whose name holds the
/// query, or a few to show when nothing does.
fn search(&self, query: &str, limit: usize) -> Vec<SearchHit> {
let names = [
("Work/Quarterly report.odt", false, 180_912),
("Work/Quarterly report 2025.pdf", false, 1_204_334),
("Work/Reports", true, 0),
("Documents/Expense report March.ods", false, 44_201),
("Documents/Lab report.pdf", false, 2_301_442),
("Projects/Annual report draft.md", false, 18_400),
("Taxes/2025/Tax report.pdf", false, 640_008),
("Pictures/Report cover.jpg", false, 2_801_220),
];
let needle = query.to_lowercase();
names
.iter()
.filter(|(path, _, _)| needle.is_empty() || path.to_lowercase().contains(&needle))
.take(limit)
.enumerate()
.map(|(i, (path, is_dir, size))| SearchHit {
name: path.rsplit('/').next().unwrap_or(path).into(),
path: (*path).into(),
is_dir: *is_dir,
size: *size,
modified: self.now - (i as i64 * 5 + 1) * DAY,
pinned: i == 0,
cached: i == 0,
uid: format!("demo-files~/{path}"),
mounted_path: Some(format!("{MOUNTPOINT}/{path}")),
score: 100 - i as i64,
})
.collect()
}
fn local_search(&self, query: &str) -> Vec<LocalHit> {
let needle = query.to_lowercase();
[("/home/alex/Downloads/report-template.ott", 22_018)]
.iter()
.filter(|(path, _)| path.to_lowercase().contains(&needle))
.map(|(path, size)| LocalHit {
name: path.rsplit('/').next().unwrap_or(path).into(),
path: (*path).into(),
is_dir: false,
size: *size,
modified: self.now - 4 * DAY,
score: 10,
})
.collect()
}
}
fn join(dir: &str, name: &str) -> String {
let dir = dir.trim_matches('/');
if dir.is_empty() {
name.into()
} else {
format!("{dir}/{name}")
}
}
/// The variant name of `request`, for the log of requests the demo ignores.
fn request_name(request: &Request) -> String {
let json = serde_json::to_string(request).unwrap_or_default();
json.trim_start_matches(['{', '"'])
.split('"')
.next()
.unwrap_or_default()
.to_string()
}
+340 -34
View File
@@ -123,13 +123,84 @@ fn client_config() -> ProtonClientConfiguration {
ProtonClientConfiguration::new(app_version).with_user_agent(user_agent) ProtonClientConfiguration::new(app_version).with_user_agent(user_agent)
} }
fn keyring_entry() -> Result<Entry> { /// Run `op` on the session's keyring entry.
// Installed lazily rather than once at startup so a session bus that was not fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
// up yet on the first attempt is retried on the next one. with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op)
if keyring_core::get_default_store().is_none() { }
keyring_core::set_default_store(dbus_secret_service_keyring_store::Store::new()?);
/// Run `op` on the entry `service`/`user`, reconnecting once if the Secret
/// Service fails the call.
///
/// 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)?)?)
}
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()?),
} }
Ok(Entry::new(KEYRING_SERVICE, KEYRING_USER)?)
} }
/// What the user answered when asked for the mailbox password. /// What the user answered when asked for the mailbox password.
@@ -419,19 +490,54 @@ fn classify_verification_gate(e: ProtonError) -> Error {
} }
} }
/// 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.
fn write_stored(stored: &StoredSession) -> Result<()> { fn write_stored(stored: &StoredSession) -> Result<()> {
let json = Zeroizing::new(serde_json::to_string(stored)?); let json = Zeroizing::new(serde_json::to_string(stored)?);
keyring_entry()?.set_password(&json)?; if replace_items() {
Ok(()) 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()
}
/// A short, one-way tag for a refresh token, for the log: enough to tell
/// whether the token a start finds is the one the last save wrote, and
/// nothing that helps anyone use it.
fn fingerprint(token: &str) -> String {
use sha2::{Digest, Sha256};
Sha256::digest(token.as_bytes())[..4]
.iter()
.map(|b| format!("{b:02x}"))
.collect()
} }
/// Load the persisted session blob, or `Error::NotLoggedIn` if absent. /// Load the persisted session blob, or `Error::NotLoggedIn` if absent.
pub fn load() -> Result<StoredSession> { pub fn load() -> Result<StoredSession> {
let entry = keyring_entry()?; match with_keyring(|entry| entry.get_password()) {
match entry.get_password() {
Ok(json) => Ok(serde_json::from_str(&json)?), Ok(json) => Ok(serde_json::from_str(&json)?),
Err(keyring_core::Error::NoEntry) => Err(Error::NotLoggedIn), Err(Error::Keyring(keyring_core::Error::NoEntry)) => Err(Error::NotLoggedIn),
Err(e) => Err(e.into()), Err(e) => Err(e),
} }
} }
@@ -589,9 +695,9 @@ pub fn logout() -> Result<bool> {
tracing::warn!(error = %e, "clearing the kernel-keyring unlock on logout failed"); tracing::warn!(error = %e, "clearing the kernel-keyring unlock on logout failed");
} }
let _ = kernelkey::UNSAVED_TOKENS.clear(); let _ = kernelkey::UNSAVED_TOKENS.clear();
match keyring_entry()?.delete_credential() { match with_keyring(|entry| entry.delete_credential()) {
Ok(()) | Err(keyring_core::Error::NoEntry) => Ok(ended), Ok(()) | Err(Error::Keyring(keyring_core::Error::NoEntry)) => Ok(ended),
Err(e) => Err(e.into()), Err(e) => Err(e),
} }
} }
@@ -634,6 +740,10 @@ fn resume_stored(stored: &StoredSession) -> Result<ProtonApiSession> {
resumed.access_token = tokens.access_token.clone(); resumed.access_token = tokens.access_token.clone();
resumed.refresh_token = tokens.refresh_token.clone(); resumed.refresh_token = tokens.refresh_token.clone();
} }
tracing::info!(
refresh = %fingerprint(&resumed.refresh_token),
"resuming the stored session"
);
let session = ProtonApiSession::resume(client_config(), resumed.to_params())?; let session = ProtonApiSession::resume(client_config(), resumed.to_params())?;
let sink = register_refresh_handler(&session, stored.refresh_token.clone()); let sink = register_refresh_handler(&session, stored.refresh_token.clone());
if let Some(tokens) = unsaved { if let Some(tokens) = unsaved {
@@ -996,21 +1106,15 @@ impl TokenSink {
} }
} }
/// Write the unsaved rotation, if there is one. A blob that moved on, or /// Write the unsaved rotation, if there is one. A blob that moved on drops
/// is gone with a logout, drops it: there is nothing it may still go into. /// it. A missing blob is retried: some Secret Service providers also report
/// locked or temporarily hidden items as absent. Never recreate it here.
fn flush(&self) -> Result<()> { fn flush(&self) -> Result<()> {
let mut state = self.state.lock(); let mut state = self.state.lock();
let Some(tokens) = state.unsaved.clone() else { let Some(tokens) = state.unsaved.clone() else {
return Ok(()); return Ok(());
}; };
let mut stored = match load() { let mut stored = load()?;
Ok(stored) => stored,
Err(Error::NotLoggedIn) => {
state.settle();
return Ok(());
}
Err(e) => return Err(e),
};
match take_rotation( match take_rotation(
&mut stored, &mut stored,
&self.session_id, &self.session_id,
@@ -1019,8 +1123,11 @@ impl TokenSink {
) { ) {
Rotation::Taken => { Rotation::Taken => {
write_stored(&stored)?; write_stored(&stored)?;
tracing::info!(
refresh = %fingerprint(&tokens.refresh_token),
"successfully auto-persisted refreshed tokens in keyring"
);
state.stored_refresh = tokens.refresh_token; state.stored_refresh = tokens.refresh_token;
tracing::info!("successfully auto-persisted refreshed tokens in keyring");
} }
Rotation::MovedOn => { Rotation::MovedOn => {
tracing::info!( tracing::info!(
@@ -1213,12 +1320,180 @@ mod tests {
/// The keyring is one store per process, so the tests that use it, /// The keyring is one store per process, so the tests that use it,
/// through `keyring-core`'s in-memory store, take turns. /// through `keyring-core`'s in-memory store, take turns.
fn mock_keyring() -> parking_lot::MutexGuard<'static, ()> { fn mock_keyring() -> parking_lot::MutexGuard<'static, ()> {
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
let turn = KEYRING.lock(); let turn = KEYRING.lock();
keyring_core::set_default_store(keyring_core::mock::Store::new().unwrap()); 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);
turn turn
} }
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
/// The in-memory store a reconnect hands out, so it finds the same
/// entries; `None` connects to the real Secret Service.
pub(super) static MOCK_STORE: parking_lot::Mutex<Option<Arc<keyring_core::CredentialStore>>> =
parking_lot::Mutex::new(None);
/// How many times a store was connected.
pub(super) static KEYRING_CONNECTS: std::sync::atomic::AtomicUsize =
std::sync::atomic::AtomicUsize::new(0);
/// The session's entry, to make its next call fail.
fn keyring_entry() -> Entry {
Entry::new(KEYRING_SERVICE, KEYRING_USER).unwrap()
}
/// Make the session entry's next call fail with `error`.
fn fail_next(error: keyring_core::Error) {
keyring_entry()
.as_any()
.downcast_ref::<keyring_core::mock::Cred>()
.unwrap()
.set_error(error);
}
fn no_session() -> keyring_core::Error {
keyring_core::Error::PlatformFailure(
std::io::Error::other("The session does not exist (NoSession)").into(),
)
}
/// B285: a restarted Secret Service no longer knows the process's
/// session, and every call on it failed until the process restarted.
#[test]
fn a_dropped_secret_service_session_is_reconnected_and_retried() {
let _turn = mock_keyring();
write_stored(&stored_with("r")).unwrap();
let connects = KEYRING_CONNECTS.load(Ordering::SeqCst);
fail_next(no_session());
assert_eq!(load().unwrap().refresh_token, "r");
assert_eq!(KEYRING_CONNECTS.load(Ordering::SeqCst), connects + 1);
fail_next(no_session());
write_stored(&stored_with("r2")).unwrap();
assert_eq!(load().unwrap().refresh_token, "r2");
assert_eq!(KEYRING_CONNECTS.load(Ordering::SeqCst), connects + 2);
}
#[test]
fn a_rotation_lands_at_once_after_the_keyring_restarts() {
let _turn = mock_keyring();
write_stored(&stored_with("r")).unwrap();
let sink = Arc::new(TokenSink::new("s", "r".into()));
fail_next(no_session());
sink.rotated(tokens("a2", "r2")).unwrap();
assert_eq!(load().unwrap().refresh_token, "r2");
assert!(sink.state.lock().unsaved.is_none());
}
/// A locked keyring or a dismissed prompt is no fault of the connection.
#[test]
fn a_locked_keyring_is_not_reconnected() {
let _turn = mock_keyring();
write_stored(&stored_with("r")).unwrap();
let connects = KEYRING_CONNECTS.load(Ordering::SeqCst);
fail_next(keyring_core::Error::NoStorageAccess(
std::io::Error::other("locked").into(),
));
assert!(matches!(
load(),
Err(Error::Keyring(keyring_core::Error::NoStorageAccess(_)))
));
assert_eq!(KEYRING_CONNECTS.load(Ordering::SeqCst), connects);
assert_eq!(load().unwrap().refresh_token, "r");
}
/// The real Secret Service, restarted between two calls on one store.
///
/// Run inside a throwaway session bus, never against the desktop's
/// keyring. With gnome-keyring:
///
/// ```sh
/// echo -n pw | gnome-keyring-daemon --unlock --components=secrets
/// PDFS_SECRET_SERVICE_RESTART_TEST=1 \
/// PDFS_RESTART_PROVIDER='echo -n pw | gnome-keyring-daemon --replace --unlock --components=secrets' \
/// cargo test -p pdfs-core real_secret_service -- --ignored
/// ```
#[test]
#[ignore = "needs a throwaway Secret Service; see the doc comment"]
fn real_secret_service_survives_a_provider_restart() {
if std::env::var_os("PDFS_SECRET_SERVICE_RESTART_TEST").is_none() {
return;
}
let restart = std::env::var("PDFS_RESTART_PROVIDER").expect("PDFS_RESTART_PROVIDER");
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
let (service, user) = ("pdfs-test", "restart");
with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
let status = std::process::Command::new("sh")
.args(["-c", &restart])
.status()
.unwrap();
assert!(status.success(), "restarting the provider failed");
std::thread::sleep(Duration::from_secs(1));
let connects = KEYRING_CONNECTS.load(Ordering::SeqCst);
let read = with_keyring_entry(service, user, |e| e.get_password()).unwrap();
assert_eq!(read, "before");
assert_eq!(
KEYRING_CONNECTS.load(Ordering::SeqCst),
connects + 1,
"the provider kept the old session, so nothing was tested"
);
with_keyring_entry(service, user, |e| e.set_password("after")).unwrap();
let read = with_keyring_entry(service, user, |e| e.get_password()).unwrap();
assert_eq!(read, "after");
with_keyring_entry(service, user, |e| e.delete_credential()).unwrap();
keyring_core::unset_default_store();
}
/// B291: every save after the first replaces the keyring item, so a
/// provider that keeps an edited secret only in memory (oo7 before 0.7.0)
/// still has the last one after a restart, and only one item is left.
///
/// Run like [`real_secret_service_survives_a_provider_restart`], in a
/// throwaway session bus only.
#[test]
#[ignore = "needs a throwaway Secret Service; see real_secret_service_survives_a_provider_restart"]
fn real_secret_service_keeps_the_last_save_across_a_provider_restart() {
if std::env::var_os("PDFS_SECRET_SERVICE_RESTART_TEST").is_none() {
return;
}
let restart = std::env::var("PDFS_RESTART_PROVIDER").expect("PDFS_RESTART_PROVIDER");
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
for refresh in ["r1", "r2", "r3"] {
write_stored(&stored_with(refresh)).unwrap();
}
let status = std::process::Command::new("sh")
.args(["-c", &restart])
.status()
.unwrap();
assert!(status.success(), "restarting the provider failed");
std::thread::sleep(Duration::from_secs(1));
assert_eq!(load().unwrap().refresh_token, "r3");
let ss =
dbus_secret_service::SecretService::connect(dbus_secret_service::EncryptionType::Plain)
.unwrap();
let found = ss
.search_items(std::collections::HashMap::from([
("service", KEYRING_SERVICE),
("username", KEYRING_USER),
]))
.unwrap();
assert_eq!(found.unlocked.len() + found.locked.len(), 1);
with_keyring(|e| e.delete_credential()).unwrap();
keyring_core::unset_default_store();
}
fn stored_with(refresh: &str) -> StoredSession { fn stored_with(refresh: &str) -> StoredSession {
serde_json::from_str(&blob("").replace(r#""r""#, &format!("{refresh:?}"))).unwrap() serde_json::from_str(&blob("").replace(r#""r""#, &format!("{refresh:?}"))).unwrap()
} }
@@ -1273,12 +1548,7 @@ mod tests {
write_stored(&stored_with("r")).unwrap(); write_stored(&stored_with("r")).unwrap();
let sink = Arc::new(TokenSink::new("s", "r".into())); let sink = Arc::new(TokenSink::new("s", "r".into()));
let entry = keyring_entry().unwrap(); fail_next(keyring_core::Error::NoStorageAccess(
let cred = entry
.as_any()
.downcast_ref::<keyring_core::mock::Cred>()
.unwrap();
cred.set_error(keyring_core::Error::NoStorageAccess(
std::io::Error::other("locked").into(), std::io::Error::other("locked").into(),
)); ));
assert!(sink.rotated(tokens("a2", "r2")).is_err()); assert!(sink.rotated(tokens("a2", "r2")).is_err());
@@ -1306,6 +1576,42 @@ mod tests {
} }
} }
/// oo7 0.7.0 reports a locked collection's items as absent (upstream #614).
/// Treating that as logout loses the only live tokens (B284, issue #78).
#[test]
fn a_temporarily_missing_session_does_not_discard_a_rotation() {
let _turn = mock_keyring();
write_stored(&stored_with("r")).unwrap();
let sink = Arc::new(TokenSink::new("s", "r".into()));
fail_next(keyring_core::Error::NoEntry);
assert!(sink.rotated(tokens("a2", "r2")).is_err());
assert!(sink.state.lock().unsaved.is_some());
assert_eq!(load().unwrap().refresh_token, "r");
sink.flush().unwrap();
assert_eq!(load().unwrap().refresh_token, "r2");
assert!(sink.state.lock().unsaved.is_none());
}
#[test]
fn retrying_a_missing_session_never_recreates_it_or_overwrites_a_new_login() {
let _turn = mock_keyring();
let sink = TokenSink::new("s", "r".into());
sink.state.lock().unsaved = Some(tokens("a2", "r2"));
assert!(matches!(sink.flush(), Err(Error::NotLoggedIn)));
assert!(matches!(load(), Err(Error::NotLoggedIn)));
assert!(sink.state.lock().unsaved.is_some());
let mut login = stored_with("fresh");
login.session_id = "new".into();
write_stored(&login).unwrap();
sink.flush().unwrap();
assert!(sink.state.lock().unsaved.is_none());
assert_eq!(load().unwrap().refresh_token, "fresh");
}
#[test] #[test]
fn an_unsaved_rotation_goes_only_into_the_blob_it_was_refused_for() { fn an_unsaved_rotation_goes_only_into_the_blob_it_was_refused_for() {
let unsaved = UnsavedRotation { let unsaved = UnsavedRotation {
+71 -34
View File
@@ -579,6 +579,7 @@ impl ContentCache {
// the disk. // the disk.
cache.reseed_totals(); cache.reseed_totals();
cache.import_legacy_pins()?; cache.import_legacy_pins()?;
cache.set_budget(max_bytes);
Ok(cache) Ok(cache)
} }
@@ -1153,16 +1154,18 @@ impl ContentCache {
}; };
let mut skipped = 0usize; let mut skipped = 0usize;
while running > cap { while running > cap {
// Fetch a batch past whatever we have already skipped as exempt. // A whole batch can be pinned. Keep looking until the index has
let want = skipped + EVICT_BATCH; // no entries past the ones we have skipped.
let Ok(batch) = self.db.cache_eviction_candidates(kind, want) else { let Ok(batch) = self
.db
.cache_eviction_candidates(kind, EVICT_BATCH, skipped)
else {
break; break;
}; };
if batch.len() <= skipped { if batch.is_empty() {
break; // nothing new to consider break;
} }
let mut evicted_any = false; for (key, size) in batch {
for (key, size) in batch.into_iter().skip(skipped) {
if running <= cap { if running <= cap {
break; break;
} }
@@ -1170,14 +1173,18 @@ impl ContentCache {
skipped += 1; // counts toward the total, never a victim skipped += 1; // counts toward the total, never a victim
continue; continue;
} }
let _ = std::fs::remove_file(dir.join(&key)); if let Err(error) = std::fs::remove_file(dir.join(&key))
&& error.kind() != std::io::ErrorKind::NotFound
{
skipped += 1;
continue;
}
let _ = std::fs::remove_file(dir.join(format!("{key}.meta"))); let _ = std::fs::remove_file(dir.join(format!("{key}.meta")));
let _ = self.db.cache_remove(&key); if self.db.cache_remove(&key).is_err() {
skipped += 1;
continue;
}
running = running.saturating_sub(size); running = running.saturating_sub(size);
evicted_any = true;
}
if !evicted_any {
break; // every remaining candidate is exempt
} }
} }
// The index is the truth; realign the fast path with it. // The index is the truth; realign the fast path with it.
@@ -1405,7 +1412,7 @@ impl ContentCache {
.collect(); .collect();
let content_dir = self.content_dir.clone(); let content_dir = self.content_dir.clone();
// Force pool enforcement ignoring current cap check to free disk space immediately // Force pool enforcement ignoring current cap check to free disk space immediately
let Ok(list) = self.db.cache_eviction_candidates(KIND_BLOB, 10) else { let Ok(list) = self.db.cache_eviction_candidates(KIND_BLOB, 10, 0) else {
return; return;
}; };
for (key, bytes) in list { for (key, bytes) in list {
@@ -1883,13 +1890,13 @@ impl ContentCache {
// Pinned blobs (by cache key) are exempt from eviction. Resolves direct // Pinned blobs (by cache key) are exempt from eviction. Resolves direct
// pins plus every descendant of a recursively-pinned folder, hashed into // pins plus every descendant of a recursively-pinned folder, hashed into
// cache keys to match on-disk filenames. // cache keys to match on-disk filenames.
let pinned: HashSet<String> = self let pinned = match self.db.pinned_uids() {
.db Ok(uids) => uids.iter().map(|uid| Self::key_str(uid)).collect(),
.pinned_uids() Err(error) => {
.unwrap_or_default() tracing::warn!(%error, "reading pins for cache eviction failed");
.iter() return;
.map(|uid| Self::key_str(uid)) }
.collect(); };
let content_dir = self.content_dir.clone(); let content_dir = self.content_dir.clone();
self.enforce_pool(KIND_BLOB, &content_dir, Some(&pinned)); self.enforce_pool(KIND_BLOB, &content_dir, Some(&pinned));
} }
@@ -2010,8 +2017,7 @@ impl ContentCache {
} }
/// Retune the soft byte cap (`0` = unlimited) at runtime and immediately /// Retune the soft byte cap (`0` = unlimited) at runtime and immediately
/// enforce it: blobs and blocks are LRU-evicted back under the new cap (a /// enforce it across all three pools.
/// lower cap frees space now; a higher one is a no-op until the next store).
/// Called by the daemon when the Settings page changes the cache budget. /// Called by the daemon when the Settings page changes the cache budget.
pub fn set_budget(&self, bytes: u64) { pub fn set_budget(&self, bytes: u64) {
self.max_bytes.store(bytes, Ordering::Relaxed); self.max_bytes.store(bytes, Ordering::Relaxed);
@@ -2245,19 +2251,50 @@ mod tests {
// crash) but the same on-disk cache: reconcile repopulates from disk. // crash) but the same on-disk cache: reconcile repopulates from disk.
let db2 = Arc::new(Db::open_in_memory().unwrap()); let db2 = Arc::new(Db::open_in_memory().unwrap());
assert!(db2.cache_entries_by_kind("blob").unwrap().is_empty()); assert!(db2.cache_entries_by_kind("blob").unwrap().is_empty());
let c = ContentCache::open(content, pins, 8, db2.clone()).unwrap(); let c = ContentCache::open(content, pins, 0, db2.clone()).unwrap();
assert_eq!(db2.cache_entries_by_kind("blob").unwrap().len(), 3); assert_eq!(db2.cache_entries_by_kind("blob").unwrap().len(), 3);
// With the index rebuilt, a further store enforces the budget against the assert_eq!(c.usage(), 12);
// reconciled entries instead of leaking them. }
c.store(&uid("d"), 1, 4, b"dddd").unwrap();
let total: u64 = db2 #[test]
.cache_entries_by_kind("blob") fn reopening_trims_all_cache_pools_even_when_the_oldest_batch_is_pinned() {
.unwrap() let (c, _dir) = cache();
.iter() for i in 0..EVICT_BATCH {
.map(|(_, s)| s) let u = uid(&format!("pinned-{i}"));
.sum(); c.store(&u, 1, 1, b"p").unwrap();
assert!(total <= 8, "budget enforced after reconcile, total={total}"); c.add_pin(&u, Path::new("pinned"), false).unwrap();
std::fs::File::open(c.blob_path(&u))
.unwrap()
.set_modified(UNIX_EPOCH)
.unwrap();
}
let unpinned = uid("unpinned");
let payload = [0u8; 64];
let size = payload.len() as u64;
c.store(&unpinned, 1, size, &payload).unwrap();
c.store_block(&unpinned, 1, size, blk(size, 0), &payload)
.unwrap();
c.store_thumbnail(&unpinned, 1, 1, &payload).unwrap();
let recovery = c.recovery_dir.join("recovered.bin");
std::fs::write(&recovery, b"recovered write").unwrap();
let budget = (EVICT_BATCH as u64 * 100).div_ceil(SPLIT_BLOB);
let reopened = ContentCache::open(
c.content_dir.clone(),
c.pins_path.clone(),
budget,
c.db.clone(),
)
.unwrap();
assert_eq!(reopened.usage(), EVICT_BATCH as u64);
assert!(!reopened.blob_path(&unpinned).exists());
for i in 0..EVICT_BATCH {
assert!(reopened.is_cached(&uid(&format!("pinned-{i}")), 1, 1));
}
assert_eq!(std::fs::read(recovery).unwrap(), b"recovered write");
} }
/// An eviction removes the blob, then its tag. A crash in between, or a /// An eviction removes the blob, then its tag. A crash in between, or a
+249 -54
View File
@@ -391,6 +391,27 @@ impl AppConfig {
} }
} }
/// Apply `edit` to the ignore patterns in effect in the config at `path`,
/// under the config lock, and return the saved config. A list equal to the
/// built-in one is stored as unset, so it follows the built-in list in later
/// releases.
pub fn change_ignore_patterns_at(
path: &Path,
edit: impl FnOnce(&mut Vec<String>),
) -> Result<AppConfig> {
update_config_at(path, |config| {
let mut list = config.resolved_ignore_patterns();
edit(&mut list);
let builtin = list.len() == DEFAULT_IGNORE_PATTERNS.len()
&& list
.iter()
.zip(DEFAULT_IGNORE_PATTERNS)
.all(|(a, b)| a == b);
config.ignore_patterns = (!builtin).then_some(list);
config.clone()
})
}
/// Fail when the config file at `path` exists but does not parse, so that /// Fail when the config file at `path` exists but does not parse, so that
/// [`AppDirs::save_config`] never writes over settings it could not read. /// [`AppDirs::save_config`] never writes over settings it could not read.
fn refuse_to_replace_unreadable(path: &Path) -> Result<()> { fn refuse_to_replace_unreadable(path: &Path) -> Result<()> {
@@ -407,6 +428,116 @@ fn refuse_to_replace_unreadable(path: &Path) -> Result<()> {
} }
} }
/// [`AppDirs::load_config`] for the file at `path`.
fn load_config_at(path: &Path) -> AppConfig {
if path.exists() {
match std::fs::read_to_string(path)
.map_err(Error::from)
.and_then(|content| serde_json::from_str::<AppConfig>(&content).map_err(Error::from))
{
Ok(config) => return config,
Err(e) => {
// Preserve the original bytes for diagnosis/recovery. In
// particular, never replace a truncated config with defaults
// and silently lose mount, device, or ignore settings.
// `save_config` refuses to write over it for the same reason.
tracing::error!(path = %path.display(), error = %e, "config is unreadable; using in-memory defaults without overwriting it");
return AppConfig::default();
}
}
}
let default_config = AppConfig::default();
if let Err(e) = save_config_at(path, &default_config) {
tracing::warn!(path = %path.display(), error = %e, "could not write the default config");
}
default_config
}
/// [`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()?;
Ok(())
}
/// [`AppDirs::update_config`] for the file at `path`.
fn update_config_at<R>(path: &Path, change: impl FnOnce(&mut AppConfig) -> R) -> Result<R> {
let _lock = lock_config(path)?;
// Refuse before reading: an unreadable file loads as defaults, and the
// change must not be applied to those.
refuse_to_replace_unreadable(path)?;
let mut config = load_config_at(path);
let out = change(&mut config);
save_config_at(path, &config)?;
Ok(out)
}
/// How long [`lock_config`] waits for another writer. A change holds the lock
/// for one small read and write; anything longer is a stuck process, and the
/// setting is better reported as not saved than waited on forever.
const CONFIG_LOCK_WAIT: std::time::Duration = std::time::Duration::from_secs(5);
/// Take the lock that orders changes to the config file at `path`, held until
/// the returned file is dropped.
///
/// A separate `config.json.lock`, never the config file itself: that file is
/// replaced by a rename on every save, so a lock on it would guard a file
/// nobody reads any more.
fn lock_config(path: &Path) -> Result<std::fs::File> {
use std::os::fd::AsRawFd as _;
use std::os::unix::fs::OpenOptionsExt as _;
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut name = path.as_os_str().to_owned();
name.push(".lock");
let file = std::fs::OpenOptions::new()
.create(true)
.read(true)
.write(true)
.truncate(false)
.mode(0o600)
.open(PathBuf::from(name))?;
let deadline = std::time::Instant::now() + CONFIG_LOCK_WAIT;
loop {
// SAFETY: `file` owns the descriptor and outlives the call.
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0 {
return Ok(file);
}
let e = std::io::Error::last_os_error();
if e.raw_os_error() != Some(libc::EWOULDBLOCK) {
return Err(Error::Io(e));
}
if std::time::Instant::now() >= deadline {
return Err(Error::Other(format!(
"{} is being changed by another process; try again",
path.display()
)));
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
/// Resolved XDG locations for state, cache, and the default mountpoint. /// Resolved XDG locations for state, cache, and the default mountpoint.
pub struct AppDirs { pub struct AppDirs {
dirs: ProjectDirs, dirs: ProjectDirs,
@@ -426,65 +557,40 @@ impl AppDirs {
/// Load config from disk, creating default if missing. /// Load config from disk, creating default if missing.
pub fn load_config(&self) -> AppConfig { pub fn load_config(&self) -> AppConfig {
let path = self.config_path(); load_config_at(&self.config_path())
if path.exists() {
match std::fs::read_to_string(&path)
.map_err(Error::from)
.and_then(|content| {
serde_json::from_str::<AppConfig>(&content).map_err(Error::from)
}) {
Ok(config) => return config,
Err(e) => {
// Preserve the original bytes for diagnosis/recovery. In
// particular, never replace a truncated config with defaults
// and silently lose mount, device, or ignore settings.
// `save_config` refuses to write over it for the same reason.
tracing::error!(path = %path.display(), error = %e, "config is unreadable; using in-memory defaults without overwriting it");
return AppConfig::default();
}
}
}
let default_config = AppConfig::default();
if let Err(e) = self.save_config(&default_config) {
tracing::warn!(path = %path.display(), error = %e, "could not write the default config");
}
default_config
} }
/// Persist `config` to [`config_path`](Self::config_path), creating the /// Persist `config` to [`config_path`](Self::config_path), creating the
/// config dir if missing. The Settings page calls this after editing the /// config dir if missing.
/// cache budget or mountpoint; the daemon re-reads the file on its next mount.
/// ///
/// Refuses while the file on disk does not parse. Every caller loads, /// Refuses while the file on disk does not parse: [`load_config`](Self::load_config)
/// changes one field and saves, and [`load_config`](Self::load_config) /// gives defaults for a file it cannot read, so the first change after the
/// gives defaults for a file it cannot read, so the first change after /// file was damaged would write defaults over the mountpoint, the device
/// the file was damaged wrote defaults over the mountpoint, the device and /// and the ignore rules the user had (`docs/BUGS.md` B223).
/// the ignore rules the user had (`docs/BUGS.md` B223). ///
/// Writes the whole file. To change a setting, use
/// [`update_config`](Self::update_config), which does not lose another
/// process's change.
pub fn save_config(&self, config: &AppConfig) -> Result<()> { pub fn save_config(&self, config: &AppConfig) -> Result<()> {
let path = self.config_path(); save_config_at(&self.config_path(), config)
refuse_to_replace_unreadable(&path)?; }
let parent = path
.parent() /// Change settings in place: read the file, apply `change`, write it back,
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?; /// all under a lock, and return what `change` returned.
std::fs::create_dir_all(parent)?; ///
let nonce = std::time::SystemTime::now() /// The app, the tray and the daemon each write the file. Without the lock,
.duration_since(std::time::UNIX_EPOCH) /// two of them changing different settings at once both read the old file,
.map(|duration| duration.as_nanos()) /// and the one that wrote last undid the other's change (`docs/BUGS.md`
.unwrap_or(0); /// B292).
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id())); pub fn update_config<R>(&self, change: impl FnOnce(&mut AppConfig) -> R) -> Result<R> {
use std::os::unix::fs::OpenOptionsExt as _; update_config_at(&self.config_path(), change)
let mut file = std::fs::OpenOptions::new() }
.write(true)
.create_new(true) /// Apply `edit` to the ignore patterns in effect for every synced folder
.mode(0o600) /// and save them, returning the saved config. See
.open(&tmp)?; /// [`change_ignore_patterns_at`].
use std::io::Write as _; pub fn change_ignore_patterns(&self, edit: impl FnOnce(&mut Vec<String>)) -> Result<AppConfig> {
file.write_all(&serde_json::to_vec_pretty(config)?)?; change_ignore_patterns_at(&self.config_path(), edit)
file.sync_all()?;
std::fs::rename(&tmp, &path)?;
std::fs::File::open(parent)?.sync_all()?;
Ok(())
} }
/// This machine's id (e.g. ~/.config/proton-drive-linux/machine-id). See /// This machine's id (e.g. ~/.config/proton-drive-linux/machine-id). See
@@ -562,6 +668,12 @@ impl AppDirs {
self.state_dir().join("control.sock") self.state_dir().join("control.sock")
} }
/// The Google Photos import's last run: its archives and how it ended, so
/// an import cut short by a restart can be resumed.
pub fn takeout_import_path(&self) -> PathBuf {
self.state_dir().join("takeout-import.json")
}
/// Unix domain socket the tray uses to ensure single instance. /// Unix domain socket the tray uses to ensure single instance.
pub fn tray_socket(&self) -> PathBuf { pub fn tray_socket(&self) -> PathBuf {
self.state_dir().join("tray.sock") self.state_dir().join("tray.sock")
@@ -676,6 +788,89 @@ mod tests {
std::fs::metadata(p).unwrap().permissions().mode() & 0o777 std::fs::metadata(p).unwrap().permissions().mode() & 0o777
} }
/// Two writers changing different settings at once both keep their change
/// (`docs/BUGS.md` B292).
#[test]
fn concurrent_changes_to_different_settings_are_all_kept() {
let dir = std::env::temp_dir().join(format!(
"pdfs-cfg-race-{}-{:?}",
std::process::id(),
std::thread::current().id()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
let a = {
let path = path.clone();
std::thread::spawn(move || {
for i in 1..=100u64 {
update_config_at(&path, |c| c.upload_limit = Some(i)).unwrap();
}
})
};
let b = {
let path = path.clone();
std::thread::spawn(move || {
for i in 1..=100u64 {
update_config_at(&path, |c| c.download_limit = Some(i)).unwrap();
}
})
};
a.join().unwrap();
b.join().unwrap();
let config = load_config_at(&path);
assert_eq!(config.upload_limit, Some(100));
assert_eq!(config.download_limit, Some(100));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn ignore_patterns_back_at_the_built_in_list_are_stored_as_unset() {
let dir = std::env::temp_dir().join(format!(
"pdfs-cfg-ignore-{}-{:?}",
std::process::id(),
std::thread::current().id()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
let config = change_ignore_patterns_at(&path, |list| list.push("*.db".into())).unwrap();
assert_eq!(
config.ignore_patterns.as_ref().unwrap().last().unwrap(),
"*.db"
);
let config = change_ignore_patterns_at(&path, |list| list.retain(|p| p != "*.db")).unwrap();
assert_eq!(config.ignore_patterns, None);
assert_eq!(load_config_at(&path).ignore_patterns, None);
// An empty list is a choice, not the built-in one.
let config = change_ignore_patterns_at(&path, Vec::clear).unwrap();
assert_eq!(config.ignore_patterns, Some(Vec::new()));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_change_is_never_applied_over_an_unreadable_config() {
let dir = std::env::temp_dir().join(format!(
"pdfs-cfg-update-guard-{}-{:?}",
std::process::id(),
std::thread::current().id()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
std::fs::write(&path, br#"{"mountpoint": "/home/me/Pro"#).unwrap();
assert!(update_config_at(&path, |c| c.tray_hidden = true).is_err());
assert_eq!(
std::fs::read(&path).unwrap(),
br#"{"mountpoint": "/home/me/Pro"#
);
let _ = std::fs::remove_dir_all(&dir);
}
/// A damaged config must not be replaced by defaults the next time a /// A damaged config must not be replaced by defaults the next time a
/// setting changes (`docs/BUGS.md` B223). /// setting changes (`docs/BUGS.md` B223).
#[test] #[test]
File diff suppressed because it is too large. Load diff
+131 -32
View File
@@ -31,8 +31,30 @@ pub struct StoredAlbum {
impl Db { impl Db {
/// Replace the album listing wholesale, in the given order. /// Replace the album listing wholesale, in the given order.
pub fn albums_replace(&self, albums: &[StoredAlbum]) -> Result<()> { 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 mut conn = self.conn.lock();
let tx = conn.transaction()?; 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 // Contents of an album that no longer exists (unshared, deleted) go with
// it — otherwise they would linger forever, keyed by an album uid no // it — otherwise they would linger forever, keyed by an album uid no
// listing mentions again. // listing mentions again.
@@ -56,7 +78,11 @@ impl Db {
let mut stmt = tx.prepare( let mut stmt = tx.prepare(
"INSERT INTO albums "INSERT INTO albums
(uid, name, photo_count, cover_uid, last_activity, shared, seq) (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() { for (seq, album) in albums.iter().enumerate() {
stmt.execute(params![ 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()?; tx.commit()?;
Ok(()) Ok(true)
} }
/// The persisted album listing, in stored order. /// The persisted album listing, in stored order.
@@ -111,15 +140,44 @@ impl Db {
album_uid: &str, album_uid: &str,
items: &[(String, i64, Option<String>, Option<String>)], items: &[(String, i64, Option<String>, Option<String>)],
) -> Result<()> { ) -> 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 mut conn = self.conn.lock();
let tx = conn.transaction()?; 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( 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", WHERE album_uid = ?1",
)?; )?;
let rows = stmt.query_map([album_uid], |r| { 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<_>>()? rows.collect::<rusqlite::Result<_>>()?
}; };
@@ -128,15 +186,17 @@ impl Db {
{ {
let mut stmt = tx.prepare( let mut stmt = tx.prepare(
"INSERT INTO album_photos "INSERT INTO album_photos
(album_uid, uid, capture_time, name, media_type, kind, ratio, thumb_state, seq) (album_uid, uid, capture_time, name, media_type, kind, ratio, thumb_state, seq, resolved)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", 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() { for (seq, (uid, capture_time, name, media_type)) in items.iter().enumerate() {
let (ratio, thumb_state, learned_media) = let (ratio, thumb_state, learned_media, learned_name) = learned
learned .get(uid)
.get(uid) .cloned()
.cloned() .unwrap_or((None, THUMB_UNKNOWN, None, None));
.unwrap_or((None, THUMB_UNKNOWN, None)); let resolved = name.is_some();
let name = name.clone().or(learned_name);
let media_type = media_type.clone().or(learned_media); let media_type = media_type.clone().or(learned_media);
let kind = let kind =
crate::control::PhotoKind::classify(name.as_deref(), media_type.as_deref()); crate::control::PhotoKind::classify(name.as_deref(), media_type.as_deref());
@@ -150,11 +210,32 @@ impl Db {
ratio, ratio,
thumb_state, thumb_state,
seq as i64, seq as i64,
resolved,
])?; ])?;
} }
} }
if let Some((_, now)) = stamp {
super::photos::gallery_state(&tx, &format!("album_synced_ms:{album_uid}"), now)?;
}
tx.commit()?; 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. /// One page of an album's photos, in stored order.
@@ -163,31 +244,47 @@ impl Db {
album_uid: &str, album_uid: &str,
offset: usize, offset: usize,
limit: 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>> { ) -> Result<Vec<StoredPhoto>> {
let conn = self.read(); let conn = self.read();
let mut stmt = conn.prepare( let mut stmt = conn.prepare(
"SELECT uid, capture_time, name, ratio, thumb_state, kind FROM album_photos "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 let rows = stmt
.query_map(params![album_uid, limit as i64, offset as i64], |r| { .query_map(
Ok(StoredPhoto { params![album_uid, limit as i64, offset as i64, excluded],
uid: r.get(0)?, |r| {
capture_time: r.get(1)?, Ok(StoredPhoto {
name: r.get(2)?, uid: r.get(0)?,
ratio: r.get(3)?, capture_time: r.get(1)?,
thumb_state: r.get(4)?, name: r.get(2)?,
kind: crate::control::PhotoKind::from_i64(r.get(5)?), ratio: r.get(3)?,
// Album rows have no favorite state of their own: an album thumb_state: r.get(4)?,
// photo on someone else's volume is not in our timeline, and kind: crate::control::PhotoKind::from_i64(r.get(5)?),
// favouriting one is not supported yet anyway. // Album rows have no favorite state of their own: an album
favorite: false, // photo on someone else's volume is not in our timeline, and
// Nor are album rows grouped: an album is a list the user // favouriting one is not supported yet anyway.
// made, and it shows exactly what they put in it. favorite: false,
group_size: 1, // Nor are album rows grouped: an album is a list the user
has_raw: false, // 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<_>>()?; .collect::<rusqlite::Result<_>>()?;
Ok(rows) Ok(rows)
} }
@@ -247,6 +344,8 @@ impl Db {
// made, and it shows exactly what they put in it. // made, and it shows exactly what they put in it.
group_size: 1, group_size: 1,
has_raw: false, has_raw: false,
// Album rows carry no location.
place_id: None,
}) })
})? })?
.collect::<rusqlite::Result<_>>()?; .collect::<rusqlite::Result<_>>()?;
+5 -3
View File
@@ -108,7 +108,8 @@ impl Db {
Ok(total.max(0) as u64) Ok(total.max(0) as u64)
} }
/// The `limit` least-recently-accessed entries of `kind`, oldest first. /// The `limit` least-recently-accessed entries of `kind` after `offset`,
/// oldest first.
/// ///
/// Eviction wants a handful of victims, not the whole table. Bounded so a /// Eviction wants a handful of victims, not the whole table. Bounded so a
/// pass over a large cache does not read every row to drop a few, and so the /// pass over a large cache does not read every row to drop a few, and so the
@@ -118,13 +119,14 @@ impl Db {
&self, &self,
kind: &str, kind: &str,
limit: usize, limit: usize,
offset: usize,
) -> Result<Vec<(String, u64)>> { ) -> Result<Vec<(String, u64)>> {
let conn = self.read(); let conn = self.read();
let mut stmt = conn.prepare_cached( let mut stmt = conn.prepare_cached(
"SELECT cache_key, size_bytes FROM cache_entries "SELECT cache_key, size_bytes FROM cache_entries
WHERE kind = ?1 ORDER BY last_accessed ASC LIMIT ?2", WHERE kind = ?1 ORDER BY last_accessed ASC LIMIT ?2 OFFSET ?3",
)?; )?;
let rows = stmt.query_map(params![kind, limit as i64], |r| { let rows = stmt.query_map(params![kind, limit as i64, offset as i64], |r| {
Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?.max(0) as u64)) Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?.max(0) as u64))
})?; })?;
let mut out = Vec::new(); let mut out = Vec::new();
+22 -1
View File
@@ -11,7 +11,7 @@ use super::Db;
use crate::Result; use crate::Result;
/// Current schema version. Bump on every forward migration added below. /// 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 { impl Db {
pub(super) fn migrate(&self) -> Result<()> { 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( tx.execute(
"INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1) "INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1)
ON CONFLICT(key) DO UPDATE SET value = excluded.value", 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; UPDATE mount SET kind = NEW.kind WHERE sync_folder_id = NEW.id;
END; 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;
";
+23 -6
View File
@@ -445,6 +445,13 @@ fn is_in_memory(path: &Path) -> bool {
/// SQLite uses POSIX record locks, so the two never interact, and a lock file /// SQLite uses POSIX record locks, so the two never interact, and a lock file
/// left behind carries no state — the lock lives in the kernel and dies with /// left behind carries no state — the lock lives in the kernel and dies with
/// the process, however it exits. /// the process, however it exits.
///
/// A refusal is retried for [`LOCK_RETRY`] before it counts as another
/// daemon. A child this process spawns holds a copy of every descriptor from
/// its fork until its exec closes them, and `flock` belongs to the open file,
/// not the descriptor. So a lock the process has just let go of can stay held
/// for that moment, and a reopen right after a drop is refused
/// (`docs/BUGS.md` B290).
fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> { fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> {
if is_in_memory(path) { if is_in_memory(path) {
return Ok(None); return Ok(None);
@@ -456,22 +463,32 @@ fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> {
.truncate(false) .truncate(false)
.write(true) .write(true)
.open(&lock_path)?; .open(&lock_path)?;
// SAFETY: `file` owns the descriptor and outlives the call. let deadline = std::time::Instant::now() + LOCK_RETRY;
let rc = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) }; loop {
if rc != 0 { // SAFETY: `file` owns the descriptor and outlives the call.
let rc = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
if rc == 0 {
return Ok(Some(file));
}
let e = std::io::Error::last_os_error(); let e = std::io::Error::last_os_error();
if e.raw_os_error() == Some(libc::EWOULDBLOCK) { if e.raw_os_error() != Some(libc::EWOULDBLOCK) {
return Err(Error::Io(e));
}
if std::time::Instant::now() >= deadline {
return Err(Error::Other(format!( return Err(Error::Other(format!(
"another Proton Drive daemon is already using {} — \ "another Proton Drive daemon is already using {} — \
stop it first (`systemctl --user stop proton-drive.service`)", stop it first (`systemctl --user stop proton-drive.service`)",
path.display() path.display()
))); )));
} }
return Err(Error::Io(e)); std::thread::sleep(std::time::Duration::from_millis(20));
} }
Ok(Some(file))
} }
/// How long a refused single-writer lock is retried; far longer than a fork
/// takes to reach its exec, far shorter than anyone notices.
const LOCK_RETRY: std::time::Duration = std::time::Duration::from_millis(500);
fn lock_path_for(path: &Path) -> PathBuf { fn lock_path_for(path: &Path) -> PathBuf {
let mut name = path.as_os_str().to_owned(); let mut name = path.as_os_str().to_owned();
name.push(".lock"); name.push(".lock");
+58 -10
View File
@@ -252,9 +252,32 @@ const UID_NOW: &str = "COALESCE((SELECT uid FROM nodes WHERE lid = pending_op.li
const PARENT_NOW: &str = const PARENT_NOW: &str =
"COALESCE((SELECT uid FROM nodes WHERE lid = pending_op.parent_lid), parent_uid)"; "COALESCE((SELECT uid FROM nodes WHERE lid = pending_op.parent_lid), parent_uid)";
/// Whether any queued move takes a node out of the folder `source.uid`.
/// A move updates the local node tree immediately, so its original parent
/// comes from the queue, including while a worker is sending it to Drive.
const MOVES_OUT_OF_FOLDER: &str = "
COALESCE((SELECT is_dir FROM nodes WHERE uid = source.uid), 1) = 1
AND EXISTS (
WITH RECURSIVE folders(uid, lid) AS (
SELECT source.uid, (SELECT lid FROM nodes WHERE uid = source.uid)
UNION
SELECT n.uid, n.lid FROM nodes n JOIN folders f
ON n.parent_lid = f.lid OR (n.parent_lid IS NULL AND n.parent_uid = f.uid)
WHERE n.is_dir = 1
)
SELECT 1 FROM pending_op AS move
WHERE move.kind = 'rename'
AND CASE WHEN json_valid(move.meta_json)
THEN json_extract(move.meta_json, '$.original_parent_uid') END
IN (SELECT uid FROM folders)
AND move.parent_uid IS NOT NULL
AND NOT EXISTS (SELECT 1 FROM folders f
WHERE f.lid = move.parent_lid OR f.uid = move.parent_uid)
)";
/// The `WHERE` terms for a row a drain worker may claim once it falls due: not /// The `WHERE` terms for a row a drain worker may claim once it falls due: not
/// claimed already, no other claimed op on the same node, and not under a /// claimed already, no other claimed op on the same node, no pending creation
/// folder that has yet to land. /// of its parent, and no moves that still need a folder we are about to trash.
/// ///
/// One fragment for [`Db::claim_next_due_op`] and [`Db::earliest_due_at`]. A /// One fragment for [`Db::claim_next_due_op`] and [`Db::earliest_due_at`]. A
/// row the claim skips but the wait counts is due "now" for as long as it is /// row the claim skips but the wait counts is due "now" for as long as it is
@@ -265,7 +288,9 @@ fn claimable() -> String {
AND (parent_uid IS NULL OR substr({PARENT_NOW}, 1, {n}) <> '{v}~') AND (parent_uid IS NULL OR substr({PARENT_NOW}, 1, {n}) <> '{v}~')
AND uid NOT IN (SELECT uid FROM pending_op WHERE claimed_at <> 0) AND uid NOT IN (SELECT uid FROM pending_op WHERE claimed_at <> 0)
AND (lid IS NULL OR lid NOT IN ( AND (lid IS NULL OR lid NOT IN (
SELECT lid FROM pending_op WHERE claimed_at <> 0 AND lid IS NOT NULL))", SELECT lid FROM pending_op WHERE claimed_at <> 0 AND lid IS NOT NULL))
AND (kind <> 'trash' OR NOT EXISTS (
SELECT 1 FROM (SELECT {UID_NOW} AS uid) AS source WHERE {MOVES_OUT_OF_FOLDER}))",
v = LOCAL_VOLUME, v = LOCAL_VOLUME,
n = LOCAL_VOLUME.len() + 1, n = LOCAL_VOLUME.len() + 1,
) )
@@ -475,19 +500,40 @@ pub struct AttachedBlob {
} }
impl Db { impl Db {
/// Whether a queued trash still holds `name` somewhere. /// A folder can look empty locally while Drive still holds the queued
/// moves' source files. A trash has to go through the drain in that case.
pub fn has_pending_moves_out_of(&self, uid: &str) -> Result<bool> {
let conn = self.read();
Ok(conn
.prepare_cached(&format!(
"SELECT EXISTS (SELECT 1 FROM (SELECT ?1 AS uid) AS source
WHERE {MOVES_OUT_OF_FOLDER})"
))?
.query_row(params![uid], |row| row.get(0))?)
}
/// Whether a queued trash still holds `name` in `parent_uid`.
/// ///
/// A replacing rename or a delete-then-recreate queues the trash of the old /// A replacing rename or a delete-then-recreate queues the trash of the old
/// node ahead of the op that wants its name. With several drain workers the /// node ahead of the op that wants its name. With several drain workers the
/// later op can run first and find the name still taken; this tells it to /// later op can run first and find the name still taken; this tells it to
/// wait for the trash rather than land under a conflict name. /// wait for the trash rather than land under a conflict name. Older rows
pub fn has_pending_trash_named(&self, name: &str) -> Result<bool> { /// whose node and parent are unknown are matched by name alone.
pub fn has_pending_trash_named(&self, name: &str, parent_uid: Option<&str>) -> Result<bool> {
let conn = self.read(); let conn = self.read();
conn.query_row( conn.query_row(
"SELECT EXISTS( "SELECT EXISTS(
SELECT 1 FROM pending_op WHERE kind = ?1 AND name = ?2 SELECT 1 FROM pending_op AS p
)", WHERE p.kind = ?1 AND p.name = ?2
params![OP_TRASH, name], AND (?3 IS NULL OR ?3 = COALESCE(
(SELECT uid FROM nodes WHERE lid = p.parent_lid),
p.parent_uid,
(SELECT COALESCE(parent.uid, n.parent_uid)
FROM nodes n LEFT JOIN nodes parent ON parent.lid = n.parent_lid
WHERE n.uid = p.uid),
?3))
)",
params![OP_TRASH, name, parent_uid],
|row| row.get(0), |row| row.get(0),
) )
.map_err(Into::into) .map_err(Into::into)
@@ -1219,7 +1265,7 @@ impl Db {
/// the claim is a column: a row is offered to exactly one worker, and the /// the claim is a column: a row is offered to exactly one worker, and the
/// worker that took it is the only one that may retire, defer or fail it. /// worker that took it is the only one that may retire, defer or fail it.
/// ///
/// Two exclusions on top of [`next_due_op`](Self::next_due_op)'s: /// The selected row must also satisfy [`claimable`]:
/// ///
/// * `claimed_at = 0` — not already in flight somewhere else. /// * `claimed_at = 0` — not already in flight somewhere else.
/// * no *other* claimed op shares this `uid`. Ordering only has to hold per /// * no *other* claimed op shares this `uid`. Ordering only has to hold per
@@ -1229,6 +1275,8 @@ impl Db {
/// pending entry. `ORDER BY id` plus this exclusion gives per-uid serial /// pending entry. `ORDER BY id` plus this exclusion gives per-uid serial
/// order for free — the older op is claimed first and the newer one is /// order for free — the older op is claimed first and the newer one is
/// invisible until it retires. /// invisible until it retires.
/// * its destination folder already exists remotely.
/// * a folder trash waits for pending moves out of that folder's subtree.
/// ///
/// Select and mark are one transaction, so two workers cannot both see the /// Select and mark are one transaction, so two workers cannot both see the
/// row as unclaimed. /// row as unclaimed.
+404 -174
View File
@@ -1,10 +1,12 @@
//! The photos timeline: a flat, date-ordered projection of the photo share, //! The photos timeline: a flat, date-ordered projection of the photo share,
//! persisted so the gallery opens instantly instead of re-enumerating on launch. //! 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 std::collections::{HashMap, HashSet};
use proton_gallery_rs::grouping::{Grouped, group_photos, name_stem};
use super::Db; use super::Db;
use crate::Result; use crate::Result;
@@ -40,6 +42,8 @@ pub struct StoredPhoto {
/// Whether any member of the group is a camera raw file. The grid badges /// Whether any member of the group is a camera raw file. The grid badges
/// that, because the JPEG it shows is not the whole of what is stored. /// that, because the JPEG it shows is not the whole of what is stored.
pub has_raw: bool, pub has_raw: bool,
/// The town the photo was taken in, once its location has been read.
pub place_id: Option<u32>,
} }
/// A town photos were taken in: its GeoNames id (see [`crate::places`]), how /// A town photos were taken in: its GeoNames id (see [`crate::places`]), how
@@ -119,135 +123,6 @@ fn capture_day(conn: &rusqlite::Connection, capture_time: i64) -> Option<String>
.flatten() .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. /// 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 /// `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. /// camera raw file — one query rather than a second lookup per tile.
@@ -256,7 +131,7 @@ fn group_photos(entries: &[Grouped]) -> Vec<String> {
/// own group: the column is `NULL` until the next refresh computes it, and a /// own group: the column is `NULL` until the next refresh computes it, and a
/// `NULL` would otherwise match nothing and drop the photo off the page. /// `NULL` would otherwise match nothing and drop the photo off the page.
const PHOTO_SELECT: &str = "SELECT p.uid, p.capture_time, p.name, p.ratio, p.thumb_state, \ const PHOTO_SELECT: &str = "SELECT p.uid, p.capture_time, p.name, p.ratio, p.thumb_state, \
p.kind, p.favorite, g.n, g.raw \ p.kind, p.favorite, g.n, g.raw, p.place_id \
FROM photos p JOIN (SELECT COALESCE(group_key, uid) AS k, COUNT(*) AS n, \ FROM photos p JOIN (SELECT COALESCE(group_key, uid) AS k, COUNT(*) AS n, \
MAX(kind = 2) AS raw FROM photos GROUP BY k) g ON g.k = COALESCE(p.group_key, p.uid)"; MAX(kind = 2) AS raw FROM photos GROUP BY k) g ON g.k = COALESCE(p.group_key, p.uid)";
@@ -272,18 +147,290 @@ fn stored_photo(r: &rusqlite::Row<'_>) -> rusqlite::Result<StoredPhoto> {
favorite: r.get::<_, i64>(6)? != 0, favorite: r.get::<_, i64>(6)? != 0,
group_size: r.get::<_, i64>(7)?.max(1) as usize, group_size: r.get::<_, i64>(7)?.max(1) as usize,
has_raw: r.get::<_, i64>(8)? != 0, has_raw: r.get::<_, i64>(8)? != 0,
place_id: r.get(9)?,
}) })
} }
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 { 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 /// 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 — /// 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 /// 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 /// `resolved_at` is `None` was skipped or failed to resolve, and keeps
/// whatever is already stored rather than having it silently cleared. /// whatever is already stored rather than having it silently cleared.
pub fn photos_replace(&self, items: &[TimelineRow]) -> Result<()> { 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 mut conn = self.conn.lock();
let tx = conn.transaction()?; 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 // `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 // 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 // daemon may not know them when it replaces the timeline — because the
@@ -322,6 +469,7 @@ impl Db {
// Everything the insert and the grouping need, resolved once per photo. // Everything the insert and the grouping need, resolved once per photo.
let resolved: Vec<(&TimelineRow, Learned, crate::control::PhotoKind)> = items let resolved: Vec<(&TimelineRow, Learned, crate::control::PhotoKind)> = items
.iter() .iter()
.filter(|row| !tombstones.contains(&row.uid))
.map(|row| { .map(|row| {
let mut carried = learned.get(&row.uid).cloned().unwrap_or(Learned { let mut carried = learned.get(&row.uid).cloned().unwrap_or(Learned {
thumb_state: THUMB_UNKNOWN, thumb_state: THUMB_UNKNOWN,
@@ -366,7 +514,7 @@ impl Db {
.iter() .iter()
.map(|(row, carried, kind)| Grouped { .map(|(row, carried, kind)| Grouped {
uid: row.uid.clone(), uid: row.uid.clone(),
kind: *kind, raw: *kind == crate::control::PhotoKind::Raw,
main_uid: carried.main_uid.clone(), main_uid: carried.main_uid.clone(),
day: capture_day(&tx, row.capture_time), day: capture_day(&tx, row.capture_time),
stem: name_stem(carried.name.as_deref()), stem: name_stem(carried.name.as_deref()),
@@ -411,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()?; tx.commit()?;
Ok(()) Ok(true)
} }
/// The uids whose node metadata is already resolved, so a refresh can skip /// The uids whose node metadata is already resolved, so a refresh can skip
@@ -455,8 +607,16 @@ impl Db {
/// refresh. For a continuity loss, where the daemon cannot know what it /// refresh. For a continuity loss, where the daemon cannot know what it
/// missed, and for an explicit `refresh photos --full`. /// missed, and for an explicit `refresh photos --full`.
pub fn photos_mark_all_unresolved(&self) -> Result<usize> { pub fn photos_mark_all_unresolved(&self) -> Result<usize> {
let conn = self.conn.lock(); let mut conn = self.conn.lock();
Ok(conn.execute("UPDATE photos SET resolved_at = NULL", [])?) 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 /// Forget photos that have been trashed, so the gallery does not show them
@@ -471,23 +631,9 @@ impl Db {
} }
let mut conn = self.conn.lock(); let mut conn = self.conn.lock();
let tx = conn.transaction()?; let tx = conn.transaction()?;
let mut removed = 0; let removed = photos_delete_tx(&tx, uids)?;
{ let generation = photos_generation(&tx)?;
let mut photos = tx.prepare("DELETE FROM photos WHERE uid = ?1")?; gallery_state(&tx, PHOTOS_GENERATION, generation + 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)",
[],
)?;
tx.commit()?; tx.commit()?;
Ok(removed) Ok(removed)
} }
@@ -510,24 +656,42 @@ impl Db {
range: Option<(i64, i64)>, range: Option<(i64, i64)>,
favorites: bool, favorites: bool,
not_in_album: 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>> { ) -> Result<Vec<StoredPhoto>> {
let conn = self.read(); let conn = self.read();
// Built up so any combination of the optional filters is one indexed // Built up so any combination of the optional filters is one indexed
// query rather than a statement per case. // query rather than a statement per case.
let mut sql = String::from(PHOTO_SELECT); 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(); 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) { if kind != Some(crate::control::PhotoKind::Raw) {
conds.push("p.uid = COALESCE(p.group_key, p.uid)".to_string()); conds.push("p.uid = COALESCE(p.group_key, p.uid)".to_string());
} }
if let Some(k) = kind { if let Some(k) = kind {
binds.push(k.as_i64()); binds.push((k.as_i64()).into());
conds.push(format!("p.kind = ?{}", binds.len())); conds.push(format!("p.kind = ?{}", binds.len()));
} }
if let Some((from, to)) = range { if let Some((from, to)) = range {
binds.push(from); binds.push((from).into());
conds.push(format!("p.capture_time >= ?{}", binds.len())); conds.push(format!("p.capture_time >= ?{}", binds.len()));
binds.push(to); binds.push((to).into());
conds.push(format!("p.capture_time < ?{}", binds.len())); conds.push(format!("p.capture_time < ?{}", binds.len()));
} }
if favorites { if favorites {
@@ -546,9 +710,9 @@ impl Db {
sql.push_str(" WHERE "); sql.push_str(" WHERE ");
sql.push_str(&conds.join(" AND ")); sql.push_str(&conds.join(" AND "));
} }
binds.push(limit as i64); binds.push((limit as i64).into());
let limit_pos = binds.len(); let limit_pos = binds.len();
binds.push(offset as i64); binds.push((offset as i64).into());
let offset_pos = binds.len(); let offset_pos = binds.len();
sql.push_str(&format!( sql.push_str(&format!(
" ORDER BY p.seq LIMIT ?{limit_pos} OFFSET ?{offset_pos}" " ORDER BY p.seq LIMIT ?{limit_pos} OFFSET ?{offset_pos}"
@@ -577,6 +741,25 @@ impl Db {
Ok(rows) 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 /// 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 /// per group. Only for whole-library passes (the photo re-date); the gallery
/// pages with [`Db::photos_page`]. /// pages with [`Db::photos_page`].
@@ -598,27 +781,38 @@ impl Db {
pub fn photos_months( pub fn photos_months(
&self, &self,
kind: Option<crate::control::PhotoKind>, 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)>> { ) -> Result<Vec<(i32, i32, usize)>> {
let conn = self.read(); let conn = self.read();
// The scrubber has to agree with the page it scrubs, so it counts what // The scrubber has to agree with the page it scrubs, so it counts what
// the page shows: groups everywhere except on the Raw tab. // the page shows: groups everywhere except on the Raw tab.
let (filter, binds): (&str, Vec<i64>) = match kind { let filter = match kind {
Some(crate::control::PhotoKind::Raw) => (" WHERE kind = 2", Vec::new()), Some(crate::control::PhotoKind::Raw) => "kind = ?2",
Some(k) => ( Some(_) => "uid = COALESCE(group_key, uid) AND kind = ?2",
" WHERE uid = COALESCE(group_key, uid) AND kind = ?1", None => "uid = COALESCE(group_key, uid) AND ?2 IS NULL",
vec![k.as_i64()],
),
None => (" WHERE uid = COALESCE(group_key, uid)", Vec::new()),
}; };
let sql = format!( 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, \ CAST(strftime('%m', capture_time, 'unixepoch', 'localtime') AS INTEGER) AS m, \
COUNT(*) \ 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 mut stmt = conn.prepare(&sql)?;
let rows = stmt let rows = stmt
.query_map(rusqlite::params_from_iter(binds), |r| { .query_map(params![excluded, kind.map(|kind| kind.as_i64())], |r| {
Ok(( Ok((
r.get::<_, i32>(0)?, r.get::<_, i32>(0)?,
r.get::<_, i32>(1)?, r.get::<_, i32>(1)?,
@@ -634,6 +828,15 @@ impl Db {
/// pick the date, and its own year is left out, because today's photos are /// 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. /// 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>> { 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 conn = self.read();
let sql = format!( let sql = format!(
"{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) \ "{PHOTO_SELECT} WHERE p.uid = COALESCE(p.group_key, p.uid) \
@@ -641,11 +844,12 @@ impl Db {
= strftime('%m-%d', ?1, 'unixepoch', 'localtime') \ = strftime('%m-%d', ?1, 'unixepoch', 'localtime') \
AND strftime('%Y', p.capture_time, 'unixepoch', 'localtime') \ AND strftime('%Y', p.capture_time, 'unixepoch', 'localtime') \
< strftime('%Y', ?1, 'unixepoch', 'localtime') \ < strftime('%Y', ?1, 'unixepoch', 'localtime') \
AND p.uid NOT IN (SELECT value FROM json_each(?3))
ORDER BY p.seq LIMIT ?2" ORDER BY p.seq LIMIT ?2"
); );
let mut stmt = conn.prepare(&sql)?; let mut stmt = conn.prepare(&sql)?;
let rows = stmt 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<_>>()?; .collect::<rusqlite::Result<_>>()?;
Ok(rows) Ok(rows)
} }
@@ -654,6 +858,10 @@ impl Db {
/// cover, most photographed first. Counted per group, like the timeline; /// cover, most photographed first. Counted per group, like the timeline;
/// photos without a location, or taken far from any town, are in none. /// photos without a location, or taken far from any town, are in none.
pub fn photo_places(&self) -> Result<Vec<StoredPlace>> { 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 rows: Vec<(u32, usize, String)> = {
let conn = self.read(); let conn = self.read();
// SQLite fills the bare `uid` from the row `MIN(seq)` picked, which // SQLite fills the bare `uid` from the row `MIN(seq)` picked, which
@@ -661,9 +869,10 @@ impl Db {
let mut stmt = conn.prepare( let mut stmt = conn.prepare(
"SELECT place_id, COUNT(*), uid, MIN(seq) FROM photos \ "SELECT place_id, COUNT(*), uid, MIN(seq) FROM photos \
WHERE uid = COALESCE(group_key, uid) AND place_id IS NOT NULL \ 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)", 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)?)) Ok((r.get(0)?, r.get::<_, i64>(1)? as usize, r.get(2)?))
})? })?
.collect::<rusqlite::Result<_>>()? .collect::<rusqlite::Result<_>>()?
@@ -692,15 +901,29 @@ impl Db {
id: u32, id: u32,
offset: usize, offset: usize,
limit: 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>> { ) -> Result<Vec<StoredPhoto>> {
let conn = self.read(); let conn = self.read();
let sql = format!( 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" ORDER BY p.seq LIMIT ?2 OFFSET ?3"
); );
let mut stmt = conn.prepare(&sql)?; let mut stmt = conn.prepare(&sql)?;
let rows = stmt 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<_>>()?; .collect::<rusqlite::Result<_>>()?;
Ok(rows) Ok(rows)
} }
@@ -881,6 +1104,10 @@ impl Db {
/// Per-tab counts for the Photos page subtitle: `(photos, videos, raw)`. /// Per-tab counts for the Photos page subtitle: `(photos, videos, raw)`.
pub fn photos_counts(&self) -> Result<(usize, usize, usize)> { 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; use crate::control::PhotoKind;
let conn = self.read(); let conn = self.read();
// Photos and Videos count groups — one shot is one entry, however many // Photos and Videos count groups — one shot is one entry, however many
@@ -888,9 +1115,12 @@ impl Db {
// them individually. // them individually.
let mut stmt = conn.prepare( let mut stmt = conn.prepare(
"SELECT kind, COUNT(*) FROM photos \ "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); let (mut photos, mut videos, mut raw) = (0usize, 0usize, 0usize);
for row in rows { for row in rows {
let (kind, n) = row?; let (kind, n) = row?;
+200 -5
View File
@@ -337,6 +337,10 @@ fn places_group_photos_by_the_nearest_town() {
.map(|p| p.uid) .map(|p| p.uid)
.collect(); .collect();
assert_eq!(berlin, ["b2", "b1-jpeg"]); 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. /// A town's photos come with where each was taken, one per RAW+JPEG shot.
@@ -363,6 +367,23 @@ fn place_photos_carry_their_own_location() {
); );
} }
/// A timeline photo names the town it was taken in, so the viewer can show it;
/// one without a location names none.
#[test]
fn timeline_photos_name_their_town() {
let db = Db::open_in_memory().unwrap();
db.photos_replace(&[
located("b", 500, "IMG_5.JPG", BERLIN),
TimelineRow::new("n", 400),
])
.unwrap();
let berlin = db.photo_places().unwrap()[0].id;
let mut photos = db.photos_by_uid(&["b".into(), "n".into()]).unwrap();
photos.sort_by(|a, b| a.uid.cmp(&b.uid));
let towns: Vec<Option<u32>> = photos.iter().map(|photo| photo.place_id).collect();
assert_eq!(towns, [Some(berlin), None]);
}
/// A refresh that skips an already-resolved photo keeps where it was taken; one /// A refresh that skips an already-resolved photo keeps where it was taken; one
/// that reads the node again takes what the node now says. /// that reads the node again takes what the node now says.
#[test] #[test]
@@ -2723,15 +2744,34 @@ fn atomic_trash_replacement_returns_owned_blobs_after_commit() {
#[test] #[test]
fn a_queued_trash_holds_its_name_until_it_lands() { fn a_queued_trash_holds_its_name_until_it_lands() {
let db = Db::open_in_memory().unwrap(); let db = Db::open_in_memory().unwrap();
db.upsert_node(&file("held-name", "root", "report.txt", 1))
.unwrap();
let node = uid("held-name").to_string(); let node = uid("held-name").to_string();
assert!(!db.has_pending_trash_named("report.txt").unwrap()); let root = uid("root").to_string();
assert!(
!db.has_pending_trash_named("report.txt", Some(&root))
.unwrap()
);
let (trash_id, _) = db.replace_ops_with_trash(&node, "report.txt", 1).unwrap(); let (trash_id, _) = db.replace_ops_with_trash(&node, "report.txt", 1).unwrap();
assert!(db.has_pending_trash_named("report.txt").unwrap()); assert!(
assert!(!db.has_pending_trash_named("other.txt").unwrap()); db.has_pending_trash_named("report.txt", Some(&root))
.unwrap()
);
assert!(
!db.has_pending_trash_named("other.txt", Some(&root))
.unwrap()
);
assert!(
!db.has_pending_trash_named("report.txt", Some(&uid("other").to_string()))
.unwrap()
);
db.delete_op(trash_id).unwrap(); db.delete_op(trash_id).unwrap();
assert!(!db.has_pending_trash_named("report.txt").unwrap()); assert!(
!db.has_pending_trash_named("report.txt", Some(&root))
.unwrap()
);
} }
/// A create that found its name held by a queued trash backed off. The trash /// A create that found its name held by a queued trash backed off. The trash
@@ -6077,7 +6117,7 @@ fn cache_eviction_candidates_are_lru_ordered_and_limited() {
} }
db.cache_touch("other", "block", 100, 0).unwrap(); db.cache_touch("other", "block", 100, 0).unwrap();
let batch = db.cache_eviction_candidates("blob", 3).unwrap(); let batch = db.cache_eviction_candidates("blob", 3, 0).unwrap();
assert_eq!(batch.len(), 3, "honours the limit"); assert_eq!(batch.len(), 3, "honours the limit");
let keys: Vec<&str> = batch.iter().map(|(k, _)| k.as_str()).collect(); let keys: Vec<&str> = batch.iter().map(|(k, _)| k.as_str()).collect();
assert_eq!(keys, ["k9", "k8", "k7"], "least-recently-accessed first"); assert_eq!(keys, ["k9", "k8", "k7"], "least-recently-accessed first");
@@ -6908,6 +6948,54 @@ fn two_workers_never_share_a_node() {
); );
} }
#[test]
fn trashing_a_folder_waits_for_moves_out_of_its_subtree() {
let db = Db::open_in_memory().unwrap();
db.upsert_nodes(&[
folder("root", None, "My Files"),
folder("source", Some("root"), "source"),
folder("nested", Some("source"), "nested"),
folder("destination", Some("root"), "destination"),
file("photo", "destination", "photo.jpg", 1),
])
.unwrap();
let source = uid("source").to_string();
let destination = uid("destination").to_string();
let (move_id, _) = db
.enqueue_op(&PendingOp {
kind: OP_RENAME.to_string(),
uid: uid("photo").to_string(),
parent_uid: Some(destination.clone()),
name: Some("photo.jpg".into()),
blob_path: None,
meta_json: Some(
serde_json::to_string(&RenameMeta {
original_parent_uid: uid("nested").to_string(),
original_name: Some("photo.jpg".into()),
})
.unwrap(),
),
next_attempt_at: 20,
..bulk_op(0, &destination)
})
.unwrap();
assert!(db.has_pending_moves_out_of(&source).unwrap());
assert!(!db.has_pending_moves_out_of(&destination).unwrap());
assert!(
!db.has_pending_moves_out_of(&uid("root").to_string())
.unwrap()
);
let (trash_id, _) = db.replace_ops_with_trash(&source, "source", 2).unwrap();
assert!(db.claim_next_due_op(10).unwrap().is_none());
assert_eq!(db.earliest_due_at().unwrap(), Some(20));
assert_eq!(db.claim_next_due_op(20).unwrap().unwrap().id, move_id);
assert!(db.claim_next_due_op(20).unwrap().is_none());
assert_eq!(db.earliest_due_at().unwrap(), None);
db.delete_op(move_id).unwrap();
assert_eq!(db.claim_next_due_op(20).unwrap().unwrap().id, trash_id);
}
#[test] #[test]
fn claims_do_not_survive_the_process_that_took_them() { fn claims_do_not_survive_the_process_that_took_them() {
let db = Db::open_in_memory().unwrap(); let db = Db::open_in_memory().unwrap();
@@ -7081,6 +7169,29 @@ fn a_raw_and_its_jpeg_are_one_entry_in_the_grid() {
["jpeg", "raw"] ["jpeg", "raw"]
); );
assert_eq!(db.photos_group("alone").unwrap().len(), 1); 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 /// Pixel names the two files of one raw capture after the role each plays, so
@@ -7761,3 +7872,87 @@ fn migration_v45_keeps_existing_device_folders_and_location_ids() {
db.migrate().unwrap(); db.migrate().unwrap();
assert_eq!(db.mount_list().unwrap().len(), 2); 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));
}
-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);
}
}
+4 -4
View File
@@ -10,7 +10,6 @@ pub mod config;
pub mod control; pub mod control;
pub mod db; pub mod db;
pub mod error; pub mod error;
pub mod exiftime;
pub mod kernelkey; pub mod kernelkey;
pub mod keycheck; pub mod keycheck;
pub mod localindex; pub mod localindex;
@@ -19,20 +18,21 @@ pub mod mountfail;
pub mod mountpoint; pub mod mountpoint;
pub mod mounts; pub mod mounts;
pub mod opener; pub mod opener;
pub mod places;
pub mod profile; pub mod profile;
pub mod sdkcache; pub mod sdkcache;
pub mod search; pub mod search;
mod secretservice;
pub mod service; pub mod service;
pub mod shell; pub mod shell;
pub mod similar;
pub mod syncignore; pub mod syncignore;
pub mod syncroot; pub mod syncroot;
pub mod takeout;
pub mod timestamp; pub mod timestamp;
pub mod tray; pub mod tray;
pub mod update; 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 access::{Access, access_for, perm_bits};
pub use error::{CoreError, CoreResult, Error, Result}; pub use error::{CoreError, CoreResult, Error, Result};
+56 -12
View File
@@ -206,26 +206,23 @@ pub fn reap(mut child: std::process::Child) {
}); });
} }
/// [`open`] with the policy from the user's `config.json`, read once per /// [`open`] with the policy from the user's `config.json`, read again on
/// process. For callers that open the occasional path and have no reason to /// every call: the file is small, a path is opened by hand, and a rule changed
/// carry a policy around; long-lived windows should hold their own copy. /// in Preferences then applies to the next file opened, without a restart.
pub fn open_default(path: &Path, is_dir: bool) { pub fn open_default(path: &Path, is_dir: bool) {
open(default_policy(), path, is_dir); open(&default_policy(), path, is_dir);
} }
/// [`open_default`] matching the rules against `name` — see /// [`open_default`] matching the rules against `name` — see
/// [`OpenWith::command_for_named`]. /// [`OpenWith::command_for_named`].
pub fn open_default_named(path: &Path, name: &str, is_dir: bool) { pub fn open_default_named(path: &Path, name: &str, is_dir: bool) {
open_named(default_policy(), path, name, is_dir); open_named(&default_policy(), path, name, is_dir);
} }
fn default_policy() -> &'static OpenWith { fn default_policy() -> OpenWith {
static POLICY: std::sync::OnceLock<OpenWith> = std::sync::OnceLock::new(); crate::config::AppDirs::new()
POLICY.get_or_init(|| { .map(|dirs| dirs.load_config().resolved_open_with())
crate::config::AppDirs::new() .unwrap_or_default()
.map(|dirs| dirs.load_config().resolved_open_with())
.unwrap_or_default()
})
} }
/// `$PDFS_TERMINAL`, then `$TERMINAL`, then the first [`KNOWN_TERMINALS`] entry /// `$PDFS_TERMINAL`, then `$TERMINAL`, then the first [`KNOWN_TERMINALS`] entry
@@ -266,6 +263,33 @@ fn with_exec_flag(program: &str) -> Vec<String> {
argv argv
} }
/// Split a command line typed by the user into argv, the way a shell would:
/// quotes keep spaces, nothing is expanded. `None` for an unclosed quote.
pub fn parse_command(line: &str) -> Option<Vec<String>> {
shell_words::split(line).ok()
}
/// Show `argv` as one line that [`parse_command`] turns back into it.
pub fn format_command(argv: &[String]) -> String {
shell_words::join(argv)
}
/// Whether the program `argv` starts with can be found: an absolute or
/// relative path to a file, or a name on `PATH`. A `$VAR` program counts as
/// found, since it is looked up only when a file is opened.
pub fn command_available(argv: &[String]) -> bool {
let Some(program) = argv.first() else {
return false;
};
if program.starts_with('$') {
return true;
}
if program.contains('/') {
return Path::new(program).is_file();
}
on_path(program)
}
fn on_path(program: &str) -> bool { fn on_path(program: &str) -> bool {
let Some(path) = std::env::var_os("PATH") else { let Some(path) = std::env::var_os("PATH") else {
return false; return false;
@@ -703,4 +727,24 @@ mod tests {
// Unknown terminals get the near-universal `-e`. // Unknown terminals get the near-universal `-e`.
assert_eq!(with_exec_flag("mystery-term"), vec!["mystery-term", "-e"]); assert_eq!(with_exec_flag("mystery-term"), vec!["mystery-term", "-e"]);
} }
#[test]
fn a_typed_command_line_round_trips() {
let argv = parse_command("alacritty -e 'my editor' --flag").unwrap();
assert_eq!(argv, ["alacritty", "-e", "my editor", "--flag"]);
assert_eq!(parse_command(&format_command(&argv)).unwrap(), argv);
assert_eq!(parse_command("nvim 'unclosed"), None);
assert_eq!(parse_command(" ").unwrap(), Vec::<String>::new());
}
#[test]
fn a_command_is_available_when_its_program_is() {
assert!(command_available(&["sh".to_string()]));
assert!(command_available(&["$EDITOR".to_string()]));
assert!(!command_available(&[]));
assert!(!command_available(
&["pdfs-no-such-program-xyz".to_string()]
));
assert!(!command_available(&["/nonexistent/program".to_string()]));
}
} }
-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
@@ -0,0 +1,135 @@
//! 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]]);
}
}
+498
View File
@@ -30,6 +30,11 @@ use ignore::gitignore::{Gitignore, GitignoreBuilder};
/// them. Version-control metadata, dependency and build trees, editor /// them. Version-control metadata, dependency and build trees, editor
/// leftovers, and OS turds — none of which belong on Drive, all of which are /// leftovers, and OS turds — none of which belong on Drive, all of which are
/// large or rewritten constantly. /// large or rewritten constantly.
///
/// The second half is what Nextcloud, Dropbox and Syncthing leave out as well:
/// files a desktop, a file system or a program in the middle of a write leaves
/// behind, never anything a person made. Every one is in a test, next to a real
/// file of a similar name that must stay synced.
pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[ pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[
".git/", ".git/",
".hg/", ".hg/",
@@ -43,6 +48,23 @@ pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[
"*.tmp", "*.tmp",
".DS_Store", ".DS_Store",
"Thumbs.db", "Thumbs.db",
// Folder settings of Windows and KDE's Dolphin.
"desktop.ini",
".directory",
// Trash folders and file-system leftovers: a file deleted while open on a
// FUSE or NFS mount lives on under one of these names until it is closed.
".Trash-*/",
".Trashes/",
".Spotlight-V100/",
".fuse_hidden*",
".nfs*",
// Downloads and saves still being written.
"*.part",
"*.crdownload",
"*.kate-swp",
// Office lock files: LibreOffice's `.~lock.<name>#`, Microsoft Office's `~$<name>`.
".~lock.*#",
"~$*",
]; ];
/// Suffixes that mean a file is incomplete *by construction*: only the program /// Suffixes that mean a file is incomplete *by construction*: only the program
@@ -119,6 +141,225 @@ pub fn is_scratch_name(name: &str) -> bool {
/// Filenames accepted as a folder's ignore file, in precedence order. /// Filenames accepted as a folder's ignore file, in precedence order.
const IGNORE_FILE_NAMES: &[&str] = &[".pdfsignore", ".protonignore"]; const IGNORE_FILE_NAMES: &[&str] = &[".pdfsignore", ".protonignore"];
/// Whether `line` is a rule [`IgnoreRules::load`] accepts: a pattern, a
/// comment or a blank line. The error says what is wrong with it.
pub fn check_pattern(line: &str) -> Result<(), String> {
GitignoreBuilder::new("/")
.add_line(None, line)
.map(|_| ())
.map_err(|e| e.to_string())
}
/// The lines of an ignore file that [`IgnoreRules::load`] would skip, by line
/// number (from 1), with what is wrong with each.
pub fn check_rules(text: &str) -> Vec<(usize, String)> {
text.lines()
.enumerate()
.filter_map(|(i, line)| check_pattern(line).err().map(|e| (i + 1, e)))
.collect()
}
/// A synced folder's own ignore file, read so it can be edited and written
/// back. See [`FolderRules::read`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FolderRules {
/// The file the rules are in: the one in use, or `.pdfsignore` when there
/// is none yet.
pub path: std::path::PathBuf,
/// The rules as read; empty when there is no file. `None` means there was
/// no file, which [`write`](Self::write) checks is still so.
pub text: Option<String>,
}
/// Why [`FolderRules::write`] did not write.
#[derive(Debug)]
pub enum WriteRulesError {
/// The file changed after it was read, for example by an edit on another
/// computer that sync brought in. The rules on disk are the new ones.
Changed,
/// Reading or writing failed.
Io(std::io::Error),
}
impl std::fmt::Display for WriteRulesError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Changed => f.write_str("the file changed since it was opened"),
Self::Io(e) => e.fmt(f),
}
}
}
impl std::error::Error for WriteRulesError {}
impl From<std::io::Error> for WriteRulesError {
fn from(e: std::io::Error) -> Self {
Self::Io(e)
}
}
impl FolderRules {
/// Read the ignore file of the folder at `root`, the same one
/// [`IgnoreRules::load`] uses.
pub fn read(root: &Path) -> std::io::Result<Self> {
for name in IGNORE_FILE_NAMES {
let path = root.join(name);
match std::fs::read_to_string(&path) {
Ok(text) => {
return Ok(Self {
path,
text: Some(text),
});
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
Err(e) => return Err(e),
}
}
// Like `load`, a missing folder reads as one without rules; the write
// is what fails then.
Ok(Self {
path: root.join(IGNORE_FILE_NAMES[0]),
text: None,
})
}
/// Replace the rules with `text`, unless the file changed since it was
/// read. Rules that are all blank remove the file, so a folder never keeps
/// an empty one around.
///
/// Written to a temporary file and renamed over the old one, so the sync
/// pass reading the rules at the same moment sees the old ones or the new
/// ones, never half of them.
pub fn write(&self, text: &str) -> Result<(), WriteRulesError> {
let now = match std::fs::read_to_string(&self.path) {
Ok(now) => Some(now),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
Err(e) => return Err(e.into()),
};
if now != self.text {
return Err(WriteRulesError::Changed);
}
if text.trim().is_empty() {
return match std::fs::remove_file(&self.path) {
Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(e.into()),
_ => Ok(()),
};
}
let Some(name) = self.path.file_name() else {
return Err(std::io::Error::other("the rules path has no file name").into());
};
let mut tmp_name = std::ffi::OsString::from(".");
tmp_name.push(name);
tmp_name.push(format!(".tmp-{}", std::process::id()));
let tmp = self.path.with_file_name(tmp_name);
let mut body = text.to_string();
if !body.ends_with('\n') {
body.push('\n');
}
let written = std::fs::write(&tmp, body).and_then(|()| std::fs::rename(&tmp, &self.path));
if written.is_err() {
let _ = std::fs::remove_file(&tmp);
}
Ok(written?)
}
/// The patterns in the rules: every line that is not blank or a comment,
/// trimmed of surrounding white space.
pub fn patterns(&self) -> Vec<&str> {
self.text
.as_deref()
.unwrap_or_default()
.lines()
.map(str::trim)
.filter(|line| !line.is_empty() && !line.starts_with('#'))
.collect()
}
}
/// How often [`add_folder_pattern`] and [`remove_folder_pattern`] read the
/// rules again when they changed between the read and the write.
const RULES_RETRIES: usize = 3;
/// Add `pattern` at the end of the own rules of the folder at `root`, keeping
/// every other line and comment. Says whether it added it: a pattern already
/// there is left alone.
pub fn add_folder_pattern(root: &Path, pattern: &str) -> std::io::Result<bool> {
let pattern = pattern.trim();
edit_folder_rules(root, |rules| {
if rules.patterns().contains(&pattern) {
return None;
}
let mut text = rules.text.clone().unwrap_or_default();
if !text.is_empty() && !text.ends_with('\n') {
text.push('\n');
}
text.push_str(pattern);
text.push('\n');
Some(text)
})
}
/// Remove every line that is `pattern` from the own rules of the folder at
/// `root`. Says whether there was one.
pub fn remove_folder_pattern(root: &Path, pattern: &str) -> std::io::Result<bool> {
let pattern = pattern.trim();
edit_folder_rules(root, |rules| {
if !rules.patterns().contains(&pattern) {
return None;
}
let text = rules.text.as_deref().unwrap_or_default();
Some(
text.lines()
.filter(|line| line.trim() != pattern)
.map(|line| format!("{line}\n"))
.collect(),
)
})
}
/// Read the folder's rules, let `edit` return their new text (or `None` to
/// leave them), and write it. Rules that changed in between, such as by sync
/// bringing in an edit from another computer, are read again and edited anew.
fn edit_folder_rules(
root: &Path,
edit: impl Fn(&FolderRules) -> Option<String>,
) -> std::io::Result<bool> {
for _ in 0..RULES_RETRIES {
let rules = FolderRules::read(root)?;
let Some(text) = edit(&rules) else {
return Ok(false);
};
match rules.write(&text) {
Ok(()) => return Ok(true),
Err(WriteRulesError::Changed) => continue,
Err(WriteRulesError::Io(e)) => return Err(e),
}
}
Err(std::io::Error::other(
"the rules kept changing while they were being saved",
))
}
/// Where a rule that decided about a path came from.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RuleSource {
/// The rules for every synced folder (`ignore_patterns`).
AllFolders,
/// The folder's own ignore file.
ThisFolder,
}
/// What the rules say about one path, and which rule says it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Verdict {
/// No rule matches: the path is synced.
Synced,
/// Left out by `pattern`. `pattern` may name a folder the path is in.
Excluded { pattern: String, source: RuleSource },
/// A rule excluded it, and a later `!pattern` brought it back.
Included { pattern: String, source: RuleSource },
}
/// Compiled ignore rules for one synced folder. /// Compiled ignore rules for one synced folder.
pub struct IgnoreRules { pub struct IgnoreRules {
matcher: Option<Gitignore>, matcher: Option<Gitignore>,
@@ -161,6 +402,27 @@ impl IgnoreRules {
} }
} }
/// [`load`](Self::load) with `text` standing in for the folder's ignore
/// file, for showing what rules being edited would do before they are
/// saved.
pub fn with_folder_text(root: &Path, globals: &[String], text: &str) -> Self {
let mut builder = GitignoreBuilder::new(root);
let mut any = false;
for pattern in globals {
any |= builder.add_line(None, pattern).is_ok();
}
let file = root.join(IGNORE_FILE_NAMES[0]);
for line in text.lines() {
any |= builder.add_line(Some(file.clone()), line).is_ok();
}
if !any {
return Self { matcher: None };
}
Self {
matcher: builder.build().ok(),
}
}
/// Rules matching nothing, for callers with no folder context. /// Rules matching nothing, for callers with no folder context.
pub fn empty() -> Self { pub fn empty() -> Self {
Self { matcher: None } Self { matcher: None }
@@ -207,6 +469,50 @@ impl IgnoreRules {
} }
} }
impl IgnoreRules {
/// What the rules say about `rel`, and which rule decides, the way
/// [`is_ignored`](Self::is_ignored) decides it.
pub fn explain(&self, rel: &str, is_dir: bool) -> Verdict {
let Some(matcher) = &self.matcher else {
return Verdict::Synced;
};
let rel = rel.trim_matches('/');
if rel.is_empty() {
return Verdict::Synced;
}
let source = |glob: &ignore::gitignore::Glob| match glob.from() {
Some(_) => RuleSource::ThisFolder,
None => RuleSource::AllFolders,
};
let mut prefix = String::new();
let mut parts = rel.split('/').peekable();
while let Some(part) = parts.next() {
if !prefix.is_empty() {
prefix.push('/');
}
prefix.push_str(part);
let last = parts.peek().is_none();
let as_dir = if last { is_dir } else { true };
match matcher.matched(&prefix, as_dir) {
ignore::Match::Ignore(glob) => {
return Verdict::Excluded {
pattern: glob.original().to_string(),
source: source(glob),
};
}
ignore::Match::Whitelist(glob) if last => {
return Verdict::Included {
pattern: glob.original().to_string(),
source: source(glob),
};
}
_ => {}
}
}
Verdict::Synced
}
}
impl std::fmt::Debug for IgnoreRules { impl std::fmt::Debug for IgnoreRules {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("IgnoreRules") f.debug_struct("IgnoreRules")
@@ -255,6 +561,198 @@ mod tests {
std::fs::write(root.join(name), body).unwrap(); std::fs::write(root.join(name), body).unwrap();
} }
#[test]
fn the_added_defaults_leave_out_clutter_but_not_look_alikes() {
let dir = TempDir::new();
let rules = IgnoreRules::load(dir.path(), &globals());
for (clutter, is_dir) in [
("desktop.ini", false),
("Photos/.directory", false),
(".Trash-1000", true),
(".Trashes", true),
(".Spotlight-V100", true),
(".fuse_hidden0000001a00000002", false),
(".nfs000000000123abcd", false),
("movie.mkv.part", false),
("setup.exe.crdownload", false),
("notes.txt.kate-swp", false),
(".~lock.report.odt#", false),
("~$budget.xlsx", false),
] {
assert!(rules.is_ignored(clutter, is_dir), "{clutter}");
}
for kept in [
"Desktop/notes.txt",
"directory.txt",
"Trash-talk.md",
"nfs-setup.md",
"parts.csv",
"part.txt",
"report.odt",
"budget.xlsx",
] {
assert!(!rules.is_ignored(kept, false), "{kept}");
}
}
#[test]
fn a_bad_pattern_is_reported_with_its_line() {
assert!(check_pattern("*.db").is_ok());
assert!(check_pattern("# a comment").is_ok());
assert!(check_pattern("").is_ok());
assert!(check_pattern("*.{jpg,png").is_err());
assert!(check_pattern("[z-a]").is_err());
let bad = check_rules("*.log\n{oops\nbuild/\n");
assert_eq!(bad.len(), 1);
assert_eq!(bad[0].0, 2);
}
#[test]
fn explain_names_the_rule_and_where_it_came_from() {
let dir = TempDir::new();
write(dir.path(), ".pdfsignore", "*.db\n!keep.tmp\n");
let rules = IgnoreRules::load(dir.path(), &globals());
assert_eq!(
rules.explain("data/cache.db", false),
Verdict::Excluded {
pattern: "*.db".into(),
source: RuleSource::ThisFolder
}
);
assert_eq!(
rules.explain("app/node_modules/x/index.js", false),
Verdict::Excluded {
pattern: "node_modules/".into(),
source: RuleSource::AllFolders
}
);
assert_eq!(
rules.explain("keep.tmp", false),
Verdict::Included {
pattern: "!keep.tmp".into(),
source: RuleSource::ThisFolder
}
);
assert_eq!(rules.explain("src/main.rs", false), Verdict::Synced);
// `explain` and `is_ignored` never disagree.
for (path, is_dir) in [
("data/cache.db", false),
("keep.tmp", false),
("x.tmp", false),
] {
assert_eq!(
rules.is_ignored(path, is_dir),
matches!(rules.explain(path, is_dir), Verdict::Excluded { .. }),
"{path}"
);
}
}
#[test]
fn rules_being_edited_explain_like_the_saved_ones() {
let dir = TempDir::new();
let text = "*.db\n!keep.db\n";
write(dir.path(), ".pdfsignore", text);
let saved = IgnoreRules::load(dir.path(), &globals());
let edited = IgnoreRules::with_folder_text(dir.path(), &globals(), text);
for path in ["a.db", "keep.db", "node_modules/x", "src/x.rs"] {
assert_eq!(
saved.explain(path, false),
edited.explain(path, false),
"{path}"
);
}
}
#[test]
fn folder_rules_are_written_back_and_removed_when_blank() {
let dir = TempDir::new();
let rules = FolderRules::read(dir.path()).unwrap();
assert_eq!(rules.text, None);
assert_eq!(rules.path, dir.path().join(".pdfsignore"));
rules.write("*.db").unwrap();
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"*.db\n"
);
assert!(IgnoreRules::load(dir.path(), &[]).is_ignored("x.db", false));
let rules = FolderRules::read(dir.path()).unwrap();
rules.write(" \n").unwrap();
assert!(!dir.path().join(".pdfsignore").exists());
}
#[test]
fn folder_rules_keep_the_file_name_in_use() {
let dir = TempDir::new();
write(dir.path(), ".protonignore", "old/\n");
let rules = FolderRules::read(dir.path()).unwrap();
assert_eq!(rules.path, dir.path().join(".protonignore"));
rules.write("new/\n").unwrap();
assert!(!dir.path().join(".pdfsignore").exists());
assert_eq!(
std::fs::read_to_string(dir.path().join(".protonignore")).unwrap(),
"new/\n"
);
}
#[test]
fn folder_rules_changed_elsewhere_are_not_written_over() {
let dir = TempDir::new();
write(dir.path(), ".pdfsignore", "a/\n");
let rules = FolderRules::read(dir.path()).unwrap();
write(dir.path(), ".pdfsignore", "b/\n");
assert!(matches!(rules.write("c/"), Err(WriteRulesError::Changed)));
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"b/\n"
);
// A file that appeared after an empty read counts as a change too.
let dir = TempDir::new();
let rules = FolderRules::read(dir.path()).unwrap();
write(dir.path(), ".pdfsignore", "b/\n");
assert!(matches!(rules.write("c/"), Err(WriteRulesError::Changed)));
}
#[test]
fn a_pattern_added_to_a_folder_keeps_its_other_lines() {
let dir = TempDir::new();
assert!(add_folder_pattern(dir.path(), " *.db ").unwrap());
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"*.db\n"
);
write(dir.path(), ".pdfsignore", "# my notes\nbuild/");
assert!(add_folder_pattern(dir.path(), "*.db").unwrap());
assert!(!add_folder_pattern(dir.path(), "build/").unwrap());
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"# my notes\nbuild/\n*.db\n"
);
assert_eq!(
FolderRules::read(dir.path()).unwrap().patterns(),
["build/", "*.db"]
);
}
#[test]
fn removing_a_folder_pattern_keeps_comments_and_drops_an_empty_file() {
let dir = TempDir::new();
write(dir.path(), ".pdfsignore", "# keep\nbuild/\n*.db\n");
assert!(remove_folder_pattern(dir.path(), "build/").unwrap());
assert!(!remove_folder_pattern(dir.path(), "build/").unwrap());
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"# keep\n*.db\n"
);
write(dir.path(), ".pdfsignore", "*.db\n");
assert!(remove_folder_pattern(dir.path(), "*.db").unwrap());
assert!(!dir.path().join(".pdfsignore").exists());
}
#[test] #[test]
fn no_rules_at_all_ignores_nothing() { fn no_rules_at_all_ignores_nothing() {
let dir = TempDir::new(); let dir = TempDir::new();
File diff suppressed because it is too large. Load diff
+10
View File
@@ -14,15 +14,25 @@ pdfs-core.workspace = true
zip.workspace = true zip.workspace = true
sha1.workspace = true sha1.workspace = true
proton-drive-rs.workspace = true proton-drive-rs.workspace = true
proton-gallery-app-rs.workspace = true
proton-gallery-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 futures.workspace = true
async-trait.workspace = true async-trait.workspace = true
tokio.workspace = true tokio.workspace = true
tracing.workspace = true tracing.workspace = true
fuser.workspace = true fuser.workspace = true
libc.workspace = true libc.workspace = true
rustix = { version = "1", features = ["net", "process"] }
serde.workspace = true
serde_json.workspace = true serde_json.workspace = true
base64.workspace = true base64.workspace = true
image.workspace = true image.workspace = true
lofty.workspace = true
notify = "8" notify = "8"
parking_lot.workspace = true parking_lot.workspace = true
+111 -92
View File
@@ -12,7 +12,7 @@
//! than looked up in our own timeline, where a shared album's photos never //! than looked up in our own timeline, where a shared album's photos never
//! appear. //! appear.
use std::collections::{HashMap, HashSet}; use std::collections::HashSet;
use std::sync::atomic::Ordering; use std::sync::atomic::Ordering;
use pdfs_core::control::{AlbumInfo, PhotoItem, Topic}; use pdfs_core::control::{AlbumInfo, PhotoItem, Topic};
@@ -24,8 +24,8 @@ use proton_drive_rs::proton_sdk::ids::NodeUid;
use tracing::warn; use tracing::warn;
use super::{ use super::{
ALBUM_SYNCED_PREFIX, ALBUMS_SYNCED_MS, Core, PHOTOS_AVAILABLE, PHOTOS_SYNCED_MS, ALBUM_SYNCED_PREFIX, ALBUMS_SYNCED_MS, Core, PHOTOS_AVAILABLE, TIMELINE_ENRICH_CHUNK,
TIMELINE_ENRICH_CHUNK, TIMELINE_TTL, now_ms, parse_uid, TIMELINE_TTL, link, now_ms, parse_uid,
}; };
impl Core { impl Core {
@@ -34,7 +34,13 @@ impl Core {
/// [`Core::photos_timeline`] gives. /// [`Core::photos_timeline`] gives.
pub(crate) fn albums(&self) -> CoreResult<Option<Vec<AlbumInfo>>> { pub(crate) fn albums(&self) -> CoreResult<Option<Vec<AlbumInfo>>> {
let count = self.db.albums_count().map_err(CoreError::from)?; 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 // Nothing on disk, so this one request waits for the fetch — unless
// the account is already known to have no photos volume. // the account is already known to have no photos volume.
let known_empty = self.db.state_i64(PHOTOS_AVAILABLE).ok().flatten() == Some(0); 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 /// the persisted listing. Returns false when the account has no photos
/// volume. /// volume.
pub(crate) async fn refresh_albums(&self) -> CoreResult<bool> { pub(crate) async fn refresh_albums(&self) -> CoreResult<bool> {
let generation = self
.db
.photo_projection_generation()
.map_err(CoreError::from)?;
let photos = self.photos(); let photos = self.photos();
if photos if link::bounded(photos.get_photos_root())
.get_photos_root()
.await .await
.map_err(|e| CoreError::from_api(&e, "photos root"))? .map_err(|e| CoreError::from_api(&e, "photos root"))?
.is_none() .is_none()
{ {
let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 0); self.db
let _ = self.db.set_state_i64(PHOTOS_SYNCED_MS, now_ms()); .albums_replace_at(&[], generation, now_ms())
let _ = self.db.set_state_i64(ALBUMS_SYNCED_MS, now_ms()); .map_err(CoreError::from)?;
return Ok(false); return Ok(false);
} }
let mut uids = link::bounded(photos.enumerate_album_node_uids())
let mut uids = photos
.enumerate_album_node_uids()
.await .await
.map_err(|e| CoreError::from_api(&e, "albums"))?; .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. let mut albums = Vec::with_capacity(uids.len());
// 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());
for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) { for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) {
match photos.enumerate_nodes(chunk).await { let nodes = link::bounded(photos.enumerate_nodes(chunk))
Ok(nodes) => { .await
for node in nodes { .map_err(|e| CoreError::from_api(&e, "album metadata"))?;
let key = node.uid.to_string(); if nodes.len() != chunk.len() {
let props = node.album.as_ref(); return Err(CoreError::remote(
albums.push(StoredAlbum { "Some album details are still unavailable.",
shared: shared.contains(&key), ));
uid: key, }
name: node.name, for node in nodes.into_iter().filter(|node| !node.trashed) {
photo_count: props.map_or(0, |a| a.photo_count.max(0) as usize), let uid = node.uid.to_string();
cover_uid: props let props = node.album.as_ref();
.and_then(|a| a.cover_photo_uid.as_ref()) albums.push(StoredAlbum {
.map(|u| u.to_string()), shared: shared_keys.contains(&uid),
last_activity: props.and_then(|a| a.last_activity_time), uid,
}); name: node.name,
} photo_count: props.map_or(0, |a| a.photo_count.max(0) as usize),
} cover_uid: props
Err(e) => warn!(error = %e, "resolving an album chunk failed"), .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| { albums.sort_by(|a, b| {
b.last_activity b.last_activity
.cmp(&a.last_activity) .cmp(&a.last_activity)
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())) .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
}); });
if !self
self.db.albums_replace(&albums).map_err(CoreError::from)?; .db
let _ = self.db.set_state_i64(PHOTOS_AVAILABLE, 1); .albums_replace_at(&albums, generation, now_ms())
let _ = self.db.set_state_i64(ALBUMS_SYNCED_MS, now_ms()); .map_err(CoreError::from)?
{
return Err(CoreError::remote(
"Photos changed during the album refresh. Try again shortly.",
));
}
Ok(true) Ok(true)
} }
@@ -154,11 +154,21 @@ impl Core {
album: &NodeUid, album: &NodeUid,
offset: usize, offset: usize,
limit: usize, limit: usize,
excluded: &str,
) -> CoreResult<Vec<PhotoItem>> { ) -> CoreResult<Vec<PhotoItem>> {
let key = album.to_string(); 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 stamp = format!("{ALBUM_SYNCED_PREFIX}{key}");
let count = self.db.album_photos_count(&key).map_err(CoreError::from)?; 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))?; self.rt.block_on(self.refresh_album(album))?;
} else if self.listing_stale(&stamp, TIMELINE_TTL) { } else if self.listing_stale(&stamp, TIMELINE_TTL) {
let core = self.clone(); let core = self.clone();
@@ -172,7 +182,7 @@ impl Core {
let page = self let page = self
.db .db
.album_photos_page(&key, offset, limit) .album_photos_page_visible(&key, offset, limit, excluded)
.map_err(CoreError::from)?; .map_err(CoreError::from)?;
Ok(page.into_iter().map(|p| self.photo_item(p)).collect()) 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. /// Re-enumerate one album's photos and replace its persisted contents.
pub(crate) async fn refresh_album(&self, album: &NodeUid) -> CoreResult<()> { 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 photos = self.photos();
let items = photos let items = link::bounded(photos.enumerate_album(album))
.enumerate_album(album)
.await .await
.map_err(|e| CoreError::from_api(&e, "album"))?; .map_err(|e| CoreError::from_api(&e, "album"))?;
let key = album.to_string();
// Same enrichment as the timeline: the listing carries a uid and a let mut meta = self
// capture time, and the gallery needs a name and media type to classify .db
// each entry. Best-effort per chunk. .album_photo_metadata(&key)
let uids: Vec<NodeUid> = items.iter().map(|it| it.uid.clone()).collect(); .map_err(CoreError::from)?;
let mut meta: HashMap<String, (Option<String>, Option<String>)> = HashMap::new(); 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) { for chunk in uids.chunks(TIMELINE_ENRICH_CHUNK) {
match photos.enumerate_nodes(chunk).await { let nodes = link::bounded(photos.enumerate_nodes(chunk))
Ok(nodes) => { .await
for node in nodes { .map_err(|e| CoreError::from_api(&e, "album photo metadata"))?;
let media_type = match &node.kind { for node in nodes.into_iter().filter(|node| !node.trashed) {
NodeKind::File { media_type, .. } => Some(media_type.clone()), let media_type = match node.kind {
NodeKind::Folder => None, NodeKind::File { media_type, .. } => Some(media_type),
}; NodeKind::Folder => None,
meta.insert(node.uid.to_string(), (Some(node.name), media_type)); };
} meta.insert(node.uid.to_string(), (node.name, media_type));
}
Err(e) => warn!(error = %e, "resolving album photo metadata failed"),
} }
} }
let rows: Vec<_> = items
let rows: Vec<(String, i64, Option<String>, Option<String>)> = items .into_iter()
.iter() .map(|item| {
.map(|it| { let uid = item.uid.to_string();
let key = it.uid.to_string(); let (name, media_type) = meta
let (name, media_type) = meta.get(&key).cloned().unwrap_or((None, None)); .get(&uid)
(key, it.capture_time, name, media_type) .map(|(name, mime)| (Some(name.clone()), mime.clone()))
.unwrap_or_default();
(uid, item.capture_time, name, media_type)
}) })
.collect(); .collect();
let key = album.to_string(); if !self
self.db
.album_photos_replace(&key, &rows)
.map_err(CoreError::from)?;
let _ = self
.db .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(()) Ok(())
} }
@@ -283,7 +302,7 @@ impl Core {
.block_on(self.photos().delete_album(album, delete_photos)) .block_on(self.photos().delete_album(album, delete_photos))
.map_err(|e| CoreError::from_api(&e, "delete album"))?; .map_err(|e| CoreError::from_api(&e, "delete album"))?;
let key = album.to_string(); 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"); warn!(%album, %error, "a deleted album's photos could not be dropped");
} }
self.after_album_change(None); 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 /// Follow the Photos volume and commit changes with its durable event cursor.
/// 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.
pub(super) async fn run_photos_event_sync(core: Core) { pub(super) async fn run_photos_event_sync(core: Core) {
let photos = core.photos(); let photos = core.photos();
// The photos volume only exists once the user has used Photos at all, and // The photos volume only exists once the user has used Photos at all, and
// the daemon may well start before the network does. // the daemon may well start before the network does.
let scope = loop { 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(Some(root)) => break root.tree_event_scope_id(),
Ok(None) => { Ok(None) => core.next_poll(POLL_INTERVAL).await,
debug!("no photos volume; photo event sync not started");
return;
}
Err(error) if session_revoked(&error) => { Err(error) if session_revoked(&error) => {
core.mark_session_expired("read the photos root", &error); core.mark_session_expired("read the photos root", &error);
return; return;
@@ -554,39 +537,71 @@ pub(super) async fn run_photos_event_sync(core: Core) {
} }
}; };
let mut cursor: Option<DriveEventId> = core let key = format!("photos_event_cursor:{}", scope.volume_id());
.db let mut cursor = loop {
.state_str(PHOTOS_EVENT_CURSOR) match core.db.state_str(&key) {
.ok() Ok(cursor) => break cursor.map(DriveEventId::from),
.flatten() Err(error) => {
.map(DriveEventId::from); warn!(%error, "reading the photo event checkpoint failed");
info!(?cursor, "photo event sync started"); core.next_poll(POLL_INTERVAL).await;
}
}
};
info!("photo event sync started");
loop { loop {
core.next_poll(POLL_INTERVAL).await;
let events = match link::bounded(photos.enumerate_events(&scope, cursor.as_ref())).await { let events = match link::bounded(photos.enumerate_events(&scope, cursor.as_ref())).await {
Ok(events) => events, Ok(events) => events,
Err(error) if core.lost_link(&error, "poll photo events") => continue,
Err(error) => { 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; continue;
} }
}; };
let Some(head) = events.last().map(|event| event.id().clone()) else { if let Some(head) = events.last().map(|event| event.id().clone()) {
continue; if let Err(error) = invalidate_photo_events(&core, &events).await {
}; warn!(%error, "invalidating photo event metadata failed");
apply_photo_events(&core, &events); core.next_poll(POLL_INTERVAL).await;
core.events.publish(&[Topic::Photos]); continue;
// One cursor write per batch, after the batch is applied: a crash in }
// between replays events whose effects are idempotent. // A failed database write must replay all changes, including echoes.
if let Err(error) = core.db.set_state_str(PHOTOS_EVENT_CURSOR, head.as_str()) { let plan = classify_photo_events(&events, |_| false);
warn!(%error, "persisting the photo event cursor failed"); if let Err(error) = core.db.photos_apply_events(
continue; &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. /// What one batch of photos-volume events asks the gallery's tables to do.
#[derive(Debug, Default, PartialEq)] #[derive(Debug, Default, PartialEq)]
pub(super) struct PhotoEventPlan { pub(super) struct PhotoEventPlan {
@@ -616,14 +631,22 @@ fn classify_photo_events(
mut is_echo: impl FnMut(&NodeUid) -> bool, mut is_echo: impl FnMut(&NodeUid) -> bool,
) -> PhotoEventPlan { ) -> PhotoEventPlan {
let mut plan = PhotoEventPlan::default(); let mut plan = PhotoEventPlan::default();
for event in events { let mut seen = HashSet::new();
for event in events.iter().rev() {
match event { 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 { DriveEvent::NodeUpdated {
node_uid, node_uid,
is_trashed, is_trashed,
.. ..
} => { } => {
if !seen.insert(node_uid) {
continue;
}
if *is_trashed { if *is_trashed {
plan.gone.push(node_uid.to_string()); plan.gone.push(node_uid.to_string());
} else if !is_echo(node_uid) { } else if !is_echo(node_uid) {
@@ -641,47 +664,11 @@ fn classify_photo_events(
DriveEvent::CursorAdvanced { .. } | DriveEvent::SharedWithMeUpdated { .. } => {} DriveEvent::CursorAdvanced { .. } | DriveEvent::SharedWithMeUpdated { .. } => {}
} }
} }
plan.gone.reverse();
plan.touched.reverse();
plan 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" /// 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`], /// 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. /// then sleeps; runs on its own thread for the life of the daemon.
+212 -51
View File
@@ -396,6 +396,11 @@ fn touched_topics(request: &CtlRequest) -> &'static [Topic] {
use CtlRequest as R; use CtlRequest as R;
match request { match request {
R::Pin { .. } | R::Unpin { .. } => &[Topic::Files], 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::CreateAlbum { .. }
| R::RenameAlbum { .. } | R::RenameAlbum { .. }
| R::DeleteAlbum { .. } | 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 // Registered before the request is even parsed, so a handler that wedges
// inside the daemon shows up by name in `pdfs diagnostics`. // inside the daemon shows up by name in `pdfs diagnostics`.
let _inflight = super::diagnostics::InflightGuard::new(super::diagnostics::request_kind(&line)); 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 { let response = match request {
Ok(CtlRequest::Status) => status_response(core, username, mountpoint), Ok(CtlRequest::Status) => status_response(core, username, mountpoint),
Ok(CtlRequest::Subscribe) => { 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 // A full refresh is "forget what you know", not a second code
// path: the ordinary refresh then finds every photo stale. // path: the ordinary refresh then finds every photo stale.
if let Some(Err(e)) = full.then(|| core.db.photos_mark_all_unresolved()) { 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 // Whatever changed the timeline can just as easily have
// changed an album; one scope covers the whole photos view. // 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, range,
favorites, favorites,
not_in_album, not_in_album,
&excluded,
) { ) {
Ok(Some(items)) => CtlResponse::Photos { Ok(Some(items)) => CtlResponse::Photos {
available: true, available: true,
items, items,
counts: core.db.photos_counts().ok(), counts: core.db.photos_counts_visible(&excluded).ok(),
}, },
Ok(None) => CtlResponse::Photos { Ok(None) => CtlResponse::Photos {
available: false, available: false,
@@ -693,7 +761,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
}, },
Err(e) => CtlResponse::error(e), Err(e) => CtlResponse::error(e),
}, },
Ok(CtlRequest::PhotoPlaces) => match core.photo_places() { Ok(CtlRequest::PhotoPlaces) => match core.photo_places(&excluded) {
Ok(items) => CtlResponse::Places { Ok(items) => CtlResponse::Places {
items, items,
mapping: core.timeline_progress(), 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), Err(e) => CtlResponse::error(e),
}, },
Ok(CtlRequest::PlacePhotos { id, offset, limit }) => { 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 { Ok(items) => CtlResponse::Photos {
available: true, available: true,
items, items,
@@ -715,7 +783,7 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
Err(e) => CtlResponse::error(e), Err(e) => CtlResponse::error(e),
}, },
Ok(CtlRequest::PhotosOnThisDay { limit }) => { 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 { Ok(items) => CtlResponse::Photos {
available: true, available: true,
items, 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 // 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` // concerned, so it comes back in the same reply — with `counts`
// unset, which describe the whole timeline rather than this album. // 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 { Ok(items) => CtlResponse::Photos {
available: true, available: true,
items, items,
@@ -802,17 +873,28 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
core.remove_from_album(album, photos) core.remove_from_album(album, photos)
}) })
} }
Ok(CtlRequest::PhotoMonths { kind }) => match core.db.photos_months(kind) { Ok(CtlRequest::PhotoPresence { uid, album }) => match core.cached_gallery_visibility() {
Ok(months) => CtlResponse::PhotoMonths { Ok(visibility)
months: months if visibility.media.contains(&uid)
.into_iter() || album
.map(|(year, month, count)| PhotoMonth { year, month, count }) .as_ref()
.collect(), .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 }) => { 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 { CtlResponse::Thumbs {
items: core.photo_thumbs(&parsed), 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(), running: core.timeline_refreshing(),
}, },
Ok(CtlRequest::OpenPhoto { uid }) => match parse_uid(&uid) { 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 { Ok(p) => CtlResponse::FilePath {
path: p.display().to_string(), 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}"))), 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 // The scan alone walks every archive's central directory, so even the
// dry run goes to a background thread and is read back through // dry run goes to a background thread and is read back through
// `ImportStatus` rather than answered inline. // `ImportStatus` rather than answered inline.
@@ -877,35 +991,23 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
if archives.is_empty() { if archives.is_empty() {
CtlResponse::error(CoreError::invalid("no Takeout archives given")) CtlResponse::error(CoreError::invalid("no Takeout archives given"))
} else { } else {
let paths: Vec<PathBuf> = archives.into_iter().map(PathBuf::from).collect(); let paths = archives.into_iter().map(PathBuf::from).collect();
let missing: Vec<String> = paths start_takeout_import(core, paths, dry_run)
.iter()
.filter(|path| !path.is_file())
.map(|path| path.display().to_string())
.collect();
if !missing.is_empty() {
CtlResponse::error(CoreError::not_found(format!(
"cannot read: {}",
missing.join(", ")
)))
} else {
let count = paths.len();
match core.spawn_takeout_import(paths, dry_run) {
Ok(()) => CtlResponse::Ok {
message: format!(
"{} {count} archive(s)",
if dry_run { "scanning" } else { "importing" }
),
},
Err(e) => CtlResponse::error(e),
}
}
} }
} }
Ok(CtlRequest::ImportStatus) => { Ok(CtlRequest::ImportStatus) => {
let (running, summary) = crate::takeout::import_status(); let report = crate::takeout::import_status();
CtlResponse::ImportStatus { running, summary } CtlResponse::ImportStatus {
running: report.running,
summary: report.summary,
progress: report.progress,
resumable: report.resumable,
}
} }
Ok(CtlRequest::ResumeImport) => match crate::takeout::resumable_archives() {
None => CtlResponse::error(CoreError::not_found("there is no import to resume")),
Some(paths) => start_takeout_import(core, paths, false),
},
Ok(CtlRequest::CancelImport) => { Ok(CtlRequest::CancelImport) => {
if crate::takeout::cancel_import() { if crate::takeout::cancel_import() {
CtlResponse::Ok { CtlResponse::Ok {
@@ -998,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 // timeline, and the GUI reloads the gallery the moment this
// reply lands — so refresh now rather than leaving it to a // reply lands — so refresh now rather than leaving it to a
// background pass that would land just after that reload. // 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"); warn!(error = %e, "timeline refresh after upload failed");
} }
CtlResponse::Ok { CtlResponse::Ok {
@@ -1332,11 +1435,9 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
core.cache.set_budget(bytes); core.cache.set_budget(bytes);
// Persist so the next mount keeps the new cap. Best-effort: a config // Persist so the next mount keeps the new cap. Best-effort: a config
// write failure is reported but the live cap is already applied. // write failure is reported but the live cap is already applied.
match AppDirs::new().map(|dirs| { match AppDirs::new()
let mut cfg = dirs.load_config(); .map(|dirs| dirs.update_config(|cfg| cfg.cache_budget = Some(bytes)))
cfg.cache_budget = Some(bytes); {
dirs.save_config(&cfg)
}) {
Ok(Ok(())) => { Ok(Ok(())) => {
core.touch_profile(); core.touch_profile();
CtlResponse::Ok { CtlResponse::Ok {
@@ -1356,10 +1457,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// Persisted like the cache budget: best-effort, the live caps are // Persisted like the cache budget: best-effort, the live caps are
// already applied. // already applied.
match AppDirs::new().map(|dirs| { match AppDirs::new().map(|dirs| {
let mut cfg = dirs.load_config(); dirs.update_config(|cfg| {
cfg.upload_limit = Some(upload); cfg.upload_limit = Some(upload);
cfg.download_limit = Some(download); cfg.download_limit = Some(download);
dirs.save_config(&cfg) })
}) { }) {
Ok(Ok(())) => CtlResponse::Ok { Ok(Ok(())) => CtlResponse::Ok {
message: format!( message: format!(
@@ -1943,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. // The request did not parse: the caller sent something malformed.
Err(e) => CtlResponse::error(CoreError::invalid(format!("bad request: {e}"))), 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 { .. }) { if !touched.is_empty() && !matches!(response, CtlResponse::Error { .. }) {
core.events.publish(touched); 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) { let mut out = match serde_json::to_vec(&response) {
Ok(v) => v, Ok(v) => v,
Err(e) => { Err(e) => {
@@ -1954,10 +2060,40 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
} }
}; };
out.push(b'\n'); out.push(b'\n');
let mut stream = stream;
let _ = stream.write_all(&out); 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 /// 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. /// own thread. Runs on its own thread; returns only if the listener itself fails.
/// ///
@@ -2009,6 +2145,31 @@ pub(crate) fn run_control_socket(
} }
} }
/// Check that every archive is there, then start the import in the background.
fn start_takeout_import(core: &Core, paths: Vec<PathBuf>, dry_run: bool) -> CtlResponse {
let missing: Vec<String> = paths
.iter()
.filter(|path| !path.is_file())
.map(|path| path.display().to_string())
.collect();
if !missing.is_empty() {
return CtlResponse::error(CoreError::not_found(format!(
"cannot read: {}",
missing.join(", ")
)));
}
let count = paths.len();
match core.spawn_takeout_import(paths, dry_run) {
Ok(()) => CtlResponse::Ok {
message: format!(
"{} {count} archive(s)",
if dry_run { "scanning" } else { "importing" }
),
},
Err(e) => CtlResponse::error(e),
}
}
#[cfg(test)] #[cfg(test)]
mod request_limit_tests { mod request_limit_tests {
use super::*; use super::*;
+1 -3
View File
@@ -123,9 +123,7 @@ pub(crate) fn sync_root_reserved() -> pdfs_core::syncroot::Reserved {
pub(crate) fn set_adopted_device_uid(uid: Option<&str>) -> CoreResult<()> { pub(crate) fn set_adopted_device_uid(uid: Option<&str>) -> CoreResult<()> {
let dirs = pdfs_core::config::AppDirs::new() let dirs = pdfs_core::config::AppDirs::new()
.map_err(|e| CoreError::internal(format!("config dirs: {e}")))?; .map_err(|e| CoreError::internal(format!("config dirs: {e}")))?;
let mut cfg = dirs.load_config(); dirs.update_config(|cfg| cfg.device_uid = uid.map(|u| u.to_string()))
cfg.device_uid = uid.map(|u| u.to_string());
dirs.save_config(&cfg)
.map_err(|e| CoreError::internal(format!("write config: {e}"))) .map_err(|e| CoreError::internal(format!("write config: {e}")))
} }
+101 -16
View File
@@ -20,7 +20,7 @@
//! are kept as a conflict copy rather than discarded — see //! are kept as a conflict copy rather than discarded — see
//! [`Core::revision_conflict`]. //! [`Core::revision_conflict`].
use std::collections::HashMap; use std::collections::{HashMap, HashSet};
use std::fs::File; use std::fs::File;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::sync::Arc; use std::sync::Arc;
@@ -53,6 +53,21 @@ use super::{
use proton_drive_rs::proton_sdk::api::ResponseCode; use proton_drive_rs::proton_sdk::api::ResponseCode;
use proton_drive_rs::proton_sdk::error::ProtonError; 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); const DRAIN_ACCESS_RECHECK: Duration = Duration::from_secs(5);
/// How long an op may stay access-deferred before the deferral is reported as a /// 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 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")?; 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 // A trashed node can be restored. Only retire the operation if the node
// way there is nothing to rename and nothing to lose — a rename holds no // is gone entirely.
// bytes — so the op is satisfied rather than retried forever.
let node = match self.fetch_node_remote(&uid)? { let node = match self.fetch_node_remote(&uid)? {
Some(n) if !n.trashed => n, Some(n) if n.trashed => return Err(TrashedMove(n.name).into()),
_ => { Some(n) => n,
warn!(%uid, name, "renamed node is gone or trashed remotely; dropping the rename"); None => {
warn!(%uid, name, "renamed node is gone remotely; dropping the rename");
self.db.delete_op(op.id)?; self.db.delete_op(op.id)?;
return Ok(()); return Ok(());
} }
@@ -827,23 +842,38 @@ impl Core {
// no window for the requirements to go stale between two calls — // no window for the requirements to go stale between two calls —
// the race B46 queued this op to get away from. // the race B46 queued this op to get away from.
let target = (node.name != name).then_some(name.as_str()); 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(), Ok(()) => name.clone(),
// The destination holds that name already. Landing under a // The destination holds that name already. Landing under a
// *different* name is the non-destructive resolution: it neither // *different* name is the non-destructive resolution: it neither
// clobbers their file nor drops ours, and it is visible. // 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)? { if self.name_is_held(op, Some(&parent), &name)? {
return Err(held_by_queued_change(&name)); return Err(held_by_queued_change(&name));
} }
// What held it may have let go since Drive answered // What held it may have let go since Drive answered
// (docs/BUGS.md B144). // (docs/BUGS.md B144).
match self.move_rename_remote(&uid, &parent, target) { match try_move(target) {
Ok(()) => name.clone(), 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()); let alt = conflict_name(&name, now_secs());
warn!(%uid, name, alt, "destination already holds that name; using a conflict name"); 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.adopt_drained_name(&uid, &alt);
self.log_activity( self.log_activity(
ActivityKind::Rename, ActivityKind::Rename,
@@ -853,7 +883,7 @@ impl Core {
); );
alt alt
} }
Err(e) => return Err(e.into()), Err(e) => return Err(e),
} }
} }
// The destination folder is gone. Leaving the node in its current // 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 // the user chose still applies there. Retrying the move could
// only fail again — the folder is not coming back — and would // only fail again — the folder is not coming back — and would
// wedge the queue. // 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"); warn!(%uid, name, %parent, "move destination is gone; leaving the node where it is");
let landed = match self.drain_rename_in_place( let landed = match self.drain_rename_in_place(
op, op,
@@ -885,7 +915,7 @@ impl Core {
); );
landed landed
} }
Err(e) => return Err(e.into()), Err(e) => return Err(e),
} }
}; };
self.db.delete_op(op.id)?; self.db.delete_op(op.id)?;
@@ -1349,7 +1379,11 @@ impl Core {
parent: Option<&NodeUid>, parent: Option<&NodeUid>,
name: &str, name: &str,
) -> Result<bool, Box<dyn std::error::Error>> { ) -> Result<bool, Box<dyn std::error::Error>> {
if self.db.has_pending_trash_named(name)? { let parent_uid = parent.map(NodeUid::to_string);
if self
.db
.has_pending_trash_named(name, parent_uid.as_deref())?
{
return Ok(true); return Ok(true);
} }
if op.attempts >= NAME_HOLD_ATTEMPTS { if op.attempts >= NAME_HOLD_ATTEMPTS {
@@ -2695,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) !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. /// 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> { 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>()) std::iter::successors(Some(e), |e| e.source()).find_map(|e| e.downcast_ref::<ProtonError>())
@@ -2704,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 /// 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. /// is, or `Some(None)` for a failure that is not a refusal.
fn refusal(e: &(dyn std::error::Error + 'static)) -> Option<Option<SyncIssue>> { 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)?; let proton = proton_error(e)?;
// A refused session refuses everything, so it says nothing about this // A refused session refuses everything, so it says nothing about this
// op either; the mount is offline for it (`Core::lost_link`). // op either; the mount is offline for it (`Core::lost_link`).
@@ -3111,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] #[test]
fn queued_cross_parent_rename_retains_viewer_source_authority_after_local_move() { fn queued_cross_parent_rename_retains_viewer_source_authority_after_local_move() {
use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::atomic::{AtomicU64, Ordering};
+8 -6
View File
@@ -2372,17 +2372,19 @@ impl ProtonFs {
} }
} }
} }
// Offline: queue it. Trashing is the one mutation a user expects to work // Queue a folder trash while Drive still holds children that were moved
// regardless — the file is gone from their point of view the moment the // out locally. The drain waits for those moves before sending it.
// command returns. The same when the network goes
// away under the remote call below.
let queue_it = |reply: ReplyEmpty| match self.core.queue_trash(&uid, name, open_now) { let queue_it = |reply: ReplyEmpty| match self.core.queue_trash(&uid, name, open_now) {
Ok(()) => reply.ok(), Ok(()) => reply.ok(),
Err(e) => reply.error(e), Err(e) => reply.error(e),
}; };
if !self.core.sends_inline() { if !self.core.sends_inline() {
queue_it(reply); return queue_it(reply);
return; }
match self.core.has_pending_moves_out_of(&uid) {
Ok(false) => {}
Ok(true) => return queue_it(reply),
Err(error) => return reply.error(error),
} }
if let Err(e) = self.core.require_uid_writable(&uid) { if let Err(e) = self.core.require_uid_writable(&uid) {
reply.error(e); reply.error(e);
+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);
}
}
+43 -3
View File
@@ -91,6 +91,7 @@ mod drive;
use drive::{DriveApi, RevisionRead}; use drive::{DriveApi, RevisionRead};
mod events; mod events;
mod filesystem; mod filesystem;
mod gallery;
mod keeper; mod keeper;
mod link; mod link;
pub use filesystem::ProtonFs; pub use filesystem::ProtonFs;
@@ -499,6 +500,7 @@ struct Core {
/// The concrete client, for what [`DriveApi`] does not cover: sharing, /// The concrete client, for what [`DriveApi`] does not cover: sharing,
/// Photos, devices, invitations and public links. /// Photos, devices, invitations and public links.
client: ProtonDriveClient, client: ProtonDriveClient,
gallery: Option<Arc<gallery::Gallery>>,
rt: tokio::runtime::Handle, rt: tokio::runtime::Handle,
/// The daemon's My Files root. Forked on-demand sessions retain this value /// 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. /// so ownership checks never mistake their own mount root for account scope.
@@ -3168,6 +3170,28 @@ impl Core {
) )
} }
/// [`Core::resolve_anywhere`], widened to the Photos timeline for sharing.
///
/// A photo lives on the photos volume, which no location shows, so the
/// residency proof above never finds it. The timeline in the `photos` table
/// is this daemon's proof instead: it lists only photos on the user's own
/// volume, which are theirs to share. A photo in an album someone else
/// shared is not in it and stays refused.
pub(crate) fn resolve_shareable(&self, uid: &str) -> CoreResult<NodeUid> {
resolve_anywhere_with(
uid,
|uid| self.owns_visible_uid(uid),
|uid| {
let uid = uid.to_string();
Ok(self.db.mirror_contains_uid(&uid)?
|| !self
.db
.photos_by_uid(std::slice::from_ref(&uid))?
.is_empty())
},
)
}
fn source_parent_uid(&self, ino: u64, rel: &Path) -> CoreResult<NodeUid> { fn source_parent_uid(&self, ino: u64, rel: &Path) -> CoreResult<NodeUid> {
let state = self.state(); let state = self.state();
let entry = state let entry = state
@@ -3990,6 +4014,15 @@ impl Core {
Ok(()) Ok(())
} }
fn has_pending_moves_out_of(&self, uid: &NodeUid) -> Result<bool, Errno> {
self.db
.has_pending_moves_out_of(&uid.to_string())
.map_err(|error| {
error!(%uid, %error, "checking for moves out of a trash target failed");
Errno::EIO
})
}
/// Queue trashing a node the server knows about, and drop it from the tree /// Queue trashing a node the server knows about, and drop it from the tree
/// now. /// now.
/// ///
@@ -5368,6 +5401,11 @@ impl Core {
&parent_uid, &parent_uid,
) )
.map_err(|error| self.errno_error(error, "trash access"))?; .map_err(|error| self.errno_error(error, "trash access"))?;
if self.db.has_pending_moves_out_of(&uid.to_string())? {
return Err(CoreError::conflict(
"wait for pending moves out of this folder to sync before trashing it",
));
}
self.rt self.rt
.block_on(self.drive.trash_nodes(std::slice::from_ref(&uid))) .block_on(self.drive.trash_nodes(std::slice::from_ref(&uid)))
.and_then(batch::into_unit) .and_then(batch::into_unit)
@@ -5432,11 +5470,13 @@ impl Core {
} else { } else {
uid uid
}; };
// Local-first or offline, or the network goes away under the call: // Local-first or offline: queue the trash and the rename that follows.
// queue the trash. The rename that follows queues as well, behind it.
if !self.sends_inline() { if !self.sends_inline() {
return self.queue_trash(uid, name, open); return self.queue_trash(uid, name, open);
} }
if self.has_pending_moves_out_of(uid)? {
return Err(Errno::EBUSY);
}
self.require_uid_writable(uid)?; self.require_uid_writable(uid)?;
if let Err(e) = self if let Err(e) = self
.block_on_bounded(self.drive.trash_nodes(std::slice::from_ref(uid))) .block_on_bounded(self.drive.trash_nodes(std::slice::from_ref(uid)))
@@ -5732,7 +5772,7 @@ impl Core {
/// Drop the persisted photos timeline's freshness stamp, so the next timeline /// Drop the persisted photos timeline's freshness stamp, so the next timeline
/// read fetches rather than serving what it already has. /// read fetches rather than serving what it already has.
fn invalidate_photos(&self) { 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 /// 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 /// Unless the keyring holds a newer session than the refused one: then
/// the mount ends, for the daemon to mount again on that one. /// 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) { 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) { if self.link.resume_stored.load(Ordering::Relaxed) {
return self.mark_offline(what, error); return self.mark_offline(what, error);
} }
+12
View File
@@ -310,6 +310,7 @@ enum Start {
pub struct MountOptions { pub struct MountOptions {
/// Proton account the session belongs to, for display and per-user paths. /// Proton account the session belongs to, for display and per-user paths.
pub username: String, 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. /// What the background conflict sweep may do. See `docs/BUGS.md` B71.
pub sweep_mode: SweepMode, pub sweep_mode: SweepMode,
/// Upload and download caps in bytes per second (`0` = no cap). /// Upload and download caps in bytes per second (`0` = no cap).
@@ -456,6 +457,7 @@ pub(crate) fn mount_with(
) -> std::io::Result<MountOutcome> { ) -> std::io::Result<MountOutcome> {
let MountOptions { let MountOptions {
username, username,
gallery_session,
sweep_mode, sweep_mode,
upload_limit, upload_limit,
download_limit, download_limit,
@@ -480,9 +482,13 @@ pub(crate) fn mount_with(
let (sync_tx, sync_rx) = std::sync::mpsc::channel::<sync::SyncMsg>(); let (sync_tx, sync_rx) = std::sync::mpsc::channel::<sync::SyncMsg>();
let paused_until = pause::load_paused_until(&db); 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 { let core = Core {
drive, drive,
client, client,
gallery,
rt: rt.clone(), rt: rt.clone(),
maintenance: Arc::new(Mutex::new(Default::default())), maintenance: Arc::new(Mutex::new(Default::default())),
primary_root_uid: root.uid.clone(), 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: // 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. // the walk is I/O-heavy and must never sit in front of a FUSE callback.
if matches!(host, Host::Daemon) { if matches!(host, Host::Daemon) {
if let Some(gallery) = &core.gallery {
rt.spawn(gallery.clone().poll(core.clone()));
}
let db = core.db.clone(); let db = core.db.clone();
let indexing = core.indexing.clone(); let indexing = core.indexing.clone();
let transfers = core.transfers.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`]. /// 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<()>>) { fn halt_workers(core: &Core, control_socket: &Path, workers: Vec<std::thread::JoinHandle<()>>) {
core.shutdown.stop(); core.shutdown.stop();
if let Some(gallery) = &core.gallery {
gallery.cancel();
}
core.wake_drain(); core.wake_drain();
let _ = core.sync_tx.send(sync::SyncMsg::Stop); let _ = core.sync_tx.send(sync::SyncMsg::Stop);
// Connect while the socket still exists — that is the whole point of the // Connect while the socket still exists — that is the whole point of the
File diff suppressed because it is too large. Load diff
+8 -8
View File
@@ -105,7 +105,7 @@ impl Core {
role: &str, role: &str,
message: Option<&str>, message: Option<&str>,
) -> CoreResult<(usize, usize)> { ) -> CoreResult<(usize, usize)> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.share_node_for_uid(&uid, emails, role, message) self.share_node_for_uid(&uid, emails, role, message)
} }
@@ -138,7 +138,7 @@ impl Core {
&self, &self,
uid: &str, uid: &str,
) -> CoreResult<(Vec<ShareEntry>, Option<PublicLinkInfo>)> { ) -> CoreResult<(Vec<ShareEntry>, Option<PublicLinkInfo>)> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.list_share_for_uid(&uid) self.list_share_for_uid(&uid)
} }
@@ -215,7 +215,7 @@ impl Core {
kind: ShareEntryKind, kind: ShareEntryKind,
role: &str, role: &str,
) -> CoreResult<()> { ) -> CoreResult<()> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.update_share_role_for_uid(&uid, id, kind, role) self.update_share_role_for_uid(&uid, id, kind, role)
} }
@@ -278,7 +278,7 @@ impl Core {
id: &str, id: &str,
kind: ShareEntryKind, kind: ShareEntryKind,
) -> CoreResult<()> { ) -> CoreResult<()> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.remove_share_entry_for_uid(&uid, id, kind) self.remove_share_entry_for_uid(&uid, id, kind)
} }
@@ -349,7 +349,7 @@ impl Core {
password: Option<&str>, password: Option<&str>,
expires: Option<i64>, expires: Option<i64>,
) -> CoreResult<PublicLinkInfo> { ) -> CoreResult<PublicLinkInfo> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.create_public_link_for_uid(&uid, role, password, expires) self.create_public_link_for_uid(&uid, role, password, expires)
} }
@@ -391,7 +391,7 @@ impl Core {
password: LinkChange<String>, password: LinkChange<String>,
expires: LinkChange<i64>, expires: LinkChange<i64>,
) -> CoreResult<PublicLinkInfo> { ) -> CoreResult<PublicLinkInfo> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.update_public_link_for_uid(&uid, id, role, password, expires) self.update_public_link_for_uid(&uid, id, role, password, expires)
} }
@@ -460,7 +460,7 @@ impl Core {
/// [`Core::remove_public_link`] for a node addressed through any daemon /// [`Core::remove_public_link`] for a node addressed through any daemon
/// location. /// location.
pub(crate) fn remove_public_link_by_uid(&self, uid: &str, id: &str) -> CoreResult<()> { pub(crate) fn remove_public_link_by_uid(&self, uid: &str, id: &str) -> CoreResult<()> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.remove_public_link_for_uid(&uid, id) self.remove_public_link_for_uid(&uid, id)
} }
@@ -486,7 +486,7 @@ impl Core {
/// [`Core::stop_sharing`] for a node addressed through any daemon location. /// [`Core::stop_sharing`] for a node addressed through any daemon location.
pub(crate) fn stop_sharing_by_uid(&self, uid: &str) -> CoreResult<StopSharingOutcome> { pub(crate) fn stop_sharing_by_uid(&self, uid: &str) -> CoreResult<StopSharingOutcome> {
let uid = self.resolve_anywhere(uid)?; let uid = self.resolve_shareable(uid)?;
self.stop_sharing_for_uid(&uid) self.stop_sharing_for_uid(&uid)
} }
+145
View File
@@ -89,6 +89,7 @@ impl Daemon {
db, db,
MountOptions { MountOptions {
username: "sim".into(), username: "sim".into(),
gallery_session: None,
sweep_mode: AppConfig::default().resolved_conflict_sweep(), sweep_mode: AppConfig::default().resolved_conflict_sweep(),
upload_limit: 0, upload_limit: 0,
download_limit: 0, download_limit: 0,
@@ -1917,6 +1918,68 @@ mod tests {
let _ = std::fs::remove_dir_all(&dir); 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] #[test]
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"] #[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() { fn a_write_over_a_create_whose_read_back_failed_is_not_a_conflict() {
@@ -3732,6 +3795,88 @@ mod tests {
let _ = std::fs::remove_dir_all(&dir); let _ = std::fs::remove_dir_all(&dir);
} }
/// A song with no picture in its tags shows the cover image in its folder,
/// and the daemon tells a following front-end that a thumbnail landed, so
/// a folder on screen fills in without being opened again.
#[test]
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
fn a_song_without_a_cover_shows_its_folders_and_says_so() {
let dir = scratch("song-cover");
std::fs::create_dir_all(&dir).unwrap();
// Silent MPEG-1 Layer III frames, without any tag.
let mut frame = vec![0u8; 417];
frame[..4].copy_from_slice(&[0xFF, 0xFB, 0x90, 0x64]);
let song = frame.repeat(64);
let mut cover = Vec::new();
image::codecs::jpeg::JpegEncoder::new(&mut cover)
.encode_image(&image::RgbImage::new(300, 300))
.unwrap();
let drive = FakeDrive::new();
drive.device().write("track one.mp3", &song);
drive.device().write("Cover.jpg", &cover);
let client = drive.client(1, Faults::lan());
let daemon = Daemon::start(&dir.join("daemon"), client).unwrap();
let landed = Arc::new(std::sync::atomic::AtomicBool::new(false));
let mut subscription = control::subscribe(&daemon.socket).unwrap();
let flag = landed.clone();
std::thread::spawn(move || {
// The first change names every topic: a new subscription catches up.
let mut caught_up = false;
while let Ok(Some(event)) = subscription.next_event() {
if let control::Event::Changed { topics } = event {
if caught_up && topics.contains(&control::Topic::Thumbnails) {
flag.store(true, std::sync::atomic::Ordering::SeqCst);
return;
}
caught_up = true;
}
}
});
let Ok(Response::Entries { entries }) = daemon.request(&Request::ListDir {
path: String::new(),
}) else {
panic!("listing");
};
let song = entries
.iter()
.find(|entry| entry.name == "track one.mp3")
.expect("the song is listed");
let items = vec![control::FileThumbRequest {
uid: song.uid.clone(),
modified: song.modified,
name: song.name.clone(),
}];
let Ok(Response::FileThumbGeneration { generation }) =
daemon.request(&Request::ReserveFileThumbGeneration)
else {
panic!("generation");
};
let mut path = None;
let settled = wait_until(Duration::from_secs(60), || {
let Ok(Response::Thumbs { items: replies }) = daemon.request(&Request::FileThumbs {
items: items.clone(),
generation,
}) else {
return false;
};
path = replies.first().and_then(|reply| reply.path.clone());
path.is_some()
});
assert!(settled, "the song got no thumbnail");
let thumb = image::load_from_memory(&std::fs::read(path.unwrap()).unwrap()).unwrap();
assert_eq!(thumb.width(), thumb.height(), "the square cover");
assert!(
wait_until(Duration::from_secs(15), || landed
.load(std::sync::atomic::Ordering::SeqCst)),
"no thumbnails change was published"
);
assert!(matches!(daemon.stop(), Ok(MountOutcome::Shutdown)));
let _ = std::fs::remove_dir_all(&dir);
}
/// A video in My files gets a thumbnail from a frame of its own, but a /// A video in My files gets a thumbnail from a frame of its own, but a
/// recording can be gigabytes: only its start, and an MP4's index, are /// recording can be gigabytes: only its start, and an MP4's index, are
/// downloaded for it. A video with a thumbnail from its uploader is not /// downloaded for it. A video with a thumbnail from its uploader is not
+17
View File
@@ -160,6 +160,17 @@ impl Server {
.is_some_and(|remote| remote.file.is_none() && !remote.trashed) .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 { fn is_below(&self, uid: &NodeUid, ancestor: &NodeUid) -> bool {
let mut cursor = Some(uid.clone()); let mut cursor = Some(uid.clone());
while let Some(at) = cursor { while let Some(at) = cursor {
@@ -1037,6 +1048,12 @@ impl FakeClient {
} }
let parent = new_parent.cloned().or(remote.parent.clone()); let parent = new_parent.cloned().or(remote.parent.clone());
let name = new_name.unwrap_or(&remote.name).to_owned(); 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 let Some(parent) = &parent {
if !server.is_folder(parent) { if !server.is_folder(parent) {
return Err(api( 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 /// Run `profile` on `seed`. It answers a report of what went wrong, if
/// anything did. /// anything did.
pub(crate) fn run(seed: u64, profile: &'static Profile) -> Result<(), String> { 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 dir = scratch(&format!("{}-{seed}", profile.name));
let mut rng = Rng::new(seed); let mut rng = Rng::new(seed);
let drive = FakeDrive::new(); let drive = FakeDrive::new();
@@ -137,6 +139,7 @@ pub(crate) fn run(seed: u64, profile: &'static Profile) -> Result<(), String> {
let _ = daemon.stop(); let _ = daemon.stop();
} }
} }
run.logged.extend(take_logged());
match outcome { match outcome {
Ok(()) => { Ok(()) => {
let _ = std::fs::remove_dir_all(&dir); let _ = std::fs::remove_dir_all(&dir);
@@ -432,6 +435,7 @@ impl Run {
fn report(&self, failure: &str, dir: &Path) -> String { 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("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)..]; let tail = &self.log[self.log.len().saturating_sub(LOG_TAIL)..];
format!( format!(
"{} seed {} failed: {failure}\nreplay with PDFS_SIM_SEED={}; state kept in {}\nlast steps:\n{}", "{} seed {} failed: {failure}\nreplay with PDFS_SIM_SEED={}; state kept in {}\nlast steps:\n{}",
File diff suppressed because it is too large. Load diff
+2
View File
@@ -22,6 +22,8 @@ name = "pdfs-prompt"
path = "src/prompt.rs" path = "src/prompt.rs"
[dependencies] [dependencies]
proton-gallery-rs.workspace = true
base64.workspace = true
pdfs-core.workspace = true pdfs-core.workspace = true
tracing.workspace = true tracing.workspace = true
tracing-subscriber.workspace = true tracing-subscriber.workspace = true
+22 -4
View File
@@ -61,14 +61,28 @@ scale.browser-status-meter trough { min-width: 140px; min-height: 6px; }
/* Photo viewer: always light-on-dark, whatever the system style */ /* Photo viewer: always light-on-dark, whatever the system style */
.photo-viewer-window { background-color: #111014; } .photo-viewer-window { background-color: #111014; }
.viewer-top-bar { background: linear-gradient(to bottom, rgba(0, 0, 0, 0.75), rgba(0, 0, 0, 0)); padding: 10px 16px 28px 20px; color: white; } .media-player-window video { background-color: black; }
.media-player-note { color: rgba(255, 255, 255, 0.5); }
.media-player-note .file-thumbnail { border-radius: 12px; }
.viewer-top-bar { background: linear-gradient(to bottom, rgba(0, 0, 0, 0.85), rgba(0, 0, 0, 0.45) 60%, rgba(0, 0, 0, 0)); padding: 10px 16px 40px 20px; color: white; }
.viewer-title { font-weight: 700; font-size: 1.05rem; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); color: white; } .viewer-title { font-weight: 700; font-size: 1.05rem; text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); color: white; }
.viewer-counter { font-size: 0.8rem; color: rgba(255, 255, 255, 0.72); text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); } .viewer-counter { font-size: 0.8rem; color: rgba(255, 255, 255, 0.72); text-shadow: 0 1px 3px rgba(0, 0, 0, 0.9); }
.viewer-action-btn { color: white; background-color: rgba(255, 255, 255, 0.12); border-radius: 50%; min-width: 34px; min-height: 34px; margin-left: 4px; } /* Dark discs with a white glyph read on a white photo as well as on a black one. */
.viewer-action-btn:hover { background-color: rgba(255, 255, 255, 0.28); color: white; } .viewer-action-btn { color: white; background-color: rgba(0, 0, 0, 0.5); border-radius: 50%; min-width: 36px; min-height: 36px; margin-left: 4px; -gtk-icon-shadow: 0 1px 2px rgba(0, 0, 0, 0.6); }
.viewer-action-btn:hover { background-color: rgba(0, 0, 0, 0.75); color: white; }
.viewer-action-btn:checked { background-color: var(--accent-bg-color); color: var(--accent-fg-color); } .viewer-action-btn:checked { background-color: var(--accent-bg-color); color: var(--accent-fg-color); }
.viewer-close-btn { background-color: rgba(255, 255, 255, 0.2); margin-left: 10px; } .viewer-close-btn { margin-left: 12px; }
.viewer-close-btn:hover { background-color: var(--destructive-bg-color); color: var(--destructive-fg-color); } .viewer-close-btn:hover { background-color: var(--destructive-bg-color); color: var(--destructive-fg-color); }
.viewer-group-pill { color: white; background-color: rgba(0, 0, 0, 0.5); border-radius: 999px; min-height: 36px; padding: 0 14px; font-weight: 700; font-size: 0.85rem; }
.viewer-group-pill:hover { background-color: rgba(0, 0, 0, 0.75); color: white; }
.viewer-group-pill.lit { background-color: var(--accent-bg-color); color: var(--accent-fg-color); }
/* The thumbnail strip along the lightbox's bottom edge, the photo on screen ringed in the accent. */
.viewer-strip-bar { background: linear-gradient(to top, rgba(0, 0, 0, 0.8), rgba(0, 0, 0, 0)); padding: 28px 12px 10px 12px; }
.viewer-strip { background: none; }
.viewer-strip > row { padding: 2px; margin: 0 2px; border-radius: 8px; background: none; }
.viewer-strip > row:hover { background-color: rgba(255, 255, 255, 0.15); }
.viewer-strip > row:selected { background-color: var(--accent-bg-color); }
.viewer-strip-thumb { border-radius: 6px; background-color: rgba(255, 255, 255, 0.08); }
.viewer-nav-btn { background-color: rgba(0, 0, 0, 0.45); color: white; margin: 20px; min-width: 44px; min-height: 44px; border-radius: 50%; opacity: 0.7; transition: opacity 150ms ease, background-color 150ms ease; } .viewer-nav-btn { background-color: rgba(0, 0, 0, 0.45); color: white; margin: 20px; min-width: 44px; min-height: 44px; border-radius: 50%; opacity: 0.7; transition: opacity 150ms ease, background-color 150ms ease; }
.viewer-nav-btn:hover { background-color: rgba(0, 0, 0, 0.85); color: white; opacity: 1; } .viewer-nav-btn:hover { background-color: rgba(0, 0, 0, 0.85); color: white; opacity: 1; }
.viewer-nav-btn:disabled { opacity: 0; } .viewer-nav-btn:disabled { opacity: 0; }
@@ -104,11 +118,15 @@ scale.browser-status-meter trough { min-width: 140px; min-height: 6px; }
.memory-card { padding: 0; border-radius: 12px; } .memory-card { padding: 0; border-radius: 12px; }
.memory-cover { border-radius: 12px; background: alpha(currentColor, 0.06); } .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)); } .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 { padding: 0; border-radius: 16px; transition: background 180ms ease; }
.album-card:hover { background: alpha(currentColor, 0.07); } .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-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 .album-cover { box-shadow: 0 10px 26px rgba(0, 0, 0, 0.5); }
.album-card:hover .photo-thumb { transform: scale(1.05); } .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; } .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. */ /* Shared with Me: what a share lets me do, as a tinted pill beside the name. */
+45 -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); follow_takeout(ui, state, &jobs);
} }
Feed::Event(Event::Changed { topics }) if hidden => { Feed::Event(Event::Changed { topics }) if hidden => {
if topics.contains(&Topic::Photos) {
check_photo_viewer(ui);
}
state.deferred.borrow_mut().extend(topics); state.deferred.borrow_mut().extend(topics);
} }
Feed::Event(Event::Changed { topics }) => follow_changes(ui, state, &topics), Feed::Event(Event::Changed { topics }) => follow_changes(ui, state, &topics),
@@ -128,11 +131,50 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
if changed(Topic::Shares) { if changed(Topic::Shares) {
refresh_invitations_badge(ui, Duration::ZERO); refresh_invitations_badge(ui, Duration::ZERO);
} }
// On any page: a grid, a list or a player may show a tile still blank.
if changed(Topic::Thumbnails) {
refresh_file_thumbnails(ui);
}
let page = ui.stack.visible_child_name(); let page = ui.stack.visible_child_name();
// A timeline out of sight is read again when the user comes back to it; if changed(Topic::GalleryVisibility) || changed(Topic::GalleryVisibilitySynced) {
// one on screen is left alone (below). if let Some(browser) = ui.drive_galleries.borrow().upgrade() {
if changed(Topic::Photos) && (page.as_deref() != Some("gallery") || !photo_grid_shown(ui)) { 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.photo_tex_order.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); 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() { match page.as_deref() {
// A search on screen is left alone: reloading would swap its hits for // A search on screen is left alone: reloading would swap its hits for
@@ -140,8 +182,6 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
Some("browser") if changed(Topic::Files) && ui.browser.search.text().trim().is_empty() => { Some("browser") if changed(Topic::Files) && ui.browser.search.text().trim().is_empty() => {
load_browser(ui) 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") Some("gallery")
if changed(Topic::Photos) if changed(Topic::Photos)
&& ui.gallery.content.visible_child_name().as_deref() == Some("albums") => && ui.gallery.content.visible_child_name().as_deref() == Some("albums") =>
+184 -20
View File
@@ -26,9 +26,12 @@ use pages::photo_viewer::*;
use pages::photos::*; use pages::photos::*;
use pages::places::*; use pages::places::*;
use pages::places_map::*; use pages::places_map::*;
use pages::preferences_apps::*;
use pages::preferences_sync::*;
use pages::shared::*; use pages::shared::*;
use pages::shared_by_me::*; use pages::shared_by_me::*;
use pages::status::*; use pages::status::*;
use pages::sync_exclusions::*;
use pages::takeout::*; use pages::takeout::*;
use pages::trash::*; use pages::trash::*;
use pages::verify::*; use pages::verify::*;
@@ -39,7 +42,10 @@ use widgets::compat::*;
use widgets::crumb::*; use widgets::crumb::*;
use widgets::details::*; use widgets::details::*;
use widgets::file_list::*; use widgets::file_list::*;
use widgets::ignore_dialog::*;
use widgets::menu::*; use widgets::menu::*;
use widgets::photo_drag::*;
use widgets::player::*;
use widgets::scrubber::*; use widgets::scrubber::*;
use widgets::share_dialog::*; use widgets::share_dialog::*;
use widgets::thumbnails::*; use widgets::thumbnails::*;
@@ -75,11 +81,11 @@ use pdfs_core::config::{AppDirs, FileSort, FilesView, PhotosView, WindowState};
use pdfs_core::control::{ use pdfs_core::control::{
ActivityEntry, ActivityKind, AlbumInfo, BookmarkInfo, ConflictInfo, ConflictKeep, DeviceInfo, ActivityEntry, ActivityKind, AlbumInfo, BookmarkInfo, ConflictInfo, ConflictKeep, DeviceInfo,
DirEntry, ErrorKind, ImportSummary, InvitationInfo, JobItem, LinkChange, MappingProgress, DirEntry, ErrorKind, ImportPhase, ImportProgress, ImportSummary, InvitationInfo, JobItem,
PendingOpInfo, PhotoItem, PhotoKind, PhotoMonth, PlaceInfo, PublicLinkInfo, RefreshScope, LinkChange, MappingProgress, PendingOpInfo, PhotoItem, PhotoKind, PhotoMonth, PlaceInfo,
Request, Response, RestorableFolder, RestoreItem, RevisionInfo, SearchHit, ShareEntry, PublicLinkInfo, RefreshScope, Request, Response, RestorableFolder, RestoreItem, RevisionInfo,
ShareEntryKind, SharedItem, SyncFolderInfo, SyncIssue, SyncPhase, SyncProgress, SearchHit, ShareEntry, ShareEntryKind, SharedItem, SyncFolderInfo, SyncIssue, SyncPhase,
ThumbnailBuildStatus, Topic, TransferDirection, TransferItem, send, SyncProgress, ThumbnailBuildStatus, Topic, TransferDirection, TransferItem, send,
}; };
use pdfs_core::mounts::{MountAccess, MountKind, MountMode, MountSpec}; use pdfs_core::mounts::{MountAccess, MountKind, MountMode, MountSpec};
@@ -154,6 +160,7 @@ struct Ui {
pub(crate) details: DetailsState, pub(crate) details: DetailsState,
pub(crate) trash: TrashState, pub(crate) trash: TrashState,
pub(crate) gallery: GalleryState, pub(crate) gallery: GalleryState,
drive_galleries: RefCell<std::rc::Weak<pages::drive_galleries::Browser>>,
pub(crate) shared: SharedState, pub(crate) shared: SharedState,
pub(crate) shared_by_me: SharedByMeState, pub(crate) shared_by_me: SharedByMeState,
pub(crate) devices: DevicesState, pub(crate) devices: DevicesState,
@@ -295,6 +302,39 @@ fn parse_launch(args: &[String]) -> Launch {
Launch::Window Launch::Window
} }
/// The Sync view a `--page` name opens: "activity" lives on as its History
/// view, and "sync-folders" is its Folders view.
fn sync_view(page: &str) -> Option<&'static str> {
match page {
"activity" => Some("history"),
"sync-folders" => Some("folders"),
_ => None,
}
}
/// The Preferences page a `--page` name opens: "preferences" and
/// "preferences-" followed by the page's name.
fn preferences_page(page: &str) -> Option<&'static str> {
match page {
"preferences" | "preferences-general" => Some("general"),
"preferences-sync" => Some("sync"),
"preferences-apps" => Some("apps"),
"preferences-storage" => Some("storage"),
_ => None,
}
}
/// The Photos view a `--page` name opens, and whether Places shows its map:
/// "albums", "places" and "places-map". Other names are stack pages.
fn photos_view(page: &str) -> Option<(u32, bool)> {
match page {
"albums" => Some((VIEW_ALBUMS, false)),
"places" => Some((VIEW_PLACES, false)),
"places-map" => Some((VIEW_PLACES, true)),
_ => None,
}
}
/// Raise the window if there is one, else build it. A second launch reaches /// Raise the window if there is one, else build it. A second launch reaches
/// the running instance, which must not open a second window. /// the running instance, which must not open a second window.
fn present_window(app: &adw::Application) { fn present_window(app: &adw::Application) {
@@ -306,7 +346,15 @@ fn present_window(app: &adw::Application) {
/// Spawn the tray icon process in the background. /// Spawn the tray icon process in the background.
pub(crate) fn spawn_tray() { pub(crate) fn spawn_tray() {
match Command::new("pdfs-tray").spawn() { // The tray installed next to this app, as the tray finds the app; the
// bare name for a PATH install. An install into ~/.local is often not on
// the PATH of a desktop session.
let tray = std::env::current_exe()
.ok()
.and_then(|p| p.parent().map(|d| d.join("pdfs-tray")))
.filter(|p| p.exists())
.unwrap_or_else(|| PathBuf::from("pdfs-tray"));
match Command::new(&tray).spawn() {
Ok(child) => { Ok(child) => {
tracing::info!("spawned `pdfs-tray`"); tracing::info!("spawned `pdfs-tray`");
pdfs_core::opener::reap(child); pdfs_core::opener::reap(child);
@@ -412,6 +460,7 @@ fn build_window(app: &adw::Application) {
nav: split.clone(), nav: split.clone(),
narrow: Cell::new(false), narrow: Cell::new(false),
file_thumbs: FileThumbnailState::new(), file_thumbs: FileThumbnailState::new(),
drive_galleries: RefCell::default(),
login: login_widgets, login: login_widgets,
status: StatusState { status: StatusState {
status_inflight: Cell::new(false), status_inflight: Cell::new(false),
@@ -512,6 +561,10 @@ fn build_window(app: &adw::Application) {
gallery: GalleryState { gallery: GalleryState {
model: gallery_widgets.model.clone(), model: gallery_widgets.model.clone(),
groups: gallery_widgets.groups.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), row_height: Cell::new(ROW_DEFAULT),
scrolling_down: Cell::new(true), scrolling_down: Cell::new(true),
scroll_offset: Cell::new(0.0), scroll_offset: Cell::new(0.0),
@@ -525,6 +578,7 @@ fn build_window(app: &adw::Application) {
jump: Cell::new(None), jump: Cell::new(None),
burst: Cell::new(false), burst: Cell::new(false),
import_banner: gallery_widgets.import_banner.clone(), import_banner: gallery_widgets.import_banner.clone(),
upload_bar: gallery_widgets.upload_bar.clone(),
upload: gallery_widgets.upload.clone(), upload: gallery_widgets.upload.clone(),
empty_actions: gallery_widgets.empty_actions.clone(), empty_actions: gallery_widgets.empty_actions.clone(),
title: gallery_widgets.title.clone(), title: gallery_widgets.title.clone(),
@@ -567,6 +621,10 @@ fn build_window(app: &adw::Application) {
memory_cards: gallery_widgets.memory_cards.clone(), memory_cards: gallery_widgets.memory_cards.clone(),
has_memories: Cell::new(false), has_memories: Cell::new(false),
date_suppress: 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), reload_pending: Cell::new(false),
loading: Cell::new(false), loading: Cell::new(false),
has_more: Cell::new(false), has_more: Cell::new(false),
@@ -578,12 +636,14 @@ fn build_window(app: &adw::Application) {
photo_nothumb: RefCell::new(HashSet::new()), photo_nothumb: RefCell::new(HashSet::new()),
thumb_wanted: RefCell::new(HashMap::new()), thumb_wanted: RefCell::new(HashMap::new()),
thumb_queue: RefCell::new(VecDeque::new()), thumb_queue: RefCell::new(VecDeque::new()),
thumb_inflight: Cell::new(false), thumb_inflight: RefCell::default(),
thumb_generation: Cell::new(0),
decode_queue: RefCell::new(VecDeque::new()), decode_queue: RefCell::new(VecDeque::new()),
decode_idle: Cell::new(false), decode_idle: Cell::new(false),
thumb_source: RefCell::new(None), thumb_source: RefCell::new(None),
relayout_source: RefCell::new(None), relayout_source: RefCell::new(None),
bound: RefCell::new(BTreeMap::new()), bound: RefCell::new(BTreeMap::new()),
visible_tiles_pending: Cell::new(0),
tile_pools: RefCell::new(HashMap::new()), tile_pools: RefCell::new(HashMap::new()),
list: gallery_widgets.list.clone(), list: gallery_widgets.list.clone(),
selecting: Cell::new(false), selecting: Cell::new(false),
@@ -634,6 +694,13 @@ fn build_window(app: &adw::Application) {
views: locations_widgets.views.clone(), views: locations_widgets.views.clone(),
banner: locations_widgets.banner.clone(), banner: locations_widgets.banner.clone(),
failing: Cell::new(0), failing: Cell::new(0),
exclusions: ExclusionsState {
group: locations_widgets.exclusions_group.clone(),
add: locations_widgets.add_pattern.clone(),
rows: RefCell::new(Vec::new()),
folders: RefCell::new(Vec::new()),
generation: Cell::new(0),
},
}, },
activity: ActivityState { activity: ActivityState {
content: activity_widgets.content.clone(), content: activity_widgets.content.clone(),
@@ -665,9 +732,11 @@ fn build_window(app: &adw::Application) {
progress_bar: takeout_widgets.progress_bar.clone(), progress_bar: takeout_widgets.progress_bar.clone(),
summary_group: takeout_widgets.summary_group.clone(), summary_group: takeout_widgets.summary_group.clone(),
summary_rows: RefCell::new(Vec::new()), summary_rows: RefCell::new(Vec::new()),
resume_group: takeout_widgets.resume_group.clone(),
resume_row: takeout_widgets.resume_row.clone(),
resume_button: takeout_widgets.resume_button.clone(),
inflight: Cell::new(false), inflight: Cell::new(false),
running: Cell::new(false), running: Cell::new(false),
dry_run: Cell::new(false),
}, },
update, update,
}); });
@@ -684,6 +753,8 @@ fn build_window(app: &adw::Application) {
&main_widgets.purge_button, &main_widgets.purge_button,
&main_widgets.mountpoint_button, &main_widgets.mountpoint_button,
); );
wire_sync_prefs(&ui, main_widgets.sync_prefs);
wire_apps_prefs(&ui, main_widgets.apps_prefs);
wire_sidebar(&ui); wire_sidebar(&ui);
wire_browser(&ui); wire_browser(&ui);
wire_bulk( wire_bulk(
@@ -713,6 +784,7 @@ fn build_window(app: &adw::Application) {
wire_shared_by_me(&ui, &shared_by_me_widgets); wire_shared_by_me(&ui, &shared_by_me_widgets);
wire_devices(&ui, &devices_widgets); wire_devices(&ui, &devices_widgets);
wire_locations(&ui, &locations_widgets.retry, &locations_widgets.add_folder); wire_locations(&ui, &locations_widgets.retry, &locations_widgets.add_folder);
wire_exclusions(&ui);
wire_activity(&ui, &activity_widgets); wire_activity(&ui, &activity_widgets);
wire_takeout(&ui, &takeout_widgets); wire_takeout(&ui, &takeout_widgets);
wire_retry(&ui); wire_retry(&ui);
@@ -727,6 +799,11 @@ fn build_window(app: &adw::Application) {
// thumbnail generation as it paints. // thumbnail generation as it paints.
cancel_file_thumbnails(&ui_nav); cancel_file_thumbnails(&ui_nav);
sync_sidebar(&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() { match st.visible_child_name().as_deref() {
Some("browser") => reload_browser_view(&ui_nav), Some("browser") => reload_browser_view(&ui_nav),
// The Albums and Places listings are re-read in place. Loading the // The Albums and Places listings are re-read in place. Loading the
@@ -736,7 +813,7 @@ fn build_window(app: &adw::Application) {
// sight (see `follow_changes`) or nothing is loaded yet. // sight (see `follow_changes`) or nothing is loaded yet.
Some("gallery") if !ui_nav.gallery.in_collection() => { Some("gallery") if !ui_nav.gallery.in_collection() => {
match ui_nav.gallery.view_switch.active() { 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), VIEW_PLACES => load_places(&ui_nav),
_ if ui_nav.gallery.timeline_stale.replace(false) _ if ui_nav.gallery.timeline_stale.replace(false)
|| ui_nav.gallery.model.n_items() == 0 => || ui_nav.gallery.model.n_items() == 0 =>
@@ -773,6 +850,14 @@ fn build_window(app: &adw::Application) {
.height_request(WindowState::MIN_HEIGHT) .height_request(WindowState::MIN_HEIGHT)
.content(&toasts) .content(&toasts)
.build(); .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); remember_window_state(&ui, app, &window);
// A wide window docks the details pane beside the files instead of laying it // A wide window docks the details pane beside the files instead of laying it
// over them. // over them.
@@ -842,12 +927,10 @@ fn save_window_state(ui: &Ui, window: &adw::ApplicationWindow) {
height, height,
maximized: window.is_maximized(), maximized: window.is_maximized(),
}; };
let mut config = ui.dirs.load_config(); if ui.dirs.load_config().window == state {
if config.window == state {
return; return;
} }
config.window = state; if let Err(e) = ui.dirs.update_config(|config| config.window = state) {
if let Err(e) = ui.dirs.save_config(&config) {
tracing::warn!("cannot save the window size: {e}"); tracing::warn!("cannot save the window size: {e}");
} }
} }
@@ -1339,7 +1422,7 @@ fn install_window_actions(ui: &Rc<Ui>, window: &adw::ApplicationWindow) {
// The Albums view's New Album button. // The Albums view's New Album button.
let new_album = gio::SimpleAction::new("new-album", None); let new_album = gio::SimpleAction::new("new-album", None);
let ui_album = ui.clone(); let ui_album = ui.clone();
new_album.connect_activate(move |_, _| prompt_new_album(&ui_album, Vec::new())); new_album.connect_activate(move |_, _| prompt_new_album(&ui_album, Vec::new(), None));
window.add_action(&new_album); window.add_action(&new_album);
let shortcuts = gio::SimpleAction::new("shortcuts", None); let shortcuts = gio::SimpleAction::new("shortcuts", None);
@@ -1445,10 +1528,21 @@ fn install_launch_actions(ui: &Rc<Ui>, app: &adw::Application, window: &adw::App
show_login(&ui_page); show_login(&ui_page);
return; return;
} }
// Activity lives on as the Sync page's History view. if let Some(name) = preferences_page(page) {
if page == "activity" { ui_page.status.prefs.set_visible_page_name(name);
ui_page.locations.views.set_visible_child_name("history"); ui_page.status.prefs.present(ui_window(&ui_page).as_ref());
} else if let Some(view) = sync_view(page) {
ui_page.locations.views.set_visible_child_name(view);
ui_page.stack.set_visible_child_name("locations"); ui_page.stack.set_visible_child_name("locations");
} else if let Some((view, map)) = photos_view(page) {
ui_page.stack.set_visible_child_name("gallery");
if view == VIEW_PLACES {
ui_page
.gallery
.places_layout
.set_active(if map { PLACES_MAP } else { 0 });
}
ui_page.gallery.view_switch.set_active(view);
} else if ui_page.stack.child_by_name(page).is_some() { } else if ui_page.stack.child_by_name(page).is_some() {
ui_page.stack.set_visible_child_name(page); ui_page.stack.set_visible_child_name(page);
} }
@@ -1517,7 +1611,7 @@ fn debug_info(ui: &Rc<Ui>) -> String {
/// The keyboard-shortcut cheatsheet behind the menu entry, listing exactly what /// The keyboard-shortcut cheatsheet behind the menu entry, listing exactly what
/// [`install_shortcuts`], the Photos page and the photo viewer bind. /// [`install_shortcuts`], the Photos page and the photo viewer bind.
fn show_shortcuts(window: &adw::ApplicationWindow) { fn show_shortcuts(window: &adw::ApplicationWindow) {
const GROUPS: [(&str, &[(&str, &str)]); 4] = [ const GROUPS: [(&str, &[(&str, &str)]); 5] = [
( (
gettext_noop("General"), gettext_noop("General"),
&[ &[
@@ -1560,8 +1654,20 @@ fn show_shortcuts(window: &adw::ApplicationWindow) {
("Home End", gettext_noop("First / last photo")), ("Home End", gettext_noop("First / last photo")),
("i", gettext_noop("Show details")), ("i", gettext_noop("Show details")),
("f", gettext_noop("Fullscreen")), ("f", gettext_noop("Fullscreen")),
("F5", gettext_noop("Slideshow")),
("F10", gettext_noop("More")),
("<Control>c", gettext_noop("Copy Image")),
("Delete", gettext_noop("Move to Trash")), ("Delete", gettext_noop("Move to Trash")),
("Escape", gettext_noop("Close")), ("Escape <Alt>Left", gettext_noop("Close")),
],
),
(
gettext_noop("Video Player"),
&[
("space k", gettext_noop("Play / pause")),
("j l", gettext_noop("Back / forward 10 seconds")),
("m", gettext_noop("Mute")),
("f", gettext_noop("Fullscreen")),
], ],
), ),
]; ];
@@ -1592,7 +1698,9 @@ fn install_shortcuts(ui: &Rc<Ui>, window: &adw::ApplicationWindow) {
let on_trash = page.as_deref() == Some("trash"); let on_trash = page.as_deref() == Some("trash");
let on_gallery = page.as_deref() == Some("gallery"); let on_gallery = page.as_deref() == Some("gallery");
// Pages with a level to go back to, besides My files' own history. // 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 = let in_shared_folder =
page.as_deref() == Some("shared") && !ui.shared.nav.borrow().is_empty(); page.as_deref() == Some("shared") && !ui.shared.nav.borrow().is_empty();
let in_device_folder = let in_device_folder =
@@ -1997,6 +2105,27 @@ mod tests {
assert_eq!(parse_launch(&args(&["--page"])), Launch::Window); assert_eq!(parse_launch(&args(&["--page"])), Launch::Window);
} }
#[test]
fn a_page_name_can_open_a_photos_or_sync_view() {
assert_eq!(photos_view("albums"), Some((VIEW_ALBUMS, false)));
assert_eq!(photos_view("places"), Some((VIEW_PLACES, false)));
assert_eq!(photos_view("places-map"), Some((VIEW_PLACES, true)));
// The timeline is the Photos stack page itself.
assert_eq!(photos_view("gallery"), None);
assert_eq!(sync_view("activity"), Some("history"));
assert_eq!(sync_view("sync-folders"), Some("folders"));
assert_eq!(sync_view("locations"), None);
}
#[test]
fn a_page_name_can_open_a_preferences_page() {
assert_eq!(preferences_page("preferences"), Some("general"));
assert_eq!(preferences_page("preferences-sync"), Some("sync"));
assert_eq!(preferences_page("preferences-apps"), Some("apps"));
assert_eq!(preferences_page("preferences-storage"), Some("storage"));
assert_eq!(preferences_page("sync"), None);
}
/// One file of a shot, for the group-switch tests. /// One file of a shot, for the group-switch tests.
fn member(uid: &str, name: Option<&str>, kind: PhotoKind) -> PhotoItem { fn member(uid: &str, name: Option<&str>, kind: PhotoKind) -> PhotoItem {
PhotoItem { PhotoItem {
@@ -2010,6 +2139,7 @@ mod tests {
favorite: false, favorite: false,
group_size: 2, group_size: 2,
has_raw: kind == PhotoKind::Raw, has_raw: kind == PhotoKind::Raw,
place_id: None,
} }
} }
@@ -2032,6 +2162,40 @@ mod tests {
assert!(next_group_member(&[], "jpeg").is_none()); assert!(next_group_member(&[], "jpeg").is_none());
} }
/// The upload bar counts the upload under way, not the ones finished.
#[test]
fn the_upload_bar_counts_the_upload_under_way() {
assert_eq!(upload_progress_text(0, 12), "Uploading 1 of 12 items…");
assert_eq!(upload_progress_text(11, 12), "Uploading 12 of 12 items…");
}
/// The pill names what kind of shot it switches through, and lights up
/// on the file that is not the shot's main one.
#[test]
fn the_group_pill_names_the_kind_of_shot() {
let pair = [
member("jpeg", Some("IMG_1.JPG"), PhotoKind::Photo),
member("raw", Some("IMG_1.CR2"), PhotoKind::Raw),
];
assert_eq!(group_pill(&pair, "jpeg"), Some(("RAW".into(), false)));
assert_eq!(group_pill(&pair, "raw"), Some(("RAW".into(), true)));
let live = [
member("still", Some("IMG_2.HEIC"), PhotoKind::Photo),
member("clip", Some("IMG_2.MOV"), PhotoKind::Video),
];
assert_eq!(group_pill(&live, "still"), Some(("Live".into(), false)));
assert_eq!(group_pill(&live, "clip"), Some(("Live".into(), true)));
let burst = [
member("a", None, PhotoKind::Photo),
member("b", None, PhotoKind::Photo),
member("c", None, PhotoKind::Photo),
];
assert_eq!(group_pill(&burst, "b"), Some(("2 of 3".into(), false)));
assert_eq!(group_pill(&burst, "elsewhere"), None);
}
/// The switch names what it will show; a file whose name the daemon has not /// The switch names what it will show; a file whose name the daemon has not
/// resolved still gets a sentence rather than a blank. /// resolved still gets a sentence rather than a blank.
#[test] #[test]
+48 -21
View File
@@ -18,6 +18,9 @@ const COVER_EDGE: i32 = 200;
pub(crate) fn show_albums(ui: &Rc<Ui>) { pub(crate) fn show_albums(ui: &Rc<Ui>) {
show_album_grid(ui); show_album_grid(ui);
load_albums(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 /// 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.albums.remove(&child);
} }
*ui.gallery.album_list.borrow_mut() = albums.to_vec(); *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( ui.gallery.title.set_subtitle(&ngettext_f(
"{n} album", "{n} album",
"{n} albums", "{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 /// 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, /// holds. An album shared with us says so — it lives on someone else's volume,
/// and that is worth knowing before opening it. /// 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() let picture = gtk4::Picture::builder()
// Fills and crops the cover square, like a timeline tile. // Fills and crops the cover square, like a timeline tile.
.content_fit(gtk4::ContentFit::Cover) .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"); picture.add_css_class("photo-thumb");
let placeholder = gtk4::Image::builder() let placeholder = gtk4::Image::builder()
.icon_name("pdfs-album-symbolic") .icon_name(icon)
.pixel_size(32) .pixel_size(32)
.halign(gtk4::Align::Center) .halign(gtk4::Align::Center)
.valign(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(); let cover = gtk4::Overlay::new();
cover.set_child(Some(&placeholder)); cover.set_child(Some(&placeholder));
cover.add_overlay(&picture); 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.set_overflow(gtk4::Overflow::Hidden);
cover.add_css_class("album-cover"); cover.add_css_class("album-cover");
let name = gtk4::Label::builder() let name = gtk4::Label::builder()
.label(&album.name) .label(title)
.halign(gtk4::Align::Start) .halign(gtk4::Align::Start)
.xalign(0.0) .xalign(0.0)
.ellipsize(gtk4::pango::EllipsizeMode::End) .ellipsize(gtk4::pango::EllipsizeMode::End)
@@ -159,7 +167,7 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
name.add_css_class("heading"); name.add_css_class("heading");
let count = gtk4::Label::builder() let count = gtk4::Label::builder()
.label(album_subtitle(album)) .label(subtitle)
.halign(gtk4::Align::Start) .halign(gtk4::Align::Start)
.xalign(0.0) .xalign(0.0)
.ellipsize(gtk4::pango::EllipsizeMode::End) .ellipsize(gtk4::pango::EllipsizeMode::End)
@@ -172,10 +180,23 @@ fn album_card(ui: &Rc<Ui>, album: &AlbumInfo) -> gtk4::Button {
card.append(&name); card.append(&name);
card.append(&count); 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("flat");
button.add_css_class("album-card"); 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() { if let Some(uid) = album.cover_uid.clone() {
want_cover(ui, uid, &picture); want_cover(ui, uid, &picture);
@@ -225,12 +246,13 @@ fn show_album_menu(ui: &Rc<Ui>, album: &AlbumInfo, anchor: &gtk4::Widget, x: f64
/// while the entry is blank. /// while the entry is blank.
fn prompt_album_name( fn prompt_album_name(
ui: &Rc<Ui>, ui: &Rc<Ui>,
parent: Option<gtk4::Window>,
heading: &str, heading: &str,
action: &str, action: &str,
current: &str, current: &str,
on_name: impl Fn(String) + 'static, on_name: impl Fn(String) + 'static,
) { ) {
let win = ui_window(ui); let win = parent.or_else(|| ui_window(ui));
let dialog = adw::AlertDialog::builder().heading(heading).build(); let dialog = adw::AlertDialog::builder().heading(heading).build();
let group = adw::PreferencesGroup::new(); let group = adw::PreferencesGroup::new();
let row = adw::EntryRow::builder() let row = adw::EntryRow::builder()
@@ -260,10 +282,12 @@ fn prompt_album_name(
} }
/// Ask for a name and create an album, then add `photos` to it, if any. /// Ask for a name and create an album, then add `photos` to it, if any.
pub(crate) fn prompt_new_album(ui: &Rc<Ui>, photos: Vec<String>) { ///
/// The dialogs open over `parent`, or over the main window without one.
pub(crate) fn prompt_new_album(ui: &Rc<Ui>, photos: Vec<String>, parent: Option<gtk4::Window>) {
let ui_c = ui.clone(); let ui_c = ui.clone();
let (heading, action) = (gettext("New Album"), gettext("Create")); let (heading, action) = (gettext("New Album"), gettext("Create"));
prompt_album_name(ui, &heading, &action, "", move |name| { prompt_album_name(ui, parent, &heading, &action, "", move |name| {
let rx = spawn_request(ui_c.dirs.control_socket(), Request::CreateAlbum { name }); let rx = spawn_request(ui_c.dirs.control_socket(), Request::CreateAlbum { name });
let ui = ui_c.clone(); let ui = ui_c.clone();
let photos = photos.clone(); let photos = photos.clone();
@@ -296,7 +320,7 @@ pub(crate) fn prompt_new_album(ui: &Rc<Ui>, photos: Vec<String>) {
fn prompt_rename_album(ui: &Rc<Ui>, album: &AlbumInfo) { fn prompt_rename_album(ui: &Rc<Ui>, album: &AlbumInfo) {
let (ui_c, uid) = (ui.clone(), album.uid.clone()); let (ui_c, uid) = (ui.clone(), album.uid.clone());
let (heading, action) = (gettext("Rename Album"), gettext("Rename")); let (heading, action) = (gettext("Rename Album"), gettext("Rename"));
prompt_album_name(ui, &heading, &action, &album.name, move |name| { prompt_album_name(ui, None, &heading, &action, &album.name, move |name| {
run_album_request( run_album_request(
&ui_c, &ui_c,
Request::RenameAlbum { Request::RenameAlbum {
@@ -368,7 +392,7 @@ fn reload_album_grid(ui: &Rc<Ui>) {
} }
/// Offer our own albums to add `photos` to, plus a new one. /// Offer our own albums to add `photos` to, plus a new one.
pub(crate) fn prompt_add_to_album(ui: &Rc<Ui>, photos: Vec<String>) { pub(crate) fn prompt_add_to_album(ui: &Rc<Ui>, photos: Vec<String>, parent: Option<gtk4::Window>) {
let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoAlbums); let rx = spawn_request(ui.dirs.control_socket(), Request::PhotoAlbums);
let ui = ui.clone(); let ui = ui.clone();
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
@@ -390,7 +414,7 @@ pub(crate) fn prompt_add_to_album(ui: &Rc<Ui>, photos: Vec<String>) {
} }
}; };
if albums.is_empty() { if albums.is_empty() {
prompt_new_album(&ui, photos); prompt_new_album(&ui, photos, parent);
return; return;
} }
@@ -436,11 +460,11 @@ pub(crate) fn prompt_add_to_album(ui: &Rc<Ui>, photos: Vec<String>) {
add_to_album(&ui_c, album.uid.clone(), photos_c.clone()); add_to_album(&ui_c, album.uid.clone(), photos_c.clone());
} }
}); });
let ui_c = ui.clone(); let (ui_c, parent_c) = (ui.clone(), parent.clone());
dialog.connect_response(Some("new"), move |_, _| { dialog.connect_response(Some("new"), move |_, _| {
prompt_new_album(&ui_c, photos.clone()) prompt_new_album(&ui_c, photos.clone(), parent_c.clone())
}); });
dialog.present(ui_window(&ui).as_ref()); dialog.present(parent.or_else(|| ui_window(&ui)).as_ref());
}); });
} }
@@ -595,10 +619,7 @@ pub(crate) fn want_cover(ui: &Rc<Ui>, uid: String, picture: &gtk4::Picture) {
if ui.gallery.photo_nothumb.borrow().contains(&uid) { if ui.gallery.photo_nothumb.borrow().contains(&uid) {
return; return;
} }
ui.gallery ui.gallery.await_thumb(&uid, picture);
.thumb_wanted
.borrow_mut()
.insert(uid.clone(), picture.clone());
let mut queue = ui.gallery.thumb_queue.borrow_mut(); let mut queue = ui.gallery.thumb_queue.borrow_mut();
if !queue.contains(&uid) { if !queue.contains(&uid) {
queue.push_back(uid); queue.push_back(uid);
@@ -693,6 +714,12 @@ pub(crate) fn wire_albums(ui: &Rc<Ui>) {
// where it was, instead of reloading it. // where it was, instead of reloading it.
let ui_back = ui.clone(); let ui_back = ui.clone();
ui.gallery.back.clone().connect_clicked(move |_| { 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() { if ui_back.gallery.place.borrow().is_some() {
show_place_grid(&ui_back); show_place_grid(&ui_back);
return; return;
+15 -57
View File
@@ -898,27 +898,15 @@ fn show_location_column(ui: &Rc<Ui>, visible: bool) {
pub(crate) fn entry_context_menu(ui: &Rc<Ui>, entry: &DirEntry) -> ActionMenu { pub(crate) fn entry_context_menu(ui: &Rc<Ui>, entry: &DirEntry) -> ActionMenu {
let mut menu = ActionMenu::new(); let mut menu = ActionMenu::new();
let (ui_c, entry_c) = (ui.clone(), entry.clone()); let (ui_c, entry_c) = (ui.clone(), entry.clone());
// Open does what a double-click does: a video or a song plays in the app,
// and Open With is the way to another player.
menu.item(&pgettext("verb", "Open"), move || { menu.item(&pgettext("verb", "Open"), move || {
// Open always means "download a local copy and hand off", even for a activate_entry(&ui_c, &entry_c)
// media file — `activate_entry` would otherwise stream it.
if is_streamable_media_entry(&entry_c) {
download_and_open(&ui_c, &entry_c);
} else {
activate_entry(&ui_c, &entry_c);
}
}); });
let (ui_c, entry_c) = (ui.clone(), entry.clone()); let (ui_c, entry_c) = (ui.clone(), entry.clone());
menu.item(&gettext("Open With…"), move || { menu.item(&gettext("Open With…"), move || {
open_entry_with(&ui_c, &entry_c) open_entry_with(&ui_c, &entry_c)
}); });
// Play streams from the mount, no download; Open above still fetches a
// local copy for anyone who wants one.
if is_streamable_media_entry(entry) {
let (ui_c, entry_c) = (ui.clone(), entry.clone());
menu.item(&pgettext("verb", "Play"), move || {
stream_entry(&ui_c, &entry_c)
});
}
menu.section(); menu.section();
// Kept through a pinned folder above it, the entry has no pin of its own // Kept through a pinned folder above it, the entry has no pin of its own
@@ -1107,38 +1095,8 @@ pub(crate) fn entry_at(model: Option<&impl IsA<gio::ListModel>>, pos: u32) -> Op
Some(entry) Some(entry)
} }
/// Whether an entry can be opened through FUSE instead of fully materialized. /// Open an entry the Nautilus way: folders descend, media plays in the app,
pub(crate) fn is_streamable_media_entry(entry: &DirEntry) -> bool { /// streamed from the mount, other files download-and-open.
drive_activation(&entry.name, entry.is_dir) == DriveActivation::MountedMedia
}
/// Stream media straight from the mount, no download. Drive folders *are* part
/// of the FUSE mount, so a player pointed at `<mountpoint>/<rel>` reads the file
/// through [`Core::read_range_remote`] — 4 MB blocks fetched on demand as it
/// seeks and buffers — instead of waiting for the whole file to land like
/// [`Request::OpenFile`] does. This is the point of the feature: a 2 GB HEVC
/// `.mkv` starts playing in seconds.
pub(crate) fn stream_entry(ui: &Rc<Ui>, entry: &DirEntry) {
let rel = entry_rel(ui, entry);
let mountpoint = ui.dirs.resolved_mountpoint(&ui.dirs.load_config());
let abs = mounted_path(&mountpoint, &rel);
let Some(path) = abs.to_str() else {
toast_error(
ui,
&gettext("Couldn't play media"),
&gettext("The file path isn't valid UTF-8."),
);
return;
};
toast(
ui,
&gettext_f("Streaming “{name}”…", &[("name", &entry.name)]),
);
play_external(path);
}
/// Open an entry the Nautilus way: folders descend, media streams from the mount,
/// other files download-and-open.
pub(crate) fn activate_entry(ui: &Rc<Ui>, entry: &DirEntry) { pub(crate) fn activate_entry(ui: &Rc<Ui>, entry: &DirEntry) {
let rel = entry_rel(ui, entry); let rel = entry_rel(ui, entry);
if entry.is_dir { if entry.is_dir {
@@ -1151,16 +1109,16 @@ pub(crate) fn activate_entry(ui: &Rc<Ui>, entry: &DirEntry) {
} else if drive_activation(&entry.name, entry.is_dir) == DriveActivation::MountedMedia { } else if drive_activation(&entry.name, entry.is_dir) == DriveActivation::MountedMedia {
// Media streams rather than downloads: that is exactly the "play it, // Media streams rather than downloads: that is exactly the "play it,
// don't fetch the whole thing" behaviour this is for. // don't fetch the whole thing" behaviour this is for.
stream_entry(ui, entry); open_media_player(ui, entry);
} else { } else {
download_and_open(ui, entry); download_and_open(ui, entry);
} }
} }
/// Hand a file to the user's default application: through the mount when it is /// Hand a file to the user's default application: through the mount when it is
/// there, otherwise downloaded into the cache first. The open path behind both /// there, otherwise downloaded into the cache first. The open path behind a
/// a plain double-click and the context menu's "Open" (including for a video, /// double-click and the context menu's "Open" for anything but a folder or
/// when the user wants their default application rather than the player). /// media, and for media the mount doesn't show.
/// ///
/// The mount comes first because the cache blob is a *copy* keyed by content /// The mount comes first because the cache blob is a *copy* keyed by content
/// hash — an application saving into it writes where Drive will never look, and /// hash — an application saving into it writes where Drive will never look, and
@@ -1473,9 +1431,11 @@ fn save_icon_size(ui: &Rc<Ui>, size: i32) {
let ui_save = ui.clone(); let ui_save = ui.clone();
let source = glib::timeout_add_local_once(Duration::from_millis(500), move || { let source = glib::timeout_add_local_once(Duration::from_millis(500), move || {
ui_save.browser.zoom_save.borrow_mut().take(); ui_save.browser.zoom_save.borrow_mut().take();
let mut config = ui_save.dirs.load_config(); let icon_size = ui_save.browser.view.get().icon_size;
config.files_view.icon_size = ui_save.browser.view.get().icon_size; if let Err(e) = ui_save
if let Err(e) = ui_save.dirs.save_config(&config) { .dirs
.update_config(|config| config.files_view.icon_size = icon_size)
{
tracing::warn!("cannot save the icon size: {e}"); tracing::warn!("cannot save the icon size: {e}");
} }
}); });
@@ -1506,9 +1466,7 @@ pub(crate) fn set_files_view(ui: &Rc<Ui>, view: FilesView) {
return; return;
} }
apply_files_view(ui, view); apply_files_view(ui, view);
let mut config = ui.dirs.load_config(); if let Err(e) = ui.dirs.update_config(|config| config.files_view = view) {
config.files_view = view;
if let Err(e) = ui.dirs.save_config(&config) {
toast_error(ui, &gettext("Couldn't save the view"), &e.to_string()); toast_error(ui, &gettext("Couldn't save the view"), &e.to_string());
} }
if (old.sort, old.descending, old.folders_first) if (old.sort, old.descending, old.folders_first)
File diff suppressed because it is too large. Load diff
+26 -1
View File
@@ -35,6 +35,8 @@ pub(crate) struct LocationsState {
pub(crate) banner: adw::Banner, pub(crate) banner: adw::Banner,
/// Changes the daemon failed to upload, from the last status. /// Changes the daemon failed to upload, from the last status.
pub(crate) failing: Cell<u64>, pub(crate) failing: Cell<u64>,
/// Excluded Files, under the folder list.
pub(crate) exclusions: ExclusionsState,
} }
/// The status card heading the Sync page's Overview, and Pause/Resume in the /// The status card heading the Sync page's Overview, and Pause/Resume in the
@@ -120,6 +122,8 @@ pub(crate) struct LocationsWidgets {
pub(crate) conflicts_group: adw::PreferencesGroup, pub(crate) conflicts_group: adw::PreferencesGroup,
pub(crate) views: adw::ViewStack, pub(crate) views: adw::ViewStack,
pub(crate) banner: adw::Banner, pub(crate) banner: adw::Banner,
pub(crate) exclusions_group: adw::PreferencesGroup,
pub(crate) add_pattern: gtk4::Button,
} }
/// The Sync page: Overview (the status, conflicts, transfers and queue), /// The Sync page: Overview (the status, conflicts, transfers and queue),
@@ -208,8 +212,14 @@ pub(crate) fn build_locations_page(history: &gtk4::Widget) -> (gtk4::Widget, Loc
.child(&status) .child(&status)
.build(); .build();
// What the folders leave out, under them: the rules belong to the folders.
let (exclusions_group, add_pattern) = build_exclusions_group();
let folders = gtk4::Box::new(gtk4::Orientation::Vertical, 24);
folders.append(&group);
folders.append(&exclusions_group);
let content = gtk4::Stack::new(); let content = gtk4::Stack::new();
content.add_named(&scrolled_column(&group), Some("list")); content.add_named(&scrolled_column(&folders), Some("list"));
content.add_named(&status_scroll, Some("status")); content.add_named(&status_scroll, Some("status"));
let views = adw::ViewStack::new(); let views = adw::ViewStack::new();
@@ -267,6 +277,8 @@ pub(crate) fn build_locations_page(history: &gtk4::Widget) -> (gtk4::Widget, Loc
conflicts_group, conflicts_group,
views, views,
banner, banner,
exclusions_group,
add_pattern,
}; };
(frame.upcast(), widgets) (frame.upcast(), widgets)
} }
@@ -776,6 +788,9 @@ pub(crate) fn issue_text(issue: SyncIssue) -> String {
SyncIssue::Access => gettext( 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.", "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( SyncIssue::Missing => gettext(
"The folder this change belongs in is gone from Proton Drive. Export the file to keep your version.", "The folder this change belongs in is gone from Proton Drive. Export the file to keep your version.",
), ),
@@ -1243,6 +1258,7 @@ pub(crate) fn repaint_locations(ui: &Rc<Ui>, items: &[MountSpec]) {
}; };
if !unchanged { if !unchanged {
rebuild_locations(ui, items, keys); rebuild_locations(ui, items, keys);
paint_exclusions(ui, items);
} }
for (row, spec) in ui.locations.rows.borrow().iter().zip(items) { for (row, spec) in ui.locations.rows.borrow().iter().zip(items) {
update_location_row(row, spec); update_location_row(row, spec);
@@ -1498,6 +1514,7 @@ fn folder_mode_label(ondemand: bool) -> String {
/// synced folder's menu. /// synced folder's menu.
fn add_device_items(ui: &Rc<Ui>, menu: &mut ActionMenu, spec: &MountSpec, id: i64) { fn add_device_items(ui: &Rc<Ui>, menu: &mut ActionMenu, spec: &MountSpec, id: i64) {
if spec.mode != MountMode::OnDemand { if spec.mode != MountMode::OnDemand {
let ui_ignore = ui.clone();
// A paused folder skips its passes, so Sync now would do nothing. // A paused folder skips its passes, so Sync now would do nothing.
if !spec.paused { if !spec.paused {
let ui = ui.clone(); let ui = ui.clone();
@@ -1516,6 +1533,14 @@ fn add_device_items(ui: &Rc<Ui>, menu: &mut ActionMenu, spec: &MountSpec, id: i6
menu.item(&gettext("Sync From Scratch…"), move || { menu.item(&gettext("Sync From Scratch…"), move || {
confirm_reset_sync_folder(&ui, id, &path) confirm_reset_sync_folder(&ui, id, &path)
}); });
// Only a synced copy has local files for the rules to leave out.
if spec.mode == MountMode::Mirror {
let ui = ui_ignore;
let root = PathBuf::from(&spec.local_path);
menu.item(&gettext("Excluded Files…"), move || {
present_ignore_dialog(&ui, id, root.clone())
});
}
menu.section(); menu.section();
} }
let ui = ui.clone(); let ui = ui.clone();
+4
View File
@@ -683,6 +683,10 @@ pub(crate) fn sign_out(ui: &Rc<Ui>) {
), ),
&gettext("Sign Out"), &gettext("Sign Out"),
move || { 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. // systemctl and the keyring both block, so run them on a worker.
let ui = ui.clone(); let ui = ui.clone();
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
+4
View File
@@ -3,6 +3,7 @@ pub(crate) mod activity_text;
pub(crate) mod albums; pub(crate) mod albums;
pub(crate) mod browser; pub(crate) mod browser;
pub(crate) mod devices; pub(crate) mod devices;
pub(crate) mod drive_galleries;
pub(crate) mod duplicates; pub(crate) mod duplicates;
pub(crate) mod locations; pub(crate) mod locations;
pub(crate) mod login; pub(crate) mod login;
@@ -12,9 +13,12 @@ pub(crate) mod photo_viewer;
pub(crate) mod photos; pub(crate) mod photos;
pub(crate) mod places; pub(crate) mod places;
pub(crate) mod places_map; pub(crate) mod places_map;
pub(crate) mod preferences_apps;
pub(crate) mod preferences_sync;
pub(crate) mod shared; pub(crate) mod shared;
pub(crate) mod shared_by_me; pub(crate) mod shared_by_me;
pub(crate) mod status; pub(crate) mod status;
pub(crate) mod sync_exclusions;
pub(crate) mod takeout; pub(crate) mod takeout;
pub(crate) mod trash; pub(crate) mod trash;
pub(crate) mod verify; pub(crate) mod verify;
+566 -148
View File
@@ -31,6 +31,11 @@ pub(crate) struct Viewer {
pub(crate) scroller: gtk4::ScrolledWindow, pub(crate) scroller: gtk4::ScrolledWindow,
pub(crate) picture: gtk4::Picture, pub(crate) picture: gtk4::Picture,
pub(crate) video: gtk4::Video, 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) spinner: Spinner,
pub(crate) status: gtk4::Label, pub(crate) status: gtk4::Label,
pub(crate) title: gtk4::Label, pub(crate) title: gtk4::Label,
@@ -52,9 +57,9 @@ pub(crate) struct Viewer {
/// uses for its pin switch, so painting a photo doesn't fire a round-trip. /// uses for its pin switch, so painting a photo doesn't fire a round-trip.
pub(crate) favorite: gtk4::ToggleButton, pub(crate) favorite: gtk4::ToggleButton,
pub(crate) favorite_suppress: Cell<bool>, pub(crate) favorite_suppress: Cell<bool>,
/// The button that switches between the files of one shot, and the files it /// The pill that switches between the files of one shot, and the files it
/// switches between (the JPEG and the RAW of a photo, a live photo and its /// switches between (the JPEG and the RAW of a photo, a live photo and its
/// clip). Empty, and the button hidden, for a photo stored as one file. /// clip). Empty, and the pill hidden, for a photo stored as one file.
pub(crate) group_btn: gtk4::Button, pub(crate) group_btn: gtk4::Button,
pub(crate) group: RefCell<Vec<PhotoItem>>, pub(crate) group: RefCell<Vec<PhotoItem>>,
/// uid of the photo currently on screen. /// uid of the photo currently on screen.
@@ -81,14 +86,25 @@ pub(crate) struct Viewer {
/// rests; whether the pointer is over one of them (which keeps them up); /// rests; whether the pointer is over one of them (which keeps them up);
/// and the pending fade-out. /// and the pending fade-out.
pub(crate) chrome: Vec<gtk4::Revealer>, pub(crate) chrome: Vec<gtk4::Revealer>,
/// The strip of thumbnails along the bottom, its selection (the photo on
/// screen), and the revealer it fades with. Hidden in a slideshow.
pub(crate) strip: gtk4::ListView,
pub(crate) strip_selection: gtk4::SingleSelection,
pub(crate) strip_reveal: gtk4::Revealer,
pub(crate) chrome_hover: Cell<bool>, pub(crate) chrome_hover: Cell<bool>,
pub(crate) chrome_source: RefCell<Option<glib::SourceId>>, pub(crate) chrome_source: RefCell<Option<glib::SourceId>>,
/// The slideshow toggle; the timer that moves it on; and whether it put /// The ⋮ button, and whether its menu is open, which keeps the controls
/// the window in fullscreen, so stopping it only leaves a fullscreen it /// up the way resting the pointer on them does.
pub(crate) more: gtk4::Button,
pub(crate) menu_open: Cell<bool>,
/// Whether a slideshow runs; the timer that moves it on; and whether it
/// put the window in fullscreen, so stopping it only leaves a fullscreen it
/// entered itself. /// entered itself.
pub(crate) slideshow: gtk4::ToggleButton, pub(crate) slideshow: Cell<bool>,
pub(crate) slide_source: RefCell<Option<glib::SourceId>>, pub(crate) slide_source: RefCell<Option<glib::SourceId>>,
pub(crate) slide_fullscreened: Cell<bool>, pub(crate) slide_fullscreened: Cell<bool>,
/// Toasts over the lightbox. The main window's would land behind it.
pub(crate) toasts: adw::ToastOverlay,
} }
/// Camera/exposure/location facts pulled from a photo's own EXIF tags, as /// Camera/exposure/location facts pulled from a photo's own EXIF tags, as
@@ -163,6 +179,14 @@ fn load_photo_group(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: &str) {
.group_btn .group_btn
.set_tooltip_text(Some(&member_tooltip(next))); .set_tooltip_text(Some(&member_tooltip(next)));
} }
if let Some((label, lit)) = group_pill(&items, &uid) {
viewer.group_btn.set_label(&label);
if lit {
viewer.group_btn.add_css_class("lit");
} else {
viewer.group_btn.remove_css_class("lit");
}
}
*viewer.group.borrow_mut() = items; *viewer.group.borrow_mut() = items;
viewer.group_btn.set_visible(true); viewer.group_btn.set_visible(true);
}); });
@@ -175,6 +199,34 @@ pub(crate) fn next_group_member<'a>(members: &'a [PhotoItem], uid: &str) -> Opti
members.get((at + 1) % members.len()) members.get((at + 1) % members.len())
} }
/// What the group pill reads for the shot whose files are `members`, with
/// `uid` on screen, and whether it is lit. A raw pair reads "RAW", lit while
/// the raw file is shown; a live photo reads "Live", lit while its clip plays;
/// a burst counts its frames.
pub(crate) fn group_pill(members: &[PhotoItem], uid: &str) -> Option<(String, bool)> {
let at = members.iter().position(|item| item.uid == uid)?;
let shown = members[at].kind;
if members.iter().any(|item| item.kind == PhotoKind::Raw) {
// Translators: badge on a photo tile whose shot includes a raw camera file.
return Some((gettext("RAW"), shown == PhotoKind::Raw));
}
if members.len() == 2 && members.iter().any(|item| item.kind == PhotoKind::Video) {
// Translators: the switch between a live photo and its short clip in the photo viewer.
return Some((pgettext("live photo", "Live"), shown == PhotoKind::Video));
}
Some((
// Translators: the lightbox counter, such as "12 of 340"; {position} is the photo's place, {total} how many there are.
gettext_f(
"{position} of {total}",
&[
("position", &thousands(at + 1)),
("total", &thousands(members.len())),
],
),
false,
))
}
/// What to call one file of a shot: its name, or its kind when the daemon has /// What to call one file of a shot: its name, or its kind when the daemon has
/// not resolved a name for it. /// not resolved a name for it.
pub(crate) fn member_label(item: &PhotoItem) -> String { pub(crate) fn member_label(item: &PhotoItem) -> String {
@@ -225,13 +277,16 @@ 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 /// full-size file, and swap it in — plus its EXIF — when it lands. A video
/// plays in place once its file is down. /// plays in place once its file is down.
pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) { 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.spinner.set_visible(true);
viewer.status.set_visible(false); viewer.status.set_visible(false);
viewer.loading.set(true); viewer.loading.set(true);
*viewer.path.borrow_mut() = None; *viewer.path.borrow_mut() = None;
clear_info(viewer); clear_info(viewer);
stop_video(viewer); stop_video(ui, viewer);
viewer.media.set_visible_child_name("photo"); viewer.media.set_visible_child_name("photo");
sync_strip(viewer);
reset_zoom(viewer); reset_zoom(viewer);
// A slideshow waits for this photo to land before it starts counting. // A slideshow waits for this photo to land before it starts counting.
disarm_slide(viewer); disarm_slide(viewer);
@@ -254,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), None => viewer.picture.set_paintable(gtk4::gdk::Paintable::NONE),
} }
let rx = spawn_request( let request = if is_video {
ui.dirs.control_socket(), Request::OpenGalleryVideo {
Request::OpenPhoto { uid: uid.clone() }, 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 viewer = viewer.clone();
let ui = ui.clone(); let ui = ui.clone();
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
let result = rx.recv().await; let result = rx.recv().await;
// The user may have moved on while this was in flight; that photo's own // The user may have moved on while this was in flight; that photo's own
// request owns the viewer now. // 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; return;
} }
viewer.spinner.set_visible(false); viewer.spinner.set_visible(false);
@@ -278,6 +341,14 @@ pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) {
viewer.status.set_visible(true); viewer.status.set_visible(true);
}; };
let path = match result { 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::FilePath { path })) => path,
Ok(Ok(Response::Error { message, .. })) => return fail(&message), Ok(Ok(Response::Error { message, .. })) => return fail(&message),
Ok(Ok(_)) => return fail(&gettext("Unexpected reply from the Proton Drive service.")), Ok(Ok(_)) => return fail(&gettext("Unexpected reply from the Proton Drive service.")),
@@ -309,6 +380,7 @@ pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) {
None => { None => {
viewer.video.set_filename(Some(&path)); viewer.video.set_filename(Some(&path));
viewer.media.set_visible_child_name("video"); viewer.media.set_visible_child_name("video");
sync_strip(&viewer);
*viewer.path.borrow_mut() = Some(path.clone()); *viewer.path.borrow_mut() = Some(path.clone());
show_info(&viewer, size, ExifInfo::default()); show_info(&viewer, size, ExifInfo::default());
} }
@@ -341,14 +413,15 @@ pub(crate) fn load_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>, uid: String) {
/// Start the slideshow: fullscreen, controls out of the way, and the photo on /// Start the slideshow: fullscreen, controls out of the way, and the photo on
/// screen counted down once it has loaded. /// screen counted down once it has loaded.
fn start_slideshow(ui: &Rc<Ui>, viewer: &Rc<Viewer>) { fn start_slideshow(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
if viewer.slideshow.replace(true) {
return;
}
if !viewer.window.is_fullscreen() { if !viewer.window.is_fullscreen() {
viewer.window.fullscreen(); viewer.window.fullscreen();
viewer.slide_fullscreened.set(true); viewer.slide_fullscreened.set(true);
} }
viewer
.slideshow
.set_icon_name("media-playback-pause-symbolic");
hide_chrome(viewer); hide_chrome(viewer);
sync_strip(viewer);
if !viewer.loading.get() { if !viewer.loading.get() {
arm_slide(ui, viewer); arm_slide(ui, viewer);
} }
@@ -356,13 +429,20 @@ fn start_slideshow(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
/// Stop the slideshow, leaving fullscreen only if the slideshow entered it. /// Stop the slideshow, leaving fullscreen only if the slideshow entered it.
fn stop_slideshow(viewer: &Rc<Viewer>) { fn stop_slideshow(viewer: &Rc<Viewer>) {
viewer.slideshow.set(false);
sync_strip(viewer);
disarm_slide(viewer); disarm_slide(viewer);
if viewer.slide_fullscreened.replace(false) { if viewer.slide_fullscreened.replace(false) {
viewer.window.unfullscreen(); viewer.window.unfullscreen();
} }
viewer.slideshow.set_icon_name("pdfs-slideshow-symbolic"); }
if viewer.slideshow.is_active() {
viewer.slideshow.set_active(false); /// Start the slideshow, or stop the one running.
fn toggle_slideshow(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
if viewer.slideshow.get() {
stop_slideshow(viewer);
} else {
start_slideshow(ui, viewer);
} }
} }
@@ -370,7 +450,7 @@ fn stop_slideshow(viewer: &Rc<Viewer>) {
/// [`SLIDESHOW_INTERVAL`] for a still, once it has played through for a video. /// [`SLIDESHOW_INTERVAL`] for a still, once it has played through for a video.
fn arm_slide(ui: &Rc<Ui>, viewer: &Rc<Viewer>) { fn arm_slide(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
disarm_slide(viewer); disarm_slide(viewer);
if !viewer.slideshow.is_active() { if !viewer.slideshow.get() {
return; return;
} }
let playing_video = viewer.media.visible_child_name().as_deref() == Some("video"); let playing_video = viewer.media.visible_child_name().as_deref() == Some("video");
@@ -424,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 /// Stop whatever the player was playing, so stepping off a video (or closing
/// the lightbox) doesn't leave its sound running. /// 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); 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 /// Warm the cache with the photo `delta` steps away, so stepping there is
@@ -790,7 +880,7 @@ fn show_chrome(viewer: &Rc<Viewer>) {
}; };
// This timer has fired, so its id must not be removed again. // This timer has fired, so its id must not be removed again.
viewer.chrome_source.borrow_mut().take(); viewer.chrome_source.borrow_mut().take();
if !viewer.chrome_hover.get() { if !viewer.chrome_hover.get() && !viewer.menu_open.get() {
hide_chrome(&viewer); hide_chrome(&viewer);
} }
}); });
@@ -808,14 +898,14 @@ fn hide_chrome(viewer: &Rc<Viewer>) {
} }
/// Copy the photo on screen to where the user picks, under its Drive name. /// Copy the photo on screen to where the user picks, under its Drive name.
pub(crate) fn save_photo_to_disk(ui: &Rc<Ui>, window: &gtk4::Window, source: &str, name: &str) { pub(crate) fn save_photo_to_disk(viewer: &Rc<Viewer>, source: &str, name: &str) {
let dialog = gtk4::FileDialog::builder() let dialog = gtk4::FileDialog::builder()
.title(gettext("Save a Copy")) .title(gettext("Save a Copy"))
.initial_name(name) .initial_name(name)
.build(); .build();
let source = source.to_string(); let source = source.to_string();
let ui = ui.clone(); let toasts = viewer.toasts.clone();
dialog.save(Some(window), gio::Cancellable::NONE, move |res| { dialog.save(Some(&viewer.window), gio::Cancellable::NONE, move |res| {
// An error here is the dialog being dismissed. // An error here is the dialog being dismissed.
let Some(dest) = res.ok().and_then(|file| file.path()) else { let Some(dest) = res.ok().and_then(|file| file.path()) else {
return; return;
@@ -824,26 +914,67 @@ pub(crate) fn save_photo_to_disk(ui: &Rc<Ui>, window: &gtk4::Window, source: &st
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
let copied = let copied =
gio::spawn_blocking(move || std::fs::copy(&source, &dest).map(|_| dest)).await; gio::spawn_blocking(move || std::fs::copy(&source, &dest).map(|_| dest)).await;
match copied { let message = match copied {
Ok(Ok(dest)) => { Ok(Ok(dest)) => {
let saved = dest.file_name().map_or_else( let saved = dest.file_name().map_or_else(
|| dest.display().to_string(), || dest.display().to_string(),
|name| name.to_string_lossy().into_owned(), |name| name.to_string_lossy().into_owned(),
); );
// Translators: {name} is the saved file's name. // Translators: {name} is the saved file's name.
toast(&ui, &gettext_f("Saved “{name}”", &[("name", &saved)])); gettext_f("Saved “{name}”", &[("name", &saved)])
} }
Ok(Err(e)) => toast_error(&ui, &gettext("Couldn't save the copy"), &e.to_string()), Ok(Err(e)) => failure(&gettext("Couldn't save the copy"), &e.to_string()),
Err(_) => toast_error( Err(_) => failure(
&ui,
&gettext("Couldn't save the copy"), &gettext("Couldn't save the copy"),
&gettext("The copy was interrupted."), &gettext("The copy was interrupted."),
), ),
} };
toasts.add_toast(
adw::Toast::builder()
.title(&message)
.use_markup(false)
.build(),
);
}); });
}); });
} }
/// A failed action's toast text, worded like [`toast_error`]'s.
fn failure(what: &str, detail: &str) -> String {
tracing::warn!("{what}: {detail}");
// Translators: a failed action's toast. {what} says what failed, such as
// "Couldn't rename"; {detail} is the reason, usually untranslated text
// from the mount service.
gettext_f("{what}: {detail}", &[("what", what), ("detail", detail)])
}
/// Put the photo on screen on the clipboard as an image, for pasting into a
/// chat or a document.
fn copy_shown_photo(_ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
let Some(texture) = viewer
.picture
.paintable()
.and_downcast::<gtk4::gdk::Texture>()
else {
return;
};
viewer.window.clipboard().set_texture(&texture);
viewer.toasts.add_toast(
adw::Toast::builder()
// Translators: toast after the photo viewer put the photo on the clipboard.
.title(gettext("Image copied"))
.use_markup(false)
.build(),
);
}
/// Open the Share dialog for the photo on screen, over the lightbox.
fn share_shown_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
let uid = viewer.uid.borrow().clone();
let name = viewer.name.borrow().clone().unwrap_or_default();
share_photo(ui, uid, name, Some(viewer.window.clone()));
}
/// A symlink to the cached file `path` under its Drive `name`, in a directory /// A symlink to the cached file `path` under its Drive `name`, in a directory
/// of its own below `base`. The cache names files by content hash, with no /// of its own below `base`. The cache names files by content hash, with no
/// extension; the app chooser and the app it launches both need the real name /// extension; the app chooser and the app it launches both need the real name
@@ -983,16 +1114,124 @@ pub(crate) fn position_label(index: u32, loaded: u32, more: bool, total: Option<
} }
} }
/// Set the lightbox's title (the photo's date) and its "12 of 340" counter. /// The lightbox's title: when the photo was taken, as "Wednesday, October 7,
/// 2026, 13:42".
fn photo_title(capture_time: i64) -> String {
let title = dates::full(capture_time);
if title.is_empty() {
gettext("Unknown Date")
} else {
title
}
}
/// Set the lightbox's title (the photo's date) and the line under it: the town
/// it was taken in, when known, and its "12 of 340" counter.
fn show_photo_position(ui: &Rc<Ui>, viewer: &Rc<Viewer>, index: u32, capture_time: i64) { fn show_photo_position(ui: &Rc<Ui>, viewer: &Rc<Viewer>, index: u32, capture_time: i64) {
let loaded = ui.gallery.model.n_items(); let loaded = ui.gallery.model.n_items();
let more = ui.gallery.has_more.get(); let more = ui.gallery.has_more.get();
viewer.prev.set_sensitive(index > 0); viewer.prev.set_sensitive(index > 0);
viewer.next.set_sensitive(index + 1 < loaded || more); viewer.next.set_sensitive(index + 1 < loaded || more);
viewer.title.set_label(&format_capture_time(capture_time)); viewer.title.set_label(&photo_title(capture_time));
let position = position_label(index, loaded, more, gallery_total(ui));
let place = viewer_item(ui, viewer, &viewer.uid.borrow())
.and_then(|item| item.place_id)
.and_then(pdfs_core::places::city)
.map(|city| city.name);
let line = match place {
Some(place) => {
let args = [("place", place), ("position", position.as_str())];
// Translators: the line under the photo viewer's title, such as "Berlin · 12 of 340"; {place} is a town, {position} the counter.
gettext_f("{place} · {position}", &args)
}
None => position,
};
viewer.counter.set_label(&line);
sync_strip(viewer);
mark_in_strip(viewer, index);
}
/// Show the strip of thumbnails when there is more than one photo to pick
/// from. Not in a slideshow, and not over a video, where it would cover the
/// player's seek bar.
fn sync_strip(viewer: &Rc<Viewer>) {
let video = viewer.media.visible_child_name().as_deref() == Some("video");
viewer viewer
.counter .strip_reveal
.set_label(&position_label(index, loaded, more, gallery_total(ui))); .set_visible(viewer.strip_selection.n_items() > 1 && !viewer.slideshow.get() && !video);
}
/// Mark the photo at `index` in the strip and bring it into view.
fn mark_in_strip(viewer: &Rc<Viewer>, index: u32) {
if index >= viewer.strip_selection.n_items() {
return;
}
viewer.strip_selection.set_selected(index);
viewer
.strip
.scroll_to(index, gtk4::ListScrollFlags::NONE, None);
}
/// The strip of thumbnails along the lightbox's bottom edge: the gallery's
/// photos in its order, the one on screen marked. A click steps straight to a
/// photo; the thumbnails come through the gallery's own pipeline and cache.
fn build_strip(ui: &Rc<Ui>) -> (gtk4::ListView, gtk4::SingleSelection) {
let selection = gtk4::SingleSelection::new(Some(ui.gallery.model.clone()));
selection.set_autoselect(false);
selection.set_can_unselect(true);
let factory = gtk4::SignalListItemFactory::new();
factory.connect_setup(|_, item| {
let item = item.downcast_ref::<gtk4::ListItem>().unwrap();
let picture = gtk4::Picture::builder()
.content_fit(gtk4::ContentFit::Cover)
.width_request(56)
.height_request(56)
.can_shrink(true)
.build();
picture.add_css_class("viewer-strip-thumb");
// The arrow keys belong to the lightbox, not to the strip.
item.set_focusable(false);
item.set_child(Some(&picture));
});
let ui_bind = ui.clone();
factory.connect_bind(move |_, item| {
let item = item.downcast_ref::<gtk4::ListItem>().unwrap();
let Some(picture) = item.child().and_downcast::<gtk4::Picture>() else {
return;
};
let Some(boxed) = item.item().and_downcast::<BoxedAnyObject>() else {
return;
};
let photo = boxed.borrow::<PhotoItem>().clone();
picture.set_paintable(gtk4::gdk::Paintable::NONE);
picture.set_tooltip_text(Some(&dates::full(photo.capture_time)));
want_thumb(&ui_bind, &photo, &picture);
schedule_thumbs(&ui_bind);
});
let ui_unbind = ui.clone();
factory.connect_unbind(move |_, item| {
let item = item.downcast_ref::<gtk4::ListItem>().unwrap();
let (Some(picture), Some(boxed)) = (
item.child().and_downcast::<gtk4::Picture>(),
item.item().and_downcast::<BoxedAnyObject>(),
) else {
return;
};
let uid = boxed.borrow::<PhotoItem>().uid.clone();
ui_unbind
.gallery
.release_thumb(&uid, |waiting| waiting == &picture);
});
let list = gtk4::ListView::builder()
.model(&selection)
.factory(&factory)
.orientation(gtk4::Orientation::Horizontal)
.focusable(false)
.build();
list.add_css_class("viewer-strip");
(list, selection)
} }
/// The in-app lightbox: the photo or video, edge-to-edge on a dark backdrop, /// The in-app lightbox: the photo or video, edge-to-edge on a dark backdrop,
@@ -1004,6 +1243,43 @@ fn show_photo_position(ui: &Rc<Ui>, viewer: &Rc<Viewer>, index: u32, capture_tim
/// ///
/// Returns the lightbox's window, for a caller that has to put the page /// Returns the lightbox's window, for a caller that has to put the page
/// behind it back once it closes. /// 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 { pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Window {
let parent = ui.stack.root().and_downcast::<gtk4::Window>().unwrap(); let parent = ui.stack.root().and_downcast::<gtk4::Window>().unwrap();
@@ -1041,6 +1317,7 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
.hexpand(true) .hexpand(true)
.vexpand(true) .vexpand(true)
.build(); .build();
wire_player(&video, &window);
let media = gtk4::Stack::new(); let media = gtk4::Stack::new();
media.add_named(&scroller, Some("photo")); media.add_named(&scroller, Some("photo"));
media.add_named(&video, Some("video")); media.add_named(&video, Some("video"));
@@ -1125,22 +1402,21 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
favorite_btn.add_css_class("flat"); favorite_btn.add_css_class("flat");
favorite_btn.add_css_class("viewer-action-btn"); favorite_btn.add_css_class("viewer-action-btn");
let slideshow_btn = gtk4::ToggleButton::builder()
.icon_name("pdfs-slideshow-symbolic")
.tooltip_text(gettext("Slideshow (F5)"))
.valign(gtk4::Align::Center)
.build();
slideshow_btn.add_css_class("flat");
slideshow_btn.add_css_class("viewer-action-btn");
// Only shown for a shot stored as more than one file; `load_photo_group` // Only shown for a shot stored as more than one file; `load_photo_group`
// decides that per photo. // decides that per photo and labels it ("RAW", "Live", "2 of 3").
let group_btn = action("view-paged-symbolic", &gettext("Other files of this photo")); let group_btn = gtk4::Button::builder()
group_btn.set_visible(false); .valign(gtk4::Align::Center)
.visible(false)
.build();
group_btn.add_css_class("flat");
group_btn.add_css_class("viewer-group-pill");
let download_btn = action("document-save-symbolic", &gettext("Save a Copy…")); // Everything used less often than the favorite and the details sits in
let delete_btn = action("user-trash-symbolic", &gettext("Move to Trash (Delete)")); // one menu, named in words rather than in icons.
let open_ext_btn = action("document-open-symbolic", &gettext("Open With…")); let more_btn = action("view-more-symbolic", &gettext("More"));
let fullscreen_btn = fullscreen_button(&window);
fullscreen_btn.add_css_class("flat");
fullscreen_btn.add_css_class("viewer-action-btn");
let close_btn = action("window-close-symbolic", &gettext("Close (Esc)")); let close_btn = action("window-close-symbolic", &gettext("Close (Esc)"));
close_btn.add_css_class("viewer-close-btn"); close_btn.add_css_class("viewer-close-btn");
@@ -1150,14 +1426,26 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
top_bar.append(&group_btn); top_bar.append(&group_btn);
top_bar.append(&favorite_btn); top_bar.append(&favorite_btn);
top_bar.append(&info_toggle); top_bar.append(&info_toggle);
top_bar.append(&slideshow_btn); top_bar.append(&fullscreen_btn);
top_bar.append(&download_btn); top_bar.append(&more_btn);
top_bar.append(&delete_btn);
top_bar.append(&open_ext_btn);
top_bar.append(&close_btn); top_bar.append(&close_btn);
let top_reveal = fade(top_bar.upcast_ref(), gtk4::Align::Fill, gtk4::Align::Start); let top_reveal = fade(top_bar.upcast_ref(), gtk4::Align::Fill, gtk4::Align::Start);
overlay.add_overlay(&top_reveal); overlay.add_overlay(&top_reveal);
let (strip, strip_selection) = build_strip(ui);
let strip_scroll = gtk4::ScrolledWindow::builder()
.hscrollbar_policy(gtk4::PolicyType::External)
.vscrollbar_policy(gtk4::PolicyType::Never)
.child(&strip)
.build();
strip_scroll.add_css_class("viewer-strip-bar");
let strip_reveal = fade(
strip_scroll.upcast_ref(),
gtk4::Align::Fill,
gtk4::Align::End,
);
overlay.add_overlay(&strip_reveal);
// Details panel: docked beside the image as a real surface, so opening it // Details panel: docked beside the image as a real surface, so opening it
// narrows the photo instead of covering part of it. // narrows the photo instead of covering part of it.
let info_rows = gtk4::Box::new(gtk4::Orientation::Vertical, 12); let info_rows = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
@@ -1245,7 +1533,9 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
narrow.add_setter(&info_split, "collapsed", Some(&true.to_value())); narrow.add_setter(&info_split, "collapsed", Some(&true.to_value()));
adw_window.add_breakpoint(narrow); adw_window.add_breakpoint(narrow);
let body = info_split.clone(); let body = info_split.clone();
adw_window.set_content(Some(&body)); let toasts = adw::ToastOverlay::new();
toasts.set_child(Some(&body));
adw_window.set_content(Some(&toasts));
let viewer = Rc::new(Viewer { let viewer = Rc::new(Viewer {
window: window.clone(), window: window.clone(),
@@ -1253,6 +1543,16 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
scroller: scroller.clone(), scroller: scroller.clone(),
picture: picture.clone(), picture: picture.clone(),
video, 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, spinner,
status: status_label, status: status_label,
title: title_label, title: title_label,
@@ -1276,14 +1576,26 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
pinch_start: Cell::new(1.0), pinch_start: Cell::new(1.0),
drag_start: Cell::new((0.0, 0.0)), drag_start: Cell::new((0.0, 0.0)),
pointer: Cell::new((0.0, 0.0)), pointer: Cell::new((0.0, 0.0)),
chrome: vec![top_reveal.clone(), prev_reveal.clone(), next_reveal.clone()], chrome: vec![
top_reveal.clone(),
prev_reveal.clone(),
next_reveal.clone(),
strip_reveal.clone(),
],
strip: strip.clone(),
strip_selection: strip_selection.clone(),
strip_reveal: strip_reveal.clone(),
chrome_hover: Cell::new(false), chrome_hover: Cell::new(false),
chrome_source: RefCell::new(None), chrome_source: RefCell::new(None),
slideshow: slideshow_btn.clone(), more: more_btn.clone(),
menu_open: Cell::new(false),
slideshow: Cell::new(false),
slide_source: RefCell::new(None), slide_source: RefCell::new(None),
slide_fullscreened: Cell::new(false), slide_fullscreened: Cell::new(false),
toasts,
}); });
*ui.gallery.viewer.borrow_mut() = Rc::downgrade(&viewer);
let initial_idx = find_photo_index(&ui.gallery.model, &initial_uid).unwrap_or(0); 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); 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); show_photo_position(ui, &viewer, initial_idx, capture_time);
@@ -1307,7 +1619,7 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
} }
}); });
body.add_controller(motion); body.add_controller(motion);
for revealer in [&top_reveal, &prev_reveal, &next_reveal] { for revealer in [&top_reveal, &prev_reveal, &next_reveal, &strip_reveal] {
let hover = gtk4::EventControllerMotion::new(); let hover = gtk4::EventControllerMotion::new();
let viewer_enter = Rc::downgrade(&viewer); let viewer_enter = Rc::downgrade(&viewer);
hover.connect_enter(move |_, _, _| { hover.connect_enter(move |_, _, _| {
@@ -1423,16 +1735,56 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
w_close.close(); w_close.close();
}); });
// A click on a thumbnail selects it; step there. Every selection the
// lightbox sets itself is the photo on screen, and the model's own changes
// (a page landing, a favorite rewritten in place) keep the selected photo
// or drop it, so a selection elsewhere can only be the user's.
let ui_strip = ui.clone();
let viewer_strip = Rc::downgrade(&viewer);
strip_selection.connect_selection_changed(move |selection, _, _| {
let Some(viewer) = viewer_strip.upgrade() else {
return;
};
let picked = selection.selected();
let Some(current) = find_photo_index(&ui_strip.gallery.model, &viewer.uid.borrow()) else {
return;
};
if picked != gtk4::INVALID_LIST_POSITION && picked != current {
navigate_photo(&ui_strip, &viewer, picked as i32 - current as i32);
}
});
let viewer_items = Rc::downgrade(&viewer);
let items_handler = ui
.gallery
.model
.connect_items_changed(move |model, _, _, _| {
let Some(viewer) = viewer_items.upgrade() else {
return;
};
if let Some(index) = find_photo_index(model, &viewer.uid.borrow()) {
viewer.strip_selection.set_selected(index);
}
sync_strip(&viewer);
});
// The one strong handle on the viewer. Every handler holds a weak one: a // The one strong handle on the viewer. Every handler holds a weak one: a
// strong one in a handler of a widget the viewer holds is a cycle, which // strong one in a handler of a widget the viewer holds is a cycle, which
// kept every closed lightbox, its window and its full-size photo in memory // kept every closed lightbox, its window and its full-size photo in memory
// for the life of the app. // for the life of the app.
let keep = RefCell::new(Some(viewer.clone())); let keep = RefCell::new(Some(viewer.clone()));
let ui_close = ui.clone(); let ui_close = ui.clone();
let items_handler = RefCell::new(Some(items_handler));
window.connect_close_request(move |_| { window.connect_close_request(move |_| {
// The gallery's model outlives the lightbox.
if let Some(handler) = items_handler.borrow_mut().take() {
ui_close.gallery.model.disconnect(handler);
}
if let Some(viewer) = keep.borrow_mut().take() { if let Some(viewer) = keep.borrow_mut().take() {
reveal_photo(&ui_close, &viewer.uid.borrow()); 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); disarm_slide(&viewer);
if let Some(source) = viewer.chrome_source.borrow_mut().take() { if let Some(source) = viewer.chrome_source.borrow_mut().take() {
source.remove(); source.remove();
@@ -1457,36 +1809,14 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
} }
}); });
let ui_slides = ui.clone();
let viewer_slides = Rc::downgrade(&viewer);
slideshow_btn.connect_toggled(move |toggle| {
let Some(viewer_slides) = viewer_slides.upgrade() else {
return;
};
if toggle.is_active() {
start_slideshow(&ui_slides, &viewer_slides);
} else {
stop_slideshow(&viewer_slides);
}
});
let toggle_off = info_toggle.clone(); let toggle_off = info_toggle.clone();
info_close.connect_clicked(move |_| toggle_off.set_active(false)); info_close.connect_clicked(move |_| toggle_off.set_active(false));
let ui_map = ui.clone(); let ui_map = ui.clone();
let viewer_map = Rc::downgrade(&viewer); let viewer_map = Rc::downgrade(&viewer);
let w_map = window.downgrade();
info_map.connect_clicked(move |_| { info_map.connect_clicked(move |_| {
let Some(w_map) = w_map.upgrade() else { if let Some(viewer_map) = viewer_map.upgrade() {
return; show_photo_on_map(&ui_map, &viewer_map);
};
let Some(viewer_map) = viewer_map.upgrade() else {
return;
};
let coords = *viewer_map.coords.borrow();
if let Some((lat, lon)) = coords {
w_map.close();
show_on_map(&ui_map, lat, lon);
} }
}); });
@@ -1538,24 +1868,6 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
}); });
}); });
// Deleting the photo on screen closes the lightbox: what it was showing is
// gone, and leaving it open on a trashed photo invites a second Delete on
// something the user cannot see.
let ui_delete = ui.clone();
let viewer_delete = Rc::downgrade(&viewer);
let w_delete = window.downgrade();
delete_btn.connect_clicked(move |_| {
let Some(w_delete) = w_delete.upgrade() else {
return;
};
let Some(viewer_delete) = viewer_delete.upgrade() else {
return;
};
let uid = viewer_delete.uid.borrow().clone();
w_delete.close();
trash_photos(&ui_delete, vec![uid], false);
});
let ui_group = ui.clone(); let ui_group = ui.clone();
let viewer_group = Rc::downgrade(&viewer); let viewer_group = Rc::downgrade(&viewer);
group_btn.connect_clicked(move |_| { group_btn.connect_clicked(move |_| {
@@ -1571,38 +1883,11 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
} }
}); });
let ui_download = ui.clone(); let ui_more = ui.clone();
let w_download = window.downgrade(); let viewer_more = Rc::downgrade(&viewer);
let viewer_download = Rc::downgrade(&viewer); more_btn.connect_clicked(move |_| {
download_btn.connect_clicked(move |_| { if let Some(viewer_more) = viewer_more.upgrade() {
let Some(w_download) = w_download.upgrade() else { open_viewer_menu(&ui_more, &viewer_more);
return;
};
let Some(viewer_download) = viewer_download.upgrade() else {
return;
};
if let Some(path) = viewer_download.path.borrow().as_deref() {
let name = viewer_download.name.borrow();
save_photo_to_disk(
&ui_download,
&w_download,
path,
name.as_deref().unwrap_or("photo"),
);
}
});
let w_ext = window.downgrade();
let viewer_ext = Rc::downgrade(&viewer);
open_ext_btn.connect_clicked(move |_| {
let Some(w_ext) = w_ext.upgrade() else {
return;
};
let Some(viewer_ext) = viewer_ext.upgrade() else {
return;
};
if let Some(path) = viewer_ext.path.borrow().as_deref() {
open_with(&w_ext, path, viewer_ext.name.borrow().as_deref());
} }
}); });
@@ -1680,13 +1965,22 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
return glib::Propagation::Proceed; return glib::Propagation::Proceed;
}; };
let ctrl = state.contains(gtk4::gdk::ModifierType::CONTROL_MASK); let ctrl = state.contains(gtk4::gdk::ModifierType::CONTROL_MASK);
let alt = state.contains(gtk4::gdk::ModifierType::ALT_MASK);
let playing_video = viewer_key.media.visible_child_name().as_deref() == Some("video"); let playing_video = viewer_key.media.visible_child_name().as_deref() == Some("video");
if playing_video
&& let Some(name) = key.name()
&& player_key(&viewer_key.video, &name, state)
{
return glib::Propagation::Stop;
}
match key.name().as_deref() { match key.name().as_deref() {
Some("space") if playing_video => { Some("space") if playing_video => {
if let Some(stream) = viewer_key.video.media_stream() { if let Some(stream) = viewer_key.video.media_stream() {
stream.set_playing(!stream.is_playing()); stream.set_playing(!stream.is_playing());
} }
} }
// Alt+Left is Back everywhere else in the app.
Some("Left") if alt => w_key.close(),
Some("Left" | "Up" | "BackSpace") => navigate_photo(&ui_key, &viewer_key, -1), Some("Left" | "Up" | "BackSpace") => navigate_photo(&ui_key, &viewer_key, -1),
Some("Right" | "Down" | "space") => navigate_photo(&ui_key, &viewer_key, 1), Some("Right" | "Down" | "space") => navigate_photo(&ui_key, &viewer_key, 1),
Some("Home") => navigate_photo(&ui_key, &viewer_key, i32::MIN / 2), Some("Home") => navigate_photo(&ui_key, &viewer_key, i32::MIN / 2),
@@ -1695,30 +1989,20 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
Some("minus" | "KP_Subtract") => zoom_by(&viewer_key, 1.0 / ZOOM_STEP), Some("minus" | "KP_Subtract") => zoom_by(&viewer_key, 1.0 / ZOOM_STEP),
Some("0" | "KP_0") => reset_zoom(&viewer_key), Some("0" | "KP_0") => reset_zoom(&viewer_key),
Some("1" | "KP_1") => zoom_to(&viewer_key, Some(1.0), None), Some("1" | "KP_1") => zoom_to(&viewer_key, Some(1.0), None),
Some("F5") => viewer_key Some("F5") => toggle_slideshow(&ui_key, &viewer_key),
.slideshow
.set_active(!viewer_key.slideshow.is_active()),
// Escape ends a slideshow before it closes anything. // Escape ends a slideshow before it closes anything.
Some("Escape") if viewer_key.slideshow.is_active() => { Some("Escape") if viewer_key.slideshow.get() => stop_slideshow(&viewer_key),
viewer_key.slideshow.set_active(false) Some("F10" | "Menu") => open_viewer_menu(&ui_key, &viewer_key),
}
Some("i") => viewer_key Some("i") => viewer_key
.info_toggle .info_toggle
.set_active(!viewer_key.info_toggle.is_active()), .set_active(!viewer_key.info_toggle.is_active()),
Some("f" | "F11") => { Some("f" | "F11") => toggle_fullscreen(&w_key),
if w_key.is_fullscreen() { Some("Delete" | "KP_Delete") => trash_shown_photo(&ui_key, &viewer_key),
w_key.unfullscreen();
} else {
w_key.fullscreen();
}
}
Some("Delete" | "KP_Delete") => {
let uid = viewer_key.uid.borrow().clone();
w_key.close();
trash_photos(&ui_key, vec![uid], false);
}
Some("Escape" | "q") => w_key.close(), Some("Escape" | "q") => w_key.close(),
Some("w") if ctrl => w_key.close(), Some("w") if ctrl => w_key.close(),
Some("c") if ctrl && viewer_key.path.borrow().is_some() && !playing_video => {
copy_shown_photo(&ui_key, &viewer_key)
}
_ => return glib::Propagation::Proceed, _ => return glib::Propagation::Proceed,
} }
glib::Propagation::Stop glib::Propagation::Stop
@@ -1729,6 +2013,140 @@ pub(crate) fn open_photo_viewer(ui: &Rc<Ui>, initial_uid: String) -> gtk4::Windo
window window
} }
/// The ⋮ menu: what the lightbox can do with the photo on screen besides
/// starring it and showing its details. Built when it opens, so it offers
/// only what applies to this photo.
fn open_viewer_menu(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
let weak = Rc::downgrade(viewer);
let with_viewer = move |run: fn(&Rc<Ui>, &Rc<Viewer>), ui: &Rc<Ui>| {
let (ui, weak) = (ui.clone(), weak.clone());
move || {
if let Some(viewer) = weak.upgrade() {
run(&ui, &viewer);
}
}
};
let mut menu = ActionMenu::new();
menu.item(&gettext("Slideshow"), with_viewer(toggle_slideshow, ui));
if viewer.media.visible_child_name().as_deref() == Some("video") {
let video = viewer.video.clone();
menu.toggle(&gettext("Repeat"), video.is_loop(), move |on| {
video.set_loop(on)
});
}
menu.section();
// These need the full-size file, which may still be downloading.
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.
menu.item(&gettext("Copy Image"), with_viewer(copy_shown_photo, ui));
}
menu.item(&gettext("Save a Copy…"), with_viewer(save_shown_photo, ui));
menu.item(&gettext("Open With…"), with_viewer(open_shown_photo, ui));
}
if photo_shareable(ui) {
menu.item(&gettext("Share…"), with_viewer(share_shown_photo, ui));
}
// A RAW is not on the timeline, and an album holds the shot it belongs to.
if find_photo_index(&ui.gallery.model, &viewer.uid.borrow()).is_some() {
menu.item(
&gettext("Add to Album…"),
with_viewer(add_shown_photo_to_album, ui),
);
}
if viewer.coords.borrow().is_some() {
menu.item(&gettext("Show on Map"), with_viewer(show_photo_on_map, ui));
}
menu.section();
menu.item(
&gettext("Move to Trash…"),
with_viewer(trash_shown_photo, ui),
);
let button = &viewer.more;
let popover = menu.popup_at(
button,
f64::from(button.width()) / 2.0,
f64::from(button.height()),
);
viewer.menu_open.set(true);
let weak = Rc::downgrade(viewer);
popover.connect_closed(move |_| {
if let Some(viewer) = weak.upgrade() {
viewer.menu_open.set(false);
// A slideshow started from the menu keeps the controls hidden.
if !viewer.slideshow.get() {
show_chrome(&viewer);
}
}
});
}
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>) {
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() {
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>) {
let uid = viewer.uid.borrow().clone();
prompt_add_to_album(ui, vec![uid], Some(viewer.window.clone()));
}
/// Close the lightbox and show where the photo was taken.
fn show_photo_on_map(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
let coords = *viewer.coords.borrow();
if let Some((lat, lon)) = coords {
viewer.window.close();
show_on_map(ui, lat, lon);
}
}
/// Ask, then move the photo on screen to the trash. Confirmed, the lightbox
/// closes first: what it was showing is gone, and leaving it open on a
/// trashed photo invites a second Delete on something the user cannot see.
fn trash_shown_photo(ui: &Rc<Ui>, viewer: &Rc<Viewer>) {
let uid = viewer.uid.borrow().clone();
let window = viewer.window.clone();
ask_trash_photos(ui, vec![uid], Some(window.clone()), move || window.close());
}
/// Whether `(x, y)` — in `picture`'s coordinates — lands on the photo itself /// Whether `(x, y)` — in `picture`'s coordinates — lands on the photo itself
/// rather than the backdrop around it. [`gtk4::ContentFit::Contain`] centres the /// rather than the backdrop around it. [`gtk4::ContentFit::Contain`] centres the
/// image and letterboxes the rest, so the drawn rectangle is the widget scaled /// image and letterboxes the rest, so the drawn rectangle is the widget scaled
File diff suppressed because it is too large. Load diff
+12 -2
View File
@@ -267,7 +267,12 @@ fn want_map_thumb(ui: &Rc<Ui>, photo: &PhotoItem) {
} }
// A town's card may be waiting for the same photo: share its picture // A town's card may be waiting for the same photo: share its picture
// rather than take its place in the queue. // rather than take its place in the queue.
let waiting = ui.gallery.thumb_wanted.borrow().get(&photo.uid).cloned(); let waiting = ui
.gallery
.thumb_wanted
.borrow()
.get(&photo.uid)
.and_then(|waiting| waiting.first().cloned());
let picture = waiting.unwrap_or_else(|| { let picture = waiting.unwrap_or_else(|| {
let picture = gtk4::Picture::new(); let picture = gtk4::Picture::new();
want_thumb(ui, photo, &picture); want_thumb(ui, photo, &picture);
@@ -362,7 +367,12 @@ fn show_spot_photos(ui: &Rc<Ui>, photos: Vec<(PlaceInfo, PhotoItem)>, (x, y): (f
/// Show photo's thumbnail in `picture`, sharing one another widget is /// Show photo's thumbnail in `picture`, sharing one another widget is
/// already waiting for. /// already waiting for.
fn spot_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: &gtk4::Picture) { fn spot_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: &gtk4::Picture) {
let waiting = ui.gallery.thumb_wanted.borrow().get(&photo.uid).cloned(); let waiting = ui
.gallery
.thumb_wanted
.borrow()
.get(&photo.uid)
.and_then(|waiting| waiting.first().cloned());
match waiting { match waiting {
Some(waiting) => { Some(waiting) => {
waiting waiting
@@ -0,0 +1,606 @@
//! Preferences → Apps: which program opens which file (`open_with`) and how
//! the search launcher shows itself (`prompt`).
//!
//! Neither involves the service. The app and the search launcher read both
//! again each time they open something, so a change applies to the next file
//! opened or the next search.
use crate::*;
use pdfs_core::menu::{PromptConfig, PromptMode};
use pdfs_core::opener::{
OpenRule, OpenWith, command_available, format_command, parse_command, resolve_terminal,
};
/// The widgets of the Apps page, built with the rest of the dialog and wired
/// once the app's state exists.
pub(crate) struct AppsPrefs {
pub(crate) page: adw::PreferencesPage,
rules: adw::PreferencesGroup,
add_rule: gtk4::Button,
other_row: adw::EntryRow,
terminal_row: adw::EntryRow,
mode_row: adw::ComboRow,
menu_row: adw::EntryRow,
prompt_terminal_row: adw::EntryRow,
limit_row: adw::SpinRow,
icons_row: adw::SwitchRow,
}
/// The launcher modes in the order the combo row lists them.
const MODES: [PromptMode; 3] = [PromptMode::Gtk, PromptMode::Dmenu, PromptMode::Fzf];
/// The file classes a rule can name, with what the dialog calls them.
fn classes() -> [(&'static str, String); 6] {
[
("@text", gettext("Text")),
("@document", gettext("Documents")),
("@image", gettext("Images")),
("@media", gettext("Audio and Video")),
("@dir", gettext("Folders")),
("@any", gettext("Everything")),
]
}
pub(crate) fn build_apps_prefs() -> AppsPrefs {
let add_rule = gtk4::Button::builder()
.label(gettext("Add Rule…"))
.valign(gtk4::Align::Center)
.build();
add_rule.add_css_class("flat");
let rules = adw::PreferencesGroup::builder()
.title(gettext("Open Files With"))
.description(gettext(
"For files opened from Proton Drive and the search launcher. The first rule that matches a file decides; other files open in their default app.",
))
.header_suffix(&add_rule)
.build();
let other_row = adw::EntryRow::builder()
.title(gettext("Other files (empty: default app)"))
.show_apply_button(true)
.build();
other_row.add_css_class("monospace");
let terminal_row = adw::EntryRow::builder()
.title(terminal_title())
.show_apply_button(true)
.build();
terminal_row.add_css_class("monospace");
let other = adw::PreferencesGroup::new();
other.add(&other_row);
other.add(&terminal_row);
let mode_row = adw::ComboRow::builder()
.title(gettext("Opens as"))
.model(&gtk4::StringList::new(&[
&gettext("Window"),
&gettext("Your Launcher"),
&gettext("fzf in a Terminal"),
]))
.build();
let menu_row = adw::EntryRow::builder()
.title(gettext("Launcher command (empty: find one)"))
.show_apply_button(true)
.build();
menu_row.add_css_class("monospace");
let prompt_terminal_row = adw::EntryRow::builder()
.title(terminal_title())
.show_apply_button(true)
.build();
prompt_terminal_row.add_css_class("monospace");
let limit_row = adw::SpinRow::builder()
.title(gettext("Results shown"))
.adjustment(&gtk4::Adjustment::new(
pdfs_core::menu::DEFAULT_MENU_LIMIT as f64,
5.0,
500.0,
5.0,
25.0,
0.0,
))
.build();
let icons_row = adw::SwitchRow::builder()
.title(gettext("Show icons"))
.subtitle(gettext("When the launcher can show them"))
.build();
let launcher = adw::PreferencesGroup::builder()
.title(gettext("Search Launcher"))
.description(gettext(
"How “pdfs-prompt” shows search results, for example from a keyboard shortcut. Your launcher can be any program that reads choices like dmenu, such as rofi, wofi, fuzzel or bemenu.",
))
.build();
launcher.add(&mode_row);
launcher.add(&menu_row);
launcher.add(&prompt_terminal_row);
launcher.add(&limit_row);
launcher.add(&icons_row);
let page = adw::PreferencesPage::builder()
.title(gettext("Apps"))
.name("apps")
.icon_name("application-x-executable-symbolic")
.build();
page.add(&rules);
page.add(&other);
page.add(&launcher);
AppsPrefs {
page,
rules,
add_rule,
other_row,
terminal_row,
mode_row,
menu_row,
prompt_terminal_row,
limit_row,
icons_row,
}
}
/// "Terminal", naming the one used when the row is left empty.
fn terminal_title() -> String {
match resolve_terminal() {
// Translators: {terminal} is a terminal command line such as "foot -e".
Some(found) => gettext_f(
"Terminal (empty: {terminal})",
&[("terminal", &format_command(&found))],
),
None => gettext("Terminal"),
}
}
/// Shared by every handler of the page.
struct Apps {
ui: Rc<Ui>,
widgets: AppsPrefs,
rule_rows: RefCell<Vec<adw::ActionRow>>,
}
/// Fill the page from the config and connect its controls.
pub(crate) fn wire_apps_prefs(ui: &Rc<Ui>, widgets: AppsPrefs) {
let apps = Rc::new(Apps {
ui: ui.clone(),
widgets,
rule_rows: RefCell::default(),
});
let config = ui.dirs.load_config();
let open_with = config.resolved_open_with();
let prompt = config.resolved_prompt();
let w = &apps.widgets;
let suppress = ui.status.settings_suppress.replace(true);
paint_rules(&apps, &open_with);
w.other_row
.set_text(&format_command(open_with.default.as_deref().unwrap_or(&[])));
w.terminal_row.set_text(&format_command(
open_with.terminal.as_deref().unwrap_or(&[]),
));
let mode = prompt.resolved_mode();
w.mode_row
.set_selected(MODES.iter().position(|m| *m == mode).unwrap_or_default() as u32);
w.menu_row
.set_text(&format_command(prompt.menu.as_deref().unwrap_or(&[])));
w.prompt_terminal_row
.set_text(&format_command(prompt.terminal.as_deref().unwrap_or(&[])));
w.limit_row.set_value(prompt.resolved_menu_limit() as f64);
w.icons_row.set_active(prompt.resolved_menu_icons());
show_mode_rows(w, mode);
ui.status.settings_suppress.set(suppress);
let a = apps.clone();
w.add_rule
.connect_clicked(move |_| edit_rule(&a, None, OpenRule::default()));
// Command lines: checked as typed, saved on apply. Empty means "unset".
connect_command_row(&apps, &w.other_row, |config, argv| {
open_with_of(config).default = argv;
});
connect_command_row(&apps, &w.terminal_row, |config, argv| {
open_with_of(config).terminal = argv;
});
connect_command_row(&apps, &w.menu_row, |config, argv| {
prompt_of(config).menu = argv;
});
connect_command_row(&apps, &w.prompt_terminal_row, |config, argv| {
prompt_of(config).terminal = argv;
});
let a = apps.clone();
w.mode_row.connect_selected_notify(move |row| {
if a.ui.status.settings_suppress.get() {
return;
}
let mode = MODES
.get(row.selected() as usize)
.copied()
.unwrap_or_default();
show_mode_rows(&a.widgets, mode);
save(&a, move |config| {
prompt_of(config).mode = (mode != PromptMode::default()).then_some(mode);
});
});
let a = apps.clone();
w.limit_row.connect_value_notify(move |row| {
if a.ui.status.settings_suppress.get() {
return;
}
let limit = row.value().round() as usize;
save(&a, move |config| {
prompt_of(config).menu_limit =
(limit != pdfs_core::menu::DEFAULT_MENU_LIMIT).then_some(limit);
});
});
let a = apps.clone();
w.icons_row.connect_active_notify(move |row| {
if a.ui.status.settings_suppress.get() {
return;
}
let on = row.is_active();
save(&a, move |config| {
prompt_of(config).menu_icons = (!on).then_some(false)
});
});
}
/// Show only the rows the chosen launcher mode uses.
fn show_mode_rows(w: &AppsPrefs, mode: PromptMode) {
w.menu_row.set_visible(mode == PromptMode::Dmenu);
w.icons_row.set_visible(mode == PromptMode::Dmenu);
w.prompt_terminal_row.set_visible(mode == PromptMode::Fzf);
w.limit_row.set_visible(mode != PromptMode::Gtk);
}
/// The `open_with` section, created when absent.
fn open_with_of(config: &mut pdfs_core::config::AppConfig) -> &mut OpenWith {
config.open_with.get_or_insert_with(OpenWith::default)
}
/// The `prompt` section, created when absent.
fn prompt_of(config: &mut pdfs_core::config::AppConfig) -> &mut PromptConfig {
config.prompt.get_or_insert_with(PromptConfig::default)
}
/// Save a change, then drop sections left at their defaults so the file only
/// holds what the user chose. Says whether it saved.
fn save(apps: &Rc<Apps>, change: impl FnOnce(&mut pdfs_core::config::AppConfig)) -> bool {
let saved = apps.ui.dirs.update_config(|config| {
change(config);
if config.open_with.as_ref() == Some(&OpenWith::default()) {
config.open_with = None;
}
if config.prompt.as_ref() == Some(&PromptConfig::default()) {
config.prompt = None;
}
config.resolved_open_with()
});
match saved {
Ok(open_with) => {
paint_rules(apps, &open_with);
true
}
Err(e) => {
prefs_toast(
&apps.ui,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the setting")),
("detail", &e.to_string()),
],
),
);
false
}
}
}
/// Check a command line as it is typed, and save it when applied.
fn connect_command_row(
apps: &Rc<Apps>,
row: &adw::EntryRow,
store: impl Fn(&mut pdfs_core::config::AppConfig, Option<Vec<String>>) + 'static,
) {
row.connect_changed(|row| mark_command(row, false));
let a = apps.clone();
row.connect_apply(move |row| {
let Some(argv) = parse_command(&row.text()) else {
prefs_toast(&a.ui, &gettext("A quote is not closed in the command"));
return;
};
if !argv.is_empty() && !command_available(&argv) {
prefs_toast(
&a.ui,
// Translators: {program} is a program name such as "nvim".
&gettext_f(
"“{program}” isn't installed; saved anyway",
&[("program", &argv[0])],
),
);
}
let argv = (!argv.is_empty()).then_some(argv);
save(&a, |config| store(config, argv));
mark_command(row, true);
});
}
/// Mark a command line that doesn't parse as an error, and, once `applied`,
/// one whose program isn't found as a warning.
fn mark_command(row: &adw::EntryRow, applied: bool) {
row.remove_css_class("error");
row.remove_css_class("warning");
match parse_command(&row.text()) {
None => row.add_css_class("error"),
Some(argv) if applied && !argv.is_empty() && !command_available(&argv) => {
row.add_css_class("warning")
}
Some(_) => {}
}
}
/// Show the rules, one row each, in the order they are tried.
fn paint_rules(apps: &Rc<Apps>, open_with: &OpenWith) {
let group = &apps.widgets.rules;
for row in apps.rule_rows.borrow_mut().drain(..) {
group.remove(&row);
}
let count = open_with.rules.len();
if count == 0 {
let row = adw::ActionRow::builder()
.title(gettext("No rules: every file opens in its default app"))
.build();
row.add_css_class("dim-label");
group.add(&row);
apps.rule_rows.borrow_mut().push(row);
return;
}
let names = classes();
for (index, rule) in open_with.rules.iter().enumerate() {
let patterns: Vec<String> = rule
.patterns
.iter()
.map(|p| {
names
.iter()
.find(|(class, _)| class == p)
.map_or_else(|| p.clone(), |(_, name)| name.clone())
})
.collect();
let command = format_command(&rule.command);
let subtitle = if rule.terminal {
// Translators: {command} is a command line such as "nvim".
gettext_f("{command}, in a terminal", &[("command", &command)])
} else {
command
};
let row = adw::ActionRow::builder()
.title(patterns.join(", "))
.subtitle(subtitle)
.use_markup(false)
.activatable(true)
.build();
if !command_available(&rule.command) {
let warning = gtk4::Image::builder()
.icon_name("dialog-warning-symbolic")
// Translators: {program} is a program name such as "nvim".
.tooltip_text(gettext_f(
"“{program}” isn't installed",
&[("program", rule.command.first().map_or("", String::as_str))],
))
.build();
warning.add_css_class("warning");
row.add_prefix(&warning);
}
let up = rule_button("go-up-symbolic", &gettext("Move Up"), index > 0);
let down = rule_button("go-down-symbolic", &gettext("Move Down"), index + 1 < count);
let remove = rule_button("user-trash-symbolic", &gettext("Remove"), true);
let a = apps.clone();
up.connect_clicked(move |_| {
save(&a, |config| {
open_with_of(config).rules.swap(index - 1, index)
});
});
let a = apps.clone();
down.connect_clicked(move |_| {
save(&a, |config| {
open_with_of(config).rules.swap(index, index + 1)
});
});
let a = apps.clone();
remove.connect_clicked(move |_| {
save(&a, |config| {
let rules = &mut open_with_of(config).rules;
if index < rules.len() {
rules.remove(index);
}
});
});
row.add_suffix(&up);
row.add_suffix(&down);
row.add_suffix(&remove);
let a = apps.clone();
let rule = rule.clone();
row.connect_activated(move |_| edit_rule(&a, Some(index), rule.clone()));
group.add(&row);
apps.rule_rows.borrow_mut().push(row);
}
}
fn rule_button(icon: &str, tooltip: &str, sensitive: bool) -> gtk4::Button {
let button = gtk4::Button::builder()
.icon_name(icon)
.tooltip_text(tooltip)
.valign(gtk4::Align::Center)
.sensitive(sensitive)
.build();
button.add_css_class("flat");
button
}
/// Split a typed pattern list into patterns, dropping empty ones.
fn split_patterns(text: &str) -> Vec<String> {
text.split(',')
.map(str::trim)
.filter(|p| !p.is_empty())
.map(str::to_string)
.collect()
}
/// Edit one rule, or a new one when `index` is `None`, in a dialog over the
/// Preferences.
fn edit_rule(apps: &Rc<Apps>, index: Option<usize>, rule: OpenRule) {
let patterns_row = adw::EntryRow::builder()
.title(gettext("Files, such as *.md, *.txt"))
.text(rule.patterns.join(", "))
.build();
patterns_row.add_css_class("monospace");
let chips = gtk4::FlowBox::builder()
.selection_mode(gtk4::SelectionMode::None)
.column_spacing(6)
.row_spacing(6)
.max_children_per_line(6)
.margin_top(6)
.build();
for (class, name) in classes() {
let chip = gtk4::Button::builder().label(&name).build();
chip.add_css_class("pill");
chip.add_css_class("small");
let row = patterns_row.clone();
chip.connect_clicked(move |_| {
let mut list = split_patterns(&row.text());
if !list.iter().any(|p| p == class) {
list.push(class.to_string());
}
row.set_text(&list.join(", "));
});
chips.insert(&chip, -1);
}
let command_row = adw::EntryRow::builder()
.title(gettext("Command, such as nvim or code --wait"))
.text(format_command(&rule.command))
.build();
command_row.add_css_class("monospace");
let terminal_row = adw::SwitchRow::builder()
.title(gettext("Run in a terminal"))
.subtitle(gettext("For programs that run in a terminal, such as vim"))
.active(rule.terminal)
.build();
let hint = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.margin_top(6)
.build();
hint.add_css_class("caption");
hint.add_css_class("dim-label");
let group = adw::PreferencesGroup::new();
group.add(&patterns_row);
let files = adw::PreferencesGroup::builder()
.description(gettext("Or pick kinds of files:"))
.build();
files.add(&chips);
let program = adw::PreferencesGroup::new();
program.add(&command_row);
program.add(&terminal_row);
program.add(&hint);
let page = adw::PreferencesPage::new();
page.add(&group);
page.add(&files);
page.add(&program);
let cancel = gtk4::Button::with_label(&gettext("Cancel"));
let save_button = gtk4::Button::with_label(&gettext("Save"));
save_button.add_css_class("suggested-action");
let header = adw::HeaderBar::builder()
.show_start_title_buttons(false)
.show_end_title_buttons(false)
.build();
header.pack_start(&cancel);
header.pack_end(&save_button);
let view = adw::ToolbarView::new();
view.add_top_bar(&header);
view.set_content(Some(&page));
let dialog = adw::Dialog::builder()
.title(if index.is_some() {
gettext("Edit Rule")
} else {
gettext("New Rule")
})
.content_width(480)
.child(&view)
.build();
// Save only a rule that matches something and runs something.
let check = {
let (patterns_row, command_row, save_button, hint) = (
patterns_row.clone(),
command_row.clone(),
save_button.clone(),
hint.clone(),
);
move || {
let patterns = split_patterns(&patterns_row.text());
let argv = parse_command(&command_row.text());
command_row.remove_css_class("error");
hint.set_text("");
match &argv {
None => {
command_row.add_css_class("error");
hint.set_text(&gettext("A quote is not closed in the command."));
}
Some(argv) if !argv.is_empty() && !command_available(argv) => {
hint.set_text(&gettext_f(
"“{program}” isn't installed.",
&[("program", &argv[0])],
));
}
Some(_) => {}
}
save_button
.set_sensitive(!patterns.is_empty() && argv.is_some_and(|argv| !argv.is_empty()));
}
};
check();
let c = check.clone();
patterns_row.connect_changed(move |_| c());
command_row.connect_changed(move |_| check());
let d = dialog.clone();
cancel.connect_clicked(move |_| {
d.close();
});
let (a, d) = (apps.clone(), dialog.clone());
save_button.connect_clicked(move |_| {
let Some(command) = parse_command(&command_row.text()) else {
return;
};
let rule = OpenRule {
patterns: split_patterns(&patterns_row.text()),
command,
terminal: terminal_row.is_active(),
};
let saved = save(&a, move |config| {
let rules = &mut open_with_of(config).rules;
match index {
Some(i) if i < rules.len() => rules[i] = rule,
_ => rules.push(rule),
}
});
if saved {
d.close();
}
});
dialog.present(Some(&apps.ui.status.prefs));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn typed_patterns_are_split_on_commas() {
assert_eq!(
split_patterns(" *.md, @text ,, notes-*.txt "),
["*.md", "@text", "notes-*.txt"]
);
assert!(split_patterns(" , ").is_empty());
}
}
@@ -0,0 +1,346 @@
//! Preferences → Sync: the patterns every synced folder leaves out
//! (`ignore_patterns`) and what the conflict sweep may do (`conflict_sweep`).
//!
//! Both live in `config.json`. The daemon reads the patterns again on every
//! sync pass, so a change here is followed by a Sync Now and applies at once;
//! the sweep mode is read when the service starts, so a change offers a
//! restart, as the mountpoint does.
use crate::*;
use pdfs_core::config::SweepMode;
use pdfs_core::syncignore::{DEFAULT_IGNORE_PATTERNS, check_pattern};
/// The widgets of the Sync page, built with the rest of the dialog and wired
/// once the app's state exists.
pub(crate) struct SyncPrefs {
pub(crate) page: adw::PreferencesPage,
patterns: adw::PreferencesGroup,
add_row: adw::EntryRow,
reset: gtk4::Button,
sweep_row: adw::ComboRow,
/// Whether the built-in patterns are shown, kept across repaints.
builtin_expanded: Cell<bool>,
}
/// The sweep modes in the order the combo row lists them.
const SWEEP_MODES: [SweepMode; 3] = [SweepMode::Report, SweepMode::Enforce, SweepMode::Off];
pub(crate) fn build_sync_prefs() -> SyncPrefs {
let reset = gtk4::Button::builder()
.label(gettext("Reset"))
.tooltip_text(gettext("Use the built-in patterns again"))
.valign(gtk4::Align::Center)
.build();
reset.add_css_class("flat");
let patterns = adw::PreferencesGroup::builder()
.title(gettext("Excluded Files"))
.description(gettext(
"Files and folders matching these patterns are not synced in any synced folder. Use * for any characters, end a pattern with / to match folders only, and start it with ! to include something again. Excluding never deletes anything from Proton Drive.",
))
.header_suffix(&reset)
.build();
let add_row = adw::EntryRow::builder()
.title(gettext("Add Pattern"))
.show_apply_button(true)
.build();
add_row.add_css_class("monospace");
patterns.add(&add_row);
let sweep_row = adw::ComboRow::builder()
.title(gettext("Identical conflict copies"))
.subtitle(gettext(
"A copy made when a file changed in two places, found to be the same as the file",
))
.model(&gtk4::StringList::new(&[
&gettext("Report Only"),
&gettext("Move to Trash"),
&gettext("Off"),
]))
.build();
let conflicts = adw::PreferencesGroup::builder()
.title(gettext("Conflict Copies"))
.build();
conflicts.add(&sweep_row);
let page = adw::PreferencesPage::builder()
.title(gettext("Sync"))
.name("sync")
.icon_name("pdfs-sync-symbolic")
.build();
page.add(&patterns);
page.add(&conflicts);
SyncPrefs {
page,
patterns,
add_row,
reset,
sweep_row,
builtin_expanded: Cell::new(false),
}
}
/// Fill the page from the config and connect its controls.
pub(crate) fn wire_sync_prefs(ui: &Rc<Ui>, widgets: SyncPrefs) {
let widgets = Rc::new(widgets);
let rows: Rc<RefCell<Vec<adw::PreferencesRow>>> = Rc::default();
let config = ui.dirs.load_config();
paint_patterns(ui, &widgets, &rows, &config);
// The Sync page and `pdfs sync ignore` change the patterns too: show the
// saved ones each time the page comes up.
let (ui_map, w_map, rows_map) = (ui.clone(), widgets.clone(), rows.clone());
widgets.page.connect_map(move |_| {
let config = ui_map.dirs.load_config();
paint_patterns(&ui_map, &w_map, &rows_map, &config);
});
let mode = config.conflict_sweep.unwrap_or_default();
let suppress = ui.status.settings_suppress.replace(true);
widgets.sweep_row.set_selected(
SWEEP_MODES
.iter()
.position(|m| *m == mode)
.unwrap_or_default() as u32,
);
ui.status.settings_suppress.set(suppress);
widgets.add_row.connect_changed(|row| {
let text = row.text();
if text.trim().is_empty() || check_pattern(text.trim()).is_ok() {
row.remove_css_class("error");
} else {
row.add_css_class("error");
}
});
let (ui_add, w_add, rows_add) = (ui.clone(), widgets.clone(), rows.clone());
widgets.add_row.connect_apply(move |row| {
let pattern = row.text().trim().to_string();
if pattern.is_empty() {
return;
}
if let Err(e) = check_pattern(&pattern) {
tracing::debug!(%pattern, error = %e, "not a valid ignore pattern");
prefs_toast(
&ui_add,
// Translators: {pattern} is what the user typed as a pattern.
&gettext_f(
"“{pattern}” isn't a valid pattern",
&[("pattern", &pattern)],
),
);
return;
}
let added = change_patterns(&ui_add, &w_add, &rows_add, |list| {
if !list.contains(&pattern) {
list.push(pattern.clone());
}
});
if added {
row.set_text("");
}
});
let (ui_reset, w_reset, rows_reset) = (ui.clone(), widgets.clone(), rows.clone());
widgets.reset.connect_clicked(move |_| {
let (ui, w, rows) = (ui_reset.clone(), w_reset.clone(), rows_reset.clone());
confirm_destructive(
&ui_reset.status.prefs,
&gettext("Reset Excluded Files?"),
&gettext("Your own patterns are removed, and the built-in ones apply again."),
&gettext("Reset"),
move || {
change_patterns(&ui, &w, &rows, |list| {
*list = default_patterns();
});
},
);
});
let ui_sweep = ui.clone();
widgets.sweep_row.connect_selected_notify(move |row| {
if ui_sweep.status.settings_suppress.get() {
return;
}
let Some(mode) = SWEEP_MODES.get(row.selected() as usize).copied() else {
return;
};
let stored = (mode != SweepMode::default()).then_some(mode);
match ui_sweep
.dirs
.update_config(|config| config.conflict_sweep = stored)
{
Ok(()) => offer_restart(&ui_sweep),
Err(e) => prefs_toast(
&ui_sweep,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the setting")),
("detail", &e.to_string()),
],
),
),
}
});
}
fn default_patterns() -> Vec<String> {
DEFAULT_IGNORE_PATTERNS
.iter()
.map(|p| (*p).to_string())
.collect()
}
/// Apply `edit` to the patterns in effect and save them, then show them and
/// have every synced folder sync with them. Says whether it saved.
fn change_patterns(
ui: &Rc<Ui>,
widgets: &Rc<SyncPrefs>,
rows: &Rc<RefCell<Vec<adw::PreferencesRow>>>,
edit: impl FnOnce(&mut Vec<String>),
) -> bool {
match ui.dirs.change_ignore_patterns(edit) {
Ok(config) => {
paint_patterns(ui, widgets, rows, &config);
// Best effort: the next pass picks the change up anyway.
let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id: None });
true
}
Err(e) => {
prefs_toast(
ui,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the patterns")),
("detail", &e.to_string()),
],
),
);
false
}
}
}
/// Show the patterns in effect below the entry row: the user's own one row
/// each, then the built-in ones folded into one row, since they are many and
/// rarely changed.
fn paint_patterns(
ui: &Rc<Ui>,
widgets: &Rc<SyncPrefs>,
rows: &Rc<RefCell<Vec<adw::PreferencesRow>>>,
config: &pdfs_core::config::AppConfig,
) {
for row in rows.borrow_mut().drain(..) {
widgets.patterns.remove(&row);
}
widgets
.reset
.set_sensitive(config.ignore_patterns.is_some());
let list = config.resolved_ignore_patterns();
let (builtin, own): (Vec<String>, Vec<String>) = list
.into_iter()
.partition(|p| DEFAULT_IGNORE_PATTERNS.contains(&p.as_str()));
for pattern in own {
let row = pattern_row(ui, widgets, rows, pattern);
widgets.patterns.add(&row);
rows.borrow_mut().push(row.upcast());
}
// Every built-in pattern, on or off, so one turned off can be turned on
// again without losing the user's own.
let on = builtin.len();
let total = DEFAULT_IGNORE_PATTERNS.len();
let expander = adw::ExpanderRow::builder()
.title(gettext("Built-in patterns"))
// Translators: {on} and {total} are numbers of patterns.
.subtitle(gettext_f(
"{on} of {total} on: version control, dependency and build folders, and what editors, downloads and systems leave behind",
&[("on", &on.to_string()), ("total", &total.to_string())],
))
.expanded(widgets.builtin_expanded.get())
.build();
let w = widgets.clone();
expander.connect_expanded_notify(move |row| w.builtin_expanded.set(row.is_expanded()));
for pattern in DEFAULT_IGNORE_PATTERNS {
let row = adw::SwitchRow::builder()
.title(format!("<tt>{}</tt>", glib::markup_escape_text(pattern)))
.use_markup(true)
.active(builtin.iter().any(|p| p == pattern))
.build();
let (ui, w, r) = (ui.clone(), widgets.clone(), rows.clone());
row.connect_active_notify(move |row| {
let active = row.is_active();
// Repainting replaces this row; let the switch finish first.
let (ui, w, r) = (ui.clone(), w.clone(), r.clone());
glib::idle_add_local_once(move || {
change_patterns(&ui, &w, &r, move |list| {
list.retain(|p| p != pattern);
if active {
list.push((*pattern).to_string());
}
});
});
});
expander.add_row(&row);
}
widgets.patterns.add(&expander);
rows.borrow_mut().push(expander.upcast());
}
/// One pattern, in monospace, with a button that removes it.
fn pattern_row(
ui: &Rc<Ui>,
widgets: &Rc<SyncPrefs>,
rows: &Rc<RefCell<Vec<adw::PreferencesRow>>>,
pattern: String,
) -> adw::ActionRow {
let row = adw::ActionRow::builder()
.title(format!("<tt>{}</tt>", glib::markup_escape_text(&pattern)))
.use_markup(true)
.build();
let remove = gtk4::Button::builder()
.icon_name("user-trash-symbolic")
.tooltip_text(gettext("Remove"))
.valign(gtk4::Align::Center)
.build();
remove.add_css_class("flat");
let (ui, w, r) = (ui.clone(), widgets.clone(), rows.clone());
remove.connect_clicked(move |_| {
let pattern = pattern.clone();
change_patterns(&ui, &w, &r, move |list| list.retain(|p| *p != pattern));
});
row.add_suffix(&remove);
row
}
/// The sweep mode is read when the service starts; offer that restart.
fn offer_restart(ui: &Rc<Ui>) {
let confirm = adw::AlertDialog::builder()
.heading(gettext("Restart Proton Drive?"))
.body(gettext(
"The new setting applies after Proton Drive restarts.",
))
.build();
confirm.add_response("later", &gettext("Later"));
confirm.add_response("restart", &gettext("Restart Now"));
confirm.set_response_appearance("restart", adw::ResponseAppearance::Suggested);
confirm.set_default_response(Some("restart"));
confirm.set_close_response("later");
let ui_restart = ui.clone();
confirm.connect_response(None, move |_, resp| {
if resp == "restart" {
restart_service_then(&ui_restart, |_| {});
}
});
confirm.present(Some(&ui.status.prefs));
}
/// A toast on the Preferences dialog, which covers the window's own toasts.
pub(crate) fn prefs_toast(ui: &Rc<Ui>, message: &str) {
ui.status.prefs.add_toast(
adw::Toast::builder()
.title(message)
.use_markup(false)
.timeout(6)
.build(),
);
}
+39 -24
View File
@@ -169,6 +169,9 @@ pub(crate) struct MainWidgets {
pub(crate) tray_row: adw::SwitchRow, pub(crate) tray_row: adw::SwitchRow,
pub(crate) update_row: adw::SwitchRow, pub(crate) update_row: adw::SwitchRow,
pub(crate) language_row: adw::ComboRow, pub(crate) language_row: adw::ComboRow,
/// Preferences → Sync and → Apps, wired once the app's state exists.
pub(crate) sync_prefs: SyncPrefs,
pub(crate) apps_prefs: AppsPrefs,
} }
/// Build the two surfaces that replaced the old Settings page: /// Build the two surfaces that replaced the old Settings page:
@@ -267,6 +270,7 @@ pub(crate) fn build_main_page() -> MainWidgets {
let general = adw::PreferencesPage::builder() let general = adw::PreferencesPage::builder()
.title(gettext("General")) .title(gettext("General"))
.name("general")
.icon_name("preferences-system-symbolic") .icon_name("preferences-system-symbolic")
.build(); .build();
general.add(&startup_group); general.add(&startup_group);
@@ -335,6 +339,7 @@ pub(crate) fn build_main_page() -> MainWidgets {
let storage = adw::PreferencesPage::builder() let storage = adw::PreferencesPage::builder()
.title(gettext("Storage")) .title(gettext("Storage"))
.name("storage")
.icon_name("drive-harddisk-symbolic") .icon_name("drive-harddisk-symbolic")
.build(); .build();
storage.add(&storage_group); storage.add(&storage_group);
@@ -343,7 +348,11 @@ pub(crate) fn build_main_page() -> MainWidgets {
let prefs = adw::PreferencesDialog::builder() let prefs = adw::PreferencesDialog::builder()
.search_enabled(false) .search_enabled(false)
.build(); .build();
let sync_prefs = build_sync_prefs();
let apps_prefs = build_apps_prefs();
prefs.add(&general); prefs.add(&general);
prefs.add(&sync_prefs.page);
prefs.add(&apps_prefs.page);
prefs.add(&storage); prefs.add(&storage);
// ---- Sidebar footer // ---- Sidebar footer
@@ -463,6 +472,8 @@ pub(crate) fn build_main_page() -> MainWidgets {
tray_row, tray_row,
update_row, update_row,
language_row, language_row,
sync_prefs,
apps_prefs,
} }
} }
@@ -678,9 +689,10 @@ pub(crate) fn wire_settings(
let rows = list.model.n_items(); let rows = list.model.n_items();
list.model.items_changed(0, rows, rows); list.model.items_changed(0, rows, rows);
} }
let mut config = ui_theme.dirs.load_config(); if let Err(e) = ui_theme
config.proton_theme = Some(on); .dirs
if let Err(e) = ui_theme.dirs.save_config(&config) { .update_config(|config| config.proton_theme = Some(on))
{
toast_error( toast_error(
&ui_theme, &ui_theme,
&gettext("Couldn't save the theme"), &gettext("Couldn't save the theme"),
@@ -700,9 +712,7 @@ pub(crate) fn wire_settings(
.gallery .gallery
.places_map .places_map
.set_online(on, ui_map.dirs.cache_dir()); .set_online(on, ui_map.dirs.cache_dir());
let mut config = ui_map.dirs.load_config(); if let Err(e) = ui_map.dirs.update_config(|config| config.online_map = on) {
config.online_map = on;
if let Err(e) = ui_map.dirs.save_config(&config) {
toast_error( toast_error(
&ui_map, &ui_map,
&gettext("Couldn't save the map setting"), &gettext("Couldn't save the map setting"),
@@ -717,9 +727,10 @@ pub(crate) fn wire_settings(
if ui_update.status.settings_suppress.get() { if ui_update.status.settings_suppress.get() {
return; return;
} }
let mut config = ui_update.dirs.load_config(); if let Err(e) = ui_update
config.update_check = row.is_active(); .dirs
if let Err(e) = ui_update.dirs.save_config(&config) { .update_config(|config| config.update_check = row.is_active())
{
toast_error( toast_error(
&ui_update, &ui_update,
&gettext("Couldn't save the update setting"), &gettext("Couldn't save the update setting"),
@@ -739,9 +750,10 @@ pub(crate) fn wire_settings(
return; return;
} }
let show = row.is_active(); let show = row.is_active();
let mut config = ui_tray.dirs.load_config(); if let Err(e) = ui_tray
config.tray_hidden = !show; .dirs
if let Err(e) = ui_tray.dirs.save_config(&config) { .update_config(|config| config.tray_hidden = !show)
{
toast_error( toast_error(
&ui_tray, &ui_tray,
&gettext("Couldn't save the tray setting"), &gettext("Couldn't save the tray setting"),
@@ -763,9 +775,9 @@ pub(crate) fn wire_settings(
if ui_language.status.settings_suppress.get() { if ui_language.status.settings_suppress.get() {
return; return;
} }
let mut config = ui_language.dirs.load_config(); if let Err(e) = ui_language.dirs.update_config(|config| {
config.language = language_at(row.selected()).map(str::to_string); config.language = language_at(row.selected()).map(str::to_string)
if let Err(e) = ui_language.dirs.save_config(&config) { }) {
toast_error( toast_error(
&ui_language, &ui_language,
&gettext("Couldn't save the language"), &gettext("Couldn't save the language"),
@@ -864,9 +876,10 @@ fn use_mountpoint(ui: &Rc<Ui>, path: &std::path::Path) {
let path_str = path.display().to_string(); let path_str = path.display().to_string();
// Persist the choice to config so the next mount uses it. // Persist the choice to config so the next mount uses it.
let mut config = ui.dirs.load_config(); if let Err(e) = ui
config.mountpoint = Some(path_str.clone()); .dirs
if let Err(e) = ui.dirs.save_config(&config) { .update_config(|config| config.mountpoint = Some(path_str.clone()))
{
toast_error(ui, &gettext("Couldn't save the folder"), &e.to_string()); toast_error(ui, &gettext("Couldn't save the folder"), &e.to_string());
return; return;
} }
@@ -1115,9 +1128,6 @@ pub(crate) fn repaint_transfers(ui: &Rc<Ui>, items: &[TransferItem], jobs: &[Job
// count falling to zero is what "the sync finished" looks like from here. // count falling to zero is what "the sync finished" looks like from here.
// Jobs are deliberately not counted — a bulk upload retires its scan job and // Jobs are deliberately not counted — a bulk upload retires its scan job and
// starts its upload job mid-flight, which is not a thing finishing. // starts its upload job mid-flight, which is not a thing finishing.
// The Import page reads its progress off the same snapshot rather than
// polling the daemon a second time for numbers already on the wire.
takeout_progress(ui, jobs);
let previous = ui.status.active_transfers.replace(items.len()); let previous = ui.status.active_transfers.replace(items.len());
if !items.is_empty() { if !items.is_empty() {
@@ -1211,13 +1221,18 @@ pub(crate) fn repaint_transfers(ui: &Rc<Ui>, items: &[TransferItem], jobs: &[Job
pub(crate) fn job_line(j: &JobItem) -> ActivityLine { pub(crate) fn job_line(j: &JobItem) -> ActivityLine {
let done = j.done.to_string(); let done = j.done.to_string();
let total = j.total.to_string(); let total = j.total.to_string();
let (title, detail) = if j.title == IMPORT_JOB {
import_job_text(&j.detail)
} else {
(j.title.clone(), j.detail.clone())
};
let args: [(&str, &str); 4] = [ let args: [(&str, &str); 4] = [
("title", &j.title), ("title", &title),
("detail", &j.detail), ("detail", &detail),
("done", &done), ("done", &done),
("total", &total), ("total", &total),
]; ];
let text = match (j.total > 0, j.detail.is_empty()) { let text = match (j.total > 0, detail.is_empty()) {
// Translators: a background job's progress. {title} is the job, such as // Translators: a background job's progress. {title} is the job, such as
// "Scanning Photos"; {done} and {total} are counts. // "Scanning Photos"; {done} and {total} are counts.
(true, true) => gettext_f("{title} — {done} of {total}", &args), (true, true) => gettext_f("{title} — {done} of {total}", &args),
@@ -0,0 +1,426 @@
//! The Excluded Files group on the Sync page's Folders view: what is left out
//! of every synced folder and of each one on its own, with how many patterns
//! each has, and an Add Pattern dialog that asks where a pattern goes.
//!
//! The rows open the editors that already exist: Preferences → Sync for the
//! patterns of all folders, the Excluded Files dialog for a folder's own
//! `.pdfsignore`. Only folders kept on this computer are listed; an
//! online-only folder has no local files for patterns to leave out. With none
//! of those, the group still shows, so the patterns can be found and set up
//! before a folder is switched to Synced, and says why they do nothing yet.
use crate::*;
use pdfs_core::syncignore::{FolderRules, add_folder_pattern, check_pattern};
pub(crate) struct ExclusionsState {
pub(crate) group: adw::PreferencesGroup,
pub(crate) add: gtk4::Button,
pub(crate) rows: RefCell<Vec<adw::ActionRow>>,
/// The synced folders kept on this computer the rows were built for, as
/// id and root.
pub(crate) folders: RefCell<Vec<(i64, PathBuf)>>,
/// Counts painted, so a slow read from an older paint does not land on
/// newer rows.
pub(crate) generation: Cell<u64>,
}
pub(crate) fn build_exclusions_group() -> (adw::PreferencesGroup, gtk4::Button) {
let add = gtk4::Button::builder()
.child(
&adw::ButtonContent::builder()
.label(gettext("Add Pattern"))
.icon_name("list-add-symbolic")
.build(),
)
.tooltip_text(gettext(
"Leave files matching a pattern out of all synced folders or one of them",
))
.valign(gtk4::Align::Center)
.build();
add.add_css_class("flat");
let group = adw::PreferencesGroup::builder()
.title(gettext("Excluded Files"))
.description(gettext(
"Files matching these patterns stay on this computer and are not synced. Excluding never deletes anything from Proton Drive.",
))
.header_suffix(&add)
.visible(false)
.build();
(group, add)
}
pub(crate) fn wire_exclusions(ui: &Rc<Ui>) {
let ui_add = ui.clone();
ui.locations
.exclusions
.add
.connect_clicked(move |_| present_add_pattern_dialog(&ui_add, None));
// Preferences change the patterns of all folders; show the new count.
let ui_prefs = ui.clone();
ui.status
.prefs
.connect_closed(move |_| refresh_exclusions(&ui_prefs));
}
/// Rebuild the rows for the folders in `items` when the set of synced folders
/// kept on this computer changed, or on the first paint. The tick repaints the folder list every few
/// seconds; the rows and their counts stay as they are in between.
pub(crate) fn paint_exclusions(ui: &Rc<Ui>, items: &[MountSpec]) {
let folders: Vec<(i64, PathBuf)> = items
.iter()
.filter(|spec| spec.mode == MountMode::Mirror)
.filter_map(|spec| match spec.kind {
MountKind::Device { sync_folder_id } | MountKind::Attached { sync_folder_id } => {
Some((sync_folder_id, PathBuf::from(&spec.local_path)))
}
_ => None,
})
.collect();
let state = &ui.locations.exclusions;
if *state.folders.borrow() == folders && !state.rows.borrow().is_empty() {
return;
}
*state.folders.borrow_mut() = folders;
refresh_exclusions(ui);
}
/// Build the rows again from the folders last painted, and read every count
/// anew: after a pattern was added or a list edited.
pub(crate) fn refresh_exclusions(ui: &Rc<Ui>) {
let state = &ui.locations.exclusions;
for row in state.rows.borrow_mut().drain(..) {
state.group.remove(&row);
}
let folders = state.folders.borrow().clone();
state.group.set_visible(true);
let generation = state.generation.get() + 1;
state.generation.set(generation);
let config = ui.dirs.load_config();
let all = adw::ActionRow::builder()
.title(gettext("All Synced Folders"))
.subtitle(glib::markup_escape_text(&all_folders_subtitle(&config)).as_str())
.activatable(true)
.build();
all.add_prefix(&gtk4::Image::from_icon_name("view-list-symbolic"));
all.add_suffix(&gtk4::Image::from_icon_name("go-next-symbolic"));
let ui_all = ui.clone();
all.connect_activated(move |_| {
let prefs = &ui_all.status.prefs;
prefs.set_visible_page_name("sync");
prefs.present(ui_window(&ui_all).as_ref());
});
state.group.add(&all);
let mut rows = vec![all];
if folders.is_empty() {
let none = adw::ActionRow::builder()
.title(gettext("No folder is set to Synced"))
.subtitle(gettext(
"Patterns apply only to folders kept on this computer. Online-only folders upload every file saved in them.",
))
.build();
none.add_prefix(&gtk4::Image::from_icon_name("info-outline-symbolic"));
state.group.add(&none);
rows.push(none);
}
let mut counted = Vec::new();
for (id, root) in folders {
let name = root
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| root.display().to_string());
let row = adw::ActionRow::builder()
.title(glib::markup_escape_text(&name).as_str())
.tooltip_text(root.display().to_string())
.subtitle(glib::markup_escape_text(&tilde_path(&root.display().to_string())).as_str())
.subtitle_lines(1)
.activatable(true)
.build();
row.add_prefix(&gtk4::Image::from_icon_name("folder-symbolic"));
row.add_suffix(&gtk4::Image::from_icon_name("go-next-symbolic"));
let (ui_row, root_row) = (ui.clone(), root.clone());
row.connect_activated(move |_| present_ignore_dialog(&ui_row, id, root_row.clone()));
state.group.add(&row);
counted.push((row.clone(), root));
rows.push(row);
}
*state.rows.borrow_mut() = rows;
// A folder may sit on a slow or sleeping disk: count off the main thread.
let ui = ui.clone();
glib::spawn_future_local(async move {
let roots: Vec<PathBuf> = counted.iter().map(|(_, root)| root.clone()).collect();
let counts = gio::spawn_blocking(move || {
roots
.iter()
.map(|root| {
FolderRules::read(root)
.ok()
.map(|rules| rules.patterns().len())
})
.collect::<Vec<_>>()
})
.await
.unwrap_or_default();
if ui.locations.exclusions.generation.get() != generation {
return;
}
for ((row, root), count) in counted.iter().zip(counts) {
let state = match count {
Some(0) => gettext("no own patterns"),
// Translators: how many patterns a synced folder has of its own.
Some(n) => ngettext_f("{n} own pattern", "{n} own patterns", n as u64, &[]),
None => gettext("own patterns unreadable"),
};
// Translators: a synced folder's location and how many patterns of its own it has, such as "~/Projects · 2 own patterns".
let subtitle = gettext_f(
"{path} · {state}",
&[
("path", &tilde_path(&root.display().to_string())),
("state", &state),
],
);
row.set_subtitle(glib::markup_escape_text(&subtitle).as_str());
}
});
}
/// How many patterns apply to every synced folder, and whether they are the
/// built-in ones.
fn all_folders_subtitle(config: &pdfs_core::config::AppConfig) -> String {
let n = config.resolved_ignore_patterns().len() as u64;
match (&config.ignore_patterns, n) {
(_, 0) => gettext("No patterns: every file is synced"),
(None, n) => ngettext_f("{n} built-in pattern", "{n} built-in patterns", n, &[]),
(Some(_), n) => ngettext_f("{n} pattern", "{n} patterns", n, &[]),
}
}
/// Ask for a pattern and where it applies: every synced folder, or one of
/// them (`folder`, preselected when given).
pub(crate) fn present_add_pattern_dialog(ui: &Rc<Ui>, folder: Option<i64>) {
let folders = ui.locations.exclusions.folders.borrow().clone();
let pattern_row = adw::EntryRow::builder().title(gettext("Pattern")).build();
pattern_row.add_css_class("monospace");
let mut places = vec![gettext("All synced folders")];
places.extend(
folders
.iter()
.map(|(_, root)| tilde_path(&root.display().to_string())),
);
let places: Vec<&str> = places.iter().map(String::as_str).collect();
let scope_row = adw::ComboRow::builder()
.title(gettext("Apply To"))
.model(&gtk4::StringList::new(&places))
.build();
if let Some(at) = folder.and_then(|id| folders.iter().position(|(f, _)| *f == id)) {
scope_row.set_selected(at as u32 + 1);
}
let rows = adw::PreferencesGroup::new();
rows.add(&pattern_row);
rows.add(&scope_row);
let hint = gtk4::Label::builder()
.label(gettext(
"Use * for any characters, such as *.db, and end a pattern with / to match folders only, such as build/.",
))
.wrap(true)
.xalign(0.0)
.build();
hint.add_css_class("dim-label");
hint.add_css_class("caption");
let problem = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.visible(false)
.build();
problem.add_css_class("error");
let body = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
body.set_margin_top(12);
body.set_margin_bottom(18);
body.set_margin_start(18);
body.set_margin_end(18);
body.append(&rows);
body.append(&hint);
body.append(&problem);
let cancel = gtk4::Button::with_label(&gettext("Cancel"));
let add = gtk4::Button::with_label(&gettext("Add"));
add.add_css_class("suggested-action");
add.set_sensitive(false);
let header = adw::HeaderBar::builder()
.show_start_title_buttons(false)
.show_end_title_buttons(false)
.build();
header.pack_start(&cancel);
header.pack_end(&add);
let view = adw::ToolbarView::new();
view.add_top_bar(&header);
view.set_content(Some(&body));
let dialog = adw::Dialog::builder()
.title(gettext("Add Pattern"))
.content_width(460)
.child(&view)
.build();
let (add_check, problem_check) = (add.clone(), problem.clone());
pattern_row.connect_changed(move |row| {
let verdict = pattern_problem(&row.text());
match &verdict {
Some(message) if !row.text().trim().is_empty() => {
row.add_css_class("error");
problem_check.set_text(message);
problem_check.set_visible(true);
}
_ => {
row.remove_css_class("error");
problem_check.set_visible(false);
}
}
add_check.set_sensitive(verdict.is_none());
});
let d = dialog.clone();
cancel.connect_clicked(move |_| {
d.close();
});
let submit = {
let (ui, dialog, pattern_row, scope_row, add, problem) = (
ui.clone(),
dialog.clone(),
pattern_row.clone(),
scope_row.clone(),
add.clone(),
problem.clone(),
);
move || {
if !add.is_sensitive() {
return;
}
let pattern = pattern_row.text().trim().to_string();
let target = match scope_row.selected() {
0 => None,
at => folders.get(at as usize - 1).cloned(),
};
// One click, one save: the button comes back if the save fails.
add.set_sensitive(false);
add_pattern(&ui, &dialog, &add, &problem, pattern, target);
}
};
let submit_enter = submit.clone();
pattern_row.connect_entry_activated(move |_| submit_enter());
add.connect_clicked(move |_| submit());
dialog.present(ui_window(ui).as_ref());
pattern_row.grab_focus();
}
/// What is wrong with `text` as a pattern to add, or `None` when it is one.
fn pattern_problem(text: &str) -> Option<String> {
let text = text.trim();
if text.is_empty() {
return Some(String::new());
}
if text.starts_with('#') {
return Some(gettext(
"A line starting with # is a comment, not a pattern.",
));
}
check_pattern(text).err().map(|e| {
tracing::debug!(pattern = %text, error = %e, "not a valid ignore pattern");
// Translators: {pattern} is what the user typed as a pattern.
gettext_f("“{pattern}” isn't a valid pattern.", &[("pattern", text)])
})
}
/// Save `pattern` for every synced folder (`target` is `None`) or for the
/// folder `target`, then close `dialog`, say so and sync. A failure shows in
/// `problem`, in the dialog, which stays open.
fn add_pattern(
ui: &Rc<Ui>,
dialog: &adw::Dialog,
add: &gtk4::Button,
problem: &gtk4::Label,
pattern: String,
target: Option<(i64, PathBuf)>,
) {
let (ui, dialog, add, problem) = (ui.clone(), dialog.clone(), add.clone(), problem.clone());
glib::spawn_future_local(async move {
let (id, place) = match &target {
None => (None, gettext("all synced folders")),
Some((id, root)) => (Some(*id), tilde_path(&root.display().to_string())),
};
let added: Result<bool, String> = match target {
None => {
let mut added = false;
ui.dirs
.change_ignore_patterns(|list| {
if !list.contains(&pattern) {
list.push(pattern.clone());
added = true;
}
})
.map(|_| added)
.map_err(|e| e.to_string())
}
Some((_, root)) => {
let p = pattern.clone();
gio::spawn_blocking(move || add_folder_pattern(&root, &p))
.await
.unwrap_or_else(|_| Err(std::io::Error::other("the save did not finish")))
.map_err(|e| e.to_string())
}
};
match added {
Ok(added) => {
dialog.close();
let message = if added {
// Translators: {pattern} is an ignore pattern, {place} "all synced folders" or a folder path.
gettext_f(
"“{pattern}” is now excluded in {place}",
&[("pattern", &pattern), ("place", &place)],
)
} else {
gettext_f(
"“{pattern}” was already excluded in {place}",
&[("pattern", &pattern), ("place", &place)],
)
};
toast(&ui, &message);
refresh_exclusions(&ui);
if added {
// Best effort: the next pass picks the change up anyway.
let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id });
}
}
Err(e) => {
add.set_sensitive(true);
problem.set_text(&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the patterns")),
("detail", &e),
],
));
problem.set_visible(true);
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_real_patterns_can_be_added() {
assert!(pattern_problem("*.db").is_none());
assert!(pattern_problem(" build/ ").is_none());
assert!(pattern_problem("").is_some());
assert!(pattern_problem(" ").is_some());
assert!(pattern_problem("# note").is_some());
assert!(pattern_problem("*.{jpg,png").is_some());
}
}
+326 -158
View File
@@ -15,17 +15,30 @@
//! Import — staging is local, so a mis-drop costs nothing. //! Import — staging is local, so a mis-drop costs nothing.
//! //!
//! The daemon owns the run itself ([`Request::ImportTakeout`]): this page only //! The daemon owns the run itself ([`Request::ImportTakeout`]): this page only
//! stages paths, launches, asks [`Request::ImportStatus`] for the final report, //! stages paths, launches, and asks [`Request::ImportStatus`] for the step, the
//! and reads live progress off the import's job in the transfer snapshot the //! running counts and the final report. It asks again whenever the import's job
//! daemon already pushes (see [`takeout_progress`]). //! moves in the transfer snapshot the daemon already pushes. A run the service
//! did not get to finish can be picked up with [`Request::ResumeImport`].
use crate::*; use crate::*;
/// The title the daemon gives the import's job in [`Request::GetQueueStatus`]. /// The title the daemon gives the import's job in [`Request::GetQueueStatus`].
/// Matching on it is how this page borrows the progress the daemon already /// Seeing it move is the cue to ask for the import's status; the Activity list
/// pushes instead of asking for it separately. /// shows it under its translated name ([`import_job_text`]).
pub(crate) const IMPORT_JOB: &str = "Importing Google Photos"; pub(crate) const IMPORT_JOB: &str = "Importing Google Photos";
/// The import job's title and detail in the user's language. The daemon names
/// its steps in English; the file being uploaded passes through as it is.
pub(crate) fn import_job_text(detail: &str) -> (String, String) {
let detail = match detail {
"reading archives" => gettext("Reading the archives"),
"checking for photos you already have" => gettext("Checking for photos you already have"),
"sorting photos into albums" => gettext("Sorting photos into albums"),
other => other.to_string(),
};
(gettext("Importing from Google Photos"), detail)
}
/// What the archive list says before anything is staged. `repaint_archives` /// What the archive list says before anything is staged. `repaint_archives`
/// swaps in the count and total once there is something to report, and swaps /// swaps in the count and total once there is something to report, and swaps
/// this back when the list is emptied again. /// this back when the list is emptied again.
@@ -95,18 +108,19 @@ pub(crate) struct TakeoutState {
pub(crate) progress_group: adw::PreferencesGroup, pub(crate) progress_group: adw::PreferencesGroup,
pub(crate) progress_label: gtk4::Label, pub(crate) progress_label: gtk4::Label,
pub(crate) progress_bar: gtk4::ProgressBar, pub(crate) progress_bar: gtk4::ProgressBar,
/// Report group for the last finished run, hidden until there is one. /// The running counts, or the report for the last finished run; hidden
/// until there is one.
pub(crate) summary_group: adw::PreferencesGroup, pub(crate) summary_group: adw::PreferencesGroup,
pub(crate) summary_rows: RefCell<Vec<adw::ActionRow>>, pub(crate) summary_rows: RefCell<Vec<adw::ActionRow>>,
/// Offers to resume an import the service did not get to finish.
pub(crate) resume_group: adw::PreferencesGroup,
pub(crate) resume_row: adw::ActionRow,
pub(crate) resume_button: gtk4::Button,
/// One [`Request::ImportStatus`] in flight at a time, so a wedged daemon /// One [`Request::ImportStatus`] in flight at a time, so a wedged daemon
/// can't stack worker threads on the 2s tick. /// can't stack worker threads on the 2s tick.
pub(crate) inflight: Cell<bool>, pub(crate) inflight: Cell<bool>,
/// Whether the daemon reported an import running on the last poll. /// Whether the daemon reported an import running on the last poll.
pub(crate) running: Cell<bool>, pub(crate) running: Cell<bool>,
/// Whether the run in flight was launched as a dry run, so the report can
/// say "would upload" rather than claiming photos were sent. The daemon's
/// summary carries no such flag — it is the same shape either way.
pub(crate) dry_run: Cell<bool>,
} }
/// Widgets the Import page hands back for wiring. /// Widgets the Import page hands back for wiring.
@@ -126,6 +140,9 @@ pub(crate) struct TakeoutWidgets {
pub(crate) progress_label: gtk4::Label, pub(crate) progress_label: gtk4::Label,
pub(crate) progress_bar: gtk4::ProgressBar, pub(crate) progress_bar: gtk4::ProgressBar,
pub(crate) summary_group: adw::PreferencesGroup, pub(crate) summary_group: adw::PreferencesGroup,
pub(crate) resume_group: adw::PreferencesGroup,
pub(crate) resume_row: adw::ActionRow,
pub(crate) resume_button: gtk4::Button,
} }
pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) { pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
@@ -261,7 +278,23 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
.visible(false) .visible(false)
.build(); .build();
// An import cut short by a restart or a lost connection, offered back at the
// top of the page: picking the archives again is exactly what a reboot in
// the middle of a migration should not cost.
let resume_button = gtk4::Button::builder()
.label(pgettext("verb", "Resume"))
.valign(gtk4::Align::Center)
.build();
resume_button.add_css_class("suggested-action");
let resume_row = adw::ActionRow::builder()
.title(gettext("The last import didn't finish"))
.build();
resume_row.add_suffix(&resume_button);
let resume_group = adw::PreferencesGroup::builder().visible(false).build();
resume_group.add(&resume_row);
let groups = gtk4::Box::new(gtk4::Orientation::Vertical, 18); let groups = gtk4::Box::new(gtk4::Orientation::Vertical, 18);
groups.append(&resume_group);
groups.append(&dropzone); groups.append(&dropzone);
groups.append(&list_group); groups.append(&list_group);
groups.append(&actions); groups.append(&actions);
@@ -301,6 +334,9 @@ pub(crate) fn build_takeout_page() -> (gtk4::Widget, TakeoutWidgets) {
progress_label: progress_label.clone(), progress_label: progress_label.clone(),
progress_bar: progress_bar.clone(), progress_bar: progress_bar.clone(),
summary_group: summary_group.clone(), summary_group: summary_group.clone(),
resume_group,
resume_row,
resume_button,
}; };
(frame.upcast(), widgets) (frame.upcast(), widgets)
} }
@@ -427,6 +463,28 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
}); });
}); });
let ui_resume = ui.clone();
widgets.resume_button.connect_clicked(move |_| {
let ui = ui_resume.clone();
ui.busy_begin();
let rx = spawn_request(ui.dirs.control_socket(), Request::ResumeImport);
glib::spawn_future_local(async move {
let result = rx.recv().await;
ui.busy_end();
match result {
Ok(Ok(Response::Ok { .. })) => import_started(&ui, false),
Ok(Ok(Response::Error { message, kind })) => {
toast_failure(&ui, &gettext("Couldn't resume the import"), &message, kind);
}
_ => toast_error(
&ui,
&gettext("Couldn't resume the import"),
&gettext("The Proton Drive service didn't respond."),
),
}
});
});
let ui_back = ui.clone(); let ui_back = ui.clone();
widgets widgets
.back_button .back_button
@@ -559,6 +617,7 @@ fn sync_takeout_actions(ui: &Rc<Ui>) {
.import_button .import_button
.set_sensitive(has_files && !running); .set_sensitive(has_files && !running);
ui.takeout.clear_button.set_sensitive(has_files && !running); ui.takeout.clear_button.set_sensitive(has_files && !running);
ui.takeout.resume_button.set_sensitive(!running);
ui.takeout.cancel_button.set_visible(running); ui.takeout.cancel_button.set_visible(running);
} }
@@ -577,7 +636,6 @@ fn start_import(ui: &Rc<Ui>, dry_run: bool) {
return; return;
} }
ui.takeout.dry_run.set(dry_run);
ui.busy_begin(); ui.busy_begin();
let rx = spawn_request( let rx = spawn_request(
ui.dirs.control_socket(), ui.dirs.control_socket(),
@@ -588,27 +646,7 @@ fn start_import(ui: &Rc<Ui>, dry_run: bool) {
let result = rx.recv().await; let result = rx.recv().await;
ui.busy_end(); ui.busy_end();
match result { match result {
Ok(Ok(Response::Ok { .. })) => { Ok(Ok(Response::Ok { .. })) => import_started(&ui, dry_run),
ui.takeout.running.set(true);
ui.gallery.import_banner.set_revealed(true);
ui.takeout.summary_group.set_visible(false);
ui.takeout.progress_group.set_visible(true);
ui.takeout.progress_bar.set_fraction(0.0);
ui.takeout.progress_label.set_text(&if dry_run {
gettext("Reading archives…")
} else {
gettext("Starting import…")
});
sync_takeout_actions(&ui);
toast(
&ui,
&if dry_run {
gettext("Scanning the export…")
} else {
gettext("Import started — you can leave this page, it keeps running.")
},
);
}
Ok(Ok(Response::Error { message, kind })) => { Ok(Ok(Response::Error { message, kind })) => {
toast_failure(&ui, &gettext("Couldn't start the import"), &message, kind); toast_failure(&ui, &gettext("Couldn't start the import"), &message, kind);
} }
@@ -621,9 +659,39 @@ fn start_import(ui: &Rc<Ui>, dry_run: bool) {
}); });
} }
/// Ask the daemon for the import's state, and paint the report once a run has /// Switch the page over to reporting progress once the daemon took the run.
/// finished. Asked on arrival and while import progress keeps arriving. Cheap fn import_started(ui: &Rc<Ui>, dry_run: bool) {
/// and inflight-guarded. ui.takeout.running.set(true);
if !dry_run {
ui.gallery.import_banner.set_revealed(true);
}
ui.takeout.resume_group.set_visible(false);
ui.takeout.summary_group.set_visible(false);
ui.takeout.progress_group.set_visible(true);
ui.takeout.progress_group.set_title(&if dry_run {
gettext("Scan in progress")
} else {
gettext("Import in progress")
});
ui.takeout.progress_bar.set_fraction(0.0);
ui.takeout
.progress_label
.set_text(&gettext("Reading the archives…"));
sync_takeout_actions(ui);
toast(
ui,
&if dry_run {
gettext("Scanning the export…")
} else {
gettext("Import started — you can leave this page, it keeps running.")
},
);
}
/// Ask the daemon for the import's state and paint it: the step and counts
/// while it runs, the report once it has ended, and the offer to resume a run
/// that did not finish. Asked on arrival and while import progress keeps
/// arriving. Cheap and inflight-guarded.
pub(crate) fn refresh_takeout(ui: &Rc<Ui>) { pub(crate) fn refresh_takeout(ui: &Rc<Ui>) {
if ui.takeout.inflight.get() { if ui.takeout.inflight.get() {
return; return;
@@ -634,124 +702,250 @@ pub(crate) fn refresh_takeout(ui: &Rc<Ui>) {
glib::spawn_future_local(async move { glib::spawn_future_local(async move {
let result = rx.recv().await; let result = rx.recv().await;
ui.takeout.inflight.set(false); ui.takeout.inflight.set(false);
let Ok(Ok(Response::ImportStatus { running, summary })) = result else { let Ok(Ok(Response::ImportStatus {
running,
summary,
progress,
resumable,
})) = result
else {
return; return;
}; };
let was_running = ui.takeout.running.replace(running); let was_running = ui.takeout.running.replace(running);
ui.gallery.import_banner.set_revealed(running); let dry = summary.as_ref().is_some_and(|s| s.dry_run);
ui.gallery.import_banner.set_revealed(running && !dry);
ui.takeout.progress_group.set_visible(running);
if running { if running {
ui.takeout.progress_group.set_visible(true); ui.takeout.progress_group.set_title(&if dry {
} else { gettext("Scan in progress")
ui.takeout.progress_group.set_visible(false); } else {
// An import runs for hours, so its ending is announced rather than gettext("Import in progress")
// left to be discovered: a toast for whoever is looking at the });
// window, and a desktop notification for whoever is not. paint_progress(&ui, progress.as_ref());
let failed = summary.as_ref().and_then(|s| s.error.clone()); } else if was_running && let Some(summary) = &summary {
if was_running && let Some(error) = &failed { announce_end(&ui, summary);
let headline = gettext("Couldn't import from Google Photos");
toast_error(&ui, &headline, error);
notify("takeout-import", &headline, error);
} else if was_running {
let dry = ui.takeout.dry_run.get();
let headline = if dry {
gettext("Scan finished")
} else {
gettext("Import finished")
};
toast(&ui, &headline);
if !dry {
let body = match &summary {
// Translators: {n} is the number of photos uploaded, {failed} the number that failed.
Some(s) if s.failed > 0 => ngettext_f(
"{n} photo added, {failed} failed.",
"{n} photos added, {failed} failed.",
s.uploaded as u64,
&[("failed", &s.failed.to_string())],
),
Some(s) if s.cancelled => ngettext_f(
"Stopped after {n} photo.",
"Stopped after {n} photos.",
s.uploaded as u64,
&[],
),
Some(s) => ngettext_f(
"{n} photo added to Proton Photos.",
"{n} photos added to Proton Photos.",
s.uploaded as u64,
&[],
),
None => gettext("The Google Photos import has finished."),
};
notify("takeout-import", &headline, &body);
}
}
} }
if was_running != running { if was_running != running {
sync_takeout_actions(&ui); sync_takeout_actions(&ui);
} }
match summary { match &summary {
Some(summary) => repaint_summary(&ui, &summary), Some(summary) => repaint_summary(&ui, summary, running),
None => ui.takeout.summary_group.set_visible(false), None => ui.takeout.summary_group.set_visible(false),
} }
paint_resume(&ui, running, summary.as_ref(), &resumable);
}); });
} }
/// Paint the last run's report. /// Tell the user how a run ended. An import runs for hours, so its ending is
fn repaint_summary(ui: &Rc<Ui>, summary: &ImportSummary) { /// announced rather than left to be discovered: a toast for whoever is looking
/// at the window, and a desktop notification for whoever is not.
fn announce_end(ui: &Rc<Ui>, summary: &ImportSummary) {
if summary.dry_run {
toast(ui, &gettext("Scan finished"));
return;
}
if let Some(error) = &summary.error {
let kind = summary.error_kind.unwrap_or_default();
let headline = gettext("Couldn't import from Google Photos");
toast_failure(ui, &headline, error, kind);
notify(
"takeout-import",
&headline,
&gettext("You can resume it once the problem is solved."),
);
return;
}
let (headline, body) = if summary.interrupted {
(
gettext("Import interrupted"),
gettext("You can resume it where it stopped."),
)
} else if summary.cancelled {
(
gettext("Import stopped"),
ngettext_f(
"Stopped after {n} photo.",
"Stopped after {n} photos.",
summary.uploaded as u64,
&[],
),
)
} else if summary.failed > 0 {
(
gettext("Import finished"),
// Translators: {n} is the number of photos uploaded, {failed} the number that failed.
ngettext_f(
"{n} photo added, {failed} failed.",
"{n} photos added, {failed} failed.",
summary.uploaded as u64,
&[("failed", &summary.failed.to_string())],
),
)
} else {
(
gettext("Import finished"),
ngettext_f(
"{n} photo added to Proton Photos.",
"{n} photos added to Proton Photos.",
summary.uploaded as u64,
&[],
),
)
};
toast(ui, &headline);
notify("takeout-import", &headline, &body);
// A complete import is done with its archives; keeping them staged would
// only invite running the same export again.
if summary.complete() {
ui.takeout.archives.borrow_mut().clear();
repaint_archives(ui);
}
}
/// Paint where a running import is.
fn paint_progress(ui: &Rc<Ui>, progress: Option<&ImportProgress>) {
let Some(progress) = progress else {
ui.takeout.progress_bar.pulse();
return;
};
let done = progress.done.to_string();
let total = progress.total.to_string();
let current = progress.current.clone().unwrap_or_default();
let counted = progress.total > 0;
let args = [
("done", done.as_str()),
("total", total.as_str()),
("name", current.as_str()),
];
let text = match (progress.phase, counted) {
(ImportPhase::Scanning, _) => gettext("Reading the archives…"),
(ImportPhase::Checking, false) => gettext("Checking for photos you already have…"),
// Translators: {done} and {total} are counts of photos.
(ImportPhase::Checking, true) => gettext_f(
"Checking for photos you already have — {done} of {total}",
&args,
),
(ImportPhase::Uploading, false) => gettext("Uploading…"),
(ImportPhase::Uploading, true) if current.is_empty() => {
// Translators: {done} and {total} are counts of photos.
gettext_f("Uploading {done} of {total}", &args)
}
// Translators: {done} and {total} are counts of photos; {name} is the file being uploaded.
(ImportPhase::Uploading, true) => gettext_f("Uploading {done} of {total} — {name}", &args),
(ImportPhase::Albums, false) => gettext("Sorting photos into albums…"),
// Translators: {done} and {total} are counts of albums.
(ImportPhase::Albums, true) => {
gettext_f("Sorting photos into albums — {done} of {total}", &args)
}
};
ui.takeout.progress_label.set_text(&text);
if counted {
ui.takeout
.progress_bar
.set_fraction((progress.done as f64 / progress.total as f64).min(1.0));
} else {
ui.takeout.progress_bar.pulse();
}
}
/// Offer to resume the last run when the service says it can be.
fn paint_resume(ui: &Rc<Ui>, running: bool, summary: Option<&ImportSummary>, resumable: &[String]) {
let offer = !running && !resumable.is_empty();
ui.takeout.resume_group.set_visible(offer);
if !offer {
return;
}
let uploaded = summary.map_or(0, |s| s.uploaded) as u64;
// Translators: {n} is the number of photos uploaded before the import stopped.
ui.takeout.resume_row.set_subtitle(&ngettext_f(
"{n} photo uploaded before it stopped. Resuming skips what is already there.",
"{n} photos uploaded before it stopped. Resuming skips what is already there.",
uploaded,
&[],
));
}
/// Paint the counts of a running import, or the report of the last one.
fn repaint_summary(ui: &Rc<Ui>, summary: &ImportSummary, running: bool) {
for row in ui.takeout.summary_rows.borrow_mut().drain(..) { for row in ui.takeout.summary_rows.borrow_mut().drain(..) {
ui.takeout.summary_group.remove(&row); ui.takeout.summary_group.remove(&row);
} }
let dry = ui.takeout.dry_run.get(); let dry = summary.dry_run;
ui.takeout.summary_group.set_title(&if dry { ui.takeout.summary_group.set_title(&if running {
gettext("So far")
} else if dry {
gettext("Scan result") gettext("Scan result")
} else { } else {
gettext("Last import") gettext("Last import")
}); });
ui.takeout.summary_group.set_description(Some(&if let Some(error) = &summary.error { let description = if running {
// The reason is the service's own text, which is not translated. A None
// group's description is markup, and the reason may name a path. } else if let Some(error) = &summary.error {
glib::markup_escape_text(&gettext_f( // The reason is the service's own text, which is not translated; the
"{what}: {detail}", // headline in front of it is. A group's description is markup, and the
&[ // reason may name a path.
("what", &gettext("Couldn't import from Google Photos")), let what = gettext("Couldn't import from Google Photos");
("detail", error), Some(
], glib::markup_escape_text(&gettext_f(
)) "{what}: {detail}",
.to_string() &[
(
"what",
error_headline(summary.error_kind.unwrap_or_default(), &what),
),
("detail", error),
],
))
.to_string(),
)
} else if dry { } else if dry {
gettext("Nothing was uploaded — this is what an import would do.") Some(gettext(
"Nothing was uploaded — this is what an import would do.",
))
} else if summary.interrupted {
Some(gettext(
"The Proton Drive service stopped while the import ran. Resume it to continue where it left off.",
))
} else if summary.cancelled { } else if summary.cancelled {
gettext("Stopped early. Everything uploaded so far is in your timeline; run it again to continue where it left off.") Some(gettext(
"Stopped early. Everything uploaded so far is in your timeline; run it again to continue where it left off.",
))
} else if !summary.complete() {
Some(gettext(
"Finished with problems. Run it again to retry what didn't upload.",
))
} else { } else {
gettext("Finished.") Some(gettext("Finished."))
})); };
ui.takeout
.summary_group
.set_description(description.as_deref());
// Only lines that carry information: a run with no failures should not have // Only lines that carry information: a run with no failures should not have
// to show a "0 failed" row for the user to read past. // to show a "0 failed" row for the user to read past.
let mut lines: Vec<(String, String)> = vec![ let mut lines: Vec<(String, String)> =
(gettext("Photos in the export"), summary.found.to_string()), vec![(gettext("Photos in the export"), summary.found.to_string())];
( if dry {
if dry { lines.push((gettext("Would upload"), summary.to_upload.to_string()));
gettext("Would upload") } else {
} else { lines.push((gettext("Uploaded"), summary.uploaded.to_string()));
gettext("Uploaded") }
},
summary.uploaded.to_string(),
),
];
if summary.duplicates > 0 { if summary.duplicates > 0 {
lines.push(( lines.push((
gettext("Already in Proton Photos"), gettext("Already in Proton Photos"),
summary.duplicates.to_string(), summary.duplicates.to_string(),
)); ));
} }
if summary.live_photos > 0 {
lines.push((
gettext("Live photos kept together"),
summary.live_photos.to_string(),
));
}
if summary.albums_created > 0 { if summary.albums_created > 0 {
lines.push(( lines.push((
if dry { gettext("Albums created"),
gettext("Albums to create")
} else {
gettext("Albums created")
},
summary.albums_created.to_string(), summary.albums_created.to_string(),
)); ));
} }
@@ -767,25 +961,31 @@ fn repaint_summary(ui: &Rc<Ui>, summary: &ImportSummary) {
summary.skipped_trashed.to_string(), summary.skipped_trashed.to_string(),
)); ));
} }
if summary.bytes > 0 { if dry && summary.to_upload_bytes > 0 {
lines.push(( lines.push((
if dry { gettext("Data to upload"),
gettext("Data to upload") human_bytes(summary.to_upload_bytes),
} else {
gettext("Data uploaded")
},
human_bytes(summary.bytes),
)); ));
} else if summary.bytes > 0 {
lines.push((gettext("Data uploaded"), human_bytes(summary.bytes)));
} }
if summary.failed > 0 { if summary.failed > 0 {
lines.push((pgettext("state", "Failed"), summary.failed.to_string())); lines.push((pgettext("state", "Failed"), summary.failed.to_string()));
} }
for path in &summary.unreadable_archives {
let name = Path::new(path)
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| path.clone());
lines.push((gettext("Couldn't read this archive"), name));
}
let mut rows = Vec::new(); let mut rows = Vec::new();
for (title, value) in lines { for (title, value) in lines {
let row = adw::ActionRow::builder() let row = adw::ActionRow::builder()
.title(title) .title(title)
.subtitle(value) .subtitle(value)
.use_markup(false)
.build(); .build();
row.add_css_class("property"); row.add_css_class("property");
ui.takeout.summary_group.add(&row); ui.takeout.summary_group.add(&row);
@@ -794,35 +994,3 @@ fn repaint_summary(ui: &Rc<Ui>, summary: &ImportSummary) {
*ui.takeout.summary_rows.borrow_mut() = rows; *ui.takeout.summary_rows.borrow_mut() = rows;
ui.takeout.summary_group.set_visible(true); ui.takeout.summary_group.set_visible(true);
} }
/// Paint the import's progress from the transfer snapshot the daemon pushed,
/// so this page costs no extra request. A job with no known total
/// pulses instead of showing a fraction, the same as the Activity list.
pub(crate) fn takeout_progress(ui: &Rc<Ui>, jobs: &[JobItem]) {
let Some(job) = jobs.iter().find(|job| job.title == IMPORT_JOB) else {
return;
};
ui.takeout.progress_group.set_visible(true);
if job.total > 0 {
ui.takeout
.progress_bar
.set_fraction((job.done as f64 / job.total as f64).min(1.0));
let done = job.done.to_string();
let total = job.total.to_string();
// Translators: progress such as "120 of 4000 — IMG_0001.jpg"; {detail} is what is being worked on.
let text = gettext_f(
"{done} of {total} — {detail}",
&[("done", &done), ("total", &total), ("detail", &job.detail)],
);
ui.takeout.progress_label.set_text(&text);
} else {
ui.takeout.progress_bar.pulse();
ui.takeout
.progress_label
.set_text(&if job.detail.is_empty() {
gettext("Working…")
} else {
job.detail.clone()
});
}
}
+4 -4
View File
@@ -82,10 +82,10 @@ pub(crate) fn start_update_checks(ui: &Rc<Ui>) {
match fetch_latest().await { match fetch_latest().await {
Ok(latest) => { Ok(latest) => {
checked = Some(unix_now()); checked = Some(unix_now());
let mut config = ui.dirs.load_config(); if let Err(e) = ui.dirs.update_config(|config| {
config.update_last_checked = checked; config.update_last_checked = checked;
config.update_latest = latest; config.update_latest = latest;
if let Err(e) = ui.dirs.save_config(&config) { }) {
tracing::warn!("update check: cannot save the result: {e}"); tracing::warn!("update check: cannot save the result: {e}");
} }
show_latest(&ui); show_latest(&ui);
@@ -0,0 +1,343 @@
//! The Excluded Files dialog of one synced folder: its own `.pdfsignore`,
//! edited as text, with a check of what the rules do to a path.
//!
//! The file sits in the synced folder and syncs like any other file, so it can
//! change on another computer while it is open here. Saving checks for that
//! and asks, rather than writing over the other edit.
use crate::*;
use pdfs_core::syncignore::{FolderRules, IgnoreRules, RuleSource, Verdict, WriteRulesError};
/// Open the dialog for the synced folder `id` at `root`.
pub(crate) fn present_ignore_dialog(ui: &Rc<Ui>, id: i64, root: PathBuf) {
let root_display = tilde_path(&root.display().to_string());
let intro = gtk4::Label::builder()
// Translators: {folder} is a local folder path such as ~/Projects.
.label(gettext_f(
"Patterns for {folder} only, one per line, on top of the ones for all synced folders. Lines starting with # are comments.",
&[("folder", &root_display)],
))
.wrap(true)
.xalign(0.0)
.build();
let text = gtk4::TextView::builder()
.monospace(true)
.wrap_mode(gtk4::WrapMode::WordChar)
.top_margin(8)
.bottom_margin(8)
.left_margin(8)
.right_margin(8)
.sensitive(false)
.build();
let scroller = gtk4::ScrolledWindow::builder()
.child(&text)
.min_content_height(180)
.vexpand(true)
.build();
scroller.add_css_class("card");
let problems = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.visible(false)
.build();
problems.add_css_class("error");
let check_row = adw::EntryRow::builder()
.title(gettext("Check a path in the folder"))
.build();
let verdict = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.margin_top(6)
.build();
verdict.add_css_class("dim-label");
let check_group = adw::PreferencesGroup::new();
check_group.add(&check_row);
let all_folders = gtk4::Button::builder()
.label(gettext("Patterns for All Folders…"))
.halign(gtk4::Align::Start)
.build();
all_folders.add_css_class("flat");
let body = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
body.set_margin_top(12);
body.set_margin_bottom(18);
body.set_margin_start(18);
body.set_margin_end(18);
body.append(&intro);
body.append(&scroller);
body.append(&problems);
body.append(&check_group);
body.append(&verdict);
body.append(&all_folders);
let cancel = gtk4::Button::with_label(&gettext("Cancel"));
let save = gtk4::Button::with_label(&gettext("Save"));
save.add_css_class("suggested-action");
save.set_sensitive(false);
let header = adw::HeaderBar::builder()
.show_start_title_buttons(false)
.show_end_title_buttons(false)
.build();
header.pack_start(&cancel);
header.pack_end(&save);
let toasts = adw::ToastOverlay::new();
toasts.set_child(Some(&body));
let view = adw::ToolbarView::new();
view.add_top_bar(&header);
view.set_content(Some(&toasts));
let dialog = adw::Dialog::builder()
.title(gettext("Excluded Files"))
.content_width(560)
.content_height(560)
.child(&view)
.build();
// What was read, so the save can tell whether the file changed since.
let loaded: Rc<RefCell<Option<FolderRules>>> = Rc::default();
let globals = Rc::new(ui.dirs.load_config().resolved_ignore_patterns());
let show_verdict = {
let (text, check_row, verdict, root, globals) = (
text.clone(),
check_row.clone(),
verdict.clone(),
root.clone(),
globals.clone(),
);
move || {
let typed = check_row.text();
let typed = typed.trim();
if typed.is_empty() {
verdict.set_text("");
return;
}
let path = Path::new(typed);
let rel = path.strip_prefix(&root).unwrap_or(path);
let rel = rel.to_string_lossy();
let rel = rel.trim_start_matches('/');
let is_dir = typed.ends_with('/') || root.join(rel).is_dir();
let rules = IgnoreRules::with_folder_text(&root, &globals, &buffer_text(&text));
verdict.set_text(&verdict_text(&rules.explain(rel, is_dir)));
}
};
let on_text = {
let (problems, save, show_verdict) = (problems.clone(), save.clone(), show_verdict.clone());
move |text: &str| {
let bad = pdfs_core::syncignore::check_rules(text);
problems.set_visible(!bad.is_empty());
if let Some((line, _)) = bad.first() {
problems.set_text(&ngettext_f(
"Line {line} isn't a valid pattern.",
"Line {line} and {more} more aren't valid patterns.",
bad.len() as u64,
&[
("line", &line.to_string()),
("more", &(bad.len() - 1).to_string()),
],
));
}
save.set_sensitive(bad.is_empty());
show_verdict();
}
};
let on_text_changed = on_text.clone();
text.buffer()
.connect_changed(move |buffer| on_text_changed(&buffer_text_of(buffer)));
check_row.connect_changed(move |_| show_verdict());
let d = dialog.clone();
cancel.connect_clicked(move |_| {
d.close();
});
let (ui_all, d) = (ui.clone(), dialog.clone());
all_folders.connect_clicked(move |_| {
d.close();
let prefs = &ui_all.status.prefs;
prefs.set_visible_page_name("sync");
prefs.present(ui_window(&ui_all).as_ref());
});
// Read off the main thread: the folder may be on a slow disk.
let reader = {
let (text, loaded, root, toasts) =
(text.clone(), loaded.clone(), root.clone(), toasts.clone());
move || {
let (text, loaded, root, toasts) =
(text.clone(), loaded.clone(), root.clone(), toasts.clone());
glib::spawn_future_local(async move {
let read = gio::spawn_blocking(move || FolderRules::read(&root))
.await
.unwrap_or_else(|_| Err(std::io::Error::other("the read did not finish")));
match read {
Ok(rules) => {
text.buffer().set_text(rules.text.as_deref().unwrap_or(""));
text.set_sensitive(true);
*loaded.borrow_mut() = Some(rules);
}
Err(e) => dialog_toast(
&toasts,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't read the patterns")),
("detail", &e.to_string()),
],
),
),
}
});
}
};
reader();
let (ui_save, d) = (ui.clone(), dialog.clone());
save.connect_clicked(move |_| {
let Some(rules) = loaded.borrow().clone() else {
return;
};
write_rules(
&ui_save,
&d,
&toasts,
id,
rules,
buffer_text(&text),
reader.clone(),
);
});
dialog.present(ui_window(ui).as_ref());
}
/// Save `body` over `rules`, then close and sync the folder. When the file
/// changed since it was read, ask whether to load the other version or to
/// replace it; `reload` reads the file into the dialog again.
fn write_rules(
ui: &Rc<Ui>,
dialog: &adw::Dialog,
toasts: &adw::ToastOverlay,
id: i64,
rules: FolderRules,
body: String,
reload: impl Fn() + Clone + 'static,
) {
let (ui, dialog, toasts) = (ui.clone(), dialog.clone(), toasts.clone());
glib::spawn_future_local(async move {
let to_write = rules.clone();
let text = body.clone();
let written = gio::spawn_blocking(move || to_write.write(&text))
.await
.unwrap_or_else(|_| {
Err(WriteRulesError::Io(std::io::Error::other(
"the write did not finish",
)))
});
match written {
Ok(()) => {
dialog.close();
toast(&ui, &gettext("Excluded files saved"));
refresh_exclusions(&ui);
let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id: Some(id) });
}
Err(WriteRulesError::Changed) => {
let ask = adw::AlertDialog::builder()
.heading(gettext("Patterns Changed Elsewhere"))
.body(gettext(
"The patterns of this folder changed while you edited them, for example on another computer. Load the other version, or replace it with yours?",
))
.build();
ask.add_response("cancel", &gettext("Cancel"));
ask.add_response("reload", &gettext("Load Other Version"));
ask.add_response("replace", &gettext("Replace"));
ask.set_response_appearance("replace", adw::ResponseAppearance::Destructive);
ask.set_default_response(Some("cancel"));
ask.set_close_response("cancel");
let (ui, d, t) = (ui.clone(), dialog.clone(), toasts.clone());
ask.connect_response(None, move |_, response| match response {
"reload" => reload(),
"replace" => {
// Read the other version only as the base to check
// against, then write over it.
let (ui, d, t, body, reload) = (
ui.clone(),
d.clone(),
t.clone(),
body.clone(),
reload.clone(),
);
let root = rules.path.parent().map(Path::to_path_buf);
glib::spawn_future_local(async move {
let Some(root) = root else { return };
let read = gio::spawn_blocking(move || FolderRules::read(&root))
.await
.ok()
.and_then(Result::ok);
if let Some(current) = read {
write_rules(&ui, &d, &t, id, current, body, reload);
}
});
}
_ => {}
});
ask.present(Some(&dialog));
}
Err(WriteRulesError::Io(e)) => dialog_toast(
&toasts,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the patterns")),
("detail", &e.to_string()),
],
),
),
}
});
}
/// Say what the rules do to the path being checked.
fn verdict_text(verdict: &Verdict) -> String {
match verdict {
Verdict::Synced => gettext("Synced: no pattern matches it."),
// Translators: {pattern} is an ignore pattern such as *.log.
Verdict::Excluded {
pattern,
source: RuleSource::ThisFolder,
} => gettext_f(
"Not synced: excluded by “{pattern}” above.",
&[("pattern", pattern)],
),
Verdict::Excluded {
pattern,
source: RuleSource::AllFolders,
} => gettext_f(
"Not synced: excluded by “{pattern}” in the patterns for all folders.",
&[("pattern", pattern)],
),
Verdict::Included { pattern, .. } => gettext_f(
"Synced: “{pattern}” includes it again.",
&[("pattern", pattern)],
),
}
}
fn buffer_text(view: &gtk4::TextView) -> String {
buffer_text_of(&view.buffer())
}
fn buffer_text_of(buffer: &gtk4::TextBuffer) -> String {
let (start, end) = buffer.bounds();
buffer.text(&start, &end, false).to_string()
}
fn dialog_toast(toasts: &adw::ToastOverlay, message: &str) {
toasts.add_toast(
adw::Toast::builder()
.title(message)
.use_markup(false)
.timeout(6)
.build(),
);
}
+9 -2
View File
@@ -101,8 +101,14 @@ impl ActionMenu {
/// Pop the menu up over `anchor` at `(x, y)` in its coordinates. The /// Pop the menu up over `anchor` at `(x, y)` in its coordinates. The
/// popover removes itself once dismissed; it waits for an idle turn, so the /// popover removes itself once dismissed; it waits for an idle turn, so the
/// item that closed it still finds its action. /// item that closed it still finds its action. Returned for a caller that
pub(crate) fn popup_at(self, anchor: &impl IsA<gtk4::Widget>, x: f64, y: f64) { /// has to know when it closes.
pub(crate) fn popup_at(
self,
anchor: &impl IsA<gtk4::Widget>,
x: f64,
y: f64,
) -> gtk4::PopoverMenu {
let (menu, group) = self.finish(); let (menu, group) = self.finish();
let anchor = anchor.as_ref(); let anchor = anchor.as_ref();
let host = popover_host(anchor); let host = popover_host(anchor);
@@ -122,6 +128,7 @@ impl ActionMenu {
glib::idle_add_local_once(move || p.unparent()); glib::idle_add_local_once(move || p.unparent());
}); });
popover.popup(); popover.popup();
popover
} }
/// A flat ⋮ button that opens this menu. /// A flat ⋮ button that opens this menu.
+3
View File
@@ -2,7 +2,10 @@ pub(crate) mod compat;
pub(crate) mod crumb; pub(crate) mod crumb;
pub(crate) mod details; pub(crate) mod details;
pub(crate) mod file_list; pub(crate) mod file_list;
pub(crate) mod ignore_dialog;
pub(crate) mod menu; pub(crate) mod menu;
pub(crate) mod photo_drag;
pub(crate) mod player;
pub(crate) mod scrubber; pub(crate) mod scrubber;
pub(crate) mod share_dialog; pub(crate) mod share_dialog;
pub(crate) mod thumbnails; pub(crate) mod thumbnails;
@@ -0,0 +1,237 @@
//! Dragging photos out of the timeline into a file manager or another app.
//!
//! A photo is not a file anywhere the receiver can read until it has been
//! downloaded, and a drag has to start the moment the pointer moves. So the
//! drag offers a list of files without having them: [`PhotoDrag`] downloads
//! the photos only when the receiver asks for the list, which it does once the
//! photos are dropped on it, and then hands over copies under their own names.
use std::future::Future;
use std::pin::Pin;
use std::time::{Duration, SystemTime};
use gtk4::gdk;
use gtk4::gdk::subclass::prelude::*;
use crate::*;
/// The one format a drag of photos offers. GTK turns it into a file list for
/// a receiver in this app, and every file manager reads it.
const URI_LIST: &str = "text/uri-list";
/// How long the copies handed to a receiver are kept. The receiver copies
/// them on drop, so a day is far more than it needs.
const KEEP_DRAGGED: Duration = Duration::from_secs(24 * 60 * 60);
mod imp {
use super::*;
#[derive(Default)]
pub struct PhotoDrag {
/// The photos dragged, as uid and Drive name.
pub(super) photos: RefCell<Vec<(String, Option<String>)>>,
pub(super) socket: RefCell<PathBuf>,
}
#[glib::object_subclass]
impl ObjectSubclass for PhotoDrag {
const NAME: &'static str = "PdfsPhotoDrag";
type Type = super::PhotoDrag;
type ParentType = gdk::ContentProvider;
}
impl ObjectImpl for PhotoDrag {}
impl ContentProviderImpl for PhotoDrag {
fn formats(&self) -> gdk::ContentFormats {
gdk::ContentFormats::new(&[URI_LIST])
}
fn write_mime_type_future(
&self,
mime_type: &str,
stream: &gio::OutputStream,
io_priority: glib::Priority,
) -> Pin<Box<dyn Future<Output = Result<(), glib::Error>> + 'static>> {
let photos = self.photos.borrow().clone();
let socket = self.socket.borrow().clone();
let stream = stream.clone();
let wanted = mime_type == URI_LIST;
Box::pin(async move {
if !wanted {
return Err(glib::Error::new(
gio::IOErrorEnum::NotSupported,
"photos are offered as a list of files only",
));
}
let files = fetch_dragged(socket, photos).await?;
let list: String = files
.iter()
.map(|path| format!("{}\r\n", gio::File::for_path(path).uri()))
.collect();
stream
.write_all_future(list.into_bytes(), io_priority)
.await
.map_err(|(_, e)| e)?;
Ok(())
})
}
}
}
glib::wrapper! {
/// The content of a drag of photos: their files, fetched when dropped.
pub struct PhotoDrag(ObjectSubclass<imp::PhotoDrag>)
@extends gdk::ContentProvider;
}
impl PhotoDrag {
pub(crate) fn new(socket: PathBuf, photos: Vec<(String, Option<String>)>) -> Self {
let drag: Self = glib::Object::new();
*drag.imp().photos.borrow_mut() = photos;
*drag.imp().socket.borrow_mut() = socket;
drag
}
}
/// Download each dragged photo and put a copy under its Drive name where the
/// receiver can read it. A photo that fails is left out; only when every one
/// fails does the drop fail.
async fn fetch_dragged(
socket: PathBuf,
photos: Vec<(String, Option<String>)>,
) -> Result<Vec<PathBuf>, glib::Error> {
let base = glib::user_cache_dir().join("pdfs-drag");
let mut files = Vec::new();
let mut last_error = None;
for (uid, name) in photos {
let rx = spawn_request(socket.clone(), Request::OpenPhoto { uid: uid.clone() });
let source = match rx.recv().await {
Ok(Ok(Response::FilePath { path })) => path,
Ok(Ok(Response::Error { message, .. })) => {
last_error = Some(message);
continue;
}
_ => {
last_error = Some("the Proton Drive service didn't respond".to_string());
continue;
}
};
let base = base.clone();
let copied = gio::spawn_blocking(move || {
prune_dragged(&base, SystemTime::now());
let name = name.unwrap_or_else(|| "photo".to_string());
hand_over(&base, Path::new(&source), &uid, &name)
})
.await;
match copied {
Ok(Ok(path)) => files.push(path),
Ok(Err(e)) => last_error = Some(e.to_string()),
Err(_) => last_error = Some("the copy was interrupted".to_string()),
}
}
if files.is_empty() {
let message = last_error.unwrap_or_else(|| "nothing to drop".to_string());
tracing::warn!("dragging photos out failed: {message}");
return Err(glib::Error::new(gio::IOErrorEnum::Failed, &message));
}
Ok(files)
}
/// Put the cached photo `source` at `base/<uid>/<name>`, where a receiver
/// copies it from.
///
/// A hard link when the cache is on the same file system, so a large video is
/// not copied twice; a copy otherwise. Not a symlink: a file manager copies a
/// symlink as a link, which would leave the user a link into the cache.
pub(crate) fn hand_over(
base: &Path,
source: &Path,
uid: &str,
name: &str,
) -> std::io::Result<PathBuf> {
let file_name = Path::new(name)
.file_name()
.ok_or_else(|| std::io::Error::other("the photo has no usable name"))?;
let dir = base.join(uid.replace('/', "_"));
std::fs::create_dir_all(&dir)?;
let dest = dir.join(file_name);
let _ = std::fs::remove_file(&dest);
if std::fs::hard_link(source, &dest).is_err() {
std::fs::copy(source, &dest)?;
}
Ok(dest)
}
/// Remove the copies handed over more than [`KEEP_DRAGGED`] before `now`.
pub(crate) fn prune_dragged(base: &Path, now: SystemTime) {
let Ok(entries) = std::fs::read_dir(base) else {
return;
};
for entry in entries.flatten() {
let old = entry
.metadata()
.and_then(|meta| meta.modified())
.is_ok_and(|modified| {
now.duration_since(modified)
.is_ok_and(|age| age > KEEP_DRAGGED)
});
if old {
let _ = std::fs::remove_dir_all(entry.path());
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn scratch(name: &str) -> PathBuf {
let dir =
std::env::temp_dir().join(format!("pdfs-drag-test-{}-{name}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
#[test]
fn a_dragged_photo_is_handed_over_under_its_own_name() {
let dir = scratch("name");
let source = dir.join("0f3a9c");
std::fs::write(&source, b"jpeg bytes").unwrap();
let base = dir.join("out");
let path = hand_over(&base, &source, "vol~link", "IMG_0001.JPG").unwrap();
assert_eq!(path, base.join("vol~link").join("IMG_0001.JPG"));
assert_eq!(std::fs::read(&path).unwrap(), b"jpeg bytes");
assert!(!path.is_symlink());
// Dragged again, it replaces the copy rather than failing on it.
std::fs::write(&source, b"new bytes").unwrap();
let again = hand_over(&base, &source, "vol~link", "IMG_0001.JPG").unwrap();
assert_eq!(std::fs::read(again).unwrap(), b"new bytes");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_name_cannot_climb_out_of_its_folder() {
let dir = scratch("climb");
let source = dir.join("blob");
std::fs::write(&source, b"x").unwrap();
let base = dir.join("out");
let path = hand_over(&base, &source, "u", "../../escape.jpg").unwrap();
assert_eq!(path, base.join("u").join("escape.jpg"));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn only_old_handovers_are_pruned() {
let dir = scratch("prune");
std::fs::create_dir_all(dir.join("fresh")).unwrap();
prune_dragged(&dir, SystemTime::now());
assert!(dir.join("fresh").exists());
prune_dragged(&dir, SystemTime::now() + KEEP_DRAGGED * 2);
assert!(!dir.join("fresh").exists());
let _ = std::fs::remove_dir_all(&dir);
}
}
+356
View File
@@ -0,0 +1,356 @@
//! Playing videos and music inside the app.
//!
//! The pieces both players share live here: the one My files opens a video or
//! a song in ([`open_media_player`]) and the Photos lightbox. A GTK
//! [`gtk4::Video`] brings play, pause, a seek bar and the volume; this adds
//! fullscreen, the keys every video player answers to, a repeat switch and a
//! volume that carries over from one video to the next.
use crate::activation::{mounted_path, present_within};
use crate::*;
/// How far `J` and `L` (or Shift+←/→) jump.
const SEEK_LONG: i64 = 10;
/// How far ← and → jump in the My files player, where they don't move to
/// another photo.
const SEEK_SHORT: i64 = 5;
/// How much ↑ and ↓ change the volume in the My files player.
const VOLUME_STEP: f64 = 0.1;
/// The edge of a song's cover in the My files player, in logical pixels.
const COVER_SIZE: i32 = 320;
thread_local! {
/// The volume and mute the user last set, applied to the next stream so
/// muting one video doesn't leave the next one blaring. Kept for the run
/// of the app only.
static LEVEL: Cell<Option<(f64, bool)>> = const { Cell::new(None) };
}
/// Where a jump of `delta_secs` from `now` lands, in microseconds, as a
/// [`gtk4::MediaStream`] counts. Kept inside the stream; a `duration` of 0
/// means the stream doesn't know its length yet, which bounds only the start.
pub(crate) fn seek_target(now: i64, duration: i64, delta_secs: i64) -> i64 {
let target = now
.saturating_add(delta_secs.saturating_mul(1_000_000))
.max(0);
if duration > 0 {
target.min(duration)
} else {
target
}
}
/// Jump the stream `delta_secs` forward, or back when negative.
pub(crate) fn seek_by(video: &gtk4::Video, delta_secs: i64) {
if let Some(stream) = video.media_stream()
&& stream.is_seekable()
{
stream.seek(seek_target(
stream.timestamp(),
stream.duration(),
delta_secs,
));
}
}
/// Play a paused stream, pause a playing one.
pub(crate) fn toggle_playing(video: &gtk4::Video) {
if let Some(stream) = video.media_stream() {
stream.set_playing(!stream.is_playing());
}
}
fn toggle_muted(video: &gtk4::Video) {
if let Some(stream) = video.media_stream() {
stream.set_muted(!stream.is_muted());
}
}
fn change_volume(video: &gtk4::Video, delta: f64) {
if let Some(stream) = video.media_stream() {
stream.set_muted(false);
stream.set_volume((stream.volume() + delta).clamp(0.0, 1.0));
}
}
/// Enter fullscreen, or leave it.
pub(crate) fn toggle_fullscreen(window: &gtk4::Window) {
if window.is_fullscreen() {
window.unfullscreen();
} else {
window.fullscreen();
}
}
/// The keys both players answer to the same way: `K` plays and pauses, `J` and
/// `L` (or Shift+← and Shift+→) jump ten seconds, `M` mutes. True when `key`
/// was one of them.
pub(crate) fn player_key(video: &gtk4::Video, key: &str, state: gtk4::gdk::ModifierType) -> bool {
let shift = state.contains(gtk4::gdk::ModifierType::SHIFT_MASK);
let plain = !state
.intersects(gtk4::gdk::ModifierType::CONTROL_MASK | gtk4::gdk::ModifierType::ALT_MASK);
if !plain {
return false;
}
match key {
"k" | "K" => toggle_playing(video),
"j" | "J" => seek_by(video, -SEEK_LONG),
"l" | "L" => seek_by(video, SEEK_LONG),
"Left" if shift => seek_by(video, -SEEK_LONG),
"Right" if shift => seek_by(video, SEEK_LONG),
"m" | "M" => toggle_muted(video),
_ => return false,
}
true
}
/// Make `video` carry the volume over between streams and toggle `window`'s
/// fullscreen on a double-click.
pub(crate) fn wire_player(video: &gtk4::Video, window: &gtk4::Window) {
video.connect_media_stream_notify(|video| {
let Some(stream) = video.media_stream() else {
return;
};
if let Some((volume, muted)) = LEVEL.get() {
stream.set_volume(volume);
stream.set_muted(muted);
}
let remember = |stream: &gtk4::MediaStream| {
LEVEL.set(Some((stream.volume(), stream.is_muted())));
};
stream.connect_volume_notify(remember);
stream.connect_muted_notify(remember);
});
// The controls' own buttons and seek bar claim their clicks, so this only
// sees a double-click on the picture.
let click = gtk4::GestureClick::new();
let window = window.downgrade();
click.connect_pressed(move |_, n_press, _, _| {
if n_press == 2
&& let Some(window) = window.upgrade()
{
toggle_fullscreen(&window);
}
});
video.add_controller(click);
}
/// A button that enters and leaves `window`'s fullscreen, showing which one
/// it will do.
pub(crate) fn fullscreen_button(window: &gtk4::Window) -> gtk4::Button {
let button = gtk4::Button::builder().valign(gtk4::Align::Center).build();
let paint = |button: &gtk4::Button, fullscreen: bool| {
if fullscreen {
button.set_icon_name("view-restore-symbolic");
button.set_tooltip_text(Some(&gettext("Leave Fullscreen (F)")));
} else {
button.set_icon_name("view-fullscreen-symbolic");
button.set_tooltip_text(Some(&gettext("Fullscreen (F)")));
}
};
paint(&button, window.is_fullscreen());
let weak = button.downgrade();
window.connect_fullscreened_notify(move |window| {
if let Some(button) = weak.upgrade() {
paint(&button, window.is_fullscreen());
}
});
let target = window.downgrade();
button.connect_clicked(move |_| {
if let Some(window) = target.upgrade() {
toggle_fullscreen(&window);
}
});
button
}
/// Play a video or a song from My files in a window of its own, streamed from
/// the mount: the player reads the blocks it needs as it plays and seeks, so a
/// long video starts in seconds instead of after a full download. A file the
/// mount doesn't show, or the service is down, opens in the default
/// application instead, after a download.
pub(crate) fn open_media_player(ui: &Rc<Ui>, entry: &DirEntry) {
let rel = entry_rel(ui, entry);
let mountpoint = ui.dirs.resolved_mountpoint(&ui.dirs.load_config());
let (ui, entry) = (ui.clone(), entry.clone());
glib::spawn_future_local(async move {
match present_within(mounted_path(&mountpoint, &rel)).await {
Some(path) => build_media_player(&ui, &entry, &path),
None => download_and_open(&ui, &entry),
}
});
}
fn build_media_player(ui: &Rc<Ui>, entry: &DirEntry, path: &Path) {
let window = adw::Window::builder()
.title(&entry.name)
.default_width(960)
.default_height(600)
.build();
if let Some(parent) = ui_window(ui) {
window.set_transient_for(Some(&parent));
}
window.add_css_class("media-player-window");
let gtk_window: gtk4::Window = window.clone().upcast();
let video = gtk4::Video::builder()
.autoplay(true)
.hexpand(true)
.vexpand(true)
.build();
wire_player(&video, &gtk_window);
// A song has no picture, which would leave a black window above the
// controls: its cover stands in for it, the one its listing tile shows,
// and a note while there is none.
let note = file_thumbnail_widget(COVER_SIZE, 128);
note.set_can_target(false);
note.set_visible(false);
note.add_css_class("media-player-note");
if let Some(cover) = note
.child()
.and_then(|fallback| fallback.next_sibling())
.and_downcast::<gtk4::Picture>()
{
// The whole cover, not a square cut out of it.
cover.set_content_fit(gtk4::ContentFit::Contain);
}
bind_file_thumbnail(ui, &note, entry, true);
let overlay = gtk4::Overlay::new();
overlay.set_child(Some(&video));
overlay.add_overlay(&note);
let failed = adw::StatusPage::builder()
.icon_name("dialog-warning-symbolic")
.title(gettext("Couldn't play this file"))
.build();
let open_with = gtk4::Button::builder()
.label(gettext("Open With…"))
.halign(gtk4::Align::Center)
.build();
open_with.add_css_class("pill");
open_with.add_css_class("suggested-action");
failed.set_child(Some(&open_with));
let stack = gtk4::Stack::new();
stack.add_named(&overlay, Some("player"));
stack.add_named(&failed, Some("failed"));
let header = adw::HeaderBar::new();
header.pack_end(&fullscreen_button(&gtk_window));
let mut menu = ActionMenu::new();
let (ui_c, entry_c) = (ui.clone(), entry.clone());
menu.item(&gettext("Open With…"), move || {
open_entry_with(&ui_c, &entry_c)
});
let video_c = video.clone();
// Translators: menu item of the video player that plays the file again
// and again.
menu.toggle(&gettext("Repeat"), false, move |on| video_c.set_loop(on));
header.pack_end(&menu.button());
let toolbar = adw::ToolbarView::new();
toolbar.add_top_bar(&header);
toolbar.set_content(Some(&stack));
// Fullscreen is the video alone, its own controls still at hand.
window
.bind_property("fullscreened", &toolbar, "reveal-top-bars")
.invert_boolean()
.sync_create()
.build();
window.set_content(Some(&toolbar));
let (ui_c, entry_c) = (ui.clone(), entry.clone());
open_with.connect_clicked(move |_| open_entry_with(&ui_c, &entry_c));
let (stack_c, failed_c, note_c) = (stack.clone(), failed.clone(), note.clone());
video.connect_media_stream_notify(move |video| {
let Some(stream) = video.media_stream() else {
return;
};
let (stack, failed) = (stack_c.clone(), failed_c.clone());
stream.connect_error_notify(move |stream| {
if let Some(error) = stream.error() {
tracing::warn!("in-app player failed: {error}");
failed.set_description(Some(&error.to_string()));
stack.set_visible_child_name("failed");
}
});
let note = note_c.clone();
stream.connect_prepared_notify(move |stream| {
note.set_visible(stream.is_prepared() && stream.has_audio() && !stream.has_video());
});
});
video.set_filename(Some(path));
let keys = gtk4::EventControllerKey::new();
let (video_k, window_k) = (video.clone(), gtk_window.downgrade());
keys.connect_key_pressed(move |_, key, _code, state| {
let Some(window) = window_k.upgrade() else {
return glib::Propagation::Proceed;
};
let Some(name) = key.name() else {
return glib::Propagation::Proceed;
};
// The open menu keeps its arrows and Enter.
let in_menu = gtk4::prelude::GtkWindowExt::focus(&window)
.is_some_and(|focus| focus.ancestor(gtk4::Popover::static_type()).is_some());
if in_menu {
return glib::Propagation::Proceed;
}
if player_key(&video_k, &name, state) {
return glib::Propagation::Stop;
}
let ctrl = state.contains(gtk4::gdk::ModifierType::CONTROL_MASK);
match name.as_str() {
"space" => toggle_playing(&video_k),
"Left" => seek_by(&video_k, -SEEK_SHORT),
"Right" => seek_by(&video_k, SEEK_SHORT),
"Up" => change_volume(&video_k, VOLUME_STEP),
"Down" => change_volume(&video_k, -VOLUME_STEP),
"f" | "F11" => toggle_fullscreen(&window),
// Escape leaves fullscreen before it closes anything.
"Escape" if window.is_fullscreen() => window.unfullscreen(),
"Escape" | "q" => window.close(),
"w" if ctrl => window.close(),
_ => return glib::Propagation::Proceed,
}
glib::Propagation::Stop
});
// Capture, so the arrows and Space reach the player rather than moving the
// focus between its controls.
keys.set_propagation_phase(gtk4::PropagationPhase::Capture);
window.add_controller(keys);
// Stop the sound with the window, not when the window is finally freed.
let video_c = video.clone();
window.connect_close_request(move |_| {
video_c.set_media_stream(gtk4::MediaStream::NONE);
glib::Propagation::Proceed
});
window.present();
}
#[cfg(test)]
mod tests {
use super::*;
const SEC: i64 = 1_000_000;
#[test]
fn a_jump_stays_inside_the_video() {
assert_eq!(seek_target(30 * SEC, 60 * SEC, 10), 40 * SEC);
assert_eq!(seek_target(30 * SEC, 60 * SEC, -10), 20 * SEC);
assert_eq!(seek_target(5 * SEC, 60 * SEC, -10), 0);
assert_eq!(seek_target(55 * SEC, 60 * SEC, 10), 60 * SEC);
}
#[test]
fn a_jump_forward_in_a_stream_of_unknown_length_is_not_held_back() {
assert_eq!(seek_target(30 * SEC, 0, 10), 40 * SEC);
}
}
@@ -334,6 +334,13 @@ pub(crate) struct ShareDialog {
/// Open the per-node Share dialog: invite Proton/external users, manage who has /// Open the per-node Share dialog: invite Proton/external users, manage who has
/// access and their roles, and create/copy/remove a public link. /// access and their roles, and create/copy/remove a public link.
pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) { pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
open_share_dialog_over(ui, entry, None);
}
/// [`open_share_dialog`] over `parent` rather than the main window. The photo
/// viewer is a window of its own, and a dialog on the main window would open
/// behind it.
pub(crate) fn open_share_dialog_over(ui: &Rc<Ui>, entry: &DirEntry, parent: Option<gtk4::Window>) {
if !*ui.mounted.borrow() { if !*ui.mounted.borrow() {
toast_error( toast_error(
ui, ui,
@@ -491,7 +498,7 @@ pub(crate) fn open_share_dialog(ui: &Rc<Ui>, entry: &DirEntry) {
} }
}); });
share_dialog_reload(&state); share_dialog_reload(&state);
dialog.present(ui_window(ui).as_ref()); dialog.present(parent.or_else(|| ui_window(ui)).as_ref());
} }
/// Re-fetch the node's share and rebuild the people + public-link sections. /// Re-fetch the node's share and rebuild the people + public-link sections.
+114 -6
View File
@@ -11,6 +11,7 @@ use pdfs_core::control::{FileThumbRequest, is_thumbnail_media_name, is_video_fil
const THUMB_BATCH: usize = 32; const THUMB_BATCH: usize = 32;
const THUMB_CACHE_MAX: usize = 256; const THUMB_CACHE_MAX: usize = 256;
const THUMB_MISSING_MAX: usize = 2048; const THUMB_MISSING_MAX: usize = 2048;
const THUMB_BLANK_MAX: usize = 1024;
const THUMB_DEBOUNCE: Duration = Duration::from_millis(40); const THUMB_DEBOUNCE: Duration = Duration::from_millis(40);
const THUMB_RETRY: Duration = Duration::from_secs(2); const THUMB_RETRY: Duration = Duration::from_secs(2);
@@ -20,6 +21,9 @@ pub(crate) struct FileThumbnailState {
missing: RefCell<HashSet<String>>, missing: RefCell<HashSet<String>>,
missing_order: RefCell<VecDeque<String>>, missing_order: RefCell<VecDeque<String>>,
wanted: RefCell<HashMap<String, Vec<gtk4::Picture>>>, wanted: RefCell<HashMap<String, Vec<gtk4::Picture>>>,
/// Tiles on screen still showing their icon, by key, kept across a
/// cancelled request so [`refresh_file_thumbnails`] can ask for them again.
blank: RefCell<HashMap<String, BlankTile>>,
queue: RefCell<VecDeque<FileThumbRequest>>, queue: RefCell<VecDeque<FileThumbRequest>>,
inflight: Cell<bool>, inflight: Cell<bool>,
source: RefCell<Option<glib::SourceId>>, source: RefCell<Option<glib::SourceId>>,
@@ -27,6 +31,18 @@ pub(crate) struct FileThumbnailState {
generation_loading: Cell<bool>, generation_loading: Cell<bool>,
} }
/// What a tile left blank needs to be asked for again.
struct BlankTile {
request: FileThumbRequest,
pictures: Vec<glib::WeakRef<gtk4::Picture>>,
}
/// Whether a picture registered as blank under `key` still is: bound to that
/// key, not painted, and in a window rather than in a list's spare pool.
fn tile_still_blank(key: &str, bound: &str, painted: bool, attached: bool) -> bool {
bound == key && !painted && attached
}
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq)]
enum ReplyDisposition { enum ReplyDisposition {
Ignore, Ignore,
@@ -55,6 +71,7 @@ impl FileThumbnailState {
missing: RefCell::new(HashSet::new()), missing: RefCell::new(HashSet::new()),
missing_order: RefCell::new(VecDeque::new()), missing_order: RefCell::new(VecDeque::new()),
wanted: RefCell::new(HashMap::new()), wanted: RefCell::new(HashMap::new()),
blank: RefCell::new(HashMap::new()),
queue: RefCell::new(VecDeque::new()), queue: RefCell::new(VecDeque::new()),
inflight: Cell::new(false), inflight: Cell::new(false),
source: RefCell::new(None), source: RefCell::new(None),
@@ -88,6 +105,85 @@ impl FileThumbnailState {
} }
} }
} }
fn remember_blank(&self, key: &str, request: &FileThumbRequest, picture: &gtk4::Picture) {
let mut blank = self.blank.borrow_mut();
if blank.len() >= THUMB_BLANK_MAX {
prune_blank(&mut blank);
}
let tile = blank.entry(key.to_string()).or_insert_with(|| BlankTile {
request: request.clone(),
pictures: Vec::new(),
});
if !tile
.pictures
.iter()
.any(|weak| weak.upgrade().as_ref() == Some(picture))
{
tile.pictures.push(picture.downgrade());
}
}
}
/// Drop the tiles that were painted, rebound to another file, or freed.
fn prune_blank(blank: &mut HashMap<String, BlankTile>) {
blank.retain(|key, tile| {
tile.pictures.retain(|weak| {
weak.upgrade().is_some_and(|picture| {
tile_still_blank(
key,
&picture.widget_name(),
picture.is_visible(),
picture.root().is_some(),
)
})
});
!tile.pictures.is_empty()
});
}
/// Ask again for every tile on screen still showing its icon. Sent when the
/// daemon says thumbnails landed, so a folder fills in while a build runs in
/// it, or after its own requests were cancelled, without being opened again.
pub(crate) fn refresh_file_thumbnails(ui: &Rc<Ui>) {
let tiles: Vec<(String, FileThumbRequest, Vec<gtk4::Picture>)> = {
let mut blank = ui.file_thumbs.blank.borrow_mut();
prune_blank(&mut blank);
blank
.iter()
.map(|(key, tile)| {
let pictures = tile.pictures.iter().filter_map(|w| w.upgrade()).collect();
(key.clone(), tile.request.clone(), pictures)
})
.collect()
};
if tiles.is_empty() {
return;
}
for (key, request, pictures) in tiles {
let cached = ui.file_thumbs.textures.borrow().get(&key).cloned();
if let Some(texture) = cached {
for picture in &pictures {
paint(picture, &key, &texture);
}
ui.file_thumbs.blank.borrow_mut().remove(&key);
continue;
}
// A miss from before the thumbnail landed is no verdict any more.
ui.file_thumbs.missing.borrow_mut().remove(&key);
let mut wanted = ui.file_thumbs.wanted.borrow_mut();
let waiters = wanted.entry(key).or_default();
for picture in pictures {
if !waiters.contains(&picture) {
waiters.push(picture);
}
}
drop(wanted);
let mut queue = ui.file_thumbs.queue.borrow_mut();
queue.retain(|item| item.uid != request.uid);
queue.push_back(request);
}
schedule_file_thumbs(ui);
} }
/// Abandon every opportunistic ordinary-file thumbnail associated with the /// Abandon every opportunistic ordinary-file thumbnail associated with the
@@ -230,6 +326,12 @@ pub(crate) fn bind_file_thumbnail(
paint(&picture, &key, texture); paint(&picture, &key, texture);
return; return;
} }
let request = FileThumbRequest {
uid: entry.uid.clone(),
modified: entry.modified,
name: entry.name.clone(),
};
ui.file_thumbs.remember_blank(&key, &request, &picture);
if ui.file_thumbs.missing.borrow().contains(&key) { if ui.file_thumbs.missing.borrow().contains(&key) {
return; return;
} }
@@ -242,11 +344,7 @@ pub(crate) fn bind_file_thumbnail(
.push(picture); .push(picture);
let mut queue = ui.file_thumbs.queue.borrow_mut(); let mut queue = ui.file_thumbs.queue.borrow_mut();
queue.retain(|item| item.uid != entry.uid); queue.retain(|item| item.uid != entry.uid);
queue.push_back(FileThumbRequest { queue.push_back(request);
uid: entry.uid.clone(),
modified: entry.modified,
name: entry.name.clone(),
});
drop(queue); drop(queue);
schedule_file_thumbs(ui); schedule_file_thumbs(ui);
} }
@@ -387,6 +485,7 @@ fn flush_file_thumbs(ui: &Rc<Ui>) {
match gtk4::gdk::Texture::from_filename(&path) { match gtk4::gdk::Texture::from_filename(&path) {
Ok(texture) => { Ok(texture) => {
ui.file_thumbs.store_texture(&key, texture.clone()); ui.file_thumbs.store_texture(&key, texture.clone());
ui.file_thumbs.blank.borrow_mut().remove(&key);
if let Some(pictures) = if let Some(pictures) =
ui.file_thumbs.wanted.borrow_mut().remove(&key) ui.file_thumbs.wanted.borrow_mut().remove(&key)
{ {
@@ -447,7 +546,16 @@ fn retry_file_thumbs(ui: &Rc<Ui>, items: Vec<FileThumbRequest>) {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{ReplyDisposition, reply_disposition}; use super::{ReplyDisposition, reply_disposition, tile_still_blank};
#[test]
fn only_a_tile_still_showing_its_icon_is_asked_for_again() {
assert!(tile_still_blank("a:1", "a:1", false, true));
assert!(!tile_still_blank("a:1", "a:1", true, true), "painted");
assert!(!tile_still_blank("a:1", "b:1", false, true), "rebound");
assert!(!tile_still_blank("a:1", "a:2", false, true), "file changed");
assert!(!tile_still_blank("a:1", "a:1", false, false), "spare row");
}
fn is_image_name(name: &str) -> bool { fn is_image_name(name: &str) -> bool {
pdfs_core::control::is_thumbnail_image_name(name) pdfs_core::control::is_thumbnail_image_name(name)
+59 -8
View File
@@ -13,6 +13,7 @@
use gettextrs::LocaleCategory; use gettextrs::LocaleCategory;
use pdfs_core::config::AppDirs; use pdfs_core::config::AppDirs;
use std::path::{Path, PathBuf};
/// The gettext text domain, matching `po/pdfs.pot` and the installed `.mo` name. /// The gettext text domain, matching `po/pdfs.pot` and the installed `.mo` name.
pub(crate) const DOMAIN: &str = "pdfs"; pub(crate) const DOMAIN: &str = "pdfs";
@@ -53,14 +54,11 @@ pub(crate) fn init() {
if let Some(code) = language { if let Some(code) = language {
apply_language(&code); apply_language(&code);
} }
let dir = std::env::var(LOCALEDIR_ENV) let dir = locale_dir(
.ok() std::env::var(LOCALEDIR_ENV).ok(),
.filter(|dir| !dir.is_empty()) option_env!("PDFS_LOCALEDIR"),
.unwrap_or_else(|| { std::env::current_exe().ok(),
option_env!("PDFS_LOCALEDIR") );
.unwrap_or(DEFAULT_LOCALEDIR)
.to_string()
});
if let Err(e) = gettextrs::bindtextdomain(DOMAIN, dir) { if let Err(e) = gettextrs::bindtextdomain(DOMAIN, dir) {
tracing::warn!("bindtextdomain failed: {e}"); tracing::warn!("bindtextdomain failed: {e}");
} }
@@ -73,6 +71,33 @@ pub(crate) fn init() {
} }
} }
/// Where the catalogs are: `$PDFS_LOCALEDIR`, then the directory the build
/// named, then `share/locale` beside the `bin` directory the program runs
/// from when that holds a catalog of ours, then [`DEFAULT_LOCALEDIR`].
///
/// The third is for an install outside `/usr`, such as the release tarball's
/// `install.sh` into `~/.local`: its programs find their translations without
/// a wrapper setting the variable.
fn locale_dir(env: Option<String>, build: Option<&str>, exe: Option<PathBuf>) -> PathBuf {
if let Some(dir) = env.filter(|dir| !dir.is_empty()) {
return PathBuf::from(dir);
}
if let Some(dir) = build {
return PathBuf::from(dir);
}
let beside = exe
.as_deref()
.and_then(Path::parent)
.and_then(Path::parent)
.map(|prefix| prefix.join("share/locale"))
.filter(|dir| {
LANGUAGES
.iter()
.any(|(code, _)| dir.join(code).join("LC_MESSAGES/pdfs.mo").is_file())
});
beside.unwrap_or_else(|| PathBuf::from(DEFAULT_LOCALEDIR))
}
/// The iso-codes text domain that translates ISO 3166-1 country names. /// The iso-codes text domain that translates ISO 3166-1 country names.
const ISO_3166_DOMAIN: &str = "iso_3166-1"; const ISO_3166_DOMAIN: &str = "iso_3166-1";
@@ -234,6 +259,32 @@ fn fill(template: &str, args: &[(&str, &str)]) -> String {
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn the_catalogs_are_found_beside_an_install_outside_usr() {
let prefix = std::env::temp_dir().join(format!("pdfs-locale-{}", std::process::id()));
let mo = prefix.join("share/locale/de/LC_MESSAGES/pdfs.mo");
std::fs::create_dir_all(mo.parent().unwrap()).unwrap();
std::fs::write(&mo, b"").unwrap();
let exe = Some(prefix.join("bin/pdfs-app"));
assert_eq!(
locale_dir(None, None, exe.clone()),
prefix.join("share/locale")
);
// The variable and the build's own choice still win.
assert_eq!(
locale_dir(Some("/x".into()), Some("/y"), exe.clone()),
PathBuf::from("/x")
);
assert_eq!(locale_dir(None, Some("/y"), exe), PathBuf::from("/y"));
// A prefix without our catalogs falls back to the system's.
assert_eq!(
locale_dir(None, None, Some(PathBuf::from("/nonexistent/bin/pdfs-app"))),
PathBuf::from(DEFAULT_LOCALEDIR)
);
let _ = std::fs::remove_dir_all(&prefix);
}
#[test] #[test]
fn fill_replaces_named_placeholders_in_any_order() { fn fill_replaces_named_placeholders_in_any_order() {
assert_eq!( assert_eq!(
+24 -6
View File
@@ -398,12 +398,10 @@ fn open_manager(args: &[&str]) {
/// Remember that the user hid the icon, so the next login's autostart and the /// Remember that the user hid the icon, so the next login's autostart and the
/// app both leave it away, then exit. /// app both leave it away, then exit.
fn hide_tray() { fn hide_tray() {
if let Ok(dirs) = AppDirs::new() { if let Ok(dirs) = AppDirs::new()
let mut config = dirs.load_config(); && let Err(e) = dirs.update_config(|config| config.tray_hidden = true)
config.tray_hidden = true; {
if let Err(e) = dirs.save_config(&config) { tracing::warn!("hide tray icon: {e}");
tracing::warn!("hide tray icon: {e}");
}
} }
std::process::exit(0); std::process::exit(0);
} }
@@ -421,6 +419,10 @@ impl Tray for DriveTray {
self.state.phase.icon().into() self.state.phase.icon().into()
} }
fn attention_icon_name(&self) -> String {
self.icon_name()
}
fn status(&self) -> Status { fn status(&self) -> Status {
match self.state.phase { match self.state.phase {
Phase::Attention | Phase::SessionExpired => Status::NeedsAttention, Phase::Attention | Phase::SessionExpired => Status::NeedsAttention,
@@ -674,6 +676,22 @@ mod tests {
assert_eq!(phase_of(false, 0, true, false), Phase::Synced); assert_eq!(phase_of(false, 0, true, false), Phase::Synced);
} }
#[test]
fn attention_states_supply_the_icon_the_tray_requests() {
let mut tray = DriveTray {
state: status_state(&status(""), &[], &[], Path::new("/m")),
socket: PathBuf::new(),
};
for (phase, icon) in [
(Phase::Attention, "dialog-warning-symbolic"),
(Phase::SessionExpired, "dialog-password-symbolic"),
] {
tray.state.phase = phase;
assert_eq!(tray.status(), Status::NeedsAttention);
assert_eq!(tray.attention_icon_name(), icon);
}
}
fn status(extra: &str) -> Response { fn status(extra: &str) -> Response {
status_from(env!("CARGO_PKG_VERSION"), extra) status_from(env!("CARGO_PKG_VERSION"), extra)
} }
+5
View File
@@ -24,6 +24,9 @@ const STOCK: &[&str] = &[
// GTK's built-in icons // GTK's built-in icons
"info-outline-symbolic", "info-outline-symbolic",
// Adwaita // Adwaita
"application-x-executable-symbolic",
"audio-x-generic-symbolic",
"changes-prevent-symbolic",
"checkbox-checked-symbolic", "checkbox-checked-symbolic",
"checkbox-symbolic", "checkbox-symbolic",
"computer-symbolic", "computer-symbolic",
@@ -68,12 +71,14 @@ const STOCK: &[&str] = &[
"text-x-generic-symbolic", "text-x-generic-symbolic",
"user-trash-symbolic", "user-trash-symbolic",
"video-x-generic-symbolic", "video-x-generic-symbolic",
"view-fullscreen-symbolic",
"view-grid-symbolic", "view-grid-symbolic",
"view-list-symbolic", "view-list-symbolic",
"view-more-symbolic", "view-more-symbolic",
"view-paged-symbolic", "view-paged-symbolic",
"view-pin-symbolic", "view-pin-symbolic",
"view-refresh-symbolic", "view-refresh-symbolic",
"view-restore-symbolic",
"window-close-symbolic", "window-close-symbolic",
"zoom-fit-best-symbolic", "zoom-fit-best-symbolic",
"zoom-in-symbolic", "zoom-in-symbolic",
+292 -1
View File
@@ -109,6 +109,13 @@ a live account since.
| Entry | Title | | Entry | Title |
|---|---| |---|---|
| [B291](#b291--on-fedora-45s-oo7-every-saved-sign-in-is-lost-at-the-next-reboot) | On Fedora 45's oo7, every saved sign-in is lost at the next reboot |
| [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos |
| [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it |
| [B287](#b287--a-photo-draft-left-by-an-interrupted-upload-blocks-that-name) | A photo draft left by an interrupted upload blocks that name |
| [B286](#b286--resuming-a-takeout-import-fails-on-a-draft-with-no-content-hash) | Resuming a Takeout import fails on a draft with no content hash |
| [B285](#b285--a-restarted-secret-service-leaves-the-process-on-a-dead-session) | A restarted Secret Service leaves the process on a dead session |
| [B284](#b284--a-keyring-entry-reported-missing-discards-refreshed-session-tokens) | A keyring entry reported missing discards refreshed session tokens |
| [B283](#b283--videos-have-no-thumbnail-outside-photos-and-a-ts-recording-looks-like-source-code) | Videos have no thumbnail outside Photos, and a `.ts` recording looks like source code | | [B283](#b283--videos-have-no-thumbnail-outside-photos-and-a-ts-recording-looks-like-source-code) | Videos have no thumbnail outside Photos, and a `.ts` recording looks like source code |
| [B282](#b282--a-file-kept-offline-is-downloaded-again-after-a-change-made-elsewhere) | A file kept offline is downloaded again after a change made elsewhere | | [B282](#b282--a-file-kept-offline-is-downloaded-again-after-a-change-made-elsewhere) | A file kept offline is downloaded again after a change made elsewhere |
| [B281](#b281--a-file-in-a-synced-folder-cannot-be-kept-offline) | A file in a synced folder cannot be kept offline | | [B281](#b281--a-file-in-a-synced-folder-cannot-be-kept-offline) | A file in a synced folder cannot be kept offline |
@@ -299,6 +306,8 @@ a live account since.
| Entry | Title | | Entry | Title |
|---|---| |---|---|
| [B292](#b292--two-programs-changing-settings-at-once-lose-one-of-the-changes) | Two programs changing settings at once lose one of the changes |
| [B290](#b290--reopening-the-database-right-after-closing-it-can-be-refused-as-another-daemon) | Reopening the database right after closing it can be refused as another daemon |
| [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for | | [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for |
| [B258](#b258--journalctl--p-warning-shows-nothing-whatever-the-daemon-logged) | `journalctl -p warning` shows nothing, whatever the daemon logged | | [B258](#b258--journalctl--p-warning-shows-nothing-whatever-the-daemon-logged) | `journalctl -p warning` shows nothing, whatever the daemon logged |
| [B256](#b256--pdfs-copy-right-after-a-save-copies-the-old-version) | `pdfs copy` right after a save copies the old version | | [B256](#b256--pdfs-copy-right-after-a-save-copies-the-old-version) | `pdfs copy` right after a save copies the old version |
@@ -386,6 +395,283 @@ a live account since.
Newest first. Newest first.
### B292 — Two programs changing settings at once lose one of the changes
**Status:** Fixed
**Found:** 2026-11-15, reading every writer of `config.json` while adding settings to Preferences.
**Where:** `crates/pdfs-core/src/config.rs`, `AppDirs::save_config` and its callers in the app,
the tray and the daemon
**Repro:** Change the cache size in Preferences (the daemon writes `cache_budget`) while the app
saves the window size or the tray hides itself. Both read the file before either wrote it, and
the one that wrote last puts the other setting back. Not seen in the field; the window is a few
milliseconds, but more settings in the app make it more likely.
**Cause:** Every writer loaded the file, changed one field and wrote the whole file back, with
nothing ordering them. The atomic rename kept the file whole, not the changes.
**Fix:** `AppDirs::update_config` reads, changes and writes under an `flock` on
`config.json.lock`, and every writer goes through it. It refuses an unreadable file before
applying the change (B223). A lock held longer than 5 seconds is reported as an error instead of
waited on.
**Verified:** `cargo test -p pdfs-core config::tests` on 2026-11-15,
`concurrent_changes_to_different_settings_are_all_kept` and
`a_change_is_never_applied_over_an_unreadable_config`.
---
### B291 — On Fedora 45's oo7, every saved sign-in is lost at the next reboot
**Status:** Fixed, not verified live
**Found:** 2026-11-15, from the reporter's package list in
[issue #78](https://github.com/narrrl/proton-drive-linux/issues/78): `oo7-daemon-0.7.0~beta^1.e91b98a`,
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`
**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
store writes an existing item with `SetSecret`, and that oo7 build applies `SetSecret` only to the
item in memory; the keyring file keeps what `CreateItem` wrote. Within a boot every read returns
the new tokens, so nothing looks wrong. After a reboot the daemon resumes with the refresh token
of the last `pdfs login`, which Proton spent long ago: `InvalidRefreshToken`, and the user has to
sign in again. Typing the password at login, or the fixes for B284 and B285, change nothing.
**Cause:** A bug in that oo7 build, fixed in oo7 0.7.0 but not packaged by Fedora. Every token
refresh pdfs saved went through the one call it does not persist.
**Fix:** An existing entry is saved by `CreateItem` with `replace`, which that build writes to the
file: a new item in the old one's collection, with its label and all its attributes, so the
provider replaces the old one. A duplicate that a provider leaves behind is removed; if it cannot
be, the new item is taken out again and the save falls back to the usual `SetSecret`. The first
save, a locked item, two matching items, or any failure before the new item exists also fall back
to it. The connection used for this never shows a prompt. The daemon log now has a short
fingerprint of the refresh token at each start and each save, so a log across a reboot shows
whether the keyring returned the last token saved.
**Verified:** 2026-11-15, `real_secret_service_keeps_the_last_save_across_a_provider_restart`
(ignored; needs a throwaway Secret Service) against oo7-daemon built at e91b98a: with the
in-place write it reads `r1` after the restart, with this change `r3` and one item. The same test
and `real_secret_service_survives_a_provider_restart` pass against gnome-keyring. Not yet run on
a Fedora 45 desktop with a real account.
---
### B290 — Reopening the database right after closing it can be refused as another daemon
**Status:** Fixed, 2026-11-15
**Found:** 2026-11-15, CI on `chore/release-3.8.0` (fd6b2d3):
`db::tests::what_a_create_sent_outlives_a_newer_blob_its_trash_and_a_restart` failed once with
"another Proton Drive daemon is already using /tmp/pdfs-create-sent-….db". It passes on its own.
**Where:** `crates/pdfs-core/src/db/mod.rs`, `acquire_single_writer_lock`
**Repro:** In one process, drop a `Db` and open the same file again while another thread spawns a
child process. Rare; seen once in about 500 tests that run in parallel, several of which spawn
processes.
**Cause:** The single-writer lock is a `flock` on `<db>.lock`, and a `flock` belongs to the open
file, not to one descriptor. A child holds a copy of every descriptor from its fork until its exec
closes the `O_CLOEXEC` ones. A lock dropped by the parent in that moment stays held by the child,
and an immediate reopen gets `EWOULDBLOCK`, which reads as a second daemon.
**Fix:** A refused lock is retried every 20 ms for up to 500 ms before it counts as another
daemon. That covers any fork-to-exec window. A real second daemon is still refused, half a
second later.
**Verified:** `cargo test -p pdfs-core` on 2026-11-15, including
`a_second_writer_is_refused_while_the_first_holds_the_database`.
---
### B289 — The Takeout import mixes in other services and drops location and live photos
**Status:** Fixed, not verified live
**Found:** 2026-11-15, auditing the Google Photos import alongside
[issue #94](https://github.com/narrrl/proton-drive-linux/issues/94).
**Where:** `crates/pdfs-core/src/takeout.rs`; `plan` and `upload_takeout_photo` in
`crates/pdfs-fuse/src/takeout.rs`
**Repro:** Import a Takeout export that also holds `Drive/` or `YouTube/`, with Pixel motion
photos, iPhone live photos and photos that have a place in Google Photos.
**Cause.** Five gaps in what the import carried over:
- The service folder was dropped without being checked, so media from other Google services in
the same export landed in the photo timeline.
- `geoData` was never read, although `docs/PHOTOS.md` said the import takes locations from the
export, and the SDK had no way to upload a location.
- The two halves of a live or motion photo uploaded as unrelated photos, the `.MOV` half usually
without a date, and the `.MP` half of a Pixel motion photo was skipped as unknown.
- `creationTime`, the day the photo reached Google, outranked the date in the file name and the
photo's own EXIF.
- A sidecar with `null` in `favorited`, a numeric `timestamp` or a `0` timestamp lost its other
fields or filed the photo under 1970.
**Fix:** The Photos service is the folder whose sidecars carry `photoTakenTime`, and only it is
imported (everything, when no folder does). `geoData`, else `geoDataExif`, becomes the photo's
`Location` attribute through SDK 0.12.0's `PhotoUploadMetadata::location`; `0, 0` is no position.
Stills and videos with the same stem in one folder (`IMG_1.HEIC` + `IMG_1.MOV`,
`PXL_1.MP.jpg` + `PXL_1.MP`) are paired unless their dates are minutes apart: the still is
tagged as a live or motion photo, the video is uploaded after it with `main_photo_uid` and takes
its date and place. The capture time is `photoTakenTime`, then the name, then EXIF, then
`creationTime`. Favorites are also set on photos that were already on the account.
**Verified:** `takeout::tests` in `pdfs-core` (services, locations, timestamps, live keys) and
`pdfs-fuse` (pairing, skew, folded copies). Not run against a real export and account.
---
### B288 — An interrupted Takeout import reads as finished, and one error ends it
**Status:** Fixed, not verified live
**Found:** 2026-11-15, auditing the Google Photos import alongside
[issue #94](https://github.com/narrrl/proton-drive-linux/issues/94).
**Where:** `crates/pdfs-fuse/src/takeout.rs`; `refresh_takeout` in
`crates/pdfs-gui/src/app/pages/takeout.rs`; `cmd_import_google_photos` in
`crates/pdfs-cli/src/main.rs`
**Repro:** Start an import of several archives, one of them damaged, and restart the service
while it uploads.
**Cause.**
- The import state lived only in memory. After a restart `ImportStatus` had no summary, and the
app announced "Import finished". The archives had to be chosen again to continue.
- A daemon shutdown broke the upload loop but still filed albums and logged a success.
- One unreadable archive failed the scan, and a failed request in the middle of the run
discarded every count and skipped the albums for what had uploaded.
- The progress total counted photos already on the account, so the bar stopped short of the
end; a dry run reported "Would upload: 0"; the job's phases reached the app in English.
**Fix:** The last run's archives and summary are kept in `takeout-import.json` in the state
directory. A run still marked running at start-up is `interrupted`, and `ImportStatus` lists
its archives as `resumable`; `ResumeImport` (`pdfs import-google-photos --resume`, **Resume** in
the app) starts it again, and the duplicate check skips what is there. An unreadable archive is
listed in `unreadable_archives` and the rest imports. A failure keeps the counts and still files
albums. `ImportStatus` carries the phase and its own progress, the summary says `dry_run`,
`to_upload` and `error_kind`, and the app words them in the user's language. The inline
timeline refresh of an empty gallery waits for a refresh already running instead of starting a
second one (`refresh_timeline_joined`).
**Verified:** `takeout::tests` in `pdfs-fuse` (saved state, resumable runs) and `pdfs-core`
(unreadable archive), and the CLI tests for `--resume` and the exit status. Not run live.
---
### B287 — A photo draft left by an interrupted upload blocks that name
**Status:** Fixed, not verified live
**Found:** 2026-11-15, reading the SDK upload path for
[issue #94](https://github.com/narrrl/proton-drive-linux/issues/94).
**Where:** `upload_photo_from`, `upload_file_from_inner` and `abandon_file_draft` in
`proton-drive-rs` (SDK 0.12.0)
**Repro:** Interrupt a photo upload after its draft is created, sign in again, and upload a
photo with the same name.
**Cause.** Photo uploads replaced a leftover draft only when its `ClientUID` was the current
session's. A new login is a new session, so the next upload of that name failed with 2500. A
failed upload also never deleted its own draft, which the C# and TypeScript SDKs do.
**Fix:** SDK 0.12.0 adds `PhotoUploadMetadata::replace_existing_draft`, which the Takeout import
sets, and deletes the draft of a new file or photo whose upload fails. After a failed seal it
only does so on a definite rejection, because a seal lost in transit may have been applied.
**Verified:** SDK unit test `draft_cleanup_only_after_a_definite_seal_rejection`. Not run live.
---
### B286 — Resuming a Takeout import fails on a draft with no content hash
**Status:** Fixed, not verified live
**Found:** 2026-11-15, [issue #94](https://github.com/narrrl/proton-drive-linux/issues/94)
(3.7.0, Fedora). An import stopped by a restart failed every re-run at once with
`check for existing photos: serialization error: invalid type: null, expected a string at line
1 column 2063`.
**Where:** `FoundPhotoDuplicateDto` in `proton-drive-rs` (SDK 0.11.0)
**Repro:** Interrupt a photo upload after its draft is created, then run the import again.
**Cause.** The duplicates endpoint sends `ContentHash` (and can send `Hash`) as `null` for a
draft, as its API schema says. The SDK declared both as `String` with `#[serde(default)]`,
which covers a missing field but not `null`, so one draft failed the whole batch of 150 names
and the import ended before uploading anything.
**Fix:** SDK 0.12.0 makes both fields optional and skips drafts, trashed links and candidates
without hashes, like the TypeScript SDK. Every other defaulted DTO field reads `null` as its
default too, and an undecodable response is logged with its path.
**Verified:** SDK unit tests `duplicate_response_tolerates_null_fields_and_skips_drafts` and
`duplicate_response_tolerates_a_null_list`. Not run against the reporter's account.
---
### B285 — A restarted Secret Service leaves the process on a dead session
**Status:** Fixed (unverified)
**Found:** 2026-11-14, following up [issue #78](https://github.com/narrrl/proton-drive-linux/issues/78)
(signed out after every cold boot on Fedora 45, which replaced gnome-keyring with oo7). See
[the investigation](ISSUE-78.md#a-restarted-secret-service).
**Where:** `crates/pdfs-core/src/auth.rs`, `with_keyring_entry`
**Repro:** Write the session blob, restart the Secret Service provider
(`gnome-keyring-daemon --replace`, or `oo7-daemon --replace`), then read or write it again from
the same process. `dbus-secret-service-keyring-store` keeps one D-Bus connection and one Secret
Service session for the life of the process, and pdfs installed it once. The session exists only
in the provider's memory, so the new provider answers every `GetSecret` and `SetSecret` with
`org.freedesktop.Secret.Error.NoSession`, for as long as the process runs. A fresh store in the
same process reads the same entry fine. oo7's systemd unit restarts the daemon on failure, and
both providers can be replaced, so the daemon could meet this mid-session. A token refresh after
that point reached only memory and the kernel keyring: B61's retry kept asking on the dead
session, and the next cold boot read the spent refresh token (`InvalidRefreshToken`).
**Fix:** Every keyring call goes through `with_keyring_entry`. A platform failure (which is what
`NoSession` and other D-Bus errors become) logs "the Secret Service failed this process's
connection; reconnecting", drops the store unless another thread already replaced it, and makes
the call once more on a new connection and session. A locked keyring, a dismissed prompt and a
missing entry come back unchanged. Affects the daemon, the app and the tray alike.
**Verified:** `auth::tests::a_dropped_secret_service_session_is_reconnected_and_retried`,
`a_rotation_lands_at_once_after_the_keyring_restarts` and `a_locked_keyring_is_not_reconnected`
on the in-memory store. The ignored `auth::tests::real_secret_service_survives_a_provider_restart`
passes against gnome-keyring 51.1 and oo7 0.7.1 (built from its tag), each in a throwaway session
bus and restarted with `--replace`; it checks that a reconnect actually happened. A standalone
program holding one store, as before the fix, gets `NoSession` on read and write after the same
restart under both providers. Whether the reporter's oo7 restarts during a session is not known.
---
### B284 — A keyring entry reported missing discards refreshed session tokens
**Status:** Fixed (unverified)
**Found:** 2026-11-14, investigating [issue #78](https://github.com/narrrl/proton-drive-linux/issues/78)
after the reporter's oo7 0.7.0 retest ruled out the original persistence fix as a sufficient
explanation. See [the investigation and isolated reproducer](ISSUE-78.md).
**Where:** `crates/pdfs-core/src/auth.rs`, `TokenSink::flush`
**Repro:** Refresh a session while the keyring lookup reports `NoEntry` for its existing blob.
oo7 0.7.0 does this for a locked collection (upstream #614), reproduced with fake tokens on a
private D-Bus connection. pdfs dropped the pending rotation and returned success, leaving the
spent refresh token in the saved blob without triggering B61's retry or kernel recovery paths.
The running session can still work, but restarting it exposes the stale saved credentials.
**Fix:** Propagate the missing-session error so the rotation stays pending and is retried.
Persistence still requires the matching existing blob; a retry never recreates a deleted
session or overwrites a new login. This does not make a locked keyring writable, and pending
tokens still need to reach it before power-off to survive a cold boot.
**Verified:** The two regression tests
`auth::tests::a_temporarily_missing_session_does_not_discard_a_rotation` and
`auth::tests::retrying_a_missing_session_never_recreates_it_or_overwrites_a_new_login`
failed before the fix and pass afterward. The oo7 fixture confirms its locked lookup behavior
and repeated binary `SetSecret` persistence. The reporter's complete Fedora cold-boot sequence
has not been reproduced; issue #78's precise trigger remains unconfirmed.
---
### B283 — Videos have no thumbnail outside Photos, and a `.ts` recording looks like source code ### B283 — Videos have no thumbnail outside Photos, and a `.ts` recording looks like source code
**Status:** Fixed, not verified live **Status:** Fixed, not verified live
@@ -702,11 +988,16 @@ timing.
**Where:** not located; the drain's conflict check in `crates/pdfs-fuse/src/drain.rs` is the **Where:** not located; the drain's conflict check in `crates/pdfs-fuse/src/drain.rs` is the
first suspect 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 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 37 bytes, and the full content was in `x/z/y/a (sync-conflict …).txt`. No other client wrote
to it. 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 **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 conflicted with its own create. B183 and B184 found the same symptom after a lost create
reply. reply.
+189 -2
View File
@@ -11,6 +11,59 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
## [Unreleased] ## [Unreleased]
### Changed
- 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.
## [3.9.0] — 2026-11-19
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
### Added
- 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
- 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 ## [3.8.0] — 2026-11-14
Schema: **45**. Synced folders now tell device backups apart from folders attached to My files. Schema: **45**. Synced folders now tell device backups apart from folders attached to My files.
@@ -18,6 +71,39 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
### Added ### Added
- **Excluded files, opening files and the search launcher in Preferences** (#99). Settings that
could only be changed in `config.json` now have a place in the app:
- **Sync → Excluded Files**: the patterns every synced folder leaves out. Add your own, such as
`*.db` or `build/`, and turn each built-in pattern on or off. A change applies at once.
- **Sync → Conflict Copies**: whether identical conflict copies are only reported, moved to the
trash, or not looked for.
- **Apps → Open Files With**: which program opens which kind of file, in order, optionally in a
terminal, for example `nvim` for text files. A change applies to the next file opened.
- **Apps → Search Launcher**: whether `pdfs-prompt` opens its own window, your dmenu-style
launcher (rofi, wofi, fuzzel, bemenu) or fzf in a terminal.
The Sync page's Folders view lists **Excluded Files** under the folders: how many patterns
apply to all of them and to each one, and **Add Pattern** to add one for all synced folders or
for a single folder. A folder's own rules (its `.pdfsignore`) open in an editor, also from the
folder's menu. It checks every line as you type, tells you whether a path is synced and which
pattern decides, and asks before replacing rules that changed on another computer meanwhile.
`pdfs sync ignore list|add|remove|reset|check` does the same from a terminal, and `--folder`
picks a single folder.
`pdfs-app --page preferences-sync` (or `-apps`, `-storage`, plain `preferences`) opens
Preferences at that page.
- **More clutter left out of synced folders by default**: `desktop.ini`, `.directory`, trash
folders, `.fuse_hidden*` and `.nfs*` leftovers, partial downloads (`*.part`, `*.crdownload`),
Kate swap files and office lock files. This only changes folders where you never set your own
list. Leaving a file out never deletes its copy on Proton Drive.
- **An install without a package, for immutable distributions** (#99). The release `.tar.gz` now
carries everything around the programs and an `install.sh` that installs them into your home
folder, no root needed: `~/.local` for the programs, menu entry, icon, translations and shell
completion, `~/.config` for the service and the tray's login entry. It checks the libraries
first and names the packages to install, refuses to install next to a package of the client,
updates in place (restarting a running service) and removes itself with `--uninstall`, leaving
settings and data alone. The app finds its translations and the tray beside its own program, so
nothing has to be on the `PATH`. [Installation](INSTALL.md) also shows how to layer the COPR
package on Fedora Atomic (Silverblue, Kinoite, Bazzite, Bluefin).
- **Sync a local folder with a folder you already have in My files** (#67, #77). - **Sync a local folder with a folder you already have in My files** (#67, #77).
`pdfs sync attach ~/Work --to Work` keeps `~/Work` an ordinary local folder and syncs it both `pdfs sync attach ~/Work --to Work` keeps `~/Work` an ordinary local folder and syncs it both
ways with My files/Work. The first sync uploads files that are only on this computer, downloads ways with My files/Work. The first sync uploads files that are only on this computer, downloads
@@ -79,14 +165,105 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
the grid to the photo it was showing. Alt+Left and Backspace go back a level in Shared with me the grid to the photo it was showing. Alt+Left and Backspace go back a level in Shared with me
and Computers and leave an open album or place in Photos, as Escape does too. and Computers and leave an open album or place in Photos, as Escape does too.
- **Share photos, and more in the photo viewer.**
- **Share…** in a photo's menu and in the viewer's ⋮ menu opens the usual Share dialog: invite
people or make a public link. It is not offered for a photo in an album someone else shared.
- **Copy Image** (Ctrl+C) puts the photo on screen on the clipboard.
- A strip of thumbnails along the bottom of the viewer shows the photos around the one on
screen; click one to jump to it. It fades with the other controls and stays hidden during a
slideshow.
- The line under the date names the town the photo was taken in, when it is known.
- **Drag photos out of Photos.** Select photos, then drag one of them into a file manager, a chat
or any app that takes files. The photos download when dropped and arrive under their own
names. A drag that starts on a photo that is not selected still selects, as before.
- **Upload progress in Photos.** Uploading several photos at once shows "Uploading 3 of 12
items…" with a progress bar above the timeline, instead of a single toast at the start.
- **Videos and music play in the app.** Opening a video or a song in My files, by a double-click
or **Open**, plays it in a player window, streamed from the mount like before. **Open With…**
still hands it to another player, and the separate **Play** item is gone. When the file can't
be played (a codec GStreamer lacks), the window says so and offers **Open With…**. Both this
player and the one in Photos gained a fullscreen button, fullscreen on a double-click,
**Repeat** in the ⋮ menu, `K` to play and pause, `J` and `L` (or Shift+←/→) to jump
10 seconds, and `M` to mute. The volume carries over from one video to the next, and the
thumbnail strip in Photos stays off a video, where it covered the seek bar.
- **Album covers for songs.** A song in My files, in search and in Shared shows its cover as its
thumbnail, and the player shows it above the controls instead of a music note. The cover is the
picture in the song's tags (MP3, FLAC, Ogg, Opus, M4A, WAV, AIFF, WavPack, Monkey's Audio), or
else a `cover`, `folder`, `front` or `album` image (`.jpg`, `.png`, `.webp`) in the same folder.
Only the song's tags are downloaded for it, not the whole song. Songs uploaded from this computer
carry their cover as their thumbnail, so they show it at once on other devices too. A cover
image added to a folder later is picked up once the song changes or the service restarts.
- **Resume a Google Photos import** (B288). The archives and the outcome of the last import are
kept, so an import cut short by a restart or a reboot no longer has to be set up again. The
Import page offers **Resume**, and `pdfs import-google-photos --resume` does the same. Photos
that are already uploaded are skipped as before.
- **More pages to open the app on.** `pdfs-app --page` also takes `albums`, `places`,
`places-map` and `sync-folders`.
### Changed ### Changed
- **`proton-sdk` and `proton-drive-rs` 0.11.0.** Timestamps are converted where they enter - **`proton-sdk` and `proton-drive-rs` 0.12.0.** Timestamps are converted where they enter
from the SDK, and a photo keeps its own modification time now that it no longer follows the from the SDK, and a photo keeps its own modification time now that it no longer follows the
capture time. [The SDK review](SDK-0.11.0.md) lists the new features and breaking changes. capture time. 0.12.0 fixes the photo duplicate check and failed-upload drafts below.
[The 0.11.0 review](SDK-0.11.0.md) and [the 0.12.0 review](SDK-0.12.0.md) list the new
features and breaking changes.
- **The Google Photos import brings more of the export along** (B289).
- Places from Google Photos are kept, so imported photos show up under **Places**.
- Live photos and Pixel motion photos stay one photo: the video is filed with its still and
takes its date. The `.MP` half of a motion photo is no longer skipped.
- Only the Google Photos part of an export is imported. Files from Google Drive, YouTube and
other services in the same Takeout stay out of the timeline.
- A photo without a date of its own is dated by its file name and then by its EXIF before
the day it reached Google Photos.
- Favorites are also set on photos that were already in Proton Photos.
- **The import reports what it is doing** (B288). The Import page shows the current step
(reading, checking for photos you already have, uploading, sorting into albums), the counts
so far, and a progress bar that reaches the end. A scan says how many photos and how much
data an import would upload. `pdfs import-google-photos --wait` prints its progress, and
`pdfs import-status` shows the step.
### Fixed ### Fixed
- **Two programs changing settings at once no longer lose one of the changes** (B292). The app,
the tray and the service now change `config.json` under a lock, so for example a new cache
size saved by the service and the window size saved by the app both stay.
- **Resuming a Google Photos import no longer fails at once** (#94, B286, B287). A photo upload
that was cut short left a draft behind, and every later run stopped with
`check for existing photos: serialization error: invalid type: null`. Such drafts are now
skipped by the duplicate check and replaced by the next upload of that photo, also after
signing in again. A failed upload removes its draft.
- **One bad archive or error no longer ends the whole import** (B288). An archive that cannot be
read is left out and named in the report, and the rest of the export imports. When an import
stops early, it keeps the counts of what it did and still files the uploaded photos into their
albums. A restart of the service while importing is reported as an interruption, not as a
finished import.
- **Photos zoomed all the way out shows the whole timeline.** The first 200 photos fit on one
screen there, and with nothing to scroll no more were loaded. More now load whenever the photos
don't fill the window, also after a zoom or a resize.
- **Signed out after every reboot on Fedora 45** (issue #78, B284, B285, B291). Fedora 45 replaced
the GNOME keyring with oo7, and the oo7 build it ships keeps a changed keyring entry only in
memory: every refreshed sign-in the client saved was gone after a reboot, and the next start
found one Proton had already retired. The client now saves the sign-in as a new entry that
replaces the old one, which that oo7 does write to disk. It also no longer drops a refreshed
sign-in when oo7 reports the entries of a locked keyring as missing, and it reconnects to a
keyring service that restarted.
- **Thumbnails appear in the folder you are looking at as soon as they are made.** During
**Build thumbnails**, the folder on screen kept its file icons until you left it and opened it
again. Its tiles now fill in while the build runs, and the same goes for any tile whose
thumbnail is made while it is on screen.
- **My files comes back after the service was killed for hanging** (B279). A killed service left - **My files comes back after the service was killed for hanging** (B279). A killed service left
its folders behind as dead mounts, and every restart then failed with `File exists` and retried its folders behind as dead mounts, and every restart then failed with `File exists` and retried
forever without opening anything, until the mounts were cleared by hand. The service now clears forever without opening anything, until the mounts were cleared by hand. The service now clears
@@ -136,6 +313,14 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
- **A search in My files stays.** It was replaced by the folder's listing whenever files - **A search in My files stays.** It was replaced by the folder's listing whenever files
changed, on refresh and on coming back to the page, while the query stayed in the box. changed, on refresh and on coming back to the page, while the query stayed in the box.
- **The photo viewer's buttons are readable on any photo.** They were white on a see-through
white, and vanished over a bright photo. The bar now keeps only the favorite star, the details
and a menu, which names Slideshow, Save a Copy, Open With, Add to Album, Show on Map and Move to
Trash in words where eight icons stood. A shot stored as more than one file shows a "RAW" or
"Live" switch, or "2 of 3" for a burst, where an unlabelled icon was. The title reads
"Wednesday, October 7, 2026, 13:42" rather than a timestamp. Delete asks first, as it does in
the grid, and Alt+Left closes the viewer.
- **A date jump in Photos stops when you look elsewhere.** A jump still loading the timeline - **A date jump in Photos stops when you look elsewhere.** A jump still loading the timeline
kept going after another filter, album or place was opened. kept going after another filter, album or place was opened.
@@ -2221,6 +2406,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 - The outstanding FUSE defects tracked in `docs/BUGS.md`, plus a truncate defect, validated
by a new POSIX compliance suite for the filesystem. 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.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.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 [3.4.0]: https://github.com/narrrl/proton-drive-linux/releases/tag/v3.4.0
+5
View File
@@ -119,6 +119,10 @@ commands are for scripts and for cases where the mount is not available.
| `pdfs sync reset ID` | Forget what a synced folder synced before and compare it with Proton Drive again. A file on one side only is copied to the other, and a file that differs keeps both versions. Nothing is deleted. | | `pdfs sync reset ID` | Forget what a synced folder synced before and compare it with Proton Drive again. A file on one side only is copied to the other, and a file that differs keeps both versions. Nothing is deleted. |
| `pdfs sync pause [--for 1h] [--folder ID]` | Pause uploads and synced folders. Reading files keeps working. `--for` ends the pause by itself (`30m`, `1h`, `2d`). | | `pdfs sync pause [--for 1h] [--folder ID]` | Pause uploads and synced folders. Reading files keeps working. `--for` ends the pause by itself (`30m`, `1h`, `2d`). |
| `pdfs sync resume [--folder ID]` | Resume after a pause. | | `pdfs sync resume [--folder ID]` | Resume after a pause. |
| `pdfs sync ignore list [--folder PATH]` | Print the patterns every synced folder leaves out; built-in ones are marked. With `--folder`, the own patterns of the synced folder holding `PATH`. |
| `pdfs sync ignore add PATTERN [--folder PATH]` / `remove PATTERN [--folder PATH]` | Leave out, or stop leaving out, files matching a gitignore-style pattern such as `*.db` or `build/`, in every synced folder or, with `--folder`, in that folder's `.pdfsignore` only. A pattern starting with `-` goes after `--`. |
| `pdfs sync ignore reset` | Use the built-in patterns again. |
| `pdfs sync ignore check PATH` | Say whether a file in a synced folder is synced, and which pattern decides. |
| `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. | | `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. |
| `pdfs sync queue` | List changes that have not reached Proton Drive yet. | | `pdfs sync queue` | List changes that have not reached Proton Drive yet. |
| `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. | | `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. |
@@ -196,6 +200,7 @@ commands are for scripts and for cases where the mount is not available.
| `pdfs add-to-album UID PHOTOS...` | Add photos to an album. | | `pdfs add-to-album UID PHOTOS...` | Add photos to an album. |
| `pdfs remove-from-album UID PHOTOS...` | Take photos out of an album. | | `pdfs remove-from-album UID PHOTOS...` | Take photos out of an album. |
| `pdfs import-google-photos ARCHIVES... [--dry-run] [--wait]` | Import a Google Takeout export. Pass every `.zip` of the export. | | `pdfs import-google-photos ARCHIVES... [--dry-run] [--wait]` | Import a Google Takeout export. Pass every `.zip` of the export. |
| `pdfs import-google-photos --resume [--wait]` | Start the last import again with the same archives after it was interrupted, stopped or failed. |
| `pdfs import-status` / `pdfs cancel-import` | Follow or stop a running import. | | `pdfs import-status` / `pdfs cancel-import` | Follow or stop a running import. |
| `pdfs redate-photos [--dry-run] [--from DATE] [--to DATE] [--limit N] [--wait]` | Fix photos filed under their upload day when the file name carries the real date. | | `pdfs redate-photos [--dry-run] [--from DATE] [--to DATE] [--limit N] [--wait]` | Fix photos filed under their upload day when the file name carries the real date. |
| `pdfs redate-status` / `pdfs cancel-redate` | Follow or stop a running re-date. | | `pdfs redate-status` / `pdfs cancel-redate` | Follow or stop a running re-date. |
+15 -7
View File
@@ -44,9 +44,13 @@ the [security model](SECURITY_MODEL.md#what-is-kept-on-this-computer).
## `config.json` ## `config.json`
The file is created with defaults on first start. Every key is optional; a missing key takes its The file is created with defaults on first start. Every key is optional; a missing key takes its
default. Edit it while the app is closed, then restart the service default. Most keys can be changed in the app, under **Preferences** (the "In app" column below).
To edit the file by hand, close the app first, then restart the service
(`systemctl --user restart proton-drive.service`) for service settings to apply. (`systemctl --user restart proton-drive.service`) for service settings to apply.
The app, the tray and the service each change the file under a lock (`config.json.lock` next to
it), so two of them changing different settings at once both keep their change.
An unreadable file is never overwritten: the programs log an error and run with defaults until you An unreadable file is never overwritten: the programs log an error and run with defaults until you
fix it. fix it.
@@ -80,9 +84,9 @@ fix it.
| `cache_budget` | bytes | 5 GiB | Storage → Cache | Soft limit for cached content. `0` means unlimited. Available-offline files do not count against it | | `cache_budget` | bytes | 5 GiB | Storage → Cache | Soft limit for cached content. `0` means unlimited. Available-offline files do not count against it |
| `upload_limit` | bytes/s | none | General → Network | Shared cap for all uploads. `0` or `null` means none | | `upload_limit` | bytes/s | none | General → Network | Shared cap for all uploads. `0` or `null` means none |
| `download_limit` | bytes/s | none | General → Network | Shared cap for all downloads, reads from the mount included | | `download_limit` | bytes/s | none | General → Network | Shared cap for all downloads, reads from the mount included |
| `ignore_patterns` | list | see below | — | Global ignore rules for synced folders | | `ignore_patterns` | list | see below | Sync → Excluded Files | Global ignore rules for synced folders |
| `device_uid` | string | none | Computers → Continue This Backup Here… or Sync With This Computer… | The computer this machine syncs into. Unset means "match by hostname" | | `device_uid` | string | none | Computers → Continue This Backup Here… or Sync With This Computer… | The computer this machine syncs into. Unset means "match by hostname" |
| `conflict_sweep` | `off` / `report` / `enforce` | `report` | — | See [`conflict_sweep`](#conflict_sweep) | | `conflict_sweep` | `off` / `report` / `enforce` | `report` | Sync → Conflict Copies | See [`conflict_sweep`](#conflict_sweep) |
| `local_first` | bool | `true` | — | See [`local_first`](#local_first) | | `local_first` | bool | `true` | — | See [`local_first`](#local_first) |
| `language` | gettext code | system | General → Appearance | Language of the app, tray and prompt, such as `de` or `pt_BR` | | `language` | gettext code | system | General → Appearance | Language of the app, tray and prompt, such as `de` or `pt_BR` |
| `proton_theme` | bool | follow system | General → Appearance | Proton's colours instead of the system theme | | `proton_theme` | bool | follow system | General → Appearance | Proton's colours instead of the system theme |
@@ -93,8 +97,8 @@ fix it.
| `update_latest` | version | none | — | The latest release the update check found | | `update_latest` | version | none | — | The latest release the update check found |
| `files_view` | object | grid, by name | My files view menu | `list`, `sort` (`name`, `size`, `modified`), `descending`, `folders_first` | | `files_view` | object | grid, by name | My files view menu | `list`, `sort` (`name`, `size`, `modified`), `descending`, `folders_first` |
| `window` | object | 980 × 680 | Resizing the app window | `width`, `height` (the unmaximized size), `maximized` | | `window` | object | 980 × 680 | Resizing the app window | `width`, `height` (the unmaximized size), `maximized` |
| `open_with` | object | `xdg-open` | — | See [`open_with`](#open_with) | | `open_with` | object | `xdg-open` | Apps → Open Files With | See [`open_with`](#open_with) |
| `prompt` | object | built-in window | — | See [`prompt`](#prompt) | | `prompt` | object | built-in window | Apps → Search Launcher | See [`prompt`](#prompt) |
`app_version` and `user_agent` identify the client to Proton. When the keys are absent, the `app_version` and `user_agent` identify the client to Proton. When the keys are absent, the
client sends its own release (`external-drive-linux@<version>-stable`, `proton-drive-linux/<version>`). client sends its own release (`external-drive-linux@<version>-stable`, `proton-drive-linux/<version>`).
@@ -109,10 +113,14 @@ Gitignore-style rules applied to every synced folder, in addition to each folder
```json ```json
[".git/", ".hg/", ".svn/", "node_modules/", "target/", ".venv/", "__pycache__/", [".git/", ".hg/", ".svn/", "node_modules/", "target/", ".venv/", "__pycache__/",
"*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db"] "*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db",
"desktop.ini", ".directory", ".Trash-*/", ".Trashes/", ".Spotlight-V100/",
".fuse_hidden*", ".nfs*", "*.part", "*.crdownload", "*.kate-swp", ".~lock.*#", "~$*"]
``` ```
Set it to `[]` to turn the defaults off. See Preferences → Sync → Excluded Files edits this list, **Add Pattern** on the Sync page's Folders
view adds to it, and `pdfs sync ignore` does the same from a terminal. A list equal to the defaults is saved as absent, so it follows the defaults of later
releases. Set it to `[]` to turn the defaults off. See
[Synced folders](SYNCED_FOLDERS.md#excluding-files-with-pdfsignore) for how excluding behaves. [Synced folders](SYNCED_FOLDERS.md#excluding-files-with-pdfsignore) for how excluding behaves.
### `conflict_sweep` ### `conflict_sweep`
+24
View File
@@ -161,6 +161,30 @@ links, copies the images and writes the sidebar. `docs/README.md` becomes the wi
Never edit the wiki in the browser: the next publish replaces every page. Never edit the wiki in the browser: the next publish replaces every page.
**Screenshots.** The pictures in `images/` (except the cover) are taken by a script, from an
invented account, so they never show anyone's files:
```bash
scripts/screenshots.sh # all of them, into images/
scripts/screenshots.sh --only photos,files # just these
scripts/screenshots.sh --debug --skip-build # reuse already-built debug binaries
scripts/screenshots.sh --website ../proton-drive-linux-website # and copy them to the website
```
It builds the app and runs it against `crates/pdfs-core/examples/demo_daemon.rs`, a stand-in
daemon that answers the control socket with made-up files, photos, places, computers and history.
The app runs in a headless `cage` compositor with its own HOME, XDG directories, session bus and
keyring, so nothing touches your account, your keyring or a running service. It needs `cage`,
`grim`, `wlr-randr`, ImageMagick, `dbus-run-session` and `gnome-keyring-daemon`, plus `wtype` for
the launcher's query, and `fzf` and `alacritty` for its fzf variant. The demo photos come from
[picsum.photos](https://picsum.photos) (Unsplash licence) on the first run and are cached in
`~/.cache/pdfs-screenshots`. Dates are relative to the day you run it.
Retake them before a release, and look at each one before committing. A page that grew new data
needs a matching answer in the demo daemon; the requests it has no answer for are logged in
`demo_daemon.log` (keep it with `--keep`). The demo daemon is built with every `cargo test` and
`cargo clippy --all-targets`, so a change to the control protocol that breaks it fails CI.
## Releasing ## Releasing
Releases are cut from `main` by pushing a `v*` tag. `.github/workflows/release.yml` then: Releases are cut from `main` by pushing a `v*` tag. `.github/workflows/release.yml` then:
+49 -8
View File
@@ -21,7 +21,8 @@ again.
| [Arch Linux](#arch-linux-aur) | `proton-drive-for-linux` in the AUR | With your AUR helper | | [Arch Linux](#arch-linux-aur) | `proton-drive-for-linux` in the AUR | With your AUR helper |
| [Debian, Ubuntu 24.04 or newer](#debian-and-ubuntu-2404-or-newer) | `.deb` from the release page | Download each release | | [Debian, Ubuntu 24.04 or newer](#debian-and-ubuntu-2404-or-newer) | `.deb` from the release page | Download each release |
| [NixOS](#nixos-flake) | The flake in this repository | With `nix flake update` | | [NixOS](#nixos-flake) | The flake in this repository | With `nix flake update` |
| [Anything else](#other-distributions) | `.tar.gz` from the release page, or [build from source](#build-from-source) | By hand | | [Fedora Atomic](#fedora-atomic-silverblue-kinoite-bazzite-bluefin) (Silverblue, Kinoite, Bazzite, Bluefin) | The COPR repository, layered with `rpm-ostree` | With `rpm-ostree upgrade` |
| [Anything else](#other-distributions), immutable ones included | `.tar.gz` from the release page, installed into your home folder by its `install.sh`, or [build from source](#build-from-source) | Run the new release's `install.sh` |
Release packages are for x86_64. You also need a Secret Service provider, such as GNOME Release packages are for x86_64. You also need a Secret Service provider, such as GNOME
Keyring, KWallet or KeePassXC, to keep your session. Most desktops have one already. Keyring, KWallet or KeePassXC, to keep your session. Most desktops have one already.
@@ -139,12 +140,42 @@ the module) and a Secret Service such as GNOME Keyring or KWallet. To leave out
it video thumbnails, override the package with `withFfmpeg = false`. The recipe is in it video thumbnails, override the package with `withFfmpeg = false`. The recipe is in
[`packaging/nix/`](../packaging/nix/). [`packaging/nix/`](../packaging/nix/).
### Fedora Atomic (Silverblue, Kinoite, Bazzite, Bluefin)
The system is read-only, so layer the COPR package on top of it. It brings its libraries along:
```bash
sudo curl -o /etc/yum.repos.d/proton-drive-linux.repo \
"https://copr.fedorainfracloud.org/coprs/narl-rs/proton-drive-linux/repo/fedora-$(rpm -E %fedora)/narl-rs-proton-drive-linux-fedora-$(rpm -E %fedora).repo"
rpm-ostree install proton-drive-linux
systemctl reboot
```
`rpm-ostree upgrade` brings new releases with the system's own updates.
### Other distributions ### Other distributions
Unpack the `.tar.gz` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest) The `.tar.gz` from the [latest release](https://github.com/narrrl/proton-drive-linux/releases/latest)
into a directory on your `PATH`, then install the service as shown in installs into your home folder, without root, so it also works where the system is read-only:
[Using a binary outside `/usr/bin`](#using-a-binary-outside-usrbin). The binaries need GTK 4.12,
libadwaita 1.5, WebKitGTK 6.0 and FUSE 3; see [Requirements](#requirements). ```bash
tar -xzf proton-drive-linux-*-x86_64.tar.gz
proton-drive-linux-*-x86_64/install.sh
```
It puts the programs in `~/.local/bin`, the menu entry, icon, translations and shell completion in
`~/.local/share`, the service in `~/.config/systemd/user` and the tray's login entry in
`~/.config/autostart`, each pointing at `~/.local/bin`. Then open **Proton Drive for Linux** from
your applications menu. `--prefix DIR` installs somewhere else.
The system has to provide glibc 2.39 or newer (the binaries are built on Ubuntu 24.04), GTK 4.12,
libadwaita 1.5, WebKitGTK 6.0 and FUSE 3 with a setuid `fusermount3`; see
[Requirements](#requirements). `install.sh` checks the libraries first and names the packages to
install for each distribution. It refuses to install next to a package of this client, since the
two would run different versions of the service.
To update, download the new release and run its `install.sh`; a running service restarts on the new
version. Turn on **Preferences → General → Check for updates** to hear about new releases.
## Optional extras ## Optional extras
@@ -195,7 +226,9 @@ browser, solve it, then press Enter.
| COPR (Fedora) | `sudo dnf upgrade` | | COPR (Fedora) | `sudo dnf upgrade` |
| AUR | `paru -Syu`, or your AUR helper's equivalent | | AUR | `paru -Syu`, or your AUR helper's equivalent |
| Nix flake | `nix flake update proton-drive-linux`, or change the pinned tag, then rebuild | | Nix flake | `nix flake update proton-drive-linux`, or change the pinned tag, then rebuild |
| `.deb`, release `.rpm`, `.tar.gz` | Download the new release and install it over the old one | | Fedora Atomic | `rpm-ostree upgrade`, then reboot |
| `.deb`, release `.rpm` | Download the new release and install it over the old one |
| `.tar.gz` | Download the new release and run its `install.sh` |
The service switches to the new version the next time it starts. To switch at once: The service switches to the new version the next time it starts. To switch at once:
@@ -245,6 +278,8 @@ open in an older release, so going back to an older version means clearing the l
| `.deb` | `sudo apt remove proton-drive-linux` | | `.deb` | `sudo apt remove proton-drive-linux` |
| AUR | `sudo pacman -R proton-drive-for-linux` (or the `-bin` or `-git` package) | | AUR | `sudo pacman -R proton-drive-for-linux` (or the `-bin` or `-git` package) |
| NixOS | Remove the module and the flake input, then rebuild | | NixOS | Remove the module and the flake input, then rebuild |
| Fedora Atomic | `rpm-ostree uninstall proton-drive-linux`, remove `/etc/yum.repos.d/proton-drive-linux.repo`, then reboot |
| `.tar.gz` | `~/.local/share/proton-drive-linux/install.sh --uninstall` |
Removing the package also stops the service of every logged-in user, in case step 1 was Removing the package also stops the service of every logged-in user, in case step 1 was
skipped. skipped.
@@ -353,8 +388,10 @@ sudo dnf install packaging/out/x86_64/proton-drive-linux-*.rpm
### Using a binary outside `/usr/bin` ### Using a binary outside `/usr/bin`
The service unit starts `/usr/bin/pdfs daemon`. If you installed the programs somewhere else, for The release tarball's `install.sh` does all of this for you (see
example `~/.local/bin`, install the unit for your user and point it at your binary: [Other distributions](#other-distributions)). For programs you built yourself: the service unit
starts `/usr/bin/pdfs daemon`. If you installed the programs somewhere else, for example
`~/.local/bin`, install the unit for your user and point it at your binary:
```bash ```bash
mkdir -p ~/.config/systemd/user mkdir -p ~/.config/systemd/user
@@ -382,3 +419,7 @@ Every package installs the same files:
| `/usr/lib/systemd/user/proton-drive.service` | User service that keeps the drive mounted | | `/usr/lib/systemd/user/proton-drive.service` | User service that keeps the drive mounted |
| `/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop` | Starts the tray at login | | `/etc/xdg/autostart/io.narl.proton-drive-linux-tray.desktop` | Starts the tray at login |
| `/usr/share/locale/*/LC_MESSAGES/pdfs.mo` | Translations | | `/usr/share/locale/*/LC_MESSAGES/pdfs.mo` | Translations |
The release tarball's `install.sh` puts the same files under `~/.local` instead of `/usr`, the
service in `~/.config/systemd/user` and the tray's login entry in `~/.config/autostart`. It keeps a
list of them in `~/.local/share/proton-drive-linux/installed-files` for `--uninstall`.
+175
View File
@@ -0,0 +1,175 @@
# Issue #78: session loss on Fedora 45
Investigation on 2026-11-14 of [issue #78](https://github.com/narrrl/proton-drive-linux/issues/78),
using its report and comments through `gh`, pdfs 3.7.0/current source, and the oo7 0.7.0 tag.
## What is established
The reporter still saw the problem with oo7 0.7.0 on November 7. The original
[SetSecret persistence fix](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
is present in that release. In an isolated test, three successive binary `SetSecret` updates
survived reopening the keyring file. Repeating the original persistence explanation is therefore
insufficient.
A different, reproducible failure exists at the boundary between oo7 and pdfs:
1. oo7 0.7.0's `Collection::search_inner_items` returns an empty list for a locked collection.
`SearchItems` consequently returns **both** the unlocked and locked lists empty even when the
matching item is on disk. The isolated test reproduces this with pdfs's exact lookup attributes.
This is upstream [oo7 #614](https://github.com/linux-credentials/oo7/issues/614).
2. `dbus-secret-service-keyring-store` 1.0.1 maps an empty search to `keyring_core::Error::NoEntry`;
pdfs maps that to `Error::NotLoggedIn`. The client cannot offer an unlock when no locked item
is reported.
3. In pdfs 3.7.0 and the code before this change, `TokenSink::flush` treated `NotLoggedIn` as a
logout, cleared the pending rotation and returned success. It skipped the error path that
retains the new tokens in the kernel keyring and retries their persistence. The code was
unchanged between v3.7.0 and this investigation.
4. If a token refresh encounters that reply, the saved blob retains a spent refresh token. The
running process can keep working with the new tokens in memory; a restart then exposes the
stale saved credentials. A regression test failed before the fix and passes afterward.
The same unsafe assumption also applies to transient empty lookups such as the race reported in
[oo7 #652](https://github.com/linux-credentials/oo7/issues/652), fixed in 0.7.1. That issue's
replacement race was not independently reproduced here; pdfs normally updates existing items
with `SetSecret`, so it must not be assumed to encounter the same-item `CreateItem` race.
## Change and limits
`TokenSink::flush` now propagates a missing-session error instead of discarding the rotation.
The existing retry, kernel-keyring recovery and unsaved-token status paths can then run. Once
the collection is unlocked and readable, the pending rotation is saved. A genuinely deleted
session is never recreated: flushing still requires a readable blob with the matching session
ID and expected refresh token. A new login causes the old rotation to be discarded as before.
This is a confirmed pdfs defect (B284), **not a confirmed complete explanation of the reporter's
cold-boot failure**. The issue has no oo7 logs or record showing that its collection was locked
when a token rotated. A locked keyring only at startup can hide a login, but does not by itself
explain `InvalidRefreshToken`. The token-loss path requires a successful refresh while the saved
entry is unreadable.
The fix does not make a locked keyring writable. If it stays unreadable until power-off, tokens
retained in process/kernel memory still cannot survive a cold boot. No new disk credential store
or credential format is introduced.
Other upstream Fedora-upgrade issues were checked: [oo7 #651](https://github.com/linux-credentials/oo7/issues/651)
creates duplicate placeholder/migrated collections and refuses writes; [oo7 #662](https://github.com/linux-credentials/oo7/issues/662)
can resolve the default alias to a locked collection. Both have fixes in
[0.7.1](https://github.com/linux-credentials/oo7/releases/tag/0.7.1), released November 10,
after the reporter's November 7 retest. Neither can be assigned as this report's cause without
matching runtime evidence.
## SetSecret is kept only in memory in Fedora's oo7
Follow-up on 2026-11-15. The reporter's `rpm -qa 'oo7*'` shows
`oo7-daemon-0.7.0~beta^1.e91b98a-1.fc45`, not the 0.7.0 release assumed above. Bodhi lists that
build as the stable oo7 for Fedora 45 and 46; neither has 0.7.0 or 0.7.1. Commit e91b98a
(October 24) predates
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
(October 28): "Setting the Label or Attributes of an item, or calling SetSecret, only changed the
item in memory, so the old values came back once the daemon restarted." 0.7.0 carries it as
37e3334.
pdfs writes an existing entry with `SetSecret`, so on that build every saved token rotation was
lost at the next reboot. This explains the reporter's log: the keyring was unlocked one second
before pdfs started (they type their password at login) and still held a spent refresh token.
It does not need a locked keyring or a restarted provider.
pdfs now saves an existing entry with `CreateItem` and `replace` instead
(`crates/pdfs-core/src/secretservice.rs`, B291), which e91b98a writes to the keyring file.
Reproduced and verified with oo7-daemon built at e91b98a in a throwaway session bus:
```sh
git clone https://github.com/linux-credentials/oo7.git /tmp/oo7 && git -C /tmp/oo7 checkout e91b98a
cargo build --manifest-path /tmp/oo7/Cargo.toml -p oo7-daemon --bin oo7-daemon
OO7=/tmp/oo7/target/debug/oo7-daemon
T=$(mktemp -d /tmp/ss.XXXX); mkdir -p $T/data $T/run; chmod 700 $T/run
XDG_DATA_HOME=$T/data XDG_RUNTIME_DIR=$T/run OO7=$OO7 PDFS_SECRET_SERVICE_RESTART_TEST=1 \
PDFS_RESTART_PROVIDER='pkill -x oo7-daemon; sleep 1; (printf pw | setsid "$OO7" --login >/dev/null 2>&1 &); sleep 2' \
dbus-run-session -- sh -c 'printf pw | setsid "$OO7" --login >/dev/null 2>&1 & sleep 2;
cargo test -p pdfs-core real_secret_service_keeps -- --ignored'
```
With the in-place write, the read after the restart returns the first of three saves (`r1`);
with the replacing write it returns the last (`r3`), and one item is left.
The daemon also logs a short fingerprint of the refresh token when it resumes the stored session
and each time it saves a rotation (`refresh=1a2b3c4d`). If a start is refused, compare the
fingerprint it resumed with against the last one saved in the boot before:
```sh
journalctl --user -b -1 -u proton-drive.service | grep -E 'refresh=' | tail -2
journalctl --user -b 0 -u proton-drive.service | grep -E 'refresh=' | head -2
```
The same fingerprint means the keyring kept the last save and Proton refused it; a different one
means the keyring lost it.
## A restarted Secret Service
A second path to the same symptom, independent of locking (B285). The keyring store pdfs used
holds one D-Bus connection and one Secret Service session for the whole process, and was
installed once. The session lives only in the provider's memory. When the provider restarts,
the new one answers every `GetSecret` and `SetSecret` on the old session with
`org.freedesktop.Secret.Error.NoSession`, until the pdfs process itself restarts. Reproduced
with both gnome-keyring 51.1 and oo7 0.7.1 using `--replace`.
gnome-keyring practically never restarts within a desktop session. oo7 can:
`oo7-daemon.service` has `Restart=on-failure`, the daemon allows itself to be replaced, and it
exits on a wrong credential password and is D-Bus-activated again. A daemon that met a restarted
provider kept every later token refresh only in memory and the kernel keyring, and a cold boot
then left the spent refresh token in the saved blob.
Now a platform failure drops the store and the call is retried once on a new connection. The
daemon log shows `the Secret Service failed this process's connection; reconnecting` when that
happens. To check whether a machine meets this, look for oo7 restarts in the same boot:
```sh
journalctl --user -b -1 -u oo7-daemon.service | grep -E 'Started|Stopped|Starting oo7|Main process exited'
journalctl --user -b -1 -u proton-drive.service | grep -iE 'keyring|reconnecting|refresh'
```
Reproduce in a throwaway session bus (never against the desktop's keyring; the runtime directory
must be short, as it holds a Unix socket):
```sh
T=$(mktemp -d /tmp/ss.XXXX); mkdir -p $T/data $T/run; chmod 700 $T/run
XDG_DATA_HOME=$T/data XDG_RUNTIME_DIR=$T/run PDFS_SECRET_SERVICE_RESTART_TEST=1 \
PDFS_RESTART_PROVIDER='echo -n pw | gnome-keyring-daemon --replace --unlock --components=secrets >/dev/null' \
dbus-run-session -- sh -c 'echo -n pw | gnome-keyring-daemon --unlock --components=secrets >/dev/null; sleep 1;
cargo test -p pdfs-core real_secret_service -- --ignored'
```
For oo7, start `oo7-daemon --login` with the password on stdin instead, and restart it with
`--login --replace` in the background.
## Reproduce without a Proton account or desktop keyring
The oo7 fixture uses fake tokens, a temporary disk keyring and a private peer-to-peer D-Bus
connection. It asserts the observed 0.7.0 behavior, including the incorrect empty locked lookup;
passing means that behavior was reproduced. It does not simulate Proton refresh or a full boot.
From the pdfs repository, choose an unused temporary checkout path:
```sh
git clone --depth 1 --branch 0.7.0 https://github.com/linux-credentials/oo7.git /tmp/pdfs-oo7-repro
git -C /tmp/pdfs-oo7-repro apply "$PWD/docs/repro/oo7-0.7.0-issue78.patch"
cargo test --manifest-path /tmp/pdfs-oo7-repro/Cargo.toml \
-p oo7-daemon --lib --features test-util issue78 -- --nocapture
```
Observed output:
```text
oo7 0.7.0: locked session is on disk but SearchItems returns (0, 0)
oo7 0.7.0: all three binary SetSecret updates survived reopening the disk keyring
test item::tests::issue78_locked_lookup_hides_saved_tokens ... ok
```
The pdfs side is covered by `cargo test -p pdfs-core auth::tests`, specifically
`a_temporarily_missing_session_does_not_discard_a_rotation` and
`retrying_a_missing_session_never_recreates_it_or_overwrites_a_new_login`.
Remaining live validation: reproduce on a Fedora 45 GNOME session across logout/shutdown,
correlating oo7 lock/write errors with pdfs refresh and retry logs, and checking the running
daemon's package version rather than just the CLI version. The investigation did not use a real
Proton account, alter a desktop keyring, or post to either GitHub issue.
+4 -3
View File
@@ -69,9 +69,10 @@ windowrulev2 = center, class:^(pdfs-prompt)$
bind = SUPER, space, exec, pdfs-prompt --fzf bind = SUPER, space, exec, pdfs-prompt --fzf
``` ```
To make `--dmenu` or `--fzf` the default without changing your shortcut, set `prompt.mode` in To make `--dmenu` or `--fzf` the default without changing your shortcut, pick it in
`config.json` (see [Configuration → `prompt`](CONFIGURATION.md#prompt)). `--gtk` always opens the **Preferences → Apps → Search Launcher**, or set `prompt.mode` in `config.json` (see
built-in window. [Configuration → `prompt`](CONFIGURATION.md#prompt)). `--gtk` always opens the built-in window.
Which program opens a file you pick is set under **Preferences → Apps → Open Files With**.
## Tray ## Tray
+51 -2
View File
@@ -1,5 +1,39 @@
# Photos # 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 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`. My files, so they do not appear in `~/ProtonDrive`.
@@ -55,6 +89,7 @@ server learns which areas you look at.
2. In the app, open the **Upload** menu on the Photos page and choose **Import from Google 2. In the app, open the **Upload** menu on the Photos page and choose **Import from Google
Photos…**. Select all the `.zip` files at once, because a photo and its details are often in Photos…**. Select all the `.zip` files at once, because a photo and its details are often in
different parts of the export. different parts of the export.
3. Choose **Scan** to see what an import would do without uploading anything, then **Import**.
From a terminal: From a terminal:
@@ -63,8 +98,22 @@ pdfs import-google-photos --dry-run ~/Downloads/takeout-*.zip # show what woul
pdfs import-google-photos --wait ~/Downloads/takeout-*.zip pdfs import-google-photos --wait ~/Downloads/takeout-*.zip
``` ```
The import recreates your albums and takes capture dates and locations from the export. Photos What the import takes from the export:
already in your library are skipped, so an interrupted import can simply be run again.
- **Albums** are recreated. A photo that is in several albums is uploaded once and added to each.
- **Dates** come from the export's details, else from a date in the file name, else from the
photo's EXIF.
- **Places** come from the export, so imported photos appear under [Places](#places).
- **Favorites** are kept.
- **Live photos and motion photos** stay one photo: the video is filed with its still.
What it leaves out: photos in Google's trash, and files from other Google services (Drive,
YouTube) that are in the same export. A `.zip` that cannot be read is left out and named in the
report; the rest still imports.
Photos already in your library are skipped, so an interrupted import can simply be run again.
If the import was cut short, for example by a restart, the Import page offers **Resume**, and
`pdfs import-google-photos --resume` does the same without naming the archives again.
`pdfs import-status` shows how far an import is, and `pdfs cancel-import` stops it. `pdfs import-status` shows how far an import is, and `pdfs cancel-import` stops it.
## Fixing photos filed under the wrong date ## Fixing photos filed under the wrong date
+2 -1
View File
@@ -63,7 +63,8 @@ them along.
| Add someone else's photo to your album | Blocked | Needs `copyPhoto` in the SDK | | Add someone else's photo to your album | Blocked | Needs `copyPhoto` in the SDK |
| Photo name search | Not started | Photos search by date and filters only | | Photo name search | Not started | Photos search by date and filters only |
| Automatic photo upload from a folder | Not started | | | Automatic photo upload from a folder | Not started | |
| Faster Google Photos import | Not started | Uploads run one at a time. Trash folders of locales missing from `TRASH_FOLDERS` import as photos; motion-photo `.MP` parts are skipped | | Faster Google Photos import | Not started | Uploads run one at a time. Trash folders of locales missing from `TRASH_FOLDERS` import as photos |
| More of a Google Photos export | Not started | `.tgz` exports and extracted folders; shared albums told apart from own ones; album descriptions and covers; photo descriptions |
| Content-addressed block cache | Idea | Store blocks by hash to deduplicate identical content | | Content-addressed block cache | Idea | Store blocks by hash to deduplicate identical content |
## Performance and correctness ## Performance and correctness
View File
Whitespace-only changes.
+33 -4
View File
@@ -100,10 +100,39 @@ apply together:
!important.log !important.log
``` ```
2. The `ignore_patterns` list in `config.json`, for every synced folder (see 2. The patterns for every synced folder: **Preferences → Sync → Excluded Files** in the app, or
[Configuration](CONFIGURATION.md#ignore_patterns)). When you have not set it, it skips `ignore_patterns` in `config.json` (see [Configuration](CONFIGURATION.md#ignore_patterns)).
`.git/`, `.hg/`, `.svn/`, `node_modules/`, `target/`, `.venv/`, `__pycache__/`, `*~`, Built in are version control (`.git/`, `.hg/`, `.svn/`), dependency and build folders
`*.swp`, `*.tmp`, `.DS_Store` and `Thumbs.db`. (`node_modules/`, `target/`, `.venv/`, `__pycache__/`), and what editors, downloads and other
systems leave behind (`*~`, `*.swp`, `*.tmp`, `*.part`, `*.crdownload`, `*.kate-swp`, office
lock files, `.DS_Store`, `Thumbs.db`, `desktop.ini`, `.directory`, trash folders, `.nfs*` and
`.fuse_hidden*`). Each built-in pattern can be turned off on its own.
In the app, open the **Sync** page, then **Folders**. Under the folder list, **Excluded Files**
shows how many patterns apply to all synced folders and how many each folder has of its own:
- **Add Pattern** asks for a pattern and where it applies: all synced folders, or one of them.
- **All Synced Folders** opens Preferences → Sync, with every pattern and the built-in ones.
- A folder opens the editor for its own rules, which **Excluded Files…** in the folder's menu
opens too. It checks every line as you type, and **Check a path** tells you whether a file is
synced and which pattern decides. If the file changed meanwhile, for example on another
computer, it asks before replacing that version.
From a terminal:
```bash
pdfs sync ignore list # the patterns for every synced folder
pdfs sync ignore add '*.db' # leave out files ending in .db
pdfs sync ignore remove '*.db'
pdfs sync ignore reset # back to the built-in patterns
pdfs sync ignore add 'cache/' --folder ~/Projects # only in ~/Projects/.pdfsignore
pdfs sync ignore list --folder ~/Projects
pdfs sync ignore check ~/Projects/app/node_modules
```
The rules apply to folders kept on this computer. Files you save into `~/ProtonDrive` itself or into
an online-only folder are always uploaded, except download and editor scratch files, which wait for
their final name.
Rules are read again on every sync pass. Excluding never deletes anything: a file that becomes Rules are read again on every sync pass. Excluding never deletes anything: a file that becomes
excluded is no longer synced, and its copy on Proton Drive stays. excluded is no longer synced, and its copy on Proton Drive stays.
+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 | | `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 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 ## Acceptance suite
+2
View File
@@ -53,6 +53,8 @@ The app uses these words, and so do these pages:
| Page | Settings | | Page | Settings |
|---|---| |---|---|
| **General** | Start on login · Proton Drive folder location · upload and download limits · Proton theme, street map for Places, tray icon · language · check for updates | | **General** | Start on login · Proton Drive folder location · upload and download limits · Proton theme, street map for Places, tray icon · language · check for updates |
| **Sync** | Files and folders every synced folder leaves out · what happens to identical conflict copies |
| **Apps** | Which program opens which kind of file · how the search launcher opens |
| **Storage** | Cache size limit · clear the cache · files kept available offline | | **Storage** | Cache size limit · clear the cache · files kept available offline |
The account menu shows the storage you use and holds **Sign Out…**. Settings that are not in the The account menu shows the storage you use and holds **Sign Out…**. Settings that are not in the
+53
View File
@@ -0,0 +1,53 @@
diff --git a/server/src/item/tests.rs b/server/src/item/tests.rs
index 99c25dc..2ba705d 100644
--- a/server/src/item/tests.rs
+++ b/server/src/item/tests.rs
@@ -5,6 +5,48 @@ use tokio_stream::StreamExt;
use crate::{service::PrompterType, tests::TestServiceSetup};
+// Investigation for proton-drive-linux #78. Fake tokens and a private p2p bus;
+// no desktop keyring or Proton account is used.
+#[tokio::test]
+async fn issue78_locked_lookup_hides_saved_tokens() -> Result<(), Box<dyn std::error::Error>> {
+ let setup =
+ TestServiceSetup::with_login_keyring(oo7::Secret::from("test-password-long-enough"))
+ .await?;
+ let collection = setup.default_collection().await?;
+ let attributes = [("service", "proton-drive-linux"), ("username", "session")];
+ let secret = setup.create_dbus_secret(oo7::Secret::blob(b"fake-refresh-r1"))?;
+ collection
+ .create_item("pdfs fake session", &attributes, &secret, false, None)
+ .await?;
+
+ let (unlocked, locked) = setup.service_api.search_items(&attributes).await?;
+ assert_eq!((unlocked.len(), locked.len()), (1, 0));
+ setup.lock_collection(collection).await?;
+ assert!(collection.is_locked().await?);
+
+ let (unlocked, locked) = setup.service_api.search_items(&attributes).await?;
+ // This is the problematic reply, not the Secret Service behavior expected
+ // by keyring-store: the saved item is neither unlocked nor reported locked.
+ assert_eq!((unlocked.len(), locked.len()), (0, 0));
+ assert_eq!(setup.login_keyring().await?.items().await?.len(), 1);
+ eprintln!("oo7 0.7.0: locked session is on disk but SearchItems returns (0, 0)");
+
+ setup.unlock_collection(collection).await?;
+ let (unlocked, locked) = setup.service_api.search_items(&attributes).await?;
+ assert_eq!((unlocked.len(), locked.len()), (1, 0));
+
+ // Exercise the binary SetSecret path used by pdfs's keyring-store. Reopen
+ // the disk keyring after each update, rather than trusting a memory read.
+ for refresh in [b"fake-refresh-r2", b"fake-refresh-r3", b"fake-refresh-r4"] {
+ let secret = setup.create_dbus_secret(oo7::Secret::blob(refresh))?;
+ unlocked[0].set_secret(&secret).await?;
+ let items = setup.login_keyring().await?.items().await?;
+ assert_eq!(items[0].secret().as_bytes(), refresh);
+ }
+ eprintln!("oo7 0.7.0: all three binary SetSecret updates survived reopening the disk keyring");
+ Ok(())
+}
+
#[tokio::test]
async fn label_property() -> Result<(), Box<dyn std::error::Error>> {
let setup = TestServiceSetup::plain_session(true).await?;
+40
View File
@@ -0,0 +1,40 @@
# Violet / Copper vector branding
Drive, Stream, and Gallery share frontal violet–pink faces, shallow metallic copper backing, and narrow edge highlights. The icons are editable vector artwork with no embedded images or raster effects.
| App | Mark |
| --- | --- |
| Proton Drive for Linux | Open folder with lilac documents |
| Proton Stream | Rounded play prism |
| Proton Gallery | Stacked photo plates, mountains, and a copper sun |
## Master artwork
Edit `images/logo.svg`. It uses a 256-unit grid with transparent margins, a `mark` group, and reusable linear gradients. The copper backing extends six units up and right. SVG paths, rounded rectangles, circles, strokes, translation, and the photo clip are retained when exporting Android VectorDrawables. Unsupported SVG features cause generation to fail rather than silently change the artwork.
Earlier artwork is preserved in `images/branding-archive/`. The new assets replace the active branding without removing previous designs.
## Regeneration
```sh
python scripts/render-branding.py
python scripts/render-branding.py --check
```
Requires Python 3, librsvg (`rsvg-convert`), and ImageMagick (`magick`). Stream's TV banner also requires fontconfig and DejaVu Sans. Keep the generator identical across the three repositories; every checkout renders independently and requires no sibling checkout. Edit the canonical master rather than generated platform assets.
## Platform treatment
- Desktop SVGs and PNGs retain transparent margins and the exact approved geometry. The same colored artwork works on light and dark surfaces.
- Android adaptive icons use a pale lavender full-bleed background and a separate foreground containing the complete object. The 256-unit canvas maps to the central 64dp of the 108dp adaptive canvas; the painted geometry stays within the central safe circle. Android supplies the outer mask.
- Themed launcher icons and Stream's status-bar notification icon use a white silhouette without colored bevel highlights.
- iOS uses the same play prism over an opaque pale lavender square, exported at 1024px. The system supplies the corner mask.
- The Android TV banner pairs the play prism with the full Proton Stream name.
Keep full product names in launcher metadata. Application UI typography and photo-content icons are independent of this branding.
## Outputs
`packaging/io.narl.proton-drive-linux.svg` is installed by the desktop packages and embedded in the GTK resource bundle for in-app branding.
The Drive cover (`images/cover.svg` and `images/cover.png`) also embeds the canonical icon. The generator updates its `app-logo` group while preserving the surrounding cover layout.
Binary file not shown.

After

Width:  |  Height:  |  Size: 363 KiB

@@ -0,0 +1,156 @@
<svg width="1920" height="1080" viewBox="0 0 1920 1080" xmlns="http://www.w3.org/2000/svg">
<defs>
<linearGradient id="bg" x1="0" y1="0" x2="1920" y2="1080" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#1A1240"/>
<stop offset="1" stop-color="#0A0618"/>
</linearGradient>
<radialGradient id="glow1" cx="1390" cy="520" r="640" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#6D4AFF" stop-opacity="0.55"/>
<stop offset="0.5" stop-color="#6D4AFF" stop-opacity="0.15"/>
<stop offset="1" stop-color="#6D4AFF" stop-opacity="0"/>
</radialGradient>
<radialGradient id="glow2" cx="160" cy="1080" r="700" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#A855F7" stop-opacity="0.25"/>
<stop offset="1" stop-color="#A855F7" stop-opacity="0"/>
</radialGradient>
<pattern id="dots" width="32" height="32" patternUnits="userSpaceOnUse">
<circle cx="2" cy="2" r="1.6" fill="#FFFFFF"/>
</pattern>
<radialGradient id="dotfade" cx="1390" cy="520" r="900" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#FFFFFF" stop-opacity="1"/>
<stop offset="1" stop-color="#FFFFFF" stop-opacity="0"/>
</radialGradient>
<mask id="dotmask" maskUnits="userSpaceOnUse" x="0" y="0" width="1920" height="1080">
<rect width="1920" height="1080" fill="url(#dotfade)"/>
</mask>
<linearGradient id="title2" x1="140" y1="0" x2="760" y2="0" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#C9BBFF"/>
<stop offset="1" stop-color="#8A6CFF"/>
</linearGradient>
<!-- app logo -->
<linearGradient id="pdl-face" x1="12" y1="12" x2="116" y2="112" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#A48BFF"/>
<stop offset="0.55" stop-color="#7552FF"/>
<stop offset="1" stop-color="#5B36F2"/>
</linearGradient>
<linearGradient id="pdl-cloud" x1="0" y1="34" x2="0" y2="88" gradientUnits="userSpaceOnUse">
<stop offset="0" stop-color="#FFFFFF"/>
<stop offset="1" stop-color="#ECE6FF"/>
</linearGradient>
<mask id="pdl-cut" maskUnits="userSpaceOnUse" x="0" y="0" width="128" height="128">
<g fill="#FFFFFF">
<circle cx="66" cy="57" r="23"/>
<circle cx="42" cy="68" r="16"/>
<circle cx="88" cy="69" r="15"/>
<rect x="26" y="68" width="77" height="20" rx="10"/>
</g>
<g stroke="#000000" stroke-width="7.5" stroke-linecap="round" stroke-linejoin="round" fill="none">
<path d="M64 49v26"/>
<path d="M54.5 65.5l9.5 9.5 9.5-9.5"/>
</g>
</mask>
<filter id="logoshadow" x="-50%" y="-50%" width="200%" height="200%">
<feGaussianBlur stdDeviation="6"/>
</filter>
<filter id="chipshadow" x="-50%" y="-50%" width="200%" height="200%">
<feGaussianBlur stdDeviation="14"/>
</filter>
</defs>
<!-- background -->
<rect width="1920" height="1080" fill="url(#bg)"/>
<rect width="1920" height="1080" fill="url(#glow2)"/>
<rect width="1920" height="1080" fill="url(#glow1)"/>
<rect width="1920" height="1080" fill="url(#dots)" opacity="0.07" mask="url(#dotmask)"/>
<!-- orbit rings -->
<g fill="none" stroke="#FFFFFF">
<circle cx="1390" cy="520" r="300" stroke-opacity="0.10" stroke-width="2"/>
<circle cx="1390" cy="520" r="420" stroke-opacity="0.06" stroke-width="2" stroke-dasharray="4 14" stroke-linecap="round"/>
</g>
<!-- logo, 128 -> 384 -->
<g transform="translate(1198 328) scale(3)">
<rect x="16" y="24" width="96" height="92" rx="24" fill="#2A1080" opacity="0.8" filter="url(#logoshadow)"/>
<rect x="12" y="16" width="104" height="100" rx="26" fill="#4424C0"/>
<rect x="12" y="12" width="104" height="100" rx="26" fill="url(#pdl-face)"/>
<rect x="12.5" y="12.5" width="103" height="99" rx="25.5" fill="none" stroke="#FFFFFF" stroke-opacity="0.2"/>
<rect y="3" width="128" height="128" fill="#2E1596" fill-opacity="0.3" mask="url(#pdl-cut)"/>
<rect width="128" height="128" fill="url(#pdl-cloud)" mask="url(#pdl-cut)"/>
</g>
<!-- feature chips around the logo -->
<g font-family="Adwaita Sans" font-size="26" font-weight="600" fill="#FFFFFF">
<!-- folder, top left -->
<g transform="translate(1000 200)">
<rect x="0" y="10" width="236" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/>
<rect x="0" y="0" width="236" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/>
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#6D4AFF"/>
<path d="M8 13a2 2 0 0 1 2-2h5l2.5 2.5H26a2 2 0 0 1 2 2V25a2 2 0 0 1-2 2H10a2 2 0 0 1-2-2z" fill="#FFFFFF"/>
</g>
<text x="74" y="47">On demand</text>
</g>
<!-- sync, top right -->
<g transform="translate(1590 290)">
<rect x="0" y="10" width="164" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/>
<rect x="0" y="0" width="164" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/>
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#1EA885"/>
<g fill="none" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round">
<path d="M26 15a8.5 8.5 0 0 0-15-2"/>
<path d="M10 9v4.5h4.5"/>
<path d="M10 21a8.5 8.5 0 0 0 15 2"/>
<path d="M26 27v-4.5h-4.5"/>
</g>
</g>
<text x="74" y="47">Sync</text>
</g>
<!-- photos, bottom right -->
<g transform="translate(1560 690)">
<rect x="0" y="10" width="206" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/>
<rect x="0" y="0" width="206" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/>
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#E8618C"/>
<rect x="8" y="9" width="20" height="18" rx="3" fill="none" stroke="#FFFFFF" stroke-width="2.4"/>
<circle cx="14" cy="15" r="2" fill="#FFFFFF"/>
<path d="M9.5 25l6-6 4 4 3-3 4 4" fill="none" stroke="#FFFFFF" stroke-width="2.4" stroke-linejoin="round"/>
</g>
<text x="74" y="47">Photos</text>
</g>
<!-- terminal, bottom left -->
<g transform="translate(980 790)">
<rect x="0" y="10" width="206" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/>
<rect x="0" y="0" width="206" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/>
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#3B3F5C"/>
<path d="M9 12l6 6-6 6" fill="none" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"/>
<path d="M18 25h9" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round"/>
</g>
<text x="74" y="48" font-family="JetBrainsMono NF" font-size="25" font-weight="700">pdfs</text>
<text x="150" y="48" font-weight="500" fill="#B9B0D9">CLI</text>
</g>
</g>
<!-- text block -->
<g font-family="Adwaita Sans">
<g transform="translate(140 292)">
<rect width="410" height="48" rx="24" fill="#6D4AFF" fill-opacity="0.18" stroke="#8A6CFF" stroke-opacity="0.6" stroke-width="1.5"/>
<circle cx="28" cy="24" r="6" fill="#A48BFF"/>
<text x="46" y="32" font-size="21" font-weight="700" letter-spacing="2.4" fill="#D6CCFF">UNOFFICIAL · OPEN SOURCE</text>
</g>
<text x="134" y="478" font-size="124" font-weight="800" letter-spacing="-3" fill="#FFFFFF">Proton Drive</text>
<text x="134" y="610" font-size="124" font-weight="800" letter-spacing="-3" fill="url(#title2)">for Linux</text>
<text x="140" y="702" font-size="38" font-weight="400" fill="#B9B0D9">Your Drive as a folder, and a native GTK4 app.</text>
<text x="140" y="752" font-size="38" font-weight="400" fill="#B9B0D9">No Electron.</text>
</g>
<!-- footer -->
<g font-family="JetBrainsMono NF" font-size="24" fill="#8C83B0">
<text x="140" y="968">github.com/narrrl/proton-drive-linux</text>
</g>
<g font-family="Adwaita Sans" font-size="22" fill="#6F6894">
<text x="1780" y="968" text-anchor="end">Not affiliated with Proton AG</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 8.3 KiB

@@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128" viewBox="0 0 128 128"
role="img" aria-label="Proton Drive for Linux" data-app="drive">
<title>Proton Drive for Linux</title>
<desc>A custom faceted D with an inset mount channel, in violet warming to copper.</desc>
<!-- Canonical artwork. Regenerate platform assets with scripts/render-branding.py. -->
<defs>
<linearGradient id="face" x1="18" y1="12" x2="112" y2="116" gradientUnits="userSpaceOnUse">
<stop stop-color="#F6F2FC"/>
<stop offset="1" stop-color="#E5DDEE"/>
</linearGradient>
<linearGradient id="material" x1="31" y1="35" x2="96" y2="95" gradientUnits="userSpaceOnUse">
<stop stop-color="#9170E2"/>
<stop offset=".38" stop-color="#6D4AFF"/>
<stop offset=".6" stop-color="#7044D1"/>
<stop offset=".82" stop-color="#A66598"/>
<stop offset="1" stop-color="#B56D51"/>
</linearGradient>
</defs>
<rect x="12" y="12" width="104" height="104" rx="27" fill="url(#face)"/>
<rect x="12.75" y="12.75" width="102.5" height="102.5" rx="26.25"
fill="none" stroke="#A18CB7" stroke-width="1.5"/>
<g id="mark">
<path d="M 43.32 33.92 H 64.94 C 73.4 33.92 80.92 36.74 86.56 42.38 L 96.9 52.72 C 103.48 59.3 103.48 68.7 96.9 75.28 L 86.56 85.62 C 80.92 91.26 73.4 94.08 64.94 94.08 H 43.32 C 38.15 94.08 33.92 89.85 33.92 84.68 V 75.28 H 47.08 V 79.04 C 47.08 80.074 47.926 80.92 48.96 80.92 H 64.94 C 69.64 80.92 73.4 79.04 77.16 75.28 L 85.62 66.82 C 87.218 65.222 87.218 62.778 85.62 61.18 L 77.16 52.72 C 73.4 48.96 69.64 47.08 64.94 47.08 H 48.96 C 47.926 47.08 47.08 47.926 47.08 48.96 V 52.72 H 33.92 V 43.32 C 33.92 38.15 38.15 33.92 43.32 33.92 Z" fill="url(#material)" fill-rule="nonzero"/>
<path d="M 29.22 58.36 H 62.12 C 65.222 58.36 67.76 60.898 67.76 64 C 67.76 67.102 65.222 69.64 62.12 69.64 H 29.22 C 26.118 69.64 23.58 67.102 23.58 64 C 23.58 60.898 26.118 58.36 29.22 58.36 Z" fill="url(#material)" fill-rule="nonzero"/>
</g>
</svg>

After

Width:  |  Height:  |  Size: 2.0 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 43 KiB

After

Width:  |  Height:  |  Size: 51 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 124 KiB

After

Width:  |  Height:  |  Size: 138 KiB

BIN
View File
Binary file not shown.

Before

Width:  |  Height:  |  Size: 363 KiB

After

Width:  |  Height:  |  Size: 407 KiB

+157 -149
View File
@@ -1,156 +1,164 @@
<svg width="1920" height="1080" viewBox="0 0 1920 1080" xmlns="http://www.w3.org/2000/svg"> <?xml version="1.0" encoding="utf-8"?>
<defs> <!-- Generated by scripts/render-branding.py; edit images/logo.svg. -->
<linearGradient id="bg" x1="0" y1="0" x2="1920" y2="1080" gradientUnits="userSpaceOnUse"> <svg xmlns="http://www.w3.org/2000/svg" width="1920" height="1080" viewBox="0 0 1920 1080">
<stop offset="0" stop-color="#1A1240"/> <defs>
<stop offset="1" stop-color="#0A0618"/> <linearGradient id="bg" x1="0" y1="0" x2="1920" y2="1080" gradientUnits="userSpaceOnUse">
</linearGradient> <stop offset="0" stop-color="#1A1240" />
<radialGradient id="glow1" cx="1390" cy="520" r="640" gradientUnits="userSpaceOnUse"> <stop offset="1" stop-color="#0A0618" />
<stop offset="0" stop-color="#6D4AFF" stop-opacity="0.55"/> </linearGradient>
<stop offset="0.5" stop-color="#6D4AFF" stop-opacity="0.15"/> <radialGradient id="glow1" cx="1390" cy="520" r="640" gradientUnits="userSpaceOnUse">
<stop offset="1" stop-color="#6D4AFF" stop-opacity="0"/> <stop offset="0" stop-color="#6D4AFF" stop-opacity="0.55" />
</radialGradient> <stop offset="0.5" stop-color="#6D4AFF" stop-opacity="0.15" />
<radialGradient id="glow2" cx="160" cy="1080" r="700" gradientUnits="userSpaceOnUse"> <stop offset="1" stop-color="#6D4AFF" stop-opacity="0" />
<stop offset="0" stop-color="#A855F7" stop-opacity="0.25"/> </radialGradient>
<stop offset="1" stop-color="#A855F7" stop-opacity="0"/> <radialGradient id="glow2" cx="160" cy="1080" r="700" gradientUnits="userSpaceOnUse">
</radialGradient> <stop offset="0" stop-color="#A855F7" stop-opacity="0.25" />
<pattern id="dots" width="32" height="32" patternUnits="userSpaceOnUse"> <stop offset="1" stop-color="#A855F7" stop-opacity="0" />
<circle cx="2" cy="2" r="1.6" fill="#FFFFFF"/> </radialGradient>
</pattern> <pattern id="dots" width="32" height="32" patternUnits="userSpaceOnUse">
<radialGradient id="dotfade" cx="1390" cy="520" r="900" gradientUnits="userSpaceOnUse"> <circle cx="2" cy="2" r="1.6" fill="#FFFFFF" />
<stop offset="0" stop-color="#FFFFFF" stop-opacity="1"/> </pattern>
<stop offset="1" stop-color="#FFFFFF" stop-opacity="0"/> <radialGradient id="dotfade" cx="1390" cy="520" r="900" gradientUnits="userSpaceOnUse">
</radialGradient> <stop offset="0" stop-color="#FFFFFF" stop-opacity="1" />
<mask id="dotmask" maskUnits="userSpaceOnUse" x="0" y="0" width="1920" height="1080"> <stop offset="1" stop-color="#FFFFFF" stop-opacity="0" />
<rect width="1920" height="1080" fill="url(#dotfade)"/> </radialGradient>
</mask> <mask id="dotmask" maskUnits="userSpaceOnUse" x="0" y="0" width="1920" height="1080">
<linearGradient id="title2" x1="140" y1="0" x2="760" y2="0" gradientUnits="userSpaceOnUse"> <rect width="1920" height="1080" fill="url(#dotfade)" />
<stop offset="0" stop-color="#C9BBFF"/> </mask>
<stop offset="1" stop-color="#8A6CFF"/> <linearGradient id="title2" x1="140" y1="0" x2="760" y2="0" gradientUnits="userSpaceOnUse">
</linearGradient> <stop offset="0" stop-color="#C9BBFF" />
<stop offset="1" stop-color="#8A6CFF" />
<!-- app logo --> </linearGradient>
<linearGradient id="pdl-face" x1="12" y1="12" x2="116" y2="112" gradientUnits="userSpaceOnUse"> <filter id="chipshadow" x="-50%" y="-50%" width="200%" height="200%">
<stop offset="0" stop-color="#A48BFF"/> <feGaussianBlur stdDeviation="14" />
<stop offset="0.55" stop-color="#7552FF"/> </filter>
<stop offset="1" stop-color="#5B36F2"/> </defs>
</linearGradient> <rect width="1920" height="1080" fill="url(#bg)" />
<linearGradient id="pdl-cloud" x1="0" y1="34" x2="0" y2="88" gradientUnits="userSpaceOnUse"> <rect width="1920" height="1080" fill="url(#glow2)" />
<stop offset="0" stop-color="#FFFFFF"/> <rect width="1920" height="1080" fill="url(#glow1)" />
<stop offset="1" stop-color="#ECE6FF"/> <rect width="1920" height="1080" fill="url(#dots)" opacity="0.07" mask="url(#dotmask)" />
</linearGradient> <g fill="none" stroke="#FFFFFF">
<mask id="pdl-cut" maskUnits="userSpaceOnUse" x="0" y="0" width="128" height="128"> <circle cx="1390" cy="520" r="300" stroke-opacity="0.10" stroke-width="2" />
<g fill="#FFFFFF"> <circle cx="1390" cy="520" r="420" stroke-opacity="0.06" stroke-width="2" stroke-dasharray="4 14" stroke-linecap="round" />
<circle cx="66" cy="57" r="23"/>
<circle cx="42" cy="68" r="16"/>
<circle cx="88" cy="69" r="15"/>
<rect x="26" y="68" width="77" height="20" rx="10"/>
</g>
<g stroke="#000000" stroke-width="7.5" stroke-linecap="round" stroke-linejoin="round" fill="none">
<path d="M64 49v26"/>
<path d="M54.5 65.5l9.5 9.5 9.5-9.5"/>
</g>
</mask>
<filter id="logoshadow" x="-50%" y="-50%" width="200%" height="200%">
<feGaussianBlur stdDeviation="6"/>
</filter>
<filter id="chipshadow" x="-50%" y="-50%" width="200%" height="200%">
<feGaussianBlur stdDeviation="14"/>
</filter>
</defs>
<!-- background -->
<rect width="1920" height="1080" fill="url(#bg)"/>
<rect width="1920" height="1080" fill="url(#glow2)"/>
<rect width="1920" height="1080" fill="url(#glow1)"/>
<rect width="1920" height="1080" fill="url(#dots)" opacity="0.07" mask="url(#dotmask)"/>
<!-- orbit rings -->
<g fill="none" stroke="#FFFFFF">
<circle cx="1390" cy="520" r="300" stroke-opacity="0.10" stroke-width="2"/>
<circle cx="1390" cy="520" r="420" stroke-opacity="0.06" stroke-width="2" stroke-dasharray="4 14" stroke-linecap="round"/>
</g>
<!-- logo, 128 -> 384 -->
<g transform="translate(1198 328) scale(3)">
<rect x="16" y="24" width="96" height="92" rx="24" fill="#2A1080" opacity="0.8" filter="url(#logoshadow)"/>
<rect x="12" y="16" width="104" height="100" rx="26" fill="#4424C0"/>
<rect x="12" y="12" width="104" height="100" rx="26" fill="url(#pdl-face)"/>
<rect x="12.5" y="12.5" width="103" height="99" rx="25.5" fill="none" stroke="#FFFFFF" stroke-opacity="0.2"/>
<rect y="3" width="128" height="128" fill="#2E1596" fill-opacity="0.3" mask="url(#pdl-cut)"/>
<rect width="128" height="128" fill="url(#pdl-cloud)" mask="url(#pdl-cut)"/>
</g>
<!-- feature chips around the logo -->
<g font-family="Adwaita Sans" font-size="26" font-weight="600" fill="#FFFFFF">
<!-- folder, top left -->
<g transform="translate(1000 200)">
<rect x="0" y="10" width="236" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/>
<rect x="0" y="0" width="236" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/>
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#6D4AFF"/>
<path d="M8 13a2 2 0 0 1 2-2h5l2.5 2.5H26a2 2 0 0 1 2 2V25a2 2 0 0 1-2 2H10a2 2 0 0 1-2-2z" fill="#FFFFFF"/>
</g>
<text x="74" y="47">On demand</text>
</g> </g>
<!-- sync, top right --> <g id="app-logo" transform="translate(1198 328) scale(1.5)">
<g transform="translate(1590 290)"> <defs>
<rect x="0" y="10" width="164" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/> <linearGradient id="drive-face" x1="36" y1="212" x2="220" y2="54" gradientUnits="userSpaceOnUse">
<rect x="0" y="0" width="164" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/> <stop stop-color="#6240DA" />
<g transform="translate(22 20)"> <stop offset=".52" stop-color="#8056EF" />
<rect width="36" height="36" rx="10" fill="#1EA885"/> <stop offset="1" stop-color="#D58BDF" />
<g fill="none" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"> </linearGradient>
<path d="M26 15a8.5 8.5 0 0 0-15-2"/> <linearGradient id="drive-rear" x1="26" y1="42" x2="218" y2="220" gradientUnits="userSpaceOnUse">
<path d="M10 9v4.5h4.5"/> <stop stop-color="#8C68EE" />
<path d="M10 21a8.5 8.5 0 0 0 15 2"/> <stop offset="1" stop-color="#5533B5" />
<path d="M26 27v-4.5h-4.5"/> </linearGradient>
<linearGradient id="drive-paper" x1="60" y1="80" x2="180" y2="162" gradientUnits="userSpaceOnUse">
<stop stop-color="#E7DFFA" />
<stop offset="1" stop-color="#BDA5EF" />
</linearGradient>
<linearGradient id="drive-copper" x1="32" y1="32" x2="232" y2="224" gradientUnits="userSpaceOnUse">
<stop stop-color="#703E30" />
<stop offset=".16" stop-color="#B47456" />
<stop offset=".28" stop-color="#E6B296" />
<stop offset=".32" stop-color="#F8D8C3" />
<stop offset=".37" stop-color="#BB7C5A" />
<stop offset=".56" stop-color="#8A4D36" />
<stop offset=".69" stop-color="#D69B77" />
<stop offset=".75" stop-color="#F2C9AA" />
<stop offset=".81" stop-color="#B87956" />
<stop offset="1" stop-color="#713F30" />
</linearGradient>
<linearGradient id="drive-sun" x1="172" y1="82" x2="201" y2="112" gradientUnits="userSpaceOnUse">
<stop stop-color="#8D513A" />
<stop offset=".33" stop-color="#DDA581" />
<stop offset=".47" stop-color="#F7D8B8" />
<stop offset=".53" stop-color="#D69B74" />
<stop offset="1" stop-color="#925439" />
</linearGradient>
<linearGradient id="drive-mountain" x1="44" y1="148" x2="186" y2="218" gradientUnits="userSpaceOnUse">
<stop stop-color="#D9C9FA" />
<stop offset="1" stop-color="#A582E9" />
</linearGradient>
<linearGradient id="drive-far-mountain" x1="142" y1="152" x2="211" y2="216" gradientUnits="userSpaceOnUse">
<stop stop-color="#E8B4EB" />
<stop offset="1" stop-color="#BB7BD7" />
</linearGradient>
<clipPath id="drive-photo-clip">
<rect x="28" y="54" width="194" height="172" rx="24" />
</clipPath>
</defs>
<g id="mark">
<path d="M48 48H91Q99 48 105 54L117 66Q123 72 132 72H208Q228 72 228 92V200Q228 220 208 220H48Q28 220 28 200V68Q28 48 48 48Z" fill="url(#drive-copper)" transform="translate(6 -6)" stroke="#7D4936" stroke-width=".8" stroke-linejoin="round" />
<path d="M48 48H91Q99 48 105 54L117 66Q123 72 132 72H208Q228 72 228 92V200Q228 220 208 220H48Q28 220 28 200V68Q28 48 48 48Z" fill="url(#drive-rear)" stroke="#5E3CBD" stroke-width=".8" />
<rect x="72" y="82" width="132" height="112" rx="10" fill="url(#drive-paper)" stroke="#EFE9FC" stroke-width="1" />
<rect x="51" y="97" width="140" height="109" rx="10" fill="url(#drive-paper)" stroke="#EFE9FC" stroke-width="1" />
<path d="M48 94H89Q97 94 103 100L115 112Q121 118 130 118H208Q228 118 228 138V206Q228 226 208 226H48Q28 226 28 206V114Q28 94 48 94Z" fill="url(#drive-copper)" transform="translate(6 -6)" stroke="#7D4936" stroke-width=".8" stroke-linejoin="round" />
<path d="M48 94H89Q97 94 103 100L115 112Q121 118 130 118H208Q228 118 228 138V206Q228 226 208 226H48Q28 226 28 206V114Q28 94 48 94Z" fill="url(#drive-face)" stroke="#5936B7" stroke-width=".9" />
<path d="M32 113Q32 98 48 98H89Q95 98 100 103L112 115Q120 122 130 122H208Q224 122 224 138" fill="none" stroke="#F3DDF9" stroke-opacity=".52" stroke-width="1.5" stroke-linecap="round" />
</g> </g>
</g>
<text x="74" y="47">Sync</text>
</g> </g>
<!-- photos, bottom right --> <g font-family="Adwaita Sans" font-size="26" font-weight="600" fill="#FFFFFF">
<g transform="translate(1560 690)"> <g transform="translate(1000 200)">
<rect x="0" y="10" width="206" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/> <rect x="0" y="10" width="236" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)" />
<rect x="0" y="0" width="206" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/> <rect x="0" y="0" width="236" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5" />
<g transform="translate(22 20)"> <g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#E8618C"/> <rect width="36" height="36" rx="10" fill="#6D4AFF" />
<rect x="8" y="9" width="20" height="18" rx="3" fill="none" stroke="#FFFFFF" stroke-width="2.4"/> <path d="M8 13a2 2 0 0 1 2-2h5l2.5 2.5H26a2 2 0 0 1 2 2V25a2 2 0 0 1-2 2H10a2 2 0 0 1-2-2z" fill="#FFFFFF" />
<circle cx="14" cy="15" r="2" fill="#FFFFFF"/> </g>
<path d="M9.5 25l6-6 4 4 3-3 4 4" fill="none" stroke="#FFFFFF" stroke-width="2.4" stroke-linejoin="round"/> <text x="74" y="47">On demand</text>
</g> </g>
<text x="74" y="47">Photos</text> <g transform="translate(1590 290)">
<rect x="0" y="10" width="164" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)" />
<rect x="0" y="0" width="164" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5" />
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#1EA885" />
<g fill="none" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round">
<path d="M26 15a8.5 8.5 0 0 0-15-2" />
<path d="M10 9v4.5h4.5" />
<path d="M10 21a8.5 8.5 0 0 0 15 2" />
<path d="M26 27v-4.5h-4.5" />
</g>
</g>
<text x="74" y="47">Sync</text>
</g>
<g transform="translate(1560 690)">
<rect x="0" y="10" width="206" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)" />
<rect x="0" y="0" width="206" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5" />
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#E8618C" />
<rect x="8" y="9" width="20" height="18" rx="3" fill="none" stroke="#FFFFFF" stroke-width="2.4" />
<circle cx="14" cy="15" r="2" fill="#FFFFFF" />
<path d="M9.5 25l6-6 4 4 3-3 4 4" fill="none" stroke="#FFFFFF" stroke-width="2.4" stroke-linejoin="round" />
</g>
<text x="74" y="47">Photos</text>
</g>
<g transform="translate(980 790)">
<rect x="0" y="10" width="206" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)" />
<rect x="0" y="0" width="206" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5" />
<g transform="translate(22 20)">
<rect width="36" height="36" rx="10" fill="#3B3F5C" />
<path d="M9 12l6 6-6 6" fill="none" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round" />
<path d="M18 25h9" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" />
</g>
<text x="74" y="48" font-family="JetBrainsMono NF" font-size="25" font-weight="700">pdfs</text>
<text x="150" y="48" font-weight="500" fill="#B9B0D9">CLI</text>
</g>
</g> </g>
<!-- terminal, bottom left --> <g font-family="Adwaita Sans">
<g transform="translate(980 790)"> <g transform="translate(140 292)">
<rect x="0" y="10" width="206" height="76" rx="22" fill="#000000" opacity="0.35" filter="url(#chipshadow)"/> <rect width="410" height="48" rx="24" fill="#6D4AFF" fill-opacity="0.18" stroke="#8A6CFF" stroke-opacity="0.6" stroke-width="1.5" />
<rect x="0" y="0" width="206" height="76" rx="22" fill="#2A2058" fill-opacity="0.85" stroke="#FFFFFF" stroke-opacity="0.14" stroke-width="1.5"/> <circle cx="28" cy="24" r="6" fill="#A48BFF" />
<g transform="translate(22 20)"> <text x="46" y="32" font-size="21" font-weight="700" letter-spacing="2.4" fill="#D6CCFF">UNOFFICIAL · OPEN SOURCE</text>
<rect width="36" height="36" rx="10" fill="#3B3F5C"/> </g>
<path d="M9 12l6 6-6 6" fill="none" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"/> <text x="134" y="478" font-size="124" font-weight="800" letter-spacing="-3" fill="#FFFFFF">Proton Drive</text>
<path d="M18 25h9" stroke="#FFFFFF" stroke-width="2.6" stroke-linecap="round"/> <text x="134" y="610" font-size="124" font-weight="800" letter-spacing="-3" fill="url(#title2)">for Linux</text>
</g> <text x="140" y="702" font-size="38" font-weight="400" fill="#B9B0D9">Your Drive as a folder, and a native GTK4 app.</text>
<text x="74" y="48" font-family="JetBrainsMono NF" font-size="25" font-weight="700">pdfs</text> <text x="140" y="752" font-size="38" font-weight="400" fill="#B9B0D9">No Electron.</text>
<text x="150" y="48" font-weight="500" fill="#B9B0D9">CLI</text>
</g> </g>
</g> <g font-family="JetBrainsMono NF" font-size="24" fill="#8C83B0">
<text x="140" y="968">github.com/narrrl/proton-drive-linux</text>
<!-- text block --> </g>
<g font-family="Adwaita Sans"> <g font-family="Adwaita Sans" font-size="22" fill="#6F6894">
<g transform="translate(140 292)"> <text x="1780" y="968" text-anchor="end">Not affiliated with Proton AG</text>
<rect width="410" height="48" rx="24" fill="#6D4AFF" fill-opacity="0.18" stroke="#8A6CFF" stroke-opacity="0.6" stroke-width="1.5"/>
<circle cx="28" cy="24" r="6" fill="#A48BFF"/>
<text x="46" y="32" font-size="21" font-weight="700" letter-spacing="2.4" fill="#D6CCFF">UNOFFICIAL · OPEN SOURCE</text>
</g> </g>
<text x="134" y="478" font-size="124" font-weight="800" letter-spacing="-3" fill="#FFFFFF">Proton Drive</text>
<text x="134" y="610" font-size="124" font-weight="800" letter-spacing="-3" fill="url(#title2)">for Linux</text>
<text x="140" y="702" font-size="38" font-weight="400" fill="#B9B0D9">Your Drive as a folder, and a native GTK4 app.</text>
<text x="140" y="752" font-size="38" font-weight="400" fill="#B9B0D9">No Electron.</text>
</g>
<!-- footer -->
<g font-family="JetBrainsMono NF" font-size="24" fill="#8C83B0">
<text x="140" y="968">github.com/narrrl/proton-drive-linux</text>
</g>
<g font-family="Adwaita Sans" font-size="22" fill="#6F6894">
<text x="1780" y="968" text-anchor="end">Not affiliated with Proton AG</text>
</g>
</svg> </svg>

Before

Width:  |  Height:  |  Size: 8.3 KiB

After

Width:  |  Height:  |  Size: 11 KiB

BIN
View File
Binary file not shown.

Before

Width:  |  Height:  |  Size: 52 KiB

After

Width:  |  Height:  |  Size: 115 KiB

Loaded 100 of 135 files, more files were not shown because too many files have changed in this diff. Show more