Compare commits

..
Author SHA1 Message Date
nvrl 0df4b3c5f9 feat(gui,core,cli): edit excluded files, open-with rules and the launcher in Preferences (#99)
Preferences gains two pages for the config.json settings that had no
place in the app:

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

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

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

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

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

The daemon also logs a short fingerprint of the refresh token at each
resume and each save, so a log across a reboot shows whether the
keyring returned the last token saved.
2026-11-15 20:31:43 +01:00
nvrl ce3bfa217d Merge pull request #97 from narrrl/fix/db-lock-fork-race
fix(core): retry the database lock briefly before calling it another daemon (B290)
2026-11-15 19:44:24 +01:00
nvrl 593df5c401 fix(core): retry the database lock briefly before calling it another daemon (B290)
A child spawned by another thread holds a copy of the lock descriptor
between its fork and its exec, so a reopen right after a drop could be
refused. Seen once in CI in
what_a_create_sent_outlives_a_newer_blob_its_trash_and_a_restart.
2026-11-15 19:42:22 +01:00
nvrl fd6b2d3e85 Merge pull request #96 from narrrl/chore/screenshots
chore: retake the screenshots from a demo account, by script
2026-11-15 19:20:45 +01:00
45 changed files with 8747 additions and 3317 deletions

No files matched your search

Generated
+8
View File
@@ -3604,6 +3604,7 @@ dependencies = [
"async-trait",
"base64 0.23.1",
"chrono",
"dbus-secret-service",
"dbus-secret-service-keyring-store",
"directories",
"ignore",
@@ -3618,6 +3619,7 @@ dependencies = [
"serde_json",
"sha1 0.11.0",
"sha2 0.11.1",
"shell-words",
"thiserror 2.0.21",
"tokio",
"tracing",
@@ -4804,6 +4806,12 @@ dependencies = [
"lazy_static",
]
[[package]]
name = "shell-words"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
[[package]]
name = "shlex"
version = "2.0.1"
+5
View File
@@ -39,6 +39,8 @@ tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
directories = "6"
ignore = "0.4"
# Command lines typed into Preferences, split and shown the way a shell would.
shell-words = "1"
sha2 = "0.11"
# Google Takeout exports are zip sets; the importer reads their central
# directories and streams entries out without extracting to disk first.
@@ -60,6 +62,9 @@ rusqlite = { version = "0.41", features = ["bundled"] }
# with no `target` it matches items v3 wrote, so existing logins survive.
keyring-core = "1"
dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an
# item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
dbus-secret-service = { version = "4.1", features = ["crypto-rust"] }
clap = { version = "4", features = ["derive"] }
# `unstable-dynamic`: Tab calls `pdfs` back, so arguments complete from the
# running service. Only `pdfs-cli/src/complete.rs` uses it.
+145
View File
@@ -751,6 +751,32 @@ enum ConflictCmd {
},
}
/// `pdfs sync ignore`: the patterns in `ignore_patterns`, for every synced
/// folder. A folder's own rules are in its `.pdfsignore`.
#[derive(Subcommand, Debug)]
enum IgnoreCmd {
/// List the patterns every synced folder leaves out.
List,
/// Leave out files matching a gitignore-style pattern, e.g. `*.db` or `build/`.
Add {
/// The pattern; end it with `/` to match folders only.
pattern: String,
},
/// Stop leaving out files matching a pattern.
Remove {
/// The pattern, as `sync ignore list` shows it.
pattern: String,
},
/// Go back to the built-in patterns.
Reset,
/// Say whether a file in a synced folder is synced, and which pattern decides.
Check {
/// A file or folder inside a synced folder.
#[arg(value_hint = ValueHint::AnyPath)]
path: PathBuf,
},
}
#[derive(Subcommand)]
enum SyncCmd {
/// Add a local folder to this machine's device and upload its contents.
@@ -849,6 +875,11 @@ enum SyncCmd {
#[arg(add = ArgValueCandidates::new(complete::queue_id))]
id: Option<i64>,
},
/// Show or change the patterns every synced folder leaves out, or check a path.
Ignore {
#[command(subcommand)]
action: IgnoreCmd,
},
/// Switch a folder between full-copy sync and on-demand (FUSE, no local storage).
Mode {
/// Synced-folder id (from `sync list`).
@@ -1324,6 +1355,7 @@ fn cmd_sync(action: SyncCmd) -> Result<()> {
SyncCmd::Issues => return cmd_sync_issues(),
SyncCmd::Export { id, dest } => return cmd_sync_export(id, &dest),
SyncCmd::Limit { up, down } => return cmd_sync_limit(up, down),
SyncCmd::Ignore { action } => return cmd_sync_ignore(action),
SyncCmd::Discard { id, yes } => {
if !yes {
confirm(&format!(
@@ -3699,6 +3731,104 @@ fn cmd_sync_limit(up: Option<u64>, down: Option<u64>) -> Result<()> {
})?)
}
fn cmd_sync_ignore(action: IgnoreCmd) -> Result<()> {
use pdfs_core::syncignore::{
DEFAULT_IGNORE_PATTERNS, IgnoreRules, RuleSource, Verdict, check_pattern,
};
let dirs = AppDirs::new()?;
let defaults: Vec<String> = DEFAULT_IGNORE_PATTERNS
.iter()
.map(|p| (*p).to_string())
.collect();
// A list equal to the built-in one is stored as unset, so it follows the
// built-in list in later releases, as Preferences does.
let change = |edit: &dyn Fn(&mut Vec<String>)| -> Result<()> {
dirs.update_config(|config| {
let mut list = config.resolved_ignore_patterns();
edit(&mut list);
config.ignore_patterns = (list != defaults).then_some(list);
})?;
// The next pass picks the change up anyway; this only hurries it.
let _ = control_request(CtlRequest::SyncNow { id: None });
Ok(())
};
match action {
IgnoreCmd::List => {
let config = dirs.load_config();
let list = config.resolved_ignore_patterns();
if list.is_empty() {
println!("No patterns: every file is synced.");
}
for pattern in list {
if DEFAULT_IGNORE_PATTERNS.contains(&pattern.as_str()) {
println!("{pattern} (built in)");
} else {
println!("{pattern}");
}
}
}
IgnoreCmd::Add { pattern } => {
let pattern = pattern.trim().to_string();
if let Err(e) = check_pattern(&pattern) {
bail!("not a valid pattern: {e}");
}
change(&|list| {
if !list.contains(&pattern) {
list.push(pattern.clone());
}
})?;
}
IgnoreCmd::Remove { pattern } => {
let list = dirs.load_config().resolved_ignore_patterns();
if !list.contains(&pattern) {
bail!("`{pattern}` is not in the list; see `pdfs sync ignore list`");
}
change(&|list| list.retain(|p| *p != pattern))?;
}
IgnoreCmd::Reset => change(&|list| *list = defaults.clone())?,
IgnoreCmd::Check { path } => {
let path = std::path::absolute(&path)?;
let folders = match control_request(CtlRequest::ListSyncFolders)? {
CtlResponse::SyncFolders { items } => items,
CtlResponse::Error { message, kind } => bail!("{}", cli_error(kind, &message)),
other => bail!("unexpected reply: {other:?}"),
};
let Some(folder) = folders
.iter()
.filter(|f| path.starts_with(&f.local_path))
.max_by_key(|f| f.local_path.len())
else {
bail!("{} is not in a synced folder", path.display());
};
if folder.mode != "mirror" {
println!(
"{} is online only; patterns apply only to folders kept on this computer.",
folder.local_path
);
return Ok(());
}
let root = PathBuf::from(&folder.local_path);
let rel = path.strip_prefix(&root).unwrap_or(&path).to_string_lossy();
let globals = dirs.load_config().resolved_ignore_patterns();
let rules = IgnoreRules::load(&root, &globals);
let source = |source: &RuleSource| match source {
RuleSource::AllFolders => "the patterns for all synced folders".to_string(),
RuleSource::ThisFolder => format!("{}/.pdfsignore", root.display()),
};
match rules.explain(&rel, path.is_dir()) {
Verdict::Synced => println!("Synced: no pattern matches it."),
Verdict::Excluded { pattern, source: s } => {
println!("Not synced: excluded by `{pattern}` in {}.", source(&s))
}
Verdict::Included { pattern, source: s } => {
println!("Synced: `{pattern}` in {} includes it again.", source(&s))
}
}
}
}
Ok(())
}
/// How long the oldest write may wait to upload before `diagnose` calls it
/// out. Under a day it is a slow link or a big file; past it, something is
/// holding the queue.
@@ -4646,6 +4776,21 @@ mod login_wait_tests {
Command::ImportGooglePhotos { resume: true, .. }
));
assert!(Cli::try_parse_from(["pdfs", "import-google-photos"]).is_err());
}
#[test]
fn sync_ignore_takes_a_pattern_that_looks_like_an_option_after_dashes() {
let cli = Cli::try_parse_from(["pdfs", "sync", "ignore", "add", "--", "-temp*"]).unwrap();
assert!(matches!(
cli.command,
Command::Sync {
action: SyncCmd::Ignore {
action: IgnoreCmd::Add { ref pattern }
}
} if pattern == "-temp*"
));
assert!(Cli::try_parse_from(["pdfs", "sync", "ignore", "add"]).is_err());
assert!(Cli::try_parse_from(["pdfs", "sync", "ignore", "reset"]).is_ok());
assert!(
Cli::try_parse_from(["pdfs", "import-google-photos", "--resume", "a.zip"]).is_err()
);
+2
View File
@@ -20,12 +20,14 @@ thiserror.workspace = true
tracing.workspace = true
directories.workspace = true
ignore.workspace = true
shell-words.workspace = true
sha2.workspace = true
sha1.workspace = true
zip.workspace = true
rusqlite.workspace = true
keyring-core.workspace = true
dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true
parking_lot.workspace = true
async-trait.workspace = true
libc.workspace = true
+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<()> {
let json = Zeroizing::new(serde_json::to_string(stored)?);
if replace_items() {
match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) {
crate::secretservice::Replaced::Saved => return Ok(()),
crate::secretservice::Replaced::Skipped(why) => {
tracing::debug!(%why, "not replacing the keyring item; writing it in place");
}
}
}
with_keyring(|entry| entry.set_password(&json))
}
/// Whether [`write_stored`] talks to the Secret Service directly: always,
/// except in tests that use the in-memory store.
#[cfg(not(test))]
fn replace_items() -> bool {
true
}
#[cfg(test)]
fn replace_items() -> bool {
tests::MOCK_STORE.lock().is_none()
}
/// 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.
pub fn load() -> Result<StoredSession> {
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.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 sink = register_refresh_handler(&session, stored.refresh_token.clone());
if let Some(tokens) = unsaved {
@@ -1082,8 +1123,11 @@ impl TokenSink {
) {
Rotation::Taken => {
write_stored(&stored)?;
tracing::info!(
refresh = %fingerprint(&tokens.refresh_token),
"successfully auto-persisted refreshed tokens in keyring"
);
state.stored_refresh = tokens.refresh_token;
tracing::info!("successfully auto-persisted refreshed tokens in keyring");
}
Rotation::MovedOn => {
tracing::info!(
@@ -1408,6 +1452,48 @@ mod tests {
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 {
serde_json::from_str(&blob("").replace(r#""r""#, &format!("{refresh:?}"))).unwrap()
}
+190 -54
View File
@@ -407,6 +407,116 @@ fn refuse_to_replace_unreadable(path: &Path) -> Result<()> {
}
}
/// [`AppDirs::load_config`] for the file at `path`.
fn load_config_at(path: &Path) -> AppConfig {
if path.exists() {
match std::fs::read_to_string(path)
.map_err(Error::from)
.and_then(|content| serde_json::from_str::<AppConfig>(&content).map_err(Error::from))
{
Ok(config) => return config,
Err(e) => {
// Preserve the original bytes for diagnosis/recovery. In
// particular, never replace a truncated config with defaults
// and silently lose mount, device, or ignore settings.
// `save_config` refuses to write over it for the same reason.
tracing::error!(path = %path.display(), error = %e, "config is unreadable; using in-memory defaults without overwriting it");
return AppConfig::default();
}
}
}
let default_config = AppConfig::default();
if let Err(e) = save_config_at(path, &default_config) {
tracing::warn!(path = %path.display(), error = %e, "could not write the default config");
}
default_config
}
/// [`AppDirs::save_config`] for the file at `path`.
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
refuse_to_replace_unreadable(path)?;
let parent = path
.parent()
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|duration| duration.as_nanos())
.unwrap_or(0);
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
use std::os::unix::fs::OpenOptionsExt as _;
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(&tmp)?;
use std::io::Write as _;
file.write_all(&serde_json::to_vec_pretty(config)?)?;
file.sync_all()?;
std::fs::rename(&tmp, path)?;
std::fs::File::open(parent)?.sync_all()?;
Ok(())
}
/// [`AppDirs::update_config`] for the file at `path`.
fn update_config_at<R>(path: &Path, change: impl FnOnce(&mut AppConfig) -> R) -> Result<R> {
let _lock = lock_config(path)?;
// Refuse before reading: an unreadable file loads as defaults, and the
// change must not be applied to those.
refuse_to_replace_unreadable(path)?;
let mut config = load_config_at(path);
let out = change(&mut config);
save_config_at(path, &config)?;
Ok(out)
}
/// How long [`lock_config`] waits for another writer. A change holds the lock
/// for one small read and write; anything longer is a stuck process, and the
/// setting is better reported as not saved than waited on forever.
const CONFIG_LOCK_WAIT: std::time::Duration = std::time::Duration::from_secs(5);
/// Take the lock that orders changes to the config file at `path`, held until
/// the returned file is dropped.
///
/// A separate `config.json.lock`, never the config file itself: that file is
/// replaced by a rename on every save, so a lock on it would guard a file
/// nobody reads any more.
fn lock_config(path: &Path) -> Result<std::fs::File> {
use std::os::fd::AsRawFd as _;
use std::os::unix::fs::OpenOptionsExt as _;
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut name = path.as_os_str().to_owned();
name.push(".lock");
let file = std::fs::OpenOptions::new()
.create(true)
.read(true)
.write(true)
.truncate(false)
.mode(0o600)
.open(PathBuf::from(name))?;
let deadline = std::time::Instant::now() + CONFIG_LOCK_WAIT;
loop {
// SAFETY: `file` owns the descriptor and outlives the call.
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0 {
return Ok(file);
}
let e = std::io::Error::last_os_error();
if e.raw_os_error() != Some(libc::EWOULDBLOCK) {
return Err(Error::Io(e));
}
if std::time::Instant::now() >= deadline {
return Err(Error::Other(format!(
"{} is being changed by another process; try again",
path.display()
)));
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
/// Resolved XDG locations for state, cache, and the default mountpoint.
pub struct AppDirs {
dirs: ProjectDirs,
@@ -426,65 +536,33 @@ impl AppDirs {
/// Load config from disk, creating default if missing.
pub fn load_config(&self) -> AppConfig {
let path = self.config_path();
if path.exists() {
match std::fs::read_to_string(&path)
.map_err(Error::from)
.and_then(|content| {
serde_json::from_str::<AppConfig>(&content).map_err(Error::from)
}) {
Ok(config) => return config,
Err(e) => {
// Preserve the original bytes for diagnosis/recovery. In
// particular, never replace a truncated config with defaults
// and silently lose mount, device, or ignore settings.
// `save_config` refuses to write over it for the same reason.
tracing::error!(path = %path.display(), error = %e, "config is unreadable; using in-memory defaults without overwriting it");
return AppConfig::default();
}
}
}
let default_config = AppConfig::default();
if let Err(e) = self.save_config(&default_config) {
tracing::warn!(path = %path.display(), error = %e, "could not write the default config");
}
default_config
load_config_at(&self.config_path())
}
/// Persist `config` to [`config_path`](Self::config_path), creating the
/// config dir if missing. The Settings page calls this after editing the
/// cache budget or mountpoint; the daemon re-reads the file on its next mount.
/// config dir if missing.
///
/// Refuses while the file on disk does not parse. Every caller loads,
/// changes one field and saves, and [`load_config`](Self::load_config)
/// gives defaults for a file it cannot read, so the first change after
/// the file was damaged wrote defaults over the mountpoint, the device and
/// the ignore rules the user had (`docs/BUGS.md` B223).
/// Refuses while the file on disk does not parse: [`load_config`](Self::load_config)
/// gives defaults for a file it cannot read, so the first change after the
/// file was damaged would write defaults over the mountpoint, the device
/// and the ignore rules the user had (`docs/BUGS.md` B223).
///
/// Writes the whole file. To change a setting, use
/// [`update_config`](Self::update_config), which does not lose another
/// process's change.
pub fn save_config(&self, config: &AppConfig) -> Result<()> {
let path = self.config_path();
refuse_to_replace_unreadable(&path)?;
let parent = path
.parent()
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
std::fs::create_dir_all(parent)?;
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|duration| duration.as_nanos())
.unwrap_or(0);
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
use std::os::unix::fs::OpenOptionsExt as _;
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(&tmp)?;
use std::io::Write as _;
file.write_all(&serde_json::to_vec_pretty(config)?)?;
file.sync_all()?;
std::fs::rename(&tmp, &path)?;
std::fs::File::open(parent)?.sync_all()?;
Ok(())
save_config_at(&self.config_path(), config)
}
/// Change settings in place: read the file, apply `change`, write it back,
/// all under a lock, and return what `change` returned.
///
/// The app, the tray and the daemon each write the file. Without the lock,
/// two of them changing different settings at once both read the old file,
/// and the one that wrote last undid the other's change (`docs/BUGS.md`
/// B292).
pub fn update_config<R>(&self, change: impl FnOnce(&mut AppConfig) -> R) -> Result<R> {
update_config_at(&self.config_path(), change)
}
/// This machine's id (e.g. ~/.config/proton-drive-linux/machine-id). See
@@ -682,6 +760,64 @@ mod tests {
std::fs::metadata(p).unwrap().permissions().mode() & 0o777
}
/// Two writers changing different settings at once both keep their change
/// (`docs/BUGS.md` B292).
#[test]
fn concurrent_changes_to_different_settings_are_all_kept() {
let dir = std::env::temp_dir().join(format!(
"pdfs-cfg-race-{}-{:?}",
std::process::id(),
std::thread::current().id()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
let a = {
let path = path.clone();
std::thread::spawn(move || {
for i in 1..=100u64 {
update_config_at(&path, |c| c.upload_limit = Some(i)).unwrap();
}
})
};
let b = {
let path = path.clone();
std::thread::spawn(move || {
for i in 1..=100u64 {
update_config_at(&path, |c| c.download_limit = Some(i)).unwrap();
}
})
};
a.join().unwrap();
b.join().unwrap();
let config = load_config_at(&path);
assert_eq!(config.upload_limit, Some(100));
assert_eq!(config.download_limit, Some(100));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_change_is_never_applied_over_an_unreadable_config() {
let dir = std::env::temp_dir().join(format!(
"pdfs-cfg-update-guard-{}-{:?}",
std::process::id(),
std::thread::current().id()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("config.json");
std::fs::write(&path, br#"{"mountpoint": "/home/me/Pro"#).unwrap();
assert!(update_config_at(&path, |c| c.tray_hidden = true).is_err());
assert_eq!(
std::fs::read(&path).unwrap(),
br#"{"mountpoint": "/home/me/Pro"#
);
let _ = std::fs::remove_dir_all(&dir);
}
/// A damaged config must not be replaced by defaults the next time a
/// setting changes (`docs/BUGS.md` B223).
#[test]
+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
/// left behind carries no state — the lock lives in the kernel and dies with
/// 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>> {
if is_in_memory(path) {
return Ok(None);
@@ -456,22 +463,32 @@ fn acquire_single_writer_lock(path: &Path) -> Result<Option<File>> {
.truncate(false)
.write(true)
.open(&lock_path)?;
// 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 {
let deadline = std::time::Instant::now() + LOCK_RETRY;
loop {
// 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();
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!(
"another Proton Drive daemon is already using {} — \
stop it first (`systemctl --user stop proton-drive.service`)",
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 {
let mut name = path.as_os_str().to_owned();
name.push(".lock");
+1
View File
@@ -23,6 +23,7 @@ pub mod places;
pub mod profile;
pub mod sdkcache;
pub mod search;
mod secretservice;
pub mod service;
pub mod shell;
pub mod similar;
+56 -12
View File
@@ -206,26 +206,23 @@ pub fn reap(mut child: std::process::Child) {
});
}
/// [`open`] with the policy from the user's `config.json`, read once per
/// process. For callers that open the occasional path and have no reason to
/// carry a policy around; long-lived windows should hold their own copy.
/// [`open`] with the policy from the user's `config.json`, read again on
/// every call: the file is small, a path is opened by hand, and a rule changed
/// in Preferences then applies to the next file opened, without a restart.
pub fn open_default(path: &Path, is_dir: bool) {
open(default_policy(), path, is_dir);
open(&default_policy(), path, is_dir);
}
/// [`open_default`] matching the rules against `name` — see
/// [`OpenWith::command_for_named`].
pub fn open_default_named(path: &Path, name: &str, is_dir: bool) {
open_named(default_policy(), path, name, is_dir);
open_named(&default_policy(), path, name, is_dir);
}
fn default_policy() -> &'static OpenWith {
static POLICY: std::sync::OnceLock<OpenWith> = std::sync::OnceLock::new();
POLICY.get_or_init(|| {
crate::config::AppDirs::new()
.map(|dirs| dirs.load_config().resolved_open_with())
.unwrap_or_default()
})
fn default_policy() -> OpenWith {
crate::config::AppDirs::new()
.map(|dirs| dirs.load_config().resolved_open_with())
.unwrap_or_default()
}
/// `$PDFS_TERMINAL`, then `$TERMINAL`, then the first [`KNOWN_TERMINALS`] entry
@@ -266,6 +263,33 @@ fn with_exec_flag(program: &str) -> Vec<String> {
argv
}
/// Split a command line typed by the user into argv, the way a shell would:
/// quotes keep spaces, nothing is expanded. `None` for an unclosed quote.
pub fn parse_command(line: &str) -> Option<Vec<String>> {
shell_words::split(line).ok()
}
/// Show `argv` as one line that [`parse_command`] turns back into it.
pub fn format_command(argv: &[String]) -> String {
shell_words::join(argv)
}
/// Whether the program `argv` starts with can be found: an absolute or
/// relative path to a file, or a name on `PATH`. A `$VAR` program counts as
/// found, since it is looked up only when a file is opened.
pub fn command_available(argv: &[String]) -> bool {
let Some(program) = argv.first() else {
return false;
};
if program.starts_with('$') {
return true;
}
if program.contains('/') {
return Path::new(program).is_file();
}
on_path(program)
}
fn on_path(program: &str) -> bool {
let Some(path) = std::env::var_os("PATH") else {
return false;
@@ -703,4 +727,24 @@ mod tests {
// Unknown terminals get the near-universal `-e`.
assert_eq!(with_exec_flag("mystery-term"), vec!["mystery-term", "-e"]);
}
#[test]
fn a_typed_command_line_round_trips() {
let argv = parse_command("alacritty -e 'my editor' --flag").unwrap();
assert_eq!(argv, ["alacritty", "-e", "my editor", "--flag"]);
assert_eq!(parse_command(&format_command(&argv)).unwrap(), argv);
assert_eq!(parse_command("nvim 'unclosed"), None);
assert_eq!(parse_command(" ").unwrap(), Vec::<String>::new());
}
#[test]
fn a_command_is_available_when_its_program_is() {
assert!(command_available(&["sh".to_string()]));
assert!(command_available(&["$EDITOR".to_string()]));
assert!(!command_available(&[]));
assert!(!command_available(
&["pdfs-no-such-program-xyz".to_string()]
));
assert!(!command_available(&["/nonexistent/program".to_string()]));
}
}
+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);
}
}
+384
View File
@@ -30,6 +30,11 @@ use ignore::gitignore::{Gitignore, GitignoreBuilder};
/// them. Version-control metadata, dependency and build trees, editor
/// leftovers, and OS turds — none of which belong on Drive, all of which are
/// large or rewritten constantly.
///
/// The second half is what Nextcloud, Dropbox and Syncthing leave out as well:
/// files a desktop, a file system or a program in the middle of a write leaves
/// behind, never anything a person made. Every one is in a test, next to a real
/// file of a similar name that must stay synced.
pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[
".git/",
".hg/",
@@ -43,6 +48,23 @@ pub const DEFAULT_IGNORE_PATTERNS: &[&str] = &[
"*.tmp",
".DS_Store",
"Thumbs.db",
// Folder settings of Windows and KDE's Dolphin.
"desktop.ini",
".directory",
// Trash folders and file-system leftovers: a file deleted while open on a
// FUSE or NFS mount lives on under one of these names until it is closed.
".Trash-*/",
".Trashes/",
".Spotlight-V100/",
".fuse_hidden*",
".nfs*",
// Downloads and saves still being written.
"*.part",
"*.crdownload",
"*.kate-swp",
// Office lock files: LibreOffice's `.~lock.<name>#`, Microsoft Office's `~$<name>`.
".~lock.*#",
"~$*",
];
/// Suffixes that mean a file is incomplete *by construction*: only the program
@@ -119,6 +141,149 @@ pub fn is_scratch_name(name: &str) -> bool {
/// Filenames accepted as a folder's ignore file, in precedence order.
const IGNORE_FILE_NAMES: &[&str] = &[".pdfsignore", ".protonignore"];
/// Whether `line` is a rule [`IgnoreRules::load`] accepts: a pattern, a
/// comment or a blank line. The error says what is wrong with it.
pub fn check_pattern(line: &str) -> Result<(), String> {
GitignoreBuilder::new("/")
.add_line(None, line)
.map(|_| ())
.map_err(|e| e.to_string())
}
/// The lines of an ignore file that [`IgnoreRules::load`] would skip, by line
/// number (from 1), with what is wrong with each.
pub fn check_rules(text: &str) -> Vec<(usize, String)> {
text.lines()
.enumerate()
.filter_map(|(i, line)| check_pattern(line).err().map(|e| (i + 1, e)))
.collect()
}
/// A synced folder's own ignore file, read so it can be edited and written
/// back. See [`FolderRules::read`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FolderRules {
/// The file the rules are in: the one in use, or `.pdfsignore` when there
/// is none yet.
pub path: std::path::PathBuf,
/// The rules as read; empty when there is no file. `None` means there was
/// no file, which [`write`](Self::write) checks is still so.
pub text: Option<String>,
}
/// Why [`FolderRules::write`] did not write.
#[derive(Debug)]
pub enum WriteRulesError {
/// The file changed after it was read, for example by an edit on another
/// computer that sync brought in. The rules on disk are the new ones.
Changed,
/// Reading or writing failed.
Io(std::io::Error),
}
impl std::fmt::Display for WriteRulesError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Changed => f.write_str("the file changed since it was opened"),
Self::Io(e) => e.fmt(f),
}
}
}
impl std::error::Error for WriteRulesError {}
impl From<std::io::Error> for WriteRulesError {
fn from(e: std::io::Error) -> Self {
Self::Io(e)
}
}
impl FolderRules {
/// Read the ignore file of the folder at `root`, the same one
/// [`IgnoreRules::load`] uses.
pub fn read(root: &Path) -> std::io::Result<Self> {
for name in IGNORE_FILE_NAMES {
let path = root.join(name);
match std::fs::read_to_string(&path) {
Ok(text) => {
return Ok(Self {
path,
text: Some(text),
});
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => continue,
Err(e) => return Err(e),
}
}
// Like `load`, a missing folder reads as one without rules; the write
// is what fails then.
Ok(Self {
path: root.join(IGNORE_FILE_NAMES[0]),
text: None,
})
}
/// Replace the rules with `text`, unless the file changed since it was
/// read. Rules that are all blank remove the file, so a folder never keeps
/// an empty one around.
///
/// Written to a temporary file and renamed over the old one, so the sync
/// pass reading the rules at the same moment sees the old ones or the new
/// ones, never half of them.
pub fn write(&self, text: &str) -> Result<(), WriteRulesError> {
let now = match std::fs::read_to_string(&self.path) {
Ok(now) => Some(now),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
Err(e) => return Err(e.into()),
};
if now != self.text {
return Err(WriteRulesError::Changed);
}
if text.trim().is_empty() {
return match std::fs::remove_file(&self.path) {
Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(e.into()),
_ => Ok(()),
};
}
let Some(name) = self.path.file_name() else {
return Err(std::io::Error::other("the rules path has no file name").into());
};
let mut tmp_name = std::ffi::OsString::from(".");
tmp_name.push(name);
tmp_name.push(format!(".tmp-{}", std::process::id()));
let tmp = self.path.with_file_name(tmp_name);
let mut body = text.to_string();
if !body.ends_with('\n') {
body.push('\n');
}
let written = std::fs::write(&tmp, body).and_then(|()| std::fs::rename(&tmp, &self.path));
if written.is_err() {
let _ = std::fs::remove_file(&tmp);
}
Ok(written?)
}
}
/// Where a rule that decided about a path came from.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RuleSource {
/// The rules for every synced folder (`ignore_patterns`).
AllFolders,
/// The folder's own ignore file.
ThisFolder,
}
/// What the rules say about one path, and which rule says it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Verdict {
/// No rule matches: the path is synced.
Synced,
/// Left out by `pattern`. `pattern` may name a folder the path is in.
Excluded { pattern: String, source: RuleSource },
/// A rule excluded it, and a later `!pattern` brought it back.
Included { pattern: String, source: RuleSource },
}
/// Compiled ignore rules for one synced folder.
pub struct IgnoreRules {
matcher: Option<Gitignore>,
@@ -161,6 +326,27 @@ impl IgnoreRules {
}
}
/// [`load`](Self::load) with `text` standing in for the folder's ignore
/// file, for showing what rules being edited would do before they are
/// saved.
pub fn with_folder_text(root: &Path, globals: &[String], text: &str) -> Self {
let mut builder = GitignoreBuilder::new(root);
let mut any = false;
for pattern in globals {
any |= builder.add_line(None, pattern).is_ok();
}
let file = root.join(IGNORE_FILE_NAMES[0]);
for line in text.lines() {
any |= builder.add_line(Some(file.clone()), line).is_ok();
}
if !any {
return Self { matcher: None };
}
Self {
matcher: builder.build().ok(),
}
}
/// Rules matching nothing, for callers with no folder context.
pub fn empty() -> Self {
Self { matcher: None }
@@ -207,6 +393,50 @@ impl IgnoreRules {
}
}
impl IgnoreRules {
/// What the rules say about `rel`, and which rule decides, the way
/// [`is_ignored`](Self::is_ignored) decides it.
pub fn explain(&self, rel: &str, is_dir: bool) -> Verdict {
let Some(matcher) = &self.matcher else {
return Verdict::Synced;
};
let rel = rel.trim_matches('/');
if rel.is_empty() {
return Verdict::Synced;
}
let source = |glob: &ignore::gitignore::Glob| match glob.from() {
Some(_) => RuleSource::ThisFolder,
None => RuleSource::AllFolders,
};
let mut prefix = String::new();
let mut parts = rel.split('/').peekable();
while let Some(part) = parts.next() {
if !prefix.is_empty() {
prefix.push('/');
}
prefix.push_str(part);
let last = parts.peek().is_none();
let as_dir = if last { is_dir } else { true };
match matcher.matched(&prefix, as_dir) {
ignore::Match::Ignore(glob) => {
return Verdict::Excluded {
pattern: glob.original().to_string(),
source: source(glob),
};
}
ignore::Match::Whitelist(glob) if last => {
return Verdict::Included {
pattern: glob.original().to_string(),
source: source(glob),
};
}
_ => {}
}
}
Verdict::Synced
}
}
impl std::fmt::Debug for IgnoreRules {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("IgnoreRules")
@@ -255,6 +485,160 @@ mod tests {
std::fs::write(root.join(name), body).unwrap();
}
#[test]
fn the_added_defaults_leave_out_clutter_but_not_look_alikes() {
let dir = TempDir::new();
let rules = IgnoreRules::load(dir.path(), &globals());
for (clutter, is_dir) in [
("desktop.ini", false),
("Photos/.directory", false),
(".Trash-1000", true),
(".Trashes", true),
(".Spotlight-V100", true),
(".fuse_hidden0000001a00000002", false),
(".nfs000000000123abcd", false),
("movie.mkv.part", false),
("setup.exe.crdownload", false),
("notes.txt.kate-swp", false),
(".~lock.report.odt#", false),
("~$budget.xlsx", false),
] {
assert!(rules.is_ignored(clutter, is_dir), "{clutter}");
}
for kept in [
"Desktop/notes.txt",
"directory.txt",
"Trash-talk.md",
"nfs-setup.md",
"parts.csv",
"part.txt",
"report.odt",
"budget.xlsx",
] {
assert!(!rules.is_ignored(kept, false), "{kept}");
}
}
#[test]
fn a_bad_pattern_is_reported_with_its_line() {
assert!(check_pattern("*.db").is_ok());
assert!(check_pattern("# a comment").is_ok());
assert!(check_pattern("").is_ok());
assert!(check_pattern("*.{jpg,png").is_err());
assert!(check_pattern("[z-a]").is_err());
let bad = check_rules("*.log\n{oops\nbuild/\n");
assert_eq!(bad.len(), 1);
assert_eq!(bad[0].0, 2);
}
#[test]
fn explain_names_the_rule_and_where_it_came_from() {
let dir = TempDir::new();
write(dir.path(), ".pdfsignore", "*.db\n!keep.tmp\n");
let rules = IgnoreRules::load(dir.path(), &globals());
assert_eq!(
rules.explain("data/cache.db", false),
Verdict::Excluded {
pattern: "*.db".into(),
source: RuleSource::ThisFolder
}
);
assert_eq!(
rules.explain("app/node_modules/x/index.js", false),
Verdict::Excluded {
pattern: "node_modules/".into(),
source: RuleSource::AllFolders
}
);
assert_eq!(
rules.explain("keep.tmp", false),
Verdict::Included {
pattern: "!keep.tmp".into(),
source: RuleSource::ThisFolder
}
);
assert_eq!(rules.explain("src/main.rs", false), Verdict::Synced);
// `explain` and `is_ignored` never disagree.
for (path, is_dir) in [
("data/cache.db", false),
("keep.tmp", false),
("x.tmp", false),
] {
assert_eq!(
rules.is_ignored(path, is_dir),
matches!(rules.explain(path, is_dir), Verdict::Excluded { .. }),
"{path}"
);
}
}
#[test]
fn rules_being_edited_explain_like_the_saved_ones() {
let dir = TempDir::new();
let text = "*.db\n!keep.db\n";
write(dir.path(), ".pdfsignore", text);
let saved = IgnoreRules::load(dir.path(), &globals());
let edited = IgnoreRules::with_folder_text(dir.path(), &globals(), text);
for path in ["a.db", "keep.db", "node_modules/x", "src/x.rs"] {
assert_eq!(
saved.explain(path, false),
edited.explain(path, false),
"{path}"
);
}
}
#[test]
fn folder_rules_are_written_back_and_removed_when_blank() {
let dir = TempDir::new();
let rules = FolderRules::read(dir.path()).unwrap();
assert_eq!(rules.text, None);
assert_eq!(rules.path, dir.path().join(".pdfsignore"));
rules.write("*.db").unwrap();
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"*.db\n"
);
assert!(IgnoreRules::load(dir.path(), &[]).is_ignored("x.db", false));
let rules = FolderRules::read(dir.path()).unwrap();
rules.write(" \n").unwrap();
assert!(!dir.path().join(".pdfsignore").exists());
}
#[test]
fn folder_rules_keep_the_file_name_in_use() {
let dir = TempDir::new();
write(dir.path(), ".protonignore", "old/\n");
let rules = FolderRules::read(dir.path()).unwrap();
assert_eq!(rules.path, dir.path().join(".protonignore"));
rules.write("new/\n").unwrap();
assert!(!dir.path().join(".pdfsignore").exists());
assert_eq!(
std::fs::read_to_string(dir.path().join(".protonignore")).unwrap(),
"new/\n"
);
}
#[test]
fn folder_rules_changed_elsewhere_are_not_written_over() {
let dir = TempDir::new();
write(dir.path(), ".pdfsignore", "a/\n");
let rules = FolderRules::read(dir.path()).unwrap();
write(dir.path(), ".pdfsignore", "b/\n");
assert!(matches!(rules.write("c/"), Err(WriteRulesError::Changed)));
assert_eq!(
std::fs::read_to_string(dir.path().join(".pdfsignore")).unwrap(),
"b/\n"
);
// A file that appeared after an empty read counts as a change too.
let dir = TempDir::new();
let rules = FolderRules::read(dir.path()).unwrap();
write(dir.path(), ".pdfsignore", "b/\n");
assert!(matches!(rules.write("c/"), Err(WriteRulesError::Changed)));
}
#[test]
fn no_rules_at_all_ignores_nothing() {
let dir = TempDir::new();
+7 -9
View File
@@ -1320,11 +1320,9 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
core.cache.set_budget(bytes);
// Persist so the next mount keeps the new cap. Best-effort: a config
// write failure is reported but the live cap is already applied.
match AppDirs::new().map(|dirs| {
let mut cfg = dirs.load_config();
cfg.cache_budget = Some(bytes);
dirs.save_config(&cfg)
}) {
match AppDirs::new()
.map(|dirs| dirs.update_config(|cfg| cfg.cache_budget = Some(bytes)))
{
Ok(Ok(())) => {
core.touch_profile();
CtlResponse::Ok {
@@ -1344,10 +1342,10 @@ fn handle_control_conn(core: &Core, username: &str, mountpoint: &Path, stream: U
// Persisted like the cache budget: best-effort, the live caps are
// already applied.
match AppDirs::new().map(|dirs| {
let mut cfg = dirs.load_config();
cfg.upload_limit = Some(upload);
cfg.download_limit = Some(download);
dirs.save_config(&cfg)
dirs.update_config(|cfg| {
cfg.upload_limit = Some(upload);
cfg.download_limit = Some(download);
})
}) {
Ok(Ok(())) => CtlResponse::Ok {
message: format!(
+1 -3
View File
@@ -123,9 +123,7 @@ pub(crate) fn sync_root_reserved() -> pdfs_core::syncroot::Reserved {
pub(crate) fn set_adopted_device_uid(uid: Option<&str>) -> CoreResult<()> {
let dirs = pdfs_core::config::AppDirs::new()
.map_err(|e| CoreError::internal(format!("config dirs: {e}")))?;
let mut cfg = dirs.load_config();
cfg.device_uid = uid.map(|u| u.to_string());
dirs.save_config(&cfg)
dirs.update_config(|cfg| cfg.device_uid = uid.map(|u| u.to_string()))
.map_err(|e| CoreError::internal(format!("write config: {e}")))
}
+32 -5
View File
@@ -26,6 +26,8 @@ use pages::photo_viewer::*;
use pages::photos::*;
use pages::places::*;
use pages::places_map::*;
use pages::preferences_apps::*;
use pages::preferences_sync::*;
use pages::shared::*;
use pages::shared_by_me::*;
use pages::status::*;
@@ -39,6 +41,7 @@ use widgets::compat::*;
use widgets::crumb::*;
use widgets::details::*;
use widgets::file_list::*;
use widgets::ignore_dialog::*;
use widgets::menu::*;
use widgets::photo_drag::*;
use widgets::player::*;
@@ -307,6 +310,18 @@ fn sync_view(page: &str) -> Option<&'static str> {
}
}
/// The Preferences page a `--page` name opens: "preferences" and
/// "preferences-" followed by the page's name.
fn preferences_page(page: &str) -> Option<&'static str> {
match page {
"preferences" | "preferences-general" => Some("general"),
"preferences-sync" => Some("sync"),
"preferences-apps" => Some("apps"),
"preferences-storage" => Some("storage"),
_ => None,
}
}
/// The Photos view a `--page` name opens, and whether Places shows its map:
/// "albums", "places" and "places-map". Other names are stack pages.
fn photos_view(page: &str) -> Option<(u32, bool)> {
@@ -710,6 +725,8 @@ fn build_window(app: &adw::Application) {
&main_widgets.purge_button,
&main_widgets.mountpoint_button,
);
wire_sync_prefs(&ui, main_widgets.sync_prefs);
wire_apps_prefs(&ui, main_widgets.apps_prefs);
wire_sidebar(&ui);
wire_browser(&ui);
wire_bulk(
@@ -868,12 +885,10 @@ fn save_window_state(ui: &Ui, window: &adw::ApplicationWindow) {
height,
maximized: window.is_maximized(),
};
let mut config = ui.dirs.load_config();
if config.window == state {
if ui.dirs.load_config().window == state {
return;
}
config.window = state;
if let Err(e) = ui.dirs.save_config(&config) {
if let Err(e) = ui.dirs.update_config(|config| config.window = state) {
tracing::warn!("cannot save the window size: {e}");
}
}
@@ -1471,7 +1486,10 @@ fn install_launch_actions(ui: &Rc<Ui>, app: &adw::Application, window: &adw::App
show_login(&ui_page);
return;
}
if let Some(view) = sync_view(page) {
if let Some(name) = preferences_page(page) {
ui_page.status.prefs.set_visible_page_name(name);
ui_page.status.prefs.present(ui_window(&ui_page).as_ref());
} else if let Some(view) = sync_view(page) {
ui_page.locations.views.set_visible_child_name(view);
ui_page.stack.set_visible_child_name("locations");
} else if let Some((view, map)) = photos_view(page) {
@@ -2055,6 +2073,15 @@ mod tests {
assert_eq!(sync_view("locations"), None);
}
#[test]
fn a_page_name_can_open_a_preferences_page() {
assert_eq!(preferences_page("preferences"), Some("general"));
assert_eq!(preferences_page("preferences-sync"), Some("sync"));
assert_eq!(preferences_page("preferences-apps"), Some("apps"));
assert_eq!(preferences_page("preferences-storage"), Some("storage"));
assert_eq!(preferences_page("sync"), None);
}
/// One file of a shot, for the group-switch tests.
fn member(uid: &str, name: Option<&str>, kind: PhotoKind) -> PhotoItem {
PhotoItem {
+6 -6
View File
@@ -1431,9 +1431,11 @@ fn save_icon_size(ui: &Rc<Ui>, size: i32) {
let ui_save = ui.clone();
let source = glib::timeout_add_local_once(Duration::from_millis(500), move || {
ui_save.browser.zoom_save.borrow_mut().take();
let mut config = ui_save.dirs.load_config();
config.files_view.icon_size = ui_save.browser.view.get().icon_size;
if let Err(e) = ui_save.dirs.save_config(&config) {
let icon_size = ui_save.browser.view.get().icon_size;
if let Err(e) = ui_save
.dirs
.update_config(|config| config.files_view.icon_size = icon_size)
{
tracing::warn!("cannot save the icon size: {e}");
}
});
@@ -1464,9 +1466,7 @@ pub(crate) fn set_files_view(ui: &Rc<Ui>, view: FilesView) {
return;
}
apply_files_view(ui, view);
let mut config = ui.dirs.load_config();
config.files_view = view;
if let Err(e) = ui.dirs.save_config(&config) {
if let Err(e) = ui.dirs.update_config(|config| config.files_view = view) {
toast_error(ui, &gettext("Couldn't save the view"), &e.to_string());
}
if (old.sort, old.descending, old.folders_first)
@@ -1498,6 +1498,7 @@ fn folder_mode_label(ondemand: bool) -> String {
/// synced folder's menu.
fn add_device_items(ui: &Rc<Ui>, menu: &mut ActionMenu, spec: &MountSpec, id: i64) {
if spec.mode != MountMode::OnDemand {
let ui_ignore = ui.clone();
// A paused folder skips its passes, so Sync now would do nothing.
if !spec.paused {
let ui = ui.clone();
@@ -1516,6 +1517,14 @@ fn add_device_items(ui: &Rc<Ui>, menu: &mut ActionMenu, spec: &MountSpec, id: i6
menu.item(&gettext("Sync From Scratch…"), move || {
confirm_reset_sync_folder(&ui, id, &path)
});
// Only a synced copy has local files for the rules to leave out.
if spec.mode == MountMode::Mirror {
let ui = ui_ignore;
let root = PathBuf::from(&spec.local_path);
menu.item(&gettext("Excluded Files…"), move || {
present_ignore_dialog(&ui, id, root.clone())
});
}
menu.section();
}
let ui = ui.clone();
+2
View File
@@ -12,6 +12,8 @@ pub(crate) mod photo_viewer;
pub(crate) mod photos;
pub(crate) mod places;
pub(crate) mod places_map;
pub(crate) mod preferences_apps;
pub(crate) mod preferences_sync;
pub(crate) mod shared;
pub(crate) mod shared_by_me;
pub(crate) mod status;
+5 -4
View File
@@ -2129,16 +2129,17 @@ fn save_photos_view(ui: &Rc<Ui>) {
let ui_save = ui.clone();
let source = glib::timeout_add_local_once(Duration::from_millis(500), move || {
ui_save.gallery.zoom_save.borrow_mut().take();
let mut config = ui_save.dirs.load_config();
let view = PhotosView {
row_height: Some(ui_save.gallery.row_height.get()),
square: ui_save.gallery.square.get(),
};
if config.photos_view == view {
if ui_save.dirs.load_config().photos_view == view {
return;
}
config.photos_view = view;
if let Err(e) = ui_save.dirs.save_config(&config) {
if let Err(e) = ui_save
.dirs
.update_config(|config| config.photos_view = view)
{
tracing::warn!("cannot save the Photos view: {e}");
}
});
@@ -0,0 +1,606 @@
//! Preferences → Apps: which program opens which file (`open_with`) and how
//! the search launcher shows itself (`prompt`).
//!
//! Neither involves the service. The app and the search launcher read both
//! again each time they open something, so a change applies to the next file
//! opened or the next search.
use crate::*;
use pdfs_core::menu::{PromptConfig, PromptMode};
use pdfs_core::opener::{
OpenRule, OpenWith, command_available, format_command, parse_command, resolve_terminal,
};
/// The widgets of the Apps page, built with the rest of the dialog and wired
/// once the app's state exists.
pub(crate) struct AppsPrefs {
pub(crate) page: adw::PreferencesPage,
rules: adw::PreferencesGroup,
add_rule: gtk4::Button,
other_row: adw::EntryRow,
terminal_row: adw::EntryRow,
mode_row: adw::ComboRow,
menu_row: adw::EntryRow,
prompt_terminal_row: adw::EntryRow,
limit_row: adw::SpinRow,
icons_row: adw::SwitchRow,
}
/// The launcher modes in the order the combo row lists them.
const MODES: [PromptMode; 3] = [PromptMode::Gtk, PromptMode::Dmenu, PromptMode::Fzf];
/// The file classes a rule can name, with what the dialog calls them.
fn classes() -> [(&'static str, String); 6] {
[
("@text", gettext("Text")),
("@document", gettext("Documents")),
("@image", gettext("Images")),
("@media", gettext("Audio and Video")),
("@dir", gettext("Folders")),
("@any", gettext("Everything")),
]
}
pub(crate) fn build_apps_prefs() -> AppsPrefs {
let add_rule = gtk4::Button::builder()
.label(gettext("Add Rule…"))
.valign(gtk4::Align::Center)
.build();
add_rule.add_css_class("flat");
let rules = adw::PreferencesGroup::builder()
.title(gettext("Open Files With"))
.description(gettext(
"For files opened from Proton Drive and the search launcher. The first rule that matches a file decides; other files open in their default app.",
))
.header_suffix(&add_rule)
.build();
let other_row = adw::EntryRow::builder()
.title(gettext("Other files (empty: default app)"))
.show_apply_button(true)
.build();
other_row.add_css_class("monospace");
let terminal_row = adw::EntryRow::builder()
.title(terminal_title())
.show_apply_button(true)
.build();
terminal_row.add_css_class("monospace");
let other = adw::PreferencesGroup::new();
other.add(&other_row);
other.add(&terminal_row);
let mode_row = adw::ComboRow::builder()
.title(gettext("Opens as"))
.model(&gtk4::StringList::new(&[
&gettext("Window"),
&gettext("Your Launcher"),
&gettext("fzf in a Terminal"),
]))
.build();
let menu_row = adw::EntryRow::builder()
.title(gettext("Launcher command (empty: find one)"))
.show_apply_button(true)
.build();
menu_row.add_css_class("monospace");
let prompt_terminal_row = adw::EntryRow::builder()
.title(terminal_title())
.show_apply_button(true)
.build();
prompt_terminal_row.add_css_class("monospace");
let limit_row = adw::SpinRow::builder()
.title(gettext("Results shown"))
.adjustment(&gtk4::Adjustment::new(
pdfs_core::menu::DEFAULT_MENU_LIMIT as f64,
5.0,
500.0,
5.0,
25.0,
0.0,
))
.build();
let icons_row = adw::SwitchRow::builder()
.title(gettext("Show icons"))
.subtitle(gettext("When the launcher can show them"))
.build();
let launcher = adw::PreferencesGroup::builder()
.title(gettext("Search Launcher"))
.description(gettext(
"How “pdfs-prompt” shows search results, for example from a keyboard shortcut. Your launcher can be any program that reads choices like dmenu, such as rofi, wofi, fuzzel or bemenu.",
))
.build();
launcher.add(&mode_row);
launcher.add(&menu_row);
launcher.add(&prompt_terminal_row);
launcher.add(&limit_row);
launcher.add(&icons_row);
let page = adw::PreferencesPage::builder()
.title(gettext("Apps"))
.name("apps")
.icon_name("application-x-executable-symbolic")
.build();
page.add(&rules);
page.add(&other);
page.add(&launcher);
AppsPrefs {
page,
rules,
add_rule,
other_row,
terminal_row,
mode_row,
menu_row,
prompt_terminal_row,
limit_row,
icons_row,
}
}
/// "Terminal", naming the one used when the row is left empty.
fn terminal_title() -> String {
match resolve_terminal() {
// Translators: {terminal} is a terminal command line such as "foot -e".
Some(found) => gettext_f(
"Terminal (empty: {terminal})",
&[("terminal", &format_command(&found))],
),
None => gettext("Terminal"),
}
}
/// Shared by every handler of the page.
struct Apps {
ui: Rc<Ui>,
widgets: AppsPrefs,
rule_rows: RefCell<Vec<adw::ActionRow>>,
}
/// Fill the page from the config and connect its controls.
pub(crate) fn wire_apps_prefs(ui: &Rc<Ui>, widgets: AppsPrefs) {
let apps = Rc::new(Apps {
ui: ui.clone(),
widgets,
rule_rows: RefCell::default(),
});
let config = ui.dirs.load_config();
let open_with = config.resolved_open_with();
let prompt = config.resolved_prompt();
let w = &apps.widgets;
let suppress = ui.status.settings_suppress.replace(true);
paint_rules(&apps, &open_with);
w.other_row
.set_text(&format_command(open_with.default.as_deref().unwrap_or(&[])));
w.terminal_row.set_text(&format_command(
open_with.terminal.as_deref().unwrap_or(&[]),
));
let mode = prompt.resolved_mode();
w.mode_row
.set_selected(MODES.iter().position(|m| *m == mode).unwrap_or_default() as u32);
w.menu_row
.set_text(&format_command(prompt.menu.as_deref().unwrap_or(&[])));
w.prompt_terminal_row
.set_text(&format_command(prompt.terminal.as_deref().unwrap_or(&[])));
w.limit_row.set_value(prompt.resolved_menu_limit() as f64);
w.icons_row.set_active(prompt.resolved_menu_icons());
show_mode_rows(w, mode);
ui.status.settings_suppress.set(suppress);
let a = apps.clone();
w.add_rule
.connect_clicked(move |_| edit_rule(&a, None, OpenRule::default()));
// Command lines: checked as typed, saved on apply. Empty means "unset".
connect_command_row(&apps, &w.other_row, |config, argv| {
open_with_of(config).default = argv;
});
connect_command_row(&apps, &w.terminal_row, |config, argv| {
open_with_of(config).terminal = argv;
});
connect_command_row(&apps, &w.menu_row, |config, argv| {
prompt_of(config).menu = argv;
});
connect_command_row(&apps, &w.prompt_terminal_row, |config, argv| {
prompt_of(config).terminal = argv;
});
let a = apps.clone();
w.mode_row.connect_selected_notify(move |row| {
if a.ui.status.settings_suppress.get() {
return;
}
let mode = MODES
.get(row.selected() as usize)
.copied()
.unwrap_or_default();
show_mode_rows(&a.widgets, mode);
save(&a, move |config| {
prompt_of(config).mode = (mode != PromptMode::default()).then_some(mode);
});
});
let a = apps.clone();
w.limit_row.connect_value_notify(move |row| {
if a.ui.status.settings_suppress.get() {
return;
}
let limit = row.value().round() as usize;
save(&a, move |config| {
prompt_of(config).menu_limit =
(limit != pdfs_core::menu::DEFAULT_MENU_LIMIT).then_some(limit);
});
});
let a = apps.clone();
w.icons_row.connect_active_notify(move |row| {
if a.ui.status.settings_suppress.get() {
return;
}
let on = row.is_active();
save(&a, move |config| {
prompt_of(config).menu_icons = (!on).then_some(false)
});
});
}
/// Show only the rows the chosen launcher mode uses.
fn show_mode_rows(w: &AppsPrefs, mode: PromptMode) {
w.menu_row.set_visible(mode == PromptMode::Dmenu);
w.icons_row.set_visible(mode == PromptMode::Dmenu);
w.prompt_terminal_row.set_visible(mode == PromptMode::Fzf);
w.limit_row.set_visible(mode != PromptMode::Gtk);
}
/// The `open_with` section, created when absent.
fn open_with_of(config: &mut pdfs_core::config::AppConfig) -> &mut OpenWith {
config.open_with.get_or_insert_with(OpenWith::default)
}
/// The `prompt` section, created when absent.
fn prompt_of(config: &mut pdfs_core::config::AppConfig) -> &mut PromptConfig {
config.prompt.get_or_insert_with(PromptConfig::default)
}
/// Save a change, then drop sections left at their defaults so the file only
/// holds what the user chose. Says whether it saved.
fn save(apps: &Rc<Apps>, change: impl FnOnce(&mut pdfs_core::config::AppConfig)) -> bool {
let saved = apps.ui.dirs.update_config(|config| {
change(config);
if config.open_with.as_ref() == Some(&OpenWith::default()) {
config.open_with = None;
}
if config.prompt.as_ref() == Some(&PromptConfig::default()) {
config.prompt = None;
}
config.resolved_open_with()
});
match saved {
Ok(open_with) => {
paint_rules(apps, &open_with);
true
}
Err(e) => {
prefs_toast(
&apps.ui,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the setting")),
("detail", &e.to_string()),
],
),
);
false
}
}
}
/// Check a command line as it is typed, and save it when applied.
fn connect_command_row(
apps: &Rc<Apps>,
row: &adw::EntryRow,
store: impl Fn(&mut pdfs_core::config::AppConfig, Option<Vec<String>>) + 'static,
) {
row.connect_changed(|row| mark_command(row, false));
let a = apps.clone();
row.connect_apply(move |row| {
let Some(argv) = parse_command(&row.text()) else {
prefs_toast(&a.ui, &gettext("A quote is not closed in the command"));
return;
};
if !argv.is_empty() && !command_available(&argv) {
prefs_toast(
&a.ui,
// Translators: {program} is a program name such as "nvim".
&gettext_f(
"“{program}” isn't installed; saved anyway",
&[("program", &argv[0])],
),
);
}
let argv = (!argv.is_empty()).then_some(argv);
save(&a, |config| store(config, argv));
mark_command(row, true);
});
}
/// Mark a command line that doesn't parse as an error, and, once `applied`,
/// one whose program isn't found as a warning.
fn mark_command(row: &adw::EntryRow, applied: bool) {
row.remove_css_class("error");
row.remove_css_class("warning");
match parse_command(&row.text()) {
None => row.add_css_class("error"),
Some(argv) if applied && !argv.is_empty() && !command_available(&argv) => {
row.add_css_class("warning")
}
Some(_) => {}
}
}
/// Show the rules, one row each, in the order they are tried.
fn paint_rules(apps: &Rc<Apps>, open_with: &OpenWith) {
let group = &apps.widgets.rules;
for row in apps.rule_rows.borrow_mut().drain(..) {
group.remove(&row);
}
let count = open_with.rules.len();
if count == 0 {
let row = adw::ActionRow::builder()
.title(gettext("No rules: every file opens in its default app"))
.build();
row.add_css_class("dim-label");
group.add(&row);
apps.rule_rows.borrow_mut().push(row);
return;
}
let names = classes();
for (index, rule) in open_with.rules.iter().enumerate() {
let patterns: Vec<String> = rule
.patterns
.iter()
.map(|p| {
names
.iter()
.find(|(class, _)| class == p)
.map_or_else(|| p.clone(), |(_, name)| name.clone())
})
.collect();
let command = format_command(&rule.command);
let subtitle = if rule.terminal {
// Translators: {command} is a command line such as "nvim".
gettext_f("{command}, in a terminal", &[("command", &command)])
} else {
command
};
let row = adw::ActionRow::builder()
.title(patterns.join(", "))
.subtitle(subtitle)
.use_markup(false)
.activatable(true)
.build();
if !command_available(&rule.command) {
let warning = gtk4::Image::builder()
.icon_name("dialog-warning-symbolic")
// Translators: {program} is a program name such as "nvim".
.tooltip_text(gettext_f(
"“{program}” isn't installed",
&[("program", rule.command.first().map_or("", String::as_str))],
))
.build();
warning.add_css_class("warning");
row.add_prefix(&warning);
}
let up = rule_button("go-up-symbolic", &gettext("Move Up"), index > 0);
let down = rule_button("go-down-symbolic", &gettext("Move Down"), index + 1 < count);
let remove = rule_button("user-trash-symbolic", &gettext("Remove"), true);
let a = apps.clone();
up.connect_clicked(move |_| {
save(&a, |config| {
open_with_of(config).rules.swap(index - 1, index)
});
});
let a = apps.clone();
down.connect_clicked(move |_| {
save(&a, |config| {
open_with_of(config).rules.swap(index, index + 1)
});
});
let a = apps.clone();
remove.connect_clicked(move |_| {
save(&a, |config| {
let rules = &mut open_with_of(config).rules;
if index < rules.len() {
rules.remove(index);
}
});
});
row.add_suffix(&up);
row.add_suffix(&down);
row.add_suffix(&remove);
let a = apps.clone();
let rule = rule.clone();
row.connect_activated(move |_| edit_rule(&a, Some(index), rule.clone()));
group.add(&row);
apps.rule_rows.borrow_mut().push(row);
}
}
fn rule_button(icon: &str, tooltip: &str, sensitive: bool) -> gtk4::Button {
let button = gtk4::Button::builder()
.icon_name(icon)
.tooltip_text(tooltip)
.valign(gtk4::Align::Center)
.sensitive(sensitive)
.build();
button.add_css_class("flat");
button
}
/// Split a typed pattern list into patterns, dropping empty ones.
fn split_patterns(text: &str) -> Vec<String> {
text.split(',')
.map(str::trim)
.filter(|p| !p.is_empty())
.map(str::to_string)
.collect()
}
/// Edit one rule, or a new one when `index` is `None`, in a dialog over the
/// Preferences.
fn edit_rule(apps: &Rc<Apps>, index: Option<usize>, rule: OpenRule) {
let patterns_row = adw::EntryRow::builder()
.title(gettext("Files, such as *.md, *.txt"))
.text(rule.patterns.join(", "))
.build();
patterns_row.add_css_class("monospace");
let chips = gtk4::FlowBox::builder()
.selection_mode(gtk4::SelectionMode::None)
.column_spacing(6)
.row_spacing(6)
.max_children_per_line(6)
.margin_top(6)
.build();
for (class, name) in classes() {
let chip = gtk4::Button::builder().label(&name).build();
chip.add_css_class("pill");
chip.add_css_class("small");
let row = patterns_row.clone();
chip.connect_clicked(move |_| {
let mut list = split_patterns(&row.text());
if !list.iter().any(|p| p == class) {
list.push(class.to_string());
}
row.set_text(&list.join(", "));
});
chips.insert(&chip, -1);
}
let command_row = adw::EntryRow::builder()
.title(gettext("Command, such as nvim or code --wait"))
.text(format_command(&rule.command))
.build();
command_row.add_css_class("monospace");
let terminal_row = adw::SwitchRow::builder()
.title(gettext("Run in a terminal"))
.subtitle(gettext("For programs that run in a terminal, such as vim"))
.active(rule.terminal)
.build();
let hint = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.margin_top(6)
.build();
hint.add_css_class("caption");
hint.add_css_class("dim-label");
let group = adw::PreferencesGroup::new();
group.add(&patterns_row);
let files = adw::PreferencesGroup::builder()
.description(gettext("Or pick kinds of files:"))
.build();
files.add(&chips);
let program = adw::PreferencesGroup::new();
program.add(&command_row);
program.add(&terminal_row);
program.add(&hint);
let page = adw::PreferencesPage::new();
page.add(&group);
page.add(&files);
page.add(&program);
let cancel = gtk4::Button::with_label(&gettext("Cancel"));
let save_button = gtk4::Button::with_label(&gettext("Save"));
save_button.add_css_class("suggested-action");
let header = adw::HeaderBar::builder()
.show_start_title_buttons(false)
.show_end_title_buttons(false)
.build();
header.pack_start(&cancel);
header.pack_end(&save_button);
let view = adw::ToolbarView::new();
view.add_top_bar(&header);
view.set_content(Some(&page));
let dialog = adw::Dialog::builder()
.title(if index.is_some() {
gettext("Edit Rule")
} else {
gettext("New Rule")
})
.content_width(480)
.child(&view)
.build();
// Save only a rule that matches something and runs something.
let check = {
let (patterns_row, command_row, save_button, hint) = (
patterns_row.clone(),
command_row.clone(),
save_button.clone(),
hint.clone(),
);
move || {
let patterns = split_patterns(&patterns_row.text());
let argv = parse_command(&command_row.text());
command_row.remove_css_class("error");
hint.set_text("");
match &argv {
None => {
command_row.add_css_class("error");
hint.set_text(&gettext("A quote is not closed in the command."));
}
Some(argv) if !argv.is_empty() && !command_available(argv) => {
hint.set_text(&gettext_f(
"“{program}” isn't installed.",
&[("program", &argv[0])],
));
}
Some(_) => {}
}
save_button
.set_sensitive(!patterns.is_empty() && argv.is_some_and(|argv| !argv.is_empty()));
}
};
check();
let c = check.clone();
patterns_row.connect_changed(move |_| c());
command_row.connect_changed(move |_| check());
let d = dialog.clone();
cancel.connect_clicked(move |_| {
d.close();
});
let (a, d) = (apps.clone(), dialog.clone());
save_button.connect_clicked(move |_| {
let Some(command) = parse_command(&command_row.text()) else {
return;
};
let rule = OpenRule {
patterns: split_patterns(&patterns_row.text()),
command,
terminal: terminal_row.is_active(),
};
let saved = save(&a, move |config| {
let rules = &mut open_with_of(config).rules;
match index {
Some(i) if i < rules.len() => rules[i] = rule,
_ => rules.push(rule),
}
});
if saved {
d.close();
}
});
dialog.present(Some(&apps.ui.status.prefs));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn typed_patterns_are_split_on_commas() {
assert_eq!(
split_patterns(" *.md, @text ,, notes-*.txt "),
["*.md", "@text", "notes-*.txt"]
);
assert!(split_patterns(" , ").is_empty());
}
}
@@ -0,0 +1,347 @@
//! Preferences → Sync: the patterns every synced folder leaves out
//! (`ignore_patterns`) and what the conflict sweep may do (`conflict_sweep`).
//!
//! Both live in `config.json`. The daemon reads the patterns again on every
//! sync pass, so a change here is followed by a Sync Now and applies at once;
//! the sweep mode is read when the service starts, so a change offers a
//! restart, as the mountpoint does.
use crate::*;
use pdfs_core::config::SweepMode;
use pdfs_core::syncignore::{DEFAULT_IGNORE_PATTERNS, check_pattern};
/// The widgets of the Sync page, built with the rest of the dialog and wired
/// once the app's state exists.
pub(crate) struct SyncPrefs {
pub(crate) page: adw::PreferencesPage,
patterns: adw::PreferencesGroup,
add_row: adw::EntryRow,
reset: gtk4::Button,
sweep_row: adw::ComboRow,
/// Whether the built-in patterns are shown, kept across repaints.
builtin_expanded: Cell<bool>,
}
/// The sweep modes in the order the combo row lists them.
const SWEEP_MODES: [SweepMode; 3] = [SweepMode::Report, SweepMode::Enforce, SweepMode::Off];
pub(crate) fn build_sync_prefs() -> SyncPrefs {
let reset = gtk4::Button::builder()
.label(gettext("Reset"))
.tooltip_text(gettext("Use the built-in patterns again"))
.valign(gtk4::Align::Center)
.build();
reset.add_css_class("flat");
let patterns = adw::PreferencesGroup::builder()
.title(gettext("Excluded Files"))
.description(gettext(
"Files and folders matching these patterns are not synced in any synced folder. Use * for any characters, end a pattern with / to match folders only, and start it with ! to include something again. Excluding never deletes anything from Proton Drive.",
))
.header_suffix(&reset)
.build();
let add_row = adw::EntryRow::builder()
.title(gettext("Add Pattern"))
.show_apply_button(true)
.build();
add_row.add_css_class("monospace");
patterns.add(&add_row);
let sweep_row = adw::ComboRow::builder()
.title(gettext("Identical conflict copies"))
.subtitle(gettext(
"A copy made when a file changed in two places, found to be the same as the file",
))
.model(&gtk4::StringList::new(&[
&gettext("Report Only"),
&gettext("Move to Trash"),
&gettext("Off"),
]))
.build();
let conflicts = adw::PreferencesGroup::builder()
.title(gettext("Conflict Copies"))
.build();
conflicts.add(&sweep_row);
let page = adw::PreferencesPage::builder()
.title(gettext("Sync"))
.name("sync")
.icon_name("pdfs-sync-symbolic")
.build();
page.add(&patterns);
page.add(&conflicts);
SyncPrefs {
page,
patterns,
add_row,
reset,
sweep_row,
builtin_expanded: Cell::new(false),
}
}
/// Fill the page from the config and connect its controls.
pub(crate) fn wire_sync_prefs(ui: &Rc<Ui>, widgets: SyncPrefs) {
let widgets = Rc::new(widgets);
let rows: Rc<RefCell<Vec<adw::PreferencesRow>>> = Rc::default();
let config = ui.dirs.load_config();
paint_patterns(ui, &widgets, &rows, &config);
let mode = config.conflict_sweep.unwrap_or_default();
let suppress = ui.status.settings_suppress.replace(true);
widgets.sweep_row.set_selected(
SWEEP_MODES
.iter()
.position(|m| *m == mode)
.unwrap_or_default() as u32,
);
ui.status.settings_suppress.set(suppress);
widgets.add_row.connect_changed(|row| {
let text = row.text();
if text.trim().is_empty() || check_pattern(text.trim()).is_ok() {
row.remove_css_class("error");
} else {
row.add_css_class("error");
}
});
let (ui_add, w_add, rows_add) = (ui.clone(), widgets.clone(), rows.clone());
widgets.add_row.connect_apply(move |row| {
let pattern = row.text().trim().to_string();
if pattern.is_empty() {
return;
}
if let Err(e) = check_pattern(&pattern) {
tracing::debug!(%pattern, error = %e, "not a valid ignore pattern");
prefs_toast(
&ui_add,
// Translators: {pattern} is what the user typed as a pattern.
&gettext_f(
"“{pattern}” isn't a valid pattern",
&[("pattern", &pattern)],
),
);
return;
}
let added = change_patterns(&ui_add, &w_add, &rows_add, |list| {
if !list.contains(&pattern) {
list.push(pattern.clone());
}
});
if added {
row.set_text("");
}
});
let (ui_reset, w_reset, rows_reset) = (ui.clone(), widgets.clone(), rows.clone());
widgets.reset.connect_clicked(move |_| {
let (ui, w, rows) = (ui_reset.clone(), w_reset.clone(), rows_reset.clone());
confirm_destructive(
&ui_reset.status.prefs,
&gettext("Reset Excluded Files?"),
&gettext("Your own patterns are removed, and the built-in ones apply again."),
&gettext("Reset"),
move || {
change_patterns(&ui, &w, &rows, |list| {
*list = default_patterns();
});
},
);
});
let ui_sweep = ui.clone();
widgets.sweep_row.connect_selected_notify(move |row| {
if ui_sweep.status.settings_suppress.get() {
return;
}
let Some(mode) = SWEEP_MODES.get(row.selected() as usize).copied() else {
return;
};
let stored = (mode != SweepMode::default()).then_some(mode);
match ui_sweep
.dirs
.update_config(|config| config.conflict_sweep = stored)
{
Ok(()) => offer_restart(&ui_sweep),
Err(e) => prefs_toast(
&ui_sweep,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the setting")),
("detail", &e.to_string()),
],
),
),
}
});
}
fn default_patterns() -> Vec<String> {
DEFAULT_IGNORE_PATTERNS
.iter()
.map(|p| (*p).to_string())
.collect()
}
/// Apply `edit` to the patterns in effect and save them, then show them and
/// have every synced folder sync with them. A list equal to the built-in one
/// is saved as "unset", so it follows the built-in list in later releases.
/// Says whether it saved.
fn change_patterns(
ui: &Rc<Ui>,
widgets: &Rc<SyncPrefs>,
rows: &Rc<RefCell<Vec<adw::PreferencesRow>>>,
edit: impl FnOnce(&mut Vec<String>),
) -> bool {
let saved = ui.dirs.update_config(|config| {
let mut list = config.resolved_ignore_patterns();
edit(&mut list);
config.ignore_patterns = (list != default_patterns()).then_some(list);
config.clone()
});
match saved {
Ok(config) => {
paint_patterns(ui, widgets, rows, &config);
// Best effort: the next pass picks the change up anyway.
let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id: None });
true
}
Err(e) => {
prefs_toast(
ui,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the patterns")),
("detail", &e.to_string()),
],
),
);
false
}
}
}
/// Show the patterns in effect below the entry row: the user's own one row
/// each, then the built-in ones folded into one row, since they are many and
/// rarely changed.
fn paint_patterns(
ui: &Rc<Ui>,
widgets: &Rc<SyncPrefs>,
rows: &Rc<RefCell<Vec<adw::PreferencesRow>>>,
config: &pdfs_core::config::AppConfig,
) {
for row in rows.borrow_mut().drain(..) {
widgets.patterns.remove(&row);
}
widgets
.reset
.set_sensitive(config.ignore_patterns.is_some());
let list = config.resolved_ignore_patterns();
let (builtin, own): (Vec<String>, Vec<String>) = list
.into_iter()
.partition(|p| DEFAULT_IGNORE_PATTERNS.contains(&p.as_str()));
for pattern in own {
let row = pattern_row(ui, widgets, rows, pattern);
widgets.patterns.add(&row);
rows.borrow_mut().push(row.upcast());
}
// Every built-in pattern, on or off, so one turned off can be turned on
// again without losing the user's own.
let on = builtin.len();
let total = DEFAULT_IGNORE_PATTERNS.len();
let expander = adw::ExpanderRow::builder()
.title(gettext("Built-in patterns"))
// Translators: {on} and {total} are numbers of patterns.
.subtitle(gettext_f(
"{on} of {total} on: version control, dependency and build folders, and what editors, downloads and systems leave behind",
&[("on", &on.to_string()), ("total", &total.to_string())],
))
.expanded(widgets.builtin_expanded.get())
.build();
let w = widgets.clone();
expander.connect_expanded_notify(move |row| w.builtin_expanded.set(row.is_expanded()));
for pattern in DEFAULT_IGNORE_PATTERNS {
let row = adw::SwitchRow::builder()
.title(format!("<tt>{}</tt>", glib::markup_escape_text(pattern)))
.use_markup(true)
.active(builtin.iter().any(|p| p == pattern))
.build();
let (ui, w, r) = (ui.clone(), widgets.clone(), rows.clone());
row.connect_active_notify(move |row| {
let active = row.is_active();
// Repainting replaces this row; let the switch finish first.
let (ui, w, r) = (ui.clone(), w.clone(), r.clone());
glib::idle_add_local_once(move || {
change_patterns(&ui, &w, &r, move |list| {
list.retain(|p| p != pattern);
if active {
list.push((*pattern).to_string());
}
});
});
});
expander.add_row(&row);
}
widgets.patterns.add(&expander);
rows.borrow_mut().push(expander.upcast());
}
/// One pattern, in monospace, with a button that removes it.
fn pattern_row(
ui: &Rc<Ui>,
widgets: &Rc<SyncPrefs>,
rows: &Rc<RefCell<Vec<adw::PreferencesRow>>>,
pattern: String,
) -> adw::ActionRow {
let row = adw::ActionRow::builder()
.title(format!("<tt>{}</tt>", glib::markup_escape_text(&pattern)))
.use_markup(true)
.build();
let remove = gtk4::Button::builder()
.icon_name("user-trash-symbolic")
.tooltip_text(gettext("Remove"))
.valign(gtk4::Align::Center)
.build();
remove.add_css_class("flat");
let (ui, w, r) = (ui.clone(), widgets.clone(), rows.clone());
remove.connect_clicked(move |_| {
let pattern = pattern.clone();
change_patterns(&ui, &w, &r, move |list| list.retain(|p| *p != pattern));
});
row.add_suffix(&remove);
row
}
/// The sweep mode is read when the service starts; offer that restart.
fn offer_restart(ui: &Rc<Ui>) {
let confirm = adw::AlertDialog::builder()
.heading(gettext("Restart Proton Drive?"))
.body(gettext(
"The new setting applies after Proton Drive restarts.",
))
.build();
confirm.add_response("later", &gettext("Later"));
confirm.add_response("restart", &gettext("Restart Now"));
confirm.set_response_appearance("restart", adw::ResponseAppearance::Suggested);
confirm.set_default_response(Some("restart"));
confirm.set_close_response("later");
let ui_restart = ui.clone();
confirm.connect_response(None, move |_, resp| {
if resp == "restart" {
restart_service_then(&ui_restart, |_| {});
}
});
confirm.present(Some(&ui.status.prefs));
}
/// A toast on the Preferences dialog, which covers the window's own toasts.
pub(crate) fn prefs_toast(ui: &Rc<Ui>, message: &str) {
ui.status.prefs.add_toast(
adw::Toast::builder()
.title(message)
.use_markup(false)
.timeout(6)
.build(),
);
}
+31 -18
View File
@@ -169,6 +169,9 @@ pub(crate) struct MainWidgets {
pub(crate) tray_row: adw::SwitchRow,
pub(crate) update_row: adw::SwitchRow,
pub(crate) language_row: adw::ComboRow,
/// Preferences → Sync and → Apps, wired once the app's state exists.
pub(crate) sync_prefs: SyncPrefs,
pub(crate) apps_prefs: AppsPrefs,
}
/// Build the two surfaces that replaced the old Settings page:
@@ -267,6 +270,7 @@ pub(crate) fn build_main_page() -> MainWidgets {
let general = adw::PreferencesPage::builder()
.title(gettext("General"))
.name("general")
.icon_name("preferences-system-symbolic")
.build();
general.add(&startup_group);
@@ -335,6 +339,7 @@ pub(crate) fn build_main_page() -> MainWidgets {
let storage = adw::PreferencesPage::builder()
.title(gettext("Storage"))
.name("storage")
.icon_name("drive-harddisk-symbolic")
.build();
storage.add(&storage_group);
@@ -343,7 +348,11 @@ pub(crate) fn build_main_page() -> MainWidgets {
let prefs = adw::PreferencesDialog::builder()
.search_enabled(false)
.build();
let sync_prefs = build_sync_prefs();
let apps_prefs = build_apps_prefs();
prefs.add(&general);
prefs.add(&sync_prefs.page);
prefs.add(&apps_prefs.page);
prefs.add(&storage);
// ---- Sidebar footer
@@ -463,6 +472,8 @@ pub(crate) fn build_main_page() -> MainWidgets {
tray_row,
update_row,
language_row,
sync_prefs,
apps_prefs,
}
}
@@ -678,9 +689,10 @@ pub(crate) fn wire_settings(
let rows = list.model.n_items();
list.model.items_changed(0, rows, rows);
}
let mut config = ui_theme.dirs.load_config();
config.proton_theme = Some(on);
if let Err(e) = ui_theme.dirs.save_config(&config) {
if let Err(e) = ui_theme
.dirs
.update_config(|config| config.proton_theme = Some(on))
{
toast_error(
&ui_theme,
&gettext("Couldn't save the theme"),
@@ -700,9 +712,7 @@ pub(crate) fn wire_settings(
.gallery
.places_map
.set_online(on, ui_map.dirs.cache_dir());
let mut config = ui_map.dirs.load_config();
config.online_map = on;
if let Err(e) = ui_map.dirs.save_config(&config) {
if let Err(e) = ui_map.dirs.update_config(|config| config.online_map = on) {
toast_error(
&ui_map,
&gettext("Couldn't save the map setting"),
@@ -717,9 +727,10 @@ pub(crate) fn wire_settings(
if ui_update.status.settings_suppress.get() {
return;
}
let mut config = ui_update.dirs.load_config();
config.update_check = row.is_active();
if let Err(e) = ui_update.dirs.save_config(&config) {
if let Err(e) = ui_update
.dirs
.update_config(|config| config.update_check = row.is_active())
{
toast_error(
&ui_update,
&gettext("Couldn't save the update setting"),
@@ -739,9 +750,10 @@ pub(crate) fn wire_settings(
return;
}
let show = row.is_active();
let mut config = ui_tray.dirs.load_config();
config.tray_hidden = !show;
if let Err(e) = ui_tray.dirs.save_config(&config) {
if let Err(e) = ui_tray
.dirs
.update_config(|config| config.tray_hidden = !show)
{
toast_error(
&ui_tray,
&gettext("Couldn't save the tray setting"),
@@ -763,9 +775,9 @@ pub(crate) fn wire_settings(
if ui_language.status.settings_suppress.get() {
return;
}
let mut config = ui_language.dirs.load_config();
config.language = language_at(row.selected()).map(str::to_string);
if let Err(e) = ui_language.dirs.save_config(&config) {
if let Err(e) = ui_language.dirs.update_config(|config| {
config.language = language_at(row.selected()).map(str::to_string)
}) {
toast_error(
&ui_language,
&gettext("Couldn't save the language"),
@@ -864,9 +876,10 @@ fn use_mountpoint(ui: &Rc<Ui>, path: &std::path::Path) {
let path_str = path.display().to_string();
// Persist the choice to config so the next mount uses it.
let mut config = ui.dirs.load_config();
config.mountpoint = Some(path_str.clone());
if let Err(e) = ui.dirs.save_config(&config) {
if let Err(e) = ui
.dirs
.update_config(|config| config.mountpoint = Some(path_str.clone()))
{
toast_error(ui, &gettext("Couldn't save the folder"), &e.to_string());
return;
}
+4 -4
View File
@@ -82,10 +82,10 @@ pub(crate) fn start_update_checks(ui: &Rc<Ui>) {
match fetch_latest().await {
Ok(latest) => {
checked = Some(unix_now());
let mut config = ui.dirs.load_config();
config.update_last_checked = checked;
config.update_latest = latest;
if let Err(e) = ui.dirs.save_config(&config) {
if let Err(e) = ui.dirs.update_config(|config| {
config.update_last_checked = checked;
config.update_latest = latest;
}) {
tracing::warn!("update check: cannot save the result: {e}");
}
show_latest(&ui);
@@ -0,0 +1,342 @@
//! The Excluded Files dialog of one synced folder: its own `.pdfsignore`,
//! edited as text, with a check of what the rules do to a path.
//!
//! The file sits in the synced folder and syncs like any other file, so it can
//! change on another computer while it is open here. Saving checks for that
//! and asks, rather than writing over the other edit.
use crate::*;
use pdfs_core::syncignore::{FolderRules, IgnoreRules, RuleSource, Verdict, WriteRulesError};
/// Open the dialog for the synced folder `id` at `root`.
pub(crate) fn present_ignore_dialog(ui: &Rc<Ui>, id: i64, root: PathBuf) {
let root_display = tilde_path(&root.display().to_string());
let intro = gtk4::Label::builder()
// Translators: {folder} is a local folder path such as ~/Projects.
.label(gettext_f(
"Patterns for {folder} only, one per line, on top of the ones for all synced folders. Lines starting with # are comments.",
&[("folder", &root_display)],
))
.wrap(true)
.xalign(0.0)
.build();
let text = gtk4::TextView::builder()
.monospace(true)
.wrap_mode(gtk4::WrapMode::WordChar)
.top_margin(8)
.bottom_margin(8)
.left_margin(8)
.right_margin(8)
.sensitive(false)
.build();
let scroller = gtk4::ScrolledWindow::builder()
.child(&text)
.min_content_height(180)
.vexpand(true)
.build();
scroller.add_css_class("card");
let problems = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.visible(false)
.build();
problems.add_css_class("error");
let check_row = adw::EntryRow::builder()
.title(gettext("Check a path in the folder"))
.build();
let verdict = gtk4::Label::builder()
.wrap(true)
.xalign(0.0)
.margin_top(6)
.build();
verdict.add_css_class("dim-label");
let check_group = adw::PreferencesGroup::new();
check_group.add(&check_row);
let all_folders = gtk4::Button::builder()
.label(gettext("Patterns for All Folders…"))
.halign(gtk4::Align::Start)
.build();
all_folders.add_css_class("flat");
let body = gtk4::Box::new(gtk4::Orientation::Vertical, 12);
body.set_margin_top(12);
body.set_margin_bottom(18);
body.set_margin_start(18);
body.set_margin_end(18);
body.append(&intro);
body.append(&scroller);
body.append(&problems);
body.append(&check_group);
body.append(&verdict);
body.append(&all_folders);
let cancel = gtk4::Button::with_label(&gettext("Cancel"));
let save = gtk4::Button::with_label(&gettext("Save"));
save.add_css_class("suggested-action");
save.set_sensitive(false);
let header = adw::HeaderBar::builder()
.show_start_title_buttons(false)
.show_end_title_buttons(false)
.build();
header.pack_start(&cancel);
header.pack_end(&save);
let toasts = adw::ToastOverlay::new();
toasts.set_child(Some(&body));
let view = adw::ToolbarView::new();
view.add_top_bar(&header);
view.set_content(Some(&toasts));
let dialog = adw::Dialog::builder()
.title(gettext("Excluded Files"))
.content_width(560)
.content_height(560)
.child(&view)
.build();
// What was read, so the save can tell whether the file changed since.
let loaded: Rc<RefCell<Option<FolderRules>>> = Rc::default();
let globals = Rc::new(ui.dirs.load_config().resolved_ignore_patterns());
let show_verdict = {
let (text, check_row, verdict, root, globals) = (
text.clone(),
check_row.clone(),
verdict.clone(),
root.clone(),
globals.clone(),
);
move || {
let typed = check_row.text();
let typed = typed.trim();
if typed.is_empty() {
verdict.set_text("");
return;
}
let path = Path::new(typed);
let rel = path.strip_prefix(&root).unwrap_or(path);
let rel = rel.to_string_lossy();
let rel = rel.trim_start_matches('/');
let is_dir = typed.ends_with('/') || root.join(rel).is_dir();
let rules = IgnoreRules::with_folder_text(&root, &globals, &buffer_text(&text));
verdict.set_text(&verdict_text(&rules.explain(rel, is_dir)));
}
};
let on_text = {
let (problems, save, show_verdict) = (problems.clone(), save.clone(), show_verdict.clone());
move |text: &str| {
let bad = pdfs_core::syncignore::check_rules(text);
problems.set_visible(!bad.is_empty());
if let Some((line, _)) = bad.first() {
problems.set_text(&ngettext_f(
"Line {line} isn't a valid pattern.",
"Line {line} and {more} more aren't valid patterns.",
bad.len() as u64,
&[
("line", &line.to_string()),
("more", &(bad.len() - 1).to_string()),
],
));
}
save.set_sensitive(bad.is_empty());
show_verdict();
}
};
let on_text_changed = on_text.clone();
text.buffer()
.connect_changed(move |buffer| on_text_changed(&buffer_text_of(buffer)));
check_row.connect_changed(move |_| show_verdict());
let d = dialog.clone();
cancel.connect_clicked(move |_| {
d.close();
});
let (ui_all, d) = (ui.clone(), dialog.clone());
all_folders.connect_clicked(move |_| {
d.close();
let prefs = &ui_all.status.prefs;
prefs.set_visible_page_name("sync");
prefs.present(ui_window(&ui_all).as_ref());
});
// Read off the main thread: the folder may be on a slow disk.
let reader = {
let (text, loaded, root, toasts) =
(text.clone(), loaded.clone(), root.clone(), toasts.clone());
move || {
let (text, loaded, root, toasts) =
(text.clone(), loaded.clone(), root.clone(), toasts.clone());
glib::spawn_future_local(async move {
let read = gio::spawn_blocking(move || FolderRules::read(&root))
.await
.unwrap_or_else(|_| Err(std::io::Error::other("the read did not finish")));
match read {
Ok(rules) => {
text.buffer().set_text(rules.text.as_deref().unwrap_or(""));
text.set_sensitive(true);
*loaded.borrow_mut() = Some(rules);
}
Err(e) => dialog_toast(
&toasts,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't read the patterns")),
("detail", &e.to_string()),
],
),
),
}
});
}
};
reader();
let (ui_save, d) = (ui.clone(), dialog.clone());
save.connect_clicked(move |_| {
let Some(rules) = loaded.borrow().clone() else {
return;
};
write_rules(
&ui_save,
&d,
&toasts,
id,
rules,
buffer_text(&text),
reader.clone(),
);
});
dialog.present(ui_window(ui).as_ref());
}
/// Save `body` over `rules`, then close and sync the folder. When the file
/// changed since it was read, ask whether to load the other version or to
/// replace it; `reload` reads the file into the dialog again.
fn write_rules(
ui: &Rc<Ui>,
dialog: &adw::Dialog,
toasts: &adw::ToastOverlay,
id: i64,
rules: FolderRules,
body: String,
reload: impl Fn() + Clone + 'static,
) {
let (ui, dialog, toasts) = (ui.clone(), dialog.clone(), toasts.clone());
glib::spawn_future_local(async move {
let to_write = rules.clone();
let text = body.clone();
let written = gio::spawn_blocking(move || to_write.write(&text))
.await
.unwrap_or_else(|_| {
Err(WriteRulesError::Io(std::io::Error::other(
"the write did not finish",
)))
});
match written {
Ok(()) => {
dialog.close();
toast(&ui, &gettext("Excluded files saved"));
let _ = spawn_request(ui.dirs.control_socket(), Request::SyncNow { id: Some(id) });
}
Err(WriteRulesError::Changed) => {
let ask = adw::AlertDialog::builder()
.heading(gettext("Patterns Changed Elsewhere"))
.body(gettext(
"The patterns of this folder changed while you edited them, for example on another computer. Load the other version, or replace it with yours?",
))
.build();
ask.add_response("cancel", &gettext("Cancel"));
ask.add_response("reload", &gettext("Load Other Version"));
ask.add_response("replace", &gettext("Replace"));
ask.set_response_appearance("replace", adw::ResponseAppearance::Destructive);
ask.set_default_response(Some("cancel"));
ask.set_close_response("cancel");
let (ui, d, t) = (ui.clone(), dialog.clone(), toasts.clone());
ask.connect_response(None, move |_, response| match response {
"reload" => reload(),
"replace" => {
// Read the other version only as the base to check
// against, then write over it.
let (ui, d, t, body, reload) = (
ui.clone(),
d.clone(),
t.clone(),
body.clone(),
reload.clone(),
);
let root = rules.path.parent().map(Path::to_path_buf);
glib::spawn_future_local(async move {
let Some(root) = root else { return };
let read = gio::spawn_blocking(move || FolderRules::read(&root))
.await
.ok()
.and_then(Result::ok);
if let Some(current) = read {
write_rules(&ui, &d, &t, id, current, body, reload);
}
});
}
_ => {}
});
ask.present(Some(&dialog));
}
Err(WriteRulesError::Io(e)) => dialog_toast(
&toasts,
&gettext_f(
"{what}: {detail}",
&[
("what", &gettext("Couldn't save the patterns")),
("detail", &e.to_string()),
],
),
),
}
});
}
/// Say what the rules do to the path being checked.
fn verdict_text(verdict: &Verdict) -> String {
match verdict {
Verdict::Synced => gettext("Synced: no pattern matches it."),
// Translators: {pattern} is an ignore pattern such as *.log.
Verdict::Excluded {
pattern,
source: RuleSource::ThisFolder,
} => gettext_f(
"Not synced: excluded by “{pattern}” above.",
&[("pattern", pattern)],
),
Verdict::Excluded {
pattern,
source: RuleSource::AllFolders,
} => gettext_f(
"Not synced: excluded by “{pattern}” in the patterns for all folders.",
&[("pattern", pattern)],
),
Verdict::Included { pattern, .. } => gettext_f(
"Synced: “{pattern}” includes it again.",
&[("pattern", pattern)],
),
}
}
fn buffer_text(view: &gtk4::TextView) -> String {
buffer_text_of(&view.buffer())
}
fn buffer_text_of(buffer: &gtk4::TextBuffer) -> String {
let (start, end) = buffer.bounds();
buffer.text(&start, &end, false).to_string()
}
fn dialog_toast(toasts: &adw::ToastOverlay, message: &str) {
toasts.add_toast(
adw::Toast::builder()
.title(message)
.use_markup(false)
.timeout(6)
.build(),
);
}
+1
View File
@@ -2,6 +2,7 @@ pub(crate) mod compat;
pub(crate) mod crumb;
pub(crate) mod details;
pub(crate) mod file_list;
pub(crate) mod ignore_dialog;
pub(crate) mod menu;
pub(crate) mod photo_drag;
pub(crate) mod player;
+4 -6
View File
@@ -398,12 +398,10 @@ fn open_manager(args: &[&str]) {
/// Remember that the user hid the icon, so the next login's autostart and the
/// app both leave it away, then exit.
fn hide_tray() {
if let Ok(dirs) = AppDirs::new() {
let mut config = dirs.load_config();
config.tray_hidden = true;
if let Err(e) = dirs.save_config(&config) {
tracing::warn!("hide tray icon: {e}");
}
if let Ok(dirs) = AppDirs::new()
&& let Err(e) = dirs.update_config(|config| config.tray_hidden = true)
{
tracing::warn!("hide tray icon: {e}");
}
std::process::exit(0);
}
+1
View File
@@ -24,6 +24,7 @@ const STOCK: &[&str] = &[
// GTK's built-in icons
"info-outline-symbolic",
// Adwaita
"application-x-executable-symbolic",
"audio-x-generic-symbolic",
"checkbox-checked-symbolic",
"checkbox-symbolic",
+96
View File
@@ -109,6 +109,7 @@ a live account since.
| Entry | Title |
|---|---|
| [B291](#b291--on-fedora-45s-oo7-every-saved-sign-in-is-lost-at-the-next-reboot) | On Fedora 45's oo7, every saved sign-in is lost at the next reboot |
| [B289](#b289--the-takeout-import-mixes-in-other-services-and-drops-location-and-live-photos) | The Takeout import mixes in other services and drops location and live photos |
| [B288](#b288--an-interrupted-takeout-import-reads-as-finished-and-one-error-ends-it) | An interrupted Takeout import reads as finished, and one error ends it |
| [B287](#b287--a-photo-draft-left-by-an-interrupted-upload-blocks-that-name) | A photo draft left by an interrupted upload blocks that name |
@@ -305,6 +306,8 @@ a live account since.
| Entry | Title |
|---|---|
| [B292](#b292--two-programs-changing-settings-at-once-lose-one-of-the-changes) | Two programs changing settings at once lose one of the changes |
| [B290](#b290--reopening-the-database-right-after-closing-it-can-be-refused-as-another-daemon) | Reopening the database right after closing it can be refused as another daemon |
| [B276](#b276--a-stop-can-end-with-a-panic-in-a-thread-the-stop-never-waited-for) | A stop can end with a panic in a thread the stop never waited for |
| [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 |
@@ -392,6 +395,99 @@ a live account since.
Newest first.
### B292 — Two programs changing settings at once lose one of the changes
**Status:** Fixed
**Found:** 2026-11-15, reading every writer of `config.json` while adding settings to Preferences.
**Where:** `crates/pdfs-core/src/config.rs`, `AppDirs::save_config` and its callers in the app,
the tray and the daemon
**Repro:** Change the cache size in Preferences (the daemon writes `cache_budget`) while the app
saves the window size or the tray hides itself. Both read the file before either wrote it, and
the one that wrote last puts the other setting back. Not seen in the field; the window is a few
milliseconds, but more settings in the app make it more likely.
**Cause:** Every writer loaded the file, changed one field and wrote the whole file back, with
nothing ordering them. The atomic rename kept the file whole, not the changes.
**Fix:** `AppDirs::update_config` reads, changes and writes under an `flock` on
`config.json.lock`, and every writer goes through it. It refuses an unreadable file before
applying the change (B223). A lock held longer than 5 seconds is reported as an error instead of
waited on.
**Verified:** `cargo test -p pdfs-core config::tests` on 2026-11-15,
`concurrent_changes_to_different_settings_are_all_kept` and
`a_change_is_never_applied_over_an_unreadable_config`.
---
### B291 — On Fedora 45's oo7, every saved sign-in is lost at the next reboot
**Status:** Fixed, not verified live
**Found:** 2026-11-15, from the reporter's package list in
[issue #78](https://github.com/narrrl/proton-drive-linux/issues/78): `oo7-daemon-0.7.0~beta^1.e91b98a`,
the build Fedora 45 and 46 ship as stable, from before oo7's
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
("server: Write item changes to the keyring file"). See
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7).
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `crates/pdfs-core/src/secretservice.rs`
**Repro:** With oo7-daemon at e91b98a, save the session blob, save it again with a new refresh
token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
store writes an existing item with `SetSecret`, and that oo7 build applies `SetSecret` only to the
item in memory; the keyring file keeps what `CreateItem` wrote. Within a boot every read returns
the new tokens, so nothing looks wrong. After a reboot the daemon resumes with the refresh token
of the last `pdfs login`, which Proton spent long ago: `InvalidRefreshToken`, and the user has to
sign in again. Typing the password at login, or the fixes for B284 and B285, change nothing.
**Cause:** A bug in that oo7 build, fixed in oo7 0.7.0 but not packaged by Fedora. Every token
refresh pdfs saved went through the one call it does not persist.
**Fix:** An existing entry is saved by `CreateItem` with `replace`, which that build writes to the
file: a new item in the old one's collection, with its label and all its attributes, so the
provider replaces the old one. A duplicate that a provider leaves behind is removed; if it cannot
be, the new item is taken out again and the save falls back to the usual `SetSecret`. The first
save, a locked item, two matching items, or any failure before the new item exists also fall back
to it. The connection used for this never shows a prompt. The daemon log now has a short
fingerprint of the refresh token at each start and each save, so a log across a reboot shows
whether the keyring returned the last token saved.
**Verified:** 2026-11-15, `real_secret_service_keeps_the_last_save_across_a_provider_restart`
(ignored; needs a throwaway Secret Service) against oo7-daemon built at e91b98a: with the
in-place write it reads `r1` after the restart, with this change `r3` and one item. The same test
and `real_secret_service_survives_a_provider_restart` pass against gnome-keyring. Not yet run on
a Fedora 45 desktop with a real account.
---
### B290 — Reopening the database right after closing it can be refused as another daemon
**Status:** Fixed, 2026-11-15
**Found:** 2026-11-15, CI on `chore/release-3.8.0` (fd6b2d3):
`db::tests::what_a_create_sent_outlives_a_newer_blob_its_trash_and_a_restart` failed once with
"another Proton Drive daemon is already using /tmp/pdfs-create-sent-….db". It passes on its own.
**Where:** `crates/pdfs-core/src/db/mod.rs`, `acquire_single_writer_lock`
**Repro:** In one process, drop a `Db` and open the same file again while another thread spawns a
child process. Rare; seen once in about 500 tests that run in parallel, several of which spawn
processes.
**Cause:** The single-writer lock is a `flock` on `<db>.lock`, and a `flock` belongs to the open
file, not to one descriptor. A child holds a copy of every descriptor from its fork until its exec
closes the `O_CLOEXEC` ones. A lock dropped by the parent in that moment stays held by the child,
and an immediate reopen gets `EWOULDBLOCK`, which reads as a second daemon.
**Fix:** A refused lock is retried every 20 ms for up to 500 ms before it counts as another
daemon. That covers any fork-to-exec window. A real second daemon is still refused, half a
second later.
**Verified:** `cargo test -p pdfs-core` on 2026-11-15, including
`a_second_writer_is_refused_while_the_first_holds_the_database`.
---
### B289 — The Takeout import mixes in other services and drops location and live photos
**Status:** Fixed, not verified live
+31 -7
View File
@@ -18,6 +18,27 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
### Added
- **Excluded files, opening files and the search launcher in Preferences** (#99). Settings that
could only be changed in `config.json` now have a place in the app:
- **Sync → Excluded Files**: the patterns every synced folder leaves out. Add your own, such as
`*.db` or `build/`, and turn each built-in pattern on or off. A change applies at once.
- **Sync → Conflict Copies**: whether identical conflict copies are only reported, moved to the
trash, or not looked for.
- **Apps → Open Files With**: which program opens which kind of file, in order, optionally in a
terminal, for example `nvim` for text files. A change applies to the next file opened.
- **Apps → Search Launcher**: whether `pdfs-prompt` opens its own window, your dmenu-style
launcher (rofi, wofi, fuzzel, bemenu) or fzf in a terminal.
Each synced folder kept on this computer has **Excluded Files…** in its menu on the Sync page,
for its own `.pdfsignore`. It checks every line as you type, tells you whether a path is synced
and which pattern decides, and asks before replacing rules that changed on another computer
meanwhile. `pdfs sync ignore list|add|remove|reset|check` does the same from a terminal.
`pdfs-app --page preferences-sync` (or `-apps`, `-storage`, plain `preferences`) opens
Preferences at that page.
- **More clutter left out of synced folders by default**: `desktop.ini`, `.directory`, trash
folders, `.fuse_hidden*` and `.nfs*` leftovers, partial downloads (`*.part`, `*.crdownload`),
Kate swap files and office lock files. This only changes folders where you never set your own
list. Leaving a file out never deletes its copy on Proton Drive.
- **Sync a local folder with a folder you already have in My files** (#67, #77).
`pdfs sync attach ~/Work --to Work` keeps `~/Work` an ordinary local folder and syncs it both
ways with My files/Work. The first sync uploads files that are only on this computer, downloads
@@ -146,6 +167,9 @@ Existing folders stay device backups. Older builds cannot open the upgraded data
### Fixed
- **Two programs changing settings at once no longer lose one of the changes** (B292). The app,
the tray and the service now change `config.json` under a lock, so for example a new cache
size saved by the service and the window size saved by the app both stay.
- **Resuming a Google Photos import no longer fails at once** (#94, B286, B287). A photo upload
that was cut short left a draft behind, and every later run stopped with
`check for existing photos: serialization error: invalid type: null`. Such drafts are now
@@ -162,13 +186,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
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
GNOME keyring with oo7, and two things there could keep a refreshed sign-in from being saved:
oo7 reports the entries of a locked keyring as missing, which the client took for a sign-out,
and a restarted oo7 no longer knew the client's connection, which then failed every save until
the service restarted. The refreshed sign-in lived only in memory, and the next boot found the
spent one. The client now keeps such a sign-in and saves it once the keyring can be read, and
reconnects to a keyring service that restarted.
- **Signed out after every reboot on Fedora 45** (issue #78, B284, B285, B291). Fedora 45 replaced
the GNOME keyring with oo7, and the oo7 build it ships keeps a changed keyring entry only in
memory: every refreshed sign-in the client saved was gone after a reboot, and the next start
found one Proton had already retired. The client now saves the sign-in as a new entry that
replaces the old one, which that oo7 does write to disk. It also no longer drops a refreshed
sign-in when oo7 reports the entries of a locked keyring as missing, and it reconnects to a
keyring service that restarted.
- **Thumbnails appear in the folder you are looking at as soon as they are made.** During
**Build thumbnails**, the folder on screen kept its file icons until you left it and opened it
+4
View File
@@ -119,6 +119,10 @@ commands are for scripts and for cases where the mount is not available.
| `pdfs sync reset ID` | Forget what a synced folder synced before and compare it with Proton Drive again. A file on one side only is copied to the other, and a file that differs keeps both versions. Nothing is deleted. |
| `pdfs sync pause [--for 1h] [--folder ID]` | Pause uploads and synced folders. Reading files keeps working. `--for` ends the pause by itself (`30m`, `1h`, `2d`). |
| `pdfs sync resume [--folder ID]` | Resume after a pause. |
| `pdfs sync ignore list` | Print the patterns every synced folder leaves out. Built-in ones are marked. |
| `pdfs sync ignore add PATTERN` / `remove PATTERN` | Leave out, or stop leaving out, files matching a gitignore-style pattern such as `*.db` or `build/`. A pattern starting with `-` goes after `--`. |
| `pdfs sync ignore reset` | Use the built-in patterns again. |
| `pdfs sync ignore check PATH` | Say whether a file in a synced folder is synced, and which pattern decides. |
| `pdfs sync limit [--up RATE] [--down RATE]` | Cap bandwidth, for example `500K` or `2M` per second. `0` removes a cap. Without options, prints the current caps. |
| `pdfs sync queue` | List changes that have not reached Proton Drive yet. |
| `pdfs sync issues` | List queued changes Proton Drive refused or that keep failing, and what to do. |
+15 -7
View File
@@ -44,9 +44,13 @@ the [security model](SECURITY_MODEL.md#what-is-kept-on-this-computer).
## `config.json`
The file is created with defaults on first start. Every key is optional; a missing key takes its
default. Edit it while the app is closed, then restart the service
default. Most keys can be changed in the app, under **Preferences** (the "In app" column below).
To edit the file by hand, close the app first, then restart the service
(`systemctl --user restart proton-drive.service`) for service settings to apply.
The app, the tray and the service each change the file under a lock (`config.json.lock` next to
it), so two of them changing different settings at once both keep their change.
An unreadable file is never overwritten: the programs log an error and run with defaults until you
fix it.
@@ -80,9 +84,9 @@ fix it.
| `cache_budget` | bytes | 5 GiB | Storage → Cache | Soft limit for cached content. `0` means unlimited. Available-offline files do not count against it |
| `upload_limit` | bytes/s | none | General → Network | Shared cap for all uploads. `0` or `null` means none |
| `download_limit` | bytes/s | none | General → Network | Shared cap for all downloads, reads from the mount included |
| `ignore_patterns` | list | see below | — | Global ignore rules for synced folders |
| `ignore_patterns` | list | see below | Sync → Excluded Files | Global ignore rules for synced folders |
| `device_uid` | string | none | Computers → Continue This Backup Here… or Sync With This Computer… | The computer this machine syncs into. Unset means "match by hostname" |
| `conflict_sweep` | `off` / `report` / `enforce` | `report` | — | See [`conflict_sweep`](#conflict_sweep) |
| `conflict_sweep` | `off` / `report` / `enforce` | `report` | Sync → Conflict Copies | See [`conflict_sweep`](#conflict_sweep) |
| `local_first` | bool | `true` | — | See [`local_first`](#local_first) |
| `language` | gettext code | system | General → Appearance | Language of the app, tray and prompt, such as `de` or `pt_BR` |
| `proton_theme` | bool | follow system | General → Appearance | Proton's colours instead of the system theme |
@@ -93,8 +97,8 @@ fix it.
| `update_latest` | version | none | — | The latest release the update check found |
| `files_view` | object | grid, by name | My files view menu | `list`, `sort` (`name`, `size`, `modified`), `descending`, `folders_first` |
| `window` | object | 980 × 680 | Resizing the app window | `width`, `height` (the unmaximized size), `maximized` |
| `open_with` | object | `xdg-open` | — | See [`open_with`](#open_with) |
| `prompt` | object | built-in window | — | See [`prompt`](#prompt) |
| `open_with` | object | `xdg-open` | Apps → Open Files With | See [`open_with`](#open_with) |
| `prompt` | object | built-in window | Apps → Search Launcher | See [`prompt`](#prompt) |
`app_version` and `user_agent` identify the client to Proton. When the keys are absent, the
client sends its own release (`external-drive-linux@<version>-stable`, `proton-drive-linux/<version>`).
@@ -109,10 +113,14 @@ Gitignore-style rules applied to every synced folder, in addition to each folder
```json
[".git/", ".hg/", ".svn/", "node_modules/", "target/", ".venv/", "__pycache__/",
"*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db"]
"*~", "*.swp", "*.tmp", ".DS_Store", "Thumbs.db",
"desktop.ini", ".directory", ".Trash-*/", ".Trashes/", ".Spotlight-V100/",
".fuse_hidden*", ".nfs*", "*.part", "*.crdownload", "*.kate-swp", ".~lock.*#", "~$*"]
```
Set it to `[]` to turn the defaults off. See
Preferences → Sync → Excluded Files edits this list, and `pdfs sync ignore` does the same from
a terminal. A list equal to the defaults is saved as absent, so it follows the defaults of later
releases. Set it to `[]` to turn the defaults off. See
[Synced folders](SYNCED_FOLDERS.md#excluding-files-with-pdfsignore) for how excluding behaves.
### `conflict_sweep`
+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
matching runtime evidence.
## SetSecret is kept only in memory in Fedora's oo7
Follow-up on 2026-11-15. The reporter's `rpm -qa 'oo7*'` shows
`oo7-daemon-0.7.0~beta^1.e91b98a-1.fc45`, not the 0.7.0 release assumed above. Bodhi lists that
build as the stable oo7 for Fedora 45 and 46; neither has 0.7.0 or 0.7.1. Commit e91b98a
(October 24) predates
[7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
(October 28): "Setting the Label or Attributes of an item, or calling SetSecret, only changed the
item in memory, so the old values came back once the daemon restarted." 0.7.0 carries it as
37e3334.
pdfs writes an existing entry with `SetSecret`, so on that build every saved token rotation was
lost at the next reboot. This explains the reporter's log: the keyring was unlocked one second
before pdfs started (they type their password at login) and still held a spent refresh token.
It does not need a locked keyring or a restarted provider.
pdfs now saves an existing entry with `CreateItem` and `replace` instead
(`crates/pdfs-core/src/secretservice.rs`, B291), which e91b98a writes to the keyring file.
Reproduced and verified with oo7-daemon built at e91b98a in a throwaway session bus:
```sh
git clone https://github.com/linux-credentials/oo7.git /tmp/oo7 && git -C /tmp/oo7 checkout e91b98a
cargo build --manifest-path /tmp/oo7/Cargo.toml -p oo7-daemon --bin oo7-daemon
OO7=/tmp/oo7/target/debug/oo7-daemon
T=$(mktemp -d /tmp/ss.XXXX); mkdir -p $T/data $T/run; chmod 700 $T/run
XDG_DATA_HOME=$T/data XDG_RUNTIME_DIR=$T/run OO7=$OO7 PDFS_SECRET_SERVICE_RESTART_TEST=1 \
PDFS_RESTART_PROVIDER='pkill -x oo7-daemon; sleep 1; (printf pw | setsid "$OO7" --login >/dev/null 2>&1 &); sleep 2' \
dbus-run-session -- sh -c 'printf pw | setsid "$OO7" --login >/dev/null 2>&1 & sleep 2;
cargo test -p pdfs-core real_secret_service_keeps -- --ignored'
```
With the in-place write, the read after the restart returns the first of three saves (`r1`);
with the replacing write it returns the last (`r3`), and one item is left.
The daemon also logs a short fingerprint of the refresh token when it resumes the stored session
and each time it saves a rotation (`refresh=1a2b3c4d`). If a start is refused, compare the
fingerprint it resumed with against the last one saved in the boot before:
```sh
journalctl --user -b -1 -u proton-drive.service | grep -E 'refresh=' | tail -2
journalctl --user -b 0 -u proton-drive.service | grep -E 'refresh=' | head -2
```
The same fingerprint means the keyring kept the last save and Proton refused it; a different one
means the keyring lost it.
## A restarted Secret Service
A second path to the same symptom, independent of locking (B285). The keyring store pdfs used
+4 -3
View File
@@ -69,9 +69,10 @@ windowrulev2 = center, class:^(pdfs-prompt)$
bind = SUPER, space, exec, pdfs-prompt --fzf
```
To make `--dmenu` or `--fzf` the default without changing your shortcut, set `prompt.mode` in
`config.json` (see [Configuration → `prompt`](CONFIGURATION.md#prompt)). `--gtk` always opens the
built-in window.
To make `--dmenu` or `--fzf` the default without changing your shortcut, pick it in
**Preferences → Apps → Search Launcher**, or set `prompt.mode` in `config.json` (see
[Configuration → `prompt`](CONFIGURATION.md#prompt)). `--gtk` always opens the built-in window.
Which program opens a file you pick is set under **Preferences → Apps → Open Files With**.
## Tray
+26 -4
View File
@@ -100,10 +100,32 @@ apply together:
!important.log
```
2. The `ignore_patterns` list in `config.json`, for every synced folder (see
[Configuration](CONFIGURATION.md#ignore_patterns)). When you have not set it, it skips
`.git/`, `.hg/`, `.svn/`, `node_modules/`, `target/`, `.venv/`, `__pycache__/`, `*~`,
`*.swp`, `*.tmp`, `.DS_Store` and `Thumbs.db`.
2. The patterns for every synced folder: **Preferences → Sync → Excluded Files** in the app, or
`ignore_patterns` in `config.json` (see [Configuration](CONFIGURATION.md#ignore_patterns)).
Built in are version control (`.git/`, `.hg/`, `.svn/`), dependency and build folders
(`node_modules/`, `target/`, `.venv/`, `__pycache__/`), and what editors, downloads and other
systems leave behind (`*~`, `*.swp`, `*.tmp`, `*.part`, `*.crdownload`, `*.kate-swp`, office
lock files, `.DS_Store`, `Thumbs.db`, `desktop.ini`, `.directory`, trash folders, `.nfs*` and
`.fuse_hidden*`). Each built-in pattern can be turned off on its own.
To edit a folder's own rules in the app, open the **Sync** page, then **Folders**, and pick
**Excluded Files…** in the folder's menu. It checks every line as you type, and **Check a path**
tells you whether a file is synced and which pattern decides. If the file changed meanwhile, for
example on another computer, it asks before replacing that version.
From a terminal:
```bash
pdfs sync ignore list # the patterns for every synced folder
pdfs sync ignore add '*.db' # leave out files ending in .db
pdfs sync ignore remove '*.db'
pdfs sync ignore reset # back to the built-in patterns
pdfs sync ignore check ~/Projects/app/node_modules
```
The rules apply to folders kept on this computer. Files you save into `~/ProtonDrive` itself or into
an online-only folder are always uploaded, except download and editor scratch files, which wait for
their final name.
Rules are read again on every sync pass. Excluding never deletes anything: a file that becomes
excluded is no longer synced, and its copy on Proton Drive stays.
+2
View File
@@ -53,6 +53,8 @@ The app uses these words, and so do these pages:
| Page | Settings |
|---|---|
| **General** | Start on login · Proton Drive folder location · upload and download limits · Proton theme, street map for Places, tray icon · language · check for updates |
| **Sync** | Files and folders every synced folder leaves out · what happens to identical conflict copies |
| **Apps** | Which program opens which kind of file · how the search launcher opens |
| **Storage** | Cache size limit · clear the cache · files kept available offline |
The account menu shows the storage you use and holds **Sign Out…**. Settings that are not in the
+3
View File
@@ -13,6 +13,8 @@ crates/pdfs-gui/src/app/pages/photo_viewer.rs
crates/pdfs-gui/src/app/pages/photos.rs
crates/pdfs-gui/src/app/pages/places.rs
crates/pdfs-gui/src/app/pages/places_map.rs
crates/pdfs-gui/src/app/pages/preferences_apps.rs
crates/pdfs-gui/src/app/pages/preferences_sync.rs
crates/pdfs-gui/src/app/pages/shared.rs
crates/pdfs-gui/src/app/pages/shared_by_me.rs
crates/pdfs-gui/src/app/pages/status.rs
@@ -23,6 +25,7 @@ crates/pdfs-gui/src/app/update.rs
crates/pdfs-gui/src/app/widgets/compat.rs
crates/pdfs-gui/src/app/widgets/details.rs
crates/pdfs-gui/src/app/widgets/file_list.rs
crates/pdfs-gui/src/app/widgets/ignore_dialog.rs
crates/pdfs-gui/src/app/widgets/menu.rs
crates/pdfs-gui/src/app/widgets/player.rs
crates/pdfs-gui/src/app/widgets/share_dialog.rs
+675 -352
View File
File diff suppressed because it is too large. Load diff
+670 -351
View File
File diff suppressed because it is too large. Load diff
+673 -352
View File
File diff suppressed because it is too large. Load diff
+673 -352
View File
File diff suppressed because it is too large. Load diff
+675 -352
View File
File diff suppressed because it is too large. Load diff
+675 -352
View File
File diff suppressed because it is too large. Load diff
+680 -348
View File
File diff suppressed because it is too large. Load diff
+676 -353
View File
File diff suppressed because it is too large. Load diff
+673 -352
View File
File diff suppressed because it is too large. Load diff
+16 -4
View File
@@ -16,7 +16,8 @@ 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)
prompt_gtk,prompt_fzf). preferences_sync and
preferences_apps exist too, for pull requests only
--website DIR afterwards, copy them into the website checkout at DIR
with its scripts/sync-screenshots.sh
--settle SECS how long a page gets to load before its capture (default 3)
@@ -34,6 +35,8 @@ EOF
repo="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
all=login,files,photos,photos_map,computers,sync,conflicts,prompt_gtk,prompt_fzf
# Not in the README, so not taken by default.
extra=preferences_sync,preferences_apps
# The capture itself, run by cage inside the throwaway session (see below).
if [[ "${1:-}" == --capture ]]; then
@@ -66,7 +69,8 @@ if [[ "${1:-}" == --capture ]]; then
app=$!
sleep "$SETTLE"
for shot in files:browser photos:gallery photos_map:places-map computers:devices \
sync:sync-folders conflicts:activity; do
sync:sync-folders conflicts:activity \
preferences_sync:preferences-sync preferences_apps:preferences-apps; do
name=${shot%%:*}
wants "$name" || continue
"$BIN/pdfs-app" --page "${shot#*:}"
@@ -138,7 +142,7 @@ while (($#)); do
shift
done
for shot in ${shots//,/ }; do
[[ ",$all," == *",$shot,"* ]] || { echo "no screenshot called $shot" >&2; exit 2; }
[[ ",$all,$extra," == *",$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; }
@@ -185,7 +189,15 @@ cat >"$root/config/proton-drive-linux/config.json" <<'EOF'
"tray_hidden": true,
"update_check": false,
"online_map": false,
"files_view": { "list": false }
"files_view": { "list": false },
"ignore_patterns": [".git/", "node_modules/", "target/", "*~", "*.swp", ".DS_Store",
"*.iso", "build/", "*.sqlite-wal"],
"open_with": {
"rules": [
{ "match": ["@text", "*.md"], "command": ["nvim"], "terminal": true },
{ "match": ["@image"], "command": ["loupe"] }
]
}
}
EOF