ffi: adapt to protocol v1

Author: yukibtc

negentropy-ffi/Cargo.lock

@@ -20,10 +20,10 @@ path = "uniffi-bindgen.rs"
 [dependencies]
 negentropy  = { path = "../negentropy" }
 parking_lot = "0.12"
-uniffi = { version = "0.24", features = ["cli"] }
+uniffi = { git = "https://github.com/mozilla/uniffi-rs", rev = "d380d164cfdba9e091c461baa6855f0a2294ac5b", features = ["cli"] }
 
 [build-dependencies]
-uniffi = { version = "0.24", features = ["build"] }
+uniffi = { git = "https://github.com/mozilla/uniffi-rs", rev = "d380d164cfdba9e091c461baa6855f0a2294ac5b", features = ["build"] }
 
 [profile.release]
 lto = true

negentropy-ffi/Cargo.toml

@@ -8,8 +8,8 @@ python:
 	rm -rf bindings-python/dist
 	pip install -r bindings-python/requirements.txt --break-system-packages
 	cargo build --release
-	cargo run --features=uniffi/cli --bin uniffi-bindgen generate src/negentropy.udl --language python --no-format -o bindings-python/src/negentropy/
-	cp ../target/release/libnegentropy_ffi.so bindings-python/src/negentropy/ | true
-	cp ../target/release/libnegentropy_ffi.dylib bindings-python/src/negentropy/ | true
+	cargo run --features=uniffi/cli --bin uniffi-bindgen generate --library ./target/release/libnegentropy_ffi.so --language python --no-format -o bindings-python/src/negentropy/
+	cp ./target/release/libnegentropy_ffi.so bindings-python/src/negentropy/ | true
+	cp ./target/release/libnegentropy_ffi.dylib bindings-python/src/negentropy/ | true
 	cd bindings-python && python setup.py --verbose bdist_wheel
 	pip install ./bindings-python/dist/negentropy*.whl --force-reinstall --break-system-packages

negentropy-ffi/Makefile

@@ -1,21 +1,23 @@
-from negentropy import Negentropy, Bytes
+from negentropy import Negentropy, NegentropyStorageVector, Bytes
 
 # Client init
