refactor meilisearch

meilisearch-http/src/index/dump.rs

@@ -1,20 +1,15 @@
-use std::fs::{create_dir_all, File};
-use std::io::{BufRead, BufReader, Write};
+use std::fs::File;
+use std::io::Write;
 use std::path::Path;
-use std::sync::Arc;
 
-use anyhow::{bail, Context};
 use heed::RoTxn;
 use indexmap::IndexMap;
-use milli::update::{IndexDocumentsMethod, UpdateFormat::JsonStream};
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
 
-use crate::index_controller::{asc_ranking_rule, desc_ranking_rule};
 use crate::option::IndexerOpts;
 
 use super::error::Result;
-use super::{update_handler::UpdateHandler, Index, Settings, Unchecked};
+use super::{Index, Settings, Unchecked};
 
 #[derive(Serialize, Deserialize)]
 struct DumpMeta {
@@ -80,91 +75,92 @@ impl Index {
     }
 
     pub fn load_dump(
-        src: impl AsRef<Path>,
-        dst: impl AsRef<Path>,
-        size: usize,
-        indexing_options: &IndexerOpts,
+        _src: impl AsRef<Path>,
+        _dst: impl AsRef<Path>,
+        _size: usize,
+        _indexing_options: &IndexerOpts,
     ) -> anyhow::Result<()> {
-        let dir_name = src
-            .as_ref()
-            .file_name()
-            .with_context(|| format!("invalid dump index: {}", src.as_ref().display()))?;
+        //let dir_name = src
+            //.as_ref()
+            //.file_name()
+            //.with_context(|| format!("invalid dump index: {}", src.as_ref().display()))?;
 
-        let dst_dir_path = dst.as_ref().join("indexes").join(dir_name);
-        create_dir_all(&dst_dir_path)?;
+        //let dst_dir_path = dst.as_ref().join("indexes").join(dir_name);
+        //create_dir_all(&dst_dir_path)?;
 
-        let meta_path = src.as_ref().join(META_FILE_NAME);
-        let mut meta_file = File::open(meta_path)?;
+        //let meta_path = src.as_ref().join(META_FILE_NAME);
+        //let mut meta_file = File::open(meta_path)?;
 
-        // We first deserialize the dump meta into a serde_json::Value and change
-        // the custom ranking rules settings from the old format to the new format.
-        let mut meta: Value = serde_json::from_reader(&mut meta_file)?;
-        if let Some(ranking_rules) = meta.pointer_mut("/settings/rankingRules") {
-            convert_custom_ranking_rules(ranking_rules);
-        }
+        //// We first deserialize the dump meta into a serde_json::Value and change
+        //// the custom ranking rules settings from the old format to the new format.
+        //let mut meta: Value = serde_json::from_reader(&mut meta_file)?;
+        //if let Some(ranking_rules) = meta.pointer_mut("/settings/rankingRules") {
+            //convert_custom_ranking_rules(ranking_rules);
+        //}
 
-        // Then we serialize it back into a vec to deserialize it
-        // into a `DumpMeta` struct with the newly patched `rankingRules` format.
-        let patched_meta = serde_json::to_vec(&meta)?;
+        //// Then we serialize it back into a vec to deserialize it
+        //// into a `DumpMeta` struct with the newly patched `rankingRules` format.
+        //let patched_meta = serde_json::to_vec(&meta)?;
 
-        let DumpMeta {
-            settings,
-            primary_key,
-        } = serde_json::from_slice(&patched_meta)?;
-        let settings = settings.check();
-        let index = Self::open(&dst_dir_path, size)?;
-        let mut txn = index.write_txn()?;
+        //let DumpMeta {
+            //settings,
+            //primary_key,
+        //} = serde_json::from_slice(&patched_meta)?;
+        //let settings = settings.check();
+        //let index = Self::open(&dst_dir_path, size)?;
+        //let mut txn = index.write_txn()?;
 
-        let handler = UpdateHandler::new(indexing_options)?;
+        //let handler = UpdateHandler::new(indexing_options)?;
 
-        index.update_settings_txn(&mut txn, &settings, handler.update_builder(0))?;
+        //index.update_settings_txn(&mut txn, &settings, handler.update_builder(0))?;
 
-        let document_file_path = src.as_ref().join(DATA_FILE_NAME);
-        let reader = File::open(&document_file_path)?;
-        let mut reader = BufReader::new(reader);
-        reader.fill_buf()?;
+        //let document_file_path = src.as_ref().join(DATA_FILE_NAME);
+        //let reader = File::open(&document_file_path)?;
+        //let mut reader = BufReader::new(reader);
+        //reader.fill_buf()?;
         // If the document file is empty, we don't perform the document addition, to prevent
         // a primary key error to be thrown.
-        if !reader.buffer().is_empty() {
-            index.update_documents_txn(
-                &mut txn,
-                JsonStream,
-                IndexDocumentsMethod::UpdateDocuments,
-                Some(reader),
-                handler.update_builder(0),
-                primary_key.as_deref(),
-            )?;
-        }
 
-        txn.commit()?;
+        todo!("fix obk document dumps")
+        //if !reader.buffer().is_empty() {
+            //index.update_documents_txn(
+                //&mut txn,
+                //IndexDocumentsMethod::UpdateDocuments,
+                //Some(reader),
+                //handler.update_builder(0),
+                //primary_key.as_deref(),
+            //)?;
+        //}
 
-        match Arc::try_unwrap(index.0) {
-            Ok(inner) => inner.prepare_for_closing().wait(),
-            Err(_) => bail!("Could not close index properly."),
-        }
+        //txn.commit()?;
 
-        Ok(())
+        //match Arc::try_unwrap(index.0) {
+            //Ok(inner) => inner.prepare_for_closing().wait(),
+            //Err(_) => bail!("Could not close index properly."),
+        //}
+
+        //Ok(())
     }
 }
 
