Merge #113

113: Implement dumps r=curquiza a=Mubelotix

Fix #54

Co-authored-by: Mubelotix <[email protected]>

Author: bors[bot]

.code-samples.meilisearch.yaml

@@ -540,3 +540,7 @@ faceted_search_walkthrough_facets_distribution_1: |-
     .await
     .unwrap();
   let genres: &HashMap<String, usize> = results.facets_distribution.unwrap().get("genres").unwrap();
+post_dump_1: |-
+  client.create_dump().await.unwrap();
+get_dump_status_1: |-
+  client.get_dump_status("20201101-110357260").await.unwrap();

src/dumps.rs

@@ -0,0 +1,158 @@
+//! The `dumps` module allows the creation of database dumps.
+//! Dumps are `.dump` files that can be used to launch MeiliSearch.
+//! Dumps are compatible between MeiliSearch versions.
+//!
+//! Creating a dump is also referred to as exporting it, whereas launching MeiliSearch with a dump is referred to as importing it.
+//!
+//! During a [dump export](Client::create_dump), all [indexes](crate::indexes::Index) of the current instance are exported—together with their documents and settings—and saved as a single `.dump` file.
+//!
+//! During a dump import, all indexes contained in the indicated `.dump` file are imported along with their associated [documents](crate::document::Document) and [settings](crate::settings::Settings).
+//! Any existing [index](crate::indexes::Index) with the same uid as an index in the dump file will be overwritten.
+//!
+//! Dump imports are [performed at launch](https://docs.meilisearch.com/reference/features/configuration.html#import-dump) using an option.
+//! [Batch size](https://docs.meilisearch.com/reference/features/configuration.html#dump-batch-size) can also be set at this time.
+//!
+//! # Example
+//!
+//! ```no_run
+//! # use meilisearch_sdk::{client::*, errors::*, dumps::*};
+//! # use futures_await_test::async_test;
+//! # use std::{thread::sleep, time::Duration};
+//! # futures::executor::block_on(async move {
+//! #
+//! let client = Client::new("http://localhost:7700", "masterKey");
+//!
+//! // Create a dump
+//! let dump_info = client.create_dump().await.unwrap();
+//! assert!(matches!(dump_info.status, DumpStatus::InProgress));
+//!
+//! // Wait for MeiliSearch to proceed
+//! sleep(Duration::from_secs(5));
+//!
+//! // Check the status of the dump
+//! let dump_info = client.get_dump_status(&dump_info.uid).await.unwrap();
+//! assert!(matches!(dump_info.status, DumpStatus::Done));
+//! # });
+//! ```
+
+use crate::{client::Client, errors::Error, request::*};
+use serde::Deserialize;
+
+/// The status of a dump.\
+/// Contained in [`DumpInfo`].
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum DumpStatus {
+    /// Dump creation is in progress.
+    Done,
+    /// Dump creation is in progress.
+    InProgress,
+    /// An error occured during dump process, and the task was aborted.
+    Failed,
+}
+
+/// Limited informations about a dump.\
+/// Can be obtained with [create_dump](Client::create_dump) and [get_dump_status](Client::get_dump_status) methods.
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DumpInfo {
+    pub uid: String,
+    pub status: DumpStatus,
+    pub error: Option<serde_json::Value>,
+}
+
+/// Dump related methods.\
+/// See the [dumps](crate::dumps) module.
+impl<'a> Client<'a> {
+    /// Triggers a dump creation process.
+    /// Once the process is complete, a dump is created in the [dumps directory](https://docs.meilisearch.com/reference/features/configuration.html#dumps-destination).
+    /// If the dumps directory does not exist yet, it will be created.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// # use meilisearch_sdk::{client::*, errors::*, dumps::*};
+    /// # use futures_await_test::async_test;
+    /// # use std::{thread::sleep, time::Duration};
+    /// # futures::executor::block_on(async move {
+    /// #
+    /// # let client = Client::new("http://localhost:7700", "masterKey");
+    /// #
+    /// let dump_info = client.create_dump().await.unwrap();
+    /// assert!(matches!(dump_info.status, DumpStatus::InProgress));
+    /// # });
+    /// ```
+    pub async fn create_dump(&self) -> Result<DumpInfo, Error> {
+        request::<(), DumpInfo>(
+            &format!("{}/dumps", self.host),
+            self.apikey,
+            Method::Post(()),
+            202,
+        )
+        .await
+    }
+
+    /// Get the status of a dump creation process using [the uid](DumpInfo::uid) returned after calling the [dump creation method](Client::create_dump).
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// # use meilisearch_sdk::{client::*, errors::*, dumps::*};
+    /// # use futures_await_test::async_test;
+    /// # use std::{thread::sleep, time::Duration};
+    /// # futures::executor::block_on(async move {
+    /// #
+    /// # let client = Client::new("http://localhost:7700", "masterKey");
+    /// # let dump_info = client.create_dump().await.unwrap();
+    /// # sleep(Duration::from_secs(5));
+    /// #
+    /// let dump_info = client.get_dump_status(&dump_info.uid).await.unwrap();
+    /// # });
+    /// ```
+    pub async fn get_dump_status(&self, dump_uid: &str) -> Result<DumpInfo, Error> {
+        request::<(), DumpInfo>(
+            &format!("{}/dumps/{}/status", self.host, dump_uid),
+            self.apikey,
+            Method::Get,
+            200,
+        )
+        .await
+    }
+}
+
+/// Alias for [create_dump](Client::create_dump).
+pub async fn create_dump<'a>(client: &'a Client<'a>) -> Result<DumpInfo, Error> {
+    client.create_dump().await
+}
+
+/// Alias for [get_dump_status](Client::get_dump_status).
+pub async fn get_dump_status<'a>(
+    client: &'a Client<'a>,
+    dump_uid: &str,
+) -> Result<DumpInfo, Error> {
+    client.get_dump_status(dump_uid).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client::*;
+    use futures_await_test::async_test;
+    use std::{thread::sleep, time::Duration};
+
+    #[async_test]
+    async fn test_dumps() {
+        let client = Client::new("http://localhost:7700", "masterKey");
+
+        // Create a dump
+        let dump_info = client.create_dump().await.unwrap();
+        assert!(matches!(dump_info.status, DumpStatus::InProgress));
+
+        // Wait for Meilisearch to do the dump
+        sleep(Duration::from_secs(5));
+
+        // Assert that the dump was successful
+        let new_dump_info = client.get_dump_status(&dump_info.uid).await.unwrap();
+        assert!(matches!(new_dump_info.status, DumpStatus::Done));
+    }
+}

