use crate::core::index::directory_reader::DirectoryReader;
use crate::core::index::index_reader::{
IndexReader, IndexReaderContextKind, IndexReaderContextType,
};
use crate::core::search::index_searcher::IndexSearcher;
use crate::core::search::similarities_impl::similarities::Similarity;
use crate::core::util::close::{Closeable, CloseableRef};
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::io_utils::IOUtils;
use parking_lot::{ReentrantMutex, RwLock};
use std::cmp::Reverse;
use std::collections::HashMap;
use std::collections::hash_map::Entry;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Instant;
type SearcherMap<DR, SIM> = HashMap<i64, Arc<SearcherTracker<DR, SIM>>>;
type ManagedSearcher<
DR,
SIM = crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
> = IndexSearcher<IndexReaderContextType<Arc<DR>>, SIM>;
struct SearcherTracker<
DR,
SIM = crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
> where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
searcher: Arc<ManagedSearcher<DR, SIM>>,
record_time: Instant,
version: i64,
}
impl<DR, SIM> SearcherTracker<DR, SIM>
where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
fn new(searcher: Arc<ManagedSearcher<DR, SIM>>) -> Result<Self> {
let version = searcher.get_index_reader().get_version()?;
searcher.get_index_reader().inc_ref()?;
let record_time = Instant::now();
Ok(Self {
searcher,
record_time,
version,
})
}
fn close(&self) -> Result<()> {
self.searcher.get_index_reader().dec_ref()
}
}
pub struct SearcherLifetimeManager<
DR,
SIM = crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
> where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
closed: AtomicBool,
searchers: RwLock<SearcherMap<DR, SIM>>,
operation_lock: ReentrantMutex<()>,
}
impl<DR, SIM> Default for SearcherLifetimeManager<DR, SIM>
where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
fn default() -> Self {
Self::new()
}
}
impl<DR, SIM> SearcherLifetimeManager<DR, SIM>
where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
pub fn new() -> Self {
Self {
closed: AtomicBool::new(false),
searchers: RwLock::new(HashMap::new()),
operation_lock: ReentrantMutex::new(()),
}
}
fn ensure_open(&self) -> Result<()> {
if self.closed.load(Ordering::SeqCst) {
return Err(LuceneError::already_closed(
"this SearcherLifetimeManager instance is closed",
));
}
Ok(())
}
pub fn record(&self, searcher: &Arc<ManagedSearcher<DR, SIM>>) -> Result<i64> {
self.ensure_open()?;
let version = searcher.get_index_reader().get_version()?;
if let Some(tracker) = self.searchers.read().get(&version) {
if !Arc::ptr_eq(&tracker.searcher, searcher) {
return Err(LuceneError::illegal_argument(format!(
"the provided searcher has the same underlying reader version yet the searcher instance differs from before (new={:p} vs old={:p})",
Arc::as_ptr(searcher),
Arc::as_ptr(&tracker.searcher)
)));
}
} else {
let tracker = SearcherTracker::new(searcher.clone())?;
let losing_tracker = {
let mut searchers = self.searchers.write();
match searchers.entry(version) {
Entry::Occupied(entry) => Some((tracker, Arc::clone(entry.get()))),
Entry::Vacant(entry) => {
entry.insert(Arc::new(tracker));
None
},
}
};
if let Some((tracker, _existing)) = losing_tracker {
tracker.close()?;
}
}
Ok(version)
}
pub fn acquire(&self, version: i64) -> Result<Option<Arc<ManagedSearcher<DR, SIM>>>> {
self.ensure_open()?;
let searcher = self
.searchers
.read()
.get(&version)
.map(|tracker| Arc::clone(&tracker.searcher));
if let Some(searcher) = searcher
&& searcher.get_index_reader().try_inc_ref()
{
return Ok(Some(searcher));
}
Ok(None)
}
pub fn release(&self, searcher: Arc<ManagedSearcher<DR, SIM>>) -> Result<()> {
searcher.get_index_reader().dec_ref()
}
pub fn prune<P>(&self, pruner: &P) -> Result<()>
where
P: Pruner<DR>,
{
let _operation_lock = self.operation_lock.lock();
let mut trackers: Vec<_> = self.searchers.read().values().cloned().collect();
trackers.sort_unstable_by_key(|tracker| Reverse(tracker.record_time));
let mut last_record_time = None;
let now = Instant::now();
for tracker in trackers {
let age_sec = last_record_time
.map(|record_time| now.duration_since(record_time).as_secs_f64())
.unwrap_or(0.0);
if pruner.do_prune(age_sec, tracker.searcher.as_ref()) {
self.searchers.write().remove(&tracker.version);
tracker.close()?;
}
last_record_time = Some(tracker.record_time);
}
Ok(())
}
pub fn close(&self) -> Result<()> {
let _operation_lock = self.operation_lock.lock();
self.closed.store(true, Ordering::SeqCst);
let to_close = std::mem::take(&mut *self.searchers.write());
IOUtils::close_with(to_close.values(), |tracker| tracker.close())?;
if !self.searchers.read().is_empty() {
return Err(LuceneError::illegal_state(
"another thread called record while this SearcherLifetimeManager instance was being closed; not all searchers were closed",
));
}
Ok(())
}
}
pub trait Pruner<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
fn do_prune<SIM>(&self, age_sec: f64, searcher: &ManagedSearcher<DR, SIM>) -> bool
where
SIM: Similarity;
}
pub struct PruneByAge {
max_age_sec: f64,
}
impl PruneByAge {
pub fn new(max_age_sec: f64) -> Result<Self> {
if max_age_sec < 0.0 {
return Err(LuceneError::illegal_argument(format!(
"maxAgeSec must be > 0 (got {max_age_sec})"
)));
}
Ok(Self { max_age_sec })
}
}
impl<DR> Pruner<DR> for PruneByAge
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
fn do_prune<SIM>(&self, age_sec: f64, _searcher: &ManagedSearcher<DR, SIM>) -> bool
where
SIM: Similarity,
{
age_sec > self.max_age_sec
}
}
impl<DR, SIM> Closeable for SearcherLifetimeManager<DR, SIM>
where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
fn close(&mut self) -> Result<()> {
SearcherLifetimeManager::close(self)
}
}
impl<DR, SIM> CloseableRef for SearcherLifetimeManager<DR, SIM>
where
SIM: Similarity,
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>>,
IndexReaderContextType<Arc<DR>>: 'static,
{
fn close(&self) -> Result<()> {
SearcherLifetimeManager::close(self)
}
}