mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-22 10:33:31 +01:00
Compare commits
39
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d0f9681593 | ||
|
|
f141d88d97 | ||
|
|
795dd7edb0 | ||
|
|
7be4c7db1e | ||
|
|
2b5d6f2436 | ||
|
|
ff8ee9d997 | ||
|
|
aa26a8e1aa | ||
|
|
9027a1465f | ||
|
|
66b634e4a1 | ||
|
|
ae46e1e544 | ||
|
|
2c4c95812f | ||
|
|
2bf1622793 | ||
|
|
2ea189f1d9 | ||
|
|
8af671d8ed | ||
|
|
9047bdd741 | ||
|
|
ca20e5ed22 | ||
|
|
10bc9a6a37 | ||
|
|
890adbc189 | ||
|
|
960c6afe2d | ||
|
|
1b545ba369 | ||
|
|
b854c1e819 | ||
|
|
3fbe651f94 | ||
|
|
61b992cb48 | ||
|
|
08e0e80f34 | ||
|
|
0488ccd5f6 | ||
|
|
62d16e03cf | ||
|
|
c92f78b5c8 | ||
|
|
b034e1d4e3 | ||
|
|
e15e1dcc76 | ||
|
|
43b76d4791 | ||
|
|
734e9040fb | ||
|
|
01e3860741 | ||
|
|
7a65e7011f | ||
|
|
233d9e9e51 | ||
|
|
73c4e1f6bf | ||
|
|
26272cda6c | ||
|
|
370abd58dc | ||
|
|
24594b24ae | ||
|
|
04f0713012 |
No files matched your search
@@ -159,6 +159,9 @@ jobs:
|
||||
install -Dm644 packaging/io.narl.proton-drive-linux.policy deb/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy
|
||||
cp packaging/proton-drive.service deb/usr/lib/systemd/user/
|
||||
cp LICENSE deb/usr/share/licenses/proton-drive-linux/
|
||||
# The offline Places basemap, already fetched for the tarball.
|
||||
scripts/fetch-basemap.sh
|
||||
install -Dm644 data/basemap-v1.pmtiles deb/usr/share/proton-drive-linux/basemap-v1.pmtiles
|
||||
po/build.sh deb/usr/share/locale
|
||||
packaging/completions.sh target/release/pdfs deb/usr/share
|
||||
|
||||
@@ -191,6 +194,8 @@ jobs:
|
||||
|
||||
- name: Package Fedora package (.rpm)
|
||||
run: |
|
||||
# The in-tree spec build installs the basemap from data/.
|
||||
scripts/fetch-basemap.sh
|
||||
# Sanitize version (replace hyphens with dots for RPM compatibility)
|
||||
RPM_VERSION=$(echo "${{ env.VERSION }}" | tr '-' '.')
|
||||
|
||||
|
||||
@@ -65,6 +65,7 @@ jobs:
|
||||
git config --global --add safe.directory "$GITHUB_WORKSPACE"
|
||||
VERSION=$(grep -m1 '^version' Cargo.toml | cut -d'"' -f2)
|
||||
SHORT=${GITHUB_SHA::7}
|
||||
scripts/fetch-basemap.sh
|
||||
mkdir -p rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS,BUILDROOT,db}
|
||||
rpmbuild -bb \
|
||||
--nodeps \
|
||||
|
||||
@@ -5,3 +5,4 @@
|
||||
/rpmbuild
|
||||
/result
|
||||
/result-*
|
||||
/data/*.pmtiles
|
||||
Generated
+225
-72
@@ -2,6 +2,22 @@
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "ab_glyph"
|
||||
version = "0.2.32"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"
|
||||
dependencies = [
|
||||
"ab_glyph_rasterizer",
|
||||
"owned_ttf_parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ab_glyph_rasterizer"
|
||||
version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
|
||||
|
||||
[[package]]
|
||||
name = "adler2"
|
||||
version = "2.0.1"
|
||||
@@ -182,6 +198,17 @@ version = "1.0.104"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
|
||||
|
||||
[[package]]
|
||||
name = "apple-native-keyring-store"
|
||||
version = "1.0.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2b350bfd03649e07aa05c0a81b3e15934374e585c98204a57e20b9d49f49bb9a"
|
||||
dependencies = [
|
||||
"keyring-core",
|
||||
"log",
|
||||
"security-framework",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "arbitrary"
|
||||
version = "1.5.0"
|
||||
@@ -221,6 +248,12 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "arrayref"
|
||||
version = "0.3.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
|
||||
|
||||
[[package]]
|
||||
name = "arrayvec"
|
||||
version = "0.7.8"
|
||||
@@ -3414,6 +3447,15 @@ dependencies = [
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "owned_ttf_parser"
|
||||
version = "0.25.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b"
|
||||
dependencies = [
|
||||
"ttf-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "p256"
|
||||
version = "0.13.2"
|
||||
@@ -3618,23 +3660,23 @@ dependencies = [
|
||||
"dbus-secret-service-keyring-store",
|
||||
"directories",
|
||||
"ignore",
|
||||
"kamadak-exif",
|
||||
"keyring-core",
|
||||
"libc",
|
||||
"parking_lot 0.13.0",
|
||||
"proton-auth-rs",
|
||||
"proton-base-rs",
|
||||
"proton-drive-rs",
|
||||
"proton-gallery-rs",
|
||||
"proton-sdk",
|
||||
"rusqlite",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha1 0.11.0",
|
||||
"sha2 0.11.1",
|
||||
"shell-words",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tracing",
|
||||
"zeroize",
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3655,9 +3697,10 @@ dependencies = [
|
||||
"notify",
|
||||
"parking_lot 0.13.0",
|
||||
"pdfs-core",
|
||||
"pg-app",
|
||||
"pg-core",
|
||||
"proton-drive-rs",
|
||||
"proton-gallery-app-rs",
|
||||
"proton-gallery-rs",
|
||||
"proton-media-rs",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -3683,7 +3726,8 @@ dependencies = [
|
||||
"libadwaita",
|
||||
"pangocairo",
|
||||
"pdfs-core",
|
||||
"pg-core",
|
||||
"proton-gallery-rs",
|
||||
"proton-map-rs",
|
||||
"reqwest",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -3708,65 +3752,6 @@ version = "2.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
|
||||
|
||||
[[package]]
|
||||
name = "pg-app"
|
||||
version = "0.3.0"
|
||||
source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"hex",
|
||||
"pg-core",
|
||||
"pg-drive",
|
||||
"proton-drive-rs",
|
||||
"proton-sdk",
|
||||
"serde_json",
|
||||
"sha2 0.11.1",
|
||||
"tempfile",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tracing",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pg-core"
|
||||
version = "0.3.0"
|
||||
source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386"
|
||||
dependencies = [
|
||||
"aes-gcm 0.11.1",
|
||||
"async-trait",
|
||||
"getrandom 0.4.3",
|
||||
"hex",
|
||||
"rusqlite",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2 0.11.1",
|
||||
"tempfile",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tokio-util",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pg-drive"
|
||||
version = "0.3.0"
|
||||
source = "git+https://github.com/narrrl/proton-gallery.git?rev=858d2446f71214ec5357eb8b543d6b82abf47386#858d2446f71214ec5357eb8b543d6b82abf47386"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"hex",
|
||||
"pg-core",
|
||||
"proton-drive-rs",
|
||||
"proton-sdk",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2 0.11.1",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tracing",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pgp"
|
||||
version = "0.21.0"
|
||||
@@ -3972,10 +3957,36 @@ dependencies = [
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-drive-rs"
|
||||
version = "0.12.1"
|
||||
name = "proton-auth-rs"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d05ad4be849ce2104759631063dd06867fbe6b6f0e5c37a172a84b5a90203fa7"
|
||||
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc"
|
||||
dependencies = [
|
||||
"apple-native-keyring-store",
|
||||
"dbus-secret-service",
|
||||
"dbus-secret-service-keyring-store",
|
||||
"keyring-core",
|
||||
"thiserror 2.0.21",
|
||||
"tracing",
|
||||
"windows-native-keyring-store",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-base-rs"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "451151bb1025ea5cb362f69e2bfb2d45afed603e5c6daa3dc752333a7c29c878"
|
||||
dependencies = [
|
||||
"rusqlite",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-drive-rs"
|
||||
version = "0.12.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "670bfcf0eeb15886c962c18c76dbac976236e4377bfe073eb2360dc1ce448da2"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"base64 0.23.1",
|
||||
@@ -4000,10 +4011,102 @@ dependencies = [
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-sdk"
|
||||
version = "0.12.1"
|
||||
name = "proton-gallery-app-rs"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "80c381e9066c0bca3c32597df2e902eecaa4c6e05e202e70ec9d0ac2eec78bfe"
|
||||
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.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e374d2053de5df0e6b0797df65d0d024dbce35f7aedfefd4a656896a0495dc9b"
|
||||
dependencies = [
|
||||
"aes-gcm 0.11.1",
|
||||
"async-trait",
|
||||
"getrandom 0.4.3",
|
||||
"hex",
|
||||
"kamadak-exif",
|
||||
"proton-base-rs",
|
||||
"rusqlite",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2 0.11.1",
|
||||
"tempfile",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tokio-util",
|
||||
"tracing",
|
||||
"zeroize",
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-map-rs"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a8440e8a25b89e1c3d3c0747285ebc558e84a019b237307111f21306f183e78d"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
"tiny-skia",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-media-rs"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f03aa6c403e4f2f7a8f9a444dff1e268d8bc9bcaf1d0d953cc3a1312d798f1ef"
|
||||
dependencies = [
|
||||
"lru",
|
||||
"sha2 0.11.1",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tracing",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-sdk"
|
||||
version = "0.12.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f578a9d920cef3f6c4da611793001fe6d2ed81face13c45f5e721274b1945f7d"
|
||||
dependencies = [
|
||||
"aes-gcm 0.11.1",
|
||||
"async-trait",
|
||||
@@ -5034,6 +5137,12 @@ version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
|
||||
|
||||
[[package]]
|
||||
name = "strict-num"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
|
||||
|
||||
[[package]]
|
||||
name = "strsim"
|
||||
version = "0.11.1"
|
||||
@@ -5139,7 +5248,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
||||
dependencies = [
|
||||
"fastrand",
|
||||
"getrandom 0.3.4",
|
||||
"getrandom 0.4.3",
|
||||
"once_cell",
|
||||
"rustix",
|
||||
"windows-sys 0.61.2",
|
||||
@@ -5208,6 +5317,31 @@ dependencies = [
|
||||
"zune-jpeg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tiny-skia"
|
||||
version = "0.11.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
|
||||
dependencies = [
|
||||
"arrayref",
|
||||
"arrayvec",
|
||||
"bytemuck",
|
||||
"cfg-if",
|
||||
"log",
|
||||
"tiny-skia-path",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tiny-skia-path"
|
||||
version = "0.11.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
|
||||
dependencies = [
|
||||
"arrayref",
|
||||
"bytemuck",
|
||||
"strict-num",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinystr"
|
||||
version = "0.8.5"
|
||||
@@ -5445,6 +5579,12 @@ version = "0.2.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
|
||||
|
||||
[[package]]
|
||||
name = "ttf-parser"
|
||||
version = "0.25.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
|
||||
|
||||
[[package]]
|
||||
name = "twofish"
|
||||
version = "0.7.1"
|
||||
@@ -5857,6 +5997,19 @@ version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-native-keyring-store"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "063426e76fdec7438d56bb777f67e318a84a25c707b07e575cb8b78e10c028f8"
|
||||
dependencies = [
|
||||
"byteorder",
|
||||
"keyring-core",
|
||||
"regex",
|
||||
"windows-sys 0.61.2",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-result"
|
||||
version = "0.4.1"
|
||||
|
||||
+10
-4
@@ -15,10 +15,11 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
|
||||
categories = ["filesystem", "command-line-utilities"]
|
||||
|
||||
[workspace.dependencies]
|
||||
proton-sdk = { version = "0.12.1" }
|
||||
proton-drive-rs = { version = "0.12.1" }
|
||||
pg-app = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" }
|
||||
pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" }
|
||||
proton-sdk = { version = "0.12.4" }
|
||||
proton-drive-rs = { version = "0.12.4" }
|
||||
proton-gallery-app-rs = "0.1.0"
|
||||
proton-gallery-rs = "0.1.5"
|
||||
proton-map-rs = "0.1.0"
|
||||
chrono = { version = "0.4", default-features = false, features = ["std"] }
|
||||
|
||||
# Internal crates.
|
||||
@@ -63,6 +64,11 @@ rusqlite = { version = "0.41", features = ["bundled"] }
|
||||
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and
|
||||
# with no `target` it matches items v3 wrote, so existing logins survive.
|
||||
keyring-core = "1"
|
||||
# The keyring store all three apps share: reconnects after a Secret Service
|
||||
# restart (B285) and replaces items instead of editing them (B291).
|
||||
proton-auth-rs = "0.1.1"
|
||||
proton-base-rs = "0.1"
|
||||
proton-media-rs = "0.1.1"
|
||||
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
|
||||
# The same Secret Service client the store wraps, used directly to replace an
|
||||
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
|
||||
|
||||
@@ -193,7 +193,8 @@ Proton Drive Linux is free and built in spare time. If it saves you a few headac
|
||||
Released under the [MIT License](LICENSE).
|
||||
|
||||
The Places map uses [GeoNames](https://www.geonames.org/) data (CC BY 4.0) and
|
||||
[Natural Earth](https://www.naturalearthdata.com/) outlines (public domain). The optional street
|
||||
[Natural Earth](https://www.naturalearthdata.com/) land, water and borders (public domain), drawn
|
||||
through [proton-map-rs](https://github.com/narrrl/proton-rs). The optional street
|
||||
map comes from [OpenFreeMap](https://openfreemap.org/), © [OpenStreetMap](https://www.openstreetmap.org/copyright)
|
||||
contributors.
|
||||
|
||||
|
||||
+144
-14
@@ -1,6 +1,6 @@
|
||||
//! `pdfs` — command-line front-end for the Proton Drive Linux client.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::FileTypeExt;
|
||||
@@ -158,8 +158,12 @@ enum Command {
|
||||
#[arg(long)]
|
||||
forget: bool,
|
||||
},
|
||||
/// Forget the stored session.
|
||||
Logout,
|
||||
/// Forget the stored session. Asks first while changes are still queued.
|
||||
Logout {
|
||||
/// Do not ask first.
|
||||
#[arg(long)]
|
||||
yes: bool,
|
||||
},
|
||||
/// Show account login state, and mount status if a daemon is running.
|
||||
Status,
|
||||
/// List every local Proton Drive location.
|
||||
@@ -432,7 +436,14 @@ enum Command {
|
||||
Diagnostics,
|
||||
/// List what is in the account's trash, with the uids the restore and
|
||||
/// delete-forever commands take.
|
||||
Trash,
|
||||
Trash {
|
||||
/// Group the trash by the folder each item was deleted from.
|
||||
#[arg(long, conflicts_with = "folder")]
|
||||
by_folder: bool,
|
||||
/// List what a trashed folder holds, by its uid.
|
||||
#[arg(long, value_name = "UID")]
|
||||
folder: Option<String>,
|
||||
},
|
||||
/// Restore trashed items, by uid, to the folders they were trashed from.
|
||||
Restore {
|
||||
/// Node uids (`volume~link`), as printed by `pdfs trash`.
|
||||
@@ -857,6 +868,13 @@ enum SyncCmd {
|
||||
},
|
||||
/// List uploads and changes not yet on Proton Drive.
|
||||
Queue,
|
||||
/// Wait until every queued change is on Proton Drive. Exits 0 once nothing
|
||||
/// is left, 3 when what is left needs you (see `sync issues`), 4 on timeout.
|
||||
Flush {
|
||||
/// Give up after this many seconds.
|
||||
#[arg(long)]
|
||||
timeout: Option<u64>,
|
||||
},
|
||||
/// List queued changes Proton Drive refused or that keep failing, and what to do.
|
||||
Issues,
|
||||
/// Save the content of a queued upload (by id from `sync queue`) to a file.
|
||||
@@ -1047,7 +1065,7 @@ fn main() -> Result<()> {
|
||||
cli.command,
|
||||
Command::Login { .. }
|
||||
| Command::Unlock { .. }
|
||||
| Command::Logout
|
||||
| Command::Logout { .. }
|
||||
| Command::Mount { .. }
|
||||
| Command::Daemon { .. }
|
||||
) {
|
||||
@@ -1057,7 +1075,7 @@ fn main() -> Result<()> {
|
||||
Command::Login { username, remember } => cmd_login(username, remember),
|
||||
Command::Unlock { remember } => cmd_unlock(remember),
|
||||
Command::Lock { forget } => cmd_lock(forget),
|
||||
Command::Logout => cmd_logout(),
|
||||
Command::Logout { yes } => cmd_logout(yes),
|
||||
Command::Status => cmd_status(),
|
||||
Command::Locations => cmd_locations(),
|
||||
Command::Mount { mountpoint } => cmd_mount(mountpoint),
|
||||
@@ -1128,7 +1146,7 @@ fn main() -> Result<()> {
|
||||
Command::Upload { sources, parent } => cmd_upload(sources, parent),
|
||||
Command::Transfers => cmd_transfers(),
|
||||
Command::Diagnostics => cmd_diagnostics(),
|
||||
Command::Trash => cmd_trash(),
|
||||
Command::Trash { by_folder, folder } => cmd_trash(by_folder, folder),
|
||||
Command::Restore { uids } => cmd_restore(uids),
|
||||
Command::DeleteForever { uids } => cmd_delete_forever(uids),
|
||||
Command::EmptyTrash => cmd_empty_trash(),
|
||||
@@ -1362,6 +1380,7 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
|
||||
})?)?
|
||||
}
|
||||
SyncCmd::Queue => return cmd_sync_queue(),
|
||||
SyncCmd::Flush { timeout } => return cmd_sync_flush(timeout),
|
||||
SyncCmd::Issues => return cmd_sync_issues(),
|
||||
SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest),
|
||||
SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down),
|
||||
@@ -1465,6 +1484,71 @@ fn cmd_sync_queue() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `pdfs sync flush`: wait for the queue to drain.
|
||||
///
|
||||
/// Failed changes are retried at once rather than after their backoff. The
|
||||
/// wait ends early, with exit code 3, when everything left is waiting on the
|
||||
/// user: refused by Drive, failing again and again, or a temporary file
|
||||
/// waiting for its final name. Paused or offline, it keeps waiting and says
|
||||
/// why.
|
||||
fn cmd_sync_flush(timeout: Option<u64>) -> Result<()> {
|
||||
const POLL: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
let deadline =
|
||||
timeout.map(|secs| std::time::Instant::now() + std::time::Duration::from_secs(secs));
|
||||
ok_or_bail(control_request(CtlRequest::RetryPendingOp { id: None })?)?;
|
||||
let mut last_line = String::new();
|
||||
loop {
|
||||
let items = match control_request(CtlRequest::ListPendingOps)? {
|
||||
CtlResponse::PendingOps { items } => items,
|
||||
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
|
||||
other => bail!("unexpected response: {other:?}"),
|
||||
};
|
||||
let waiting = items
|
||||
.iter()
|
||||
.filter(|op| !op.parked && !op.failing && op.issue.is_none())
|
||||
.count();
|
||||
if items.is_empty() {
|
||||
finish_line(&last_line);
|
||||
println!("Everything is on Proton Drive.");
|
||||
return Ok(());
|
||||
}
|
||||
if waiting == 0 {
|
||||
finish_line(&last_line);
|
||||
eprintln!(
|
||||
"{} queued change(s) need you before they can be sent. See `pdfs sync issues`.",
|
||||
items.len()
|
||||
);
|
||||
std::process::exit(3);
|
||||
}
|
||||
let reason = match control_request(CtlRequest::Status)? {
|
||||
CtlResponse::Status { paused: true, .. } => " (sync is paused; `pdfs sync resume`)",
|
||||
CtlResponse::Status { online: false, .. } => " (offline; waiting for Proton Drive)",
|
||||
_ => "",
|
||||
};
|
||||
let line = format!("{waiting} change(s) left to send{reason}");
|
||||
if line != last_line {
|
||||
if !last_line.is_empty() {
|
||||
print!("\r\x1b[2K");
|
||||
}
|
||||
print!("{line}");
|
||||
last_line = line;
|
||||
}
|
||||
if deadline.is_some_and(|deadline| std::time::Instant::now() >= deadline) {
|
||||
finish_line(&last_line);
|
||||
eprintln!("Timed out with {waiting} change(s) still queued.");
|
||||
std::process::exit(4);
|
||||
}
|
||||
std::thread::sleep(POLL);
|
||||
}
|
||||
}
|
||||
|
||||
/// End a progress line so the next message starts on its own.
|
||||
fn finish_line(last_line: &str) {
|
||||
if !last_line.is_empty() {
|
||||
println!();
|
||||
}
|
||||
}
|
||||
|
||||
/// `pdfs sync issues`: the queued changes that need the user, and what to do.
|
||||
fn cmd_sync_issues() -> Result<()> {
|
||||
let response = control_request(CtlRequest::ListPendingOps)?;
|
||||
@@ -2298,7 +2382,27 @@ fn key_state_name() -> &'static str {
|
||||
}
|
||||
}
|
||||
|
||||
fn cmd_logout() -> Result<()> {
|
||||
fn cmd_logout(yes: bool) -> Result<()> {
|
||||
// Queued changes stay staged on this computer and are sent after the next
|
||||
// sign-in, but until then they exist nowhere else. Without a running
|
||||
// daemon there is no count to show.
|
||||
if !yes
|
||||
&& let Ok(CtlResponse::Status {
|
||||
pending_uploads,
|
||||
pending_changes,
|
||||
parked_uploads,
|
||||
..
|
||||
}) = control_request(CtlRequest::Status)
|
||||
{
|
||||
let queued = pending_uploads + pending_changes + parked_uploads;
|
||||
if queued > 0 {
|
||||
println!(
|
||||
"{queued} change(s) are not on Proton Drive yet. They stay on this computer and are \
|
||||
sent after you sign in again. Run `pdfs sync flush` first to send them now."
|
||||
);
|
||||
confirm("Sign out anyway?")?;
|
||||
}
|
||||
}
|
||||
if auth::logout()? {
|
||||
println!("Signed out: the session is ended on Proton and cleared here.");
|
||||
} else {
|
||||
@@ -3520,17 +3624,37 @@ fn cmd_diagnostics() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn cmd_trash() -> Result<()> {
|
||||
let response = control_request(CtlRequest::ListTrash)?;
|
||||
fn cmd_trash(by_folder: bool, folder: Option<String>) -> Result<()> {
|
||||
let request = match folder {
|
||||
Some(uid) => CtlRequest::ListTrashedFolder { uid },
|
||||
None => CtlRequest::ListTrash,
|
||||
};
|
||||
let response = control_request(request)?;
|
||||
if emit_json(&response)? {
|
||||
return Ok(());
|
||||
}
|
||||
match response {
|
||||
CtlResponse::Entries { entries } if entries.is_empty() => println!("(trash is empty)"),
|
||||
CtlResponse::Entries { entries } if entries.is_empty() => println!("(nothing here)"),
|
||||
CtlResponse::Entries { entries } if by_folder => {
|
||||
let mut groups: BTreeMap<String, Vec<&pdfs_core::control::DirEntry>> = BTreeMap::new();
|
||||
for e in entries.iter().filter(|e| e.trashed_parent.is_none()) {
|
||||
let folder = match e.trashed_from.as_deref() {
|
||||
None => "(unknown folder)".to_string(),
|
||||
Some("") => "/".to_string(),
|
||||
Some(path) => format!("/{path}"),
|
||||
};
|
||||
groups.entry(folder).or_default().push(e);
|
||||
}
|
||||
for (folder, items) in groups {
|
||||
println!("{folder} ({} item(s))", items.len());
|
||||
for e in items {
|
||||
print_trashed(e, " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
CtlResponse::Entries { entries } => {
|
||||
for e in entries {
|
||||
let kind = if e.is_dir { "d" } else { "-" };
|
||||
println!("{kind} {:>12} {} [{}]", e.size, e.name, e.uid);
|
||||
for e in &entries {
|
||||
print_trashed(e, "");
|
||||
}
|
||||
}
|
||||
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
|
||||
@@ -3539,6 +3663,11 @@ fn cmd_trash() -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn print_trashed(e: &pdfs_core::control::DirEntry, indent: &str) {
|
||||
let kind = if e.is_dir { "d" } else { "-" };
|
||||
println!("{indent}{kind} {:>12} {} [{}]", e.size, e.name, e.uid);
|
||||
}
|
||||
|
||||
fn cmd_restore(uids: Vec<String>) -> Result<()> {
|
||||
match control_request(CtlRequest::Restore { uids })? {
|
||||
CtlResponse::Ok { message } => println!("{message}"),
|
||||
@@ -4994,6 +5123,7 @@ mod login_wait_tests {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
};
|
||||
assert_eq!(shared_by_line(&entry), None, "no invitation, no line");
|
||||
|
||||
@@ -12,6 +12,7 @@ description = "Core auth/session/config for the Proton Drive Linux client"
|
||||
[dependencies]
|
||||
proton-sdk.workspace = true
|
||||
proton-drive-rs.workspace = true
|
||||
proton-gallery-rs.workspace = true
|
||||
chrono.workspace = true
|
||||
tokio.workspace = true
|
||||
serde.workspace = true
|
||||
@@ -22,10 +23,10 @@ directories.workspace = true
|
||||
ignore.workspace = true
|
||||
shell-words.workspace = true
|
||||
sha2.workspace = true
|
||||
sha1.workspace = true
|
||||
zip.workspace = true
|
||||
rusqlite.workspace = true
|
||||
keyring-core.workspace = true
|
||||
proton-auth-rs = { workspace = true, features = ["keyring"] }
|
||||
proton-base-rs.workspace = true
|
||||
dbus-secret-service-keyring-store.workspace = true
|
||||
dbus-secret-service.workspace = true
|
||||
parking_lot.workspace = true
|
||||
@@ -33,4 +34,3 @@ async-trait.workspace = true
|
||||
libc.workspace = true
|
||||
zeroize.workspace = true
|
||||
base64.workspace = true
|
||||
exif = { version = "0.6", package = "kamadak-exif" }
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
|
@@ -337,6 +337,12 @@ impl Demo {
|
||||
Request::ListDir { path } => Response::Entries {
|
||||
entries: self.dir(path),
|
||||
},
|
||||
Request::ListTrash => Response::Entries {
|
||||
entries: self.trash(),
|
||||
},
|
||||
Request::ListTrashedFolder { uid } => Response::Entries {
|
||||
entries: self.trashed_folder(uid),
|
||||
},
|
||||
Request::ReserveFileThumbGeneration => Response::FileThumbGeneration { generation: 1 },
|
||||
Request::FileThumbs { items, .. } => Response::Thumbs {
|
||||
items: items
|
||||
@@ -591,6 +597,59 @@ impl Demo {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The trash: things deleted from a few folders, and a deleted folder with
|
||||
/// a file deleted from it before it went.
|
||||
fn trash(&self) -> Vec<DirEntry> {
|
||||
let item = |name: &str, size: u64, hours: i64, from: &str| DirEntry {
|
||||
name: name.into(),
|
||||
is_dir: size == 0,
|
||||
size,
|
||||
modified: self.now - 40 * DAY,
|
||||
uid: format!("demo-trash~{from}/{name}"),
|
||||
trashed_at: self.now - hours * 3600,
|
||||
trashed_from: Some(from.into()),
|
||||
..Default::default()
|
||||
};
|
||||
let mut inside = item("Draft 3.odt", 48_120, 30, "");
|
||||
inside.uid = "demo-trash~Old drafts/Draft 3.odt".into();
|
||||
inside.trashed_from = None;
|
||||
inside.trashed_parent = Some("demo-trash~Work/Old drafts".into());
|
||||
vec![
|
||||
item("Budget 2025.ods", 51_200, 2, "Documents"),
|
||||
item("Scan 0042.pdf", 1_204_331, 5, "Documents"),
|
||||
item("Scan 0043.pdf", 1_198_002, 5, "Documents"),
|
||||
item("IMG_2041.jpg", 3_402_112, 20, "Pictures/Lisbon"),
|
||||
item("IMG_2042.jpg", 3_311_870, 20, "Pictures/Lisbon"),
|
||||
item("IMG_2043.jpg", 3_587_004, 20, "Pictures/Lisbon"),
|
||||
item("Old drafts", 0, 26, "Work"),
|
||||
item("Meeting notes (copy).md", 6_120, 50, ""),
|
||||
item("Invoice 118.pdf", 88_341, 80, "Taxes/2025"),
|
||||
inside,
|
||||
]
|
||||
}
|
||||
|
||||
/// What the deleted folder in [`Self::trash`] holds.
|
||||
fn trashed_folder(&self, uid: &str) -> Vec<DirEntry> {
|
||||
if uid != "demo-trash~Work/Old drafts" {
|
||||
return Vec::new();
|
||||
}
|
||||
let file = |name: &str, size: u64| DirEntry {
|
||||
name: name.into(),
|
||||
size,
|
||||
modified: self.now - 50 * DAY,
|
||||
uid: format!("demo-trash~Old drafts/{name}"),
|
||||
trashed_parent: Some(uid.into()),
|
||||
..Default::default()
|
||||
};
|
||||
let mut gone = file("Draft 3.odt", 48_120);
|
||||
gone.trashed_at = self.now - 30 * 3600;
|
||||
vec![
|
||||
file("Draft 1.odt", 41_002),
|
||||
file("Draft 2.odt", 44_870),
|
||||
gone,
|
||||
]
|
||||
}
|
||||
|
||||
/// My files: folders first, then a few files, some of them pictures with
|
||||
/// thumbnails. Any folder below the root holds the same few documents.
|
||||
fn dir(&self, path: &str) -> Vec<DirEntry> {
|
||||
|
||||
+105
-170
@@ -28,6 +28,7 @@ use std::time::Duration;
|
||||
use base64::Engine as _;
|
||||
use base64::engine::general_purpose::STANDARD as BASE64;
|
||||
use keyring_core::Entry;
|
||||
use proton_auth_rs::{KeyringStore, SecretStore};
|
||||
use proton_drive_rs::{KeySalt, ProtonDriveClient};
|
||||
use proton_sdk::account::KeyPassphrases;
|
||||
use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
|
||||
@@ -35,6 +36,7 @@ use proton_sdk::cache::EncryptedCacheRepository;
|
||||
use proton_sdk::config::ProtonClientConfiguration;
|
||||
use proton_sdk::error::ProtonError;
|
||||
use proton_sdk::http::Tokens;
|
||||
use proton_sdk::login::{self, LoginError, Step};
|
||||
use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters};
|
||||
use proton_sdk::telemetry::TracingTelemetry;
|
||||
use serde::{Deserialize, Serialize};
|
||||
@@ -125,82 +127,28 @@ fn client_config() -> ProtonClientConfiguration {
|
||||
|
||||
/// Run `op` on the session's keyring entry.
|
||||
fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
|
||||
with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op)
|
||||
Ok(keyring().with_entry(KEYRING_USER, op)?)
|
||||
}
|
||||
|
||||
/// Run `op` on the entry `service`/`user`, reconnecting once if the Secret
|
||||
/// Service fails the call.
|
||||
/// The process's keyring, connected on first use.
|
||||
///
|
||||
/// The store holds one D-Bus connection and one Secret Service session for the
|
||||
/// whole process. The session lives in the provider's memory: once the provider
|
||||
/// restarts (oo7's unit restarts it on failure, and both oo7 and gnome-keyring
|
||||
/// can be `--replace`d), every read and write on the old session fails with
|
||||
/// `NoSession`, for as long as this process runs. A daemon then keeps refreshed
|
||||
/// tokens only in memory, and a cold boot loses them (`docs/BUGS.md` B285). A
|
||||
/// platform failure therefore drops the store, and the call is made once more
|
||||
/// on a new one. A locked keyring, a dismissed prompt or a missing entry is
|
||||
/// not the connection's fault and comes back as it is.
|
||||
fn with_keyring_entry<T>(
|
||||
service: &str,
|
||||
user: &str,
|
||||
op: impl Fn(&Entry) -> keyring_core::Result<T>,
|
||||
) -> Result<T> {
|
||||
let store = keyring_store()?;
|
||||
match op(&Entry::new(service, user)?) {
|
||||
Err(keyring_core::Error::PlatformFailure(e)) => {
|
||||
tracing::warn!(
|
||||
error = %e,
|
||||
"the Secret Service failed this process's connection; reconnecting"
|
||||
);
|
||||
drop_keyring_store(&store);
|
||||
keyring_store()?;
|
||||
Ok(op(&Entry::new(service, user)?)?)
|
||||
/// One connection for the whole process; when the Secret Service fails it
|
||||
/// (a restarted provider forgets the session, `docs/BUGS.md` B285), the call
|
||||
/// reconnects and is made once more. A changed session replaces its item
|
||||
/// instead of editing it (B291). Both live in `proton-auth-rs`.
|
||||
fn keyring() -> &'static KeyringStore {
|
||||
static STORE: std::sync::OnceLock<KeyringStore> = std::sync::OnceLock::new();
|
||||
STORE.get_or_init(|| {
|
||||
#[cfg(not(test))]
|
||||
{
|
||||
KeyringStore::new(KEYRING_SERVICE)
|
||||
}
|
||||
result => Ok(result?),
|
||||
}
|
||||
}
|
||||
|
||||
/// Held while the default store is looked at and replaced, so that threads
|
||||
/// failing at the same time drop the broken store once and share its
|
||||
/// replacement.
|
||||
static KEYRING_STORE: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
|
||||
|
||||
/// The process's Secret Service store, connected now if there is none.
|
||||
///
|
||||
/// Connected lazily rather than once at startup so a session bus that was not
|
||||
/// up yet on the first attempt is tried again on the next one.
|
||||
fn keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
|
||||
let _swap = KEYRING_STORE.lock();
|
||||
if let Some(store) = keyring_core::get_default_store() {
|
||||
return Ok(store);
|
||||
}
|
||||
let store = connect_keyring_store()?;
|
||||
keyring_core::set_default_store(Arc::clone(&store));
|
||||
Ok(store)
|
||||
}
|
||||
|
||||
/// Forget `failed`, unless another thread has already replaced it.
|
||||
fn drop_keyring_store(failed: &Arc<keyring_core::CredentialStore>) {
|
||||
let _swap = KEYRING_STORE.lock();
|
||||
if keyring_core::get_default_store().is_some_and(|store| Arc::ptr_eq(&store, failed)) {
|
||||
keyring_core::unset_default_store();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(test))]
|
||||
fn connect_keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
|
||||
Ok(dbus_secret_service_keyring_store::Store::new()?)
|
||||
}
|
||||
|
||||
/// The tests' in-memory store when they set one, so a reconnect finds the
|
||||
/// same entries; the real Secret Service otherwise.
|
||||
#[cfg(test)]
|
||||
fn connect_keyring_store() -> Result<Arc<keyring_core::CredentialStore>> {
|
||||
tests::KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst);
|
||||
match tests::MOCK_STORE.lock().clone() {
|
||||
Some(store) => Ok(store),
|
||||
None => Ok(dbus_secret_service_keyring_store::Store::new()?),
|
||||
}
|
||||
#[cfg(test)]
|
||||
{
|
||||
KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store))
|
||||
.replace_items(|| tests::MOCK_STORE.lock().is_none())
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// What the user answered when asked for the mailbox password.
|
||||
@@ -332,74 +280,56 @@ pub async fn login_verified(
|
||||
get_totp: impl Fn() -> Result<String>,
|
||||
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
|
||||
) -> Result<()> {
|
||||
let password = Zeroizing::new(password.to_owned());
|
||||
let session = ProtonApiSession::begin_verified(
|
||||
client_config(),
|
||||
username,
|
||||
password.as_bytes(),
|
||||
verification,
|
||||
)
|
||||
.await
|
||||
.map_err(classify_verification_gate);
|
||||
let mut session = session?;
|
||||
|
||||
if session.is_waiting_for_second_factor() {
|
||||
let code = get_totp()?;
|
||||
session.apply_second_factor_code(code.trim()).await?;
|
||||
}
|
||||
|
||||
// Grab the key salts while this access token still has the `locked` scope:
|
||||
// after its first refresh it never will again, and without them no later
|
||||
// resume can unlock the key chain. See `StoredSession::key_salts`.
|
||||
let key_salts = ProtonDriveClient::new(&session, Vec::new())
|
||||
.account()
|
||||
.key_salts()
|
||||
.await?;
|
||||
|
||||
// A single-password account's mailbox password is the login password. A
|
||||
// two-password one has a second secret the user must type, and it is checked
|
||||
// against the account now — a typo found at login is a retry, found later it
|
||||
// is a daemon that never mounts.
|
||||
let (passphrases, remember) = match session.password_mode() {
|
||||
PasswordMode::Single => (
|
||||
derive_verified(&session, password.as_bytes(), key_salts.clone()).await?,
|
||||
true,
|
||||
),
|
||||
PasswordMode::Dual => {
|
||||
let mut attempt = 0;
|
||||
loop {
|
||||
let mailbox = get_mailbox(attempt)?;
|
||||
match derive_verified(&session, mailbox.password.as_bytes(), key_salts.clone())
|
||||
.await
|
||||
{
|
||||
Ok(passphrases) => break (passphrases, mailbox.remember),
|
||||
Err(Error::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
|
||||
attempt += 1;
|
||||
}
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
// The sequence is `proton_sdk::login`, shared with the other Proton
|
||||
// apps. It reads the key salts before unlocking, while this access token
|
||||
// still has the `locked` scope: after its first refresh it never will
|
||||
// again, and without them no later resume can unlock the key chain. See
|
||||
// `StoredSession::key_salts`.
|
||||
let mut step = login::begin(client_config(), username, password, verification)
|
||||
.await
|
||||
.map_err(sign_in_error)?;
|
||||
let (unlocked, remember) = loop {
|
||||
step = match step {
|
||||
Step::SecondFactor(pending) => {
|
||||
let code = get_totp()?;
|
||||
pending.second_factor(&code).await.map_err(sign_in_error)?
|
||||
}
|
||||
}
|
||||
// A single-password account's mailbox password is the login password.
|
||||
Step::Unlock(pending) => break (pending.unlock().await.map_err(sign_in_error)?, true),
|
||||
// A two-password one has a second secret the user must type, and it is
|
||||
// checked against the account now — a typo found at login is a retry,
|
||||
// found later it is a daemon that never mounts.
|
||||
Step::MailboxPassword(pending) => {
|
||||
let mut attempt = 0;
|
||||
break loop {
|
||||
let mailbox = get_mailbox(attempt)?;
|
||||
match pending.mailbox_password(&mailbox.password).await {
|
||||
Ok(unlocked) => break (unlocked, mailbox.remember),
|
||||
Err(LoginError::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
|
||||
attempt += 1;
|
||||
}
|
||||
Err(e) => return Err(sign_in_error(e)),
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
let tokens = session.current_tokens().await;
|
||||
register_refresh_handler(&session, tokens.refresh_token.clone());
|
||||
let tokens = unlocked.resume_parameters().await;
|
||||
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
|
||||
let stored = StoredSession {
|
||||
session_id: session.session_id().as_str().to_owned(),
|
||||
username: session.username().to_owned(),
|
||||
user_id: session.user_id().as_str().to_owned(),
|
||||
session_id: tokens.session_id.as_str().to_owned(),
|
||||
username: tokens.username,
|
||||
user_id: tokens.user_id.as_str().to_owned(),
|
||||
access_token: tokens.access_token,
|
||||
refresh_token: tokens.refresh_token,
|
||||
scopes: session.scopes().to_vec(),
|
||||
password_mode: match session.password_mode() {
|
||||
PasswordMode::Single => 1,
|
||||
PasswordMode::Dual => 2,
|
||||
},
|
||||
scopes: tokens.scopes,
|
||||
password_mode: tokens.password_mode.to_wire() as u8,
|
||||
mailbox_password: String::new(),
|
||||
key_salts,
|
||||
key_salts: unlocked.key_salts,
|
||||
key_passphrases: None,
|
||||
};
|
||||
keep_passphrases(stored, &passphrases, remember)
|
||||
keep_passphrases(stored, &unlocked.key_passphrases, remember)
|
||||
}
|
||||
|
||||
/// Derive the key passphrases from `mailbox` and prove they unlock the account.
|
||||
@@ -473,52 +403,34 @@ fn decode_secret(secret: &[u8]) -> Option<KeyPassphrases> {
|
||||
decode(&serde_json::from_slice(secret).ok()?)
|
||||
}
|
||||
|
||||
/// Lift a human-verification gate out of the generic API error into the typed
|
||||
/// variant a front-end can act on.
|
||||
/// A failed sign-in step as this crate's error.
|
||||
///
|
||||
/// Only a gate that names a solvable method is converted. A `9001` with no
|
||||
/// `Details`, or one offering only `email`/`sms`, stays a plain API error:
|
||||
/// promoting it would send the UI to open a verification page it cannot
|
||||
/// complete, which reads to the user as a hang rather than a refusal.
|
||||
fn classify_verification_gate(e: ProtonError) -> Error {
|
||||
let ProtonError::Api(api) = &e else {
|
||||
return e.into();
|
||||
};
|
||||
match api.human_verification() {
|
||||
Some(hv) if hv.supports_captcha() => Error::HumanVerificationRequired(Box::new(hv)),
|
||||
_ => e.into(),
|
||||
/// A blocked, refused or wrong-code attempt goes back to the Proton error it
|
||||
/// came from, which is what the front-ends word themselves. Only a gate that
|
||||
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that
|
||||
/// offers only `email`/`sms` stays a plain API error, because sending the UI to
|
||||
/// open a page it cannot complete reads as a hang rather than a refusal.
|
||||
fn sign_in_error(e: LoginError) -> Error {
|
||||
match e {
|
||||
LoginError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
|
||||
LoginError::SecurityKeyOnly => Error::SecurityKeyOnly,
|
||||
LoginError::Blocked(api) | LoginError::Rejected(api) | LoginError::WrongCode(api) => {
|
||||
Error::Proton(ProtonError::Api(api))
|
||||
}
|
||||
LoginError::WrongMailboxPassword => Error::WrongMailboxPassword,
|
||||
LoginError::Proton(e) => e.into(),
|
||||
other => Error::Other(other.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Save `stored` to the keyring.
|
||||
///
|
||||
/// An existing entry is replaced by a new item rather than edited, because
|
||||
/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the
|
||||
/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the
|
||||
/// fallback: for the first save, and whenever replacing is not possible.
|
||||
/// Save the session. An existing entry is replaced by a new item rather than
|
||||
/// edited, because oo7 before 0.7.0 keeps an edit only in memory and a reboot
|
||||
/// brings the spent refresh token back (`docs/BUGS.md` B291).
|
||||
fn write_stored(stored: &StoredSession) -> Result<()> {
|
||||
let json = Zeroizing::new(serde_json::to_string(stored)?);
|
||||
if replace_items() {
|
||||
match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) {
|
||||
crate::secretservice::Replaced::Saved => return Ok(()),
|
||||
crate::secretservice::Replaced::Skipped(why) => {
|
||||
tracing::debug!(%why, "not replacing the keyring item; writing it in place");
|
||||
}
|
||||
}
|
||||
}
|
||||
with_keyring(|entry| entry.set_password(&json))
|
||||
}
|
||||
|
||||
/// Whether [`write_stored`] talks to the Secret Service directly: always,
|
||||
/// except in tests that use the in-memory store.
|
||||
#[cfg(not(test))]
|
||||
fn replace_items() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn replace_items() -> bool {
|
||||
tests::MOCK_STORE.lock().is_none()
|
||||
Ok(keyring().set(KEYRING_USER, &json)?)
|
||||
}
|
||||
|
||||
/// A short, one-way tag for a refresh token, for the log: enough to tell
|
||||
@@ -1324,9 +1236,30 @@ mod tests {
|
||||
let store: Arc<keyring_core::CredentialStore> = keyring_core::mock::Store::new().unwrap();
|
||||
*MOCK_STORE.lock() = Some(Arc::clone(&store));
|
||||
keyring_core::set_default_store(store);
|
||||
keyring().disconnect();
|
||||
turn
|
||||
}
|
||||
|
||||
/// The tests' in-memory store when they set one, so a reconnect finds the
|
||||
/// same entries; the real Secret Service otherwise.
|
||||
pub(super) fn connect_keyring_store() -> keyring_core::Result<Arc<keyring_core::CredentialStore>>
|
||||
{
|
||||
KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst);
|
||||
match MOCK_STORE.lock().clone() {
|
||||
Some(store) => Ok(store),
|
||||
None => Ok(dbus_secret_service_keyring_store::Store::new()?),
|
||||
}
|
||||
}
|
||||
|
||||
/// Run `op` on the entry `service`/`user` of the real Secret Service.
|
||||
fn with_keyring_entry<T>(
|
||||
store: &KeyringStore,
|
||||
user: &str,
|
||||
op: impl Fn(&Entry) -> keyring_core::Result<T>,
|
||||
) -> Result<T> {
|
||||
Ok(store.with_entry(user, op)?)
|
||||
}
|
||||
|
||||
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
|
||||
|
||||
/// The in-memory store a reconnect hands out, so it finds the same
|
||||
@@ -1427,7 +1360,8 @@ mod tests {
|
||||
let _turn = KEYRING.lock();
|
||||
*MOCK_STORE.lock() = None;
|
||||
keyring_core::unset_default_store();
|
||||
let (service, user) = ("pdfs-test", "restart");
|
||||
let user = "restart";
|
||||
let service = &KeyringStore::with_connector("pdfs-test", Arc::new(connect_keyring_store));
|
||||
|
||||
with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
|
||||
let status = std::process::Command::new("sh")
|
||||
@@ -1468,6 +1402,7 @@ mod tests {
|
||||
let _turn = KEYRING.lock();
|
||||
*MOCK_STORE.lock() = None;
|
||||
keyring_core::unset_default_store();
|
||||
keyring().disconnect();
|
||||
|
||||
for refresh in ["r1", "r2", "r3"] {
|
||||
write_stored(&stored_with(refresh)).unwrap();
|
||||
|
||||
@@ -457,26 +457,7 @@ fn load_config_at(path: &Path) -> AppConfig {
|
||||
/// [`AppDirs::save_config`] for the file at `path`.
|
||||
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
|
||||
refuse_to_replace_unreadable(path)?;
|
||||
let parent = path
|
||||
.parent()
|
||||
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
|
||||
std::fs::create_dir_all(parent)?;
|
||||
let nonce = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|duration| duration.as_nanos())
|
||||
.unwrap_or(0);
|
||||
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
|
||||
use std::os::unix::fs::OpenOptionsExt as _;
|
||||
let mut file = std::fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.mode(0o600)
|
||||
.open(&tmp)?;
|
||||
use std::io::Write as _;
|
||||
file.write_all(&serde_json::to_vec_pretty(config)?)?;
|
||||
file.sync_all()?;
|
||||
std::fs::rename(&tmp, path)?;
|
||||
std::fs::File::open(parent)?.sync_all()?;
|
||||
proton_base_rs::atomic::write(path, &serde_json::to_vec_pretty(config)?)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -621,15 +602,8 @@ impl AppDirs {
|
||||
use std::io::Read as _;
|
||||
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
|
||||
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
|
||||
let parent = path
|
||||
.parent()
|
||||
.ok_or_else(|| Error::Other("machine id path has no parent".into()))?;
|
||||
std::fs::create_dir_all(parent)?;
|
||||
let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
|
||||
std::fs::write(&tmp, format!("{id}\n"))?;
|
||||
std::fs::File::open(&tmp)?.sync_all()?;
|
||||
std::fs::rename(&tmp, &path)?;
|
||||
std::fs::File::open(parent)?.sync_all()?;
|
||||
// Not secret, and other tools may read it; keep it world-readable.
|
||||
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?;
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
|
||||
@@ -515,6 +515,13 @@ pub enum Request {
|
||||
/// its `uid` — the handle for [`Request::Restore`] and
|
||||
/// [`Request::DeleteForever`] — and its `path` is empty.
|
||||
ListTrash,
|
||||
/// List what a trashed folder holds, by the folder's `uid`. Replies with
|
||||
/// [`Response::Entries`]; each entry's `trashed_parent` is that folder.
|
||||
/// The contents went to the trash with the folder, so only the entries
|
||||
/// [`Request::ListTrash`] also lists can be restored on their own.
|
||||
ListTrashedFolder {
|
||||
uid: String,
|
||||
},
|
||||
/// Restore trashed nodes, by uid, to the folders they were trashed from.
|
||||
/// Replies with [`Response::Ok`].
|
||||
Restore {
|
||||
@@ -1566,8 +1573,8 @@ pub struct DirEntry {
|
||||
#[serde(default)]
|
||||
pub shared_by_unverified: bool,
|
||||
/// When a [`Request::ListTrash`] entry went to the trash, epoch seconds; 0
|
||||
/// when unknown, and for anything not in the trash. The API does not report
|
||||
/// it to this client, so the daemon notes when it first saw the node there.
|
||||
/// when unknown, and for anything not in the trash. Taken from the server;
|
||||
/// when it gives none, the daemon notes when it first saw the node there.
|
||||
#[serde(default)]
|
||||
pub trashed_at: i64,
|
||||
/// The folder a [`Request::ListTrash`] entry goes back to on restore, as a
|
||||
@@ -1575,6 +1582,11 @@ pub struct DirEntry {
|
||||
/// not known, and for anything not in the trash.
|
||||
#[serde(default)]
|
||||
pub trashed_from: Option<String>,
|
||||
/// The trashed folder a [`Request::ListTrash`] entry was trashed inside, by
|
||||
/// uid, when that folder is in the trash too; `None` otherwise. Lets a
|
||||
/// front end show the trash as folders.
|
||||
#[serde(default)]
|
||||
pub trashed_parent: Option<String>,
|
||||
/// Why Drive refused a change queued on the node, for a [`Request::ListDir`]
|
||||
/// entry; `None` otherwise.
|
||||
#[serde(default)]
|
||||
@@ -1740,27 +1752,6 @@ pub enum PhotoKind {
|
||||
Raw,
|
||||
}
|
||||
|
||||
/// File-name extensions that denote a video, matched case-insensitively.
|
||||
const VIDEO_EXTS: &[&str] = &[
|
||||
"mkv", "mp4", "mov", "avi", "webm", "m4v", "flv", "wmv", "mpg", "mpeg", "ts", "3gp", "m2ts",
|
||||
"mts", "ogv",
|
||||
];
|
||||
|
||||
/// File-name extensions that denote a camera raw. The server media type for
|
||||
/// these is frequently a generic `application/octet-stream`, so the extension is
|
||||
/// the authoritative signal.
|
||||
const RAW_EXTS: &[&str] = &[
|
||||
"cr2", "cr3", "nef", "nrw", "arw", "srf", "sr2", "dng", "raf", "orf", "rw2", "srw", "pef",
|
||||
"raw", "rwl", "iiq", "3fr", "dcr", "kdc", "mrw", "x3f",
|
||||
];
|
||||
|
||||
/// File-name extensions that denote a ready-to-view still photo. Listed so a
|
||||
/// known image name classifies as a photo outright, without deferring to a media
|
||||
/// type that might disagree.
|
||||
const PHOTO_EXTS: &[&str] = &[
|
||||
"jpg", "jpeg", "png", "gif", "webp", "heic", "heif", "avif", "bmp", "tif", "tiff",
|
||||
];
|
||||
|
||||
impl PhotoKind {
|
||||
/// Classify a photo from what the daemon knows about it. A recognised
|
||||
/// file-name extension is authoritative — it is reliable even before the
|
||||
@@ -1768,26 +1759,11 @@ impl PhotoKind {
|
||||
/// useless generic — so the media type is only consulted for names that carry
|
||||
/// no extension we know. Anything still unresolved is a still photo.
|
||||
pub fn classify(name: Option<&str>, media_type: Option<&str>) -> PhotoKind {
|
||||
if let Some(ext) = name
|
||||
.and_then(|n| n.rsplit_once('.'))
|
||||
.map(|(_, e)| e.to_ascii_lowercase())
|
||||
{
|
||||
if RAW_EXTS.contains(&ext.as_str()) {
|
||||
return PhotoKind::Raw;
|
||||
}
|
||||
if VIDEO_EXTS.contains(&ext.as_str()) {
|
||||
return PhotoKind::Video;
|
||||
}
|
||||
if PHOTO_EXTS.contains(&ext.as_str()) {
|
||||
return PhotoKind::Photo;
|
||||
}
|
||||
match proton_gallery_rs::grouping::MediaClass::classify(name, media_type) {
|
||||
proton_gallery_rs::grouping::MediaClass::Photo => PhotoKind::Photo,
|
||||
proton_gallery_rs::grouping::MediaClass::Video => PhotoKind::Video,
|
||||
proton_gallery_rs::grouping::MediaClass::Raw => PhotoKind::Raw,
|
||||
}
|
||||
if let Some(mt) = media_type
|
||||
&& mt.starts_with("video/")
|
||||
{
|
||||
return PhotoKind::Video;
|
||||
}
|
||||
PhotoKind::Photo
|
||||
}
|
||||
|
||||
/// The stable integer this kind is persisted as (see the `kind` column of the
|
||||
@@ -3196,7 +3172,7 @@ mod tests {
|
||||
/// videos back to the expensive whole-file path.
|
||||
#[test]
|
||||
fn photo_kind_recognises_every_supported_video_extension() {
|
||||
for ext in VIDEO_EXTS {
|
||||
for ext in proton_gallery_rs::grouping::VIDEO_EXTENSIONS {
|
||||
let lower = format!("movie.{ext}");
|
||||
let upper = format!("MOVIE.{}", ext.to_ascii_uppercase());
|
||||
assert_eq!(
|
||||
@@ -3661,6 +3637,9 @@ mod tests {
|
||||
fn trash_requests_roundtrip() {
|
||||
let reqs = [
|
||||
Request::ListTrash,
|
||||
Request::ListTrashedFolder {
|
||||
uid: "vol~folder".into(),
|
||||
},
|
||||
Request::Restore {
|
||||
uids: vec!["vol~link".into(), "vol~other".into()],
|
||||
},
|
||||
|
||||
@@ -11,7 +11,7 @@ use super::Db;
|
||||
use crate::Result;
|
||||
|
||||
/// Current schema version. Bump on every forward migration added below.
|
||||
pub(super) const SCHEMA_VERSION: i64 = 46;
|
||||
pub(super) const SCHEMA_VERSION: i64 = 47;
|
||||
|
||||
impl Db {
|
||||
pub(super) fn migrate(&self) -> Result<()> {
|
||||
@@ -501,6 +501,16 @@ impl Db {
|
||||
tx.execute_batch(MIGRATION_V46_ALBUM_PHOTOS)?;
|
||||
}
|
||||
}
|
||||
if current < 47 {
|
||||
let has_trash: bool = tx.query_row(
|
||||
"SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name = 'trash'",
|
||||
[],
|
||||
|row| row.get::<_, i64>(0).map(|n| n > 0),
|
||||
)?;
|
||||
if has_trash {
|
||||
tx.execute_batch(MIGRATION_V47)?;
|
||||
}
|
||||
}
|
||||
tx.execute(
|
||||
"INSERT INTO sync_state (key, value) VALUES ('schema_version', ?1)
|
||||
ON CONFLICT(key) DO UPDATE SET value = excluded.value",
|
||||
@@ -1480,3 +1490,12 @@ const MIGRATION_V46_ALBUM_PHOTOS: &str = "
|
||||
ALTER TABLE album_photos ADD COLUMN resolved INTEGER NOT NULL DEFAULT 0;
|
||||
UPDATE album_photos SET resolved=1 WHERE name IS NOT NULL;
|
||||
";
|
||||
|
||||
/// Index the trash by parent, for browsing it by folder. The rows are dropped
|
||||
/// so the next refresh reads them again with the time each was trashed, which
|
||||
/// earlier builds did not get from the server and made up instead.
|
||||
const MIGRATION_V47: &str = "
|
||||
CREATE INDEX IF NOT EXISTS trash_parent ON trash(parent_uid);
|
||||
DELETE FROM trash;
|
||||
DELETE FROM sync_state WHERE key IN ('trash_synced_ms', 'trash_complete_ms');
|
||||
";
|
||||
@@ -5,6 +5,8 @@ use rusqlite::{Connection, OptionalExtension, Transaction, params};
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use proton_gallery_rs::grouping::{Grouped, group_photos, name_stem};
|
||||
|
||||
use super::Db;
|
||||
use crate::Result;
|
||||
|
||||
@@ -121,135 +123,6 @@ fn capture_day(conn: &rusqlite::Connection, capture_time: i64) -> Option<String>
|
||||
.flatten()
|
||||
}
|
||||
|
||||
/// The file name without its extension, lowercased — `IMG_1234.CR2` and
|
||||
/// `IMG_1234.JPG` share `img_1234` — with the camera's own part-of-a-shot
|
||||
/// marker removed, so the two files a raw capture writes share a stem too.
|
||||
fn name_stem(name: Option<&str>) -> Option<String> {
|
||||
let name = name?;
|
||||
let stem = match name.rsplit_once('.') {
|
||||
Some((stem, _)) if !stem.is_empty() => stem,
|
||||
_ => name,
|
||||
};
|
||||
let stem = stem.to_ascii_lowercase();
|
||||
Some(strip_shot_marker(&stem).to_string())
|
||||
}
|
||||
|
||||
/// Drop a `.RAW-NN.ROLE` marker from a stem.
|
||||
///
|
||||
/// Pixel stores one raw capture as `PXL_20260919_000625670.RAW-01.COVER.jpg`
|
||||
/// and `PXL_20260919_000625670.RAW-02.ORIGINAL.dng`: one shot, two files, two
|
||||
/// stems that differ in exactly the part naming which file of the shot this is.
|
||||
/// Cutting the marker off is what lets rule 2 see the pair. The check is narrow
|
||||
/// on purpose — digits, then a single role word — so an ordinary name that
|
||||
/// happens to contain `.raw-` keeps its stem.
|
||||
fn strip_shot_marker(stem: &str) -> &str {
|
||||
let Some(at) = stem.rfind(".raw-") else {
|
||||
return stem;
|
||||
};
|
||||
let rest = &stem[at + ".raw-".len()..];
|
||||
let Some((index, role)) = rest.split_once('.') else {
|
||||
return stem;
|
||||
};
|
||||
let marked = !index.is_empty()
|
||||
&& index.bytes().all(|b| b.is_ascii_digit())
|
||||
&& !role.is_empty()
|
||||
&& role.bytes().all(|b| b.is_ascii_alphabetic());
|
||||
if marked { &stem[..at] } else { stem }
|
||||
}
|
||||
|
||||
/// One entry of the grouping pass: what rule 2 needs, plus what choosing a
|
||||
/// representative needs.
|
||||
struct Grouped {
|
||||
uid: String,
|
||||
kind: crate::control::PhotoKind,
|
||||
main_uid: Option<String>,
|
||||
day: Option<String>,
|
||||
stem: Option<String>,
|
||||
}
|
||||
|
||||
/// Which group each photo belongs to, and which member of it the gallery shows.
|
||||
///
|
||||
/// Precedence, as agreed:
|
||||
///
|
||||
/// 1. The server's own relation — a photo with a `main_photo_uid` joins that
|
||||
/// photo's group. The server knows about live photos and bursts; we do not
|
||||
/// have to guess at them.
|
||||
/// 2. Otherwise, same capture day **and** same file-name stem **and** one of the
|
||||
/// two is a camera raw while the other is not. That is the RAW+JPEG pair a
|
||||
/// camera writes, and the differing-kind clause keeps two JPEGs that happen
|
||||
/// to share a name apart.
|
||||
/// 3. Otherwise the photo is its own group.
|
||||
///
|
||||
/// The representative is the non-raw member when the group has one — a JPEG
|
||||
/// decodes in milliseconds and is what the person expects to see — and the
|
||||
/// earliest member in server order otherwise.
|
||||
fn group_photos(entries: &[Grouped]) -> Vec<String> {
|
||||
let mut parent: Vec<usize> = (0..entries.len()).collect();
|
||||
fn find(parent: &mut [usize], mut i: usize) -> usize {
|
||||
while parent[i] != i {
|
||||
parent[i] = parent[parent[i]];
|
||||
i = parent[i];
|
||||
}
|
||||
i
|
||||
}
|
||||
let union = |parent: &mut [usize], a: usize, b: usize| {
|
||||
let (a, b) = (find(parent, a), find(parent, b));
|
||||
if a != b {
|
||||
parent[b] = a;
|
||||
}
|
||||
};
|
||||
|
||||
let index: HashMap<&str, usize> = entries
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, e)| (e.uid.as_str(), i))
|
||||
.collect();
|
||||
for (i, entry) in entries.iter().enumerate() {
|
||||
if let Some(main) = entry.main_uid.as_deref()
|
||||
&& let Some(&j) = index.get(main)
|
||||
{
|
||||
union(&mut parent, j, i);
|
||||
}
|
||||
}
|
||||
|
||||
// Rule 2 needs only one pass: everything sharing a day and a stem lands in
|
||||
// the same bucket, and the raw / non-raw split is checked pairwise there.
|
||||
let mut by_name: HashMap<(&str, &str), Vec<usize>> = HashMap::new();
|
||||
for (i, entry) in entries.iter().enumerate() {
|
||||
if let (Some(day), Some(stem)) = (entry.day.as_deref(), entry.stem.as_deref()) {
|
||||
by_name.entry((day, stem)).or_default().push(i);
|
||||
}
|
||||
}
|
||||
let is_raw = |i: usize| entries[i].kind == crate::control::PhotoKind::Raw;
|
||||
for bucket in by_name.values() {
|
||||
for (n, &i) in bucket.iter().enumerate() {
|
||||
for &j in &bucket[n + 1..] {
|
||||
if is_raw(i) != is_raw(j) {
|
||||
union(&mut parent, i, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Representative per root, then the key every member carries.
|
||||
let mut representative: HashMap<usize, usize> = HashMap::new();
|
||||
for i in 0..entries.len() {
|
||||
let root = find(&mut parent, i);
|
||||
match representative.get(&root).copied() {
|
||||
Some(current) if !is_raw(current) || is_raw(i) => {}
|
||||
_ => {
|
||||
representative.insert(root, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
(0..entries.len())
|
||||
.map(|i| {
|
||||
let root = find(&mut parent, i);
|
||||
entries[representative[&root]].uid.clone()
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The columns every photo read selects, with the group aggregates joined in.
|
||||
/// `g.n` is how many photos the group holds and `g.raw` whether any of them is a
|
||||
/// camera raw file — one query rather than a second lookup per tile.
|
||||
@@ -483,7 +356,8 @@ impl Db {
|
||||
Ok((
|
||||
Grouped {
|
||||
uid: r.get(0)?,
|
||||
kind: crate::control::PhotoKind::from_i64(r.get(1)?),
|
||||
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()),
|
||||
@@ -640,7 +514,7 @@ impl Db {
|
||||
.iter()
|
||||
.map(|(row, carried, kind)| Grouped {
|
||||
uid: row.uid.clone(),
|
||||
kind: *kind,
|
||||
raw: *kind == crate::control::PhotoKind::Raw,
|
||||
main_uid: carried.main_uid.clone(),
|
||||
day: capture_day(&tx, row.capture_time),
|
||||
stem: name_stem(carried.name.as_deref()),
|
||||
|
||||
@@ -650,6 +650,54 @@ fn trash_replace_lists_folders_first() {
|
||||
assert!(db.trash_list().unwrap().is_empty());
|
||||
}
|
||||
|
||||
fn stored_trash(uid: &str, name: &str, trashed_at: Option<i64>) -> StoredTrash {
|
||||
StoredTrash {
|
||||
uid: uid.into(),
|
||||
name: name.into(),
|
||||
is_dir: false,
|
||||
size: 1,
|
||||
mtime: 1,
|
||||
parent_uid: None,
|
||||
trashed_at,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trash_upsert_keeps_other_rows_and_retain_drops_unlisted_ones() {
|
||||
let db = Db::open_in_memory().unwrap();
|
||||
db.trash_upsert(&[
|
||||
stored_trash("a", "a.txt", Some(1)),
|
||||
stored_trash("b", "b.txt", None),
|
||||
])
|
||||
.unwrap();
|
||||
// A later refresh adds what is new without touching what it kept.
|
||||
db.trash_upsert(&[
|
||||
stored_trash("c", "c.txt", Some(3)),
|
||||
stored_trash("b", "b2.txt", Some(2)),
|
||||
])
|
||||
.unwrap();
|
||||
let mut names: Vec<String> = db
|
||||
.trash_list()
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|i| i.name)
|
||||
.collect();
|
||||
names.sort();
|
||||
assert_eq!(names, ["a.txt", "b2.txt", "c.txt"]);
|
||||
|
||||
// Rows the server no longer lists go; the listed ones stay.
|
||||
let keep: std::collections::HashSet<String> = ["a", "c"].map(String::from).into();
|
||||
assert_eq!(db.trash_retain(&keep).unwrap(), 1);
|
||||
assert_eq!(db.trash_remove(&["a".into(), "gone".into()]).unwrap(), 1);
|
||||
let left: Vec<String> = db
|
||||
.trash_list()
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|i| i.uid)
|
||||
.collect();
|
||||
assert_eq!(left, ["c"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn state_stamps_round_trip_and_clear() {
|
||||
let db = Db::open_in_memory().unwrap();
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Trashed nodes, persisted so the trash view opens without a round-trip.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use rusqlite::params;
|
||||
|
||||
@@ -48,6 +48,60 @@ impl Db {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Add or update trashed nodes, keeping every other row.
|
||||
pub fn trash_upsert(&self, items: &[StoredTrash]) -> Result<()> {
|
||||
let mut conn = self.conn.lock();
|
||||
let tx = conn.transaction()?;
|
||||
{
|
||||
let mut stmt = tx.prepare(
|
||||
"INSERT INTO trash (uid, name, is_dir, size, mtime, parent_uid, trashed_at)
|
||||
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
|
||||
ON CONFLICT(uid) DO UPDATE SET
|
||||
name = excluded.name, is_dir = excluded.is_dir, size = excluded.size,
|
||||
mtime = excluded.mtime, parent_uid = excluded.parent_uid,
|
||||
trashed_at = excluded.trashed_at",
|
||||
)?;
|
||||
for item in items {
|
||||
stmt.execute(params![
|
||||
item.uid,
|
||||
item.name,
|
||||
item.is_dir as i64,
|
||||
item.size,
|
||||
item.mtime,
|
||||
item.parent_uid,
|
||||
item.trashed_at
|
||||
])?;
|
||||
}
|
||||
}
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Drop the trashed nodes with these uids. Returns how many rows went.
|
||||
pub fn trash_remove(&self, uids: &[String]) -> Result<usize> {
|
||||
let mut conn = self.conn.lock();
|
||||
let tx = conn.transaction()?;
|
||||
let mut removed = 0;
|
||||
{
|
||||
let mut stmt = tx.prepare("DELETE FROM trash WHERE uid = ?1")?;
|
||||
for uid in uids {
|
||||
removed += stmt.execute(params![uid])?;
|
||||
}
|
||||
}
|
||||
tx.commit()?;
|
||||
Ok(removed)
|
||||
}
|
||||
|
||||
/// Drop every trashed node not in `keep`. Returns how many rows went.
|
||||
pub fn trash_retain(&self, keep: &HashSet<String>) -> Result<usize> {
|
||||
let gone: Vec<String> = self
|
||||
.trash_seen()?
|
||||
.into_keys()
|
||||
.filter(|uid| !keep.contains(uid))
|
||||
.collect();
|
||||
self.trash_remove(&gone)
|
||||
}
|
||||
|
||||
/// The persisted trash listing, folders first then by name — the order the
|
||||
/// Trash page shows it in.
|
||||
pub fn trash_list(&self) -> Result<Vec<StoredTrash>> {
|
||||
|
||||
@@ -42,6 +42,13 @@ pub enum Error {
|
||||
#[error("that mailbox password does not unlock your account")]
|
||||
WrongMailboxPassword,
|
||||
|
||||
/// The account's only second factor is a security key, which needs
|
||||
/// WebAuthn. Asking for a code would only fail as a wrong one.
|
||||
#[error(
|
||||
"this account's only second factor is a security key, which pdfs cannot use yet — add an authenticator app in your Proton account settings"
|
||||
)]
|
||||
SecurityKeyOnly,
|
||||
|
||||
/// The login was gated behind human verification. Not a failure the user can
|
||||
/// fix by retrying: the challenge has to be solved and the login restarted
|
||||
/// with the resulting token (see [`auth::login_verified`](crate::auth::login_verified)).
|
||||
@@ -220,6 +227,7 @@ fn core_kind(e: &Error) -> ErrorKind {
|
||||
| Error::ReloginRequired
|
||||
| Error::Locked
|
||||
| Error::WrongMailboxPassword
|
||||
| Error::SecurityKeyOnly
|
||||
| Error::HumanVerificationRequired(_) => ErrorKind::Denied,
|
||||
Error::Proton(proton) => proton_kind(proton),
|
||||
_ => ErrorKind::Internal,
|
||||
@@ -347,6 +355,15 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool {
|
||||
/// The result every request-serving method in the daemon returns.
|
||||
pub type CoreResult<T> = std::result::Result<T, CoreError>;
|
||||
|
||||
impl From<proton_auth_rs::Error> for Error {
|
||||
fn from(error: proton_auth_rs::Error) -> Self {
|
||||
match error {
|
||||
proton_auth_rs::Error::Keyring(error) => Self::Keyring(error),
|
||||
other => Self::Other(other.to_string()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,6 @@ pub mod config;
|
||||
pub mod control;
|
||||
pub mod db;
|
||||
pub mod error;
|
||||
pub mod exiftime;
|
||||
pub mod kernelkey;
|
||||
pub mod keycheck;
|
||||
pub mod localindex;
|
||||
@@ -19,21 +18,20 @@ pub mod mountfail;
|
||||
pub mod mountpoint;
|
||||
pub mod mounts;
|
||||
pub mod opener;
|
||||
pub mod places;
|
||||
pub mod profile;
|
||||
pub mod sdkcache;
|
||||
pub mod search;
|
||||
mod secretservice;
|
||||
pub mod service;
|
||||
pub mod shell;
|
||||
pub mod similar;
|
||||
pub mod syncignore;
|
||||
pub mod syncroot;
|
||||
pub mod takeout;
|
||||
pub mod timestamp;
|
||||
pub mod tray;
|
||||
pub mod update;
|
||||
|
||||
// Photo logic shared with Proton Gallery through the proton-rs crates.
|
||||
pub use proton_gallery_rs::{exiftime, places, similar, takeout};
|
||||
|
||||
pub use access::{Access, access_for, perm_bits};
|
||||
pub use error::{CoreError, CoreResult, Error, Result};
|
||||
|
||||
|
||||
@@ -40,9 +40,7 @@ pub fn path(state_dir: &Path) -> PathBuf {
|
||||
/// and renamed, so a reader never sees half of it.
|
||||
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
|
||||
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
|
||||
let tmp = state_dir.join(format!("{FILE_NAME}.tmp"));
|
||||
std::fs::write(&tmp, json)?;
|
||||
std::fs::rename(&tmp, path(state_dir))
|
||||
proton_base_rs::atomic::write_with_mode(&path(state_dir), &json, 0o644)
|
||||
}
|
||||
|
||||
/// Forget the failure: a mount is up, or a new daemon has started.
|
||||
|
||||
@@ -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}"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
//! Saving a new secret into an existing Secret Service item by replacing the
|
||||
//! item, not by editing its secret (`docs/BUGS.md` B291).
|
||||
//!
|
||||
//! oo7-daemon before 0.7.0 applies `SetSecret` only in memory: the keyring
|
||||
//! file keeps the old secret, and it comes back once the daemon restarts.
|
||||
//! Fedora 45 ships such a build (`0.7.0~beta^1.e91b98a`). Every refreshed
|
||||
//! sign-in pdfs saved there was gone after a reboot, and the next start found
|
||||
//! a refresh token Proton had already spent.
|
||||
//!
|
||||
//! `CreateItem` with `replace` is written to the file there, and every
|
||||
//! provider implements it. So a secret that changes is written as a new item
|
||||
//! that replaces the old one: in the old one's collection, with its label and
|
||||
//! all of its attributes, so the provider recognises it as the same entry.
|
||||
|
||||
use dbus_secret_service::{Collection, EncryptionType, Path, SecretService};
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// The content type the keyring store writes its secrets with.
|
||||
const CONTENT_TYPE: &str = "application/octet-stream";
|
||||
|
||||
/// What [`replace`] did.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub(crate) enum Replaced {
|
||||
/// The secret is saved.
|
||||
Saved,
|
||||
/// Nothing was changed; save it the usual way. Says why, for the log.
|
||||
Skipped(String),
|
||||
}
|
||||
|
||||
/// Save `secret` into the one item for `service`/`user` by replacing it.
|
||||
///
|
||||
/// Skips, changing nothing, when there is no such item yet (the store creates
|
||||
/// it), when there is more than one, when it is locked, or when the Secret
|
||||
/// Service fails before the new item exists. Never shows a prompt: one would
|
||||
/// block the caller, so it is dismissed and the write is skipped.
|
||||
pub(crate) fn replace(service: &str, user: &str, secret: &[u8]) -> Replaced {
|
||||
match try_replace(service, user, secret) {
|
||||
Ok(replaced) => replaced,
|
||||
Err(e) => Replaced::Skipped(e.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
fn try_replace(
|
||||
service: &str,
|
||||
user: &str,
|
||||
secret: &[u8],
|
||||
) -> Result<Replaced, dbus_secret_service::Error> {
|
||||
let ss = SecretService::connect_with_max_prompt_timeout(EncryptionType::Dh, 0)?;
|
||||
let lookup = HashMap::from([("service", service), ("username", user)]);
|
||||
let found = ss.search_items(lookup.clone())?;
|
||||
if !found.locked.is_empty() {
|
||||
return Ok(Replaced::Skipped("the item is locked".into()));
|
||||
}
|
||||
let [old] = found.unlocked.as_slice() else {
|
||||
return Ok(Replaced::Skipped(format!(
|
||||
"{} items match, not one",
|
||||
found.unlocked.len()
|
||||
)));
|
||||
};
|
||||
let Some(collection) = collection_of(&old.path) else {
|
||||
return Ok(Replaced::Skipped(format!(
|
||||
"no collection in the item path {}",
|
||||
old.path
|
||||
)));
|
||||
};
|
||||
let label = old.get_label()?;
|
||||
let attributes = old.get_attributes()?;
|
||||
let attributes: HashMap<&str, &str> = attributes
|
||||
.iter()
|
||||
.map(|(k, v)| (k.as_str(), v.as_str()))
|
||||
.collect();
|
||||
let collection = Collection::new(&ss, collection);
|
||||
let new = collection.create_item(&label, attributes, secret, true, CONTENT_TYPE)?;
|
||||
|
||||
// A provider that did not match the old item leaves it next to the new
|
||||
// one, and two items make every read ambiguous.
|
||||
let after = ss.search_items(lookup)?;
|
||||
for item in after.unlocked.iter().chain(&after.locked) {
|
||||
if item.path == new.path {
|
||||
continue;
|
||||
}
|
||||
if let Err(e) = item.delete() {
|
||||
// The old item still holds the previous secret, so taking the new
|
||||
// one out leaves things as they were, for the usual write.
|
||||
if let Err(undo) = new.delete() {
|
||||
tracing::error!(
|
||||
error = %undo,
|
||||
"could not remove a duplicate keyring item; remove one of the two \
|
||||
`proton-drive-linux` entries in your keyring and sign in again"
|
||||
);
|
||||
}
|
||||
return Ok(Replaced::Skipped(format!(
|
||||
"could not remove the replaced item: {e}"
|
||||
)));
|
||||
}
|
||||
}
|
||||
Ok(Replaced::Saved)
|
||||
}
|
||||
|
||||
/// The collection an item path belongs to: the path without its last part,
|
||||
/// as long as it is a Secret Service object path.
|
||||
fn collection_of(item: &Path<'_>) -> Option<Path<'static>> {
|
||||
let (collection, _) = item.rsplit_once('/')?;
|
||||
if !collection.starts_with("/org/freedesktop/secrets/") || collection.ends_with('/') {
|
||||
return None;
|
||||
}
|
||||
Path::new(collection.to_owned()).ok()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn collection(item: &str) -> Option<String> {
|
||||
collection_of(&Path::new(item).unwrap()).map(|p| p.to_string())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_item_belongs_to_the_collection_its_path_names() {
|
||||
assert_eq!(
|
||||
collection("/org/freedesktop/secrets/collection/login/14").as_deref(),
|
||||
Some("/org/freedesktop/secrets/collection/login")
|
||||
);
|
||||
assert_eq!(
|
||||
collection("/org/freedesktop/secrets/aliases/default/3").as_deref(),
|
||||
Some("/org/freedesktop/secrets/aliases/default")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_path_outside_the_secret_service_names_no_collection() {
|
||||
assert_eq!(collection("/org/example/item/1"), None);
|
||||
assert_eq!(collection("/item"), None);
|
||||
}
|
||||
}
|
||||
@@ -1,193 +0,0 @@
|
||||
//! Telling photos apart by what they show rather than by their bytes.
|
||||
//!
|
||||
//! The server's content hash only matches byte-identical files. A photo that
|
||||
//! was resized, re-encoded or sent through a messenger is another file, so the
|
||||
//! similar-photo finder hashes each thumbnail instead: a 64-bit difference
|
||||
//! hash ("dHash"), which compares neighbouring brightness in a 9×8 grid. Two
|
||||
//! copies of one picture land a few bits apart, and different pictures about
|
||||
//! half of the bits apart.
|
||||
|
||||
/// Hashes this many bits apart or fewer show the same picture.
|
||||
pub const SIMILAR_BITS: u32 = 6;
|
||||
|
||||
/// Stored for a photo whose thumbnail was looked at and gave no usable hash
|
||||
/// (it couldn't be decoded, or is one flat colour), so it isn't looked at
|
||||
/// again. A real hash is never 0: a picture that would hash to 0 has no
|
||||
/// brightness changes, which [`difference_hash`] turns down as flat.
|
||||
pub const NO_HASH: u64 = 0;
|
||||
|
||||
/// Samples of the grid that differ by less than this in brightness, all of
|
||||
/// them, make a flat picture — a black frame, a blank page — whose hash is
|
||||
/// noise and would match every other flat picture.
|
||||
const FLAT: u8 = 8;
|
||||
|
||||
/// The difference hash of an 8-bit greyscale image `width` px wide, rows
|
||||
/// stored one after another in `luma`. `None` for an empty or flat image.
|
||||
pub fn difference_hash(width: usize, height: usize, luma: &[u8]) -> Option<u64> {
|
||||
if width == 0 || height == 0 || luma.len() < width * height {
|
||||
return None;
|
||||
}
|
||||
// Box-average down to 9×8, so every source pixel counts once and the hash
|
||||
// doesn't depend on which pixels a nearest-neighbour pick happens to hit.
|
||||
let mut grid = [[0u8; 9]; 8];
|
||||
for (gy, row) in grid.iter_mut().enumerate() {
|
||||
let (y0, y1) = span(gy, 8, height);
|
||||
for (gx, cell) in row.iter_mut().enumerate() {
|
||||
let (x0, x1) = span(gx, 9, width);
|
||||
let mut sum = 0u64;
|
||||
for y in y0..y1 {
|
||||
sum += luma[y * width + x0..y * width + x1]
|
||||
.iter()
|
||||
.map(|&v| u64::from(v))
|
||||
.sum::<u64>();
|
||||
}
|
||||
*cell = (sum / ((y1 - y0) * (x1 - x0)) as u64) as u8;
|
||||
}
|
||||
}
|
||||
let (min, max) = grid
|
||||
.iter()
|
||||
.flatten()
|
||||
.fold((u8::MAX, 0), |(min, max), &v| (min.min(v), max.max(v)));
|
||||
if max - min < FLAT {
|
||||
return None;
|
||||
}
|
||||
let mut hash = 0u64;
|
||||
for row in &grid {
|
||||
for pair in row.windows(2) {
|
||||
hash = hash << 1 | u64::from(pair[0] < pair[1]);
|
||||
}
|
||||
}
|
||||
(hash != NO_HASH).then_some(hash)
|
||||
}
|
||||
|
||||
/// The source pixels `from..to` that cell `i` of `cells` covers along an edge
|
||||
/// of `len` px; never empty, even for an edge shorter than the grid.
|
||||
fn span(i: usize, cells: usize, len: usize) -> (usize, usize) {
|
||||
let from = (i * len / cells).min(len - 1);
|
||||
let to = ((i + 1) * len / cells).max(from + 1);
|
||||
(from, to)
|
||||
}
|
||||
|
||||
/// Whether two hashes show the same picture.
|
||||
pub fn alike(a: u64, b: u64) -> bool {
|
||||
(a ^ b).count_ones() <= SIMILAR_BITS
|
||||
}
|
||||
|
||||
/// Group `hashes` into sets of alike ones, by index, each set in index order
|
||||
/// and the sets by their first index. A hash alike to none other is in no
|
||||
/// set. Alike is taken as catching: a burst of shots each a little different
|
||||
/// from the last is one set.
|
||||
pub fn sets(hashes: &[u64]) -> Vec<Vec<usize>> {
|
||||
// Two hashes at most SIMILAR_BITS apart agree on at least one of their
|
||||
// eight bytes, as long as SIMILAR_BITS < 8. So only hashes sharing some
|
||||
// byte are compared, not every pair of the library.
|
||||
const _: () = assert!(SIMILAR_BITS < 8);
|
||||
let mut parent: Vec<usize> = (0..hashes.len()).collect();
|
||||
fn root(parent: &mut [usize], mut i: usize) -> usize {
|
||||
while parent[i] != i {
|
||||
parent[i] = parent[parent[i]];
|
||||
i = parent[i];
|
||||
}
|
||||
i
|
||||
}
|
||||
for byte in 0..8 {
|
||||
let mut buckets: Vec<Vec<usize>> = vec![Vec::new(); 256];
|
||||
for (i, &hash) in hashes.iter().enumerate() {
|
||||
buckets[(hash >> (byte * 8)) as u8 as usize].push(i);
|
||||
}
|
||||
for bucket in &buckets {
|
||||
for (n, &a) in bucket.iter().enumerate() {
|
||||
for &b in &bucket[n + 1..] {
|
||||
if alike(hashes[a], hashes[b]) {
|
||||
let (ra, rb) = (root(&mut parent, a), root(&mut parent, b));
|
||||
if ra != rb {
|
||||
parent[ra.max(rb)] = ra.min(rb);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut by_root: std::collections::BTreeMap<usize, Vec<usize>> = Default::default();
|
||||
for i in 0..hashes.len() {
|
||||
let r = root(&mut parent, i);
|
||||
by_root.entry(r).or_default().push(i);
|
||||
}
|
||||
by_root.into_values().filter(|set| set.len() > 1).collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A 90×80 picture: a bright disc on a gradient.
|
||||
fn picture(width: usize, height: usize) -> Vec<u8> {
|
||||
let mut luma = Vec::with_capacity(width * height);
|
||||
for y in 0..height {
|
||||
for x in 0..width {
|
||||
let (fx, fy) = (x as f64 / width as f64, y as f64 / height as f64);
|
||||
let disc = ((fx - 0.3).powi(2) + (fy - 0.6).powi(2)).sqrt() < 0.2;
|
||||
let v = if disc { 240.0 } else { 40.0 + 120.0 * fx * fy };
|
||||
luma.push(v as u8);
|
||||
}
|
||||
}
|
||||
luma
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_resized_copy_hashes_alike() {
|
||||
let big = difference_hash(900, 800, &picture(900, 800)).unwrap();
|
||||
let small = difference_hash(91, 79, &picture(91, 79)).unwrap();
|
||||
assert!(
|
||||
alike(big, small),
|
||||
"{} bits apart",
|
||||
(big ^ small).count_ones()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_different_picture_hashes_apart() {
|
||||
let one = difference_hash(90, 80, &picture(90, 80)).unwrap();
|
||||
let mirrored: Vec<u8> = picture(90, 80)
|
||||
.chunks(90)
|
||||
.flat_map(|row| row.iter().rev().copied().collect::<Vec<_>>())
|
||||
.collect();
|
||||
let other = difference_hash(90, 80, &mirrored).unwrap();
|
||||
assert!(!alike(one, other));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_flat_picture_has_no_hash() {
|
||||
assert_eq!(difference_hash(64, 64, &[17; 64 * 64]), None);
|
||||
assert_eq!(difference_hash(0, 0, &[]), None);
|
||||
assert_eq!(difference_hash(4, 4, &[0; 3]), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_picture_smaller_than_the_grid_still_hashes() {
|
||||
let luma: Vec<u8> = (0..4 * 3).map(|i| (i * 20) as u8).collect();
|
||||
assert!(difference_hash(4, 3, &luma).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn alike_hashes_form_sets_and_catch_on() {
|
||||
let a = 0x0123_4567_89ab_cdef_u64;
|
||||
let hashes = [
|
||||
a,
|
||||
!a,
|
||||
a ^ 0b111,
|
||||
a ^ 0b111 ^ (0b1111 << 40),
|
||||
0x5555_0000_ffff_aaaa,
|
||||
];
|
||||
assert_eq!(sets(&hashes), vec![vec![0, 2, 3]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hashes_apart_in_most_bytes_are_still_found() {
|
||||
// One bit apart in each of six bytes: six bits in all, and only the
|
||||
// top two bytes agree.
|
||||
let a = 1u64 << 63;
|
||||
let b = (0..6).fold(a, |h, byte| h | 1 << (byte * 8));
|
||||
assert_eq!(sets(&[a, b]), vec![vec![0, 1]]);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -14,8 +14,9 @@ pdfs-core.workspace = true
|
||||
zip.workspace = true
|
||||
sha1.workspace = true
|
||||
proton-drive-rs.workspace = true
|
||||
pg-app.workspace = true
|
||||
pg-core.workspace = true
|
||||
proton-gallery-app-rs.workspace = true
|
||||
proton-gallery-rs.workspace = true
|
||||
proton-media-rs.workspace = true
|
||||
hyper = { version = "1", features = ["http1", "server"] }
|
||||
hyper-util = { version = "0.1", features = ["tokio"] }
|
||||
http-body-util = "0.1"
|
||||
|
||||
@@ -1342,6 +1342,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
|
||||
Ok(entries) => CtlResponse::Entries { entries },
|
||||
Err(e) => CtlResponse::error(e),
|
||||
},
|
||||
Ok(CtlRequest::ListTrashedFolder { uid }) => match core.list_trashed_folder(&uid) {
|
||||
Ok(entries) => CtlResponse::Entries { entries },
|
||||
Err(e) => CtlResponse::error(e),
|
||||
},
|
||||
Ok(CtlRequest::Restore { uids }) => match core.restore(&uids) {
|
||||
Ok(n) => {
|
||||
core.log_activity(ActivityKind::Restore, format!("{n} item(s)"), "", true);
|
||||
|
||||
@@ -29,7 +29,7 @@ use proton_drive_rs::proton_sdk::error::Result;
|
||||
use proton_drive_rs::proton_sdk::ids::{DriveEventId, NodeUid, ShareId};
|
||||
use proton_drive_rs::{
|
||||
AvailableNameTarget, Device, DeviceType, DriveEvent, DriveEventScopeId, Node, NodeMoveItem,
|
||||
ProtonDriveClient, RevisionReader, Thumbnail, ThumbnailType,
|
||||
ProtonDriveClient, RevisionReader, Thumbnail, ThumbnailType, TrashedNode,
|
||||
};
|
||||
|
||||
/// One outcome per node of a batch request; see [`ProtonDriveClient::trash_nodes`].
|
||||
@@ -180,6 +180,23 @@ pub(crate) trait DriveApi: Send + Sync {
|
||||
|
||||
async fn enumerate_trash_node_uids(&self) -> Result<Vec<NodeUid>>;
|
||||
|
||||
/// Permanently delete everything in the trash.
|
||||
async fn empty_trash(&self) -> Result<()>;
|
||||
|
||||
/// As [`DriveApi::enumerate_nodes_light`], for nodes in the trash, each
|
||||
/// with the time it was trashed when the server reports one.
|
||||
async fn enumerate_trashed_nodes_light(&self, uids: &[NodeUid]) -> Result<Vec<TrashedNode>> {
|
||||
Ok(self
|
||||
.enumerate_nodes_light(uids)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|node| TrashedNode {
|
||||
node,
|
||||
trash_time: None,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// The account's storage, across every Proton product.
|
||||
async fn quota(&self) -> Result<Quota>;
|
||||
|
||||
@@ -538,6 +555,14 @@ impl DriveApi for ProtonDriveClient {
|
||||
ProtonDriveClient::enumerate_trash_node_uids(self).await
|
||||
}
|
||||
|
||||
async fn enumerate_trashed_nodes_light(&self, uids: &[NodeUid]) -> Result<Vec<TrashedNode>> {
|
||||
ProtonDriveClient::enumerate_trashed_nodes_light(self, uids).await
|
||||
}
|
||||
|
||||
async fn empty_trash(&self) -> Result<()> {
|
||||
ProtonDriveClient::empty_trash(self).await
|
||||
}
|
||||
|
||||
async fn quota(&self) -> Result<Quota> {
|
||||
ProtonDriveClient::quota(self).await
|
||||
}
|
||||
|
||||
@@ -14,10 +14,10 @@ use pdfs_core::control::{
|
||||
GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace, PhotoItem, PhotoKind, Response,
|
||||
};
|
||||
use pdfs_core::{CoreError, CoreResult};
|
||||
use pg_app::{App, View};
|
||||
use pg_core::CancellationToken;
|
||||
use pg_core::model::{AssetKey, SourceId};
|
||||
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};
|
||||
@@ -187,8 +187,9 @@ impl Gallery {
|
||||
Ok(Arc::new(visibility))
|
||||
}
|
||||
|
||||
fn account(&self) -> CoreResult<pg_core::model::AccountId> {
|
||||
pg_core::model::AccountId::new(self.session.user_id().as_str()).map_err(gallery_error)
|
||||
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(
|
||||
@@ -345,13 +346,15 @@ impl Gallery {
|
||||
fn asset(&self, uid: &NodeUid) -> CoreResult<AssetKey> {
|
||||
Ok(AssetKey {
|
||||
account: self.account()?,
|
||||
volume: pg_core::model::VolumeId::new(uid.volume_id.as_str()).map_err(gallery_error)?,
|
||||
node: pg_core::model::NodeId::new(uid.link_id.as_str()).map_err(gallery_error)?,
|
||||
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: pg_core::library::Album, proton: bool) -> GalleryAlbum {
|
||||
fn gallery_album(entry: proton_gallery_rs::library::Album, proton: bool) -> GalleryAlbum {
|
||||
GalleryAlbum {
|
||||
place: GalleryPlace {
|
||||
gallery: entry.gallery.to_string(),
|
||||
@@ -444,7 +447,7 @@ impl Core {
|
||||
"Use your Linux sign-in to unlock Hidden albums.",
|
||||
));
|
||||
}
|
||||
let subject = pg_app::desktop_auth::Subject::new(
|
||||
let subject = proton_gallery_app_rs::desktop_auth::Subject::new(
|
||||
peer.pid.as_raw_nonzero().get() as u32,
|
||||
peer.uid.as_raw(),
|
||||
)
|
||||
|
||||
@@ -11,8 +11,8 @@ use hyper::{
|
||||
};
|
||||
use hyper_util::rt::TokioIo;
|
||||
use pdfs_core::{CoreResult, control::Response as ControlResponse};
|
||||
use pg_app::video::VideoStream;
|
||||
use pg_core::CancellationToken;
|
||||
use proton_gallery_app_rs::video::VideoStream;
|
||||
use proton_gallery_rs::CancellationToken;
|
||||
use tokio::net::TcpListener;
|
||||
|
||||
type Body = UnsyncBoxBody<Bytes, io::Error>;
|
||||
|
||||
@@ -0,0 +1,129 @@
|
||||
//! Hold off a shutdown while queued changes exist only on this computer.
|
||||
//!
|
||||
//! A change made through the mount is staged here and sent by the drain. Until
|
||||
//! it lands, this computer has the only copy, so powering off then risks it
|
||||
//! more than the user expects (`docs/BUGS.md` B66). While the queue holds work
|
||||
//! the drain can still send, the daemon takes a logind shutdown inhibitor
|
||||
//! through `systemd-inhibit`, which desktops show in their power-off dialog
|
||||
//! with the reason. It is let go as soon as the queue empties.
|
||||
//!
|
||||
//! Work that cannot drain on its own — a temporary file waiting for its final
|
||||
//! name, or a change Drive refused or that keeps failing — never holds the
|
||||
//! lock, or a shutdown would be held up for something that is not coming.
|
||||
//! Without `systemd-inhibit` nothing happens.
|
||||
|
||||
use std::process::{Child, Command, Stdio};
|
||||
use std::time::Duration;
|
||||
|
||||
use pdfs_core::db::PendingCounts;
|
||||
use tracing::{debug, warn};
|
||||
|
||||
use super::Core;
|
||||
|
||||
/// How often the queue is looked at.
|
||||
const CHECK_EVERY: Duration = Duration::from_secs(5);
|
||||
|
||||
/// Changes the drain can still send by itself.
|
||||
fn sendable(counts: &PendingCounts) -> i64 {
|
||||
(counts.uploads + counts.changes - counts.parked - counts.failing).max(0)
|
||||
}
|
||||
|
||||
/// Run until the daemon stops, holding the inhibitor while changes wait.
|
||||
pub(crate) fn run(core: Core) {
|
||||
let mut held: Option<Child> = None;
|
||||
loop {
|
||||
let waiting = core
|
||||
.db
|
||||
.pending_op_counts()
|
||||
.map(|counts| sendable(&counts))
|
||||
.unwrap_or(0);
|
||||
// The helper can go away (logind restarted, or it was killed); the
|
||||
// lock is then taken again on the next round.
|
||||
if let Some(child) = &mut held
|
||||
&& !matches!(child.try_wait(), Ok(None))
|
||||
{
|
||||
held = None;
|
||||
}
|
||||
match (&mut held, waiting > 0) {
|
||||
(None, true) => held = take(waiting),
|
||||
(Some(child), false) => {
|
||||
release(child);
|
||||
held = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if !core.shutdown.sleep(CHECK_EVERY) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if let Some(mut child) = held {
|
||||
release(&mut child);
|
||||
}
|
||||
}
|
||||
|
||||
fn take(waiting: i64) -> Option<Child> {
|
||||
let why = if waiting == 1 {
|
||||
"Sending 1 change to Proton Drive".to_string()
|
||||
} else {
|
||||
format!("Sending {waiting} changes to Proton Drive")
|
||||
};
|
||||
match Command::new("systemd-inhibit")
|
||||
.args([
|
||||
"--what=shutdown",
|
||||
"--who=Proton Drive",
|
||||
&format!("--why={why}"),
|
||||
"--mode=block",
|
||||
"sleep",
|
||||
"infinity",
|
||||
])
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
{
|
||||
Ok(child) => {
|
||||
debug!(waiting, "holding off shutdown while changes are queued");
|
||||
Some(child)
|
||||
}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
|
||||
Err(error) => {
|
||||
warn!(%error, "taking the shutdown inhibitor failed");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn release(child: &mut Child) {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
debug!("queue drained; shutdown no longer held off");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn counts(uploads: i64, changes: i64, parked: i64, failing: i64) -> PendingCounts {
|
||||
PendingCounts {
|
||||
uploads,
|
||||
changes,
|
||||
parked,
|
||||
failing,
|
||||
last_error: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_work_the_drain_can_send_holds_off_a_shutdown() {
|
||||
assert_eq!(sendable(&counts(0, 0, 0, 0)), 0);
|
||||
assert_eq!(sendable(&counts(2, 1, 0, 0)), 3);
|
||||
assert_eq!(sendable(&counts(1, 0, 1, 0)), 0);
|
||||
assert_eq!(sendable(&counts(2, 0, 0, 2)), 0);
|
||||
assert_eq!(sendable(&counts(3, 2, 1, 1)), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn counts_that_overlap_never_go_negative() {
|
||||
assert_eq!(sendable(&counts(1, 0, 1, 1)), 0);
|
||||
}
|
||||
}
|
||||
+195
-50
@@ -75,7 +75,7 @@ use proton_drive_rs::proton_sdk::error::ProtonError;
|
||||
use proton_drive_rs::proton_sdk::ids::{DriveEventId, LinkId, NodeUid, ShareId, VolumeId};
|
||||
use proton_drive_rs::{
|
||||
AvailableNameTarget, DriveEvent, DriveEventScopeId, MemberRole, Node, NodeKind, NodeMoveItem,
|
||||
ProtonDriveClient, ProtonPhotosClient, SharedWithMeItem, ThumbnailType,
|
||||
ProtonDriveClient, ProtonPhotosClient, SharedWithMeItem, ThumbnailType, TrashedNode,
|
||||
};
|
||||
|
||||
mod albums;
|
||||
@@ -92,6 +92,7 @@ use drive::{DriveApi, RevisionRead};
|
||||
mod events;
|
||||
mod filesystem;
|
||||
mod gallery;
|
||||
mod inhibit;
|
||||
mod keeper;
|
||||
mod link;
|
||||
pub use filesystem::ProtonFs;
|
||||
@@ -4610,6 +4611,7 @@ impl Core {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: state::ino_lid(ino)
|
||||
.and_then(|lid| issues.get(&lid))
|
||||
.map(|issue| SyncIssue::parse(issue)),
|
||||
@@ -5603,20 +5605,29 @@ impl Core {
|
||||
self.await_trash_refresh(TRASH_FIRST_WAIT);
|
||||
}
|
||||
|
||||
let items = self.db.trash_list().map_err(CoreError::from)?;
|
||||
let trashed: HashSet<&str> = items.iter().map(|item| item.uid.as_str()).collect();
|
||||
let trashed_parents: Vec<Option<String>> = items
|
||||
.iter()
|
||||
.map(|item| {
|
||||
item.parent_uid
|
||||
.clone()
|
||||
.filter(|parent| trashed.contains(parent.as_str()))
|
||||
})
|
||||
.collect();
|
||||
// Most of a trash comes from a handful of folders.
|
||||
let mut origins: HashMap<String, Option<String>> = HashMap::new();
|
||||
Ok(self
|
||||
.db
|
||||
.trash_list()
|
||||
.map_err(CoreError::from)?
|
||||
Ok(items
|
||||
.into_iter()
|
||||
.map(|item| DirEntry {
|
||||
.zip(trashed_parents)
|
||||
.map(|(item, trashed_parent)| DirEntry {
|
||||
trashed_from: item.parent_uid.as_ref().and_then(|parent| {
|
||||
origins
|
||||
.entry(parent.clone())
|
||||
.or_insert_with(|| self.db.node_path(parent).ok().flatten())
|
||||
.clone()
|
||||
}),
|
||||
trashed_parent,
|
||||
trashed_at: item.trashed_at.unwrap_or(0),
|
||||
name: item.name,
|
||||
is_dir: item.is_dir,
|
||||
@@ -5638,13 +5649,86 @@ impl Core {
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// What a trashed folder holds: its children on the server, and the
|
||||
/// stored trash entries trashed inside it before it went.
|
||||
fn list_trashed_folder(&self, uid: &str) -> CoreResult<Vec<DirEntry>> {
|
||||
let folder =
|
||||
parse_uid(uid).ok_or_else(|| CoreError::invalid(format!("invalid uid: {uid}")))?;
|
||||
let children = self
|
||||
.rt
|
||||
.block_on(within_trash_call(
|
||||
"enumerate trashed folder",
|
||||
self.drive.enumerate_folder_children_node_uids(&folder),
|
||||
))?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate trashed folder"))?;
|
||||
let mut nodes = Vec::with_capacity(children.len());
|
||||
for chunk in children.chunks(TRASH_MATERIALIZE_CHUNK) {
|
||||
nodes.extend(
|
||||
self.rt
|
||||
.block_on(within_trash_call(
|
||||
"enumerate nodes",
|
||||
self.drive.enumerate_trashed_nodes_light(chunk),
|
||||
))?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate nodes"))?,
|
||||
);
|
||||
}
|
||||
let stored = self.db.trash_list().map_err(CoreError::from)?;
|
||||
let stored_at: HashMap<&str, Option<i64>> = stored
|
||||
.iter()
|
||||
.map(|item| (item.uid.as_str(), item.trashed_at))
|
||||
.collect();
|
||||
let mut entries: Vec<DirEntry> = nodes
|
||||
.iter()
|
||||
.map(|TrashedNode { node, trash_time }| {
|
||||
let uid = node.uid.to_string();
|
||||
let trashed_at = trash_time
|
||||
.or_else(|| stored_at.get(uid.as_str()).copied().flatten())
|
||||
.unwrap_or(0);
|
||||
trashed_entry(
|
||||
uid,
|
||||
node.name.clone(),
|
||||
node.is_folder(),
|
||||
node_size(node) as i64,
|
||||
node.modification_time,
|
||||
trashed_at,
|
||||
folder.to_string(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
let listed: HashSet<String> = entries.iter().map(|e| e.uid.clone()).collect();
|
||||
entries.extend(
|
||||
stored
|
||||
.into_iter()
|
||||
.filter(|item| {
|
||||
item.parent_uid.as_deref() == Some(uid) && !listed.contains(&item.uid)
|
||||
})
|
||||
.map(|item| {
|
||||
trashed_entry(
|
||||
item.uid,
|
||||
item.name,
|
||||
item.is_dir,
|
||||
item.size,
|
||||
item.mtime,
|
||||
item.trashed_at.unwrap_or(0),
|
||||
folder.to_string(),
|
||||
)
|
||||
}),
|
||||
);
|
||||
entries.sort_by(|a, b| {
|
||||
b.is_dir
|
||||
.cmp(&a.is_dir)
|
||||
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
|
||||
});
|
||||
Ok(entries)
|
||||
}
|
||||
|
||||
/// Re-fetch the trash listing from the server and persist it.
|
||||
///
|
||||
/// Materialized in chunks of [`TRASH_MATERIALIZE_CHUNK`], each persisted as
|
||||
/// it lands: decrypting a trashed node costs an S2K unlock, so a trash of a
|
||||
/// few thousand nodes takes minutes, and an all-or-nothing write would throw
|
||||
/// that away on the first failure and show the user nothing until the very
|
||||
/// end. Every batch is a usable listing.
|
||||
/// Only nodes the stored listing does not hold yet are read, and light: a
|
||||
/// trashed file needs no content key, so none is unlocked. Each chunk of
|
||||
/// [`TRASH_MATERIALIZE_CHUNK`] is stored as it lands, so a large trash
|
||||
/// fills the page while it loads. Rows the server no longer lists go once
|
||||
/// the whole listing is in, never earlier.
|
||||
async fn refresh_trash(&self) -> CoreResult<()> {
|
||||
let started = Instant::now();
|
||||
let uids = within_trash_call("enumerate trash", self.drive.enumerate_trash_node_uids())
|
||||
@@ -5656,8 +5740,6 @@ impl Core {
|
||||
"trash refresh: enumerated"
|
||||
);
|
||||
|
||||
// What the listing held before, and whether it was the whole trash: the
|
||||
// chunks below overwrite it, so both are read up front.
|
||||
let seen = self.db.trash_seen().unwrap_or_default();
|
||||
let complete = self
|
||||
.db
|
||||
@@ -5665,36 +5747,51 @@ impl Core {
|
||||
.ok()
|
||||
.flatten()
|
||||
.is_some();
|
||||
let _ = self.db.clear_state(TRASH_COMPLETE_MS);
|
||||
let now = now_secs();
|
||||
|
||||
if uids.is_empty() {
|
||||
self.db.trash_replace(&[]).map_err(CoreError::from)?;
|
||||
}
|
||||
let mut items: Vec<StoredTrash> = Vec::with_capacity(uids.len());
|
||||
for chunk in uids.chunks(TRASH_MATERIALIZE_CHUNK) {
|
||||
let chunk_started = Instant::now();
|
||||
let nodes = within_trash_call("enumerate nodes", self.drive.enumerate_nodes(chunk))
|
||||
.await?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate nodes"))?;
|
||||
items.extend(nodes.into_iter().map(|node| StoredTrash {
|
||||
uid: node.uid.to_string(),
|
||||
name: node.name.clone(),
|
||||
is_dir: node.is_folder(),
|
||||
size: node_size(&node) as i64,
|
||||
mtime: node.modification_time,
|
||||
// The folder the node will go back to, which is also what tells
|
||||
// a restore whether that folder is itself in the trash.
|
||||
parent_uid: node.parent_uid.as_ref().map(|uid| uid.to_string()),
|
||||
trashed_at: first_seen_in_trash(&seen, &node.uid.to_string(), complete, now),
|
||||
}));
|
||||
// Cumulative, so the table is always a prefix of the real trash
|
||||
// rather than a mix of this refresh and the last one.
|
||||
self.db.trash_replace(&items).map_err(CoreError::from)?;
|
||||
let listed: HashSet<String> = uids.iter().map(ToString::to_string).collect();
|
||||
let removed = self.db.trash_retain(&listed).map_err(CoreError::from)?;
|
||||
if removed > 0 {
|
||||
self.trash_progress.notify_waiters();
|
||||
}
|
||||
let missing: Vec<NodeUid> = uids
|
||||
.into_iter()
|
||||
.filter(|uid| !seen.contains_key(&uid.to_string()))
|
||||
.collect();
|
||||
let mut materialized = 0usize;
|
||||
for chunk in missing.chunks(TRASH_MATERIALIZE_CHUNK) {
|
||||
let chunk_started = Instant::now();
|
||||
let nodes = within_trash_call(
|
||||
"enumerate nodes",
|
||||
self.drive.enumerate_trashed_nodes_light(chunk),
|
||||
)
|
||||
.await?
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate nodes"))?;
|
||||
let items: Vec<StoredTrash> = nodes
|
||||
.into_iter()
|
||||
.map(|TrashedNode { node, trash_time }| {
|
||||
let uid = node.uid.to_string();
|
||||
StoredTrash {
|
||||
trashed_at: trash_time
|
||||
.or_else(|| first_seen_in_trash(&seen, &uid, complete, now)),
|
||||
uid,
|
||||
name: node.name.clone(),
|
||||
is_dir: node.is_folder(),
|
||||
size: node_size(&node) as i64,
|
||||
mtime: node.modification_time,
|
||||
// The folder the node will go back to, which is also what
|
||||
// tells a restore whether that folder is itself in the trash.
|
||||
parent_uid: node.parent_uid.as_ref().map(|uid| uid.to_string()),
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
materialized += items.len();
|
||||
self.db.trash_upsert(&items).map_err(CoreError::from)?;
|
||||
self.trash_progress.notify_waiters();
|
||||
self.events.publish(&[Topic::Trash]);
|
||||
debug!(
|
||||
materialized = items.len(),
|
||||
total = uids.len(),
|
||||
materialized,
|
||||
total = missing.len(),
|
||||
chunk_ms = chunk_started.elapsed().as_millis() as u64,
|
||||
"trash refresh: batch"
|
||||
);
|
||||
@@ -5703,7 +5800,9 @@ impl Core {
|
||||
let _ = self.db.set_state_i64(TRASH_SYNCED_MS, now_ms());
|
||||
let _ = self.db.set_state_i64(TRASH_COMPLETE_MS, now_ms());
|
||||
info!(
|
||||
count = items.len(),
|
||||
count = listed.len(),
|
||||
new = materialized,
|
||||
removed,
|
||||
elapsed_ms = started.elapsed().as_millis() as u64,
|
||||
"trash refresh: done"
|
||||
);
|
||||
@@ -5884,6 +5983,8 @@ impl Core {
|
||||
}
|
||||
}
|
||||
});
|
||||
let back: Vec<String> = restored.iter().map(ToString::to_string).collect();
|
||||
let _ = self.db.trash_remove(&back);
|
||||
self.invalidate_trash();
|
||||
Ok(restored.len())
|
||||
}
|
||||
@@ -5897,6 +5998,7 @@ impl Core {
|
||||
// daemon interrupted mid-batch has already forgotten exactly the nodes
|
||||
// the server destroyed — never more, never fewer.
|
||||
let mut deleted = 0usize;
|
||||
let mut gone: Vec<String> = Vec::new();
|
||||
let mut first_error: Option<ProtonError> = None;
|
||||
self.rt
|
||||
.block_on(async {
|
||||
@@ -5906,6 +6008,7 @@ impl Core {
|
||||
match outcome {
|
||||
Ok(()) => {
|
||||
self.drop_local(std::slice::from_ref(&uid));
|
||||
gone.push(uid.to_string());
|
||||
deleted += 1;
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -5922,23 +6025,34 @@ impl Core {
|
||||
{
|
||||
return Err(CoreError::from_api(&error, "delete"));
|
||||
}
|
||||
let _ = self.db.trash_remove(&gone);
|
||||
self.invalidate_trash();
|
||||
Ok(deleted)
|
||||
}
|
||||
|
||||
/// Permanently delete everything in the trash. The uids are listed first so
|
||||
/// the blobs of items trashed by *another* client — which this daemon may
|
||||
/// still hold in its cache — are reclaimed too, not just the ones it trashed.
|
||||
/// Permanently delete everything in the trash.
|
||||
///
|
||||
/// The stored listing says what goes, so the blobs of items trashed by
|
||||
/// another client, which this daemon may still hold, are reclaimed too. It
|
||||
/// is not read from the server again first: on a large trash that listing
|
||||
/// is what kept the delete from ever being sent (`docs/BUGS.md` B293).
|
||||
/// The stored listing is cleared at once, and the server is asked again
|
||||
/// after [`TRASH_TTL`], so anything it still holds then shows up again.
|
||||
fn empty_trash(&self) -> CoreResult<usize> {
|
||||
let uids = self
|
||||
.rt
|
||||
.block_on(self.drive.enumerate_trash_node_uids())
|
||||
.map_err(|e| CoreError::from_api(&e, "enumerate trash"))?;
|
||||
let uids: Vec<String> = self
|
||||
.db
|
||||
.trash_seen()
|
||||
.map_err(CoreError::from)?
|
||||
.into_keys()
|
||||
.collect();
|
||||
self.rt
|
||||
.block_on(self.client.empty_trash())
|
||||
.block_on(within_trash_call("empty trash", self.drive.empty_trash()))?
|
||||
.map_err(|e| CoreError::from_api(&e, "empty trash"))?;
|
||||
self.drop_local(&uids);
|
||||
self.invalidate_trash();
|
||||
let parsed: Vec<NodeUid> = uids.iter().filter_map(|uid| parse_uid(uid)).collect();
|
||||
self.drop_local(&parsed);
|
||||
let _ = self.db.trash_replace(&[]);
|
||||
let _ = self.db.set_state_i64(TRASH_SYNCED_MS, now_ms());
|
||||
self.events.publish(&[Topic::Trash]);
|
||||
Ok(uids.len())
|
||||
}
|
||||
|
||||
@@ -6840,6 +6954,37 @@ async fn within_trash_call<T>(what: &str, call: impl Future<Output = T>) -> Core
|
||||
})
|
||||
}
|
||||
|
||||
/// An entry inside a trashed folder, for [`Core::list_trashed_folder`].
|
||||
fn trashed_entry(
|
||||
uid: String,
|
||||
name: String,
|
||||
is_dir: bool,
|
||||
size: i64,
|
||||
mtime: i64,
|
||||
trashed_at: i64,
|
||||
parent: String,
|
||||
) -> DirEntry {
|
||||
DirEntry {
|
||||
name,
|
||||
is_dir,
|
||||
size: size.max(0) as u64,
|
||||
modified: mtime,
|
||||
pinned: false,
|
||||
pinned_by_folder: false,
|
||||
cached: false,
|
||||
uid,
|
||||
path: String::new(),
|
||||
role: String::new(),
|
||||
shared_by: String::new(),
|
||||
shared_at: 0,
|
||||
shared_by_unverified: false,
|
||||
trashed_at,
|
||||
trashed_from: None,
|
||||
trashed_parent: Some(parent),
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// When a node a trash refresh found went to the trash, as far as the daemon
|
||||
/// can tell. A node the stored listing already had keeps the time it had. A new
|
||||
/// one went there since the last refresh, so now is close, but only when that
|
||||
|
||||
@@ -793,6 +793,17 @@ pub(crate) fn mount_with(
|
||||
warn!(%error, "start My Files share-id repair failed");
|
||||
}
|
||||
}
|
||||
// Hold off a shutdown while changes exist only here (B66). Only the real
|
||||
// daemon: a simulation's queue is not the user's data.
|
||||
if matches!(host, Host::Daemon) {
|
||||
let inhibit_core = core.clone();
|
||||
if let Err(error) = std::thread::Builder::new()
|
||||
.name("pdfs-inhibit".into())
|
||||
.spawn(move || crate::inhibit::run(inhibit_core))
|
||||
{
|
||||
warn!(%error, "start the shutdown inhibitor failed");
|
||||
}
|
||||
}
|
||||
|
||||
// Stop signals (SIGTERM from `systemctl --user stop`, SIGINT from Ctrl-C)
|
||||
// are delivered onto the async runtime; bridge them onto a sync channel so
|
||||
|
||||
@@ -212,15 +212,12 @@ impl BlockRing {
|
||||
}
|
||||
|
||||
/// The result of fetching one block, shared between everyone who wanted it.
|
||||
type BlockResult = Result<Arc<Vec<u8>>, Errno>;
|
||||
pub(super) type BlockResult = Result<Arc<Vec<u8>>, Errno>;
|
||||
|
||||
/// Identifies a block *of a revision*: node, validity tag, and the plaintext
|
||||
/// range the block covers — see [`RingKey`] for why it is the range and not the
|
||||
/// index.
|
||||
type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
||||
|
||||
/// A claim on a block key: who owns the fetch, and where its result is published.
|
||||
type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
|
||||
pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
||||
|
||||
/// Block fetches in flight, so a block is downloaded and decrypted once however
|
||||
/// many readers want it at that moment (audit T1).
|
||||
@@ -231,34 +228,7 @@ type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
|
||||
/// for. Without this each of them pays the full round-trip and decrypt and all
|
||||
/// but one result is discarded — roughly double the bandwidth and CPU in steady
|
||||
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
|
||||
#[derive(Default)]
|
||||
pub(super) struct BlockFlight {
|
||||
inflight: Mutex<HashMap<BlockKey, Claim>>,
|
||||
}
|
||||
|
||||
/// Distinguishes attempts at the same key, so a leader only retires its own.
|
||||
static NEXT_FLIGHT_ID: AtomicU64 = AtomicU64::new(0);
|
||||
|
||||
/// The leader's claim on a key. Retires it on drop — including when the task is
|
||||
/// cancelled mid-fetch, which is what keeps a dropped `JoinSet` from leaving a
|
||||
/// key nobody will ever publish.
|
||||
struct Flight {
|
||||
flight: Arc<BlockFlight>,
|
||||
key: BlockKey,
|
||||
id: u64,
|
||||
}
|
||||
|
||||
impl Drop for Flight {
|
||||
fn drop(&mut self) {
|
||||
let mut inflight = self.flight.inflight.lock();
|
||||
if inflight
|
||||
.get(&self.key)
|
||||
.is_some_and(|(id, _)| *id == self.id)
|
||||
{
|
||||
inflight.remove(&self.key);
|
||||
}
|
||||
}
|
||||
}
|
||||
pub(super) type BlockFlight = proton_media_rs::SingleFlight<BlockKey, BlockResult>;
|
||||
|
||||
/// Where each file's reader is expected to read next, so sequential reads can be
|
||||
/// told from random ones and only the former prefetched (audit T2).
|
||||
@@ -581,49 +551,11 @@ impl Core {
|
||||
cache_blocks: bool,
|
||||
) -> BlockResult {
|
||||
let key: BlockKey = (uid.clone(), mtime, fsize, span);
|
||||
let claim = {
|
||||
let mut inflight = self.block_flight.inflight.lock();
|
||||
match inflight.get(&key) {
|
||||
Some((_, rx)) => Err(rx.clone()),
|
||||
None => {
|
||||
let id = NEXT_FLIGHT_ID.fetch_add(1, Ordering::Relaxed);
|
||||
let (tx, rx) = tokio::sync::watch::channel(None);
|
||||
inflight.insert(key.clone(), (id, rx));
|
||||
Ok((
|
||||
tx,
|
||||
Flight {
|
||||
flight: self.block_flight.clone(),
|
||||
key: key.clone(),
|
||||
id,
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
};
|
||||
let (tx, flight) = match claim {
|
||||
Ok(lead) => lead,
|
||||
Err(mut rx) => {
|
||||
loop {
|
||||
if let Some(result) = rx.borrow_and_update().clone() {
|
||||
return result;
|
||||
}
|
||||
if rx.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return self
|
||||
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let result = self
|
||||
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||
.await;
|
||||
// Retire the claim before publishing, so a racer that wakes and re-enters
|
||||
// finds no stale entry to join.
|
||||
drop(flight);
|
||||
let _ = tx.send(Some(result.clone()));
|
||||
result
|
||||
self.block_flight
|
||||
.join(key, || {
|
||||
self.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Download and decrypt one block, then put it where the next reader will
|
||||
|
||||
@@ -77,6 +77,7 @@ fn shared_entry_of(core: &Core, n: Node) -> DirEntry {
|
||||
shared_by_unverified,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1918,6 +1918,81 @@ mod tests {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
|
||||
fn the_trash_lists_by_folder_and_empties() {
|
||||
let drive = FakeDrive::new();
|
||||
let dir = scratch("trash-by-folder");
|
||||
let daemon = Daemon::start(&dir, drive.client(1, Faults::none())).unwrap();
|
||||
let mount = &daemon.mountpoint;
|
||||
std::fs::create_dir_all(mount.join("album/inner")).unwrap();
|
||||
std::fs::write(mount.join("album/inner/a.jpg"), b"a").unwrap();
|
||||
std::fs::write(mount.join("album/b.jpg"), b"b").unwrap();
|
||||
std::fs::write(mount.join("loose.txt"), b"c").unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || daemon.drained()
|
||||
&& drive.lookup("album/inner/a.jpg").is_some()
|
||||
&& drive.lookup("loose.txt").is_some()));
|
||||
let album = drive.lookup("album").unwrap();
|
||||
let inner = drive.lookup("album/inner").unwrap();
|
||||
|
||||
// A file trashed on its own, then the folder that held it.
|
||||
drive.device().trash("album/b.jpg");
|
||||
drive.device().trash("album");
|
||||
std::fs::remove_file(mount.join("loose.txt")).unwrap();
|
||||
assert!(wait_until(Duration::from_secs(30), || daemon.drained()));
|
||||
|
||||
let list = |request: &Request| match daemon.request(request) {
|
||||
Ok(Response::Entries { entries }) => entries,
|
||||
other => panic!("unexpected reply: {other:?}"),
|
||||
};
|
||||
daemon
|
||||
.request(&Request::Refresh {
|
||||
scope: RefreshScope::Trash,
|
||||
})
|
||||
.unwrap();
|
||||
let mut trash = Vec::new();
|
||||
assert!(wait_until(Duration::from_secs(30), || {
|
||||
trash = list(&Request::ListTrash);
|
||||
trash.len() == 3
|
||||
}));
|
||||
let b = trash.iter().find(|e| e.name == "b.jpg").unwrap();
|
||||
assert_eq!(
|
||||
b.trashed_parent.as_deref(),
|
||||
Some(album.to_string().as_str())
|
||||
);
|
||||
let top: Vec<&str> = trash
|
||||
.iter()
|
||||
.filter(|e| e.trashed_parent.is_none())
|
||||
.map(|e| e.name.as_str())
|
||||
.collect();
|
||||
assert_eq!(top.len(), 2);
|
||||
assert!(top.contains(&"album") && top.contains(&"loose.txt"));
|
||||
|
||||
let inside = list(&Request::ListTrashedFolder {
|
||||
uid: album.to_string(),
|
||||
});
|
||||
let names: Vec<&str> = inside.iter().map(|e| e.name.as_str()).collect();
|
||||
assert!(names.contains(&"inner"), "{names:?}");
|
||||
assert!(names.contains(&"b.jpg"), "{names:?}");
|
||||
assert!(inside.iter().any(|e| e.uid == inner.to_string()));
|
||||
|
||||
assert!(matches!(
|
||||
daemon.request(&Request::EmptyTrash),
|
||||
Ok(Response::Ok { .. })
|
||||
));
|
||||
assert!(list(&Request::ListTrash).is_empty());
|
||||
daemon
|
||||
.request(&Request::Refresh {
|
||||
scope: RefreshScope::Trash,
|
||||
})
|
||||
.unwrap();
|
||||
assert!(list(&Request::ListTrash).is_empty());
|
||||
assert!(drive.lookup("album").is_none());
|
||||
|
||||
assert!(matches!(daemon.stop(), Ok(MountOutcome::Shutdown)));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "mounts FUSE: run with `cargo test -p pdfs-fuse sim:: -- --ignored`"]
|
||||
fn a_move_blocked_by_trash_can_be_retried_after_restore() {
|
||||
|
||||
@@ -1746,6 +1746,11 @@ impl DriveApi for FakeClient {
|
||||
.await
|
||||
}
|
||||
|
||||
async fn empty_trash(&self) -> Result<()> {
|
||||
let trashed = self.enumerate_trash_node_uids().await?;
|
||||
self.batch(&trashed, delete_one).await.map(|_| ())
|
||||
}
|
||||
|
||||
async fn enumerate_trash_node_uids(&self) -> Result<Vec<NodeUid>> {
|
||||
self.request(false, |server| {
|
||||
Ok(server
|
||||
|
||||
+222
-85
@@ -256,6 +256,62 @@ impl Reporter {
|
||||
}
|
||||
}
|
||||
|
||||
/// Photos uploaded at once. Each upload waits on Proton between its blocks,
|
||||
/// so two keep the link busy where one leaves it idle; more would mostly
|
||||
/// stage more copies on disk.
|
||||
const IMPORT_UPLOADS: usize = 2;
|
||||
|
||||
/// Where an upload reads the photo from.
|
||||
enum Source<'a> {
|
||||
/// A copy staged on disk, which a thumbnail can be made from.
|
||||
Staged(&'a Path),
|
||||
/// Straight out of the open archive.
|
||||
Archive(&'a mut zip::ZipArchive<std::io::BufReader<std::fs::File>>),
|
||||
}
|
||||
|
||||
/// A staged photo handed to an upload worker.
|
||||
struct Upload {
|
||||
index: usize,
|
||||
path: PathBuf,
|
||||
photo: TakeoutPhoto,
|
||||
tags: Vec<PhotoTag>,
|
||||
main_uid: Option<NodeUid>,
|
||||
}
|
||||
|
||||
impl Upload {
|
||||
fn landed(self, result: CoreResult<NodeUid>) -> Landed {
|
||||
Landed {
|
||||
index: self.index,
|
||||
live: self.main_uid.is_some(),
|
||||
photo: self.photo,
|
||||
result,
|
||||
}
|
||||
}
|
||||
|
||||
fn streamed(
|
||||
index: usize,
|
||||
photo: TakeoutPhoto,
|
||||
main_uid: Option<NodeUid>,
|
||||
result: CoreResult<NodeUid>,
|
||||
) -> Landed {
|
||||
Landed {
|
||||
index,
|
||||
live: main_uid.is_some(),
|
||||
photo,
|
||||
result,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A finished upload, to be counted on the import thread.
|
||||
struct Landed {
|
||||
index: usize,
|
||||
/// The video of a live pair, filed with its still.
|
||||
live: bool,
|
||||
photo: TakeoutPhoto,
|
||||
result: CoreResult<NodeUid>,
|
||||
}
|
||||
|
||||
/// How a planned photo relates to a live or motion photo pair.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum LiveRole {
|
||||
@@ -527,7 +583,7 @@ impl Core {
|
||||
let scan = match scan_archives_until(archives, || self.import_should_stop(cancel)) {
|
||||
Ok(scan) => scan,
|
||||
Err(_) if self.import_should_stop(cancel) => return Ok(true),
|
||||
Err(e) => return Err(e),
|
||||
Err(e) => return Err(CoreError::conflict(e.to_string())),
|
||||
};
|
||||
*planned = plan(&scan);
|
||||
*albums = scan.albums.clone();
|
||||
@@ -714,72 +770,133 @@ impl Core {
|
||||
}
|
||||
}
|
||||
|
||||
for (archive_index, indices) in by_archive {
|
||||
if self.import_should_stop(cancel) {
|
||||
stopped = true;
|
||||
break;
|
||||
}
|
||||
let mut archive = match open_archive(archives, archive_index) {
|
||||
Ok(archive) => archive,
|
||||
Err(e) => {
|
||||
// The archive was readable at scan time; whatever broke
|
||||
// it since costs its own photos, not the whole run.
|
||||
warn!(error = %e, photos = indices.len(), "cannot reopen a takeout archive");
|
||||
summary.failed += indices.len();
|
||||
for _ in &indices {
|
||||
job.step();
|
||||
report.step();
|
||||
// Staged photos go to IMPORT_UPLOADS workers while this thread
|
||||
// reads the next one out of its archive. A round ends only when
|
||||
// every upload in it has landed, so a pair's video always finds
|
||||
// its still's uid.
|
||||
let (jobs, queue) = std::sync::mpsc::sync_channel::<Upload>(0);
|
||||
let queue = std::sync::Mutex::new(queue);
|
||||
std::thread::scope(|scope| {
|
||||
let (landed_tx, landed) = std::sync::mpsc::channel::<Landed>();
|
||||
for _ in 0..IMPORT_UPLOADS {
|
||||
let queue = &queue;
|
||||
let landed_tx = landed_tx.clone();
|
||||
scope.spawn(move || {
|
||||
loop {
|
||||
let next = queue.lock().map(|queue| queue.recv());
|
||||
let Ok(Ok(upload)) = next else { break };
|
||||
let result = self.upload_takeout_photo(
|
||||
Source::Staged(&upload.path),
|
||||
&upload.photo,
|
||||
upload.tags.clone(),
|
||||
upload.main_uid.clone(),
|
||||
);
|
||||
let _ = std::fs::remove_file(&upload.path);
|
||||
if landed_tx.send(upload.landed(result)).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
report.counts(summary);
|
||||
continue;
|
||||
}
|
||||
};
|
||||
});
|
||||
}
|
||||
drop(landed_tx);
|
||||
|
||||
for index in indices {
|
||||
'archives: for (archive_index, indices) in by_archive {
|
||||
if self.import_should_stop(cancel) {
|
||||
stopped = true;
|
||||
break;
|
||||
}
|
||||
let main_uid = match planned[index].live {
|
||||
Some(LiveRole::Video(still)) => planned[still].uid.clone(),
|
||||
_ => None,
|
||||
};
|
||||
let photo = planned[index].photo.clone();
|
||||
job.detail(photo.name.clone());
|
||||
report.current(&photo.name);
|
||||
|
||||
let uploaded =
|
||||
self.upload_takeout_photo(&mut archive, &planned[index], main_uid.clone());
|
||||
job.step();
|
||||
report.step();
|
||||
|
||||
match uploaded {
|
||||
Ok(uid) => {
|
||||
self.note_self_change(&uid);
|
||||
summary.uploaded += 1;
|
||||
summary.bytes += photo.size;
|
||||
if main_uid.is_some() {
|
||||
summary.live_photos += 1;
|
||||
}
|
||||
if photo.favorite {
|
||||
favorites.push(uid.clone());
|
||||
}
|
||||
planned[index].uid = Some(uid);
|
||||
if summary.uploaded.is_multiple_of(TIMELINE_REFRESH_EVERY) {
|
||||
self.spawn_timeline_refresh();
|
||||
}
|
||||
if summary.uploaded.is_multiple_of(CHECKPOINT_EVERY) {
|
||||
report.counts(summary);
|
||||
report.checkpoint();
|
||||
}
|
||||
}
|
||||
let mut archive = match open_archive(archives, archive_index) {
|
||||
Ok(archive) => archive,
|
||||
Err(e) => {
|
||||
summary.failed += 1;
|
||||
warn!(name = photo.name, error = %e, "takeout photo upload failed");
|
||||
// The archive was readable at scan time; whatever
|
||||
// broke it since costs its own photos, not the run.
|
||||
warn!(error = %e, photos = indices.len(), "cannot reopen a takeout archive");
|
||||
summary.failed += indices.len();
|
||||
for _ in &indices {
|
||||
job.step();
|
||||
report.step();
|
||||
}
|
||||
report.counts(summary);
|
||||
continue;
|
||||
}
|
||||
};
|
||||
|
||||
for index in indices {
|
||||
for done in landed.try_iter() {
|
||||
self.record_upload(planned, done, summary, &mut favorites, job, report);
|
||||
}
|
||||
if self.import_should_stop(cancel) {
|
||||
stopped = true;
|
||||
break 'archives;
|
||||
}
|
||||
let item = &planned[index];
|
||||
let main_uid = match item.live {
|
||||
Some(LiveRole::Video(still)) => planned[still].uid.clone(),
|
||||
_ => None,
|
||||
};
|
||||
let tags = match item.live {
|
||||
Some(LiveRole::Still(tag)) => vec![tag],
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let photo = item.photo.clone();
|
||||
job.detail(photo.name.clone());
|
||||
report.current(&photo.name);
|
||||
|
||||
// A thumbnail is made from a file, so a photo that can
|
||||
// have one is copied out of the archive and uploaded
|
||||
// from the copy by a worker. Without one, Proton's apps
|
||||
// show a blank tile until they make their own.
|
||||
let staged = can_make_thumbnail(&photo.name, photo.size)
|
||||
.then(|| self.stage_takeout_entry(&mut archive, &photo.entry))
|
||||
.and_then(|staged| {
|
||||
staged
|
||||
.inspect_err(|e| {
|
||||
warn!(error = %e,
|
||||
"copying a takeout photo out failed; uploading it without a thumbnail")
|
||||
})
|
||||
.ok()
|
||||
});
|
||||
match staged {
|
||||
Some(path) => {
|
||||
let upload = Upload {
|
||||
index,
|
||||
path,
|
||||
photo,
|
||||
tags,
|
||||
main_uid,
|
||||
};
|
||||
if let Err(std::sync::mpsc::SendError(upload)) = jobs.send(upload) {
|
||||
let _ = std::fs::remove_file(&upload.path);
|
||||
}
|
||||
}
|
||||
None => {
|
||||
let result = self.upload_takeout_photo(
|
||||
Source::Archive(&mut archive),
|
||||
&photo,
|
||||
tags,
|
||||
main_uid.clone(),
|
||||
);
|
||||
let done = Upload::streamed(index, photo, main_uid, result);
|
||||
self.record_upload(
|
||||
planned,
|
||||
done,
|
||||
summary,
|
||||
&mut favorites,
|
||||
job,
|
||||
report,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
report.counts(summary);
|
||||
}
|
||||
|
||||
drop(jobs);
|
||||
for done in landed.iter() {
|
||||
self.record_upload(planned, done, summary, &mut favorites, job, report);
|
||||
}
|
||||
});
|
||||
if stopped {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -787,14 +904,55 @@ impl Core {
|
||||
stopped
|
||||
}
|
||||
|
||||
/// Upload one planned photo out of its open archive.
|
||||
/// Count one finished upload and file its uid in the plan.
|
||||
fn record_upload(
|
||||
&self,
|
||||
planned: &mut [Planned],
|
||||
done: Landed,
|
||||
summary: &mut ImportSummary,
|
||||
favorites: &mut Vec<NodeUid>,
|
||||
job: &crate::transfers::JobGuard,
|
||||
report: &Reporter,
|
||||
) {
|
||||
job.step();
|
||||
report.step();
|
||||
match done.result {
|
||||
Ok(uid) => {
|
||||
self.note_self_change(&uid);
|
||||
summary.uploaded += 1;
|
||||
summary.bytes += done.photo.size;
|
||||
if done.live {
|
||||
summary.live_photos += 1;
|
||||
}
|
||||
if done.photo.favorite {
|
||||
favorites.push(uid.clone());
|
||||
}
|
||||
planned[done.index].uid = Some(uid);
|
||||
if summary.uploaded.is_multiple_of(TIMELINE_REFRESH_EVERY) {
|
||||
self.spawn_timeline_refresh();
|
||||
}
|
||||
if summary.uploaded.is_multiple_of(CHECKPOINT_EVERY) {
|
||||
report.counts(summary);
|
||||
report.checkpoint();
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
summary.failed += 1;
|
||||
warn!(error = %e, "takeout photo upload failed");
|
||||
}
|
||||
}
|
||||
report.counts(summary);
|
||||
}
|
||||
|
||||
/// Upload one planned photo, from its staged copy or straight out of its
|
||||
/// open archive.
|
||||
fn upload_takeout_photo(
|
||||
&self,
|
||||
archive: &mut zip::ZipArchive<std::io::BufReader<std::fs::File>>,
|
||||
item: &Planned,
|
||||
source: Source<'_>,
|
||||
photo: &TakeoutPhoto,
|
||||
tags: Vec<PhotoTag>,
|
||||
main_uid: Option<NodeUid>,
|
||||
) -> CoreResult<NodeUid> {
|
||||
let photo = &item.photo;
|
||||
let photos = self.photos();
|
||||
let guard = self.transfers.begin(
|
||||
photo.name.clone(),
|
||||
@@ -802,10 +960,6 @@ impl Core {
|
||||
TransferDirection::Upload,
|
||||
photo.size,
|
||||
);
|
||||
let tags = match item.live {
|
||||
Some(LiveRole::Still(tag)) => vec![tag],
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let metadata = |capture_time: Option<i64>| PhotoUploadMetadata {
|
||||
capture_time,
|
||||
last_modification_time: capture_time.and_then(pdfs_core::timestamp::modification_time),
|
||||
@@ -820,21 +974,8 @@ impl Core {
|
||||
replace_existing_draft: true,
|
||||
};
|
||||
|
||||
// A thumbnail is made from a file, so a photo that can have one is
|
||||
// copied out of the archive first and uploaded from the copy. Without
|
||||
// one, Proton's apps show a blank tile until they make their own.
|
||||
let staged = can_make_thumbnail(&photo.name, photo.size)
|
||||
.then(|| self.stage_takeout_entry(archive, &photo.entry))
|
||||
.and_then(|staged| {
|
||||
staged
|
||||
.inspect_err(|e| {
|
||||
warn!(name = photo.name, error = %e,
|
||||
"copying a takeout photo out failed; uploading it without a thumbnail")
|
||||
})
|
||||
.ok()
|
||||
});
|
||||
let uploaded = match &staged {
|
||||
Some(path) => {
|
||||
match source {
|
||||
Source::Staged(path) => {
|
||||
let thumbnails = self.upload_thumbnails(path, &photo.name);
|
||||
// No sidecar date and none in the name: the photo's own EXIF,
|
||||
// then when Google received it, before Drive files it under
|
||||
@@ -860,7 +1001,7 @@ impl Core {
|
||||
.map_err(|e| CoreError::from_api(&e, "upload"))
|
||||
})
|
||||
}
|
||||
None => read_entry(archive, &photo.entry, |reader| {
|
||||
Source::Archive(archive) => read_entry(archive, &photo.entry, |reader| {
|
||||
let counting = CountingReader::new(reader, &guard);
|
||||
self.rt
|
||||
.block_on(photos.upload_photo_from(
|
||||
@@ -875,11 +1016,7 @@ impl Core {
|
||||
.map_err(|e| CoreError::from_api(&e, "upload"))
|
||||
})
|
||||
.and_then(|result| result),
|
||||
};
|
||||
if let Some(path) = staged {
|
||||
let _ = std::fs::remove_file(path);
|
||||
}
|
||||
uploaded
|
||||
}
|
||||
|
||||
/// Mark photos as favorites. A separate call: the upload seal takes
|
||||
|
||||
@@ -22,7 +22,9 @@ name = "pdfs-prompt"
|
||||
path = "src/prompt.rs"
|
||||
|
||||
[dependencies]
|
||||
pg-core.workspace = true
|
||||
proton-gallery-rs.workspace = true
|
||||
# The offline basemap under the Places map.
|
||||
proton-map-rs.workspace = true
|
||||
base64.workspace = true
|
||||
pdfs-core.workspace = true
|
||||
tracing.workspace = true
|
||||
@@ -43,3 +45,7 @@ pangocairo = "0.22"
|
||||
reqwest = { version = "0.13", default-features = false, features = ["rustls", "webpki-roots"] }
|
||||
# The system libintl (glibc) rather than a bundled gettext build.
|
||||
gettext-rs = { version = "0.8", features = ["gettext-system"] }
|
||||
|
||||
[dev-dependencies]
|
||||
# Builds small basemaps for the map tests.
|
||||
proton-map-rs = { workspace = true, features = ["writer"] }
|
||||
@@ -154,7 +154,6 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
|
||||
ui.gallery.decode_queue.borrow_mut().clear();
|
||||
ui.gallery.thumb_wanted.borrow_mut().clear();
|
||||
ui.gallery.photo_tex.borrow_mut().clear();
|
||||
ui.gallery.photo_tex_order.borrow_mut().clear();
|
||||
ui.gallery.model.remove_all();
|
||||
ui.gallery.groups.remove_all();
|
||||
ui.gallery.row_by_photo.borrow_mut().clear();
|
||||
|
||||
@@ -0,0 +1,248 @@
|
||||
//! A least-recently-used cache with a cost budget.
|
||||
//!
|
||||
//! Each entry carries a cost (bytes for a texture cache, `1` for a cache capped
|
||||
//! by count). Inserting past the budget drops the entries used longest ago.
|
||||
//! Lookups and touches are logarithmic, so a cache of a few thousand textures
|
||||
//! can be touched on every tile bind without a linear scan.
|
||||
|
||||
use std::borrow::Borrow;
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
use std::hash::Hash;
|
||||
|
||||
struct Entry<V> {
|
||||
value: V,
|
||||
cost: usize,
|
||||
stamp: u64,
|
||||
}
|
||||
|
||||
pub(crate) struct Lru<K, V> {
|
||||
entries: HashMap<K, Entry<V>>,
|
||||
/// Entries by the stamp of their last use, oldest first.
|
||||
order: BTreeMap<u64, K>,
|
||||
next: u64,
|
||||
used: usize,
|
||||
budget: usize,
|
||||
}
|
||||
|
||||
impl<K: Eq + Hash + Clone, V> Lru<K, V> {
|
||||
pub(crate) fn new(budget: usize) -> Self {
|
||||
Self {
|
||||
entries: HashMap::new(),
|
||||
order: BTreeMap::new(),
|
||||
next: 0,
|
||||
used: 0,
|
||||
budget,
|
||||
}
|
||||
}
|
||||
|
||||
/// Look an entry up without marking it used.
|
||||
pub(crate) fn get<Q>(&self, key: &Q) -> Option<&V>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
self.entries.get(key).map(|entry| &entry.value)
|
||||
}
|
||||
|
||||
pub(crate) fn contains_key<Q>(&self, key: &Q) -> bool
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
self.entries.contains_key(key)
|
||||
}
|
||||
|
||||
/// Mark an entry as just used, so it is the last to be evicted. Returns
|
||||
/// whether it was there.
|
||||
pub(crate) fn touch<Q>(&mut self, key: &Q) -> bool
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
let stamp = self.next;
|
||||
let Some(entry) = self.entries.get_mut(key) else {
|
||||
return false;
|
||||
};
|
||||
if let Some(held) = self.order.remove(&entry.stamp) {
|
||||
self.order.insert(stamp, held);
|
||||
}
|
||||
entry.stamp = stamp;
|
||||
self.next += 1;
|
||||
true
|
||||
}
|
||||
|
||||
/// Look an entry up and mark it used.
|
||||
pub(crate) fn fetch<Q>(&mut self, key: &Q) -> Option<&V>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
if !self.touch(key) {
|
||||
return None;
|
||||
}
|
||||
self.get(key)
|
||||
}
|
||||
|
||||
/// Store `value` as the most recently used entry, then evict the least
|
||||
/// recently used ones until the total cost fits the budget again. The new
|
||||
/// entry itself is never evicted, even when it alone is over budget.
|
||||
pub(crate) fn insert(&mut self, key: K, value: V, cost: usize) {
|
||||
self.remove(&key);
|
||||
let stamp = self.next;
|
||||
self.next += 1;
|
||||
self.order.insert(stamp, key.clone());
|
||||
self.entries.insert(key, Entry { value, cost, stamp });
|
||||
self.used += cost;
|
||||
while self.used > self.budget && self.order.len() > 1 {
|
||||
let Some((_, oldest)) = self.order.pop_first() else {
|
||||
break;
|
||||
};
|
||||
if let Some(entry) = self.entries.remove(&oldest) {
|
||||
self.used -= entry.cost;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn remove<Q>(&mut self, key: &Q) -> Option<V>
|
||||
where
|
||||
K: Borrow<Q>,
|
||||
Q: Eq + Hash + ?Sized,
|
||||
{
|
||||
let entry = self.entries.remove(key)?;
|
||||
self.order.remove(&entry.stamp);
|
||||
self.used -= entry.cost;
|
||||
Some(entry.value)
|
||||
}
|
||||
|
||||
/// Keep only the entries `keep` accepts.
|
||||
pub(crate) fn retain(&mut self, mut keep: impl FnMut(&K, &V) -> bool) {
|
||||
let order = &mut self.order;
|
||||
let used = &mut self.used;
|
||||
self.entries.retain(|key, entry| {
|
||||
let kept = keep(key, &entry.value);
|
||||
if !kept {
|
||||
order.remove(&entry.stamp);
|
||||
*used -= entry.cost;
|
||||
}
|
||||
kept
|
||||
});
|
||||
}
|
||||
|
||||
pub(crate) fn clear(&mut self) {
|
||||
self.entries.clear();
|
||||
self.order.clear();
|
||||
self.used = 0;
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn len(&self) -> usize {
|
||||
self.entries.len()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn used(&self) -> usize {
|
||||
self.used
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::Lru;
|
||||
|
||||
#[test]
|
||||
fn evicts_least_recently_used_past_budget() {
|
||||
let mut cache = Lru::new(3);
|
||||
cache.insert("a", 1, 1);
|
||||
cache.insert("b", 2, 1);
|
||||
cache.insert("c", 3, 1);
|
||||
assert!(cache.touch("a"));
|
||||
cache.insert("d", 4, 1);
|
||||
assert!(cache.contains_key("a"));
|
||||
assert!(!cache.contains_key("b"));
|
||||
assert!(cache.contains_key("c"));
|
||||
assert!(cache.contains_key("d"));
|
||||
assert_eq!(cache.len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn budget_counts_cost_not_entries() {
|
||||
let mut cache = Lru::new(100);
|
||||
cache.insert("small", (), 10);
|
||||
cache.insert("medium", (), 40);
|
||||
cache.insert("large", (), 60);
|
||||
// 110 > 100: the oldest goes, and that is enough.
|
||||
assert!(!cache.contains_key("small"));
|
||||
assert_eq!(cache.used(), 100);
|
||||
cache.insert("huge", (), 90);
|
||||
assert_eq!(cache.used(), 90);
|
||||
assert_eq!(cache.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keeps_a_single_entry_over_budget() {
|
||||
let mut cache = Lru::new(10);
|
||||
cache.insert("a", (), 5);
|
||||
cache.insert("big", (), 50);
|
||||
assert!(cache.contains_key("big"));
|
||||
assert!(!cache.contains_key("a"));
|
||||
assert_eq!(cache.used(), 50);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn remove_and_clear_keep_cost_in_step() {
|
||||
let mut cache = Lru::new(100);
|
||||
cache.insert("a", (), 10);
|
||||
cache.insert("b", (), 20);
|
||||
assert_eq!(cache.remove("a"), Some(()));
|
||||
assert_eq!(cache.used(), 20);
|
||||
cache.clear();
|
||||
assert_eq!(cache.used(), 0);
|
||||
assert_eq!(cache.len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reinsert_replaces_cost_and_refreshes() {
|
||||
let mut cache = Lru::new(30);
|
||||
cache.insert("a", 1, 10);
|
||||
cache.insert("b", 2, 10);
|
||||
cache.insert("a", 3, 15);
|
||||
assert_eq!(cache.used(), 25);
|
||||
assert_eq!(cache.get("a"), Some(&3));
|
||||
cache.insert("c", 4, 10);
|
||||
// "b" was used longest ago now.
|
||||
assert!(!cache.contains_key("b"));
|
||||
assert!(cache.contains_key("a"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fetch_touches_and_get_does_not() {
|
||||
let mut cache = Lru::new(2);
|
||||
cache.insert("a", 1, 1);
|
||||
cache.insert("b", 2, 1);
|
||||
assert_eq!(cache.get("a"), Some(&1));
|
||||
cache.insert("c", 3, 1);
|
||||
assert!(!cache.contains_key("a"));
|
||||
assert_eq!(cache.fetch("b"), Some(&2));
|
||||
cache.insert("d", 4, 1);
|
||||
assert!(cache.contains_key("b"));
|
||||
assert!(!cache.contains_key("c"));
|
||||
assert_eq!(cache.fetch("missing"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retain_drops_rejected_entries_and_their_cost() {
|
||||
let mut cache = Lru::new(100);
|
||||
cache.insert((true, "a".to_string()), (), 10);
|
||||
cache.insert((false, "b".to_string()), (), 20);
|
||||
cache.insert((true, "c".to_string()), (), 30);
|
||||
cache.retain(|(private, _), _| !private);
|
||||
assert_eq!(cache.used(), 20);
|
||||
assert_eq!(cache.len(), 1);
|
||||
assert!(cache.remove(&(false, "b".to_string())).is_some());
|
||||
assert_eq!(cache.used(), 0);
|
||||
cache.insert((true, "d".to_string()), (), 10);
|
||||
cache.clear();
|
||||
assert_eq!(cache.used(), 0);
|
||||
assert_eq!(cache.len(), 0);
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ pub(crate) mod dates;
|
||||
pub(crate) mod events;
|
||||
#[path = "../i18n.rs"]
|
||||
pub(crate) mod i18n;
|
||||
pub(crate) mod lru;
|
||||
pub(crate) mod pages;
|
||||
pub(crate) mod reload;
|
||||
#[path = "../theme.rs"]
|
||||
@@ -15,6 +16,7 @@ pub(crate) mod widgets;
|
||||
|
||||
use compat::*;
|
||||
use events::*;
|
||||
use lru::Lru;
|
||||
use pages::activity::*;
|
||||
use pages::albums::*;
|
||||
use pages::browser::*;
|
||||
@@ -190,16 +192,11 @@ impl Ui {
|
||||
/// Scrolling back over a day then repaints from memory rather than decoding
|
||||
/// the same JPEGs off disk again.
|
||||
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
|
||||
let mut cache = self.gallery.photo_tex.borrow_mut();
|
||||
let mut order = self.gallery.photo_tex_order.borrow_mut();
|
||||
if cache.insert(uid.to_string(), texture).is_none() {
|
||||
order.push_back(uid.to_string());
|
||||
}
|
||||
while order.len() > TEXTURE_CACHE_MAX {
|
||||
if let Some(old) = order.pop_front() {
|
||||
cache.remove(&old);
|
||||
}
|
||||
}
|
||||
let bytes = texture_bytes(texture.width(), texture.height());
|
||||
self.gallery
|
||||
.photo_tex
|
||||
.borrow_mut()
|
||||
.insert(uid.to_string(), texture, bytes);
|
||||
}
|
||||
|
||||
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles
|
||||
@@ -208,14 +205,7 @@ impl Ui {
|
||||
/// Insertion order alone evicts the top of the timeline first — exactly what
|
||||
/// a scroll back up then asks for again.
|
||||
fn touch_texture(&self, uid: &str) {
|
||||
let mut order = self.gallery.photo_tex_order.borrow_mut();
|
||||
if order.back().is_some_and(|back| back == uid) {
|
||||
return;
|
||||
}
|
||||
if let Some(at) = order.iter().position(|held| held == uid) {
|
||||
order.remove(at);
|
||||
order.push_back(uid.to_string());
|
||||
}
|
||||
self.gallery.photo_tex.borrow_mut().touch(uid);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -557,6 +547,13 @@ fn build_window(app: &adw::Application) {
|
||||
selection_bar: trash_widgets.selection_bar.clone(),
|
||||
selection_label: trash_widgets.selection_label.clone(),
|
||||
loader: Loader::new(&trash_widgets.content),
|
||||
back: trash_widgets.back.clone(),
|
||||
crumb: trash_widgets.crumb.clone(),
|
||||
search: trash_widgets.search.clone(),
|
||||
grouped: trash_widgets.grouped.clone(),
|
||||
all: RefCell::new(Vec::new()),
|
||||
nav: RefCell::new(Vec::new()),
|
||||
folder_rows: RefCell::new(None),
|
||||
},
|
||||
gallery: GalleryState {
|
||||
model: gallery_widgets.model.clone(),
|
||||
@@ -631,8 +628,7 @@ fn build_window(app: &adw::Application) {
|
||||
library: Cell::new(true),
|
||||
page_waiters: RefCell::new(Vec::new()),
|
||||
width: Cell::new(0),
|
||||
photo_tex: RefCell::new(HashMap::new()),
|
||||
photo_tex_order: RefCell::new(VecDeque::new()),
|
||||
photo_tex: RefCell::new(Lru::new(TEXTURE_CACHE_BYTES)),
|
||||
photo_nothumb: RefCell::new(HashSet::new()),
|
||||
thumb_wanted: RefCell::new(HashMap::new()),
|
||||
thumb_queue: RefCell::new(VecDeque::new()),
|
||||
@@ -640,6 +636,7 @@ fn build_window(app: &adw::Application) {
|
||||
thumb_generation: Cell::new(0),
|
||||
decode_queue: RefCell::new(VecDeque::new()),
|
||||
decode_idle: Cell::new(false),
|
||||
decode_inflight: RefCell::default(),
|
||||
thumb_source: RefCell::new(None),
|
||||
relayout_source: RefCell::new(None),
|
||||
bound: RefCell::new(BTreeMap::new()),
|
||||
@@ -652,6 +649,7 @@ fn build_window(app: &adw::Application) {
|
||||
select_btn: gallery_widgets.select_btn.clone(),
|
||||
selection: gallery_widgets.selection.clone(),
|
||||
more: gallery_widgets.more.clone(),
|
||||
gallery_actions: gallery_widgets.gallery_actions.clone(),
|
||||
upload_face: gallery_widgets.upload_face.clone(),
|
||||
float_heading: gallery_widgets.float_heading.clone(),
|
||||
float_label: gallery_widgets.float_label.clone(),
|
||||
@@ -737,6 +735,10 @@ fn build_window(app: &adw::Application) {
|
||||
resume_button: takeout_widgets.resume_button.clone(),
|
||||
inflight: Cell::new(false),
|
||||
running: Cell::new(false),
|
||||
restored: Cell::new(false),
|
||||
save_seq: Cell::new(0),
|
||||
saved_seq: Default::default(),
|
||||
repaint_seq: Cell::new(0),
|
||||
},
|
||||
update,
|
||||
});
|
||||
@@ -1481,7 +1483,7 @@ fn install_window_actions(ui: &Rc<Ui>, window: &adw::ApplicationWindow) {
|
||||
None,
|
||||
gtk4::License::Custom,
|
||||
Some(&gettext(
|
||||
"The places map is drawn from <a href=\"https://www.naturalearthdata.com/\">Natural Earth</a> land outlines and country borders, which are in the public domain.",
|
||||
"The places map is drawn from <a href=\"https://www.naturalearthdata.com/\">Natural Earth</a> land, water and borders, which are in the public domain.",
|
||||
)),
|
||||
);
|
||||
dialog.add_legal_section(
|
||||
|
||||
@@ -3185,6 +3185,7 @@ pub(crate) fn repaint_search(ui: &Rc<Ui>, hits: &[SearchHit]) {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
})
|
||||
.collect();
|
||||
@@ -3249,6 +3250,7 @@ mod tests {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +1,32 @@
|
||||
use crate::*;
|
||||
use base64::{Engine, engine::general_purpose::STANDARD};
|
||||
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
|
||||
use std::collections::VecDeque;
|
||||
|
||||
const PAGE: usize = 150;
|
||||
/// Decoded thumbnails kept, the least recently shown dropped first.
|
||||
const THUMB_CACHE: usize = 256;
|
||||
/// What a new content width asks of the rows.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
enum Reflow {
|
||||
/// Nothing changed, or there is no width yet.
|
||||
None,
|
||||
/// The first real width: lay the rows out now, nothing is on screen yet.
|
||||
Now,
|
||||
/// A resize: wait for it to settle, since the rows are rebuilt from
|
||||
/// scratch and a drag resizes on every frame.
|
||||
Debounced,
|
||||
}
|
||||
|
||||
fn reflow_for(previous: i32, width: i32) -> Reflow {
|
||||
if width <= 0 || width == previous {
|
||||
Reflow::None
|
||||
} else if previous <= 0 {
|
||||
Reflow::Now
|
||||
} else {
|
||||
Reflow::Debounced
|
||||
}
|
||||
}
|
||||
|
||||
type ThumbnailKey = (u64, bool, String);
|
||||
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
|
||||
|
||||
@@ -45,12 +67,15 @@ pub(crate) struct Browser {
|
||||
albums: RefCell<Vec<GalleryAlbum>>,
|
||||
items: RefCell<Vec<PhotoItem>>,
|
||||
width: Cell<i32>,
|
||||
/// The pending re-flow after a resize, replaced by each new width.
|
||||
reflow: RefCell<Option<glib::SourceId>>,
|
||||
generation: Cell<u64>,
|
||||
total: Cell<usize>,
|
||||
loading: Cell<bool>,
|
||||
unlocked: Cell<bool>,
|
||||
thumbnail_slots: tokio::sync::Semaphore,
|
||||
thumbnails: RefCell<VecDeque<(bool, String, gtk4::gdk::Texture)>>,
|
||||
/// Decoded thumbnails by whether they are hidden-album ones and uid.
|
||||
thumbnails: RefCell<Lru<(bool, String), gtk4::gdk::Texture>>,
|
||||
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
|
||||
}
|
||||
|
||||
@@ -86,7 +111,7 @@ impl Browser {
|
||||
}
|
||||
self.thumbnails
|
||||
.borrow_mut()
|
||||
.retain(|(private, _, _)| !private);
|
||||
.retain(|(private, _), _| !private);
|
||||
self.thumb_pending.borrow_mut().clear();
|
||||
self.trail.borrow_mut().clear();
|
||||
self.chooser.borrow_mut().take();
|
||||
@@ -552,7 +577,7 @@ impl Browser {
|
||||
if self.chooser.borrow().is_some() {
|
||||
return;
|
||||
}
|
||||
let width = (self.width.get() - 24).max(240);
|
||||
let width = self.width.get().max(240);
|
||||
let columns = ((width + 8) / 216).max(1);
|
||||
let card = (width - 8 * (columns - 1)) / columns;
|
||||
let mut rows = Vec::new();
|
||||
@@ -602,6 +627,13 @@ impl Browser {
|
||||
let generation = self.generation.get();
|
||||
glib::spawn_future_local(async move {
|
||||
let result = reply.recv().await;
|
||||
// Decoded before the checks below, so they see the state after it.
|
||||
let decoded = match &result {
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
|
||||
decode_thumbnail_off_thread(data.clone()).await
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
let close = |token| {
|
||||
let _ = spawn_request(
|
||||
browser.ui.dirs.control_socket(),
|
||||
@@ -646,8 +678,8 @@ impl Browser {
|
||||
picture.set_vexpand(true);
|
||||
content.append(&picture);
|
||||
}
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
|
||||
let Some(texture) = decode_thumbnail(&data) else {
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => {
|
||||
let Some(texture) = decoded else {
|
||||
browser
|
||||
.status
|
||||
.set_label(&gettext("Couldn't open the photo."));
|
||||
@@ -683,13 +715,15 @@ pub(crate) fn wire(
|
||||
hidden: >k4::Button,
|
||||
) {
|
||||
let title = ui.gallery.title.clone();
|
||||
let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||
header.set_halign(gtk4::Align::End);
|
||||
// The page's header bar holds these, beside Select (see `sync_header`).
|
||||
let header = &ui.gallery.gallery_actions;
|
||||
let choose = gtk4::Button::with_label(&gettext("Add This Folder"));
|
||||
choose.set_visible(false);
|
||||
choose.add_css_class("suggested-action");
|
||||
header.append(&choose);
|
||||
let more = gtk4::Button::from_icon_name("view-more-symbolic");
|
||||
more.set_tooltip_text(Some(&gettext("Gallery Options")));
|
||||
more.add_css_class("flat");
|
||||
let unlock = gtk4::Button::with_label(&gettext("Unlock"));
|
||||
unlock.set_visible(false);
|
||||
header.append(&unlock);
|
||||
@@ -709,7 +743,6 @@ pub(crate) fn wire(
|
||||
let status = gtk4::Label::new(None);
|
||||
status.set_wrap(true);
|
||||
let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
|
||||
content.append(&header);
|
||||
content.append(&status);
|
||||
content.append(&scroll);
|
||||
ui.gallery
|
||||
@@ -743,12 +776,13 @@ pub(crate) fn wire(
|
||||
albums: RefCell::new(Vec::new()),
|
||||
items: RefCell::new(Vec::new()),
|
||||
width: Cell::new(0),
|
||||
reflow: RefCell::new(None),
|
||||
generation: Cell::new(0),
|
||||
total: Cell::new(0),
|
||||
loading: Cell::new(false),
|
||||
unlocked: Cell::new(false),
|
||||
thumbnail_slots: tokio::sync::Semaphore::new(8),
|
||||
thumbnails: RefCell::default(),
|
||||
thumbnails: RefCell::new(Lru::new(THUMB_CACHE)),
|
||||
thumb_pending: RefCell::default(),
|
||||
});
|
||||
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
|
||||
@@ -794,12 +828,13 @@ pub(crate) fn wire(
|
||||
return;
|
||||
};
|
||||
let row = data.borrow::<Row>();
|
||||
// The page around the list already keeps its margins, so rows run edge
|
||||
// to edge like the timeline's.
|
||||
let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||
line.set_margin_start(12);
|
||||
line.set_margin_end(12);
|
||||
line.set_margin_bottom(8);
|
||||
match &*row {
|
||||
Row::Heading(label) => {
|
||||
line.set_margin_top(12);
|
||||
let label = gtk4::Label::new(Some(label));
|
||||
label.add_css_class("heading");
|
||||
line.append(&label);
|
||||
@@ -841,7 +876,9 @@ pub(crate) fn wire(
|
||||
}
|
||||
}
|
||||
Row::Media(items) => {
|
||||
// The same gap down as across, as in the timeline.
|
||||
line.set_spacing(super::photos::TILE_GAP);
|
||||
line.set_margin_bottom(super::photos::TILE_GAP);
|
||||
for (item, (width, height)) in items {
|
||||
let button = tile(
|
||||
&browser,
|
||||
@@ -918,11 +955,6 @@ pub(crate) fn wire(
|
||||
let browser = browser.clone();
|
||||
move || browser.close()
|
||||
});
|
||||
} else {
|
||||
menu.item(&gettext("Refresh galleries"), {
|
||||
let browser = browser.clone();
|
||||
move || browser.change(GalleryAction::Refresh)
|
||||
});
|
||||
}
|
||||
if let Some(album) = browser.current().filter(|album| !album.proton) {
|
||||
menu.item(&gettext("Choose Cover"), {
|
||||
@@ -1000,8 +1032,27 @@ pub(crate) fn wire(
|
||||
return glib::ControlFlow::Break;
|
||||
};
|
||||
let width = scroll.width();
|
||||
if width > 0 && browser.width.replace(width) != width {
|
||||
browser.rebuild();
|
||||
match reflow_for(browser.width.get(), width) {
|
||||
Reflow::None => {}
|
||||
Reflow::Now => {
|
||||
browser.width.set(width);
|
||||
browser.rebuild();
|
||||
}
|
||||
Reflow::Debounced => {
|
||||
browser.width.set(width);
|
||||
if let Some(source) = browser.reflow.borrow_mut().take() {
|
||||
source.remove();
|
||||
}
|
||||
let weak = Rc::downgrade(&browser);
|
||||
let source =
|
||||
glib::timeout_add_local_once(super::photos::RELAYOUT_DEBOUNCE, move || {
|
||||
if let Some(browser) = weak.upgrade() {
|
||||
browser.reflow.borrow_mut().take();
|
||||
browser.rebuild();
|
||||
}
|
||||
});
|
||||
*browser.reflow.borrow_mut() = Some(source);
|
||||
}
|
||||
}
|
||||
glib::ControlFlow::Continue
|
||||
}
|
||||
@@ -1089,6 +1140,15 @@ fn decode_thumbnail(data: &str) -> Option<gtk4::gdk::Texture> {
|
||||
gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok()
|
||||
}
|
||||
|
||||
/// [`decode_thumbnail`] on gio's blocking pool, so neither the base64 nor the
|
||||
/// image decoder runs on the GTK thread.
|
||||
async fn decode_thumbnail_off_thread(data: String) -> Option<gtk4::gdk::Texture> {
|
||||
gio::spawn_blocking(move || decode_thumbnail(&data))
|
||||
.await
|
||||
.ok()
|
||||
.flatten()
|
||||
}
|
||||
|
||||
impl Browser {
|
||||
fn want_thumbnail(
|
||||
self: &Rc<Self>,
|
||||
@@ -1100,20 +1160,17 @@ impl Browser {
|
||||
if private && !self.unlocked.get() {
|
||||
return;
|
||||
}
|
||||
{
|
||||
let mut cache = self.thumbnails.borrow_mut();
|
||||
if let Some(index) = cache
|
||||
.iter()
|
||||
.position(|(p, id, _)| *p == private && id == uid)
|
||||
{
|
||||
let cached = cache.remove(index).unwrap();
|
||||
picture.set_paintable(Some(&cached.2));
|
||||
if let Some(icon) = icon.upgrade() {
|
||||
icon.set_visible(false);
|
||||
}
|
||||
cache.push_back(cached);
|
||||
return;
|
||||
let cached = self
|
||||
.thumbnails
|
||||
.borrow_mut()
|
||||
.fetch(&(private, uid.to_owned()))
|
||||
.cloned();
|
||||
if let Some(texture) = cached {
|
||||
picture.set_paintable(Some(&texture));
|
||||
if let Some(icon) = icon.upgrade() {
|
||||
icon.set_visible(false);
|
||||
}
|
||||
return;
|
||||
}
|
||||
let key = (self.generation.get(), private, uid.to_owned());
|
||||
{
|
||||
@@ -1152,6 +1209,12 @@ impl Browser {
|
||||
},
|
||||
);
|
||||
let response = request.recv().await;
|
||||
let texture = match response {
|
||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) => {
|
||||
decode_thumbnail_off_thread(data).await
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
let targets = browser
|
||||
.thumb_pending
|
||||
.borrow_mut()
|
||||
@@ -1160,9 +1223,7 @@ impl Browser {
|
||||
if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
|
||||
return;
|
||||
}
|
||||
if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response
|
||||
&& let Some(texture) = decode_thumbnail(&data)
|
||||
{
|
||||
if let Some(texture) = texture {
|
||||
for (picture, icon) in targets {
|
||||
if let Some(picture) = picture.upgrade() {
|
||||
picture.set_paintable(Some(&texture));
|
||||
@@ -1171,12 +1232,27 @@ impl Browser {
|
||||
icon.set_visible(false);
|
||||
}
|
||||
}
|
||||
let mut cache = browser.thumbnails.borrow_mut();
|
||||
if cache.len() >= THUMB_CACHE {
|
||||
cache.pop_front();
|
||||
}
|
||||
cache.push_back((private, key.2, texture));
|
||||
// Capped by count, like before: every entry costs one.
|
||||
browser
|
||||
.thumbnails
|
||||
.borrow_mut()
|
||||
.insert((private, key.2), texture, 1);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{Reflow, reflow_for};
|
||||
|
||||
#[test]
|
||||
fn the_first_width_lays_out_at_once_and_a_resize_waits() {
|
||||
assert_eq!(reflow_for(0, 0), Reflow::None);
|
||||
assert_eq!(reflow_for(0, 800), Reflow::Now);
|
||||
assert_eq!(reflow_for(800, 800), Reflow::None);
|
||||
assert_eq!(reflow_for(800, 760), Reflow::Debounced);
|
||||
// A collapsed widget reports no width; keep the last layout.
|
||||
assert_eq!(reflow_for(800, 0), Reflow::None);
|
||||
}
|
||||
}
|
||||
@@ -336,6 +336,9 @@ pub(crate) fn login_error_message(error: &pdfs_core::Error) -> String {
|
||||
pdfs_core::Error::WrongMailboxPassword => {
|
||||
gettext("That mailbox password didn't unlock your account.")
|
||||
}
|
||||
pdfs_core::Error::SecurityKeyOnly => gettext(
|
||||
"This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code.",
|
||||
),
|
||||
pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
|
||||
),
|
||||
@@ -672,15 +675,45 @@ fn verify_in_browser(
|
||||
/// Sign out, after a confirmation: disable+stop the mount service (so the
|
||||
/// daemon isn't left running without credentials), forget the stored session,
|
||||
/// and drop back to the login page.
|
||||
///
|
||||
/// Changes still queued are named first: they stay staged here and are sent
|
||||
/// after the next sign-in, but until then they exist nowhere else.
|
||||
pub(crate) fn sign_out(ui: &Rc<Ui>) {
|
||||
let rx = spawn_request(ui.dirs.control_socket(), Request::Status);
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let queued = match rx.recv().await {
|
||||
Ok(Ok(Response::Status {
|
||||
pending_uploads,
|
||||
pending_changes,
|
||||
parked_uploads,
|
||||
..
|
||||
})) => pending_uploads + pending_changes + parked_uploads,
|
||||
_ => 0,
|
||||
};
|
||||
confirm_sign_out(&ui, queued);
|
||||
});
|
||||
}
|
||||
|
||||
fn confirm_sign_out(ui: &Rc<Ui>, queued: u64) {
|
||||
let Some(window) = ui_window(ui) else { return };
|
||||
let ui = ui.clone();
|
||||
let mut body = gettext(
|
||||
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
|
||||
);
|
||||
if queued > 0 {
|
||||
let warning = ngettext_f(
|
||||
"{n} change is not on Proton Drive yet. It stays on this computer and is sent after you sign in again.",
|
||||
"{n} changes are not on Proton Drive yet. They stay on this computer and are sent after you sign in again.",
|
||||
queued,
|
||||
&[],
|
||||
);
|
||||
body = format!("{warning}\n\n{body}");
|
||||
}
|
||||
confirm_destructive(
|
||||
&window,
|
||||
&gettext("Sign Out?"),
|
||||
&gettext(
|
||||
"Proton Drive will disconnect and stop syncing until you sign in again. Files already on this computer stay where they are.",
|
||||
),
|
||||
&body,
|
||||
&gettext("Sign Out"),
|
||||
move || {
|
||||
let galleries = ui.drive_galleries.borrow().upgrade();
|
||||
@@ -711,6 +744,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_cancelled_prompt_says_which_step_was_skipped() {
|
||||
assert!(
|
||||
login_error_message(&pdfs_core::Error::SecurityKeyOnly).contains("authenticator app")
|
||||
);
|
||||
let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
|
||||
assert!(login_error_message(&totp).contains("two-factor code"));
|
||||
let hv = pdfs_core::Error::Other("verification cancelled".into());
|
||||
|
||||
@@ -1,7 +1,12 @@
|
||||
//! The online street map under the Places map: vector tiles from OpenFreeMap,
|
||||
//! fetched and drawn on a worker thread, and handed to the map as finished
|
||||
//! images.
|
||||
//! The tiles under the Places map, made on worker threads and handed to the
|
||||
//! map as finished images. They come from one of two sources.
|
||||
//!
|
||||
//! The offline basemap is a PMTiles file installed with the app and drawn by
|
||||
//! `proton-map-rs`, the same map Proton Gallery shows: seas, lakes, rivers,
|
||||
//! built-up areas, borders and town names from Natural Earth and GeoNames.
|
||||
//! It sends nothing anywhere. Its names are drawn into the tiles.
|
||||
//!
|
||||
//! The online street map is vector tiles from OpenFreeMap.
|
||||
//! It is off unless turned on in Preferences, since every tile fetched tells
|
||||
//! OpenFreeMap which part of the world is being looked at. OpenFreeMap needs
|
||||
//! no account or key, and its tiles are OpenStreetMap data in the
|
||||
@@ -20,9 +25,17 @@ use std::sync::{Arc, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
use gtk4::cairo;
|
||||
use proton_map::{Basemap, Style, TileId};
|
||||
|
||||
use super::mvt::{self, Kind, Layer};
|
||||
|
||||
/// The basemap's file name, wherever it is installed.
|
||||
pub(crate) const BASEMAP_FILE: &str = "basemap-v1.pmtiles";
|
||||
|
||||
/// How many threads draw basemap tiles. Drawing is all CPU; two keep the map
|
||||
/// quick without taking the machine.
|
||||
const BASEMAP_THREADS: usize = 2;
|
||||
|
||||
/// Where OpenFreeMap describes its current tile set.
|
||||
const TILEJSON_URL: &str = "https://tiles.openfreemap.org/planet";
|
||||
|
||||
@@ -254,8 +267,20 @@ struct Job {
|
||||
dark: bool,
|
||||
}
|
||||
|
||||
/// The worker thread making tiles. Dropping it stops the thread once the
|
||||
/// fetches under way are done.
|
||||
/// Where a tile worker gets its tiles.
|
||||
pub(crate) enum Source {
|
||||
/// OpenFreeMap's street map, cached under `cache_dir`, with names in
|
||||
/// `language` where the map has them.
|
||||
Online {
|
||||
cache_dir: PathBuf,
|
||||
language: String,
|
||||
},
|
||||
/// The basemap installed at this path.
|
||||
Offline(PathBuf),
|
||||
}
|
||||
|
||||
/// The worker threads making tiles. Dropping it stops them once the tiles
|
||||
/// under way are done.
|
||||
pub(crate) struct Tiles {
|
||||
jobs: async_channel::Sender<Job>,
|
||||
wanted: Arc<Mutex<HashSet<TileKey>>>,
|
||||
@@ -264,27 +289,35 @@ pub(crate) struct Tiles {
|
||||
}
|
||||
|
||||
impl Tiles {
|
||||
/// Start the worker, caching under `cache_dir`, drawing names in
|
||||
/// `language` where the map has them. Finished tiles arrive on the
|
||||
/// returned channel.
|
||||
pub(crate) fn start(
|
||||
cache_dir: PathBuf,
|
||||
language: String,
|
||||
scale: i32,
|
||||
) -> (Self, async_channel::Receiver<Done>) {
|
||||
/// Start the worker for `source`. Finished tiles arrive on the returned
|
||||
/// channel.
|
||||
pub(crate) fn start(source: Source, scale: i32) -> (Self, async_channel::Receiver<Done>) {
|
||||
let (jobs, job_rx) = async_channel::unbounded();
|
||||
let (done_tx, done_rx) = async_channel::unbounded();
|
||||
let wanted = Arc::new(Mutex::new(HashSet::new()));
|
||||
let worker = Worker {
|
||||
dir: cache_dir,
|
||||
language,
|
||||
scale,
|
||||
wanted: wanted.clone(),
|
||||
done: done_tx,
|
||||
let spawned = match source {
|
||||
Source::Online {
|
||||
cache_dir,
|
||||
language,
|
||||
} => {
|
||||
let worker = Worker {
|
||||
dir: cache_dir,
|
||||
language,
|
||||
scale,
|
||||
wanted: wanted.clone(),
|
||||
done: done_tx,
|
||||
};
|
||||
std::thread::Builder::new()
|
||||
.name("map-tiles".into())
|
||||
.spawn(move || worker.run(job_rx))
|
||||
}
|
||||
Source::Offline(path) => {
|
||||
let wanted = wanted.clone();
|
||||
std::thread::Builder::new()
|
||||
.name("map-basemap".into())
|
||||
.spawn(move || draw_basemap(&path, scale, &wanted, &job_rx, &done_tx))
|
||||
}
|
||||
};
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("map-tiles".into())
|
||||
.spawn(move || worker.run(job_rx));
|
||||
if let Err(e) = spawned {
|
||||
tracing::warn!("map tiles: cannot start the worker: {e}");
|
||||
}
|
||||
@@ -463,6 +496,126 @@ impl Worker {
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the basemap may be installed, most specific first.
|
||||
fn basemap_paths() -> Vec<PathBuf> {
|
||||
let mut paths = Vec::new();
|
||||
if let Some(path) = std::env::var_os("PDFS_BASEMAP") {
|
||||
paths.push(PathBuf::from(path));
|
||||
}
|
||||
if let Some(dir) = std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|exe| exe.parent().map(Path::to_path_buf))
|
||||
{
|
||||
paths.push(dir.join("../share/proton-drive-linux").join(BASEMAP_FILE));
|
||||
}
|
||||
paths.push(Path::new("/usr/share/proton-drive-linux").join(BASEMAP_FILE));
|
||||
if let Some(dir) = std::env::var_os("XDG_DATA_HOME")
|
||||
.map(PathBuf::from)
|
||||
.or_else(|| std::env::var_os("HOME").map(|home| Path::new(&home).join(".local/share")))
|
||||
{
|
||||
paths.push(dir.join("proton-drive-linux").join(BASEMAP_FILE));
|
||||
}
|
||||
if cfg!(debug_assertions) {
|
||||
// `scripts/fetch-basemap.sh` puts it here for development builds.
|
||||
paths
|
||||
.push(Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../data")).join(BASEMAP_FILE));
|
||||
}
|
||||
paths
|
||||
}
|
||||
|
||||
/// The installed basemap's path, if there is one.
|
||||
pub(crate) fn find_basemap() -> Option<PathBuf> {
|
||||
basemap_paths().into_iter().find(|path| path.is_file())
|
||||
}
|
||||
|
||||
/// The basemap, read once per run: the map restarts its worker when the
|
||||
/// window moves to a screen of another density, and the file is 25 MB.
|
||||
fn open_basemap(path: &Path) -> Option<Arc<Basemap>> {
|
||||
static OPENED: Mutex<Option<(PathBuf, Arc<Basemap>)>> = Mutex::new(None);
|
||||
let mut opened = OPENED.lock().ok()?;
|
||||
if let Some((at, basemap)) = opened.as_ref()
|
||||
&& at == path
|
||||
{
|
||||
return Some(basemap.clone());
|
||||
}
|
||||
match Basemap::open(path) {
|
||||
Ok(basemap) => {
|
||||
let basemap = Arc::new(basemap);
|
||||
*opened = Some((path.to_path_buf(), basemap.clone()));
|
||||
Some(basemap)
|
||||
}
|
||||
Err(e) => {
|
||||
tracing::warn!("map tiles: cannot open the basemap: {e}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Open the basemap at `path` and draw the tiles asked for on
|
||||
/// [`BASEMAP_THREADS`] threads until the map lets go of the worker. Without
|
||||
/// a readable basemap every tile fails, and the outline shows.
|
||||
fn draw_basemap(
|
||||
path: &Path,
|
||||
scale: i32,
|
||||
wanted: &Mutex<HashSet<TileKey>>,
|
||||
jobs: &async_channel::Receiver<Job>,
|
||||
done: &async_channel::Sender<Done>,
|
||||
) {
|
||||
let basemap = open_basemap(path);
|
||||
std::thread::scope(|scope| {
|
||||
for _ in 0..BASEMAP_THREADS {
|
||||
let basemap = basemap.clone();
|
||||
scope.spawn(move || {
|
||||
while let Ok(job) = jobs.recv_blocking() {
|
||||
let key = job.key;
|
||||
let still_wanted = wanted.lock().map(|w| w.contains(&key)).unwrap_or(true);
|
||||
let result = match &basemap {
|
||||
_ if !still_wanted => Done::Dropped(key),
|
||||
Some(basemap) => Done::Tile(draw_basemap_tile(basemap, job, scale)),
|
||||
None => Done::Failed(key),
|
||||
};
|
||||
if done.send_blocking(result).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// One basemap tile at `scale` device px per logical px.
|
||||
fn draw_basemap_tile(basemap: &Basemap, job: Job, scale: i32) -> Raster {
|
||||
let style = if job.dark {
|
||||
Style::dark()
|
||||
} else {
|
||||
Style::light()
|
||||
};
|
||||
let key = job.key;
|
||||
let tile = proton_map::render_tile(
|
||||
basemap,
|
||||
TileId::new(key.z, key.x, key.y),
|
||||
scale.max(1) as f32,
|
||||
&style,
|
||||
);
|
||||
Raster {
|
||||
key,
|
||||
dark: job.dark,
|
||||
edge: tile.width as i32,
|
||||
pixels: rgba_to_cairo(tile.rgba),
|
||||
labels: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Premultiplied RGBA bytes to cairo's premultiplied ARGB, one native-endian
|
||||
/// word per pixel.
|
||||
fn rgba_to_cairo(mut pixels: Vec<u8>) -> Vec<u8> {
|
||||
for px in pixels.as_chunks_mut::<4>().0 {
|
||||
let [r, g, b, a] = *px;
|
||||
*px = u32::from_be_bytes([a, r, g, b]).to_ne_bytes();
|
||||
}
|
||||
pixels
|
||||
}
|
||||
|
||||
/// The first tile URL template in a TileJSON document.
|
||||
fn tile_template(json: &[u8]) -> Option<String> {
|
||||
let doc: serde_json::Value = serde_json::from_slice(json).ok()?;
|
||||
@@ -823,6 +976,42 @@ fn label_name(layer: &Layer, feature: &mvt::Feature, language: &str) -> Option<S
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn empty_basemap() -> Basemap {
|
||||
Basemap::from_bytes(proton_map::pmtiles::writer::Writer::new().finish(
|
||||
"{}",
|
||||
[-180.0, -85.0, 180.0, 85.0],
|
||||
[0.0, 0.0],
|
||||
))
|
||||
.expect("empty archive opens")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rgba_pixels_become_cairo_words() {
|
||||
let pixels = rgba_to_cairo(vec![0x11, 0x22, 0x33, 0xff]);
|
||||
let word = u32::from_ne_bytes(pixels.try_into().expect("one pixel"));
|
||||
assert_eq!(word, 0xff11_2233);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basemap_tiles_come_at_the_screen_density_in_the_theme_asked() {
|
||||
let basemap = empty_basemap();
|
||||
let key = TileKey { z: 3, x: 4, y: 2 };
|
||||
for dark in [false, true] {
|
||||
let raster = draw_basemap_tile(&basemap, Job { key, dark }, 2);
|
||||
assert_eq!((raster.key, raster.dark), (key, dark));
|
||||
assert_eq!(raster.edge, 512);
|
||||
assert_eq!(raster.pixels.len(), 512 * 512 * 4);
|
||||
// An empty basemap is all open sea.
|
||||
let sea = if dark { Style::dark() } else { Style::light() }.water[0];
|
||||
let word = u32::from_ne_bytes(raster.pixels[..4].try_into().expect("a pixel"));
|
||||
assert_eq!(
|
||||
word & 0x00ff_ffff,
|
||||
u32::from_be_bytes([0, sea.r, sea.g, sea.b])
|
||||
);
|
||||
assert!(raster.surface().is_some());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deep_tiles_draw_from_their_ancestor_at_the_data_zoom() {
|
||||
let key = TileKey {
|
||||
|
||||
@@ -160,11 +160,10 @@ pub(crate) struct GalleryState {
|
||||
/// Content width the grid is currently laid out to. Updated when the
|
||||
/// ListView is resized, which re-flows the visible sections.
|
||||
pub(crate) width: Cell<i32>,
|
||||
/// Decoded thumbnails by photo uid, with the insertion order that evicts the
|
||||
/// oldest past [`TEXTURE_CACHE_MAX`]. Scrolling back over a day therefore
|
||||
/// repaints from memory instead of re-decoding from disk.
|
||||
pub(crate) photo_tex: RefCell<HashMap<String, gtk4::gdk::Texture>>,
|
||||
pub(crate) photo_tex_order: RefCell<VecDeque<String>>,
|
||||
/// Decoded thumbnails by photo uid, the least recently used evicted once
|
||||
/// their pixels pass [`TEXTURE_CACHE_BYTES`]. Scrolling back over a day
|
||||
/// therefore repaints from memory instead of re-decoding from disk.
|
||||
pub(crate) photo_tex: RefCell<Lru<String, gtk4::gdk::Texture>>,
|
||||
/// Photos the daemon reported as having no thumbnail at all, so a tile that
|
||||
/// can never be filled isn't requested again on every scroll past it.
|
||||
pub(crate) photo_nothumb: RefCell<HashSet<String>>,
|
||||
@@ -186,12 +185,14 @@ pub(crate) struct GalleryState {
|
||||
pub(crate) thumb_inflight: RefCell<HashSet<String>>,
|
||||
pub(crate) thumb_generation: Cell<u64>,
|
||||
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`.
|
||||
/// Decoding happens on the GTK thread (textures are not `Send`), so it is fed
|
||||
/// a few at a time from an idle callback rather than in one blocking burst
|
||||
/// that would stutter the scroll. [`Self::decode_idle`] is the "callback
|
||||
/// already scheduled" guard.
|
||||
/// [`schedule_decode`] decodes them on worker threads a few at a time, so
|
||||
/// the scroll never waits on a JPEG decoder. [`Self::decode_idle`] is the
|
||||
/// "decoder already running" guard, and [`Self::decode_inflight`] the uids
|
||||
/// being decoded right now, so a tile rebound meanwhile doesn't queue its
|
||||
/// photo a second time.
|
||||
pub(crate) decode_queue: RefCell<VecDeque<(String, String)>>,
|
||||
pub(crate) decode_idle: Cell<bool>,
|
||||
pub(crate) decode_inflight: RefCell<HashSet<String>>,
|
||||
/// Pending debounce timers for the thumbnail queue flush and the section
|
||||
/// re-flow, replaced on each new trigger so only the last one fires.
|
||||
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>,
|
||||
@@ -225,6 +226,9 @@ pub(crate) struct GalleryState {
|
||||
/// The header's page menu and the Upload button's face, which drops its
|
||||
/// label in a narrow window.
|
||||
pub(crate) more: gtk4::MenuButton,
|
||||
/// The header's end slot for an open Drive gallery's own buttons (Add
|
||||
/// This Folder, Unlock, options), filled by the Drive gallery browser.
|
||||
pub(crate) gallery_actions: gtk4::Box,
|
||||
pub(crate) upload_face: adw::ButtonContent,
|
||||
/// The section the top of the timeline is in, floating over the grid
|
||||
/// once its own heading has scrolled away.
|
||||
@@ -348,11 +352,23 @@ pub(crate) const THUMB_DEBOUNCE: Duration = Duration::from_millis(60);
|
||||
/// in seconds, not milliseconds.
|
||||
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
|
||||
|
||||
/// Decoded thumbnails held in memory, evicted least-recently-*used* first. Each
|
||||
/// is a few hundred KiB of GPU texture, and at the justified row density 600 was
|
||||
/// under two screens' worth — a scroll down and back up then had to re-fetch and
|
||||
/// re-decode everything it had just shown.
|
||||
pub(crate) const TEXTURE_CACHE_MAX: usize = 1500;
|
||||
/// Decoded thumbnail pixels held in memory, evicted least-recently-*used*
|
||||
/// first. Budgeted by bytes rather than by count, because one oversized
|
||||
/// thumbnail costs as much as dozens of ordinary ones. A 512 px thumbnail is
|
||||
/// about 600 KiB decoded, so this holds roughly 900 of them: at the justified
|
||||
/// row density 600 was under two screens' worth, and a scroll down and back up
|
||||
/// then had to re-fetch and re-decode everything it had just shown.
|
||||
pub(crate) const TEXTURE_CACHE_BYTES: usize = 512 * 1024 * 1024;
|
||||
|
||||
/// What a decoded texture costs [`TEXTURE_CACHE_BYTES`]: four bytes a pixel.
|
||||
pub(crate) fn texture_bytes(width: i32, height: i32) -> usize {
|
||||
let width = usize::try_from(width).unwrap_or(0);
|
||||
let height = usize::try_from(height).unwrap_or(0);
|
||||
width.saturating_mul(height).saturating_mul(4).max(1)
|
||||
}
|
||||
|
||||
/// How many thumbnails [`schedule_decode`] decodes at once.
|
||||
const DECODE_BATCH: usize = 4;
|
||||
|
||||
/// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
|
||||
/// is decoded before it is scrolled onto rather than after.
|
||||
@@ -524,6 +540,7 @@ pub(crate) struct GalleryWidgets {
|
||||
pub(crate) select_btn: gtk4::Button,
|
||||
pub(crate) selection: SelectionBar,
|
||||
pub(crate) more: gtk4::MenuButton,
|
||||
pub(crate) gallery_actions: gtk4::Box,
|
||||
pub(crate) upload_face: adw::ButtonContent,
|
||||
pub(crate) float_heading: gtk4::Revealer,
|
||||
pub(crate) float_label: gtk4::Label,
|
||||
@@ -694,6 +711,12 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
||||
.build();
|
||||
more.add_css_class("flat");
|
||||
|
||||
// An open Drive gallery's own buttons live in the header too, not in a row
|
||||
// of their own above its grid: that row took height from the photos and
|
||||
// left its button touching the first row of tiles.
|
||||
let gallery_actions = gtk4::Box::new(gtk4::Orientation::Horizontal, 6);
|
||||
gallery_actions.set_visible(false);
|
||||
|
||||
// Picking photos is a mode: the button enters it, and the header then
|
||||
// trades the page's own controls for Cancel and a count, as GNOME apps do.
|
||||
let select_btn = gtk4::Button::builder()
|
||||
@@ -1002,6 +1025,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
||||
header.pack_start(&back);
|
||||
header.pack_start(&upload);
|
||||
header.pack_end(&more);
|
||||
header.pack_end(&gallery_actions);
|
||||
header.pack_end(&select_btn);
|
||||
header.pack_end(&selection.cancel);
|
||||
|
||||
@@ -1031,6 +1055,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
||||
select_btn,
|
||||
selection,
|
||||
more,
|
||||
gallery_actions,
|
||||
upload_face,
|
||||
float_heading,
|
||||
float_label,
|
||||
@@ -1141,6 +1166,7 @@ pub(crate) fn sync_header(ui: &Rc<Ui>) {
|
||||
gallery.back.set_visible(!selecting && collection);
|
||||
gallery.upload.set_visible(!selecting && !collection);
|
||||
gallery.more.set_visible(!selecting && !galleries);
|
||||
gallery.gallery_actions.set_visible(!selecting && galleries);
|
||||
gallery.select_btn.set_visible(!selecting && timeline);
|
||||
gallery.selection.title.set_visible(selecting);
|
||||
gallery.selection.cancel.set_visible(selecting);
|
||||
@@ -2360,7 +2386,7 @@ const TILE_RATIO_MAX: f64 = 2.5;
|
||||
/// The shape a photo's tile takes: its own, clamped, or square while the
|
||||
/// daemon has not seen a thumbnail of it yet.
|
||||
pub(crate) fn tile_ratio(ratio: Option<f64>) -> f64 {
|
||||
pg_core::grid::tile_ratio(ratio.unwrap_or(1.0))
|
||||
proton_gallery_rs::grid::tile_ratio(ratio.unwrap_or(1.0))
|
||||
}
|
||||
|
||||
/// The justified layout math: tiles of the given shapes, in order, broken into
|
||||
@@ -2373,7 +2399,7 @@ pub(crate) fn tile_ratio(ratio: Option<f64>) -> f64 {
|
||||
/// two photos from one day stay two photos at the target height, not two
|
||||
/// photos as tall as the window.
|
||||
pub(crate) fn plan_justified(ratios: &[f64], width: i32, target: i32) -> Vec<Vec<(i32, i32)>> {
|
||||
let Ok(grid) = pg_core::grid::plan_sections(
|
||||
let Ok(grid) = proton_gallery_rs::grid::plan_sections(
|
||||
ratios,
|
||||
&[],
|
||||
width.clamp(1, 32_768) as u32,
|
||||
@@ -3247,6 +3273,7 @@ pub(crate) fn want_thumb(ui: &Rc<Ui>, photo: &PhotoItem, picture: >k4::Picture
|
||||
|
||||
let mut decode = ui.gallery.decode_queue.borrow_mut();
|
||||
if decode.iter().any(|(uid, _)| uid == &photo.uid)
|
||||
|| ui.gallery.decode_inflight.borrow().contains(&photo.uid)
|
||||
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
|
||||
{
|
||||
return;
|
||||
@@ -3438,9 +3465,16 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
|
||||
batch
|
||||
}
|
||||
|
||||
/// Decode queued thumbnails into textures on an idle callback, a few per pass, so
|
||||
/// a big batch fills in progressively instead of freezing the scroll for the
|
||||
/// length of the whole decode.
|
||||
/// Decode queued thumbnails into textures on worker threads, a few at a time,
|
||||
/// and hand each finished texture to the tiles still waiting for it.
|
||||
///
|
||||
/// Decoding a JPEG takes milliseconds; four of them per idle pass on the GTK
|
||||
/// thread were enough to stutter a scroll. The main thread now only picks the
|
||||
/// next batch (visible tiles first) and paints what comes back. A batch that
|
||||
/// lands after the timeline was reset is dropped, and a tile that was rebound
|
||||
/// or unbound meanwhile is no longer in [`GalleryState::thumb_wanted`], so it
|
||||
/// is not painted. [`GalleryState::decode_idle`] is the "decoder running"
|
||||
/// guard.
|
||||
pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
||||
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
|
||||
return;
|
||||
@@ -3448,63 +3482,95 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
||||
ui.gallery.decode_idle.set(true);
|
||||
|
||||
let ui = ui.clone();
|
||||
glib::idle_add_local(move || {
|
||||
let batch: Vec<(String, String)> = {
|
||||
let mut queue = ui.gallery.decode_queue.borrow_mut();
|
||||
let wanted = ui.gallery.thumb_wanted.borrow();
|
||||
let list = &ui.gallery.list;
|
||||
let visible = |uid: &str| {
|
||||
wanted.get(uid).is_some_and(|pictures| {
|
||||
pictures.iter().any(|picture| {
|
||||
if !picture.is_mapped() {
|
||||
return false;
|
||||
}
|
||||
!picture.is_ancestor(list)
|
||||
|| picture.compute_bounds(list).is_some_and(|bounds| {
|
||||
bounds.y() + bounds.height() > 0.0
|
||||
&& bounds.y() < list.height() as f32
|
||||
})
|
||||
})
|
||||
})
|
||||
};
|
||||
queue.retain(|(uid, _)| wanted.contains_key(uid));
|
||||
(0..4)
|
||||
.filter_map(|_| {
|
||||
queue
|
||||
.iter()
|
||||
.position(|(uid, _)| visible(uid))
|
||||
.and_then(|index| queue.remove(index))
|
||||
.or_else(|| queue.pop_front())
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
for (uid, path) in batch {
|
||||
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
|
||||
continue;
|
||||
glib::spawn_future_local(async move {
|
||||
loop {
|
||||
let batch = next_decode_batch(&ui);
|
||||
if batch.is_empty() {
|
||||
break;
|
||||
}
|
||||
let texture = match gtk4::gdk::Texture::from_filename(&path) {
|
||||
Ok(texture) => texture,
|
||||
Err(e) => {
|
||||
tracing::debug!("cannot decode thumbnail {path}: {e}");
|
||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
||||
let generation = ui.gallery.thumb_generation.get();
|
||||
ui.gallery
|
||||
.decode_inflight
|
||||
.borrow_mut()
|
||||
.extend(batch.iter().map(|(uid, _)| uid.clone()));
|
||||
// All of the batch decodes at once, on the worker pool; the results
|
||||
// are collected in the order they were picked.
|
||||
let jobs: Vec<_> = batch
|
||||
.into_iter()
|
||||
.map(|(uid, path)| {
|
||||
let job = gio::spawn_blocking({
|
||||
let path = path.clone();
|
||||
move || gtk4::gdk::Texture::from_filename(&path)
|
||||
});
|
||||
(uid, path, job)
|
||||
})
|
||||
.collect();
|
||||
for (uid, path, job) in jobs {
|
||||
let decoded = job.await;
|
||||
ui.gallery.decode_inflight.borrow_mut().remove(&uid);
|
||||
if generation != ui.gallery.thumb_generation.get() {
|
||||
continue;
|
||||
}
|
||||
};
|
||||
ui.store_texture(&uid, texture.clone());
|
||||
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
|
||||
for picture in waiting.into_iter().flatten() {
|
||||
picture.set_paintable(Some(&texture));
|
||||
let texture = match decoded {
|
||||
Ok(Ok(texture)) => texture,
|
||||
Ok(Err(e)) => {
|
||||
tracing::debug!("cannot decode thumbnail {path}: {e}");
|
||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
||||
continue;
|
||||
}
|
||||
Err(_) => {
|
||||
tracing::debug!("thumbnail decoder for {path} panicked");
|
||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if ui.gallery.photo_tex.borrow().contains_key(&uid) {
|
||||
continue;
|
||||
}
|
||||
ui.store_texture(&uid, texture.clone());
|
||||
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
|
||||
for picture in waiting.into_iter().flatten() {
|
||||
picture.set_paintable(Some(&texture));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ui.gallery.decode_queue.borrow().is_empty() {
|
||||
ui.gallery.decode_idle.set(false);
|
||||
return glib::ControlFlow::Break;
|
||||
}
|
||||
glib::ControlFlow::Continue
|
||||
ui.gallery.decode_idle.set(false);
|
||||
});
|
||||
}
|
||||
|
||||
/// Take the next few thumbnails to decode off the queue: the ones on screen
|
||||
/// first, then in queue order, skipping tiles nobody waits for any more and
|
||||
/// photos already decoded.
|
||||
fn next_decode_batch(ui: &Rc<Ui>) -> Vec<(String, String)> {
|
||||
let mut queue = ui.gallery.decode_queue.borrow_mut();
|
||||
let wanted = ui.gallery.thumb_wanted.borrow();
|
||||
let cached = ui.gallery.photo_tex.borrow();
|
||||
let list = &ui.gallery.list;
|
||||
let visible = |uid: &str| {
|
||||
wanted.get(uid).is_some_and(|pictures| {
|
||||
pictures.iter().any(|picture| {
|
||||
if !picture.is_mapped() {
|
||||
return false;
|
||||
}
|
||||
!picture.is_ancestor(list)
|
||||
|| picture.compute_bounds(list).is_some_and(|bounds| {
|
||||
bounds.y() + bounds.height() > 0.0 && bounds.y() < list.height() as f32
|
||||
})
|
||||
})
|
||||
})
|
||||
};
|
||||
queue.retain(|(uid, _)| wanted.contains_key(uid) && !cached.contains_key(uid));
|
||||
(0..DECODE_BATCH)
|
||||
.filter_map(|_| {
|
||||
queue
|
||||
.iter()
|
||||
.position(|(uid, _)| visible(uid))
|
||||
.and_then(|index| queue.remove(index))
|
||||
.or_else(|| queue.pop_front())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Re-flow the sections on screen shortly. Debounced, because the triggers (a
|
||||
/// window resize, a zoom step) arrive in floods and only the final state
|
||||
/// matters.
|
||||
@@ -4774,13 +4840,23 @@ pub(crate) fn gallery_unreachable(ui: &Rc<Ui>) {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{
|
||||
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TILE_GAP, TILE_RATIO_MAX,
|
||||
TILE_RATIO_MIN, active_filters, copy_without_overwrite, empty_timeline_text, grouping_for,
|
||||
memory_years, month_index, month_range, plan_grid, plan_justified, section_heading,
|
||||
tile_ratio, viewport_unfilled,
|
||||
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TEXTURE_CACHE_BYTES,
|
||||
TILE_GAP, TILE_RATIO_MAX, TILE_RATIO_MIN, active_filters, copy_without_overwrite,
|
||||
empty_timeline_text, grouping_for, memory_years, month_index, month_range, plan_grid,
|
||||
plan_justified, section_heading, texture_bytes, tile_ratio, viewport_unfilled,
|
||||
};
|
||||
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth};
|
||||
|
||||
#[test]
|
||||
fn the_texture_cache_is_budgeted_by_decoded_pixels() {
|
||||
assert_eq!(texture_bytes(512, 384), 512 * 384 * 4);
|
||||
// A broken size still costs something, so it can't pile up for free.
|
||||
assert_eq!(texture_bytes(0, 512), 1);
|
||||
assert_eq!(texture_bytes(-1, -1), 1);
|
||||
// Ordinary thumbnails: well over two dense screens' worth fit.
|
||||
assert!(TEXTURE_CACHE_BYTES / texture_bytes(512, 384) >= 600);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
|
||||
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
|
||||
|
||||
@@ -2,13 +2,13 @@
|
||||
//! their newest photo, and once the map is zoomed in close, each photo where
|
||||
//! it was taken.
|
||||
//!
|
||||
//! Underneath is one of two maps. The built-in one is drawn here from Natural
|
||||
//! Underneath are up to two maps. The outline is drawn here from Natural
|
||||
//! Earth's 1:50m land polygons and country borders (public domain), trimmed
|
||||
//! into `data/land.txt` and `data/borders.txt` by
|
||||
//! `scripts/natural-earth-land.py`; it needs no network and tells nobody
|
||||
//! anything. The street map from OpenFreeMap ([`super::map_tiles`]) is
|
||||
//! opt-in, in Preferences, and draws over the built-in one wherever its tiles
|
||||
//! have arrived.
|
||||
//! `scripts/natural-earth-land.py`, and is always there. Over it go tiles
|
||||
//! ([`super::map_tiles`]) wherever they have arrived: the offline basemap
|
||||
//! installed with the app, which needs no network and tells nobody anything,
|
||||
//! or, when turned on in Preferences, the street map from OpenFreeMap.
|
||||
//!
|
||||
//! The projection is Web Mercator, the one every other map uses, so the
|
||||
//! world looks the way people expect. Markers that would overlap on screen
|
||||
@@ -17,6 +17,8 @@
|
||||
//! a single photo opens it in its town, and photos taken on one spot, which
|
||||
//! never part, are listed to pick from.
|
||||
|
||||
// Markers merge the same way in every Proton gallery app.
|
||||
use proton_gallery_rs::places::{Bubble, bubble_radius, cluster, compact_count};
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::OnceLock;
|
||||
@@ -25,7 +27,7 @@ use std::time::{Duration, Instant};
|
||||
use gtk4::cairo;
|
||||
use pdfs_core::control::PhotoLocation;
|
||||
|
||||
use super::map_tiles::{self, Done, Label, LabelClass, Palette, TILE_EDGE, TileKey, Tiles};
|
||||
use super::map_tiles::{self, Done, Label, LabelClass, Palette, Source, TILE_EDGE, TileKey, Tiles};
|
||||
use crate::*;
|
||||
|
||||
const LAND: &str = include_str!("../../../data/land.txt");
|
||||
@@ -35,8 +37,8 @@ const BORDERS: &str = include_str!("../../../data/borders.txt");
|
||||
const MAX_LATITUDE: f64 = 85.0;
|
||||
|
||||
/// How far in the map zooms, as a multiple of the whole world fitting the
|
||||
/// widget: far enough for photos in one town to part on the built-in map,
|
||||
/// and down to single streets on the street map.
|
||||
/// widget: far enough for photos in one town to part on the outline and the
|
||||
/// basemap, and down to single streets on the street map.
|
||||
const MAX_ZOOM: f64 = 8192.0;
|
||||
const ONLINE_MAX_ZOOM: f64 = 65536.0;
|
||||
|
||||
@@ -64,9 +66,14 @@ const MIN_SEGMENT: f64 = 0.75;
|
||||
/// Edge in px of the square a marker's photo is scaled down to once.
|
||||
const COVER_PX: i32 = 128;
|
||||
|
||||
/// How many street-map tiles stay in memory.
|
||||
/// How many map tiles stay in memory.
|
||||
const TILE_CACHE: usize = 160;
|
||||
|
||||
/// Photo marker covers kept, 64 KiB each. A town's own cover is never
|
||||
/// dropped (it only arrives with the town's card), but the photos zoomed past
|
||||
/// one by one would otherwise pile up for as long as the map is open.
|
||||
const COVER_CACHE: usize = 1024;
|
||||
|
||||
/// How long a tile that couldn't be had is left alone before it is tried
|
||||
/// again.
|
||||
const TILE_RETRY: Duration = Duration::from_secs(60);
|
||||
@@ -132,13 +139,6 @@ fn parse_ring(line: &str) -> Option<Ring> {
|
||||
Some(Ring { points, min, max })
|
||||
}
|
||||
|
||||
/// Radius in px of a marker holding `photos` photos: big enough to make the
|
||||
/// photo out, and growing with the count, but slowly, so a home town with
|
||||
/// thousands doesn't cover a continent.
|
||||
fn bubble_radius(photos: usize) -> f64 {
|
||||
18.0 + 2.0 * (photos.max(1) as f64).ln()
|
||||
}
|
||||
|
||||
/// What the map shows: which part of the world, at what size.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct View {
|
||||
@@ -190,18 +190,7 @@ struct Marker {
|
||||
target: Target,
|
||||
}
|
||||
|
||||
/// One marker as last drawn, standing for one or more [`Marker`]s: where, how
|
||||
/// big, and which (indices into [`MapState::markers`], the one with the most
|
||||
/// photos first).
|
||||
struct Bubble {
|
||||
x: f64,
|
||||
y: f64,
|
||||
radius: f64,
|
||||
photos: usize,
|
||||
members: Vec<usize>,
|
||||
}
|
||||
|
||||
/// A street-map tile ready to draw, and the names on it.
|
||||
/// A map tile ready to draw, and the names on it.
|
||||
struct CachedTile {
|
||||
surface: cairo::ImageSurface,
|
||||
labels: Rc<Vec<Label>>,
|
||||
@@ -209,9 +198,11 @@ struct CachedTile {
|
||||
used: u64,
|
||||
}
|
||||
|
||||
/// The street map, while it is turned on.
|
||||
struct Online {
|
||||
/// The tiles drawn over the outline, from the basemap or the street map.
|
||||
struct TileLayer {
|
||||
tiles: Tiles,
|
||||
/// Whether they come from the street map.
|
||||
online: bool,
|
||||
cache: HashMap<TileKey, CachedTile>,
|
||||
pending: HashSet<TileKey>,
|
||||
failed: HashMap<TileKey, Instant>,
|
||||
@@ -232,8 +223,11 @@ struct MapState {
|
||||
/// for from close up.
|
||||
locations: HashMap<u32, Vec<(PhotoItem, World)>>,
|
||||
asked_locations: HashSet<u32>,
|
||||
/// Marker photos, scaled and cropped to a square, by photo uid.
|
||||
covers: HashMap<String, cairo::ImageSurface>,
|
||||
/// Marker photos, scaled and cropped to a square, by photo uid, with the
|
||||
/// draw they were last shown in.
|
||||
covers: HashMap<String, (cairo::ImageSurface, u64)>,
|
||||
/// Counts draws, for dropping the covers shown longest ago.
|
||||
draws: u64,
|
||||
asked_thumbs: HashSet<String>,
|
||||
view: View,
|
||||
/// False until the view has been fitted to the places at a real size, and
|
||||
@@ -247,7 +241,11 @@ struct MapState {
|
||||
drag_origin: Option<View>,
|
||||
/// The scale a pinch started from.
|
||||
pinch_origin: Option<View>,
|
||||
online: Option<Online>,
|
||||
tiles: Option<TileLayer>,
|
||||
/// Whether the street map is turned on in Preferences.
|
||||
street_map: bool,
|
||||
/// The installed basemap, if any.
|
||||
basemap: Option<PathBuf>,
|
||||
cache_dir: Option<PathBuf>,
|
||||
/// The spot [`PlacesMap::show_spot`] went to, ringed until the map is
|
||||
/// fitted to all places again.
|
||||
@@ -303,32 +301,11 @@ impl PlacesMap {
|
||||
buttons.append(&zoom);
|
||||
buttons.append(&fit);
|
||||
|
||||
let link = |url: &str, name: &str| format!("<a href=\"{url}\">{name}</a>");
|
||||
let credit = gtk4::Label::builder()
|
||||
.use_markup(true)
|
||||
.halign(gtk4::Align::End)
|
||||
.valign(gtk4::Align::End)
|
||||
.visible(false)
|
||||
.label(gettext_f(
|
||||
// Translators: the credit on the street map. {openfreemap},
|
||||
// {openmaptiles} and {openstreetmap} are the linked names of
|
||||
// the projects, which stay as they are.
|
||||
"{openfreemap} © {openmaptiles} Data from {openstreetmap}",
|
||||
&[
|
||||
(
|
||||
"openfreemap",
|
||||
&link("https://openfreemap.org", "OpenFreeMap"),
|
||||
),
|
||||
(
|
||||
"openmaptiles",
|
||||
&link("https://www.openmaptiles.org/", "OpenMapTiles"),
|
||||
),
|
||||
(
|
||||
"openstreetmap",
|
||||
&link("https://www.openstreetmap.org/copyright", "OpenStreetMap"),
|
||||
),
|
||||
],
|
||||
))
|
||||
.build();
|
||||
credit.add_css_class("places-map-credit");
|
||||
credit.add_css_class("caption");
|
||||
@@ -349,6 +326,7 @@ impl PlacesMap {
|
||||
locations: HashMap::new(),
|
||||
asked_locations: HashSet::new(),
|
||||
covers: HashMap::new(),
|
||||
draws: 0,
|
||||
asked_thumbs: HashSet::new(),
|
||||
view: View {
|
||||
center: World { x: 0.5, y: 0.5 },
|
||||
@@ -361,7 +339,9 @@ impl PlacesMap {
|
||||
pointer: (0.0, 0.0),
|
||||
drag_origin: None,
|
||||
pinch_origin: None,
|
||||
online: None,
|
||||
tiles: None,
|
||||
street_map: false,
|
||||
basemap: map_tiles::find_basemap(),
|
||||
cache_dir: None,
|
||||
pin: None,
|
||||
}),
|
||||
@@ -486,43 +466,68 @@ impl PlacesMap {
|
||||
let Some(cover) = square_cover(texture) else {
|
||||
return;
|
||||
};
|
||||
self.state.borrow_mut().covers.insert(uid.to_owned(), cover);
|
||||
let mut state = self.state.borrow_mut();
|
||||
let state = &mut *state;
|
||||
state.covers.insert(uid.to_owned(), (cover, state.draws));
|
||||
let towns: HashSet<&str> = state
|
||||
.places
|
||||
.iter()
|
||||
.map(|(place, _)| place.cover.uid.as_str())
|
||||
.collect();
|
||||
for dropped in evict_covers(&mut state.covers, &towns, state.draws) {
|
||||
// Asked for again once it is back on screen.
|
||||
state.asked_thumbs.remove(&dropped);
|
||||
}
|
||||
self.area.queue_draw();
|
||||
}
|
||||
|
||||
/// Draw OpenFreeMap's street map under the markers, or stop, keeping its
|
||||
/// tiles in `cache_dir`.
|
||||
/// Draw OpenFreeMap's street map under the markers, keeping its tiles in
|
||||
/// `cache_dir`, or else the installed basemap.
|
||||
pub(crate) fn set_online(self: &Rc<Self>, on: bool, cache_dir: PathBuf) {
|
||||
{
|
||||
let mut state = self.state.borrow_mut();
|
||||
state.cache_dir = Some(cache_dir);
|
||||
if on == state.online.is_some() {
|
||||
let started = state.tiles.is_some() || state.basemap.is_none();
|
||||
if on == state.street_map && started {
|
||||
return;
|
||||
}
|
||||
state.online = None;
|
||||
}
|
||||
self.credit.set_visible(on);
|
||||
if on {
|
||||
self.start_tiles();
|
||||
state.street_map = on;
|
||||
state.tiles = None;
|
||||
}
|
||||
self.start_tiles();
|
||||
self.clamp_zoom();
|
||||
self.area.queue_draw();
|
||||
}
|
||||
|
||||
/// Start a tile worker for the widget's current pixel density.
|
||||
/// Start a tile worker for the widget's current pixel density, and show
|
||||
/// the credit for what it draws.
|
||||
fn start_tiles(self: &Rc<Self>) {
|
||||
let Some(dir) = self.state.borrow().cache_dir.clone() else {
|
||||
let source = {
|
||||
let state = self.state.borrow();
|
||||
match (&state.cache_dir, &state.basemap) {
|
||||
(Some(dir), _) if state.street_map => {
|
||||
let language = gtk4::pango::Language::default().to_string();
|
||||
let language = language.split(['-', '_']).next().unwrap_or("en").to_owned();
|
||||
Some(Source::Online {
|
||||
cache_dir: dir.join("map-tiles"),
|
||||
language,
|
||||
})
|
||||
}
|
||||
(_, Some(basemap)) => Some(Source::Offline(basemap.clone())),
|
||||
_ => None,
|
||||
}
|
||||
};
|
||||
let Some(source) = source else {
|
||||
self.credit.set_visible(false);
|
||||
return;
|
||||
};
|
||||
let language = gtk4::pango::Language::default().to_string();
|
||||
let language = language.split(['-', '_']).next().unwrap_or("en").to_owned();
|
||||
let (tiles, done) = Tiles::start(
|
||||
dir.join("map-tiles"),
|
||||
language,
|
||||
self.area.scale_factor().max(1),
|
||||
);
|
||||
self.state.borrow_mut().online = Some(Online {
|
||||
let online = matches!(source, Source::Online { .. });
|
||||
self.credit.set_label(&credit_text(online));
|
||||
self.credit.set_visible(true);
|
||||
let (tiles, done) = Tiles::start(source, self.area.scale_factor().max(1));
|
||||
self.state.borrow_mut().tiles = Some(TileLayer {
|
||||
tiles,
|
||||
online,
|
||||
cache: HashMap::new(),
|
||||
pending: HashSet::new(),
|
||||
failed: HashMap::new(),
|
||||
@@ -542,7 +547,7 @@ impl PlacesMap {
|
||||
|
||||
fn tile_done(&self, done: Done) {
|
||||
let mut state = self.state.borrow_mut();
|
||||
let Some(online) = state.online.as_mut() else {
|
||||
let Some(online) = state.tiles.as_mut() else {
|
||||
return;
|
||||
};
|
||||
match done {
|
||||
@@ -728,7 +733,7 @@ impl PlacesMap {
|
||||
}
|
||||
|
||||
fn max_scale(&self) -> f64 {
|
||||
let zoom = if self.state.borrow().online.is_some() {
|
||||
let zoom = if self.state.borrow().tiles.as_ref().is_some_and(|t| t.online) {
|
||||
ONLINE_MAX_ZOOM
|
||||
} else {
|
||||
MAX_ZOOM
|
||||
@@ -823,11 +828,11 @@ impl PlacesMap {
|
||||
let restart = self
|
||||
.state
|
||||
.borrow()
|
||||
.online
|
||||
.tiles
|
||||
.as_ref()
|
||||
.is_some_and(|o| o.tiles.scale != area.scale_factor().max(1));
|
||||
if restart {
|
||||
self.state.borrow_mut().online = None;
|
||||
self.state.borrow_mut().tiles = None;
|
||||
self.start_tiles();
|
||||
}
|
||||
|
||||
@@ -840,8 +845,9 @@ impl PlacesMap {
|
||||
let mut state = self.state.borrow_mut();
|
||||
let state = &mut *state;
|
||||
let view = state.view;
|
||||
state.draws += 1;
|
||||
paint_outline(cr, view, size, colors);
|
||||
let labels = match state.online.as_mut() {
|
||||
let labels = match state.tiles.as_mut() {
|
||||
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
|
||||
None => Vec::new(),
|
||||
};
|
||||
@@ -863,7 +869,10 @@ impl PlacesMap {
|
||||
}
|
||||
for bubble in &state.bubbles {
|
||||
let marker = &state.markers[bubble.members[0]];
|
||||
let cover = state.covers.get(&marker.cover);
|
||||
let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| {
|
||||
*drawn = state.draws;
|
||||
&*cover
|
||||
});
|
||||
if cover.is_none()
|
||||
&& let Target::Photo { place, index } = marker.target
|
||||
&& state.asked_thumbs.insert(marker.cover.clone())
|
||||
@@ -991,16 +1000,16 @@ fn paint_outline(cr: &cairo::Context, view: View, size: (f64, f64), colors: &Pal
|
||||
let _ = cr.stroke();
|
||||
}
|
||||
|
||||
/// The street-map zoom whose tiles come closest to their own size on screen.
|
||||
/// The tile zoom whose tiles come closest to their own size on screen.
|
||||
fn tile_zoom(scale: f64) -> u8 {
|
||||
(scale / TILE_EDGE).log2().round().clamp(0.0, 18.0) as u8
|
||||
}
|
||||
|
||||
/// Draw the street-map tiles on screen, asking for the missing ones and
|
||||
/// standing in their nearest ancestor meanwhile. Returns the names on them.
|
||||
/// Draw the map tiles on screen, asking for the missing ones and standing in
|
||||
/// their nearest ancestor meanwhile. Returns the names on them.
|
||||
fn paint_tiles(
|
||||
cr: &cairo::Context,
|
||||
online: &mut Online,
|
||||
online: &mut TileLayer,
|
||||
view: View,
|
||||
size: (f64, f64),
|
||||
dark: bool,
|
||||
@@ -1121,6 +1130,35 @@ fn evict(cache: &mut HashMap<TileKey, CachedTile>, frame: u64) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drop the photo covers drawn longest ago, down to [`COVER_CACHE`]. Never
|
||||
/// one drawn in the current draw, and never a town's cover. Returns the uids
|
||||
/// dropped.
|
||||
fn evict_covers<T>(
|
||||
covers: &mut HashMap<String, (T, u64)>,
|
||||
towns: &HashSet<&str>,
|
||||
draw: u64,
|
||||
) -> Vec<String> {
|
||||
if covers.len() <= COVER_CACHE {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut ages: Vec<(u64, &String)> = covers
|
||||
.iter()
|
||||
.filter(|(uid, (_, drawn))| *drawn < draw && !towns.contains(uid.as_str()))
|
||||
.map(|(uid, (_, drawn))| (*drawn, uid))
|
||||
.collect();
|
||||
ages.sort_unstable_by_key(|(drawn, _)| *drawn);
|
||||
let excess = covers.len() - COVER_CACHE;
|
||||
let dropped: Vec<String> = ages
|
||||
.into_iter()
|
||||
.take(excess)
|
||||
.map(|(_, uid)| uid.clone())
|
||||
.collect();
|
||||
for uid in &dropped {
|
||||
covers.remove(uid);
|
||||
}
|
||||
dropped
|
||||
}
|
||||
|
||||
/// Set the names of the tiles on screen, the most important first, leaving
|
||||
/// out any that would overlap one already set.
|
||||
fn paint_labels(
|
||||
@@ -1528,6 +1566,47 @@ impl PlacesMap {
|
||||
/// How many town names a merged marker's tooltip lists.
|
||||
const TOOLTIP_NAMES: usize = 5;
|
||||
|
||||
/// The credit for the map's tiles, as Pango markup.
|
||||
fn credit_text(online: bool) -> String {
|
||||
let link = |url: &str, name: &str| format!("<a href=\"{url}\">{name}</a>");
|
||||
if online {
|
||||
gettext_f(
|
||||
// Translators: the credit on the street map. {openfreemap},
|
||||
// {openmaptiles} and {openstreetmap} are the linked names of
|
||||
// the projects, which stay as they are.
|
||||
"{openfreemap} © {openmaptiles} Data from {openstreetmap}",
|
||||
&[
|
||||
(
|
||||
"openfreemap",
|
||||
&link("https://openfreemap.org", "OpenFreeMap"),
|
||||
),
|
||||
(
|
||||
"openmaptiles",
|
||||
&link("https://www.openmaptiles.org/", "OpenMapTiles"),
|
||||
),
|
||||
(
|
||||
"openstreetmap",
|
||||
&link("https://www.openstreetmap.org/copyright", "OpenStreetMap"),
|
||||
),
|
||||
],
|
||||
)
|
||||
} else {
|
||||
gettext_f(
|
||||
// Translators: the credit on the offline map. {naturalearth} and
|
||||
// {geonames} are the linked names of the projects, which stay as
|
||||
// they are.
|
||||
"Map data © {naturalearth} (public domain) and {geonames} (CC BY 4.0)",
|
||||
&[
|
||||
(
|
||||
"naturalearth",
|
||||
&link("https://www.naturalearthdata.com/", "Natural Earth"),
|
||||
),
|
||||
("geonames", &link("https://www.geonames.org/", "GeoNames")),
|
||||
],
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn map_button(icon: &str, tooltip: &str) -> gtk4::Button {
|
||||
let button = gtk4::Button::from_icon_name(icon);
|
||||
button.set_tooltip_text(Some(tooltip));
|
||||
@@ -1595,52 +1674,6 @@ fn spread(points: &[World]) -> f64 {
|
||||
span(&mut xs.into_iter()).max(span(&mut ys.into_iter()))
|
||||
}
|
||||
|
||||
/// Merge markers whose circles would overlap on screen, the one with the
|
||||
/// most photos claiming its neighbours (the first of equals, when counts
|
||||
/// tie). Markers off screen are left out.
|
||||
fn cluster(screen: &[(f64, f64)], counts: &[usize], width: f64, height: f64) -> Vec<Bubble> {
|
||||
let mut order: Vec<usize> = (0..screen.len()).collect();
|
||||
order.sort_by(|a, b| counts[*b].cmp(&counts[*a]));
|
||||
let mut bubbles: Vec<Bubble> = Vec::new();
|
||||
for index in order {
|
||||
let (x, y) = screen[index];
|
||||
let reach = bubble_radius(counts[index]);
|
||||
if x < -reach || y < -reach || x > width + reach || y > height + reach {
|
||||
continue;
|
||||
}
|
||||
match bubbles
|
||||
.iter_mut()
|
||||
.find(|b| (b.x - x).hypot(b.y - y) < b.radius + reach * 0.5)
|
||||
{
|
||||
Some(bubble) => {
|
||||
bubble.photos += counts[index];
|
||||
bubble.radius = bubble_radius(bubble.photos);
|
||||
bubble.members.push(index);
|
||||
}
|
||||
None => bubbles.push(Bubble {
|
||||
x,
|
||||
y,
|
||||
radius: reach,
|
||||
photos: counts[index],
|
||||
members: vec![index],
|
||||
}),
|
||||
}
|
||||
}
|
||||
// Smallest last, so a small marker next to a big one stays clickable.
|
||||
bubbles.sort_by(|a, b| b.radius.total_cmp(&a.radius));
|
||||
bubbles
|
||||
}
|
||||
|
||||
/// "7", "840", "1.2k", "35k": short enough to fit a marker. Digits and the
|
||||
/// "k" read the same in every language the app ships.
|
||||
fn compact_count(n: usize) -> String {
|
||||
match n {
|
||||
0..1_000 => n.to_string(),
|
||||
1_000..10_000 => format!("{:.1}k", n as f64 / 1_000.0),
|
||||
_ => format!("{}k", n / 1_000),
|
||||
}
|
||||
}
|
||||
|
||||
fn set_color(cr: &cairo::Context, color: >k4::gdk::RGBA, alpha: f32) {
|
||||
cr.set_source_rgba(
|
||||
f64::from(color.red()),
|
||||
@@ -1654,6 +1687,28 @@ fn set_color(cr: &cairo::Context, color: >k4::gdk::RGBA, alpha: f32) {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn covers_past_the_cap_drop_the_stalest_photos_but_no_town() {
|
||||
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE as u64 + 3)
|
||||
.map(|n| (format!("p{n}"), ((), n)))
|
||||
.collect();
|
||||
let towns: HashSet<&str> = ["p0"].into_iter().collect();
|
||||
let mut dropped = evict_covers(&mut covers, &towns, COVER_CACHE as u64);
|
||||
dropped.sort();
|
||||
assert_eq!(dropped, ["p1", "p2", "p3"]);
|
||||
assert_eq!(covers.len(), COVER_CACHE);
|
||||
assert!(covers.contains_key("p0"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn covers_drawn_this_frame_are_kept_even_past_the_cap() {
|
||||
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE + 2)
|
||||
.map(|n| (format!("p{n}"), ((), 7)))
|
||||
.collect();
|
||||
assert!(evict_covers(&mut covers, &HashSet::new(), 7).is_empty());
|
||||
assert_eq!(covers.len(), COVER_CACHE + 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn projection_puts_the_equator_and_meridian_in_the_middle() {
|
||||
let p = project(0.0, 0.0);
|
||||
|
||||
@@ -635,6 +635,7 @@ pub(crate) fn shared_item_as_entry(item: &SharedItem) -> DirEntry {
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: None,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -245,7 +245,7 @@ pub(crate) fn build_main_page() -> MainWidgets {
|
||||
let online_map_row = adw::SwitchRow::builder()
|
||||
.title(gettext("Street map for Places"))
|
||||
.subtitle(gettext(
|
||||
"Show streets and town names from OpenFreeMap. It learns which parts of the world you look at.",
|
||||
"Show streets from OpenFreeMap instead of the offline map. It learns which parts of the world you look at.",
|
||||
))
|
||||
.build();
|
||||
appearance_group.add(&online_map_row);
|
||||
|
||||
@@ -52,8 +52,9 @@ fn staged_path(ui: &Rc<Ui>) -> PathBuf {
|
||||
|
||||
/// Read the remembered set, dropping any archive that has since been moved or
|
||||
/// deleted — a stale path would only fail at launch, and silently is worse.
|
||||
fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
|
||||
let Ok(text) = std::fs::read_to_string(staged_path(ui)) else {
|
||||
/// Blocking: run it off the GTK thread.
|
||||
fn load_staged(path: &Path) -> Vec<PathBuf> {
|
||||
let Ok(text) = std::fs::read_to_string(path) else {
|
||||
return Vec::new();
|
||||
};
|
||||
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
|
||||
@@ -64,9 +65,39 @@ fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Restore whatever was staged when the window last closed, read on a worker.
|
||||
/// Anything the user staged meanwhile is kept alongside it.
|
||||
fn restore_staged(ui: &Rc<Ui>) {
|
||||
let path = staged_path(ui);
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let restored = gio::spawn_blocking(move || load_staged(&path))
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
{
|
||||
let mut staged = ui.takeout.archives.borrow_mut();
|
||||
for path in restored {
|
||||
if !staged.contains(&path) {
|
||||
staged.push(path);
|
||||
}
|
||||
}
|
||||
staged.sort();
|
||||
}
|
||||
ui.takeout.restored.set(true);
|
||||
repaint_archives(&ui);
|
||||
});
|
||||
}
|
||||
|
||||
/// Remember the staged set. Best-effort: failing to write it costs the user a
|
||||
/// re-pick next time, which is not worth interrupting them over now.
|
||||
///
|
||||
/// Written on a worker. Nothing is written before the remembered set has been
|
||||
/// read back, so the empty list shown meanwhile can't overwrite it, and a
|
||||
/// write that lands after a newer one is skipped.
|
||||
fn save_staged(ui: &Rc<Ui>) {
|
||||
if !ui.takeout.restored.get() {
|
||||
return;
|
||||
}
|
||||
let paths: Vec<String> = ui
|
||||
.takeout
|
||||
.archives
|
||||
@@ -75,12 +106,24 @@ fn save_staged(ui: &Rc<Ui>) {
|
||||
.map(|p| p.display().to_string())
|
||||
.collect();
|
||||
let path = staged_path(ui);
|
||||
let written = serde_json::to_string(&paths)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
|
||||
if let Err(e) = written {
|
||||
tracing::warn!("cannot remember staged Takeout archives: {e}");
|
||||
}
|
||||
let seq = ui.takeout.save_seq.get() + 1;
|
||||
ui.takeout.save_seq.set(seq);
|
||||
let saved = ui.takeout.saved_seq.clone();
|
||||
gio::spawn_blocking(move || {
|
||||
let Ok(mut last) = saved.lock() else {
|
||||
return;
|
||||
};
|
||||
if *last > seq {
|
||||
return;
|
||||
}
|
||||
*last = seq;
|
||||
let written = serde_json::to_string(&paths)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
|
||||
if let Err(e) = written {
|
||||
tracing::warn!("cannot remember staged Takeout archives: {e}");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn empty_list_description() -> String {
|
||||
@@ -121,6 +164,16 @@ pub(crate) struct TakeoutState {
|
||||
pub(crate) inflight: Cell<bool>,
|
||||
/// Whether the daemon reported an import running on the last poll.
|
||||
pub(crate) running: Cell<bool>,
|
||||
/// Whether the remembered staged set has been read back yet; until then
|
||||
/// nothing is saved over it.
|
||||
pub(crate) restored: Cell<bool>,
|
||||
/// The last save started, and the last one written by a worker, so an
|
||||
/// older save that lands late doesn't overwrite a newer one.
|
||||
pub(crate) save_seq: Cell<u64>,
|
||||
pub(crate) saved_seq: std::sync::Arc<std::sync::Mutex<u64>>,
|
||||
/// Bumped by every repaint of the archive list, so the sizes of an older
|
||||
/// list that arrive late are not painted over a newer one.
|
||||
pub(crate) repaint_seq: Cell<u64>,
|
||||
}
|
||||
|
||||
/// Widgets the Import page hands back for wiring.
|
||||
@@ -490,10 +543,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
|
||||
.back_button
|
||||
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
|
||||
|
||||
// Restore whatever was staged when the window last closed, before the first
|
||||
// paint, so the page comes up as the user left it.
|
||||
*ui.takeout.archives.borrow_mut() = load_staged(ui);
|
||||
// Restore whatever was staged when the window last closed, so the page
|
||||
// comes up as the user left it.
|
||||
repaint_archives(ui);
|
||||
restore_staged(ui);
|
||||
}
|
||||
|
||||
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
|
||||
@@ -503,15 +556,36 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
|
||||
/// the scan reads the archives' central directories, and an extracted tree has
|
||||
/// none — silently importing half of it would be worse than saying no.
|
||||
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
|
||||
// Whether each is a regular file is asked of the filesystem, which may be
|
||||
// a slow network mount: on a worker.
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let checked = gio::spawn_blocking(move || {
|
||||
paths
|
||||
.into_iter()
|
||||
.map(|path| {
|
||||
let file = path.is_file();
|
||||
(path, file)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
stage_archives(&ui, checked);
|
||||
});
|
||||
}
|
||||
|
||||
/// Stage the archives [`add_archives`] checked, as `(path, is a file)`.
|
||||
fn stage_archives(ui: &Rc<Ui>, paths: Vec<(PathBuf, bool)>) {
|
||||
let mut added = 0usize;
|
||||
let mut rejected = 0usize;
|
||||
{
|
||||
let mut staged = ui.takeout.archives.borrow_mut();
|
||||
for path in paths {
|
||||
for (path, file) in paths {
|
||||
let is_zip = path
|
||||
.extension()
|
||||
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
|
||||
if !is_zip || !path.is_file() {
|
||||
if !is_zip || !file {
|
||||
rejected += 1;
|
||||
continue;
|
||||
}
|
||||
@@ -542,12 +616,44 @@ pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
|
||||
}
|
||||
|
||||
/// Rebuild the staged-archive list and re-derive which actions are available.
|
||||
///
|
||||
/// The archives' sizes are read on a worker, and the list is rebuilt once
|
||||
/// they are in.
|
||||
pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||
let seq = ui.takeout.repaint_seq.get().wrapping_add(1);
|
||||
ui.takeout.repaint_seq.set(seq);
|
||||
let staged = ui.takeout.archives.borrow().clone();
|
||||
save_staged(ui);
|
||||
sync_takeout_actions(ui);
|
||||
if staged.is_empty() {
|
||||
paint_archives(ui, Vec::new());
|
||||
return;
|
||||
}
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let sized = gio::spawn_blocking(move || {
|
||||
staged
|
||||
.into_iter()
|
||||
.map(|path| {
|
||||
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
|
||||
(path, size)
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.await
|
||||
.unwrap_or_default();
|
||||
if ui.takeout.repaint_seq.get() == seq {
|
||||
paint_archives(&ui, sized);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Fill the staged-archive list with `staged`, as `(path, size)`.
|
||||
fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
|
||||
for row in ui.takeout.rows.borrow_mut().drain(..) {
|
||||
ui.takeout.list_group.remove(&row);
|
||||
}
|
||||
|
||||
let staged = ui.takeout.archives.borrow().clone();
|
||||
let mut rows: Vec<adw::PreferencesRow> = Vec::new();
|
||||
if staged.is_empty() {
|
||||
ui.takeout
|
||||
@@ -558,8 +664,8 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||
rows.push(row.upcast());
|
||||
} else {
|
||||
let mut total = 0u64;
|
||||
for path in &staged {
|
||||
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
|
||||
for (path, size) in &staged {
|
||||
let size = *size;
|
||||
total += size;
|
||||
let row = adw::ActionRow::builder()
|
||||
.title(
|
||||
@@ -601,9 +707,6 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||
)));
|
||||
}
|
||||
*ui.takeout.rows.borrow_mut() = rows;
|
||||
|
||||
save_staged(ui);
|
||||
sync_takeout_actions(ui);
|
||||
}
|
||||
|
||||
/// Enable exactly the actions that make sense right now: nothing to launch
|
||||
|
||||
@@ -16,6 +16,28 @@ pub(crate) struct TrashState {
|
||||
pub(crate) selection_label: gtk4::Label,
|
||||
/// Runs the loads; the rows stay up while one runs.
|
||||
pub(crate) loader: Rc<Loader>,
|
||||
/// Back, the breadcrumb and the search entry over the list.
|
||||
pub(crate) back: gtk4::Button,
|
||||
pub(crate) crumb: gtk4::Box,
|
||||
pub(crate) search: gtk4::SearchEntry,
|
||||
/// On: the trash as the folders things were deleted from. Off: one list.
|
||||
pub(crate) grouped: gtk4::ToggleButton,
|
||||
/// The whole trash as last read, newest deletion first.
|
||||
pub(crate) all: RefCell<Vec<DirEntry>>,
|
||||
/// Where the list is, below the top level.
|
||||
pub(crate) nav: RefCell<Vec<TrashNav>>,
|
||||
/// What the trashed folder on screen holds, once read.
|
||||
pub(crate) folder_rows: RefCell<Option<Vec<DirEntry>>>,
|
||||
}
|
||||
|
||||
/// One step down from the top of the Trash page.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) enum TrashNav {
|
||||
/// The things deleted from one folder: its path, `""` for My files, `None`
|
||||
/// when the folder is not known.
|
||||
Location { key: Option<String>, label: String },
|
||||
/// Inside a trashed folder.
|
||||
Folder { uid: String, name: String },
|
||||
}
|
||||
|
||||
/// The widgets of the Trash page that a load repaints.
|
||||
@@ -30,8 +52,18 @@ pub(crate) struct TrashWidgets {
|
||||
pub(crate) selection_label: gtk4::Label,
|
||||
pub(crate) restore_selected: gtk4::Button,
|
||||
pub(crate) delete_selected: gtk4::Button,
|
||||
pub(crate) back: gtk4::Button,
|
||||
pub(crate) crumb: gtk4::Box,
|
||||
pub(crate) search: gtk4::SearchEntry,
|
||||
pub(crate) grouped: gtk4::ToggleButton,
|
||||
}
|
||||
|
||||
/// The uid prefix of a row that stands for a folder things were deleted from.
|
||||
/// Such a row is made here, never sent to the daemon.
|
||||
const LOCATION_UID: &str = "trash-location:";
|
||||
/// The location key of the folder that is not known.
|
||||
const UNKNOWN_LOCATION: &str = "\u{0}";
|
||||
|
||||
/// The Trash page: everything Drive is holding in the trash, as a list with
|
||||
/// the folder each item came from and when it was deleted, or as a grid, where
|
||||
/// photos are easier to recognise. Restore and Delete Permanently sit in the
|
||||
@@ -75,11 +107,41 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
|
||||
content.add_named(&files.views, Some("list"));
|
||||
content.add_named(&status, Some("status"));
|
||||
|
||||
let back = gtk4::Button::builder()
|
||||
.icon_name("go-previous-symbolic")
|
||||
.tooltip_text(gettext("Back"))
|
||||
.visible(false)
|
||||
.build();
|
||||
back.add_css_class("flat");
|
||||
let crumb = gtk4::Box::new(gtk4::Orientation::Horizontal, 2);
|
||||
crumb.set_valign(gtk4::Align::Center);
|
||||
let crumb_scroll = gtk4::ScrolledWindow::builder()
|
||||
.hscrollbar_policy(gtk4::PolicyType::External)
|
||||
.vscrollbar_policy(gtk4::PolicyType::Never)
|
||||
.hexpand(true)
|
||||
.child(&crumb)
|
||||
.build();
|
||||
let search = gtk4::SearchEntry::builder()
|
||||
.placeholder_text(gettext("Search the trash"))
|
||||
.width_chars(24)
|
||||
.build();
|
||||
let path_bar = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||
path_bar.append(&back);
|
||||
path_bar.append(&crumb_scroll);
|
||||
path_bar.append(&search);
|
||||
|
||||
let grouped = gtk4::ToggleButton::builder()
|
||||
.icon_name("folder-symbolic")
|
||||
.tooltip_text(gettext("Group by original folder"))
|
||||
.active(true)
|
||||
.build();
|
||||
|
||||
let inner = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
|
||||
inner.set_margin_top(12);
|
||||
inner.set_margin_bottom(12);
|
||||
inner.set_margin_start(12);
|
||||
inner.set_margin_end(12);
|
||||
inner.append(&path_bar);
|
||||
inner.append(&content);
|
||||
|
||||
// Bulk Delete Permanently always confirms with the count, so a stale
|
||||
@@ -101,6 +163,7 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
|
||||
let (frame, header, subtitle) = page_frame(&gettext("Trash"), &inner);
|
||||
header.pack_start(&empty);
|
||||
header.pack_end(&layout);
|
||||
header.pack_end(&grouped);
|
||||
|
||||
(
|
||||
frame.upcast(),
|
||||
@@ -115,6 +178,10 @@ pub(crate) fn build_trash_page() -> (gtk4::Widget, TrashWidgets) {
|
||||
selection_label,
|
||||
restore_selected,
|
||||
delete_selected,
|
||||
back,
|
||||
crumb,
|
||||
search,
|
||||
grouped,
|
||||
},
|
||||
)
|
||||
}
|
||||
@@ -151,7 +218,10 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, widgets: &TrashWidgets) {
|
||||
files
|
||||
.column_view
|
||||
.append_column(&text_column(&pgettext("column", "Size"), |e| {
|
||||
if e.is_dir {
|
||||
if location_key(&e.uid).is_some() {
|
||||
// A location row carries how many items it holds as its size.
|
||||
ngettext_f("{n} item", "{n} items", e.size, &[])
|
||||
} else if e.is_dir {
|
||||
"—".to_string()
|
||||
} else {
|
||||
human_bytes(e.size)
|
||||
@@ -163,6 +233,21 @@ pub(crate) fn wire_trash(ui: &Rc<Ui>, widgets: &TrashWidgets) {
|
||||
.empty
|
||||
.connect_clicked(move |_| prompt_empty_trash(&ui_empty));
|
||||
|
||||
let ui_back = ui.clone();
|
||||
widgets.back.connect_clicked(move |_| {
|
||||
ui_back.trash.nav.borrow_mut().pop();
|
||||
show_trash_place(&ui_back);
|
||||
});
|
||||
let ui_search = ui.clone();
|
||||
widgets
|
||||
.search
|
||||
.connect_search_changed(move |_| render_trash(&ui_search));
|
||||
let ui_grouped = ui.clone();
|
||||
widgets.grouped.connect_toggled(move |_| {
|
||||
ui_grouped.trash.nav.borrow_mut().clear();
|
||||
show_trash_place(&ui_grouped);
|
||||
});
|
||||
|
||||
let ui_sel = ui.clone();
|
||||
files
|
||||
.selection
|
||||
@@ -193,17 +278,52 @@ fn trashed_from_label(entry: &DirEntry) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// A trashed file can't be opened; say what would let it be.
|
||||
/// Open a location or a trashed folder in place. A trashed file can't be
|
||||
/// opened; say what would let it be.
|
||||
fn activate_trashed(ui: &Rc<Ui>, entry: &DirEntry) {
|
||||
toast(
|
||||
ui,
|
||||
if let Some(key) = location_key(&entry.uid) {
|
||||
ui.trash.nav.borrow_mut().push(TrashNav::Location {
|
||||
key,
|
||||
label: entry.name.clone(),
|
||||
});
|
||||
show_trash_place(ui);
|
||||
} else if entry.is_dir {
|
||||
ui.trash.nav.borrow_mut().push(TrashNav::Folder {
|
||||
uid: entry.uid.clone(),
|
||||
name: entry.name.clone(),
|
||||
});
|
||||
show_trash_place(ui);
|
||||
} else {
|
||||
let name = match outer_folder(ui) {
|
||||
Some(folder) if !in_trash(ui, &entry.uid) => folder.name,
|
||||
_ => entry.name.clone(),
|
||||
};
|
||||
// Translators: {name} is a file or folder name.
|
||||
&gettext_f("Restore “{name}” to open it", &[("name", &entry.name)]),
|
||||
);
|
||||
toast(
|
||||
ui,
|
||||
&gettext_f("Restore “{name}” to open it", &[("name", &name)]),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn trash_entry_menu(ui: &Rc<Ui>, entry: &DirEntry) -> ActionMenu {
|
||||
let mut menu = ActionMenu::new();
|
||||
if location_key(&entry.uid).is_none()
|
||||
&& !in_trash(ui, &entry.uid)
|
||||
&& let Some(folder) = outer_folder(ui)
|
||||
{
|
||||
// Went to the trash with the folder, so only the folder goes back.
|
||||
let ui_c = ui.clone();
|
||||
let label = gettext_f(
|
||||
// Translators: {name} is a folder name.
|
||||
"Restore “{name}”",
|
||||
&[("name", &folder.name)],
|
||||
);
|
||||
menu.item(&label, move || {
|
||||
restore_entries(&ui_c, std::slice::from_ref(&folder))
|
||||
});
|
||||
return menu;
|
||||
}
|
||||
let (ui_c, entry_c) = (ui.clone(), entry.clone());
|
||||
menu.item(&pgettext("verb", "Restore"), move || {
|
||||
restore_entries(&ui_c, std::slice::from_ref(&entry_c))
|
||||
@@ -244,7 +364,7 @@ fn trash_background_menu(ui: &Rc<Ui>) -> ActionMenu {
|
||||
});
|
||||
let ui_c = ui.clone();
|
||||
menu.item(&gettext("Refresh"), move || reload_current_page(&ui_c));
|
||||
if ui.trash.files.model.n_items() > 0 {
|
||||
if !ui.trash.all.borrow().is_empty() {
|
||||
menu.section();
|
||||
let ui_c = ui.clone();
|
||||
menu.item(&gettext("Empty Trash…"), move || {
|
||||
@@ -300,7 +420,17 @@ pub(crate) fn load_trash(ui: &Rc<Ui>) {
|
||||
clear_trash(&ui);
|
||||
}
|
||||
match result {
|
||||
Ok(Ok(Response::Entries { entries })) => repaint_trash(&ui, &entries),
|
||||
Ok(Ok(Response::Entries { entries })) => {
|
||||
let mut entries = entries;
|
||||
sort_trash(&mut entries);
|
||||
*ui.trash.all.borrow_mut() = entries;
|
||||
keep_trash_place(&ui);
|
||||
if matches!(ui.trash.nav.borrow().last(), Some(TrashNav::Folder { .. })) {
|
||||
load_trashed_folder(&ui);
|
||||
} else {
|
||||
render_trash(&ui);
|
||||
}
|
||||
}
|
||||
Ok(Ok(Response::Error { message, .. })) => trash_status(
|
||||
&ui,
|
||||
"dialog-warning-symbolic",
|
||||
@@ -338,14 +468,125 @@ pub(crate) fn trash_status(ui: &Rc<Ui>, icon: &str, title: &str, description: &s
|
||||
ui.trash.subtitle.set_subtitle("");
|
||||
}
|
||||
|
||||
/// Repopulate the trash, most recently deleted first: the order in which a user
|
||||
/// looks for what they just deleted.
|
||||
pub(crate) fn repaint_trash(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
/// Go to the place `nav` now points at: read a trashed folder, or show
|
||||
/// what the stored listing already holds.
|
||||
fn show_trash_place(ui: &Rc<Ui>) {
|
||||
if !ui.trash.search.text().is_empty() {
|
||||
ui.trash.search.set_text("");
|
||||
}
|
||||
ui.trash.files.selection.unselect_all();
|
||||
ui.trash.files.scroll_to_top();
|
||||
if matches!(ui.trash.nav.borrow().last(), Some(TrashNav::Folder { .. })) {
|
||||
load_trashed_folder(ui);
|
||||
} else {
|
||||
render_trash(ui);
|
||||
}
|
||||
}
|
||||
|
||||
/// Read what the trashed folder on screen holds, then show it.
|
||||
fn load_trashed_folder(ui: &Rc<Ui>) {
|
||||
let Some(TrashNav::Folder { uid, .. }) = ui.trash.nav.borrow().last().cloned() else {
|
||||
return;
|
||||
};
|
||||
ui.trash.folder_rows.borrow_mut().take();
|
||||
let ui_p = ui.clone();
|
||||
let ticket = ui.trash.loader.replace(move || {
|
||||
clear_trash(&ui_p);
|
||||
trash_status(
|
||||
&ui_p,
|
||||
"folder-open-symbolic",
|
||||
&gettext("Loading…"),
|
||||
&gettext("Reading this folder."),
|
||||
false,
|
||||
);
|
||||
});
|
||||
ui.busy_begin();
|
||||
let rx = spawn_request(
|
||||
ui.dirs.control_socket(),
|
||||
Request::ListTrashedFolder { uid: uid.clone() },
|
||||
);
|
||||
let ui = ui.clone();
|
||||
glib::spawn_future_local(async move {
|
||||
let result = rx.recv().await;
|
||||
ui.busy_end();
|
||||
if !ticket.is_current() {
|
||||
return;
|
||||
}
|
||||
let still_here = matches!(
|
||||
ui.trash.nav.borrow().last(),
|
||||
Some(TrashNav::Folder { uid: on, .. }) if *on == uid
|
||||
);
|
||||
if !still_here {
|
||||
return;
|
||||
}
|
||||
match result {
|
||||
Ok(Ok(Response::Entries { entries })) => {
|
||||
*ui.trash.folder_rows.borrow_mut() = Some(entries);
|
||||
render_trash(&ui);
|
||||
}
|
||||
Ok(Ok(Response::Error { message, .. })) => {
|
||||
clear_trash(&ui);
|
||||
trash_status(
|
||||
&ui,
|
||||
"dialog-warning-symbolic",
|
||||
&gettext("Couldn't open the folder"),
|
||||
&message,
|
||||
false,
|
||||
);
|
||||
}
|
||||
Ok(Ok(_)) => {
|
||||
clear_trash(&ui);
|
||||
trash_status(
|
||||
&ui,
|
||||
"dialog-warning-symbolic",
|
||||
&gettext("Couldn't open the folder"),
|
||||
&gettext("Unexpected reply from the Proton Drive service."),
|
||||
false,
|
||||
);
|
||||
}
|
||||
Ok(Err(_)) | Err(_) => trash_unreachable(&ui),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// After a new listing, step back out of places that are gone from it.
|
||||
fn keep_trash_place(ui: &Rc<Ui>) {
|
||||
let all = ui.trash.all.borrow();
|
||||
let mut nav = ui.trash.nav.borrow_mut();
|
||||
let keep = kept_steps(&nav, &all);
|
||||
nav.truncate(keep);
|
||||
}
|
||||
|
||||
/// How many steps of `nav` still lead somewhere in `all`. A location stays
|
||||
/// while something deleted from it is listed, and the trashed folder opened
|
||||
/// from it while that folder is; the folders below it went with it.
|
||||
fn kept_steps(nav: &[TrashNav], all: &[DirEntry]) -> usize {
|
||||
let mut inside = false;
|
||||
for (i, step) in nav.iter().enumerate() {
|
||||
let there = match step {
|
||||
TrashNav::Location { key, .. } => all
|
||||
.iter()
|
||||
.any(|e| e.trashed_parent.is_none() && e.trashed_from == *key),
|
||||
TrashNav::Folder { uid, .. } => inside || all.iter().any(|e| e.uid == *uid),
|
||||
};
|
||||
if !there {
|
||||
return i;
|
||||
}
|
||||
inside |= matches!(step, TrashNav::Folder { .. });
|
||||
}
|
||||
nav.len()
|
||||
}
|
||||
|
||||
/// Show the rows for the current place, search and grouping.
|
||||
pub(crate) fn render_trash(ui: &Rc<Ui>) {
|
||||
let all = ui.trash.all.borrow();
|
||||
// An empty Trash has nothing to empty, so the button goes away rather than
|
||||
// sitting there greyed out.
|
||||
ui.trash.empty.set_sensitive(true);
|
||||
ui.trash.empty.set_visible(!entries.is_empty());
|
||||
if entries.is_empty() {
|
||||
ui.trash.empty.set_visible(!all.is_empty());
|
||||
repaint_trash_crumb(ui);
|
||||
if all.is_empty() {
|
||||
drop(all);
|
||||
trash_status(
|
||||
ui,
|
||||
"user-trash-symbolic",
|
||||
@@ -356,22 +597,198 @@ pub(crate) fn repaint_trash(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
clear_trash(ui);
|
||||
return;
|
||||
}
|
||||
ui.trash.content.set_visible_child_name("list");
|
||||
ui.trash.subtitle.set_subtitle(&ngettext_f(
|
||||
"{n} item",
|
||||
"{n} items",
|
||||
entries.len() as u64,
|
||||
&[],
|
||||
));
|
||||
let subtitle = ngettext_f("{n} item", "{n} items", all.len() as u64, &[]);
|
||||
|
||||
let mut sorted = entries.to_vec();
|
||||
sort_trash(&mut sorted);
|
||||
let query = ui.trash.search.text().to_lowercase();
|
||||
let nav = ui.trash.nav.borrow().clone();
|
||||
let rows: Vec<DirEntry> = if !query.is_empty() {
|
||||
all.iter()
|
||||
.filter(|e| e.name.to_lowercase().contains(&query))
|
||||
.cloned()
|
||||
.collect()
|
||||
} else if !ui.trash.grouped.is_active() {
|
||||
all.clone()
|
||||
} else {
|
||||
match nav.last() {
|
||||
None => trash_locations(&all),
|
||||
Some(TrashNav::Location { key, .. }) => all
|
||||
.iter()
|
||||
.filter(|e| e.trashed_parent.is_none() && e.trashed_from == *key)
|
||||
.cloned()
|
||||
.collect(),
|
||||
Some(TrashNav::Folder { .. }) => {
|
||||
ui.trash.folder_rows.borrow().clone().unwrap_or_default()
|
||||
}
|
||||
}
|
||||
};
|
||||
drop(all);
|
||||
if rows.is_empty() {
|
||||
clear_trash(ui);
|
||||
if query.is_empty() {
|
||||
trash_status(
|
||||
ui,
|
||||
"folder-open-symbolic",
|
||||
&gettext("This folder is empty"),
|
||||
&gettext("Nothing else was in this folder when it was deleted."),
|
||||
false,
|
||||
);
|
||||
} else {
|
||||
trash_status(
|
||||
ui,
|
||||
"edit-find-symbolic",
|
||||
&gettext("No results"),
|
||||
&gettext("Nothing in the trash has that name."),
|
||||
false,
|
||||
);
|
||||
}
|
||||
ui.trash.subtitle.set_subtitle(&subtitle);
|
||||
return;
|
||||
}
|
||||
ui.trash.content.set_visible_child_name("list");
|
||||
ui.trash.subtitle.set_subtitle(&subtitle);
|
||||
// Only the rows that changed are swapped, so a refresh keeps the
|
||||
// selection and the scroll position.
|
||||
replace_items(&ui.trash.files.model, &sorted);
|
||||
replace_items(&ui.trash.files.model, &rows);
|
||||
sync_trash_selection(ui);
|
||||
}
|
||||
|
||||
/// One row per folder things were deleted from, the most recent first. Items
|
||||
/// trashed inside a trashed folder are found by opening that folder.
|
||||
fn trash_locations(all: &[DirEntry]) -> Vec<DirEntry> {
|
||||
let mut rows: Vec<DirEntry> = Vec::new();
|
||||
let mut index: HashMap<Option<String>, usize> = HashMap::new();
|
||||
for entry in all.iter().filter(|e| e.trashed_parent.is_none()) {
|
||||
let key = entry.trashed_from.clone();
|
||||
let at = *index.entry(key.clone()).or_insert_with(|| {
|
||||
rows.push(location_row(key));
|
||||
rows.len() - 1
|
||||
});
|
||||
let row = &mut rows[at];
|
||||
row.size += 1;
|
||||
row.trashed_at = row.trashed_at.max(entry.trashed_at);
|
||||
row.modified = row.modified.max(entry.modified);
|
||||
}
|
||||
sort_trash(&mut rows);
|
||||
rows
|
||||
}
|
||||
|
||||
/// The row that stands for the folder `key`, still holding nothing.
|
||||
fn location_row(key: Option<String>) -> DirEntry {
|
||||
let (uid, name) = match key.as_deref() {
|
||||
None => (
|
||||
format!("{LOCATION_UID}{UNKNOWN_LOCATION}"),
|
||||
gettext("Unknown folder"),
|
||||
),
|
||||
Some("") => (LOCATION_UID.to_string(), gettext("My files")),
|
||||
Some(path) => (
|
||||
format!("{LOCATION_UID}{path}"),
|
||||
path.rsplit('/').next().unwrap_or(path).to_string(),
|
||||
),
|
||||
};
|
||||
DirEntry {
|
||||
name,
|
||||
is_dir: true,
|
||||
size: 0,
|
||||
modified: 0,
|
||||
pinned: false,
|
||||
pinned_by_folder: false,
|
||||
cached: false,
|
||||
uid,
|
||||
path: String::new(),
|
||||
role: String::new(),
|
||||
shared_by: String::new(),
|
||||
shared_at: 0,
|
||||
shared_by_unverified: false,
|
||||
trashed_at: 0,
|
||||
trashed_from: key,
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The folder a location row stands for, or `None` for any other row.
|
||||
fn location_key(uid: &str) -> Option<Option<String>> {
|
||||
let key = uid.strip_prefix(LOCATION_UID)?;
|
||||
Some((key != UNKNOWN_LOCATION).then(|| key.to_string()))
|
||||
}
|
||||
|
||||
/// Whether the stored listing holds `uid`, so it can be restored on its own.
|
||||
fn in_trash(ui: &Ui, uid: &str) -> bool {
|
||||
ui.trash.all.borrow().iter().any(|e| e.uid == uid)
|
||||
}
|
||||
|
||||
/// The trashed folder the user opened from a location, when inside one.
|
||||
fn outer_folder(ui: &Ui) -> Option<DirEntry> {
|
||||
let nav = ui.trash.nav.borrow();
|
||||
let uid = nav.iter().find_map(|step| match step {
|
||||
TrashNav::Folder { uid, .. } => Some(uid.clone()),
|
||||
TrashNav::Location { .. } => None,
|
||||
})?;
|
||||
ui.trash.all.borrow().iter().find(|e| e.uid == uid).cloned()
|
||||
}
|
||||
|
||||
/// What acting on `entries` acts on: a location row stands for everything
|
||||
/// deleted from that folder, and an item that went with its folder for the
|
||||
/// folder. Each node once.
|
||||
fn trashed_targets(ui: &Ui, entries: &[DirEntry]) -> Vec<DirEntry> {
|
||||
let all = ui.trash.all.borrow();
|
||||
let outer = outer_folder(ui);
|
||||
let mut seen = HashSet::new();
|
||||
let mut targets = Vec::new();
|
||||
for entry in entries {
|
||||
let picked: Vec<DirEntry> = if let Some(key) = location_key(&entry.uid) {
|
||||
all.iter()
|
||||
.filter(|e| e.trashed_parent.is_none() && e.trashed_from == key)
|
||||
.cloned()
|
||||
.collect()
|
||||
} else if all.iter().any(|e| e.uid == entry.uid) {
|
||||
vec![entry.clone()]
|
||||
} else {
|
||||
outer.clone().into_iter().collect()
|
||||
};
|
||||
for target in picked {
|
||||
if seen.insert(target.uid.clone()) {
|
||||
targets.push(target);
|
||||
}
|
||||
}
|
||||
}
|
||||
targets
|
||||
}
|
||||
|
||||
/// Rebuild the path bar for `nav`: "Trash", then each place down to the
|
||||
/// current one. Hidden at the top, where there is nowhere to go back to.
|
||||
fn repaint_trash_crumb(ui: &Rc<Ui>) {
|
||||
let nav = ui.trash.nav.borrow();
|
||||
let crumb = &ui.trash.crumb;
|
||||
while let Some(child) = crumb.first_child() {
|
||||
crumb.remove(&child);
|
||||
}
|
||||
ui.trash.back.set_visible(!nav.is_empty());
|
||||
crumb.append(&trash_crumb_node(ui, &gettext("Trash"), 0, nav.is_empty()));
|
||||
for (i, step) in nav.iter().enumerate() {
|
||||
let label = match step {
|
||||
TrashNav::Location { label, .. } => label,
|
||||
TrashNav::Folder { name, .. } => name,
|
||||
};
|
||||
crumb.append(&crumb_separator());
|
||||
crumb.append(&trash_crumb_node(ui, label, i + 1, i + 1 == nav.len()));
|
||||
}
|
||||
}
|
||||
|
||||
fn trash_crumb_node(ui: &Rc<Ui>, label: &str, depth: usize, current: bool) -> gtk4::Widget {
|
||||
if current {
|
||||
return crumb_current(label);
|
||||
}
|
||||
let button = gtk4::Button::builder().label(label).build();
|
||||
button.add_css_class("flat");
|
||||
let ui = ui.clone();
|
||||
button.connect_clicked(move |_| {
|
||||
ui.trash.nav.borrow_mut().truncate(depth);
|
||||
show_trash_place(&ui);
|
||||
});
|
||||
button.upcast()
|
||||
}
|
||||
|
||||
/// Newest deletion first. Entries with no known deletion time go last, newest
|
||||
/// modification first among themselves.
|
||||
fn sort_trash(entries: &mut [DirEntry]) {
|
||||
@@ -393,6 +810,10 @@ fn clear_trash(ui: &Rc<Ui>) {
|
||||
/// Restore trashed entries to the folders they were trashed from. When they
|
||||
/// all came from one known folder, the toast offers to show it.
|
||||
pub(crate) fn restore_entries(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
let entries = &trashed_targets(ui, entries)[..];
|
||||
if entries.is_empty() {
|
||||
return;
|
||||
}
|
||||
let message = match entries {
|
||||
// Translators: {name} is a file or folder name.
|
||||
[one] => gettext_f("Restored “{name}”", &[("name", &one.name)]),
|
||||
@@ -430,6 +851,10 @@ fn common_origin(entries: &[DirEntry]) -> Option<String> {
|
||||
|
||||
/// Confirm, then permanently delete trashed entries. Irreversible, so it asks.
|
||||
pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
let entries = &trashed_targets(ui, entries)[..];
|
||||
if entries.is_empty() {
|
||||
return;
|
||||
}
|
||||
let win = ui_window(ui);
|
||||
let uids: Vec<String> = entries.iter().map(|e| e.uid.clone()).collect();
|
||||
let count = entries.len() as u64;
|
||||
@@ -485,7 +910,7 @@ pub(crate) fn prompt_delete_forever(ui: &Rc<Ui>, entries: &[DirEntry]) {
|
||||
/// Confirm, then permanently delete everything in the trash.
|
||||
pub(crate) fn prompt_empty_trash(ui: &Rc<Ui>) {
|
||||
let win = ui_window(ui);
|
||||
let count = ui.trash.files.model.n_items();
|
||||
let count = ui.trash.all.borrow().len();
|
||||
let dialog = adw::AlertDialog::builder()
|
||||
.heading(gettext("Empty Trash?"))
|
||||
.body(ngettext_f(
|
||||
@@ -536,10 +961,64 @@ mod tests {
|
||||
shared_by_unverified: false,
|
||||
trashed_at,
|
||||
trashed_from: from.map(str::to_string),
|
||||
trashed_parent: None,
|
||||
issue: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn inside(name: &str, parent: &str) -> DirEntry {
|
||||
DirEntry {
|
||||
trashed_parent: Some(parent.into()),
|
||||
..trashed(name, 5, 1, None)
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn locations_group_top_level_items_by_folder() {
|
||||
let all = vec![
|
||||
trashed("a", 30, 1, Some("Photos/2019")),
|
||||
trashed("b", 10, 1, Some("Photos/2019")),
|
||||
trashed("c", 20, 1, Some("")),
|
||||
trashed("d", 5, 1, None),
|
||||
inside("e", "a"),
|
||||
];
|
||||
let rows = trash_locations(&all);
|
||||
let summary: Vec<(&str, u64, i64)> = rows
|
||||
.iter()
|
||||
.map(|r| (r.name.as_str(), r.size, r.trashed_at))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
summary,
|
||||
[
|
||||
("2019", 2, 30),
|
||||
("My files", 1, 20),
|
||||
("Unknown folder", 1, 5)
|
||||
]
|
||||
);
|
||||
assert_eq!(location_key(&rows[0].uid), Some(Some("Photos/2019".into())));
|
||||
assert_eq!(location_key(&rows[1].uid), Some(Some(String::new())));
|
||||
assert_eq!(location_key(&rows[2].uid), Some(None));
|
||||
assert_eq!(location_key("vol~link"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_place_stays_only_while_the_listing_still_leads_there() {
|
||||
let all = vec![trashed("album", 1, 1, Some("Photos")), inside("x", "album")];
|
||||
let location = TrashNav::Location {
|
||||
key: Some("Photos".into()),
|
||||
label: "Photos".into(),
|
||||
};
|
||||
let folder = |uid: &str| TrashNav::Folder {
|
||||
uid: uid.into(),
|
||||
name: uid.into(),
|
||||
};
|
||||
// Folders below the trashed one are not listed themselves.
|
||||
let nav = [location.clone(), folder("album"), folder("child")];
|
||||
assert_eq!(kept_steps(&nav, &all), 3);
|
||||
assert_eq!(kept_steps(&[location.clone(), folder("gone")], &all), 1);
|
||||
assert_eq!(kept_steps(&nav, &[]), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trash_lists_newest_deletion_first_and_undated_last() {
|
||||
let mut entries = vec | A file deleted online while the drain checks its write is kept as a conflict copy | Only with `local_first` off |
|
||||
| [B91](#b91--the-daemon-hung-overnight-and-nothing-could-say-what-it-was-waiting-on) | The daemon hung overnight, and nothing could say what it was waiting on | The cause is not diagnosed; the daemon now reports where it is stuck and is restarted |
|
||||
| [B67](#b67--fresh-state-restore-can-silently-select-a-new-device-high-22) | Fresh-state restore can silently select a new device (HIGH-22) | An ambiguous device after a loss of local state is not asked about |
|
||||
| [B66](#b66--local-only-pending-data-is-not-protected-at-shutdown-high-21) | Local-only pending data is not protected at shutdown (HIGH-21) | No shutdown protection and no `pdfs sync flush` |
|
||||
| [B65](#b65--release-artifacts-lack-supply-chain-verification-med-11) | Release artifacts lack supply-chain verification (MED-11) | No SBOM, provenance or checksums |
|
||||
| [B15](#b15--an-empty-but-listed-folder-and-duplicated-folder-uids) | An empty-but-`listed` folder, and duplicated folder uids | Cause not attributed |
|
||||
| [B10](#b10--glib-critical-when-the-launcher-closes-over-an-in-flight-open) | GLib critical when the launcher closes over an in-flight open | |
|
||||
@@ -109,6 +108,8 @@ a live account since.
|
||||
|
||||
| Entry | Title |
|
||||
|---|---|
|
||||
| [B66](#b66--local-only-pending-data-is-not-protected-at-shutdown-high-21) | Local-only pending data is not protected at shutdown (HIGH-21) |
|
||||
| [B293](#b293--a-large-trash-never-lists-and-empty-trash-never-empties-it) | A large trash never lists, and Empty Trash never empties it |
|
||||
| [B291](#b291--on-fedora-45s-oo7-every-saved-sign-in-is-lost-at-the-next-reboot) | On Fedora 45's oo7, every saved sign-in is lost at the next reboot |
|
||||
| [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos |
|
||||
| [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it |
|
||||
@@ -395,6 +396,38 @@ a live account since.
|
||||
|
||||
Newest first.
|
||||
|
||||
### B293 — A large trash never lists, and Empty Trash never empties it
|
||||
|
||||
**Status:** Fixed in code, live check pending
|
||||
|
||||
**Found:** 2026-11-22. The user reported that the Trash page always showed the same 64 items and
|
||||
that Empty Trash did nothing.
|
||||
|
||||
**Where:** `proton-drive-rs` `enumerate_trash_node_uids`; `crates/pdfs-fuse/src/lib.rs`
|
||||
`Core::refresh_trash` and `Core::empty_trash`
|
||||
|
||||
**Repro:** An account with a few thousand items in the trash. The log shows `background trash
|
||||
refresh failed error=enumerate trash: no answer within 120s` on every refresh, and Empty Trash
|
||||
shows `a control request has been running for a long time request=EmptyTrash age_secs=417`.
|
||||
|
||||
**Cause:** The SDK sent the trash paging parameters in lower case, unlike every other paged
|
||||
request, and kept asking while pages came back full. On a large trash the listing never
|
||||
finished. The refresh therefore timed out every time, and the page kept the rows of the last
|
||||
refresh that had got anywhere. Empty Trash listed the trash first, with no time limit, so the
|
||||
`DELETE` was never sent. A refresh also decrypted every trashed file again, and rewrote the whole
|
||||
table after every chunk.
|
||||
|
||||
**Fix:** SDK 0.12.5 sends `Page` and `PageSize` and stops on a page that brings nothing new.
|
||||
The refresh reads only nodes it has not stored yet, without unlocking file keys, and keeps the
|
||||
time the server says each was trashed. Rows go only once the whole listing is in. Empty Trash
|
||||
sends the `DELETE` at once, under the trash call time limit, and clears the stored listing.
|
||||
Restore and Delete Permanently drop their rows right away. Schema v47 indexes `trash.parent_uid`
|
||||
and drops the stored rows once, so they are read again with real deletion times.
|
||||
|
||||
**Verified:** `cargo test -p pdfs-fuse the_trash_lists_by_folder_and_empties -- --ignored`, the
|
||||
new `trash_upsert_keeps_other_rows_and_retain_drops_unlisted_ones`, and the SDK paging tests on
|
||||
2026-11-22. Pending: a live listing and empty on the affected account.
|
||||
|
||||
### B292 — Two programs changing settings at once lose one of the changes
|
||||
|
||||
**Status:** Fixed
|
||||
@@ -432,7 +465,7 @@ the build Fedora 45 and 46 ship as stable, from before oo7's
|
||||
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
|
||||
("server: Write item changes to the keyring file"). See
|
||||
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7).
|
||||
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `crates/pdfs-core/src/secretservice.rs`
|
||||
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `proton-auth-rs` (`secret_service.rs`, moved from `crates/pdfs-core/src/secretservice.rs`)
|
||||
|
||||
**Repro:** With oo7-daemon at e91b98a, save the session blob, save it again with a new refresh
|
||||
token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
|
||||
@@ -7475,7 +7508,7 @@ duplicates, renamed folders, multiple devices, and byte-identical restoration.
|
||||
|
||||
### B66 — Local-only pending data is not protected at shutdown (HIGH-21)
|
||||
|
||||
**Status:** Open — 1.0 data-safety/UX blocker
|
||||
**Status:** Fixed, unverified live
|
||||
**Found:** 2026-07-22, 1.0 recovery audit
|
||||
**Where:** shutdown, CLI/GUI status, logout/unregister workflows
|
||||
|
||||
@@ -7488,6 +7521,19 @@ and last errors, and protect destructive lifecycle actions. Test offline stop,
|
||||
logout, unregister, reboot, retry exhaustion, and drain. Credential removal must
|
||||
never delete staged bytes.
|
||||
|
||||
**Fix:** `crates/pdfs-fuse/src/inhibit.rs` takes a logind shutdown inhibitor
|
||||
(`systemd-inhibit --what=shutdown --mode=block`) while the queue holds changes
|
||||
the drain can send, and lets it go once they land. Parked transient files and
|
||||
changes that need the user are left out, so they never hold a power-off up for
|
||||
good. `pdfs sync flush` retries failed changes and waits for the queue, with
|
||||
its own exit codes for "needs you" and timeout. `pdfs logout` and the app's
|
||||
Sign Out dialog say how many changes are still queued and that they stay
|
||||
staged. Credential removal never touched `staging/`.
|
||||
|
||||
**Verified:** unit tests for which work holds the lock; `systemd-inhibit` in
|
||||
block mode taken by a user process on 2026-11-21. A power-off with a queued
|
||||
upload is still owed.
|
||||
|
||||
---
|
||||
|
||||
### B65 — Release artifacts lack supply-chain verification (MED-11)
|
||||
|
||||
@@ -11,6 +11,63 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
|
||||
- `pdfs sync flush` waits until every queued change is on Proton Drive, retrying
|
||||
failed ones at once. It exits 3 when what is left needs you and 4 on `--timeout`.
|
||||
- While changes are queued that only this computer has, the daemon holds off a
|
||||
shutdown through logind, and desktops show "Sending N changes to Proton Drive" in
|
||||
their power-off dialog. Changes waiting on you never hold it up (B66).
|
||||
- Signing out, in the app or with `pdfs logout`, says how many changes are not on
|
||||
Proton Drive yet. They stay on this computer and are sent after the next sign-in.
|
||||
|
||||
### Changed
|
||||
|
||||
- The Trash page shows the folders things were deleted from. Open one to see what
|
||||
was deleted there, and open a deleted folder to see what it held. A switch in
|
||||
the header goes back to one list, and a search box finds anything in the trash
|
||||
by name. Restore and Delete Permanently work on a whole folder row. `pdfs trash`
|
||||
takes `--by-folder`, and `--folder UID` for a deleted folder.
|
||||
- The trash loads faster: a refresh reads only what is new, without unlocking file
|
||||
keys, and shows the time each item was deleted as Proton Drive reports it.
|
||||
- The Places map draws an offline basemap, the one Proton Gallery shows: seas by
|
||||
depth, lakes, rivers, built-up areas, borders and town names, in light and dark,
|
||||
rendered in the background through `proton-map-rs`. It ships with every package
|
||||
(about 25 MB, fetched by `scripts/fetch-basemap.sh` against a pinned SHA-256) and
|
||||
sends no request. The street map stays opt-in and replaces it when turned on.
|
||||
Without the file the map falls back to the coarse outlines.
|
||||
- A Google Photos import uploads two photos at once instead of one, while the next
|
||||
photo is read out of its archive. Live-photo videos still go after their stills, and
|
||||
cancelling still lets the uploads in flight finish.
|
||||
- proton-sdk 0.12.4: thumbnails need fewer requests to Proton (0.12.3), and the SDK
|
||||
can list photos that have no thumbnail (0.12.4).
|
||||
- Signing in runs through `proton_sdk::login` (proton-sdk 0.12.2), the sequence Proton
|
||||
Gallery and Proton Stream use too. The stored session, the lock/unlock choice for two-password
|
||||
accounts, the three mailbox-password tries and the messages stay as they were.
|
||||
- An account whose only second factor is a security key now gets a clear message at
|
||||
sign-in instead of a code prompt that could only fail.
|
||||
- Block fetches shared by concurrent readers now use `SingleFlight` from
|
||||
`proton-media-rs`, the same code Proton Stream uses. Same behaviour: one
|
||||
download per block, every reader gets its result, and a reader whose fetch was
|
||||
cancelled downloads the block itself.
|
||||
- The shared Gallery engine now comes from the `proton-gallery-rs` and
|
||||
`proton-gallery-app-rs` crates on crates.io instead of a pinned Git revision of
|
||||
Proton Gallery. Builds, vendoring and the Nix package no longer fetch from Git.
|
||||
- RAW+JPEG grouping, Google Takeout reading, EXIF capture times, look-alike
|
||||
detection and the offline town lookup now come from `proton-gallery-rs`,
|
||||
shared with Proton Gallery. No behaviour change.
|
||||
- The keyring code (one Secret Service connection that reconnects after the provider
|
||||
restarts, B285, and replacing the session item instead of editing it, B291) now comes
|
||||
from `proton-auth-rs`, shared with Proton Gallery and Proton Stream. No behaviour change.
|
||||
- Config, machine-id and mount-failure files are written through `proton-base-rs`'s
|
||||
atomic writer (temporary file, sync, rename, directory sync). The mount-failure file
|
||||
is now synced before the rename too, so a crash cannot leave it empty.
|
||||
|
||||
### Fixed
|
||||
|
||||
- A large trash listed only its first items and never refreshed, and Empty Trash
|
||||
never emptied it (B293). Needs proton-drive-rs 0.12.5.
|
||||
|
||||
## [3.9.0] — 2026-11-19
|
||||
|
||||
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
|
||||
|
||||
+3
-2
@@ -70,7 +70,7 @@ The script runs `pdfs` from `PATH` on every Tab, so it keeps working after an up
|
||||
| `pdfs login [-u EMAIL] [--remember]` | Sign in (password, then a 2FA code if the account has one) and store the session in the system keyring. Restarts the service if it is running. `--remember` keeps a two-password account unlocked across logins. |
|
||||
| `pdfs unlock [--remember]` | Enter the mailbox password of a two-password account, so the service can open your files. Needed once per login session, or once with `--remember`. |
|
||||
| `pdfs lock` | Forget the unlock held in memory; the account is locked again. |
|
||||
| `pdfs logout` | End the session on Proton and remove the stored session. |
|
||||
| `pdfs logout [--yes]` | End the session on Proton and remove the stored session. Asks first while changes are still queued; they stay on this computer and are sent after the next sign-in. |
|
||||
| `pdfs status` | Account, mount, queue and cache state. |
|
||||
| `pdfs quota` | Storage used across all Proton products. |
|
||||
| `pdfs locations` | Every local place the service occupies: the Proton Drive folder and each synced folder, with mode and state. |
|
||||
@@ -125,6 +125,7 @@ commands are for scripts and for cases where the mount is not available.
|
||||
| `pdfs sync ignore check PATH` | Say whether a file in a synced folder is synced, and which pattern decides. |
|
||||
| `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. |
|
||||
| `pdfs sync queue` | List changes that have not reached Proton Drive yet. |
|
||||
| `pdfs sync flush [--timeout SECS]` | Retry failed changes now and wait until the queue is empty. Exits 0 when everything is on Proton Drive, 3 when what is left needs you (see `sync issues`), 4 on timeout. Says so while sync is paused or offline. |
|
||||
| `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. |
|
||||
| `pdfs sync export ID DEST` | Save a copy of a queued upload's content. `DEST` may be a folder; an existing file is never overwritten. The upload stays queued. |
|
||||
| `pdfs sync discard ID [--yes]` | Drop a queued change and undo it here: a new file or folder goes, anything else goes back to what Proton Drive has. Content not exported first is lost. |
|
||||
@@ -153,7 +154,7 @@ commands are for scripts and for cases where the mount is not available.
|
||||
|
||||
| Command | Description |
|
||||
|---|---|
|
||||
| `pdfs trash` | List the Trash with the UIDs the next commands take. |
|
||||
| `pdfs trash` | List the Trash with the UIDs the next commands take. `--by-folder` groups it by original folder; `--folder UID` lists a deleted folder. |
|
||||
| `pdfs restore UIDS...` | Put items back where they were. |
|
||||
| `pdfs delete-forever UIDS...` | Delete items permanently. |
|
||||
| `pdfs empty-trash` | Delete everything in the Trash permanently. |
|
||||
|
||||
+9
-2
@@ -71,13 +71,20 @@ terminal: `pdfs copy PATH... NEW_PARENT`.
|
||||
## Trash
|
||||
|
||||
Deleted files go to the Trash, both from `~/ProtonDrive` and from the app. The **Trash** page
|
||||
lists them with the date they were deleted.
|
||||
shows the folders things were deleted from, with how many items each holds and when the last
|
||||
one went. Open a folder to see what was deleted from it, and open a deleted folder to see what
|
||||
it held. The folder button in the header switches to one list of everything, newest deletion
|
||||
first, and the search box finds an item anywhere in the Trash by name.
|
||||
|
||||
- **Restore** puts an item back where it was, together with any trashed folders above it.
|
||||
- **Delete Forever** and **Empty Trash** are permanent.
|
||||
|
||||
- Restore or delete a whole folder row to act on everything deleted from that folder.
|
||||
|
||||
From a terminal: `pdfs trash` lists the Trash with an ID for each item, and `pdfs restore`,
|
||||
`pdfs delete-forever` and `pdfs empty-trash` take those IDs.
|
||||
`pdfs delete-forever` and `pdfs empty-trash` take those IDs. `pdfs trash --by-folder` groups the
|
||||
list by the folder each item was deleted from, and `pdfs trash --folder ID` shows what a deleted
|
||||
folder holds.
|
||||
|
||||
## Earlier versions of a file
|
||||
|
||||
|
||||
@@ -360,8 +360,12 @@ git clone https://github.com/narrrl/proton-drive-linux.git
|
||||
cd proton-drive-linux
|
||||
cargo build --release --locked
|
||||
po/build.sh target/locale # optional: compile the translations
|
||||
scripts/fetch-basemap.sh # optional: the offline Places map, into data/
|
||||
```
|
||||
|
||||
Install `data/basemap-v1.pmtiles` as `~/.local/share/proton-drive-linux/basemap-v1.pmtiles`, or
|
||||
point `PDFS_BASEMAP` at it. Without it Places shows coarse outlines only.
|
||||
|
||||
The four programs are in `target/release/`: `pdfs`, `pdfs-app`, `pdfs-tray` and `pdfs-prompt`.
|
||||
|
||||
### Build a package from the working tree
|
||||
@@ -376,6 +380,7 @@ cd packaging && makepkg -fi
|
||||
|
||||
```bash
|
||||
sudo dnf install -y rpm-build
|
||||
scripts/fetch-basemap.sh
|
||||
rpmbuild -bb packaging/proton-drive-linux.spec \
|
||||
--define "git_dir $PWD" \
|
||||
--define "_rpmdir $PWD/packaging/out" \
|
||||
|
||||
+6
-3
@@ -68,11 +68,14 @@ albums, and add or remove photos. Deleting an album keeps its photos in the time
|
||||
|
||||
**Places** groups photos by the town they were taken in, as cards or on a map. Town names come
|
||||
from [GeoNames](https://www.geonames.org/) data (CC BY 4.0) and the map from
|
||||
[Natural Earth](https://www.naturalearthdata.com/) (public domain). Both ship with the app, so
|
||||
nothing is fetched online.
|
||||
[Natural Earth](https://www.naturalearthdata.com/) (public domain): seas by depth, lakes, rivers,
|
||||
built-up areas, borders and town names, in light and dark. Both ship with the app as
|
||||
`/usr/share/proton-drive-linux/basemap-v1.pmtiles`, so nothing is fetched online. Without that file,
|
||||
for example in a build from source that skipped `scripts/fetch-basemap.sh`, the map shows coarse
|
||||
land outlines only. `PDFS_BASEMAP` points the app at another copy.
|
||||
|
||||
A street map from [OpenFreeMap](https://openfreemap.org/) (© OpenStreetMap contributors) can be
|
||||
turned on under **Preferences → General → Appearance**. It is off by default, because the map
|
||||
turned on instead under **Preferences → General → Appearance**. It is off by default, because the map
|
||||
server learns which areas you look at.
|
||||
|
||||
## Viewer and duplicates
|
||||
|
||||
+2
-2
@@ -43,7 +43,7 @@ them along.
|
||||
|
||||
| Item | State | Notes |
|
||||
|---|---|---|
|
||||
| Protect queued changes at shutdown | Not started | A systemd inhibitor lock while `staging/` holds unsent data, a warning when signing out, and a `pdfs sync flush` that waits for the queue. Today the queue is visible in `pdfs sync queue`, the tray and **Sync → Overview**, but nothing stops a shutdown (B66) |
|
||||
| Protect queued changes at shutdown | Done, live check owed | The daemon holds a logind shutdown inhibitor while the queue holds changes it can send, signing out warns with the count, and `pdfs sync flush` waits for the queue (B66) |
|
||||
| Restore pins from the machine profile | Not started | `profile.json` records pins; `pdfs sync restore` does not apply them yet |
|
||||
| Profile backup health | Not started | A failed profile upload is a `WARN` in the log and nothing in the app (B68) |
|
||||
| Rotated credentials survive a keyring failure | Open | Report and retry keyring write failures, so a rotated single-use refresh token is not lost (B61) |
|
||||
@@ -63,7 +63,7 @@ them along.
|
||||
| Add someone else's photo to your album | Blocked | Needs `copyPhoto` in the SDK |
|
||||
| Photo name search | Not started | Photos search by date and filters only |
|
||||
| Automatic photo upload from a folder | Not started | |
|
||||
| Faster Google Photos import | Not started | Uploads run one at a time. Trash folders of locales missing from `TRASH_FOLDERS` import as photos |
|
||||
| Faster Google Photos import | Partly done | Two uploads run at once. Trash folders of locales missing from `TRASH_FOLDERS` import as photos |
|
||||
| More of a Google Photos export | Not started | `.tgz` exports and extracted folders; shared albums told apart from own ones; album descriptions and covers; photo descriptions |
|
||||
| Content-addressed block cache | Idea | Store blocks by hash to deduplicate identical content |
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 283 KiB After Width: | Height: | Size: 702 KiB |
+5
-1
@@ -16,7 +16,7 @@ arch=('x86_64')
|
||||
url="https://proton-drive.narl.io"
|
||||
license=('MIT')
|
||||
depends=('fuse3' 'polkit' 'gtk4' 'libadwaita' 'webkitgtk-6.0' 'perl-image-exiftool')
|
||||
makedepends=('cargo' 'git' 'gettext')
|
||||
makedepends=('cargo' 'git' 'gettext' 'curl')
|
||||
provides=('pdfs')
|
||||
# Files-on-demand mount + keyring need these at runtime.
|
||||
optdepends=('gnome-keyring: credential storage via Secret Service'
|
||||
@@ -80,6 +80,10 @@ package() {
|
||||
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
|
||||
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
|
||||
|
||||
# The offline Places basemap, fetched and checked against its pinned
|
||||
# SHA-256 by scripts/fetch-basemap.sh.
|
||||
scripts/fetch-basemap.sh "$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations: compiled from po/ into /usr/share/locale.
|
||||
po/build.sh "$pkgdir/usr/share/locale"
|
||||
|
||||
|
||||
@@ -49,6 +49,10 @@ package() {
|
||||
install -Dm644 lib/systemd/user/proton-drive.service \
|
||||
"$pkgdir/usr/lib/systemd/user/proton-drive.service"
|
||||
|
||||
# The offline Places basemap.
|
||||
install -Dm644 share/proton-drive-linux/basemap-v1.pmtiles \
|
||||
"$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations and shell completion for bash, zsh and fish.
|
||||
install -dm755 "$pkgdir/usr/share"
|
||||
cp -r --no-preserve=ownership share/locale share/bash-completion share/zsh share/fish \
|
||||
|
||||
@@ -25,8 +25,10 @@ conflicts=('proton-drive-linux' 'proton-drive-for-linux' 'proton-drive-for-linux
|
||||
options=('!lto')
|
||||
# Stops the running daemon before removal, so the mount stops mirroring deletes.
|
||||
install=proton-drive.install
|
||||
source=("$pkgname::git+$_repo.git")
|
||||
sha256sums=('SKIP')
|
||||
source=("$pkgname::git+$_repo.git"
|
||||
"basemap-v1.pmtiles::https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles")
|
||||
sha256sums=('SKIP'
|
||||
'ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280')
|
||||
|
||||
pkgver() {
|
||||
cd "$pkgname"
|
||||
@@ -81,6 +83,10 @@ package() {
|
||||
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
|
||||
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
|
||||
|
||||
# The offline Places basemap.
|
||||
install -Dm644 "$srcdir/basemap-v1.pmtiles" \
|
||||
"$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations: compiled from po/ into /usr/share/locale.
|
||||
po/build.sh "$pkgdir/usr/share/locale"
|
||||
|
||||
|
||||
@@ -25,8 +25,10 @@ conflicts=('proton-drive-linux' 'proton-drive-for-linux-bin' 'proton-drive-for-l
|
||||
options=('!lto')
|
||||
# Stops the running daemon before removal, so the mount stops mirroring deletes.
|
||||
install=proton-drive.install
|
||||
source=("$pkgname-$pkgver.tar.gz::$_repo/archive/refs/tags/v$pkgver.tar.gz")
|
||||
sha256sums=('095186fa108f27ff2b175188bb13466a94cc8ecfd71088df47a41d4d9baa58c1')
|
||||
source=("$pkgname-$pkgver.tar.gz::$_repo/archive/refs/tags/v$pkgver.tar.gz"
|
||||
"basemap-v1.pmtiles::https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles")
|
||||
sha256sums=('095186fa108f27ff2b175188bb13466a94cc8ecfd71088df47a41d4d9baa58c1'
|
||||
'ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280')
|
||||
|
||||
_srcname="proton-drive-linux-$pkgver"
|
||||
|
||||
@@ -76,6 +78,10 @@ package() {
|
||||
install -Dm644 "packaging/io.narl.proton-drive-linux.policy" \
|
||||
"$pkgdir/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy"
|
||||
|
||||
# The offline Places basemap.
|
||||
install -Dm644 "$srcdir/basemap-v1.pmtiles" \
|
||||
"$pkgdir/usr/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
|
||||
# Translations: compiled from po/ into /usr/share/locale.
|
||||
po/build.sh "$pkgdir/usr/share/locale"
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
{
|
||||
lib,
|
||||
rustPlatform,
|
||||
fetchurl,
|
||||
adwaita-icon-theme,
|
||||
pkg-config,
|
||||
gettext,
|
||||
@@ -23,6 +24,11 @@
|
||||
|
||||
let
|
||||
cargoToml = lib.importTOML ../../Cargo.toml;
|
||||
# The offline Places basemap, as scripts/fetch-basemap.sh pins it.
|
||||
basemap = fetchurl {
|
||||
url = "https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles";
|
||||
sha256 = "ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280";
|
||||
};
|
||||
in
|
||||
rustPlatform.buildRustPackage {
|
||||
pname = "proton-drive-linux";
|
||||
@@ -46,10 +52,7 @@ rustPlatform.buildRustPackage {
|
||||
];
|
||||
};
|
||||
|
||||
cargoLock = {
|
||||
lockFile = ../../Cargo.lock;
|
||||
allowBuiltinFetchGit = true;
|
||||
};
|
||||
cargoLock.lockFile = ../../Cargo.lock;
|
||||
|
||||
cargoBuildFlags = [
|
||||
"--bin"
|
||||
@@ -119,6 +122,7 @@ rustPlatform.buildRustPackage {
|
||||
packaging/completions.sh $out/bin/pdfs $out/share
|
||||
|
||||
# Nix brings new releases, so the app never checks for them itself.
|
||||
install -Dm644 ${basemap} $out/share/proton-drive-linux/basemap-v1.pmtiles
|
||||
install -Dm644 /dev/null $out/share/proton-drive-linux/managed-updates
|
||||
'';
|
||||
|
||||
|
||||
@@ -25,7 +25,10 @@ ExclusiveArch: x86_64
|
||||
%if 0%{!?git_dir:1}
|
||||
Source0: %{forge}/archive/refs/tags/v%{version}.tar.gz#/%{name}-%{version}.tar.gz
|
||||
Source1: %{forge}/releases/download/v%{version}/%{name}-vendor-%{version}.tar.xz
|
||||
# The offline Places basemap, checked against its pinned SHA-256 in %%prep.
|
||||
Source2: https://github.com/narrrl/proton-rs/releases/download/basemap-v1/basemap-v1.pmtiles
|
||||
%endif
|
||||
%global basemap_sha256 ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280
|
||||
|
||||
BuildRequires: cargo
|
||||
BuildRequires: rust >= 1.96
|
||||
@@ -75,6 +78,7 @@ cp -a %{git_dir}/LICENSE .
|
||||
%else
|
||||
# -a 1 unpacks the vendored crates and their source mappings.
|
||||
%autosetup -n %{name}-%{version} -a 1
|
||||
echo "%{basemap_sha256} %{SOURCE2}" | sha256sum --check --quiet
|
||||
# Older vendor tarballs contained only crates.io dependencies.
|
||||
if [ ! -f .cargo/config.toml ]; then
|
||||
mkdir -p .cargo
|
||||
@@ -119,6 +123,14 @@ install -D -m0644 %{src}/packaging/io.narl.proton-drive-linux.policy \
|
||||
%{buildroot}/usr/share/polkit-1/actions/io.narl.proton-drive-linux.policy
|
||||
install -D -m0644 %{src}/packaging/proton-drive.service \
|
||||
%{buildroot}/usr/lib/systemd/user/proton-drive.service
|
||||
%if 0%{?git_dir:1}
|
||||
# scripts/fetch-basemap.sh puts it here for in-tree builds.
|
||||
basemap=%{git_dir}/data/basemap-v1.pmtiles
|
||||
%else
|
||||
basemap=%{SOURCE2}
|
||||
%endif
|
||||
echo "%{basemap_sha256} $basemap" | sha256sum --check --quiet
|
||||
install -D -m0644 "$basemap" %{buildroot}%{_datadir}/proton-drive-linux/basemap-v1.pmtiles
|
||||
%{src}/po/build.sh %{buildroot}%{_datadir}/locale
|
||||
%{src}/packaging/completions.sh "$rel/pdfs" %{buildroot}%{_datadir}
|
||||
%if 0%{!?git_dir:1}
|
||||
@@ -160,6 +172,8 @@ fi
|
||||
%{_datadir}/bash-completion/completions/pdfs
|
||||
%{_datadir}/zsh/site-functions/_pdfs
|
||||
%{_datadir}/fish/vendor_completions.d/pdfs.fish
|
||||
%dir %{_datadir}/proton-drive-linux
|
||||
%{_datadir}/proton-drive-linux/basemap-v1.pmtiles
|
||||
%if 0%{!?git_dir:1}
|
||||
%{_datadir}/proton-drive-linux/managed-updates
|
||||
%endif
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#!/usr/bin/env bash
|
||||
# Lay out the release tarball: built binaries, desktop files, icon, user
|
||||
# service, translations, shell completions and install.sh, under one top-level
|
||||
# service, the Places basemap, translations, shell completions and install.sh, under one top-level
|
||||
# directory with a /usr-like tree, then pack it.
|
||||
#
|
||||
# usage: packaging/tarball/build.sh <binary dir> <version> <output dir>
|
||||
@@ -37,6 +37,11 @@ install -Dm644 "$repo/packaging/io.narl.proton-drive-linux.policy" \
|
||||
install -Dm644 "$repo/packaging/proton-drive.service" \
|
||||
"$root/lib/systemd/user/proton-drive.service"
|
||||
install -Dm644 "$repo/LICENSE" "$root/share/licenses/proton-drive-linux/LICENSE"
|
||||
# The offline Places basemap, fetched once into data/ and checked against
|
||||
# its pinned SHA-256.
|
||||
"$repo/scripts/fetch-basemap.sh"
|
||||
install -Dm644 "$repo/data/basemap-v1.pmtiles" \
|
||||
"$root/share/proton-drive-linux/basemap-v1.pmtiles"
|
||||
"$repo/po/build.sh" "$root/share/locale"
|
||||
"$repo/packaging/completions.sh" "$root/bin/pdfs" "$root/share"
|
||||
install -Dm755 "$repo/packaging/tarball/install.sh" "$root/install.sh"
|
||||
|
||||
@@ -40,6 +40,7 @@ grep -qx "ExecStart=\"$prefix/bin/pdfs\" daemon" "$unit" || fail "ExecStart= was
|
||||
[ -f "$prefix/share/locale/de/LC_MESSAGES/pdfs.mo" ] || fail "no translations"
|
||||
[ -f "$prefix/share/icons/hicolor/scalable/apps/io.narl.proton-drive-linux.svg" ] || fail "no icon"
|
||||
[ -f "$prefix/share/bash-completion/completions/pdfs" ] || fail "no bash completion"
|
||||
[ -f "$prefix/share/proton-drive-linux/basemap-v1.pmtiles" ] || fail "no Places basemap"
|
||||
[ ! -e "$prefix/share/proton-drive-linux/managed-updates" ] || fail "the update check must stay on offer"
|
||||
uninstaller="$prefix/share/proton-drive-linux/install.sh"
|
||||
[ -x "$uninstaller" ] || fail "install.sh was not kept for --uninstall"
|
||||
|
||||
+841
-654
File diff suppressed because it is too large.
Load diff
+814
-631
File diff suppressed because it is too large.
Load diff
+839
-650
File diff suppressed because it is too large.
Load diff
Executable
+23
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env bash
|
||||
# Download the offline Places basemap built by proton-rs's `basemap` tool,
|
||||
# checked against its pinned SHA-256. Without it the map shows coarse
|
||||
# outlines only.
|
||||
set -euo pipefail
|
||||
root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
|
||||
name=basemap-v1.pmtiles
|
||||
url=https://github.com/narrrl/proton-rs/releases/download/basemap-v1/$name
|
||||
sha256=ce9acab1b7ed7f15b23e2365b1b6a580db79f4bc4421851ee673eff4c920d280
|
||||
out=${1:-$root/data/$name}
|
||||
if [[ -f $out ]] && echo "$sha256 $out" | sha256sum --check --status; then
|
||||
exit 0
|
||||
fi
|
||||
mkdir -p "$(dirname -- "$out")"
|
||||
part=$(mktemp "$out.XXXXXX")
|
||||
trap 'rm -f -- "$part"' EXIT
|
||||
curl --fail --location --silent --show-error --retry 3 --output "$part" "$url"
|
||||
echo "$sha256 $part" | sha256sum --check --status || {
|
||||
echo "The downloaded $name doesn't match its pinned checksum." >&2
|
||||
exit 1
|
||||
}
|
||||
chmod 644 "$part"
|
||||
mv -- "$part" "$out"
|
||||
@@ -17,7 +17,7 @@ Options:
|
||||
--only LIST capture only these, comma-separated (default: all of
|
||||
login,files,photos,photos_map,computers,sync,conflicts,
|
||||
prompt_gtk,prompt_fzf). preferences_sync and
|
||||
preferences_apps exist too, for pull requests only
|
||||
preferences_apps and trash exist too, for pull requests only
|
||||
--website DIR afterwards, copy them into the website checkout at DIR
|
||||
with its scripts/sync-screenshots.sh
|
||||
--settle SECS how long a page gets to load before its capture (default 3)
|
||||
@@ -37,7 +37,7 @@ EOF
|
||||
repo="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
|
||||
all=login,files,photos,photos_map,computers,sync,conflicts,prompt_gtk,prompt_fzf
|
||||
# Not in the README, so not taken by default.
|
||||
extra=preferences_sync,preferences_apps
|
||||
extra=preferences_sync,preferences_apps,trash
|
||||
|
||||
# The capture itself, run by cage inside the throwaway session (see below).
|
||||
if [[ "${1:-}" == --capture ]]; then
|
||||
@@ -82,7 +82,7 @@ if [[ "${1:-}" == --capture ]]; then
|
||||
sleep "$SETTLE"
|
||||
for shot in files:browser photos:gallery photos_map:places-map computers:devices \
|
||||
sync:sync-folders conflicts:activity \
|
||||
preferences_sync:preferences-sync preferences_apps:preferences-apps; do
|
||||
preferences_sync:preferences-sync preferences_apps:preferences-apps trash:trash; do
|
||||
name=${shot%%:*}
|
||||
wants "$name" || continue
|
||||
"$BIN/pdfs-app" --page "${shot#*:}"
|
||||
@@ -233,6 +233,9 @@ printf '[Settings]\ngtk-decoration-layout=:close\n' >"$root/config/gtk-4.0/setti
|
||||
home=/home/alex
|
||||
[[ -e "$home" ]] && home="$root/home"
|
||||
|
||||
# The offline Places basemap, as the packages install it.
|
||||
"$repo/scripts/fetch-basemap.sh"
|
||||
|
||||
outer_bus=${DBUS_SESSION_BUS_ADDRESS:-unset}
|
||||
env -i \
|
||||
PATH="$PATH" LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8 TZ="${TZ:-Europe/Berlin}" \
|
||||
@@ -241,6 +244,7 @@ env -i \
|
||||
XDG_CACHE_HOME="$root/cache" XDG_DATA_HOME="$root/data" \
|
||||
XDG_RUNTIME_DIR="$root/run" \
|
||||
PDFS_DEMO_ROOT="$root" PDFS_DEMO_OUTER_BUS="$outer_bus" \
|
||||
PDFS_BASEMAP="$repo/data/basemap-v1.pmtiles" \
|
||||
GSETTINGS_BACKEND=memory ADW_DEBUG_COLOR_SCHEME=prefer-dark GTK_A11Y=none GDK_DEBUG=no-portals \
|
||||
BIN="$bin" PHOTOS="$photos" OUT="$out" SHOTS="$shots" SETTLE="$settle" \
|
||||
dbus-run-session -- "$repo/scripts/screenshots.sh" --session 2>"$root/session.log"
|
||||
|
||||
Reference in new issue
Block a user