Use Builder pattern for initialization (#6)

* Use Builder pattern for initialization * Update examples to use builder pattern * Simply unit tests
SubconsciousCompute · Feb 15, 2024 · f7bb110 · f7bb110
1 parent 0adb318
commit f7bb110
Show file tree

Hide file tree

Showing 8 changed files with 96 additions and 112 deletions.
diff --git a/examples/aggregate.rs b/examples/aggregate.rs
@@ -1,12 +1,13 @@
 use libdtrace_rs::*;
 
-fn main() {
-    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0).unwrap();
-    handle.dtrace_setopt("bufsize", "4m").unwrap();
-    handle.dtrace_setopt("aggsize", "4m").unwrap();
-    handle
-        .dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)), None)
-        .unwrap();
+fn main() -> Result<(), utils::Error> {
+    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0)?
+        .dtrace_setopt("bufsize", "4m")?
+        .dtrace_setopt("aggsize", "4m")?
+        .dtrace_register_handler(
+            crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)),
+            None,
+        )?;
     let prog = handle
         .dtrace_program_strcompile(
             "syscall:::entry { @num[execname] = count(); }",
@@ -27,4 +28,6 @@ fn main() {
 
     handle.dtrace_aggregate_print(None, None).unwrap();
     handle.dtrace_stop().unwrap();
+
+    Ok(())
 }
diff --git a/examples/basic.rs b/examples/basic.rs
@@ -1,12 +1,13 @@
 use libdtrace_rs::*;
 
-fn main() {
-    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0).unwrap();
-    handle.dtrace_setopt("bufsize", "4m").unwrap();
-    handle.dtrace_setopt("aggsize", "4m").unwrap();
-    handle
-        .dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)), None)
-        .unwrap();
+fn main() -> Result<(), utils::Error> {
+    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0)?
+        .dtrace_setopt("bufsize", "4m")?
+        .dtrace_setopt("aggsize", "4m")?
+        .dtrace_register_handler(
+            crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)),
+            None,
+        )?;
     let prog = handle
         .dtrace_program_strcompile(
             "BEGIN {trace(\"Hello World\");}",
@@ -21,16 +22,14 @@ fn main() {
     match handle.dtrace_status().unwrap() {
         types::dtrace_status::Ok => {
             handle
-                .dtrace_consume(
-                    None, 
-                    Some(callbacks::chew), 
-                    Some(callbacks::chew_rec), 
-                    None
-                ).unwrap();
+                .dtrace_consume(None, Some(callbacks::chew), Some(callbacks::chew_rec), None)
+                .unwrap();
         }
         _ => {}
     }
 
     handle.dtrace_aggregate_print(None, None).unwrap();
     handle.dtrace_stop().unwrap();
-}
+
+    Ok(())
+}
diff --git a/examples/callback.rs b/examples/callback.rs
@@ -26,12 +26,13 @@ pub unsafe extern "C" fn custom_callback(
     DTRACE_CONSUME_THIS as ::core::ffi::c_int
 }
 
