Make context an Arc in the chainman

Author: sedited

examples/src/silentpaymentscanner.rs

@@ -1,6 +1,7 @@
 use std::env;
 use std::fmt;
 use std::process;
+use std::sync::Arc;
 
 use bitcoin::consensus::deserialize;
 use bitcoin::hashes::Hash;
@@ -33,11 +34,13 @@ fn setup_logging() -> Result<Logger<MainLog>, KernelError> {
     Logger::new(MainLog {})
 }
 
-fn create_context() -> Context {
-    ContextBuilder::new()
-        .chain_type(ChainType::REGTEST)
-        .build()
-        .unwrap()
+fn create_context() -> Arc<Context> {
+    Arc::new(
+        ContextBuilder::new()
+            .chain_type(ChainType::REGTEST)
+            .build()
+            .unwrap(),
+    )
 }
 
 fn vec_to_hex_string(data: &Vec<u8>) -> String {
@@ -227,7 +230,7 @@ fn main() {
     let chainman = ChainstateManager::new(
         ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
         BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-        &context,
+        Arc::clone(&context),
     )
     .unwrap();
     chainman

fuzz/fuzz_targets/fuzz_target_chainman.rs

@@ -1,6 +1,6 @@
 #![no_main]
 
-use std::sync::Once;
+use std::sync::{Arc, Once};
 
 use libfuzzer_sys::fuzz_target;
 
@@ -12,20 +12,22 @@ use bitcoinkernel::{
     KernelNotificationInterfaceCallbackHolder,
 };
 
-fn create_context(chain_type: ChainType) -> Context {
-    ContextBuilder::new()
-        .chain_type(chain_type)
-        .kn_callbacks(Box::new(KernelNotificationInterfaceCallbackHolder {
-            kn_block_tip: Box::new(|_state, _block_index| {}),
-            kn_header_tip: Box::new(|_state, _height, _timestamp, _presync| {}),
-            kn_progress: Box::new(|_title, _progress, _resume_possible| {}),
-            kn_warning_set: Box::new(|_warning, _message| {}),
-            kn_warning_unset: Box::new(|_warning| {}),
-            kn_flush_error: Box::new(|_message| {}),
-            kn_fatal_error: Box::new(|_message| {}),
-        }))
-        .build()
-        .unwrap()
+fn create_context(chain_type: ChainType) -> Arc<Context> {
+    Arc::new(
+        ContextBuilder::new()
+            .chain_type(chain_type)
+            .kn_callbacks(Box::new(KernelNotificationInterfaceCallbackHolder {
+                kn_block_tip: Box::new(|_state, _block_index| {}),
+                kn_header_tip: Box::new(|_state, _height, _timestamp, _presync| {}),
+                kn_progress: Box::new(|_title, _progress, _resume_possible| {}),
+                kn_warning_set: Box::new(|_warning, _message| {}),
+                kn_warning_unset: Box::new(|_warning| {}),
+                kn_flush_error: Box::new(|_message| {}),
+                kn_fatal_error: Box::new(|_message| {}),
+            }))
+            .build()
+            .unwrap(),
+    )
 }
 
 #[derive(Debug, Arbitrary)]
@@ -82,7 +84,8 @@ fuzz_target!(|data: ChainstateManagerInput| {
         Err(err) => panic!("this should never happen: {}", err),
     };
     let blockman_opts = BlockManagerOptions::new(&context, &blocks_dir).unwrap();
-    let chainman = ChainstateManager::new(chainman_opts, blockman_opts, &context).unwrap();
+    let chainman =
+        ChainstateManager::new(chainman_opts, blockman_opts, Arc::clone(&context)).unwrap();
 
     match chainman.load_chainstate(
         ChainstateLoadOptions::new()

src/lib.rs

@@ -6,6 +6,7 @@ use std::ffi::{CStr, CString, NulError};
 use std::fmt;
 use std::marker::PhantomData;
 use std::os::raw::{c_char, c_void};
+use std::sync::Arc;
 
 use libbitcoinkernel_sys::*;
 
@@ -297,9 +298,12 @@ impl Drop for ChainParams {
 /// The main context struct. This should be setup through the [`ContextBuilder`] and
 /// has to be kept in memory for the duration of context-dependent library
 /// operations.
+///
 pub struct Context {
     inner: *mut kernel_Context,
-    pub kn_callbacks: Box<KernelNotificationInterfaceCallbackHolder>,
+    // We need something to hold this in memory.
+    #[allow(dead_code)]
+    kn_callbacks: Option<Box<KernelNotificationInterfaceCallbackHolder>>,
 }
 
 unsafe impl Send for Context {}
@@ -350,7 +354,7 @@ impl ContextBuilder {
         unsafe { kernel_context_options_destroy(self.inner) };
         Ok(Context {
             inner,
-            kn_callbacks: self.kn_callbacks.unwrap(),
+            kn_callbacks: self.kn_callbacks,
         })
     }
 
@@ -773,24 +777,24 @@ impl Drop for Block {
 /// tree once it is loaded. The [`BlockIndex`] points to an entry in this tree.
 /// It is only valid as long as the [`ChainstateManager`] it was retrieved from
 /// remains in scope.
-pub struct BlockIndex<'a> {
+pub struct BlockIndex {
     inner: *mut kernel_BlockIndex,
-    marker: PhantomData<ChainstateManager<'a>>,
+    marker: PhantomData<ChainstateManager>,
 }
 
-unsafe impl Send for BlockIndex<'_> {}
-unsafe impl Sync for BlockIndex<'_> {}
+unsafe impl Send for BlockIndex {}
+unsafe impl Sync for BlockIndex {}
 
 /// A type for a Block hash.
 #[derive(Debug, Clone)]
 pub struct BlockHash {
     pub hash: [u8; 32],
 }
 
-impl<'a> BlockIndex<'a> {
+impl BlockIndex {
     /// Move to the previous entry in the block tree. E.g. from height n to
     /// height n-1.
-    pub fn prev(self) -> Result<BlockIndex<'a>, KernelError> {
+    pub fn prev(self) -> Result<BlockIndex, KernelError> {
         let inner = unsafe { kernel_get_previous_block_index(self.inner) };
         if inner.is_null() {
             return Err(KernelError::OutOfBounds);
@@ -808,7 +812,7 @@ impl<'a> BlockIndex<'a> {
     }
 
     /// Get the current block hash associated with this BlockIndex.
-    pub fn info(&self) -> BlockHash {
+    pub fn block_hash(&self) -> BlockHash {
         let hash = unsafe { kernel_block_index_get_block_hash(self.inner) };
         let res = BlockHash {
             hash: unsafe { (&*hash).hash },
@@ -818,7 +822,7 @@ impl<'a> BlockIndex<'a> {
     }
 }
 
-impl<'a> Drop for BlockIndex<'a> {
+impl<'a> Drop for BlockIndex {
     fn drop(&mut self) {
         unsafe { kernel_block_index_destroy(self.inner) };
     }
@@ -996,19 +1000,19 @@ impl Drop for ChainstateLoadOptions {
 /// was created remains in memory.
 ///
 /// Its functionality will be more and more exposed in the future.
-pub struct ChainstateManager<'a> {
+pub struct ChainstateManager {
     inner: *mut kernel_ChainstateManager,
-    context: &'a Context,
+    context: Arc<Context>,
 }
 
-unsafe impl Send for ChainstateManager<'_> {}
-unsafe impl Sync for ChainstateManager<'_> {}
+unsafe impl Send for ChainstateManager {}
+unsafe impl Sync for ChainstateManager {}
 
-impl<'a> ChainstateManager<'a> {
+impl<'a> ChainstateManager {
     pub fn new(
         chainman_opts: ChainstateManagerOptions,
         blockman_opts: BlockManagerOptions,
-        context: &'a Context,
+        context: Arc<Context>,
     ) -> Result<Self, KernelError> {
         let inner = unsafe {
             kernel_chainstate_manager_create(
@@ -1178,7 +1182,7 @@ impl<'a> ChainstateManager<'a> {
     }
 }
 
-impl<'a> Drop for ChainstateManager<'a> {
+impl Drop for ChainstateManager {
     fn drop(&mut self) {
         unsafe {
             kernel_chainstate_manager_destroy(self.inner, self.context.inner);

tests/test.rs

@@ -11,7 +11,7 @@ mod tests {
     };
     use std::fs::File;
     use std::io::{BufRead, BufReader};
-    use std::sync::Once;
+    use std::sync::{Arc, Once};
     use tempdir::TempDir;
 
     struct TestLog {}
@@ -78,11 +78,11 @@ mod tests {
         validation_interface
     }
 
-    fn testing_setup() -> (Context, ValidationInterfaceWrapper, String) {
+    fn testing_setup() -> (Arc<Context>, ValidationInterfaceWrapper, String) {
         START.call_once(|| {
             setup_logging();
         });
-        let context = create_context();
+        let context = Arc::new(create_context());
         let validation_interface = setup_validation_interface(&context);
 
         let temp_dir = TempDir::new("test_chainman_regtest").unwrap();
@@ -114,7 +114,7 @@ mod tests {
             let chainman = ChainstateManager::new(
                 ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
                 BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-                &context,
+                Arc::clone(&context),
             )
             .unwrap();
             chainman
@@ -129,7 +129,7 @@ mod tests {
         let chainman = ChainstateManager::new(
             ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
             BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-            &context,
+            Arc::clone(&context),
         )
         .unwrap();
         chainman
@@ -148,7 +148,7 @@ mod tests {
             let chainman = ChainstateManager::new(
                 ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
                 BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-                &context,
+                Arc::clone(&context),
             )
             .unwrap();
             chainman
@@ -181,6 +181,7 @@ mod tests {
 
     #[test]
     fn test_scan_tx() {
+        #[allow(dead_code)]
         #[derive(Debug)]
         struct Input {
             prevout: Vec<u8>,
@@ -191,6 +192,7 @@ mod tests {
         #[derive(Debug)]
         struct ScanTxHelper {
             ins: Vec<Input>,
+            #[allow(dead_code)]
             outs: Vec<Vec<u8>>,
         }
 
@@ -200,7 +202,7 @@ mod tests {
         let chainman = ChainstateManager::new(
             ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
             BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-            &context,
+            Arc::clone(&context),
         )
         .unwrap();
         chainman
@@ -271,7 +273,7 @@ mod tests {
         let chainman = ChainstateManager::new(
             ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
             BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-            &context,
+            Arc::clone(&context),
         )
         .unwrap();
         chainman
@@ -294,7 +296,7 @@ mod tests {
         let chainman = ChainstateManager::new(
             ChainstateManagerOptions::new(&context, &data_dir).unwrap(),
             BlockManagerOptions::new(&context, &blocks_dir).unwrap(),
-            &context,
+            Arc::clone(&context),
         )
         .unwrap();
         chainman