fix: move Halt and resume full nodes to be ChainDriver components (#636)

* Move Halt and resume full nodes to be ChainDriver components

* Add ResumeFullNodeOptions

* Fix misbehaviour test

* Add logs when failing to submit misbehaviour

Author: ljoss17

crates/cosmos/cosmos-integration-tests/src/contexts/binary_channel/test_driver.rs

@@ -11,8 +11,7 @@ use hermes_core::test_components::driver::traits::{
 };
 use hermes_core::test_components::setup::traits::{
     CreateClientMessageOptionsGetterAtComponent, CreateClientPayloadOptionsGetterAtComponent,
-    FullNodeForkerComponent, FullNodeHalterComponent, PortIdGetterAtComponent,
-    RecoverClientPayloadOptionsGetterAtComponent,
+    FullNodeForkerComponent, PortIdGetterAtComponent, RecoverClientPayloadOptionsGetterAtComponent,
 };
 use hermes_core::test_components::test_case::traits::recover_client::RecoverClientHandlerComponent;
 use hermes_cosmos_core::chain_components::impls::CosmosRecoverClientPayload;
@@ -70,7 +69,6 @@ delegate_components! {
             RecoverClientWithProposals,
         [
             FullNodeForkerComponent,
-            FullNodeHalterComponent,
         ]:
             ForkSecondFullNode,
         ChainDriverGetterAtComponent<Index<0>>:

crates/cosmos/cosmos-integration-tests/src/contexts/chain_driver.rs

@@ -19,6 +19,7 @@ use hermes_core::test_components::chain_driver::traits::{
     StakingDenom, TransferDenom, UserWallet, ValidatorWallet, WalletGetterComponent,
     WalletsGetterComponent,
 };
+use hermes_core::test_components::test_case::traits::node::FullNodeHalterComponent;
 use hermes_core::test_components::test_case::traits::upgrade_client::{
     SetupUpgradeClientTestHandlerComponent, UpgradeClientHandlerComponent,
 };
@@ -49,6 +50,8 @@ use hermes_runtime::types::runtime::HermesRuntime;
 use tokio::process::Child;
 use toml::to_string_pretty;
 
+use crate::impls::HaltCosmosFullNode;
+
 /**
    A chain driver for adding test functionalities to a Cosmos chain.
 */
@@ -84,6 +87,8 @@ delegate_components! {
             CosmosHandleUpgradeClient,
         SetupUpgradeClientTestHandlerComponent:
             SetupCosmosUpgradeClientTest,
+        FullNodeHalterComponent:
+            HaltCosmosFullNode,
         LoggerComponent:
             TracingLogger,
         WalletsGetterComponent:

crates/cosmos/cosmos-integration-tests/src/impls/fork.rs

@@ -1,13 +1,9 @@
 use alloc::sync::Arc;
 use core::str::FromStr;
-use std::path::PathBuf;
 
 use cgp::extra::runtime::HasRuntime;
-use eyre::eyre;
-use hermes_core::runtime_components::traits::{CanCreateDir, CanExecCommand, CanSleep};
-use hermes_core::test_components::setup::traits::{
-    FullNodeForker, FullNodeForkerComponent, FullNodeHalter, FullNodeHalterComponent,
-};
+use hermes_core::runtime_components::traits::{CanCreateDir, CanSleep};
+use hermes_core::test_components::setup::traits::{FullNodeForker, FullNodeForkerComponent};
 use hermes_cosmos_core::test_components::bootstrap::traits::CanStartChainFullNodes;
 use hermes_cosmos_relayer::contexts::{CosmosBuilder, CosmosChain};
 use hermes_error::HermesError;
@@ -21,47 +17,6 @@ use crate::impls::copy_dir_recursive;
 
 pub struct ForkSecondFullNode;
 
-#[cgp_provider(FullNodeHalterComponent)]
-impl FullNodeHalter<CosmosBinaryChannelTestDriver> for ForkSecondFullNode {
-    async fn halt_full_node(
-        driver: &CosmosBinaryChannelTestDriver,
-        chain_id: String,
-    ) -> Result<(), HermesError> {
-        let runtime = driver.chain_driver_a.chain.runtime.clone();
-        let node_pid = if chain_id == driver.chain_driver_a.chain.chain_id.to_string() {
-            driver
-                .chain_driver_a
-                .chain_processes
-                .first()
-                .expect("Failed to retrieve Chain Driver A chain process")
-                .id()
-                .expect("failed to retrieve Chain Driver A chain process ID")
-        } else if chain_id == driver.chain_driver_b.chain.chain_id.to_string() {
-            driver
-                .chain_driver_b
-                .chain_processes
-                .first()
-                .expect("Failed to retrieve Chain Driver B chain process")
-                .id()
-                .expect("failed to retrieve Chain Driver B chain process ID")
-        } else {
-            return Err(eyre!("Unknown chain ID: {chain_id}").into());
-        };
-
-        // Stop full node
-        // `kill` is used here instead of `Child::kill()` as the `kill()` method requires
-        // the child process to be mutable.
-        runtime
-            .exec_command(
-                &PathBuf::from("kill".to_string()),
-                &["-s", "KILL", &node_pid.to_string()],
-            )
-            .await?;
-
-        Ok(())
-    }
-}
-
 #[cgp_provider(FullNodeForkerComponent)]
 impl FullNodeForker<CosmosBinaryChannelTestDriver> for ForkSecondFullNode {
     async fn fork_full_node(

crates/cosmos/cosmos-integration-tests/src/impls/mod.rs

@@ -10,6 +10,9 @@ pub use fork::*;
 mod init_channel_options;
 pub use init_channel_options::*;
 
+mod node;
+pub use node::*;
+
 mod test_driver;
 pub use test_driver::*;
 

crates/cosmos/cosmos-integration-tests/src/impls/node.rs

@@ -0,0 +1,35 @@
+use std::path::PathBuf;
+
+use hermes_core::runtime_components::traits::CanExecCommand;
+use hermes_core::test_components::test_case::traits::node::{
+    FullNodeHalter, FullNodeHalterComponent,
+};
+use hermes_error::HermesError;
+use hermes_prelude::*;
+
+use crate::contexts::CosmosChainDriver;
+
+#[cgp_new_provider(FullNodeHalterComponent)]
+impl FullNodeHalter<CosmosChainDriver> for HaltCosmosFullNode {
+    async fn halt_full_node(chain_driver: &CosmosChainDriver) -> Result<(), HermesError> {
+        let runtime = chain_driver.chain.runtime.clone();
+        let node_pid = chain_driver
+            .chain_processes
+            .first()
+            .expect("Failed to retrieve Chain Driver A chain process")
+            .id()
+            .expect("failed to retrieve Chain Driver A chain process ID");
+
+        // Stop full node
+        // `kill` is used here instead of `Child::kill()` as the `kill()` method requires
+        // the child process to be mutable.
+        runtime
+            .exec_command(
+                &PathBuf::from("kill".to_string()),
+                &["-s", "KILL", &node_pid.to_string()],
+            )
+            .await?;
+
+        Ok(())
+    }
+}

crates/relayer/relayer-components/src/relay/impls/event_relayers/packet_event.rs

@@ -110,10 +110,25 @@ where
                         .await
                         .map_err(Relay::raise_error)?;
 
-                    src_chain
+                    if let Err(e) = src_chain
                         .send_message(msg)
                         .await
-                        .map_err(Relay::raise_error)?;
+                        .map_err(Relay::raise_error)
+                    {
+                        relay
+                            .log(
+                                &format!("Failed to submit misbeahviour message: {e:?}"),
+                                &LevelWarn,
+                            )
+                            .await;
+                    } else {
+                        relay
+                        .log(
+                            &format!("Successfully submitted misbehaviour message for client {src_client_id}"),
+                            &LevelDebug,
+                        )
+                        .await;
+                    }
                 }
                 Ok(None) => {
                     relay.log("no misbehaviour detected", &LevelDebug).await;

crates/test/test-components/src/setup/traits/node.rs

@@ -10,21 +10,3 @@ use hermes_prelude::*;
 pub trait CanForkFullNode: HasAsyncErrorType + Async + Sized {
     async fn fork_full_node(&self, chain_id: String) -> Result<Self, Self::Error>;
 }
-
-#[cgp_component {
-  provider: FullNodeHalter,
-  context: Driver,
-}]
-#[async_trait]
-pub trait CanHaltFullNode: HasAsyncErrorType + Async + Sized {
-    async fn halt_full_node(&self, chain_id: String) -> Result<(), Self::Error>;
-}
-
-#[cgp_component {
-  provider: FullNodeResumer,
-  context: Driver,
-}]
-#[async_trait]
-pub trait CanResumeFullNode: HasAsyncErrorType + Async + Sized {
-    async fn resume_full_node(&self, chain_id: String) -> Result<Self, Self::Error>;
-}

crates/test/test-components/src/test_case/traits/mod.rs

@@ -1,3 +1,4 @@
+pub mod node;
 pub mod recover_client;
 pub mod test_case;
 pub mod upgrade_client;

crates/test/test-components/src/test_case/traits/node.rs

@@ -0,0 +1,27 @@
+use hermes_prelude::*;
+
+#[cgp_component {
+  provider: FullNodeHalter,
+  context: ChainDriver,
+}]
+#[async_trait]
+pub trait CanHaltFullNode: HasAsyncErrorType {
+    async fn halt_full_node(&self) -> Result<(), Self::Error>;
+}
+
+#[cgp_component {
+  provider: FullNodeResumer,
+  context: ChainDriver,
+}]
+#[async_trait]
+pub trait CanResumeFullNode: HasResumeFullNodeOptionsType + HasAsyncErrorType + Sized {
+    async fn resume_full_node(
+        &self,
+        options: &Self::ResumeFullNodeOptions,
+    ) -> Result<Self, Self::Error>;
+}
+
+#[cgp_type]
+pub trait HasResumeFullNodeOptionsType {
+    type ResumeFullNodeOptions: Async;
+}