-fn main() {
-    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0).unwrap();
-    handle.dtrace_setopt("bufsize", "4m").unwrap();
-    handle
-        .dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)), None)
-        .unwrap();
+fn main() -> Result<(), utils::Error> {
+    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0)?
+        .dtrace_setopt("bufsize", "4m")?
+        .dtrace_register_handler(
+            crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)),
+            None,
+        )?;
     let prog = handle
         .dtrace_program_strcompile(
             "BEGIN {trace(\"Hello World\");}",
@@ -46,14 +47,12 @@ fn main() {
     match handle.dtrace_status().unwrap() {
         types::dtrace_status::Ok => {
             handle
-                .dtrace_consume(
-                    None, 
-                    Some(custom_callback), 
-                    Some(callbacks::chew_rec), 
-                    None
-                ).unwrap();
+                .dtrace_consume(None, Some(custom_callback), Some(callbacks::chew_rec), None)
+                .unwrap();
         }
         _ => {}
     }
     handle.dtrace_stop().unwrap();
+
+    Ok(())
 }
diff --git a/examples/channels.rs b/examples/channels.rs
@@ -14,7 +14,7 @@ pub unsafe extern "C" fn buffered(
     bufdata: *const crate::dtrace_bufdata_t,
     arg: *mut ::core::ffi::c_void,
 ) -> ::core::ffi::c_int {
-    let tx = & *(arg as *mut ::std::sync::mpsc::Sender<::std::string::String>);
+    let tx = &*(arg as *mut ::std::sync::mpsc::Sender<::std::string::String>);
     let msg = ::core::ffi::CStr::from_ptr((*bufdata).dtbda_buffered)
         .to_str()
         .expect("Failed to convert buffer to string");
@@ -26,13 +26,14 @@ pub unsafe extern "C" fn buffered(
 fn main() {
     let (tx, rx): (Sender<String>, Receiver<String>) = mpsc::channel();
 
-    thread::spawn(move || {
-        let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0).unwrap();
-        handle.dtrace_setopt("bufsize", "4m").unwrap();
-        handle.dtrace_setopt("aggsize", "4m").unwrap();
-        handle
-            .dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(buffered)), Some(&tx as *const _ as *mut _))
-            .unwrap();
+    thread::spawn(move || -> Result<(), utils::Error> {
+        let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0)?
+            .dtrace_setopt("bufsize", "4m")?
+            .dtrace_setopt("aggsize", "4m")?
+            .dtrace_register_handler(
+                crate::types::dtrace_handler::Buffered(Some(buffered)),
+                Some(&tx as *const _ as *mut _),
+            )?;
         let prog = handle
             .dtrace_program_strcompile(
                 PROGRAM,
@@ -51,10 +52,12 @@ fn main() {
                 .unwrap_or(dtrace_workstatus_t::DTRACE_WORKSTATUS_OKAY);
         }
         handle.dtrace_stop().unwrap();
+
+        Ok(())
     });
 
     loop {
         let msg = rx.recv().unwrap();
         println!("Recieved: {}", msg);
     }
-}
+}
diff --git a/examples/filehandling.rs b/examples/filehandling.rs
@@ -1,15 +1,13 @@
 use libdtrace_rs::*;
 
-fn main() {
-    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0).unwrap();
-    handle.dtrace_setopt("bufsize", "4m").unwrap();
-    handle.dtrace_setopt("aggsize", "4m").unwrap();
-    handle
+fn main() -> Result<(), utils::Error> {
+    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0)?
+        .dtrace_setopt("bufsize", "4m")?
+        .dtrace_setopt("aggsize", "4m")?
         .dtrace_register_handler(
             crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)),
             None,
-        )
-        .unwrap();
+        )?;
 
     let file = utils::File::new("examples/program.d", "r").unwrap();
     let prog = handle
@@ -22,11 +20,18 @@ fn main() {
     match handle.dtrace_status().unwrap() {
         types::dtrace_status::Ok => {
             handle
-                .dtrace_consume(Some(&output), Some(callbacks::chew), Some(callbacks::chew_rec), None)
+                .dtrace_consume(
+                    Some(&output),
+                    Some(callbacks::chew),
+                    Some(callbacks::chew_rec),
+                    None,
+                )
                 .unwrap();
         }
         _ => {}
     }
 
     handle.dtrace_stop().unwrap();
+
+    Ok(())
 }
diff --git a/examples/syscall.rs b/examples/syscall.rs
@@ -25,12 +25,13 @@ pub unsafe extern "C" fn custom_callback(
     DTRACE_CONSUME_THIS as ::core::ffi::c_int
 }
 
