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

use super::{
    super::{
        super::{data::*, errors::*, store::*},
        bindings::floria::plugins::floria as bindings,
    },
    host::*,
};

use {depiction::*, kutil::std::error::*};

impl<StoreT> bindings::Host for PluginHost<StoreT>
where
    StoreT: Clone + Send + Store,
{
    fn log(&mut self, source: String, message: String) -> wasmtime::Result<()> {
        tracing::info!("[{}] {}: {}", self.name, source, message);
        Ok(())
    }

    fn evaluate_expression(
        &mut self,
        expression: bindings::Expression,
        call_site: bindings::CallSite,
    ) -> wasmtime::Result<Result<Option<bindings::Expression>, String>> {
        Ok(self._evaluate_expression(expression, call_site).map_err(|error| error.to_string()))
    }

    fn get_entity(&mut self, id: bindings::Id) -> wasmtime::Result<Result<bindings::Entity, String>> {
        Ok(self._get_entity(id).map_err(|error| error.to_string()))
    }
}

impl<StoreT> PluginHost<StoreT>
where
    StoreT: Clone + Send + Store,
{
    fn _evaluate_expression(
        &mut self,
        expression: bindings::Expression,
        call_site: bindings::CallSite,
    ) -> Result<Option<bindings::Expression>, FloriaError> {
        // TODO: also need to make sure we're not calling into same plugin

        let mut expression = self.expression_from_bindings(expression)?;
        if let Expression::Call(call) = &mut expression {
            call.kind = CallKind::Eager;
        }

        Ok(match expression.evaluate(&call_site.into(), &mut self.library, &mut FailFastErrorReceiver)? {
            Some(expression) => Some(self.expression_to_bindings(expression)?),
            None => None,
        })
    }

    fn _get_entity(&mut self, id: bindings::Id) -> Result<bindings::Entity, FloriaError> {
        let id: ID = id.into();

        let entity: Option<bindings::Entity> = match id.kind {
            EntityKind::Vertex => match self.library.store.get_vertex(&id)? {
                Some(vertex) => Some(self.vertex_to_bindings(vertex)?.into()),
                None => None,
            },

            EntityKind::Edge => match self.library.store.get_edge(&id)? {
                Some(edge) => Some(self.edge_to_bindings(edge)?.into()),
                None => None,
            },

            _ => todo!(),
        };

        match entity {
            Some(entity) => Ok(entity),
            None => {
                // TODO: new error type
                Err(FloriaError::Instantiation(format!("entity not found: |error|{}|", escape_depiction_markup(id))))
            }
        }
    }
}