-client = Negentropy(16, None)
-client.add_item(0, Bytes.from_hex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
-client.add_item(1, Bytes.from_hex("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
-client.seal()
+storage = NegentropyStorageVector()
+storage.insert(0, Bytes.from_hex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
+storage.insert(1, Bytes.from_hex("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
+storage.seal()
+client = Negentropy(storage, None)
 init_output = client.initiate()
 print(f"Initiator Output: {init_output.as_hex()}")
 
 # Relay
-relay = Negentropy(16, None)
-relay.add_item(0, Bytes.from_hex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
-relay.add_item(2, Bytes.from_hex("cccccccccccccccccccccccccccccccc"))
-relay.add_item(3, Bytes.from_hex("11111111111111111111111111111111"))
-relay.add_item(5, Bytes.from_hex("22222222222222222222222222222222"))
-relay.add_item(10, Bytes.from_hex("33333333333333333333333333333333"))
-relay.seal()
+storage = NegentropyStorageVector()
+storage.insert(0, Bytes.from_hex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
+storage.insert(2, Bytes.from_hex("cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"))
+storage.insert(3, Bytes.from_hex("1111111111111111111111111111111111111111111111111111111111111111"))
+storage.insert(5, Bytes.from_hex("2222222222222222222222222222222222222222222222222222222222222222"))
+storage.insert(10, Bytes.from_hex("3333333333333333333333333333333333333333333333333333333333333333"))
+storage.seal()
+relay = Negentropy(storage, None)
 reconcile_output = relay.reconcile(init_output)
 print(f"Reconcile Output: {reconcile_output.as_hex()}")
 

negentropy-ffi/bindings-python/examples/client.py

@@ -2,9 +2,13 @@
 // Distributed under the MIT software license
 
 use core::ops::Deref;
+use std::sync::Arc;
+
+use uniffi::Object;
 
 use crate::error::Result;
 
+#[derive(Object)]
 pub struct Bytes {
     inner: negentropy::Bytes,
 }
@@ -22,17 +26,20 @@ impl From<negentropy::Bytes> for Bytes {
     }
 }
 
+#[uniffi::export]
 impl Bytes {
-    pub fn new(bytes: Vec<u8>) -> Self {
-        Self {
+    #[uniffi::constructor]
+    pub fn new(bytes: Vec<u8>) -> Arc<Self> {
+        Arc::new(Self {
             inner: negentropy::Bytes::new(bytes),
-        }
+        })
     }
 
-    pub fn from_hex(data: String) -> Result<Self> {
-        Ok(Self {
+    #[uniffi::constructor]
+    pub fn from_hex(data: String) -> Result<Arc<Self>> {
+        Ok(Arc::new(Self {
             inner: negentropy::Bytes::from_hex(data)?,
-        })
+        }))
     }
 
     pub fn as_hex(&self) -> String {

negentropy-ffi/build.rs

@@ -3,13 +3,17 @@
 
 use core::fmt;
 
+use uniffi::Error;
+
 pub type Result<T, E = NegentropyError> = std::result::Result<T, E>;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum NegentropyError {
     Generic { err: String },
 }
 
+impl std::error::Error for NegentropyError {}
+
 impl fmt::Display for NegentropyError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

negentropy-ffi/src/bytes.rs

@@ -5,67 +5,61 @@ use std::ops::Deref;
 use std::sync::Arc;
 
 use parking_lot::RwLock;
+use uniffi::{Object, Record};
 
 mod bytes;
 mod error;
+mod storage;
 
 pub use self::bytes::Bytes;
 pub use self::error::NegentropyError;
 use self::error::Result;
+pub use self::storage::NegentropyStorageVector;
 
+#[derive(Record)]
 pub struct ReconcileWithIds {
     pub have_ids: Vec<Arc<Bytes>>,
     pub need_ids: Vec<Arc<Bytes>>,
     pub output: Option<Arc<Bytes>>,
 }
 
+#[derive(Object)]
 pub struct Negentropy {
-    inner: RwLock<negentropy::Negentropy>,
+    inner: RwLock<negentropy::Negentropy<negentropy::NegentropyStorageVector>>,
 }
 
+#[uniffi::export]
 impl Negentropy {
-    pub fn new(id_size: u8, frame_size_limit: Option<u64>) -> Result<Self> {
-        Ok(Self {
+    /// Create new negentropy instance
+    ///
+    /// Frame size limit must be `equal to 0` or `greater than 4096`
+    #[uniffi::constructor]
+    pub fn new(
+        storage: Arc<NegentropyStorageVector>,
+        frame_size_limit: Option<u64>,
+    ) -> Result<Arc<Self>> {
+        Ok(Arc::new(Self {
             inner: RwLock::new(negentropy::Negentropy::new(
-                id_size as usize,
-                frame_size_limit,
+                storage.as_ref().to_inner(),
+                frame_size_limit.unwrap_or_default(),
             )?),
-        })
+        }))
     }
 
-    pub fn id_size(&self) -> u64 {
-        self.inner.read().id_size() as u64
+    /// Initiate reconciliation set
+    pub fn initiate(&self) -> Result<Arc<Bytes>> {
+        let mut negentropy = self.inner.write();
+        Ok(Arc::new(negentropy.initiate()?.into()))
     }
 
-    /// Check if current instance it's an initiator
     pub fn is_initiator(&self) -> bool {
         self.inner.read().is_initiator()
     }
 
-    /// Check if sealed
-    pub fn is_sealed(&self) -> bool {
-        self.inner.read().is_sealed()
-    }
-
-    /// Check if need to continue
-    pub fn continuation_needed(&self) -> bool {
-        self.inner.read().continuation_needed()
-    }
-
-    pub fn add_item(&self, created_at: u64, id: Arc<Bytes>) -> Result<()> {
+    /// Set Initiator: for resuming initiation flow with a new instance
+    pub fn set_initiator(&self) {
         let mut negentropy = self.inner.write();
-        Ok(negentropy.add_item(created_at, id.as_ref().deref().clone())?)
-    }
-
-    pub fn seal(&self) -> Result<()> {
-        let mut negentropy = self.inner.write();
-        Ok(negentropy.seal()?)
-    }
-
-    /// Initiate reconciliation set
-    pub fn initiate(&self) -> Result<Arc<Bytes>> {
-        let mut negentropy = self.inner.write();
-        Ok(Arc::new(negentropy.initiate()?.into()))
+        negentropy.set_initiator();
     }
 
     pub fn reconcile(&self, query: Arc<Bytes>) -> Result<Arc<Bytes>> {
@@ -89,5 +83,4 @@ impl Negentropy {
     }
 }
 
-// UDL
-uniffi::include_scaffolding!("negentropy");
+uniffi::setup_scaffolding!("negentropy");

negentropy-ffi/src/error.rs

@@ -0,0 +1,55 @@
+// Copyright (c) 2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+use std::ops::Deref;
+use std::sync::Arc;
+
+use negentropy::NegentropyStorageBase;
+use parking_lot::RwLock;
+use uniffi::Object;
+
+use crate::error::Result;
+use crate::Bytes;
+
+#[derive(Object)]
+pub struct NegentropyStorageVector {
+    inner: Arc<RwLock<negentropy::NegentropyStorageVector>>,
+}
+
+#[uniffi::export]
+impl NegentropyStorageVector {
+    #[uniffi::constructor]
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            inner: Arc::new(RwLock::new(negentropy::NegentropyStorageVector::new())),
+        })
+    }
+
+    /// Insert item
+    pub fn insert(&self, created_at: u64, id: Arc<Bytes>) -> Result<()> {
+        let mut storage = self.inner.write();
+        Ok(storage.insert(created_at, id.as_ref().deref().clone())?)
+    }
+
+    /// Seal
+    pub fn seal(&self) -> Result<()> {
+        let mut storage = self.inner.write();
+        Ok(storage.seal()?)
+    }
+
+    /// Unseal
+    pub fn unseal(&self) -> Result<()> {
+        let mut storage = self.inner.write();
+        Ok(storage.unseal()?)
+    }
+
+    fn size(&self) -> Result<u64> {
+        Ok(self.inner.read().size()? as u64)
+    }
+}
+
+impl NegentropyStorageVector {
+    pub(crate) fn to_inner(&self) -> negentropy::NegentropyStorageVector {
+        self.inner.read().to_owned()
+    }
+}