kaspa-consensus 0.0.2

Kaspa consensus library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use super::{factory::MultiConsensusManagementStore, Consensus};
use kaspa_consensusmanager::ConsensusCtl;
use kaspa_database::prelude::DB;
use parking_lot::RwLock;
use std::{
    path::PathBuf,
    sync::{Arc, Weak},
    thread::JoinHandle,
};

pub struct Ctl {
    management_store: Arc<RwLock<MultiConsensusManagementStore>>,
    consensus_db_ref: Weak<DB>,
    consensus_db_path: PathBuf,
    consensus: Arc<Consensus>,
}

impl Ctl {
    pub fn new(
        management_store: Arc<RwLock<MultiConsensusManagementStore>>,
        consensus_db: Arc<DB>,
        consensus: Arc<Consensus>,
    ) -> Self {
        let consensus_db_path = consensus_db.path().to_owned();
        let consensus_db_ref = Arc::downgrade(&consensus_db);
        Self { management_store, consensus_db_ref, consensus_db_path, consensus }
    }
}

impl ConsensusCtl for Ctl {
    fn start(&self) -> Vec<JoinHandle<()>> {
        self.consensus.run_processors()
    }

    fn stop(&self) {
        self.consensus.signal_exit()
    }

    fn make_active(&self) {
        // TODO: pass a value to make sure the correct consensus is committed
        self.management_store.write().commit_staging_consensus().unwrap();

        // TODO: delete previous active
    }

    fn delete(&self) {
        // TODO: see above
        self.management_store.write().cancel_staging_consensus().unwrap();

        // TODO: delete staging
        // for _ in 0..16 {
        //     if self.consensus_db_ref.strong_count() > 0 {
        //         // Sometimes another thread is shuting-down and cleaning resources
        //         std::thread::sleep(std::time::Duration::from_millis(500));
        //     } else {
        //         break;
        //     }
        // }
        // assert_eq!(self.consensus_db_ref.strong_count(), 0, "DB has strong references and cannot be deleted");
        // let options = rocksdb::Options::default();
        // DB::destroy(&options, self.consensus_db_path.clone())
        //     .expect("DB is expected to be deletable since there are no references to it");
    }
}

/// Impl for test purposes
impl ConsensusCtl for Consensus {
    fn start(&self) -> Vec<JoinHandle<()>> {
        self.run_processors()
    }

    fn stop(&self) {
        self.signal_exit()
    }

    fn make_active(&self) {
        unimplemented!()
    }

    fn delete(&self) {
        unimplemented!()
    }
}