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

use super::super::{
    super::{data::*, errors::*, plugins::*, store::*},
    vertex::*,
    vertex_template::*,
};

use kutil::std::error::*;

impl VertexTemplate {
    /// Instantiate.
    pub fn instantiate<StoreT, ErrorReceiverT>(
        &self,
        directory: &Directory,
        containing_vertex_id: Option<ID>,
        library: &mut Library<StoreT>,
        errors: &mut ErrorReceiverT,
    ) -> Result<Vertex, FloriaError>
    where
        StoreT: Clone + Send + Store,
        ErrorReceiverT: ErrorReceiver<FloriaError>,
    {
        let vertex_id = self.instantiate_vertexes(directory, containing_vertex_id, library, errors)?;
        let vertex = library.store.get_vertex(&vertex_id)?.ok_or_else(|| StoreError::ID(vertex_id.to_string()))?;

        vertex.instantiate_edges(directory, library, errors)?;

        Ok(vertex)
    }

    /// Instantiate vertexes.
    pub fn instantiate_vertexes<StoreT, ErrorReceiverT>(
        &self,
        directory: &Directory,
        containing_vertex_id: Option<ID>,
        library: &mut Library<StoreT>,
        errors: &mut ErrorReceiverT,
    ) -> Result<ID, FloriaError>
    where
        StoreT: Store,
        ErrorReceiverT: ErrorReceiver<FloriaError>,
    {
        let mut vertex = Vertex {
            instance: self.template.instantiate(EntityKind::Vertex, directory, &library.store)?,
            containing_vertex_id: containing_vertex_id,
            contained_vertex_ids: Vec::with_capacity(self.contained_vertex_template_ids.len()),
            outgoing_edge_ids: Default::default(),
            incoming_edge_ids: Default::default(),
        };

        let vertex_id = vertex.instance.id.clone();

        for contained_vertex_template_id in &self.contained_vertex_template_ids {
            match library.store.get_vertex_template(contained_vertex_template_id)? {
                Some(contained_vertex_template) => {
                    let contained_vertex_id = contained_vertex_template.instantiate_vertexes(
                        directory,
                        Some(vertex_id.clone()),
                        library,
                        errors,
                    )?;
                    vertex.contained_vertex_ids.push(contained_vertex_id);
                }

                None => tracing::warn!("vertex template not found: {}", contained_vertex_template_id),
            }
        }

        library.store.add_vertex(vertex)?;

        Ok(vertex_id)
    }
}