ThetaDev/automerge
1
0
Fork 0
Code Issues Pull requests Projects Releases Activity

Move sync structs to module

Browse source
This commit is contained in:
Andrew Jeffery 2022-03-09 12:43:52 +00:00 • committed by Orion Henry
parent aad4852e30
commit b14d874dfc
7 changed files with 47 additions and 49 deletions

22
automerge-wasm/src/interop.rs
View file

@ -25,8 +25,8 @@ impl From<JS> for JsValue {
}
}
impl From<am::SyncState> for JS {
fn from(state: am::SyncState) -> Self {
impl From<am::sync::State> for JS {
fn from(state: am::sync::State) -> Self {
let shared_heads: JS = state.shared_heads.into();
let last_sent_heads: JS = state.last_sent_heads.into();
let their_heads: JS = state.their_heads.into();
@ -133,7 +133,7 @@ impl TryFrom<JS> for Vec<Change> {
}
}
impl TryFrom<JS> for am::SyncState {
impl TryFrom<JS> for am::sync::State {
type Error = JsValue;
fn try_from(value: JS) -> Result<Self, Self::Error> {
@ -144,7 +144,7 @@ impl TryFrom<JS> for am::SyncState {
let their_need = js_get(&value, "theirNeed")?.into();
let their_have = js_get(&value, "theirHave")?.try_into()?;
let sent_hashes = js_get(&value, "sentHashes")?.try_into()?;
Ok(am::SyncState {
Ok(am::sync::State {
shared_heads,
last_sent_heads,
their_heads,
@ -155,7 +155,7 @@ impl TryFrom<JS> for am::SyncState {
}
}
impl TryFrom<JS> for Option<Vec<am::SyncHave>> {
impl TryFrom<JS> for Option<Vec<am::sync::Have>> {
type Error = JsValue;
fn try_from(value: JS) -> Result<Self, Self::Error> {
@ -167,17 +167,17 @@ impl TryFrom<JS> for Option<Vec<am::SyncHave>> {
}
}
impl TryFrom<JS> for Vec<am::SyncHave> {
impl TryFrom<JS> for Vec<am::sync::Have> {
type Error = JsValue;
fn try_from(value: JS) -> Result<Self, Self::Error> {
let value = value.0.dyn_into::<Array>()?;
let have: Result<Vec<am::SyncHave>, JsValue> = value
let have: Result<Vec<am::sync::Have>, JsValue> = value
.iter()
.map(|s| {
let last_sync = js_get(&s, "lastSync")?.try_into()?;
let bloom = js_get(&s, "bloom")?.try_into()?;
Ok(am::SyncHave { last_sync, bloom })
Ok(am::sync::Have { last_sync, bloom })
})
.collect();
let have = have?;
@ -185,7 +185,7 @@ impl TryFrom<JS> for Vec<am::SyncHave> {
}
}
impl TryFrom<JS> for am::BloomFilter {
impl TryFrom<JS> for am::sync::BloomFilter {
type Error = JsValue;
fn try_from(value: JS) -> Result<Self, Self::Error> {
@ -215,8 +215,8 @@ impl From<&[Change]> for AR {
}
}
impl From<&[am::SyncHave]> for AR {
fn from(value: &[am::SyncHave]) -> Self {
impl From<&[am::sync::Have]> for AR {
fn from(value: &[am::sync::Have]) -> Self {
AR(value
.iter()
.map(|have| {

8
automerge-wasm/src/lib.rs
View file

@ -653,7 +653,7 @@ impl Automerge {
message: Uint8Array,
) -> Result<(), JsValue> {
let message = message.to_vec();
let message = am::SyncMessage::decode(message.as_slice()).map_err(to_js_err)?;
let message = am::sync::Message::decode(message.as_slice()).map_err(to_js_err)?;
self.0
.receive_sync_message(&mut state.0, message)
.map_err(to_js_err)?;
@ -785,7 +785,7 @@ pub fn decode_change(change: Uint8Array) -> Result<JsValue, JsValue> {
#[wasm_bindgen(js_name = initSyncState)]
pub fn init_sync_state() -> SyncState {
SyncState(am::SyncState::new())
SyncState(am::sync::State::new())
}
// this is needed to be compatible with the automerge-js api
@ -807,7 +807,7 @@ pub fn encode_sync_message(message: JsValue) -> Result<Uint8Array, JsValue> {
let changes = js_get(&message, "changes")?.try_into()?;
let have = js_get(&message, "have")?.try_into()?;
Ok(Uint8Array::from(
am::SyncMessage {
am::sync::Message {
heads,
need,
have,
@ -821,7 +821,7 @@ pub fn encode_sync_message(message: JsValue) -> Result<Uint8Array, JsValue> {
#[wasm_bindgen(js_name = decodeSyncMessage)]
pub fn decode_sync_message(msg: Uint8Array) -> Result<JsValue, JsValue> {
let data = msg.to_vec();
let msg = am::SyncMessage::decode(&data).map_err(to_js_err)?;
let msg = am::sync::Message::decode(&data).map_err(to_js_err)?;
let heads = AR::from(msg.heads.as_slice());
let need = AR::from(msg.need.as_slice());
let changes = AR::from(msg.changes.as_slice());

4
automerge-wasm/src/sync.rs
View file

@ -9,7 +9,7 @@ use crate::interop::{to_js_err, AR, JS};
#[wasm_bindgen]
#[derive(Debug)]
pub struct SyncState(pub(crate) am::SyncState);
pub struct SyncState(pub(crate) am::sync::State);
#[wasm_bindgen]
impl SyncState {
@ -45,7 +45,7 @@ impl SyncState {
pub(crate) fn decode(data: Uint8Array) -> Result<SyncState, JsValue> {
let data = data.to_vec();
let s = am::SyncState::decode(&data);
let s = am::sync::State::decode(&data);
let s = s.map_err(to_js_err)?;
Ok(SyncState(s))
}

11
automerge/src/autocommit.rs
View file

@ -1,9 +1,8 @@
use crate::exid::ExId;
use crate::transaction::{CommitOptions, Transactable};
use crate::{
change::export_change, query, transaction::TransactionInner, ActorId, Automerge,
AutomergeError, Change, ChangeHash, Keys, KeysAt, ObjType, Prop, ScalarValue, SyncMessage,
SyncState, Value,
change::export_change, query, sync, transaction::TransactionInner, ActorId, Automerge,
AutomergeError, Change, ChangeHash, Keys, KeysAt, ObjType, Prop, ScalarValue, Value,
};
/// An automerge document that automatically manages transactions.
@ -211,15 +210,15 @@ impl AutoCommit {
self.doc.dump()
}
pub fn generate_sync_message(&mut self, sync_state: &mut SyncState) -> Option<SyncMessage> {
pub fn generate_sync_message(&mut self, sync_state: &mut sync::State) -> Option<sync::Message> {
self.ensure_transaction_closed();
self.doc.generate_sync_message(sync_state)
}
pub fn receive_sync_message(
&mut self,
sync_state: &mut SyncState,
message: SyncMessage,
sync_state: &mut sync::State,
message: sync::Message,
) -> Result<(), AutomergeError> {
self.ensure_transaction_closed();
self.doc.receive_sync_message(sync_state, message)

3
automerge/src/lib.rs
View file

@ -40,7 +40,7 @@ mod legacy;
mod op_set;
mod op_tree;
mod query;
mod sync;
pub mod sync;
pub mod transaction;
mod types;
mod value;
@ -55,7 +55,6 @@ pub use exid::ExId as ObjId;
pub use keys::Keys;
pub use keys_at::KeysAt;
pub use legacy::Change as ExpandedChange;
pub use sync::{BloomFilter, SyncHave, SyncMessage, SyncState};
pub use types::{ActorId, ChangeHash, ObjType, OpType, Prop};
pub use value::{ScalarValue, Value};

36
automerge/src/sync.rs
View file

@ -14,13 +14,13 @@ mod bloom;
mod state;
pub use bloom::BloomFilter;
pub use state::{SyncHave, SyncState};
pub use state::{Have, State};
const HASH_SIZE: usize = 32; // 256 bits = 32 bytes
const MESSAGE_TYPE_SYNC: u8 = 0x42; // first byte of a sync message, for identification
impl Automerge {
pub fn generate_sync_message(&self, sync_state: &mut SyncState) -> Option<SyncMessage> {
pub fn generate_sync_message(&self, sync_state: &mut State) -> Option<Message> {
let our_heads = self.get_heads();
let our_need = self.get_missing_deps(sync_state.their_heads.as_ref().unwrap_or(&vec![]));
@ -43,10 +43,10 @@ impl Automerge {
.iter()
.all(|hash| self.get_change_by_hash(hash).is_some())
{
let reset_msg = SyncMessage {
let reset_msg = Message {
heads: our_heads,
need: Vec::new(),
have: vec![SyncHave::default()],
have: vec![Have::default()],
changes: Vec::new(),
};
return Some(reset_msg);
@ -83,7 +83,7 @@ impl Automerge {
.sent_hashes
.extend(changes_to_send.iter().map(|c| c.hash));
let sync_message = SyncMessage {
let sync_message = Message {
heads: our_heads,
have: our_have,
need: our_need,
@ -95,12 +95,12 @@ impl Automerge {
pub fn receive_sync_message(
&mut self,
sync_state: &mut SyncState,
message: SyncMessage,
sync_state: &mut State,
message: Message,
) -> Result<(), AutomergeError> {
let before_heads = self.get_heads();
let SyncMessage {
let Message {
heads: message_heads,
changes: message_changes,
need: message_need,
@ -153,19 +153,19 @@ impl Automerge {
Ok(())
}
fn make_bloom_filter(&self, last_sync: Vec<ChangeHash>) -> SyncHave {
fn make_bloom_filter(&self, last_sync: Vec<ChangeHash>) -> Have {
let new_changes = self.get_changes(&last_sync);
let hashes = new_changes
.into_iter()
.map(|change| change.hash)
.collect::<Vec<_>>();
SyncHave {
Have {
last_sync,
bloom: BloomFilter::from(&hashes[..]),
}
}
fn get_changes_to_send(&self, have: Vec<SyncHave>, need: &[ChangeHash]) -> Vec<&Change> {
fn get_changes_to_send(&self, have: Vec<Have>, need: &[ChangeHash]) -> Vec<&Change> {
if have.is_empty() {
need.iter()
.filter_map(|hash| self.get_change_by_hash(hash))
@ -175,7 +175,7 @@ impl Automerge {
let mut bloom_filters = Vec::with_capacity(have.len());
for h in have {
let SyncHave { last_sync, bloom } = h;
let Have { last_sync, bloom } = h;
for hash in last_sync {
last_sync_hashes.insert(hash);
}
@ -237,14 +237,14 @@ impl Automerge {
}
#[derive(Debug, Clone)]
pub struct SyncMessage {
pub struct Message {
pub heads: Vec<ChangeHash>,
pub need: Vec<ChangeHash>,
pub have: Vec<SyncHave>,
pub have: Vec<Have>,
pub changes: Vec<Change>,
}
impl SyncMessage {
impl Message {
pub fn encode(self) -> Vec<u8> {
let mut buf = vec![MESSAGE_TYPE_SYNC];
@ -265,7 +265,7 @@ impl SyncMessage {
buf
}
pub fn decode(bytes: &[u8]) -> Result<SyncMessage, decoding::Error> {
pub fn decode(bytes: &[u8]) -> Result<Message, decoding::Error> {
let mut decoder = Decoder::new(Cow::Borrowed(bytes));
let message_type = decoder.read::<u8>()?;
@ -284,7 +284,7 @@ impl SyncMessage {
let last_sync = decode_hashes(&mut decoder)?;
let bloom_bytes: Vec<u8> = decoder.read()?;
let bloom = BloomFilter::try_from(bloom_bytes.as_slice())?;
have.push(SyncHave { last_sync, bloom });
have.push(Have { last_sync, bloom });
}
let change_count = decoder.read::<u32>()?;
@ -294,7 +294,7 @@ impl SyncMessage {
changes.push(Change::from_bytes(change)?);
}
Ok(SyncMessage {
Ok(Message {
heads,
need,
have,

12
automerge/src/sync/state.rs
View file

@ -1,27 +1,27 @@
use std::{borrow::Cow, collections::HashSet};
use super::{decode_hashes, encode_hashes};
use crate::{decoding, decoding::Decoder, BloomFilter, ChangeHash};
use super::{decode_hashes, encode_hashes, BloomFilter};
use crate::{decoding, decoding::Decoder, ChangeHash};
const SYNC_STATE_TYPE: u8 = 0x43; // first byte of an encoded sync state, for identification
#[derive(Debug, Clone, Default)]
pub struct SyncState {
pub struct State {
pub shared_heads: Vec<ChangeHash>,
pub last_sent_heads: Vec<ChangeHash>,
pub their_heads: Option<Vec<ChangeHash>>,
pub their_need: Option<Vec<ChangeHash>>,
pub their_have: Option<Vec<SyncHave>>,
pub their_have: Option<Vec<Have>>,
pub sent_hashes: HashSet<ChangeHash>,
}
#[derive(Debug, Clone, Default)]
pub struct SyncHave {
pub struct Have {
pub last_sync: Vec<ChangeHash>,
pub bloom: BloomFilter,
}
impl SyncState {
impl State {
pub fn new() -> Self {
Default::default()
}