How to deal with tcp disconnection

[StanLi-ops]

I am a novice.
I found in learning Ockam that panic occurs when the tcp connection object does not exist.
Is there a way for tcp to disconnect?
Or how should I handle the panic correctly?
I hope that when the connection object is closed or does not exist, I can try to reconnect and close it after many times.
what should I do?

#[ockam::node]
async fn main(ctx: Context) -> Result<()> {
    let tcp = TcpTransport::create(&ctx).await?;
    tcp.connect("127.0.0.1:4000").await?;
    tcp.listen("127.0.0.1:3000").await?;.
    Ok(())
}

This is panic
thread 'tokio-runtime-worker' panicked at 'called Result::unwrap()on anErr value: Error { code: 11009, domain: "OCKAM_NODE" }'

[jdspdx]

Hi @StanLi-ops !

Welcome, and thanks for trying out the Rust guide! This is a great question.

To have more control over the error handling of a function call, the Result of the call needs to be handled a little more directly, instead of using the handy ? operator.

The ? operator is shorthand for .unwrap(). This means that when the call is successful, the value is returned as normal. But on failure it panics, as you have seen.

Instead of ? or .unwrap() we can use pattern matching or other functions on Result. For retry logic, we would combine this with a delay and a loop.

In your example, it is the tcp.connect("127.0.0.1:4000").await? call that panics. One easy way to check the success is to use the is_err or is_ok functions. There are several other ways to check Results, such as using a match statement or an if let statement. These are covered in the Result link above.

A retry loop might look something like this:

use ockam::{Context, Result, TcpTransport};
use std::thread::sleep;
use std::time::Duration;

#[ockam::node]
async fn main(mut ctx: Context) -> Result<()> {
    let mut need_reconnect = true;

    let tcp = TcpTransport::create(&ctx).await?;
    while need_reconnect {
        need_reconnect = tcp.connect("127.0.0.1:4000").await.is_err();
        if need_reconnect {
            println!("Failed to connect. Sleeping");
            sleep(Duration::from_secs(1));
        }
    }
    println!("Connected!");
    ctx.stop().await
}

[StanLi-ops]

Thanks a lot！
This helped me a lot to learn Rust and Ockam.
I am now trying to use asynchronous multi-threading to realize the real-time connection and reconnection of a single node to multiple neighbor nodes.

[mrinalwadhwa]

@StanLi-ops that's awesome, looking forward to seeing what you come up with!
Let us know if you need more help.

[StanLi-ops]

@jared-s I encountered a problem in this attempt.👉#1390 (reply in thread)
Below is my code and error message：

use ockam::{Context, Result, TcpTransport};
use std::{sync::Mutex, thread::sleep, time::Duration};

#[ockam::node]
async fn main(ctx: Context) -> Result<()> {
    let tcp = TcpTransport::create(&ctx).await.unwrap();
    tcp.listen("127.0.0.1:1000").await.unwrap();

    let talbe = vec!["127.0.0.1:2000".to_string(), "127.0.0.1:3000".to_string()];

    let mut thread_pool = vec![];

    for peer in talbe.iter() {
        let peer = Mutex::new(*peer);

            let t = tokio::spawn(async move {                 👈 “Compiler error”
            let tcp = TcpTransport::create(&ctx).await.unwrap();
            let peer = peer.lock().unwrap();

            let mut need_reconnect = true;
            while need_reconnect {
                need_reconnect = tcp.connect("peer").await.is_err();
                if need_reconnect {
                    println!("{} Failed to connect. Sleeping", peer);
                    sleep(Duration::from_secs(1));
                }
            }

            println!("Connected!");
        });

        thread_pool.push(t);
    }

    for t in thread_pool {
        t.await.unwrap();
    }

    Ok(())
}

future cannot be sent between threads safely
within `impl Future`, the trait `Send` is not implemented for `std::sync::MutexGuard<'_, std::string::String>`rustc
1.rs(1, 1): required by a bound in this
spawn.rs(129, 21): required by this bound in `tokio::spawn`
1.rs(22, 34): future is not `Send` as this value is used across an await

[StanLi-ops]

Also about Context::start_worker() and "Echoer".
I hope that in "Echoer" or other methods, the received message can be passed to my other async thread to continue processing the message by using "channle".
I haven't found a method in the interface provided by Context that can help me achieve it.
Is it feasible? If I can do it, what should I do.