floria 0.0.5

Floria data system for cloud orchestration
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

use super::{
    super::{
        super::{data::*, entities::*},
        errors::*,
        store::*,
        wrapper::*,
    },
    backend::*,
};

use std::sync::*;

//
// InMemoryStore
//

/// In-memory store.
#[derive(Default, Clone)]
pub struct InMemoryStore {
    /// Backend.
    pub backend: Arc<InMemoryStoreBackend>,
}

impl InMemoryStore {
    /// Constructor.
    pub fn new(backend: Arc<InMemoryStoreBackend>) -> StoreWrapper<Self> {
        StoreWrapper::new(Self { backend })
    }
}

impl Store for InMemoryStore {
    fn create_id(&self, id: &mut ID) -> Result<(), StoreError> {
        let next_id = self.backend.get_next_id(id.kind.clone());
        id.name = next_id.to_string().into();
        Ok(())
    }

    fn get_class(&self, id: &ID) -> Result<Option<Class>, StoreError> {
        Ok(self.backend.classes.pin().get(id).cloned())
    }

    fn add_class(&self, class: Class) -> Result<(), StoreError> {
        self.backend.classes.pin().insert(class.id.clone(), class);
        Ok(())
    }

    fn get_vertex_template(&self, id: &ID) -> Result<Option<VertexTemplate>, StoreError> {
        Ok(self.backend.vertex_templates.pin().get(id).cloned())
    }

    fn add_vertex_template(&self, vertex_template: VertexTemplate) -> Result<(), StoreError> {
        self.backend.vertex_templates.pin().insert(vertex_template.template.id.clone(), vertex_template);
        Ok(())
    }

    fn get_edge_template(&self, id: &ID) -> Result<Option<EdgeTemplate>, StoreError> {
        Ok(self.backend.edge_templates.pin().get(id).cloned())
    }

    fn add_edge_template(&self, edge_template: EdgeTemplate) -> Result<(), StoreError> {
        self.backend.edge_templates.pin().insert(edge_template.template.id.clone(), edge_template);
        Ok(())
    }

    fn get_vertex(&self, id: &ID) -> Result<Option<Vertex>, StoreError> {
        Ok(self.backend.vertexes.pin().get(id).cloned())
    }

    fn get_vertexes(&self, _directories: Option<Vec<Directory>>) -> Result<Vec<Vertex>, StoreError> {
        Ok(self.backend.vertexes.pin().values().cloned().collect())
    }

    fn add_vertex(&self, vertex: Vertex) -> Result<(), StoreError> {
        self.backend.vertexes.pin().insert(vertex.instance.id.clone(), vertex);
        Ok(())
    }

    fn get_edge(&self, id: &ID) -> Result<Option<Edge>, StoreError> {
        Ok(self.backend.edges.pin().get(id).cloned())
    }

    fn add_edge(&self, edge: Edge) -> Result<(), StoreError> {
        self.backend.edges.pin().insert(edge.instance.id.clone(), edge);
        Ok(())
    }
}