xmr-btc-swap/swap/tests/harness/electrs.rs

150 lines
4.1 KiB
Rust
Raw Normal View History

use crate::harness::bitcoind;
use bitcoin::Network;
use std::collections::HashMap;
use testcontainers::core::{Container, Docker, WaitForMessage};
use testcontainers::Image;
pub const HTTP_PORT: u16 = 60401;
pub const RPC_PORT: u16 = 3002;
#[derive(Debug)]
pub struct Electrs {
tag: String,
args: ElectrsArgs,
entrypoint: Option<String>,
wait_for_message: String,
volume: String,
}
impl Image for Electrs {
type Args = ElectrsArgs;
type EnvVars = HashMap<String, String>;
type Volumes = HashMap<String, String>;
type EntryPoint = str;
fn descriptor(&self) -> String {
format!("vulpemventures/electrs:{}", self.tag)
}
fn wait_until_ready<D: Docker>(&self, container: &Container<'_, D, Self>) {
container
.logs()
.stderr
.wait_for_message(&self.wait_for_message)
.unwrap();
}
fn args(&self) -> <Self as Image>::Args {
self.args.clone()
}
fn volumes(&self) -> Self::Volumes {
let mut volumes = HashMap::new();
volumes.insert(self.volume.clone(), bitcoind::DATADIR.to_string());
volumes
}
fn env_vars(&self) -> Self::EnvVars {
HashMap::new()
}
fn with_args(self, args: <Self as Image>::Args) -> Self {
Electrs { args, ..self }
}
fn with_entrypoint(self, entrypoint: &Self::EntryPoint) -> Self {
Self {
entrypoint: Some(entrypoint.to_string()),
..self
}
}
fn entrypoint(&self) -> Option<String> {
self.entrypoint.to_owned()
}
}
impl Default for Electrs {
fn default() -> Self {
Electrs {
tag: "v0.16.0.3".into(),
args: ElectrsArgs::default(),
entrypoint: Some("/build/electrs".into()),
wait_for_message: "Running accept thread".to_string(),
volume: uuid::Uuid::new_v4().to_string(),
}
}
}
impl Electrs {
pub fn with_tag(self, tag_str: &str) -> Self {
Electrs {
tag: tag_str.to_string(),
..self
}
}
pub fn with_volume(mut self, volume: String) -> Self {
self.volume = volume;
self
}
pub fn with_daemon_rpc_addr(mut self, name: String) -> Self {
self.args.daemon_rpc_addr = name;
self
}
}
#[derive(Debug, Clone)]
pub struct ElectrsArgs {
pub network: Network,
pub daemon_dir: String,
pub daemon_rpc_addr: String,
pub cookie: String,
pub http_addr: String,
pub electrum_rpc_addr: String,
pub cors: String,
}
impl Default for ElectrsArgs {
fn default() -> Self {
// todo: these "defaults" are only suitable for our tests and need to be looked
// at
ElectrsArgs {
network: Network::Regtest,
daemon_dir: bitcoind::DATADIR.to_string(),
daemon_rpc_addr: format!("0.0.0.0:{}", bitcoind::RPC_PORT),
cookie: format!("{}:{}", bitcoind::RPC_USER, bitcoind::RPC_PASSWORD),
http_addr: format!("0.0.0.0:{}", HTTP_PORT),
electrum_rpc_addr: format!("0.0.0.0:{}", RPC_PORT),
cors: "*".to_string(),
}
}
}
impl IntoIterator for ElectrsArgs {
type Item = String;
type IntoIter = ::std::vec::IntoIter<String>;
fn into_iter(self) -> <Self as IntoIterator>::IntoIter {
let mut args = Vec::new();
match self.network {
Network::Testnet => args.push("--network=testnet".to_string()),
Network::Regtest => args.push("--network=regtest".to_string()),
Network::Bitcoin => {}
Network::Signet => panic!("signet not yet supported"),
}
args.push("-vvvvv".to_string());
args.push(format!("--daemon-dir=={}", self.daemon_dir.as_str()));
args.push(format!("--daemon-rpc-addr={}", self.daemon_rpc_addr));
args.push(format!("--cookie={}", self.cookie));
args.push(format!("--http-addr={}", self.http_addr));
args.push(format!("--electrum-rpc-addr={}", self.electrum_rpc_addr));
args.push(format!("--cors={}", self.cors));
args.into_iter()
}
}