boardwalk 1.0.0

Hypermedia server framework with reverse-tunnel federation
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

use std::collections::BTreeMap;

use serde_json::{Map, Value as Json};

use crate::runtime::{
    Actor, DynFuture, Resource, ResourceCtx, ResourceError, ResourceSnapshot, ResourceSpec,
    SnapshotStreamSpec, StreamKind, StreamSpec, TransitionAffordance, TransitionCtx,
    TransitionError, TransitionInput, TransitionOutcome, TransitionSpec,
};

#[derive(Default)]
pub(crate) struct ActorLed {
    on: bool,
}

impl ActorLed {
    fn snapshot(&self) -> ResourceSnapshot {
        let state = if self.on { "on" } else { "off" };
        let mut properties = Map::new();
        properties.insert("fixture".into(), Json::String("actor-led".into()));

        ResourceSnapshot {
            id: "runtime-assigned".into(),
            kind: "led".into(),
            name: Some("LED".into()),
            state: Some(state.into()),
            node: "runtime-assigned".into(),
            properties,
            labels: BTreeMap::new(),
            transitions: vec![
                TransitionAffordance {
                    spec: TransitionSpec {
                        name: "turn-on".into(),
                        allowed_states: vec!["off".into()],
                        ..Default::default()
                    },
                    available: !self.on,
                    unavailable_reason: self.on.then_some("already on".into()),
                },
                TransitionAffordance {
                    spec: TransitionSpec {
                        name: "turn-off".into(),
                        allowed_states: vec!["on".into()],
                        ..Default::default()
                    },
                    available: self.on,
                    unavailable_reason: (!self.on).then_some("already off".into()),
                },
            ],
            streams: vec![SnapshotStreamSpec {
                name: "state".into(),
                kind: "object".into(),
            }],
            revision: None,
            metadata: Map::new(),
        }
    }
}

impl Resource for ActorLed {
    fn spec(&self) -> ResourceSpec {
        ResourceSpec {
            kind: "led".into(),
            name: Some("LED".into()),
            labels: BTreeMap::new(),
            property_schema: None,
            streams: vec![StreamSpec {
                name: "state".into(),
                kind: StreamKind::Object,
            }],
        }
    }

    fn snapshot<'a>(
        &'a self,
        _ctx: ResourceCtx,
    ) -> DynFuture<'a, Result<ResourceSnapshot, ResourceError>> {
        Box::pin(async move { Ok(self.snapshot()) })
    }
}

impl Actor for ActorLed {
    fn transition<'a>(
        &'a mut self,
        ctx: TransitionCtx,
        name: &'a str,
        _input: TransitionInput,
    ) -> DynFuture<'a, Result<TransitionOutcome, TransitionError>> {
        Box::pin(async move {
            match name {
                "turn-on" if !self.on => self.on = true,
                "turn-off" if self.on => self.on = false,
                other => {
                    return Err(TransitionError::NotAllowed(format!(
                        "transition `{other}` is not available"
                    )));
                }
            }

            let state = if self.on { "on" } else { "off" };
            ctx.publish(
                "state",
                "resource.state.changed",
                1,
                Json::String(state.into()),
            )
            .await?;

            Ok(TransitionOutcome::Completed {
                output: None,
                snapshot: self.snapshot(),
            })
        })
    }
}