zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
Documentation 
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
125
126
127
128

use elasticsearch::auth::Credentials;
use elasticsearch::http::transport::Transport;
use elasticsearch::Elasticsearch;

use handlebars::Handlebars;

use crate::commons::json_value_to_generic2;

use crate::core::elasticsearch::EsClient;
use crate::core::http_clients::HttpClient;

const RESOURCE_FOLDER_DSL: &str = "./resources/es_dsl";
const RESOURCE_FOLDER_MAPPINGS: &str = "./resources/es_mappings";

use crate::core::error2::Error;
use crate::core::error2::Result;

pub async fn create_single_node(
    settings: &crate::core::elasticsearch::ElasticsearchSettings,
) -> Result<EsClient> {
    let server = settings.server.clone().unwrap();

    match Transport::single_node(&server) {
        Ok(transport) => {
            let h = handlebars(&String::from(RESOURCE_FOLDER_DSL));
            log::info!("Elasticsearch_initialize_completed: server={}", server);

            let es_client = EsClient {
                server: server.to_string(),
                client: Elasticsearch::new(transport),
                handlebars: h,
                request: HttpClient::build(5),
            };

            es_client.build_mappings(RESOURCE_FOLDER_MAPPINGS).await;

            Ok(es_client)
        }
        Err(e) => {
            log::error!(
                "Elasticsearch_initialize_failed: server={}, error={:?}",
                server,
                e
            );
            Err(Error::UnexpectedError(anyhow::anyhow!(e)))
        }
    }
}

pub async fn create_cluster() -> Result<EsClient> {
    let server = "http://localhost:9200";

    let user = "";
    let pass = "";
    let credentials = Credentials::Basic(user.to_string(), pass.to_string());

    match Transport::cloud(server, credentials) {
        Ok(transport) => {
            let h = handlebars(&String::from(RESOURCE_FOLDER_DSL));
            log::info!("Elasticsearch_initialize_successful: server={}", server);

            let es_client = EsClient {
                server: server.to_string(),
                client: Elasticsearch::new(transport),
                handlebars: h,
                request: HttpClient::build(5),
            };

            es_client.build_mappings(RESOURCE_FOLDER_MAPPINGS).await;

            Ok(es_client)
        }
        Err(e) => {
            log::error!(
                "Elasticsearch_initialize_failed: server={}, error={:?}",
                server,
                e
            );
            Err(Error::UnexpectedError(anyhow::anyhow!(e)))
        }
    }
}

// https://handlebarsjs.com/guide/builtin-helpers.html#if
pub fn handlebars(_dsl_template_location: &str) -> Handlebars<'static> {
    let _dsl_template_location =
        std::path::PathBuf::from(crate::commons::service_home()).join(_dsl_template_location);

    let mut handlebars = Handlebars::new();

    handlebars.set_strict_mode(false);

    if _dsl_template_location.exists() {
        let dsl_files = crate::commons::list_files(_dsl_template_location, "yaml").unwrap();

        for file in dsl_files {
            let _m2: serde_json::Map<String, serde_json::Value> = match serde_any::from_file(&file)
            {
                Ok(map) => {
                    for (key, value) in &map {
                        let source = json_value_to_generic2::<String>(value).unwrap();
                        #[allow(clippy::useless_format)]
                        let _key = format!("{}", key);
                        handlebars.register_template_string(&_key, source).unwrap();
                    }
                    map
                }
                Err(e) => {
                    log::info!(
                        "Elasticsearch-Read-YAML-Error: path={}, error={:?}",
                        &file.to_str().unwrap(),
                        e
                    );
                    serde_json::Map::new()
                }
            };
        }
    } else {
        log::warn!(
            "Elasticsearch-dsl-folder-not-exists: path={}",
            _dsl_template_location.to_str().unwrap()
        )
    }

    handlebars.set_strict_mode(true);

    handlebars
}