Tests: Async DaemonRunner for BitcoinD

I've created a DaemonRunner for `bitcoind`. It does support async

Author: ErikDeSmedt

Cargo.lock

@@ -4,7 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+anyhow.workspace= true
 bitcoin.workspace = true
+env_logger.workspace = true
 log.workspace = true
+portpicker = "0.1.1"
 rand.workspace = true
+regex = "1.10.5"
 tokio.workspace = true
+which = "6.0.1"

ark-testing/Cargo.toml

@@ -1,3 +1,6 @@
 pub mod env {
 	pub const TEST_LEAVE_INTACT : &str = "TEST_LEAVE_INTACT";
+	pub const BITCOIND_EXEC: &str = "BITCOIND_EXEC";
+	pub const BARK_EXEC: &str = "BARK_EXE";
+	pub const ASPD_EXEC: &str = "ASPD_EXE";
 }

ark-testing/src/constants.rs

@@ -6,14 +6,14 @@ use crate::constants;
 
 pub struct TestContext {
 	#[allow(dead_code)]
-	name: String,
-	datadir: PathBuf
+	pub name: String,
+	pub datadir: PathBuf
 }
 
 impl TestContext {
-
 	pub fn new(name: String, base_path: PathBuf) -> Self {
 		fs::create_dir_all(base_path.clone()).unwrap();
+		crate::util::init_logging().expect("Logging can be initialized");
 		TestContext { name, datadir: base_path}
 	}
 
@@ -31,10 +31,11 @@ impl Drop for TestContext {
 		// test-data.
 
 		if std::env::var(constants::env::TEST_LEAVE_INTACT).is_ok() {
+			log::info!("Textcontext: Leave intact at {:?}", self.datadir);
 			return
 		}
 		if self.datadir.exists() {
-			log::info!("Test clean-up");
+			log::trace!("Testcontext: Clean up datadir at {:?}", self.datadir);
 			std::fs::remove_dir_all(self.datadir.clone()).unwrap();
 		}
 	}

ark-testing/src/context.rs

@@ -0,0 +1,109 @@
+use crate::daemon::{DaemonWrapper, DaemonHelper};
+use crate::constants::env::{BITCOIND_EXEC, TEST_LEAVE_INTACT};
+
+use anyhow::Context;
+use std::path::PathBuf;
+use std::env::VarError;
+use which::which;
+use tokio::sync::broadcast;
+
+pub struct BitcoinDHelper {
+	name : String,
+	bitcoind_exec: PathBuf,
+	config: BitcoinDConfig,
+	state: BitcoinDState,
+}
+
+pub struct BitcoinDConfig {
+	pub datadir: PathBuf,
+	pub txindex: bool,
+	pub network: String,
+}
+
+impl Default for BitcoinDConfig {
+
+	fn default() -> Self {
+		Self {
+			datadir: PathBuf::from("~/.bitcoin"),
+			txindex: false,
+			network: String::from("regtest")
+		}
+	}
+}
+
+#[derive(Default)]
+pub struct BitcoinDState {
+	rpc_port: Option<u16>,
+	p2p_port: Option<u16>,
+}
+
+pub type BitcoinD = DaemonWrapper<BitcoinDHelper, BitcoinDState>;
+
+pub fn get_exe_path() -> anyhow::Result<PathBuf> {
+		match std::env::var(&BITCOIND_EXEC) {
+			Ok(var) => which(var).context("Failed to find binary path from `BITCOIND_EXEC`"),
+			Err(VarError::NotPresent) => which("bitcoind").context("Failed to find `bitcoind` installation"),
+			_ => anyhow::bail!("BITCOIND_EXEC is not valid unicode")
+		}
+}
+
+impl BitcoinD {
+
+	pub fn new(name: String, bitcoind_exec: PathBuf, config: BitcoinDConfig) -> Self {
+		let state = BitcoinDState::default();
+		let inner = BitcoinDHelper { name, bitcoind_exec, config, state};
+		DaemonWrapper::wrap(inner)
+	}
+
+}
+
+impl DaemonHelper for BitcoinDHelper {
+	type State = BitcoinDState;
+
+	fn name(&self) -> &str {
+		&self.name
+	}
+
+	async fn make_reservations(&mut self) -> anyhow::Result<()> {
+		self.state.rpc_port = Some(portpicker::pick_unused_port().expect("A port is free"));
+		self.state.p2p_port = Some(portpicker::pick_unused_port().expect("A port is free"));
+
+		Ok(())
+	}
+	async fn prepare(&self) -> anyhow::Result<()> {
+		debug!("Creating bitcoind datadir in {:?}", self.config.datadir.clone());
+		std::fs::create_dir_all(self.config.datadir.clone())?;
+		Ok(())
+	}
+
+	async fn get_command(&self) -> anyhow::Result<tokio::process::Command> {
+		let mut cmd = tokio::process::Command::new(self.bitcoind_exec.clone());
+		cmd
+			.arg(format!("--{}", self.config.network))
+			.arg(format!("-datadir={}", self.config.datadir.display().to_string()))
+			.arg(format!("-txindex={}", self.config.txindex))
+			.arg(format!("-rpcport={}", self.state.rpc_port.expect("A port has been picked")))
+			.arg(format!("-port={}", self.state.p2p_port.expect("A port has been picked")));
+
+		Ok(cmd)
+	}
+
+	async fn request_stop(&self) -> anyhow::Result<()> {
+		Ok(())
+	}
+
+	async fn wait_for_init(&self, stdout_rx: &mut broadcast::Receiver::<String>, _: &mut broadcast::Receiver::<String>) -> anyhow::Result<()> {
+		// TODO: We can find a better implementation here
+
+		// Sleeping 2 seconds is always sufficient
+		// However, this makes our tests slow
+		tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+
+		// The bitcoind create tries to ping the json-rpc frequently
+		// It will continue once a call to `getblockchaininfo` has succeeded
+
+		// An other approach is to look at the logs and identify the correct port
+
+		return Ok(())
+	}
+}