split meilisearch-http and meilisearch-lib

meilisearch-lib/src/index_controller/dump_actor/actor.rs

@@ -0,0 +1,157 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use async_stream::stream;
+use chrono::Utc;
+use futures::{lock::Mutex, stream::StreamExt};
+use log::{error, trace};
+use tokio::sync::{mpsc, oneshot, RwLock};
+use update_actor::UpdateActorHandle;
+use uuid_resolver::UuidResolverHandle;
+
+use super::error::{DumpActorError, Result};
+use super::{DumpInfo, DumpMsg, DumpStatus, DumpTask};
+use crate::index_controller::{update_actor, uuid_resolver};
+
+pub const CONCURRENT_DUMP_MSG: usize = 10;
+
+pub struct DumpActor<UuidResolver, Update> {
+    inbox: Option<mpsc::Receiver<DumpMsg>>,
+    uuid_resolver: UuidResolver,
+    update: Update,
+    dump_path: PathBuf,
+    lock: Arc<Mutex<()>>,
+    dump_infos: Arc<RwLock<HashMap<String, DumpInfo>>>,
+    update_db_size: usize,
+    index_db_size: usize,
+}
+
+/// Generate uid from creation date
+fn generate_uid() -> String {
+    Utc::now().format("%Y%m%d-%H%M%S%3f").to_string()
+}
+
+impl<UuidResolver, Update> DumpActor<UuidResolver, Update>
+where
+    UuidResolver: UuidResolverHandle + Send + Sync + Clone + 'static,
+    Update: UpdateActorHandle + Send + Sync + Clone + 'static,
+{
+    pub fn new(
+        inbox: mpsc::Receiver<DumpMsg>,
+        uuid_resolver: UuidResolver,
+        update: Update,
+        dump_path: impl AsRef<Path>,
+        index_db_size: usize,
+        update_db_size: usize,
+    ) -> Self {
+        let dump_infos = Arc::new(RwLock::new(HashMap::new()));
+        let lock = Arc::new(Mutex::new(()));
+        Self {
+            inbox: Some(inbox),
+            uuid_resolver,
+            update,
+            dump_path: dump_path.as_ref().into(),
+            dump_infos,
+            lock,
+            index_db_size,
+            update_db_size,
+        }
+    }
+
+    pub async fn run(mut self) {
+        trace!("Started dump actor.");
+
+        let mut inbox = self
+            .inbox
+            .take()
+            .expect("Dump Actor must have a inbox at this point.");
+
+        let stream = stream! {
+            loop {
+                match inbox.recv().await {
+                    Some(msg) => yield msg,
+                    None => break,
+                }
+            }
+        };
+
+        stream
+            .for_each_concurrent(Some(CONCURRENT_DUMP_MSG), |msg| self.handle_message(msg))
+            .await;
+
+        error!("Dump actor stopped.");
+    }
+
+    async fn handle_message(&self, msg: DumpMsg) {
+        use DumpMsg::*;
+
+        match msg {
+            CreateDump { ret } => {
+                let _ = self.handle_create_dump(ret).await;
+            }
+            DumpInfo { ret, uid } => {
+                let _ = ret.send(self.handle_dump_info(uid).await);
+            }
+        }
+    }
+
+    async fn handle_create_dump(&self, ret: oneshot::Sender<Result<DumpInfo>>) {
+        let uid = generate_uid();
+        let info = DumpInfo::new(uid.clone(), DumpStatus::InProgress);
+
+        let _lock = match self.lock.try_lock() {
+            Some(lock) => lock,
+            None => {
+                ret.send(Err(DumpActorError::DumpAlreadyRunning))
+                    .expect("Dump actor is dead");
+                return;
+            }
+        };
+
+        self.dump_infos
+            .write()
+            .await
+            .insert(uid.clone(), info.clone());
+
+        ret.send(Ok(info)).expect("Dump actor is dead");
+
+        let task = DumpTask {
+            path: self.dump_path.clone(),
+            uuid_resolver: self.uuid_resolver.clone(),
+            update_handle: self.update.clone(),
+            uid: uid.clone(),
+            update_db_size: self.update_db_size,
+            index_db_size: self.index_db_size,
+        };
+
+        let task_result = tokio::task::spawn(task.run()).await;
+
+        let mut dump_infos = self.dump_infos.write().await;
+        let dump_infos = dump_infos
+            .get_mut(&uid)
+            .expect("dump entry deleted while lock was acquired");
+
+        match task_result {
+            Ok(Ok(())) => {
+                dump_infos.done();
+                trace!("Dump succeed");
+            }
+            Ok(Err(e)) => {
+                dump_infos.with_error(e.to_string());
+                error!("Dump failed: {}", e);
+            }
+            Err(_) => {
+                dump_infos.with_error("Unexpected error while performing dump.".to_string());
+                error!("Dump panicked. Dump status set to failed");
+            }
+        };
+    }
+
+    async fn handle_dump_info(&self, uid: String) -> Result<DumpInfo> {
+        match self.dump_infos.read().await.get(&uid) {
+            Some(info) => Ok(info.clone()),
+            _ => Err(DumpActorError::DumpDoesNotExist(uid)),
+        }
+    }
+}

