509 lines
19 KiB
Rust
509 lines
19 KiB
Rust
|
//! The indexing service: one writer loop fed by per-root
|
||
|
|
//! walk/extract pipelines, plus the command thread that owns it.
|
||
|
|
|
||
|
|
use rusqlite::Connection;
|
||
|
|
use std::collections::HashMap;
|
||
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
||
|
|
use std::sync::{mpsc, Arc, Mutex};
|
||
|
|
use std::thread;
|
||
|
|
use std::time::{Duration, Instant};
|
||
|
|
|
||
|
|
use crate::config::Config;
|
||
|
|
use crate::db;
|
||
|
|
use crate::file_handling::normalize_root_string;
|
||
|
|
|
||
|
|
mod config_check;
|
||
|
|
mod pipeline;
|
||
|
|
mod progress;
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests;
|
||
|
|
|
||
|
|
pub use progress::{overall_progress, OverallProgress, ReconcileProgress, RootPhase, RootProgress};
|
||
|
|
|
||
|
|
/// What a run is doing before its first file is walked. Each step can run
|
||
|
|
/// for minutes on a large index.
|
||
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
|
|
pub enum PrepStep {
|
||
|
|
/// Waiting on the previous run's thread to wind down.
|
||
|
|
PreviousRun,
|
||
|
|
/// [`db::open_or_recreate`]: schema migration and WAL recovery.
|
||
|
|
OpeningIndex,
|
||
|
|
/// Re-testing stored rows against a configuration that changed since the
|
||
|
|
/// last run.
|
||
|
|
Reconciling(ReconcileProgress),
|
||
|
|
}
|
||
|
|
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub enum IndexingStatus {
|
||
|
|
Idle,
|
||
|
|
/// A run has been claimed but has not reached its walk yet. Holds the
|
||
|
|
/// database exactly as `Running` does, so every caller that defers to a
|
||
|
|
/// run must defer to this too.
|
||
|
|
Preparing {
|
||
|
|
start_time: Instant,
|
||
|
|
step: PrepStep,
|
||
|
|
},
|
||
|
|
Running {
|
||
|
|
start_time: Instant,
|
||
|
|
roots: Vec<RootProgress>,
|
||
|
|
},
|
||
|
|
Stopping,
|
||
|
|
/// Compacting and re-analysing the index after a run — see
|
||
|
|
/// [`IndexingService::run_maintenance`]. Holds the database: the
|
||
|
|
/// single-writer rule applies until this clears.
|
||
|
|
Optimizing,
|
||
|
|
Error(String),
|
||
|
|
}
|
||
|
|
|
||
|
|
/// One setting whose stored (index-build-time) value differs from the
|
||
|
|
/// current config. Values that hold lists (roots, patterns, extensions)
|
||
|
|
/// are newline-joined — display them as multi-line columns, not inline.
|
||
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
|
|
pub struct ConfigChange {
|
||
|
|
pub key: String,
|
||
|
|
/// What the index was built with.
|
||
|
|
pub stored: String,
|
||
|
|
/// What the config says now.
|
||
|
|
pub current: String,
|
||
|
|
}
|
||
|
|
|
||
|
|
#[allow(clippy::large_enum_variant)]
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub enum IndexingCommand {
|
||
|
|
Start {
|
||
|
|
/// Directory roots to index; each walks concurrently on its own
|
||
|
|
/// pool, and duplicates are dropped at run time.
|
||
|
|
paths: Vec<String>,
|
||
|
|
db_path: String,
|
||
|
|
config: Config,
|
||
|
|
},
|
||
|
|
Stop,
|
||
|
|
}
|
||
|
|
|
||
|
|
pub struct IndexingService {
|
||
|
|
status: Arc<Mutex<IndexingStatus>>,
|
||
|
|
command_tx: mpsc::Sender<IndexingCommand>,
|
||
|
|
db_connection: Arc<Mutex<Option<Arc<Mutex<Connection>>>>>,
|
||
|
|
suspend_flag: Arc<AtomicBool>,
|
||
|
|
/// The long single statement a run is inside, if any: the prologue's
|
||
|
|
/// reconcile scan or the epilogue's VACUUM — never both, so one slot
|
||
|
|
/// serves and [`IndexingService::cancel_db_work`] reaches either.
|
||
|
|
interrupt: Arc<db::InterruptSlot>,
|
||
|
|
_handle: thread::JoinHandle<()>,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Polling interval for `should_abort` while suspended.
|
||
|
|
const SUSPEND_POLL_MS: u64 = 100;
|
||
|
|
|
||
|
|
/// `indexing.root_workers` rekeyed from the spellings the user typed to the
|
||
|
|
/// canonical roots the indexer walks, so an override survives a `~`, a
|
||
|
|
/// trailing slash, a relative path or a symlinked root. Entries naming a
|
||
|
|
/// folder that is no longer indexed are dropped.
|
||
|
|
fn resolved_root_workers(config: &Config) -> HashMap<String, usize> {
|
||
|
|
config
|
||
|
|
.paths
|
||
|
|
.indexing_paths
|
||
|
|
.iter()
|
||
|
|
.zip(config.resolved_indexing_paths())
|
||
|
|
.filter_map(|(raw, resolved)| {
|
||
|
|
let workers = config.indexing.root_workers.get(raw).copied()?;
|
||
|
|
Some((normalize_root_string(&resolved.to_string_lossy()), workers))
|
||
|
|
})
|
||
|
|
.collect()
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Combined stop/suspend check used by worker loops; `true` iff the caller
|
||
|
|
/// should abort. While suspended (and not stopped) it parks the thread in
|
||
|
|
/// short sleeps until `resume()`.
|
||
|
|
pub(crate) fn should_abort(stop: &Arc<AtomicBool>, suspend: &Arc<AtomicBool>) -> bool {
|
||
|
|
loop {
|
||
|
|
if stop.load(Ordering::Relaxed) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if !suspend.load(Ordering::Relaxed) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
thread::sleep(Duration::from_millis(SUSPEND_POLL_MS));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl IndexingService {
|
||
|
|
pub fn new() -> Self {
|
||
|
|
let status = Arc::new(Mutex::new(IndexingStatus::Idle));
|
||
|
|
let (command_tx, command_rx) = mpsc::channel();
|
||
|
|
let db_connection = Arc::new(Mutex::new(None));
|
||
|
|
let suspend_flag = Arc::new(AtomicBool::new(false));
|
||
|
|
let interrupt: Arc<db::InterruptSlot> = Arc::new(db::InterruptSlot::default());
|
||
|
|
|
||
|
|
let status_clone = status.clone();
|
||
|
|
let db_connection_clone = db_connection.clone();
|
||
|
|
let suspend_clone = suspend_flag.clone();
|
||
|
|
let interrupt_clone = interrupt.clone();
|
||
|
|
let handle = thread::spawn(move || {
|
||
|
|
Self::indexing_thread(
|
||
|
|
status_clone,
|
||
|
|
command_rx,
|
||
|
|
db_connection_clone,
|
||
|
|
suspend_clone,
|
||
|
|
interrupt_clone,
|
||
|
|
);
|
||
|
|
});
|
||
|
|
|
||
|
|
IndexingService {
|
||
|
|
status,
|
||
|
|
command_tx,
|
||
|
|
db_connection,
|
||
|
|
suspend_flag,
|
||
|
|
interrupt,
|
||
|
|
_handle: handle,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Cut short the long statement a run is inside — an
|
||
|
|
/// [`IndexingStatus::Optimizing`] VACUUM, or the reconcile scan of its
|
||
|
|
/// prologue. No-op when there is none.
|
||
|
|
///
|
||
|
|
/// Stop does *not* reach the VACUUM; this is for the caller that cannot
|
||
|
|
/// wait it out — deleting the index for a rebuild, where a VACUUM still
|
||
|
|
/// holding the file would fail the delete on Windows. An interrupted
|
||
|
|
/// statement rolls back.
|
||
|
|
pub fn cancel_db_work(&self) {
|
||
|
|
db::interrupt(&self.interrupt)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Pause the indexer: worker loops calling [`should_abort`] block until
|
||
|
|
/// [`resume`](Self::resume). Does not stop the worker.
|
||
|
|
pub fn suspend(&self) {
|
||
|
|
self.suspend_flag.store(true, Ordering::Relaxed);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Resume indexing after [`suspend`](Self::suspend). No-op if not
|
||
|
|
/// suspended.
|
||
|
|
pub fn resume(&self) {
|
||
|
|
self.suspend_flag.store(false, Ordering::Relaxed);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn is_suspended(&self) -> bool {
|
||
|
|
self.suspend_flag.load(Ordering::Relaxed)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Start indexing one or more roots; all walk concurrently, funnelling
|
||
|
|
/// into one writer thread. Duplicate roots collapse to one walk, and a
|
||
|
|
/// file reachable from more than one is written once. Returns `Err` if a
|
||
|
|
/// run is already in flight. Nested roots are refused before this is
|
||
|
|
/// called (see [`crate::config::nested_roots`]).
|
||
|
|
///
|
||
|
|
/// The `Idle → Preparing` transition happens **here**, synchronously: the
|
||
|
|
/// command thread cannot flip the status until it has joined the previous
|
||
|
|
/// run's thread, and a caller polling for the flip could start writing to
|
||
|
|
/// a database this run is about to reopen.
|
||
|
|
pub fn start_indexing(
|
||
|
|
&self,
|
||
|
|
paths: Vec<String>,
|
||
|
|
db_path: String,
|
||
|
|
config: Config,
|
||
|
|
) -> Result<(), String> {
|
||
|
|
if paths.is_empty() {
|
||
|
|
return Err("start_indexing requires at least one path".into());
|
||
|
|
}
|
||
|
|
{
|
||
|
|
let mut status = crate::lock_ok(&self.status);
|
||
|
|
if matches!(
|
||
|
|
*status,
|
||
|
|
IndexingStatus::Preparing { .. }
|
||
|
|
| IndexingStatus::Running { .. }
|
||
|
|
| IndexingStatus::Stopping
|
||
|
|
) {
|
||
|
|
return Err("indexing is already running".into());
|
||
|
|
}
|
||
|
|
*status = IndexingStatus::Preparing {
|
||
|
|
start_time: Instant::now(),
|
||
|
|
step: PrepStep::PreviousRun,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
self.command_tx
|
||
|
|
.send(IndexingCommand::Start {
|
||
|
|
paths,
|
||
|
|
db_path,
|
||
|
|
config,
|
||
|
|
})
|
||
|
|
.map_err(|e| {
|
||
|
|
// The service is gone; don't leave the status stuck on a run
|
||
|
|
// that will never happen.
|
||
|
|
*crate::lock_ok(&self.status) = IndexingStatus::Idle;
|
||
|
|
format!("Failed to send start command: {}", e)
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Signal a running index pass to stop without waiting for it. Used
|
||
|
|
/// on shutdown paths that must stay responsive — the worker notices
|
||
|
|
/// the flag between batches and WAL makes an unflushed exit safe.
|
||
|
|
pub fn request_stop(&self) {
|
||
|
|
let _ = self.command_tx.send(IndexingCommand::Stop);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn stop_indexing(&self) -> Result<(), String> {
|
||
|
|
self.command_tx
|
||
|
|
.send(IndexingCommand::Stop)
|
||
|
|
.map_err(|e| format!("Failed to send stop command: {}", e))?;
|
||
|
|
|
||
|
|
let mut attempts = 0;
|
||
|
|
while attempts < 50 {
|
||
|
|
// Five seconds for the command thread to pick the Stop up; past
|
||
|
|
// that, checkpoint anyway rather than block a shutdown.
|
||
|
|
match self.get_status() {
|
||
|
|
IndexingStatus::Stopping => break,
|
||
|
|
IndexingStatus::Idle => return Ok(()), // Already stopped
|
||
|
|
IndexingStatus::Error(_) => return Ok(()), // Consider error state as stopped
|
||
|
|
_ => {
|
||
|
|
std::thread::sleep(std::time::Duration::from_millis(100));
|
||
|
|
attempts += 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Flush the WAL and release the shared connection. WAL mode itself
|
||
|
|
// stays on — it's the persistent journal mode for the index.
|
||
|
|
if let Some(db_conn_arc) = crate::lock_ok(&self.db_connection).take() {
|
||
|
|
let conn = crate::lock_ok(&db_conn_arc);
|
||
|
|
if let Err(e) = crate::db::repo::checkpoint_truncate(&conn) {
|
||
|
|
crate::log_warn!("{}", e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn get_status(&self) -> IndexingStatus {
|
||
|
|
crate::lock_ok(&self.status).clone()
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Move the prologue on to `step`, keeping the run's start time so one
|
||
|
|
/// elapsed clock spans the whole run.
|
||
|
|
///
|
||
|
|
/// A no-op once the status has left `Preparing`: a Stop that arrives
|
||
|
|
/// mid-prologue owns the status and must not be clobbered.
|
||
|
|
fn set_prep_step(status: &Arc<Mutex<IndexingStatus>>, step: PrepStep) {
|
||
|
|
let mut g = crate::lock_ok(status);
|
||
|
|
if let IndexingStatus::Preparing { start_time, .. } = *g {
|
||
|
|
*g = IndexingStatus::Preparing { start_time, step };
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The instant this run was claimed, so the prologue and the walk share
|
||
|
|
/// one clock. Falls back to now for callers that bypass
|
||
|
|
/// [`Self::start_indexing`] (tests and probes).
|
||
|
|
fn run_start(status: &Arc<Mutex<IndexingStatus>>) -> Instant {
|
||
|
|
match *crate::lock_ok(status) {
|
||
|
|
IndexingStatus::Preparing { start_time, .. }
|
||
|
|
| IndexingStatus::Running { start_time, .. } => start_time,
|
||
|
|
_ => Instant::now(),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Force graceful shutdown - used for signal handling
|
||
|
|
pub fn graceful_shutdown(&self) -> Result<(), String> {
|
||
|
|
self.stop_indexing()
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Check if configuration changes require index recreation. A pure
|
||
|
|
/// *read* check that never wipes; a missing or incompatible DB means
|
||
|
|
/// there is nothing to validate.
|
||
|
|
pub fn check_config_validation(
|
||
|
|
&self,
|
||
|
|
db_path: &str,
|
||
|
|
config: &Config,
|
||
|
|
roots: &[String],
|
||
|
|
) -> Result<Option<Vec<ConfigChange>>, String> {
|
||
|
|
match db::open_existing(db_path, false) {
|
||
|
|
Ok(conn) => Self::validate_config(&conn, config, roots),
|
||
|
|
Err(_) => Ok(None),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Stop indexing and delete the database file for a clean rebuild
|
||
|
|
pub fn delete_index_for_rebuild(&self, db_path: &str) -> Result<(), String> {
|
||
|
|
self.stop_indexing()
|
||
|
|
.map_err(|e| format!("Failed to stop indexing: {}", e))?;
|
||
|
|
// Cut short the optimize pass too: the file about to be deleted is
|
||
|
|
// the file it holds open.
|
||
|
|
self.cancel_db_work();
|
||
|
|
|
||
|
|
let mut attempts = 0;
|
||
|
|
while attempts < 50 {
|
||
|
|
// Five seconds; past that the delete is attempted anyway — on
|
||
|
|
// Windows it fails while a handle is still open.
|
||
|
|
match self.get_status() {
|
||
|
|
IndexingStatus::Idle => break,
|
||
|
|
// Optimizing holds the file, so it is waited on like a run.
|
||
|
|
IndexingStatus::Stopping
|
||
|
|
| IndexingStatus::Preparing { .. }
|
||
|
|
| IndexingStatus::Running { .. }
|
||
|
|
| IndexingStatus::Optimizing => {
|
||
|
|
std::thread::sleep(std::time::Duration::from_millis(100));
|
||
|
|
attempts += 1;
|
||
|
|
}
|
||
|
|
IndexingStatus::Error(_) => break, // Consider error state as stopped
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Before the removal, unconditionally: the half-deleted case is
|
||
|
|
// exactly where a stale reader handle does damage. See
|
||
|
|
// [`db::bump_index_epoch`].
|
||
|
|
db::bump_index_epoch();
|
||
|
|
|
||
|
|
if std::path::Path::new(db_path).exists() {
|
||
|
|
std::fs::remove_file(db_path)
|
||
|
|
.map_err(|e| format!("Failed to delete database file: {}", e))?;
|
||
|
|
}
|
||
|
|
for suffix in ["-wal", "-shm", "-journal"] {
|
||
|
|
let _ = std::fs::remove_file(format!("{}{}", db_path, suffix));
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn indexing_thread(
|
||
|
|
status: Arc<Mutex<IndexingStatus>>,
|
||
|
|
command_rx: mpsc::Receiver<IndexingCommand>,
|
||
|
|
db_connection: Arc<Mutex<Option<Arc<Mutex<Connection>>>>>,
|
||
|
|
suspend_flag: Arc<AtomicBool>,
|
||
|
|
interrupt: Arc<db::InterruptSlot>,
|
||
|
|
) {
|
||
|
|
let stop_flag = Arc::new(AtomicBool::new(false));
|
||
|
|
let mut indexing_handle: Option<thread::JoinHandle<()>> = None;
|
||
|
|
|
||
|
|
while let Ok(command) = command_rx.recv() {
|
||
|
|
match command {
|
||
|
|
IndexingCommand::Start {
|
||
|
|
paths,
|
||
|
|
db_path,
|
||
|
|
config,
|
||
|
|
} => {
|
||
|
|
// `start_indexing` already claimed the status; nothing to
|
||
|
|
// re-check. Joining the previous run can block for as long
|
||
|
|
// as it takes to wind down.
|
||
|
|
if let Some(handle) = indexing_handle.take() {
|
||
|
|
let _ = handle.join();
|
||
|
|
}
|
||
|
|
|
||
|
|
stop_flag.store(false, Ordering::Relaxed);
|
||
|
|
|
||
|
|
let status_clone = status.clone();
|
||
|
|
let stop_flag_clone = stop_flag.clone();
|
||
|
|
let paths_owned = paths.clone();
|
||
|
|
let db_path_owned = db_path.clone();
|
||
|
|
let config_owned = config.clone();
|
||
|
|
|
||
|
|
let db_connection_clone = db_connection.clone();
|
||
|
|
let suspend_clone = suspend_flag.clone();
|
||
|
|
let interrupt_clone = interrupt.clone();
|
||
|
|
indexing_handle = Some(thread::spawn(move || {
|
||
|
|
// The writer thread: every DB write and every text
|
||
|
|
// extraction a run performs happens here.
|
||
|
|
crate::platform::set_background_priority();
|
||
|
|
let result = Self::run_indexing(
|
||
|
|
&status_clone,
|
||
|
|
&paths_owned,
|
||
|
|
&db_path_owned,
|
||
|
|
&stop_flag_clone,
|
||
|
|
&suspend_clone,
|
||
|
|
&config_owned,
|
||
|
|
&db_connection_clone,
|
||
|
|
&interrupt_clone,
|
||
|
|
);
|
||
|
|
|
||
|
|
// Released before maintenance: VACUUM needs its own
|
||
|
|
// connection (see `db::open::open_maintenance`).
|
||
|
|
*crate::lock_ok(&db_connection_clone) = None;
|
||
|
|
|
||
|
|
match result {
|
||
|
|
Err(e) => *crate::lock_ok(&status_clone) = IndexingStatus::Error(e),
|
||
|
|
// Stopped runs included: a run cut short still
|
||
|
|
// leaves a log to land and, if it got as far as
|
||
|
|
// deleting rows, slack to reclaim.
|
||
|
|
Ok(()) => {
|
||
|
|
*crate::lock_ok(&status_clone) = IndexingStatus::Optimizing;
|
||
|
|
Self::run_maintenance(&db_path_owned, &interrupt_clone);
|
||
|
|
*crate::lock_ok(&status_clone) = IndexingStatus::Idle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Under glibc a run's freed working set (hundreds of
|
||
|
|
// MB at peak) never returns to the OS on its own.
|
||
|
|
// After the match: a failed or stopped run leaves as
|
||
|
|
// much behind as a successful one.
|
||
|
|
crate::platform::release_free_heap();
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
IndexingCommand::Stop => {
|
||
|
|
// Only a run is stoppable; Optimizing happens after a run
|
||
|
|
// stops.
|
||
|
|
let mut guard = crate::lock_ok(&status);
|
||
|
|
if matches!(
|
||
|
|
*guard,
|
||
|
|
IndexingStatus::Preparing { .. } | IndexingStatus::Running { .. }
|
||
|
|
) {
|
||
|
|
*guard = IndexingStatus::Stopping;
|
||
|
|
stop_flag.store(true, Ordering::Relaxed);
|
||
|
|
// The flag alone only stops the *next* statement; the
|
||
|
|
// prologue's reconcile can be inside one for minutes.
|
||
|
|
// A no-op for a walk.
|
||
|
|
db::interrupt(&interrupt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Channel closed: join any run still in flight before its thread
|
||
|
|
// outlives us.
|
||
|
|
if let Some(handle) = indexing_handle {
|
||
|
|
let _ = handle.join();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Optimize the index once a run ends, completed or stopped: land the log,
|
||
|
|
/// reclaim the file's slack, refresh the planner's statistics. Best-effort
|
||
|
|
/// — every outcome is a log line.
|
||
|
|
///
|
||
|
|
/// Runs on its own connection: VACUUM on the indexer's connection would
|
||
|
|
/// build the replacement index in RAM (see
|
||
|
|
/// [`crate::db::schema::PRAGMAS_MAINTENANCE`]). Not cancelled by the stop
|
||
|
|
/// flag — `interrupt` is the one way out (see [`Self::cancel_db_work`]).
|
||
|
|
fn run_maintenance(db_path: &str, interrupt: &db::InterruptSlot) {
|
||
|
|
let conn = match crate::db::open::open_maintenance(db_path) {
|
||
|
|
Ok(conn) => conn,
|
||
|
|
Err(e) => {
|
||
|
|
crate::log_warn!("optimize: {}", e);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
let armed = db::InterruptGuard::arm(interrupt, &conn);
|
||
|
|
|
||
|
|
let dir = std::path::Path::new(db_path)
|
||
|
|
.parent()
|
||
|
|
.map(|p| p.to_string_lossy().into_owned())
|
||
|
|
.unwrap_or_default();
|
||
|
|
let outcome = crate::db::repo::maintain(&conn, &dir);
|
||
|
|
|
||
|
|
drop(armed);
|
||
|
|
match outcome {
|
||
|
|
Ok(true) => crate::log_info!("optimized the index and reclaimed unused space"),
|
||
|
|
Ok(false) => {}
|
||
|
|
Err(e) => crate::log_warn!("optimize failed (non-fatal): {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Drop for IndexingService {
|
||
|
|
fn drop(&mut self) {
|
||
|
|
let _ = self.stop_indexing();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Default for IndexingService {
|
||
|
|
fn default() -> Self {
|
||
|
|
Self::new()
|
||
|
|
}
|
||
|
|
}
|