Compare commits

...
Author SHA1 Message Date
nvrl 64864562ef fix(core): save the session by replacing its keyring item (#78, B291)
Fedora 45 and 46 ship oo7-daemon 0.7.0~beta^1.e91b98a, which applies
SetSecret only in memory (fixed upstream in 7fb11dd, after that
snapshot). Every token rotation saved there was lost at the next
reboot, and the next start found a spent refresh token.

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

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

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

pdfs-app --page also takes albums, places, places-map and sync-folders,
which the script uses to reach those views.
2026-11-15 19:20:07 +01:00
nvrl 1dcf7c84ca Merge pull request #95 from narrrl/fix/takeout-import-94
fix(fuse,core,gui,cli): resumable, robust Google Photos import (#94)
2026-11-15 17:25:39 +01:00
23 changed files with 1584 additions and 17 deletions

No files matched your search

Generated
+1
View File
@@ -3604,6 +3604,7 @@ dependencies = [
"async-trait", "async-trait",
"base64 0.23.1", "base64 0.23.1",
"chrono", "chrono",
"dbus-secret-service",
"dbus-secret-service-keyring-store", "dbus-secret-service-keyring-store",
"directories", "directories",
"ignore", "ignore",
+3
View File
@@ -60,6 +60,9 @@ rusqlite = { version = "0.41", features = ["bundled"] }
# with no `target` it matches items v3 wrote, so existing logins survive. # with no `target` it matches items v3 wrote, so existing logins survive.
keyring-core = "1" keyring-core = "1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] } dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
dbus-secret-service = { version = "4.1", features = ["crypto-rust"] }
clap = { version = "4", features = ["derive"] } clap = { version = "4", features = ["derive"] }
# `unstable-dynamic`: Tab calls `pdfs` back, so arguments complete from the # `unstable-dynamic`: Tab calls `pdfs` back, so arguments complete from the
# running service. Only `pdfs-cli/src/complete.rs` uses it. # running service. Only `pdfs-cli/src/complete.rs` uses it.
+1
View File
@@ -26,6 +26,7 @@ zip.workspace = true
rusqlite.workspace = true rusqlite.workspace = true
keyring-core.workspace = true keyring-core.workspace = true
dbus-secret-service-keyring-store.workspace = true dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true
parking_lot.workspace = true parking_lot.workspace = true
async-trait.workspace = true async-trait.workspace = true
libc.workspace = true libc.workspace = true
+925
View File
@@ -0,0 +1,925 @@
//! A stand-in daemon that serves made-up data, for the README screenshots.
//!
//! `scripts/screenshots.sh` runs it; see `docs/DEVELOPMENT.md`. It answers the
//! control socket the way the real daemon does, for the requests the captured
//! pages send, with an invented account: no Proton login, no FUSE mount and
//! nothing private. Every name, place and number below is made up.
//!
//! ```text
//! demo_daemon serve <photos-dir> answer the control socket until killed
//! demo_daemon seed-keyring store a fake session, so the app signs in
//! ```
//!
//! Both refuse to run outside a throwaway environment: `PDFS_DEMO_ROOT` must be
//! set and every XDG directory must lie inside it, so the real daemon's socket
//! is never touched (`HOME` may instead name a folder that does not exist, the
//! demo user's, so paths read as theirs), and `seed-keyring` refuses the session bus the script was
//! started on (`PDFS_DEMO_OUTER_BUS`), so the fake session only ever lands in a
//! private keyring.
use std::collections::BTreeMap;
use std::io::{BufRead, BufReader, Write};
use std::os::unix::fs::PermissionsExt;
use std::os::unix::net::{UnixListener, UnixStream};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Duration;
use chrono::{Datelike, Local, TimeZone};
use pdfs_core::cache::Pin;
use pdfs_core::config::{AppDirs, KEYRING_SERVICE};
use pdfs_core::control::{
ActivityEntry, ActivityKind, AlbumInfo, DeviceInfo, DirEntry, Event, LocalHit, PhotoItem,
PhotoKind, PhotoLocation, PhotoMonth, PhotoThumb, PlaceInfo, Request, Response, SearchHit,
SyncFolderInfo, Topic,
};
use pdfs_core::mounts::{MountAccess, MountKind, MountMode, MountSpec};
const USERNAME: &str = "alex.example";
const MOUNTPOINT: &str = "/home/alex/ProtonDrive";
const GIB: u64 = 1 << 30;
const DAY: i64 = 86_400;
/// How many photos the timeline holds. The demo pictures repeat, but not
/// within a screen.
const PHOTOS: usize = 1_840;
fn main() {
if let Err(e) = run() {
eprintln!("demo_daemon: {e}");
std::process::exit(1);
}
}
fn run() -> Result<(), String> {
check_sandbox()?;
let args: Vec<String> = std::env::args().skip(1).collect();
match args.iter().map(String::as_str).collect::<Vec<_>>()[..] {
["serve", photos] => serve(Path::new(photos)),
["seed-keyring"] => seed_keyring(),
_ => Err("usage: demo_daemon serve <photos-dir> | seed-keyring".into()),
}
}
/// Refuse to run anywhere but inside the throwaway root the script made.
fn check_sandbox() -> Result<(), String> {
let root = std::env::var_os("PDFS_DEMO_ROOT")
.map(PathBuf::from)
.ok_or("PDFS_DEMO_ROOT is not set; run scripts/screenshots.sh")?;
let home = std::env::var_os("HOME").map(PathBuf::from);
if home.is_none_or(|home| home.exists() && !home.starts_with(&root)) {
return Err("HOME must lie inside PDFS_DEMO_ROOT or not exist".into());
}
for var in [
"XDG_CONFIG_HOME",
"XDG_STATE_HOME",
"XDG_CACHE_HOME",
"XDG_DATA_HOME",
] {
let inside = std::env::var_os(var)
.map(PathBuf::from)
.is_some_and(|dir| dir.starts_with(&root));
if !inside {
return Err(format!("{var} must lie inside PDFS_DEMO_ROOT"));
}
}
Ok(())
}
/// Store a made-up session where the app looks for one. Its keys "unlock"
/// without a prompt; nothing ever uses them against Proton.
fn seed_keyring() -> Result<(), String> {
let bus = std::env::var("DBUS_SESSION_BUS_ADDRESS").unwrap_or_default();
let outer =
std::env::var("PDFS_DEMO_OUTER_BUS").map_err(|_| "PDFS_DEMO_OUTER_BUS is not set")?;
if bus.is_empty() || bus == outer {
return Err("refusing to write a fake session to your own keyring".into());
}
let session = serde_json::json!({
"session_id": "demo-session",
"username": USERNAME,
"user_id": "demo-user",
"access_token": "demo",
"refresh_token": "demo",
"scopes": ["full", "self", "drive"],
"password_mode": 1,
"key_passphrases": { "demo-key": "ZGVtbw==" },
});
let store: Arc<keyring_core::CredentialStore> =
dbus_secret_service_keyring_store::Store::new().map_err(|e| e.to_string())?;
keyring_core::set_default_store(store);
keyring_core::Entry::new(KEYRING_SERVICE, "session")
.and_then(|entry| entry.set_password(&session.to_string()))
.map_err(|e| e.to_string())
}
fn serve(photos: &Path) -> Result<(), String> {
let demo = Arc::new(Demo::new(photos)?);
let dirs = AppDirs::new().map_err(|e| e.to_string())?;
dirs.ensure().map_err(|e| e.to_string())?;
let socket = dirs.control_socket();
let _ = std::fs::remove_file(&socket);
let listener = UnixListener::bind(&socket).map_err(|e| format!("{}: {e}", socket.display()))?;
std::fs::set_permissions(&socket, std::fs::Permissions::from_mode(0o600))
.map_err(|e| e.to_string())?;
eprintln!("demo_daemon: serving {}", socket.display());
for stream in listener.incoming().flatten() {
let demo = Arc::clone(&demo);
std::thread::spawn(move || {
if let Err(e) = connection(&demo, stream) {
eprintln!("demo_daemon: {e}");
}
});
}
Ok(())
}
fn connection(demo: &Demo, stream: UnixStream) -> std::io::Result<()> {
let mut reader = BufReader::new(stream.try_clone()?);
let mut line = String::new();
reader.read_line(&mut line)?;
let request: Request = match serde_json::from_str(line.trim()) {
Ok(request) => request,
Err(e) => {
eprintln!("demo_daemon: unreadable request: {e}");
return Ok(());
}
};
let mut out = stream;
if matches!(request, Request::Subscribe) {
return subscription(demo, &mut out);
}
send(&mut out, &demo.answer(&request))
}
/// What the real daemon sends a new subscriber, then a heartbeat now and then
/// so the window never counts the daemon as gone.
fn subscription(demo: &Demo, out: &mut UnixStream) -> std::io::Result<()> {
send(out, &Event::Status(Box::new(demo.status())))?;
send(
out,
&Event::Transfers {
items: Vec::new(),
jobs: Vec::new(),
},
)?;
send(
out,
&Event::Changed {
topics: Topic::ALL.to_vec(),
},
)?;
loop {
std::thread::sleep(Duration::from_secs(10));
send(out, &Event::Heartbeat)?;
}
}
fn send(out: &mut UnixStream, value: &impl serde::Serialize) -> std::io::Result<()> {
let mut line = serde_json::to_vec(value)?;
line.push(b'\n');
out.write_all(&line)?;
out.flush()
}
/// One invented account.
struct Demo {
now: i64,
pictures: Vec<PathBuf>,
photos: Vec<PhotoItem>,
/// Each photo's place, by index into [`PLACES`].
place_of: Vec<Option<usize>>,
}
/// Towns the photos were "taken" in: name, ISO country, latitude, longitude.
const PLACES: &[(&str, &str, f64, f64)] = &[
("Lisbon", "PT", 38.7223, -9.1393),
("Porto", "PT", 41.1579, -8.6291),
("Barcelona", "ES", 41.3874, 2.1686),
("Paris", "FR", 48.8566, 2.3522),
("Amsterdam", "NL", 52.3676, 4.9041),
("Copenhagen", "DK", 55.6761, 12.5683),
("Berlin", "DE", 52.5200, 13.4050),
("Prague", "CZ", 50.0755, 14.4378),
("Vienna", "AT", 48.2082, 16.3738),
("Florence", "IT", 43.7696, 11.2558),
("Rome", "IT", 41.9028, 12.4964),
("Thira", "GR", 36.4166, 25.4318),
];
const ALBUMS: &[&str] = &[
"Summer in Portugal",
"Family",
"Hiking",
"Food",
"City trips",
"Best of 2025",
];
impl Demo {
fn new(dir: &Path) -> Result<Self, String> {
let mut pictures: Vec<PathBuf> = std::fs::read_dir(dir)
.map_err(|e| format!("{}: {e}", dir.display()))?
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|ext| ext == "jpg"))
.collect();
pictures.sort();
if pictures.is_empty() {
return Err(format!("no .jpg pictures in {}", dir.display()));
}
let now = Local::now().timestamp();
let mut demo = Demo {
now,
pictures,
photos: Vec::new(),
place_of: Vec::new(),
};
demo.make_photos();
Ok(demo)
}
/// The timeline: newest first, a few a week back three years, plus a
/// photo on this day in each of the last three years.
fn make_photos(&mut self) {
let mut seed = 0x5eed_u64;
let mut next = move || {
seed = seed
.wrapping_mul(6364136223846793005)
.wrapping_add(1442695040888963407);
(seed >> 33) as i64
};
let today = Local::now().date_naive();
let noon = |years_back: i32| {
let day = today
.with_year(today.year() - years_back)
.unwrap_or(today - chrono::Days::new(365 * years_back as u64));
Local
.from_local_datetime(&day.and_hms_opt(11, 30, 0).unwrap_or_default())
.single()
.map_or(0, |t| t.timestamp())
};
// Three years, so a few a day.
let step = 3 * 365 * DAY / PHOTOS as i64;
let mut times: Vec<i64> = (0..PHOTOS as i64)
.map(|i| self.now - 3 * 3600 - i * step - next() % step)
.collect();
times.extend([noon(1), noon(2), noon(3)]);
times.sort_unstable_by(|a, b| b.cmp(a));
for (i, time) in times.into_iter().enumerate() {
let picture = &self.pictures[i % self.pictures.len()];
let kind = match i % 23 {
7 | 15 => PhotoKind::Video,
19 => PhotoKind::Raw,
_ => PhotoKind::Photo,
};
let place = (i % 5 != 4).then_some((i / 7) % PLACES.len());
self.photos.push(PhotoItem {
uid: format!("demo-photos~{i}"),
capture_time: time,
thumb_path: Some(picture.display().to_string()),
name: Some(format!(
"IMG_{}.{}",
20_000 + i,
if kind == PhotoKind::Video {
"MP4"
} else {
"JPG"
}
)),
ratio: Some(if picture.to_string_lossy().ends_with("-p.jpg") {
2.0 / 3.0
} else {
1.5
}),
no_thumb: false,
kind,
favorite: i % 11 == 3,
group_size: 0,
has_raw: kind == PhotoKind::Raw,
place_id: place.map(|p| p as u32 + 1),
});
self.place_of.push(place);
}
}
fn status(&self) -> Response {
Response::Status {
username: USERNAME.into(),
mountpoint: MOUNTPOINT.into(),
pinned: 3,
used: 6 * GIB + 300 * (1 << 20),
budget: 20 * GIB,
pins: self.pins(),
online: true,
pending_uploads: 0,
pending_changes: 0,
parked_uploads: 0,
failing_ops: 0,
failing_error: None,
staged_bytes: 0,
staged_oldest_secs: 0,
paused: false,
paused_until: None,
session_expired: false,
tokens_unsaved: false,
version: env!("CARGO_PKG_VERSION").into(),
}
}
fn answer(&self, request: &Request) -> Response {
match request {
Request::Status => self.status(),
Request::AccountQuota => Response::AccountQuota {
max_space: 500 * GIB as i64,
used_space: 137 * GIB as i64,
},
Request::ListDir { path } => Response::Entries {
entries: self.dir(path),
},
Request::ReserveFileThumbGeneration => Response::FileThumbGeneration { generation: 1 },
Request::FileThumbs { items, .. } => Response::Thumbs {
items: items
.iter()
.map(|item| PhotoThumb {
uid: item.uid.clone(),
path: self.file_picture(&item.uid),
pending: false,
})
.collect(),
},
Request::PhotosTimeline {
offset,
limit,
kind,
favorites,
..
} => {
let items: Vec<PhotoItem> = self
.photos
.iter()
.filter(|p| kind.is_none_or(|k| p.kind == k))
.filter(|p| !favorites || p.favorite)
.skip(*offset)
.take(*limit)
.cloned()
.collect();
Response::Photos {
available: true,
items,
counts: Some(self.counts()),
}
}
Request::PhotoMonths { kind } => Response::PhotoMonths {
months: self.months(*kind),
},
Request::PhotosOnThisDay { .. } => {
let today = Local::now();
let items = self
.photos
.iter()
.filter(|p| {
let at = Local.timestamp_opt(p.capture_time, 0).single();
at.is_some_and(|at| {
at.year() < today.year()
&& at.month() == today.month()
&& at.day() == today.day()
})
})
.cloned()
.collect();
Response::Photos {
available: true,
items,
counts: None,
}
}
Request::PhotoThumbs { uids } => Response::Thumbs {
items: uids
.iter()
.map(|uid| PhotoThumb {
uid: uid.clone(),
path: self
.photos
.iter()
.find(|p| &p.uid == uid)
.and_then(|p| p.thumb_path.clone()),
pending: false,
})
.collect(),
},
Request::PhotoAlbums => Response::Albums {
available: true,
items: self.albums(),
},
Request::AlbumPhotos { uid, offset, limit } => {
let index: usize = uid
.rsplit('~')
.next()
.and_then(|n| n.parse().ok())
.unwrap_or(0);
Response::Photos {
available: true,
items: self
.album_photos(index)
.skip(*offset)
.take(*limit)
.cloned()
.collect(),
counts: None,
}
}
Request::PhotoPlaces => Response::Places {
items: self.places(),
mapping: None,
},
Request::PlaceLocations { id } => Response::PhotoLocations {
items: self.place_locations(*id),
},
Request::PlacePhotos { id, offset, limit } => Response::Photos {
available: true,
items: self
.in_place(*id)
.map(|(_, p)| p)
.skip(*offset)
.take(*limit)
.cloned()
.collect(),
counts: None,
},
Request::ListDevices => Response::Devices {
items: self.devices(),
},
Request::ListSyncFolders => Response::SyncFolders {
items: self.sync_folders(),
},
Request::ListLocations => Response::Locations {
items: self.locations(),
},
// Every conflict in the history is resolved: an open one would
// badge every page.
Request::ListConflicts => Response::Conflicts { items: Vec::new() },
Request::ListPendingOps => Response::PendingOps { items: Vec::new() },
Request::ListActivity { limit } => Response::Activity {
items: self.activity().into_iter().take(*limit).collect(),
},
Request::ListInvitations => Response::Invitations { items: Vec::new() },
Request::ListBookmarks => Response::Bookmarks { items: Vec::new() },
Request::GetQueueStatus => Response::Transfers {
items: Vec::new(),
jobs: Vec::new(),
},
Request::ListPins => Response::Pins { pins: self.pins() },
Request::SearchV2 { query, limit, .. } => Response::SearchResultsV2 {
drive_hits: self.search(query, *limit),
local_hits: self.local_search(query),
local_indexing: false,
},
Request::Search { query, limit, .. } => Response::SearchResults {
hits: self.search(query, *limit),
},
Request::ImportStatus => Response::ImportStatus {
running: false,
summary: None,
progress: None,
resumable: Vec::new(),
},
Request::PhotosRefreshStatus => Response::PhotosRefresh { running: false },
other => {
eprintln!("demo_daemon: no demo answer for {}", request_name(other));
Response::Ok {
message: String::new(),
}
}
}
}
fn counts(&self) -> (usize, usize, usize) {
let of = |kind| self.photos.iter().filter(|p| p.kind == kind).count();
(
of(PhotoKind::Photo),
of(PhotoKind::Video),
of(PhotoKind::Raw),
)
}
fn months(&self, kind: Option<PhotoKind>) -> Vec<PhotoMonth> {
let mut months: BTreeMap<(i32, i32), usize> = BTreeMap::new();
for photo in self
.photos
.iter()
.filter(|p| kind.is_none_or(|k| p.kind == k))
{
if let Some(at) = Local.timestamp_opt(photo.capture_time, 0).single() {
*months.entry((at.year(), at.month() as i32)).or_default() += 1;
}
}
months
.into_iter()
.rev()
.map(|((year, month), count)| PhotoMonth { year, month, count })
.collect()
}
fn albums(&self) -> Vec<AlbumInfo> {
ALBUMS
.iter()
.enumerate()
.map(|(i, name)| AlbumInfo {
uid: format!("demo-album~{i}"),
name: (*name).into(),
photo_count: self.album_photos(i).count(),
cover_uid: self.album_photos(i).next().map(|p| p.uid.clone()),
last_activity: Some(self.now - (i as i64 * 9 + 2) * DAY),
shared: i == 1,
})
.collect()
}
fn album_photos(&self, album: usize) -> impl Iterator<Item = &PhotoItem> {
let stride = 3 + album;
self.photos
.iter()
.skip(album * 2)
.step_by(stride)
.take(40 + album * 17)
}
fn in_place(&self, id: u32) -> impl Iterator<Item = (usize, &PhotoItem)> {
self.photos
.iter()
.enumerate()
.filter(move |(i, _)| self.place_of[*i].is_some_and(|p| p as u32 + 1 == id))
}
fn places(&self) -> Vec<PlaceInfo> {
PLACES
.iter()
.enumerate()
.filter_map(|(i, (name, country, latitude, longitude))| {
let id = i as u32 + 1;
let count = self.in_place(id).count();
let cover = self.in_place(id).next()?.1.clone();
Some(PlaceInfo {
id,
name: (*name).into(),
country: (*country).into(),
latitude: *latitude,
longitude: *longitude,
photo_count: count,
cover,
})
})
.collect()
}
fn place_locations(&self, id: u32) -> Vec<PhotoLocation> {
let Some((_, _, latitude, longitude)) = PLACES.get(id as usize - 1) else {
return Vec::new();
};
self.in_place(id)
.map(|(i, photo)| {
// Spread around the centre, the same way on every run.
let angle = i as f64 * 2.399;
let reach = 0.004 + (i % 9) as f64 * 0.003;
PhotoLocation {
photo: photo.clone(),
latitude: latitude + reach * angle.sin(),
longitude: longitude + reach * angle.cos(),
}
})
.collect()
}
/// My files: folders first, then a few files, some of them pictures with
/// thumbnails. Any folder below the root holds the same few documents.
fn dir(&self, path: &str) -> Vec<DirEntry> {
let folder = |name: &str, days: i64| DirEntry {
name: name.into(),
is_dir: true,
modified: self.now - days * DAY,
uid: format!("demo-files~{path}/{name}"),
path: join(path, name),
..Default::default()
};
let file = |name: &str, size: u64, days: i64| DirEntry {
name: name.into(),
is_dir: false,
size,
modified: self.now - days * DAY - 4000,
uid: format!("demo-files~{path}/{name}"),
path: join(path, name),
..Default::default()
};
if !path.trim_matches('/').is_empty() {
return vec![
file("Notes.md", 4_812, 1),
file("Overview.pdf", 912_384, 6),
file("Budget.ods", 38_112, 12),
];
}
let mut entries = vec![
folder("Documents", 1),
folder("Music", 30),
folder("Pictures", 2),
folder("Projects", 4),
folder("Recipes", 60),
folder("Taxes", 120),
folder("Videos", 14),
folder("Work", 3),
];
let mut pinned = file("Lisbon sunset.jpg", 4_218_112, 20);
pinned.pinned = true;
pinned.cached = true;
entries.extend([
file("Apartment lease.pdf", 1_482_011, 40),
file("Budget 2026.ods", 52_340, 2),
file("Cliffs.jpg", 3_844_201, 33),
file("Garden.jpg", 2_904_877, 9),
pinned,
file("Meeting notes.md", 6_120, 0),
file("Mountain lake.jpg", 5_120_330, 61),
file("Packing list.txt", 1_204, 5),
file("Road trip.jpg", 3_211_008, 75),
file("Thesis draft.odt", 812_448, 18),
]);
entries
}
/// The picture behind a demo file, for its thumbnail.
fn file_picture(&self, uid: &str) -> Option<String> {
let name = uid.rsplit('/').next()?;
if !name.ends_with(".jpg") {
return None;
}
let index = name.bytes().map(usize::from).sum::<usize>() % self.pictures.len();
Some(self.pictures[index].display().to_string())
}
fn pins(&self) -> Vec<Pin> {
[
("Documents", true),
("Work/Quarterly report.odt", false),
("Lisbon sunset.jpg", false),
]
.into_iter()
.map(|(path, dir)| Pin {
uid: format!("demo-files~/{path}"),
path: (*path).into(),
recursive: dir,
is_dir: Some(dir),
cached: true,
})
.collect()
}
fn devices(&self) -> Vec<DeviceInfo> {
vec![
DeviceInfo {
uid: "demo-devices~1".into(),
name: "alex-laptop".into(),
device_type: "Linux".into(),
last_sync: Some(self.now - 240),
this_device: true,
adopted: true,
},
DeviceInfo {
uid: "demo-devices~2".into(),
name: "studio-desktop".into(),
device_type: "Windows".into(),
last_sync: Some(self.now - 2 * DAY - 3 * 3600),
this_device: false,
adopted: false,
},
DeviceInfo {
uid: "demo-devices~3".into(),
name: "old-macbook".into(),
device_type: "MacOs".into(),
last_sync: Some(self.now - 210 * DAY),
this_device: false,
adopted: false,
},
]
}
/// This computer's synced folders: mirrors, and one kept online only.
const FOLDERS: &[(&str, &str)] = &[
("/home/alex/Documents", "mirror"),
("/home/alex/Pictures/Camera", "mirror"),
("/home/alex/Music", "ondemand"),
("/home/alex/Projects", "mirror"),
];
fn sync_folders(&self) -> Vec<SyncFolderInfo> {
Self::FOLDERS
.iter()
.enumerate()
.map(|(i, (path, mode))| SyncFolderInfo {
id: i as i64 + 1,
kind: "device".into(),
local_path: (*path).into(),
remote_uid: format!("demo-sync~{i}"),
mode: (*mode).into(),
pending_mode: None,
state: "idle".into(),
last_sync: self.now - 240 - i as i64 * 60,
progress: None,
paused: false,
})
.collect()
}
fn locations(&self) -> Vec<MountSpec> {
let mut items = vec![MountSpec {
id: 1,
kind: MountKind::MyFiles,
local_path: MOUNTPOINT.into(),
root_uid: "demo-files~".into(),
root_share_id: String::new(),
mode: MountMode::OnDemand,
access: MountAccess::Rw,
state: "idle".into(),
last_sync: self.now - 60,
pending_mode: None,
mounted: true,
progress: None,
paused: false,
}];
items.extend(
Self::FOLDERS
.iter()
.enumerate()
.map(|(i, (path, mode))| MountSpec {
id: i as i64 + 2,
kind: MountKind::Device {
sync_folder_id: i as i64 + 1,
},
local_path: (*path).into(),
root_uid: format!("demo-sync~{i}"),
root_share_id: String::new(),
mode: MountMode::from(*mode),
access: MountAccess::Rw,
state: "idle".into(),
last_sync: self.now - 240 - i as i64 * 60,
pending_mode: None,
mounted: *mode == "ondemand",
progress: None,
paused: false,
}),
);
items
}
fn activity(&self) -> Vec<ActivityEntry> {
let at = |minutes: i64| self.now - minutes * 60;
let entry = |time, kind, target: &str, detail: &str, ok| ActivityEntry {
time,
kind,
target: target.into(),
detail: detail.into(),
ok,
};
let conflict = |time, name: &str, ext: &str| {
entry(
time,
ActivityKind::Conflict,
&format!("{name} (sync-conflict {time}).{ext}"),
&format!("differs from {name}.{ext}"),
false,
)
};
vec![
entry(at(2), ActivityKind::Upload, "Meeting notes.md", "", true),
entry(
at(14),
ActivityKind::Share,
"Budget 2026.ods",
"1 recipient(s) as editor",
true,
),
entry(
at(38),
ActivityKind::Upload,
"Pictures/Camera/IMG_20481.JPG",
"",
true,
),
entry(
at(39),
ActivityKind::Upload,
"Pictures/Camera/IMG_20480.JPG",
"",
true,
),
entry(
at(52),
ActivityKind::Rename,
"Thesis draft.odt",
"was thesis-v3.odt",
true,
),
conflict(at(180), "Quarterly report", "odt"),
entry(
at(240),
ActivityKind::Move,
"Taxes/2025",
"from Documents",
true,
),
entry(
at(26 * 60),
ActivityKind::PublicLink,
"Road trip.jpg",
"",
true,
),
conflict(at(26 * 60 + 5), "Packing list", "txt"),
entry(at(27 * 60), ActivityKind::CreateFolder, "Recipes", "", true),
conflict(at(28 * 60), "Garden plan", "svg"),
entry(at(29 * 60), ActivityKind::Trash, "Old invoices", "", true),
entry(
at(30 * 60),
ActivityKind::Restore,
"Apartment lease.pdf",
"",
true,
),
entry(
at(50 * 60),
ActivityKind::Upload,
"Videos/Harbour at dusk.mp4",
"",
true,
),
]
}
/// Hits for the search launcher: every demo file whose name holds the
/// query, or a few to show when nothing does.
fn search(&self, query: &str, limit: usize) -> Vec<SearchHit> {
let names = [
("Work/Quarterly report.odt", false, 180_912),
("Work/Quarterly report 2025.pdf", false, 1_204_334),
("Work/Reports", true, 0),
("Documents/Expense report March.ods", false, 44_201),
("Documents/Lab report.pdf", false, 2_301_442),
("Projects/Annual report draft.md", false, 18_400),
("Taxes/2025/Tax report.pdf", false, 640_008),
("Pictures/Report cover.jpg", false, 2_801_220),
];
let needle = query.to_lowercase();
names
.iter()
.filter(|(path, _, _)| needle.is_empty() || path.to_lowercase().contains(&needle))
.take(limit)
.enumerate()
.map(|(i, (path, is_dir, size))| SearchHit {
name: path.rsplit('/').next().unwrap_or(path).into(),
path: (*path).into(),
is_dir: *is_dir,
size: *size,
modified: self.now - (i as i64 * 5 + 1) * DAY,
pinned: i == 0,
cached: i == 0,
uid: format!("demo-files~/{path}"),
mounted_path: Some(format!("{MOUNTPOINT}/{path}")),
score: 100 - i as i64,
})
.collect()
}
fn local_search(&self, query: &str) -> Vec<LocalHit> {
let needle = query.to_lowercase();
[("/home/alex/Downloads/report-template.ott", 22_018)]
.iter()
.filter(|(path, _)| path.to_lowercase().contains(&needle))
.map(|(path, size)| LocalHit {
name: path.rsplit('/').next().unwrap_or(path).into(),
path: (*path).into(),
is_dir: false,
size: *size,
modified: self.now - 4 * DAY,
score: 10,
})
.collect()
}
}
fn join(dir: &str, name: &str) -> String {
let dir = dir.trim_matches('/');
if dir.is_empty() {
name.into()
} else {
format!("{dir}/{name}")
}
}
/// The variant name of `request`, for the log of requests the demo ignores.
fn request_name(request: &Request) -> String {
let json = serde_json::to_string(request).unwrap_or_default();
json.trim_start_matches(['{', '"'])
.split('"')
.next()
.unwrap_or_default()
.to_string()
}
+87 -1
View File
@@ -490,11 +490,48 @@ fn classify_verification_gate(e: ProtonError) -> Error {
} }
} }
/// Save `stored` to the keyring.
///
/// An existing entry is replaced by a new item rather than edited, because
/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the
/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the
/// fallback: for the first save, and whenever replacing is not possible.
fn write_stored(stored: &StoredSession) -> Result<()> { fn write_stored(stored: &StoredSession) -> Result<()> {
let json = Zeroizing::new(serde_json::to_string(stored)?); let json = Zeroizing::new(serde_json::to_string(stored)?);
if replace_items() {
match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) {
crate::secretservice::Replaced::Saved => return Ok(()),
crate::secretservice::Replaced::Skipped(why) => {
tracing::debug!(%why, "not replacing the keyring item; writing it in place");
}
}
}
with_keyring(|entry| entry.set_password(&json)) with_keyring(|entry| entry.set_password(&json))
} }
/// Whether [`write_stored`] talks to the Secret Service directly: always,
/// except in tests that use the in-memory store.
#[cfg(not(test))]
fn replace_items() -> bool {
true
}
#[cfg(test)]
fn replace_items() -> bool {
tests::MOCK_STORE.lock().is_none()
}
/// A short, one-way tag for a refresh token, for the log: enough to tell
/// whether the token a start finds is the one the last save wrote, and
/// nothing that helps anyone use it.
fn fingerprint(token: &str) -> String {
use sha2::{Digest, Sha256};
Sha256::digest(token.as_bytes())[..4]
.iter()
.map(|b| format!("{b:02x}"))
.collect()
}
/// Load the persisted session blob, or `Error::NotLoggedIn` if absent. /// Load the persisted session blob, or `Error::NotLoggedIn` if absent.
pub fn load() -> Result<StoredSession> { pub fn load() -> Result<StoredSession> {
match with_keyring(|entry| entry.get_password()) { match with_keyring(|entry| entry.get_password()) {
@@ -703,6 +740,10 @@ fn resume_stored(stored: &StoredSession) -> Result<ProtonApiSession> {
resumed.access_token = tokens.access_token.clone(); resumed.access_token = tokens.access_token.clone();
resumed.refresh_token = tokens.refresh_token.clone(); resumed.refresh_token = tokens.refresh_token.clone();
} }
tracing::info!(
refresh = %fingerprint(&resumed.refresh_token),
"resuming the stored session"
);
let session = ProtonApiSession::resume(client_config(), resumed.to_params())?; let session = ProtonApiSession::resume(client_config(), resumed.to_params())?;
let sink = register_refresh_handler(&session, stored.refresh_token.clone()); let sink = register_refresh_handler(&session, stored.refresh_token.clone());
if let Some(tokens) = unsaved { if let Some(tokens) = unsaved {
@@ -1082,8 +1123,11 @@ impl TokenSink {
) { ) {
Rotation::Taken => { Rotation::Taken => {
write_stored(&stored)?; write_stored(&stored)?;
tracing::info!(
refresh = %fingerprint(&tokens.refresh_token),
"successfully auto-persisted refreshed tokens in keyring"
);
state.stored_refresh = tokens.refresh_token; state.stored_refresh = tokens.refresh_token;
tracing::info!("successfully auto-persisted refreshed tokens in keyring");
} }
Rotation::MovedOn => { Rotation::MovedOn => {
tracing::info!( tracing::info!(
@@ -1408,6 +1452,48 @@ mod tests {
keyring_core::unset_default_store(); keyring_core::unset_default_store();
} }
/// B291: every save after the first replaces the keyring item, so a
/// provider that keeps an edited secret only in memory (oo7 before 0.7.0)
/// still has the last one after a restart, and only one item is left.
///
/// Run like [`real_secret_service_survives_a_provider_restart`], in a
/// throwaway session bus only.
#[test]
#[ignore = "needs a throwaway Secret Service; see real_secret_service_survives_a_provider_restart"]
fn real_secret_service_keeps_the_last_save_across_a_provider_restart() {
if std::env::var_os("PDFS_SECRET_SERVICE_RESTART_TEST").is_none() {
return;
}
let restart = std::env::var("PDFS_RESTART_PROVIDER").expect("PDFS_RESTART_PROVIDER");
let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None;
keyring_core::unset_default_store();
for refresh in ["r1", "r2", "r3"] {
write_stored(&stored_with(refresh)).unwrap();
}
let status = std::process::Command::new("sh")
.args(["-c", &restart])
.status()
.unwrap();
assert!(status.success(), "restarting the provider failed");
std::thread::sleep(Duration::from_secs(1));
assert_eq!(load().unwrap().refresh_token, "r3");
let ss =
dbus_secret_service::SecretService::connect(dbus_secret_service::EncryptionType::Plain)
.unwrap();
let found = ss
.search_items(std::collections::HashMap::from([
("service", KEYRING_SERVICE),
("username", KEYRING_USER),
]))
.unwrap();
assert_eq!(found.unlocked.len() + found.locked.len(), 1);
with_keyring(|e| e.delete_credential()).unwrap();
keyring_core::unset_default_store();
}
fn stored_with(refresh: &str) -> StoredSession { fn stored_with(refresh: &str) -> StoredSession {
serde_json::from_str(&blob("").replace(r#""r""#, &format!("{refresh:?}"))).unwrap() serde_json::from_str(&blob("").replace(r#""r""#, &format!("{refresh:?}"))).unwrap()
} }
+23 -6
View File
@@ -445,6 +445,13 @@ fn is_in_memory(path: &Path) -> bool {
/// SQLite uses POSIX record locks, so the two never interact, and a lock file /// SQLite uses POSIX record locks, so the two never interact, and a lock file
/// left behind carries no state — the lock lives in the kernel and dies with /// left behind carries no state — the lock lives in the kernel and dies with
/// the process, however it exits. /// the process, however it exits.
///
/// A refusal is retried for [`LOCK_RETRY`] before it counts as another
/// daemon. A child this process spawns holds a copy of every descriptor from
/// its fork until its exec closes them, and `flock` belongs to the open file,
/// not the descriptor. So a lock the process has just let go of can stay held
/// for that moment, and a reopen right after a drop is refused
/// (`docs/BUGS.md` B290).
fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> { fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> {
if is_in_memory(path) { if is_in_memory(path) {
return Ok(None); return Ok(None);
@@ -456,22 +463,32 @@ fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> {
.truncate(false) .truncate(false)
.write(true) .write(true)
.open(&lock_path)?; .open(&lock_path)?;
// SAFETY: `file` owns the descriptor and outlives the call. let deadline = std::time::Instant::now() + LOCK_RETRY;
let rc = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) }; loop {
if rc != 0 { // SAFETY: `file` owns the descriptor and outlives the call.
let rc = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
if rc == 0 {
return Ok(Some(file));
}
let e = std::io::Error::last_os_error(); let e = std::io::Error::last_os_error();
if e.raw_os_error() == Some(libc::EWOULDBLOCK) { if e.raw_os_error() != Some(libc::EWOULDBLOCK) {
return Err(Error::Io(e));
}
if std::time::Instant::now() >= deadline {
return Err(Error::Other(format!( return Err(Error::Other(format!(
"another Proton Drive daemon is already using {} — \ "another Proton Drive daemon is already using {} — \
stop it first (`systemctl --user stop proton-drive.service`)", stop it first (`systemctl --user stop proton-drive.service`)",
path.display() path.display()
))); )));
} }
return Err(Error::Io(e)); std::thread::sleep(std::time::Duration::from_millis(20));
} }
Ok(Some(file))
} }
/// How long a refused single-writer lock is retried; far longer than a fork
/// takes to reach its exec, far shorter than anyone notices.
const LOCK_RETRY: std::time::Duration = std::time::Duration::from_millis(500);
fn lock_path_for(path: &Path) -> PathBuf { fn lock_path_for(path: &Path) -> PathBuf {
let mut name = path.as_os_str().to_owned(); let mut name = path.as_os_str().to_owned();
name.push(".lock"); name.push(".lock");
+1
View File
@@ -23,6 +23,7 @@ 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 similar;
+135
View File
@@ -0,0 +1,135 @@
//! Saving a new secret into an existing Secret Service item by replacing the
//! item, not by editing its secret (`docs/BUGS.md` B291).
//!
//! oo7-daemon before 0.7.0 applies `SetSecret` only in memory: the keyring
//! file keeps the old secret, and it comes back once the daemon restarts.
//! Fedora 45 ships such a build (`0.7.0~beta^1.e91b98a`). Every refreshed
//! sign-in pdfs saved there was gone after a reboot, and the next start found
//! a refresh token Proton had already spent.
//!
//! `CreateItem` with `replace` is written to the file there, and every
//! provider implements it. So a secret that changes is written as a new item
//! that replaces the old one: in the old one's collection, with its label and
//! all of its attributes, so the provider recognises it as the same entry.
use dbus_secret_service::{Collection, EncryptionType, Path, SecretService};
use std::collections::HashMap;
/// The content type the keyring store writes its secrets with.
const CONTENT_TYPE: &str = "application/octet-stream";
/// What [`replace`] did.
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Replaced {
/// The secret is saved.
Saved,
/// Nothing was changed; save it the usual way. Says why, for the log.
Skipped(String),
}
/// Save `secret` into the one item for `service`/`user` by replacing it.
///
/// Skips, changing nothing, when there is no such item yet (the store creates
/// it), when there is more than one, when it is locked, or when the Secret
/// Service fails before the new item exists. Never shows a prompt: one would
/// block the caller, so it is dismissed and the write is skipped.
pub(crate) fn replace(service: &str, user: &str, secret: &[u8]) -> Replaced {
match try_replace(service, user, secret) {
Ok(replaced) => replaced,
Err(e) => Replaced::Skipped(e.to_string()),
}
}
fn try_replace(
service: &str,
user: &str,
secret: &[u8],
) -> Result<Replaced, dbus_secret_service::Error> {
let ss = SecretService::connect_with_max_prompt_timeout(EncryptionType::Dh, 0)?;
let lookup = HashMap::from([("service", service), ("username", user)]);
let found = ss.search_items(lookup.clone())?;
if !found.locked.is_empty() {
return Ok(Replaced::Skipped("the item is locked".into()));
}
let [old] = found.unlocked.as_slice() else {
return Ok(Replaced::Skipped(format!(
"{} items match, not one",
found.unlocked.len()
)));
};
let Some(collection) = collection_of(&old.path) else {
return Ok(Replaced::Skipped(format!(
"no collection in the item path {}",
old.path
)));
};
let label = old.get_label()?;
let attributes = old.get_attributes()?;
let attributes: HashMap<&str, &str> = attributes
.iter()
.map(|(k, v)| (k.as_str(), v.as_str()))
.collect();
let collection = Collection::new(&ss, collection);
let new = collection.create_item(&label, attributes, secret, true, CONTENT_TYPE)?;
// A provider that did not match the old item leaves it next to the new
// one, and two items make every read ambiguous.
let after = ss.search_items(lookup)?;
for item in after.unlocked.iter().chain(&after.locked) {
if item.path == new.path {
continue;
}
if let Err(e) = item.delete() {
// The old item still holds the previous secret, so taking the new
// one out leaves things as they were, for the usual write.
if let Err(undo) = new.delete() {
tracing::error!(
error = %undo,
"could not remove a duplicate keyring item; remove one of the two \
`proton-drive-linux` entries in your keyring and sign in again"
);
}
return Ok(Replaced::Skipped(format!(
"could not remove the replaced item: {e}"
)));
}
}
Ok(Replaced::Saved)
}
/// The collection an item path belongs to: the path without its last part,
/// as long as it is a Secret Service object path.
fn collection_of(item: &Path<'_>) -> Option<Path<'static>> {
let (collection, _) = item.rsplit_once('/')?;
if !collection.starts_with("/org/freedesktop/secrets/") || collection.ends_with('/') {
return None;
}
Path::new(collection.to_owned()).ok()
}
#[cfg(test)]
mod tests {
use super::*;
fn collection(item: &str) -> Option<String> {
collection_of(&Path::new(item).unwrap()).map(|p| p.to_string())
}
#[test]
fn an_item_belongs_to_the_collection_its_path_names() {
assert_eq!(
collection("/org/freedesktop/secrets/collection/login/14").as_deref(),
Some("/org/freedesktop/secrets/collection/login")
);
assert_eq!(
collection("/org/freedesktop/secrets/aliases/default/3").as_deref(),
Some("/org/freedesktop/secrets/aliases/default")
);
}
#[test]
fn a_path_outside_the_secret_service_names_no_collection() {
assert_eq!(collection("/org/example/item/1"), None);
assert_eq!(collection("/item"), None);
}
}
+44 -3
View File
@@ -297,6 +297,27 @@ fn parse_launch(args: &[String]) -> Launch {
Launch::Window Launch::Window
} }
/// The Sync view a `--page` name opens: "activity" lives on as its History
/// view, and "sync-folders" is its Folders view.
fn sync_view(page: &str) -> Option<&'static str> {
match page {
"activity" => Some("history"),
"sync-folders" => Some("folders"),
_ => None,
}
}
/// The Photos view a `--page` name opens, and whether Places shows its map:
/// "albums", "places" and "places-map". Other names are stack pages.
fn photos_view(page: &str) -> Option<(u32, bool)> {
match page {
"albums" => Some((VIEW_ALBUMS, false)),
"places" => Some((VIEW_PLACES, false)),
"places-map" => Some((VIEW_PLACES, true)),
_ => None,
}
}
/// Raise the window if there is one, else build it. A second launch reaches /// Raise the window if there is one, else build it. A second launch reaches
/// the running instance, which must not open a second window. /// the running instance, which must not open a second window.
fn present_window(app: &adw::Application) { fn present_window(app: &adw::Application) {
@@ -1450,10 +1471,18 @@ fn install_launch_actions(ui: &Rc<Ui>, app: &adw::Application, window: &adw::App
show_login(&ui_page); show_login(&ui_page);
return; return;
} }
// Activity lives on as the Sync page's History view. if let Some(view) = sync_view(page) {
if page == "activity" { ui_page.locations.views.set_visible_child_name(view);
ui_page.locations.views.set_visible_child_name("history");
ui_page.stack.set_visible_child_name("locations"); ui_page.stack.set_visible_child_name("locations");
} else if let Some((view, map)) = photos_view(page) {
ui_page.stack.set_visible_child_name("gallery");
if view == VIEW_PLACES {
ui_page
.gallery
.places_layout
.set_active(if map { PLACES_MAP } else { 0 });
}
ui_page.gallery.view_switch.set_active(view);
} else if ui_page.stack.child_by_name(page).is_some() { } else if ui_page.stack.child_by_name(page).is_some() {
ui_page.stack.set_visible_child_name(page); ui_page.stack.set_visible_child_name(page);
} }
@@ -2014,6 +2043,18 @@ mod tests {
assert_eq!(parse_launch(&args(&["--page"])), Launch::Window); assert_eq!(parse_launch(&args(&["--page"])), Launch::Window);
} }
#[test]
fn a_page_name_can_open_a_photos_or_sync_view() {
assert_eq!(photos_view("albums"), Some((VIEW_ALBUMS, false)));
assert_eq!(photos_view("places"), Some((VIEW_PLACES, false)));
assert_eq!(photos_view("places-map"), Some((VIEW_PLACES, true)));
// The timeline is the Photos stack page itself.
assert_eq!(photos_view("gallery"), None);
assert_eq!(sync_view("activity"), Some("history"));
assert_eq!(sync_view("sync-folders"), Some("folders"));
assert_eq!(sync_view("locations"), None);
}
/// One file of a shot, for the group-switch tests. /// One file of a shot, for the group-switch tests.
fn member(uid: &str, name: Option<&str>, kind: PhotoKind) -> PhotoItem { fn member(uid: &str, name: Option<&str>, kind: PhotoKind) -> PhotoItem {
PhotoItem { PhotoItem {
+67
View File
@@ -109,6 +109,7 @@ a live account since.
| Entry | Title | | Entry | Title |
|---|---| |---|---|
| [B291](#b291--on-fedora-45s-oo7-every-saved-sign-in-is-lost-at-the-next-reboot) | On Fedora 45's oo7, every saved sign-in is lost at the next reboot |
| [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos | | [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos |
| [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it | | [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it |
| [B287](#b287--a-photo-draft-left-by-an-interrupted-upload-blocks-that-name) | A photo draft left by an interrupted upload blocks that name | | [B287](#b287--a-photo-draft-left-by-an-interrupted-upload-blocks-that-name) | A photo draft left by an interrupted upload blocks that name |
@@ -305,6 +306,7 @@ a live account since.
| Entry | Title | | Entry | Title |
|---|---| |---|---|
| [B290](#b290--reopening-the-database-right-after-closing-it-can-be-refused-as-another-daemon) | Reopening the database right after closing it can be refused as another daemon |
| [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for | | [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for |
| [B258](#b258--journalctl--p-warning-shows-nothing-whatever-the-daemon-logged) | `journalctl -p warning` shows nothing, whatever the daemon logged | | [B258](#b258--journalctl--p-warning-shows-nothing-whatever-the-daemon-logged) | `journalctl -p warning` shows nothing, whatever the daemon logged |
| [B256](#b256--pdfs-copy-right-after-a-save-copies-the-old-version) | `pdfs copy` right after a save copies the old version | | [B256](#b256--pdfs-copy-right-after-a-save-copies-the-old-version) | `pdfs copy` right after a save copies the old version |
@@ -392,6 +394,71 @@ a live account since.
Newest first. Newest first.
### B291 — On Fedora 45's oo7, every saved sign-in is lost at the next reboot
**Status:** Fixed, not verified live
**Found:** 2026-11-15, from the reporter's package list in
[issue #78](https://github.com/narrrl/proton-drive-linux/issues/78): `oo7-daemon-0.7.0~beta^1.e91b98a`,
the build Fedora 45 and 46 ship as stable, from before oo7's
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
("server: Write item changes to the keyring file"). See
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7).
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `crates/pdfs-core/src/secretservice.rs`
**Repro:** With oo7-daemon at e91b98a, save the session blob, save it again with a new refresh
token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
store writes an existing item with `SetSecret`, and that oo7 build applies `SetSecret` only to the
item in memory; the keyring file keeps what `CreateItem` wrote. Within a boot every read returns
the new tokens, so nothing looks wrong. After a reboot the daemon resumes with the refresh token
of the last `pdfs login`, which Proton spent long ago: `InvalidRefreshToken`, and the user has to
sign in again. Typing the password at login, or the fixes for B284 and B285, change nothing.
**Cause:** A bug in that oo7 build, fixed in oo7 0.7.0 but not packaged by Fedora. Every token
refresh pdfs saved went through the one call it does not persist.
**Fix:** An existing entry is saved by `CreateItem` with `replace`, which that build writes to the
file: a new item in the old one's collection, with its label and all its attributes, so the
provider replaces the old one. A duplicate that a provider leaves behind is removed; if it cannot
be, the new item is taken out again and the save falls back to the usual `SetSecret`. The first
save, a locked item, two matching items, or any failure before the new item exists also fall back
to it. The connection used for this never shows a prompt. The daemon log now has a short
fingerprint of the refresh token at each start and each save, so a log across a reboot shows
whether the keyring returned the last token saved.
**Verified:** 2026-11-15, `real_secret_service_keeps_the_last_save_across_a_provider_restart`
(ignored; needs a throwaway Secret Service) against oo7-daemon built at e91b98a: with the
in-place write it reads `r1` after the restart, with this change `r3` and one item. The same test
and `real_secret_service_survives_a_provider_restart` pass against gnome-keyring. Not yet run on
a Fedora 45 desktop with a real account.
---
### B290 — Reopening the database right after closing it can be refused as another daemon
**Status:** Fixed, 2026-11-15
**Found:** 2026-11-15, CI on `chore/release-3.8.0` (fd6b2d3):
`db::tests::what_a_create_sent_outlives_a_newer_blob_its_trash_and_a_restart` failed once with
"another Proton Drive daemon is already using /tmp/pdfs-create-sent-….db". It passes on its own.
**Where:** `crates/pdfs-core/src/db/mod.rs`, `acquire_single_writer_lock`
**Repro:** In one process, drop a `Db` and open the same file again while another thread spawns a
child process. Rare; seen once in about 500 tests that run in parallel, several of which spawn
processes.
**Cause:** The single-writer lock is a `flock` on `<db>.lock`, and a `flock` belongs to the open
file, not to one descriptor. A child holds a copy of every descriptor from its fork until its exec
closes the `O_CLOEXEC` ones. A lock dropped by the parent in that moment stays held by the child,
and an immediate reopen gets `EWOULDBLOCK`, which reads as a second daemon.
**Fix:** A refused lock is retried every 20 ms for up to 500 ms before it counts as another
daemon. That covers any fork-to-exec window. A real second daemon is still refused, half a
second later.
**Verified:** `cargo test -p pdfs-core` on 2026-11-15, including
`a_second_writer_is_refused_while_the_first_holds_the_database`.
---
### B289 — The Takeout import mixes in other services and drops location and live photos ### B289 — The Takeout import mixes in other services and drops location and live photos
**Status:** Fixed, not verified live **Status:** Fixed, not verified live
+10 -7
View File
@@ -117,6 +117,9 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
Import page offers **Resume**, and `pdfs import-google-photos --resume` does the same. Photos Import page offers **Resume**, and `pdfs import-google-photos --resume` does the same. Photos
that are already uploaded are skipped as before. that are already uploaded are skipped as before.
- **More pages to open the app on.** `pdfs-app --page` also takes `albums`, `places`,
`places-map` and `sync-folders`.
### Changed ### Changed
- **`proton-sdk` and `proton-drive-rs` 0.12.0.** Timestamps are converted where they enter - **`proton-sdk` and `proton-drive-rs` 0.12.0.** Timestamps are converted where they enter
@@ -159,13 +162,13 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
screen there, and with nothing to scroll no more were loaded. More now load whenever the photos screen there, and with nothing to scroll no more were loaded. More now load whenever the photos
don't fill the window, also after a zoom or a resize. don't fill the window, also after a zoom or a resize.
- **Signed out after a cold boot on Fedora 45** (issue #78, B284, B285). Fedora 45 replaced the - **Signed out after every reboot on Fedora 45** (issue #78, B284, B285, B291). Fedora 45 replaced
GNOME keyring with oo7, and two things there could keep a refreshed sign-in from being saved: the GNOME keyring with oo7, and the oo7 build it ships keeps a changed keyring entry only in
oo7 reports the entries of a locked keyring as missing, which the client took for a sign-out, memory: every refreshed sign-in the client saved was gone after a reboot, and the next start
and a restarted oo7 no longer knew the client's connection, which then failed every save until found one Proton had already retired. The client now saves the sign-in as a new entry that
the service restarted. The refreshed sign-in lived only in memory, and the next boot found the replaces the old one, which that oo7 does write to disk. It also no longer drops a refreshed
spent one. The client now keeps such a sign-in and saves it once the keyring can be read, and sign-in when oo7 reports the entries of a locked keyring as missing, and it reconnects to a
reconnects to a keyring service that restarted. keyring service that restarted.
- **Thumbnails appear in the folder you are looking at as soon as they are made.** During - **Thumbnails appear in the folder you are looking at as soon as they are made.** During
**Build thumbnails**, the folder on screen kept its file icons until you left it and opened it **Build thumbnails**, the folder on screen kept its file icons until you left it and opened it
+23
View File
@@ -161,6 +161,29 @@ links, copies the images and writes the sidebar. `docs/README.md` becomes the wi
Never edit the wiki in the browser: the next publish replaces every page. Never edit the wiki in the browser: the next publish replaces every page.
**Screenshots.** The pictures in `images/` (except the cover) are taken by a script, from an
invented account, so they never show anyone's files:
```bash
scripts/screenshots.sh # all of them, into images/
scripts/screenshots.sh --only photos,files # just these
scripts/screenshots.sh --website ../proton-drive-linux-website # and copy them to the website
```
It builds the app and runs it against `crates/pdfs-core/examples/demo_daemon.rs`, a stand-in
daemon that answers the control socket with made-up files, photos, places, computers and history.
The app runs in a headless `cage` compositor with its own HOME, XDG directories, session bus and
keyring, so nothing touches your account, your keyring or a running service. It needs `cage`,
`grim`, `wlr-randr`, ImageMagick, `dbus-run-session` and `gnome-keyring-daemon`, plus `wtype` for
the launcher's query, and `fzf` and `alacritty` for its fzf variant. The demo photos come from
[picsum.photos](https://picsum.photos) (Unsplash licence) on the first run and are cached in
`~/.cache/pdfs-screenshots`. Dates are relative to the day you run it.
Retake them before a release, and look at each one before committing. A page that grew new data
needs a matching answer in the demo daemon; the requests it has no answer for are logged in
`demo_daemon.log` (keep it with `--keep`). The demo daemon is built with every `cargo test` and
`cargo clippy --all-targets`, so a change to the control protocol that breaks it fails CI.
## Releasing ## Releasing
Releases are cut from `main` by pushing a `v*` tag. `.github/workflows/release.yml` then: Releases are cut from `main` by pushing a `v*` tag. `.github/workflows/release.yml` then:
+46
View File
@@ -58,6 +58,52 @@ can resolve the default alias to a locked collection. Both have fixes in
after the reporter's November 7 retest. Neither can be assigned as this report's cause without after the reporter's November 7 retest. Neither can be assigned as this report's cause without
matching runtime evidence. matching runtime evidence.
## SetSecret is kept only in memory in Fedora's oo7
Follow-up on 2026-11-15. The reporter's `rpm -qa 'oo7*'` shows
`oo7-daemon-0.7.0~beta^1.e91b98a-1.fc45`, not the 0.7.0 release assumed above. Bodhi lists that
build as the stable oo7 for Fedora 45 and 46; neither has 0.7.0 or 0.7.1. Commit e91b98a
(October 24) predates
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
(October 28): "Setting the Label or Attributes of an item, or calling SetSecret, only changed the
item in memory, so the old values came back once the daemon restarted." 0.7.0 carries it as
37e3334.
pdfs writes an existing entry with `SetSecret`, so on that build every saved token rotation was
lost at the next reboot. This explains the reporter's log: the keyring was unlocked one second
before pdfs started (they type their password at login) and still held a spent refresh token.
It does not need a locked keyring or a restarted provider.
pdfs now saves an existing entry with `CreateItem` and `replace` instead
(`crates/pdfs-core/src/secretservice.rs`, B291), which e91b98a writes to the keyring file.
Reproduced and verified with oo7-daemon built at e91b98a in a throwaway session bus:
```sh
git clone https://github.com/linux-credentials/oo7.git /tmp/oo7 && git -C /tmp/oo7 checkout e91b98a
cargo build --manifest-path /tmp/oo7/Cargo.toml -p oo7-daemon --bin oo7-daemon
OO7=/tmp/oo7/target/debug/oo7-daemon
T=$(mktemp -d /tmp/ss.XXXX); mkdir -p $T/data $T/run; chmod 700 $T/run
XDG_DATA_HOME=$T/data XDG_RUNTIME_DIR=$T/run OO7=$OO7 PDFS_SECRET_SERVICE_RESTART_TEST=1 \
PDFS_RESTART_PROVIDER='pkill -x oo7-daemon; sleep 1; (printf pw | setsid "$OO7" --login >/dev/null 2>&1 &); sleep 2' \
dbus-run-session -- sh -c 'printf pw | setsid "$OO7" --login >/dev/null 2>&1 & sleep 2;
cargo test -p pdfs-core real_secret_service_keeps -- --ignored'
```
With the in-place write, the read after the restart returns the first of three saves (`r1`);
with the replacing write it returns the last (`r3`), and one item is left.
The daemon also logs a short fingerprint of the refresh token when it resumes the stored session
and each time it saves a rotation (`refresh=1a2b3c4d`). If a start is refused, compare the
fingerprint it resumed with against the last one saved in the boot before:
```sh
journalctl --user -b -1 -u proton-drive.service | grep -E 'refresh=' | tail -2
journalctl --user -b 0 -u proton-drive.service | grep -E 'refresh=' | head -2
```
The same fingerprint means the keyring kept the last save and Proton refused it; a different one
means the keyring lost it.
## A restarted Secret Service ## A restarted Secret Service
A second path to the same symptom, independent of locking (B285). The keyring store pdfs used A second path to the same symptom, independent of locking (B285). The keyring store pdfs used
Binary file not shown.

Before

Width:  |  Height:  |  Size: 43 KiB

After

Width:  |  Height:  |  Size: 51 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 124 KiB

After

Width:  |  Height:  |  Size: 137 KiB

BIN
View File
Binary file not shown.

Before

Width:  |  Height:  |  Size: 52 KiB

After

Width:  |  Height:  |  Size: 115 KiB

BIN
View File
Binary file not shown.

Before

Width:  |  Height:  |  Size: 32 KiB

After

Width:  |  Height:  |  Size: 32 KiB

BIN
View File
Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.6 MiB

After

Width:  |  Height:  |  Size: 1.6 MiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.6 MiB

After

Width:  |  Height:  |  Size: 283 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 16 KiB

After

Width:  |  Height:  |  Size: 36 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 114 KiB

After

Width:  |  Height:  |  Size: 96 KiB

BIN
View File
Binary file not shown.

Before

Width:  |  Height:  |  Size: 71 KiB

After

Width:  |  Height:  |  Size: 69 KiB

+218
View File
@@ -0,0 +1,218 @@
#!/usr/bin/env bash
# Retakes the README and website screenshots from made-up data.
set -Eeuo pipefail
usage() {
cat >&2 <<'EOF'
usage: scripts/screenshots.sh [OPTION ...]
Builds the app, starts it against a stand-in daemon that serves an invented
account (crates/pdfs-core/examples/demo_daemon.rs), and captures every page in
a headless Wayland compositor. No Proton account, no FUSE mount, nothing from
your own files: HOME, every XDG directory, the session bus and the keyring
are throwaway ones under a temporary directory.
Options:
--out DIR where the PNGs go (default: images/)
--only LIST capture only these, comma-separated (default: all of
login,files,photos,photos_map,computers,sync,conflicts,
prompt_gtk,prompt_fzf)
--website DIR afterwards, copy them into the website checkout at DIR
with its scripts/sync-screenshots.sh
--settle SECS how long a page gets to load before its capture (default 3)
--debug use a debug build instead of a release build
--keep keep the temporary directory, for a look at the logs
Needs cage, grim, wlr-randr, ImageMagick, dbus-run-session and
gnome-keyring-daemon; prompt_gtk types its query with wtype when there is one,
and prompt_fzf needs fzf and alacritty. Demo photos come from picsum.photos
(Unsplash licence) on the first run and are cached in
~/.cache/pdfs-screenshots.
EOF
exit 2
}
repo="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
all=login,files,photos,photos_map,computers,sync,conflicts,prompt_gtk,prompt_fzf
# The capture itself, run by cage inside the throwaway session (see below).
if [[ "${1:-}" == --capture ]]; then
shots=",$SHOTS,"
wants() { [[ "$shots" == *",$1,"* ]]; }
output() { wlr-randr --output "$(wlr-randr | awk 'NR==1 {print $1}')" --custom-mode "$1"; }
shoot() {
sleep "$SETTLE"
grim "$OUT/$1.png"
echo "captured $1"
}
# Cut the compositor's black background off a window smaller than it.
trim() {
magick "$OUT/$1.png" -bordercolor black -border 1 -trim +repage "$OUT/$1.png"
}
quit() {
kill "$@" 2>/dev/null || true
wait "$@" 2>/dev/null || true
}
output 1836x1006
if wants login; then
"$BIN/pdfs-app" &
app=$!
shoot login
quit "$app"
fi
"$BIN/demo_daemon" seed-keyring
"$BIN/pdfs-app" &
app=$!
sleep "$SETTLE"
for shot in files:browser photos:gallery photos_map:places-map computers:devices \
sync:sync-folders conflicts:activity; do
name=${shot%%:*}
wants "$name" || continue
"$BIN/pdfs-app" --page "${shot#*:}"
shoot "$name"
done
quit "$app"
if wants prompt_gtk; then
output 860x723
"$BIN/pdfs-prompt" --gtk &
prompt=$!
sleep 1
# The window has no --query; type one, as a person would.
# The first key only sets up the keymap.
command -v wtype >/dev/null && wtype -k Shift_L -s 200 report
shoot prompt_gtk
quit "$prompt"
trim prompt_gtk
fi
if wants prompt_fzf; then
if command -v fzf >/dev/null && command -v alacritty >/dev/null; then
output 800x600
alacritty -o font.size=11 -e "$BIN/pdfs-prompt" --fzf --inner --query report &
term=$!
shoot prompt_fzf
quit "$term"
trim prompt_fzf
else
echo "skipped prompt_fzf: needs fzf and alacritty" >&2
fi
fi
exit 0
fi
# Inside the private session bus: an unlocked, empty keyring, the demo daemon,
# then the compositor running the capture above.
if [[ "${1:-}" == --session ]]; then
# A password it never asks for again: an empty one leaves no keyring.
printf demo | gnome-keyring-daemon --unlock --components=secrets >/dev/null
"$BIN/demo_daemon" serve "$PHOTOS" 2>"$PDFS_DEMO_ROOT/demo_daemon.log" &
daemon=$!
trap 'kill "$daemon" 2>/dev/null || true' EXIT
for _ in $(seq 50); do
[[ -S "$XDG_STATE_HOME/proton-drive-linux/control.sock" ]] && break
sleep 0.1
done
WLR_BACKENDS=headless WLR_LIBINPUT_NO_DEVICES=1 \
cage -- "$repo/scripts/screenshots.sh" --capture 2>"$PDFS_DEMO_ROOT/cage.log"
exit 0
fi
out="$repo/images"
shots=$all
website=
settle=3
profile=release
keep=
while (($#)); do
case "$1" in
--out) out=$(realpath -m -- "${2:?}"); shift ;;
--only) shots=${2:?}; shift ;;
--website) website=$(realpath -- "${2:?}"); shift ;;
--settle) settle=${2:?}; shift ;;
--debug) profile=debug ;;
--keep) keep=1 ;;
-h | --help) usage ;;
*) echo "unknown option: $1" >&2; usage ;;
esac
shift
done
for shot in ${shots//,/ }; do
[[ ",$all," == *",$shot,"* ]] || { echo "no screenshot called $shot" >&2; exit 2; }
done
for tool in cage grim wlr-randr magick dbus-run-session gnome-keyring-daemon cargo curl; do
command -v "$tool" >/dev/null || { echo "$tool is required" >&2; exit 2; }
done
# Demo photos, fetched once. Fixed picsum ids keep every run the same; a
# trailing -p marks a portrait one.
photos="${XDG_CACHE_HOME:-$HOME/.cache}/pdfs-screenshots"
mkdir -p "$photos"
for id in 10 11 13 15 16 17 28 29 37 42 43 49 54 57 58 76 82 83 84 96 101 103 110 \
111 116 119 122 128 129 135 142 145 152 164 167 174 176 180 184 188 192 200 \
210 218 219 225 231 237; do
size=600/400 file="$photos/$id.jpg"
if ((id % 7 == 0)); then size=400/600 file="$photos/$id-p.jpg"; fi
[[ -s "$file" ]] || curl -fsSL "https://picsum.photos/id/$id/$size.jpg" -o "$file" ||
{ rm -f "$file"; echo "could not fetch demo photo $id; skipped" >&2; }
done
cargo_flags=(--manifest-path "$repo/Cargo.toml" --locked)
[[ "$profile" == release ]] && cargo_flags+=(--release)
cargo build "${cargo_flags[@]}" -p pdfs-gui --bin pdfs-app --bin pdfs-prompt
cargo build "${cargo_flags[@]}" -p pdfs-core --example demo_daemon
target=$(cargo metadata --manifest-path "$repo/Cargo.toml" --format-version 1 --no-deps |
python3 -c 'import json, sys; print(json.load(sys.stdin)["target_directory"])')
bin="$(mktemp -d)"
ln -s "$target/$profile/pdfs-app" "$target/$profile/pdfs-prompt" \
"$target/$profile/examples/demo_daemon" "$bin/"
root=$(mktemp -d -t pdfs-screenshots.XXXXXX)
cleanup() {
rm -rf "$bin"
if [[ -n "$keep" ]]; then echo "kept $root" >&2; else rm -rf "$root"; fi
}
trap cleanup EXIT
mkdir -p "$root"/{home,config,state,cache,data} "$root/run" "$out"
chmod 700 "$root/run"
# The user's own fonts, so the shots look like the app does here.
mkdir -p "$root/data/fonts"
[[ -d "$HOME/.local/share/fonts" ]] && cp -rs "$HOME/.local/share/fonts/." "$root/data/fonts/"
mkdir -p "$root/config/proton-drive-linux"
cat >"$root/config/proton-drive-linux/config.json" <<'EOF'
{
"proton_theme": true,
"tray_hidden": true,
"update_check": false,
"online_map": false,
"files_view": { "list": false }
}
EOF
# Only a close button, as GNOME shows it.
mkdir -p "$root/config/gtk-4.0"
printf '[Settings]\ngtk-decoration-layout=:close\n' >"$root/config/gtk-4.0/settings.ini"
# The demo user's home, so paths read "Home / …" for them, not for you. A
# folder that does not exist takes no writes; everything goes to XDG_*.
home=/home/alex
[[ -e "$home" ]] && home="$root/home"
outer_bus=${DBUS_SESSION_BUS_ADDRESS:-unset}
env -i \
PATH="$PATH" LANG=en_US.UTF-8 LC_ALL=en_US.UTF-8 TZ="${TZ:-Europe/Berlin}" \
HOME="$home" \
XDG_CONFIG_HOME="$root/config" XDG_STATE_HOME="$root/state" \
XDG_CACHE_HOME="$root/cache" XDG_DATA_HOME="$root/data" \
XDG_RUNTIME_DIR="$root/run" \
PDFS_DEMO_ROOT="$root" PDFS_DEMO_OUTER_BUS="$outer_bus" \
GSETTINGS_BACKEND=memory ADW_DEBUG_COLOR_SCHEME=prefer-dark GTK_A11Y=none GDK_DEBUG=no-portals \
BIN="$bin" PHOTOS="$photos" OUT="$out" SHOTS="$shots" SETTLE="$settle" \
dbus-run-session -- "$repo/scripts/screenshots.sh" --session 2>"$root/session.log"
for shot in ${shots//,/ }; do
[[ -s "$out/$shot.png" ]] || echo "missing: $out/$shot.png (logs: --keep)" >&2
done
if [[ -n "$website" ]]; then
"$website/scripts/sync-screenshots.sh" "$repo"
fi