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

use async_trait::async_trait;
use std::collections::HashSet;
use std::fmt::Debug;
use std::sync::Arc;

use tokio::sync::oneshot;

use crate::moiradb::MoiraDb;
pub type DBValue<V> = Arc<Option<V>>;

pub type Block<K, C> = Vec<Arc<Transaction<K, C>>>;

#[async_trait]
pub trait Command<K, V>
where
    K: Debug,
    V: Debug,
    Self: Debug,
{
    async fn execute(&self, db: &mut MoiraDb<K, V, Self>) -> TransactionResult;

    fn merge_operator(_key: &K, _prev_value: DBValue<V>, _updates: Vec<DBValue<V>>) -> DBValue<V> {
        unimplemented!();
    }
}

pub trait MergeCommand<K, V>: Command<K, V>
where
    K: Debug,
    V: Debug,
    Self: Debug,
{
}

#[derive(Debug, PartialEq, Clone, Copy)]
pub enum ExecState {
    Abort,
    Commit,
    Merge,
    NoWrite,
    Pending,
    Reschedule,
}

#[derive(Debug)]
pub struct Entry<K, V, C> {
    pub transaction: Arc<Transaction<K, C>>,
    pub state: ExecState,
    pub value: Option<DBValue<V>>,
    pub futures: Vec<oneshot::Sender<(Vec<DBValue<V>>, DBValue<V>)>>,
}

#[derive(Debug)]
pub enum MoiraCommand<K, V, C>
where
    C: ?Sized + Debug,
    K: Debug,
    V: Debug,
{
    Read(K, u64, oneshot::Sender<(Vec<DBValue<V>>, DBValue<V>)>),
    Outcome(MoiraDb<K, V, C>),
}

#[derive(Debug)]
pub struct Transaction<K, C: ?Sized> {
    pub seq: u64,
    pub write_set: HashSet<K>,
    pub command: C,
}

#[derive(Debug, PartialEq)]
pub enum TransactionResult {
    Commit,
    Abort(String),
    Reschedule,
}