Spawn empty relayer, and one client per configured chain

relayer/cli/src/commands/light/init.rs

@@ -1,16 +1,23 @@
 use std::future::Future;
+use std::time::{Duration, SystemTime};
 
 // use crate::application::APPLICATION;
 use crate::prelude::*;
 
 use abscissa_core::{Command, Options, Runnable};
 
-use relayer::config::Config;
-
 use tendermint::chain::Id as ChainId;
 use tendermint::hash::Hash;
+use tendermint::lite::types::Header;
 use tendermint::lite::Height;
 
+use relayer::chain::tendermint::TendermintChain;
+use relayer::chain::Chain;
+use relayer::client::{trust_options::TrustOptions, Client};
+use relayer::config::{ChainConfig, Config};
+use relayer::store::mem::MemStore;
+use relayer::store::Store;
+
 #[derive(Command, Debug, Options)]
 pub struct InitCmd {
     #[options(free, help = "identifier of the chain to initialize light client for")]
@@ -23,7 +30,7 @@ pub struct InitCmd {
     height: Option<Height>,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 struct InitOptions {
     /// identifier of chain to initialize light client for
     chain_id: ChainId,
@@ -66,29 +73,67 @@ impl Runnable for InitCmd {
         // FIXME: This just hangs and never runs the given future
         // abscissa_tokio::run(&APPLICATION, run_init(&*config, opts)).unwrap();
 
-        block_on(run_init(&*config, opts));
+        block_on(run_init(config.clone(), opts));
     }
 }
 
-pub fn block_on<F: Future>(future: F) -> F::Output {
-    tokio::runtime::Builder::new()
-        .basic_scheduler()
-        .enable_all()
-        .build()
-        .unwrap()
-        .block_on(future)
+async fn run_init(config: Config, opts: InitOptions) {
+    status_info!("Options", "{:?}", opts);
+
+    for chain_config in config.chains {
+        let opts = opts.clone();
+
+        status_info!(
+            "Relayer",
+            "Spawning light client for chain {}",
+            chain_config.id
+        );
+
+        let _handle = tokio::spawn(async move {
+            let client = create_client(chain_config, opts).await;
+            update_headers(client).await;
+        });
+    }
+
+    start_relayer().await
 }
 
-async fn run_init(config: &Config, opts: InitOptions) {
-    use relayer::chain::tendermint::TendermintChain;
-    use relayer::client::{trust_options::TrustOptions, Client};
-    use relayer::store::mem::MemStore;
+async fn start_relayer() {
+    let mut interval = tokio::time::interval(Duration::from_secs(3));
 
-    status_info!("Options", "{:?}", opts);
+    loop {
+        interval.tick().await;
+        status_info!("Relayer", "Relayer is running")
+    }
+}
+
+async fn update_headers<C: Chain, S: Store<C>>(mut client: Client<C, S>) {
+    let mut interval = tokio::time::interval(Duration::from_secs(3));
+
+    loop {
+        let result = client.update(SystemTime::now()).await;
+        match result {
+            Ok(Some(trusted_state)) => status_ok!(
+                client.chain().id(),
+                "Updated to trusted state: {} at {}",
+                trusted_state.header().hash(),
+                trusted_state.header().height()
+            ),
+
+            Ok(None) => status_info!(client.chain().id(), "Ignoring update to a previous state"),
+            Err(err) => status_info!(client.chain().id(), "Error when updating headers: {}", err),
+        }
 
-    let chain_config = config.chains[0].clone();
+        interval.tick().await;
+    }
+}
+
+async fn create_client(
+    chain_config: ChainConfig,
+    opts: InitOptions,
+) -> Client<TendermintChain, MemStore<TendermintChain>> {
+    let store = MemStore::new();
 
-    let store = MemStore::<TendermintChain>::new();
     let trust_options = TrustOptions::new(
         opts.trusted_hash,
         opts.trusted_height,
@@ -98,11 +143,15 @@ async fn run_init(config: &Config, opts: InitOptions) {
     .unwrap();
 
     let chain = TendermintChain::from_config(chain_config).unwrap();
-    let client = Client::new(chain, store, trust_options).await.unwrap();
 
-    status_ok!(
-        "Success",
-        "Last trusted state:\n{:#?}",
-        client.last_trusted_state()
-    );
+    Client::new(chain, store, trust_options).await.unwrap()
+}
+
+fn block_on<F: Future>(future: F) -> F::Output {
+    tokio::runtime::Builder::new()
+        .basic_scheduler()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(future)
 }

relayer/relay/src/client.rs

@@ -63,6 +63,10 @@ where
         self.last_trusted_state.as_ref()
     }
 
+    pub fn chain(&self) -> &Chain {
+        &self.chain
+    }
+
     pub async fn update(
         &mut self,
         now: SystemTime,

relayer/relay/tests/config/fixtures/relayer_conf_example.toml

@@ -19,7 +19,8 @@ strategy = "naive"
 
 [[chains]]
   id = "chain-B"
-  rpc_addr = "localhost:26557"
+  # rpc_addr = "localhost:26557"
+  rpc_addr = "localhost:26657"
   account_prefix = "cosmos"
   key_name = "testkey"
   client_ids = ["clB1"]