-/// Converts the ranking rules from the format `asc(_)`, `desc(_)` to the format `_:asc`, `_:desc`.
-///
-/// This is done for compatibility reasons, and to avoid a new dump version,
-/// since the new syntax was introduced soon after the new dump version.
-fn convert_custom_ranking_rules(ranking_rules: &mut Value) {
-    *ranking_rules = match ranking_rules.take() {
-        Value::Array(values) => values
-            .into_iter()
-            .filter_map(|value| match value {
-                Value::String(s) if s.starts_with("asc") => asc_ranking_rule(&s)
-                    .map(|f| format!("{}:asc", f))
-                    .map(Value::String),
-                Value::String(s) if s.starts_with("desc") => desc_ranking_rule(&s)
-                    .map(|f| format!("{}:desc", f))
-                    .map(Value::String),
-                otherwise => Some(otherwise),
-            })
-            .collect(),
-        otherwise => otherwise,
-    }
-}
+// /// Converts the ranking rules from the format `asc(_)`, `desc(_)` to the format `_:asc`, `_:desc`.
+// ///
+// /// This is done for compatibility reasons, and to avoid a new dump version,
+// /// since the new syntax was introduced soon after the new dump version.
+//fn convert_custom_ranking_rules(ranking_rules: &mut Value) {
+    //*ranking_rules = match ranking_rules.take() {
+        //Value::Array(values) => values
+            //.into_iter()
+            //.filter_map(|value| match value {
+                //Value::String(s) if s.starts_with("asc") => asc_ranking_rule(&s)
+                    //.map(|f| format!("{}:asc", f))
+                    //.map(Value::String),
+                //Value::String(s) if s.starts_with("desc") => desc_ranking_rule(&s)
+                    //.map(|f| format!("{}:desc", f))
+                    //.map(Value::String),
+                //otherwise => Some(otherwise),
+            //})
+            //.collect(),
+        //otherwise => otherwise,
+    //}
+//}