gun 0.1.2

The Gun database, in Rust
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

use anyhow::{anyhow, Result};
use serde_json::{json, Value};

use crate::util::{timestamp, SOUL, METADATA, STATE};

struct HAM {
	converge: bool,
	current: bool,
	defer: bool,
	historical: bool,
	incoming: bool,
	state: bool,
}

impl Default for HAM {
	fn default() -> Self {
		Self {
			converge: false,
			current: false,
			defer: false,
			historical: false,
			incoming: false,
			state: false,
		}
	}
}

fn ham(
	machine_state: u64,
	incoming_state: u64,
	current_state: u64,
	incoming_value: &str,
	current_value: &str,
) -> Result<HAM> {
	if machine_state < incoming_state {
        return Ok(HAM { defer: true, ..Default::default() });
    } else if incoming_state < current_state {
        return Ok(HAM { historical: true, ..Default::default() });
    } else if current_state < incoming_state {
        return Ok(HAM { converge: true, incoming: true, ..Default::default() });
    } else if incoming_state == current_state {
        if incoming_value == current_value {
        	return Ok(HAM { state: true, ..Default::default() });
        } else if incoming_value < current_value {
            return Ok(HAM { converge: true, current: true, ..Default::default() });
        } else if current_value < incoming_value {
            return Ok(HAM { converge: true, incoming: true, ..Default::default() });
        }
    }

    Err(anyhow!("Invalid CRDT Data: {} to {} at {} to {}!",
    	incoming_value, current_value, incoming_state, current_state))
}

pub fn mix_ham(change: Value, graph: &mut Value) -> Value {
	let machine = timestamp();
	let mut diff = json!({});

	for (soul, node) in change.as_object().unwrap().iter() {
		for (key, val) in node.as_object().unwrap().iter() {
			if let SOUL | METADATA | STATE = &key[..] {
				continue;
			}

			let state = node[METADATA][STATE][key].as_u64().unwrap();
			let was = match graph.get(soul) {
				Some(node) => match node[METADATA][STATE].get(key) {
					Some(val) => val.as_u64().unwrap(),
					None => 0,
				},
				None => 0,
			};
			let val = val.to_string();
			let known = match graph.get(soul) {
				Some(node) => node[key].to_string(),
				None => "".to_owned(),
			};

			let ham = match ham(machine, state, was, &val, &known) {
				Ok(ham) => ham,
				Err(err) => {
					log::error!("{}", err);
					continue;
				},
			};

			if !ham.incoming {
				if ham.defer {
					log::info!("DEFER {} {}", key, val);
				}
				continue;
			}

			if graph[soul].is_null() {
				graph[soul] = json!({METADATA: {SOUL: soul, STATE: {}}});
			}

			if diff[soul].is_null() {
				diff[soul] = json!({METADATA: {SOUL: soul, STATE: {}}});
			}

			graph[soul][key] = json!(val);
			diff[soul][key] = json!(val);

			graph[soul][METADATA][STATE][key] = json!(state);
			diff[soul][METADATA][STATE][key] = json!(state);
   		}
	}

	diff
}