mirror of
https://github.com/NotAShelf/stash.git
synced 2026-04-12 22:17:41 +00:00
Merge pull request #58 from NotAShelf/notashelf/push-oksprvxpxpxt
various: improve robustness of entry tracking in database
This commit is contained in:
GitHub
commit
4ab9ce4a71
7 changed files with 668 additions and 138 deletions
1
Cargo.lock
generated
1
Cargo.lock
generated
|
|
@ -1712,6 +1712,7 @@ dependencies = [
|
|||
"serde",
|
||||
"serde_json",
|
||||
"smol",
|
||||
"tempfile",
|
||||
"thiserror",
|
||||
"unicode-segmentation",
|
||||
"unicode-width 0.2.0",
|
||||
|
|
|
|||
|
|
@ -47,6 +47,9 @@ wayland-client = { version = "0.31.11", features = ["log"], optional = true }
|
|||
wayland-protocols-wlr = { version = "0.3.9", default-features = false, optional = true }
|
||||
notify-rust = { version = "4.11.7", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3.18.0"
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
opt-level = "z"
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
clippy,
|
||||
taplo,
|
||||
rust-analyzer-unwrapped,
|
||||
cargo-nextest,
|
||||
rustPlatform,
|
||||
}:
|
||||
mkShell {
|
||||
|
|
@ -20,6 +21,9 @@ mkShell {
|
|||
cargo
|
||||
taplo
|
||||
rust-analyzer-unwrapped
|
||||
|
||||
# Additional Cargo Tooling
|
||||
cargo-nextest
|
||||
];
|
||||
|
||||
RUST_SRC_PATH = "${rustPlatform.rustLibSrc}";
|
||||
|
|
|
|||
|
|
@ -55,7 +55,10 @@ impl SqliteClipboardDb {
|
|||
// Query entries from DB
|
||||
let mut stmt = self
|
||||
.conn
|
||||
.prepare("SELECT id, contents, mime FROM clipboard ORDER BY id DESC")
|
||||
.prepare(
|
||||
"SELECT id, contents, mime FROM clipboard ORDER BY last_accessed \
|
||||
DESC, id DESC",
|
||||
)
|
||||
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
|
||||
let mut rows = stmt
|
||||
.query([])
|
||||
|
|
@ -242,13 +245,15 @@ impl SqliteClipboardDb {
|
|||
|
||||
if event::poll(std::time::Duration::from_millis(250))
|
||||
.map_err(|e| StashError::ListDecode(e.to_string().into()))?
|
||||
{
|
||||
if let Event::Key(key) = event::read()
|
||||
&& let Event::Key(key) = event::read()
|
||||
.map_err(|e| StashError::ListDecode(e.to_string().into()))?
|
||||
{
|
||||
match (key.code, key.modifiers) {
|
||||
(KeyCode::Char('q') | KeyCode::Esc, _) => break,
|
||||
(KeyCode::Down | KeyCode::Char('j'), _) => {
|
||||
{
|
||||
match (key.code, key.modifiers) {
|
||||
(KeyCode::Char('q') | KeyCode::Esc, _) => break,
|
||||
(KeyCode::Down | KeyCode::Char('j'), _) => {
|
||||
if entries.is_empty() {
|
||||
state.select(None);
|
||||
} else {
|
||||
let i = match state.selected() {
|
||||
Some(i) => {
|
||||
if i >= entries.len() - 1 {
|
||||
|
|
@ -260,8 +265,12 @@ impl SqliteClipboardDb {
|
|||
None => 0,
|
||||
};
|
||||
state.select(Some(i));
|
||||
},
|
||||
(KeyCode::Up | KeyCode::Char('k'), _) => {
|
||||
}
|
||||
},
|
||||
(KeyCode::Up | KeyCode::Char('k'), _) => {
|
||||
if entries.is_empty() {
|
||||
state.select(None);
|
||||
} else {
|
||||
let i = match state.selected() {
|
||||
Some(i) => {
|
||||
if i == 0 {
|
||||
|
|
@ -273,27 +282,25 @@ impl SqliteClipboardDb {
|
|||
None => 0,
|
||||
};
|
||||
state.select(Some(i));
|
||||
},
|
||||
(KeyCode::Enter, _) => {
|
||||
if let Some(idx) = state.selected() {
|
||||
if let Some((id, ..)) = entries.get(idx) {
|
||||
// Fetch full contents for the selected entry
|
||||
let (contents, mime): (Vec<u8>, Option<String>) = self
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT contents, mime FROM clipboard WHERE id = ?1",
|
||||
rusqlite::params![id],
|
||||
|row| Ok((row.get(0)?, row.get(1)?)),
|
||||
)
|
||||
.map_err(|e| {
|
||||
StashError::ListDecode(e.to_string().into())
|
||||
})?;
|
||||
// Copy to clipboard
|
||||
}
|
||||
},
|
||||
(KeyCode::Enter, _) => {
|
||||
if let Some(idx) = state.selected()
|
||||
&& let Some((id, ..)) = entries.get(idx)
|
||||
{
|
||||
match self.copy_entry(*id) {
|
||||
Ok((new_id, contents, mime)) => {
|
||||
if new_id != *id {
|
||||
entries[idx] = (
|
||||
new_id,
|
||||
entries[idx].1.clone(),
|
||||
entries[idx].2.clone(),
|
||||
);
|
||||
}
|
||||
let opts = Options::new();
|
||||
// Default clipboard is regular, seat is default
|
||||
let mime_type = match mime {
|
||||
Some(ref m) if m == "text/plain" => MimeType::Text,
|
||||
Some(ref m) => MimeType::Specific(m.clone()),
|
||||
Some(ref m) => MimeType::Specific(m.clone().to_owned()),
|
||||
None => MimeType::Text,
|
||||
};
|
||||
let copy_result = opts
|
||||
|
|
@ -313,42 +320,49 @@ impl SqliteClipboardDb {
|
|||
.show();
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
(KeyCode::Char('D'), KeyModifiers::SHIFT) => {
|
||||
if let Some(idx) = state.selected() {
|
||||
if let Some((id, ..)) = entries.get(idx) {
|
||||
// Delete entry from DB
|
||||
self
|
||||
.conn
|
||||
.execute(
|
||||
"DELETE FROM clipboard WHERE id = ?1",
|
||||
rusqlite::params![id],
|
||||
)
|
||||
.map_err(|e| {
|
||||
StashError::DeleteEntry(*id, e.to_string().into())
|
||||
})?;
|
||||
// Remove from entries and update selection
|
||||
entries.remove(idx);
|
||||
let new_len = entries.len();
|
||||
if new_len == 0 {
|
||||
state.select(None);
|
||||
} else if idx >= new_len {
|
||||
state.select(Some(new_len - 1));
|
||||
} else {
|
||||
state.select(Some(idx));
|
||||
}
|
||||
// Show notification
|
||||
},
|
||||
Err(e) => {
|
||||
log::error!("Failed to fetch entry {id}: {e}");
|
||||
let _ = Notification::new()
|
||||
.summary("Stash")
|
||||
.body("Deleted entry")
|
||||
.body(&format!("Failed to fetch entry: {e}"))
|
||||
.show();
|
||||
}
|
||||
},
|
||||
}
|
||||
},
|
||||
_ => {},
|
||||
}
|
||||
}
|
||||
},
|
||||
(KeyCode::Char('D'), KeyModifiers::SHIFT) => {
|
||||
if let Some(idx) = state.selected()
|
||||
&& let Some((id, ..)) = entries.get(idx)
|
||||
{
|
||||
// Delete entry from DB
|
||||
self
|
||||
.conn
|
||||
.execute(
|
||||
"DELETE FROM clipboard WHERE id = ?1",
|
||||
rusqlite::params![id],
|
||||
)
|
||||
.map_err(|e| {
|
||||
StashError::DeleteEntry(*id, e.to_string().into())
|
||||
})?;
|
||||
// Remove from entries and update selection
|
||||
entries.remove(idx);
|
||||
let new_len = entries.len();
|
||||
if new_len == 0 {
|
||||
state.select(None);
|
||||
} else if idx >= new_len {
|
||||
state.select(Some(new_len - 1));
|
||||
} else {
|
||||
state.select(Some(idx));
|
||||
}
|
||||
// Show notification
|
||||
let _ = Notification::new()
|
||||
.summary("Stash")
|
||||
.body("Deleted entry")
|
||||
.show();
|
||||
}
|
||||
},
|
||||
_ => {},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
638
src/db/mod.rs
638
src/db/mod.rs
|
|
@ -89,6 +89,10 @@ pub trait ClipboardDb {
|
|||
) -> Result<(), StashError>;
|
||||
fn delete_query(&self, query: &str) -> Result<usize, StashError>;
|
||||
fn delete_entries(&self, input: impl Read) -> Result<usize, StashError>;
|
||||
fn copy_entry(
|
||||
&self,
|
||||
id: i64,
|
||||
) -> Result<(i64, Vec<u8>, Option<String>), StashError>;
|
||||
fn next_sequence(&self) -> i64;
|
||||
}
|
||||
|
||||
|
|
@ -110,7 +114,7 @@ pub struct SqliteClipboardDb {
|
|||
}
|
||||
|
||||
impl SqliteClipboardDb {
|
||||
pub fn new(conn: Connection) -> Result<Self, StashError> {
|
||||
pub fn new(mut conn: Connection) -> Result<Self, StashError> {
|
||||
conn
|
||||
.pragma_update(None, "synchronous", "OFF")
|
||||
.map_err(|e| {
|
||||
|
|
@ -139,26 +143,124 @@ impl SqliteClipboardDb {
|
|||
conn.pragma_update(None, "page_size", "512") // small(er) pages
|
||||
.map_err(|e| StashError::Store(format!("Failed to set page_size pragma: {e}").into()))?;
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
let tx = conn.transaction().map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to begin migration transaction: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
|
||||
let schema_version: i64 = tx
|
||||
.pragma_query_value(None, "user_version", |row| row.get(0))
|
||||
.map_err(|e| {
|
||||
StashError::Store(format!("Failed to read schema version: {e}").into())
|
||||
})?;
|
||||
|
||||
if schema_version == 0 {
|
||||
tx.execute_batch(
|
||||
"CREATE TABLE IF NOT EXISTS clipboard (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
contents BLOB NOT NULL,
|
||||
mime TEXT
|
||||
);",
|
||||
)
|
||||
.map_err(|e| StashError::Store(e.to_string().into()))?;
|
||||
.map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to create clipboard table: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
|
||||
tx.execute("PRAGMA user_version = 1", []).map_err(|e| {
|
||||
StashError::Store(format!("Failed to set schema version: {e}").into())
|
||||
})?;
|
||||
}
|
||||
|
||||
// Add content_hash column if it doesn't exist
|
||||
// Migration MUST be done to avoid breaking existing installations.
|
||||
let _ =
|
||||
conn.execute("ALTER TABLE clipboard ADD COLUMN content_hash INTEGER", []);
|
||||
if schema_version < 2 {
|
||||
let has_content_hash: bool = tx
|
||||
.query_row(
|
||||
"SELECT sql FROM sqlite_master WHERE type='table' AND \
|
||||
name='clipboard'",
|
||||
[],
|
||||
|row| {
|
||||
let sql: String = row.get(0)?;
|
||||
Ok(sql.to_lowercase().contains("content_hash"))
|
||||
},
|
||||
)
|
||||
.unwrap_or(false);
|
||||
|
||||
// Create index for content_hash if it doesn't exist
|
||||
let _ = conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_content_hash ON clipboard(content_hash)",
|
||||
[],
|
||||
);
|
||||
if !has_content_hash {
|
||||
tx.execute("ALTER TABLE clipboard ADD COLUMN content_hash INTEGER", [])
|
||||
.map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to add content_hash column: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
}
|
||||
|
||||
// Create index for content_hash if it doesn't exist
|
||||
tx.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_content_hash ON \
|
||||
clipboard(content_hash)",
|
||||
[],
|
||||
)
|
||||
.map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to create content_hash index: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
|
||||
tx.execute("PRAGMA user_version = 2", []).map_err(|e| {
|
||||
StashError::Store(format!("Failed to set schema version: {e}").into())
|
||||
})?;
|
||||
}
|
||||
|
||||
// Add last_accessed column if it doesn't exist
|
||||
if schema_version < 3 {
|
||||
let has_last_accessed: bool = tx
|
||||
.query_row(
|
||||
"SELECT sql FROM sqlite_master WHERE type='table' AND \
|
||||
name='clipboard'",
|
||||
[],
|
||||
|row| {
|
||||
let sql: String = row.get(0)?;
|
||||
Ok(sql.to_lowercase().contains("last_accessed"))
|
||||
},
|
||||
)
|
||||
.unwrap_or(false);
|
||||
|
||||
if !has_last_accessed {
|
||||
tx.execute("ALTER TABLE clipboard ADD COLUMN last_accessed INTEGER", [
|
||||
])
|
||||
.map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to add last_accessed column: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
}
|
||||
|
||||
// Create index for last_accessed if it doesn't exist
|
||||
tx.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_last_accessed ON \
|
||||
clipboard(last_accessed)",
|
||||
[],
|
||||
)
|
||||
.map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to create last_accessed index: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
|
||||
tx.execute("PRAGMA user_version = 3", []).map_err(|e| {
|
||||
StashError::Store(format!("Failed to set schema version: {e}").into())
|
||||
})?;
|
||||
}
|
||||
|
||||
tx.commit().map_err(|e| {
|
||||
StashError::Store(
|
||||
format!("Failed to commit migration transaction: {e}").into(),
|
||||
)
|
||||
})?;
|
||||
|
||||
// Initialize Wayland state in background thread. This will be used to track
|
||||
// focused window state.
|
||||
|
|
@ -172,7 +274,10 @@ impl SqliteClipboardDb {
|
|||
pub fn list_json(&self) -> Result<String, StashError> {
|
||||
let mut stmt = self
|
||||
.conn
|
||||
.prepare("SELECT id, contents, mime FROM clipboard ORDER BY id DESC")
|
||||
.prepare(
|
||||
"SELECT id, contents, mime FROM clipboard ORDER BY \
|
||||
COALESCE(last_accessed, 0) DESC, id DESC",
|
||||
)
|
||||
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
|
||||
let mut rows = stmt
|
||||
.query([])
|
||||
|
|
@ -243,11 +348,11 @@ impl ClipboardDb for SqliteClipboardDb {
|
|||
let regex = load_sensitive_regex();
|
||||
if let Some(re) = regex {
|
||||
// Only check text data
|
||||
if let Ok(s) = std::str::from_utf8(&buf) {
|
||||
if re.is_match(s) {
|
||||
warn!("Clipboard entry matches sensitive regex, skipping store.");
|
||||
return Err(StashError::Store("Filtered by sensitive regex".into()));
|
||||
}
|
||||
if let Ok(s) = std::str::from_utf8(&buf)
|
||||
&& re.is_match(s)
|
||||
{
|
||||
warn!("Clipboard entry matches sensitive regex, skipping store.");
|
||||
return Err(StashError::Store("Filtered by sensitive regex".into()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -264,14 +369,27 @@ impl ClipboardDb for SqliteClipboardDb {
|
|||
self
|
||||
.conn
|
||||
.execute(
|
||||
"INSERT INTO clipboard (contents, mime, content_hash) VALUES (?1, ?2, \
|
||||
?3)",
|
||||
params![buf, mime, content_hash],
|
||||
"INSERT INTO clipboard (contents, mime, content_hash, last_accessed) \
|
||||
VALUES (?1, ?2, ?3, ?4)",
|
||||
params![
|
||||
buf,
|
||||
mime,
|
||||
content_hash,
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.expect("Time went backwards")
|
||||
.as_secs() as i64
|
||||
],
|
||||
)
|
||||
.map_err(|e| StashError::Store(e.to_string().into()))?;
|
||||
|
||||
let id = self
|
||||
.conn
|
||||
.query_row("SELECT last_insert_rowid()", [], |row| row.get(0))
|
||||
.map_err(|e| StashError::Store(e.to_string().into()))?;
|
||||
|
||||
self.trim_db(max_items)?;
|
||||
Ok(self.next_sequence())
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
fn deduplicate_by_hash(
|
||||
|
|
@ -317,6 +435,8 @@ impl ClipboardDb for SqliteClipboardDb {
|
|||
let max_i64 = i64::try_from(max).unwrap_or(i64::MAX);
|
||||
if count > max_i64 {
|
||||
let to_delete = count - max_i64;
|
||||
|
||||
#[allow(clippy::useless_conversion)]
|
||||
self
|
||||
.conn
|
||||
.execute(
|
||||
|
|
@ -369,7 +489,10 @@ impl ClipboardDb for SqliteClipboardDb {
|
|||
) -> Result<usize, StashError> {
|
||||
let mut stmt = self
|
||||
.conn
|
||||
.prepare("SELECT id, contents, mime FROM clipboard ORDER BY id DESC")
|
||||
.prepare(
|
||||
"SELECT id, contents, mime FROM clipboard ORDER BY \
|
||||
COALESCE(last_accessed, 0) DESC, id DESC",
|
||||
)
|
||||
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
|
||||
let mut rows = stmt
|
||||
.query([])
|
||||
|
|
@ -476,6 +599,48 @@ impl ClipboardDb for SqliteClipboardDb {
|
|||
Ok(deleted)
|
||||
}
|
||||
|
||||
fn copy_entry(
|
||||
&self,
|
||||
id: i64,
|
||||
) -> Result<(i64, Vec<u8>, Option<String>), StashError> {
|
||||
let (contents, mime, content_hash): (Vec<u8>, Option<String>, Option<i64>) =
|
||||
self
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT contents, mime, content_hash FROM clipboard WHERE id = ?1",
|
||||
params![id],
|
||||
|row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
|
||||
)
|
||||
.map_err(|e| StashError::DecodeGet(e.to_string().into()))?;
|
||||
|
||||
if let Some(hash) = content_hash {
|
||||
let most_recent_id: Option<i64> = self
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT id FROM clipboard WHERE content_hash = ?1 AND last_accessed \
|
||||
= (SELECT MAX(last_accessed) FROM clipboard WHERE content_hash = \
|
||||
?1)",
|
||||
params![hash],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.optional()
|
||||
.map_err(|e| StashError::DecodeGet(e.to_string().into()))?;
|
||||
|
||||
if most_recent_id != Some(id) {
|
||||
self
|
||||
.conn
|
||||
.execute(
|
||||
"UPDATE clipboard SET last_accessed = CAST(strftime('%s', 'now') \
|
||||
AS INTEGER) WHERE id = ?1",
|
||||
params![id],
|
||||
)
|
||||
.map_err(|e| StashError::Store(e.to_string().into()))?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok((id, contents, mime))
|
||||
}
|
||||
|
||||
fn next_sequence(&self) -> i64 {
|
||||
match self
|
||||
.conn
|
||||
|
|
@ -560,6 +725,7 @@ pub fn detect_mime(data: &[u8]) -> Option<String> {
|
|||
ImageType::Qoi => "image/qoi",
|
||||
ImageType::Tga => "image/x-tga",
|
||||
ImageType::Vtf => "image/x-vtf",
|
||||
ImageType::Heif(imagesize::Compression::Hevc) => "image/heic",
|
||||
ImageType::Heif(_) => "image/heif",
|
||||
_ => "application/octet-stream",
|
||||
};
|
||||
|
|
@ -693,11 +859,11 @@ fn get_focused_window_app() -> Option<String> {
|
|||
}
|
||||
|
||||
// Fallback: Check WAYLAND_CLIENT_NAME environment variable
|
||||
if let Ok(client) = env::var("WAYLAND_CLIENT_NAME") {
|
||||
if !client.is_empty() {
|
||||
debug!("Found WAYLAND_CLIENT_NAME: {client}");
|
||||
return Some(client);
|
||||
}
|
||||
if let Ok(client) = env::var("WAYLAND_CLIENT_NAME")
|
||||
&& !client.is_empty()
|
||||
{
|
||||
debug!("Found WAYLAND_CLIENT_NAME: {client}");
|
||||
return Some(client);
|
||||
}
|
||||
|
||||
debug!("No focused window detection method worked");
|
||||
|
|
@ -717,19 +883,17 @@ fn get_recently_active_excluded_app(
|
|||
|
||||
if let Ok(entries) = std::fs::read_dir(proc_dir) {
|
||||
for entry in entries.flatten() {
|
||||
if let Ok(pid) = entry.file_name().to_string_lossy().parse::<u32>() {
|
||||
if let Ok(comm) = fs::read_to_string(format!("/proc/{pid}/comm")) {
|
||||
let process_name = comm.trim();
|
||||
if let Ok(pid) = entry.file_name().to_string_lossy().parse::<u32>()
|
||||
&& let Ok(comm) = fs::read_to_string(format!("/proc/{pid}/comm"))
|
||||
{
|
||||
let process_name = comm.trim();
|
||||
|
||||
// Check process name against exclusion list
|
||||
if app_matches_exclusion(process_name, excluded_apps)
|
||||
&& has_recent_activity(pid)
|
||||
{
|
||||
candidates.push((
|
||||
process_name.to_string(),
|
||||
get_process_activity_score(pid),
|
||||
));
|
||||
}
|
||||
// Check process name against exclusion list
|
||||
if app_matches_exclusion(process_name, excluded_apps)
|
||||
&& has_recent_activity(pid)
|
||||
{
|
||||
candidates
|
||||
.push((process_name.to_string(), get_process_activity_score(pid)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -763,15 +927,13 @@ fn has_recent_activity(pid: u32) -> bool {
|
|||
// Check /proc/PID/io for recent I/O activity
|
||||
if let Ok(io_stats) = fs::read_to_string(format!("/proc/{pid}/io")) {
|
||||
for line in io_stats.lines() {
|
||||
if line.starts_with("write_bytes:") || line.starts_with("read_bytes:") {
|
||||
if let Some(value_str) = line.split(':').nth(1) {
|
||||
if let Ok(value) = value_str.trim().parse::<u64>() {
|
||||
if value > 1024 * 1024 {
|
||||
// 1MB threshold
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (line.starts_with("write_bytes:") || line.starts_with("read_bytes:"))
|
||||
&& let Some(value_str) = line.split(':').nth(1)
|
||||
&& let Ok(value) = value_str.trim().parse::<u64>()
|
||||
&& value > 1024 * 1024
|
||||
{
|
||||
// 1MB threshold
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -786,24 +948,22 @@ fn get_process_activity_score(pid: u32) -> u64 {
|
|||
// Add CPU time to score
|
||||
if let Ok(stat) = fs::read_to_string(format!("/proc/{pid}/stat")) {
|
||||
let fields: Vec<&str> = stat.split_whitespace().collect();
|
||||
if fields.len() > 14 {
|
||||
if let (Ok(utime), Ok(stime)) =
|
||||
if fields.len() > 14
|
||||
&& let (Ok(utime), Ok(stime)) =
|
||||
(fields[13].parse::<u64>(), fields[14].parse::<u64>())
|
||||
{
|
||||
score += utime + stime;
|
||||
}
|
||||
{
|
||||
score += utime + stime;
|
||||
}
|
||||
}
|
||||
|
||||
// Add I/O activity to score
|
||||
if let Ok(io_stats) = fs::read_to_string(format!("/proc/{pid}/io")) {
|
||||
for line in io_stats.lines() {
|
||||
if line.starts_with("write_bytes:") || line.starts_with("read_bytes:") {
|
||||
if let Some(value_str) = line.split(':').nth(1) {
|
||||
if let Ok(value) = value_str.trim().parse::<u64>() {
|
||||
score += value / 1024; // convert to KB
|
||||
}
|
||||
}
|
||||
if (line.starts_with("write_bytes:") || line.starts_with("read_bytes:"))
|
||||
&& let Some(value_str) = line.split(':').nth(1)
|
||||
&& let Ok(value) = value_str.trim().parse::<u64>()
|
||||
{
|
||||
score += value / 1024; // convert to KB
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -834,11 +994,11 @@ fn app_matches_exclusion(app_name: &str, excluded_apps: &[String]) -> bool {
|
|||
} else if excluded.contains('*') {
|
||||
// Simple wildcard matching
|
||||
let pattern = excluded.replace('*', ".*");
|
||||
if let Ok(regex) = regex::Regex::new(&pattern) {
|
||||
if regex.is_match(app_name) {
|
||||
debug!("Matched wildcard pattern: {app_name} matches {excluded}");
|
||||
return true;
|
||||
}
|
||||
if let Ok(regex) = regex::Regex::new(&pattern)
|
||||
&& regex.is_match(app_name)
|
||||
{
|
||||
debug!("Matched wildcard pattern: {app_name} matches {excluded}");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -846,3 +1006,353 @@ fn app_matches_exclusion(app_name: &str, excluded_apps: &[String]) -> bool {
|
|||
debug!("No match found for '{app_name}'");
|
||||
false
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use rusqlite::Connection;
|
||||
|
||||
use super::*;
|
||||
|
||||
fn get_schema_version(conn: &Connection) -> rusqlite::Result<i64> {
|
||||
conn.pragma_query_value(None, "user_version", |row| row.get(0))
|
||||
}
|
||||
|
||||
fn table_column_exists(conn: &Connection, table: &str, column: &str) -> bool {
|
||||
let query = format!(
|
||||
"SELECT sql FROM sqlite_master WHERE type='table' AND name='{}'",
|
||||
table
|
||||
);
|
||||
match conn.query_row(&query, [], |row| row.get::<_, String>(0)) {
|
||||
Ok(sql) => sql.contains(column),
|
||||
Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn index_exists(conn: &Connection, index: &str) -> bool {
|
||||
let query = "SELECT name FROM sqlite_master WHERE type='index' AND name=?1";
|
||||
conn
|
||||
.query_row(query, [index], |row| row.get::<_, String>(0))
|
||||
.is_ok()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fresh_database_v3_schema() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_fresh.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
assert_eq!(
|
||||
get_schema_version(&db.conn).expect("Failed to get schema version"),
|
||||
3
|
||||
);
|
||||
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "content_hash"));
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "last_accessed"));
|
||||
|
||||
assert!(index_exists(&db.conn, "idx_content_hash"));
|
||||
assert!(index_exists(&db.conn, "idx_last_accessed"));
|
||||
|
||||
db.conn
|
||||
.execute(
|
||||
"INSERT INTO clipboard (contents, mime, content_hash, last_accessed) \
|
||||
VALUES (x'010203', 'text/plain', 12345, 1704067200)",
|
||||
[],
|
||||
)
|
||||
.expect("Failed to insert test data");
|
||||
|
||||
let count: i64 = db
|
||||
.conn
|
||||
.query_row("SELECT COUNT(*) FROM clipboard", [], |row| row.get(0))
|
||||
.expect("Failed to count");
|
||||
assert_eq!(count, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_migration_from_v0() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_v0.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"CREATE TABLE IF NOT EXISTS clipboard (id INTEGER PRIMARY KEY \
|
||||
AUTOINCREMENT, contents BLOB NOT NULL, mime TEXT);",
|
||||
)
|
||||
.expect("Failed to create table");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"INSERT INTO clipboard (contents, mime) VALUES (x'010203', \
|
||||
'text/plain')",
|
||||
)
|
||||
.expect("Failed to insert data");
|
||||
|
||||
assert_eq!(get_schema_version(&conn).expect("Failed to get version"), 0);
|
||||
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
assert_eq!(
|
||||
get_schema_version(&db.conn)
|
||||
.expect("Failed to get version after migration"),
|
||||
3
|
||||
);
|
||||
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "content_hash"));
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "last_accessed"));
|
||||
|
||||
let count: i64 = db
|
||||
.conn
|
||||
.query_row("SELECT COUNT(*) FROM clipboard", [], |row| row.get(0))
|
||||
.expect("Failed to count");
|
||||
assert_eq!(count, 1, "Existing data should be preserved");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_migration_from_v1() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_v1.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"CREATE TABLE IF NOT EXISTS clipboard (id INTEGER PRIMARY KEY \
|
||||
AUTOINCREMENT, contents BLOB NOT NULL, mime TEXT);",
|
||||
)
|
||||
.expect("Failed to create table");
|
||||
|
||||
conn
|
||||
.pragma_update(None, "user_version", 1i64)
|
||||
.expect("Failed to set version");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"INSERT INTO clipboard (contents, mime) VALUES (x'010203', \
|
||||
'text/plain')",
|
||||
)
|
||||
.expect("Failed to insert data");
|
||||
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
assert_eq!(
|
||||
get_schema_version(&db.conn)
|
||||
.expect("Failed to get version after migration"),
|
||||
3
|
||||
);
|
||||
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "content_hash"));
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "last_accessed"));
|
||||
|
||||
let count: i64 = db
|
||||
.conn
|
||||
.query_row("SELECT COUNT(*) FROM clipboard", [], |row| row.get(0))
|
||||
.expect("Failed to count");
|
||||
assert_eq!(count, 1, "Existing data should be preserved");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_migration_from_v2() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_v2.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"CREATE TABLE IF NOT EXISTS clipboard (id INTEGER PRIMARY KEY \
|
||||
AUTOINCREMENT, contents BLOB NOT NULL, mime TEXT, content_hash \
|
||||
INTEGER);",
|
||||
)
|
||||
.expect("Failed to create table");
|
||||
|
||||
conn
|
||||
.pragma_update(None, "user_version", 2i64)
|
||||
.expect("Failed to set version");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"INSERT INTO clipboard (contents, mime, content_hash) VALUES \
|
||||
(x'010203', 'text/plain', 12345)",
|
||||
)
|
||||
.expect("Failed to insert data");
|
||||
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
assert_eq!(
|
||||
get_schema_version(&db.conn)
|
||||
.expect("Failed to get version after migration"),
|
||||
3
|
||||
);
|
||||
|
||||
assert!(table_column_exists(&db.conn, "clipboard", "last_accessed"));
|
||||
assert!(index_exists(&db.conn, "idx_last_accessed"));
|
||||
|
||||
let count: i64 = db
|
||||
.conn
|
||||
.query_row("SELECT COUNT(*) FROM clipboard", [], |row| row.get(0))
|
||||
.expect("Failed to count");
|
||||
assert_eq!(count, 1, "Existing data should be preserved");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_idempotent_migration() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_idempotent.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"CREATE TABLE IF NOT EXISTS clipboard (id INTEGER PRIMARY KEY \
|
||||
AUTOINCREMENT, contents BLOB NOT NULL, mime TEXT);",
|
||||
)
|
||||
.expect("Failed to create table");
|
||||
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
let version_after_first =
|
||||
get_schema_version(&db.conn).expect("Failed to get version");
|
||||
|
||||
let db2 =
|
||||
SqliteClipboardDb::new(db.conn).expect("Failed to create database again");
|
||||
let version_after_second =
|
||||
get_schema_version(&db2.conn).expect("Failed to get version");
|
||||
|
||||
assert_eq!(version_after_first, version_after_second);
|
||||
assert_eq!(version_after_first, 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_store_and_retrieve_with_new_columns() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_store.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
let test_data = b"Hello, World!";
|
||||
let cursor = std::io::Cursor::new(test_data.to_vec());
|
||||
|
||||
let id = db
|
||||
.store_entry(cursor, 100, 1000, None)
|
||||
.expect("Failed to store entry");
|
||||
|
||||
let content_hash: Option<i64> = db
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT content_hash FROM clipboard WHERE id = ?1",
|
||||
[id],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.expect("Failed to get content_hash");
|
||||
|
||||
let last_accessed: Option<i64> = db
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT last_accessed FROM clipboard WHERE id = ?1",
|
||||
[id],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.expect("Failed to get last_accessed");
|
||||
|
||||
assert!(content_hash.is_some(), "content_hash should be set");
|
||||
assert!(last_accessed.is_some(), "last_accessed should be set");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_last_accessed_updated_on_copy() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_copy.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
let test_data = b"Test content for copy";
|
||||
let cursor = std::io::Cursor::new(test_data.to_vec());
|
||||
let id_a = db
|
||||
.store_entry(cursor, 100, 1000, None)
|
||||
.expect("Failed to store entry A");
|
||||
|
||||
let original_last_accessed: i64 = db
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT last_accessed FROM clipboard WHERE id = ?1",
|
||||
[id_a],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.expect("Failed to get last_accessed");
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(1100));
|
||||
|
||||
let mut hasher = std::collections::hash_map::DefaultHasher::new();
|
||||
test_data.hash(&mut hasher);
|
||||
let content_hash = hasher.finish() as i64;
|
||||
|
||||
let now = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.expect("Time went backwards")
|
||||
.as_secs() as i64;
|
||||
|
||||
db.conn
|
||||
.execute(
|
||||
"INSERT INTO clipboard (contents, mime, content_hash, last_accessed) \
|
||||
VALUES (?1, ?2, ?3, ?4)",
|
||||
params![test_data as &[u8], "text/plain", content_hash, now],
|
||||
)
|
||||
.expect("Failed to insert entry B directly");
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(1100));
|
||||
|
||||
let (..) = db.copy_entry(id_a).expect("Failed to copy entry");
|
||||
|
||||
let new_last_accessed: i64 = db
|
||||
.conn
|
||||
.query_row(
|
||||
"SELECT last_accessed FROM clipboard WHERE id = ?1",
|
||||
[id_a],
|
||||
|row| row.get(0),
|
||||
)
|
||||
.expect("Failed to get updated last_accessed");
|
||||
|
||||
assert!(
|
||||
new_last_accessed > original_last_accessed,
|
||||
"last_accessed should be updated when copying an entry that is not the \
|
||||
most recent"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_migration_with_existing_columns_but_v0() {
|
||||
let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
|
||||
let db_path = temp_dir.path().join("test_v0_with_cols.db");
|
||||
let conn = Connection::open(&db_path).expect("Failed to open database");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"CREATE TABLE IF NOT EXISTS clipboard (id INTEGER PRIMARY KEY \
|
||||
AUTOINCREMENT, contents BLOB NOT NULL, mime TEXT, content_hash \
|
||||
INTEGER, last_accessed INTEGER);",
|
||||
)
|
||||
.expect("Failed to create table with all columns");
|
||||
|
||||
conn
|
||||
.pragma_update(None, "user_version", 0i64)
|
||||
.expect("Failed to set version to 0");
|
||||
|
||||
conn
|
||||
.execute_batch(
|
||||
"INSERT INTO clipboard (contents, mime, content_hash, last_accessed) \
|
||||
VALUES (x'010203', 'text/plain', 12345, 1704067200)",
|
||||
)
|
||||
.expect("Failed to insert data");
|
||||
|
||||
let db = SqliteClipboardDb::new(conn).expect("Failed to create database");
|
||||
|
||||
assert_eq!(
|
||||
get_schema_version(&db.conn).expect("Failed to get version"),
|
||||
3
|
||||
);
|
||||
|
||||
let count: i64 = db
|
||||
.conn
|
||||
.query_row("SELECT COUNT(*) FROM clipboard", [], |row| row.get(0))
|
||||
.expect("Failed to count");
|
||||
assert_eq!(count, 1, "Existing data should be preserved");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ use clap::{CommandFactory, Parser, Subcommand};
|
|||
use inquire::Confirm;
|
||||
|
||||
mod commands;
|
||||
mod db;
|
||||
pub(crate) mod db;
|
||||
mod multicall;
|
||||
#[cfg(feature = "use-toplevel")] mod wayland;
|
||||
|
||||
|
|
|
|||
|
|
@ -33,11 +33,11 @@ pub fn init_wayland_state() {
|
|||
/// Get the currently focused window application name using Wayland protocols
|
||||
pub fn get_focused_window_app() -> Option<String> {
|
||||
// Try Wayland protocol first
|
||||
if let Ok(focused) = FOCUSED_APP.lock() {
|
||||
if let Some(ref app) = *focused {
|
||||
debug!("Found focused app via Wayland protocol: {app}");
|
||||
return Some(app.clone());
|
||||
}
|
||||
if let Ok(focused) = FOCUSED_APP.lock()
|
||||
&& let Some(ref app) = *focused
|
||||
{
|
||||
debug!("Found focused app via Wayland protocol: {app}");
|
||||
return Some(app.clone());
|
||||
}
|
||||
|
||||
debug!("No focused window detection method worked");
|
||||
|
|
@ -81,11 +81,10 @@ impl Dispatch<wl_registry::WlRegistry, ()> for AppState {
|
|||
interface,
|
||||
version: _,
|
||||
} = event
|
||||
&& interface == "zwlr_foreign_toplevel_manager_v1"
|
||||
{
|
||||
if interface == "zwlr_foreign_toplevel_manager_v1" {
|
||||
let _manager: ZwlrForeignToplevelManagerV1 =
|
||||
registry.bind(name, 1, qh, ());
|
||||
}
|
||||
let _manager: ZwlrForeignToplevelManagerV1 =
|
||||
registry.bind(name, 1, qh, ());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -155,11 +154,10 @@ impl Dispatch<ZwlrForeignToplevelHandleV1, ()> for AppState {
|
|||
// Update focused app to the `app_id` of this handle
|
||||
if let (Ok(apps), Ok(mut focused)) =
|
||||
(TOPLEVEL_APPS.lock(), FOCUSED_APP.lock())
|
||||
&& let Some(app_id) = apps.get(&handle_id)
|
||||
{
|
||||
if let Some(app_id) = apps.get(&handle_id) {
|
||||
debug!("Setting focused app to: {app_id}");
|
||||
*focused = Some(app_id.clone());
|
||||
}
|
||||
debug!("Setting focused app to: {app_id}");
|
||||
*focused = Some(app_id.clone());
|
||||
}
|
||||
}
|
||||
},
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue