a3s-runtime 0.2.0

Provider-neutral execution contract and client for A3S runtimes
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

mod file;
mod record;

use crate::contract::{
    RuntimeActionRequest, RuntimeApplyRequest, RuntimeExecRequest, RuntimeExecResult,
    RuntimeObservation, RuntimeRemoval,
};
use crate::RuntimeResult;
use async_trait::async_trait;

pub use file::FileRuntimeStateStore;
pub use record::{
    RuntimeActionKind, RuntimeRequestKind, RuntimeRequestReceipt, RuntimeRequestState,
    RuntimeStateReservation, RuntimeUnitRecord,
};

#[cfg(test)]
mod transition_tests;

/// Owned guard for one unit's cross-process operation lease. Implementations
/// release the lease when the guard is dropped.
pub trait RuntimeOperationLease: Send {}

#[async_trait]
pub trait RuntimeStateStore: Send + Sync {
    async fn acquire_operation_lease(
        &self,
        unit_id: &str,
    ) -> RuntimeResult<Box<dyn RuntimeOperationLease>>;

    async fn reserve_apply(
        &self,
        request: &RuntimeApplyRequest,
        now_ms: u64,
    ) -> RuntimeResult<RuntimeStateReservation>;

    async fn reserve_action(
        &self,
        kind: RuntimeActionKind,
        request: &RuntimeActionRequest,
        now_ms: u64,
    ) -> RuntimeResult<RuntimeStateReservation>;

    async fn reserve_exec(
        &self,
        request: &RuntimeExecRequest,
        now_ms: u64,
    ) -> RuntimeResult<RuntimeStateReservation>;

    async fn load(&self, unit_id: &str) -> RuntimeResult<RuntimeUnitRecord>;

    async fn load_request(
        &self,
        unit_id: &str,
        request_id: &str,
    ) -> RuntimeResult<RuntimeRequestReceipt>;

    async fn update_observation(
        &self,
        request_id: Option<&str>,
        observation: &RuntimeObservation,
    ) -> RuntimeResult<RuntimeUnitRecord>;

    async fn complete_removal(&self, removal: &RuntimeRemoval) -> RuntimeResult<RuntimeUnitRecord>;

    async fn complete_exec(&self, result: &RuntimeExecResult) -> RuntimeResult<RuntimeUnitRecord>;
}