harmos-runtime 0.1.13

Harmos runtime: managed state, undo, recovery, background work and typed streams.
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
120
121
122
123
124
125
126
127
128
129
130
131

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports

// Third Party Imports

// Local Imports
use crate::state::support::{Bank, HOUSE, alice, deposit, runtime};
use harmos_runtime::{Application, Runtime, state::Focus, state::ManagedState, state::Never, state::Position};

/* === Constants === */

/* === Macros === */

/* === Type Aliases === */

/* === Structs === */

struct State {
    value: i64,
}
struct Plain;

/* === Enums === */

/* === Traits === */

/* === Implementations === */

#[harmos_runtime::lanes]
pub enum PlainLanes {
    #[default]
    Open,
}
impl harmos_runtime::Lifecycle for Plain {
    type Config = ();
    type Error = std::convert::Infallible;
    type Context = harmos_runtime::Startup<Self>;

    async fn prepare(_: (), _: &mut harmos_runtime::Setup<Self>) -> std::result::Result<Self, Self::Error> {
        Ok(Self)
    }

    async fn initialize(&mut self, _: &Self::Context) -> std::result::Result<(), Self::Error> {
        Ok(())
    }

    async fn stop(&mut self, _: &Self::Context) -> std::result::Result<(), Self::Error> {
        Ok(())
    }

    async fn cleanup(&mut self) -> std::result::Result<(), Self::Error> {
        Ok(())
    }
}

impl Application for Plain {
    type Lanes = PlainLanes;
    type State = State;
    type Transaction = Never;
    type Record = ();
    type Streams = ();
}

/* === Public Functions === */

/* === Private Functions === */

/* === Tests === */

#[tokio::test]
async fn cloned_read_handles() {
    let runtime = runtime().await;
    let manager = runtime.state.as_principal(alice());
    let state: ManagedState<Bank> = manager.state();
    let cloned = state.clone();
    let receipt = manager.clone().commit(deposit(40)).await.unwrap();
    let value = cloned.read(|state| state.balance(HOUSE)).await.unwrap();
    assert_eq!(value.value, 40);
    assert_eq!(value.position, receipt.frontier);

    let undone = manager.undo(alice(), Focus::all()).await.unwrap();
    let value = state.read(|state| state.balance(HOUSE)).await.unwrap();
    assert_eq!(value.value, 0);
    assert_eq!(value.position, undone.frontier);

    let redone = manager.redo(alice(), Focus::all()).await.unwrap();
    let value = cloned.read(|state| state.balance(HOUSE)).await.unwrap();
    assert_eq!(value.value, 40);
    assert_eq!(value.position, redone.frontier);
    runtime.shutdown().await.unwrap();
}

#[tokio::test]
async fn state_survives_stop() {
    let runtime = runtime().await;
    let manager = runtime.state.clone();
    let state = manager.state();
    manager.commit(deposit(7)).await.unwrap();
    let through = runtime.shutdown().await.unwrap();
    assert_eq!(through, Position(1));
    assert!(manager.commit(deposit(1)).await.is_err());
    drop((manager, runtime));
    let value = state.read(|state| state.balance(HOUSE)).await.unwrap();
    assert_eq!(value.value, 7);
    assert_eq!(value.position, through);
}

#[tokio::test]
async fn handles_share_nonclone() {
    let runtime = Runtime::<Plain>::launch(State { value: 19 }, ()).await.unwrap();
    let manager = runtime.state.clone();
    let state = manager.state().clone();
    let value = state.read(|state| state.value).await.unwrap();
    assert_eq!(value.value, 19);
    assert_eq!(value.position, Position::ORIGIN);
    runtime.shutdown().await.unwrap();
}