crates/test/test-suite/src/tests/misebehaviour.rs

@@ -9,7 +9,8 @@ use hermes_chain_components::traits::{
 };
 use hermes_prelude::*;
 use hermes_test_components::relay_driver::run::CanRunRelayerInBackground;
-use hermes_test_components::setup::traits::{CanForkFullNode, CanHaltFullNode};
+use hermes_test_components::setup::traits::CanForkFullNode;
+use hermes_test_components::test_case::traits::node::CanHaltFullNode;
 use hermes_test_components::test_case::traits::test_case::TestCase;
 
 use crate::traits::CanUseBinaryTestDriverMethods;
@@ -24,16 +25,16 @@ impl<A, B> Default for TestMisbehaviourDetection<A, B> {
 
 impl<Driver, A, B> TestCase<Driver> for TestMisbehaviourDetection<A, B>
 where
-    Driver: CanUseBinaryTestDriverMethods<A, B>
-        + CanForkFullNode
-        + CanHaltFullNode
-        + CanRaiseAsyncError<&'static str>,
+    Driver:
+        CanUseBinaryTestDriverMethods<A, B> + CanForkFullNode + CanRaiseAsyncError<&'static str>,
     A: Async,
     B: Async,
 {
     async fn run_test(&self, driver: &Driver) -> Result<(), Driver::Error> {
         let relay_driver = driver.relay_driver();
 
+        let chain_driver_b = driver.chain_driver_b();
+
         let chain_a = driver.chain_a();
 
         let client_id_a = driver.client_id_a();
@@ -44,9 +45,10 @@ where
 
         tokio::time::sleep(Duration::from_secs(10)).await;
 
-        driver
-            .halt_full_node(driver.chain_b().chain_id().to_string())
-            .await?;
+        chain_driver_b
+            .halt_full_node()
+            .await
+            .map_err(Driver::raise_error)?;
 
         let forked_setup = driver
             .fork_full_node(driver.chain_b().chain_id().to_string())