jupiter 4.1.0

Jupiter is a library for providing high-throughput ultra low latency services via the RESP protocol as defined by Redis.
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

//! Imports JSON files into InfoGraph DB.
//!
//! ## Example data:
//! ```json
//! [
//!     {"name": "test", "unit": "PCE"},
//!     {"name": "foo", "unit": "MTR"},
//! ]
//! ```
//! ## Example loader:
//! ```yaml
//! file: 'path/to/file.json'
//! loader: 'idb-json'
//! namespace: 'target namespace to import into'
//! table: 'target-table-name'
//! indices: ['fields', 'to', 'index']
//! fulltextIndices: ['fields', 'to', 'search', 'in']
//! ```
use crate::ig::json::list_to_doc;
use crate::platform::Platform;
use crate::repository::loader::{Loader, LoaderInfo};
use anyhow::Context;
use serde_json::Value;
use std::fmt::{Display, Formatter};
use std::sync::Arc;

/// Represents the global loader instance.
pub struct IdbJsonLoader {
    platform: Arc<Platform>,
}

impl IdbJsonLoader {
    /// Creates a new loader to be passed into [Repository::register_loader].
    pub fn new(platform: Arc<Platform>) -> Self {
        IdbJsonLoader { platform }
    }
}

impl Display for IdbJsonLoader {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "IDB-JSON")
    }
}

#[async_trait::async_trait]
impl Loader for IdbJsonLoader {
    async fn file_changed(&self, loader_info: &LoaderInfo) -> anyhow::Result<()> {
        let data = loader_info.get_data_str().await?;
        let rows: Value =
            serde_json::from_str(data.as_str()).context("Cannot parse the given JSON data.")?;
        let doc = list_to_doc(rows.as_array().context("The given JSON wasn't an array.")?)
            .context("Cannot transform JSON to doc")?;

        self.update_table(doc, loader_info).await
    }

    fn platform(&self) -> &Arc<Platform> {
        &self.platform
    }
}