meilisearch-lib/src/index_controller/dump_actor/error.rs

@@ -0,0 +1,52 @@
+use meilisearch_error::{Code, ErrorCode};
+
+use crate::index_controller::update_actor::error::UpdateActorError;
+use crate::index_controller::uuid_resolver::error::UuidResolverError;
+
+pub type Result<T> = std::result::Result<T, DumpActorError>;
+
+#[derive(thiserror::Error, Debug)]
+pub enum DumpActorError {
+    #[error("Another dump is already in progress")]
+    DumpAlreadyRunning,
+    #[error("Dump `{0}` not found")]
+    DumpDoesNotExist(String),
+    #[error("Internal error: {0}")]
+    Internal(Box<dyn std::error::Error + Send + Sync + 'static>),
+    #[error("{0}")]
+    UuidResolver(#[from] UuidResolverError),
+    #[error("{0}")]
+    UpdateActor(#[from] UpdateActorError),
+}
+
+macro_rules! internal_error {
+    ($($other:path), *) => {
+        $(
+            impl From<$other> for DumpActorError {
+                fn from(other: $other) -> Self {
+                    Self::Internal(Box::new(other))
+                }
+            }
+        )*
+    }
+}
+
+internal_error!(
+    heed::Error,
+    std::io::Error,
+    tokio::task::JoinError,
+    serde_json::error::Error,
+    tempfile::PersistError
+);
+
+impl ErrorCode for DumpActorError {
+    fn error_code(&self) -> Code {
+        match self {
+            DumpActorError::DumpAlreadyRunning => Code::DumpAlreadyInProgress,
+            DumpActorError::DumpDoesNotExist(_) => Code::NotFound,
+            DumpActorError::Internal(_) => Code::Internal,
+            DumpActorError::UuidResolver(e) => e.error_code(),
+            DumpActorError::UpdateActor(e) => e.error_code(),
+        }
+    }
+}

meilisearch-lib/src/index_controller/dump_actor/handle_impl.rs

@@ -0,0 +1,52 @@
+use std::path::Path;
+
+use tokio::sync::{mpsc, oneshot};
+
+use super::error::Result;
+use super::{DumpActor, DumpActorHandle, DumpInfo, DumpMsg};
+
+#[derive(Clone)]
+pub struct DumpActorHandleImpl {
+    sender: mpsc::Sender<DumpMsg>,
+}
+
+#[async_trait::async_trait]
+impl DumpActorHandle for DumpActorHandleImpl {
+    async fn create_dump(&self) -> Result<DumpInfo> {
+        let (ret, receiver) = oneshot::channel();
+        let msg = DumpMsg::CreateDump { ret };
+        let _ = self.sender.send(msg).await;
+        receiver.await.expect("IndexActor has been killed")
+    }
+
+    async fn dump_info(&self, uid: String) -> Result<DumpInfo> {
+        let (ret, receiver) = oneshot::channel();
+        let msg = DumpMsg::DumpInfo { ret, uid };
+        let _ = self.sender.send(msg).await;
+        receiver.await.expect("IndexActor has been killed")
+    }
+}
+
+impl DumpActorHandleImpl {
+    pub fn new(
+        path: impl AsRef<Path>,
+        uuid_resolver: crate::index_controller::uuid_resolver::UuidResolverHandleImpl,
+        update: crate::index_controller::update_actor::UpdateActorHandleImpl,
+        index_db_size: usize,
+        update_db_size: usize,
+    ) -> anyhow::Result<Self> {
+        let (sender, receiver) = mpsc::channel(10);
+        let actor = DumpActor::new(
+            receiver,
+            uuid_resolver,
+            update,
+            path,
+            index_db_size,
+            update_db_size,
+        );
+
+        tokio::task::spawn(actor.run());
+
+        Ok(Self { sender })
+    }
+}

meilisearch-lib/src/index_controller/dump_actor/loaders/mod.rs

@@ -0,0 +1,2 @@
+pub mod v1;
+pub mod v2;

meilisearch-lib/src/index_controller/dump_actor/loaders/v1.rs

@@ -0,0 +1,224 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::marker::PhantomData;
+use std::path::Path;
+
+use log::{error, info, warn};
+use milli::update::Setting;
+use serde::{Deserialize, Deserializer, Serialize};
+use uuid::Uuid;
+
+use crate::index_controller::{self, uuid_resolver::HeedUuidStore, IndexMetadata};
+use crate::index_controller::{asc_ranking_rule, desc_ranking_rule};
+use crate::{
+    index::Unchecked,
+    options::IndexerOpts,
+};
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MetadataV1 {
+    db_version: String,
+    indexes: Vec<IndexMetadata>,
+}
+
+impl MetadataV1 {
+    pub fn load_dump(
+        self,
+        src: impl AsRef<Path>,
+        dst: impl AsRef<Path>,
+        size: usize,
+        indexer_options: &IndexerOpts,
+    ) -> anyhow::Result<()> {
+        info!(
+            "Loading dump, dump database version: {}, dump version: V1",
+            self.db_version
+        );
+
+        let uuid_store = HeedUuidStore::new(&dst)?;
+        for index in self.indexes {
+            let uuid = Uuid::new_v4();
+            uuid_store.insert(index.uid.clone(), uuid)?;
+            let src = src.as_ref().join(index.uid);
+            load_index(
+                &src,
+                &dst,
+                uuid,
+                index.meta.primary_key.as_deref(),
+                size,
+                indexer_options,
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+pub fn deserialize_some<'de, T, D>(deserializer: D) -> std::result::Result<Option<T>, D::Error>
+where
+    T: Deserialize<'de>,
+    D: Deserializer<'de>,
+{
+    Deserialize::deserialize(deserializer).map(Some)
+}
+
+// These are the settings used in legacy meilisearch (<v0.21.0).
+#[derive(Default, Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct Settings {
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub ranking_rules: Option<Option<Vec<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub distinct_attribute: Option<Option<String>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub searchable_attributes: Option<Option<Vec<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub displayed_attributes: Option<Option<BTreeSet<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub stop_words: Option<Option<BTreeSet<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub synonyms: Option<Option<BTreeMap<String, Vec<String>>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub attributes_for_faceting: Option<Option<Vec<String>>>,
+}
+
+fn load_index(
+    _src: impl AsRef<Path>,
+    _dst: impl AsRef<Path>,
+    _uuid: Uuid,
+    _primary_key: Option<&str>,
+    _size: usize,
+    _indexer_options: &IndexerOpts,
+) -> anyhow::Result<()> {
+    todo!("fix dump obkv documents")
+    //let index_path = dst.as_ref().join(&format!("indexes/index-{}", uuid));
+
+    //create_dir_all(&index_path)?;
+    //let mut options = EnvOpenOptions::new();
+    //options.map_size(size);
+    //let index = milli::Index::new(options, index_path)?;
+    //let index = Index(Arc::new(index));
+
+    //// extract `settings.json` file and import content
+    //let settings = import_settings(&src)?;
+    //let settings: index_controller::Settings<Unchecked> = settings.into();
+
+    //let mut txn = index.write_txn()?;
+
+    //let handler = UpdateHandler::new(indexer_options)?;
+
+    //index.update_settings_txn(&mut txn, &settings.check(), handler.update_builder(0))?;
+
+    //let file = File::open(&src.as_ref().join("documents.jsonl"))?;
+    //let mut reader = std::io::BufReader::new(file);
+    //reader.fill_buf()?;
+    //if !reader.buffer().is_empty() {
+        //index.update_documents_txn(
+            //&mut txn,
+            //IndexDocumentsMethod::ReplaceDocuments,
+            //Some(reader),
+            //handler.update_builder(0),
+            //primary_key,
+        //)?;
+    //}
+
+    //txn.commit()?;
+
+    //// Finaly, we extract the original milli::Index and close it
+    //Arc::try_unwrap(index.0)
+        //.map_err(|_e| "Couldn't close the index properly")
+        //.unwrap()
+        //.prepare_for_closing()
+        //.wait();
+
+    //// Updates are ignored in dumps V1.
+
+    //Ok(())
+}
+
+/// we need to **always** be able to convert the old settings to the settings currently being used
+impl From<Settings> for index_controller::Settings<Unchecked> {
+    fn from(settings: Settings) -> Self {
+        Self {
+            distinct_attribute: match settings.distinct_attribute {
+                Some(Some(attr)) => Setting::Set(attr),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            // we need to convert the old `Vec<String>` into a `BTreeSet<String>`
+            displayed_attributes: match settings.displayed_attributes {
+                Some(Some(attrs)) => Setting::Set(attrs.into_iter().collect()),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            searchable_attributes: match settings.searchable_attributes {
+                Some(Some(attrs)) => Setting::Set(attrs),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            filterable_attributes: match settings.attributes_for_faceting {
+                Some(Some(attrs)) => Setting::Set(attrs.into_iter().collect()),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            sortable_attributes: Setting::NotSet,
+            ranking_rules: match settings.ranking_rules {
+                Some(Some(ranking_rules)) => Setting::Set(ranking_rules.into_iter().filter_map(|criterion| {
+                    match criterion.as_str() {
+                        "words" | "typo" | "proximity" | "attribute" | "exactness" => Some(criterion),
+                        s if s.starts_with("asc") => asc_ranking_rule(s).map(|f| format!("{}:asc", f)),
+                        s if s.starts_with("desc") => desc_ranking_rule(s).map(|f| format!("{}:desc", f)),
+                        "wordsPosition" => {
+                            warn!("The criteria `attribute` and `wordsPosition` have been merged \
+                                into a single criterion `attribute` so `wordsPositon` will be \
+                                ignored");
+                            None
+                        }
+                        s => {
+                            error!("Unknown criterion found in the dump: `{}`, it will be ignored", s);
+                            None
+                        }
+                    }
+                }).collect()),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            // we need to convert the old `Vec<String>` into a `BTreeSet<String>`
+            stop_words: match settings.stop_words {
+                Some(Some(stop_words)) => Setting::Set(stop_words.into_iter().collect()),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            // we need to convert the old `Vec<String>` into a `BTreeMap<String>`
+            synonyms: match settings.synonyms {
+                Some(Some(synonyms)) => Setting::Set(synonyms.into_iter().collect()),
+                Some(None) => Setting::Reset,
+                None => Setting::NotSet
+            },
+            _kind: PhantomData,
+        }
+    }
+}
+
+// /// Extract Settings from `settings.json` file present at provided `dir_path`
+//fn import_settings(dir_path: impl AsRef<Path>) -> anyhow::Result<Settings> {
+    //let path = dir_path.as_ref().join("settings.json");
+    //let file = File::open(path)?;
+    //let reader = std::io::BufReader::new(file);
+    //let metadata = serde_json::from_reader(reader)?;
+
+    //Ok(metadata)
+//}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn settings_format_regression() {
+        let settings = Settings::default();
+        assert_eq!(
+            r##"{"rankingRules":null,"distinctAttribute":null,"searchableAttributes":null,"displayedAttributes":null,"stopWords":null,"synonyms":null,"attributesForFaceting":null}"##,
+            serde_json::to_string(&settings).unwrap()
+        );
+    }
+}

meilisearch-lib/src/index_controller/dump_actor/loaders/v2.rs

@@ -0,0 +1,59 @@
+use std::path::Path;
+
+use chrono::{DateTime, Utc};
+use log::info;
+use serde::{Deserialize, Serialize};
+
+use crate::index::Index;
+use crate::index_controller::{update_actor::UpdateStore, uuid_resolver::HeedUuidStore};
+use crate::options::IndexerOpts;
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct MetadataV2 {
+    db_version: String,
+    index_db_size: usize,
+    update_db_size: usize,
+    dump_date: DateTime<Utc>,
+}
+
+impl MetadataV2 {
+    pub fn new(index_db_size: usize, update_db_size: usize) -> Self {
+        Self {
+            db_version: env!("CARGO_PKG_VERSION").to_string(),
+            index_db_size,
+            update_db_size,
+            dump_date: Utc::now(),
+        }
+    }
+
+    pub fn load_dump(
+        self,
+        src: impl AsRef<Path>,
+        dst: impl AsRef<Path>,
+        index_db_size: usize,
+        update_db_size: usize,
+        indexing_options: &IndexerOpts,
+    ) -> anyhow::Result<()> {
+        info!(
+            "Loading dump from {}, dump database version: {}, dump version: V2",
+            self.dump_date, self.db_version
+        );
+
+        info!("Loading index database.");
+        HeedUuidStore::load_dump(src.as_ref(), &dst)?;
+
+        info!("Loading updates.");
+        UpdateStore::load_dump(&src, &dst, update_db_size)?;
+
+        info!("Loading indexes.");
+        let indexes_path = src.as_ref().join("indexes");
+        let indexes = indexes_path.read_dir()?;
+        for index in indexes {
+            let index = index?;
+            Index::load_dump(&index.path(), &dst, index_db_size, indexing_options)?;
+        }
+
+        Ok(())
+    }
+}

meilisearch-lib/src/index_controller/dump_actor/message.rs

@@ -0,0 +1,14 @@
+use tokio::sync::oneshot;
+
+use super::error::Result;
+use super::DumpInfo;
+
+pub enum DumpMsg {
+    CreateDump {
+        ret: oneshot::Sender<Result<DumpInfo>>,
+    },
+    DumpInfo {
+        uid: String,
+        ret: oneshot::Sender<Result<DumpInfo>>,
+    },
+}

meilisearch-lib/src/index_controller/dump_actor/mod.rs

@@ -0,0 +1,204 @@
+use std::fs::File;
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+use chrono::{DateTime, Utc};
+use log::{info, trace, warn};
+#[cfg(test)]
+use mockall::automock;
+use serde::{Deserialize, Serialize};
+use tokio::fs::create_dir_all;
+
+use loaders::v1::MetadataV1;
+use loaders::v2::MetadataV2;
+
+pub use actor::DumpActor;
+pub use handle_impl::*;
+pub use message::DumpMsg;
+
+use super::{update_actor::UpdateActorHandle, uuid_resolver::UuidResolverHandle};
+use crate::index_controller::dump_actor::error::DumpActorError;
+use crate::options::IndexerOpts;
+use error::Result;
+
+mod actor;
+pub mod error;
+mod handle_impl;
+mod loaders;
+mod message;
+
+const META_FILE_NAME: &str = "metadata.json";
+
+#[async_trait::async_trait]
+#[cfg_attr(test, automock)]
+pub trait DumpActorHandle {
+    /// Start the creation of a dump
+    /// Implementation: [handle_impl::DumpActorHandleImpl::create_dump]
+    async fn create_dump(&self) -> Result<DumpInfo>;
+
+    /// Return the status of an already created dump
+    /// Implementation: [handle_impl::DumpActorHandleImpl::dump_info]
+    async fn dump_info(&self, uid: String) -> Result<DumpInfo>;
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "dumpVersion")]
+pub enum Metadata {
+    V1(MetadataV1),
+    V2(MetadataV2),
+}
+
+impl Metadata {
+    pub fn new_v2(index_db_size: usize, update_db_size: usize) -> Self {
+        let meta = MetadataV2::new(index_db_size, update_db_size);
+        Self::V2(meta)
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum DumpStatus {
+    Done,
+    InProgress,
+    Failed,
+}
+
+#[derive(Debug, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DumpInfo {
+    pub uid: String,
+    pub status: DumpStatus,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+    started_at: DateTime<Utc>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    finished_at: Option<DateTime<Utc>>,
+}
+
+impl DumpInfo {
+    pub fn new(uid: String, status: DumpStatus) -> Self {
+        Self {
+            uid,
+            status,
+            error: None,
+            started_at: Utc::now(),
+            finished_at: None,
+        }
+    }
+
+    pub fn with_error(&mut self, error: String) {
+        self.status = DumpStatus::Failed;
+        self.finished_at = Some(Utc::now());
+        self.error = Some(error);
+    }
+
+    pub fn done(&mut self) {
+        self.finished_at = Some(Utc::now());
+        self.status = DumpStatus::Done;
+    }
+
+    pub fn dump_already_in_progress(&self) -> bool {
+        self.status == DumpStatus::InProgress
+    }
+}
+
+pub fn load_dump(
+    dst_path: impl AsRef<Path>,
+    src_path: impl AsRef<Path>,
+    index_db_size: usize,
+    update_db_size: usize,
+    indexer_opts: &IndexerOpts,
+) -> anyhow::Result<()> {
+    let tmp_src = tempfile::tempdir_in(".")?;
+    let tmp_src_path = tmp_src.path();
+
+    crate::from_tar_gz(&src_path, tmp_src_path)?;
+
+    let meta_path = tmp_src_path.join(META_FILE_NAME);
+    let mut meta_file = File::open(&meta_path)?;
+    let meta: Metadata = serde_json::from_reader(&mut meta_file)?;
+
+    let dst_dir = dst_path
+        .as_ref()
+        .parent()
+        .with_context(|| format!("Invalid db path: {}", dst_path.as_ref().display()))?;
+
+    let tmp_dst = tempfile::tempdir_in(dst_dir)?;
+
+    match meta {
+        Metadata::V1(meta) => {
+            meta.load_dump(&tmp_src_path, tmp_dst.path(), index_db_size, indexer_opts)?
+        }
+        Metadata::V2(meta) => meta.load_dump(
+            &tmp_src_path,
+            tmp_dst.path(),
+            index_db_size,
+            update_db_size,
+            indexer_opts,
+        )?,
+    }
+    // Persist and atomically rename the db
+    let persisted_dump = tmp_dst.into_path();
+    if dst_path.as_ref().exists() {
+        warn!("Overwriting database at {}", dst_path.as_ref().display());
+        std::fs::remove_dir_all(&dst_path)?;
+    }
+
+    std::fs::rename(&persisted_dump, &dst_path)?;
+
+    Ok(())
+}
+
+struct DumpTask<U, P> {
+    path: PathBuf,
+    uuid_resolver: U,
+    update_handle: P,
+    uid: String,
+    update_db_size: usize,
+    index_db_size: usize,
+}
+
+impl<U, P> DumpTask<U, P>
+where
+    U: UuidResolverHandle + Send + Sync + Clone + 'static,
+    P: UpdateActorHandle + Send + Sync + Clone + 'static,
+
+{
+    async fn run(self) -> Result<()> {
+        trace!("Performing dump.");
+
+        create_dir_all(&self.path).await?;
+
+        let path_clone = self.path.clone();
+        let temp_dump_dir =
+            tokio::task::spawn_blocking(|| tempfile::TempDir::new_in(path_clone)).await??;
+        let temp_dump_path = temp_dump_dir.path().to_owned();
+
+        let meta = Metadata::new_v2(self.index_db_size, self.update_db_size);
+        let meta_path = temp_dump_path.join(META_FILE_NAME);
+        let mut meta_file = File::create(&meta_path)?;
+        serde_json::to_writer(&mut meta_file, &meta)?;
+
+        let uuids = self.uuid_resolver.dump(temp_dump_path.clone()).await?;
+
+        self.update_handle
+            .dump(uuids, temp_dump_path.clone())
+            .await?;
+
+        let dump_path = tokio::task::spawn_blocking(move || -> Result<PathBuf> {
+            let temp_dump_file = tempfile::NamedTempFile::new_in(&self.path)?;
+            crate::to_tar_gz(temp_dump_path, temp_dump_file.path())
+                .map_err(|e| DumpActorError::Internal(e.into()))?;
+
+            let dump_path = self.path.join(self.uid).with_extension("dump");
+            temp_dump_file.persist(&dump_path)?;
+
+            Ok(dump_path)
+        })
+        .await??;
+
+        info!("Created dump in {:?}.", dump_path);
+
+        Ok(())
+    }
+}