use crate::core::codecs::CodecUtil;
use crate::core::index::IndexFileNames;
use crate::core::store::directory::Directory;
use crate::core::store::{DataInput, DataOutput, IOContext, IndexOutput};
use crate::core::util::StringHelper;
use crate::core::util::close::{Closeable, CloseableRef};
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::io_utils::IOUtils;
use crate::core::util::packed::direct_monotonic_writer::DirectMonotonicWriter;
use std::sync::Arc;
pub struct FieldsIndexWriter<D>
where
D: Directory,
{
dir: D,
name: Arc<str>,
suffix: String,
extension: &'static str,
codec_name: &'static str,
id: [u8; StringHelper::ID_LENGTH],
block_shift: i32,
io_context: IOContext,
docs_out: D::IndexOutput,
file_pointers_out: D::IndexOutput,
docs_out_pending_delete: bool,
file_pointers_out_pending_delete: bool,
temp_outputs_closed: bool,
total_docs: i32,
total_chunks: i32,
previous_fp: usize,
}
pub(crate) mod fields_index_writer_const {
pub(crate) const VERSION_START: i32 = 0;
pub(crate) const VERSION_CURRENT: i32 = 0;
}
pub(crate) fn with_index_label<R>(
base: &str,
suffix: &str,
use_label: impl FnOnce(&str) -> R,
) -> R {
stack_or_heap_buffer!(bytes, u8, base.len() + suffix.len(), 64, 0);
let (prefix_bytes, suffix_bytes) = bytes.split_at_mut(base.len());
prefix_bytes.copy_from_slice(base.as_bytes());
suffix_bytes.copy_from_slice(suffix.as_bytes());
use_label(expect_invariant!(
std::str::from_utf8(bytes),
"codec label parts are UTF-8"
))
}
impl<D> FieldsIndexWriter<D>
where
D: Directory,
{
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
dir: D,
name: &Arc<str>,
suffix: &str,
extension: &'static str,
codec_name: &'static str,
id: [u8; StringHelper::ID_LENGTH],
block_shift: i32,
io_context: IOContext, ) -> Result<Self> {
let mut docs_out = with_index_label(codec_name, "-doc_ids", |label| {
dir.create_temp_output(name, label, &io_context)
})?;
let mut file_pointers_out = None;
let mut success = false;
let init_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
with_index_label(codec_name, "Docs", |label| {
CodecUtil::write_header(
&mut docs_out,
label,
fields_index_writer_const::VERSION_CURRENT,
)
})?;
file_pointers_out = Some(with_index_label(codec_name, "file_pointers", |label| {
dir.create_temp_output(name, label, &io_context)
})?);
let output = file_pointers_out
.as_mut()
.ok_or_else(|| LuceneError::illegal_state("file pointers output is missing"))?;
with_index_label(codec_name, "FilePointers", |label| {
CodecUtil::write_header(output, label, fields_index_writer_const::VERSION_CURRENT)
})?;
success = true;
Ok(())
}));
let cleanup_result = if success {
Ok(Ok(()))
} else {
let has_file_pointers_out = file_pointers_out.is_some();
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
Self::close_temp_outputs(
&dir,
&mut docs_out,
file_pointers_out.as_mut(),
false,
true,
has_file_pointers_out,
)
}))
};
IOUtils::finally_caught_result(init_result, cleanup_result)?;
let file_pointers_out = file_pointers_out
.ok_or_else(|| LuceneError::illegal_state("file_pointers_out must be initialized"))?;
Ok(FieldsIndexWriter {
dir,
name: Arc::clone(name),
suffix: suffix.to_string(),
extension,
codec_name,
id,
block_shift,
io_context,
docs_out,
file_pointers_out,
docs_out_pending_delete: true,
file_pointers_out_pending_delete: true,
temp_outputs_closed: false,
total_docs: 0,
total_chunks: 0,
previous_fp: 0,
})
}
pub(crate) fn write_index(&mut self, num_docs: i32, start_pointer: usize) -> Result<()> {
debug_assert!(start_pointer >= self.previous_fp);
debug_assert!(self.docs_out_pending_delete);
debug_assert!(self.file_pointers_out_pending_delete);
debug_assert!(!self.temp_outputs_closed);
self.docs_out.write_vint(num_docs)?;
self
.file_pointers_out
.write_vlong((start_pointer - self.previous_fp) as i64)?;
self.previous_fp = start_pointer;
self.total_docs += num_docs;
self.total_chunks += 1;
Ok(())
}
pub(crate) fn finish(
&mut self,
num_docs: i32,
max_pointer: usize,
meta_out: &mut D::IndexOutput,
) -> Result<()> {
if num_docs != self.total_docs {
return Err(LuceneError::illegal_state(format!(
"Expected {} docs, but got {}",
num_docs, self.total_docs
)));
}
CodecUtil::write_footer(&mut self.docs_out)?;
CodecUtil::write_footer(&mut self.file_pointers_out)?;
let docs_out_file_name = self.docs_out.get_name().to_string();
let file_pointers_out_file_name = self.file_pointers_out.get_name().to_string();
let close_result = IOUtils::close([&mut self.docs_out, &mut self.file_pointers_out]);
if close_result.is_ok() {
self.temp_outputs_closed = true;
}
close_result?;
let mut data_out =
IndexFileNames::with_segment_file_name(&self.name, &self.suffix, self.extension, |name| {
self.dir.create_output(name, &self.io_context)
})?;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
with_index_label(self.codec_name, "Idx", |label| {
CodecUtil::write_index_header(
&mut data_out,
label,
fields_index_writer_const::VERSION_CURRENT,
&self.id,
&self.suffix,
)
})?;
meta_out.write_int(num_docs)?;
meta_out.write_int(self.block_shift)?;
meta_out.write_int(self.total_chunks + 1)?;
meta_out.write_long(data_out.get_file_pointer()? as i64)?;
{
let mut docs_in = self.dir.open_checksum_input(&docs_out_file_name)?;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
with_index_label(self.codec_name, "Docs", |label| {
CodecUtil::check_header(
&mut docs_in,
label,
fields_index_writer_const::VERSION_CURRENT,
fields_index_writer_const::VERSION_CURRENT,
)
})?;
let body_result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
let mut docs = DirectMonotonicWriter::get_instance(
meta_out,
&mut data_out,
(self.total_chunks + 1) as i64,
self.block_shift,
)?;
let mut doc = 0;
docs.add(doc)?;
for _ in 0..self.total_chunks {
doc += docs_in.read_vint()? as i64;
docs.add(doc)?;
}
docs.finish()?;
if doc != self.total_docs as i64 {
return Err(LuceneError::corrupt_index("Docs don't add up".to_string()));
}
Ok(())
}));
let prior_result = match body_result {
Ok(Ok(())) => None,
body_result => Some(body_result),
};
CodecUtil::check_footer_with_error(&mut docs_in, prior_result)
}));
let close_result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| docs_in.close()));
IOUtils::use_or_suppress_caught_result(result, close_result)?;
}
self.dir.delete_file(&docs_out_file_name)?;
self.docs_out_pending_delete = false;
meta_out.write_long(data_out.get_file_pointer()? as i64)?;
{
let mut file_pointers_in = self.dir.open_checksum_input(&file_pointers_out_file_name)?;
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
with_index_label(self.codec_name, "FilePointers", |label| {
CodecUtil::check_header(
&mut file_pointers_in,
label,
fields_index_writer_const::VERSION_CURRENT,
fields_index_writer_const::VERSION_CURRENT,
)
})?;
let body_result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
let mut file_pointers = DirectMonotonicWriter::get_instance(
meta_out,
&mut data_out,
(self.total_chunks + 1) as i64,
self.block_shift,
)?;
let mut fp = 0;
for _ in 0..self.total_chunks {
fp += file_pointers_in.read_vlong()?;
file_pointers.add(fp)?;
}
if max_pointer < fp as usize {
return Err(LuceneError::corrupt_index(
"File pointers don't add up".to_string(),
));
}
file_pointers.add(max_pointer as i64)?;
file_pointers.finish()?;
Ok(())
}));
let prior_result = match body_result {
Ok(Ok(())) => None,
body_result => Some(body_result),
};
CodecUtil::check_footer_with_error(&mut file_pointers_in, prior_result)
}));
let close_result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| file_pointers_in.close()));
IOUtils::use_or_suppress_caught_result(result, close_result)?;
}
self.dir.delete_file(&file_pointers_out_file_name)?;
self.file_pointers_out_pending_delete = false;
meta_out.write_long(data_out.get_file_pointer()? as i64)?;
meta_out.write_long(max_pointer as i64)?;
CodecUtil::write_footer(&mut data_out)
}));
let close_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| data_out.close()));
IOUtils::use_or_suppress_caught_result(result, close_result)
}
fn close_temp_outputs(
dir: &D,
docs_out: &mut D::IndexOutput,
mut file_pointers_out: Option<&mut D::IndexOutput>,
temp_outputs_closed: bool,
docs_out_pending_delete: bool,
file_pointers_out_pending_delete: bool,
) -> Result<()> {
let close_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
if temp_outputs_closed {
Ok(())
} else {
match file_pointers_out.as_deref_mut() {
Some(out) => IOUtils::close([&mut *docs_out, out]),
None => IOUtils::close(&mut *docs_out),
}
}
}));
let delete_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let docs_file_name = if docs_out_pending_delete {
Some(docs_out.get_name())
} else {
None
};
let file_pointers_file_name = if file_pointers_out_pending_delete {
file_pointers_out.as_ref().map(|out| out.get_name())
} else {
None
};
IOUtils::delete_files(dir, [docs_file_name, file_pointers_file_name])
}));
IOUtils::finally_caught_result(close_result, delete_result)
}
}
impl<D> Closeable for FieldsIndexWriter<D>
where
D: Directory,
{
fn close(&mut self) -> Result<()> {
if !self.docs_out_pending_delete && !self.file_pointers_out_pending_delete {
return Ok(());
}
let cleanup_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
Self::close_temp_outputs(
&self.dir,
&mut self.docs_out,
Some(&mut self.file_pointers_out),
self.temp_outputs_closed,
self.docs_out_pending_delete,
self.file_pointers_out_pending_delete,
)
}));
self.docs_out_pending_delete = false;
self.file_pointers_out_pending_delete = false;
self.temp_outputs_closed = true;
unwrap_caught_result!(cleanup_result)
}
}
impl<D> Drop for FieldsIndexWriter<D>
where
D: Directory,
{
fn drop(&mut self) {
let _ = self.close();
}
}