esdiag 0.16.4

Elastic Stack diagnostic collector and processor
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

// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
// or more contributor license agreements. Licensed under the Elastic License 2.0;
// you may not use this file except in compliance with the Elastic License 2.0.

use super::{
    super::{Lookup, data_stream::DataStreamDocument, ilm_explain::IlmStats},
    IndexSettings, IndicesSettings, StoreSettings,
};
use eyre::Result;
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;

impl From<IndicesSettings> for Lookup<IndexSettings> {
    fn from(mut indices_settings: IndicesSettings) -> Self {
        let mut lookup = Lookup::<IndexSettings>::new();
        indices_settings.drain().for_each(|(name, settings)| {
            let index_settings = settings.settings.index.name(name.clone()).build();
            let id = index_settings.uuid.clone();
            lookup.add(index_settings).with_name(&name).with_id(&id);
        });
        lookup
    }
}

impl From<Result<IndicesSettings>> for Lookup<IndexSettings> {
    fn from(indices_settings: Result<IndicesSettings>) -> Self {
        match indices_settings {
            Ok(indices_settings) => Lookup::<IndexSettings>::from_parsed(indices_settings),
            Err(e) => {
                tracing::warn!("Failed to parse IndicesSettings: {}", e);
                Lookup::new()
            }
        }
    }
}

#[skip_serializing_none]
#[derive(Clone, Deserialize, Serialize)]
pub struct IndexSettingsDocument {
    pub age: Option<u64>,
    pub codec: String,
    pub creation_date: u64,
    pub data_stream: Option<DataStreamDocument>,
    pub lifecycle: Option<Box<serde_json::value::RawValue>>,
    pub ilm: Option<IlmStats>,
    pub is_write_index: Option<bool>,
    pub mode: String,
    pub name: String,
    pub store: Option<StoreSettings>,
    pub number_of_shards: Option<u64>,
    pub number_of_replicas: Option<u64>,
    pub refresh_interval: String,
    pub source: Option<String>,
    pub write_phase_sec: Option<u64>,
    pub uuid: String,
}

impl IndexSettingsDocument {
    pub fn ilm(self, ilm: Option<IlmStats>) -> Self {
        Self { ilm, ..self }
    }

    pub fn write_phase(self, write_phase_sec: Option<u64>) -> Self {
        Self {
            write_phase_sec,
            ..self
        }
    }
}

impl From<IndexSettings> for IndexSettingsDocument {
    fn from(index_settings: IndexSettings) -> Self {
        IndexSettingsDocument {
            age: index_settings.age,
            codec: index_settings.codec,
            creation_date: index_settings.creation_date.unwrap_or(0),
            data_stream: index_settings.data_stream,
            lifecycle: index_settings.lifecycle,
            ilm: None,
            is_write_index: Some(index_settings.is_write_index),
            mode: index_settings.mode,
            name: index_settings.name.expect("Name is required"),
            store: index_settings.store,
            number_of_shards: index_settings.number_of_shards,
            number_of_replicas: index_settings.number_of_replicas,
            refresh_interval: index_settings.refresh_interval,
            source: index_settings.source,
            write_phase_sec: None,
            uuid: index_settings.uuid,
        }
    }
}