ffi: init negentropy-ffi

Author: yukibtc

Cargo.toml

@@ -3,7 +3,9 @@ members = [
     "negentropy",
     "negentropy/fuzz/harness",
     "negentropy/fuzz/perf",
+    "negentropy-ffi",
 ]
+resolver = "2"
 
 [profile.release]
 lto = true

negentropy-ffi/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "negentropy-ffi"
+version = "0.1.0"
+edition = "2021"
+authors = ["Yuki Kishimoto <[email protected]>"]
+publish = false
+
+[lib]
+name = "negentropy_ffi"
+crate-type = ["lib", "cdylib", "staticlib"]
+
+[[bin]]
+name = "uniffi-bindgen"
+path = "uniffi-bindgen.rs"
+
+[dependencies]
+negentropy  = { path = "../negentropy" }
+parking_lot = "0.12"
+uniffi = { version = "0.24", features = ["cli"] }
+
+[build-dependencies]
+uniffi = { version = "0.24", features = ["build"] }
+

negentropy-ffi/build.rs

@@ -0,0 +1,6 @@
+// Copyright (c) 2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+fn main() {
+    uniffi::generate_scaffolding("./src/negentropy.udl").expect("Building the UDL file failed");
+}

negentropy-ffi/src/bytes.rs

@@ -0,0 +1,45 @@
+// Copyright (c) 2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+use core::ops::Deref;
+
+use crate::error::Result;
+
+pub struct Bytes {
+    inner: negentropy::Bytes,
+}
+
+impl Deref for Bytes {
+    type Target = negentropy::Bytes;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl From<negentropy::Bytes> for Bytes {
+    fn from(inner: negentropy::Bytes) -> Self {
+        Self { inner }
+    }
+}
+
+impl Bytes {
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Self {
+            inner: negentropy::Bytes::new(bytes)
+        }
+    }
+
+    pub fn from_hex(data: String) -> Result<Self> {
+        Ok(Self {
+            inner: negentropy::Bytes::from_hex(data)?
+        })
+    }
+
+    pub fn as_hex(&self) -> String {
+        self.inner.as_hex()
+    }
+
+    pub fn as_bytes(&self) -> Vec<u8> {
+        self.inner.as_bytes().to_vec()
+    }
+}

negentropy-ffi/src/error.rs

@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+use core::fmt;
+
+pub type Result<T, E = NegentropyError> = std::result::Result<T, E>;
+
+#[derive(Debug)]
+pub enum NegentropyError {
+    Generic { err: String },
+}
+
+impl fmt::Display for NegentropyError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Generic { err } => write!(f, "{err}"),
+        }
+    }
+}
+
+impl From<negentropy::Error> for NegentropyError {
+    fn from(e: negentropy::Error) -> Self {
+        Self::Generic { err: e.to_string() }
+    }
+}

negentropy-ffi/src/lib.rs

@@ -0,0 +1,91 @@
+// Copyright (c) 2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+use std::ops::Deref;
+use std::sync::Arc;
+
+use parking_lot::RwLock;
+
+mod error;
+mod bytes;
+
+use self::error::Result;
+pub use self::bytes::Bytes;
+pub use self::error::NegentropyError;
+
+pub struct ReconcileWithIds {
+    pub have_ids: Vec<Arc<Bytes>>,
+    pub need_ids: Vec<Arc<Bytes>>,
+    pub output: Option<Arc<Bytes>>,
+}
+
+pub struct Negentropy {
+    inner: RwLock<negentropy::Negentropy>,
+}
+
+impl Negentropy {
+    pub fn new(id_size: u8, frame_size_limit: Option<u64>) -> Result<Self> {
+        Ok(Self {
+            inner: RwLock::new(negentropy::Negentropy::new(id_size as usize, frame_size_limit)?)
+        })
+    }
+
+    pub fn id_size(&self) -> u64 {
+        self.inner.read().id_size() as u64
+    }
+
+    /// 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<()> {
+        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()))
+    }
+
+    pub fn reconcile(&self, query: Arc<Bytes>) -> Result<Arc<Bytes>> {
+        let mut negentropy = self.inner.write();
+        Ok(Arc::new(negentropy.reconcile(query.as_ref().deref())?.into()))
+    }
+
+    pub fn reconcile_with_ids(
+        &self,
+        query: Arc<Bytes>,
+    ) -> Result<ReconcileWithIds> {
+        let mut negentropy = self.inner.write();
+        let mut have_ids: Vec<negentropy::Bytes> = Vec::new();
+        let mut need_ids: Vec<negentropy::Bytes> = Vec::new();
+        let output: Option<negentropy::Bytes> = negentropy.reconcile_with_ids(query.as_ref().deref(), &mut have_ids, &mut need_ids)?;
+        Ok(ReconcileWithIds { 
+            have_ids: have_ids.into_iter().map(|id| Arc::new(id.into())).collect(), 
+            need_ids: need_ids.into_iter().map(|id| Arc::new(id.into())).collect(), 
+            output: output.map(|o| Arc::new(o.into()))
+        })
+    }
+}
+
+
+// UDL
+uniffi::include_scaffolding!("negentropy");

negentropy-ffi/src/negentropy.udl

@@ -0,0 +1,42 @@
+// Copyright (c) 2022-2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+namespace negentropy {};
+
+[Error]
+interface NegentropyError {
+    Generic(string err);
+};
+
+interface Bytes {
+    constructor(bytes bytes);
+    [Throws=NegentropyError, Name=from_hex]
+    constructor(string data);
+    string as_hex();
+    bytes as_bytes();
+};
+
+dictionary ReconcileWithIds {
+    sequence<Bytes> have_ids;
+    sequence<Bytes> need_ids;
+    Bytes? output;
+};
+
+interface Negentropy {
+    [Throws=NegentropyError]
+    constructor(u8 id_size, u64? frame_size_limit);
+    u64 id_size();
+    boolean is_initiator();
+    boolean is_sealed();
+    boolean continuation_needed();
+    [Throws=NegentropyError]
+    void add_item(u64 created_at, Bytes id);
+    [Throws=NegentropyError]
+    void seal();
+    [Throws=NegentropyError]
+    Bytes initiate();
+    [Throws=NegentropyError]
+    Bytes reconcile(Bytes query);
+    [Throws=NegentropyError]
+    ReconcileWithIds reconcile_with_ids(Bytes query);
+};

negentropy-ffi/uniffi-bindgen.rs

@@ -0,0 +1,6 @@
+// Copyright (c) 2023 Yuki Kishimoto
+// Distributed under the MIT software license
+
+fn main() {
+    uniffi::uniffi_bindgen_main()
+}

negentropy-ffi/uniffi.toml

@@ -0,0 +1,10 @@
+[bindings.kotlin]
+package_name = "negentropy"
+cdylib_name = "negentropy_ffi"
+
+[bindings.swift]
+ffi_module_filename = "negentropyFFI"
+cdylib_name = "negentropy_ffi"
+
+[bindings.python]
+cdylib_name = "negentropy_ffi"