src/errors.rs

@@ -117,6 +117,10 @@ pub enum ErrorCode {
     /// The payload content type is not supported by MeiliSearch. Currently,
     /// MeiliSearch only supports JSON payloads.
     UnsupportedMediaType,
+    /// A dump creation is already in progress and a new one can't be triggered until the previous dump creation is not finished.
+    DumpAlreadyInProgress,
+    /// An error occured during dump creation process, task aborted.
+    DumpProcessFailed,
 
     /// That's unexpected. Please open a GitHub issue after ensuring you are
     /// using the supported version of the MeiliSearch server.
@@ -194,6 +198,8 @@ impl ErrorCode {
             ErrorCode::UnretrievableDocument => "unretrievable_document",
             ErrorCode::SearchError => "search_error",
             ErrorCode::UnsupportedMediaType => "unsupported_media_type",
+            ErrorCode::DumpAlreadyInProgress => "dump_already_in_progress",
+            ErrorCode::DumpProcessFailed => "dump_process_failed",
             // Other than this variant, all the other `&str`s are 'static
             ErrorCode::Unknown(inner) => &inner.0,
         }
@@ -227,6 +233,8 @@ impl ErrorCode {
             "unretrievable_document" => ErrorCode::UnretrievableDocument,
             "search_error" => ErrorCode::SearchError,
             "unsupported_media_type" => ErrorCode::UnsupportedMediaType,
+            "dump_already_in_progress" => ErrorCode::DumpAlreadyInProgress,
+            "dump_process_failed" => ErrorCode::DumpProcessFailed,
             inner => ErrorCode::Unknown(UnknownErrorCode(inner.to_string())),
         }
     }

src/lib.rs

@@ -99,6 +99,7 @@
 pub mod client;
 /// Module containing the Document trait.
 pub mod document;
+pub mod dumps;
 /// Module containing the Error struct.
 pub mod errors;
 /// Module containing the Index struct.