Address already in use after restarting a node

[sammy007]

Running few nodes, restarting one and getting:

Connection attempt to peer failed with Transport([(/ip4/127.0.0.1/tcp/3030/p2p/12D3KooWN2FYkvz41zPag4AFANw2cVjF5RPMx4qP48NvefabtXYz, Other(Custom { kind: Other, error: Other(Left(Left(Os { code: 48, kind: AddrInUse, message: "Address already in use" }))) }))]). peer=12D3KooWN2FYkvz41zPag4AFANw2cVjF5RPMx4qP48NvefabtXYz

Is there anything to prevent this? It's odd. Using basic swarm configuration:

.with_tokio()
            .with_tcp(
                tcp::Config::default(),
                noise::Config::new,
                yamux::Config::default,
            )

[drHuangMHT]

Are you binding listening addresses on the same port? randomly binding ports(using 0 for the port number) should prevent this.

[sammy007]

No. Listen ports are all different. Only happens if I restart one of these nodes. I can wait few minutes and it starts normally. Switched to udp/quic-v1 for now and problem no longer bites me, but would like to know what I misconfigured in swarm or perhaps a encountered some bug :-/

[drHuangMHT]

Might have something to do with port reuse, which is more of an OS setting.

[elenaf9]

No. Listen ports are all different

Do you mean the listen ports for different nodes are different, or you use a different listen port each time you restart the node?

In other words: have you hardcoded for that one node that is listening on port 3030 or is it listening on port 0/ a random port?

[sammy007]

Perhaps somebody could highlight what to do on macos. I tried that setting on tcp transport, no effect.

[getong]

libp2p 0.55 the same bug in macos, but in Linux , it is ok.

[elenaf9]

Same question here: have you hardcoded the listening port, or are you using an OS-assigned port (i.e. by listening on port 0)?

[getong]

some cod snippet:

handle_event() {
    SwarmEvent::NewListenAddr { .. } => match Self::parse_legacy_multiaddr() {
        Ok(boot_node_url_list) => {
            for boot_node_url in boot_node_url_list {
                _ = self.swarm.dial(boot_node_url.clone());
            }
        }
        Err(_) => {
            let bootnode_address = Self::get_bootnode_address();
            error!("can not get boot address: {:?} fail ", bootnode_address);
        }
    }

    pub fn parse_legacy_multiaddr() -> Result<Vec<Multiaddr>, Box<dyn Error>> {
        let multiaddr = Multiaddr::from_str(&Self::get_bootnode_address())?;
        let mut dns_name = None;
        let mut port = None;

        for protocol in multiaddr.iter() {
            match protocol {
                Protocol::Dns4(name) => dns_name = Some(name),
                Protocol::Tcp(p) => port = Some(p),
                _ => {}
            }
        }

        let mut url_list = vec![];
        if let (Some(dns_name), Some(port)) = (dns_name, port) {
            let addr = format!("{}:{}", dns_name, port);
            let resolved = addr.to_socket_addrs()?;

            for resolved_ip in resolved {
                // info!("Resolved IP address: {}", resolved_ip);
                // Construct a new Multiaddr with the resolved IP
                if let Ok(resolved_multiaddr) =
                    Multiaddr::from_str(&format!("/ip4/{}/tcp/{}", resolved_ip.ip(), port))
                {
                    url_list.push(resolved_multiaddr);
                }
            }

            Ok(url_list)
        } else {
            Err("not a libp2p dns multiaddr".into())
        }
    }
}

Self::get_bootnode_address() return

"/dns4/boot_node/tcp/8002"

in /etc/hosts

192.168.1.136   boot_node

[elenaf9]

Ah yes if Self::get_bootnode_address() will always return an address with port 8002, it means that each time you start the node it will try to listen on a socket with port 8002. If you just stopped the node and directly restart it, it will try to reuse the same port, but the OS still has it mapped to the old process and thus the above error happens. That is independent of libp2p.

If you wait a bit after stopping a node before restarting it, you should be fine.