restate-sdk-shared-core 8.0.0

SDK Shared core
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

use crate::service_protocol::messages::{
    get_state_ephemeral_notification_message, GetStateEphemeralCommandMessage,
    GetStateEphemeralNotificationMessage,
};
use crate::service_protocol::RawMessage;
use crate::vm::context::{Context, EagerGetState};
use crate::vm::errors::{
    EphemeralStateGetWithClosedInput, EMPTY_GET_STATE_EPHEMERAL_NOTIFICATION,
    EPHEMERAL_COMMAND_DURING_REPLAY,
};
use crate::vm::transitions::{Transition, TransitionAndReturn};
use crate::vm::State;
use crate::{EphemeralCompletionId, Error, Value};
use bytes::Bytes;

pub(crate) struct EphemeralStateGet(pub(crate) String);

impl TransitionAndReturn<Context, EphemeralStateGet> for State {
    type Output = EphemeralCompletionId;

    fn transition_and_return(
        mut self,
        context: &mut Context,
        EphemeralStateGet(key): EphemeralStateGet,
    ) -> Result<(Self, Self::Output), Error> {
        match &mut self {
            State::Processing {
                eager_state,
                ephemeral_commands,
                ..
            } => {
                match eager_state.get(&key) {
                    EagerGetState::Value(v) => {
                        let completion_id = ephemeral_commands.next_completion_id();
                        ephemeral_commands.register_ready(completion_id, Value::Success(v));
                        Ok((self, completion_id.into()))
                    }
                    EagerGetState::Empty => {
                        let completion_id = ephemeral_commands.next_completion_id();
                        ephemeral_commands.register_ready(completion_id, Value::Void);
                        Ok((self, completion_id.into()))
                    }
                    EagerGetState::Unknown => {
                        if context.input_is_closed {
                            // The runtime can't answer anymore.
                            return Err(EphemeralStateGetWithClosedInput::new(key).into());
                        }
                        let completion_id = ephemeral_commands.next_completion_id();
                        ephemeral_commands.register_in_flight(completion_id);
                        context.output.send(&GetStateEphemeralCommandMessage {
                            ephemeral_completion_id: completion_id,
                            key: Bytes::from(key),
                        });
                        Ok((self, completion_id.into()))
                    }
                }
            }
            State::Replaying { .. } => Err(EPHEMERAL_COMMAND_DURING_REPLAY),
            s => Err(s.as_unexpected_state("SysEphemeralStateGet")),
        }
    }
}

pub(crate) struct NewGetStateEphemeralNotificationMessage(pub(crate) RawMessage);

impl Transition<Context, NewGetStateEphemeralNotificationMessage> for State {
    fn transition(
        mut self,
        _: &mut Context,
        NewGetStateEphemeralNotificationMessage(msg): NewGetStateEphemeralNotificationMessage,
    ) -> Result<Self, Error> {
        match &mut self {
            State::Processing {
                ephemeral_commands, ..
            } => {
                let msg = msg.decode_to::<GetStateEphemeralNotificationMessage>(0)?;
                let value = match msg.result.ok_or(EMPTY_GET_STATE_EPHEMERAL_NOTIFICATION)? {
                    get_state_ephemeral_notification_message::Result::Void(_) => Value::Void,
                    get_state_ephemeral_notification_message::Result::Value(v) => {
                        Value::Success(v.content)
                    }
                };
                ephemeral_commands.complete(msg.ephemeral_completion_id, value);
            }
            State::Closed => {
                // Can ignore
            }
            s => return Err(s.as_unexpected_state("NewGetStateEphemeralNotificationMessage")),
        };
        Ok(self)
    }
}

pub(crate) struct TakeEphemeralNotification(pub(crate) EphemeralCompletionId);

impl TransitionAndReturn<Context, TakeEphemeralNotification> for State {
    type Output = Option<Value>;

    fn transition_and_return(
        mut self,
        _: &mut Context,
        TakeEphemeralNotification(completion_id): TakeEphemeralNotification,
    ) -> Result<(Self, Self::Output), Error> {
        match &mut self {
            State::Processing {
                ephemeral_commands, ..
            } => {
                let value = ephemeral_commands.take_notification(completion_id);
                Ok((self, value))
            }
            s => Err(s.as_unexpected_state("TakeEphemeralNotification")),
        }
    }
}