bayard 0.9.0

A distributed search server.
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

use std::path::Path;

use regex::Regex;
use tantivy::{directory::MmapDirectory, schema::Schema, Index, IndexSettings};
use tokio::fs;

use crate::index::analyzer::{register, Analyzers};

use super::{NodeError, NodeErrorKind};

#[cfg(not(target_os = "windows"))]
const INDEX_NAME_PATTERN: &str = r"^.*/indices/([^/]+).*$";
#[cfg(target_os = "windows")]
const INDEX_NAME_PATTERN: &str = r"^.*\indices\([^\]+).*$";

pub async fn index_exists(index_data_dir: &Path) -> Result<bool, NodeError> {
    if !index_data_dir.exists() {
        return Ok(false);
    }

    let index_mmap_dir = MmapDirectory::open(index_data_dir)
        .map_err(|error| NodeErrorKind::IndexDirectoryCreationFailure.with_error(error))?;

    Index::exists(&index_mmap_dir)
        .map_err(|error| NodeErrorKind::IndexExistenceFailure.with_error(error))
}

pub async fn create_index(
    index_data_dir: &Path,
    schema: &Schema,
    index_settings: &IndexSettings,
    analyzers: &Analyzers,
) -> Result<Index, NodeError> {
    if index_exists(index_data_dir).await? {
        return Err(NodeErrorKind::IndexExists.with_error(anyhow::anyhow!(
            "Index {:?} already exists.",
            index_data_dir
        )));
    }

    fs::create_dir_all(&index_data_dir)
        .await
        .map_err(|error| NodeErrorKind::DirectoryCreationFailure.with_error(error))?;

    // Create directory.
    let index_mmap_dir = MmapDirectory::open(index_data_dir)
        .map_err(|error| NodeErrorKind::IndexDirectoryCreationFailure.with_error(error))?;

    // Create index.
    let index = Index::create(index_mmap_dir, schema.clone(), index_settings.clone())
        .map_err(|error| NodeErrorKind::IndexCreationFailure.with_error(error))?;

    // Register analyzers.
    register(index.tokenizers(), analyzers)
        .map_err(|error| NodeErrorKind::AnalyzerRegistrationFailure.with_error(error))?;

    Ok(index)
}

pub async fn open_index(index_data_dir: &Path, analyzers: &Analyzers) -> Result<Index, NodeError> {
    if !index_exists(index_data_dir).await? {
        return Err(NodeErrorKind::IndexNotFound.with_error(anyhow::anyhow!(
            "Index {:?} does not exist.",
            index_data_dir
        )));
    }

    let index_mmap_dir = MmapDirectory::open(index_data_dir)
        .map_err(|error| NodeErrorKind::DirectoryCreationFailure.with_error(error))?;

    let index = Index::open(index_mmap_dir)
        .map_err(|error| NodeErrorKind::IndexOpenFailure.with_error(error))?;

    // Register analyzers.
    register(index.tokenizers(), analyzers)
        .map_err(|error| NodeErrorKind::AnalyzerRegistrationFailure.with_error(error))?;

    Ok(index)
}

pub async fn delete_index(index_data_dir: &Path) -> Result<(), NodeError> {
    fs::remove_dir_all(index_data_dir)
        .await
        .map_err(|error| NodeErrorKind::IndexDeletionFailure.with_error(error))
}

pub fn extract_index_name(path: &Path) -> Result<String, NodeError> {
    let re = Regex::new(INDEX_NAME_PATTERN)
        .map_err(|error| NodeErrorKind::InvalidPath.with_error(error))?;

    // Get path string.
    let path_str = match path.to_str() {
        Some(path_str) => path_str,
        None => {
            return Err(NodeErrorKind::InvalidPath
                .with_error(anyhow::anyhow!("No index name part in path.")))
        }
    };

    let caps = re.captures(path_str).ok_or_else(|| {
        NodeErrorKind::InvalidPath.with_error(anyhow::anyhow!("Invalid Path: {}.", path_str))
    })?;
    let index_name = caps
        .get(1)
        .ok_or_else(|| {
            NodeErrorKind::InvalidPath.with_error(anyhow::anyhow!("Invalid Path: {}.", path_str))
        })?
        .as_str();

    Ok(index_name.to_string())
}