freenet 0.2.113

Freenet core software
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#![cfg(feature = "test-network")]
//! Minimal riverctl propagation smoke test to reproduce intermittent "missing contract" errors.
//!
//! This intentionally runs outside CI (ignored) so it can be executed manually when debugging
//! contract propagation races:
//! ```text
//! cargo test -p freenet --test river_smoke -- --ignored
//! ```

mod common;

use anyhow::{Context, Result, bail};
use common::RiverSession;
use freenet_test_network::{BuildProfile, FreenetBinary, TestNetwork};
use tokio::time::{Duration, sleep};
use tracing::info;

const ITERATIONS: usize = 5;

#[test_log::test(tokio::test(flavor = "current_thread", start_paused = true))]
#[ignore = "manual-only: reproduces riverctl missing contract race"]
async fn river_missing_contract_smoke() -> Result<()> {
    let riverctl = which::which("riverctl").context("riverctl not found in PATH")?;

    for iter in 1..=ITERATIONS {
        info!("=== iteration {iter}/{ITERATIONS} ===");
        let network = TestNetwork::builder()
            .gateways(1)
            .peers(1)
            .preserve_temp_dirs_on_failure(true)
            .preserve_temp_dirs_on_success(true)
            .binary(FreenetBinary::CurrentCrate(BuildProfile::Debug))
            .build()
            .await
            .context("start test network")?;

        let gw_url = format!("{}?encodingProtocol=native", network.gateway(0).ws_url());
        let peer_url = format!("{}?encodingProtocol=native", network.peer(0).ws_url());

        // Use no-retry mode to catch propagation races
        let session = RiverSession::initialize_no_retry(riverctl.clone(), gw_url, peer_url).await?;
        match session
            .send_message(common::RiverUser::Alice, "smoke test")
            .await
        {
            Ok(_) => {
                info!(
                    "iteration {iter} succeeded (run_root={})",
                    network.run_root().display()
                );
            }
            Err(err) => {
                info!(
                    "iteration {iter} failed: {err} (run_root={})",
                    network.run_root().display()
                );
                bail!(err);
            }
        }

        // Give the OS a moment to free ports between iterations.
        sleep(Duration::from_secs(2)).await;
    }

    Ok(())
}