use crate::core::index::doc_values_update::DocValuesUpdate;
use crate::core::index::documents_writer_delete_queue::{DocumentsWriterDeleteQueue, Node};
use crate::core::index::documents_writer_flush_control::DocumentsWriterFlushControl;
use crate::core::index::documents_writer_flush_queue::{DocumentsWriterFlushQueue, FlushTicket};
use crate::core::index::documents_writer_per_thread_pool::DwptWrapper;
use crate::core::index::index_writer::{IndexWriter, IndexingDocument, IntoFallibleIterator};
use crate::core::index::live_index_writer_config::LiveIndexWriterConfig;
use crate::core::index::lockable_concurrent_approximate_priority_queue::Lock;
use crate::core::index::segment_info::SegmentInfo;
use crate::core::index::term::Term;
use crate::core::search::query::Query;
use crate::core::search::similarities_impl::similarities::Similarity;
use crate::core::store::directory::Directory;
use crate::core::util::accountable::Accountable;
use crate::core::util::close::{Closeable, CloseableRef};
use crate::core::util::error::lucene_error::Result;
use crate::core::util::error::lucene_error::{CaughtResult, LuceneError};
use crate::core::util::info_stream::{InfoStream, InfoStreamMT};
use crate::core::util::io_utils::IOUtils;
use parking_lot::{Mutex, MutexGuard};
use std::collections::HashSet;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicI32, AtomicI64, Ordering};
use std::thread;
pub(crate) struct DocumentsWriter<D, FN>
where
D: Directory,
{
closed: AtomicBool,
info_stream: InfoStreamMT,
num_docs_in_ram: AtomicI32,
ticket_queue: DocumentsWriterFlushQueue<D>,
pending_changes_in_current_full_flush: AtomicBool,
pending_num_docs: Arc<AtomicI64>,
pub(crate) guard: Mutex<()>,
pub(crate) inner: Mutex<Inner>,
pub(crate) flush_control: DocumentsWriterFlushControl<D>,
flush_notifications: FN,
}
pub(crate) struct Inner {
current_full_flush_del_queue: Option<Arc<DocumentsWriterDeleteQueue>>,
}
impl<D, FN> DocumentsWriter<D, FN>
where
D: Directory,
FN: FlushNotifications,
{
#[allow(clippy::too_many_arguments)]
pub(crate) fn new<L>(
flush_notifications: FN,
pending_num_docs: Arc<AtomicI64>,
config: &L,
) -> Result<Self>
where
L: LiveIndexWriterConfig,
{
let info_stream = config.get_info_stream();
let delete_queue = Arc::new(DocumentsWriterDeleteQueue::new(info_stream.clone()));
Ok(DocumentsWriter {
closed: AtomicBool::new(false),
info_stream,
num_docs_in_ram: AtomicI32::new(0),
ticket_queue: DocumentsWriterFlushQueue::new(),
pending_changes_in_current_full_flush: AtomicBool::new(false),
pending_num_docs,
guard: Mutex::new(()),
inner: Mutex::new(Inner {
current_full_flush_del_queue: None,
}),
flush_control: DocumentsWriterFlushControl::new(config, delete_queue)?,
flush_notifications,
})
}
pub(crate) fn delete_queries<L>(&self, config: &L, queries: Vec<Query>) -> Result<i64>
where
L: LiveIndexWriterConfig,
{
self.apply_delete_or_update(config, |upd| upd.add_delete_query(queries))
}
pub(crate) fn delete_terms<L>(&self, config: &L, terms: Vec<Term>) -> Result<i64>
where
L: LiveIndexWriterConfig,
{
self.apply_delete_or_update(config, |upd| upd.add_delete_term(terms))
}
pub(crate) fn update_doc_values<L>(
&self,
config: &L,
updates: Vec<DocValuesUpdate>,
) -> Result<i64>
where
L: LiveIndexWriterConfig,
{
self.apply_delete_or_update(config, |upd| upd.add_doc_values_updates(updates))
}
fn apply_delete_or_update<F, L>(&self, config: &L, func: F) -> Result<i64>
where
F: FnOnce(&DocumentsWriterDeleteQueue) -> Result<i64>,
L: LiveIndexWriterConfig,
{
let _guard = &self.guard.lock();
let mut seq_no = {
let seq_no = {
let delete_queue = &self.flush_control.delete_queue.lock();
func(delete_queue)?
};
self.flush_control.do_on_delete(config)?;
seq_no
};
if self.apply_all_deletes()? {
seq_no = -seq_no;
}
Ok(seq_no)
}
fn apply_all_deletes(&self) -> Result<bool> {
let delete_queue = self.flush_control.delete_queue.lock().clone();
let should_apply_all_deletes = self.flush_control.get_apply_all_deletes()
&& !self.flush_control.is_full_flush()
&& delete_queue.is_open()
&& self.flush_control.get_and_reset_apply_all_deletes();
if !should_apply_all_deletes {
return Ok(false);
}
let Some(_) = self
.ticket_queue
.add_ticket(|| Self::maybe_freeze_global_buffer(&delete_queue))?
else {
return Ok(false);
};
self.flush_notifications.on_deletes_applied()?; Ok(true)
}
fn maybe_freeze_global_buffer(
delete_queue: &DocumentsWriterDeleteQueue,
) -> Result<Option<FlushTicket<D>>> {
match delete_queue.maybe_freeze_global_buffer()? {
Some(frozen_updates) => Ok(Some(FlushTicket::new(Some(frozen_updates), false))),
None => Ok(None),
}
}
pub(crate) fn purge_flush_tickets<F>(&self, forced: bool, consumer: F) -> Result<()>
where
F: Fn(FlushTicket<D>) -> Result<()>,
{
if forced {
self.ticket_queue.force_purge(consumer)
} else {
self.ticket_queue.try_purge(consumer)
}
}
pub(crate) fn get_num_docs(&self) -> i32 {
self.num_docs_in_ram.load(Ordering::SeqCst)
}
fn ensure_open(&self) -> Result<()> {
if self.closed.load(Ordering::SeqCst) {
Err(LuceneError::already_closed(
"this DocumentsWriter is closed",
))
} else {
Ok(())
}
}
pub(crate) fn flush_one_dwpt(&self, writer: &IndexWriter<D>) -> Result<bool> {
{
if self.info_stream.is_enabled("DW") {
self.info_stream.message("DW", "startFlushOneDWPT")?;
}
}
if !self.maybe_flush(writer)? {
if let Some(dwpt) = self
.flush_control
.checkout_largest_non_pending_writer(&writer.config)?
{
self.do_flush(dwpt, writer)?;
return Ok(true);
}
return Ok(false);
}
Ok(true)
}
pub(crate) fn lock_and_abort_all<L>(&self, config: &L) -> Result<LockAndAbortAllGuard<'_, D, FN>>
where
L: LiveIndexWriterConfig,
{
let _guard = self.guard.lock();
if self.info_stream.is_enabled("DW") {
self.info_stream.message("DW", "lockAndAbortAll")?;
}
self.ticket_queue.force_purge(|ticket| {
if let Some(flushed_segment) = ticket.get_flushed_segment() {
self.pending_num_docs.fetch_add(
-(flushed_segment.segment_info.info.max_doc()? as i64),
Ordering::SeqCst,
);
}
Ok(())
})?;
let mut finalizer = LockAndAbortAllGuard::new(self);
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
self.flush_control.delete_queue.lock().clear();
self.flush_control.per_thread_pool.lock_new_writers();
finalizer.writers = self
.flush_control
.per_thread_pool
.filter_and_lock(|_| true)?;
for per_thread in &finalizer.writers {
debug_assert!(per_thread.state.is_held_by_current_thread());
self.abort_documents_writer_per_thread(per_thread, config)?;
}
self.flush_control.delete_queue.lock().clear();
self
.flush_control
.delete_queue
.lock()
.skip_sequence_numbers(self.flush_control.per_thread_pool.size() as i64 + 1);
self
.flush_control
.abort_pending_flushes(None, config, self)?;
self.flush_control.wait_for_flush();
if self.info_stream.is_enabled("DW") {
self
.info_stream
.message("DW", "finished lockAndAbortAll success=true")?;
}
Ok(())
}));
match result {
Ok(Ok(())) => Ok(finalizer),
result => {
if self.info_stream.is_enabled("DW") {
self
.info_stream
.message("DW", "finished lockAndAbortAll success=false")?;
}
let close_result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| finalizer.close()));
IOUtils::use_or_suppress_caught_result(result, close_result)?;
Err(LuceneError::illegal_state(
"lockAndAbortAll unexpectedly succeeded after an error",
))
},
}
}
fn abort_documents_writer_per_thread<L>(
&self,
per_thread: &Arc<DwptWrapper<D>>,
config: &L,
) -> Result<()>
where
L: LiveIndexWriterConfig,
{
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
let num = per_thread.state.get_num_docs_in_ram();
self.subtract_flushed_num_docs(num);
per_thread.dwpt.lock().abort()?;
Ok(())
}));
self.flush_control.do_on_abort(per_thread, config)?;
unwrap_caught_result!(result)
}
pub(crate) fn get_max_completed_sequence_number(&self) -> i64 {
self
.flush_control
.delete_queue
.lock()
.get_max_completed_seq_no()
}
pub(crate) fn any_changes(&self) -> Result<bool> {
let num_docs = self.num_docs_in_ram.load(Ordering::SeqCst);
let deletions = self.any_deletions();
let tickets = self.ticket_queue.has_tickets();
let pending_full = self
.pending_changes_in_current_full_flush
.load(Ordering::SeqCst);
let any = num_docs != 0 || deletions || tickets || pending_full;
if self.info_stream.is_enabled("DW") && any {
self.info_stream.message(
"DW",
&format!(
"anyChanges? numDocsInRam={num_docs} deletes={deletions} hasTickets={tickets} pendingChangesInFullFlush={pending_full}"
),
)?;
}
Ok(any)
}
#[cfg(test)]
pub(crate) fn get_buffered_delete_terms_size(&self) -> Result<i32> {
self
.flush_control
.delete_queue
.lock()
.get_buffered_updates_terms_size()
}
pub(crate) fn any_deletions(&self) -> bool {
self.flush_control.delete_queue.lock().any_changes(None)
}
pub(crate) fn abort<L>(&self, config: &L) -> Result<()>
where
L: LiveIndexWriterConfig,
{
let _guard = self.guard.lock();
let mut success = false;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
self.flush_control.delete_queue.lock().clear();
if self.info_stream.is_enabled("DW") {
self.info_stream.message("DW", "abort")?;
}
for per_thread in self
.flush_control
.per_thread_pool
.filter_and_lock(|_| true)?
{
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
self.abort_documents_writer_per_thread(&per_thread, config)
}));
per_thread.unlock()?;
unwrap_caught_result!(result)?;
}
self
.flush_control
.abort_pending_flushes(None, config, self)?;
self.flush_control.wait_for_flush();
debug_assert_eq!(
0,
self.flush_control.per_thread_pool.size(),
"There are still active DWPT in the pool: {}",
self.flush_control.per_thread_pool.size()
);
success = true;
Ok(())
}));
if success {
debug_assert_eq!(
0,
self.flush_control.get_flushing_bytes(None),
"flushingBytes has unexpected value 0 != {}",
self.flush_control.get_flushing_bytes(None)
);
debug_assert_eq!(
0,
self.flush_control.net_bytes(None),
"netBytes has unexpected value 0 != {}",
self.flush_control.net_bytes(None)
);
}
if self.info_stream.is_enabled("DW") {
self
.info_stream
.message("DW", &format!("done abort success={success}"))?;
}
unwrap_caught_result!(result)
}
fn pre_update(&self, writer: &IndexWriter<D>) -> Result<bool> {
self.ensure_open()?;
let mut has_events = false;
while self.flush_control.any_stalled_threads()
|| (writer.config.get_check_pending_flush_on_update()
&& self.flush_control.num_queued_flushes() > 0)
{
has_events |= self.maybe_flush(writer)?;
self.flush_control.wait_if_stalled();
}
Ok(has_events)
}
fn post_update(
&self,
flushing_dwpt: Option<Arc<DwptWrapper<D>>>,
mut has_events: bool,
writer: &IndexWriter<D>,
) -> Result<bool> {
has_events |= self.apply_all_deletes()?;
if let Some(dwpt) = flushing_dwpt {
self.do_flush(dwpt, writer)?;
has_events = true;
} else if writer.config.get_check_pending_flush_on_update() {
has_events |= self.maybe_flush(writer)?;
}
Ok(has_events)
}
pub(crate) fn update_documents<DI, S>(
&self,
docs: DI,
del_node: Option<Arc<Node>>,
writer: &IndexWriter<D>,
similarity: &S,
) -> Result<i64>
where
S: Similarity,
DI: IntoFallibleIterator<Item: IndexingDocument>,
{
let has_events = self.pre_update(writer)?;
let dwpt_wrapper = self.flush_control.obtain_and_lock(writer)?;
let mut flushing_dwpt_opt = None;
let mut seq_no = 0;
let config = &writer.config;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
self.ensure_open()?;
let mut dw = Some(dwpt_wrapper.dwpt.lock());
let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let dw = dw
.as_mut()
.ok_or_else(|| LuceneError::illegal_state("DWPT lock is missing"))?;
dw.update_documents(
docs,
del_node,
&self.flush_notifications,
&self.num_docs_in_ram,
writer,
similarity,
)
}));
let aborted = dwpt_wrapper.state.is_aborted();
if aborted || !matches!(&res, Ok(Ok(_))) {
dw.take();
}
if aborted {
self.flush_control.do_on_abort(&dwpt_wrapper, config)?;
}
seq_no = unwrap_caught_result!(res)?;
flushing_dwpt_opt = {
match dw.as_ref() {
Some(dw) => self.flush_control.do_after_document(dw, config)?,
None => self
.flush_control
.do_after_document(&dwpt_wrapper.dwpt.lock(), config)?,
}
};
Ok(())
}));
{
let inner = self.flush_control.inner.lock();
if dwpt_wrapper.state.is_flush_pending()
|| dwpt_wrapper.state.is_aborted()
|| dwpt_wrapper.state.delete_queue.is_advanced()
{
dwpt_wrapper.state.unlock()?;
} else {
self
.flush_control
.per_thread_pool
.mark_as_free_and_unlock(dwpt_wrapper)?;
}
drop(inner);
}
unwrap_caught_result!(result)?;
if self.post_update(flushing_dwpt_opt, has_events, writer)? {
seq_no = -seq_no;
}
Ok(seq_no)
}
fn maybe_flush(&self, writer: &IndexWriter<D>) -> Result<bool> {
let flushing_dwpt = self
.flush_control
.next_pending_flush(None, &writer.config)?;
if let Some(flushing_dwpt) = flushing_dwpt {
self.do_flush(flushing_dwpt, writer)?;
Ok(true)
} else {
Ok(false)
}
}
fn do_flush(
&self,
mut flushing_dwpt: Arc<DwptWrapper<D>>,
writer: &IndexWriter<D>,
) -> Result<()> {
loop {
debug_assert!(!flushing_dwpt.state.has_flushed());
let res = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
debug_assert!({
let current_full_flush_del_queue = &self.inner.lock().current_full_flush_del_queue;
match current_full_flush_del_queue.as_ref() {
Some(queue) => Arc::ptr_eq(&flushing_dwpt.state.delete_queue, queue),
None => true,
}
});
let mut has_ticket = None;
let mut success = false;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
debug_assert!(self.assert_ticket_queue_modification(&flushing_dwpt.state.delete_queue));
let ticket = {
let mut dwpt = flushing_dwpt.dwpt.lock();
self.ticket_queue.add_ticket(|| {
let frozen_buffered_updates = dwpt.prepare_flush()?;
Ok(Some(FlushTicket::new(frozen_buffered_updates, true)))
})?
};
let ticket = ticket.ok_or_else(|| LuceneError::illegal_state("ticket returned None"))?;
let ticket = has_ticket.insert(ticket);
let flushing_docs_in_ram = flushing_dwpt.state.get_num_docs_in_ram();
{
let mut dwpt = flushing_dwpt.dwpt.lock();
let mut dwpt_success = false;
let result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
let v = dwpt.flush(&self.flush_notifications, writer)?;
match v {
Some(new_segment) => {
self.ticket_queue.add_segment(ticket, new_segment)?;
dwpt_success = true;
Ok(())
},
None => Err(LuceneError::illegal_state("flush_segment returned None")),
}
}));
self.subtract_flushed_num_docs(flushing_docs_in_ram);
let files = dwpt.take_pending_files_to_delete();
if !files.is_empty() {
self.flush_notifications.delete_unused_files(files)?;
}
if !dwpt_success {
let dir = dwpt.segment_info.dir.clone();
self.flush_notifications.flush_failed(std::mem::replace(
&mut dwpt.segment_info,
SegmentInfo::dummy(dir, Arc::from("")),
))?
}
unwrap_caught_result!(result)
}?;
success = true;
Ok(())
}));
if !success && let Some(ticket_idx) = has_ticket {
self.ticket_queue.mark_ticket_failed(ticket_idx)?;
}
unwrap_caught_result!(result)?;
if self.ticket_queue.get_ticket_count() as usize
>= self.flush_control.per_thread_pool.size()
{
self.flush_notifications.on_ticket_backlog()?;
}
Ok(())
}));
let config = &writer.config;
self
.flush_control
.do_after_flush(None, flushing_dwpt, config)?;
unwrap_caught_result!(res)?;
let v = self.flush_control.next_pending_flush(None, config)?;
match v {
Some(next_dwpt) => {
flushing_dwpt = next_dwpt;
continue;
},
None => break,
}
}
self.flush_notifications.after_segments_flushed(writer)?;
Ok(())
}
pub(crate) fn get_next_sequence_number(&self) -> i64 {
self
.flush_control
.delete_queue
.lock()
.get_next_sequence_number()
}
pub(crate) fn reset_delete_queue(
&self,
_guard: &MutexGuard<'_, ()>,
max_num_pending_ops: i64,
) -> Result<i64> {
let mut delete_queue = self.flush_control.delete_queue.lock();
let new_queue = delete_queue.advance_queue(max_num_pending_ops)?;
debug_assert!(delete_queue.is_advanced());
debug_assert!(!new_queue.is_advanced());
debug_assert!(delete_queue.get_last_sequence_number() <= new_queue.get_last_sequence_number());
debug_assert!(
delete_queue.get_max_seq_no() <= new_queue.get_last_sequence_number(),
"max_seq_no: {} vs. {}",
delete_queue.get_max_seq_no(),
new_queue.get_last_sequence_number()
);
let old_max_seq_no = delete_queue.get_max_seq_no();
*delete_queue = Arc::new(new_queue);
Ok(old_max_seq_no)
}
pub(crate) fn subtract_flushed_num_docs(&self, num_flushed: i32) {
self
.num_docs_in_ram
.fetch_sub(num_flushed, Ordering::SeqCst);
debug_assert!(self.num_docs_in_ram.load(Ordering::SeqCst) >= 0);
}
fn set_flushing_delete_queue(
&self,
session: Option<Arc<DocumentsWriterDeleteQueue>>,
guard: Option<&mut MutexGuard<'_, ()>>,
) -> bool {
let _guard = match guard {
Some(v) => v,
None => &self.guard.lock(),
};
let mut inner = self.inner.lock();
debug_assert!(
inner
.current_full_flush_del_queue
.as_ref()
.is_none_or(|q| !q.is_open()),
"Can not replace a full flush queue if the queue is not closed"
);
inner.current_full_flush_del_queue = session;
true
}
fn assert_ticket_queue_modification(
&self,
delete_queue: &Arc<DocumentsWriterDeleteQueue>,
) -> bool {
let inner = self.inner.lock();
debug_assert!(
inner
.current_full_flush_del_queue
.as_ref()
.is_none_or(|q| Arc::ptr_eq(q, delete_queue)),
"only modifications from the current flushing queue are permitted while doing a full flush"
);
true
}
pub(crate) fn flush_all_threads<L>(&self, writer: &IndexWriter<D>, config: &L) -> Result<i64>
where
L: LiveIndexWriterConfig,
{
if self.info_stream.is_enabled("DW") {
self.info_stream.message("DW", "startFullFlush")?;
}
let (flushing_delete_queue, seq_no) = {
let mut guard = self.guard.lock();
let pending = self.any_changes()?;
self
.pending_changes_in_current_full_flush
.store(pending, Ordering::SeqCst);
let flushing_delete_queue = self.flush_control.delete_queue.lock().clone();
let sn = self
.flush_control
.mark_for_full_flush(self, &guard, config)?;
debug_assert!(
self.set_flushing_delete_queue(Some(Arc::clone(&flushing_delete_queue)), Some(&mut guard))
);
(flushing_delete_queue, sn)
};
debug_assert!({
let inner = self.inner.lock();
let current_full_flush_del_queue = &inner.current_full_flush_del_queue;
current_full_flush_del_queue
.as_ref()
.is_some_and(|current| !Arc::ptr_eq(&self.flush_control.delete_queue.lock(), current))
});
let mut anything_flushed = false;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
anything_flushed |= self.maybe_flush(writer)?;
self.flush_control.wait_for_flush();
if !anything_flushed && flushing_delete_queue.any_changes(None) {
{
if self.info_stream.is_enabled("DW") {
let v = thread::current();
let name = v.name().unwrap_or("<unnamed>");
self
.info_stream
.message("DW", &format!("{name}: flush naked frozen global deletes"))?;
}
}
debug_assert!(self.assert_ticket_queue_modification(&flushing_delete_queue));
self
.ticket_queue
.add_ticket(|| Self::maybe_freeze_global_buffer(&flushing_delete_queue))?;
}
debug_assert!(!flushing_delete_queue.any_changes(None));
Ok(())
}));
debug_assert!({
let inner = self.inner.lock();
match inner.current_full_flush_del_queue.as_ref() {
Some(queue) => Arc::ptr_eq(&flushing_delete_queue, queue),
None => false,
}
});
flushing_delete_queue.close()?;
unwrap_caught_result!(result)?;
Ok(if anything_flushed { -seq_no } else { seq_no })
}
pub(crate) fn finish_full_flush<L>(&self, success: bool, config: &L) -> Result<()>
where
L: LiveIndexWriterConfig,
{
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
if self.info_stream.is_enabled("DW") {
let current_thread = thread::current();
let thread_name = current_thread.name().unwrap_or("<unnamed>");
self.info_stream.message(
"DW",
&format!("{thread_name} finishFullFlush success={success}"),
)?;
}
debug_assert!(self.set_flushing_delete_queue(None, None));
if success {
self.flush_control.finish_full_flush(config)?;
} else {
self.flush_control.abort_full_flushes(self, config)?;
}
Ok(())
}));
self
.pending_changes_in_current_full_flush
.store(false, Ordering::SeqCst);
self.apply_all_deletes()?;
unwrap_caught_result!(result)
}
pub(crate) fn get_flushing_bytes(&self) -> i64 {
self.flush_control.get_flushing_bytes(None)
}
}
impl<D, FN> Accountable for DocumentsWriter<D, FN>
where
D: Directory,
{
fn ram_bytes_used(&self) -> Result<i64> {
Ok(self.flush_control.get_delete_bytes_used()? + self.flush_control.net_bytes(None))
}
}
impl<D, FN> CloseableRef for DocumentsWriter<D, FN>
where
D: Directory,
FN: FlushNotifications,
{
fn close(&self) -> Result<()> {
self.closed.store(true, Ordering::SeqCst);
IOUtils::close_with(0..2, |operation| match operation {
0 => {
self.flush_control.close();
Ok(())
},
_ => self.flush_control.per_thread_pool.close(),
})
}
}
pub(crate) struct LockAndAbortAllGuard<'a, D, FN>
where
D: Directory,
FN: FlushNotifications,
{
documents_writer: &'a DocumentsWriter<D, FN>,
writers: smallvec::SmallVec<[Arc<DwptWrapper<D>>; 4]>,
released: AtomicBool,
}
impl<'a, D, FN> LockAndAbortAllGuard<'a, D, FN>
where
D: Directory,
FN: FlushNotifications,
{
fn new(documents_writer: &'a DocumentsWriter<D, FN>) -> Self {
Self {
documents_writer,
writers: smallvec::SmallVec::new(),
released: AtomicBool::new(false),
}
}
}
impl<D, FN> Closeable for LockAndAbortAllGuard<'_, D, FN>
where
D: Directory,
FN: FlushNotifications,
{
fn close(&mut self) -> Result<()> {
if self
.released
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
.is_ok()
{
self
.documents_writer
.flush_control
.per_thread_pool
.unlock_new_writers();
for writer in &self.writers {
writer.unlock()?;
}
if self.documents_writer.info_stream.is_enabled("DW") {
self
.documents_writer
.info_stream
.message("DW", "unlockAllAbortedThread")?;
}
}
Ok(())
}
}
pub(crate) trait FlushNotifications {
fn delete_unused_files(&self, files: HashSet<String>) -> Result<()>;
fn flush_failed<D>(&self, info: SegmentInfo<D>) -> Result<()>;
fn after_segments_flushed<D>(&self, writer: &IndexWriter<D>) -> Result<()>
where
D: Directory;
fn on_tragic_event<D>(
&self,
event: &CaughtResult,
message: &str,
writer: &IndexWriter<D>,
) -> Result<()>
where
D: Directory;
fn on_deletes_applied(&self) -> Result<()>;
fn on_ticket_backlog(&self) -> Result<()>;
}