-fn main() {
-    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0).unwrap();
-    handle.dtrace_setopt("bufsize", "4m").unwrap();
-    handle
-        .dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)), None)
-        .unwrap();
+fn main() -> Result<(), utils::Error> {
+    let handle = wrapper::dtrace_hdl::dtrace_open(libdtrace_rs::DTRACE_VERSION as i32, 0)?
+        .dtrace_setopt("bufsize", "4m")?
+        .dtrace_register_handler(
+            crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)),
+            None,
+        )?;
     let prog = handle
         .dtrace_program_strcompile(
             "syscall",
@@ -46,16 +47,14 @@ fn main() {
         match handle.dtrace_status().unwrap() {
             types::dtrace_status::Ok => {
                 handle
-                    .dtrace_consume(
-                        None, 
-                        Some(custom_callback), 
-                        Some(callbacks::chew_rec), 
-                        None
-                    ).unwrap();
+                    .dtrace_consume(None, Some(custom_callback), Some(callbacks::chew_rec), None)
+                    .unwrap();
             }
             _ => break,
         }
     }
 
     handle.dtrace_stop().unwrap();
+
+    Ok(())
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -12,62 +12,38 @@ mod tests {
     use crate::*;
     use wrapper::dtrace_hdl;
     #[test]
-    fn dtrace_get_handle() {
-        let handle = dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0);
-        match handle {
-            Ok(_) => {}
-            Err(error) => {
-                panic!("{}", error);
-            }
-        }
+    fn dtrace_get_handle() -> Result<(), utils::Error> {
+        dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0)?;
+        Ok(())
     }
 
     #[test]
-    fn dtrace_set_option() {
-        let handle = dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0).unwrap();
-        let status = handle.dtrace_setopt("bufsize", "4m");
-        match status {
-            Ok(_) => {}
-            Err(error) => {
-                panic!("{}", error);
-            }
-        }
+    fn dtrace_set_option() -> Result<(), utils::Error> {
+        let result = dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0)?
+                    .dtrace_setopt("bufsize", "4m")?;
+        assert_eq!(result.dtrace_getopt("bufsize")?, 4194304);
+        Ok(())
     }
 
     #[test]
-    fn dtrace_handle_buffered() {
-        let handle = dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0).unwrap();
-        let status = handle.dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)), None);
-        match status {
-            Ok(_) => {}
-            Err(error) => {
-                panic!("{}", error);
-            }
-        }
+    fn dtrace_handle_buffered() -> Result<(), utils::Error> {
+        dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0)?
+            .dtrace_register_handler(crate::types::dtrace_handler::Buffered(Some(callbacks::buffered)), None)?;
+        Ok(())
     }
 
     #[test]
-    fn dtrace_compile_and_exec() {
-        let handle = dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0).unwrap();
+    fn dtrace_compile_and_exec() -> Result<(), utils::Error> {
+        let handle = dtrace_hdl::dtrace_open(DTRACE_VERSION as i32, 0)?;
         let prog = handle
                     .dtrace_program_strcompile(
                         "dtrace:::BEGIN {trace(\"Hello World\");} syscall:::entry { @num[execname] = count(); }", 
                         dtrace_probespec::DTRACE_PROBESPEC_NAME, 
                         DTRACE_C_ZDEFS,
-                        None);
-        match prog {
-            Ok(prog) => {
-                let status = handle.dtrace_program_exec(prog, None);
-                match status {
-                    Ok(_) => {}
-                    Err(error) => {
-                        panic!("{}", error);
-                    }
-                }
-            }
-            Err(error) => {
-                panic!("{}", error);
-            }
-        }                        
+                        None)?;
+
+        handle.dtrace_program_exec(prog, None)?;
+
+        Ok(())
     }
 }
diff --git a/src/wrapper.rs b/src/wrapper.rs
@@ -145,12 +145,12 @@ impl dtrace_hdl {
     ///
     /// Returns `Ok(())` if the option was set successfully, or an error code if the option could
     /// not be set.
-    pub fn dtrace_setopt(&self, option: &str, value: &str) -> Result<(), Error> {
+    pub fn dtrace_setopt(self, option: &str, value: &str) -> Result<Self, Error> {
         let option = std::ffi::CString::new(option).unwrap();
         let value = std::ffi::CString::new(value).unwrap();
         match unsafe { crate::dtrace_setopt(self.handle, option.as_ptr(), value.as_ptr()) } {
-            0 => Ok(()),
-            _ => Err(Error::from(self)),
+            0 => Ok(self),
+            _ => Err(Error::from(&self)),
         }
     }
 
@@ -461,10 +461,10 @@ impl dtrace_hdl {
     /// Returns `Ok(())` if the handler was set successfully, or an error code if the handler could
     /// not be set.
     pub fn dtrace_register_handler(
-        &self,
+        self,
         handler: crate::types::dtrace_handler,
         arg: Option<*mut ::core::ffi::c_void>,
-    ) -> Result<(), Error> {
+    ) -> Result<Self, Error> {
         let status;
         let arg = match arg {
             Some(arg) => arg,
@@ -492,9 +492,9 @@ impl dtrace_hdl {
         }
 
         if status == 0 {
-            Ok(())
+            Ok(self)
         } else {
-            Err(Error::from(self))
+            Err(Error::from(&self))
         }
     }