cuprated: Add graceful shutdown, pt2: service error propagation

binaries/cuprated/Cargo.toml

@@ -7,6 +7,12 @@ license = "AGPL-3.0-only"
 authors = ["Boog900", "hinto-janai", "SyntheticBird45"]
 repository = "https://github.com/Cuprate/cuprate/tree/main/binaries/cuprated"
 
+[lib]
+name = "cuprated"
+
+[[bin]]
+name = "cuprated"
+
 [features]
 default = ["arti"]
 arti = ["arti-client", "tor-hsservice", "tor-persist", "tor-rtcompat", "cuprate-p2p-transport/arti"]

binaries/cuprated/src/blockchain.rs

@@ -17,36 +17,34 @@ use cuprate_types::{
     VerifiedBlockInformation,
 };
 
-use crate::constants::PANIC_CRITICAL_SERVICE_ERROR;
-
 mod chain_service;
 mod fast_sync;
 pub mod interface;
 mod manager;
 mod syncer;
 mod types;
 
-pub use fast_sync::set_fast_sync_hashes;
-pub use manager::init_blockchain_manager;
-pub use syncer::SyncNotify;
+pub use fast_sync::get_fast_sync_hashes;
+pub use interface::BlockchainManagerHandle;
+pub use manager::{init_blockchain_manager, IncomingBlockError, IncomingBlockOk};
+pub use syncer::{Syncer, SyncerHandle};
 pub use types::ConsensusBlockchainReadHandle;
 
 /// Checks if the genesis block is in the blockchain and adds it if not.
 pub async fn check_add_genesis(
     blockchain_read_handle: &mut BlockchainReadHandle,
     blockchain_write_handle: &mut BlockchainWriteHandle,
     network: Network,
-) {
+) -> anyhow::Result<()> {
     // Try to get the chain height, will fail if the genesis block is not in the DB.
     if blockchain_read_handle
         .ready()
-        .await
-        .expect(PANIC_CRITICAL_SERVICE_ERROR)
+        .await?
         .call(BlockchainReadRequest::ChainHeight)
         .await
         .is_ok()
     {
-        return;
+        return Ok(());
     }
 
     let genesis = generate_genesis_block(network);
@@ -56,8 +54,7 @@ pub async fn check_add_genesis(
 
     blockchain_write_handle
         .ready()
-        .await
-        .expect(PANIC_CRITICAL_SERVICE_ERROR)
+        .await?
         .call(BlockchainWriteRequest::WriteBlock(
             VerifiedBlockInformation {
                 block_blob: genesis.serialize(),
@@ -74,8 +71,9 @@ pub async fn check_add_genesis(
                 block: genesis,
             },
         ))
-        .await
-        .expect(PANIC_CRITICAL_SERVICE_ERROR);
+        .await?;
+
+    Ok(())
 }
 
 /// Initializes the consensus services.

binaries/cuprated/src/blockchain/chain_service.rs

@@ -14,15 +14,18 @@ use cuprate_types::blockchain::{BlockchainReadRequest, BlockchainResponse};
 ///
 /// This has a more minimal interface than [`BlockchainReadRequest`] to make using the p2p crates easier.
 #[derive(Clone)]
-pub struct ChainService(pub BlockchainReadHandle);
+pub struct ChainService {
+    pub blockchain_read: BlockchainReadHandle,
+    pub fast_sync_hashes: &'static [[u8; 32]],
+}
 
 impl<N: NetworkZone> Service<ChainSvcRequest<N>> for ChainService {
     type Response = ChainSvcResponse<N>;
     type Error = tower::BoxError;
     type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.poll_ready(cx).map_err(Into::into)
+        self.blockchain_read.poll_ready(cx).map_err(Into::into)
     }
 
     fn call(&mut self, req: ChainSvcRequest<N>) -> Self::Future {
@@ -42,21 +45,20 @@ impl<N: NetworkZone> Service<ChainSvcRequest<N>> for ChainService {
             _ => unreachable!(),
         };
 
+        let mut blockchain_read = self.blockchain_read.clone();
+
         match req {
-            ChainSvcRequest::CompactHistory => self
-                .0
+            ChainSvcRequest::CompactHistory => blockchain_read
                 .call(BlockchainReadRequest::CompactChainHistory)
                 .map_ok(map_res)
                 .map_err(Into::into)
                 .boxed(),
-            ChainSvcRequest::FindFirstUnknown(req) => self
-                .0
+            ChainSvcRequest::FindFirstUnknown(req) => blockchain_read
                 .call(BlockchainReadRequest::FindFirstUnknown(req))
                 .map_ok(map_res)
                 .map_err(Into::into)
                 .boxed(),
-            ChainSvcRequest::CumulativeDifficulty => self
-                .0
+            ChainSvcRequest::CumulativeDifficulty => blockchain_read
                 .call(BlockchainReadRequest::CompactChainHistory)
                 .map_ok(|res| {
                     // TODO create a custom request instead of hijacking this one.
@@ -74,12 +76,16 @@ impl<N: NetworkZone> Service<ChainSvcRequest<N>> for ChainService {
                 .map_err(Into::into)
                 .boxed(),
             ChainSvcRequest::ValidateEntries(entries, start_height) => {
-                let mut blockchain_read_handle = self.0.clone();
+                let fast_sync_hashes = self.fast_sync_hashes;
 
                 async move {
-                    let (valid, unknown) =
-                        validate_entries(entries, start_height, &mut blockchain_read_handle)
-                            .await?;
+                    let (valid, unknown) = validate_entries(
+                        entries,
+                        start_height,
+                        &mut blockchain_read,
+                        fast_sync_hashes,
+                    )
+                    .await?;
 
                     Ok(ChainSvcResponse::ValidateEntries { valid, unknown })
                 }

binaries/cuprated/src/blockchain/fast_sync.rs

@@ -7,13 +7,15 @@ use cuprate_helper::network::Network;
 /// See `build.rs` for how this file is generated.
 static FAST_SYNC_HASHES: &[[u8; 32]] = &include!(concat!(env!("OUT_DIR"), "/fast_sync_hashes.rs"));
 
-/// Set the fast-sync hashes according to the provided values.
-pub fn set_fast_sync_hashes(fast_sync: bool, network: Network) {
-    cuprate_fast_sync::set_fast_sync_hashes(if fast_sync && network == Network::Mainnet {
+/// Returns the fast-sync hashes for the given configuration.
+///
+/// Returns a non-empty slice only for mainnet with fast sync enabled.
+pub fn get_fast_sync_hashes(fast_sync: bool, network: Network) -> &'static [[u8; 32]] {
+    if fast_sync && network == Network::Mainnet {
         FAST_SYNC_HASHES
     } else {
         &[]
-    });
+    }
 }
 
 #[cfg(test)]