1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! 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::*, dumps::*, task_info::*, tasks::*};
//! # use futures_await_test::async_test;
//! # use std::{thread::sleep, time::Duration};
//! # futures::executor::block_on(async move {
//! #
//! # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
//! # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
//! #
//! let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
//!
//! // Create a dump
//! let task_info = client.create_dump().await.unwrap();
//! assert!(matches!(
//!    task_info,
//!    TaskInfo {
//!        update_type: TaskType::DumpCreation { .. },
//!        ..
//!    }
//!));
//! # });
//! ```

use crate::{client::Client, errors::Error, request::*, task_info::TaskInfo};

/// Dump related methods.\
/// See the [dumps](crate::dumps) module.
impl Client {
    /// 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::*, dumps::*, task_info::*, tasks::*};
    /// # use futures_await_test::async_test;
    /// # use std::{thread::sleep, time::Duration};
    /// # futures::executor::block_on(async move {
    /// #
    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
    /// #
    /// # let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
    /// #
    /// let task_info = client.create_dump().await.unwrap();
    /// assert!(matches!(
    ///    task_info,
    ///    TaskInfo {
    ///        update_type: TaskType::DumpCreation { .. },
    ///        ..
    ///    }
    /// ));
    /// # });
    /// ```
    pub async fn create_dump(&self) -> Result<TaskInfo, Error> {
        request::<(), TaskInfo>(
            &format!("{}/dumps", self.host),
            &self.api_key,
            Method::Post(()),
            202,
        )
        .await
    }
}

/// Alias for [create_dump](Client::create_dump).
pub async fn create_dump(client: &Client) -> Result<TaskInfo, Error> {
    client.create_dump().await
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{client::*, tasks::*};
    use meilisearch_test_macro::meilisearch_test;
    use std::time::Duration;

    #[meilisearch_test]
    async fn test_dumps_success_creation(client: Client) -> Result<(), Error> {
        let task = client
            .create_dump()
            .await?
            .wait_for_completion(
                &client,
                Some(Duration::from_millis(1)),
                Some(Duration::from_millis(6000)),
            )
            .await?;

        assert!(matches!(task, Task::Succeeded { .. }));
        Ok(())
    }

    #[meilisearch_test]
    async fn test_dumps_correct_update_type(client: Client) -> Result<(), Error> {
        let task_info = client.create_dump().await.unwrap();

        assert!(matches!(
            task_info,
            TaskInfo {
                update_type: TaskType::DumpCreation { .. },
                ..
            }
        ));
        Ok(())
    }
}