fix(tests): stabilize multi-gateway integration

Author: sanity

apps/freenet-ping/app/tests/common/mod.rs

@@ -208,13 +208,23 @@ pub(crate) enum PackageType {
     Delegate,
 }
 
+const CONTRACT_EXTRA_FEATURES: [&str; 1] = ["contract"];
+const NO_EXTRA_FEATURES: [&str; 0] = [];
+
 impl PackageType {
     pub fn feature(&self) -> &'static str {
         match self {
             PackageType::Contract => "freenet-main-contract",
             PackageType::Delegate => "freenet-main-delegate",
         }
     }
+
+    pub fn extra_features(&self) -> &'static [&'static str] {
+        match self {
+            PackageType::Contract => &CONTRACT_EXTRA_FEATURES,
+            PackageType::Delegate => &NO_EXTRA_FEATURES,
+        }
+    }
 }
 
 impl std::fmt::Display for PackageType {
@@ -250,9 +260,10 @@ fn compile_options(cli_config: &BuildToolConfig) -> impl Iterator<Item = String>
         .iter()
         .flat_map(|s| {
             s.split(',')
-                .filter(|p| *p != cli_config.package_type.feature())
+                .filter(|p| *p != cli_config.package_type.feature() && *p != "contract")
         })
-        .chain([cli_config.package_type.feature()]);
+        .chain([cli_config.package_type.feature()])
+        .chain(cli_config.package_type.extra_features().iter().copied());
     let features = [
         "--features".to_string(),
         feature_list.collect::<Vec<_>>().join(","),
@@ -262,7 +273,33 @@ fn compile_options(cli_config: &BuildToolConfig) -> impl Iterator<Item = String>
         .chain(release.iter().map(|s| s.to_string()))
 }
 // TODO: refactor so we share the implementation with fdev (need to extract to )
+fn ensure_target_dir_env() {
+    if std::env::var(TARGET_DIR_VAR).is_err() {
+        let workspace_dir = std::env::var("CARGO_WORKSPACE_DIR")
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| find_workspace_root());
+        let target_dir = workspace_dir.join("target");
+        std::env::set_var(TARGET_DIR_VAR, &target_dir);
+    }
+}
+
+fn find_workspace_root() -> PathBuf {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    manifest_dir
+        .ancestors()
+        .find(|dir| {
+            let cargo_toml = dir.join("Cargo.toml");
+            cargo_toml.exists()
+                && std::fs::read_to_string(&cargo_toml)
+                    .map(|contents| contents.contains("[workspace]"))
+                    .unwrap_or(false)
+        })
+        .expect("Could not determine workspace root from manifest directory")
+        .to_path_buf()
+}
+
 fn compile_contract(contract_path: &PathBuf) -> anyhow::Result<Vec<u8>> {
+    ensure_target_dir_env();
     println!("module path: {contract_path:?}");
     let target = std::env::var(TARGET_DIR_VAR)
         .map_err(|_| anyhow::anyhow!("CARGO_TARGET_DIR should be set"))?;

apps/freenet-ping/app/tests/run_app.rs

@@ -1750,15 +1750,18 @@ async fn test_ping_partially_connected_network() -> TestResult {
                           i, NUM_GATEWAYS, num_connections);
         }
 
-        // Load the ping contract
+        // Load the ping contract. Compile once to determine the code hash, then again with proper options.
         let path_to_code = PathBuf::from(PACKAGE_DIR).join(PATH_TO_CONTRACT);
         tracing::info!(path=%path_to_code.display(), "loading contract code");
-        let code = std::fs::read(path_to_code)
-            .ok()
-            .ok_or_else(|| anyhow!("Failed to read contract code"))?;
-        let code_hash = CodeHash::from_code(&code);
-
-        // Create ping contract options
+        let temp_options = PingContractOptions {
+            frequency: Duration::from_secs(3),
+            ttl: Duration::from_secs(60),
+            tag: APP_TAG.to_string(),
+            code_key: String::new(),
+        };
+        let temp_params = Parameters::from(serde_json::to_vec(&temp_options).unwrap());
+        let temp_container = common::load_contract(&path_to_code, temp_params)?;
+        let code_hash = CodeHash::from_code(temp_container.data());
         let ping_options = PingContractOptions {
             frequency: Duration::from_secs(3),
             ttl: Duration::from_secs(60),
@@ -1767,7 +1770,7 @@ async fn test_ping_partially_connected_network() -> TestResult {
         };
 
         let params = Parameters::from(serde_json::to_vec(&ping_options).unwrap());
-        let container = ContractContainer::try_from((code, &params))?;
+        let container = common::load_contract(&path_to_code, params)?;
         let contract_key = container.key();
 
         // Choose a node to publish the contract

crates/core/src/node/network_bridge/p2p_protoc.rs

@@ -1020,23 +1020,64 @@ impl P2pConnManager {
             tracing::debug!(tx = %tx, "Blocked addresses: {:?}, peer addr: {}", blocked_addrs, peer.addr);
         }
         state.awaiting_connection.insert(peer.addr, callback);
-        let res = timeout(
+        match timeout(
             Duration::from_secs(10),
             handshake_handler_msg.establish_conn(peer.clone(), tx, is_gw),
         )
         .await
-        .inspect_err(|error| {
-            tracing::error!(tx = %tx, "Failed to establish connection: {:?}", error);
-        })?;
-        match res {
-            Ok(()) => {
-                tracing::debug!(tx = %tx,
+        {
+            Ok(Ok(())) => {
+                tracing::debug!(
+                    tx = %tx,
                     "Successfully initiated connection process for peer: {:?}",
                     peer
                 );
                 Ok(())
             }
-            Err(e) => Err(anyhow::Error::msg(e)),
+            Ok(Err(e)) => {
+                tracing::error!(
+                    tx = %tx,
+                    remote = %peer,
+                    "Handshake handler failed while queuing connection request: {}",
+                    e
+                );
+                if let Some(mut cb) = state.awaiting_connection.remove(&peer.addr) {
+                    cb.send_result(Err(HandshakeError::ChannelClosed))
+                        .await
+                        .inspect_err(|err| {
+                            tracing::debug!(
+                                remote = %peer,
+                                "Failed to notify caller about handshake failure: {:?}",
+                                err
+                            );
+                        })
+                        .ok();
+                }
+                Err(anyhow::Error::new(e))
+            }
+            Err(elapsed) => {
+                tracing::warn!(
+                    tx = %tx,
+                    remote = %peer,
+                    elapsed = ?elapsed,
+                    "Timed out while queuing handshake request; treating as connection failure"
+                );
+                if let Some(mut cb) = state.awaiting_connection.remove(&peer.addr) {
+                    cb.send_result(Err(HandshakeError::ConnectionError(
+                        ConnectionError::Timeout,
+                    )))
+                    .await
+                    .inspect_err(|err| {
+                        tracing::debug!(
+                            remote = %peer,
+                            "Failed to notify caller about handshake timeout: {:?}",
+                            err
+                        );
+                    })
+                    .ok();
+                }
+                Ok(())
+            }
         }
     }