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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::super::{super::store::*, bindings, errors::*, host::*, library::*};

use {anyhow::Context, kutil::std::immutable::*, std::path, wasmtime::component::*};

//
// DispatchPlugin
//

/// Floria dispatch plugin.
pub struct DispatchPlugin<StoreT>
where
    StoreT: 'static + Store,
{
    /// Name.
    pub name: ByteString,

    /// Host
    pub host: wasmtime::Store<PluginHost<StoreT>>,

    /// Bindings.
    pub bindings: bindings::DispatchPlugin,
}

impl<StoreT> DispatchPlugin<StoreT>
where
    StoreT: Clone + Send + Store,
{
    /// Constructor.
    pub fn new(
        name: ByteString,
        host: wasmtime::Store<PluginHost<StoreT>>,
        bindings: bindings::DispatchPlugin,
    ) -> Self {
        Self { name, host, bindings }
    }

    /// Constructor.
    pub fn new_from_component(
        component: Component,
        name: ByteString,
        library: &Library<StoreT>,
    ) -> Result<Self, PluginError> {
        // Host
        let mut host =
            wasmtime::Store::new(&library.environment.engine, PluginHost::new(name.clone(), library.clone()));

        // Linker

        let mut linker = Linker::new(&library.environment.engine);

        wasmtime_wasi::p2::add_to_linker_sync(&mut linker)
            .context("adding WASI bindings")
            .map_err(PluginError::LinkWasm)?;

        bindings::DispatchPlugin::add_to_linker::<_, HasSelf<_>>(&mut linker, |state: &mut PluginHost<StoreT>| state)
            .context("adding dispatch plugin bindings")
            .map_err(PluginError::LinkWasm)?;

        // Bindings
        let bindings = bindings::DispatchPlugin::instantiate(&mut host, &component, &linker)
            .context("instantiating dispatch plugin bindings")
            .map_err(PluginError::InstantiateWasm)?;

        Ok(Self::new(name, host, bindings))
    }

    /// Constructor.
    ///
    /// Make sure you trust the component when precompiled is true!
    pub fn new_from_bytes(
        bytes: &[u8],
        precompiled: bool,
        name: ByteString,
        library: &Library<StoreT>,
    ) -> Result<Self, PluginError> {
        let component = if precompiled {
            // SAFETY: we are assuming the precompiled .cwasm is safe!
            unsafe {
                Component::deserialize(&library.environment.engine, bytes)
                    .context("loading precompiled Wasm component from bytes")
                    .map_err(PluginError::LoadWasm)?
            }
        } else {
            Component::from_binary(&library.environment.engine, bytes)
                .context("loading Wasm component from bytes")
                .map_err(PluginError::LoadWasm)?
        };

        Self::new_from_component(component, name, library)
    }

    /// Constructor.
    ///
    /// Make sure you trust the component when precompiled is true!
    pub fn new_from_file<PathT>(
        path: PathT,
        precompiled: bool,
        name: ByteString,
        library: &Library<StoreT>,
    ) -> Result<Self, PluginError>
    where
        PathT: AsRef<path::Path>,
    {
        let component = if precompiled {
            // SAFETY: we are assuming the precompiled .cwasm is safe!
            unsafe {
                Component::deserialize_file(&library.environment.engine, path)
                    .context("loading precompiled Wasm component from file")
                    .map_err(PluginError::LoadWasm)?
            }
        } else {
            Component::from_file(&library.environment.engine, path)
                .context("loading Wasm component from file")
                .map_err(PluginError::LoadWasm)?
        };

        Self::new_from_component(component, name, library)
    }
}