Initial code review

lib/Cargo.toml

@@ -9,7 +9,7 @@ libloading = "0.8.3"
 libc = "0.2.153"
 rand = "0.8.5"
 rustc_version_runtime = "0.3.0"
-lazy_static = "1.4.0"
+once_cell = "1"
 linkme = "0.3"
 paste = "1.0.14"
 

lib/src/assert/mod.rs

@@ -1,3 +1,4 @@
+use once_cell::sync::Lazy;
 use serde_json::{Value, json};
 use std::collections::HashMap;
 use crate::internal;
@@ -221,9 +222,7 @@ impl AssertionInfo {
     }
 }
 
-lazy_static!{
-    static ref ASSERT_TRACKER: Mutex<HashMap<String, TrackingInfo>> = Mutex::new(HashMap::new());
-}
+static ASSERT_TRACKER: Lazy<Mutex<HashMap<String, TrackingInfo>>> = Lazy::new(|| Mutex::new(HashMap::new()));
 
 #[allow(clippy::too_many_arguments)]
 pub fn assert_impl(

lib/src/internal/local_handler.rs

@@ -1,15 +1,14 @@
 use serde_json::{Value};
 use std::env;
 use std::fs::File;
-use std::io::{Write, BufWriter, Error};
+use std::io::{Write, Error};
 
 use crate::internal::{LibHandler};
 
 const LOCAL_OUTPUT: &str = "ANTITHESIS_SDK_LOCAL_OUTPUT";
 
-// #[allow(dead_code)]
 pub struct LocalHandler {
-    maybe_writer: Option<BufWriter<Box<dyn Write + Send>>>
+    maybe_writer: Option<File>
 }
 
 impl LocalHandler {
@@ -27,7 +26,7 @@ impl LocalHandler {
             // Seems like LocalHandler gets bound to a reference with 
             // a 'static lifetime.
             LocalHandler{
-                maybe_writer: Some(BufWriter::with_capacity(0, Box::new(f)))
+                maybe_writer: Some(f)
             }
         } else {
                 eprintln!("Unable to write to '{}' - {}", filename.as_str(), create_result.unwrap_err());
@@ -39,13 +38,15 @@ impl LocalHandler {
 }
 
 impl LibHandler for LocalHandler {
-    fn output(&mut self, value: &Value) -> Result<(), Error> {
-        let maybe_writer = self.maybe_writer.as_mut();
-        match maybe_writer {
+    fn output(&self, value: &Value) -> Result<(), Error> {
+        match &self.maybe_writer {
             Some(b2w) => {
-                let mut text_line = value.to_string();
-                text_line.push('\n');
-                b2w.write_all(text_line.as_bytes())?;
+                let mut b2w = b2w;
+                // The compact Display impl (selected using `{}`) of `serde_json::Value` contains no newlines,
+                // hence we are outputing valid JSONL format here.
+                // Using the `{:#}` format specifier may results in extra newlines and indentation.
+                // See https://docs.rs/serde_json/latest/serde_json/enum.Value.html#impl-Display-for-Value.
+                writeln!(b2w, "{}", value)?;
                 b2w.flush()?;
                 Ok(())
             },

lib/src/internal/mod.rs

@@ -1,9 +1,9 @@
+use once_cell::sync::Lazy;
 use rustc_version_runtime::version;
 use serde_json::{Value, json};
 use std::io::{Error};
-use std::sync::Mutex;
 use local_handler::LocalHandler;
-use voidstar_handler::{VoidstarHandler, has_voidstar};
+use voidstar_handler::{VoidstarHandler};
 
 mod local_handler;
 mod voidstar_handler;
@@ -14,39 +14,21 @@ const PROTOCOL_VERSION: &str = "1.0.0";
 // Tracks SDK releases
 const SDK_VERSION: &str = "0.1.1";
 
-// static mut LIB_HANDLER: Option<Box<dyn LibHandler>> = None;
-static LIB_HANDLER: Mutex<Option<Box<dyn LibHandler + Send>>> = Mutex::new(None);
+static LIB_HANDLER: Lazy<Box<dyn LibHandler + Sync + Send>> = Lazy::new(|| {
+    match VoidstarHandler::try_load() {
+        Ok(handler) => Box::new(handler),
+        Err(_) => Box::new(LocalHandler::new()),
+    }
+});
 
 trait LibHandler {
-    fn output(&mut self, value: &Value) -> Result<(), Error>;
+    fn output(&self, value: &Value) -> Result<(), Error>;
     fn random(&self) -> u64;
 }
 
-fn instantiate_handler() {
-    if LIB_HANDLER.lock().unwrap().is_some() {
-        return
-    }
-
-    let lh : Box<dyn LibHandler + Send> = if has_voidstar() {
-        Box::new(VoidstarHandler::new())
-    } else {
-        Box::new(LocalHandler::new())
-    };
-
-    {
-        let mut x = LIB_HANDLER.lock().unwrap();
-        *x = Some(lh);
-    }
-
-    let sdk_value: Value = sdk_info();
-    dispatch_output(&sdk_value)
-}
-
 // Made public so it can be invoked from the antithesis_sdk_rust::random module
 pub fn dispatch_random() -> u64 {
-    instantiate_handler();
-    LIB_HANDLER.lock().unwrap().as_ref().unwrap().random()
-
+    LIB_HANDLER.random()
 }
 
 // Ignore any and all errors - either the output is completed,
@@ -66,8 +48,7 @@ pub fn dispatch_random() -> u64 {
 // Made public so it can be invoked from the antithesis_sdk_rust::lifecycle 
 // and antithesis_sdk_rust::assert module
 pub fn dispatch_output(json_data: &Value) {
-    instantiate_handler();
-    let _ = LIB_HANDLER.lock().unwrap().as_mut().unwrap().output(json_data);
+    let _ = LIB_HANDLER.output(json_data);
 }
 
 fn sdk_info() -> Value {

lib/src/internal/voidstar_handler.rs

@@ -2,47 +2,25 @@ use libc::{c_char, size_t};
 use libloading::{Library, Symbol};
 use serde_json::{Value};
 use std::io::{Error};
-use std::sync::{Once, Mutex, Arc};
 
 use crate::internal::{LibHandler};
 
 const LIB_NAME: &str = "/usr/lib/libmockstar.so";
 
-pub fn has_voidstar() -> bool {
-    load_voidstar();
-    LIB_VOIDSTAR.lock().unwrap().is_some()
-}
-
-static LIB_VOIDSTAR: Mutex<Option<Arc<Library>>> = Mutex::new(None);
-
-fn load_voidstar() {
-    static LOAD_VOIDSTAR: Once = Once::new();
-    LOAD_VOIDSTAR.call_once(|| {
-        let result = unsafe {
-            Library::new(LIB_NAME)
-        };
-        let mut lib_voidstar = LIB_VOIDSTAR.lock().unwrap();
-        *lib_voidstar = result.ok().map(Arc::new);
-    });
-}
-
 #[derive(Debug)]
 pub struct VoidstarHandler {
-    voidstar_lib: Arc<Library>,
+    voidstar_lib: Library,
 }
 
 impl VoidstarHandler {
-    pub fn new() -> Self {
-        load_voidstar();
-        let lib = LIB_VOIDSTAR.lock().unwrap().as_ref().unwrap().clone();
-        VoidstarHandler{
-            voidstar_lib: lib,
-        }
+    pub fn try_load() -> Result<Self, libloading::Error> {
+        let lib = unsafe { Library::new(LIB_NAME) }?;
+        Ok(VoidstarHandler { voidstar_lib: lib })
     }
 }
 
 impl LibHandler for VoidstarHandler {
-    fn output(&mut self, value: &Value) -> Result<(), Error> {
+    fn output(&self, value: &Value) -> Result<(), Error> {
         let payload = value.to_string();
         unsafe {
             let json_data_func: Symbol<unsafe extern fn(s: *const c_char, l: size_t)> = self.voidstar_lib.get(b"fuzz_json_data").unwrap();

lib/src/lib.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate lazy_static;
-
 pub mod assert;
 pub mod lifecycle;
 pub mod random;