avrocadabra 0.0.1

data/ext/avrocadabra/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "avrocadabra"
+version = "0.0.1"
+edition = "2024"
+rust-version = "1.99"
+authors = ["Alexander Grebennik <sl.bug.sl@gmail.com>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+apache-avro = { version = "*", default-features = false }
+magnus = { version = "*", features = ["rb-sys"] }
+num-bigint = "*"
+num-traits = "*"
+ouroboros = "*"
+rb-sys = { version = "*", features = ["stable-api-compiled-fallback"] }
+serde = "*"
+serde_json = { version = "*", features = ["preserve_order"] }
+uuid = "*"
+
+[build-dependencies]
+rb-sys-env = "*"
+
+[lints.rust]
+deprecated = "deny"
+raw_borrows_via_references = "warn"

data/ext/avrocadabra/build.rs

@@ -0,0 +1,4 @@
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    rb_sys_env::activate()?;
+    Ok(())
+}

data/ext/avrocadabra/extconf.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("avrocadabra/avrocadabra") do |config|
+  config.auto_install_rust_toolchain = false
+  config.extra_cargo_args = ["--locked"]
+end

data/ext/avrocadabra/src/big_decimal.rs

@@ -0,0 +1,107 @@
+use apache_avro::BigDecimal;
+
+pub fn encode(value: &BigDecimal) -> Result<Vec<u8>, String> {
+    let (coefficient, scale) = value.as_bigint_and_exponent();
+    let coefficient = coefficient.to_signed_bytes_be();
+    let length = i64::try_from(coefficient.len()).map_err(|_| "big-decimal is too large")?;
+    let capacity = coefficient
+        .len()
+        .checked_add(20)
+        .ok_or("big-decimal is too large")?;
+    let mut output = Vec::new();
+    output
+        .try_reserve_exact(capacity)
+        .map_err(|e| e.to_string())?;
+    write_long(length, &mut output);
+    output.extend_from_slice(&coefficient);
+    write_long(scale, &mut output);
+    Ok(output)
+}
+
+pub fn decode(bytes: &[u8]) -> Result<BigDecimal, String> {
+    let (coefficient, scale) = parts(bytes)?;
+    Ok(BigDecimal::new(
+        apache_avro::Decimal::from(coefficient).into(),
+        scale,
+    ))
+}
+
+pub fn validate(bytes: &[u8]) -> Result<(), String> {
+    parts(bytes).map(|_| ())
+}
+
+fn parts(mut bytes: &[u8]) -> Result<(&[u8], i64), String> {
+    let length = usize::try_from(read_long(&mut bytes)?)
+        .map_err(|_| "big-decimal has a negative coefficient length")?;
+    if length == 0 {
+        return Err("big-decimal requires at least one signed coefficient byte".into());
+    }
+    let coefficient = bytes
+        .get(..length)
+        .ok_or("truncated big-decimal coefficient")?;
+    bytes = &bytes[length..];
+    let scale = read_long(&mut bytes)?;
+    if !bytes.is_empty() {
+        return Err("trailing bytes inside big-decimal".into());
+    }
+    Ok((coefficient, scale))
+}
+
+fn read_long(bytes: &mut &[u8]) -> Result<i64, String> {
+    let mut value = 0_u64;
+    for shift in (0..70).step_by(7) {
+        let (&byte, rest) = bytes.split_first().ok_or("truncated big-decimal varint")?;
+        *bytes = rest;
+        if shift == 63 && byte > 1 {
+            return Err("big-decimal varint overflows 64 bits".into());
+        }
+        value |= u64::from(byte & 0x7f) << shift;
+        if byte & 0x80 == 0 {
+            return Ok(((value >> 1) as i64) ^ -((value & 1) as i64));
+        }
+    }
+    Err("unterminated big-decimal varint".into())
+}
+
+fn write_long(value: i64, output: &mut Vec<u8>) {
+    let mut value = ((value as u64) << 1) ^ ((value >> 63) as u64);
+    while value > 0x7f {
+        output.push((value as u8) | 0x80);
+        value >>= 7;
+    }
+    output.push(value as u8);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scale_spans_the_rust_wire_domain_without_expansion() {
+        for scale in [i64::MIN, -1, 0, 1, i64::MAX] {
+            let value = BigDecimal::new((-129).into(), scale);
+            let bytes = encode(&value).unwrap();
+            assert!(bytes.len() <= 13);
+            assert_eq!(
+                decode(&bytes).unwrap().as_bigint_and_exponent(),
+                ((-129).into(), scale)
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_malformed_internal_frames() {
+        for bytes in [
+            vec![],
+            vec![0, 0],
+            vec![1, 0],
+            vec![4, 1],
+            vec![2, 1],
+            vec![2, 1, 0, 0],
+            vec![2, 1, 0x80],
+            vec![0xff; 10],
+        ] {
+            assert!(validate(&bytes).is_err(), "{bytes:?}");
+        }
+    }
+}

data/ext/avrocadabra/src/callback.rs

@@ -0,0 +1,106 @@
+use magnus::{
+    DataTypeFunctions, Error, Ruby, TypedData, Value,
+    block::Proc,
+    fiber::Fiber,
+    gc,
+    prelude::*,
+    rb_sys::{AsRawValue, FromRawValue, protect, resume_error},
+    typed_data::Obj,
+    value::Opaque,
+};
+use std::sync::Mutex;
+
+#[derive(TypedData)]
+#[magnus(class = "Avrocadabra::NativeCallback", free_immediately, mark)]
+pub struct Callback {
+    address: Mutex<Option<usize>>,
+    invoke: unsafe fn(usize, &[Value]) -> Result<(), Error>,
+    owner: std::thread::ThreadId,
+    fiber: Opaque<Fiber>,
+}
+
+impl DataTypeFunctions for Callback {
+    fn mark(&self, marker: &gc::Marker) {
+        marker.mark(self.fiber);
+    }
+}
+
+struct Scope(Obj<Callback>);
+
+impl Drop for Scope {
+    fn drop(&mut self) {
+        *self
+            .0
+            .address
+            .lock()
+            .unwrap_or_else(|error| error.into_inner()) = None;
+    }
+}
+
+unsafe extern "C" fn call(
+    _: rb_sys::VALUE,
+    data: rb_sys::VALUE,
+    argc: std::ffi::c_int,
+    argv: *const rb_sys::VALUE,
+    _: rb_sys::VALUE,
+) -> rb_sys::VALUE {
+    let ruby = unsafe { Ruby::get_unchecked() };
+    let result = crate::boundary(&ruby, "EncodeError", || {
+        let callback = Obj::<Callback>::try_convert(unsafe { Value::from_raw(data) })?;
+        if std::thread::current().id() != callback.owner
+            || ruby.fiber_current().as_raw() != ruby.get_inner(callback.fiber).as_raw()
+        {
+            return Err(Error::new(
+                ruby.exception_thread_error(),
+                "encoding block called from another thread or fiber",
+            ));
+        }
+        let address = callback
+            .address
+            .lock()
+            .unwrap_or_else(|error| error.into_inner())
+            .take()
+            .ok_or_else(|| {
+                Error::new(ruby.exception_local_jump_error(), "inactive encoding block")
+            })?;
+        let args = if argc == 0 {
+            &[]
+        } else {
+            unsafe { std::slice::from_raw_parts(argv.cast(), argc as usize) }
+        };
+        // Escaped and reentrant blocks cannot access the borrowed encoder.
+        let result = unsafe { (callback.invoke)(address, args) };
+        *callback
+            .address
+            .lock()
+            .unwrap_or_else(|error| error.into_inner()) = Some(address);
+        result
+    });
+    match result {
+        Ok(()) => ruby.qnil().as_raw(),
+        Err(error) => unsafe { resume_error(error) },
+    }
+}
+
+pub fn each<F>(ruby: &Ruby, value: Value, mut callback: F) -> Result<(), Error>
+where
+    F: FnMut(&[Value]) -> Result<(), Error>,
+{
+    unsafe fn invoke<F>(address: usize, args: &[Value]) -> Result<(), Error>
+    where
+        F: FnMut(&[Value]) -> Result<(), Error>,
+    {
+        unsafe { (&mut *(address as *mut F))(args) }
+    }
+
+    let scope = Scope(ruby.obj_wrap(Callback {
+        address: Mutex::new(Some((&raw mut callback) as usize)),
+        invoke: invoke::<F>,
+        owner: std::thread::current().id(),
+        fiber: ruby.fiber_current().into(),
+    }));
+    let block = protect(|| unsafe { rb_sys::rb_proc_new(Some(call), scope.0.as_raw()) })?;
+    let block = Proc::try_convert(unsafe { Value::from_raw(block) })?;
+    let _: Value = value.funcall_with_block("each", (), block)?;
+    Ok(())
+}