mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-21 18:23:48 +01:00
Compare commits
24
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2ad0bad09c | ||
|
|
ca20e5ed22 | ||
|
|
10bc9a6a37 | ||
|
|
890adbc189 | ||
|
|
960c6afe2d | ||
|
|
1b545ba369 | ||
|
|
b854c1e819 | ||
|
|
3fbe651f94 | ||
|
|
08e0e80f34 | ||
|
|
0488ccd5f6 | ||
|
|
62d16e03cf | ||
|
|
c92f78b5c8 | ||
|
|
b034e1d4e3 | ||
|
|
e15e1dcc76 | ||
|
|
43b76d4791 | ||
|
|
734e9040fb | ||
|
|
01e3860741 | ||
|
|
7a65e7011f | ||
|
|
233d9e9e51 | ||
|
|
73c4e1f6bf | ||
|
|
26272cda6c | ||
|
|
370abd58dc | ||
|
|
24594b24ae | ||
|
|
04f0713012 |
No files matched your search
Generated
+143
-72
@@ -182,6 +182,17 @@ version = "1.0.104"
|
|||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
|
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]]
|
[[package]]
|
||||||
name = "arbitrary"
|
name = "arbitrary"
|
||||||
version = "1.5.0"
|
version = "1.5.0"
|
||||||
@@ -3618,23 +3629,23 @@ dependencies = [
|
|||||||
"dbus-secret-service-keyring-store",
|
"dbus-secret-service-keyring-store",
|
||||||
"directories",
|
"directories",
|
||||||
"ignore",
|
"ignore",
|
||||||
"kamadak-exif",
|
|
||||||
"keyring-core",
|
"keyring-core",
|
||||||
"libc",
|
"libc",
|
||||||
"parking_lot 0.13.0",
|
"parking_lot 0.13.0",
|
||||||
|
"proton-auth-rs",
|
||||||
|
"proton-base-rs",
|
||||||
"proton-drive-rs",
|
"proton-drive-rs",
|
||||||
|
"proton-gallery-rs",
|
||||||
"proton-sdk",
|
"proton-sdk",
|
||||||
"rusqlite",
|
"rusqlite",
|
||||||
"serde",
|
"serde",
|
||||||
"serde_json",
|
"serde_json",
|
||||||
"sha1 0.11.0",
|
|
||||||
"sha2 0.11.1",
|
"sha2 0.11.1",
|
||||||
"shell-words",
|
"shell-words",
|
||||||
"thiserror 2.0.21",
|
"thiserror 2.0.21",
|
||||||
"tokio",
|
"tokio",
|
||||||
"tracing",
|
"tracing",
|
||||||
"zeroize",
|
"zeroize",
|
||||||
"zip",
|
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
@@ -3655,9 +3666,10 @@ dependencies = [
|
|||||||
"notify",
|
"notify",
|
||||||
"parking_lot 0.13.0",
|
"parking_lot 0.13.0",
|
||||||
"pdfs-core",
|
"pdfs-core",
|
||||||
"pg-app",
|
|
||||||
"pg-core",
|
|
||||||
"proton-drive-rs",
|
"proton-drive-rs",
|
||||||
|
"proton-gallery-app-rs",
|
||||||
|
"proton-gallery-rs",
|
||||||
|
"proton-media-rs",
|
||||||
"rustix",
|
"rustix",
|
||||||
"serde",
|
"serde",
|
||||||
"serde_json",
|
"serde_json",
|
||||||
@@ -3683,7 +3695,7 @@ dependencies = [
|
|||||||
"libadwaita",
|
"libadwaita",
|
||||||
"pangocairo",
|
"pangocairo",
|
||||||
"pdfs-core",
|
"pdfs-core",
|
||||||
"pg-core",
|
"proton-gallery-rs",
|
||||||
"reqwest",
|
"reqwest",
|
||||||
"serde",
|
"serde",
|
||||||
"serde_json",
|
"serde_json",
|
||||||
@@ -3708,65 +3720,6 @@ version = "2.3.2"
|
|||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
|
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]]
|
[[package]]
|
||||||
name = "pgp"
|
name = "pgp"
|
||||||
version = "0.21.0"
|
version = "0.21.0"
|
||||||
@@ -3972,10 +3925,36 @@ dependencies = [
|
|||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "proton-drive-rs"
|
name = "proton-auth-rs"
|
||||||
version = "0.12.1"
|
version = "0.1.1"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
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.2"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "bdeb7ee7495bc34198c78d7ec569f6371ad01a88f188b5eee418b013b082626a"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"async-trait",
|
"async-trait",
|
||||||
"base64 0.23.1",
|
"base64 0.23.1",
|
||||||
@@ -4000,10 +3979,89 @@ dependencies = [
|
|||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "proton-sdk"
|
name = "proton-gallery-app-rs"
|
||||||
version = "0.12.1"
|
version = "0.1.0"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "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.1"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "dc9c9bbb76a5fba4071ee90de4aada71c292c0e408024ddfb04a12869291404a"
|
||||||
|
dependencies = [
|
||||||
|
"aes-gcm 0.11.1",
|
||||||
|
"async-trait",
|
||||||
|
"getrandom 0.4.3",
|
||||||
|
"hex",
|
||||||
|
"kamadak-exif",
|
||||||
|
"rusqlite",
|
||||||
|
"serde",
|
||||||
|
"serde_json",
|
||||||
|
"sha2 0.11.1",
|
||||||
|
"tempfile",
|
||||||
|
"thiserror 2.0.21",
|
||||||
|
"tokio",
|
||||||
|
"tokio-util",
|
||||||
|
"tracing",
|
||||||
|
"zeroize",
|
||||||
|
"zip",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "proton-media-rs"
|
||||||
|
version = "0.1.1"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "f03aa6c403e4f2f7a8f9a444dff1e268d8bc9bcaf1d0d953cc3a1312d798f1ef"
|
||||||
|
dependencies = [
|
||||||
|
"lru",
|
||||||
|
"sha2 0.11.1",
|
||||||
|
"thiserror 2.0.21",
|
||||||
|
"tokio",
|
||||||
|
"tracing",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "proton-sdk"
|
||||||
|
version = "0.12.2"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
checksum = "3189873dcdf0bc0a3d0fa5619cea80594085252d1d66a57459ec6adfd1f35ac1"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"aes-gcm 0.11.1",
|
"aes-gcm 0.11.1",
|
||||||
"async-trait",
|
"async-trait",
|
||||||
@@ -5139,7 +5197,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||||||
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"fastrand",
|
"fastrand",
|
||||||
"getrandom 0.3.4",
|
"getrandom 0.4.3",
|
||||||
"once_cell",
|
"once_cell",
|
||||||
"rustix",
|
"rustix",
|
||||||
"windows-sys 0.61.2",
|
"windows-sys 0.61.2",
|
||||||
@@ -5857,6 +5915,19 @@ version = "0.2.1"
|
|||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
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]]
|
[[package]]
|
||||||
name = "windows-result"
|
name = "windows-result"
|
||||||
version = "0.4.1"
|
version = "0.4.1"
|
||||||
|
|||||||
+9
-4
@@ -15,10 +15,10 @@ keywords = ["proton", "drive", "fuse", "sync", "linux"]
|
|||||||
categories = ["filesystem", "command-line-utilities"]
|
categories = ["filesystem", "command-line-utilities"]
|
||||||
|
|
||||||
[workspace.dependencies]
|
[workspace.dependencies]
|
||||||
proton-sdk = { version = "0.12.1" }
|
proton-sdk = { version = "0.12.2" }
|
||||||
proton-drive-rs = { version = "0.12.1" }
|
proton-drive-rs = { version = "0.12.2" }
|
||||||
pg-app = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" }
|
proton-gallery-app-rs = "0.1.0"
|
||||||
pg-core = { git = "https://github.com/narrrl/proton-gallery.git", rev = "858d2446f71214ec5357eb8b543d6b82abf47386" }
|
proton-gallery-rs = "0.1.1"
|
||||||
chrono = { version = "0.4", default-features = false, features = ["std"] }
|
chrono = { version = "0.4", default-features = false, features = ["std"] }
|
||||||
|
|
||||||
# Internal crates.
|
# Internal crates.
|
||||||
@@ -63,6 +63,11 @@ rusqlite = { version = "0.41", features = ["bundled"] }
|
|||||||
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and
|
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and
|
||||||
# with no `target` it matches items v3 wrote, so existing logins survive.
|
# with no `target` it matches items v3 wrote, so existing logins survive.
|
||||||
keyring-core = "1"
|
keyring-core = "1"
|
||||||
|
# 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"] }
|
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
|
||||||
# The same Secret Service client the store wraps, used directly to replace an
|
# The same Secret Service client the store wraps, used directly to replace an
|
||||||
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
|
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
|
||||||
|
|||||||
@@ -12,6 +12,7 @@ description = "Core auth/session/config for the Proton Drive Linux client"
|
|||||||
[dependencies]
|
[dependencies]
|
||||||
proton-sdk.workspace = true
|
proton-sdk.workspace = true
|
||||||
proton-drive-rs.workspace = true
|
proton-drive-rs.workspace = true
|
||||||
|
proton-gallery-rs.workspace = true
|
||||||
chrono.workspace = true
|
chrono.workspace = true
|
||||||
tokio.workspace = true
|
tokio.workspace = true
|
||||||
serde.workspace = true
|
serde.workspace = true
|
||||||
@@ -22,10 +23,10 @@ directories.workspace = true
|
|||||||
ignore.workspace = true
|
ignore.workspace = true
|
||||||
shell-words.workspace = true
|
shell-words.workspace = true
|
||||||
sha2.workspace = true
|
sha2.workspace = true
|
||||||
sha1.workspace = true
|
|
||||||
zip.workspace = true
|
|
||||||
rusqlite.workspace = true
|
rusqlite.workspace = true
|
||||||
keyring-core.workspace = true
|
keyring-core.workspace = true
|
||||||
|
proton-auth-rs = { workspace = true, features = ["keyring"] }
|
||||||
|
proton-base-rs.workspace = true
|
||||||
dbus-secret-service-keyring-store.workspace = true
|
dbus-secret-service-keyring-store.workspace = true
|
||||||
dbus-secret-service.workspace = true
|
dbus-secret-service.workspace = true
|
||||||
parking_lot.workspace = true
|
parking_lot.workspace = true
|
||||||
@@ -33,4 +34,3 @@ async-trait.workspace = true
|
|||||||
libc.workspace = true
|
libc.workspace = true
|
||||||
zeroize.workspace = true
|
zeroize.workspace = true
|
||||||
base64.workspace = true
|
base64.workspace = true
|
||||||
exif = { version = "0.6", package = "kamadak-exif" }
|
|
||||||
File diff suppressed because it is too large.
Load diff
@@ -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
|
|
||||||
|
+105
-170
@@ -28,6 +28,7 @@ use std::time::Duration;
|
|||||||
use base64::Engine as _;
|
use base64::Engine as _;
|
||||||
use base64::engine::general_purpose::STANDARD as BASE64;
|
use base64::engine::general_purpose::STANDARD as BASE64;
|
||||||
use keyring_core::Entry;
|
use keyring_core::Entry;
|
||||||
|
use proton_auth_rs::{KeyringStore, SecretStore};
|
||||||
use proton_drive_rs::{KeySalt, ProtonDriveClient};
|
use proton_drive_rs::{KeySalt, ProtonDriveClient};
|
||||||
use proton_sdk::account::KeyPassphrases;
|
use proton_sdk::account::KeyPassphrases;
|
||||||
use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
|
use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
|
||||||
@@ -35,6 +36,7 @@ use proton_sdk::cache::EncryptedCacheRepository;
|
|||||||
use proton_sdk::config::ProtonClientConfiguration;
|
use proton_sdk::config::ProtonClientConfiguration;
|
||||||
use proton_sdk::error::ProtonError;
|
use proton_sdk::error::ProtonError;
|
||||||
use proton_sdk::http::Tokens;
|
use proton_sdk::http::Tokens;
|
||||||
|
use proton_sdk::login::{self, LoginError, Step};
|
||||||
use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters};
|
use proton_sdk::session::{PasswordMode, ProtonApiSession, ResumeParameters};
|
||||||
use proton_sdk::telemetry::TracingTelemetry;
|
use proton_sdk::telemetry::TracingTelemetry;
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
@@ -125,82 +127,28 @@ fn client_config() -> ProtonClientConfiguration {
|
|||||||
|
|
||||||
/// Run `op` on the session's keyring entry.
|
/// Run `op` on the session's keyring entry.
|
||||||
fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
|
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
|
/// The process's keyring, connected on first use.
|
||||||
/// Service fails the call.
|
|
||||||
///
|
///
|
||||||
/// The store holds one D-Bus connection and one Secret Service session for the
|
/// One connection for the whole process; when the Secret Service fails it
|
||||||
/// whole process. The session lives in the provider's memory: once the provider
|
/// (a restarted provider forgets the session, `docs/BUGS.md` B285), the call
|
||||||
/// restarts (oo7's unit restarts it on failure, and both oo7 and gnome-keyring
|
/// reconnects and is made once more. A changed session replaces its item
|
||||||
/// can be `--replace`d), every read and write on the old session fails with
|
/// instead of editing it (B291). Both live in `proton-auth-rs`.
|
||||||
/// `NoSession`, for as long as this process runs. A daemon then keeps refreshed
|
fn keyring() -> &'static KeyringStore {
|
||||||
/// tokens only in memory, and a cold boot loses them (`docs/BUGS.md` B285). A
|
static STORE: std::sync::OnceLock<KeyringStore> = std::sync::OnceLock::new();
|
||||||
/// platform failure therefore drops the store, and the call is made once more
|
STORE.get_or_init(|| {
|
||||||
/// on a new one. A locked keyring, a dismissed prompt or a missing entry is
|
#[cfg(not(test))]
|
||||||
/// not the connection's fault and comes back as it is.
|
{
|
||||||
fn with_keyring_entry<T>(
|
KeyringStore::new(KEYRING_SERVICE)
|
||||||
service: &str,
|
|
||||||
user: &str,
|
|
||||||
op: impl Fn(&Entry) -> keyring_core::Result<T>,
|
|
||||||
) -> Result<T> {
|
|
||||||
let store = keyring_store()?;
|
|
||||||
match op(&Entry::new(service, user)?) {
|
|
||||||
Err(keyring_core::Error::PlatformFailure(e)) => {
|
|
||||||
tracing::warn!(
|
|
||||||
error = %e,
|
|
||||||
"the Secret Service failed this process's connection; reconnecting"
|
|
||||||
);
|
|
||||||
drop_keyring_store(&store);
|
|
||||||
keyring_store()?;
|
|
||||||
Ok(op(&Entry::new(service, user)?)?)
|
|
||||||
}
|
}
|
||||||
result => Ok(result?),
|
#[cfg(test)]
|
||||||
}
|
{
|
||||||
}
|
KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store))
|
||||||
|
.replace_items(|| tests::MOCK_STORE.lock().is_none())
|
||||||
/// 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()?),
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// What the user answered when asked for the mailbox password.
|
/// 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_totp: impl Fn() -> Result<String>,
|
||||||
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
|
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
|
||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
let password = Zeroizing::new(password.to_owned());
|
// The sequence is `proton_sdk::login`, shared with the other Proton
|
||||||
let session = ProtonApiSession::begin_verified(
|
// apps. It reads the key salts before unlocking, while this access token
|
||||||
client_config(),
|
// still has the `locked` scope: after its first refresh it never will
|
||||||
username,
|
// again, and without them no later resume can unlock the key chain. See
|
||||||
password.as_bytes(),
|
// `StoredSession::key_salts`.
|
||||||
verification,
|
let mut step = login::begin(client_config(), username, password, verification)
|
||||||
)
|
.await
|
||||||
.await
|
.map_err(sign_in_error)?;
|
||||||
.map_err(classify_verification_gate);
|
let (unlocked, remember) = loop {
|
||||||
let mut session = session?;
|
step = match step {
|
||||||
|
Step::SecondFactor(pending) => {
|
||||||
if session.is_waiting_for_second_factor() {
|
let code = get_totp()?;
|
||||||
let code = get_totp()?;
|
pending.second_factor(&code).await.map_err(sign_in_error)?
|
||||||
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),
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
// 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;
|
let tokens = unlocked.resume_parameters().await;
|
||||||
register_refresh_handler(&session, tokens.refresh_token.clone());
|
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
|
||||||
let stored = StoredSession {
|
let stored = StoredSession {
|
||||||
session_id: session.session_id().as_str().to_owned(),
|
session_id: tokens.session_id.as_str().to_owned(),
|
||||||
username: session.username().to_owned(),
|
username: tokens.username,
|
||||||
user_id: session.user_id().as_str().to_owned(),
|
user_id: tokens.user_id.as_str().to_owned(),
|
||||||
access_token: tokens.access_token,
|
access_token: tokens.access_token,
|
||||||
refresh_token: tokens.refresh_token,
|
refresh_token: tokens.refresh_token,
|
||||||
scopes: session.scopes().to_vec(),
|
scopes: tokens.scopes,
|
||||||
password_mode: match session.password_mode() {
|
password_mode: tokens.password_mode.to_wire() as u8,
|
||||||
PasswordMode::Single => 1,
|
|
||||||
PasswordMode::Dual => 2,
|
|
||||||
},
|
|
||||||
mailbox_password: String::new(),
|
mailbox_password: String::new(),
|
||||||
key_salts,
|
key_salts: unlocked.key_salts,
|
||||||
key_passphrases: None,
|
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.
|
/// 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()?)
|
decode(&serde_json::from_slice(secret).ok()?)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Lift a human-verification gate out of the generic API error into the typed
|
/// A failed sign-in step as this crate's error.
|
||||||
/// variant a front-end can act on.
|
|
||||||
///
|
///
|
||||||
/// Only a gate that names a solvable method is converted. A `9001` with no
|
/// A blocked, refused or wrong-code attempt goes back to the Proton error it
|
||||||
/// `Details`, or one offering only `email`/`sms`, stays a plain API error:
|
/// came from, which is what the front-ends word themselves. Only a gate that
|
||||||
/// promoting it would send the UI to open a verification page it cannot
|
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that
|
||||||
/// complete, which reads to the user as a hang rather than a refusal.
|
/// offers only `email`/`sms` stays a plain API error, because sending the UI to
|
||||||
fn classify_verification_gate(e: ProtonError) -> Error {
|
/// open a page it cannot complete reads as a hang rather than a refusal.
|
||||||
let ProtonError::Api(api) = &e else {
|
fn sign_in_error(e: LoginError) -> Error {
|
||||||
return e.into();
|
match e {
|
||||||
};
|
LoginError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
|
||||||
match api.human_verification() {
|
LoginError::SecurityKeyOnly => Error::SecurityKeyOnly,
|
||||||
Some(hv) if hv.supports_captcha() => Error::HumanVerificationRequired(Box::new(hv)),
|
LoginError::Blocked(api) | LoginError::Rejected(api) | LoginError::WrongCode(api) => {
|
||||||
_ => e.into(),
|
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.
|
/// Save `stored` to the keyring.
|
||||||
///
|
///
|
||||||
/// An existing entry is replaced by a new item rather than edited, because
|
/// Save the session. An existing entry is replaced by a new item rather than
|
||||||
/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the
|
/// edited, because oo7 before 0.7.0 keeps an edit only in memory and a reboot
|
||||||
/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the
|
/// brings the spent refresh token back (`docs/BUGS.md` B291).
|
||||||
/// fallback: for the first save, and whenever replacing is not possible.
|
|
||||||
fn write_stored(stored: &StoredSession) -> Result<()> {
|
fn write_stored(stored: &StoredSession) -> Result<()> {
|
||||||
let json = Zeroizing::new(serde_json::to_string(stored)?);
|
let json = Zeroizing::new(serde_json::to_string(stored)?);
|
||||||
if replace_items() {
|
Ok(keyring().set(KEYRING_USER, &json)?)
|
||||||
match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) {
|
|
||||||
crate::secretservice::Replaced::Saved => return Ok(()),
|
|
||||||
crate::secretservice::Replaced::Skipped(why) => {
|
|
||||||
tracing::debug!(%why, "not replacing the keyring item; writing it in place");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
with_keyring(|entry| entry.set_password(&json))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Whether [`write_stored`] talks to the Secret Service directly: always,
|
|
||||||
/// except in tests that use the in-memory store.
|
|
||||||
#[cfg(not(test))]
|
|
||||||
fn replace_items() -> bool {
|
|
||||||
true
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
fn replace_items() -> bool {
|
|
||||||
tests::MOCK_STORE.lock().is_none()
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A short, one-way tag for a refresh token, for the log: enough to tell
|
/// 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();
|
let store: Arc<keyring_core::CredentialStore> = keyring_core::mock::Store::new().unwrap();
|
||||||
*MOCK_STORE.lock() = Some(Arc::clone(&store));
|
*MOCK_STORE.lock() = Some(Arc::clone(&store));
|
||||||
keyring_core::set_default_store(store);
|
keyring_core::set_default_store(store);
|
||||||
|
keyring().disconnect();
|
||||||
turn
|
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(());
|
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
|
||||||
|
|
||||||
/// The in-memory store a reconnect hands out, so it finds the same
|
/// The in-memory store a reconnect hands out, so it finds the same
|
||||||
@@ -1427,7 +1360,8 @@ mod tests {
|
|||||||
let _turn = KEYRING.lock();
|
let _turn = KEYRING.lock();
|
||||||
*MOCK_STORE.lock() = None;
|
*MOCK_STORE.lock() = None;
|
||||||
keyring_core::unset_default_store();
|
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();
|
with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
|
||||||
let status = std::process::Command::new("sh")
|
let status = std::process::Command::new("sh")
|
||||||
@@ -1468,6 +1402,7 @@ mod tests {
|
|||||||
let _turn = KEYRING.lock();
|
let _turn = KEYRING.lock();
|
||||||
*MOCK_STORE.lock() = None;
|
*MOCK_STORE.lock() = None;
|
||||||
keyring_core::unset_default_store();
|
keyring_core::unset_default_store();
|
||||||
|
keyring().disconnect();
|
||||||
|
|
||||||
for refresh in ["r1", "r2", "r3"] {
|
for refresh in ["r1", "r2", "r3"] {
|
||||||
write_stored(&stored_with(refresh)).unwrap();
|
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`.
|
/// [`AppDirs::save_config`] for the file at `path`.
|
||||||
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
|
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
|
||||||
refuse_to_replace_unreadable(path)?;
|
refuse_to_replace_unreadable(path)?;
|
||||||
let parent = path
|
proton_base_rs::atomic::write(path, &serde_json::to_vec_pretty(config)?)?;
|
||||||
.parent()
|
|
||||||
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
|
|
||||||
std::fs::create_dir_all(parent)?;
|
|
||||||
let nonce = std::time::SystemTime::now()
|
|
||||||
.duration_since(std::time::UNIX_EPOCH)
|
|
||||||
.map(|duration| duration.as_nanos())
|
|
||||||
.unwrap_or(0);
|
|
||||||
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
|
|
||||||
use std::os::unix::fs::OpenOptionsExt as _;
|
|
||||||
let mut file = std::fs::OpenOptions::new()
|
|
||||||
.write(true)
|
|
||||||
.create_new(true)
|
|
||||||
.mode(0o600)
|
|
||||||
.open(&tmp)?;
|
|
||||||
use std::io::Write as _;
|
|
||||||
file.write_all(&serde_json::to_vec_pretty(config)?)?;
|
|
||||||
file.sync_all()?;
|
|
||||||
std::fs::rename(&tmp, path)?;
|
|
||||||
std::fs::File::open(parent)?.sync_all()?;
|
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -621,15 +602,8 @@ impl AppDirs {
|
|||||||
use std::io::Read as _;
|
use std::io::Read as _;
|
||||||
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
|
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
|
||||||
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
|
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
|
||||||
let parent = path
|
// Not secret, and other tools may read it; keep it world-readable.
|
||||||
.parent()
|
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?;
|
||||||
.ok_or_else(|| Error::Other("machine id path has no parent".into()))?;
|
|
||||||
std::fs::create_dir_all(parent)?;
|
|
||||||
let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
|
|
||||||
std::fs::write(&tmp, format!("{id}\n"))?;
|
|
||||||
std::fs::File::open(&tmp)?.sync_all()?;
|
|
||||||
std::fs::rename(&tmp, &path)?;
|
|
||||||
std::fs::File::open(parent)?.sync_all()?;
|
|
||||||
Ok(id)
|
Ok(id)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -1740,27 +1740,6 @@ pub enum PhotoKind {
|
|||||||
Raw,
|
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 {
|
impl PhotoKind {
|
||||||
/// Classify a photo from what the daemon knows about it. A recognised
|
/// Classify a photo from what the daemon knows about it. A recognised
|
||||||
/// file-name extension is authoritative — it is reliable even before the
|
/// file-name extension is authoritative — it is reliable even before the
|
||||||
@@ -1768,26 +1747,11 @@ impl PhotoKind {
|
|||||||
/// useless generic — so the media type is only consulted for names that carry
|
/// useless generic — so the media type is only consulted for names that carry
|
||||||
/// no extension we know. Anything still unresolved is a still photo.
|
/// no extension we know. Anything still unresolved is a still photo.
|
||||||
pub fn classify(name: Option<&str>, media_type: Option<&str>) -> PhotoKind {
|
pub fn classify(name: Option<&str>, media_type: Option<&str>) -> PhotoKind {
|
||||||
if let Some(ext) = name
|
match proton_gallery_rs::grouping::MediaClass::classify(name, media_type) {
|
||||||
.and_then(|n| n.rsplit_once('.'))
|
proton_gallery_rs::grouping::MediaClass::Photo => PhotoKind::Photo,
|
||||||
.map(|(_, e)| e.to_ascii_lowercase())
|
proton_gallery_rs::grouping::MediaClass::Video => PhotoKind::Video,
|
||||||
{
|
proton_gallery_rs::grouping::MediaClass::Raw => PhotoKind::Raw,
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
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
|
/// The stable integer this kind is persisted as (see the `kind` column of the
|
||||||
@@ -3196,7 +3160,7 @@ mod tests {
|
|||||||
/// videos back to the expensive whole-file path.
|
/// videos back to the expensive whole-file path.
|
||||||
#[test]
|
#[test]
|
||||||
fn photo_kind_recognises_every_supported_video_extension() {
|
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 lower = format!("movie.{ext}");
|
||||||
let upper = format!("MOVIE.{}", ext.to_ascii_uppercase());
|
let upper = format!("MOVIE.{}", ext.to_ascii_uppercase());
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
|
|||||||
@@ -5,6 +5,8 @@ use rusqlite::{Connection, OptionalExtension, Transaction, params};
|
|||||||
|
|
||||||
use std::collections::{HashMap, HashSet};
|
use std::collections::{HashMap, HashSet};
|
||||||
|
|
||||||
|
use proton_gallery_rs::grouping::{Grouped, group_photos, name_stem};
|
||||||
|
|
||||||
use super::Db;
|
use super::Db;
|
||||||
use crate::Result;
|
use crate::Result;
|
||||||
|
|
||||||
@@ -121,135 +123,6 @@ fn capture_day(conn: &rusqlite::Connection, capture_time: i64) -> Option<String>
|
|||||||
.flatten()
|
.flatten()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The file name without its extension, lowercased — `IMG_1234.CR2` and
|
|
||||||
/// `IMG_1234.JPG` share `img_1234` — with the camera's own part-of-a-shot
|
|
||||||
/// marker removed, so the two files a raw capture writes share a stem too.
|
|
||||||
fn name_stem(name: Option<&str>) -> Option<String> {
|
|
||||||
let name = name?;
|
|
||||||
let stem = match name.rsplit_once('.') {
|
|
||||||
Some((stem, _)) if !stem.is_empty() => stem,
|
|
||||||
_ => name,
|
|
||||||
};
|
|
||||||
let stem = stem.to_ascii_lowercase();
|
|
||||||
Some(strip_shot_marker(&stem).to_string())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Drop a `.RAW-NN.ROLE` marker from a stem.
|
|
||||||
///
|
|
||||||
/// Pixel stores one raw capture as `PXL_20260919_000625670.RAW-01.COVER.jpg`
|
|
||||||
/// and `PXL_20260919_000625670.RAW-02.ORIGINAL.dng`: one shot, two files, two
|
|
||||||
/// stems that differ in exactly the part naming which file of the shot this is.
|
|
||||||
/// Cutting the marker off is what lets rule 2 see the pair. The check is narrow
|
|
||||||
/// on purpose — digits, then a single role word — so an ordinary name that
|
|
||||||
/// happens to contain `.raw-` keeps its stem.
|
|
||||||
fn strip_shot_marker(stem: &str) -> &str {
|
|
||||||
let Some(at) = stem.rfind(".raw-") else {
|
|
||||||
return stem;
|
|
||||||
};
|
|
||||||
let rest = &stem[at + ".raw-".len()..];
|
|
||||||
let Some((index, role)) = rest.split_once('.') else {
|
|
||||||
return stem;
|
|
||||||
};
|
|
||||||
let marked = !index.is_empty()
|
|
||||||
&& index.bytes().all(|b| b.is_ascii_digit())
|
|
||||||
&& !role.is_empty()
|
|
||||||
&& role.bytes().all(|b| b.is_ascii_alphabetic());
|
|
||||||
if marked { &stem[..at] } else { stem }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// One entry of the grouping pass: what rule 2 needs, plus what choosing a
|
|
||||||
/// representative needs.
|
|
||||||
struct Grouped {
|
|
||||||
uid: String,
|
|
||||||
kind: crate::control::PhotoKind,
|
|
||||||
main_uid: Option<String>,
|
|
||||||
day: Option<String>,
|
|
||||||
stem: Option<String>,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Which group each photo belongs to, and which member of it the gallery shows.
|
|
||||||
///
|
|
||||||
/// Precedence, as agreed:
|
|
||||||
///
|
|
||||||
/// 1. The server's own relation — a photo with a `main_photo_uid` joins that
|
|
||||||
/// photo's group. The server knows about live photos and bursts; we do not
|
|
||||||
/// have to guess at them.
|
|
||||||
/// 2. Otherwise, same capture day **and** same file-name stem **and** one of the
|
|
||||||
/// two is a camera raw while the other is not. That is the RAW+JPEG pair a
|
|
||||||
/// camera writes, and the differing-kind clause keeps two JPEGs that happen
|
|
||||||
/// to share a name apart.
|
|
||||||
/// 3. Otherwise the photo is its own group.
|
|
||||||
///
|
|
||||||
/// The representative is the non-raw member when the group has one — a JPEG
|
|
||||||
/// decodes in milliseconds and is what the person expects to see — and the
|
|
||||||
/// earliest member in server order otherwise.
|
|
||||||
fn group_photos(entries: &[Grouped]) -> Vec<String> {
|
|
||||||
let mut parent: Vec<usize> = (0..entries.len()).collect();
|
|
||||||
fn find(parent: &mut [usize], mut i: usize) -> usize {
|
|
||||||
while parent[i] != i {
|
|
||||||
parent[i] = parent[parent[i]];
|
|
||||||
i = parent[i];
|
|
||||||
}
|
|
||||||
i
|
|
||||||
}
|
|
||||||
let union = |parent: &mut [usize], a: usize, b: usize| {
|
|
||||||
let (a, b) = (find(parent, a), find(parent, b));
|
|
||||||
if a != b {
|
|
||||||
parent[b] = a;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
let index: HashMap<&str, usize> = entries
|
|
||||||
.iter()
|
|
||||||
.enumerate()
|
|
||||||
.map(|(i, e)| (e.uid.as_str(), i))
|
|
||||||
.collect();
|
|
||||||
for (i, entry) in entries.iter().enumerate() {
|
|
||||||
if let Some(main) = entry.main_uid.as_deref()
|
|
||||||
&& let Some(&j) = index.get(main)
|
|
||||||
{
|
|
||||||
union(&mut parent, j, i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Rule 2 needs only one pass: everything sharing a day and a stem lands in
|
|
||||||
// the same bucket, and the raw / non-raw split is checked pairwise there.
|
|
||||||
let mut by_name: HashMap<(&str, &str), Vec<usize>> = HashMap::new();
|
|
||||||
for (i, entry) in entries.iter().enumerate() {
|
|
||||||
if let (Some(day), Some(stem)) = (entry.day.as_deref(), entry.stem.as_deref()) {
|
|
||||||
by_name.entry((day, stem)).or_default().push(i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let is_raw = |i: usize| entries[i].kind == crate::control::PhotoKind::Raw;
|
|
||||||
for bucket in by_name.values() {
|
|
||||||
for (n, &i) in bucket.iter().enumerate() {
|
|
||||||
for &j in &bucket[n + 1..] {
|
|
||||||
if is_raw(i) != is_raw(j) {
|
|
||||||
union(&mut parent, i, j);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Representative per root, then the key every member carries.
|
|
||||||
let mut representative: HashMap<usize, usize> = HashMap::new();
|
|
||||||
for i in 0..entries.len() {
|
|
||||||
let root = find(&mut parent, i);
|
|
||||||
match representative.get(&root).copied() {
|
|
||||||
Some(current) if !is_raw(current) || is_raw(i) => {}
|
|
||||||
_ => {
|
|
||||||
representative.insert(root, i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
(0..entries.len())
|
|
||||||
.map(|i| {
|
|
||||||
let root = find(&mut parent, i);
|
|
||||||
entries[representative[&root]].uid.clone()
|
|
||||||
})
|
|
||||||
.collect()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The columns every photo read selects, with the group aggregates joined in.
|
/// The columns every photo read selects, with the group aggregates joined in.
|
||||||
/// `g.n` is how many photos the group holds and `g.raw` whether any of them is a
|
/// `g.n` is how many photos the group holds and `g.raw` whether any of them is a
|
||||||
/// camera raw file — one query rather than a second lookup per tile.
|
/// camera raw file — one query rather than a second lookup per tile.
|
||||||
@@ -483,7 +356,8 @@ impl Db {
|
|||||||
Ok((
|
Ok((
|
||||||
Grouped {
|
Grouped {
|
||||||
uid: r.get(0)?,
|
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)?,
|
main_uid: r.get(2)?,
|
||||||
day: r.get(3)?,
|
day: r.get(3)?,
|
||||||
stem: name_stem(name.as_deref()),
|
stem: name_stem(name.as_deref()),
|
||||||
@@ -640,7 +514,7 @@ impl Db {
|
|||||||
.iter()
|
.iter()
|
||||||
.map(|(row, carried, kind)| Grouped {
|
.map(|(row, carried, kind)| Grouped {
|
||||||
uid: row.uid.clone(),
|
uid: row.uid.clone(),
|
||||||
kind: *kind,
|
raw: *kind == crate::control::PhotoKind::Raw,
|
||||||
main_uid: carried.main_uid.clone(),
|
main_uid: carried.main_uid.clone(),
|
||||||
day: capture_day(&tx, row.capture_time),
|
day: capture_day(&tx, row.capture_time),
|
||||||
stem: name_stem(carried.name.as_deref()),
|
stem: name_stem(carried.name.as_deref()),
|
||||||
|
|||||||
@@ -42,6 +42,13 @@ pub enum Error {
|
|||||||
#[error("that mailbox password does not unlock your account")]
|
#[error("that mailbox password does not unlock your account")]
|
||||||
WrongMailboxPassword,
|
WrongMailboxPassword,
|
||||||
|
|
||||||
|
/// The account's only second factor is a security key, which needs
|
||||||
|
/// WebAuthn. Asking for a code would only fail as a wrong one.
|
||||||
|
#[error(
|
||||||
|
"this account's only second factor is a security key, which pdfs cannot use yet — add an authenticator app in your Proton account settings"
|
||||||
|
)]
|
||||||
|
SecurityKeyOnly,
|
||||||
|
|
||||||
/// The login was gated behind human verification. Not a failure the user can
|
/// The login was gated behind human verification. Not a failure the user can
|
||||||
/// fix by retrying: the challenge has to be solved and the login restarted
|
/// fix by retrying: the challenge has to be solved and the login restarted
|
||||||
/// with the resulting token (see [`auth::login_verified`](crate::auth::login_verified)).
|
/// with the resulting token (see [`auth::login_verified`](crate::auth::login_verified)).
|
||||||
@@ -220,6 +227,7 @@ fn core_kind(e: &Error) -> ErrorKind {
|
|||||||
| Error::ReloginRequired
|
| Error::ReloginRequired
|
||||||
| Error::Locked
|
| Error::Locked
|
||||||
| Error::WrongMailboxPassword
|
| Error::WrongMailboxPassword
|
||||||
|
| Error::SecurityKeyOnly
|
||||||
| Error::HumanVerificationRequired(_) => ErrorKind::Denied,
|
| Error::HumanVerificationRequired(_) => ErrorKind::Denied,
|
||||||
Error::Proton(proton) => proton_kind(proton),
|
Error::Proton(proton) => proton_kind(proton),
|
||||||
_ => ErrorKind::Internal,
|
_ => ErrorKind::Internal,
|
||||||
@@ -347,6 +355,15 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool {
|
|||||||
/// The result every request-serving method in the daemon returns.
|
/// The result every request-serving method in the daemon returns.
|
||||||
pub type CoreResult<T> = std::result::Result<T, CoreError>;
|
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)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
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 control;
|
||||||
pub mod db;
|
pub mod db;
|
||||||
pub mod error;
|
pub mod error;
|
||||||
pub mod exiftime;
|
|
||||||
pub mod kernelkey;
|
pub mod kernelkey;
|
||||||
pub mod keycheck;
|
pub mod keycheck;
|
||||||
pub mod localindex;
|
pub mod localindex;
|
||||||
@@ -19,21 +18,20 @@ pub mod mountfail;
|
|||||||
pub mod mountpoint;
|
pub mod mountpoint;
|
||||||
pub mod mounts;
|
pub mod mounts;
|
||||||
pub mod opener;
|
pub mod opener;
|
||||||
pub mod places;
|
|
||||||
pub mod profile;
|
pub mod profile;
|
||||||
pub mod sdkcache;
|
pub mod sdkcache;
|
||||||
pub mod search;
|
pub mod search;
|
||||||
mod secretservice;
|
|
||||||
pub mod service;
|
pub mod service;
|
||||||
pub mod shell;
|
pub mod shell;
|
||||||
pub mod similar;
|
|
||||||
pub mod syncignore;
|
pub mod syncignore;
|
||||||
pub mod syncroot;
|
pub mod syncroot;
|
||||||
pub mod takeout;
|
|
||||||
pub mod timestamp;
|
pub mod timestamp;
|
||||||
pub mod tray;
|
pub mod tray;
|
||||||
pub mod update;
|
pub mod update;
|
||||||
|
|
||||||
|
// Photo logic shared with Proton Gallery through the proton-rs crates.
|
||||||
|
pub use proton_gallery_rs::{exiftime, places, similar, takeout};
|
||||||
|
|
||||||
pub use access::{Access, access_for, perm_bits};
|
pub use access::{Access, access_for, perm_bits};
|
||||||
pub use error::{CoreError, CoreResult, Error, Result};
|
pub use error::{CoreError, CoreResult, Error, Result};
|
||||||
|
|
||||||
|
|||||||
@@ -40,9 +40,7 @@ pub fn path(state_dir: &Path) -> PathBuf {
|
|||||||
/// and renamed, so a reader never sees half of it.
|
/// and renamed, so a reader never sees half of it.
|
||||||
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
|
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
|
||||||
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
|
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
|
||||||
let tmp = state_dir.join(format!("{FILE_NAME}.tmp"));
|
proton_base_rs::atomic::write_with_mode(&path(state_dir), &json, 0o644)
|
||||||
std::fs::write(&tmp, json)?;
|
|
||||||
std::fs::rename(&tmp, path(state_dir))
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Forget the failure: a mount is up, or a new daemon has started.
|
/// Forget the failure: a mount is up, or a new daemon has started.
|
||||||
|
|||||||
@@ -1,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
|
zip.workspace = true
|
||||||
sha1.workspace = true
|
sha1.workspace = true
|
||||||
proton-drive-rs.workspace = true
|
proton-drive-rs.workspace = true
|
||||||
pg-app.workspace = true
|
proton-gallery-app-rs.workspace = true
|
||||||
pg-core.workspace = true
|
proton-gallery-rs.workspace = true
|
||||||
|
proton-media-rs.workspace = true
|
||||||
hyper = { version = "1", features = ["http1", "server"] }
|
hyper = { version = "1", features = ["http1", "server"] }
|
||||||
hyper-util = { version = "0.1", features = ["tokio"] }
|
hyper-util = { version = "0.1", features = ["tokio"] }
|
||||||
http-body-util = "0.1"
|
http-body-util = "0.1"
|
||||||
|
|||||||
@@ -14,10 +14,10 @@ use pdfs_core::control::{
|
|||||||
GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace, PhotoItem, PhotoKind, Response,
|
GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace, PhotoItem, PhotoKind, Response,
|
||||||
};
|
};
|
||||||
use pdfs_core::{CoreError, CoreResult};
|
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_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 tokio::sync::{Mutex, Notify, OnceCell};
|
||||||
|
|
||||||
use super::{Core, NodeUid, parse_uid};
|
use super::{Core, NodeUid, parse_uid};
|
||||||
@@ -187,8 +187,9 @@ impl Gallery {
|
|||||||
Ok(Arc::new(visibility))
|
Ok(Arc::new(visibility))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn account(&self) -> CoreResult<pg_core::model::AccountId> {
|
fn account(&self) -> CoreResult<proton_gallery_rs::model::AccountId> {
|
||||||
pg_core::model::AccountId::new(self.session.user_id().as_str()).map_err(gallery_error)
|
proton_gallery_rs::model::AccountId::new(self.session.user_id().as_str())
|
||||||
|
.map_err(gallery_error)
|
||||||
}
|
}
|
||||||
|
|
||||||
async fn page(
|
async fn page(
|
||||||
@@ -345,13 +346,15 @@ impl Gallery {
|
|||||||
fn asset(&self, uid: &NodeUid) -> CoreResult<AssetKey> {
|
fn asset(&self, uid: &NodeUid) -> CoreResult<AssetKey> {
|
||||||
Ok(AssetKey {
|
Ok(AssetKey {
|
||||||
account: self.account()?,
|
account: self.account()?,
|
||||||
volume: pg_core::model::VolumeId::new(uid.volume_id.as_str()).map_err(gallery_error)?,
|
volume: proton_gallery_rs::model::VolumeId::new(uid.volume_id.as_str())
|
||||||
node: pg_core::model::NodeId::new(uid.link_id.as_str()).map_err(gallery_error)?,
|
.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 {
|
GalleryAlbum {
|
||||||
place: GalleryPlace {
|
place: GalleryPlace {
|
||||||
gallery: entry.gallery.to_string(),
|
gallery: entry.gallery.to_string(),
|
||||||
@@ -444,7 +447,7 @@ impl Core {
|
|||||||
"Use your Linux sign-in to unlock Hidden albums.",
|
"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.pid.as_raw_nonzero().get() as u32,
|
||||||
peer.uid.as_raw(),
|
peer.uid.as_raw(),
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -11,8 +11,8 @@ use hyper::{
|
|||||||
};
|
};
|
||||||
use hyper_util::rt::TokioIo;
|
use hyper_util::rt::TokioIo;
|
||||||
use pdfs_core::{CoreResult, control::Response as ControlResponse};
|
use pdfs_core::{CoreResult, control::Response as ControlResponse};
|
||||||
use pg_app::video::VideoStream;
|
use proton_gallery_app_rs::video::VideoStream;
|
||||||
use pg_core::CancellationToken;
|
use proton_gallery_rs::CancellationToken;
|
||||||
use tokio::net::TcpListener;
|
use tokio::net::TcpListener;
|
||||||
|
|
||||||
type Body = UnsyncBoxBody<Bytes, io::Error>;
|
type Body = UnsyncBoxBody<Bytes, io::Error>;
|
||||||
|
|||||||
@@ -212,15 +212,12 @@ impl BlockRing {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// The result of fetching one block, shared between everyone who wanted it.
|
/// The result of fetching one block, shared between everyone who wanted it.
|
||||||
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
|
/// Identifies a block *of a revision*: node, validity tag, and the plaintext
|
||||||
/// range the block covers — see [`RingKey`] for why it is the range and not the
|
/// range the block covers — see [`RingKey`] for why it is the range and not the
|
||||||
/// index.
|
/// index.
|
||||||
type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
||||||
|
|
||||||
/// A claim on a block key: who owns the fetch, and where its result is published.
|
|
||||||
type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
|
|
||||||
|
|
||||||
/// Block fetches in flight, so a block is downloaded and decrypted once however
|
/// Block fetches in flight, so a block is downloaded and decrypted once however
|
||||||
/// many readers want it at that moment (audit T1).
|
/// many readers want it at that moment (audit T1).
|
||||||
@@ -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
|
/// for. Without this each of them pays the full round-trip and decrypt and all
|
||||||
/// but one result is discarded — roughly double the bandwidth and CPU in steady
|
/// but one result is discarded — roughly double the bandwidth and CPU in steady
|
||||||
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
|
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
|
||||||
#[derive(Default)]
|
pub(super) type BlockFlight = proton_media_rs::SingleFlight<BlockKey, BlockResult>;
|
||||||
pub(super) struct BlockFlight {
|
|
||||||
inflight: Mutex<HashMap<BlockKey, Claim>>,
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Distinguishes attempts at the same key, so a leader only retires its own.
|
|
||||||
static NEXT_FLIGHT_ID: AtomicU64 = AtomicU64::new(0);
|
|
||||||
|
|
||||||
/// The leader's claim on a key. Retires it on drop — including when the task is
|
|
||||||
/// cancelled mid-fetch, which is what keeps a dropped `JoinSet` from leaving a
|
|
||||||
/// key nobody will ever publish.
|
|
||||||
struct Flight {
|
|
||||||
flight: Arc<BlockFlight>,
|
|
||||||
key: BlockKey,
|
|
||||||
id: u64,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Drop for Flight {
|
|
||||||
fn drop(&mut self) {
|
|
||||||
let mut inflight = self.flight.inflight.lock();
|
|
||||||
if inflight
|
|
||||||
.get(&self.key)
|
|
||||||
.is_some_and(|(id, _)| *id == self.id)
|
|
||||||
{
|
|
||||||
inflight.remove(&self.key);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Where each file's reader is expected to read next, so sequential reads can be
|
/// Where each file's reader is expected to read next, so sequential reads can be
|
||||||
/// told from random ones and only the former prefetched (audit T2).
|
/// told from random ones and only the former prefetched (audit T2).
|
||||||
@@ -581,49 +551,11 @@ impl Core {
|
|||||||
cache_blocks: bool,
|
cache_blocks: bool,
|
||||||
) -> BlockResult {
|
) -> BlockResult {
|
||||||
let key: BlockKey = (uid.clone(), mtime, fsize, span);
|
let key: BlockKey = (uid.clone(), mtime, fsize, span);
|
||||||
let claim = {
|
self.block_flight
|
||||||
let mut inflight = self.block_flight.inflight.lock();
|
.join(key, || {
|
||||||
match inflight.get(&key) {
|
self.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||||
Some((_, rx)) => Err(rx.clone()),
|
})
|
||||||
None => {
|
.await
|
||||||
let id = NEXT_FLIGHT_ID.fetch_add(1, Ordering::Relaxed);
|
|
||||||
let (tx, rx) = tokio::sync::watch::channel(None);
|
|
||||||
inflight.insert(key.clone(), (id, rx));
|
|
||||||
Ok((
|
|
||||||
tx,
|
|
||||||
Flight {
|
|
||||||
flight: self.block_flight.clone(),
|
|
||||||
key: key.clone(),
|
|
||||||
id,
|
|
||||||
},
|
|
||||||
))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
let (tx, flight) = match claim {
|
|
||||||
Ok(lead) => lead,
|
|
||||||
Err(mut rx) => {
|
|
||||||
loop {
|
|
||||||
if let Some(result) = rx.borrow_and_update().clone() {
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
if rx.changed().await.is_err() {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return self
|
|
||||||
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
|
||||||
.await;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
let result = self
|
|
||||||
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
|
||||||
.await;
|
|
||||||
// Retire the claim before publishing, so a racer that wakes and re-enters
|
|
||||||
// finds no stale entry to join.
|
|
||||||
drop(flight);
|
|
||||||
let _ = tx.send(Some(result.clone()));
|
|
||||||
result
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Download and decrypt one block, then put it where the next reader will
|
/// Download and decrypt one block, then put it where the next reader will
|
||||||
|
|||||||
@@ -527,7 +527,7 @@ impl Core {
|
|||||||
let scan = match scan_archives_until(archives, || self.import_should_stop(cancel)) {
|
let scan = match scan_archives_until(archives, || self.import_should_stop(cancel)) {
|
||||||
Ok(scan) => scan,
|
Ok(scan) => scan,
|
||||||
Err(_) if self.import_should_stop(cancel) => return Ok(true),
|
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);
|
*planned = plan(&scan);
|
||||||
*albums = scan.albums.clone();
|
*albums = scan.albums.clone();
|
||||||
|
|||||||
@@ -22,7 +22,7 @@ name = "pdfs-prompt"
|
|||||||
path = "src/prompt.rs"
|
path = "src/prompt.rs"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
pg-core.workspace = true
|
proton-gallery-rs.workspace = true
|
||||||
base64.workspace = true
|
base64.workspace = true
|
||||||
pdfs-core.workspace = true
|
pdfs-core.workspace = true
|
||||||
tracing.workspace = true
|
tracing.workspace = true
|
||||||
|
|||||||
@@ -154,7 +154,6 @@ fn follow_changes(ui: &Rc<Ui>, state: &FeedState, topics: &[Topic]) {
|
|||||||
ui.gallery.decode_queue.borrow_mut().clear();
|
ui.gallery.decode_queue.borrow_mut().clear();
|
||||||
ui.gallery.thumb_wanted.borrow_mut().clear();
|
ui.gallery.thumb_wanted.borrow_mut().clear();
|
||||||
ui.gallery.photo_tex.borrow_mut().clear();
|
ui.gallery.photo_tex.borrow_mut().clear();
|
||||||
ui.gallery.photo_tex_order.borrow_mut().clear();
|
|
||||||
ui.gallery.model.remove_all();
|
ui.gallery.model.remove_all();
|
||||||
ui.gallery.groups.remove_all();
|
ui.gallery.groups.remove_all();
|
||||||
ui.gallery.row_by_photo.borrow_mut().clear();
|
ui.gallery.row_by_photo.borrow_mut().clear();
|
||||||
|
|||||||
@@ -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;
|
pub(crate) mod events;
|
||||||
#[path = "../i18n.rs"]
|
#[path = "../i18n.rs"]
|
||||||
pub(crate) mod i18n;
|
pub(crate) mod i18n;
|
||||||
|
pub(crate) mod lru;
|
||||||
pub(crate) mod pages;
|
pub(crate) mod pages;
|
||||||
pub(crate) mod reload;
|
pub(crate) mod reload;
|
||||||
#[path = "../theme.rs"]
|
#[path = "../theme.rs"]
|
||||||
@@ -15,6 +16,7 @@ pub(crate) mod widgets;
|
|||||||
|
|
||||||
use compat::*;
|
use compat::*;
|
||||||
use events::*;
|
use events::*;
|
||||||
|
use lru::Lru;
|
||||||
use pages::activity::*;
|
use pages::activity::*;
|
||||||
use pages::albums::*;
|
use pages::albums::*;
|
||||||
use pages::browser::*;
|
use pages::browser::*;
|
||||||
@@ -190,16 +192,11 @@ impl Ui {
|
|||||||
/// Scrolling back over a day then repaints from memory rather than decoding
|
/// Scrolling back over a day then repaints from memory rather than decoding
|
||||||
/// the same JPEGs off disk again.
|
/// the same JPEGs off disk again.
|
||||||
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
|
fn store_texture(&self, uid: &str, texture: gtk4::gdk::Texture) {
|
||||||
let mut cache = self.gallery.photo_tex.borrow_mut();
|
let bytes = texture_bytes(texture.width(), texture.height());
|
||||||
let mut order = self.gallery.photo_tex_order.borrow_mut();
|
self.gallery
|
||||||
if cache.insert(uid.to_string(), texture).is_none() {
|
.photo_tex
|
||||||
order.push_back(uid.to_string());
|
.borrow_mut()
|
||||||
}
|
.insert(uid.to_string(), texture, bytes);
|
||||||
while order.len() > TEXTURE_CACHE_MAX {
|
|
||||||
if let Some(old) = order.pop_front() {
|
|
||||||
cache.remove(&old);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles
|
/// Mark a cached thumbnail as freshly used, so eviction takes the tiles
|
||||||
@@ -208,14 +205,7 @@ impl Ui {
|
|||||||
/// Insertion order alone evicts the top of the timeline first — exactly what
|
/// Insertion order alone evicts the top of the timeline first — exactly what
|
||||||
/// a scroll back up then asks for again.
|
/// a scroll back up then asks for again.
|
||||||
fn touch_texture(&self, uid: &str) {
|
fn touch_texture(&self, uid: &str) {
|
||||||
let mut order = self.gallery.photo_tex_order.borrow_mut();
|
self.gallery.photo_tex.borrow_mut().touch(uid);
|
||||||
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());
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -631,8 +621,7 @@ fn build_window(app: &adw::Application) {
|
|||||||
library: Cell::new(true),
|
library: Cell::new(true),
|
||||||
page_waiters: RefCell::new(Vec::new()),
|
page_waiters: RefCell::new(Vec::new()),
|
||||||
width: Cell::new(0),
|
width: Cell::new(0),
|
||||||
photo_tex: RefCell::new(HashMap::new()),
|
photo_tex: RefCell::new(Lru::new(TEXTURE_CACHE_BYTES)),
|
||||||
photo_tex_order: RefCell::new(VecDeque::new()),
|
|
||||||
photo_nothumb: RefCell::new(HashSet::new()),
|
photo_nothumb: RefCell::new(HashSet::new()),
|
||||||
thumb_wanted: RefCell::new(HashMap::new()),
|
thumb_wanted: RefCell::new(HashMap::new()),
|
||||||
thumb_queue: RefCell::new(VecDeque::new()),
|
thumb_queue: RefCell::new(VecDeque::new()),
|
||||||
@@ -640,6 +629,7 @@ fn build_window(app: &adw::Application) {
|
|||||||
thumb_generation: Cell::new(0),
|
thumb_generation: Cell::new(0),
|
||||||
decode_queue: RefCell::new(VecDeque::new()),
|
decode_queue: RefCell::new(VecDeque::new()),
|
||||||
decode_idle: Cell::new(false),
|
decode_idle: Cell::new(false),
|
||||||
|
decode_inflight: RefCell::default(),
|
||||||
thumb_source: RefCell::new(None),
|
thumb_source: RefCell::new(None),
|
||||||
relayout_source: RefCell::new(None),
|
relayout_source: RefCell::new(None),
|
||||||
bound: RefCell::new(BTreeMap::new()),
|
bound: RefCell::new(BTreeMap::new()),
|
||||||
@@ -652,6 +642,7 @@ fn build_window(app: &adw::Application) {
|
|||||||
select_btn: gallery_widgets.select_btn.clone(),
|
select_btn: gallery_widgets.select_btn.clone(),
|
||||||
selection: gallery_widgets.selection.clone(),
|
selection: gallery_widgets.selection.clone(),
|
||||||
more: gallery_widgets.more.clone(),
|
more: gallery_widgets.more.clone(),
|
||||||
|
gallery_actions: gallery_widgets.gallery_actions.clone(),
|
||||||
upload_face: gallery_widgets.upload_face.clone(),
|
upload_face: gallery_widgets.upload_face.clone(),
|
||||||
float_heading: gallery_widgets.float_heading.clone(),
|
float_heading: gallery_widgets.float_heading.clone(),
|
||||||
float_label: gallery_widgets.float_label.clone(),
|
float_label: gallery_widgets.float_label.clone(),
|
||||||
@@ -737,6 +728,10 @@ fn build_window(app: &adw::Application) {
|
|||||||
resume_button: takeout_widgets.resume_button.clone(),
|
resume_button: takeout_widgets.resume_button.clone(),
|
||||||
inflight: Cell::new(false),
|
inflight: Cell::new(false),
|
||||||
running: Cell::new(false),
|
running: Cell::new(false),
|
||||||
|
restored: Cell::new(false),
|
||||||
|
save_seq: Cell::new(0),
|
||||||
|
saved_seq: Default::default(),
|
||||||
|
repaint_seq: Cell::new(0),
|
||||||
},
|
},
|
||||||
update,
|
update,
|
||||||
});
|
});
|
||||||
|
|||||||
@@ -1,10 +1,32 @@
|
|||||||
use crate::*;
|
use crate::*;
|
||||||
use base64::{Engine, engine::general_purpose::STANDARD};
|
use base64::{Engine, engine::general_purpose::STANDARD};
|
||||||
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
|
use pdfs_core::control::{GalleryAction, GalleryAlbum, GalleryFolder, GalleryPlace};
|
||||||
use std::collections::VecDeque;
|
|
||||||
|
|
||||||
const PAGE: usize = 150;
|
const PAGE: usize = 150;
|
||||||
|
/// Decoded thumbnails kept, the least recently shown dropped first.
|
||||||
const THUMB_CACHE: usize = 256;
|
const THUMB_CACHE: usize = 256;
|
||||||
|
/// What a new content width asks of the rows.
|
||||||
|
#[derive(Debug, PartialEq, Eq)]
|
||||||
|
enum Reflow {
|
||||||
|
/// Nothing changed, or there is no width yet.
|
||||||
|
None,
|
||||||
|
/// The first real width: lay the rows out now, nothing is on screen yet.
|
||||||
|
Now,
|
||||||
|
/// A resize: wait for it to settle, since the rows are rebuilt from
|
||||||
|
/// scratch and a drag resizes on every frame.
|
||||||
|
Debounced,
|
||||||
|
}
|
||||||
|
|
||||||
|
fn reflow_for(previous: i32, width: i32) -> Reflow {
|
||||||
|
if width <= 0 || width == previous {
|
||||||
|
Reflow::None
|
||||||
|
} else if previous <= 0 {
|
||||||
|
Reflow::Now
|
||||||
|
} else {
|
||||||
|
Reflow::Debounced
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
type ThumbnailKey = (u64, bool, String);
|
type ThumbnailKey = (u64, bool, String);
|
||||||
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
|
type ThumbnailTarget = (glib::WeakRef<gtk4::Picture>, glib::WeakRef<gtk4::Image>);
|
||||||
|
|
||||||
@@ -45,12 +67,15 @@ pub(crate) struct Browser {
|
|||||||
albums: RefCell<Vec<GalleryAlbum>>,
|
albums: RefCell<Vec<GalleryAlbum>>,
|
||||||
items: RefCell<Vec<PhotoItem>>,
|
items: RefCell<Vec<PhotoItem>>,
|
||||||
width: Cell<i32>,
|
width: Cell<i32>,
|
||||||
|
/// The pending re-flow after a resize, replaced by each new width.
|
||||||
|
reflow: RefCell<Option<glib::SourceId>>,
|
||||||
generation: Cell<u64>,
|
generation: Cell<u64>,
|
||||||
total: Cell<usize>,
|
total: Cell<usize>,
|
||||||
loading: Cell<bool>,
|
loading: Cell<bool>,
|
||||||
unlocked: Cell<bool>,
|
unlocked: Cell<bool>,
|
||||||
thumbnail_slots: tokio::sync::Semaphore,
|
thumbnail_slots: tokio::sync::Semaphore,
|
||||||
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>>>,
|
thumb_pending: RefCell<HashMap<ThumbnailKey, Vec<ThumbnailTarget>>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -86,7 +111,7 @@ impl Browser {
|
|||||||
}
|
}
|
||||||
self.thumbnails
|
self.thumbnails
|
||||||
.borrow_mut()
|
.borrow_mut()
|
||||||
.retain(|(private, _, _)| !private);
|
.retain(|(private, _), _| !private);
|
||||||
self.thumb_pending.borrow_mut().clear();
|
self.thumb_pending.borrow_mut().clear();
|
||||||
self.trail.borrow_mut().clear();
|
self.trail.borrow_mut().clear();
|
||||||
self.chooser.borrow_mut().take();
|
self.chooser.borrow_mut().take();
|
||||||
@@ -552,7 +577,7 @@ impl Browser {
|
|||||||
if self.chooser.borrow().is_some() {
|
if self.chooser.borrow().is_some() {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
let width = (self.width.get() - 24).max(240);
|
let width = self.width.get().max(240);
|
||||||
let columns = ((width + 8) / 216).max(1);
|
let columns = ((width + 8) / 216).max(1);
|
||||||
let card = (width - 8 * (columns - 1)) / columns;
|
let card = (width - 8 * (columns - 1)) / columns;
|
||||||
let mut rows = Vec::new();
|
let mut rows = Vec::new();
|
||||||
@@ -602,6 +627,13 @@ impl Browser {
|
|||||||
let generation = self.generation.get();
|
let generation = self.generation.get();
|
||||||
glib::spawn_future_local(async move {
|
glib::spawn_future_local(async move {
|
||||||
let result = reply.recv().await;
|
let result = reply.recv().await;
|
||||||
|
// Decoded before the checks below, so they see the state after it.
|
||||||
|
let decoded = match &result {
|
||||||
|
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
|
||||||
|
decode_thumbnail_off_thread(data.clone()).await
|
||||||
|
}
|
||||||
|
_ => None,
|
||||||
|
};
|
||||||
let close = |token| {
|
let close = |token| {
|
||||||
let _ = spawn_request(
|
let _ = spawn_request(
|
||||||
browser.ui.dirs.control_socket(),
|
browser.ui.dirs.control_socket(),
|
||||||
@@ -646,8 +678,8 @@ impl Browser {
|
|||||||
picture.set_vexpand(true);
|
picture.set_vexpand(true);
|
||||||
content.append(&picture);
|
content.append(&picture);
|
||||||
}
|
}
|
||||||
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) if private => {
|
Ok(Ok(Response::GalleryThumbnail { data: Some(_) })) if private => {
|
||||||
let Some(texture) = decode_thumbnail(&data) else {
|
let Some(texture) = decoded else {
|
||||||
browser
|
browser
|
||||||
.status
|
.status
|
||||||
.set_label(&gettext("Couldn't open the photo."));
|
.set_label(&gettext("Couldn't open the photo."));
|
||||||
@@ -683,13 +715,15 @@ pub(crate) fn wire(
|
|||||||
hidden: >k4::Button,
|
hidden: >k4::Button,
|
||||||
) {
|
) {
|
||||||
let title = ui.gallery.title.clone();
|
let title = ui.gallery.title.clone();
|
||||||
let header = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
// The page's header bar holds these, beside Select (see `sync_header`).
|
||||||
header.set_halign(gtk4::Align::End);
|
let header = &ui.gallery.gallery_actions;
|
||||||
let choose = gtk4::Button::with_label(&gettext("Add This Folder"));
|
let choose = gtk4::Button::with_label(&gettext("Add This Folder"));
|
||||||
choose.set_visible(false);
|
choose.set_visible(false);
|
||||||
|
choose.add_css_class("suggested-action");
|
||||||
header.append(&choose);
|
header.append(&choose);
|
||||||
let more = gtk4::Button::from_icon_name("view-more-symbolic");
|
let more = gtk4::Button::from_icon_name("view-more-symbolic");
|
||||||
more.set_tooltip_text(Some(&gettext("Gallery Options")));
|
more.set_tooltip_text(Some(&gettext("Gallery Options")));
|
||||||
|
more.add_css_class("flat");
|
||||||
let unlock = gtk4::Button::with_label(&gettext("Unlock"));
|
let unlock = gtk4::Button::with_label(&gettext("Unlock"));
|
||||||
unlock.set_visible(false);
|
unlock.set_visible(false);
|
||||||
header.append(&unlock);
|
header.append(&unlock);
|
||||||
@@ -709,7 +743,6 @@ pub(crate) fn wire(
|
|||||||
let status = gtk4::Label::new(None);
|
let status = gtk4::Label::new(None);
|
||||||
status.set_wrap(true);
|
status.set_wrap(true);
|
||||||
let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
|
let content = gtk4::Box::new(gtk4::Orientation::Vertical, 0);
|
||||||
content.append(&header);
|
|
||||||
content.append(&status);
|
content.append(&status);
|
||||||
content.append(&scroll);
|
content.append(&scroll);
|
||||||
ui.gallery
|
ui.gallery
|
||||||
@@ -743,12 +776,13 @@ pub(crate) fn wire(
|
|||||||
albums: RefCell::new(Vec::new()),
|
albums: RefCell::new(Vec::new()),
|
||||||
items: RefCell::new(Vec::new()),
|
items: RefCell::new(Vec::new()),
|
||||||
width: Cell::new(0),
|
width: Cell::new(0),
|
||||||
|
reflow: RefCell::new(None),
|
||||||
generation: Cell::new(0),
|
generation: Cell::new(0),
|
||||||
total: Cell::new(0),
|
total: Cell::new(0),
|
||||||
loading: Cell::new(false),
|
loading: Cell::new(false),
|
||||||
unlocked: Cell::new(false),
|
unlocked: Cell::new(false),
|
||||||
thumbnail_slots: tokio::sync::Semaphore::new(8),
|
thumbnail_slots: tokio::sync::Semaphore::new(8),
|
||||||
thumbnails: RefCell::default(),
|
thumbnails: RefCell::new(Lru::new(THUMB_CACHE)),
|
||||||
thumb_pending: RefCell::default(),
|
thumb_pending: RefCell::default(),
|
||||||
});
|
});
|
||||||
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
|
*ui.drive_galleries.borrow_mut() = Rc::downgrade(&browser);
|
||||||
@@ -794,12 +828,13 @@ pub(crate) fn wire(
|
|||||||
return;
|
return;
|
||||||
};
|
};
|
||||||
let row = data.borrow::<Row>();
|
let row = data.borrow::<Row>();
|
||||||
|
// The page around the list already keeps its margins, so rows run edge
|
||||||
|
// to edge like the timeline's.
|
||||||
let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
let line = gtk4::Box::new(gtk4::Orientation::Horizontal, 8);
|
||||||
line.set_margin_start(12);
|
|
||||||
line.set_margin_end(12);
|
|
||||||
line.set_margin_bottom(8);
|
line.set_margin_bottom(8);
|
||||||
match &*row {
|
match &*row {
|
||||||
Row::Heading(label) => {
|
Row::Heading(label) => {
|
||||||
|
line.set_margin_top(12);
|
||||||
let label = gtk4::Label::new(Some(label));
|
let label = gtk4::Label::new(Some(label));
|
||||||
label.add_css_class("heading");
|
label.add_css_class("heading");
|
||||||
line.append(&label);
|
line.append(&label);
|
||||||
@@ -841,7 +876,9 @@ pub(crate) fn wire(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
Row::Media(items) => {
|
Row::Media(items) => {
|
||||||
|
// The same gap down as across, as in the timeline.
|
||||||
line.set_spacing(super::photos::TILE_GAP);
|
line.set_spacing(super::photos::TILE_GAP);
|
||||||
|
line.set_margin_bottom(super::photos::TILE_GAP);
|
||||||
for (item, (width, height)) in items {
|
for (item, (width, height)) in items {
|
||||||
let button = tile(
|
let button = tile(
|
||||||
&browser,
|
&browser,
|
||||||
@@ -918,11 +955,6 @@ pub(crate) fn wire(
|
|||||||
let browser = browser.clone();
|
let browser = browser.clone();
|
||||||
move || browser.close()
|
move || browser.close()
|
||||||
});
|
});
|
||||||
} else {
|
|
||||||
menu.item(&gettext("Refresh galleries"), {
|
|
||||||
let browser = browser.clone();
|
|
||||||
move || browser.change(GalleryAction::Refresh)
|
|
||||||
});
|
|
||||||
}
|
}
|
||||||
if let Some(album) = browser.current().filter(|album| !album.proton) {
|
if let Some(album) = browser.current().filter(|album| !album.proton) {
|
||||||
menu.item(&gettext("Choose Cover"), {
|
menu.item(&gettext("Choose Cover"), {
|
||||||
@@ -1000,8 +1032,27 @@ pub(crate) fn wire(
|
|||||||
return glib::ControlFlow::Break;
|
return glib::ControlFlow::Break;
|
||||||
};
|
};
|
||||||
let width = scroll.width();
|
let width = scroll.width();
|
||||||
if width > 0 && browser.width.replace(width) != width {
|
match reflow_for(browser.width.get(), width) {
|
||||||
browser.rebuild();
|
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
|
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()
|
gtk4::gdk::Texture::from_bytes(&glib::Bytes::from_owned(bytes)).ok()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// [`decode_thumbnail`] on gio's blocking pool, so neither the base64 nor the
|
||||||
|
/// image decoder runs on the GTK thread.
|
||||||
|
async fn decode_thumbnail_off_thread(data: String) -> Option<gtk4::gdk::Texture> {
|
||||||
|
gio::spawn_blocking(move || decode_thumbnail(&data))
|
||||||
|
.await
|
||||||
|
.ok()
|
||||||
|
.flatten()
|
||||||
|
}
|
||||||
|
|
||||||
impl Browser {
|
impl Browser {
|
||||||
fn want_thumbnail(
|
fn want_thumbnail(
|
||||||
self: &Rc<Self>,
|
self: &Rc<Self>,
|
||||||
@@ -1100,20 +1160,17 @@ impl Browser {
|
|||||||
if private && !self.unlocked.get() {
|
if private && !self.unlocked.get() {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
{
|
let cached = self
|
||||||
let mut cache = self.thumbnails.borrow_mut();
|
.thumbnails
|
||||||
if let Some(index) = cache
|
.borrow_mut()
|
||||||
.iter()
|
.fetch(&(private, uid.to_owned()))
|
||||||
.position(|(p, id, _)| *p == private && id == uid)
|
.cloned();
|
||||||
{
|
if let Some(texture) = cached {
|
||||||
let cached = cache.remove(index).unwrap();
|
picture.set_paintable(Some(&texture));
|
||||||
picture.set_paintable(Some(&cached.2));
|
if let Some(icon) = icon.upgrade() {
|
||||||
if let Some(icon) = icon.upgrade() {
|
icon.set_visible(false);
|
||||||
icon.set_visible(false);
|
|
||||||
}
|
|
||||||
cache.push_back(cached);
|
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
return;
|
||||||
}
|
}
|
||||||
let key = (self.generation.get(), private, uid.to_owned());
|
let key = (self.generation.get(), private, uid.to_owned());
|
||||||
{
|
{
|
||||||
@@ -1152,6 +1209,12 @@ impl Browser {
|
|||||||
},
|
},
|
||||||
);
|
);
|
||||||
let response = request.recv().await;
|
let response = request.recv().await;
|
||||||
|
let texture = match response {
|
||||||
|
Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) => {
|
||||||
|
decode_thumbnail_off_thread(data).await
|
||||||
|
}
|
||||||
|
_ => None,
|
||||||
|
};
|
||||||
let targets = browser
|
let targets = browser
|
||||||
.thumb_pending
|
.thumb_pending
|
||||||
.borrow_mut()
|
.borrow_mut()
|
||||||
@@ -1160,9 +1223,7 @@ impl Browser {
|
|||||||
if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
|
if key.0 != browser.generation.get() || private && !browser.unlocked.get() {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if let Ok(Ok(Response::GalleryThumbnail { data: Some(data) })) = response
|
if let Some(texture) = texture {
|
||||||
&& let Some(texture) = decode_thumbnail(&data)
|
|
||||||
{
|
|
||||||
for (picture, icon) in targets {
|
for (picture, icon) in targets {
|
||||||
if let Some(picture) = picture.upgrade() {
|
if let Some(picture) = picture.upgrade() {
|
||||||
picture.set_paintable(Some(&texture));
|
picture.set_paintable(Some(&texture));
|
||||||
@@ -1171,12 +1232,27 @@ impl Browser {
|
|||||||
icon.set_visible(false);
|
icon.set_visible(false);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
let mut cache = browser.thumbnails.borrow_mut();
|
// Capped by count, like before: every entry costs one.
|
||||||
if cache.len() >= THUMB_CACHE {
|
browser
|
||||||
cache.pop_front();
|
.thumbnails
|
||||||
}
|
.borrow_mut()
|
||||||
cache.push_back((private, key.2, texture));
|
.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 => {
|
pdfs_core::Error::WrongMailboxPassword => {
|
||||||
gettext("That mailbox password didn't unlock your account.")
|
gettext("That mailbox password didn't unlock your account.")
|
||||||
}
|
}
|
||||||
|
pdfs_core::Error::SecurityKeyOnly => gettext(
|
||||||
|
"This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code.",
|
||||||
|
),
|
||||||
pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
|
pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
|
||||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
|
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
|
||||||
),
|
),
|
||||||
@@ -711,6 +714,9 @@ mod tests {
|
|||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn a_cancelled_prompt_says_which_step_was_skipped() {
|
fn a_cancelled_prompt_says_which_step_was_skipped() {
|
||||||
|
assert!(
|
||||||
|
login_error_message(&pdfs_core::Error::SecurityKeyOnly).contains("authenticator app")
|
||||||
|
);
|
||||||
let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
|
let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
|
||||||
assert!(login_error_message(&totp).contains("two-factor code"));
|
assert!(login_error_message(&totp).contains("two-factor code"));
|
||||||
let hv = pdfs_core::Error::Other("verification cancelled".into());
|
let hv = pdfs_core::Error::Other("verification cancelled".into());
|
||||||
|
|||||||
@@ -160,11 +160,10 @@ pub(crate) struct GalleryState {
|
|||||||
/// Content width the grid is currently laid out to. Updated when the
|
/// Content width the grid is currently laid out to. Updated when the
|
||||||
/// ListView is resized, which re-flows the visible sections.
|
/// ListView is resized, which re-flows the visible sections.
|
||||||
pub(crate) width: Cell<i32>,
|
pub(crate) width: Cell<i32>,
|
||||||
/// Decoded thumbnails by photo uid, with the insertion order that evicts the
|
/// Decoded thumbnails by photo uid, the least recently used evicted once
|
||||||
/// oldest past [`TEXTURE_CACHE_MAX`]. Scrolling back over a day therefore
|
/// their pixels pass [`TEXTURE_CACHE_BYTES`]. Scrolling back over a day
|
||||||
/// repaints from memory instead of re-decoding from disk.
|
/// therefore repaints from memory instead of re-decoding from disk.
|
||||||
pub(crate) photo_tex: RefCell<HashMap<String, gtk4::gdk::Texture>>,
|
pub(crate) photo_tex: RefCell<Lru<String, gtk4::gdk::Texture>>,
|
||||||
pub(crate) photo_tex_order: RefCell<VecDeque<String>>,
|
|
||||||
/// Photos the daemon reported as having no thumbnail at all, so a tile that
|
/// Photos the daemon reported as having no thumbnail at all, so a tile that
|
||||||
/// can never be filled isn't requested again on every scroll past it.
|
/// can never be filled isn't requested again on every scroll past it.
|
||||||
pub(crate) photo_nothumb: RefCell<HashSet<String>>,
|
pub(crate) photo_nothumb: RefCell<HashSet<String>>,
|
||||||
@@ -186,12 +185,14 @@ pub(crate) struct GalleryState {
|
|||||||
pub(crate) thumb_inflight: RefCell<HashSet<String>>,
|
pub(crate) thumb_inflight: RefCell<HashSet<String>>,
|
||||||
pub(crate) thumb_generation: Cell<u64>,
|
pub(crate) thumb_generation: Cell<u64>,
|
||||||
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`.
|
/// Thumbnails on disk waiting to be turned into textures, as `(uid, path)`.
|
||||||
/// Decoding happens on the GTK thread (textures are not `Send`), so it is fed
|
/// [`schedule_decode`] decodes them on worker threads a few at a time, so
|
||||||
/// a few at a time from an idle callback rather than in one blocking burst
|
/// the scroll never waits on a JPEG decoder. [`Self::decode_idle`] is the
|
||||||
/// that would stutter the scroll. [`Self::decode_idle`] is the "callback
|
/// "decoder already running" guard, and [`Self::decode_inflight`] the uids
|
||||||
/// already scheduled" guard.
|
/// 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_queue: RefCell<VecDeque<(String, String)>>,
|
||||||
pub(crate) decode_idle: Cell<bool>,
|
pub(crate) decode_idle: Cell<bool>,
|
||||||
|
pub(crate) decode_inflight: RefCell<HashSet<String>>,
|
||||||
/// Pending debounce timers for the thumbnail queue flush and the section
|
/// Pending debounce timers for the thumbnail queue flush and the section
|
||||||
/// re-flow, replaced on each new trigger so only the last one fires.
|
/// re-flow, replaced on each new trigger so only the last one fires.
|
||||||
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>,
|
pub(crate) thumb_source: RefCell<Option<glib::SourceId>>,
|
||||||
@@ -225,6 +226,9 @@ pub(crate) struct GalleryState {
|
|||||||
/// The header's page menu and the Upload button's face, which drops its
|
/// The header's page menu and the Upload button's face, which drops its
|
||||||
/// label in a narrow window.
|
/// label in a narrow window.
|
||||||
pub(crate) more: gtk4::MenuButton,
|
pub(crate) more: gtk4::MenuButton,
|
||||||
|
/// The header's end slot for an open Drive gallery's own buttons (Add
|
||||||
|
/// This Folder, Unlock, options), filled by the Drive gallery browser.
|
||||||
|
pub(crate) gallery_actions: gtk4::Box,
|
||||||
pub(crate) upload_face: adw::ButtonContent,
|
pub(crate) upload_face: adw::ButtonContent,
|
||||||
/// The section the top of the timeline is in, floating over the grid
|
/// The section the top of the timeline is in, floating over the grid
|
||||||
/// once its own heading has scrolled away.
|
/// once its own heading has scrolled away.
|
||||||
@@ -348,11 +352,23 @@ pub(crate) const THUMB_DEBOUNCE: Duration = Duration::from_millis(60);
|
|||||||
/// in seconds, not milliseconds.
|
/// in seconds, not milliseconds.
|
||||||
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
|
pub(crate) const THUMB_RETRY: Duration = Duration::from_secs(4);
|
||||||
|
|
||||||
/// Decoded thumbnails held in memory, evicted least-recently-*used* first. Each
|
/// Decoded thumbnail pixels held in memory, evicted least-recently-*used*
|
||||||
/// is a few hundred KiB of GPU texture, and at the justified row density 600 was
|
/// first. Budgeted by bytes rather than by count, because one oversized
|
||||||
/// under two screens' worth — a scroll down and back up then had to re-fetch and
|
/// thumbnail costs as much as dozens of ordinary ones. A 512 px thumbnail is
|
||||||
/// re-decode everything it had just shown.
|
/// about 600 KiB decoded, so this holds roughly 900 of them: at the justified
|
||||||
pub(crate) const TEXTURE_CACHE_MAX: usize = 1500;
|
/// 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
|
/// How many tiles beyond the realised rows [`prefetch_thumbs`] warms, so a tile
|
||||||
/// is decoded before it is scrolled onto rather than after.
|
/// is decoded before it is scrolled onto rather than after.
|
||||||
@@ -524,6 +540,7 @@ pub(crate) struct GalleryWidgets {
|
|||||||
pub(crate) select_btn: gtk4::Button,
|
pub(crate) select_btn: gtk4::Button,
|
||||||
pub(crate) selection: SelectionBar,
|
pub(crate) selection: SelectionBar,
|
||||||
pub(crate) more: gtk4::MenuButton,
|
pub(crate) more: gtk4::MenuButton,
|
||||||
|
pub(crate) gallery_actions: gtk4::Box,
|
||||||
pub(crate) upload_face: adw::ButtonContent,
|
pub(crate) upload_face: adw::ButtonContent,
|
||||||
pub(crate) float_heading: gtk4::Revealer,
|
pub(crate) float_heading: gtk4::Revealer,
|
||||||
pub(crate) float_label: gtk4::Label,
|
pub(crate) float_label: gtk4::Label,
|
||||||
@@ -694,6 +711,12 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
|||||||
.build();
|
.build();
|
||||||
more.add_css_class("flat");
|
more.add_css_class("flat");
|
||||||
|
|
||||||
|
// An open Drive gallery's own buttons live in the header too, not in a row
|
||||||
|
// of their own above its grid: that row took height from the photos and
|
||||||
|
// left its button touching the first row of tiles.
|
||||||
|
let gallery_actions = gtk4::Box::new(gtk4::Orientation::Horizontal, 6);
|
||||||
|
gallery_actions.set_visible(false);
|
||||||
|
|
||||||
// Picking photos is a mode: the button enters it, and the header then
|
// Picking photos is a mode: the button enters it, and the header then
|
||||||
// trades the page's own controls for Cancel and a count, as GNOME apps do.
|
// trades the page's own controls for Cancel and a count, as GNOME apps do.
|
||||||
let select_btn = gtk4::Button::builder()
|
let select_btn = gtk4::Button::builder()
|
||||||
@@ -1002,6 +1025,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
|||||||
header.pack_start(&back);
|
header.pack_start(&back);
|
||||||
header.pack_start(&upload);
|
header.pack_start(&upload);
|
||||||
header.pack_end(&more);
|
header.pack_end(&more);
|
||||||
|
header.pack_end(&gallery_actions);
|
||||||
header.pack_end(&select_btn);
|
header.pack_end(&select_btn);
|
||||||
header.pack_end(&selection.cancel);
|
header.pack_end(&selection.cancel);
|
||||||
|
|
||||||
@@ -1031,6 +1055,7 @@ pub(crate) fn build_gallery_page() -> (gtk4::Widget, GalleryWidgets) {
|
|||||||
select_btn,
|
select_btn,
|
||||||
selection,
|
selection,
|
||||||
more,
|
more,
|
||||||
|
gallery_actions,
|
||||||
upload_face,
|
upload_face,
|
||||||
float_heading,
|
float_heading,
|
||||||
float_label,
|
float_label,
|
||||||
@@ -1141,6 +1166,7 @@ pub(crate) fn sync_header(ui: &Rc<Ui>) {
|
|||||||
gallery.back.set_visible(!selecting && collection);
|
gallery.back.set_visible(!selecting && collection);
|
||||||
gallery.upload.set_visible(!selecting && !collection);
|
gallery.upload.set_visible(!selecting && !collection);
|
||||||
gallery.more.set_visible(!selecting && !galleries);
|
gallery.more.set_visible(!selecting && !galleries);
|
||||||
|
gallery.gallery_actions.set_visible(!selecting && galleries);
|
||||||
gallery.select_btn.set_visible(!selecting && timeline);
|
gallery.select_btn.set_visible(!selecting && timeline);
|
||||||
gallery.selection.title.set_visible(selecting);
|
gallery.selection.title.set_visible(selecting);
|
||||||
gallery.selection.cancel.set_visible(selecting);
|
gallery.selection.cancel.set_visible(selecting);
|
||||||
@@ -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
|
/// The shape a photo's tile takes: its own, clamped, or square while the
|
||||||
/// daemon has not seen a thumbnail of it yet.
|
/// daemon has not seen a thumbnail of it yet.
|
||||||
pub(crate) fn tile_ratio(ratio: Option<f64>) -> f64 {
|
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
|
/// 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
|
/// two photos from one day stay two photos at the target height, not two
|
||||||
/// photos as tall as the window.
|
/// photos as tall as the window.
|
||||||
pub(crate) fn plan_justified(ratios: &[f64], width: i32, target: i32) -> Vec<Vec<(i32, i32)>> {
|
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,
|
ratios,
|
||||||
&[],
|
&[],
|
||||||
width.clamp(1, 32_768) as u32,
|
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();
|
let mut decode = ui.gallery.decode_queue.borrow_mut();
|
||||||
if decode.iter().any(|(uid, _)| uid == &photo.uid)
|
if decode.iter().any(|(uid, _)| uid == &photo.uid)
|
||||||
|
|| ui.gallery.decode_inflight.borrow().contains(&photo.uid)
|
||||||
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
|
|| ui.gallery.thumb_inflight.borrow().contains(&photo.uid)
|
||||||
{
|
{
|
||||||
return;
|
return;
|
||||||
@@ -3438,9 +3465,16 @@ fn prefetch_thumbs(ui: &Rc<Ui>, mut batch: Vec<String>) -> Vec<String> {
|
|||||||
batch
|
batch
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Decode queued thumbnails into textures on an idle callback, a few per pass, so
|
/// Decode queued thumbnails into textures on worker threads, a few at a time,
|
||||||
/// a big batch fills in progressively instead of freezing the scroll for the
|
/// and hand each finished texture to the tiles still waiting for it.
|
||||||
/// length of the whole decode.
|
///
|
||||||
|
/// Decoding a JPEG takes milliseconds; four of them per idle pass on the GTK
|
||||||
|
/// thread were enough to stutter a scroll. The main thread now only picks the
|
||||||
|
/// next batch (visible tiles first) and paints what comes back. A batch that
|
||||||
|
/// lands after the timeline was reset is dropped, and a tile that was rebound
|
||||||
|
/// or unbound meanwhile is no longer in [`GalleryState::thumb_wanted`], so it
|
||||||
|
/// is not painted. [`GalleryState::decode_idle`] is the "decoder running"
|
||||||
|
/// guard.
|
||||||
pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
||||||
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
|
if ui.gallery.decode_idle.get() || ui.gallery.decode_queue.borrow().is_empty() {
|
||||||
return;
|
return;
|
||||||
@@ -3448,63 +3482,95 @@ pub(crate) fn schedule_decode(ui: &Rc<Ui>) {
|
|||||||
ui.gallery.decode_idle.set(true);
|
ui.gallery.decode_idle.set(true);
|
||||||
|
|
||||||
let ui = ui.clone();
|
let ui = ui.clone();
|
||||||
glib::idle_add_local(move || {
|
glib::spawn_future_local(async move {
|
||||||
let batch: Vec<(String, String)> = {
|
loop {
|
||||||
let mut queue = ui.gallery.decode_queue.borrow_mut();
|
let batch = next_decode_batch(&ui);
|
||||||
let wanted = ui.gallery.thumb_wanted.borrow();
|
if batch.is_empty() {
|
||||||
let list = &ui.gallery.list;
|
break;
|
||||||
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;
|
|
||||||
}
|
}
|
||||||
let texture = match gtk4::gdk::Texture::from_filename(&path) {
|
let generation = ui.gallery.thumb_generation.get();
|
||||||
Ok(texture) => texture,
|
ui.gallery
|
||||||
Err(e) => {
|
.decode_inflight
|
||||||
tracing::debug!("cannot decode thumbnail {path}: {e}");
|
.borrow_mut()
|
||||||
ui.gallery.photo_nothumb.borrow_mut().insert(uid);
|
.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;
|
continue;
|
||||||
}
|
}
|
||||||
};
|
let texture = match decoded {
|
||||||
ui.store_texture(&uid, texture.clone());
|
Ok(Ok(texture)) => texture,
|
||||||
let waiting = ui.gallery.thumb_wanted.borrow_mut().remove(&uid);
|
Ok(Err(e)) => {
|
||||||
for picture in waiting.into_iter().flatten() {
|
tracing::debug!("cannot decode thumbnail {path}: {e}");
|
||||||
picture.set_paintable(Some(&texture));
|
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));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
ui.gallery.decode_idle.set(false);
|
||||||
if ui.gallery.decode_queue.borrow().is_empty() {
|
|
||||||
ui.gallery.decode_idle.set(false);
|
|
||||||
return glib::ControlFlow::Break;
|
|
||||||
}
|
|
||||||
glib::ControlFlow::Continue
|
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// 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
|
/// 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
|
/// window resize, a zoom step) arrive in floods and only the final state
|
||||||
/// matters.
|
/// matters.
|
||||||
@@ -4774,13 +4840,23 @@ pub(crate) fn gallery_unreachable(ui: &Rc<Ui>) {
|
|||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::{
|
use super::{
|
||||||
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TILE_GAP, TILE_RATIO_MAX,
|
Grouping, PHOTOS_PAGE, ROW_DEFAULT, ROW_MAX, ROW_MIN, ROW_STEP, TEXTURE_CACHE_BYTES,
|
||||||
TILE_RATIO_MIN, active_filters, copy_without_overwrite, empty_timeline_text, grouping_for,
|
TILE_GAP, TILE_RATIO_MAX, TILE_RATIO_MIN, active_filters, copy_without_overwrite,
|
||||||
memory_years, month_index, month_range, plan_grid, plan_justified, section_heading,
|
empty_timeline_text, grouping_for, memory_years, month_index, month_range, plan_grid,
|
||||||
tile_ratio, viewport_unfilled,
|
plan_justified, section_heading, texture_bytes, tile_ratio, viewport_unfilled,
|
||||||
};
|
};
|
||||||
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth};
|
use pdfs_core::control::{PhotoItem, PhotoKind, PhotoMonth};
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn the_texture_cache_is_budgeted_by_decoded_pixels() {
|
||||||
|
assert_eq!(texture_bytes(512, 384), 512 * 384 * 4);
|
||||||
|
// A broken size still costs something, so it can't pile up for free.
|
||||||
|
assert_eq!(texture_bytes(0, 512), 1);
|
||||||
|
assert_eq!(texture_bytes(-1, -1), 1);
|
||||||
|
// Ordinary thumbnails: well over two dense screens' worth fit.
|
||||||
|
assert!(TEXTURE_CACHE_BYTES / texture_bytes(512, 384) >= 600);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
|
fn the_scrubber_finds_the_month_a_photo_was_taken_in() {
|
||||||
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
|
let months = [(2026, 3), (2025, 12), (2025, 11)].map(|(year, month)| PhotoMonth {
|
||||||
|
|||||||
@@ -67,6 +67,11 @@ const COVER_PX: i32 = 128;
|
|||||||
/// How many street-map tiles stay in memory.
|
/// How many street-map tiles stay in memory.
|
||||||
const TILE_CACHE: usize = 160;
|
const TILE_CACHE: usize = 160;
|
||||||
|
|
||||||
|
/// Photo marker covers kept, 64 KiB each. A town's own cover is never
|
||||||
|
/// dropped (it only arrives with the town's card), but the photos zoomed past
|
||||||
|
/// one by one would otherwise pile up for as long as the map is open.
|
||||||
|
const COVER_CACHE: usize = 1024;
|
||||||
|
|
||||||
/// How long a tile that couldn't be had is left alone before it is tried
|
/// How long a tile that couldn't be had is left alone before it is tried
|
||||||
/// again.
|
/// again.
|
||||||
const TILE_RETRY: Duration = Duration::from_secs(60);
|
const TILE_RETRY: Duration = Duration::from_secs(60);
|
||||||
@@ -232,8 +237,11 @@ struct MapState {
|
|||||||
/// for from close up.
|
/// for from close up.
|
||||||
locations: HashMap<u32, Vec<(PhotoItem, World)>>,
|
locations: HashMap<u32, Vec<(PhotoItem, World)>>,
|
||||||
asked_locations: HashSet<u32>,
|
asked_locations: HashSet<u32>,
|
||||||
/// Marker photos, scaled and cropped to a square, by photo uid.
|
/// Marker photos, scaled and cropped to a square, by photo uid, with the
|
||||||
covers: HashMap<String, cairo::ImageSurface>,
|
/// 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>,
|
asked_thumbs: HashSet<String>,
|
||||||
view: View,
|
view: View,
|
||||||
/// False until the view has been fitted to the places at a real size, and
|
/// False until the view has been fitted to the places at a real size, and
|
||||||
@@ -349,6 +357,7 @@ impl PlacesMap {
|
|||||||
locations: HashMap::new(),
|
locations: HashMap::new(),
|
||||||
asked_locations: HashSet::new(),
|
asked_locations: HashSet::new(),
|
||||||
covers: HashMap::new(),
|
covers: HashMap::new(),
|
||||||
|
draws: 0,
|
||||||
asked_thumbs: HashSet::new(),
|
asked_thumbs: HashSet::new(),
|
||||||
view: View {
|
view: View {
|
||||||
center: World { x: 0.5, y: 0.5 },
|
center: World { x: 0.5, y: 0.5 },
|
||||||
@@ -486,7 +495,18 @@ impl PlacesMap {
|
|||||||
let Some(cover) = square_cover(texture) else {
|
let Some(cover) = square_cover(texture) else {
|
||||||
return;
|
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();
|
self.area.queue_draw();
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -840,6 +860,7 @@ impl PlacesMap {
|
|||||||
let mut state = self.state.borrow_mut();
|
let mut state = self.state.borrow_mut();
|
||||||
let state = &mut *state;
|
let state = &mut *state;
|
||||||
let view = state.view;
|
let view = state.view;
|
||||||
|
state.draws += 1;
|
||||||
paint_outline(cr, view, size, colors);
|
paint_outline(cr, view, size, colors);
|
||||||
let labels = match state.online.as_mut() {
|
let labels = match state.online.as_mut() {
|
||||||
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
|
Some(online) => paint_tiles(cr, online, view, size, dark, area.scale_factor()),
|
||||||
@@ -863,7 +884,10 @@ impl PlacesMap {
|
|||||||
}
|
}
|
||||||
for bubble in &state.bubbles {
|
for bubble in &state.bubbles {
|
||||||
let marker = &state.markers[bubble.members[0]];
|
let marker = &state.markers[bubble.members[0]];
|
||||||
let cover = state.covers.get(&marker.cover);
|
let cover = state.covers.get_mut(&marker.cover).map(|(cover, drawn)| {
|
||||||
|
*drawn = state.draws;
|
||||||
|
&*cover
|
||||||
|
});
|
||||||
if cover.is_none()
|
if cover.is_none()
|
||||||
&& let Target::Photo { place, index } = marker.target
|
&& let Target::Photo { place, index } = marker.target
|
||||||
&& state.asked_thumbs.insert(marker.cover.clone())
|
&& state.asked_thumbs.insert(marker.cover.clone())
|
||||||
@@ -1121,6 +1145,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
|
/// Set the names of the tiles on screen, the most important first, leaving
|
||||||
/// out any that would overlap one already set.
|
/// out any that would overlap one already set.
|
||||||
fn paint_labels(
|
fn paint_labels(
|
||||||
@@ -1654,6 +1707,28 @@ fn set_color(cr: &cairo::Context, color: >k4::gdk::RGBA, alpha: f32) {
|
|||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn covers_past_the_cap_drop_the_stalest_photos_but_no_town() {
|
||||||
|
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE as u64 + 3)
|
||||||
|
.map(|n| (format!("p{n}"), ((), n)))
|
||||||
|
.collect();
|
||||||
|
let towns: HashSet<&str> = ["p0"].into_iter().collect();
|
||||||
|
let mut dropped = evict_covers(&mut covers, &towns, COVER_CACHE as u64);
|
||||||
|
dropped.sort();
|
||||||
|
assert_eq!(dropped, ["p1", "p2", "p3"]);
|
||||||
|
assert_eq!(covers.len(), COVER_CACHE);
|
||||||
|
assert!(covers.contains_key("p0"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn covers_drawn_this_frame_are_kept_even_past_the_cap() {
|
||||||
|
let mut covers: HashMap<String, ((), u64)> = (0..COVER_CACHE + 2)
|
||||||
|
.map(|n| (format!("p{n}"), ((), 7)))
|
||||||
|
.collect();
|
||||||
|
assert!(evict_covers(&mut covers, &HashSet::new(), 7).is_empty());
|
||||||
|
assert_eq!(covers.len(), COVER_CACHE + 2);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn projection_puts_the_equator_and_meridian_in_the_middle() {
|
fn projection_puts_the_equator_and_meridian_in_the_middle() {
|
||||||
let p = project(0.0, 0.0);
|
let p = project(0.0, 0.0);
|
||||||
|
|||||||
@@ -52,8 +52,9 @@ fn staged_path(ui: &Rc<Ui>) -> PathBuf {
|
|||||||
|
|
||||||
/// Read the remembered set, dropping any archive that has since been moved or
|
/// Read the remembered set, dropping any archive that has since been moved or
|
||||||
/// deleted — a stale path would only fail at launch, and silently is worse.
|
/// deleted — a stale path would only fail at launch, and silently is worse.
|
||||||
fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
|
/// Blocking: run it off the GTK thread.
|
||||||
let Ok(text) = std::fs::read_to_string(staged_path(ui)) else {
|
fn load_staged(path: &Path) -> Vec<PathBuf> {
|
||||||
|
let Ok(text) = std::fs::read_to_string(path) else {
|
||||||
return Vec::new();
|
return Vec::new();
|
||||||
};
|
};
|
||||||
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
|
let paths: Vec<String> = serde_json::from_str(&text).unwrap_or_default();
|
||||||
@@ -64,9 +65,39 @@ fn load_staged(ui: &Rc<Ui>) -> Vec<PathBuf> {
|
|||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Restore whatever was staged when the window last closed, read on a worker.
|
||||||
|
/// Anything the user staged meanwhile is kept alongside it.
|
||||||
|
fn restore_staged(ui: &Rc<Ui>) {
|
||||||
|
let path = staged_path(ui);
|
||||||
|
let ui = ui.clone();
|
||||||
|
glib::spawn_future_local(async move {
|
||||||
|
let restored = gio::spawn_blocking(move || load_staged(&path))
|
||||||
|
.await
|
||||||
|
.unwrap_or_default();
|
||||||
|
{
|
||||||
|
let mut staged = ui.takeout.archives.borrow_mut();
|
||||||
|
for path in restored {
|
||||||
|
if !staged.contains(&path) {
|
||||||
|
staged.push(path);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
staged.sort();
|
||||||
|
}
|
||||||
|
ui.takeout.restored.set(true);
|
||||||
|
repaint_archives(&ui);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
/// Remember the staged set. Best-effort: failing to write it costs the user a
|
/// Remember the staged set. Best-effort: failing to write it costs the user a
|
||||||
/// re-pick next time, which is not worth interrupting them over now.
|
/// re-pick next time, which is not worth interrupting them over now.
|
||||||
|
///
|
||||||
|
/// Written on a worker. Nothing is written before the remembered set has been
|
||||||
|
/// read back, so the empty list shown meanwhile can't overwrite it, and a
|
||||||
|
/// write that lands after a newer one is skipped.
|
||||||
fn save_staged(ui: &Rc<Ui>) {
|
fn save_staged(ui: &Rc<Ui>) {
|
||||||
|
if !ui.takeout.restored.get() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
let paths: Vec<String> = ui
|
let paths: Vec<String> = ui
|
||||||
.takeout
|
.takeout
|
||||||
.archives
|
.archives
|
||||||
@@ -75,12 +106,24 @@ fn save_staged(ui: &Rc<Ui>) {
|
|||||||
.map(|p| p.display().to_string())
|
.map(|p| p.display().to_string())
|
||||||
.collect();
|
.collect();
|
||||||
let path = staged_path(ui);
|
let path = staged_path(ui);
|
||||||
let written = serde_json::to_string(&paths)
|
let seq = ui.takeout.save_seq.get() + 1;
|
||||||
.map_err(|e| e.to_string())
|
ui.takeout.save_seq.set(seq);
|
||||||
.and_then(|text| std::fs::write(&path, text).map_err(|e| e.to_string()));
|
let saved = ui.takeout.saved_seq.clone();
|
||||||
if let Err(e) = written {
|
gio::spawn_blocking(move || {
|
||||||
tracing::warn!("cannot remember staged Takeout archives: {e}");
|
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 {
|
fn empty_list_description() -> String {
|
||||||
@@ -121,6 +164,16 @@ pub(crate) struct TakeoutState {
|
|||||||
pub(crate) inflight: Cell<bool>,
|
pub(crate) inflight: Cell<bool>,
|
||||||
/// Whether the daemon reported an import running on the last poll.
|
/// Whether the daemon reported an import running on the last poll.
|
||||||
pub(crate) running: Cell<bool>,
|
pub(crate) running: Cell<bool>,
|
||||||
|
/// Whether the remembered staged set has been read back yet; until then
|
||||||
|
/// nothing is saved over it.
|
||||||
|
pub(crate) restored: Cell<bool>,
|
||||||
|
/// The last save started, and the last one written by a worker, so an
|
||||||
|
/// older save that lands late doesn't overwrite a newer one.
|
||||||
|
pub(crate) save_seq: Cell<u64>,
|
||||||
|
pub(crate) saved_seq: std::sync::Arc<std::sync::Mutex<u64>>,
|
||||||
|
/// Bumped by every repaint of the archive list, so the sizes of an older
|
||||||
|
/// list that arrive late are not painted over a newer one.
|
||||||
|
pub(crate) repaint_seq: Cell<u64>,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Widgets the Import page hands back for wiring.
|
/// Widgets the Import page hands back for wiring.
|
||||||
@@ -490,10 +543,10 @@ pub(crate) fn wire_takeout(ui: &Rc<Ui>, widgets: &TakeoutWidgets) {
|
|||||||
.back_button
|
.back_button
|
||||||
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
|
.connect_clicked(move |_| ui_back.stack.set_visible_child_name("gallery"));
|
||||||
|
|
||||||
// Restore whatever was staged when the window last closed, before the first
|
// Restore whatever was staged when the window last closed, so the page
|
||||||
// paint, so the page comes up as the user left it.
|
// comes up as the user left it.
|
||||||
*ui.takeout.archives.borrow_mut() = load_staged(ui);
|
|
||||||
repaint_archives(ui);
|
repaint_archives(ui);
|
||||||
|
restore_staged(ui);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
|
/// Stage `paths`, keeping only `.zip` files and skipping ones already staged.
|
||||||
@@ -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
|
/// the scan reads the archives' central directories, and an extracted tree has
|
||||||
/// none — silently importing half of it would be worse than saying no.
|
/// none — silently importing half of it would be worse than saying no.
|
||||||
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
|
pub(crate) fn add_archives(ui: &Rc<Ui>, paths: Vec<PathBuf>) {
|
||||||
|
// Whether each is a regular file is asked of the filesystem, which may be
|
||||||
|
// a slow network mount: on a worker.
|
||||||
|
let ui = ui.clone();
|
||||||
|
glib::spawn_future_local(async move {
|
||||||
|
let checked = gio::spawn_blocking(move || {
|
||||||
|
paths
|
||||||
|
.into_iter()
|
||||||
|
.map(|path| {
|
||||||
|
let file = path.is_file();
|
||||||
|
(path, file)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap_or_default();
|
||||||
|
stage_archives(&ui, checked);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Stage the archives [`add_archives`] checked, as `(path, is a file)`.
|
||||||
|
fn stage_archives(ui: &Rc<Ui>, paths: Vec<(PathBuf, bool)>) {
|
||||||
let mut added = 0usize;
|
let mut added = 0usize;
|
||||||
let mut rejected = 0usize;
|
let mut rejected = 0usize;
|
||||||
{
|
{
|
||||||
let mut staged = ui.takeout.archives.borrow_mut();
|
let mut staged = ui.takeout.archives.borrow_mut();
|
||||||
for path in paths {
|
for (path, file) in paths {
|
||||||
let is_zip = path
|
let is_zip = path
|
||||||
.extension()
|
.extension()
|
||||||
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
|
.is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
|
||||||
if !is_zip || !path.is_file() {
|
if !is_zip || !file {
|
||||||
rejected += 1;
|
rejected += 1;
|
||||||
continue;
|
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.
|
/// Rebuild the staged-archive list and re-derive which actions are available.
|
||||||
|
///
|
||||||
|
/// The archives' sizes are read on a worker, and the list is rebuilt once
|
||||||
|
/// they are in.
|
||||||
pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
||||||
|
let seq = ui.takeout.repaint_seq.get().wrapping_add(1);
|
||||||
|
ui.takeout.repaint_seq.set(seq);
|
||||||
|
let staged = ui.takeout.archives.borrow().clone();
|
||||||
|
save_staged(ui);
|
||||||
|
sync_takeout_actions(ui);
|
||||||
|
if staged.is_empty() {
|
||||||
|
paint_archives(ui, Vec::new());
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let ui = ui.clone();
|
||||||
|
glib::spawn_future_local(async move {
|
||||||
|
let sized = gio::spawn_blocking(move || {
|
||||||
|
staged
|
||||||
|
.into_iter()
|
||||||
|
.map(|path| {
|
||||||
|
let size = std::fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
|
||||||
|
(path, size)
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
.unwrap_or_default();
|
||||||
|
if ui.takeout.repaint_seq.get() == seq {
|
||||||
|
paint_archives(&ui, sized);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fill the staged-archive list with `staged`, as `(path, size)`.
|
||||||
|
fn paint_archives(ui: &Rc<Ui>, staged: Vec<(PathBuf, u64)>) {
|
||||||
for row in ui.takeout.rows.borrow_mut().drain(..) {
|
for row in ui.takeout.rows.borrow_mut().drain(..) {
|
||||||
ui.takeout.list_group.remove(&row);
|
ui.takeout.list_group.remove(&row);
|
||||||
}
|
}
|
||||||
|
|
||||||
let staged = ui.takeout.archives.borrow().clone();
|
|
||||||
let mut rows: Vec<adw::PreferencesRow> = Vec::new();
|
let mut rows: Vec<adw::PreferencesRow> = Vec::new();
|
||||||
if staged.is_empty() {
|
if staged.is_empty() {
|
||||||
ui.takeout
|
ui.takeout
|
||||||
@@ -558,8 +664,8 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
|||||||
rows.push(row.upcast());
|
rows.push(row.upcast());
|
||||||
} else {
|
} else {
|
||||||
let mut total = 0u64;
|
let mut total = 0u64;
|
||||||
for path in &staged {
|
for (path, size) in &staged {
|
||||||
let size = std::fs::metadata(path).map(|m| m.len()).unwrap_or(0);
|
let size = *size;
|
||||||
total += size;
|
total += size;
|
||||||
let row = adw::ActionRow::builder()
|
let row = adw::ActionRow::builder()
|
||||||
.title(
|
.title(
|
||||||
@@ -601,9 +707,6 @@ pub(crate) fn repaint_archives(ui: &Rc<Ui>) {
|
|||||||
)));
|
)));
|
||||||
}
|
}
|
||||||
*ui.takeout.rows.borrow_mut() = rows;
|
*ui.takeout.rows.borrow_mut() = rows;
|
||||||
|
|
||||||
save_staged(ui);
|
|
||||||
sync_takeout_actions(ui);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Enable exactly the actions that make sense right now: nothing to launch
|
/// Enable exactly the actions that make sense right now: nothing to launch
|
||||||
|
|||||||
+1
-1
@@ -432,7 +432,7 @@ the build Fedora 45 and 46 ship as stable, from before oo7's
|
|||||||
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
|
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
|
||||||
("server: Write item changes to the keyring file"). See
|
("server: Write item changes to the keyring file"). See
|
||||||
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7).
|
[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
|
**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
|
token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
|
||||||
|
|||||||
@@ -11,6 +11,30 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
|
|||||||
|
|
||||||
## [Unreleased]
|
## [Unreleased]
|
||||||
|
|
||||||
|
### Changed
|
||||||
|
|
||||||
|
- Signing in runs through `proton_sdk::login` (proton-sdk 0.12.2), the sequence Proton
|
||||||
|
Gallery and Proton Stream use too. The stored session, the lock/unlock choice for two-password
|
||||||
|
accounts, the three mailbox-password tries and the messages stay as they were.
|
||||||
|
- An account whose only second factor is a security key now gets a clear message at
|
||||||
|
sign-in instead of a code prompt that could only fail.
|
||||||
|
- Block fetches shared by concurrent readers now use `SingleFlight` from
|
||||||
|
`proton-media-rs`, the same code Proton Stream uses. Same behaviour: one
|
||||||
|
download per block, every reader gets its result, and a reader whose fetch was
|
||||||
|
cancelled downloads the block itself.
|
||||||
|
- The shared Gallery engine now comes from the `proton-gallery-rs` and
|
||||||
|
`proton-gallery-app-rs` crates on crates.io instead of a pinned Git revision of
|
||||||
|
Proton Gallery. Builds, vendoring and the Nix package no longer fetch from Git.
|
||||||
|
- RAW+JPEG grouping, Google Takeout reading, EXIF capture times, look-alike
|
||||||
|
detection and the offline town lookup now come from `proton-gallery-rs`,
|
||||||
|
shared with Proton Gallery. No behaviour change.
|
||||||
|
- The keyring code (one Secret Service connection that reconnects after the provider
|
||||||
|
restarts, B285, and replacing the session item instead of editing it, B291) now comes
|
||||||
|
from `proton-auth-rs`, shared with Proton Gallery and Proton Stream. No behaviour change.
|
||||||
|
- Config, machine-id and mount-failure files are written through `proton-base-rs`'s
|
||||||
|
atomic writer (temporary file, sync, rename, directory sync). The mount-failure file
|
||||||
|
is now synced before the rename too, so a crash cannot leave it empty.
|
||||||
|
|
||||||
## [3.9.0] — 2026-11-19
|
## [3.9.0] — 2026-11-19
|
||||||
|
|
||||||
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
|
Schema: **46**. Photos adds a local database migration for incremental metadata sync.
|
||||||
|
|||||||
@@ -46,10 +46,7 @@ rustPlatform.buildRustPackage {
|
|||||||
];
|
];
|
||||||
};
|
};
|
||||||
|
|
||||||
cargoLock = {
|
cargoLock.lockFile = ../../Cargo.lock;
|
||||||
lockFile = ../../Cargo.lock;
|
|
||||||
allowBuiltinFetchGit = true;
|
|
||||||
};
|
|
||||||
|
|
||||||
cargoBuildFlags = [
|
cargoBuildFlags = [
|
||||||
"--bin"
|
"--bin"
|
||||||
|
|||||||
+620
-484
File diff suppressed because it is too large.
Load diff
+604
-475
File diff suppressed because it is too large.
Load diff
+615
-479
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user