selium-kernel 1.0.0-alpha.6

Streaming compute fabric
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

//! Hostcall drivers for singleton dependency registration and lookup.

use std::{
    future::{Future, ready},
    sync::Arc,
};

use wasmtime::Caller;

use crate::{
    guest_data::{GuestError, GuestResult},
    operation::{Contract, Operation},
    registry::InstanceRegistry,
};
use selium_abi::{GuestResourceId, SingletonLookup, SingletonRegister};

type SingletonOps = (
    Arc<Operation<SingletonRegisterDriver>>,
    Arc<Operation<SingletonLookupDriver>>,
);

/// Hostcall driver that registers singleton dependencies.
pub struct SingletonRegisterDriver;
/// Hostcall driver that looks up singleton dependencies.
pub struct SingletonLookupDriver;

impl Contract for SingletonRegisterDriver {
    type Input = SingletonRegister;
    type Output = ();

    fn to_future(
        &self,
        caller: &mut Caller<'_, InstanceRegistry>,
        input: Self::Input,
    ) -> impl Future<Output = GuestResult<Self::Output>> + 'static {
        let registry = caller.data().registry_arc();
        let SingletonRegister { id, resource } = input;

        ready((|| -> GuestResult<Self::Output> {
            let resource_id = registry
                .resolve_shared(resource)
                .ok_or(GuestError::NotFound)?;
            registry.metadata(resource_id).ok_or(GuestError::NotFound)?;
            let inserted = registry.register_singleton(id, resource_id)?;
            if !inserted {
                return Err(GuestError::StableIdExists);
            }
            Ok(())
        })())
    }
}

impl Contract for SingletonLookupDriver {
    type Input = SingletonLookup;
    type Output = GuestResourceId;

    fn to_future(
        &self,
        caller: &mut Caller<'_, InstanceRegistry>,
        input: Self::Input,
    ) -> impl Future<Output = GuestResult<Self::Output>> + 'static {
        let registry = caller.data().registry_arc();
        let SingletonLookup { id } = input;

        ready((|| -> GuestResult<Self::Output> {
            let resource_id = registry.singleton(id).ok_or(GuestError::NotFound)?;
            registry.metadata(resource_id).ok_or(GuestError::NotFound)?;
            registry.share_handle(resource_id).map_err(GuestError::from)
        })())
    }
}

/// Build hostcall operations for singleton registration and lookup.
pub fn operations() -> SingletonOps {
    (
        Operation::from_hostcall(
            SingletonRegisterDriver,
            selium_abi::hostcall_contract!(SINGLETON_REGISTER),
        ),
        Operation::from_hostcall(
            SingletonLookupDriver,
            selium_abi::hostcall_contract!(SINGLETON_LOOKUP),
        ),
    )
}