meerkat-machine-schema 0.8.13

Formal machine schemas and transition definitions for Meerkat
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

use meerkat_machine_dsl::machine;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub enum SessionPersistenceVersionField {
    #[default]
    SessionEnvelope,
    StoredInputState,
    SessionMetadataSchema,
}

machine! {
    machine SessionPersistenceVersionAuthorityMachine {
        version: 1,
        rust: "self" / "catalog::dsl::session_persistence_version_authority",

        state {
            lifecycle_phase: SessionPersistenceVersionAuthorityPhase,
            session_envelope_version: u64,
            stored_input_state_version: u64,
            stored_input_state_migration_v4: u64,
            stored_input_state_released_v3: u64,
            session_metadata_schema_version: u64,
        }

        init(Ready) {
            session_envelope_version = 3,
            stored_input_state_version = 5,
            stored_input_state_migration_v4 = 4,
            stored_input_state_released_v3 = 3,
            session_metadata_schema_version = 2,
        }

        terminal []

        phase SessionPersistenceVersionAuthorityPhase {
            Ready,
        }

        input SessionPersistenceVersionAuthorityInput {
            RestoreSessionEnvelopeVersion { persisted_version: u64 },
            RestoreStoredInputStateVersion { persisted_version: u64 },
            RestoreSessionMetadataSchemaVersion { persisted_version: u64 },
        }

        effect SessionPersistenceVersionAuthorityEffect {
            VersionRestoreAuthorized {
                field: Enum<SessionPersistenceVersionField>,
                version: u64,
            },
        }

        disposition VersionRestoreAuthorized => local seam NoOwnerRealization,

        transition RestoreCurrentSessionEnvelopeVersion {
            on input RestoreSessionEnvelopeVersion { persisted_version }
            guard {
                self.lifecycle_phase == Phase::Ready
                && persisted_version == self.session_envelope_version
            }
            update {}
            to Ready
            emit VersionRestoreAuthorized {
                field: SessionPersistenceVersionField::SessionEnvelope,
                version: self.session_envelope_version
            }
        }

        transition RestoreCurrentStoredInputStateVersion {
            on input RestoreStoredInputStateVersion { persisted_version }
            guard {
                self.lifecycle_phase == Phase::Ready
                && persisted_version == self.stored_input_state_version
            }
            update {}
            to Ready
            emit VersionRestoreAuthorized {
                field: SessionPersistenceVersionField::StoredInputState,
                version: self.stored_input_state_version
            }
        }

        transition MigrateStoredInputStateV4ToV5 {
            on input RestoreStoredInputStateVersion { persisted_version }
            guard {
                self.lifecycle_phase == Phase::Ready
                && persisted_version == self.stored_input_state_migration_v4
            }
            update {}
            to Ready
            emit VersionRestoreAuthorized {
                field: SessionPersistenceVersionField::StoredInputState,
                version: self.stored_input_state_version
            }
        }

        transition MigrateReleasedStoredInputStateV3ToV5 {
            on input RestoreStoredInputStateVersion { persisted_version }
            guard {
                self.lifecycle_phase == Phase::Ready
                && persisted_version == self.stored_input_state_released_v3
            }
            update {}
            to Ready
            emit VersionRestoreAuthorized {
                field: SessionPersistenceVersionField::StoredInputState,
                version: self.stored_input_state_version
            }
        }

        transition RestoreCurrentSessionMetadataSchemaVersion {
            on input RestoreSessionMetadataSchemaVersion { persisted_version }
            guard {
                self.lifecycle_phase == Phase::Ready
                && persisted_version == self.session_metadata_schema_version
            }
            update {}
            to Ready
            emit VersionRestoreAuthorized {
                field: SessionPersistenceVersionField::SessionMetadataSchema,
                version: self.session_metadata_schema_version
            }
        }
    }
}